{Aluno: Gustavo Sverzut Barbieri      RA: 008849}
{Prof.: Arnaldo   - MC102                       }

program pol;

type 
   polinomio = ^parcela; 
   parcela   = record 
		  coeficiente : real; 
		  expoente    : integer; 
		  prox	      : polinomio 
	       end;	      

var 
   opcao : char; { pega a opcao }
   p	 : array[1..10] of polinomio; { guarda os 10 polinomios }
   pos	 : array[1..3] of integer; { pega posicoes, no. inteiros, quando precisar }
   num	 : real; { para guardar numero real }
   c	 : integer; {contador}
   
{%%%%% Funcoes e Procedimentos %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%}
procedure apaga_polinomio(var node : polinomio);
begin
   if (node <> nil) then begin
      apaga_polinomio(node^.prox); {muda o valor do node^.prox e nao do node}
      dispose(node);
      node:=nil;
   end;
end; { apaga_polinomio }




procedure imprime_polinomio(var node : polinomio);
begin
   if (node <> nil) then begin
      writeln(node^.coeficiente:0:3,' ',
	      node^.expoente);
      imprime_polinomio(node^.prox);
   end;
end; { imprime_polinomio }





procedure le_polinomio(n_parcelas : integer; var node : polinomio; inicio:boolean);
begin

   if inicio then apaga_polinomio(node);

   if n_parcelas = 0 then
      node:=nil
   else begin
      new(node);
      read(node^.coeficiente,
	   node^.expoente);
      le_polinomio(n_parcelas-1,node^.prox, false); {muda o valor do node^.prox e nao do nod}
   end;
     
end; { le_polinomio }





procedure deriva(src : polinomio; var dst : polinomio; inicio : boolean);
begin
   if inicio then apaga_polinomio(dst);
   
   if (src <> nil) and (src^.expoente > 0) then begin
	 new(dst);
	 dst^.expoente := src^.expoente - 1;
	 dst^.coeficiente := src^.coeficiente * src^.expoente;
	 deriva(src^.prox, dst^.prox, false);
   end else
      dst:=nil;
end; { deriva }






function pwr(base : real; expoente : integer):real;
var
   i	   : integer;
   produto : real;
begin
   produto:=1;
   if expoente > 0 then
      for i:=1 to expoente do
	 produto:=produto*base;
   pwr:=produto;
end; { pwr }




function resolve(var node : polinomio; num,anterior: real):real;
begin
   if (node <> nil) then
      anterior := resolve(node^.prox, num, (anterior +  node^.coeficiente * pwr(num, node^.expoente)));
   resolve:=anterior;
end;




procedure multiplica(var dst : polinomio; src : polinomio; num : real; inicio : boolean);
begin
   
   if (src <> nil) and (num <> 0) then begin
      new(dst);
      dst^.coeficiente := src^.coeficiente * num;
      dst^.expoente := src^.expoente;
      multiplica(dst^.prox, src^.prox, num, false);
   end else
      dst:=nil;
end; { multiplica }




procedure soma_polinomios(var dst : polinomio; src1, src2 : polinomio; tipo : integer; inicio:boolean);
var coef : array[1..2] of real;
begin

   if (src1 <> nil) or (src2 <> nil) then begin
      
      if ((src1 <> nil) and (src2 <> nil) and (src1^.expoente = src2^.expoente)) then begin
	 coef[1]:=src1^.coeficiente;
	 coef[2]:=src2^.coeficiente;

	 if (tipo <> 1) then
	    coef[2]:= -1 * coef[2]; { subtracao }
	 if ((coef[1] + coef[2]) <> 0) then begin
	    new(dst);
	    dst^.coeficiente:=coef[1]+coef[2];
	    dst^.expoente:=src1^.expoente;
	    soma_polinomios(dst^.prox, src1^.prox, src2^.prox, tipo, false);
	 end else
	    soma_polinomios(dst,src1^.prox, src2^.prox, tipo, false);
	 
      end else  if ((src1 <> nil) and ((src2 = nil) or (src1^.expoente > src2^.expoente))) then begin
	 new(dst);
	 dst^.coeficiente:=src1^.coeficiente;
	 dst^.expoente:=src1^.expoente;
	 soma_polinomios(dst^.prox, src1^.prox, src2, tipo, false);
      end else if ((src2 <> nil) and ((src1 = nil) or (src2^.expoente > src1^.expoente))) then begin
	 new(dst);
	 if (tipo = 1) then
	    dst^.coeficiente := src2^.coeficiente
	 else
	    dst^.coeficiente := -1 * src2^.coeficiente;
	 
	 dst^.expoente:=src2^.expoente;
	 soma_polinomios(dst^.prox, src1, src2^.prox, tipo, false);
      end;
   end else
      dst:=nil;
      
end; { soma_polinomios }







{%%%%% Corpo Principal do Programa %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%}
{
c x y   - lê o x-ésimo polinômio composto de y parcelas, que serão fornecidas nas y linhas seguintes no
          formato especificado; 
+ z x y - atribui ao z-ésimo polinômio a soma do x-ésimo e y-ésimo polinômios; 
- z x y - atribui ao z-ésimo polinômio a diferença do x-ésimo e y-ésimo polinômios; 
* z x y - atribui ao z-ésimo polinômio o produto do x-ésimo polinômio pelo escalar y; 
d z x   - atribui ao z-ésimo polinômio o resultado da derivada do x-ésimo; 
a x y   - imprime o valor do x-ésimo polinômio calculado em y; 
p x     - imprime o x-ésimo polinômio no formato especificado; 
l x     - libera a memória dinamicamente alocada para o x-ésimo polinômio;
q       - sai do programa. 
}

begin

   read(opcao);

   while (opcao <> 'q') do begin
      case opcao of
	'c' : begin { c <posicao> <n_parcelas> le o polinomio para <posicao> com <n_parcelas> }
	   read(pos[1],pos[2]); { OBS: aqui, pos[2] comporta-se como <n_parcelas> }
	   le_polinomio(pos[2],p[pos[1]],true);
	end;
	'l' : begin { l <posicao> libera memoria alocada para o p[posicao] }
	   read(pos[1]);
	   apaga_polinomio(p[pos[1]]);
	end;
	'p' : begin { p <posicao> imprime o polinomio da <posicao> }
	   read(pos[1]);
	   imprime_polinomio(p[pos[1]]);
	end;
	'd' : begin {d <pos1> <pos2> deriva <pos2> e guarda em <pos1> }
	   read(pos[1],pos[2]);
	   deriva(p[pos[2]],p[pos[1]],true);
	end;
	'a' : begin {a <posicao> <n_real>  resolve p[<posicao>] para <n_real>}
	   read(pos[1],num);
	   writeln(resolve(p[pos[1]],num,0):0:3);
	end;
	'*' : begin {* <pos1> <pos2> <num>  p[<pos1>]:=p[<pos[2]>] * num }
	   read(pos[1],pos[2],num);
	   multiplica(p[pos[1]],p[pos[2]],num,true);
	end;
	'+' : begin {+ <pos1> <pos2> <pos3>    p[<pos1>] = p[<pos2>] + p[<pos3>]}
	   read(pos[1],pos[2],pos[3]);
	   soma_polinomios(p[pos[1]], p[pos[2]], p[pos[3]], 1,true);
	end;
	'-' : begin {- <pos1> <pos2> <pos3>    p[<pos1>] = p[<pos2>] - p[<pos3>]}
	   read(pos[1],pos[2],pos[3]);
	   soma_polinomios(p[pos[1]], p[pos[2]], p[pos[3]], 2, true);
	end;
      end; { case }
      read(opcao);
   end;
   
end.