Lineares Gleichungssystem lösen

[Kegasetu]

Probiert habe ich es, weit bin ich nicht gekommen

Delphi-Quellcode:

type
  TGaussSolved = array of Extended;
  TGaussLine = TGaussSolved;
  TGaussMatrix = array of TGaussLine;

Leider bekomme ich hier nur Fehler angezeigt.

[Andreas13]

Hallo,
Dein Zahlenbeispiel ist - wie von Dir oben angegeben wurde - noch nicht lösbar, weil die konkreten Zahlenwerte fehlen und Widersprüche in den Unbekannten vorhanden sind. Bitte alles überprüfen und korrigieren.

Du solltest Dein Programm etwa so gestalten:

Delphi-Quellcode:

VAR
  A_Matrix     : TGaussMatrix; // korrigiert!
  X_Vektor     : TGaussSolved; // korrigiert!
  n_Gleichungen: Integer;
...

  n_Gleichungen := 10;

  SetLength(A_Matrix, n_Gleichungen, n_Gleichungen + 1);
  SetLength(X_Vektor, n_Gleichungen);

  Try
    // 0. Zeile:         1*a+l2*b+l3*b+00*c+00*d+00*e+00*f+00*g+00*h+000*i =b1
    A_Matrix[0, 0] := ;  
    A_Matrix[0, 1] := ;  
    A_Matrix[0, 2] := ;
    A_Matrix[0, 3] := ;
    A_Matrix[0, 4] := ;
    A_Matrix[0, 5] := ;
    A_Matrix[0, 6] := ;
    A_Matrix[0, 7] := ;
    A_Matrix[0, 8] := ;
    A_Matrix[0, 9] := ;
    
    // 1. Zeile:         00*a+l2*b+l3*b+l4*c+l5*d+00*e+00*f+00*g+00*h+000*i =b2
    A_Matrix[1, 0] := ;  
    A_Matrix[1, 1] := ;  
    A_Matrix[1, 2] := ;
    A_Matrix[1, 3] := ;
    A_Matrix[1, 4] := ;
    A_Matrix[1, 5] := ;
    A_Matrix[1, 6] := ;
    A_Matrix[1, 7] := ;
    A_Matrix[1, 8] := ;
    A_Matrix[1, 9] := ;

    // 2. Zeile:         00*a+00*b+l3*b+l4*c+l5*d+l6*e+00*f+00*g+00*h+000*i =b3
    A_Matrix[2, 0] := ;  
    A_Matrix[2, 1] := ;  
    A_Matrix[2, 2] := ;
    A_Matrix[2, 3] := ;
    A_Matrix[2, 4] := ;
    A_Matrix[2, 5] := ;
    A_Matrix[2, 6] := ;
    A_Matrix[2, 7] := ;
    A_Matrix[2, 8] := ;
    A_Matrix[2, 9] := ;

    // 3 Zeile:          00*a+00*b+00*b+l4*c+l5*d+l6*e+l7*f+00*g+00*h+000*i =b4
    A_Matrix[3, 0] := ;  
    A_Matrix[3, 1] := ;  
    A_Matrix[3, 2] := ;
    A_Matrix[3, 3] := ;
    A_Matrix[3, 4] := ;
    A_Matrix[3, 5] := ;
    A_Matrix[3, 6] := ;
    A_Matrix[3, 7] := ;
    A_Matrix[3, 8] := ;
    A_Matrix[3, 9] := ;

    // 4 Zeile:          00*a+00*b+00*b+00*c+00*d+l6*e+l7*f+l8*g+00*h+000*i =b5
    A_Matrix[4, 0] := ;  
    A_Matrix[4, 1] := ;  
    A_Matrix[4, 2] := ;
    A_Matrix[4, 3] := ;
    A_Matrix[4, 4] := ;
    A_Matrix[4, 5] := ;
    A_Matrix[4, 6] := ;
    A_Matrix[4, 7] := ;
    A_Matrix[4, 8] := ;
    A_Matrix[4, 9] := ;

    // 5 Zeile:          00*a+00*b+00*b+00*c+00*d+00*e+l7*f+l8*g+l9*h+000*i =b6
    A_Matrix[5, 0] := ;  
    A_Matrix[5, 1] := ;  
    A_Matrix[5, 2] := ;
    A_Matrix[5, 3] := ;
    A_Matrix[5, 4] := ;
    A_Matrix[5, 5] := ;
    A_Matrix[5, 6] := ;
    A_Matrix[5, 7] := ;
    A_Matrix[5, 8] := ;
    A_Matrix[5, 9] := ;


    // 6 Zeile:          00*a+00*b+00*b+00*c+00*d+00*e+00*f+l8*g+l9*h+l10*i =b7
    A_Matrix[6, 0] := ;  
    A_Matrix[6, 1] := ;  
    A_Matrix[6, 2] := ;
    A_Matrix[6, 3] := ;
    A_Matrix[6, 4] := ;
    A_Matrix[6, 5] := ;
    A_Matrix[6, 6] := ;
    A_Matrix[6, 7] := ;
    A_Matrix[6, 8] := ;
    A_Matrix[6, 9] := ;

    // 7 Zeile:         00*a+00*b+00*b+00*c+00*d+00*e+00*f+00*g+l9*h+l10*i =b8
    A_Matrix[7, 0] := ;  
    A_Matrix[7, 1] := ;  
    A_Matrix[7, 2] := ;
    A_Matrix[7, 3] := ;
    A_Matrix[7, 4] := ;
    A_Matrix[7, 5] := ;
    A_Matrix[7, 6] := ;
    A_Matrix[7, 7] := ;
    A_Matrix[7, 8] := ;
    A_Matrix[7, 9] := ;

    // 8 Zeile:         00*a+00*b+00*b+00*c+00*d+00*e+00*f+00*g+00*h+l10*i =b9
    A_Matrix[8, 0] := ;  
    A_Matrix[8, 1] := ;  
    A_Matrix[8, 2] := ;
    A_Matrix[8, 3] := ;
    A_Matrix[8, 4] := ;
    A_Matrix[8, 5] := ;
    A_Matrix[8, 6] := ;
    A_Matrix[8, 7] := ;
    A_Matrix[8, 8] := ;
    A_Matrix[8, 9] := ;

    // 9 Zeile:         00*a+00*b+00*b+00*c+00*d+00*e+00*f+00*g+00*h+000*i =b10 
    A_Matrix[9, 0] := ;  
    A_Matrix[9, 1] := ;  
    A_Matrix[9, 2] := ;
    A_Matrix[9, 3] := ;
    A_Matrix[9, 4] := ;
    A_Matrix[9, 5] := ;
    A_Matrix[9, 6] := ;
    A_Matrix[9, 7] := ;
    A_Matrix[9, 8] := ;
    A_Matrix[9, 9] := ;
    

    // Rechte Seite des GL-Systems: b1 ... b10
    A_Matrix[0, 10] := ;
    A_Matrix[1, 10] := ;
    A_Matrix[2, 10] := ;
    A_Matrix[3, 10] := ;
    A_Matrix[4, 10] := ;
    A_Matrix[5, 10] := ;
    A_Matrix[6, 10] := ;
    A_Matrix[7, 10] := ;
    A_Matrix[8, 10] := ;
    A_Matrix[9, 10] := ;

  X_Vektor:= SolveLinearSystem(A_Matrix, n_Gleichungen, n_Gleichungen + 1);
...


  Finally
    A_Matrix:= NIL;
    X_Vektor:= NIL;
  End;

Gruß, Andreas

[Kegasetu]

Erstmal vielen Dank für die Unterstützung!

Ja, ich habe einen Fehler eingebaut und b doppelt drin. Es sollte natürlich mit c weitergehen.

Ich selber muss mal einen Gang zurückschalten, da ich davon nahezu Null verstehe Es ist doch etwas komplizierter als anfänglich gedacht.

Mal zum Hintergrund. Es werden immer Werte nach meinem Schema(a-j) gegeben sein. Es gilt b herauszufinden.

Mein Plan war es, einfach ein paar Zeilen in mein bereits bestehendes Programm zu geben und dann mittels Arrays ein paar Rechnungen durchzugehen. Mal sehen ob ich den Anhang entsprechend zerpflücken und dann simpel implementieren kann.

[Andreas13]

Eleganter wäre eine Lösung, wenn Du Deine Daten aus einer Textdatei einlesen würdest und die Matrix A in zwei Teile aufspaltest: Linke Seite (= Quadratische Matrix) und rechte Seite (= SpaltenVektor). Die Vektorspalte kannst Du an die Matrix per Programm-Code ranhängen. So kann man z.B. für verschiedene rechte Seiten des Gleichungssystems einfach neue Lösungen generieren.

Melde Dich wieder, wenn ich Dir etwas helfen kann.
Gruß, Andreas

[Kegasetu]

So sieht die "verbale" Matrix aus die ich lösen will:

lzha1[1]*MA+2(lzha1[1]+lzha1[2])*MB+lzha1[2]*MC=MMA1[1]
lzha1[2]*MB+2(lzha1[2]+lzha1[3])*MC+lzha1[3]*MD=MMA1[2]
lzha1[3]*MC+2(lzha1[3]+lzha1[4])*MD+lzha1[4]*ME=MMA1[3]
lzha1[4]*MD+2(lzha1[4]+lzha1[5])*ME+lzha1[5]*MF=MMA1[4]
lzha1[5]*ME+2(lzha1[5]+lzha1[6])*MF+lzha1[6]*MG=MMA1[5]
lzha1[6]*MF+2(lzha1[6]+lzha1[7])*MG+lzha1[7]*MH=MMA1[6]
........... (Eigentlich sollten jeweils die ersten Variablen untereinander stehen...)

Zusammengeschrieben:
lzha1[1]*MA+2(lzha1[1]+lzha1[2])*MB+lzha1[2]*MC=MMA1[1]
lzha1[2]*MB+2(lzha1[2]+lzha1[3])*MC+lzha1[3]*MD=MMA1[2]
lzha1[3]*MC+2(lzha1[3]+lzha1[4])*MD+lzha1[4]*ME=MMA1[3]
lzha1[4]*MD+2(lzha1[4]+lzha1[5])*ME+lzha1[5]*MF=MMA1[4]
lzha1[5]*ME+2(lzha1[5]+lzha1[6])*MF+lzha1[6]*MG=MMA1[5]
lzha1[6]*MF+2(lzha1[6]+lzha1[7])*MG+lzha1[7]*MH=MMA1[6]
lzha1[7]*MG+2(lzha1[7]+lzha1[8])*MH+lzha1[8]*MI=MMA1[7]
lzha1[8]*MH+2(lzha1[8]+lzha1[9])*MI+lzha1[9]*MJ=MMA1[8]
lzha1[9]*MI+2(lzha1[9]+lzha1[10])*MJ+lzha1[10]*MK=MMA1[9]
lzha1[10]*MJ+2(lzha1[10]+lzha1[11])*MK+lzha1[11]*ML=MMA1[10]

Dabei sind in jeder Gleichung alle Koeffizienten vorhanden, jedoch sind nur die hier hingeschrieben ungleich 0.

EDIT
MA und ML sind vorher schon definiert. Die Gleichungen lassen sich alles nach Gauss lösen (habe ich händisch ausprobiert)

[Andreas13]

Wenn Du die Koeffizienten der Gleichungen bereits in Arrays hast, dann kannst Du die Matrix A einfach per Code (= For-Schleifen) füllen. Das gezeigte Muster kann Dir dabei helfen.

Es würde Deine Arbeit enorm erleichtern, wenn Du auch die Unbekannten (MA, MB etc.) in einem Vektor (= Array) ablegen würdest.

[Kegasetu]

Zitat von Andreas13:

Eleganter wäre eine Lösung, wenn Du Deine Daten aus einer Textdatei einlesen würdest und die Matrix A in zwei Teile aufspaltest: Linke Seite (= Quadratische Matrix) und rechte Seite (= SpaltenVektor). Die Vektorspalte kannst Du an die Matrix per Programm-Code ranhängen. So kann man z.B. für verschiedene rechte Seiten des Gleichungssystems einfach neue Lösungen generieren.

Melde Dich wieder, wenn ich Dir etwas helfen kann.
Gruß, Andreas

Danke für die Hilfe, morgen Früh werde ich mich wieder ransetzten!

[Jens01]

Wenn Du einen Gleichungenlöser suchst für Delphi, dann ist das eigentlich das Maß der Dinge:
https://github.com/mikerabat/mrmath

[Kegasetu]

Zitat von Jens01:

Wenn Du einen Gleichungenlöser suchst für Delphi, dann ist das eigentlich das Maß der Dinge:
https://github.com/mikerabat/mrmath

Ich glaube das greift mir etwas zu weit. Aber Danke, ich werde es mir mal zurücklegen.

[Kegasetu]

Zitat von Andreas13:

Wenn Du die Koeffizienten der Gleichungen bereits in Arrays hast, dann kannst Du die Matrix A einfach per Code (= For-Schleifen) füllen. Das gezeigte Muster kann Dir dabei helfen.

Es würde Deine Arbeit enorm erleichtern, wenn Du auch die Unbekannten (MA, MB etc.) in einem Vektor (= Array) ablegen würdest.

Ich muss mich nochmal korrigieren. Die Koeffizienten MB-MH muss ich herausfinden.