Q1. Une procédure calculant les nombres de Catalan 

>	a:=proc(n) option remember; if n=0 then 1 else add(a(i)*a(n-i-1),i=0..n-1) fi end;

 

>	L:=[seq(a(i),i=0..10)];

 

Q2. Une équation devinée 

>	gfun:-listtoalgeq(L,y(z));

 

Q3. Résolution et vérification 

>	solve(%[1],y(z));

 

>	map(series,[%],z);

 

C'est donc la seconde qui est la bonne. 

>	sol:=%%[2];

 

>	C100:=coeff(series(sol,z,105),z,100);

 

>	C100-a(100);

 

Q4. Une récurrence satisfaite par les  

>	gfun:-listtorec(L,c(n));

 

>	rsolve(op(1,%),c(n));

 

>	simplify(eval(%,n=100)-C100);

 

Q5. Leur nombre pour  

>	a:=proc(n) option remember; if n=0 then 1 else add(add(add(add(a(i1)*a(i2)*a(i3)*a(i4)*a(n-1-i1-i2-i3-i4),i4=0..n-1-i1-i2-i3),i3=0..n-1-i1-i2),i2=0..n-1-i1),i1=0..n-1) fi end;

 

>	L:=[seq(a(i),i=0..20)];

 

Q6. Un polynôme dont la série génératrice est solution 

>	gfun:-listtoalgeq(L,y(z));

 

>	gfun:-Parameters(maxdegeqn=10);

 

>	gfun:-listtoalgeq(L,y(z));

 

>	pol:=subs(y(z)=y,%[1]);

 

Q7. Les 64 premiers coefficients par itération de Newton 

>	dpol:=diff(pol,y);

 

>	newt:=proc(n) local G; if n=1 then 1 else G:=convert(newt(ceil(n/2)),polynom); series(G-subs(y=G,pol/dpol),z,n) fi end;

 

>

 

>	S:=newt(64);

 

Vérification : 

>	coeff(S,z,30)-a(30);

 

Q8. Forme close pour les coefficients 

>	gfun:-seriestorec(series(S,z,51),u(n));

 

>	rsolve(%[1],u(n));

 

>	val60:=eval(%,n=60);

 

>	val60:=simplify(%);

 

>	coeff(S,z,60)-%;

 

Q9. La matrice jacobienne du système 

>	jac:=linalg[jacobian](sys,[B,V]);

 

Q10. Formation de l'itération de Newton 

On utilise la possibilité de faire de l'inversion symbolique (mais on pourrait aussi faire l'inversion en série, ce qui serait moins coûteux) : 

>	jacm1:=linalg[inverse](jac);

 

>	newtit:=convert(evalm([B,V]-jacm1 &* sys),list);

 

>	newt:=proc(n) local G; if n=1 then [0,0] else G:=map(convert,newt(ceil(n/2)),polynom); map(series,subs(B=G[1],V=G[2],newtit),z,n) fi end;

 

Q11. Itération jusqu'à la taille 31 

>	newt(32)[1];

 

Q12. L'équation linéarisée et sa résolution 

>	deq:=op(1,deq)-op(2,deq);

 

>	eval(deq,y(x)=y(x)+u(x))-deq;

 

>	expand(%);

 

On ne garde que la partie linéaire : 

>	lineq:=subs(u(x)^2=0,u(x)^3=0,%)=deq;

 

>	dsolve(lineq,u(x));

 

>	findu:=proc(y,ord) local hom; hom:=series(exp(Int(3*y^2,x)),x,ord); series(hom*Int(series((diff(y,x)-1-y^3)/hom,x,ord),x),x,ord) end;

 

Q13. Itération de Newton 

>	newt:=proc(n) local G; if n=1 then x else G:=convert(newt(ceil(n/2)),polynom); series(G-findu(G,n),x,n) fi end;

 

>

newt(32);

 

Q14. Équation linéarisée 

>	eval(eq,T=proc(z) T(z)+u(z) end)-eq=eq;

 

Q15. Résolution par itération 

L'idée est que pour résoudre l'équation  

>	subsop(2=A(z),%);

 

il suffit d'itérer 

>	isolate(%,u(z));

 

Voici donc une procédure qui calcule S à partir de T: 

>	evaleq:=proc(T, ord) series(T-z-subs(z=z^2+z^3,T),z,ord) end;

 

et l'itération pour calculer u: 

>	findu:=proc(s, ord) local estim, new, membredroit; membredroit:=evaleq(s,ord); estim:=membredroit; do new:=series(membredroit+subs(z=z^2+z^3,estim),z,ord); if new=estim then return new else estim:=new fi od; end;

 

Q20. L'itération de Newton 

>	newt:=proc(n)local G; if n=1 then z else G:=convert(newt(ceil(n/2)),polynom); series(G-findu(G,n),z,n) fi end;

 

>

newt(64);