Дифференцирование полинома / EX_ARR93

{=========  ЇаЁ¬Ґа : Їа®жҐ¤гал  ®Ўа Ў®вЄЁ  ¬ ббЁў®ў ==========}
{ „ ­®: Ї®«Ё­®¬  Ї®ап¤Є   n   б Є®нддЁжЁҐ­в ¬Ё a [1..n]:      }
{ p(n,a[1..n];x) = a[1] + a[2]*x + a[3]*x^2 +...+ a[n]*x^(n-1)}
{ ’ॡгҐвбп: Ї®«гзЁвм ўбҐ Їа®Ё§ў®¤­лҐ (®в 1-© ¤® (n-1)-©)     }
{            Ёб室­®Ј® Ї®«Ё­®¬ .                              }
{ Ћб­®ў­®Ґ ᮮ⭮襭ЁҐ ¤«п Є®нддЁжЁҐ­в®ў Ї®«Ё­®¬ -Їа®Ё§ў®¤­®©:}
{           (ALL i: 1<=i<=(n-1) : b[i] = i*a[i+1] ),          }
{ Ј¤Ґ b[*] - Є®нддЁжЁҐ­вл Ї®«Ё­®¬ -Їа®Ё§ў®¤­®© Ёб室­®Ј® я    }
{            Ї®«Ё­®¬  c  Є®нддЁжЁҐ­в ¬Ё a[*]                  }
{ ============================================================}

const MaxOrder  = 10 ;
 type OrderPoly = 1..MaxOrder;
          index = OrderPoly;
       CoefPoly = array [index] of Real;

 var  n : OrderPoly;     { Ї®а冷Є Ёб室­®Ј® Ї®«Ё­®¬  }
      j : index;         { ­®¬Ґа Їа®Ё§ў®¤­®©          }
      a : CoefPoly;      { ¬ ббЁў Є®нддЁжЁҐ­в®ў       }
    fout: Text;          { ўл室­®© д ©« Ё«Ё нЄа ­    }
     ch : Char;
 {------------------------------------------------------------}
 procedure DiffPoly ( n : OrderPoly; var a : CoefPoly );
 {   ўлзЁб«Ґ­ЁҐ Їа®Ё§ў®¤­®© Ї®«Ё­®¬                           }
 {        аЈ : n - Ї®а冷Є Ёб室­®Ј® Ї®«Ё­®¬ ;                }
 {    аЈ-१ :                                                }
 {     -  ЇаЁ ўе®¤Ґ  a[1..n] - Є®нддЁжЁҐ­вл Ёб室­®Ј® Ї®«Ё­®¬ }
 {     -  ЇаЁ ўл室Ґ a[1..n-1] - Є®нд-вл Ї®«Ё­®¬ -Їа®Ё§ў®¤­®© }
   var
      i : index;
   begin
      {  a[1..n]=A[1..n] & n>1 }

     for i:=1 to n-1 do
       a[i] := i*a[i+1];

      {  (ALL i: 1<=i<=(n-1) : a[i]=i*A[i+1] ) & (a[n]=A[n]) }
   end { DiffPoly };
 {------------------------------------------------------------}
 procedure OutPoly ( n: OrderPoly; var a: CoefPoly;
                                    var fout: Text);
 {   аЈ : n, a ;  १ : fout                          }
 {  ў­Ґи­Ё© нд䥪в:  ўлў®¤ ў д ©« fout                }
   var
      i : index;
   begin
     for i:=1 to n do
       WriteLn( fout, '(', a[i] :13,') * x^', (i-1) :1 )

   end { OutPoly };
 {------------------------------------------------------------}
 procedure InCorrPoly ( var n : OrderPoly; var a: CoefPoly;
                                           var fout : Text);
  { ўў®¤, Їа®ўҐаЄ  Є®а४⭮бвЁ Ё ўлў®¤ Ї а ¬Ґва®ў Ї®«Ё­®¬  }
  {                аЈ : ­Ґв ;      १ : n, a, fout         }
  {  ў­Ґи­Ё© нд䥪в:  ўлў®¤ ў д ©« fout                     }
   var i  : index;
       Cor: Boolean;
   begin
     {======  ўў®¤ n ======}
     repeat
       WriteLn('ўўҐ¤ЁвҐ Ї®а冷Є Ї®«Ё­®¬  [2..',MaxOrder,'] :');
       {$R-} {Ї®Їа®Ўг©вҐ Ё б $R+}
       ReadLn( n );
       {нв®в да Ј¬Ґ­в - ЇаЁ ®вЄ«о祭­®© ®ЇжЁЁ
             Options/Compiler/Runtime errors/Range checking -
             б¬. 3 бва®Є ¬Ё ўлиҐ}
       if ( 2<=n ) and ( n<=MaxOrder )
         then Cor:= true
         else
           begin
             Cor:= false;
             WriteLn( '‚л ®иЁЎ«Ёбм Ё ўўҐ«Ё n =',n);
             Write('‚­®ўм ')
           end { if }
     until Cor;
     {====== ўў®¤ Є®нддЁжЁҐ­в®ў ======}
     WriteLn( 'ўўҐ¤ЁвҐ Є®нддЁжЁҐ­вл');
     for i:=1 to n do
       begin
         Write('ЇаЁ б⥯Ґ­Ё x^', (i-1) :1, ':');
         ReadLn( a[i] )
       end { for };
     {====== ўлў®¤ Ї®«Ё­®¬  ======}
     WriteLn( fout, 'ўўҐ¤Ґ­ Ї®«Ё­®¬ Ї®ап¤Є  ', n, ' :');
     OutPoly( n, a, fout );
     WriteLn('ў ў ® ¤   ¤   ­ ­ л е   §   ў Ґ а и Ґ ­ ! [‚Љ]');
     ReadLn             { ­ ¦ вм ‚Љ }
   end { InCorrPoly };
 {------------------------------------------------------------}
 begin { main }
   Write('ўлў®¤ ў д ©« ["¤ " - Y Ё«Ё y / "­Ґв" - «оЎ®© ¤агЈ®© бЁ¬ў®«] ?');
   ReadLn( ch );
   if UpCase(ch)='Y'
    then Assign( fout, 'OUTPOLY.DAT')
    else Assign( fout, 'CON'    );
   Rewrite( fout );

   InCorrPoly( n, a, fout );

   WriteLn(fout,'**** ¤ЁддҐаҐ­жЁа㥬 Ёб室­л© Ї®«Ё­®¬ ****');
   for j:=1 to n-1 do
     begin
        {¤Ёдд-Ґ¬ Ї®«Ё­®¬ Ї®ап¤Є  n-j+1 б Є®нд-¬Ё a[1..(n-j+1)]}
       DiffPoly( n-j+1, a );
        { १:   Ї®«Ё­®¬ Ї®ап¤Є   n-j  б Є®нд-¬Ё a[1.. (n-j) ]}
       WriteLn( fout, j, '-п Їа®Ё§ў®¤­ п :');
       OutPoly( n-j, a, fout );
       WriteLn( fout,'~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
     end { for };
   Close( fout )
 end { main }.