restart;maple_mode(1);cas_setup(0,0,0,1,0,1e-10,10,[1,50,0,25],0,0,0); #radians,pas de cmplx, pas de  Sqrt
/* astuces, a retenir: sous xcas on utilise unapply qui est en general plus sur£que la methode suivante avec subs. */
 f:=x^2+1; g:=unapply(f,x);expand(g(x+2));
 g:=t->subs(x=t,f);g(x+2);
 f:=x->x^2-2;
 df:=x->eval(diff(f(x),x));
 df(x);u:=x^2;df(u);
/*  ca ne marche pas toujours, mieux vaut utiliser unapply, Ou mieux,£ deriver une fonction*/
 df:=unapply(diff(f(x),x),x);df(x);df(u);
 D(g);fonction_diff(g);D(g)(5);
/*  pour changer la valeur par defaut, soit dans le menu, soit avec la variable£ Digits, mais c'est pris en compte a partir de l'evaluation suivante.£ Ex: Digits:=100;sqrt(2.0); sur une meme ligne ne marche pas.*/
 Digits:=1;
 13*2.;evalf(13*2,3);
 Digits:=2;
 13.26*2;
 Digits:=10000;
 U:=1.:
/*  On fait 14 iterations de la methode de Newton, et on affiche la difference£ avec racine de 2. La majoration du reste montre qu'asymptotiquement le nombre£ de decimales exactes est multiplie par 2 a chaque iteration. Ce qui correspond£ bien a une majoration du type: |u_{n+1}-l|<C|u_n-l|^2£*/
 normal(x-f(x)/df(x));#On trouve x/2 +1/x c'est donc Heron.
 r:=evalf(sqrt(2));#on ne le calcule qu'une fois.
 for i from 1 to 14 do U:=U/2+1/U:a:=U-r:print(evalf(a,15)) od:
 Digits:=10;
/*  -------------------------------------------Jordan, Dunford--------------------------------------*/
/*  La decomposition d'une matrice reelle est reelle: par conjugaison et unicite£ de la decomp de Dunford*/
 C1:=companion((X^3-8)^2,X);
 C2:=companion((X^2-4)^3,X);
 A:=diag(C1,C2);
 cas_setup(0,0,1,1,0,1e-10,10,[1,50,0,25],0,1,0); #mode complexe est racines carrees.
 rat_jordan(A);
 rat_jordan(companion((x^3-2)^2,x));
 J:=jordan(A,'Q');Q;
 f:=(i,j)->if i=j then J[i,j] else 0 fi;
 dia:=matrix(op(dim(J)),f);
 S:=normal(Q*dia*Q^(-1));N:=A-S; #on remarque que les coeff sont dans le meme corps que ceux de A
 normal(S*N-N*S); # verification:
 u:=x^2;p:=x^2+1;
 f:=x->eval(diff(p,x));
 f(x);
 f(u); #ca ne convient donc pas. mieux vaut faire unapply.
 f:=unapply(diff(p,x),x);
f(x);f(u);
d:=gcdex(x^2+2,x,'s','t');normal((x^2+2)*s+t*x); # attention on trouve d et non 1
/*  n_u est dans l'ideal N car c'est la somme des u_n-u_{n+1} qui sont tous dans N, donc n_u est nilpotent. £ Pour tout polynome r, r(u) est somme de r(s_u) et d'un element de N, donc r(s_u)=0 implique£ que r(u) est dans N et donc que p divise r par definition de p. donc p est le pol min de s */
/* Pour que l'algorithme fasse au moins 2 iterations, on met un facteur a la£puissance 5 dans le polynome minimal. Pour etre sur du resultat on prend une£matrice diagonale par blocs de type compagnon*/
 A:=diag([companion((x^3-2)^5,x),companion(x^5-2*x^2,x)]);
 Dunford:=proc(A)
 m:=pcar(A,x,lagrange);
 p:=unapply(normal(m/(gcd(m,diff(m,x)))),x);
 dp:=unapply(normal(diff(p(x),x)),x);
 u:=x;
 #on itere
 while rem(p(u),m,x) <> 0 do
 d:=gcdex(m,dp(u),x,'s','t');
 invdp:=t/d;
 u:=rem(u-p(u)*invdp,m,x); 
 od;
 horner(u,A); 
 end proc;
/*  Pour avoir au moins deux it\'erations, il faut un facteur de degre au moins 4£ dans le polynome minimal, ce que l'on obtient par exemple avec£companion((x^3-2)^5,x)*/
 S:=Dunford(A);
 N:=A-S; 
 N*S-S*N; # S et N commutent bien
 mu:=pmin(S,x); gcd(mu,diff(mu,x)); #S est bien diagonalisable
/*   p = m/D ou D est le pgcd de m et m'£  NB:en caract q K=F_q(T), m=X^q-T, alors m'=0, mais p n'est pas 1 car£  l'algebre n'a pas de nilpotents.*/
/*  1/(e(1+n/e)) se developpe en somme finie, et c'est l'inverse de e+n*/