Witam,

tutaj znalazłem taki kod do odwracania macierzy:

Odwracanie macierzy

Wygląda on tak:

 {$N+}
Program Macierz_Odwrotna;
Const
  Max  = 50;      { Maksymalny stopien macierzy }
  Zero = 1.0E-7;  { Umowne zero }
Type
  TMacierz= Array[1..Max,1..Max] of Real;
 
 
Function OdwracanieMacierzy(Var Macierz: TMacierz;Stopien:Byte): Boolean;
Var
  w,k,w1,k1,i,                { zmienne wykorzystywane przy iteracji }
  p,q              : Integer;  { wspolrzedne elementu osiowego }
  c               : Array[1..Max] of Byte;
  BylaJuzKolOsiowa: Array[1..Max]of boolean;
  Max             : Real;
  MacPom          : TMacierz;
begin
FillChar(BylaJuzKolOsiowa,SizeOf(BylaJuzKolOsiowa),False);
for w:=1 to Stopien do
  begin
    c[w]:=0;
    Max:=0.0;
    for k:=1 to Stopien do
      begin
        if not(BylaJuzKolOsiowa[k]) then
        if Max < Abs(Macierz[w,k]) then
          begin
            Max:=Abs(Macierz[w,k]);
            p:=w;
            q:=k;
          end;
      end;
    if Max<Zero then
      begin
        OdwracanieMacierzy:= False;
        Exit;
      end;
    for w1:=1 to Stopien do
      for k1:=1 to Stopien do
        if (w1<>p)and(k1<>q)then
          Macierz[w1,k1]:= Macierz[w1,k1]-(Macierz[p,k1]*Macierz[w1,q]/Macierz[p,q]);
    for w1:=1 to Stopien do
      if w1<>p then Macierz[w1,q]:= -Macierz[w1,q]/Macierz[p,q];
    for k1:=1 to Stopien do
      if k1<>q then Macierz[p,k1]:= Macierz[p,k1]/Macierz[p,q];
    Macierz[p,q]:= 1/Macierz[p,q];
 
    c[w]:= q;
    BylaJuzKolOsiowa[q]:= True;
  end;
 
 
(* Permutowanie macierzy *)
MacPom:=Macierz;
for k:=1 to Stopien do
  for i:=1 to Stopien do
    Macierz[c[k],i]:= MacPom[k,i];
 
MacPom:=Macierz;
for k:=1 to Stopien do
  for i:=1 to Stopien do
    Macierz[i,k]:= MacPom[i,c[k]];
 
 
OdwracanieMacierzy:= True;
end;
 
Procedure Wczytaj(var Macierz:TMacierz;var Stopien:Byte);
Var
  f   : Text;
  i,j : Integer;
Begin
  Assign(f,'.\in.txt');
  Reset(f);
  ReadLn(f,Stopien);
  if Stopien>max then
    begin
      WriteLn('Macierz za duza!!!');
      Halt;
    end;
  for i:=1 to Stopien do
    begin
      for j:=1 to Stopien do
        Read(f,Macierz[i,j]);
      ReadLn(f);
    end;
  Close(f);
end;
 
Procedure Zapisz(Var Macierz:TMacierz; Stopien:Integer; OK:Boolean);
Var
  f   : Text;
  i,j : Integer;
Begin
  Assign(f,'.\out.txt');
  Rewrite(f);
  if OK then
    for i:=1 to Stopien do
      begin
        for j:=1 to Stopien do
          Write(f,Macierz[i,j],' ');
        WriteLn(f);
      end
    else
    WriteLn(f,'Macierz osobliwa!!!');
  Close(f);
end;
 
 
Var
  Macierz : TMacierz;
  Stopien : Byte;
Begin
  Wczytaj(Macierz,Stopien);
  if OdwracanieMacierzy(Macierz,Stopien) then
    Zapisz(Macierz,Stopien,True)
    else
    Zapisz(Macierz,Stopien,False);
end.

Teraz muszę na podstawie tego wprowadzić do swojego programu odwracanie macierzy, ale o znanym wymiarze (12x12). Część kodu zaczynająca się od

Procedure Wczytaj(var Macierz:TMacierz;var Stopien:Byte);

nie będzie mi potrzebna.

Elementy macierzy, która zostanie odwrócona zostaną obliczone na podstawie wartości wpisanych do pól edit, z tym sobie poradzę, chodzi o samą procedurę odwracania. Będę wdzięczny, jeśli ktoś mógłby pomóc mi rozgryźć ten algorytm i podpowiedzieć których elementów się pozbyć w przypadku znanego rozmiaru macierzy, tj. 12x12.