Ecole Nationale des Sciences

Appliques dEl Jadida

Dr. M. EL MOUDEN
Anne Universitaire 2010-2011
Table des matires Table des matires
1) Introduction )
2) Arithmtique
3) F ti 3) Fonctions
4) Graphique 4) Graphique
5) Analyse
6) Programmation
MAPLE est un langage de manipulation
symbolique qui permet: symbolique qui permet:
d'accder une large bibliothque de d accder une large bibliothque de
fonctions trs bien adaptes,
de raliser aussi bien des calculs
numriques que des calculs formels.
1. Commandes Maple de base.
1 1 Calculs numriques 1.1 Calculs numriques.
1.2 Calculs sur des nombres "spciaux".
1 3 Quelques fonctions mathmatiques 1.3 Quelques fonctions mathmatiques.
1.4 Calculs symboliques.
2 Reprsentation Graphique 2. Reprsentation Graphique.
Au dmarrage d'une session; MAPLE affiche un prompt .
L'utilisateur peut alors lui demander d'excuter "quelque
chose". Pour cela il doit rentrer au clavier une assertion MAPLE.
l fi d h d M l il it la fin de chaque commandes Maple, il y a un soit:
Un point-virgule (;) Maple affiche le rsultat du calcul
D i t ( ) M l ff t l l l i Deux points (:) Maple effectue le calcul, mais ne
l'affiche pas.
Si l'on ne mets rien la fin d'une ligne et qu'on la valide (en Si l'on ne mets rien la fin d'une ligne et qu'on la valide (en
appuyant sur la touche [entre]), Maple affiche alors un "
warning" (attention en anglais) signalant une fin prmature de warning (attention en anglais) signalant une fin prmature de
la commande.
1 2 > 1+2;
> 1+2:
> 3*7*15 > 3 7 15
> :
Si l'on appuie sur [entre] la fin d'une ligne, Maple
essaie de calculer ce qu'on a crit essaie de calculer ce qu on a crit.
On peut cependant crire plusieurs lignes de calcul en
appuyant la fin d'une ligne simultanment sur les touches
[shift] et [entre] (ce que l'on note dans la littrature par
[shift]+[entre]) [shift]+[entre]).
> 1+2;
3+4:
Rappel du dernier calcul
Dans le langage Maple, le caractre pourcent (%) permet
de rappeler la valeur du dernier calcul effectu par la machine.
Ce n'est pas ncessairement le dernier calcul affich Ce n'est pas ncessairement le dernier calcul affich.
De mme, (%%) permet de revenir deux calculs en arrire et De mme, (%%) permet de revenir deux calculs en arrire et
(%%%) permet de rappeler 3 calculs.etc
Pour indiquer une multiplication ou une division, il faut
toujours mettre une toile (*) ou un slash(/) entre les facteurs
> (%); 4*8*758*248*1258; (%%%); 8/4; 7/8;
Maple calcule la longueur (le nombre de chiffres) du rsultat
qu'il calcule, en utilisant la commande : length
> length(4*8*758*248*1258);
Pour indiquer un factoriel, il faut toujours mettre un point q , j p
d'exclamation (!) la fin du nombre:
50! > 50!;
> length(%);
Une variable muette est donne par une lettre ou un mot
> x; fonc; 5*x; fonc; > x; fonc; 5*x; fonc;
Ici, si on tape 5x la place de 5 x, Maple va retourner
un 'warning' signalant qu'il manque un oprateur ou un un warning signalant qu il manque un oprateur ou un
point-virgule.
Notez que lorsque Maple affiche un 'warning' le curseur Notez que lorsque Maple affiche un warning , le curseur
se place l'endroit o l'erreur t rencontre.
> 5x;;
Mais x5 "x attache 5" sera considre comme variable (5
jouera le rle d'indice)
> x5;
> x 5;
> 5*x; > 5 x;
L'exposant d'une variable peut scrire de deux manire
diffrentes:
> y:=x**2; z:=y^3;
U bl M l t l id Aid li Un problme: Maple est l pour vous aider Aide en ligne.
Maple dispose d'une aide en ligne (trs pratique lorsqu'on a
oubli comment se servir d'une fonction ou d'une commande) oubli comment se servir d une fonction ou d une commande).
Celle-ci s'obtient en tapant un point d'interrogation avant le nom
de la fonction.
,Notez qu'il n'y a pas de point-virgule aprs cette commande.
> ?sin
ou encore ou encore
> help(sin)
soit encore sur le site web officiel de Maple:
http://www.maplesoft.com
Attribution des variables
Pour attribuer une valeur une variable, on se sert de la
commande (:= ) (comme dans le langage Pascal). Par commande (: ) (comme dans le langage Pascal). Par
exemple, supposons que l'on veuille donner x la valeur de
5, on procde comme suit :
>x:=5; v:=8;
Le maple mmorise tout ce qui a t excut.
> y; z; > y; z;
Jusqu' la fin des calculs, x sera gal 5. Pour supprimer la
valeur affecte x, on se sert de la commande unassign(..), valeur affecte x, on se sert de la commande unassign(..),
comme dans l'exemple suivant :
> unassign('x');
> x;
et aussi.
> v; y; z; > v; y; z;
R-initialisation
On r-initialise une feuille de calcul, par la commande restart, pour , p , p
supprimer la valeur de x, et aussi de toutes les autres variables.
> restart;
>> x; y; z; v;
Commentaires Commentaires
Lorsqu'on veut crire un commentaire dans ses calculs, on crit une
dise (#) suivi du commentaire. Tout ce qui sera aprs la dise ne
sera pas pris en compte dans l'valuation par Maple de la feuille de
calcul
> # Ceci est un commentaire : on fait du maple Vive la > # Ceci est un commentaire : on fait du maple Vive la
PARESSE.
# Suggestion au commentaire : on ne fera plus de CALCUL. gg p
# Rponse la suggestion : mon OEIL, tu parles.
> sin(x) + cos(y); # Ceci est un autre commentaire.
# i ( ) ' t t i l # sin(x); <- c'est un commentaire, a ne sera pas valu.
> # ceci est un commentaire; sin(x)+cos(x); x;
Calculs numriques
Evaluation
La commande evalf(...), qui signifie "evaluate foating" permet
dvaluer une approximation numrique des calculs effectus.
> 5/3; > 5/3;
evalf(%);
Maple donne les rsultats dans leur forme la plus formelle. p p
Pour les calculs numriques on doit donner des instructions tel
que evalf(...).
1 /2 3/10 > 1./2+3/10;
Cependant, si l'on ajoute un point (.) la fin d'un nombre,
Maple pense alors que le nombre en question est un rel (et non Maple pense alors que le nombre en question est un rel (et non
plus un entier ou un rationnel) et donnera le rsultat sous forme
d'un nombre rel. Lorsqu'on crit 1., cela signifie pour Maple le q , g p p
nombre 1.0.
> 1 /2+3/10; > 1./2+3/10;
> Pi;
> evalf(Pi); ( );
> ln(2);
> evalf(%);
l (2 ) > ln(2.);
> exp(1);
> evalf(%); > evalf(%);
> sin(90.):
> sin(180.): ( )
> sin(Pi/2):
> sin(Pi):
, Remarquer que l'argument l'intrieur d'une parenthse d'une
fonction circulaire est en radians fonction circulaire est en radians.
> ln(exp(-5));
exp(ln(-5)); exp(ln(-5));
exp(ln(-5.));
Trop de chiffres aprs la virgule
Ce n'est pas un problme: Il existe une commande Maple pour
fi l b d hiff ffi h il ' it d l d fixer le nombre de chiffre afficher, il s'agit de la commande
Digits:=n. Par dfaut, Maple affiche 15 chiffres au total (partie
entire et partie dcimale) entire et partie dcimale).
> sin(0.2);
n:=4; Digits:=n; ; g ;
sin(0.2);
T l hiff i i t ' ffi h t hiff Tous les chiffres qui viennent aprs s'afficheront n chiffres
aprs la virgule
> sin(0 2); evalf(% 8); > sin(0.2); evalf(%,8);
> 5/7.;
Calcul symbolique
Pour dvelopper une expression, on utilise la commande expand(...), pp p ( )
Pour la simplifier, on utilise la fonction simplify(...)
Pour la factoriser, on utilise la commande factor(...).
> (1+x)^2; > (1+x) 2;
expand(%);
factor(%);
simplify(cos(x)^2 + sin(x)^2);
> y:=(1+x)*(3-2*x^2);
> z:=expand(y); > z:=expand(y);
> factor(z);
> y:=cos(x)^2+sin(x)^2;
> expand(y);
factor(y);
simplify(y); simplify(y);
> y:=(x^2-1)/(x-1);
expand(y); p (y);
factor(y);
simplify(y);
Quelques fonctions de base
Maple connait un grand nombre de fonctions mathmatiques Maple connait un grand nombre de fonctions mathmatiques
de base (certainement beaucoup plus que vous mme en
connaissez) et il est possible dvaluer ces fonctions un point ) p p
donn.
> restart; > restart;
x:=Pi; ln(x); exp(x); sin(x); sinh(x); tan(x);
Reprsentations graphiques
Maple permet galement de tracer n'importe quelle fonction,
aussi bien sur le plan que dans l'espace aussi bien sur le plan que dans l espace.
Pour commencer, on utilisera l'instruction plot(...).
>plot( x^2, x=-5..5);
>plot( sin(x^2) x=0 5); >plot( sin(x^2), x=0..5);
>plot3d(x*sin(y+x), x=-5..5, y=-5..5);
>plot3d(x*sin(y)*exp(-x*y), x=-1..1, y=-1..1); plot3d(x sin(y) exp( x y), x 1..1, y 1..1);
Exercices (Srie1)
Solutions
Solutions
Solutions
1. Nombres complexes.
2 Operations d'arithmtiques 2. Operations d arithmtiques.
3. Calculs sur les polynmes.
4 Equations 4. Equations.
Nombres complexes
Maple sait faire peu prs n'importe quel calcul sur les
nombres complexes. p
En langage Maple, I (i majuscule) dsigne une racine carr du
nombre -1, c'est dire le nombre tel que I
2
= -1.
Maple peut dcomposer toujours le rsultat sous la forme
habituelle a+ib, dans le cas d'une reprsentation numrique.
> i*i; I*I; > i i; I I;
> z1:=a+I*b; z2:=c+I*d;
> z0:=z1+z2; z3:=z1*z2; z4:=z1/z2; ; ; ;
D'autres exemples :
> (2+5*I)+(1-I)+5*(3+6*I);
(4 6*I) * ( 9*I) (4+6*I) * (7 - 9*I);
(1+I)/(3-2*I);
(2+8*I)^2; (2+8 I) 2;
Maple possde des commandes spcifique aux calculs sur le
b l nombres complexes :
La plus usuelle est la commande evalc( ) qui simplifie une La plus usuelle est la commande evalc(...), qui simplifie une
expression complexe sous la forme a + ib.
, ne pas confondre avec la commande evalf(...), qui
permet dvaluer une approximation numrique des
l l ff t calculs effectu
> evalc(z3); evalc(z4); > evalc(z3); evalc(z4);
La commande conjugate(...) donnera son conjugu.
> z5:=sqrt(3)+I; # Un nombre complexe
6 j t ( 5) # S j z6:=conjugate(z5); # Son conjugu
La commande Re(...) donne la partie relle d'une expression
complexe. p
La commande Im(...) donne la partie imaginaire d'une
i expression.
> z5:=sqrt(3)+I; # Un nombre complexe > z5:=sqrt(3)+I; # Un nombre complexe
rez5:=Re(z5); # Sa partie relle
imz5:=Im(z5); # Sa partie imaginaire ( ) p g
La commande abs(...) donnera le module d'un complexe.
La commande argument(...) donnera son argument.
> z5:=sqrt(3)+I; # Un nombre complexe
absz5:=abs(z5); # Son module
argz5:=argument(z5); # Son argument
argz6:=argument(z6);
Dautres exemples:
> z7:=2^(3-4*I);
argument(z7); g ( )
evalf(abs(z7));
evalc(z7);
lf(%) evalf(%);
> z8:=2*ln(3-4*I);
argument(z8); argument(z8);
evalf(abs(z8));
evalc(z8);
evalf(%);
E d' t l Encore d'autres exemples:
> evalc(Im((3+5*I)*(7+4*I))); > evalc(Im((3+5 I) (7+4 I)));
> evalc(conjugate(exp(2*I))); evalf(%);
Reprsentation usuelle et reprsentation polaire
Un complexe peut tre galement reprsent de faon polaire,
c'est dire sous la forme e
(Iu)
, o est son module et u son ,
argument.
Pour avoir une telle reprsentation, on utilise la commande
polar(, u)
> z:=a+b*I; abs(z); argument(z); convert(z,polar);
> zp1:=polar(1, Pi/6); # le nombre complexe de module 1 et
d'argument Pi/6
l ( 1) evalc(zp1);
> zp3:=polar(2 Pi/3); evalc(zp3); > zp3:=polar(2,Pi/3); evalc(zp3);
Pour mettre un nombre de la forme a + ib en forme polaire, on
utilise la commande convert( polar) utilise la commande convert(..., polar) .
> zp2:=convert(sqrt(3)-I,polar); # On met sous forme polaire le p ( q ( ) ,p ); p
nombre sqrt(3)-I
evalc(zp2);
> # On met sous forme polaire le nombre 3-4*I
convert(3 4*I polar); convert(3-4 I,polar);
> # Rciproquement, pour passer de la forme polaire la forme p q , p p p
usuelle, on utilise la commande evalc(...), que nous avons dj
vu.
l (%) evalc(%);
> zp3:=polar(2 Pi/3); evalc(zp3); > zp3:=polar(2,Pi/3); evalc(zp3);
Operations d'arithmtiques
Maple sait galement faire de nombreuses oprations Maple sait galement faire de nombreuses oprations
d'arithmtique.
Il peut faire des calculs des pgcd et ppcm,
donner ne factorisation d' n nombre en nombres premiers donner une factorisation d'un nombre en nombres premiers,
dterminer le n
ime
nombre premier etc dterminer le n nombre premier, etc..
pgcd, ppcm et factorisation d'entiers
Pour le Plus Grand Commun Diviseur (pgcd) de deux, trois,
ou plus, nombres entiers se calcule l'aide de la commande
i d( ) ( I t G t C Di i ) igcd(...) (pour Integer Greater Common Divisor ).
le pgcd se calcule comme suit :
i d(616 1834 56) > igcd(616,1834,56);
igcd(24,4);
igcd(6160 8372 56); igcd(6160,8372,56);
Pour le Plus Petit Commun Multiple (ppcm) de deux, trois p (pp )
ou plus, nombres entiers se calcule grce la commande
ilcm(...) (pour Integer Less Common Multiple ).
le ppcm se calcule comme suit :
> ilcm(35,235);
il (38 341) ilcm(38,341);
ilcm(6,9,18);
La commande ifactor(...) permet de factoriser des nombres
entiers en facteurs premiers entiers en facteurs premiers.
,Notez que cette commande a un certain nombre d'options qui ,Notez que cette commande a un certain nombre d options qui
permettent de choisir la mthode de factorisation. Regardez
l'aide-en-ligne ce sujet.
Pour factoriser un nombre en nombres premiers :
> ifactor(1733398734375000); ifactor(2850375285); > ifactor(1733398734375000); ifactor(2850375285);
ifactor(123456789);
Nombres premiers
Un nombre premier est un nombre entier dont les diviseurs
positifs sont 1 et par lui-mme.
Par convention:
1 n'est pas premier. p p
24 n'est pas premier car il est divisible (au moins) par 2.
23, par contre, est un nombre premier.
La commande ithprime(...) permet d'afficher le i-me nombre
premier.
, Notez que le premier nombre premier est 2.
Pour savoir si un nombre est premier on se sert de la Pour savoir si un nombre est premier, on se sert de la
commande isprime(...).
P t l l tit b i i d Pour connatre le plus petit nombre premier qui succde un
nombre donn, on se sert de la commande nextprime(...).
P it l i
me
b i Pour connaitre le i
me
nombre premier.
> ithprime(1); ithprime(11); ithprime(23); ithprime(31);
Pour savoir si un nombre est premier :
> isprime(357649); isprime(4); isprime(3807);
Pour connatre le plus petit nombre premier qui succde un
b d nombre donn :
> nextprime(29); nextprime(275); nextprime(8723);
Pour connatre le plus petit nombre premier qui prcde un
nombre donn :
> prevprime(29); prevprime(275); prevprime(8723);
> prevprime(7); nextprime(7);
Calculs sur les polynmes
Le travail le plus simple sur les expressions symboliques
concerne: les polynmes.
V i i t i b d l l l t i l Voici un certains nombres de calculs lmentaires sur les
polynmes :
> P1:= 3 * x^2 + 4 * x + 7; # On assigne P1 un polynme > P1:= 3 x 2 + 4 x + 7; # On assigne P1 un polynme.
P2:= x^3 - 1; # On assigne P2 un polynme.
On calcule le carr de P1:
> P1^2;
On calcule le rapport de P1 / P2:
P1/P2 > P1/P2;
On value P1 et P2 respectivement aux points x = 2 et
x = - 4 Pour cela on utilise la commande eval( x= ): x 4. Pour cela on utilise la commande eval(..., x=...):
> eval(P1, x=2); eval(P2, x=-4); eval(P2/P1, x=-1);
De mme on peut dvelopper, factoriser, simplifier et
ordonner des polynmes, grce aux commandes
expand(...), factor(...), collect(...), simplify(...) et sort(...).
La commande expand(...)
La commande expand(...) permet de dvelopper un polynme. ( ) y
> p1:=(x+1)*(x+2); p2:=(x-y)*(x^2+x*y+y^2);
3 (3* +10)*(7* +6)*( +3) p3:=(3*x+10)*(7*x+6)*(x+3);
p1:=expand(p1); p2:=expand(p2); p3:=expand(p3);
La commande factor(...)
La commande factor(...) permet de factoriser un polynme.
> P3:=21*x^3+151*x^2+324*x+180; P3:=factor(P3);
P4 14* ^4 23* ^3 347* ^2+575* 75 P4 f t (P4) P4:=14*x^4-23*x^3-347*x^2+575*x-75; P4:=factor(P4);
P5:=x^2 - 1; P5:=factor(P5);
P6:=x^2 - 2; P6:=factor(P6); P6: x 2 2; P6: factor(P6);
La factorisation se fait dans le plus petit corps qui contient les
coefficients du polynme. Remarquons la diffrence entre les
deux expressions suivantes :
> P6:=factor(P6); P7:=x^2 2 ; P7:=factor(P7); > P6:=factor(P6); P7:=x^2 - 2.; P7:=factor(P7);
Cette commande permet galement de factoriser un polynme Cette commande permet galement de factoriser un polynme
plusieurs variables.
> factor(x^3-y^3);
La commande collect( ) La commande collect(...)
La commande collect(...) permet de grouper les termes d'une
expression suivant une variable donne, collect(......, nom de la
variable) .
> P * ^3 + * ( ^2+1)*(2* 2)+ ^2*( ^2+4* +2)+4 > Po:=a*x^3 +y*x-(x^2+1)*(2*y-2)+x^2*(y ^2+4*y+2)+4;
Po:=collect(Po , x); Po:=collect(Po, y);
On peut factoriser une expression suivant plusieurs variables,
en respectant l'ordre des variables.
> collect(Po,[x,y]); collect(Po,[y,x]);
> P1:= x*y+x*y^2+a*x*y+y*x^2-a*y*x^2-a*x*y^2+y+x+a*x+a*y;
> collect(P1 [ ]) collect(P1 [ ]) > collect(P1,[x,y]); collect(P1,[y,x]);
La commande simplify(...)
La commande simplify(...) permet de simplifier une
expression.
,Attention, cependant, cette commande ne donne pas toujours
le rsultat voulu (Maple oublie parfois certaines simplifications le rsultat voulu (Maple oublie parfois certaines simplifications
videntes, mais c'est relativement rare).
> P1:=x^5-3*x^3-x^4+2*x+4; P2:=x^4+x-2*x^3-2; R:=P1/P2;
> R:=simplify(R);
La commande sort(...)
La commande sort(...) permet de classer les coefficients d'un
polynme suivant la valeur dcroissante des puissances.
> Pol:=x+x^2 - x^3+7 - x^6 + x^22;
P l t(P l) # O t i l l l i bl Pol:=sort(Pol); # On trie le polynme une seule variable.
Si l'on a un polynme plusieurs variables on peut bien sr Si l on a un polynme plusieurs variables, on peut bien sr
prciser l'ordre dans lequel on veut classer le polynme.
> poly2:= x*y^3 - 2*x^2*y^5 + 4*x*y^4 + y^8+x^7; # On trie
polynme deux variables.
pol 2 sort(pol 2 [ ]) # On trie pol 2 s i ant p is poly2:=sort(poly2,[x,y]); # On trie poly2 suivant x puis y.
poly2:=sort(poly2,[y,x]); # On trie poly2 suivant y puis x.
La commande normal(...)
La commande normal( ) permet de mettre des fractions de La commande normal(...) permet de mettre des fractions de
polynmes au mme dnominateur.
> ploy1:=1/(1+2*x^2) + 2*x/(1+x) + 3*x^2/(4-x^3) -
2*x^3/(3+x+x^4); # Un polynme plusieurs variables
ploy1:=normal(%);
> poly2:=y/(1+2*y^2) + 2*x*y/(1+x); # Un polynme plusieurs > poly2:=y/(1+2 y 2) + 2 x y/(1+x); # Un polynme plusieurs
variables
ploy2:=normal(%); p y ( );
La commande degree(...)
La commande degree(...) permet d'obtenir le degr d'un
polynme polynme.
Si le polynme a plusieurs variables, on peut prciser suivant p y p , p p
quelles variable on veut le degr.
Si l'on ne prcise pas la variable, on obtient le degr total de
l'expression.
> P:= 4*x^5 + 3*x^4 - 8*x +2; degree(P);
Q:= 4*y^2*x^4 + 12*y^5 + 7*x^2*y^2 + 7; degree(Q); y y y ; g ( );
degree(Q,x); degree(Q,y);
La commande coeff(...)
La commande coeff(...,x^n) permet d'obtenir la valeur d'un
coefficient du terme de degr n du polynme considr. g p y
La commande lcoeff(...) permet d'obtenir le coefficient du
terme de plus haut degr ("l" inital pour "lead").
> P:= 4*x^5 + 3*x^4 8*x +2; > P:= 4 x 5 + 3 x 4 - 8 x +2;
coeff(P, x^4); coeff(P, x^2); lcoeff(P);
La commande gcd( ) et lcm( ) La commande gcd(...) et lcm(...)
Le Plus Grand Commun Diviseur (pgcd) de deux, trois, ou
plus, polynmes se calcule l'aide de la commande gcd(...)
(pour Greatest Common Divisor ).
Le Plus Petit Commun Multiple (ppcm) de deux, trois ou
plus polynmes entiers se calcule grce la commande lcm( ) plus, polynmes entiers se calcule grce la commande lcm(...)
(pour Less Common Multiple ).
> P:= 1/2*x^3 - 1/2; Q:= x^2 - 1;
> gcd(PQ) lcm(PQ) > gcd(P,Q); lcm(P,Q);
Equations Equations
En Maple, la rsolution des quations se fait avec les En Maple, la rsolution des quations se fait avec les
commandes solve(...) (effectivement quand la mthode
analytique le permet).
Notez que si l'on met l'inconnue entre accolades ({ }), alors
Maple prcise de quelle variable on parle par exemple dans Maple prcise de quelle variable on parle par exemple dans
l'quation suivant c'est x et non pas y.
La prcision des variables est importante dans des
expressions thoriques, sinon Maple peut rserver des drles
de surprises. . .voir exemple ci dessous:
> eqn:= x^2 - y = 0;
solve(eqn); ( q );
solve(eqn, x);
solve(eqn, y);
l ( { }) solve(eqn, {x});
solve(eqn, {y});
> eqn:= x^3 +2*y*x = 0; > eqn:= x 3 +2 y x = 0;
solve(eqn);
solve(eqn,x); ( q )
> eqn := a * x^2 + b * x + c = 0;
solve(eqn);
l ( ) solve(eqn,x);
> eqn := x^4 - 3 * x^2 + x + 1 = 0;
solve(eqn x); solve(eqn,x);
> fsolve(eqn,x);
> fsolve(eqn,x=0..2);
,Notez que l'expression eqn est dfinie comme une quation et
non pas comme une variable.
Systmes dquations Systmes d quations
Maple ne se limite pas la rsolution des systmes linaires,
mais bien au contraire, il peut rsoudre des systmes nettement
plus compliqus plus compliqus.
> restart; {x+2*y=3, x+y =1 }; ; { y , y };
> solve({x+2*y=3, x+y =1 }, {x,y});
La commande assign(...) et unassign(...)
On peut forcer Maple pour qu'il donne une valeur prcise un
nom donn, l'aide de la commande assign(...) . , g ( )
> sys3:={u+v=1, 2*u+v=3};
sol3:=solve(sys3,{u,v});
On note que u et v sont encore considr par Maple comme
des variable sans valeur prcise des variable, sans valeur prcise
> u,v;
Si on veut donner u et v les valeurs solution du systme
prcdent, on fait comme suit :
i ( l3) > assign(sol3);
u,v;
sys3; sys3;
Pour redonner le statut de variable u et v on utilise la
commande unassign( ) commande unassign(...) .
> unassign('u');
u,v; , ;
> unassign('u','v');
u,v;
, Note: la commande restart permet de rinitialiser Maple ce , Note: la commande restart permet de rinitialiser Maple, ce
qui peut tre utile, parfois.
La commande allvalues( ) La commande allvalues()
Parfois,.........pour un systme un peu plus complexe......... , p y p p p
> sys:={x^2+y=1,x^2-y^2=2};
> solve(sys,{x,y});
La rponse n'est que partielle!
plutt que de calculer une solution Maple donne un rsultat en plutt que de calculer une solution, Maple donne un rsultat en
RootOf(...) .
Si l'on veut toutes les solutions, il suffit de se servir de la
commande allvalues(...) .
> allvalues(%); # On veut toutes les solutions.
Solutions numriques
> poly1:=3*x^4-16*x^3-3*x^2+13*x+16;
> solve(poly1,x);
l 2 23* ^5 105* ^4 10* ^2 17* > poly2:=23*x^5+105*x^4-10*x^2+17*x;
> solve(poly2,x);
> allvalues(%); # On veut toutes les solutions > allvalues(%); # On veut toutes les solutions.
La commande fsolve(...) permet d'obtenir des solutions ( ) p
numriques ('f' veut dire 'floating').
P ti i l i l ti (l i d' Pour une quation qui a plusieurs solutions (les racines d'un
polynme, par exemple), fsolve(...) ne donnera pas
obligatoirement toutes les solutions elle ne donne par dfaut que obligatoirement toutes les solutions, elle ne donne par dfaut que
les racines relles.
Pour les racines complexes, il faudra utiliser la commande
allvalues(...).
> fsolve(poly1 {x}); > fsolve(poly1,{x});
> fsolve(poly2,{x});
fsolve(...) a beaucoup d'options. Par exemple, on peut
spcifier dans quel intervalle on veut la solution:
> fsolve(poly1, x, 2..8); # Ses racines entre 2 et 8.
ou bien spcifier que l'on veut les racines complexes:
> fsolve(poly2, {x}, complex); # Ses racines complexes.
Ell bi ill d ll Elle est bien gentille cette commande; elle me retrouve toutes
mes solutions
La commande isolve(...)
Ces commandes sont utiles lorsqu'on cherches des solutions
entires de certaines quations [pour la relation de Bezout, par
l + + + d( )] exemple: a
0
n
0
+ a
1
n
1
+ a
2
n
2
+... = pgcd( n
0
, n
1
,n
2
, ...)].
La commande isolve(...) permet de donner des solutions La commande isolve(...) permet de donner des solutions
entires d'une quation.
> isolve({5*x-3*y=4}); # Solutions entires de 5x - 3y = 4
> solve({x+7*y=1,3*x+2*y=2});
Exercices (Srie2) Exercices (Srie2)
Solutions
Exercice 1.
a)
> z[1] := 6+I*Pi ; convert(z[1], polar);
b) b)
> z[2] := (3-6*I)^(3*I); Re(z[2]); Im(z[2]);
> argument(z[2]); argument(z[2]);
> abs(z[2]);
> sqrt(Re(z[2])^2+Im(z[2])^2); simplify(%);
c)
> z[1] := -1+I ; abs(z[1]); argument(z[1]);
> z[2] := 2*I ; abs(z[2]); argument(z[2]); > z[2] := 2*I ; abs(z[2]); argument(z[2]);
> z[3] :=z[1]/z[2] ;
> convert(z[3],polar); convert(z[3],polar);
> z[3]^n ;
Exercice 2.
a)
> x1 :=1049427; x2 :=17493; x3 :=igcd(x1,x2); isprime(x3);
> ifactor(x1); ifactor(x2); ifactor(x3); > ifactor(x1); ifactor(x2); ifactor(x3);
> x4 :=ilcm(x1,x2); ifactor(x4); # Non demand dans l'exercice
b) b)
> ithprime(500);
c)
> x5 := 200! ; ifactor(x5);
> x6:=2^49*5^49; # il faut penser aux facteurs premiers de 10.
> x5/x6; > x5/x6;
Exercice 3.
) a)
> p[1] := x^4-1; p[2] := x^3+x^2-5*x-5;
> p[1] :=factor(p[1]); p[2] :=factor(p[2]); > p[1] :=factor(p[1]); p[2] :=factor(p[2]);
b)
> restart;;
> poly := (x^2-a)*(x*y+b)*(x^4-y^4)*(3*x+z)*(z-x) ;
> poly1 := expand(poly); poly2 := simplify(poly1);
l 3 i lif ( l ) l 4 f t ( l ) # N > poly3 := simplify(poly); poly4 := factor(poly); # Non
demand dans l'exercice
> sort(poly1 x); > sort(poly1,x);
> sort(poly1,[x,y]);
> sort(poly1,[x,y,z]); (p y ,[ ,y, ]);
> sort(poly1,[x,z]);
> sort(poly1,[x,z,y]);
ff( l ^5) l ff( l ) > coeff(poly, x^5); lcoeff(poly);
Exercice 3.(suite)
b)
> degree(poly); degree(poly x); degree(poly y);degree(poly y); > degree(poly); degree(poly,x); degree(poly,y);degree(poly,y);
# non demand dans l'exercice
> collect(poly,x); # non demand dans l'exercice (p y, );
> collect(poly,[x,y]); # non demand dans l'exercice
> collect(poly,[x,y,z]); # non demand dans l'exercice
ll t( l [ ]) # d d d l' i > collect(poly,[x,z]); # non demand dans l'exercice
> collect(poly,[x,z,y]); # non demand dans l'exercice
Exercice 4.
a)
> p := a*x^3+b*x^2+c*x+d ;
> l ( 0 ) > solve( p=0, x);
b)
> eq := exp(x)-3*x; > eq : exp(x) 3 x;
> solve( eq=0, x);
> plot(-LambertW(x), x);
> plot(LambertW(-1,x), x=-0.5..0.1);
c)
> eq1:= x+2*y+3*z+4*t+10 = 41; > eq1:= x+2*y+3*z+4*t+10 = 41;
eq2:= 8*x+ 4*z+3*t+4 = 11;
eq3:= x+ y+ z+ t+2 = 9; eq3: x y z t 2 9;
eq4:= 3*y+4*z-8*t+4 = 125;
> solve({eq1,eq2,eq3,eq4}, {x,y,z,t});
> solve({eq1,eq2,eq3}, {x,y,z}); # t sera considr comme un
paramtre
Exercice 4. (suite)
d)
> eq1:= x+ y+2*z = 2; eq2:= 2*x+3*y+ z = 4; eq3:= x-y+5*z = 7;
> solve({eq1,eq2,eq3},{x,y,z});
e) e)
> eq1:= x^2+ y^2 = 3; eq2:= x^2+2*y^2 = 3;
> solve({eq1,eq2},{x,y}); ({ q , q },{ ,y});
> allvalues(%);
f)
> fonc:= tan(x)-x;
> solve(fonc);
> allvalues(%); > allvalues(%);
> fsolve(fonc=0,x);
> plot(tan(x)-x,x); p ( ( ) , );
> fsolve(fonc=0,x=1..6);
g)
f ( i ( )) > fonc:=tan(sin(x));
fsolve(fonc=1,x=-Pi..Pi);
1. Fonctions.
1 1 Fonctions plusieurs variables 1.1 Fonctions plusieurs variables,
1.2 Fonctions composes,
1 3 Suites 1.3 Suites,
2. Limites.
3 Drivs 3. Drivs.
3.1 Drives partielles,
3 2 La commande D 3.2. La commande D,
4. Intgrales.
Remarques prliminaires
On peut, avec Maple, afficher quelque chose sans le
calculer. Il suffit de mettre des apostrophes (') au dbut et la
fin de ce qu'on crit.
Si l'on veut insrer une espace il faut alors crer une Si l'on veut insrer une espace, il faut alors crer une
chaine. Pour ce faire, il faut utiliser les guillemets anglais (").
Par exemple :
> 'sin(Pi)' = sin(Pi);
"a marche";
Pour plus de dtail utilisez l'aide du Maple Pour plus de dtail, utilisez l aide du Maple
> ?'
> ?" ?
> restart;
Fonctions Fonctions
Une fonction sous Maple se dfini de la faon suivante :
nom de la fonction:= variable(s) > definition de la fonction nom_de_la_fonction:= variable(s)-> definition_de_la_fonction
> f := x->f (x) ( )
, Il est possible de dfinir une fonction en utilisant la commande
unapply(fonction,variable):
> f := unapply(2*exp( x^2) x/2 x); > f := unapply(2 exp(-x^2)-x/2, x);
Fonctions usuelles
Exemple de fonction sous Maple:
> g(x)=2*x^2-3*x+4; > g(x)=2 x 2-3 x+4;
> f:=x->2*x^2-3*x+4;
L'expression de la fonction: p
> 'g(x)'=g(x);
> 'f(x)'=f(x);
V l d l f ti 2 Valeur de la fonction pour x=2:
> 'g(2)'=g(2); # l'criture de g(x) ne dfinie pas une fonction.
> 'f(2)'=f(2); > f(2) =f(2);
> plot(f(x), x=-5..5);
Un autre exemple de fonctions: p
> f:=x->x^2;
'f(5)' = f(5);
'f( 1)' f( 1) 'f(y+1)' = f(y+1);
Fonctions plusieurs variables Fonctions plusieurs variables
Une fonction plusieurs variables est dfini de la mme
manire qu'une fonction une seule variable, soit:
> f := (x,y) -> sin(x)*cos(y);
Sa valeur en un point donn (x,y) du plan est obtenue par:
> 'f(x,y)' = f(x,y); f(x,y) f(x,y);
'f(15,2)' = f(15,2);
'f(Pi,7)' = f(Pi,7);
'f(8,Pi/2)' = f(8,Pi/2);
Le graphe d'un telle fonction (n'oubliez pas que c'est un Le graphe d un telle fonction (n oubliez pas que c est un
graphe en trois dimensions) :
> plot3d(f(x,y), x=-5..5, y=-4..4); plot3d(f(x,y), x 5..5, y 4..4);
Fonctions composes
Maple sait composer des fonctions entres-elles. On se sert de
l'oprateur @:
( i @ )( ) > (sin@cos)(x);
Un autre exemple plus explicite: Un autre exemple plus explicite:
> g := x -> x^n +a;
h := y -> ln(y); y (y)
'g(h(x))' = (g@h)(x);
'h(g(x))' = (h@g)(x);
On peut galement composer une fonction par elle-mme. On
utilise alors l'operateur @@: utilise alors l operateur @@:
> 'g(x)' = g(x);
'(g@@2)(x)' = (g@@2)(x);
'(g@@3)(x)' = (g@@3)(x);
'(g@@4)(x)' = (g@@4)(x);
U l d f i Un autre exemple de fonction compose:
> (sin@arcsin)(x);
L'operateur @@(-1) permet galement de dfinir la fonction
inverse:
> (sin@@(-1))(x);
> (sin@@(-2))(x); expand(%);
( @@( 1))( ) > (exp@@(-1))(x);
> (exp@@(-2))(x); expand(%);
> (ln@@(-1))(x); > (ln@@(-1))(x);
k1 := x -> (ln@@(-1))(x);
k2 := x -> (ln@@(-2))(x); ( @@( ))( );
'k1(x)'=k1(x); 'k1(x)'=expand(k1(x));
'k2(x)'=k2(x); 'k2(x)'=expand(k2(x));
Suites dfinies par des fonctions p
Les suites dfinies par des fonctions sont des fonctions
"comme les autres", si ce n'est qu'elles sont dfinies dans au
lieu de 9.
> u := n > 3*ln(n) + 4; > u := n -> 3 ln(n) + 4;
Les suites sont en gnrales indexes (u
n
), pour indiquer g (
n
), p q
l'indice n on utilise l'instruction [n] devant la fonction indexer.
> 'u[n]'=u(n);
' [1]' (1) 'u[1]'=u(1);
'u[4]'=u(4);
,Note : Si on dfinie la suite par u
0
et u
n
=f (u
n-1
) alors on a
u
n
= (f
(n)
)(u
0
)
n
( )(
0
)
Limites
La syntaxe pour calculer la limite de la fonction f au point a La syntaxe pour calculer la limite de la fonction f au point a
est de la forme suivante :
limit(f(x), x = a)
Voici quelques exemples :
> limit(sin(x)/x,x=0); ( ( ) , );
> limit(exp(x^2)*(1-erf(x)), x=infinity);
> plot(exp(x^2), x=-5..5);
l t((1 f( )) 5 5) > plot((1-erf(x)), x=-5..5);
> limit((1+x)^(1/x), x=0);
> limit((1+x^2+3*x^3)/(2-3*x+x^3) x=infinity); > limit((1+x 2+3 x 3)/(2-3 x+x 3), x=infinity);
Si on veut juste crire la limite d'une fonction sans l'valuer, il
suffit de mettre une majuscule Limit(f(x) x = a) (L en suffit de mettre une majuscule Limit(f(x), x = a) (L en
majuscule).
> Limit(sin(x), x=0); Limit(sin(x), x 0);
> Limit(sin(x)/x,x=0) =limit(sin(x)/x, x=0);
Limit((1+x)^(1/x),x=0) =limit((1+x)^(1/x), x=0);
De nombreuses options sont disponibles concernant la
direction o vous voulez calculer la limite (si vous voulez calculer
l li it h d it l ) la limite gauche ou droite par exemple).
Pour ces deux dernires limites on utilise les instructions:
limit(f(x), x = a, left) ou limit(f(x), x = a, right) .
, Notez que Maple a le courage de vous dire si une limite n'est q p g
pas dfinie.
> plot(floor(x), x); # Fonction escalier
li it(fl ( ) 1) > limit(floor(x), x=1);
> limit(floor(x), x=1, right);
> limit(floor(x) x=1 left); > limit(floor(x), x=1, left);
La notion de la limite est tendue mme pour des fonction
plusieurs variables: plusieurs variables:
> limit((x^2-y^2)/(x^2+y^2), {x=0, y=0});
> limit(x+1/y, {x=0, y=infinity}); limit(x 1/y, {x 0, y infinity});
> limit(x*y, {x=0, y=infinity});
> limit((sin(x^2)-sin(y^2))/(x-y), {x=0, y=0});
Drives
Drive d'une fonction usuelle
L d i " di i " ti l t t f it Les drives "ordinaires" ou partiels peuvent tre faite en
utilisant la commande diff. La syntaxe de cette commande est :
diff(f(x) x ) diff(f(x), x )
pour une drive ordinaire
diff(f(x,y,z), x )
o f(x,y,z) est la fonction driver et x la variable par rapport
laquelle on drive.
, Notez que si vous crivez Diff(f(...), ... ) la place de
diff(f(...), ... ) , Maple nvaluera pas la drive (D en majuscule).
> Diff(sin(x), x) = diff(sin(x),x);
> Diff((1+x^2+4*x^3)/(1+2*x-x^2), x) = diff((1+x^2+4*x^3)
/(1 2* ^2) ) /(1+2*x-x^2), x);
Les drives multiples peuvent tre values en rptant la
variable plusieurs fois:
> Diff(sin(x^2), x, x)= diff(sin(x^2), x, x);
Ou bien, de manire quivalente en crivant x$n, o n est le , q $ ,
nombre de fois o l'on drive:
Diff( i ( ^2) $2) diff( i ( ^2) $2) > Diff(sin(x^2), x$2)= diff(sin(x^2), x$2);
Drives partielles Drives partielles
De manire similaire, Maple value les drives partielles , p p
d'une fonction plusieurs variables :
> 'Diff(cos(x*tan(y)), x)'= diff(cos(x*tan(y)), x);
, Notez que l'ordre dans lequel Maple drive les fonctions est
de gauche droite (dans l'ordre o vous les crivez) Parfois de gauche droite (dans l ordre o vous les crivez). Parfois
(assez rarement), cet ordre peut tre important.
> 'Diff(cos(x+y^2), x, y)'= diff(cos(x+y^2), x, y); ( ( y ), , y) ( ( y ), , y);
> 'Diff(cos(x+y^2), y, x)'= diff(cos(x+y^2), y, x):
> 'Diff((x^2+y^2)*(ln(x)-ln(y)), x$2, y)'= diff((x^2+y^2)*
(l ( ) l ( )) $2 ) (ln(x)-ln(y)), x$2, y);
> 'Diff((x^2+y^2)*(ln(x)-ln(y)),y,x$2)'= diff((x^2+y^2)*
(ln(x)-ln(y)) y x$2): (ln(x)-ln(y)), y, x$2):
La commande D
Un autre moyen pour driver les fonction est d'utiliser le
symbole D qui peut tre appliqu une fonction sans avoir symbole D, qui peut tre appliqu une fonction sans avoir
spcifier ses arguments.
> D(sin);
> unassign('f','g');
D(f@g);
D(f*g) D(f*g);
> D(exp@cos)(x); diff(exp(cos(x)), x);
> D(cos@ln)(x); diff(cos(ln(x)), x); > D(cos@ln)(x); diff(cos(ln(x)), x);
> D(exp@cos@ln)(x); diff(exp(cos(ln(x))), x);
Cela peut bien sur tre itr en utilisant le symbole @@n (o
n est un entier) dans la composition de D.
> (D@@2)(sin); > (D@@2)(sin);
- sin
Ou encore en utilisant l'indexation en i, dans la forme D[i], ce
qui donnera une drive partielle par rapport la i
me
variable:
> D[1]((x y) > x^7*y^3); # drive partielle par rapport x > D[1]((x,y)-> x^7*y^3); # drive partielle par rapport x
> D[2]((x,y)-> x^7*y^3); # drive partielle par rapport y
Pour des drives partielles, on utilise une indexation par
rapport l'ordre dont on veut driver les fonctions :
> D[1,1]((x,y)-> x^7*y^3);
> D[2 2]((x y) > x^7*y^3); > D[2,2]((x,y)-> x^7*y^3);
> D[1,2]((x,y)-> x^7*y^3);
> D[2,1]((x,y)-> x^7*y^3); [ , ](( ,y) y );
> D[1,2$2]((x,y)-> x^7*y^3);
> D[1$2,2]((x,y)-> x^7*y^3);
$ $ > D[1$2,2$2]((x,y)-> x^7*y^3);
Intgrales
Maple sait calculer les intgrales, grce la commande Int.
La syntaxe pour les intgrales indfinies (les "primitives")
est :
int(expr x) int(expr, x)
o expr est l'expression que vous intgrez et x la variable par
rapport laquelle vous intgrez. rapport laquelle vous intgrez.
Pour les intgrales dfinies, la syntaxe est la suivante :
int(expr, x=a..b)
o expr est l'expression que vous intgrez et a..b l'intervalle sur
lequel vous intgrez lequel vous intgrez.
,Note: Comme pour la drive, si on crit Int(expr, x) la place ,Note: Comme pour la drive, si on crit Int(expr, x) la place
de int(expr, x), vous aurez la forme non value.
> Int( tan(x), x ) = int( tan(x), x );
> Int( (1 x^2)/(1+x^2) x ) = int( (1 x^2)/(1+x^2) x ); > Int( (1-x^2)/(1+x^2), x ) = int( (1-x^2)/(1+x^2), x );
> Int( x^2*exp(-x^2), x ) = int( x^2*exp(-x^2), x );
Voici quelques intgrales dfinies et impropre :
> Int( cos(x), x=-Pi/2..Pi/2 ) = int( cos(x), x=-Pi/2..Pi/2 );
> Int( x^2*exp(-x^2), x=0..infinity ) = int( x^2*exp(-x^2),
x=0 infinity ); x=0..infinity );
> Int( exp(-x^2), x=0..infinity ) = int( exp(-x^2), x=0..infinity );
Les intgrales multiples sont faites par itration de l'intgrale :
I (I (I ( ( ) 0 ) 0 ) 0 1) > Int(Int(Int(exp(-x-y-z),x=0..y), y=0..z), z=0..1)
= int(int(int(exp(-x-y-z),x=0..y), y=0..z), z=0..1);
Exercices (Srie3) Exercices (Srie3)
Solutions
Exercice 1.
a) Dfinissez la fonction f (x) = sin(x)cos(x) a) Dfinissez la fonction f
1
(x) = sin(x)cos(x).
Tracer la fonction entre 0 et .
Calculez f
1
(0) et f
1
() Calculez f
1
(0) et f
1
()
> f[1]:=x-> sin(x)*cos(x);
> plot(f[1](x), x=0..Pi);
> f[1](0); f[1](Pi);
b) Dfinissez la fonction f (x y) = e
(xy)
cos(x)sin(y) b) Dfinissez la fonction f
2
(x,y) = e
(xy)
cos(x)sin(y).
Tracer sa courbe reprsentative pour x = .. et y = .. .
> f[2]:=(x,y)-> x*exp(-x^2-y^2); # non demand dans l'exercice [ ] ( ,y) p( y );
> plot3d(f[2](x,y), x=-2..2, y=-2..2, color=y); # non demand
dans l'exercice
> f[2]:= exp(x*y)*cos(x)*sin(y);
> plot3d(f[2](x,y), x=-Pi..Pi, y =-Pi..Pi, color=x);
Exercice 1.(suite)
c) Dfinissez la fonction g(x) =3x/ ln(x). Que vaut e
g
? Et g(exp) ?
> g:=x->3*x/ln(x);
> 'exp(g)'=(exp@g)(x); > exp(g) =(exp@g)(x);
> 'g(exp)'=(g@exp)(x);
d) Soit la suite u
n
dfinie par u
0
= 3 et u
n
= ln(u
n1
) + 5.
Calculez les 5
me
, 10
me
et 100
me
termes en fonction de u
0
.
Refaites le calcul si u
0
= 10
> u[0] :=3;
> u[n] :=n > ln(u[n 1])+5; > u[n] :=n-> ln(u[n-1])+5;
> f:=x-> ln(x)+5;
> 'u[n]'=(f@@n)(u[0]); u[ ] ( @@ )(u[0]);
> 'u[1]'=(f@@1)(u[0]); 'u[2]'=(f@@2)(u[0]); 'u[3]'=(f@@3)(u[0]);
> 'u[5]'= evalf((f@@5)(u[0]));
'u[10]'= evalf((f@@10)(u[0]));
'u[100]= evalf((f@@100)(u[0]));
Exercice 2.
a) Trouvez la limite en + et - de la fonction f
3
= sin(x)cos(x)/x
> f[3] :=x-> sin(x)*cos(x)/x; [ ] ( ) ( ) ;
> Limit(f[3](x), x=-infinity)= limit(f[3](x), x=-infinity);
Limit(f[3](x), x=infinity)= limit(f[3](x), x=infinity);
b) Quelle est la limite en 0 de la fonction f
4
= 4cos(x)/(1 x
2
)?
> f[4] :=x-> 4*cos(x)/(1-x^2); > f[4] :=x-> 4 cos(x)/(1-x 2);
> Limit(f[4](x), x=0)= limit(f[4](x), x=0);
c) Quelle est la limite en 1 droite de floor(x)? Quelle est la limite
en 1 gauche de cette fonction ?
li it(fl ( ) 1) > limit(floor(x), x=1);
> limit(floor(x), x=1, right);
> limit(floor(x) x=1 left); > limit(floor(x), x=1, left);
Exercice 3.
) Q ll l d i d ( )/ ( )? a) Quelle est la drive de u(x)/v(x)?
Calculez la drive seconde de ce quotient.
> restart; > restart;
> Diff((u(x)/v(x)), x)= diff((u(x)/v(x)), x);
> Diff((u(x)/v(x)), x$2)= diff((u(x)/v(x)), x$2); (( ( ) ( )), ) (( ( ) ( )), );
b) Donnez toutes les drives partielles d'ordre 1 de
f ( )
( )
( ) i ( ) f
2
(x, y) = e
(xy)
cos(x)sin(y).
Donnez toutes les drives partielles d'ordre 2 de f
2
.
Ecrivez ces formules de deux faons diffrentes Ecrivez ces formules de deux faons diffrentes
> f[2] := (x,y) -> exp(x*y)*cos(x)*sin(y);
> "premire criture"; p ;
> "drives premires";
> Diff(f[2](x,y), x)= diff(f[2](x,y), x);
Diff(f[2]( ) ) diff(f[2]( ) ) Diff(f[2](x,y), y)= diff(f[2](x,y), y);
Exercice 3.(suite)
> "drives secondes";
> Diff(f[2](x y) x$2)=diff(f[2](x y) x$2); > Diff(f[2](x,y), x$2)=diff(f[2](x,y), x$2);
Diff(f[2](x,y), y$2)= diff(f[2](x,y), y$2);
> Diff(f[2](x,y), x, y)= diff(f[2](x,y), x, y);
Diff(f[2](x,y), y, x)= diff(f[2](x,y), y, x);
> "seconde criture";
> "drives premires"; > drives premires ;
> D[1](f[2]); D[2](f[2]);
> "drives secondes";
> D[1$2](f[2]); D[2$2](f[2]);
> D[1,2](f[2]); D[2,1](f[2]);
Exercice 3 (suite) Exercice 3.(suite)
c) Dfinissez la fonction g(x) = x
2
+ ln(3x). Puis, en une seule ligne c) Dfinissez la fonction g(x) x ln(3x). Puis, en une seule ligne
de commande, tracez sur un mme graphe la fonction g, ainsi que
ses deux premires drives, pour x compris entre 0.5 et 2
> g:=x >x^2+ln(3*x); D(g); (D@@2)(g); > g:=x->x^2+ln(3*x); D(g); (D@@2)(g);
> plot([g(x),D(g)(x), (D@@2)(g)(x)], x=0.5..2,
color=[red,blue,green] ); color [red,blue,green] );
Exercice 4.
2
a) Soit f
5
(x) = e
(x
2
)
Calculez l'intgrale de f
5
entre 0 et l'infini.
C l l l'i t l d f t + t Calculez l'intgrale de f
5
entre + et -.
> f[5] :=x -> exp(-x^2);
> 'Int(f[5](x), x=0..infinity)'= Int(f[5](x), x=0..infinity); > Int(f[5](x), x 0..infinity) Int(f[5](x), x 0..infinity);
'Int(f[5](x), x=0..infinity)'= int(f[5](x), x=0..infinity);
> Int(f[5](x), x=-infinity..infinity)= int(f[5](x), x=-infinity..infinity);
b) Tracez les deux courbes: y = et y=x/2 entre 0 et 16.
Calculez les intgrales de ces deux fonctions entre 0 et 16
4x
Calculez les intgrales de ces deux fonctions entre 0 et 16.
Puis, par un calcul d'intgrale, donnez l'aire entre les deux courbes
> plot([sqrt(4*x), x/2], x=0..16, color=[red,blue] ); plot([sqrt(4 x), x/2], x 0..16, color [red,blue] );
> Int(sqrt(4*x), x=0..16)= int(sqrt(4*x), x=0..16);
> Int(x/2, x=0..16)= int(x/2, x=0..16);
> Int(sqrt(4*x)-x/2, x=0..16)= int(sqrt(4*x)-x/2, x=0..16);
Exercice 4. (suite)
c) Cherchez une primitive en x de la fonction c) Cherchez une primitive en x de la fonction
f
6
(x, y, z) = e
(x+y)
-3sin(xz) +[ln(z)/x]
Calculez une primitive en y et une en z de cette fonction. Calculez une primitive en y et une en z de cette fonction.
Vrifiez vos rsultats.
> f[6] := (x,y,z) -> exp(x+y)-3*sin(x*z)+ln(z)/x;
> 'Int(f[6](x,y,z), x)'= int(f[6](x,y,z), x); diff(%,x);
> 'Int(f[6](x y z) y)'= int(f[6](x y z) y); diff(% y); > Int(f[6](x,y,z), y) = int(f[6](x,y,z), y); diff(%,y);
> 'Int(f[6](x,y,z), z)'= int(f[6](x,y,z), z); diff(%,z);
> 'Int(Int(f[6](x,y,z), x), y)' = int(int(f[6](x,y,z), x),y); diff(%,x,y); ( ( [ ]( ,y, ), ), y) ( ( [ ]( ,y, ), ),y); ( , ,y);
> 'Int(Int(Int(f[6](x,y,z), x), y), z)' = int(int(int(f[6](x,y,z),x), y),z);
diff(%,x,y,z);
1. Graphiques en deux dimensions 1. Graphiques en deux dimensions
1.1 Introduction aux graphiques
1.2 Package "plots"
2. D'autres type de graphes en 2-d
2.1 Courbes paramtres
2 2 Ch d t 2 d 2.2 Champs de vecteurs en 2-d
2.3 Graphes de courbes dfinies implicitement
2 3 1 Fonctions implicites 2.3.1 Fonctions implicites
2.3.2 Graphes de points
2.4 D'autres systmes de coordonnes y
2.5 Ingalits
2.6 Echelles logarithmiques
3 G hi t i di i 3. Graphiques en trois dimensions
4. Animations.
Graphiques en deux dimensions
Maple dispose de nombreuses commandes et fonctions pour Maple dispose de nombreuses commandes et fonctions pour
tracer des fonctions, des graphiques ou des animations en deux
ou trois dimensions.
Pour tracer un graphique avec Maple on utilise la syntaxe
gnrale suivante : gnrale suivante :
plot_type(expression, intervalle, options,..), indiquant le type
de graphique que l'on veut tracer, o : de graphique que l on veut tracer, o :
-expression est une expression mathmatique ou un ensemble
d'expression dfinissant la (les) fonctions tracer d expression dfinissant la (les) fonctions tracer.
-intervalle est de la forme x = a..b avec a et b des nombres rels
et a < b ou une liste d'intervalles de la mme forme et a < b, ou une liste d intervalles de la mme forme.
- option correspond une ou plusieurs spcifications
optionnelles qui dterminent l'apparence du graphe (titre optionnelles qui dterminent l'apparence du graphe (titre,
chelles, etc.).
La commande de base pour tracer un graphique est la
commande plot. Cependant, de nombreuses commandes
existent pour tracer diffrents type de graphiques.
Il existe mme un package (un librairie) pour tracer certains
hi C k ' ll l t t i l graphiques. Ce package s'appelle plots, et pour pouvoir le
charger en mmoire il faut avoir recours la commande : with
(plots): (plots):.
Si on charge tout le package en mmoire on peut faire appel
la commande en tapant commande Mais si tout le package la commande en tapant commande. Mais si tout le package
n'est pas charg on peut toujours crire plots[command] qui
donnera le mme rsultat.
, Remarquons que si l'on remplace le deux-points final par un
point virgule, cd with(plots);, Maple va afficher l'ensemble des
nouvelles fonctions et commandes qu'il a charg en mmoire.
>?plots
# N'oubliez pas que l'aide est toujours l pour vous aider et
vous rappeler des diffrentes instructions de base
Le type le plus simple de graphiques en deux dimensions est Le type le plus simple de graphiques en deux dimensions est
obtenu par une expression de la forme :
plot3d (f(x,y), x=a..b, y=c..d, opt1, opt2, ...) p ( ( ,y), , y , p , p , )
o les terme en italiques sont optionnels.
f( ) t f ti d d t d l i bl ll t l f(x) est une fonction dpendantes de la variable relle x et le
domaine o l'on va tracer la fonction est x=a..b (avec a < b).
Nous verrons les options les plus souvent utilises.
> ?plot[options] p [ p ]
Voici un exemple de la commande plot qui vous donne
l t l' ll d' f ti t l i l seulement l'allure d'une fonction courante par exemple exp, sin, ln
...
> plot(sin*ln); > plot(sin ln);
1Attention si on introduit la variable x:
> plot(sin(x)*ln(x),x);
Le Maple est incapable d'valuer les valeurs numriques de la
fonction par dfaut de la rgion des valeurs de la variable x; fonction par dfaut de la rgion des valeurs de la variable x;
le Maple vous demande de voire la page de l'aide pour le Maple vous demande de voire la page de l aide pour
s'assurer de la squence correcte pour tracer les graphiques en
deux dimensions.
Pour tracer le graphe, on doit introduire l'intervalle d'tude.
> plot(sin(x)*ln(x) x= 10 10); > plot(sin(x)*ln(x),x=-10..10);
Et un autre graphique avec un titre, et la spcification des
caractres et du style de la police utilise. y p
> plot(x*sin(x), x=-3*Pi..3*Pi, title="x*sin(x)",
titlefont=[HELVETICA, BOLD,18]);
Un autre avec des noms aux axes pour cela on introduit
l'option labels=[....]: p [ ]
> plot(exp(-t^2), t=0..4, labels=[eleves, notes]);
Introduction aux graphiques
Lorsqu'on essaie de tracer une fonction discontinue, Maple va
essayer par dfaut de joindre les points de discontinuits essayer par dfaut de joindre les points de discontinuits.
Ce qui peut viter en mettant l'option discont = true, Maple
va dterminer les points de discontinuits de l'expression et
sparera l'intervalle de dfinition en sous intervalles o la
fonction est contin e fonction est continue.
Voici l'exemple d'une fonction discontinue : Voici l exemple d une fonction discontinue :
> plot(x-floor(x), x=-3..3);
> plot(x-floor(x), x=-3..3, discont=true);
L'option scaling = constrained permet d'avoir la mme
h ll l d d h chelle sur les deux axes du graphe.
,Attention par dfaut ce n'est pas le cas ! ,Attention, par dfaut ce n est pas le cas !
> plot(x-floor(x), x =-3..3, scaling=constrained);
> plot(x-floor(x), x=-3..3, discont=true, scaling=constrained);
Par dfaut, Maple calcule un minimum de 50 points par
graphe, mais dans le cas o il est ncessaire d'augmenter ce
nombre de points; pour optimiser, on utilise alors l'option
i t numpoints.
Considrons l'exemple d'une fonction d'amplitude trs petite Considrons l exemple d une fonction d amplitude trs petite.
> plot(x^3*sin(exp(1/x)), x=(.2)..(.3));
> plot (x^3*sin(exp(1/x)),x=(.2)..(.3), numpoints=5);
> plot (x^3*sin(exp(1/x)),x=(.2)..(.3), numpoints=500);
Spcification d'un graphe
Voici deux faon de spcifier la couleur d'un graphe deux
dimensions : dimensions :
> plot(BesselJ(0,x), x=0..10, color=green);
> plot(BesselJ(1,x), x=0..10, color=COLOR(RGB,.8,.4,.4));
> plot([BesselJ(1,x),BesselJ(0,x)],x= 0..10, color= [red,green],
st le [line point ]) # on pe t dfinir a ssi le st le de la style = [line, point ]); # on peut dfinir aussi le style de la
courbe
En utilisant l'option style=point on trace un graphe de faon
discrte.
Trac de plusieurs fonctions
On peut tracer plusieurs graphes sparment l'un de l'autre :
> plot(x-x^3/6 x = -1 1); > plot(x x 3/6, x 1..1);
> plot(sin(x), x = -1..1);
Le Maple peut galement tracer plusieurs courbes la fois
avec la commande plot, pour diffrencier entre les graphes: on
pe t imposer diffrentes options tels q e la co le r le st le etc peut imposer diffrentes options tels que la couleur, le style, etc.
pour chacune des courbes.
>plot([sin(x), x-x^3/6, cos(x)], x=-1..1, color=[red, >plot([sin(x), x x 3/6, cos(x)], x 1..1, color [red,
blue,green], style= [point,line,patch]);
De manire gnrale, plusieurs courbes peuvent tre traces
simultanment avec la syntaxe gnrale suivantes :
plot([expr1 expr2 exprn] range color=[c1 c2 ] plot([expr1,expr2, ... , exprn], range, color=[c1, c2, ...],
style=[s1,s2, ... ], ...)
La librairie ou package "plots"
Un autre moyen d'afficher plusieurs graphes en mme temps
est d'utiliser la commande display. Cette commande fait partie
d k l t du package plots.
Cette commande peut donc soit tre utilise sous la forme Cette commande peut donc soit tre utilise sous la forme
plots[display] soit sous la forme display en chargeant d'abord
en mmoire le package en entier, via la commande with(plots). p g (p )
> plot1:=plot(sin(x), x=-Pi..Pi, color=red):
plot2:=plot(cos(x), x=-2*Pi..2*Pi, color=green): p p ( ( ), , g )
plot3:=plot( x-x^3/6+x^5/120-x^7/7!+x^9/9!, x=-1..1,
color=yellow):
# trois graphes (pas affichs).
> display([plot1,plot2,plot3]);
> plots[display] ([plot1,plot2,plot3]);
# Affichage des trois graphes. display([plot1,plot2,plot3]);
ETUDE LOCALE DES FONCTIONS NUMRIQUES
Dveloppements
Pour les dveloppements limits ou de Taylor:
l ( ) taylor(expr ,x=a,n)
Pour des dveloppements asymptotiques plus gnraux: Pour des dveloppements asymptotiques plus gnraux:
series(expr ,x=a ,n) ou asympt(expr , x=a , n). ( p , , ) y p ( p , , )
L'ordre n est facultatif et vaut 6 par dfaut .
> 'taylor(sin(x),x)' = taylor(sin(x),x); # x=0 par dfaut
>'taylor(x^2/(x^2+1), x=infinity,10)' = taylor(x^2/(x^2+1),
x=infinity,10);
>'series(exp(x)/x x 9)' =series(exp(x)/x x 9); # a=0 par dfaut > series(exp(x)/x,x,9) =series(exp(x)/x,x,9); # a=0 par dfaut
> 'Series(1*x-1/6*x^3+1/120*x^5+O(x^6),x,6)' = series(1* ( ( ), , ) (
x-1/6*x^3+1/120*x^5+O(x^6),x,6);
t(l ( 1/ ) 7) # t j l l'i fi i > asympt(ln(x+1/x),x,7); # toujours en plus l'infini
> 'series(ln(x+1/x) x 7)' = series(ln(x+1/x) x 7); > series(ln(x+1/x),x,7) = series(ln(x+1/x),x,7);
> Sum(x, x=1..4) = sum(x, x=1..4); ( ) ( )
> restart; restart;
> Sum(1/k,k=1..n) = sum(1/k,k=1..n);
> Sum(1/k,k=1..infinity) = sum(1/k,k=1..infinity);
Limit(ln(n), n=infinity)=limit(ln(n),n=infinity);
> Limit(Sum(1/k,k=1..n)-ln(n), n=infinity) =
limit(sum(1/k,k=1..n)-ln(n), n=infinity); limit(sum(1/k,k 1..n) ln(n), n infinity);
> 'gamma' = asympt(Sum(1/k,k=1..n)-ln(n),n,10); # la
constante d'Euler gamma
> Psi(n+1); gamma; > Psi(n+1); gamma;
> evalf(gamma);
Affichage du terme principal d'une srie
L d l dt t d' ffi h l t i i l d' La commande leadterm permet d'afficher le terme principal d'une
srie:
> series(sin(x^3)/(2*x),x=0,10);
> series(leadterm(sin(x^3)/(2*x)),x=0); ( ( ( ) ( )), );
Conversion en polynme de Taylor p y y
Pour convertir un dveloppement en polynme, on utilisera la
commande convert(taylor(expr ;x=a,n))
> P:=convert(taylor(exp(x),x=0,5),polynom); ( y ( p( ), , ),p y );
> f := (x^3+x)/(x^2-1);
> convert(f, parfrac, x);
i (f 4) > s := series(f,x,4);
> s:=convert(s, polynom); 's'=s; # Drop the order term;
QUATIONS ET SYSTMES DIFFRENTIELS
Equations du premier ordre Equations du premier ordre
Avec MAPLE; nous pouvons rsoudre directement les
ti d t l i li i f t i t t quations de type classique - linaire - avec facteur intgrant -
sparable - homogne - rsolue en x - de Bernoulli de Clairaut -
de Riccati de Riccati.
Pour cela on utilise la commande dsolve(eq,y(x)) o eq
dsigne l'expression de l'quation rsoudre dsigne l'expression de l'quation rsoudre.
quation y ' + 3 y = exp(-x)
>restart: eq:= diff(y(x),x)+3*y(x)=exp(-x); dsolve(eq,y(x)); restart: eq: diff(y(x),x) 3 y(x) exp( x); dsolve(eq,y(x));
Dans la rsolution le terme du type _C1 dsignera la
Constante relle arbitraire Constante relle arbitraire.
Pour tenir compte et dfinir cette constante, on introduit la
condition initiale de la manire suivante :
dsolve(eq,y(0)=val, y(x)).
> dsolve({eq,y(0)=1.5},y(x));
,Remarque:
Les solutions y(x) ne sont pas directement utilisables pour
t l b i t l i l i t reprsenter les courbes intgrales, voir exemple suivant:
> plot(y(x),x);
Warning unable to evaluate the function to numeric values in Warning, unable to evaluate the function to numeric values in
the region; see the plotting command's help page to ensure the
calling sequence is correct g q
Plotting error, empty plot
fff( ) ^2+1 fff(2) > fff(x):=x^2+1; fff(2);
> ggg:=x->x^2+1; ggg(2);
Reprsentation des courbes intgrales
Pour cela on doit assigner la solution y(x) on utilisera la
commande assign, puis utiliser la commande
l ( ( ) C1 ) i i P d' unapply(y(x),_C1,x) qui, pour une expression P d'une
variable libre x ( ou couple de variables libres (x,y)), retourne la
fonction qui la variable x (x y) associe P fonction qui la variable x (x,y) associe P.
> restart: eq:=diff(y(x),x)+3*y(x)=exp(-x); dsolve(eq,y(x)); q (y( ) ) y( ) p( ) ( q y( ))
> assign(dsolve(eq,y(x))); y:=unapply(y(x),_C1,x);
E fi bt i l' bl d b d l Enfin pour obtenir l'ensemble des courbes avec des valeurs
rgulirement espaces du paramtres , on peut utiliser la
commande seq(y(x C1) C1=a b) combine la commande { } commande seq(y(x,_C1),_C1=a..b) combine la commande { }.
> seq(y(_C1,x),_C1=-3..3);
> plot({seq(y(_C1,x),_C1=-1..1)}, x=-5..5, y=-2..2);
On peut prciser des options de rsolution par exemple :
series (chercher les solutions sous forme de sries) ( )
> eq:={diff(z(x),x)+z(x)*cos(x)=1,z(0)=1};
d l ( ( )) > dsolve(eq,z(x));
> dsolve(eq,z(x),series);
La fonction odeplot(dsn, vars, range, options)(y(x,_C1) du
package plots permet de reprsenter les solutions d'une quation p g p p p q
diffrentielle.
La solution pourra tre visualise graphiquement avec la
f ti d l t ( di diff ti l ti l t) d l fonction odeplot (pour ordinary differential equation plot) de la
bibliothque graphique plots:
Le premier argument est le nom de la procdure Le premier argument est le nom de la procdure,
Le deuxime une liste qui donne la ou les reprsentations
choisies (f(x) en fonction de x ou x en fonction de f(x)). ( ( ) ( ))
Le troisime argument donne l'intervalle des valeurs choisies
pour x .
> restart; with(plots,odeplot);
odeplot
D( )( ) ( ) > D(z)(x) = z(x);
> dsolve({D(z)(x) = z(x),z(0)=1}, z(x));
> D(z)(x) = z(x);
p:= dsolve({D(z)(x) = z(x),z(0)=1}, z(x),type=numeric): p ({ ( )( ) ( ), ( ) }, ( ), yp )
odeplot(p,[x,z(x)], -2..0.5, title="Fonction exponentielle");
D( )( ) ( ) >D(z)(x) = z(x);
p:= dsolve({D(z)(x) = z(x),z(0)=1}, z(x),type=numeric):
odeplot(p -2 0 5 title="Fonction exponentielle"); odeplot(p,-2..0.5, title= Fonction exponentielle );
Equations du second ordre
Avec MAPLE; nous pouvons rsoudre galement les quations
de second ordre de type classique - linaire - d'Euler - de Bessel
Pour cela on utilise la commande dsolve(eq,y(x)) o eq
dsigne l'expression de l'quation rsoudre. g p q
Les options de rsolution sont les mmes qu' l'ordre 1.
quation y " + y ' + y = t quation y + y + y = t
> restart: eq2:=diff(y(t),t$2)+diff(y(t),t)+y(t)=t;
> 2 diff( (t) `$`(t 2))+diff( (t) t)+ (t) t > 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));
SYSTMES DIFFRENTIELS
Pour cela on utilise la commande dsolve(eq,y(x)) o eq
dsigne l'expression de l'quation rsoudre.
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)});
> dsolve({sys, x(0)=0, y(0)=1}, {x(t),y(t)});
> q:=dsolve({sys,x(0)=0,y(0)=1},{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) color=red] [t y(t) color=blue]] > with(plots): odeplot(p,[[t,x(t), color=red],[t,y(t), color=blue]],
-1..2);
>t^2*diff(y(t),t$2)+2*t*diff(y(t),t)+y(t)=0; (y( ), $ ) (y( ), ) y( ) ;
dsolve(t^2*diff(y(t),t$2)+2*t*diff(y(t),t)+y(t)=0,y(t));
Rsolution d'quations aux drives partielles
Pour cela on utilise la commande dsolve(eq,y(x)) o eq
dsigne l'expression de l'quation rsoudre.
> edp:=y*diff(U(x,y),x)+x*diff(U(x,y),y)=0;
| | c c
| |
> pdsolve(edp U(x y));
( , ) ( , ) 0 y U x y x U x y
x y
| | c c
| |
+ =
| |
c c
\ .
\ .
> pdsolve(edp,U(x,y));
2 2
( , ) 1( ) U x y F x y = +
o _F1 dsigne une fonction arbitraire de classe C1 de la variable
( , ) _ 1( ) U x y F x y +
-x^2+y^2 .
1) Dfinir un vecteur, matrice en Maple
2) Oprations sur les vecteurs et matrices: Somme,
multiplication, matrice inverse, puissance, p , , p ,
3) Etude dune matrice: Trace, rang, valeurs
propres, vecteurs propres, transpos,
diagonalisation, jordanisation, g , j ,
4) Exemple
A rendre le 06/06/2011 avant Midi (rapport+cd/usb)
TESTS
Structures Boolennes Structures Boolennes
Ce sont des structures concernant des variables boolennes
i t d l i (t ) f (f l ) qui ne prennent que deux valeurs : vrai (true) ou faux (false).
L'valuation des Boolens se fait par l'intermdiaire de la
commande evalb( ): La fonction evalb permet de tester cette commande evalb(......): La fonction evalb permet de tester cette
galit.
Les oprations logiques permettant de construire des p g q p
expressions boolennes plus labores sont utiliss partir des
oprateurs : ngation not(......) , et conjonction (...and...) et
di j ti ( ) disjonction (...or...).
> evalb (2 = 3); evalb (2 = 3); evalb (2 > 3);
> evalb ((2 <=3) or (2 >=3)); > evalb ((2 <=3) or (2 >=3));
> evalb ((2 <=3) and (2 >=3));
> evalb (not ((2 <=3) or (2 >=3)));
> evalb (not ((2 <=3) and (2 >=3)));
> not (2 =3); evalb (%);
Structure de test
Un test permet deffectuer des groupes de commandes si
certaines conditions sont vrifies ou non.
La syntaxe peut se prsenter comme suit
if condition then commande effectuer fi commande if condition then commande effectuer fi commande
effectuer (else sinon et end if " fin du bloc if ")
On comprend aisment l'criture suivante (sachant que if
signifie si, then signifie alors, fi signifie passer la syntaxe qui
it t i l d ) suit ou terminer la commande.)

if condition then 1 choix de commande effectuer

else 2 choix de commande effectuer fi commande effectuer
( if signifie si, then signifie alors, else signifie sinon. )

if condition then 1 choix de commande effectuer

else 2 choix de commande effectuer fi commande effectuer
(if i ifi i th i ifi l l i ifi i ) (if signifie si, then signifie alors, else signifie sinon.)
if condition then 1ier choix de commande effectuer if condition then 1ier choix de commande effectuer
elif condition then 2ime choix de commande effectuer
elif condition then 3ime choix de commande effectuer
.........................................................................
.........................................................................
.........................................................................
elif condition then nime choix de commande effectuer
else (n+1)ime choix de commande effectuer else (n+1)ime choix de commande effectuer
fi commande effectuer
(elif est la contraction de else et if)
> restart; > restart;
> a:=2; if a < 3 then "a est infrieur 3" fi;
> a := 4; if a < 3 then "a est infrieur 3" fi;
f f f > a := 4; if a < 3 then "a est infrieur 3" fi;
if a>3 then "a est suprieur 3" fi;
> a := 4; if a < 3 then "a est infrieur 3" else "a est suprieur
3" fi;;
> a := 3; if a < 3 then "a est infrieur 3" elif 3 <= a <= 4 then
" t i t 3 t 4" l " t i 4" fi "a est comprise entre 3 et 4" else "a est suprieur 4" fi;
BOUCLES
Boucle for Boucle for
Une boucle permet la rptition du calcul d'une expression ou
d' it d' i d'une suite d'expressions.
Elle commence par le mot cl for suivi du nom de la variable Elle commence par le mot cl for suivi du nom de la variable
de comptage ( x ).
Celle-ci dbute la boucle avec la valeur qui suit le mot cl
from, puis est incrmente de la valeur ( p ) suivant le mot cl by
t i t t ' ll t i f i l l l i t l et ceci tant qu'elle reste infrieure ou gale la valeur suivant le
mot cl to.
, La variable de comptage (p) nest pas muette : elle vaut la
dernire valeur calcule avant le test arrtant la boucle.
Un groupe 'form d'une expression ou plusieurs expressions (
ensemble d'instructions) est plac entre les mots cls do et end
d ( d) t l t ti do (ou od) et spares par la ponctuation ; ou :
Ici il n'y a trois expressions: La premire est une liste de deux Ici il n y a trois expressions: La premire est une liste de deux
nombres, la deuxime une mise en facteur premiers et la
troisime l'affichage d'un symbole non assign. g y g
for x from x1 to x2 by p do groupe od :
,Attention les variables x1 et x2 doivent tre de du type numeric
mais pas de type constant comme ou Dans ce dernier il faut 2
t
mais pas de type constant comme ou . Dans ce dernier il faut
utiliser evalf
2
t
> type (Pi constant ); type (sqrt(2) constant) ; > type (Pi, constant ); type (sqrt(2) , constant) ;
> type (Pi, numeric) ; type (sqrt(2) , numeric) ;
> type ("2",'character' ); yp ( , );
> type (2,'character' );
f f / / ( * ) > for x from 0 by 3 / 4 to Pi / 2 do cos (Pi * x) end do;
Error, final value in for loop must be numeric or character
> for x from 0 by 3 / 4 to evalf (Pi / 2) do cos(Pi * x) end do; > for x from 0 by 3 / 4 to evalf (Pi / 2) do cos(Pi x) end do;
Nombres paires comprises entre 6 et 10: p p
> for i from 6 by 2 to 10 do print (i) end do;
> restart;
E l C l l d' it d f t i l Exemple : Calcul d'une suite de factoriel
> for i from 0 by 2 to 6 do [i, i!] ; ifactor (i!) ; `-----`; end do;
> type (Pi, constant ); type (sqrt(2) , constant) ;
> type (Pi, numeric) ; type (sqrt(2) , numeric) ; yp ( , ) ; yp ( q ( ) , ) ;
> type ("2",'character' );
> type (2,'character' );
> restart;
Exemple : Calcul d'une suite de factoriel Exemple : Calcul d une suite de factoriel
> for i from 0 by 2 to 6 do [i, i!] ; ifactor (i!) ; `-----`; end do;
> x=1. ;
to 4 do
( ( ) ) / ( i ( ) 1) x:=x+(cos(x)-x) / (sin(x)+1) :
end do;
> x=1. ;
to 4 by 0.1 do y
x:=x+(cos(x)-x) / (sin(x)+1) :
end do;
Application une suite du type u[k]:= ln(1+u[k-1]):
> u[0]:=1:
for k from 1 to 10 do u[k]:= ln(1+u[k-1]); print ('k'= k); od;
,Mot cl NULL; Ce mot cl est un concept informatique plutt p q p
que mathmatique. Il ne signifie pas qu'un objet est nul (gal 0),
mais qu'il n'existe pas.
X NULL ' ' > X:=NULL; 'x'= x;
Cration d'une squence des 5 premiers nombres pairs:
> L:=[ 0, 1, 2, 3, 4] ;
for k in L do k, 2*k od;
> L:=[ 0, 1, 2, 3, 4] ;
S:=NULL;
f k i L d S S 2*k d S for k in L do S:=S, 2*k: od: S ;
> restart;
> tot := 0; for z in 1, x, y, q
2
, 3 do tot := tot+z end do; tot;
> tot := 0; for z in [1, x, y, q
2
, 3] do tot := tot+z end do; tot;
Boucle While
On peut galement construire des boucles for avec le mot cl
while suivi d'une condition logique (expression boolenne) ( =, = ,
) <=, >=, <, >).
Le mot anglais while signifiant "tant que" la boucle sera Le mot anglais while signifiant tant que , la boucle sera
effectue tant que la condition demande est vraie.
La boucle while permet darrter en cours de route les
itrations ds quune certaine condition est vrifie: cest ce quon
ll l t t d t d l b l appelle le test darrt de la boucle.
La syntaxe sous Maple est la suivante: La syntaxe sous Maple est la suivante:
while condition do groupe od:
La somme des nombres impaires compris entre 11 et 100;
> tot := 0;
for i from 11 by 2
while i<100 do
tot:= tot+i tot:= tot+i
end do;
tot; tot;
> k := 1:
while k
2
<=50 do while k < 50 do
k
2
;
k:=k+1:
od;
> L:=[ 3, 2, 5,-1, 6,-2] ; nops(L);Somme:=0 : [ ] p ( )
for i while i<=nops(L) and abs(L[i])<=4 do
Somme:=Somme+L[i] ;
d d end do:
L; Somme;
> Somme:=0 :
for i in [ 3 2 5 -1 6 -2] do for i in [ 3, 2, 5, 1, 6, 2] do
if i<=0 then
break
end if;
Somme:=Somme+ln(i) ;
d d end do;
Somme;
> Somme:=0 :
for i in [ 3, 2, 5,-1, 6,-2] do
if i<=0 then
next
d if end if;
Somme:=Somme+ln(i) ;
end do; end do;
Somme;