Lineares Gleichungssystem lösen

[Kegasetu]

Hallo Zusammen.
Für mich und mein Programm geht es in die nächste Runde.

Ich stehe vor der Aufgabe Gleichungen aufzustellen und zu lösen.

Mein Überlegung ging in die Richtung Gauß. Da ich allerdings mir etwas Arbeit sparen wollte, will ich vorher die Frage loswerden, ab es dafür nicht eine vorgefertigte "solve"-Funktion gibt?

Im Internet habe ich nur Beiträge von vor 10 Jahren gefunden. Eventuell ist Delphi ja diesbezüglich etwas weiter.

[Rollo62]

Du könntest bei den Livebindings mal den Expression Parser ansehen,
aber ein fertiges Sover-Modul ist meines Wissens nicht dabei.
Bei TMS gibt es auch was, vermutlich aber auch nicht der fertige Solver.

[TigerLilly]

TMS kann das, die haben symbolische Mathe mit an Board - sehr cool. Aber zum Lösen linearer Gleichungssysteme mit Delphi/Pascal gibt Google auch einiges her.

Auch hier in der DP gibt es was:
https://www.delphipraxis.net/225-lin...en-loesen.html

[Kegasetu]

Ich werde mich mal reinlesen. Vielen Dank!

[Kegasetu]

Zitat:

Zitat von TigerLilly (Beitrag 1475899)

TMS kann das, die haben symbolische Mathe mit an Board - sehr cool. Aber zum Lösen linearer Gleichungssysteme mit Delphi/Pascal gibt Google auch einiges her.

Auch hier in der DP gibt es was:
https://www.delphipraxis.net/225-lin...en-loesen.html

Ich habe mich jetzt etwas mit TMS auseiandergesetzt, blicke aber nicht so ganz durch.. Info ist absolut nicht meine Stärke. Unter den Beispielen war einiges dabei, aber ich bin nicht so ganz durchgestiegen...

Gibt es zufällig ein Beispiel, bei dem ein solver in Delphi fertig implementiert ist? Natürlich nicht den ganzen Backgroud, sondern die Schreibweise aus der neuen Funktion heraus?

[Kegasetu]

Ich habe mich mit den Operatoren von TMS etwas länger auseinandergesetzt, jedoch liegt der Entschluss, dass dies nicht unbedingt notwendig ist. In Excel ist es relativ einfach solche Gleichungssysteme zu lösen, dafür gibt es fast schon komplett vorgefertigte Funktionen.
Während eine Internetsuche bin ich bezüglich Gauß und Delphi dann auf folgenden Code gestoßen:

Delphi-Quellcode:

Beispiel 15.2 Der allgemeine Gauß'sche Algorithmus.
Diesmal verwenden wir ein dynamische Array. Das zweidimensionale Array wird deklariert durch den Typ:

type TarrayOfArrayOfExtended = array of array of extended;

Falls koeff[i,i] = 0 ist müssen noch die Spalten vertauscht werden. Das geschieht mit der Permutation p und Umkehrpermutation q.
Hier musst Du noch die Untit MathMohr miteinbinden. (oder die Entsprechenden Prozeduren durch eigene ersetzten.)

function IsInteger(const x: extended; eps: extended): boolean;
begin //eps globale Variable. Zum Beispiel eps = 1E-9
  result := frac(abs(x) + eps) < eps*2;
end;

FUNCTION ggtInt(a,b:longint):longint;
  begin if b=0 then result:=a
        else result:=ggtInt(b,a mod b);
  end;

FUNCTION ggtReal(a,b:Extended):Extended;
  begin if (a < maxlongint) and (b < maxlongint) then
           result:=ggTInt(round(a),round(b))
        else Begin
          if abs(b) < 0.5 then result:=a
          else result:=ggtReal(b,a-b*int(a/b));
        end;
end;

FUNCTION kgVReal(a, b: extended): extended;
begin result := a * b / ggTReal(a, b) end;

procedure LSG(n: integer; var aa: TarrayOfArrayOfExtended; var xx: array of extended);
             //Arrray aa[0..n,0..n+1]
var i0, j0,j0max: integer; //n Unbekannte bzw. Gleichungen
  p, q: array of integer; //permutation q=inv_p
  procedure invers; //erzeugt q = inverse Permutation von p
  var u, v: integer;
  begin
    for u := 0 to n - 1 do
      for v := 0 to n - 1 do
        if p[u] = v then q[v] := u;
  end;
  procedure tausche_sp(i, j: integer); // Spalten werden ausgetauscht
  var u, k: integer;
    x: extended;
  begin
    for u := 0 to n - 1 do Begin
      x := aa[u, i];
      aa[u, i] := aa[u, j];
      aa[u, j] := x; //=altes aa[u,i]
    End;
    k := p[i];
    p[i] := p[j];
    p[j] := k; //altes p[i]
    invers;
  end;

  procedure macheZeileGanzzahlig(zeile: integer); //bis auf rechte Seite  aa[z,n+1]
  var k : integer;
    d, zae, nen: extended; //wird das kgV des Nenners
  begin
    try
      d := 1;
      for k := 0 to n - 1 do Begin
        if not ErmittleBruch(abs(aa[zeile, k]), zae, nen,g_eps) then exit;
        d := kgVReal(nen, d);
      End;
      for k := 0 to n do aa[zeile, k] := d * aa[zeile, k];
      //Jetzt noch kürzen
      if not isInteger(aa[zeile, 1], g_eps) then exit;
      d := round(aa[zeile, 1]);
      for k := 0 to n - 1 do Begin
        if not isInteger(aa[zeile, k], g_eps) then exit;
        if d = 0 then d := round(aa[zeile, k]); //falls aa[zeile,1..]=0
        if abs(aa[zeile, k]) > 0 then
          d := ggTReal(round(aa[zeile, k]), d);
      End;
      if d <> 0 then for k := 0 to n do aa[zeile, k] := aa[zeile, k] / d;
    except {dann halt nicht} end;
    if aa[zeile, zeile] < 0 then for k := 0 to n do aa[zeile, k] := -aa[zeile, k];
  end;

  procedure VereinfacheRest(i: integer);
  var zeile, spalte: integer;
    d: extended;
  begin
    for zeile := 0 to n - 1 do if zeile <> i then Begin
        d := aa[zeile, i] / aa[i, i];
        if d <> 0 then Begin
          for spalte := 0 to n do if spalte <> i then
              aa[zeile, spalte] := aa[zeile, spalte] - d * aa[i, spalte] else
              aa[zeile, i] := 0; //=aa[zeile,i]-aa[zeile,i]/aa[i,i]*aa[i,i]
          macheZeileGanzzahlig(zeile);
        End;
      End;
  end;

begin //Hauptprogramm
  setlength(p,n+1);
  setlength(q,n);
  for j0 := 0 to n - 1 do Begin
    p[j0] := j0;
    q[j0] := j0;
  End;
  for i0 := 0 to n - 1 do Begin
    j0max := i0;
    for j0 := i0 + 1 to n - 1 do if abs(aa[i0, j0]) > abs(aa[i0, j0max]) then j0max := j0;
    if aa[i0,j0max] = 0 then Begin
      showmessage('Keine eindeutige Lösng!');
      exit;
    End;
    VereinfacheRest(i0);
  end;
  for i0 := 0 to n - 1 do xx[p[i0]] := aa[i0, n] ;
end;

procedure ArrayInMemo(n: integer; aa: TarrayOfArrayOfExtended; m:Tmemo);
  var i, j: integer;   //aa n zeilen und n + 1 Spalten
      s: string;
begin
  m.Lines.Clear;
  for i := 0 to n-1 do Begin
    s := '';
    for j := 0 to n do
      s := s + ' ' + floatToStr(aa[i,j]);
    m.Lines.Add(s);
  End;
end;

procedure TForm1.Button1Click(Sender: TObject);
  var n, i: integer;
      koeff: TarrayOfArrayOfExtended;
      a: array of extended;
begin
  n := 3; // von 0 bis 2
  setlength(a, n);
  setlength(koeff, length(a),length(a) + 1);
  koeff[0,0] := 5;  koeff[0,1] := -7; koeff[0,2] := 1; koeff[0,3] := 9;
  koeff[1,0] := -3; koeff[1,1] := 2;  koeff[1,2] := 3; koeff[1,3] := 4;
  koeff[2,0] := 2;  koeff[2,1] := 3;  koeff[2,2] := 4; koeff[2,3] := 0;
  ArrayInMemo(length(a),Koeff,memo1);
  LSG(length(a),koeff,a);
  memo1.lines.add('Lösung');
  for i := 0 to n - 1 do
    memo1.lines.add(ReellZuBruch(a[i]));
end;

(https://kilchb.de/lektionen1ff.php)

Ich bekomme das Kotzen :D so kompliziert kann das doch nicht sein?

Gegeben ist eine 10x10 Matrix, welche gelöst werden muss.

[TigerLilly]

Bist du mit der Mathematik dahinter vertraut? Wenn nicht, ist das natürlich schwierig umzusetzen.

Aber sieh doch hier
https://www.delphipraxis.net/225-lin...en-loesen.html

Da ist auch die Mathe dahinter gut erklärt.

[Kegasetu]

Zitat:

Zitat von TigerLilly (Beitrag 1476341)

Bist du mit der Mathematik dahinter vertraut? Wenn nicht, ist das natürlich schwierig umzusetzen.

Aber sieh doch hier
https://www.delphipraxis.net/225-lin...en-loesen.html

Da ist auch die Mathe dahinter gut erklärt.

Die Mathematik dahinter ist ja nicht so kompliziert, aber beim Verständnis der Informatik hapert es gewaltig. Ich bin nur kurzfristig gezwungen mich damit auseinander zu setzen, also keine Sache die wirklich verinnerlichen muss.

Hier z.B.

Delphi-Quellcode:

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

function SolveLinearSystem(A: TGaussMatrix; m, n: Integer): TGaussSolved;
var
  i, j, k: Integer;
  Pivot: TGaussLine;
  PivotRow: Integer;
  Multiplicator, Sum: Extended;

Was genau diese Type-Funktion macht, kann ich mir nicht ganz erklären. So etwas habe ich nie behandelt. Nicht falsch verstehen, ich bin nicht faul um mich darein zu denken, aber eine möglich einfachen Weg würde ich schon gerne gehen, da ich dies nur, wie schon erwähnt, einmal mache.

[Andreas13]

Hallo Kegasetu,
Die Parameter der Funktion sind wie folgt zu deuten:

Delphi-Quellcode:

A: TGaussMatrix;

ist die sog. erweiterte Koeffizienten-Matrix des Gleichungssystems, d.h. linke UND rechte Seiten aller Gleichungen zusammen:

a_0_0, a_0_1, a_0_2, ... a_0_m, b_0 // 1. Gleichung
a_1_0, a_1_1, a_1_2, ... a_1_m, b_1 // 2. Gleichung
... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
a_m_0, a_m_1, a_m_2, ... a_m_m, b_m // letzte Gleichung

a_0_0 bis a_m_m sind die Koeffizienten der linken Seiten der Gleichungen.
Die Reihenfolge der Indizes der Matrix ist immer: Zeile, Spalte.
b_0 bis b_m sind die Koeffizienten der rechten Seiten der Gleichungen.
m: Anzahl der Zeilen (= Anzahl der Unbekannten)
n: Anzahl der Spalten
Es gilt hierbei: n = m + 1 d.h. n_Spalten = n_Zeilen + 1
Der Rückgabewert

Delphi-Quellcode:

TGaussSolved;

der Funktion ist der Lösungsvektor und enthält die berechneten Werte:
X_0, X_1, X_2, ... X_m

Die Vektoren und die Matrix sind hier jeweils NULL-basierte Arrays.
Viel Erfolg!
Gruß, Andreas

[Kegasetu]

Zitat:

Zitat von Andreas13 (Beitrag 1476361)

Hallo Kegasetu,
Die Parameter der Funktion sind wie folgt zu deuten:

Delphi-Quellcode:

A: TGaussMatrix;

ist die sog. erweiterte Koeffizienten-Matrix des Gleichungssystems, d.h. linke UND rechte Seiten aller Gleichungen zusammen:

a_0_0, a_0_1, a_0_2, ... a_0_m, b_0 // 1. Gleichung
a_1_0, a_1_1, a_1_2, ... a_1_m, b_1 // 2. Gleichung
... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
a_m_0, a_m_1, a_m_2, ... a_m_m, b_m // letzte Gleichung

a_0_0 bis a_m_m sind die Koeffizienten der linken Seiten der Gleichungen.
Die Reihenfolge der Indizes der Matrix ist immer: Zeile, Spalte.
b_0 bis b_m sind die Koeffizienten der rechten Seiten der Gleichungen.
m: Anzahl der Zeilen (= Anzahl der Unbekannten)
n: Anzahl der Spalten
Es gilt hierbei: n = m + 1 d.h. n_Spalten = n_Zeilen + 1
Der Rückgabewert

Delphi-Quellcode:

TGaussSolved;

der Funktion ist der Lösungsvektor und enthält die berechneten Werte:
X_0, X_1, X_2, ... X_n

Die Vektoren und die Matrix sind hier jeweils NULL-basierte Arrays.
Viel Erfolg!
Gruß, Andreas

Danke, die Erklärung hilft.
Ich versuche das jetzt mal auf diesen Fall zu adaptieren:

l1*a+l2*b+l3*b+00*c+00*d+00*e+00*f+00*g+00*h+000*i =b1
00*a+l2*b+l3*b+l4*c+l5*d+00*e+00*f+00*g+00*h+000*i =b2
00*a+00*b+l3*b+l4*c+l5*d+l6*e+00*f+00*g+00*h+000*i =b3
00*a+00*b+00*b+l4*c+l5*d+l6*e+l7*f+00*g+00*h+000*i =b4
00*a+00*b+00*b+00*c+00*d+l6*e+l7*f+l8*g+00*h+000*i =b5
00*a+00*b+00*b+00*c+00*d+00*e+l7*f+l8*g+l9*h+000*i =b6
00*a+00*b+00*b+00*c+00*d+00*e+00*f+l8*g+l9*h+l10*i =b7
00*a+00*b+00*b+00*c+00*d+00*e+00*f+00*g+l9*h+l10*i =b8
00*a+00*b+00*b+00*c+00*d+00*e+00*f+00*g+00*h+l10*i =b9
00*a+00*b+00*b+00*c+00*d+00*e+00*f+00*g+00*h+000*i =b10

[Kegasetu]

Probiert habe ich es, weit bin ich nicht gekommen :D

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:

Zitat von Andreas13 (Beitrag 1476370)

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:

Zitat von Jens01 (Beitrag 1476379)

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:

Zitat von Andreas13 (Beitrag 1476374)

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.

[Kegasetu]

Zitat:

Zitat von Andreas13 (Beitrag 1476370)

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

Auf der grundlage der A-Matrix im Programm müsste die Matrix welche ich eingebe ja so aussehen:

A[0, 0] := l1*MA;
A[0, 1] := l2*MB;
A[0, 2] := l3*MC;
A[0, 3] := 0;
A[0, 4] := 0;
A[0, 5] := 0;
A[0, 6] := 0;
A[0, 7] := 0;
A[0, 8] := 0;
A[0, 9] := 0;
A[0, 10] := 0;
A[0, 11] := b1;

A[1, 0] := 0;
A[1, 1] := l2*MB;
A[1, 2] := l3*MC;
A[1, 3] := l4*MD;
A[1, 4] := 0;
A[1, 5] := 0;
A[1, 6] := 0;
A[1, 7] := 0;
A[1, 8] := 0;
A[1, 9] := 0;
A[1, 10] := 0;
A[1, 11] := b2;
usw..

Ich habe lzha[] jetzt mit l vereinfacht

Mir stellt sich jetzt noch die Frage, wie ich mit dem "SetLength" umgehe und vielmehr was es bedeutet?

Das n müsste ja n= 11 sein.

[Jens01]

Zitat:

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

Das Ding ist mit der Zeit etwas umfangreich geworden.
Du mußt Dir die Matrix.pas angucken.
Dort mußt Du 2 Matrizen erstellen und mit SolveLinEQ lösen. Das Ding ist sehr schnell, weil einige Teile über Assembler laufen.
Und eigentlich sehr einfach.
(Ich finde gerade kein Beispiel dafür :shock:)

[shebang]

Zitat:

Zitat von Andreas13 (Beitrag 1476367)

n_Gleichungen := 10;

SetLength(A_Matrix, n_Gleichungen, n_Gleichungen + 1);
SetLength(X_Vektor, n_Gleichungen);
Gruß, Andreas

Zitat:

Zitat von Kegasetu (Beitrag 1476405)

Mir stellt sich jetzt noch die Frage, wie ich mit dem "SetLength" umgehe und vielmehr was es bedeutet?

SetLength setzt die Länge des Vektors bzw. der Matrix. In Andreas' Beispiel hat der Vektor 10 Zeilen und die Matrix 10 Zeilen und 11 Spalten.

[Jens01]

Hier ist wenigstens ein Beispiel aus dem Testsystem:

Delphi-Quellcode:

procedure TestTThreadedMatrix.TestMatrixSolve;
const cBlkWidth = 512;
      cBlkSize = cBlkWidth*cBlkWidth;
var a, x1, x2, b : TDoubleDynArray;
    i : integer;
    start, stop : int64;
    index : integer;
    m1, m2 : IMatrix;
    mb : IMatrix;
begin
     {$IFDEF FMX} Setup; {$ENDIF};
     SetLength(a, cBlkSize);
     SetLength(b, 3*cBlkWidth);
     SetLength(x1, 3*cBlkWidth);
     SetLength(x2, 3*cBlkWidth);

     RandSeed := 15;
     for i := 0 to cBlkSize - 1 do
         a[i] := Random - 0.5;

     for i := 0 to 3*cBlkWidth - 1 do
         b[i] := Random - 0.5;

     mb := TDoubleMatrix.Create(b, 3, cBlkWidth);
     m1 := TDoubleMatrix.Create(a, cBlkWidth, cBlkWidth);
     m2 := TThreadedMatrix.Create(a, cBlkWidth, cBlkWidth);

     start := MtxGetTime;
     m1.SolveLinEQInPlace(mb);
     stop := MtxGetTime;
     Status(Format('Blocked LU decomp: %.2fms', [(stop - start)/mtxfreq*1000]));

     start := MtxGetTime;
     m2.SolveLinEQInPlace(mb);
     stop := MtxGetTime;
     Status(Format('Threaded LU decomp: %.2fms', [(stop - start)/mtxfreq*1000]));

     index := 0;
     Check(CheckMtxIdx(m1.SubMatrix, m2.SubMatrix, index), Format('error Lin equation solve. Error at x[%d] = %.5f, y[%d] = %.5f', [index, x1[index], index, x2[index]]));
     {$IFDEF FMX} TearDown; {$ENDIF};
end;

[Kegasetu]

Zitat:

Zitat von Jens01 (Beitrag 1476428)

Hier ist wenigstens ein Beispiel aus dem Testsystem:

Delphi-Quellcode:

procedure TestTThreadedMatrix.TestMatrixSolve;
const cBlkWidth = 512;
      cBlkSize = cBlkWidth*cBlkWidth;
var a, x1, x2, b : TDoubleDynArray;
    i : integer;
    start, stop : int64;
    index : integer;
    m1, m2 : IMatrix;
    mb : IMatrix;
begin
     {$IFDEF FMX} Setup; {$ENDIF};
     SetLength(a, cBlkSize);
     SetLength(b, 3*cBlkWidth);
     SetLength(x1, 3*cBlkWidth);
     SetLength(x2, 3*cBlkWidth);

     RandSeed := 15;
     for i := 0 to cBlkSize - 1 do
         a[i] := Random - 0.5;

     for i := 0 to 3*cBlkWidth - 1 do
         b[i] := Random - 0.5;

     mb := TDoubleMatrix.Create(b, 3, cBlkWidth);
     m1 := TDoubleMatrix.Create(a, cBlkWidth, cBlkWidth);
     m2 := TThreadedMatrix.Create(a, cBlkWidth, cBlkWidth);

     start := MtxGetTime;
     m1.SolveLinEQInPlace(mb);
     stop := MtxGetTime;
     Status(Format('Blocked LU decomp: %.2fms', [(stop - start)/mtxfreq*1000]));

     start := MtxGetTime;
     m2.SolveLinEQInPlace(mb);
     stop := MtxGetTime;
     Status(Format('Threaded LU decomp: %.2fms', [(stop - start)/mtxfreq*1000]));

     index := 0;
     Check(CheckMtxIdx(m1.SubMatrix, m2.SubMatrix, index), Format('error Lin equation solve. Error at x[%d] = %.5f, y[%d] = %.5f', [index, x1[index], index, x2[index]]));
     {$IFDEF FMX} TearDown; {$ENDIF};
end;

Jetzt mal ganz dreist gefragt, wäre es möglich mir ein Beispiel zu zeigen in dem die Beiden simplen Gleichungen: 5*x=y u. 4+x=y; gelöst werden?

Irgendwie ist mir der Code nicht schlüssig. Warum braucht es z.B. einen Zeitparameter?

[Jens01]

Zitat:

Irgendwie ist mir der Code nicht schlüssig. Warum braucht es z.B. einen Zeitparameter?

Mann, ich hab das einfach nur aus dem Testprogramm bei Github kopiert, um Dir irgendwas zu zeigen. Ich weiß nicht, warum er dafür kein BeiSpiel hat. Ist dem Michael scheinbar zu banal. Ich kann mal bei mir gucken, ob ich in meinem Code etwas finde. Moment mal...

[Jens01]

Ich habe das einfach nur in den Editor getippt. Probier mal aus. Ich habe schon lange keine Matrizen mehr lösen müssen.:wink:

Delphi-Quellcode:

var
  a, b : TDoubleDynArray;
  m1, m2, mres : IMatrix;
begin
  a := [1,2,3];
  b := [1,2,3,4,5,6,7,8,9];
  
  m1 := TDoubleMatrix.Create(a, 1, 3);
  m2 := TDoubleMatrix.Create(b, 3, 3);  
  
  try
    mres := m2.SolveLinEQ(m1);
  except
    // hier kommt was, wenn die Matrix nicht funktioniert
  end;
  
  write(mres[0,0].tostring);
  write(mres[0,1].tostring);
  write(mres[0,2].tostring);
end;

[Rollo62]

Unabhängig von dem eigentlichen Problem empfehle ich mal das hier.
https://mathematikalpha.de/

Ist auch hier in der DP bekannt.
https://www.delphipraxis.net/187612-...tik-alpha.html

[Andreas13]

Zitat:

Zitat von Kegasetu (Beitrag 1476405)

Auf der grundlage der A-Matrix im Programm müsste die Matrix welche ich eingebe ja so aussehen:

A[0, 0] := l1*MA;
A[0, 1] := l2*MB;
A[0, 2] := l3*MC;
A[0, 3] := 0;
A[0, 4] := 0;
A[0, 5] := 0;
A[0, 6] := 0;
A[0, 7] := 0;
A[0, 8] := 0;
A[0, 9] := 0;
A[0, 10] := 0;
A[0, 11] := b1;

A[1, 0] := 0;
A[1, 1] := l2*MB;
A[1, 2] := l3*MC;
A[1, 3] := l4*MD;
A[1, 4] := 0;
A[1, 5] := 0;
A[1, 6] := 0;
A[1, 7] := 0;
A[1, 8] := 0;
A[1, 9] := 0;
A[1, 10] := 0;
A[1, 11] := b2;
usw..
Ich habe lzha[] jetzt mit l vereinfacht
Mir stellt sich jetzt noch die Frage, wie ich mit dem "SetLength" umgehe und vielmehr was es bedeutet?
Das n müsste ja n= 11 sein.

Hallo Kegasetu,
schreib bitte alle Deine 10 Gleichungen mit den konkreten Koeffizienten (= Zahlenwerten) auf, damit ich für Dich das Programm erstellen kann.
Gruß, Andreas

[Fiete45]

Moin Kegasetu,
mit dem Programm kannst Du Gleichungssysteme lösen.
Die Daten mußt Du selbst eingeben.
Die Größe der Systeme ist vom SpinEditN abhängig.
Viel Erfolg beim Testen!
Gruß Fiete

[Andreas13]

:thumb:

[Kegasetu]

Zitat:

Zitat von Andreas13 (Beitrag 1476459)

Zitat:

Zitat von Kegasetu (Beitrag 1476405)

usw..
Ich habe lzha[] jetzt mit l vereinfacht
Mir stellt sich jetzt noch die Frage, wie ich mit dem "SetLength" umgehe und vielmehr was es bedeutet?
Das n müsste ja n= 11 sein.

Hallo Kegasetu,
schreib bitte alle Deine 10 Gleichungen mit den konkreten Koeffizienten (= Zahlenwerten) auf, damit ich für Dich das Programm erstellen kann.
Gruß, Andreas

Danke für das Angebot!!!

Ich schreibe morgen Früh alles raus.

[Kegasetu]

Zitat:

Zitat von Fiete45 (Beitrag 1476489)

Moin Kegasetu,
mit dem Programm kannst Du Gleichungssysteme lösen.
Die Daten mußt Du selbst eingeben.
Die Größe der Systeme ist vom SpinEditN abhängig.
Viel Erfolg beim Testen!
Gruß Fiete

Danke für die zahlreiche Unterstützung. Auch das werde ich morgen mal durchgehen.

[Kegasetu]

Zitat:

Zitat von Andreas13 (Beitrag 1476492)

:thumb:

Die Gleichungen lauetet wie folgt:

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]



fab11[1]*blf11[1]+bl*lzha1[1]+mb=0
fab11[1]*blf11[1]+a*lzha1[1]-mb=0

fab11[2]*blf11[2]+cl*lzha1[2]+mb-mc=0
fab11[2]*blf11[2]+br*lzha1[2]-mb+mc=0

Die vier unteren sind noch nicht vollständig. Es geht mir erstmal um die oberen acht.

[Kegasetu]

Zitat:

Zitat von Kegasetu (Beitrag 1476529)

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]

Es gilt mb bis mi herauszufinden.

[Kegasetu]

Zitat:

Zitat von Fiete45 (Beitrag 1476489)

Moin Kegasetu,
mit dem Programm kannst Du Gleichungssysteme lösen.
Die Daten mußt Du selbst eingeben.
Die Größe der Systeme ist vom SpinEditN abhängig.
Viel Erfolg beim Testen!
Gruß Fiete

Super Teil!

[Andreas13]

Zitat:

Zitat von Kegasetu (Beitrag 1476531)

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]

Es gilt mb bis mi herauszufinden.

Was ist mit ma und mj? Sind sie bekannt oder kommen noch zwei weitere Gleichungen dafür?
Gruß, Andreas

[Kegasetu]

Zitat:

Zitat von Andreas13 (Beitrag 1476555)

Zitat:

Zitat von Kegasetu (Beitrag 1476531)

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]

Es gilt mb bis mi herauszufinden.

Was ist mit ma und mj? Sind sie bekannt oder kommen noch zwei weitere Gleichungen dafür?
Gruß, Andreas

Die sind bekannt. Andernfalls würde sich das System auch nicht lösen lassen.
Ich bin gerade dabei mein Programm zu vereinfachen. Eventuell gelingt es mir sogar, den Code abzuändern und zu implementieren.
Danke für deine Unterstützung, ich würde mich später (morgen, übermorgen) nochmal melden und fragen, wenn ich nicht weiterkomme.

[Andreas13]

Hallo,
wenn allerdings ma und mj bekannt sind, habe sie auf der linken Seite des Gleichungssystems (GLS) nichts verloren! Denn die konstanten Terme sind per Definition auf der rechten Seite. Sie müssen dann von den jeweiligen mma1[Zeile] abgezogen werden.

Damit wird allerdings nicht nur die Struktur Deiner Koeffizienten-Matrix (= linke Seite des GLS; A_Matrix) und der Rechte-Seite-Vektor (b_Vektor) chaotisch, sondern auch die Benennung Deiner Variablen: Der Vektor mma1[..] enthält sowohl konstante, also bekannte Terme, wie auch die zu bestimmenden Unbekannten!

Zwei Vermutungen habe ich hierbei:

1):
Wenn ma und mj wirklich bekannt sein sollen, dann darfst Du sie nicht mit den Unbekannten zusammen speichern, sondern separat, unter ganz anderen Namen, sonst ist das Chaos perfekt und Du kannst später Deinen Code weder verstehen, noch warten, geschweige denn weiterentwickeln.

2):
Daher vermute ich eher, daß Du hier wahrscheinlich einen Spezialfall Deines GLS mit ursprünglich 10 Unbekannten behandeln willst, wenn zwei Unbekannte ma und mj definierte Werte annehmen. In diesem Fall solltest Du für die beiden „momentan“ konstanten Variablen ma und mj zwei weitere Gleichungen hinzufügen:

Code:

ma = mma1[0]
mj = mma1[9]

Damit wird die in der Struktur der Matrix und des Vektors steckende Gesetzmäßigkeit gewahrt. Das ist extrem wichtig für die Belegung von A-Matrix und b_Vektor, damit Du diese mit einer einfachen For-Schleife füllen kannst und nicht jedes Element mühselig und vor allem fehleranfällig „zu Fuß“ hinzufügen mußt.

Wenn Du obige Ratschläge beherzigst, entsteht auf der linken Seite Deines Gleichungssystems eine sogenannte Bandmatrix, ganz speziell eine Tridiagonal-Matrix. Diese läßt sich wesentlich schneller – mit einem Bruchteil an Operationen – und genauer (weniger Operationen, weniger Rundungsfehler) berechnen, allerdings nicht mit dem Gaußschen Algorithmus, sondern mit speziell für Tridiagonal-Matrizen entwickelten Algorithmen der linearen Algebra. Aber das würde hier zu weit führen. Daher nur so viel: Gauß ist OK, aber er macht hier riesige unnötige Umwege. Aber der heutige PC ist schnell und es fällt daher gar nicht auf.

Summe Summarum: Bevor Du also weiter programmierst, überprüfe zunächst Dein Gleichungssystem und benenne Deine Variablen mit Bedacht, damit Du es beim Implementieren der Algorithmen und bei der späteren Pflege der Routinen leichter hast.

Gruß, Andreas

[Michael II]

Noch ein Tipp: Zum Beispiel Maple und Mathematica können dir bei solchen Problemen oft sehr rasch helfen. Wenn du also Zugriff auf solche Software hast...

Maple gibt's auch online; allerdings in sehr reduzierter Form (LGS zum Beispiel nur bis dim=5):
https://de.maplesoft.com/products/St...pps/index.aspx

Wenn du oft Matheprobleme lösen musst und mit deiner Software Geld verdienst, dann lohnt sich die Anschaffung einer Vollversion ganz sicher.