Inverse einer matrix

[swarley]

Hallo,
ich brauche dringend Hilfe. Ich soll in einer eigenen Unit ein Unterprogramm schreiben, dass die Inverse einer Matrix berechnet. Als Hinweiß habe ich gegeben, dass man den Gauß Jordan Algorithmus verwenden soll. Soweit so gut, ich habe mich durchs www gegooglet und verschiedene Quelltexte gefunden, aber beim "abtippen" in delphi sozusagen, hauts nicht mehr hin.
ich würde euch zeigen was ich da zusammengebastelt habe, bin aber auch offen für völlig neue tipps, bzw vllt seiten im internet wo ich eine gute beschreibung finde, wie ich vorgehen kann. Also wie gesagt, jegliche Form von Hilfe ist sehr willkommen.

Liebe Grüße

hier der Quelltext:

procedure invers(spalten1, zeilen1: Integer);
var
i, j,k, spalteninv: Integer;
begin
spalteninv := spalten1 + spalten1;

for i := 0 to zeilen1 - 1 do
for j := 0 to spalten1 - 1 do
begin
matIn[i, j] := mat1[i, j];
end;

for i := 0 to zeilen1 - 1 do
for j := spalten1 to spalteninv - 1 do
begin
if matIn[i, j] = matIn[i, (spalten1 + i)]
then
matIn[i, j] := 1
else
matIn[i, j] := 0;
end;

for k := 0 to zeilen1 - 1 do
for j := 0 to zeilen1 - 1 do
if j <> k
then
begin
for i := 0 to spalteninv - 1 do
matIn[j, i] := matIn[j, i] - ((matIn[j, k] / matIn[k, k]) * matIn[k, i]);
end
else
break;

[Medium]

A) Wilkommen in der DP
B) Quellcode bitte zwecks Lesbarkeit in [ delphi] .. [ /delphi]-Tags packen (ohne Leerzeichen)
C) "hauts nicht mehr hin" ist keine Problembeschreibung. Was soll passieren, was passiert statt dessen? (Dass man das aber auch jedem sagen muss, hach ja )

[gammatester]

Hallo,

zu allererst soltest Du Deinen Quelltext in Delphi formatieren (Helmsymbol).

Ich kann in Deiner procedure invers(spalten1, zeilen1: Integer) weder eine Eingabe- noch eine Ausgabematrix erkennen. Was sind die Parameter? Invertieren kann man nur eine "quadratische Matrix", also eine Matrix mit Spaltenzahl=Zeilenzahl, also wäre nur eine Eingabe zu erwarten.

Was funktioniert nicht? Kannst Du Deinen Quellcode nicht übersetzen (wäre kein Wunder, da eine procedure kann nie mit break enden kann) oder erhältst Du falsche Ergebnisse oder was?

[DeddyH]

Das break gehört zur Schleife

Zitat:

Delphi-Quellcode:

for k := 0 to zeilen1 - 1 do
  for j := 0 to zeilen1 - 1 do //hier
    if j <> k then
      begin
        for i := 0 to spalteninv - 1 do
          matIn[j, i] := matIn[j, i] - ((matIn[j, k] / matIn[k, k]) * matIn[k, i]);
      end
    else
      break;

[BUG]

Erst einmal: Es gibt eine inverse Matrix nur für quadratische Matrizen mit vollem Rang (reguläre Matrix). Das heißt die Anzahl der Zeilen und Spalten ist gleich.

Dann könntest du etwas Abstraktion vertragen: schreibe erst einmal die Prozeduren für die Zeilenoperationen.
Das könntest du in einer Matrizen-Klasse kapseln.

Jetzt kommt der eigentliche Algorithmus:
Dazu musst du dir überlegen wie du Gauß implementierst ... wenn du soweit bist, dass du mit deiner Gauß-Algorithmus-Prozedur unter Nutzung der Zeilenoperationen jede reguläre Matrix in eine Einheitsmatrix umformen kannst, bist du so gut wie fertig:
Jetzt musst du nur noch alle Operationen, die du bei der Umformung machst, zusätzlich auf einer Einheitsmatrix ausführen, die damit zur inversen Matrix umgeformt wird.

[swarley]

okay, ich war etwas übereilig. ihr könnt ja gar nicht wissen, was ich da noch alles fabriziert habe
Aufgabe ist es ein Unit namens "MyUnitMatrix" zu schreiben, in der mittels Unterprogrammen 2 Matrizen zu addieren, subtrahieren und multiplizieren sind. Zusätlich soll die Inverse ermittelt werden, und am besten das ganze auch nochmal überprüft werden (inverse mit ausgangsmatrix multiplizieren soll einheitsmatrix ergeben sozusagen). Soweit sogut.
ich hatte ein "urfassung" aus der entstammt auch der quelltext. Leider hat meiner Professorin das ganze optisch nicht gepasst (mal abgesehen davon, dass es nicht richtig funktioniert hat[was an dieser stelle heißt: programm wurde ausgeführt, inverse lieferte allerdings nicht das richtige ergebnis, die erste spalte war richtig, die restlichen enthielten werte, nicht die richtigen])
In dieser "urfassung" muss der Benutzer zu erst den rang seiner beiden Matrizen eingeben. anschließend mit dem button weiter erscheinen die Stringgrids der entsprechenden Größe, die angegeben wurde. Anschließend werden diese mit Zahlen gefüllt und je nach Button ("+", "-", "*") wurde überprüft ob die matrizen den bedingungen entsprechen, ansonsten müssen werte geändert werden. Unter einem der Stringgrids befand sich dann der button "inverse" dazu nun der quelltext aus der "hauptunit" sozusagen

Delphi-Quellcode:

procedure TForm2.ButtonInversClick(Sender: TObject);
var
  i, j, zeilen, spalten: Integer;
begin
  zeilen := StrToInt(Zeilenedit1.Text);
  spalten := StrToInt(Spaltenedit1.Text);
  if zeilen = spalten then
  begin
    for i := 0 to zeilen - 1 do
      for j := 0 to spalten - 1 do
      begin
        mat1[i, j] := StrToFloat(StringGridMatrix1.Cells[j, i]);
      end;
  end
  else
  begin
    ShowMessage('Zeilen-und Spaltenanzahl muss gleich groß sein!');
    exit;
  end;

  setlength(mathilf, zeilen);
  for i := 0 to zeilen - 1 do
  begin
    setlength(mathilf[i], 2 * spalten);
  end;

  invers(zeilen); // da spalten=zeilen reicht es aus, eins davon zu übergeben

  setlength(matinv, zeilen);
  for i := 0 to zeilen - 1 do
  begin
    setlength(matinv[i], zeilen);
  end;

  for i := 0 to zeilen - 1 do
  begin
    for j := 0 to zeilen - 1 do
    begin
      matinv[i, j] := mathilf[i, j + zeilen];
    end;
  end;

  StringGridMatrix3.Visible := true;
  labelergebnis.Visible := true;

  for i := 0 to zeilen - 1 do
  begin
    for j := 0 to zeilen - 1 do
    begin
      StringGridMatrix3.Cells[j, i] := FloatToStr(matinv[i, j]);
    end;
  end;
end;

end;

so, die matrizen, die eingegeben wurden also "mat1" und "mat2" habe ich global deklariert (was leider aufgabentechnisch auch falsch war). Ich hätte es lokal deklarieren und in das unterprogramm mit übergeben sollen. Das muss ich auch erneut überarbeiten.
naja und dann in meiner Unit "myunitmatrix" sozusagen, habe ich das unterprogramm deklariert, das is sozusagen der Quelltext oben. ich poste ihn trotzdem nochmal.

Delphi-Quellcode:

procedure invers(zeilen: Integer);
var
  i, j, k, pivotzeile: Integer;
  mateinheit: array of array of double;
  pivotelement, faktor, hilf: double;
begin
  setlength(mateinheit, zeilen);
  for i := 0 to zeilen - 1 do
  begin
    setlength(mateinheit[i], zeilen);
    mateinheit[i, i] := 1;
  end;

  for i := 0 to zeilen - 1 do
  begin
    for j := 0 to zeilen - 1 do
    begin
      mathilf[i, j] := mat1[i, j];
    end;
  end;

  for i := 0 to zeilen - 1 do
  begin
    for j := 0 to zeilen - 1 do
    begin
      mathilf[i, j + zeilen] := mateinheit[i, j];
    end;
  end;

  for k := 0 to zeilen - 2 do
  begin
    pivotelement := 0;
    pivotzeile := k;
    for i := k to zeilen - 1 do
    begin
      if abs(mathilf[i, k]) > pivotelement then
      begin
        pivotelement := abs(mathilf[i, k]);
        pivotzeile := i;
      end;
      if k <> pivotzeile then
      begin
        for j := k to zeilen do
        begin
          hilf := mathilf[k, j];
          mathilf[k, j] := mathilf[i, j];
          mathilf[i, j] := hilf;
        end;
      end;
    end;
    if mathilf[k, k] = 0 then
      exit;
    for i := k + 1 to zeilen - 1 do
    begin
      faktor := mathilf[i, k] / mathilf[k, k];
      for j := k to zeilen do
      begin
        mathilf[i, j] := mathilf[i, j] - faktor * mathilf[k, j];
      end;
    end;
  end;

  for k := zeilen - 1 downto 0 do
  begin
    if mathilf[k, k] = 0 then
      exit;
    for i := k - 1 downto 0 do
    begin
      faktor := mathilf[i, k] / mathilf[k, k];
      for j := zeilen downto i do
      begin
        mathilf[i, j] := mathilf[i, j] - faktor * mathilf[k, j];
      end;
    end;
    for j := zeilen to 2 * zeilen - 1 do
    begin
      mathilf[k, j] := mathilf[k, j] / mathilf[k, k];
    end;
  end;
end;

ich weiß dieser beitrag ist mittlerweile schon überlang, aber ich komm echt nicht mehr klar. ich bräuchte irgendwie einen funktionierenden algorithmus für diese gauß jordan geschichte. Ich habe dummerweiße (glaub ich) auch noch nicht den fall abgegriffen, was geschieht wenn das erste element der ersten zeile eine 0 ist.
ich wäre auch über neue denkanstöße oder hilfelinks sehr dankbar, denn da ich selber nicht mehr checke was ich da hin implementiert habe, besstehe ich nicht auf das gedöns ^^
vielen dank an alle die sich die zeit nehmen das anzusehen

PS: ich habe die beschriebenen dateien mal als zip angehängt falls ich in meiner ausführung zu ungenau oder schlusig war.

[BUG]

Zitat von swarley:

ich wäre auch über neue denkanstöße oder hilfelinks sehr dankbar, denn da ich selber nicht mehr checke was ich da hin implementiert habe, besstehe ich nicht auf das gedöns ^^

Wie wäre es, wenn du die Zeilenoperationen in eigene Funktionen schiebst?
Das würde deinen Code viel lesbarer machen.


Du kannst Gauß "rekursiv" anwenden, wobei du immer eine Spalte und eine Zeile weniger betrachtest:

Angenommen du hast eine n*n-Matrix M = (a_ij) mit i = Zeilennummer, j = Spaltennummer.

Code:

für j := 1 bis n tue
  wenn a_jj = 0 dann
    suche i > j mit a_ij <> 0; // existiert, da Matrix vollen Rang hat
    tauche a_1j und a_ij;
  // jetzt ist a_jj <> 1
  Multipliziere Zeile j mit dem multiplikativen Inversen von a_jj;
  // jetzt ist a_jj = 1
  Addiere Zeile j so auf die restlichen Zeilen, dass dort Nullen in Spalte j entstehen (passenden Faktor wählen);

XXXX 1. Schleifendurchlauf
XXXX 2. Schleifendurchlauf
XXXX 3. Schleifendurchlauf
XXXX 4. Schleifendurchlauf

Apropos, in welchem Körper rechnest du eigentlich?

[swarley]

stimmt, an rekursion habe ich noch gar nicht gedacht... werde mich daran mal versuchen.
also in der aufgabenstellung ist nichts gegeben, demnach nehm ich ma ganz stark an, dass wir uns in Q befinden.
es soll grob gesehn ein Programm für Schüler entstehen, demnach nehme ich an, dass eben einfach positive und negative Dezimalzahlen mit und ohne Nachkommastellen eingegeben werden sollen
wie schaffe ich es denn, dass ich die eingelesen matrizen dem unterprogramm übergeben kann. muss ich dazu eine typdeklaration machen? also ich meine:
type Matrizen = TMatrix usw? wenn ich die arrays als lokale variablen einfach übergeben, wird mir das rot unterwellt.

[Delphi-Laie]

Zitat von swarley:

googlet und verschiedene Quelltexte gefunden, aber beim "abtippen" in delphi sozusagen, hauts nicht mehr hin.

Das ist nicht verwunderlich, weil Du nur kopiertest, ohne den Algorithmus verinnerlicht zu haben. Asche auf jedermanns Haupt, wer tat das bisher noch nie, aber die Gefahr ist immer groß, auf diese bequeme Weise Schiffbruch zu erleiden.

[BUG]

Zitat von swarley:

also in der aufgabenstellung ist nichts gegeben, demnach nehm ich ma ganz stark an, dass wir uns in Q befinden.

Das solltest du unbedingt klären oder den Algorithmus unabhängig vom Körper implementieren (aber deinem bisher gezeigtem Quellcode nach solltest du das besser nicht versuchen).

Die reellen Zahlen solltest du vermeiden, da man die im Computer nicht genau darstellen kann und deshalb nur Ärger hat.
Wenn du es dir aussuchen darfst: mit einer Restklasse modulo einer Primzahl gibt es imho am wenigsten Probleme.