Tour d'horizon des fonctionnalités de Maple

DEA algorithmique






Remarques

1  Un peu de syntaxe

Une commande Maple se termine par un point-virgule ;. Si l'on ne souhaite pas voir l'affichage du résultat, on termine la commande par :

= représente l'égalité dans une équation, l'affectation est représentée par :=.

Quand on tape seulement le nom d'une variable, on en voit le contenu. Une variable contient son propre nom avant sa première affectation. Pour savoir si c'est le cas : 
    assigned(v1);
    v1:=1;
    assigned(v1);
    unassign('v1');
    v1;
    assigned(v1);
Avec Maple 5.5, %, %% et %%% représentent respectivement le résultat de la commande précédente, de la pénultième commande et de l'anté-pénultième commande Maple. Si vous utilisez une version plus ancienne de Maple (il y a des versions 5.5 et 5.4 dans vos salles de TP !), ce sont ", "" et """ qui jouent les rôles ci-dessus.

Cela peut être utile quand on a tapé une expression dont l'évaluation a demandé un temps certain, mais dont on n'a pas nommé le résultat alors qu'on veut le ré-utiliser. On nomme alors le résultat par nom:=%; 
    1=2;
    evalb(%);
    n1:=1;
    n1;
    n2:=2:
    n2;
    n1=n2;
    evalb(%);
    c;
    1000!;
    f:=%;
Pour revenir à une session vierge: restart;

2  Premiers essais

    Pi; 
    pi;
    evalf(Pi);
    evalf(pi);
    sqrt(-1);
    exp(1);
    E;
    infinity;
    int(1/(1+x^2),x=0..infinity);
    sin(%);
    plot(sin(x),x=-Pi..Pi);
    plot3d(x^2-y^2,x=-10..10,y=-10..10);

3  Les fonctions d'aide

Essayez 
    ?convert
    ?sin
    ?index
on peut aussi avoir accès à l'aide à partir du browser d'aide (menu déroulant Help en haut à droite de la barre de menu).

4  Entiers et rationnels

    2+2;
    2^10;
    7^500;
    200!;
    ifactor(200!);
    igcd(1000!,7^500);
    1153*(3^58+^40)/(29!-7^36);
et pour en voir une valeur décimale approchée 
    evalf(%);
avec f pour flottante.

Maintenant tapez 
    ?numtheory
C'est le premier exemple de package. Certaines fonctions s'obtiennent directement : 
    nextprime(10^20);
alors que d'autres ont besoin d'une forme d'appel plus longue : 
    cyclotomic(7,x);
    numtheory[cyclotomic](7,x);
ou : 
    with(numtheory,cyclotomic):
    cyclotomic(8,x);
Ces deux dernières formes d'appel sont censées toujours marcher. La notation package[fonction,options] est la forme de référence, elle est sans aucune ambiguité et pour lever une ambiguité (si deux fonctions de deux packages différents portent le même nom) il suffit de revenir à cette notation.

5  Calcul matriciel

5.1  La syntaxe des matrices

    a:=array([[1,x,y],[x,y,z],[y,z,1]]);
    a[1,2];
Le package linalg contient les fonctions relatives aux matrices. 
    linalg[det](a);
    linalg[charpoly](a,lambda);
    ?vandermonde
    b:=linalg[vandermonde]([x,y,z]);
    linalg[det](%);
    factor(%);
    m:=array(1..5,1..5);
    for i from 1 to 5 do
      for j from 1 to 5 do
        m[i,j]:=1/(i+j-1)
      od;
    od;
    evalm(m);
    H:=linalg[hilbert](5);

5.2  Le produit de matrices

    linalg[multiply](a,b);
ou 
    evalm(a &* b);

6  Calculs polynomiaux

6.1  Manipulations de base

On a vu plus haut un exemple d'utilisation de factor. Voici quelques manipulations plus simples : 
    p:=x^5*y+3*x^2+1;
    degree(p,x);
    coeff(p,x,2);
    expand((x+1)^20);
    expand((1+x*x^2)^5);
    sort(%);
    factor(x^4-1);
    factor(x^4-1,I);
    f:=(1+x*(1+y))^2/(1-y^2);
    collect(f,x);
    collect(f,x,normal);
    p:=x^3*y^2+2*x*y^2-9*x*y^3+5*x;
    q:=x^4+x^2+1;
    pq:=p*q;
    expand(pq);
    collect(%,x);
    coeff(%,x,3);
un peu plus de vrai calcul : 
    P:=x^10+u*x+1; 
    Q:=2*x^3+v*x^2-1;
    rem(P,Q,x);
on a aussi le pgcd 
    gcd(P,Q);
et la version Bezout (plus lente) : 
    gcdex(P,Q,x,U,V);
on a donc UP+V Q=1 comme on peut le vérifier 
    normal(U*P+V*Q);
On peut aussi manipuler des fractions 
    f:=7/((x+1)^7-x^7-1);
    convert(f,parfrac,x);

6.2  Résolution d'équations

On peut rechercher des racines exactement 
    solve(1/f,x);
    solve(a*x^2+b*x+c,x);
    solve(a*x^3+b*x^2+c*x+d,x);
ou numériquement 
    fsolve(f=1,x);
on peut aussi trouver les racines complexes d'un polynôme 
    fsolve(numer(f-1),x,complex);
Toutes les solutions ne s'expriment pas facilement 
    solve(x^7+x+1,x);
On peut manipuler cet objet avec evala (a pour algèbrique) 
    alias(alpha=%);
    evala(Normal((alpha^5+1)/(alpha^2-1)));
On peut aussi compter le nombre de racines sur un intervalle de R 
    readlib(sturm):
    sturm(sturmseq(x^7+x+1,x),x,-infinity,infinity);
et quelques autres simplifications sont possibles 
    sum(x^10,x=RootOf(x^4+a*x+b,x));
On peut aussi s'attaquer à des systèmes d'équations : 
    solve({3*w+4*x-2*y+z=-2, w-x+2*y+2*z=7, 4*w-3*x+4*y-3*z=2, -w+x+6*y-z=1},
          {w, x, y, z});
    solve({x+y+z=a, x+2*y-a*z=0, b*z+a*y=0}, {x, y, z});
On reviendra sur toutes ces opérations plus en détail par la suite. Pour en savoir un peu plus d'ores et déjà : 
    ? polynom

7  Primitives, équations différentielles, intégrales définies

    int(1/(x^2-2),x);
    int(exp(x^2),x);
    int(exp(x^3),x);
on verra pourquoi ceci prouve qu'il n'y a pas de primitive élémentaire. 
    deq:=diff(y(x),x,x)^2=(1+diff(y(x),x))^3;
    dsolve({deq,y(0)=0,D(y)(0)=1},y(x));
    deq:=(x^3/2-x^2)*diff(y(x),x,x)+(2*x^2-3*x+1)*diff(y(x),x)+(x-1)*y(x);
    dsolve(deq,y(x));
et une intégrale définie 
    int(sqrt(x^2),x=-1..0);

8  Suites et séries

    rsolve({u(n+2)=u(n+1)+u(n),u(0)=1,u(1)=1},u(n));

    v:=(3*n^3-10*n^2-9*n+11)*(n+1)!*2^n/(2*n+3)!/(n-5)/(n-4);
    Sum(v,n)=sum(v,n);

8.1  Quelques sommations définies

    factor(sum(i^2,i=0..n));
    sum(1/n^2,n=1..infinity);
    sum(x^n/(n-1)!,n=1..infinity);

8.2  Développement en série

    f:=(sin(Pi/(6+x))+cos(Pi/(3+x)))^(1/x);
    series(f,x,4);
    taylor(f,x=0,4);
    convert(%,polynom);
    series(arccos(1-x),x);
    asympt(n!,n);

9  Substitutions - Évaluation - Changement de variables

    g:=(x-1)*(x-2)*(x-3)/((x-4)*(x-5)*(x-6));
    subs(x=3/4,g);
    evalf(%);
    subs(x=0.75,g);
    p:=x^3*y^2+2*x*y^2-9*x*y^3+5*x;
    subs(x=-3,p);
    subs(x=-3,y=2,p);
    subs(x=z+1,p);
    expand(%);
    q:=x^4+x^2+1;
    subs(x=X^(1/2),q);

10  Groupes

Le package group permet de travailler en particulier sur les groupes de permutations. Pour la représentation des permutations à l'aide de listes, voir l'aide de permgroup.

On peut charger tout le package 
    with(group);
Pour la composition de permutations, attention à l'ordre 
    p1:=[[1,2]];p2:=[[1,3]];
    p3:=mulperms(p2,p1);
    mulperms(p1,p2);
Construisons le groupe symétrique de degré 8 
    {[1,2],[1,3],[1,4],[1,5],[1,6],[1,7],[1,8]}:
    transgen := map(x->[x],%);
    S8 :=permgroup(8,transgen);
    evalb(grouporder(S8)=8!);
Le groupe alterné maintenant 
    {seq([1,2,i],i=3..8)};
    tricycgen:= map(x->[x],%);
    A8:=permgroup(8,tricycgen);
    evalb(grouporder(A8)=8!/2);
Quelques fonctionnalités 
    RandElement(A8);
    groupmember(p1,A8);
    groupmember(p3,A8);
    isnormal(A48,S8);
    isabelian(A8);
    cyc:=[[1,2,3,4,5,6,7,8]]:
    invperm(cyc);
Deux cycles sont conjugués dans S_n si et seulement si ils ont même longueur 
    areconjugate(S8,cyc,[[4,5,3,1,6,2,7]]); 
    areconjugate(S8,cyc,[[4,5,3,1,6,2,7,8]]);
Si c'est trop long alors stopper et passer à la construction du groupe cyclique ci-dessous 
    G:=permgroup(8,{cyc});
    grouporder(G);
    isabelian(G);
    issubgroup(G,A8);
Intéressons-nous à l'intersection 
    H:=inter(G,A8);
    grouporder(%);
    isnormal(H,A8);
    orbit(G,1);
    orbit(H,1);
On peut afficher explicitement les éléments du groupe H en retournant les représentants des classes à droite de H mod {Id}. 
    Ident := permgroup (8, {[]} );
    cosets(H,Ident);
    cosets(H,permgroup (8, {[[1, 5], [2, 6], [3, 7], [4, 8]]} ));
    cosets(G,H);

11  Graphiques 2D

Attention, certaines fonctions ne sont accessibles que par le package plots.

Tracer une fonction y=f(x) 
    plot(3*x^3-10*x^2+4,x=-10..10);
    plot(3*x^3-10*x^2+4,x=-5..5);
    plot(3*x^3-10*x^2+4,x=-1..4);
    plot(sin);
    f:=x->-x^4+10*x^3-12;
    plot(f);
Il existe beaucoup d'options (voir l'aide à partir de plot) 
    plot(x*sin(10/x),x=-0.5..0.5,numpoints = 10);
    plot(x*sin(10/x),x=-0.5..0.5);
    plot(x*sin(10/x),x=-0.5..0.5,numpoints = 100);
    plot(x*sin(10/x),x=-0.5..0.5,numpoints = 100,axes=BOXED);
    plot(x*sin(10/x),x=-0.5..0.5,numpoints = 100,axes=FRAMED);
    plot(x*sin(10/x),x=-0.5..0.5,numpoints = 100,axes=NONE);
La spécification d'un intervalle vertical peut se révéler utile 
    plot((1/x),x=-0.2..0.2);
    plot((1/x),x=-0.2..0.2,numpoints=100);
    plot((1/x),x=-0.2..0.2,y=-100..100);

11.1  Courbes paramétrées

    plot([t*cos(5*t), sin(5*t)*t-t,t=0..2*Pi]);

11.2  Coordonnées polaires

plot([r(t),theta(t),t=range of t ],h,v,coords=polar); avec r(t) la distance à l'origine, theta(t) l'angle de rotation, h et v les intervalles horizontaux et verticaux. 
    plot([1/100*t^2,t,t=0..15*Pi],coords=polar);

11.3  Courbes implicites

Il est possible de tracer des courbes implicites (f(x,y)=0) à l'aide de la commande implicitplot. Cependant, au voisinage des singularités, un manque de précision apparaît. Il est alors conseillé de trouver une représentation paramétrée pour tracer. Essayez 
    plots[implicitplot](x^6+y^6+3*x^4*y^2+3*x^2*y^4-x^4+2*x^2*y^2-y^4,x=-1..1,y=-1..1);?
    plots[polarplot](cos(2*t),t=0..2*Pi);
Une session réelle est un mélange de tout ça, avec expérimentations, calculs de valeurs numeriques, petites procédures, ...



12  Fichiers

    currentdir();
Vous pouvez modifier le répertoire dans lequel s'écrivent et se lisent les fichiers par currentdir("chemin du nouveau répertoire"); 
    save g,p,q,r,toto;
    save g,p,q,r,"toto.m";
Noter la différence de contenu des fichiers ainsi créés par Maple (utiliser cat ou more dans un shell par exemple).

Quelle différence lorsque Maple charge ces fichiers? 
    restart;
    read toto;
    p;q;r;
    restart
    read "toto.m";
    p;q;r;
Pour finir, on sauvegarde la feuille de travail. On pourra ensuite comparer les deux sortes de fichiers texte sous lesquels on peut sauvegarder. Éditer un petit fichier de commandes que vous chargerez dans Maple.



Valérie Ménissier-Morain et Philippe Aubry
Friday 22 October 1999
This document was translated from LATEX by HEVEA.