Полином Гира (экстраполяция методом Гира)


	Загрузить архив:
	Файл: ref-13172.zip (4kb [zip], Скачиваний: 83) скачать

{****************************************************************************}

{ }

{ Вариант №1.23 Экстраполяция методом Гира гр. ##-### Ф.И.О. }

{ }

{ P^2 P = 50-200 [Ом], }

{ f(w) = ----- * ( 1 + Q^2 * (2*dw/wp))^(-1/2), Rn= 0.1-5[Ом], }

{ Rn Q = 50-1000, }

{ wp- частота резонанса, }

{ dw- шаг, }

{ }

{****************************************************************************}

{ Аппроксимация

Аппроксимацией называетсязамена однихматематическихобъектов

(чисел, функций)другими,более простымив томили иномсмыслеи

близкими к исходным.

Прирешении задачи аппроксимациипредполагается, что известны

значненияаппроксимируемойфункции f(x)(снятые эксперементально или

расчитанные по формуле)вузловых точках(обычно их называютузлами

интерполяции) X1, X2, ..., Xn.Необходимо найти функцию P(x), с помощью

которой можнобыло бы определитьзначения исходной функциидля других

(отличных от узлов)значений аргументаxс некоторой достаточно малой

погрешностью.

Различают две задачи аппроксимации: интерполяцию и экстраполяцию.

Интерполяция-это отыскание промежуточныхзначений функции внутри

заданного интервала [X1, Xк]для значенийxне совпадающих с узловыми

точками.

Экстраполяция - это распространение выводов, полученных из наблюдения

над однойчастью явленияна другую ее часть,то есть это определение

значений функции вне заданного интервала [Xн, Xк]. }

PROGRAM GIR;

{$N-}

USES Crt;

CONST

Max_kol = 25; {Максимальное количество узлов}

Tochka= 10; {Количество знаков после запятой}

TYPE

_Real = Real;

_INTEGER = Byte;

_Mas = array [1..Max_kol] of _Real;

VAR

H, F_up, F_down, eps_pol, eps_tek : _Real;

Xpol, Ypol, V : _Mas;

n, m : _INTEGER; {n-количествоузлов}

Pr : Char; {переключатель}

{----------------------------------------------------------------------------}

{Расчет табличных данных для заданной функции}

PROCEDURE TABL_FUNC(Var Xpol, Ypol: _Mas; Var n: _INTEGER; Var dw, eps_pol: _Real);

VAR

P, Rn, Q, wp, wn : _Real;

I : _INTEGER; {счетчик}

BEGIN

Write('Сопротивление P ............. = '); ReadLn(P);

Write('Сопротивление нагрузки Rn ... = '); ReadLn(Rn);

Write('Параметр Q .................. = '); ReadLn(Q);

Write('Начальна частота wp ......... = '); ReadLn(wn);

Write('Шаг изменения частота dw .... = '); ReadLn(dw);

Write('Количество узлов (< ', Max_kol:2, ') ..... = '); ReadLn(n);

Write('Точность eps_pol ............ = '); ReadLn(eps_pol);

WriteLn;

{расчет функции в узлах}

wp:= wn;

FOR I:= 1 TO (n+1) DO

begin

Xpol[I]:= wp;

Ypol[I]:= Sqr(P) / (Rn * Sqrt(1 + Sqr(Q) * Sqr(2*dw/wp)));

wp:= wp + dw;

end;

END;

{--------------------------< Конец ПП TABL_FUNC >----------------------------}

{Ввод значений аппроксимируемой функции}

PROCEDURE VVOD_TABL(Var Xpol, Ypol: _Mas; Var n: _INTEGER; Var dw, eps_pol: _Real);

VAR

wp, wn : _Real;

I : _INTEGER; {счетчик}

BEGIN

Write('Начальныйузел ............ = '); ReadLn(wn);

Write('Шаг изменения узла ........ = '); ReadLn(dw);

Write('Количество узлов (< ', Max_kol:2, ') ... = '); ReadLn(n);

Write('Погрешность eps .............. = '); ReadLn(eps_pol);

WriteLn;

{ввод значений функции в узлах}

WriteLn('Введите значение функции в узлах:');

wp:= wn;

FOR I:= 1 TO n DO

begin

Xpol[I]:= wp;

Write('Y(', wp:Tochka, ')= '); ReadLn(Ypol[I]);

wp:= wp + dw;

end;

{задание (n+1)-узла}

Xpol[n+1]:= wp;

END;

{---------------------------< КонецПП VVOD_TABL >---------------------------}

{Расчеткоэффициентовполинома}

PROCEDURE Kff_pol(X: _Mas; H: _Real; n, m: _INTEGER; Var V: _Mas);

TYPE

_Matric = array [1..Max_kol] of _Mas;

_Vector = array [1..Max_kol] of Byte;

VAR

G : _Matric;

P : _Vector;

I, J : _INTEGER; {счетчики}

{----------------------------------------------------------------------------}

{рашение матричной системы уравнений, методом "LU-разложений"}

PROCEDURE GVP(G: _Matric; P: _Vector; m: _INTEGER; Var V: _Mas);

VAR

K, I, J : _INTEGER; {счетчики}

L, U : _Matric; {вспомогательные матрицы}

SOS : _Mas; {вспомогательный вектор}

alf, S : _Real; {вспомогательные переменные}

BEGIN

{обнуление элементов вспомогательных матриц L и U}

FOR I:= 1 TO m DO

For J:= 1 To m Do

begin

L[I, J]:= 0; { L[I, J] = 0, где I=1..m, J=1..m }

U[I, J]:= 0; { U[I, J] = 0, где I=1..m, J=1..m }

end;

{разложение матрицы G на матрицу L и U}

FOR K:= 1 TO m DO

begin

{формированиематрицы L}

For I:= K To m Do

begin

{накопление суммы элементов в S}

S:= 0;

for J:= 1 to (K - 1) do

begin { k-1 }

alf:= L[I, J] * U[J, K]; { S = E (L[I, J] * U[J, K]), }

S:= S + alf; { j=1 }

end;

L[I, K]:= G[I, K] - S; { L[I, K] = G[I, K] - S, где k=1..m, i=k..m }

end;

{формирование матрицы U}

U[K, K]:= 1;

For I:= (K + 1) To m Do

begin

{накопление суммы элементов в S}

S:= 0;

for J:= 1 to (K - 1) do

begin { k-1 }

alf:= L[K, J] * U[J, I]; { S = E (L[K, J] * U[J, I]), }

S:= S + alf; { j=1 }

end;

{G[I, K] - S }

alf:= G[I, K] - S; { U[K, I] = -------------,где k=1..m, i=(k+1)..m}

U[K, I]:= alf/L[K, K]; { L[K, K] }

end;

{вычисление вспомогательного вектора SOS}

FOR K:= 1 TO m DO

begin

{накопление суммы элементов в S}

S:= 0;

For I:= 1 To (K - 1) Do

begin { k-1 }

alf:= L[K, I] * SOS[I]; { S = E (L[K, I] * SOS[I]), }

S:= S + alf; { i=1 }

end;

{ P[K] - S }

alf:= P[K] - S; { SOS[K] = ----------, где k=1..m }

SOS[K]:= alf/L[K, K]; {L[K, K] }

end;

{вычислениевектора V}

FOR K:= m DOWNTO 1 DO

begin

{накопление суммы элементов в S}

S:= 0;

For I:= (K + 1) To m Do

begin { m }

alf:= U[K, I] * V[I]; { S = E (U[K, I] * V[I]), }

S:= S + alf; { i=k+1 }

end;

V[K]:= SOS[K] - S; { V[K] = SOS[K] - S, где k=1..m }

end;

END;

{------------------------------< конецПП GVP >------------------------------}

BEGIN

{формированиематрицы G}

FOR I:= 1 TO m DO { | X[n+1] - X[n - (m-1)] | (m-1) }

For J:= 1 To m Do { G[I, J] = |-----------------------| }

G[I, J]:= exp( (I-1)*Ln((X[n+1] - X[n-(J-1)]) / H) ); { |H | }

{формированиевектора P = [1, 0, 0, 0, ..., 0]}

P[1]:= 1;

FOR I:= 2 TO m DO P[I]:= 0;

{обращение к ПП GVP}

GVP(G, P, m, V);

END;

{---------------------------< КонецПП Kff_pol >-----------------------------}

{Расчетполинома}

FUNCTION F_pol(V, Y: _Mas; n, m: _INTEGER): _Real;

VAR

I: _INTEGER; {счетчик}

S: _Real;{сумматор}

BEGIN

S:= 0;

FOR I:= 1 TO m DO S:= S + V[I]*Y[n+1-I];

F_pol:= S;

END;

{-----------------------------< КонецПП F_pol >-----------------------------}

{Вывод значения функции в (n+1) узле}

PROCEDURE VIVOD1(Xpol, Ypol, eps_tek: _Real; n, m: _INTEGER);

BEGIN

WriteLn;

WriteLn('Значениефункциив (n+1) узле: Y(', Xpol:Tochka, ')=', Ypol:Tochka);

WriteLn('Количество используемых узлов', m:3, ' из', n:3);

WriteLn('Погрешность расчета =', eps_tek:Tochka);

END;

{-----------------------------< Конец ПП VIVOD1 >----------------------------}

{Вывод значения функции в (n+1) узле для тестовой функции}

PROCEDURE VIVOD2(Xpol, Ypol, eps_tek, Y: _Real; n, m: _INTEGER);

VAR

eps: _Real;

BEGIN { Y_полином - Y_точное}

eps:= Abs((Ypol - Y)/Y); { EPS_точное = ---------------------- }

{ Y_точное }

WriteLn;

WriteLn(' Значениефункциив узле X(n+1)=', Xpol:Tochka , ' :');

WriteLn('Y полинома ... =', Ypol:Tochka);

WriteLn('Y точное ..... =', Y:Tochka);

WriteLn('Погрешность расчета :');

WriteLn('текущая ...... =', eps_tek:Tochka);

WriteLn('точная ....... =', eps:Tochka);

WriteLn;

WriteLn('Количество используемых узлов', m:3, ' из', n:3);

END;

{-----------------------------< Конец ПП VIVOD2 >----------------------------}

{основной блок программы}

BEGIN

ClrScr;

WriteLn;

{Ввод исходных данных}

Write('Тестовый расчет? [Y/N]'); ReadLn(Pr);

WriteLn;

{Ввод значений функции в узлах}

IF (UpCase(Pr) = 'Y')

{обращениекПП TABL_FUNC}

THEN TABL_FUNC(Xpol, Ypol, n, H, eps_pol)

{обращение к ПП VVOD_TABL}

ELSE VVOD_TABL(Xpol, Ypol, n, H, eps_pol);

{итерационный процесс}

m:= 2;

F_down:= 0;

REPEAT

{обращение к ПП Kff_pol}

Kff_pol(Xpol, H, n, m, V);

{обращение к ПФ F_pol}

F_up:= F_pol(V, Ypol, n, m);

{точностьрасчета}

IF Not(F_up = 0) THEN eps_tek:= Abs((F_up - F_down)/F_up);

F_down:= F_up;

Inc(m);

UNTIL (eps_tek < eps_pol) or (m > n);

{вывод полученных результатов}

IF (UpCase(Pr) = 'Y')

{обращение к ПП VIVOD2}

THEN VIVOD2(Xpol[n+1], F_up, eps_tek, Ypol[n+1], n, (m-1))

{обращение к ПП VIVOD1}

ELSE VIVOD1(Xpol[n+1], F_up, eps_tek, n, (m-1));

ReadKey;

END. {Конец основного блока}