[Delphi/Pascal]Metoda eliminacji gaussa dla l. zespolonych

Molekh · Post autor: **Molekh** » 20 maja 2013, o 17:15

Witajcie!
Jestem studentem pierwszego roku elektrotechniki i mam na zaliczenie projekt z informatyki. Napisałem program, kompiluje, jednak gdzieś wkradł się błąd logiczny i podaje zły wynik. Niestety nie potrafię odnaleźć samemu tego błędu, dlatego zwracam się do was o pomoc.
Oto biblioteka tego programu:

Kod: Zaznacz cały

unit biblioteka;

interface
type
  Zesp = record
    Re, Im : Real;
  end;
  Wekz = array[1..10] of Zesp;
  Mac = array[1..10, 1..10] of Real;
  Macz = array[1..10, 1..10] of Zesp;
  Wek = array[1..10] of Real;

procedure Pisz_Macz_Zb(X : Macz; M, L : Integer; S : String; var ZB : TextFile);
procedure Pisz_Wekz_Zb(X : Wekz; M : Integer; S : String; var ZB : TextFile);
procedure Czyt_Wekz_Zb(var X : Wekz; M : Integer; var ZB : TextFile);
procedure Czyt_Macz_Zb(var X : Macz; M, L : Integer; var ZB : TextFile);
procedure Dod_Zesp(var X : Zesp; Y, Z : Zesp);
procedure Ode_Zesp(var X : Zesp; Y, Z : Zesp);
procedure Mno_Zesp(var X : Zesp; Y, Z : Zesp);
procedure Mno_Zesp_R(var X : Zesp; Y : Zesp; R : Real);
procedure Odw_Zesp(var X : Zesp; Y : Zesp);
procedure Sprz_Zesp(var X : Zesp; Y : Zesp);
function Modul_Zesp(X : ZESP) : Real;
procedure Dziel_Zesp(var X : Zesp; Y, Z : Zesp);
procedure Czyt_Zesp(var X : Zesp; S : string);
procedure Pisz_Zesp(X : Zesp; S : String);
procedure Dod_Wekz(var X : Wekz; Y, Z : Wekz; M : Integer);
procedure Ode_Wekz(var X : Wekz; Y, Z : Wekz; M : Integer);
procedure Dod_Macz(var X : Macz; Y, Z : Macz; M, L : Integer);
procedure Mno_Macz(var X : Macz; Y, Z : Macz; M, L, L1 : Integer);
procedure MNO_Macz_Wekz(var X : Wekz; Y : Macz; Z : Wekz; M, L : Integer);
procedure Czyt_Wekz(var X : Wekz; M : Integer; S : String);
procedure Czyt_Macz(var X : Macz; M, L : Integer; S : String);
procedure Pisz_Wekz(X : Wekz; M : Integer; S : String);
procedure Pisz_Macz(X : Macz; M, L : Integer; S : String);
procedure Gauss_Zesp(A : Macz; B : Wekz; var X : Wekz; N : Integer; EPS : Real;
  var IST : Boolean; var Det : Zesp);

implementation
procedure Pisz_Macz_Zb(X : Macz; M, L : Integer; S : String; var ZB : TextFile);
var
  I, J : Integer;
begin
  Writeln(ZB, 'MACIERZ ', S);
  for I := 1 to M do
  begin
    for J := 1 to L do
      Write(ZB, X[I, J].RE: 4: 2, ' ', X[I, J].IM: 4: 2, ' ');
    Writeln(ZB);
  end;
end;

procedure Czyt_Wekz_Zb(var X : Wekz; M : Integer; var ZB : TextFile);
var
  I : Integer;
begin
  for I := 1 to M do
    Read(Zb, X[I].Re, X[I].Im);
end;

procedure Czyt_Macz_Zb(var X : Macz; M, L : Integer; var ZB : TextFile);
var
  I, J : Integer;
begin
  for I := 1 to M do
    for J := 1 to L do
      Read(ZB, X[I, J].Re, X[I, J].Im);
end;

procedure Pisz_Wekz_Zb(X : Wekz; M : Integer; S : String; var ZB : TextFile);
var
  I : integer;
begin
  Writeln(ZB, 'WEKTOR ', S);
  for I := 1 to M do
    Writeln(ZB, X[I].Re: 4: 2, ' ', X[I].IM: 4: 2);
end;

 procedure Dod_Zesp(var X : Zesp; Y, Z : Zesp);
begin
  X.RE := Y.Re + Z.Re;
  X.IM := Y.Im + Z.Im;
end;

procedure Ode_Zesp(var X : Zesp; Y, Z : Zesp);
begin
  X.Re := Y.Re - Z.Re;
  X.Im := Y.Im - Z.Im;
end;

procedure Mno_Zesp(var X : Zesp; Y, Z : Zesp);
begin
  X.Re := Y.Re * Z.Re - Y.Im * Z.Im;
  X.Im := Y.Re * Z.Im + Y.Im * Z.Re;
end;

procedure Mno_Zesp_R(var X : Zesp; Y : Zesp; R : Real);
begin
  X.Re := Y.Re * R;
  X.Im := Y.Im * R;
end;

procedure Odw_Zesp(var X : Zesp; Y : Zesp);
begin
  Sprz_Zesp(Y, Y);
  Mno_Zesp_R(X, Y, 1 / Sqr(Modul_Zesp(Y)));
end;

procedure Sprz_Zesp(var X : Zesp; Y : Zesp);
begin
  X.RE := Y.Re;
  X.IM := -Y.Im;
end;

function Modul_Zesp(X : ZESP) : Real;
begin
  Result := Sqrt(Sqr(X.RE) + Sqr(X.IM));
end;

procedure Dziel_Zesp(var X : Zesp; Y, Z : Zesp);
begin
  Odw_Zesp(Z, Z);
  Mno_Zesp(X, Y, Z);
end;

procedure Czyt_Zesp(var X : Zesp; S : string);
begin
  Write('Re{', S, '}Y=');
  Readln(X.Re);
  Write('Im{', S, '}Y=');
  Readln(X.Im);
end;

procedure Pisz_Zesp(X : Zesp; S : String);
begin
  Write(S, '=', X.Re: 4: 2);
  if X.Im < 0 then
    Writeln(' -j ', ABS(X.IM): 4: 2)
  else
    Writeln(' +j ', ABS(X.IM): 4: 2);
end;

procedure Dod_Wekz(var X : Wekz; Y, Z : Wekz; M : Integer);
var
  I : Integer;
begin
  for I := 1 to M do
    Dod_Zesp(X[I], Y[I], Z[I]);
end;

procedure Ode_Wekz(var X : Wekz; Y, Z : Wekz; M : Integer);
var
  I : integer;
begin
  for I := 1 to M do
    ODE_ZESP(X[I], Y[I], Z[I]);
end;

procedure Dod_Macz(var X : Macz; Y, Z : Macz; M, L : Integer);
var
  I, J : Integer;
begin
  for I := 1 to M do
    for J := 1 to L do
      Dod_Zesp(X[I, J], Y[I, J], Z[I, J]);
end;

procedure Mno_Macz(var X : Macz; Y, Z : Macz; M, L, L1 : Integer);
var
  I, J, K : Integer;
  W : Zesp;
begin
  for I := 1 to M do
    for J := 1 to L do
    begin
      X[I, J].Re := 0;
      X[I, J].Im := 0;
      for K := 1 to L1 do
      begin
        Mno_Zesp(W, Y[I, K], Z[K, J]);
        Dod_Zesp(X[I, J], X[I, J], W);
      end;
    end;
end;

procedure MNO_Macz_Wekz(var X : Wekz; Y : Macz; Z : Wekz; M, L : Integer);
var
  I, J : Integer;
  W : Zesp;

begin
  for I := 1 to M do
  begin
    X[I].Re := 0;
    X[I].Im := 0;
    for J := 1 to L do
    begin
      Mno_Zesp(W, Y[I, J], Z[J]);
      Dod_Zesp(X[I], X[I], W);
    end;
  end;
end;

procedure Czyt_Wekz(var X : Wekz; M : Integer; S : String);
var
  I : Integer;
begin
  for I := 1 to M do
  begin
    Write(S, '[', I, '].Re=');
    Readln(X[I].Re);
    Write(S, '[', I, '].Im=');
    Readln(X[I].Im);
  end;
end;

procedure Czyt_Macz(var X : Macz; M, L : Integer; S : String);
var
  I, J : Integer;
begin
  for I := 1 to M do
    for J := 1 to L do
    begin
      Write(S, '[', I, ',', J, '].Re= ');
      Readln(X[I, J].RE);
      Write(S, '[', I, ',', J, '].IM= ');
      Readln(X[I, J].IM);
    end;
end;

procedure Pisz_Wekz(X : Wekz; M : Integer; S : String);
var
  I : Integer;
begin
  Writeln('Wektor ', S);
  for I := 1 to M do
    Writeln(X[I].Re: 4: 2, ' +J ', X[I].Im: 4: 2);
end;

procedure Pisz_Macz(X : Macz; M, L : Integer; S : String);
var
  I, J : Integer;
begin
  Writeln('Macierz ', S);
  for I := 1 to M do
  begin
    ;
    for J := 1 to L do
      Write(X[I, J].Re: 4: 2, ' +J ', X[I, J].Im: 4: 2, ' ');
    Writeln;
  end;
end;

 procedure Gauss_Zesp(A : Macz; B : Wekz; var X : Wekz; N : Integer; EPS : Real;
  var IST : Boolean; var Det : Zesp);
var
  I, J, K : Integer;
var
  ZNAK : Integer;
  M : Real;
  Z, V : Zesp;

begin
  IST := True;
  ZNAK := 1;
  for I := 1 to N - 1 do
  begin
    M := Modul_Zesp(A[I, I]);
    K := I;
    for J := I + 1 to N do
      if Modul_Zesp(A[J, I]) > M then
      begin
        M := Modul_Zesp(A[J, I]);
        K := J;
      end;
    if M < EPS then
    begin
      IST := False;
      Exit;
    end;
    if K > I then
    begin
      ZNAK := -ZNAK;
      Z := B[I];
      B[I] := B[K];
      B[K] := Z;
      for J := I to N do
      begin
        Z := A[I, J];
        A[I, J] := A[K, J];
        A[K, J] := Z;
      end;
    end;
    for J := I + 1 to N do
    begin
      dziel_Zesp(Z, A[J, I], A[I, I]);
      Mno_Zesp_R(Z, Z, -1);
      Mno_Zesp_R(V, B[I], m);
      Dod_Zesp(B[J], B[J], V);
      for K := I to N do
      begin
        Mno_Zesp_R(V, A[I, K], M);
        Dod_Zesp(A[J, K], A[J, K], V);
      end;
    end;
    //PISZ_MAC_ZB(A,N,N,'A',ZB);
    //PISZ_WEK_ZB(B,N,'B',ZB);
  end;
  if Modul_Zesp(A[N, N]) < EPS then
  begin
    IST := False;
    Exit;
  end;
  for I := N downto 1 do
  begin
    Z.Re := 0;
    Z.Im := 0;
    for J := I + 1 to N do
      Mno_Zesp(V, A[I, J], X[J]);
    Dod_Zesp(Z, Z, V);
    Ode_Zesp(V, B[I], Z);
    Dziel_Zesp(X[I], V, A[I, I]);
  end;
  Det.Re := 1;
  Det.Im := 0;
  for I := 1 to N do
    Mno_Zesp(DET, DET, A[I, I]);
  Mno_Zesp_R(DET, DET, ZNAK);
  //DET:=DET*ZNAK;    mnozenie rzeczywistej  z zespolonej
end;
end.

Zakładam iż błąd logiczny jest w procedurze gauss_zesp.
Dziękuje wszystkim za pomoc.
Pozdrawiam.

kadiii · Post autor: **kadiii** » 20 maja 2013, o 17:54

Procedura wygląda tak:
1. Debagujesz swój program - linijka po linijce
2. Dochodzisz do momentu, w którym program zachowuje się inaczej niż zakladałeś -> naprawiasz błąd i wracasz do punktu 1 aby sprawdzić rozwiązanie.
3. Jeśli nie potrafisz dojść dlaczego dana instrukcja wykonuje się inaczej niż oczekiwałeś szukasz w Googlu lub pytasz na forum
Procedura ma tą zaletę, że w większości przypadków kończy się na punkcie 2.

Molekh · Post autor: **Molekh** » 20 maja 2013, o 18:02

Znaczy program kompiluje. Działa. Wypluwa wynik. Tyle tylko że błędny. Dlatego nie potrafię go samemu odnaleźć, gdyż na matmie macierzy liczb zespolonych nie mieliśmy.

kadiii · Post autor: **kadiii** » 20 maja 2013, o 18:17

To, że się kompiluje znaczy tylko tyle, że jest poprawny składniowo. Po to debuggujesz aby dowiedzieć się jak działa. Przeczytaj tekst z linku, który Ci podałem.

gdyż na matmie macierzy liczb zespolonych nie mieliśmy.

Jeżeli nie potrafisz wykonać tych operacji na kartce to tym bardziej nie stworzysz programu, który to wykona. Zakładając nawet, że znalazłbyś gotowy program nie jesteś w stanie zweryfikowac czy w większosci przypadków działa. W takiej sytuacji musisz zacząć od tego aby nauczyć się to wykonać na kartce.

Molekh · Post autor: **Molekh** » 20 maja 2013, o 19:11

Hm... Kolega podał mi debugowanie pod pascala, za co jestem mu wdzięczny, jednak program był pisany w Delphi 4, więc nie wiem jak za to się zabrać w tym środowisku. Pozdrawiam

kadiii · Post autor: **kadiii** » 20 maja 2013, o 21:25

Sorry za ironię, ale czy masz zablokowany dostep do Google-a? Pierwsze wyniki po wpisaniu frazy Delphi 4 dubugging... dodasz do tej frazy jeszcze środowisko IDE jakie używasz i będziesz miał pełną odpowiedź. Trochę samodzielności, w końcu to już studia.