Програма Zeidel

program Zeidel; {$N+} {$E+} {Розв’язання СЛР x=Bx+d за методом Зейделя

ВХІД: Zeidel.inp --- текстовий вихідний файл з СЛР. Наприклад,

--------------------- початок ---------------------

4 1.0e-3 8 5

0.00 -0.15 0.20 -0.35 0.40 0.00

0.12 0.00 0.36 0.04 -0.12 0.00

0.36 -0.24 0.00 0.20 -0.12 0.00

-0.40 0.15 -0.25 0.00 0.85 0.00

---------------------- Кінець ---------------------

де 4 – розмір матриці A, 1.0e-3 – точність підрахунків, 8 – число всіх цифр, 5 – число цифр після коми.

ВИХІД: Zeidel.out --- текстовий фай з результатами}

const _N=10; NamePrg=’Zeidel’;

type TVect = array [1.._N] of extended;

TMatr = array [1.._N,1.._N] of extended;

{індекс y TNorm: 1=m-норма,2=k-норма,3=1-норма}

TNorm = array [1..3] of extended;

var Stop, Step: boolean;

i,j,k,n,All,Dec: integer;

All_Iter, {Загальне число ітерацій}

NIter: longint; {Номер поточної ітерації}

eps, {Точність підрахунків}

qq, {коефіцієнт стиску}

delta: extended; {граничний крок для зупинки}

NameInp,NameOut,{Імена вхідного,вихідного файлів}

answer: string;

a: TMatr; {матриця B ітераційної схеми}

b, {вектор d ітераційної схеми}

XtempOld, {старий поточний вектор}

Xtemp: TVect; {новий поточний вектор}

finm,fout:text; {вхідний та вихідний файли}

procedure VectNorms(n:integer;v:TVect;var norm:TNorm);

var j,k:integer; sum:extended;

BEGIN {VectNorms}

norm[1]:=abs(v[1]);

for i:=1 to n do

if norm[1]<abs(v[1]) then norm[1]:=abs(v[1]);

norm[2]:=0;

for i:=1 to n do norm[2]:=norm[2]+sqr(v[i]);

norm[2]:=sqrt(norm[2]);

norm[3]:=0;

for i:=1 to n do norm[3]:=norm[3]+abs(v[i]);

END; {VectNorms}

procedure MatrNorms(n,m:integer;A:TMatr;var norm:TNorm);

var j,k:integer; sum:extended;

BEGIN {MatrNorms}

norm[1]:=0; for i:=1 to n do

begin sum:=0; for j:=1 to m do sum:=sum+abs(a[i,j]);

if norm[1]<sum then norm[1]:=sum;

end;

norm[2]:=0;

for i:=1 to n do for j:=1 to m do norm[2]:=norm[2]+sqr(a[i,j]);

norm[2]:=sqrt(norm[2]); norm[3]:=0;

for j:=1 to m do begin

sum:=0; for i:=1 to n do sum:=sum+abs(a[i,j]);

if norm[3]<sum then norm[3]:=sum;

end;

END; {MatrNorms}

function q(n,m:integer;A:TMatr):extended;

var j,k:integer; sum:extended; norm:TNorm;

BEGIN MatrNorms(n,m,A,norm); Q:=norm[1];END;

procedure PrintIter(Niter:integer; n:integer;

X:TVect; All,Dec:integer; var f:text);

var j,k:integer;

BEGIN writeln(f); write(f,’x]’,Niter:2,’ ] = {‘);

for k:=1 to n-1 do write(f,x[k]:All:Dec,’,’);

write(f,x[k]:All:Dec,’}’);

END;

procedure NextZeidelIter(n:integer;A:TMatr;

b:TVect;var X:TVect);

var j , k: integer

BEGIN {NextZeideliter}

for j:=1 to n do begin x[j] :=b[j];

for k:=1 to n do x[j]:=x[j]+a{j,k]*x[k];

end;

END; {NextZeideliter}

BEGIN {Zeidel}

ALL_Iter:=0; writeln (‘Start’ + NamePrg);

repeat write (‘зупинка за кроком (y/n)? =’);

readln (answer); if answer=’’ then answer:=’y’;

if answer=’y’ then Step:=true else Step:=false’

until (answer=’y’) or (answer=’n’);

write ‘ім’я вхідного файла =’); readln (answer);

if Length (answer) >0

then NameInp:=answer else NameInp:=NamePrg+’.inp’;

write (‘ім’я вихідного файла =’); readln (answer);

if Length (answer) >0

then NameOut :=answer else NameOut:=NamePrg+’.out’;

assign (fout, NameOut); rewrite (fout);

assign (finp, NameInp); reset (finp);

readln (finp, n, eps, ALL, Dec);

writeln; write (n,’ ‘,eps,’ ‘,ALL:1,’ ‘,Dec:1);

writeln (fout);

write (fout, n’ ‘,eps,’ ‘,ALL:1.’ ‘,Dec:1);

if ((n<1) or (n>_N) or (eps<=0))

then begin {(n<_N) or (n>_N) or (eps<=0)}

writeln (fout,’Error: n=’,n:1);

end {(n<_N) or (n>_N) or (eps<=0)}

else begin {(1<=n<=_N) and (eps>0)}

for i:=1 to n do begin

for j:=1 to n do begin read (finp, a[i,j]);

write (fout,’ ‘,a[i,j]:ALL: Dec); end;

readln (finp, b[i], XTemp[i]);

writeln(fout,’ ‘,b[i]:ALL:Dec,

’ ‘,

XTemp[i];ALL:Dec);

end;

close (finp); writeln; writeln(‘Матриця В:’);

for i:=1 to n do begin

for i:=1 to n do write (‘ ‘,a[i,j]:ALL: Dec);

writeln;

end;

writeln; write (‘Вектор d:’);

for i:=1 to n do write (‘ ‘,b[i]:ALL: Dec);

writeln; write (‘Старт x[0]:’);

for i:=1 to n do write (‘ ‘,XTerm[i]:ALL: Dec);

writeln (fout); writeln (fout,‘Матриця В:’);

for i:=1 to n do begin

for i:=1 to n do

write (fout,’ ‘,a[i,j]:ALL: Dec);

writeln (fout);

end;

writeln (fout); write (fout,‘Вектор d:’);

for i:=1 to n do write (fout,‘ ‘,b[i]:ALL: Dec);

writeln (fout); write (fout,‘Старт x[0]:’);

for i:=1 to n do write (fout,‘ ‘,XTerm[i]:ALL: Dec);

qq:=Q(n,n,A);

if qq>=1 then begin

writeln (fout); write (fout,‘ ,qq:ALL:Dec,’>=1’);

writeln; write (‘ ,qq:ALL:Dec,’>=1’);

repeat writeln; write (‘ Число ітерацій =’);

readln (ALL_Iter);

until (ALL_Iter>0);

writeln (fout);

write (fout,’ Число ітерацій =’, ALL_Iter:1);

if ALL_Iter<=0 then ALL_Iter:=0;

end;

if Step then begin {Step}

delta:=eps*(1/qq-1);

writeln; write (

‘Зупинка обчислень за кроком=’,delta:ALL:Dec);

writeln (fout); write (fout,

‘ Зупинка обчислень за кроком=’,delta:ALL:Dec);

end {Step}

else begin {not Step}

if ALL_Iter<=0 then begin

{‘Знаходження m–норми вектора b’}

VectNorms (n,b,norm);

ALL_Iter:=

Round (ln((eps*(1-qq))/(norm[1]))/ln(qq))+1;

end;

writeln;write (

‘Зупинка обчислень за числом ітерацій =‘,ALL_Iter:1);

writeln (fout);write (fout,

‘Зупинка обчислень за числом ітерацій =‘,ALL_Iter:1);

end; {not Step}

if Step

then begin {YesStep} Niter:=0; Stop:=false;

while not Stop do

begin {while not Stop}

Niter:= Niter+1; XTempOld:=XTemp;

NextZeidelIter (n,A,b,XTemp);

PrintIter (Niter, n, XTemp, ALL, Dec fout);

for i:=1 to n do XTempOld[i]:=XTemp[i] - XTempOld[i];

VectNorms (n, XTempOld, norm);

if norm [i]<Delta then Stop:=true

end; {while not Stop}

end {Step}

else begin {not Step}

for Niter:=l to All_Iter do

begin NextZeidelIter(n,A,b,Xtemp) ;

PrintIter(Niter,n,Xtemp,All,Dec,fout);

end;

end; {not Step}

end; {(1<=n<=_N)and(eps>0)}

writeln;

if Step then write('x[' ,(NIter+1) :!,']={') else write('x[',All_Iter:l, ']={');

for i:=l to n do

write( ',Xtemp[i] :All:Dec) ;write('}') ;

close (fout);

writeln; write ('Finish '+NamePrg) ; readln;

END. {Zeidel}