Et puis il y a ça aussi que je ne comprends pas:

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...

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

On voit aussi (matrice intermédiaire et résultat) des valeurs proches de 0 ou 1 systématiquement ce que ne me parait pas normal.

L'algorithme semble donc bien faux. A l'expérience je voterais pour une subtile confusion d'indice entre indices des formules mathématiques et indices d'accès aux valeurs des matrices.

Le challenge est intéressant. Dès que j'ai un moment j'essaie d'y voir clair, maintenant que j'ai enfin saisi le problème à résoudre (ca a été dur...)

A propos de résultat faux, la première chose que je vais faire est d'essayer votre code sur 4 points (constants plutôt qu'aléatoires pour commencer), donc (si je comprends bien) dans un espace à trois dimensions que je peux me représenter dans ma petite tête obtue. Je ferai d'abord les calculs à la main et vérifierai dans un premier temps que le code donne le même résultat.
Vous l'avez fait ce test ?

De toutes façons ça sera soit ça soit que les formules mathématiques sont fausses. Bon bien sûr elles sont peut être mal transcrites, mais après un mois de vérif ça semble peu probable.

Désolé je n'ai pas pu me retenir :oops:

Bon, j'ai regardé un peu et je pense pouvoir aider.
J'ai repris le code de willbback (merci à lui :) )

Je me suis permis de renommer quelques variables pour la clarté. renommer aussi un j en k pour que ça colle mieux à la formule mathématique donnée dans le lien, etc.
Mais c'est du détail. Voici le code toutefois:

package test;

class Geotest {
    final int NB_POINTS = 4;
    //  n = nombre de points
    //  m = dimension de l'espace
    private int n = NB_POINTS;
    
    private int m = NB_POINTS - 1;
    
    public double[][] coordonneesInitiales = new double[n][m];
                                      
    // Matrice des positions initiales
    
    
    // Matrice des positions reconstruites par l'algorithme
    public double[][] coordonnees = new double[n][m];
    
    // Matrice des distances
    public double[][] distances = new double[n][n];
    
    // petite methode pour calculer un carre
    double carre(double x) {
        return x * x;
    }
    
    // Calcul de la distance euclidienne pour la matrice de position
    double dist(double[][] coords, int a, int b) {
        double sum = 0;
        for (int i = 0; i < m; i++) {
            sum = sum + carre(coords[a][i] - coords[b][i]);
        }
        return Math.sqrt(sum);
    }
    
    public void executeTest() {
        
        // On crée une matrice triangulaire aléatoire
       
        System.out.println("Matrice Initiale");
        for (int i = 0; i < n; i++) {
            System.out.print(i + "=>   ");
            for (int j = 0; j < i; j++) {
                coordonneesInitiales[i][j] = (int)(Math.random() * 10);
                System.out.print(coordonneesInitiales[i][j] + " ");
            }
            System.out.println();
        }
         
        
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<m; j++)
              System.out.print(coordonneesInitiales[i][j] + " ");
            System.out.println();
        }
        
        
        // On calcul les distances euclidiennes entre les points
        System.out.println("Matrice distance");
        for (int i = 0; i < n; i++) {
            System.out.print(i + "=>   ");
            for (int j = 0; j < m; j++) {
                distances[i][j] = dist(coordonneesInitiales, i, j);
                distances[j][i] = dist(coordonneesInitiales, i, j);
                System.out.print(distances[i][j] + " ");
            }
            System.out.println();
        }
        
        System.out.println("Matrice Résultat (intermediaire)");
        System.out.print("1=>   ");
        // Le premier point a tout ces coordonnées nulles
        // Le deuxième n'a qu'une seule coordonnée nulle
        coordonnees[1][0] = distances[1][0];
        System.out.println(coordonneesInitiales[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
            System.out.print(i + "=>   ");
            // La norme du vecteur sera sa distance au point 1
            double norme = carre(distances[0][i]);
            
            // On calcul d'abord les n-2 premières coordonnées du point courant
            for (int p = 0; p < i - 1; p++) {
                coordonnees[i][p] = norme - carre(distances[p + 1][i]) + carre(distances[p + 1][0]);
                
                double sumCoord = 0;
                for (int k = 0; k <= p - 1; k++) {
                    sumCoord += coordonnees[i][k] * coordonnees[p + 1][k];
                }
                coordonnees[i][p] = coordonnees[i][p] - 2 * sumCoord;
                coordonnees[i][p] = coordonnees[i][p] / (2 * coordonnees[p + 1][p]);
                System.out.print(coordonnees[i][p] + " ");
            }
            System.out.println();
            // On calcul enfin la dernière coord du point courant en utilisant les coord calculés à
            // l'instant
            double sumSQR = 0;
            for (int j = 0; j < i - 1; j++) {
                sumSQR += carre(coordonnees[i][j]);
            }
            
            // Le dernier calcul devrait tjs etre vrai car norme > sumSQR (mathematiquement j'entend)
            coordonnees[i][i - 1] = (float)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(coordonnees[i][i - 1]) == true && zero == 0) {
                zero++;
                System.out.println("Nan a " + i);
            }
        }
        System.out.println("Matrice resultat");
        for (int i = 0; i < n; i++) {
            System.out.print(i + "=>   ");
            for (int j = 0; j < i; j++) {
                System.out.print(coordonnees[i][j] + " ");
            }
            System.out.println();
        }
        
    }
    
    public static void main(String[] args) {
        Geotest test = new Geotest();
        test.executeTest();
    }
}

J'ai encore limité les essais à N = 4, ce qui est largement suffisant pour y voir clair.

Voir un premier résultat

0=>   
1=>   1.0 
2=>   9.0 4.0 
3=>   5.0 5.0 2.0 
0.0 0.0 0.0 
1.0 0.0 0.0 
9.0 4.0 0.0 
5.0 5.0 2.0 
Matrice distance
0=>   0.0 1.0 9.848857801796104 
1=>   1.0 0.0 8.94427190999916 
2=>   9.848857801796104 8.94427190999916 0.0 
3=>   7.3484692283495345 6.708203932499369 4.58257569495584 
Matrice Résultat (intermediaire)
1=>   1.0 
2=>   8.999999999999986 
3=>   4.9999999999999964 5.000000000000025 
Matrice resultat
0=>   
1=>   1.0 
2=>   8.999999999999986 4.0 
3=>   4.9999999999999964 5.000000000000025 2.0 

Ici tout marche bien, ou du moins tout semble.

Voici un second résultat:

Matrice Initiale
0=>   
1=>   7.0 
2=>   1.0 0.0 
3=>   7.0 6.0 5.0 
0.0 0.0 0.0 
7.0 0.0 0.0 
1.0 0.0 0.0 
7.0 6.0 5.0 
Matrice distance
0=>   0.0 7.0 1.0 
1=>   7.0 0.0 6.0 
2=>   1.0 6.0 0.0 
3=>   10.488088481701515 7.810249675906654 9.848857801796104 
Matrice Résultat (intermediaire)
1=>   7.0 
2=>   1.0 
3=>   7.0 Infinity 
Nan a 3
Matrice resultat
0=>   
1=>   7.0 
2=>   1.0 0.0 
3=>   7.0 Infinity NaN 
 

Là c'est beaucoup plus amusant .... et instructif. :twisted:

Il y a du Nan d'accord, mais surtout de l'Infinity. Et on comprends tout de suite.
Quand on a des coordonnées (autres que la première) nulles, cela provoque une division par zéro ici

coordonnees[i][p] = coordonnees[i][p] / (2 * coordonnees[p + 1][p]);

Quand coordonnées [p+1][p] vaut zéro :twisted:
Le Nan n'est qu'un corollaire de ça

Voci un code tout cuit avec cet exemple pour le vérifier

package test;

class Geotest {
    final int NB_POINTS = 4;
    //  n = nombre de points
    //  m = dimension de l'espace
    private int n = NB_POINTS;
    
    private int m = NB_POINTS - 1;
    
    //public double[][] coordonneesInitiales = new double[n][m];
                                      
    // Matrice des positions initiales
    
    public double[][] coordonneesInitiales = 
                                      
    { 
        { 0.0, 0.0, 0.0 } ,
        { 7.0, 0.0, 0.0 },
        { 1.0, 0.0, 0.0 },
        { 7.0, 6.0, 5.0 }
    };
    
    
    // Matrice des positions reconstruites par l'algorithme
    public double[][] coordonnees = new double[n][m];
    
    // Matrice des distances
    public double[][] distances = new double[n][n];
    
    // petite methode pour calculer un carre
    double carre(double x) {
        return x * x;
    }
    
    // Calcul de la distance euclidienne pour la matrice de position
    double dist(double[][] coords, int a, int b) {
        double sum = 0;
        for (int i = 0; i < m; i++) {
            sum = sum + carre(coords[a][i] - coords[b][i]);
        }
        return Math.sqrt(sum);
    }
    
    public void executeTest() {
        
        // On crée une matrice triangulaire aléatoire
        /*
        System.out.println("Matrice Initiale");
        for (int i = 0; i < n; i++) {
            System.out.print(i + "=>   ");
            for (int j = 0; j < i; j++) {
                coordonneesInitiales[i][j] = (int)(Math.random() * 10);
                System.out.print(coordonneesInitiales[i][j] + " ");
            }
            System.out.println();
        }
         */
        
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<m; j++)
              System.out.print(coordonneesInitiales[i][j] + " ");
            System.out.println();
        }
        
        
        // On calcul les distances euclidiennes entre les points
        System.out.println("Matrice distance");
        for (int i = 0; i < n; i++) {
            System.out.print(i + "=>   ");
            for (int j = 0; j < m; j++) {
                distances[i][j] = dist(coordonneesInitiales, i, j);
                distances[j][i] = dist(coordonneesInitiales, i, j);
                System.out.print(distances[i][j] + " ");
            }
            System.out.println();
        }
        
        System.out.println("Matrice Résultat (intermediaire)");
        System.out.print("1=>   ");
        // Le premier point a tout ces coordonnées nulles
        // Le deuxième n'a qu'une seule coordonnée nulle
        coordonnees[1][0] = distances[1][0];
        System.out.println(coordonneesInitiales[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
            System.out.print(i + "=>   ");
            // La norme du vecteur sera sa distance au point 1
            double norme = carre(distances[0][i]);
            
            // On calcul d'abord les n-2 premières coordonnées du point courant
            for (int p = 0; p < i - 1; p++) {
                coordonnees[i][p] = norme - carre(distances[p + 1][i]) + carre(distances[p + 1][0]);
                
                double sumCoord = 0;
                for (int k = 0; k <= p - 1; k++) {
                    sumCoord += coordonnees[i][k] * coordonnees[p + 1][k];
                }
                coordonnees[i][p] = coordonnees[i][p] - 2 * sumCoord;
                coordonnees[i][p] = coordonnees[i][p] / (2 * coordonnees[p + 1][p]);
                System.out.print(coordonnees[i][p] + " ");
            }
            System.out.println();
            // On calcul enfin la dernière coord du point courant en utilisant les coord calculés à
            // l'instant
            double sumSQR = 0;
            for (int j = 0; j < i - 1; j++) {
                sumSQR += carre(coordonnees[i][j]);
            }
            
            // Le dernier calcul devrait tjs etre vrai car norme > sumSQR (mathematiquement j'entend)
            coordonnees[i][i - 1] = (float)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(coordonnees[i][i - 1]) == true && zero == 0) {
                zero++;
                System.out.println("Nan a " + i);
            }
        }
        System.out.println("Matrice resultat");
        for (int i = 0; i < n; i++) {
            System.out.print(i + "=>   ");
            for (int j = 0; j < i; j++) {
                System.out.print(coordonnees[i][j] + " ");
            }
            System.out.println();
        }
        
    }
    
    public static void main(String[] args) {
        Geotest test = new Geotest();
        test.executeTest();
    }
}

Division par zéro....

arf ces scientifiques :twisted:

Désolé je n'ai pas pu me retenir. :oops:
Mais au delà de la taquinerie, j'espère très sincèrement que ça t'aidera :)

Au fait pour le million d'Euro, où dois je facturer ? :D

C'est déjà pas cool comme ça.
J'avais remarqué le risque de division par zéro, mais dans tous mes essais, je n'ai jamais vu "Infinity" dans les resultats affichés.
Je viens donc de refaire les essais avec ton code légèrement modifié.

class Geotest {
	final int NB_POINTS = 40;

	// n = nombre de points
	// m = dimension de l'espace
	private int n = NB_POINTS;

	private int m = NB_POINTS - 1;

	// Matrice des positions initiales
	public double[][] coordonneesInitiales = new double[n][m];

	// public double[][] coordonneesInitiales =
	// {
	// { 0.0, 0.0, 0.0 } ,
	// { 7.0, 0.0, 0.0 },
	// { 1.0, 0.0, 0.0 },
	// { 7.0, 6.0, 5.0 }
	// };

	// Matrice des positions reconstruites par l'algorithme
	public double[][] coordonnees = new double[n][m];

	// Matrice des distances
	public double[][] distances = new double[n][n];

	// petite methode pour calculer un carre
	double carre(double x) {
		return x * x;
	}

	// Calcul de la distance euclidienne pour la matrice de position
	double dist(double[][] coords, int a, int b) {
		double sum = 0;
		for (int i = 0; i < m; i++) {
			sum = sum + carre(coords[a][i] - coords[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++) {
				coordonneesInitiales[i][j] = Math.random();
				if (coordonneesInitiales[i][j] == 0) {
					System.out.println("********  coordonneesInitiales[i][j] ["
							+ i + "][" + j + "] == 0 ********");
				}
			}
		}

		printMatrice("Matrice Initiale Complète", coordonneesInitiales);

		// On calcul les distances euclidiennes entre les points
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				distances[i][j] = dist(coordonneesInitiales, i, j);
				distances[j][i] = dist(coordonneesInitiales, i, j);
			}
		}
		printMatrice("Matrice distance", distances);

		// Le premier point a tout ces coordonnées nulles
		// Le deuxième n'a qu'une seule coordonnée nulle
		coordonnees[1][0] = distances[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 = carre(distances[0][i]);
			if (norme == 0) {
				System.out.println("********  norme [0][" + i + "] == 0 ********");
			}

			// On calcul d'abord les n-2 premières coordonnées du point courant
			for (int p = 0; p < i - 1; p++) {
				coordonnees[i][p] = norme - carre(distances[p + 1][i])
						+ carre(distances[p + 1][0]);

				double sumCoord = 0;
				for (int k = 0; k <= p - 1; k++) {
					sumCoord += coordonnees[i][k] * coordonnees[p + 1][k];
				}
				coordonnees[i][p] = coordonnees[i][p] - 2 * sumCoord;
				if (coordonnees[p + 1][p] == 0) {
					System.out.println("********  coordonnees[p + 1][p] ["
							+ (p + 1) + "][" + p + "] == 0 ********");
				}
				coordonnees[i][p] = coordonnees[i][p]
						/ (2 * coordonnees[p + 1][p]);
			}
			// On calcul enfin la dernière coord du point courant en utilisant
			// les coord calculés à
			// l'instant
			double sumSQR = 0;
			for (int j = 0; j < i - 1; j++) {
				sumSQR += carre(coordonnees[i][j]);
			}

			// Le dernier calcul devrait tjs etre vrai car norme > sumSQR
			// (mathematiquement j'entend)
			if ((norme - sumSQR) <= 0) {
				System.out.println("********  (norme - sumSQR) <= 0 "+ (norme - sumSQR) + "********");
			}
			coordonnees[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(coordonnees[i][i - 1]) == true && zero == 0) {
				zero++;
				System.out.println("NaN a " + i);
			}
		}
		printMatrice("Matrice resultat", coordonnees);
		System.out.println("Nombre NaN :" + zero);
	}

	private void printMatrice(String legende, double[][] matrice) {
		System.out.println(legende);
		for (int i = 0; i < n; i++) {
			System.out.print(i + "|	");
			for (int j = 0; j < m; j++) {
				System.out.print(matrice[i][j] + "	");
			}
			System.out.println();
		}
	}

	public static void main(String[] args) {
		Geotest test = new Geotest();
		test.executeTest();
	}
}

J'ai eu un ensemble de valeurs à NaN sans pour autant avoir un Infinity. En français dans le texte, j'ai bien eu une valeur négative passée à la fonction racine carré (sqrt) sans pour autant avoir des valeurs à 0 dans les coordonnées.
Il existe donc 2 bugs :
_ Quand les coordonnées sont égales à 0
_ Quand les valeurs sont très petites, la somme "sumSQR" est supérieur à la "norme".
Lors d'un précédent post, j'ai évoqué le problème de la fonction "dist" qui accède à des valeurs dans la partie supérieur de la matrice triangulaire, donc des valeurs à 0.
Il est très probable que si les valeurs sont suffisament petites, le fait de "louper" une valeur dans le calcul de la distance fait que la "sumSQR".
Je continu donc à soutenir que la fonction "dist" a un problème d'indice.

Et pour fredericmazue, le meilleur langage qui existe est celui que chacun maîtrise le mieux (dicton de consultant) :lol:

Ca parait quand même incroyable que tu n'ais pas Infinity. Comme j'étais fatigué l'autre soir, j'ai vérifié ce matin ce que j'ai dit plus haut et ca fait bien comme j'ai dit.

J'ai aussi essayé ce matin

    public double[][] coordonneesInitiales = 
                                      
    { 
        { 0.0, 0.0, 0.0 } ,
        { 2.0, 0.0, 0.0 },
        { 7.0, 0.0, 0.0 },
        { 0.0, 1.0, 2.0 }
    };

qui donne

0.0 0.0 0.0 
2.0 0.0 0.0 
7.0 0.0 0.0 
0.0 1.0 2.0 
Matrice distance
0=>   0.0 2.0 7.0 
1=>   2.0 0.0 5.0 
2=>   7.0 5.0 0.0 
3=>   2.23606797749979 3.0 7.3484692283495345 
Matrice Résultat (intermediaire)
1=>   2.0 
2=>   7.0 
3=>   2.220446049250313E-16 -Infinity 
Nan a 3
Matrice resultat
0=>   
1=>   2.0 
2=>   7.0 0.0 
3=>   2.220446049250313E-16 -Infinity NaN 

Sur JVM 1.6.0_02-b06
Quelle JVM tu as ?
Non non on se marre pas, les JVM sont pleines de surprises...

On arrête pas de te le dire :lol:

Bon tu dois être content que le problème se débloque.

Bon, je répète ma question: pour le million d'Euro, où dois je facturer ? ;)

Je dirais, toujours avec l'aide de mon ampéro-pifomètre, que le problème est le même.
N'y aurait-il pas du NaN quand il y a du "presque zéro", des valeurs très petites quoi. D'ailleurs willbback te l'a suggéré dans un de ses posts je crois.

Pour qu'on parle bien tous de la même chose, peut tu poster, fut il horrible ;) le code avec lequel tu travailles maintenant, si tu as fait des changement par rapport au tout premier code que tu as posté.

Parce que là je viens d'essayer ta matrice avec ton premier code et elle fait pas de Nan sauf erreur de ma part.... :shock:

Qu'est-ce que tu racontes ?

d'un côté (code d'origine)

   //  n = nombre de points 
   //  m = dimension de l'espace 
   static int n =  100; 
   static int m = n-1;

et mon code

    final int NB_POINTS = 100;
    //  n = nombre de points
    //  m = dimension de l'espace
    private int n = NB_POINTS;
    
    private int m = NB_POINTS - 1;

C'est bien la même chose non ? :lol:
C'est juste que mon code est plus lisible à mon goût.

Entre outre mon code marche très bien parce qu'avec "une matrice qui va bien" il restitue convenablement les coordonnées des points comme je l'ai dit dans un post précédent

Par contre quand j'ai dit dans mon post précédent ne pas obtenir de NaN avec la dernière matrice de Itchris, ce n'était pas avec mon code, mais avec le sien, celui qu'il a posté en tout début. :twisted:
Et je maintiens qu'il n'est pas exclu que ces différences viennent de JVM différentes sous des OS différents. Là je suis sous Windows. Peut être Itchris est sous Linux. Les différences de calculs entre JVM avec des (très) petits nombres ça c'est déjà vu. Pourquoi est-ce que je parle de petits nombres ? Parce que si on a vu le problème de la division par zéro. En informatique, il faut se préoccuper de la division par "presque zéro". Tu as contasté qu'avec des "grand nombres" dans la matrice ça allait mieux, et je l'ai constaté aussi. Avec des grands nombres sans coordonnés nulles le code de Itchris (ou le mien puisque c'est le même ré-écrit) fonctionne très bien. Par exemple pour cette matrice

    public double[][] coordonneesInitiales =
    {
        { 0.0, 0.0, 0.0 } ,
        { 9.0, 0.0, 0.0 }, 
        { 4.0, 5.0, 0.0 },
        { 7.0, 1.0, 3.0} 
    };

Par contre avec de très petits nombres, donc des divisions par presque zéro, rien n'est garanti. d'ailleurs quand j'aurais une minute, je vais essayer exactement les mêmes calculs que ceux faits jusque là avec une autre version de JVM et sous Linux, juste pour voir :)

C'est par rapport au code de ltchris. La matrice qu'il présente dans ses résultats est carré et non plus n*m. Je pense donc que nous (toi et moi) n'avons plus la dernière version du code sur lequel il travail . C'est juste une constatation tirée de son dernier poste.
Et effectivement avec les valeurs postées par ltchris, je n'ai pas de NaN non plus. Je suis donc en parfait accord avec tes dires :wink:

J'essaye de reprendre les formules qu'il a posté précédement mais j'ai quelques problèmes d'interprétation. Le calcul de la distance est fait en colonne dans la matrice, les calculs suivants sont fait en ligne. Je suis donc un peut surpris de la progession "cahotique" des indices. Mais ce n'est qu'une intuition mal placée de développeur.

Par exemple la norme est calculée par norme= carre(distances[0][i]), ce qui indique une variation de colonne dans la matrice, les coordonnées sont calculés par coordonnees[i][p] = norme - carre(distances[p + 1][i]) carre(distances[p + 1][0]), qui effectue une variation mélangée colonne et ligne. Mon instinct me dicte plutôt une ligne du type
coordonnees[p][i] = norme - carre(distances[p + 1][i]) + carre(distances[p + 1][0]). Avec un inquiétude sur p + 1. Lors d'une boucle sur p, il est rare d'essayé d'aller voir l'item suivant. Bref, je me pose bien des questions.....
Ou alors, il essaye d'inversé la matrice, et là le parcours n'est pas bon non plus. Mais vu que je ne comprends toujours pas la finalité du "bidule", j'ai du mal.
Il serait peut-être temps de poser le problème en terme plus simple, sans grande théorie mathématique, du genre : je calcul la distante entre le début de la colonne de la matrice initiale jusqu'à un point donné avec la formule ...

Je viens de passer le code de double vers BigDecimal et................. Nous avons toujours des problèmes de NaN. Bref, quand les nombres sont trop petits y a un gros problème....

Laissons tomber les "petits"
Je viens de faire quelues essais aves des matrices contenant des nombres microscopiques et je n'ai pas vu de problème.

Qu'est-ce que quoi comment ?? :shock:

Tu veux dire que quand par exemple tu as des nombre qui se balladent de E-37 à E-38 (passage de float à double si ma mémoire est bonne) tu as du NaN ?
Bon je n'ai peut être pas compris ce que tu veux dire, mais ça ne semble pas faire de sens ce que tu dis, parce que les nombres sont tous doubles dans ton code et normalement la JVM va les coder sur 8 octets tout le temps. Et non pas une fois 4 une fois 8. C'est du Java, mais quand même ;)

Tu aurais une matrice toute prête qu'il n'y aurait qu'à copier-coller dans le code ? Je voudrais bien voir ça de mes petits yeux porcins je dois dire.