Delphi 4 - Metoda eliminacji gaussa liczb zespolonych

0

Witajcie, jestem studentem pierwszego roku elektrotechniki i mam problem z programem który oblicza za pomocą metody eliminacji gaussa. Program źle wykonuje obliczenia dla części rzeczywistych (dla urojonych pewnie też), gdyż gdy wstawiam te same dane liczbowe dla innego programu co liczy tylko liczby rzeczywiste, pokazuje inne wyniki. Dlatego prosze was o pomoc.

Program główny:

procedure TForm1.Button1Click(Sender : TObject);
var
  A : Macz;
  X, B, Z : Wekz;
  N : Integer;
  NA, NB : TextFile;
var
  IST : Boolean;
  DET : Zesp;
begin
  AssignFile(NA, edit1.Text);
  Reset(NA);
  Readln(NA, n);
  Czyt_Macz_Zb(A, N, N, NA);
  Czyt_Wekz_Zb(B, N, NA);
  CloseFile(NA);
  AssignFile(NB, edit2.Text);
  Rewrite(NB);
  Pisz_Macz_Zb(A, N, N, 'A', NB);
  Pisz_Wekz_Zb(B, N, 'B', NB);
  Gauss_Zesp(A, B, X, n, 1E-8, IST, DET);
  if IST then
  begin
    Pisz_Wekz_Zb(X, n, 'X', NB);
    ;
  end
  else
    Writeln(NB, 'Nie uzyskano wyniku');
  Mno_Macz_Wekz(Z, A, X, N, N);
  Pisz_Wekz_Zb(Z, N, 'Z', NB);
  CloseFile(NB);
end;

Jako iż bibliotekę musiałem pisać sam, podsyłam również jej fragmenty które były potrzebne do tego programu:

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.

Z góry dziękuje za odpowiedzi.
Pozdrawiam

0

Sformatuj kod i wstaw o odpowiednie znaczniki, to ktoś spojrzy, bo teraz to jest całkowicie nieczytelne. Jeżeli sam nie umiesz formatować kodu skorzystaj choćby z: http://olesio.eu/jcf

0

Taka moja podpowiedź. Zrób z tych liczb zespolonych klasę i przeciąż operatory. Wygodniej będzie się tego używać.

Delphi 4 - Metoda eliminacji gaussa liczb zespolonych

1 użytkowników online, w tym zalogowanych: 0, gości: 1

Praca dla programistów

Forum dyskusyjne

Sprawy administracyjne

O nas

Skontaktuj się z nami