Dcouverte des premires fonctionnalits

Tous les ordres passs l'ordinateur se font dans les zones prcdes du signe > . Ces zones sont des zones d'entre ( input ). Presser la touche Entre pour transmettre l'ordre au logiciel. Les lignes doivent imprativement se terminer par un point-virgule ; ou par deux points : Noter la diffrence entre ces deux possibilits:

> 12+abs(4-3*sqrt(5));

Si la ligne se termine par un point-virgule, l'ordre est valid et le logiciel fournit une rponse dans une zone de sortie ( output ) .

> 12+abs(4-3*sqrt(5)): Si la ligne se termine par deux points, l'ordre est simplement valid sans rponse du logiciel.

Des messages d'erreur peuvent apparatre en cas de mauvaise saisie ou d'oprations illicites: > 12+abs(4-3*sqrt(5); Error, `;` unexpected > 1/cos(Pi/2); Error, numeric exception: division by zero

Obtenir de l'aide sur une fonction en utilisant ? ou help:

Ici on cherche de l'aide sur la fonction solve . > ??solve; > help(solve); Voir aussi plus en dtail pour les variantes ?? et ??? .

Faire des calculs simples: > 15!; # ou factorial(15)

> (1-1/7)*(1+2/3)^2;

Affecter une valeur une variable en utilisant := > p:=2.14;

> expr:=p-ln(p);

Dvelopper , factoriser , ou simplifier une expression: > f:=(a+b)^6;

> expand(f);

> factor(%);

> %%;

% permet de rappeler la dernire expression calcule (% est le Ditto Operator ) %% permet de rappeler l'avant-dernire expression calcule. %%% permet de rappeler l'avant-avant-dernire expression calcule.

> simplify(cos(x)^2+sin(x)^2);

Substituer en utilisant la fonction subs(variable=remplacement,expression) > subs(a=c,f);

Calculer une prcision voulue: evalf(expression) ou evalf(expression,nbdcimales) > evalf(sqrt(3)); # sqrt dsigne la racine carre

> evalf(sqrt(3),50);

# permet de dfinir un commentaire dans une ligne (tout ce qui est aprs le signe # est ignor)

Ecrire une expression avec print ou lprint ou printf

> f:=a-3/a+1/(a*a+1);

> print(f);

> lprint(f); a-3/a+1/(a^2+1)

La fonction printf est celle du langage C, permettant l'affichage de donnes selon des formats prtablis et en utilisant des caractres de contrle. Exemple: %d : nombre entier, %f : nombre en virgule flottante simple prcision, \n : passage la ligne. Voir galement les fonctions: fprintf , sprintf , et nprintf . > printf("%d %f \n",123,1234/567); 123 2.176367

Dfinir une fonction une ou plusieurs variables: > f:=t->sin(t)-t;

> f(3*x+2);

> g:=(u,v,w)->1/u+exp(u+v)+(u-v+w)^2;

> g(2*a,b,3*c);

Driver une fonction une ou plusieurs variables en utilisant la fonction diff: > diff(f(t),t);

> diff(g(u,v,w),v);

Intgrer une fonction une variable en utilisant la fonction int:

> int(f(t),t); # donne une primitive de f

> Int(g(u,v,w),v)=int(g(u,v,w),v);

> Int(f(t),t=0..Pi)=int(f(t),t=0..Pi);

Noter la forme inerte Int qui affiche l'intgrale et la forme int qui calcule l'intgrale.

Calcul de limites, de sommes, de produits: > limit((2*t-3)/(3*t+4),t=infinity);

> limit((2*t-3)/(3*t+4),t=-4/3,right); #limite droite (left pour une limite gauche)

> Sum(i^2,i=1..10)=sum(i^2,i=1..10);

> Product(1/i,i=1..10)=product(1/i,i=1..10);

Noter l aussi les formes inertes Sum et Product qui affichent respectivement les symboles sigma et pi .

Rsoudre une quation une inconnue en utilisant la fonction solve: > solve(2*t+3=-t+6*sqrt(2));

> solve(t-15/4*u=5/2*(u-t)+3,u);

Rsoudre un systme d'quations plusieurs inconnues en utilisant la fonction solve: > solve({a-b=2,a+3*b=7},{a,b});

Approcher les solutions d'une quation ou d'un systme d'quations en utilisant la fonction fsolve: > fsolve(cos(t)=t);

> fsolve({t^3+u=1,u-(t-1)^3=t},{t,u});

Reprsenter une fonction une ou plusieurs variables en utilisant la fonction plot ou plot3d: > plot(sin(t)/t,t=-20..20,title="fonction t ---> sin t / t");

> plot3d(x*exp(-x^2-y^2),x=-2..2,y=-2..2,color=x,orientation=[120,75]);

Exercice corrig 1:

1. Dfinir la fonction f :

2. Calculer les 3 premires drives de f , en les donnant sous forme factorise .

3. Calculer la valeur numrique de l'intgrale de f sur

4. Reprsenter dans un mme repre f et la fonction

sur

5. Les deux courbes ont un point commun : calculer une valeur approche de son abscisse .

> f:=x->2*exp(-x^2)-x/2;

> diff(f(x),x);

> factor(diff(%,x));

> factor(diff(%,x));

> evalf(int(f(x),x=-1..2));

> plot({f(x),x},x=-1..2);

> fsolve(f(x)=x);

Travail dirig 1:

TD 1.1:

1 Dfinir la fonction f qui x associe

2 Calculer les 3 premiers nombres drivs successifs (on les crira sous forme factorise)

de f au point x

3 On pose pour forme simplifie)

. Calculer

(on les crira sous

4 Calculer les racines des polynmes

5 Reprsenter

dans un mme repre pour x compris entre

et 2.

6 Calculer l'intgrale de

sur

TD 1.2:

1 Dvelopper

en fonction de

2 Dterminer les polynmes

de la variable X tels que

lorsque

(polynmes de Tchbychev ) .

3 Reprsenter

sur

4 Calculer les racines de

lments de base
LES VARIABLES:
Une variable informatique est l'adresse , dans la mmoire de l'ordinateur , d'un emplacement permettant de stocker un objet d'un type donn . Exemples: AB, aB , X1, _var , x[a] sont des noms de variables MAPLE .

Si l'on affecte une variable une valeur , la variable est dite assigne . Si elle n'est associe aucune valeur , la variable est dite non assigne .

La fonction restart permet de rinitialiser toutes les variables de la feuille de calcul. > restart;

var est une variable assigne, dont la valeur est 3 : > var:=3;

La variable a et la variable indice > a,x[a];

sont non assignes :

Une autre manire d'affecter une valeur une variable est d'utiliser la fonction assign : > assign(nom,10-var); > nom;

Pour dsaffecter une variable assigne, lui affecter son nom crit entre deux accents aigus : > nom:='nom':nom;

On peut aussi utiliser la fonction evaln (valuer en un nom) : > var:=evaln(var):var;

LES CONSTANTES:

true , false (valeurs boolennes vrai , faux) , I (complexe de carr -1) , Pi (nombre pi) , infinity (plus l'infini) sont des constantes MAPLE. E (base des logarithmes npriens) n'est pas une constante MAPLE : faire exp(1). > eval(exp(1))=evalf(exp(1));

LES EXPRESSIONS:

Elles sont values de la gauche vers la droite , avec la priorit usuelle des oprateurs. Pour afficher une expression, utiliser les fonctions lprint ou print :

> lprint(1-2/a+(a+1)/(a-5)); 1-2/a+(a+1)/(a-5) > print(1-2/a+(a+1)/(a-5));

Toute expression a un type que l'on peut obtenir grce la fonction whattype :

Parmi les types possibles figurent : + (somme) , * (produit) , ^ (puissance) , = (galit) , <> (non galit) , < , <= (ingalit au sens strict ou large) , and , or , not (et,ou,non) , integer (nb entier) , fraction (nb rationnel) , float (nb rel en virgule flottante) , complex (nb complexe) , numeric (numrique) , symbol (symbole), string (chane de caractres) , list (liste) , set (ensemble) , table (table) , array(tableau) , function (fonction) , name (nom) , .. (intervalle).

> whattype(a+b),whattype(a>b),whattype(1.2245),whattype(a^7),whattype((a and b) or (c or d));

> whattype(x2/y),whattype(a/b),whattype(`MAPLE`),whattype("MAPLE"),whattype({a,b});

On peut tester si une expression a un type donn en utilisant la fonction type : > type(x,name),type(a+3*x-7/5,list);

Autres fonctions : > expr:=x-3*y+5/(x+y);

nops(expression) donne le nombre d'oprandes de l'expression: > nops(expr);

op(i,expression) donne le i-me oprande de l'expression: > op(2,expr);

op(i..j,expression) donne les oprandes de l'expression, du i-me au j-me: > op(2..3,expr);

Transformation des expressions:

Regrouper certains termes selon une ou plusieurs variables avec collect(expression,v) ; v est une variable ou une liste de variables :

> expr:=x^3*ln(x)+3*x^2+ln(x)*x-x:collect(expr,ln(x));

> expr:=x^2+5*x-25*y+48*(x-2*y+7)+y^3:collect(expr,[x,y]);

Transformer en un seul terme avec combine(expression,noms) : Le paramtre noms est optionnel et choisir par exemple parmi : exp , ln , trig , power .

> combine(2*Sum(i^2,i=1..n)+Sum(i^3,i=1..n));

> combine(exp(sin(a)*cos(b))/exp(cos(a)*sin(b)),[trig,exp]);

Simplifier une expression avec normal(expression) , simplifier une expression contenant des radicaux avec radsimp(expression) :

> normal( 1/x+x/(x+1) );

> normal( 1/x+x/(x+1), expanded );

> radsimp((x-1)*sqrt(x*x-2*x+1)*(x+1));

Ordonner une expression avec sort(expression,v) ; v est une variable ou une liste de variables : > sort(expr,y);

Ordonner selon un critre avec sort(liste,paramtre) ; liste est une liste de valeurs , paramtre = `<` ou `>` (ordre croissant, dcroissant) , lexorder ou string (ordre lexicographique) .

> liste1:=[12,-2,5,1]:liste2:=[s,q,a,g,h,p,z,j,l,m,o,b,i]: > sort(liste1,`>`),sort(liste2,lexorder);

Transformer une expression selon le modle forme avec convert(expression,forme) : > sin(2*x)=convert(sin(2*x),tan);

Faire des substitutions avec subs(eq1,eq2,...,eqn,expression):

> expr; subs(x=lambda,y=2*t,expr); expr;

On constate que expr n'a pas chang. > subsop(1=w,2=-t,4=mu,expr);

L'oprande n1 a t remplac par w , l'oprande n2 a t remplac par par .

et le n4

On peut galement utiliser use ... in .. end use : > use x=4*rho, y=h, z=mu in (x+y-z+3)^7 end use;

Appliquer une fonction tous les oprandes avec map(fonction,expression) ; > map(x->x^2,expr);

Isoler une expression dans une quation avec isolate(equation,expression) ; > expr:=-x^3+2*(sqrt(y-sin(x))+1):isolate(expr,y);

Obtenir le membre gauche ou droit d'une galit avec lhs(expression); ou rhs(expression); > lhs(%);rhs(%%);

LES FONCTIONS:

Pour dfinir une fonction , on peut utiliser les syntaxes :

nom := var -> expr; pour une fonction d'une variable var nom := (var1,var2,...,varN) -> expr; pour une fonction de N variables var1,var2,...,varN .

> f:=x->exp(x)-x;

> f:=(x,y,z,t)->x^2-3*y+4*z-t;

La fonction unapply (expr,var1,var2,...,varN) permet de transformer l'expression expr en une fonction des N variables var1,var2,...,varN:

> expr:=u^2-3*v+4*w : f:=unapply(expr,u,v,w);

Composition des fonctions: l'oprateur @ , l'oprateur de composition itre @@

> f:=u->u^3:g:=t->2*t+1: (f@g)(a);(g@f)(a);

f@@N correspond f o f o . . . o f (N fois) > (f@@3)(u);

> (D@@2)(f); # fonction drive seconde de f

LES TYPES DE BASE:

LES TYPES NUMRIQUES:

On peut utiliser la fonction assume pour imposer une condition: Exemple: on impose r la condition > assume(r,positive);r; sign(r); ( r est alors affich suivi d'une tilde: r ~ )

La fonction about permet d'obtenir une information sur une variable: > about(r); Originally r, renamed r~: is assumed to be: RealRange(Open(0),infinity)

LES ENTIERS : ce sont des objets de typ e integer . Un entier peut tre positive (>0) , (<0), nonneg (>=0) , posint (entier>0) , negint (entier<0) , nonnegint (entier>=0) , even (pair) , odd (impair) , primeint (premier). Ce que l'on peut tester avec type ou is .

> type(-15,negint), is(13,even);

On peut slectionner des lments rpondant une condition boolenne avec select(condition,v); Exemple: slectionner dans une liste de nombres ceux qui sont entiers >0 > select(x->type(x,posint),[-1/2,-7,Pi,3/4,0.25,18,2^5]);

Quelques fonctions utilisant les entiers: > q:=iquo(89,-12);r:=irem(89,-12);

( quotient et reste de la division euclidienne de a par b : a =bq +r , avec |r|<|b| , ici

89 = (-12) (-7) + 5 )

54 est-il premier? > isprime(54);

nombre premier suivant , nombre premier prcdent: > nextprime(215),prevprime(215);

Le 17 me nombre premier: > ithprime(17);

Dcomposition en facteurs premiers: > ifactor(117208);

Le ppcm et le pgcd de plusieurs entiers: > ilcm(20,25,15);igcd(20,25,15);

Le plus petit ou le plus grand: > min(712,56,100,25,125),max(712,56,100,25,125);

mod ( a modulo n donne le reste de la division de a par n , ici 31=4*7+3 ) : > 31 mod 4;

rand(n) rend une fonction (appele ici hasard) calculant un entier alatoire entre .

> hasard:=rand(100):h:=hasard();

Fonction sign : cette fonction rend : -1 si > n:=-7;sign(n);

, 1 si

Fonction valeur absolue: > abs(n);

LES RATIONNELS : ce sont des objets de type fraction (ou rational ) . Un rationnel peut tre positive (>0) , negative (<0) , nonneg (>=0) , ce qui peut tre test par type ou is (comme pour les entiers).

Quelques fonctions utilisant les rationnels: > q:=21*(144/124);numer(q);denom(q);

Comme pour les entiers , on a aussi les fonctions assume , min , max , sign , abs.

LES REELS : un rel de type float , a une mantisse et un exposant . Exemple: 1234567=0.1234567*10^7 . La mantisse est 0.1234567 , et l'exposant 7 . Le nombre s'crit Float(0.1234567,7);

> evalf(Float(0.1234567,7));

L'utilisation du point . dclenche l'affichage en calcul flottant dans le second membre: > 1/9=1.0/9;

Digits est une variable d'environnement reprsentant le nombre de dcimales affiches (10 par dfaut). > Digits:=30:evalf(exp(1));

Quelques fonctions utilisant les rels:

abs , sqrt (racine carre) , exp , ln , log10 , log[a] (logarithme de base a) , sin , cos , tan , cot (fonctions circulaires) , sinh , cosh , tanh , coth (fonctions hyperboliques) , arcsin ,arccos , arctan , arccot (fonctions circulaires rciproques) , arcsinh , arccosh , arctanh , arccoth (fonctions hyperboliques rciproques). La fonction partie entire : floor(x) est le plus grand entier infrieur ou gal x.

> sqrt(1250);ln(exp(7));arctan(1);

> floor(-7.98);floor(7.98);

La fonction Gamma d'Euler : > GAMMA(x)=Int(t^(x-1)*exp(-t),t=0..infinity);

LES COMPLEXES : de type complex , sont constitus de deux rels , la partie relle et la partie imaginaire . > z:=1-5*I*sqrt(2):z,Re(z),Im(z);

evalc : fonction d'valuation des nombres complexes > z:=evalc((1+exp(1)^(I*Pi/6))/(1-I));

> Digits:=10:evalf(z);

> map(evalc,polar(a+I*b));

Quelques fonctions utilisant les complexes:

abs(z) , argument(z) , conjugate(z) : module , argument dans ]-Pi,Pi] , conjugu de z. > z:=1+sqrt(3)*I:abs(z),argument(z),conjugate(z);

AUTRES TYPES:

LE TYPE BOOLEAN : Les boolens sont de type boolean et peuvent prendre 2 valeurs : false et true . Si MAPLE ne parvient pas rsoudre un problme , il peut rendre le rsultat FAIL .

Les oprateurs logiques sont : not (non) , or (ou) , and (et) , xor (ou exclusif) , implies (implication). Une expression boolenne peut tre value par la fonction evalb :

> t:=10: evalb(t*t>0),evalb(isprime(t) and t>0);

> evalb(evalf(exp(1))<evalf(Pi));

LES TYPES NOM (name), SYMBOLE (symbol), et INDEX (indexed):

Une expression Maple est de type index, si elle dfinie partir d'indices ou d'index. Elle est alors de type indexed . Exemple: est une variable indexe, contrairement la variable

> type(a[x],`indexed`);

> type(nom_var,`indexed`);

Un nom, de type name , est une expression Maple dfinie partir d'une lettre, suivie d'autres lettres ou de chiffres, ou d'autres symboles, comme _ ,ou si elle est de type index. Un nom peut aussi tre form en entourant une squence de caractres par des accents graves ` `. > type(a[x],`name`);

> type(nom_var,`name`);

> type(a/b,`name`);

> type(`12345`,`name`);

> type(12345,`name`);

Un symbole, de type symbol, est une expression Maple qui est un nom, mais n'est pas de type index. > type(a[x],`symbol`);

> type(nom_var,`symbol`);

> type(a/b,`symbol`);

Quelques fonctions utilisant ces types: length ( c ) retourne la longueur de c ( c tant un nom ou un symbole ) .

L'oprateur de concatnation || ou la fonction cat permettent de rassembler 2 noms ou symboles.

> length(nom_var);

> nom_var || a;

> cat(nom_var,a);

LE TYPE CHANE DE CARACTRES (string):

Les chanes de caractres, de type string , se notent entre guillemets " " : par exemple , "MAPLE " et "7 pour Linux et Windows" sont 2 chanes de caractres . L'oprateur de concatnation || permet de rassembler 2 chanes de caractres :

> ch:="MAPLE " || "7 pour Linux et Windows";

On peut aussi utiliser la fonction cat : > ch:=cat("MAPLE ","7 pour Linux et Windows");

Quelques fonctions utilisant les chanes de caractres: length ( chaine ) retourne la longueur de la chane de caractres chaine . substring ( chaine,a..b ) retourne la sous-chane constitue par les caractres de chaine situs entre les positions a et b . > length(ch);

> substring(ch,9..18); caractre: x. > x:=3: x+1,`x`+1,'x'+1; "x";

Exercice corrig 2:

Ecrire une fonction F qui n entier naturel non nul , associe le produit des n premiers nombres premiers. > F:=n->product(ithprime(k),k=1..n);

> F(5);

En effet, F(5) = 2.3.5.7.11 = 2310.

Travail dirig 2:

TD 2.1:
Ecrire une fonction F qui n entier naturel non nul , associe la somme des n premiers entiers naturels non nuls.

TD 2.2:
Soit l'expression expr dfinie par :

1 De quel type est cette expression ?

2 Dvelopper expr .

3 Ordonner expr suivant les puissances dcroissantes de x .

4 Substituer dans expr : x+1 x , y-2 y , z z .

TD 2.3:
1 Dfinir la fonction P qui x associe :

2 Factoriser

et calculer ses racines x .

3 Dvelopper

et regrouper ses termes suivant les puissances dcroissantes de a .

4 On prend dsormais

a) reprsenter graphiquement P pour x entre

et 1.

b) calculer l'image de

par P .

5 Calculer l'intgrale de P entre -1 et 1.

Programmation

Remarque importante: pour pouvoir entrer plusieurs lignes d'instructions Maple successives, sans excution la fin de chaque ligne, presser Shift+Entre la fin de chaque ligne. Puis, pour valider l'ensemble des lignes ainsi crites, presser Entre en plaant le curseur par exemple sur la dernire ligne crite.

LES STRUCTURES DE CONTRLE:

Structure de contrle if .. then: if condition1 then instruction 1 elif condition2 then instruction2 elif et else sont optionnels) elif condition3 then instruction3 ... else instructionN end if;

Effectue un test selon certaines conditions: elif signifie "autrement si" . La dernire instruction excuter doit tre prcde de else .

Exemple 1: rsolution de l'quation du premier degr . Modifiez les valeurs de a et de b , puis validez les lignes suivantes: > a:=7:b:=3: > if a<>0 then print(`Une solution : x `=-b/a) elif b=0 then print(`Tout x est solution`) else print(`Pas de solution`) end if;

Structure de contrle while .. do: while condition do ... end do; Excute une suite d'instructions, tant que la condition est vraie.

Exemple 2: calcul de la somme des 100 premiers entiers naturels > somme:=0:k:=-1: while k<100 do k:=k+1:somme:=somme+k end do: `somme `=somme;

Structure de contrle for .. to: for variable from initiale to finale by pas do ... end do; Excute une boucle pour une variable allant d'une valeur initiale une valeur finale, avec un pas donn.

from , by peuvent tre omises ou crites dans un ordre quelconque. Si l'on omet from , initiale vaut 1. Si l'on omet by , pas vaut 1.

Exemple 3: calcul de la somme des 100 premiers entiers naturels > somme:=0: for k from 0 to 100 do somme:=somme+k end do: `somme `=somme;

Exemple 4: calcul de la somme des entiers impairs infrieurs 100 Ici, on omet from donc la premire valeur de k est 1. La dernire valeur prise par k sera 99. > somme:=0: for k to 100 by 2 do somme:=somme+k end do: `somme `=somme;

for variable in expression do .. end do; Exemple 5: donner les nombres premiers de la liste [31,39,47,105] > for k in [31,39,47,105] do if isprime(k) then print(k,`est premier`) end if end do;

LES PROCDURES:

Un programme MAPLE peut tre organis en sous-programmes appeles procdures . Une procdure, de type procedure , est dfinie par le mot-cl proc et peut tre assigne un nom de variable. Pour dfinir une procdure intitule nom , on utilisera la syntaxe suivante:

nom := proc (paramtres_formels) global variables_globales; (la ligne global est optionnelle) local variables_locales; (la ligne local est optionnelle) description chane_de_description; (la ligne description est optionnelle) option nom_option; (la ligne option est optionnelle) . . . instructions . . . (corps de la procdure) end proc;

Exemple 6: La procdure intitule maxi calcule le plus grand de 2 entiers positifs. Elle comporte 2 paramtres formels u et v . Leur type peut tre omis, mais si on le veut le prciser,

bien noter la syntaxe u :: posint , v :: posint pour signifier que u et v sont de type posint . Elle ne comporte ni variables globales, ni variables locales, mais une chane de description de la procdure et une option de copyright. > maxi:=proc(u::posint,v::posint) description "calcule le plus grand de 2 entiers positifs"; option `Copyright (c) 2001 A.Le Stang`; if u<v then v else u end if; end proc;

> maxi(5,9);maxi(1.2,Pi);

Error, invalid input: maxi expects its 1st argument, u, to be of type posint, but received 1.2

Une variable locale est une variable qui n'est reconnue qu' l'intrieur de la procdure, contrairement une variable globale accessible en dehors de la procdure. Exemple 7: > messages:=proc() global message1; local message2; message1:="Hello, world!"; message2:="How are you?"; end proc;

> messages();

La valeur de la variable locale message2 n'a pas t reconnue, contrairement celle de la variable globale message1 .

Remarque importante: Un paramtre formel pass une procdure ne peut tre modifi l'intrieur de cette procdure

Exemple 8: Diviser un entier positif x par 2 tant qu'il est pair. > div:=proc(x::posint) while type(x,even) do x:=x/2 end do; end proc;

> div(48); Error, (in div) illegal use of a formal parameter La tentative d'affecter au paramtre formel x sa valeur divise par 2 provoque une erreur. On peut modifier la procdure de la manire suivante: > div:=proc(x::posint) local y; y:=x; while type(y,even) do y:=y/2 end do; y end proc;

> div(48);

On obtient en effet successivement : 48,24,12,6,3. > div(45);

return met fin la procdure en donnant un rsultat. next permet de passer la valeur suivante dans une itration. break permet de sortir de la structure de contr le en cours.

Exemple 9: On parcourt une liste de nombres. Au premier entier positif trouv, on sort de la procdure avec pour rsultat cet entier, sinon si ce nombre est ngatif, on sort de la boucle avec pour rsultat -1, sinon on passe au nombre suivant.

> liste:=proc(L::list(numeric)) local k; for k in L do print(`lecture de`,k); if type(k,nonnegint) then return k elif k<0 then break; else next; end if end do; return -1; end proc;

> liste([12.56,8.9,7,3.14]);

> liste([12.56,-8.9,7,3.14]);

> liste([12.56,8.9,7.1,3.14]);

Rcursivit: Une procdure qui fait rfrence elle mme dans sa dfinition est une procdure rcursive .

Exemple 10: factorielle de n > factorielle := proc(n::nonnegint) if n>0 then n*factorielle(n-1) else 1 end if; end proc;

> factorielle(12);

Fonction error: La fonction error permet de dfinir des messages d'erreur personnaliss. Exemple 11: racine carre de x > racine := proc (x) if x<0 then error "invalide x: %1", x else simplify(x^(1/2)) end if end proc;

> racine(144);

> racine(-144); Error, (in racine) invalide x: -144

LES MODULES:

Un module est une collection de procdures et de donnes. Un module, de type module , est dfini par le mot-cl module et peut tre assign un nom de variable. Pour dfinir un module intitul nom , on utilisera la syntaxe suivante: nom := module ()

global variables_globales; (la ligne global est optionnelle) local variables_locales; (la ligne local est optionnelle) export variables_locales_exportes; (la ligne export est optionnelle) description chane_de_description; (la ligne description est optionnelle) option nom_option; (la ligne option est optionnelle) . . . instructions . . . (corps du module) end module;

Contrairement au cas des procdures, le module ne peut avoir de paramtres formels . On retrouve les notions de variables globales et locales, comme pour les procdures, mais les modules peuvent exporter des variables locales (celles de la ligne export ), auxquelles on a accs de l'extrieur du module en utilisant la syntaxe suivante: nom :- var permet d'accder la variable locale exporte var du module nom . En utilisant la terminologie de la programmation oriente objet, les variables dclares dans la ligne local s'apparentent des membres privs du module, tandis que celles dclares dans la ligne export s'apparentent des membres publics du module.

Exemple 12: Anneau Z/4Z des entiers modulo 4. > Z4:=module() description "Arithmtique modulo 4"; export add,mult,opp; add := (x,y)-> (x+y) mod 4; mult := (x,y)-> (x*y) mod 4; opp := x-> (-x) mod 4; end module;

Le module comporte 3 variables locales exportes add , mult , opp . Vrifions que: (2+3) mod 4 = 1 , que (2*3) mod 4 = 2 et opp (1) = -1 mod 4 = 3 : > Z4:-add(2,3);

> Z4:-mult(2,3);

> Z4:-opp(1);

Exemple 13: Anneau Z/ n Z des entiers modulo n . On dsire modifier le programme prcdent pour effectuer de l'arithmtique modulo n ,

entier quelconque. avec Un module n'acceptant pas de paramtre formel, crivons une procdure Construire_Zn de paramtre formel n , rendant pour rsultat un module: > Construire_Zn:=proc(n::posint) module() description "Arithmtique modulo n"; export add,mult,opp; add := (x,y)-> (x+y) mod n; mult := (x,y)-> (x*y) mod n; opp := x-> (-x) mod n; end module; end proc;

> Z7:=Construire_Zn(7);

> Z7:-add(6,5);

> Z7:-mult(5,3);

> Z7:-opp(3);

On peut utiliser la structure de contrle use pour accder aux variables locales exportes du module nom sans avoir recours l'utilisation de :Exemple: (opp(3) mod 7) = (4 mod 7) = 4 ( (opp(3) mod 7)*5 ) mod 7 = (4*5) mod 7 =6 (2 + ( (opp(3) mod 7)*5 ) mod 7 ) = (2+6) mod 7 = 1 > use Z7 in add( 2, mult( opp(3), 5) ) end use;

La fonction member permet de savoir si une expression est membre d'un module: > member(mult,Z7) , member(prod,Z7);

Le constructeur Record: Le constructeur Record cre un enregistrement Maple. Un enregistrement, de type record , est dfini par les noms de ses champs (appels "slots" ou "fields" en anglais). Exemple 14: On veut crer un enregistrement pour modliser les nombres complexes. Un nombre complexe z est dfini par 2 champs: sa partie relle et sa partie imaginaire.

> z := Record( 're', 'im' );

On voit qu'un enregistrement est un module particulier, qui a l'option record .

On dfinit un nouveau type complexe associ et la fonction module d'un nombre complexe: > `type/complexe` := 'record( re, im )': Mon_module:=(z::complexe)->sqrt(z:-re^2+z:-im^2);

> z:-re:=1 : z:-im:=2 :Mon_module(z);

On peut aussi initialiser les valeurs des parties relle et imaginaire de la faon suivante: > z:= Record( 're' = 1, 'im' = 2 ):Mon_module(z);

LES LIBRAIRIES ET PACKAGES:

Pour obtenir le listing de certaines fonctions des librairies MAPLE, comme ici la fonction ithprime utiliser: > interface(verboseproc=2);print(ithprime);

Les packages regroupent des fonctions utiles dans des domaines particuliers. La fonction suivante appelle la page d'aide donnant les packages existants :

> ?index,package

La fonction with permet de charger toute ou partie d'un package choisi:

> with(student); #charge toutes les fonctions du package student

Chargement de la fonction binomial du package combinat :

> with(combinat,binomial);

Cette fonction retourne le nombre binomial( ).

)=

appel aussi C(

Exercice corrig 3:

Ex 3.1
Ecrire une procdure calculant le plus grand de 3 entiers naturels non nuls a , b , c . > max3:=proc(a::posint,b::posint,c::posint) local max2; max2:=proc(x::posint,y::posint) if x>y then x else y end if; end proc; max2(a,max2(b,c)); end proc;

> max3(5!,5^3,123);

max3 comporte une variable locale max2 laquelle est affecte une procdure calculant le plus grand de 2 entiers naturels non nuls.

Ex 3.2
1 crire un module pnt permettant de modliser un point du plan, dfini par ses coordonnes x , y . Ce module comportera des variables locales exportes rendant comme rsultat

l'abscisse et l'ordonne du point.

2 crire un module cercle permettant de modliser un cercle du plan, dfini par son centre et son rayon. Ce module comportera des variables locales exportes rendant comme rsultat le centre, le rayon, le diamtre, l'aire, et la circonfrence du cercle.

1 Dfinition de la procdure pnt rendant pour rsultat un module: > pnt:=proc(x,y) module() export abscisse,ordonnee; abscisse:=()->x; ordonnee:=()->y; end module end proc;

Dfinition d'un point A de coordonnes ( a , b ) : > A:=pnt(a,b);

> A:-abscisse(), A:-ordonnee();

2 Dfinition de la procdure cercle rendant pour rsultat un module: > cercle:=proc(c,r) module() export centre,rayon,diametre,aire,circonference; centre:=()->c; rayon:=()->r; diametre:=()->2*rayon(); aire:=()->Pi*r^2; circonference:=()->Pi*diametre(); end module end proc;

Dfinition d'un cercle C de centre A de rayon R : > C:=cercle(A,R);

> C:-centre(), C:-rayon(), C:-diametre(), C:-aire(), C:-circonference();

Utilisation des deux structures pour obtenir les coordonnes du centre de C : > C:-centre():-abscisse(), C:-centre():-ordonnee();

Travail dirig 3:

TD 3.1:
crire une procdure second_degr(a,b,c) qui rsout l'quation du second degr

coefficients rels:

en distinguant 3 cas selon le signe du discriminant.

TD 3.2:
crire une procdure somme(n) calculant rcursivement la somme des entiers de 0 n , pour

n entier naturel donn.

TD 3.3:
crire une procdure renverser(n) , qui , tant donn un entier naturel n ne comportant pas de 0 dans son criture dcimale , rend pour rsultat l'criture renverse de cet entier . Prvoir un message d'erreur si l'entier comporte le chiffre 0.

Exemple: > renverser(122564);

> renverser(120325); Error, (in renverser) le chiffre 0 n'est pas autoris.

TD 3.4:
crire un module segment permettant de modliser un segment du plan, dfini par ses deux points extrmits.Ce module comportera des variables locales exportes rendant comme rsultat la premire et la seconde extrmit du segment, sa longueur, et son milieu. On pourra utiliser le module dfini par la procdure pnt de l'exercice corrig 3.2 .

Squences, listes, ensembles, tables et tableaux

LES SQUENCES:
Une squence , de type exprseq , est une suite d'lments spars par une virgule . On accde chaque lment par son rang , mais l'affectation est interdite :

> restart: s:=a,b,-1,2*p-q,r;

> s[4];s[2..5];s[3]:=0;

Error, cannot assign to an expression sequence NULL dsigne la squence vide: > v:=NULL;

Pour rpter un lment , utiliser l'oprateur dollar $ : > t:=a$2,y$5;

Pour concatner 2 squences ,utiliser l'oprateur virgule , > u:=s,t;

op(expr) retourne la squence forme des oprandes de l'expression expr :

> op(a-y*(a+y+z)+3*z);

La fonction seq permet de crer une squence pour un indice i variant de a b avec un pas de 1 : syntaxe seq(expr,i=a..b) , ou pour un indice dcrivant les oprandes d'une expression e : syntaxe seq(expr,i=e) :

> seq(i^3,i=-1/2..2);

> e:=a-y*(a+y+z)+3*z:op(e); seq(mu+i,i=e);

> seq(seq(a||i||j,j=1..3),i=1..3);

LES LISTES:

Une liste , de type list , est obtenue en plaant une squence entre les crochets [ et ] . La liste vide se note [] .

> s:=a$2,b$3,alpha,beta;L:=[s];

On accde chaque lment d'une liste par son rang , l'affectation est autorise: > L[6];L[2..5];L[3]:=delta;

op transforme une liste en squence , nops donne le nombre d'lments d'une liste . Les fonctions op et nops ne peuvent agir sur une squence s : faire ops([s]) et nops([s])

> op(L);

> nops(L);

Pour modifier une liste, on peut aussi utiliser subs ou subsop : > L:=subs(b=b1,L);

> L:=subsop(3=gamma,L);

La fonction boolenne member permet de savoir si une expression est membre d'une liste: > member(gamma,L), member(epsilon,L);

LES ENSEMBLES:

Un ensemble , de type set , est obtenu en plaant une squence entre les accolades { et }. Les lments sont rangs par adresse , donc l'ordre initial n'est pas ncessairement conserv et les lments en

double sont supprims. L'ensemble vide se note {} .

> s:=a$2,b$3,alpha,beta;e:={s};

On accde chaque lment d'un ensemble par son rang , mais l'affectation est interdite :

> e[2];e[2..3];e[3]:=delta;

Error, cannot assign to a set op transforme un ensemble en squence , nops donne le nombre d'lments d'un ensemble .

> op(e);nops(e);

Pour modifier un ensemble , l'affectation tant interdite , utiliser sub s ou subsop :

> e:=subs(b=b1,e);

> e:=subsop(3=delta,e);

La fonction boolenne member permet de savoir si une expression est membre d'un ensemble:

> member(delta,e), member(epsilon,e);

Convertir un ensemble en somme, en produit, en liste, ou convertir une liste en ensemble avec convert : > convert(e,`+`);convert(e,`*`); e:=convert(e,list);e:=convert(e,set);

Oprations sur les ensembles: union (union) , intersect (intersection) , minus (diffrence) . la fonction boolenne a indique si a est un sous-ensemble de b .

> e:={alpha,beta,gamma,delta}:f:={beta,delta,epsilon,phi,lambda}: u:=e union f;i:=e intersect f;m:=f minus e;

> i subset e, i subset m;

QUELQUES OUTILS DU PACKAGE COMBINAT:

> with(combinat,choose): (appel de l'outil choose , qui gnre les sous-listes ordonnes d'une liste donne)

> choose([a,b,c]);

Gnration de toutes les sous-listes de longueur 2 ordonnes d'une liste de longueur 3: > choose([a,b,c],2);

choose ( n , p ) avec n , p entiers , gnre toutes les sous-listes de longueur p ordonnes de [1,2,.., n ] > choose(4,3);

> with(combinat,permute): (appel de l'outil permute , qui gnre les listes de permutation d'une liste donne) > permute([a,b,c]);

Gnration de toutes les sous-listes de permutation de longueur 2 de [a,b,c] : > permute([a,b,c],2);

permute ( n ) , avec n entier , donne les listes de permutation de [1,2,..., n ] > permute(3);

permute ( n , p ) , avec n , p entiers , donne les sous-listes de permutation de de longueur p de [1,2,..., n ] > permute(3,2);

> restart;

LES TABLES:

Une table est une structure indexe dont les indices (ou index ) peuvent tre de n'importe quel type. La fonction table permet de crer une table :

Cration d'une table vide: > v:=table();

Cration d'une table T avec une liste de valeurs: > T:=table([valeur1,valeur2]);

Cration d'une table U avec liste d'index (ici . *) et de valeurs: > U:=table([``=valeur1,`.`=valeur2,`*`=valeur3]);

Pour afficher le contenu d'une table , utiliser print ou eval > print(T),eval(U);

On peut modifier , crer un nouvel lment , ou supprimer un lment par affectation : > T[a]:=valeur3:U[~]:=valeur4:print(T),eval(U);

Une table peut tre directement cre par assignation : > V[a]:=1:V[b]:=2:V[c]:=3:eval(V);

Fonctions agissant sur des tables:

> op(op(V));

> indices(V);

> entries(V);

La fonction map permet d'appliquer une fonction sur les valeurs d'une table: > V:=map(sqrt,V);

La fonction copy permet d'effectuer une copie d'une table: > W:=copy(V);

LES TABLEAUX:
Un tableau est une structure indexe, de type array , de plusieurs dimensions, dont les indices sont des entiers appartenant un intervalle a..b (de type range ) .

La fonction array permet de crer un tableau : Des fonctions analogues celles utilises pour les tables existent :

Cration d'un tableau une dimension: > T:=array(1..3);

Cration d'un tableau une dimension avec initialisation partielle: > U:=array(1..5,[a,b,c]);

Cration d'un tableau 2 dimensions avec initialisation complte: > V:=array([[a,b,c],[d,e,f]]);

Cration d'un tableau rectangulaire d'entiers par affectation l'aide de boucles imbriques: > T:=array(1..2,1..3): for i to 2 do for j to 3 do T[i,j]:=(i-1)*3+j; end do; end do: print(T);

> op(op(T));

> indices(T);

> entries(T);

> map(x->x^2,T);

Conversion d'un tableau en liste (si la dimension est 1) ou en liste de listes (si la dimension est >1): > convert(U,list);convert(T,listlist);

Conversion d'un tableau de dimension quelconque en ensemble: > convert(T,set);

> T:=convert([a,b,c,d],array);

> U:=copy(T);

Exercice corrig 4:

Ex 4.1: Ecrire une procdure qui inverse les lments d'une liste .

> restart; listeinverse:= proc(L::list) local i; [seq(op(nops(L)-i,L),i=0..nops(L)-1)]; end proc: > listeinverse([a,b,c,d,e,f]);

Ex 4.2: Crer une matrice de Vandermonde d'ordre n . Exemple , pour

> VDM:=proc(n::posint) local i,j,a,V; a:=array(1..n):V:=array(1..n,1..n): for i to n do for j to n do V[i,j]:=a[i]^(j-1) end do end do;

print(V); end proc:

> VDM(4);

Travail dirig 4:

TD 4.1:
1 Un tableau T n lignes et p colonnes tant donn , crire une procdure ligne( T , p , i ) qui calcule la somme des lments de T situs en ligne i .

2 Un tableau T n lignes et p colonnes tant donn , crire une procdure colonne( T , n , j ) qui calcule la somme des lments de T situs en colonne j .

3 Un tableau carr T n lignes et n colonnes tant donn , crire une procdure diagonale1( T , n ) qui calcule la somme des lments de T situs sur la premire diagonale.

4 Un tableau carr T n lignes et n colonnes tant donn , crire une procdure diagonale2( T , n ) qui calcule la somme des lments de T situs sur la seconde diagonale.

5 Un tableau T carr n lignes et n colonnes est dit magique si la somme des lments de n'importe quelle ligne , de n'importe quelle colonne , et de n'importe quelle diagonale est la mme . Utiliser les procdures prcdentes pour crire une fonction boolenne magique( T , n ) rendant la valeur true si T est magique, et false sinon .

Exemples:

> magique(T,3);

> magique(U,3);

TD 4.2:
Ecrire la procdure intitule coder(st::string) qui convertit la chane de caractres st (crite en lettres minuscules) en un nombre.

On code :

, etc ... ,

Exemple: si

alors

6,

> coder("maple");

Aide: pour crire cette procdure , on construira un alphabet puis une table T de conversion

et on utilisera au besoin les fonctions de Maple suivantes:

length(st) qui donne la longueur de la chane de caractres st . substring(st,m..n) qui extrait de st la sous-chane des caractres situs entre les positions m et n .

Polynmes et fractions rationnelles

POLYNMES:

> restart; Un polynme a le type polynom , et peut avoir plusieurs variables :

> P:=-7*x+5*x^2+75*x^3;Q:=x*(2*x-3*y)^2*(x-y);

> type(P,polynom),whattype(P),whattype(Q);

nops(P) donne le nombre de termes selon la forme , dveloppe ou factorise , de P :

> nops(P),nops(Q);

op(P) donne sous forme de squence les termes ou les facteurs de P :

> op(P);op(Q);

Coefficients , degr , valuation: Les 2 syntaxes sont quivalentes: > coeff(P,x^3);

> coeff(P,x,3);

Obtenir tous les coefficients de P (valable lorsque P est sous forme dveloppe) > coeffs(P);coeffs(Q);

Error, invalid arguments to coeffs

> coeffs(expand(Q));

Coefficient du terme de plus haut (de plus bas) degr: > lcoeff(P),tcoeff(P);

> lcoeff(Q,y),tcoeff(Q,y);

Degr et valuation: > degree(P),degree(Q,x),degree(Q,y);

> ldegree(P),ldegree(Q,x),ldegree(Q,y);

FONCTIONS SUR LES POLYNMES:

quo(P,Q,x,'r') : quotient de la division euclidienne de P par Q , variable x , 'r' (optionnel) variable non assigne recevant le reste . > quo(x^5-1,x^2+x+1,x, 'r');r;

rem(P,Q,x,'q') : reste de la division euclidienne de P par Q , variable x , 'q' (optionnel) variable non assigne recevant le quotient . > rem(x^5-1,x^2+x+1,x, 'q');q;

Discriminant: > discrim(x^3+a*x+b,x);

Evaluer, ordonner, transformer un polynme:

> subs(x=1+2*I,y=I,Q);

Ordonner Q selon les puissances dcroissantes de y: > sort(expand(Q),y);

Dvelopper: > expand((x-3*y+a)*(1-a^2+x+y));

Regrouper les monmes de l'expression en l'indtermine a : > collect((x-3*y+a)*(1-a^2+x+y),a);

Mettre P sous la forme de Hrner: > P;H:=convert(P,horner);

> with(codegen,cost);

Ce qui est moins coteux en oprations:

> cost(P),cost(H);

Factoriser sur le corps Q des rationnels > factor(x^3+x^2+x+1);

Normaliser: > normal((4*x-3)^2+x-1);

RACINES ET FACTORISATION DES POLYNMES:

Valeur approches des zros rels ou complexes avec fsolve : > P:=x^3+x+1:fsolve(P);

> fsolve(P,x,complex);

Localiser les zros rels dans un intervalle de longueur voulue , ici 10^-3 , avec realroot : > realroot(P,0.001);

Calcul des zros avec solve(P) : > solve(x^4+1);

Par la fonction factor , on peut factoriser sur Q ou sur le corps induit par les coefficients : > factor(x^4-1);

> factor(x^3-I*x-I+1);

Pour obtenir la factorisation complte:

factor (P,{ nombres algbriques

,...,

}) autorise Maple factoriser P sur un corps contenant les ,...,

> factor(x^4-1,I);

> factor(x^3-x^2+2*x-2);

> factor(x^3-x^2+2*x-2,{I,sqrt(2)});

On peut aussi utiliser Split , qui donne une factorisation complte : > with(PolynomialTools,Split):P:=Split(x^4-1,x);

RootOf dsigne ici toute racine du polynme _Z+1, on peut simplifier l'criture en utilisant alias : > alias(alpha=RootOf(_Z^2+1)):P;

Pour calculer les valeurs possibles de alpha : > allvalues(RootOf(_Z^2+1));

La fonction roots donne les zros avec leur ordre de multiplicit:

n'a aucun zro sur Q: > roots(x^2+1);

On calcule ses zros sur le corps Q(I) induit par les coefficients: > roots(x^2+1,I);

FRACTIONS RATIONNELLES : de type ratpoly

> F:=(2*x^2+x-3)^2/(x^4-1);numer(F),denom(F);

> simplify(F);

Factorisation sur IR ou C: factorisation sur IR: > factor(F);

factorisation sur C: > factor(F,I);

retour la forme normale: > normal(%,expanded);

Dcomposition en lments simples sur IR ou C:

convert(F,parfrac, x ) dcompose en lments simples la fraction rationnelle F en l'indtermine x . convert(F,parfrac, x, { ,..., } ) autorise Maple dcomposer sur un ,...,

corps contenant les nombres algbriques

Dcomposition sur IR: > convert(F,parfrac,x);

Dcomposition sur C: > convert(F,parfrac,x,I);

Exercice corrig 5:

Ex 5.1: Dcomposer en lments simples sur

> F:=1/(x^4+1);

> convert(F,parfrac,x);

F n'est pas dcompose. Voyons les racines du dnominateur: > {solve(denom(F))};

On obtient la dcomposition sur IR par: > convert(F,parfrac,x,sqrt(2));

On obtient la dcomposition sur C par: > convert(F,parfrac,x,{I,sqrt(2)});

Ex 5.2: Soit

Montrer que les zros du polynme driv P' sont 3 termes conscutifs d'une suite arithmtique.

> P:=X*(X-1)*(X-2)*(X-3):dP:=diff(expand(P),X);

> zeros:=[solve(dP)];

On trie les lments de la liste par ordre croissant , sort ne fonctionnant pas ici : > tri:=proc(L::list) local x,y,Z; Z:=L; for x to nops(Z)-1 do for y from x+1 to nops(Z) do if evalf(Z[y]-Z[x])<0 then Z:=subsop(x=Z[y],y=Z[x],Z) end if; end do; end do; Z; end proc: > zeros:=tri(zeros);

On calcule les carts entre 2 termes conscutifs , la raison est

> for k to nops(zeros)-1 do print(zeros[k+1]-zeros[k]) end do;

Travail dirig 5:

TD 5.1:

Soit la fraction rationnelle F dfinie par :

1 La dcomposition de F en lments simples dans R s'crit:

On rduit les fractions composant G au mme dnominateur et on identifie les numrateurs de F et de G . En dduire les valeurs de a,b,c,d,e,f,g .

2 Calculer la dcomposition de F en lments simples dans C

TD 5.2:
Soit P un polynme de K[ x ] , s'crivant sous la forme :

L'algorithme de Hrner permet d'crire P( x ) sous la forme :

Exemple:

Ecrire une procdure PolyHorner(P , x ) permettant d'crire P( x ) sous cette forme , P tant un polynme donn de K[ x ] , x tant le nom de la variable .

NB: il est interdit d'utiliser la fonction horner de MAPLE .

Grace la fonction cost , valuer le cot en oprations ncessaires pour valuer Q et PolyHorner(Q, x ) , Q tant le polynme donn en exemple.

Graphisme avec Maple

GRAPHIQUES EN DIMENSION 2:

La fonction smartplot constitue la faon la plus simple de reprsenter une ou plusieurs fonctions : Par dfaut , le range est -10..10. > smartplot(cos(2*x)+sin(x),x);

Pour reprsenter une ou plusieurs fonctions, utiliser plot(f , h , v) ou plot(f, h, v,...) o f : fonction(s) reprsente(s) , h et v : intervalle horizontal et vertical (optionnels). La syntaxe la plus simple est plot(f) ou plot(f(x),x=a..b) :

> f:=x->cos(2*x)+sin(x):plot(f(x),x=-2*Pi..2*Pi);

Les arguments restants sont des options que l'on peut spcifier par des quations de la forme option = valeur.

scaling = CONSTRAINED (repre orthonormal) ou UNCONSTRAINED (repre non orthonormal) .Par dfaut : UNCONSTRAINED.

axes = Spcifie le type d'axes : FRAMED , BOXED, NORMAL , et NONE.

coords = polar Indique une courbe paramtrique en coordonnes polaires.

numpoints = n Spcifie le nombre minimum de points tre gnrs (dfaut n = 49 ).

resolution = n Spcifie la rsolution horizontale en pixels (dfaut n = 200 ).

color = n Spcifie la couleur des courbes tracer .

xtickmarks = n ytickmarks = n Spcifie le nombre de graduations sur l'axe des x ou des y .

style = s Spcifie le style du trac : par dfaut LINE POINT (trac point par point) , LINE (points relis par des segments) PATCH (style pour les polygones) , SPLINE (points relis par une courbe spline)

discont = s Mettre s la valeur boolenne true pour des fonctions discontinues

title = t Spcifie le titre pour le graphique ( t de type string ).

thickness = n Spcifie l'paisseur du trait , ( n = 0, 1, 2 , ou 3 , dfaut : 0 ).

linestyle = n Spcifie le motif des lignes traces (lignes pleines : 0 et 1, d'autres valeurs plus grandes donnent des pointills par exemple).

symbol = s Spcifie le symbole de reprsentation d'un point : BOX, CROSS, CIRCLEPOINT, et DIAMOND.

font = liste Polices des caractres affichs . liste est une liste [famille, style, taille] , famille : TIMES, COURIER, HELVETICA, SYMBOL. Pour TIMES, le style est ROMAN, BOLD, ITALIC ou BOLDITALIC. Pour HELVETICA et COURIER style omis ou BOLD, OBLIQUE, ou BOLDOBLIQUE. Pour SYMBOL , pas de style .

titlefont = liste , axesfont = liste , labelfont = l iste Polices des caractres affichs pour le titre,les graduations des axes,les lgendes des axes (pour liste , voir font = liste).

view=[xmin .. xmax,ymin .. ymax] Spcifie la zone de dessin reprsenter l'cran .

Reprsenter un ensemble de plusieurs courbes:

> plot({sin(x),x, x-x^3/6}, x=-2..2,thickness=2,scaling=CONSTRAINED);

Intervalle borne infinie: > plot(sin(x)/x, x=0..infinity);

Reprsenter des points: on donne la liste des coordonnes, abscisse puis ordonne.

> plot([[0,0],[1,1],[2,1],[2,0],[1,-1],[0,0]], x=0..2, style=point);

Reprsenter des lignes brises: mme principe que pour les points, en enlevant style=point . > plot([[0,0],[1,1],[2,1],[2,0],[1,-1],[0,0]], x=0..2);

Courbe en coordonnes polaires: plot([r(t),theta(t),t=a..b],coords=polar,...) > plot([sin(4*t),t,t=2*Pi..2*Pi],coords=polar,thickness=2,font=[HELVETICA,BOLD,8],title="R=sin 4t",color=red);

On obtient le mme rsultat en utilisant la fonction polarplot du package plots : > with(plots):polarplot([sin(4*t),t,t=2*Pi..2*Pi],thickness=2,font=[HELVETICA,BOLD,8],title="R=sin 4t",color=red);

Courbe paramtre: plot([x(t),y(t),t=a..b],...)

> plot([cos(2*t)+2*cos(t),sin(2*t),t=0..2*Pi],color=blue);

OUTILS 2D DU PACKAGE plots:

Le package plots fournit d'autres outils graphiques pour la dimension 2 :

> with(plots);

Citons , entre autres :

La fonction animate , qui permet de crer des animations dans une fentre dont la barre d'outils comporte des touches identiques celles d'un lecteur de cassettes : Exemple: famille de paraboles dpendant de m > animate(m*x^2,x=-3..3,m=-10..10);

Tracer des courbes dfinies implicitement sous la forme f(x,y)=0 avec implicitplot > implicitplot(x^3+x-y^2+1=0,x=-10..10,y=-10..10);

Visualiser un champ de vecteurs avec fieldplot , ( arrows = LINE,SLIM,THIN ou THICK) > fieldplot([x*x-y*y,2*x+y^3],x=-1..1,y=-1..1,arrows=SLIM);

gradplot permet de visualiser un champ de gradients .

logplot , loglogplot donnent une graduation logarithmique sur l'axe des y ou les 2 axes

odeplot permet de tracer les courbes intgrales d'une quation diffrentielle.

textplot permet d'crire sur un dessin .

densityplot et contourplot permettent de tracer respectivement des graphes de densit ou des courbes de niveau.

display permet de reprsenter plusieurs objets graphiques de nature ventuellement diffrentes

sur un mme graphique. L'option insequence=true permet de le transformer en animation.

Exemple: trac du cercle c de centre O de rayon 1, de la droite d:

, de l'ellipse e

d'quation

,dans un mme repre orthonormal.

> c:=plot([cos(t),sin(t),t=0..2*Pi],color=blue): d:=plot(x,x=-2..2,color=black): e:=implicitplot(x^2/4+y^2-1,x=-2..2,y=-1..1): display({c,d,e});

GRAPHIQUES EN DIMENSION 3:

La fonction smartplot3d constitue la faon la plus simple de reprsenter une ou plusieurs surfaces : Par dfaut, le range est [-5..5,-5..5]. > smartplot3d(exp(-(x^2+y^2)));

plot3d(f(x,y),x=a..b,y=c..d,...) ou plot3d(f,a..b,c..d,...) permettent de tracer une surface. > f:=(x,y)->exp(-(x^2+y^2)):plot3d(f,-1..1,-1..1,axes=BOXED,orientation=[45,60],numpoints =1000,color=blue);

Comme pour la dimension 2 , on retrouve les options axes , scaling , tickmarks , title , view , numpoints (par dfaut 625) et :

labels = [`x`,`y`,`z`]

orientation = [theta,phi] prcise les angles de vision en coordonnes sphriques .

projection = r , avec r rel de [0,1] . FISHEYE=0 , NORMAL=0.5 , ORTHOGONAL=1.

grid = [m,n] dtermine la grille rectangulaire m x n (par dfaut 25 x 25)

style = s ( o s parmi POINT,HIDDEN,PATCH,WIREFRAME,CONTOUR, PATCHNOGRID,PATCHNOCONTOUR,LINE . Par dfaut : HIDDEN )

ambientlight = [r,v,b] fixe l'intensit des couleurs rouge,vert,bleu (valeurs dans [0,1]) .

colour = c fixe la couleur c .

light = [phi,theta,r,v,b] fixe l'clairage de la surface selon les angles phi,theta en coordonnes sphriques avec les couleurs r,v,b .

shading = s ( o s parmi XYZ,XY,Z,ZGREYSCALE,ZHUE,NONE ) pour prciser la faon

dont la surface est colorie .

coords = c ( ou c parmi cartesian,spherical,cylindrical )

Les surfaces peuvent tre paramtres :

> plot3d([(4+sin(t))*cos(u),(4+sin(t))*sin(u),2*sin(t)],t=0..2*Pi,u=0..2*Pi,axes =framed,shading=ZHUE,ambientlight =[0.85,0.75,0.1]);

> plot3d(z,theta=0..2*Pi,z=0..2,coords=cylindrical,title="Un cne");

> plot3d(5,theta=0..2*Pi,phi=0..Pi,axes=BOXED,coords=spherical,scaling=constr ained,color=blue,title="Une sphre");

OUTILS 3D DU PACKAGE plots:

Le package plots fournit d'autres outils graphiques pour la dimension 3 :

> with(plots); Warning, the name changecoords has been redefined

Citons entre autres :

animate3d , pour crer des animations graphiques .

fieldplot3d , gradplot3d pour visualiser un champ de vecteurs ou de gradients .

display3d permet de reprsenter plusieurs objets graphiques de nature ventuellement diffrentes sur un mme graphique. L'option insequence=true permet de le transformer en animation.

polyhedraplot pour reprsenter des polydres : polyscale = n (taille du polydre) polytype parmi tetrahedron,octahedron,hexahedron,dodecahedron,icosahedron.

> polyhedraplot([0,0,0],polyscale=10,polytype = icosahedron,scaling=CONSTRAINED,axes=BOXED,title="Icosadre");

Trac de surfaces implicites ou de courbes gauches: > implicitplot3d(x^2+y^2/4+z^2/4-1=0,x=-1..1,y=-2..2,z=2..2,title="ellipsoide",color=red);

> spacecurve([cos(t),sin(t),t],t=4*Pi..4*Pi,numpoints=500,axes=FRAMED,title="Courbe gauche : une hlice",color=black);

Exercice corrig 6:

Soit S la surface d'quation cartsienne une nappe)

(hyperboloide de rvolution

1 Reprsenter S partir de son quation implicite , pour z variant entre -1 et 1.

2 Dfinir S partir d'une reprsentation paramtrique et reprsenter alors S .

> with(plots):implicitplot3d(x^2+y^2-z^2-1,x=-sqrt(2)..sqrt(2),y=sqrt(2)..sqrt(2),z=-1..1,color=blue);

> S:=[cosh(phi)*cos(theta),cosh(phi)*sin(theta),sin(phi)]:plot3d(S,phi=arcsinh(1)..arcsinh(1),theta=0..2*Pi,color=blue);

Travail dirig 6:

TD 6.1:
crire une procdure polygone_regulier ( n:: posint) permettant de reprsenter un polygne rgulier n cts, de centre (0,0) et de rayon 1: > polygone_regulier(8);

TD 6.2:
1 Paramtrer en coordonnes sphriques une sphre de centre (x,y,z) de rayon R en crant une fonction sphere des 4 variables x,y,z,R .

2 Reprsenter sur un mme graphique les sphres (3,0,0) , (0,3,0) et (0,0,0) et de rayons respectifs 2,2,1.

de centres respectifs

Maple en analyse
FONCTIONS NUMRIQUES:

Domaine de dfinition: la fonction singular permet de dterminer les singularits de certaines fonctions:

> restart; singular(tan(x));

Continuit: la fonction iscont permet de dterminer la continuit de certaines fonctions. closed signifie que l'intervalle est ferm.MAPLE travaille par dfaut sur des intervalles ouverts.

> iscont(tan(x),x=-Pi/2..Pi/2,closed);

> iscont(tan(x),x=-Pi/2..Pi/2);

Image d'une runion d'intervalles ferms , avec la fonction evalr : > evalr((x->x^2)(INTERVAL(-1..-0.5)));

Extrema d'une fonction , avec les fonctions minimize et maximize : > minimize(x^2+x-3),maximize(-x^4+x^2+1);

Fonctions dfinies par intervalles: piecewise permet de dfinir une fonction partir de conditions sur diffrents intervalles: piecewise (cond1,f1, cond2,f2, ..., condN,fN, f_autrement) > f:=piecewise(x<0,exp(x),x<=4,x/4+1,2);

> plot(f(x),x=-4..8);

Limites: avec la fonction limit(expr, x=a , option) option = left , right .

> limit(sin(x)/x,x=0);

> limit(1/x^3,x=0);

Utilisation de la forme inerte Limit : > Limit(1/x^3,x=0,right) = limit(1/x^3,x=0,right);

Etude locale: avec taylor(expr , x=a , n) pour les dveloppements limits ou de Taylor, series(expr , x=a , n) ou asympt(expr , x , n) pour des dveloppements asymptotiques plus gnraux. L'ordre n est facultatif et vaut 6 par dfaut .

> taylor(sin(x),x); # a=0 par dfaut

> taylor(x^2/(x^2+1),x=infinity,10);

> series(exp(x)/x,x,9); # a=0 par dfaut

> asympt(ln(x+1/x),x,7); # toujours en plus l'infini

> asympt(Sum(1/k,k=1..n)-ln(n),n,10); # la constante d'Euler gamma

> evalf(gamma);

leadterm donne le terme principal d'une srie:

> series(leadterm(sin(x^3)/(2*x)),x=0);

Conversion en polynme de Taylor: > P:=convert(taylor(exp(x),x=0,5),polynom);

Drivation: Pour driver une fonction , utiliser diff(expr,v1,v2,...,vn) qui calcule la drive partielle de expr par rapport aux variables v1,v2,...,vn .

> Diff(x/(x^2+y^2),x,y)=diff(x/(x^2+y^2),x,y); # quivaut Diff(x/(x^2+y^2),x,y): % = value(%);

Noter l'absence de parenthses dans l'criture du premier membre . On peut utiliser l'oprateur $ pour viter de rpter plusieurs fois une variable :

> Diff(x/(x^2+y^2),x$2,y) : % = value(%);

Oprateur diffrentiel D: D( f ) retourne la fonction drive premire de f Fonctions drives premire et seconde: > D(sin),(D@@2)(sin);

> D(x->x*sin(x)-x);

> f:=(x,y,z)->x^2-3*x*y*z+z^4;

fonction drive par rapport x,y , et z respectivement : > D[1](f);D[2](f);D[3](f);

D[i,j](f) quivaut D[i](D[j](f)) : > D[1,2](f);

SUITES ET SRIES:

Suites dfinies par des sommes ou des produits:

> Sum(k^2,k=1..n) : % = factor(value(%));

> Product(k/(k+1),k=1..n) : % = simplify(value(%));

Dveloppement asymptotique de la somme partielle d'une srie: > series(sum(1/k^2,k=1..n),n=infinity);

Suites rcurrentes:

Type

Exemple:

, calcul de

, pour

,..,15.

> f:=x->cos(x):n:=15:u[0]:=-1: for k to n do u[k]:=evalf(f(u[k-1])) end do:

On peut reprsenter graphiquement la convergence de la suite en construisant une liste T forme des points (u(0),0) , (u(0),u(1)) , (u(1),u(1)) , (u(1),u(2)) , etc...

> T:=array(1..4*n,[u[0],0,u[0],f(u[0])]): for k from 2 to 2*n-1 do T[2*k+1]:=T[2*k]: if is(k,odd) then T[2*(k+1)]:=evalf(f(T[2*k+1])) else T[2*(k+1)]:=evalf(T[2*k+1]) end if end do: T:=convert(T,list):U:=NULL: for k to nops(T)-1 by 2 do U:=U,[T[k],T[k+1]] end do: U:=plot([U],color=blue):G:=plot({f(x),x},x=1.3..1.3,scaling=constrained):plots[display]({G,U},title="point fixe du cosinus",view=[-1.3..1.3,-1.3..1.3]);

Type

Exemple:

> u[0]:=1:v[0]:=4:n:=15: for k to n do u[k]:=evalf(sqrt(u[k-1]*v[k-1])):v[k]:=(u[k-1]+v[k-1])/2 end do:

Type

Exemple:

> u[0]:=0:u[1]:=4:n:=15: for k from 2 to n do u[k]:=evalf(sqrt(u[k-1]+u[k-2])) end do:

Rsolution de rcurrences , avec la fonction rsolve .

Une suite arithmtique de raison -3:

> restart:rsolve(w(n+1) = w(n)-3,w);

Une suite gomtrique avec condition initiale: > rsolve({w(n+1)=w(n)/3,w(0)=-7},w);

La suite de Fibonacci: > rsolve({fib(n+2)=fib(n+1)+fib(n),fib(0)=0,fib(1)=1},fib);

Sries numriques:

Somme d'une srie de Riemann convergente: > sum(1/k^2,k=1..infinity);

La srie harmonique est divergente: > sum(1/k,k=1..infinity);

Calcul de la somme d'une srie de fonctions > Sum(sin(x)^k,k=1..infinity)=sum(sin(x)^k,k=1..infinity);

Le package powseries contient des fonctions mettant en jeu les sries entires: Consulter les pages d'aide de powseries pour plus de prcision. > with(powseries);

> sh := evalpow( sinh(x) ): tpsform(sh, x, 9);

INTGRATION:

Le calcul des primitives et des intgrales se fait avec la fonction int . Syntaxes: int(expr , x) et int(expr, x=a..b) .

> Int(x/(x^4+1),x)=int(x/(x^4+1),x); # quivaut Int(x/(x^4+1),x) : % = value(%);

> Int(x/(x^4+1),x=0..1) : % = value(%);

Intgrale gnralise convergente: > Int(x/(x^4+1),x=0..infinity) : % = value(%);

Intgrale gnralise divergente: > Int(exp(x)/x,x=1..infinity) : % = value(%);

Le package inttrans contient quelques outils pour la transformation d'intgrales. Consulter les pages d'aide de inttrans pour plus de prcision.

> with(inttrans);

La transforme de Laplace de f est dfinie par > laplace(sin(omega*t), t, s);

Quelques outils du package student :

> with(student);

Changement de variables dans les intgrales: changevar(eq , intgrale , u) eq est l'quation du changement de variable de la forme f(x)=g(u) , intgrale est l'intgrale et u la nouvelle variable d'intgration :

> J:=Int(t/((t^2+1)*sqrt(1-t^4)),t=0..1);

> changevar(t^2=u,J,u):% = value(%);

Intgration par parties , avec la fonction intparts(intgrale,u) , u est le facteur driver.

> J:=Int(x^2*arccos(x),x):intparts(J,arccos(x));

> J:=value(%);

METHODES D'APPROXIMATION D'INTEGRALES:

METHODE DES RECTANGLES: On dcoupe [a,b] en n intervalles de mme longueur extrmit gauche : reprsentation avec leftbox(expr,x=a..b,n) , calcul avec leftsum(expr,x=a..b,n)

extrmit droite : reprsentation avec rightbox(expr,x=a..b,n) , calcul avec rightsum(expr,x=a..b,n)

point mdian : reprsentation avec middlebox(expr,x=a..b,n) , calcul avec middlesum(expr,x=a..b,n)

METHODE DES TRAPEZES: calcul avec trapezoid(expr,x=a..b,n)

METHODE DE SIMPSON: calcul avec simpson(expr,x=a..b,n) , avec n pair.

Exemple: avec f: > middlebox(exp(-x^2),x=-1..1,20);middlesum(exp(-x^2),x=1..1,20);evalf(%);

> evalf(trapezoid(exp(-x^2),x=-1..1,20));

> evalf(simpson(exp(-x^2),x=-1..1,20));

Calcul d'intgrales doubles ou triples:

> Doubleint(x^3*y-x^2-y*x,x=-a..a,y=-b..b):%=value(%);

> Tripleint(x*y*z*sin(x+y+z),x=0..Pi,y=-Pi..Pi,z=0..Pi):%=value(%);

QUATIONS ET SYSTMES DIFFRENTIELS:

Equations du premier ordre: MAPLE sait rsoudre directement les quations de type classique - linaire - avec facteur intgrant - sparable - homogne - rsolue en x - de Bernoulli de Clairaut - de Riccati .

quation y ' + 3 y = > restart:eq:=diff(y(x),x)+3*y(x)=exp(-x):dsolve(eq,y(x));

_C1 dsigne une constante relle arbitraire.

La mme avec la condition initiale > dsolve({eq,y(0)=1.5},y(x));

Les solutions y(x) ne sont pas directement utilisables : en assignant la solution y(x) on peut utiliser le rsultat , par exemple pour reprsenter les courbes intgrales :

> assign(dsolve(eq,y(x))):y:=unapply(y(x),_C1,x);

> plot({seq(y(_C1,x),_C1=-3..3)},x=-5..5,y=-20..20);

On peut prciser des options de rsolution : explicit (pour tenter d'exprimer la solution comme fonction explicite de la variable) , series (chercher les solutions sous forme de sries)

> eq:={diff(z(x),x)+z(x)*cos(x)=1,z(0)=1}: dsolve(eq,z(x));dsolve(eq,z(x),series);

La fonction odeplot du package plots permet de reprsenter les solutions d'une quation diffrentielle:

> with(plots,odeplot): p:= dsolve({D(z)(x) = z(x),z(0)=1}, z(x),type=numeric): odeplot(p,[x,z(x)],-2..2,title="Fonction exponentielle");

Equations du second ordre: MAPLE sait rsoudre directement les quations de type classique - linaire - d'Euler - de Bessel .

quation y " + y ' + y = t > restart:eq2:=diff(y(t),t$2)+diff(y(t),t)+y(t)=t;

> dsolve(eq2,y(t));

La mme avec conditions initiales: > dsolve({eq2,y(0)=0,D(y)(0)=-1},y(t));

Les options de rsolution sont les mmes qu' l'ordre 1.

Systmes diffrentiels:

Exemple: rsoudre x ' =x- 2 y , y ' = 2 x+ 3 y . Reprsenter la solution vrifiant x (0) = 0 et y( 0) = 1 .

> restart:sys:=diff(x(t),t)=x(t)-2*y(t),diff(y(t),t)=2*x(t)+3*y(t): dsolve({sys},{x(t),y(t)});

> p:=dsolve({sys,x(0)=0,y(0)=1},{x(t),y(t)},numeric): with(plots):odeplot(p,[[t,x(t)],[t,y(t)]],-1..2);

Rsolution d'quations aux drives partielles:

> edp:=y*diff(U(x,y),x)+x*diff(U(x,y),y)=0;

> pdsolve(edp,U(x,y) );

_F1 dsigne une fonction arbitraire de classe C1 de la variable

Travail dirig 7:

Soit f la fonction dfinie pour tout rel x >0 par

1 Etablir les singularits de la fonction f et vrifier sa continuit.

2 Etudier les limites de f aux bornes des intervalles composant Df. Quelle est l'asymptote de la courbe Cf de f ?

3 Calculer f '( x ) et tudier son signe ( on aura recours une fonction auxiliaire g ).

4 Reprsenter la courbe Cf.

5 Etudier la drivabilit du prolongement par continuit de f aux points 0 et 1.

Maple en algbre linaire

FONCTIONS DE BASE:

> restart; Les vecteurs et les matrices peuvent tre dfinis comme des tableaux rectangulaires, par la fonction array , rencontre dans le chapitre sur les tableaux :

Vecteur-ligne d'ordre 3 sans initialisation: > A:=array(1..3);

Vecteur-ligne d'ordre 3 avec initialisation: > B:=array([x,y,z]);

Vecteur-colonne d'ordre 3 sans initialisation: > U:=array(1..3,1..1);print(U);

Vecteur-colonne d'ordre 3 avec initialisation: > V:=array([[x],[y],[z]]);

Matrice carre d'ordre 2 sans initialisation: > M:=array(1..2,1..2);print(M);

Matrice carre d'ordre 2 avec initialisation: > N:=array([[a,b],[c,d]]);

Oprations sur les vecteurs et les matrices , avec la fonction evalm : Somme de vecteurs ou de matrices de mme dimension avec + > evalm(A+U);

Multiplication de vecteurs ou de matrices de dimensions compatibles avec &* > evalm(M &* N);

Calcul de la matrice inverse, lorsque N est inversible, avec ^(-1) > evalm(N^(-1));

Puissance n-ime avec ^n > evalm(N^3);

Multiplication par un scalaire avec * > evalm(2*M-5*N);

LES OUTILS DU PACKAGE linalg:

Le package linalg contient plus d'une centaine d'outils en algbre linaire:

> with(linalg);

Les fonctions matrix et vector permettent de dfinir respectivement une matrice (tableau rectangulaire d'objets) ou un vecteur (tableau d'objets une seule ligne) :

Dfinition d'une matrice 2x4 : > P:=matrix([[s,t,u,v],[w,x,y,z]]);

Dfinition d'un vecteur-ligne d'ordre 4 et d'une matrice-colonne d'ordre 3: > V:=vector([a,b,c,d]);

> C:=matrix([[1],[2],[3]]);

Une matrice a le type matrix , un vecteur a le type vector .

Oprations sur les matrices:

A la place de la fonction evalm , on peut utiliser les outils spcifiques du package linalg :

Multiplication de vecteurs ou de matrices de dimensions compatibles avec multiply

> multiply(M,N);

Calcul de la matrice inverse,lorsque N est inversible, avec inverse

> inverse(N);

Multiplication par un scalaire > scalarmul(P,lambda);

avec scalarmul

Test d'galit de deux matrices avec equal > equal(M,N);

Etude d'une matrice:

Dterminant et trace d'une matrice carre (somme des lments diagonaux): > N:=matrix([[1,2],[4,-3]]);det(N);trace(N);

Rang d'une matrice: > rank(N);

kernel(A); ou nullspace(A); dtermine une base du noyau de A colspace(A); dtermine une base du sous-espace engendr par les vecteurs-colonnes de A rowspace(A); dtermine une base du sous-espace engendr par les vecteurs-lignes de A

> A:=matrix([[2,-2],[-1,1]]);kernel(A);

> colspace(A);

> rowspace(A);

Matrice caractristique: > charmat(A,lambda);

> charpoly(A,lambda);

Valeurs propres de A (ce sont les racines du polynme caractristique): > eigenvals(A);

Un vecteur propre associ la valeur propre . > eigenvects(A);

est un vecteur X non nul tel que

Le rsultat affich signifie que associ

est une valeur propre d'ordre 1 de vecteur propre

et que .

est une valeur propre d'ordre 1 de vecteur propre associ

Modification d'une matrice:

> print(P);

row(P,k) permet d'extraire la k-ime ligne de la matrice P. Le rsultat est un vecteur. col(P,k) permet d'extraire la k-ime colonne de la matrice P. Le rsultat est un vecteur. > row(P,2),col(P,3);

rowdim(P) et coldim(P) retournent le nombre de lignes et de colonnes de la matrice P . > rowdim(P),coldim(P);

augment(M1,M2,...,Mn) permet de concatner horizontalement les n matrices M1,M2,...,Mn : > augment(A,P);

stackmatrix(M1,M2,...,Mn) permet de concatner verticalement les n matrices M1,M2,...,Mn : > stackmatrix(A,N);

copyinto(M,N,m,n) : copie M dans N , l'lment M[1,1] tant copi en > copyinto(N,P,1,2);

swapcol(M,m,n) et swaprow(M,m,n) permettent d'changer les colonnes (ou les lignes) m et n de la matrice M : > swaprow(A,1,2);

transpose(M) permet de transposer la matrice M : > print(M);transpose(M);

addcol(M,m,n,k) ou addrow(M,m,n,k) rendent une matrice obtenue partir de M par

l'opration col n := col n + k * col m (respectivement lig n := lig n + k * lig m ) :

> print(N);addcol(N,1,2,mu);

Matrices particulires: > vandermonde([a,b,c,d]);

> JordanBlock(expr,4);

LES OUTILS DU PACKAGE LinearAlgebra:

A partir de la version 7, existe dans Maple un nouveau package LinearAlgebra avec des outils similaires ceux du package linalg et destin supplanter l'ancien. En voici les fonctions: > with(LinearAlgebra);

On dfinit une matrice A dont on calcule le dterminant, la matrice et le polynme caractristique, ainsi que les valeurs propres et vecteurs propres associs: > A:=Matrix([[1,-1,-1],[-2,2,3],[2,-2,-3]]); Determinant(A); CharacteristicMatrix(A,lambda); factor(CharacteristicPolynomial(A,lambda)); Eigenvalues(A); Eigenvectors(A);

Exercice corrig 8:

Rechercher les matrices carres X d'ordre 2 telles que > with(linalg):A:=matrix(2,2,1);X:=matrix(2,2):

, o

> Y:=evalm(X^2+X-A);

> Y:={seq(seq(Y[i,j],j=1..2),i=1..2)};

> solutions:={solve(Y)}: for k to nops(solutions) do X:=matrix(2,2):assign(solutions[k]):print(X); end do:

Donc 4 matrices solutions.

Travail dirig 8:

TD 8.1:
Ecrire une procdure pcd(L::list) retournant partir d'une liste donne L la liste obtenue par permutation circulaire vers la droite des lments de L . Exemple:

> pcd([a,b,c,d,e,f,g]);

TD 8.2:
Ecrire une procdure circulante_droite(n::posint) retournant partir de l'entier n> 0 une matrice carre d'ordre n telle que

- sa premire ligne est constitue par les entiers de 1 n . - pour k> 1 , sa k-ime ligne est dduite de la ligne prcdente par permutation circulaire vers la droite de ses lments.

Exemple: > circulante_droite(5);

TD 8.3:
Test d'galit de 2 matrices:

2 matrices M et N sont gales si et seulement si elles ont mme nombre de lignes, mme nombre de colonnes, et les mmes coefficients . Sans avoir recours la fonction prexistante equal de Maple, crire une procdure egal(M: : matrix , N: : matrix) retournant la valeur boolenne true si M=N et false sinon.

Maple en gomtrie
GEOMETRIE PLANE:

> restart; Le package geometry contient des outils pour la gomtrie plane :

> with(geometry);

La fonction point permet de dfinir un point du plan: Syntaxes quivalentes: point(P, Px, Py) ou point(P, [Px, Py]).

Exemple: pour dfinir les points O(0,0) , A(-1,3) et B(4,2). > point(O,[0,0]):point(A,[-1,3]):point(B,[4,2]):

La fonction detail permet d'obtenir des informations sur un objet gomtrique: > detail(A);

> point(M,X,Y):

La fonction line permet de dfinir une droite, dont on peut avoir l'quation.

> line(AB,[A,B]):Equation(AB,[x,y]);

La fonction triangle permet de dfinir un triangle , dont on peut avoir l'orthocentre , ou le centre de gravit. > triangle(OAB,[O,A,B]):orthocenter(H,OAB):coordinates(H);

> centroid(K,OAB):coordinates(K);

La fonction circle permet de dfinir un cercle, dont on peut avoir le centre, ou le rayon :

> circle(C,[O,A,B]):omega:=center(C):coordinates(omega);r:=radius(C);

> detail(C); assume that the names of the horizontal and vertical axes are _x and _y, respectively

Calcul de la distance entre 2 points ou de la distance d'un point une droite: > distance(A,B);

> distance(M,AB);

Projet d'un point sur une droite projet de M sur (AB): > projection(P,M,AB):coordinates(P);

Equation de la parallle ou de la perpendiculaire une droite donne passant par un point donn d1 est la parallle (AB) passant par K, d2 est la perpendiculaire (AB) passant par K:

> ParallelLine(d1,K,AB):Equation(d1,[x,y]);

> PerpendicularLine(d2,K,AB):Equation(d2,[x,y]);

> ArePerpendicular(d1,d2);

Intersection de 2 droites , d'une droite et d'un cercle , de 2 cercles > intersection(i1,d1,d2):detail(i1);coordinates(i1);

> intersection(i2,d1,C):detail(i2);

Trac de la figure: on remarquera le paramtrage des 2 droites d1 et d2 et du cercle C . La fonction display du package plots permet de reprsenter sur un mme graphique diffrents objets graphiques prcdemment dfinis , tels ici OAB , texte , etc ...

> with(plots): > OAB:=plot([[HorizontalCoord(O),VerticalCoord(O)],[HorizontalCoord(A),Vertica lCoord(A)],

[HorizontalCoord(B),VerticalCoord(B)],[HorizontalCoord(O),VerticalCoord(O) ]],color=green): > d1:=plot([HorizontalCoord(K)-5*t,VerticalCoord(K)+t,t=2/3..3/4],numpoints=100,color=red): > d2:=plot([HorizontalCoord(K)+t,VerticalCoord(K)+5*t,t=0.5..0.75],numpoints=100,color=red): > cercleC:=plot([HorizontalCoord(omega)+r*cos(t),VerticalCoord(omega)+r*sin( t),t=0..2*Pi], numpoints=100,color=blue): > texte:=textplot([[-1.15,3,`A`],[4+0.15,2,`B`],[1.8,5.2,`D2`],[2,1.9,`D1`],[1.3,1.9,`K`]],color=black): > display({OAB,d1,d2,cercleC,texte},scaling=constrained);

AUTRES OUTILS DU PACKAGE LINALG POUR LA GOMTRIE:

Le package linalg d'algbre linaire contient galement quelques outils utiles en gomtrie euclidienne, notamment:

dotprod (v1,v2) calcule le produit scalaire(hermitien) des vecteurs v1 et v2. norm (v) calcule la norme du vecteur v. crossprod (v1,v2) calcule le produit vectoriel des vecteurs v1 et v2 (en dimension 3). GramSchmidt ({v1,v2,...,vn}) retourne la base orthogonale dduite de la famille {v1,v2,...,vn} par le procd de Gram-Schmidt.

> with(linalg): v1:=vector([x1,y1,z1]);v2:=vector([x2,y2,z2]);

> dotprod(v1,v2);

> norm(v1);

> crossprod(v1,v2);

> v1:=vector([1,2,4]);v2:=vector([-1,6,5]);v3:=vector([2,0,3]); GramSchmidt({v1,v2,v3});

Reprsentation de polygnes rguliers, et polygnes toils: > opts := filled=true, style=patch, axes=none: point(o,0,0): s1 := draw( RegularPolygon(_r7, 7, o, 3), opts, title="{7}" ): s2 := draw( RegularStarPolygon(_r7_2, 7/2, o, 3), opts, title="{7/2}" ): s3 := draw( RegularStarPolygon(_r7_3, 7/3, o, 3), opts, title="{7/3}" ): s4 := draw( RegularPolygon(_r9, 9, o, 3), opts, title="{9}" ): s5 := draw( RegularStarPolygon(_r9_2, 9/2, o, 3), opts, title="{9/2}" ): s6 := draw( RegularStarPolygon(_r9_4, 9/4, o, 3), opts, title="{9/4}" ): s7 := draw( RegularPolygon(_r11, 11, o, 3),opts, title="{11}" ): s8 := draw( RegularStarPolygon(_r11_3, 11/3, o, 3), opts, title="{11/3}" ): s9 := draw( RegularStarPolygon(_r11_5, 11/4, o, 3), opts, title="{11/5}" ): plots[display](array(1..3,1..3,[[s1,s4,s7],[s2,s5,s8],[s3,s6,s9]]));

GEOMETRIE DE L'ESPACE:

Le package geom3d contient des outils pour travailler la gomtrie dans l'espace :

> with(geom3d);

La dfinition de points , de droites , de plans , se fait comme en dimension 2 par les fonctions point , line , et plane .

On dfinit 4 points O,A,B,C: > point(O,[0,0,0]):point(A,[-1,2,0]):point(B,[0,1,1]):point(C,[-1,2,1]): > detail(A);

d est la droite passant par A dirige par U(1,2,-1) > U:=[1,2,-1]:line(d,[A,U]): > plane(P,[A,B,C]):Equation(P,[x,y,z]); # quation du plan P=(ABC)

Un plan a une structure que l'on peut visualiser par detail :

> detail(P);

> parallel(Q, O, P):detail(Q); # Q est le plan passant par O et parallle P

> plane(P1,[O,A,B]): intersection(delta,P1,P):detail(delta); # delta est l'intersection des plans P1 et P , dfinie par un systme paramtrique : Warning, assume that the parameter in the parametric equations is _t

> ArePerpendicular(P,P1);

> distance(O,P);

> sphere(S,[O,A,B,C]):detail(S); Warning, assume that the name of the axes are _x, _y and _z

> omega:=center(S):coordinates(omega); # centre omega de la sphre S

> projection(proj,O,P):coordinates(proj); # projet de O sur le plan P

AUTRES OUTILS DU PACKAGE GEOM3D:

Des outils existent pour reprsenter des polydres, solides de l'espace ventuellement toils: > octahedron(Oct,point(O,0,0,0),1.): stellate(StOct,Oct,1): draw( StOct, cutout=7/8, lightmodel=light4);

> point(e1,10,15,0), point(e2,-10,15,0), point(e3,-10,-15,0),point(e4,10,-15,0): r1 := 1.: point(o1,-2,2,r1):tetrahedron(p1,o1,r1): r2 := 2.: point(o2,-4,5,r2):cube(p2,o2,r2): r3 := 5./2: point(o3,-7,8,r3):octahedron(p3,o3,r3): r4 := 3.: point(o4,-3,12,r4):dodecahedron(p4,o4,r4): r5 := 7./2: point(o5,3,18,r5):icosahedron(p5,o5,r5): r6 := 6.: point(o6,15,9,r6):GreatStellatedDodecahedron(p6,o6,r6): r7 := 9./2: point(o7,11,23,r7):GreatDodecahedron(p7,o7,r7): r8 := 7.: point(o8,17,-9,r8):SmallStellatedDodecahedron(p8,o8,r8): r9 := 15./2: point(o9,2,-11,r9):GreatIcosahedron(p9,o9,r9):

fl := [[25,30,0],[-10,30,0],[-10,-20,0],[25,-20,0]]: pic1 := plots[polygonplot3d](fl,color=sienna): pic2 := draw([seq(p||i,i=1..9)],color=COLOR(RGB,.9335294125,.9129411760,.520588 2350)): plots[display]([pic2,pic1],style=patch,orientation=[-97,52],title="Les neuf polydres rguliers", lightmodel=light4);

Exercice corrig 9:

Dterminer et reprsenter la surface S, ensemble des points M dont la somme des carrs des distances aux droites d1: y=x , z= 1 et d2 : y=-x , z=- 1 est gale 3.

> restart:with(geom3d):

d1 est l'intersection de 2 plans p1 et q1: > plane(p1,y-x=0,[x,y,z]):plane(q1,z-1=0,[x,y,z]):intersection(d1,p1,q1): d2 est l'intersection de 2 plans p2 et q2: > plane(p2,y+x=0,[x,y,z]):plane(q2,z+1=0,[x,y,z]):intersection(d2,p2,q2):

Dfinition d'un point quelconque M: > point(M,X,Y,Z):

Equation et reprsentation de S: > S:=distance(M,d1)^2+distance(M,d2)^2-3;

> with(plots): > implicitplot3d(S,X=-1..1,Y=-1..1,Z=1/sqrt(2)..1/sqrt(2),numpoints=300,color=blue,axes=BOXED);

Il s'agit d'un ellipsoide d'quation

de centre O.

Travail dirig 9:

Soit ABC un triangle du plan affine euclidien , M un point quelconque que l'on projette orthogonalement en H1,H2,H3 sur (BC) , (CA) , (AB) respectivement .

Montrer que M est sur le cercle circonscrit ABC si et seulement si H1,H2,H3 sont aligns, sur la droite dite de Simson associe M:

On travaillera dans un repre orthonormal tel que A(0,0) , B(1,0) , C(-2,3).