Hilfestellung zur Implementierung des Gaußsches Eliminationsverfahren

[atrunz]

Hallo Zusammen,

Ich befinde mich derzeit in den Anfängen des Programmierens.
Zu Übungszwecken wollte ich das aus Schulzeiten bekannte Gaußsches Eliminationsverfahren in Java implementieren.
Für die Anfänge habe ich die Matritzengröße fest vorgegeben, dass erzeugen des "Null-Dreieicks" funktioniert auch soweit.
Nun würde ich gerne auch größere Matritzen umstellen können, hierzu müsste ich etliche for-Schleifen einfügen (Für Zeile 3: 3 FOR-Schleifen, für Zeile 4: 4 FOR-Schleifen ...).
Ist es möglich diese Berechnung kompakter zu gestalten? Möglichst auch unabhängig von der Größe des LGS.


Über Hilfestellungen würde ich mich freuen


Bisheriger Code:

public class Gauß
{
    public static void main (String args [])
    {
        double[][] LGS =
        {
          { 3, 9, 8, 5 },//Zeile 0
          { 0, 2, 3, 6 },
          { 5, 1, 2, 6,}
        };
       
        // Array auf Gaußform bringen
    
        //Zeile 1
        double c = -LGS[1][0] / LGS[0][0];
        System.out.println("c: "+c);
        if(LGS[1][0]!=0)
        {
            for (int j=0; j<=3; j++)//breite der matrix
            {   
                LGS[1][j] = (LGS[0][j]*c) + LGS[1][j];
            }
        }
        //Zeile 2 - 1
        double e = -LGS[2][0] / LGS[0][0];
        System.out.println("e: " + e);
        if(LGS[2][0] != 0)
        {      
            for (int k=0; k<=3; k++)
            {   
                LGS[2][k] = (LGS[0][k]*e) + LGS[2][k];
            }
        }
      
        //Zeile 2 - 2
        double d = -LGS[2][1] / LGS[1][1];
        System.out.println("d: " +d);
        for (int l=0; l<=3; l++)
        {
            LGS[2][l] = (LGS[1][l]*d) + LGS[2][l];
        }
       
       
       
        // das Array ausgeben
        for ( int zeile = 0; zeile < LGS.length; zeile++ )
        {
          System.out.print("Zeile " + zeile + ": ");
         
          for ( int spalte=0; spalte < LGS[zeile].length; spalte++ )
            System.out.print( LGS[zeile][spalte] + " ");
          System.out.println();
        }
    }   

}

 

[stg]

Ja, ist es.

Dein Code unter //Zeile 1, //Zeile 2-1 und //Zeile 2-2 ist nahezu identisch. Wenn du diesen verallgemeinerst und in eine weitere for-Schleife packst, dann bist du schon ein großen Schritt weiter. Vielleicht siehst du dann ja auch selbst schon, wohin das ganze führen soll?!

 

[atrunz]

Vielen Dank für die Antwort

Beim Verallgemeinern habe ich leider etwas Schwierigkeiten.
Mittlerweile bin ich mir sicher ( hoffentlich das stimmt auch ) dass ich die zwei for-Schleifen verschachteln muss.

        for(int m=1; m<=3; m++)
        {
                for (int j=0; j<=3; j++)
                {   
                    //hier die for-Schleife die ich bereits verwende
                }
           
           
        }

Jedoch habe ich beim Verallgemeinern Probleme, da meine Berechnungen pro Zeile um einen Schritt wachsen. Untenstehend sind die Berechnungsformlen zu sehen. Jedoch müsste mein Indize der for schleife sich hierzu unregelmäig ändern? sprich 1, 2, 2, 3, 3, 3. Die Multiplikation des Wertes mit dem Kürzungsfaktor bereitet mir beim Verallgemeinern auch noch Kopfzerbrechen ..
Hättest du mir vielleicht einen weiteren Tipp?
Vielen Dank im Voraus

LGS[1][j] = (LGS[0][j]*c) + LGS[1][j]; //Zeile 1

LGS[2][j] = (LGS[0][j]*e) + LGS[2][j];//Zeile 2
LGS[2][j] = (LGS[1][j]*d) + LGS[2][j];

LGS[3][j] = (LGS[0][j]*f) + LGS[3][j];//Zeile 3
LGS[3][j] = (LGS[1][j]*g) + LGS[3][j];
LGS[3][j] = (LGS[2][j]*h) + LGS[3][j];
.
.
.

 

[Jardcore]

Ich habe das Verfahren leider nicht mehr im Kopf, aber google spuckt sowas aus und das sieht mir relativ dynamisch aus. Vielleicht hilft es dir weiter.
http://introcs.cs.princeton.edu/java/95linear/GaussianElimination.java.html

 

[stg]

Beim Verallgemeinern habe ich leider etwas Schwierigkeiten.
Mittlerweile bin ich mir sicher ( hoffentlich das stimmt auch ) dass ich die zwei for-Schleifen verschachteln muss.

Insgesamt kommst damit du auf sogar drei ineinander geschachtelte for-Schleife, ja.

Jedoch habe ich beim Verallgemeinern Probleme, da meine Berechnungen pro Zeile um einen Schritt wachsen. Untenstehend sind die Berechnungsformlen zu sehen. Jedoch müsste mein Indize der for schleife sich hierzu unregelmäig ändern?

Die ändern sich, ja, aber nicht unregelmäßig, sonder da gibt es eine regelmäßigkeit.
Die Grenzen der Laufindize der inneren beiden Schleifen hängen vom Index der äußeren Schleife ab.