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 :)