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

Загрузить архив:
Файл: 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;

      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;

   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('  ExtraPol_GIRA 1.00          Copyright (c) 1999-00                      DGur.');

   WriteLn;

   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.                                             {Конец основного блока}