Добавил:

Mendeleev Опубликованный материал нарушает ваши авторские права? Сообщите нам.

Вуз:

Российский химико-технологический университет им. Д.И. Менделеева

Предмет:

Вычислительная математика

Файл:

PDF / all

.pdf

Скачиваний:

Добавлен:

07.01.2014

Размер:

308.62 Кб

Скачать

☆

1: program TABULATION;

3: const a=-5; {левая граница}

4:b=5; {правая граница}

5:n=10; {количество разбиений}

7:var h,xc,fc: real;

8:i:byte;

10:function MyFunction(x:real):real;

11:begin

12:MyFunction:=-13.392-11.358*x+1.176*sqr(x)+x*sqr(x);

13:end;

14:

15:begin

16:WriteLn('-- Табулирование значений функции --');

17:h:=(b-a)/10;

18: WriteLn('

f(x)');

19:for i:=1 to (n+1) do

20:begin

21:xc:=a+(i-1)*h;

22:fc:=MyFunction(xc);

23:WriteLn(xc:5:2, ' ', fc:7:2);

24:end;

25:ReadLn;

26:end.

27:

28:

1: program TANGENT; 2:

3:const

4:a: real = -1.473;

5:b: real = -5.738;

6:c: real = 6.763;

8:function f(x: real): real;

9:begin

10:f := x*x*x + a*x*x + b*x + c;

11:end;

12:

13:function f_(x: real): real;

14:begin

15:f_ := 3*x*x + a*2*x + b;

16:end;

17:

18:var

19:x,e:real;

20:

21:begin

22:WriteLn('-- Решение нелинейных уравнений методом касательных --');

23:Write(' Введите X : '); ReadLn(x);

24:Write(' Введите E : '); ReadLn(e);

25:repeat

26:x := x - f(x)/f_(x);

27:until abs(-f(x)/f_(x))<=e;

28:WriteLn(' X = ',x:7:3);

29:ReadLn;

30:end.

1: program CHORD; 2:

3:const

4:m: real = -0.39;

5:n: real = -10.5;

6:k: real = 11;

8:a_s: real = 2;

9:b_s: real = 3;

11:var

12: a,b,e,x:real; 13:

14:begin

15:WriteLn('-- Решение нелинейных уравнений методом хорд --');

16:a:=a_s; b:=b_s;

17:Write(' Введите E : '); ReadLn(e);

18:repeat

19:x:=a-(a*a*a+m*a*a+n*a+k)*(b-a)/((b*b*b+m*b*b+n*b+k)-(a*a*a+m*a*a+n*a+k));

20:if (a*a*a+m*a*a+n*a+k)*(x*x*x+m*x*x+n*x+k)<0 then

21:b:=x

22:else

23:a:=x;

24:until abs(a-b)<=e;

25:WriteLn(' X = ',(a+b)/2:7:3);

26:ReadLn;

27:end.

1: program MMS; 2:

3:const

4:maxn=10;

6:type

7:matrix = array [1..maxn,1..maxn] of real;

8:vector = array[1..maxn] of real;

10:var

11:ns,i,j:integer;

12:x:real;

13:ss:matrix;

14:as,bs,xs,ys:vector;

16:procedure gauss_method( N : integer; var A : matrix; var B,X : vector );

17:var

18:m:real;

19:i,j,k,l:integer;

20:begin

21:for k:=1 to n-1 do

22:for i:=k+1 to n do begin

23:m:=a[i,k]/a[k,k];

24:b[i]:=b[i]-m*b[k];

25:for j:=k to n do a[i,j]:=a[i,j]-m*a[k,j];

26:end;

27:for j:=n downto 1 do begin

28:m:=b[j];

29:for l:=n downto j+1 do m:=m-a[j,l]*x[l];

30:x[j]:=m/a[j,j];

31:end;

32:end;

33:

34:procedure mnk2_method(N: integer; var X,Y,A: vector);

35:var

36:i,j,k:integer;

37:s1,s2,s3,s4,s5,s6,s7:real;

38:begin s1:=0; s2:=0; s3:=0; s4:=0; s5:=0; s6:=0; s7:=0;

39:for i:=1 to n do

40:begin

41:s1:=s1+x[i]; s2:=s2+x[i]*x[i]; s3:=s3+x[i]*x[i]*x[i];

42:s4:=s4+x[i]*x[i]*x[i]*x[i]; s5:=s5+y[i]; s6:=s6+x[i]*y[i];

43:s7:=s7+x[i]*x[i]*y[i];

44:end;

45: ss[1,1]:=n;		ss[1,2]:=s1;	ss[1,3]:=s2;	bs[1]:=s5;
46:	ss[2,1]:=s1; ss[2,2]:=s2;		ss[2,3]:=s3;	bs[2]:=s6;
47:	ss[3,1]:=s2;	ss[3,2]:=s3;	ss[3,3]:=s4;	bs[3]:=s7;

48:gauss_method(3,ss,bs,as);

49:end;

50:

51:begin

52:WriteLn('-- Интерполяция по методу МНК --');

53:Write(' Введите количество экспериментально полученных точек : ');

54:ReadLn(ns);

55:for j:=1 to ns do

56:begin

57:Write(' Введите : X(',j,') = '); readln(xs[j]);

58:Write(' Введите : Y(',j,') = '); readln(ys[j]);

59:end;

60:mnk2_method(ns,xs,ys,as);

61:WriteLn(' Решение : A(0) = ',as[1]:7:3);

62:WriteLn(' Решение : A(1) = ',as[2]:7:3);

63:WriteLn(' Решение : A(2) = ',as[3]:7:3);

64:WriteLn(' Проверка :');

65:Write(' Введите X = '); ReadLn(x);

66:WriteLn(' Y (',x:7:3,') = ',(as[1]+as[2]*x+as[3]*x*x):7:3);

67:ReadLn;

68:end.

69:

1: program SLHE;

3: {AS: если найдете нижеуказанные модули, то можете 4: спокойно использовать эту программу }

6: uses crt, matrix, matrixex, inout; 7:

8:var a:TNmatrix;

9:b,x,ax: TNvector;

10:n,ni,mi:integer;

11:er:byte;

12:eps:real;

13:

14:begin

15:WriteLn('-- Решение СЛАУ методом Гаусса --');

16:ReadIntXY(1,2,'Введите размерность системы: ',n);

17:PutString(1,3,'Ввод матрицы коэффициентов');

18:ReadMatr(1,4,'A',n,n,a);

19:PutString(50,3,'Ввод вектора свободных членов');

20:ReadArr(60,5,'b',n,b);

21:Gaussian_Elimination(n,a,b,x,er);

22:case er of

23:0: begin

24:	PutString(1,13,'Решение СЛАУ:');
25:	WriteArr(1,14,'x',n,x);
26:	PutString(35,13,'Проверка (вектор свободных членов):');
27:	MultiplicMatVec(n,n,a,x,ax);
28:	WriteArr(35,14,'b',n,ax);

29:end;

30:	1: PutString(1,13,'Размерность меньше 1.'); {такой ошибки добиться невозможно!}

31:2: PutString(1,13,'Решения нет (система несовместна).');

32:end;

33:ReadLn;

34:

35:WriteLn('-- Решение СЛАУ методом Гаусса-Зейделя --');

36:WriteLn('Чтобы метод сходился, переставьте уравнения так, чтобы в i-ой строке');

37:WriteLn('i-ый элемент был наибольшим по модулю из всех элементов этой строки!');

38:ReadIntXY(1,4,'Введите размерность системы: ',n);

39:PutString(1,5,'Ввод матрицы коэффициентов');

40:ReadMatr(1,6,'A',n,n,a);

41:PutString(50,5,'Ввод вектора свободных членов');

42:ReadArr(60,7,'b',n,b);

43:ReadRealXY(1,15,'Введите точность решения: ',eps);

44:ReadIntXY(1,16,'Введите максимальное число итераций: ',mi);

45:Gauss_Seidel(n,a,b,eps,mi,x,ni,er);

46:case er of

47:0: begin

48:	PutString(1,18,'Решение СЛАУ:');
49:	WriteArr(1,19,'x',n,x);
50:	PutString(35,18,'Проверка (вектор свободных членов):');
51:	MultiplicMatVec(n,n,a,x,ax);
52:	WriteArr(35,19,'b',n,ax);
53:	WriteIntXY(1,24,'Число итераций: ',ni,2);

54:end;

55:1: PutString(1,18,'Число итераций превышено и матрица не диагонально-доминантная.');

56:2: PutString(1,18,'Число итераций превышено.');

57:	3: PutString(1,18,'Размерность меньше 1.'); {такой ошибки добиться невозможно!}

58:4: PutString(1,18,'Точность <= 0.');

59:5: PutString(1,18,'Максимальное число итераций меньше 0.');

60:6: PutString(1,18,'0 на диагонали матрицы коэффициентов.');

61:7: PutString(1,18,'Метод расходится.');

62:end;

63:ReadLn;

64:end.

65:

1: program GAUSS; 2:

3:const

4:maxn = 10;

6:type

7:matrix = array [1..maxn,1..maxn] of real;

8:vector = array [1..maxn] of real;

10:var

11:ns,i,j: integer;

12:as: matrix;

13:xs,bs: vector;

15:procedure gauss_method(N: integer; var A: matrix; var B,X: vector );

16:var

17:m:real;

18:i,j,k,l:integer;

19:begin

20:for k:=1 to n-1 do

21:for i:=k+1 to n do begin

22:m:=a[i,k]/a[k,k];

23:b[i]:=b[i]-m*b[k];

24:for j:=k to n do a[i,j]:=a[i,j]-m*a[k,j];

25:end;

26:for j:=n downto 1 do begin

27:m:=b[j];

28:for l:=n downto j+1 do m:=m-a[j,l]*x[l];

29:x[j]:=m/a[j,j];

30:end;

31:end;

32:

33:begin

34:WriteLn('-- Решение СЛАУ методом Гаусса --');

35:Write(' Порядок СЛАУ : ');

36:ReadLn(ns);

37:for i:=1 to ns do

38:for j:=1 to ns do

39:begin

40:Write(' Введите : A(',i,',',j,') = ');

41:ReadLn(as[i,j]);

42:end;

43:for j:=1 to ns do

44:begin

45:Write(' Введите : B(',j,') = ');

46:ReadLn(bs[j]);

47:end;

48:gauss_method(ns,as,bs,xs);

49:for j:=1 to ns do

50:WriteLn(' Решение : X(',j,') = ',xs[j]:3:0);

51:ReadLn;

52:end.

53:

54:

55:

56:

1: program ZEIDEL; 2:

3:const

4:maxn=10;

6:type

7:matrix = array [1..maxn,1..maxn] of real;

8:vector = array [1..maxn] of real;

10:procedure gauss_zeidel (N: integer; var A: matrix; var B,X: vector; E: real);

11:var

12:m,em:real;

13:i,j:integer;

14:x0:vector;

15:begin

16:repeat

17:x0:=x;

18:for i:=1 to n do

19:begin

20:m:=b[i];

21:for j:=1 to n do

22:if j<>i then m:=m-a[i,j]*x[j];

23:x[i]:=m/a[i,i]

24:end;

25:em:=abs(x[1]-x0[1]);

26:for j:=2 to n do

27:if abs(x[i]-x0[i])>em then em:=abs(x[i]-x0[i]);

28:until em<=e;

29:end;

30:

31:var

32:ns,i,j:integer;

33:err:real;

34:as:matrix;

35:xs,bs:vector;

37:begin

38:WriteLn('-- Решение СЛАУ методом Гаусса-Зейделя --');

39:Write(' Порядок СЛАУ : ');

40:ReadLn(ns);

41:for i:=1 to ns do

42:for j:=1 to ns do

43:begin

44:Write(' Введите : A(',i,',',j,') = ');

45:ReadLn(as[i,j]);

46:end;

47:for j:=1 to ns do

48:begin

49:Write(' Введите : B(',j,') = ');

50:ReadLn(bs[j]);

51:end;

52:Write(' Введите абсолютную погрешность вычисления корней : ');

53:ReadLn(err);

54:gauss_zeidel(ns,as,bs,xs,err);

55:for j:=1 to ns do

56:WriteLn(' Решение : X(',j,') = ',xs[j]:3:0);

57:ReadLn;

58:END.

59:

60:

61:

62:

63:

64:

1: program INTEGRATION; 2:

3:	const
4:	a =	3;

5:b = -63;

6:c = 416;

7:d = -837;

9:range_start = 4;

10:range_end = 7;

11:step_count = 10;

12: step = (range_end - range_start)/step_count; 13:

14:

15:function f(x: real): real; // вычисление значений функции

16:begin

17:f:=x*x*x*a + x*x*b + x*c + d;

18:end;

19:

20:procedure rectangles_forward; // метод прямоугольников "вперед"

21:var

22:i: integer;

23:S: real;

24:begin

25:S:=0;

26:for i:=0 to step_count-1 do

27:S:=S + f(range_start + step*i);

28:S:=S*step;

29: WriteLn(' метод прямоугольников вперед : ', S:12:6); 30: end;

31:

32:procedure rectangles_rearward; // метод прямоугольников "назад"

33:var

34:i: integer;

35:S: real;

36:begin

37:S:=0;

38:for I:=1 to step_count do

39:S:=S + f(range_start + step*i);

40:S:=S*step;

41: WriteLn(' метод прямоугольников назад : ', S:12:6); 42: end;

43:

44:procedure rectangles_average; // метод прямоугольников "в середине"

45:var

46:i: integer;

47:S: real;

48:begin

49:S:=0;

50:for i:=0 to step_count-1 do

51:S:=S + f(range_start + step*i + step/2);

52:S:=S*step;

53:WriteLn(' метод прямоугольников "посередине" : ', S:12:6);

54:end;

55:

56:procedure trapezium; // метод трапеций

57:var

58:i: integer;

59:S: real;

60:begin

61:S:=0;

62:for i:=0 to step_count-1 do

63:S:=S + (f(range_start + step*i) + f(range_start + step*(i+1)));

64:S:=S*(step/2);

65: WriteLn(' метод трапеций : ', S:12:6); 66: end;

67:

68:procedure simpson; // метод Сипмсона

69:var

70:i: integer;

71:S: real;

72:mult: byte;

73:begin

74:S:=0;

75:mult:=1;

76:for i:=0 to step_count do

77:begin

78:if i mod 2 = 0 then mult:=4 else mult:=2;

79:if (i = step_count) or (i=0) then mult:=1;

80:S:=S + mult*f(range_start + step*i);

81:end;

82:S:=S*(step/3);

83: WriteLn(' метод Симпсона : ', S:12:6); 84: end;

85:

86:begin

87:WriteLn('-- Вычисление определенного интеграла --');

88:rectangles_forward;

89:rectangles_rearward;

90:rectangles_average;

91:trapezium;

92:simpson;

93:ReadLn;

94:end.

1: program EILER; 2:

3:var

4:a,b,x0,y0:real;

5:n1,n2:integer;

7:function F(x,y:real):real;

8:begin

9:F:= -1.180 * y -3.367 * x / y +3.371 * x +2.004;

10:end;

11:

12:procedure Eiler(n:byte);

13:var i:byte;

14:h,x,y,fxy,hfxy:real; {h,x,y,f(x,y),h*f(x,y)}

15:begin

16:h:=(b-a)/n;

17:WriteLn('Число разбиений n=',n,'. Шаг h=',h:5:3);

18:

WriteLn(' N x

f(x,y) h*f(x,y) ');

19:WriteLn('------------------------------------');

20:x:=x0;

21:y:=y0;

22:for i:=0 to n do

23:begin

24:fxy:=f(x,y);

25:hfxy:=h*fxy;

26:WriteLn(' ',i:2,' ',x:5:2,' ',y:7:3,' ',fxy:8:3,' ',hfxy:8:3,' ');

27:y:=y+hfxy;

28:x:=x+h;

29:end;

30:WriteLn('------------------------------------');

31:ReadLn;

32:end;

33:

34:begin

35:WriteLn('-- Решение ДУ методом Эйлера --');

36:WriteLn(' интервал [a;b]');

37:Write(' a = '); ReadLn(a);

38:Write(' b = '); ReadLn(b);

39:WriteLn(' начальные условия');

40:Write(' x0 = '); ReadLn(x0);

41:Write(' y0 = '); ReadLn(y0);

42:WriteLn(' число разбиений');

43:Write(' n1 ='); ReadLn(n1);

44:Write(' n2 ='); ReadLn(n2);

45:Eiler(n1);

46:Eiler(n2);

47:end.

48:

49:

Соседние файлы в папке PDF

#
07.01.2014108.21 Кб4309-Нелинейные уравнения.pdf
#
07.01.2014120.03 Кб5310-Системы нелинейных уравнений.pdf
#
07.01.2014121.63 Кб5811-Одномерная оптимизация.pdf
#
07.01.2014132.13 Кб4712-Многомерная оптимизация.pdf
#
07.01.2014177.32 Кб4313-Дифференцальные ур-ия.pdf
#
07.01.2014308.62 Кб40all.pdf
#
07.01.201428.76 Кб41EILER.pdf
#
07.01.201429.04 Кб42GAUSS.pdf
#
07.01.201449.68 Кб40INTEGRATION.pdf
#
07.01.2014231.75 Кб42Job-1.pdf
#
07.01.2014120.03 Кб39Job-10.pdf