C'est ce que j'avais constaté aussi. Dis je ne voudrais pas mourir idiot... Tu as compris toi ce qu'il veut faire ? Et pourquoi il fait un changement de repère de la façon dont il le fait ? Je n'arrive pas à saisir...
Moi, je ne suis qu'un bête développeur, je code que ce qui est dans les spécifications. :shock:
Concernant la précision, je veux bien croire qu'il ya un problème de précision, mais reste quand même beaucoup de problème d'algorithmie dans ce "bout de code".
Je suis loin d'être une super tronche en math, donc loin de moi l'idée de critiqué les formules mathématiques. Mais là, l'écart entre les 2 nombres produisants la valeure négative est tout de même proche de 2, ce qui fait beaucoup pour une imprécision de calcul sur un nombre si petit.
De plus, l'ordre de grandeur de chaque nombre devient très vite significatif, j'ai fait des éxecutions en faisant varier le nombre de points. Le problème ne se produit pas toujours au même endroit, et la fréquence est relativement rare en dessous de n=47.
Je pencherais plus sur un problème de donnée.
A au fait, voici le code un peu nettoyé
package test;
class Geotest {
// n = nombre de points
// m = dimension de l'espace
private int n = 100;
private int m = n - 1;
// Matrice des positions initiales
public double[][] positionInit = new double[n][m];
// Matrice des positions reconstruites par l'algorithme
public double[][] position = new double[n][m];
// Matrice des distances
public double[][] distance = new double[n][n];
// petite methode pour calculer un carre
double SQR(double x) {
return x * x;
}
// Calcul de la distance euclidienne pour la matrice de position
double dist(double[][] position, int a, int b) {
double sum = 0.0;
for (int i = 0; i < m; i++) {
sum = sum + SQR(position[a][i] - position[b][i]);
}
return Math.sqrt(sum);
}
public void executeTest() {
// On crée une matrice triangulaire aléatoire
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++)
positionInit[i][j] = Math.random();
}
// On calcul les distances euclidiennes entre les points
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
distance[i][j] = dist(positionInit, i, j);
distance[j][i] = dist(positionInit, i, j);
}
}
// Le premier point a tout ces coordonnées nulles
// Le deuxième n'a qu'une seule coordonnée nulle
position[1][0] = distance[1][0];
/* On lance notre algorithme pour trouver les coordonnées des points 3 à n */
double zero = 0;
for (int WichPoint = 2; WichPoint < n; WichPoint++) {
int i = WichPoint; // je met i juste pour simplifier le code, et Wichpoint pour comprendre de
// quoi je parle
// La norme du vecteur sera sa distance au point 1
double norme = SQR(distance[0][i]);
// On calcul d'abord les n-2 premières coordonnées du point courant
for (int p = 0; p < i - 1; p++) {
position[i][p] = norme - SQR(distance[p + 1][i]) + SQR(distance[p + 1][0]);
double sumCoord = 0.0;
for (int j = 0; j <= p - 1; j++) {
sumCoord += position[i][j] * position[p + 1][j];
}
position[i][p] = position[i][p] - 2 * sumCoord;
position[i][p] = position[i][p] / (2 * position[p + 1][p]);
}
// On calcul enfin la dernière coord du point courant en utilisant les coord calculés à
// l'instant
double sumSQR = 0.0;
for (int j = 0; j < i - 1; j++) {
sumSQR += SQR(position[i][j]);
}
// Le dernier calcul devrait tjs etre vrai car norme > sumSQR (mathematiquement j'entend)
position[i][i - 1] = Math.sqrt(norme - sumSQR);
// Or y'a du NaN ???? donc norme < sumSQR et c pas normal !!!
// On test le dernier calcul voir quand apparait ce NaN
if (Double.isNaN(position[i][i - 1]) == true && zero == 0) {
zero++;
}
}
}
public static void main(String[] args) {
Geotest test = new Geotest();
test.executeTest();
}
}
C'est ce que j'avais constaté aussi. Dis je ne voudrais pas mourir idiot... Tu as compris toi ce qu'il veut faire ? Et pourquoi il fait un changement de repère de la façon dont il le fait ? Je n'arrive pas à saisir...
Moi, je ne suis qu'un bête développeur, je code que ce qui est dans les spécifications. :shock:
Concernant la précision, je veux bien croire qu'il ya un problème de précision, mais reste quand même beaucoup de problème d'algorithmie dans ce "bout de code".
Je suis loin d'être une super tronche en math, donc loin de moi l'idée de critiqué les formules mathématiques. Mais là, l'écart entre les 2 nombres produisants la valeure négative est tout de même proche de 2, ce qui fait beaucoup pour une imprécision de calcul sur un nombre si petit.
De plus, l'ordre de grandeur de chaque nombre devient très vite significatif, j'ai fait des éxecutions en faisant varier le nombre de points. Le problème ne se produit pas toujours au même endroit, et la fréquence est relativement rare en dessous de n=47.
Je pencherais plus sur un problème de donnée.
A au fait, voici le code un peu nettoyé