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();
	}
}