GaussJordan in Java, wo liegt mein Fehler?

[setech]

Hallöchen,

ich versuche gerade den Gauss Jordan Algorithmus in Java umzusetzen, er klappt auch teilweise nur habe ich einen Fehler drin (oder einfach nur riesengroße Tomaten auf den Augen)

Erstmal die komplette Klasse:

public class GaussJordan {
    private double[][] A;
    private double[][] b;
    
    public GaussJordan(Matrix A, Matrix b){
        this.A = A.toArray();
        this.b = b.toArray();
        
        this.solve();
    }
    
    private void solve(){
        for(int i=0; i < this.A.length; i++){
            double alpha = 0;
            for(int j=i+1; j < this.A.length; j++){
                alpha = SMath.kgV(Math.abs(this.A[i][i]), Math.abs(this.A[j][i]));
                
                
                double beta = alpha/this.A[i][i];
                double gamma = alpha/this.A[j][i];
                if(this.A[i][i] < 0)
                    beta *= -1;
                if(this.A[j][i] < 0)
                    gamma *= -1;
                
                this.A[i] = this.multiplyRow(this.A[i], beta);
                this.b[i] = this.multiplyRow(this.b[i], beta);
                
                this.A[j] = this.multiplyRow(this.A[j], gamma);
                this.b[j] = this.multiplyRow(this.b[j], gamma);
                
                this.A[j] = this.addRow(this.A[i], this.A[j]);
                this.b[j] = this.addRow(this.b[i], this.b[j]);
                
                this.A[i] = this.divideRow(this.A[i], beta);
                this.b[i] = this.divideRow(this.b[j], beta);
//                this.show();
                
                System.out.printf("i: %d | alpha: %8.3f beta: %8.3f gamma: %8.3f\n", i, alpha, beta, gamma);
                System.out.println("");
            }
            this.show();
            System.out.println("");
        }
    }
    
    private double[] multiplyRow(double[] a, double factor){
        for(int i=0; i < a.length; i++)
            a[i] *= factor;
        
        return a;
    }
    
    private double[] divideRow(double[] a, double factor){
        for(int i=0; i < a.length; i++)
            a[i] /= factor;
        
        return a;
    }
    public double[] addRow(double[] a, double[] tar){
        for(int i=0; i < a.length; i++)
            tar[i] += a[i];
        
        return tar;
    }
    
    private void show(){
        for(int i=0; i < this.A.length; i++){
            for(int j=0; j < this.A[0].length; j++){
                System.out.printf("%9.4f  ", this.A[i][j]);
            }
            System.out.print("|  ");
            for(int j=0; j < this.b[0].length; j++){
                System.out.printf("%9.4f  ", this.b[i][j]);
            }
            System.out.println("");
        }
    }
}

zum Beispiel habe ich als Matrix A folgende:

double[][] x = {
            {-3,4,5},
            {7,3,2},
            {9,2,1}
        };

und als b die normale Einheitsmatrix.

Was ich nun vorhabe ist die untere Dreiecksmatrix zu erzeugen - sprich in dem linken unteren Dreieck alles 0 haben. Anschließend will ich dann die Matrix von unten aufrollen um auch die obere Dreiecksmatrix zu erzeugen.

Mein Code funktioniert nur leider nicht so ganz wie ich es mir vorgestellt habe, er erzeugt mir zwar in der ersten Spalte alle nötigen 0'en außer in der ersten Zeile (das ist auch so gewollt)
Sobald ich nun jedoch in die nächste Spalte gehen will, kommen ziemlich blöde ergebnisse raus und die sind auch nicht wirklich das was ich mir dort erwünscht habe

Ich bekomme z.B. die folgende Ausgabe

i: 0 | alpha:   21,000 beta:    7,000 gamma:    3,000

i: 0 | alpha:    9,000 beta:    3,000 gamma:    1,000

  -3,0000     4,0000     5,0000  |     1,0000     0,4286     0,3333  
   0,0000    37,0000    41,0000  |     3,0000     1,2857     0,0000  
   0,0000    14,0000    16,0000  |     1,0000     0,4286     0,3333  

i: 1 | alpha:  518,000 beta:   14,000 gamma:   37,000

  -3,0000     4,0000     5,0000  |     5,6429     2,4184     0,8810  
   0,0000    37,0000    41,0000  |     5,6429     2,4184     0,8810  
   0,0000  1036,0000  1166,0000  |     5,6429     2,4184     0,8810  

  -3,0000     4,0000     5,0000  |     5,6429     2,4184     0,8810  
   0,0000    37,0000    41,0000  |     5,6429     2,4184     0,8810  
   0,0000  1036,0000  1166,0000  |     5,6429     2,4184     0,8810

bis das i von 0 auf 1 springt ist alles in ordnung, aber sobald i > 0 wird kommen besonders in der letzten Zeile diese komischen Zahlen.

Zudem würde mich interessieren ob es auch möglich ist die Klasse ohne die divide funktion, denn ohne diese sind in der entsprechenden Zeile auch die veränderten werte - welche aber gleich bleiben sollen.

Ich versuche also im prinzip den schriftlichen GJA in Java umzusetzen

Vielen dank schonmal und falls es doch ins Mathe forum gehört, dann sorry

 

[Plastagen]

Diese "komischen" Zahlen kommen daher, da

alpha = SMath.kgV(Math.abs(this.A[i][i]), Math.abs(this.A[j][i]));

Und der kgV von 37 und 14 entspricht 518.

beta: 518/37 = 14
gamma: 518/14 = 37

A[1] * beta = 0 518 574
A[2]*gamma = 0 518 592

A[2] = A[1] + A[2] = 0 1036 1166

A[1] / beta = 0 37 41

Und somit erhälst du für A auch die dort angegebene Matrix.
Und ich bin mir fast sicher, wenn man die gleich Rechnung mit b[] durchführt, dass du dort auch zu der angegebenen Matrix kommst.

 

[setech]

Diese "komischen" Zahlen kommen daher, da

alpha = SMath.kgV(Math.abs(this.A[i][i]), Math.abs(this.A[j][i]));

Und der kgV von 37 und 14 entspricht 518.

Wie schaffe ich es denn das der kgV von 4 und 14 berechnet wird? ich bin gerade ratlos :/

 

[Plastagen]

Wozu brauchst du denn den kgV von 4 und 14?
Es wird ja schon der richtige kgV berechnet.
Was im Endeffekt fehlt ist die Überprüfung, wenn beide Werte positiv sind, dann muss man die Zeilen voneinander abziehen und nicht addieren.

In diesem Beispiel jetzt müsste es dann sein:
A[2] - A[1] und nicht wie bei dir vorhanden A[1] + A[2]
Wenn du sie voneinander abziehst, dann erhälst du auch die gewünschte 0 statt der 1036.

 

[setech]

Habs hinbekommen, allerdings auf einen etwas anderen Weg.

trotzdem danke für die Hilfe