program polynomes; {TP 922 01 - le squelette}

uses crt;

const long    = 250 ;
const deg_nul = -10;    {le degre du polynome nul, par convention}
type poly = array[-1..long] of integer ;
	  
function max(a,b:integer):integer; {comme son nom l'indique ...}
begin
   if a<b then max:=b
   else max:=a
end;

procedure poly_nul(var P:poly);
var i : integer;
begin 
   ...
end;


procedure saisie(var P:poly);  {saisie au clavier}
var deg,i,aux : integer;
begin	      
   ...
end;

procedure visu(P:poly);  {visualisation a l'ecran}
begin	      
   ...
end;

procedure addition(P:poly;Q:poly;var R:poly);
var int_fin : integer; {qd s'arrete-t-on?}
var i	: integer;
var deg	: integer; {nouveau degre}
begin	
   if (P[-1]=Q[-1]) AND (P[-1]=deg_nul) then
      poly_nul(R)
   else
   begin
      ...
   end
end;

procedure scal_mul(P:poly;c:integer;var R:poly);  {c*P avec c entier}
var i : integer ;
begin 
   poly_nul(R);
   if c<>0 then
   begin
      ...
   end
end;

procedure produit(P:poly;Q:poly;var R:poly);
var deg,i,j : integer;
begin	    
   poly_nul(R);
   if (P[-1]<>deg_nul) AND (Q[-1]<>deg_nul) {ni P ni Q ne sont nuls}
      then
   begin
      ...
   end
end;

procedure puis_n(P:poly;n:integer;var R:poly);   {P^n avec n entier}
var i : integer;
begin 
   if n=0 then
   begin
      ...
   end
   else
      ...
end;



procedure compose(P:poly;Q:poly;var R:poly);   {R=PoQ}
var q_i, aux : poly;
var i,deg : integer ;
begin	  
   poly_nul(R);
   
   if P[-1]<>deg_nul then
      if Q[-1]=deg_nul then     {cas non indispensable}
      begin
	 if P[0]<>0 then R[-1]:=0 else R[-1]:=deg_nul;
	 R[0]:=P[0]
      end
      else
      begin
	 ...
      end
end;


procedure division_exacte(A,B : poly; var res:poly); {avec recursion}
var
   a_soustraire,a_ajouter,reste,quot_reste : poly;					   
begin
   poly_nul(res);
   if A[-1]<>deg_nul then
   begin
      ...
   end
end;

procedure division_exacte2(A,B : poly; var res:poly); {sans recursion}
var
   a_soustraire,a_ajouter,monome : poly;
begin
   poly_nul(res);
   if A[-1]<>deg_nul then res[-1]:=A[-1]-B[-1];
   while A[-1]<>deg_nul do
   begin
      ...
   end;
end;


procedure cyclotomic(n : integer; var C:poly);
var
   cyc_aux : poly;
   i	   : integer;
begin
   ...
end;

var
   P,Q,R : poly;
   n	 : integer;
	 
begin
   clrscr;
   writeln('saisie du polynome P');
   saisie(P);
   writeln;
   write('polynome P : ') ; visu(P);
   readln;
   writeln('saisie du polynome Q');
   saisie(Q);
   writeln;
   write('polynome Q : ') ; visu(Q);
   readln;
   poly_nul(R);
   writeln('somme de P et Q:');
   addition(P,Q,R);
   write('polynome P : ') ; visu(P); 
   write('polynome Q : ') ; visu(Q);  
   write('polynome R=P+Q : ') ; visu(R);
   readln;
   writeln('3P : ');
   scal_mul(P,3,R);
   visu(R);
   readln;
   writeln('produit de P et Q:');
   produit(P,Q,R);
   write('polynome P : ') ; visu(P);
   write('polynome Q : ') ; visu(Q); 
   write('polynome R=PQ : ') ; visu(R);
   readln;
   writeln('P puissance 4');
   puis_n(P,4,R);
   write('polynome P : ') ; visu(P); 
   write('polynome R=P^4 : ') ; visu(R);
   readln;
   writeln('P puissance 0');
   puis_n(P,0,R);
   write ('P^0 : ') ; visu(R);
   readln;
   writeln('composee de P et Q : ');
   produit(P,Q,R);
   write('polynome P : ') ; visu(P); 
   write('polynome Q : ') ; visu(Q);  
   write('polynome R=PoQ : ') ; visu(R);
   readln;
   writeln('quotient exact de P par Q : ');
   division_exacte(P,Q,R);
   write('polynome P : ') ; visu(P);  
   write('polynome Q : ') ; visu(Q);  
   write('polynome R=P div Q : ') ; visu(R);
   readln;
   n:=10;
   writeln('cyclo(n) : entrez n :');
   readln(n);
   while n>=0 do
   begin
      cyclotomic(n,R);
      write('cyclotomic ',n,' : ');visu(R);
      writeln('cyclo(n) : entrez n :');
      readln(n)
   end;
end.