Ecole�Nationale�des�Sciences�Appliquées�d’El�Jadida�

Dr. M. EL MOUDEN

Année Universitaire 2010-2011

Table des matièresTable des matières

1) Introduction)2) Arithmétique3) F ti3) Fonctions4) Graphique4) Graphique5) Analyse6) Programmation

MAPLE est un langage de manipulation symbolique qui permet:symbolique qui permet:

� d'accéder à une large bibliothèque de� d accéder à une large bibliothèque de fonctions très bien adaptées,

� de réaliser aussi bien des calculs numériques que des calculs formels.

1. Commandes Maple de base.1 1 Calculs numériques1.1 Calculs numériques.1.2 Calculs sur des nombres "spéciaux".1 3 Quelques fonctions mathématiques1.3 Quelques fonctions mathématiques.1.4 Calculs symboliques.

2 Représentation Graphique2. Représentation Graphique.

� Au démarrage d'une session; MAPLE affiche un prompt .�� L'utilisateur peut alors lui demander d'exécuter "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 résultat 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 [entrée]), Maple affiche alors un "warning" (attention en anglais) signalant une fin prématurée dewarning (attention en anglais) signalant une fin prématurée de la commande.

1 2> 1+2;> 1+2:> 3*7*15> 3 7 15> :

� Si l'on appuie sur [entrée] à la fin d'une ligne, Maple essaie de calculer ce qu'on a écritessaie de calculer ce qu on a écrit.

� On peut cependant écrire plusieurs lignes de calcul en appuyant à la fin d'une ligne simultanément sur les touches [shift] et [entrée] (ce que l'on note dans la littérature par [shift]+[entrée])[shift]+[entrée]).

> 1+2;3+4:

Rappel du dernier calcul

� Dans le langage Maple, le caractère pourcent (%) permet de rappeler la valeur du dernier calcul effectué par la machine. Ce n'est pas nécessairement le dernier calcul affichéCe n'est pas nécessairement le dernier calcul affiché.

De même, (%%) permet de revenir deux calculs en arrière etDe même, (%%) permet de revenir deux calculs en arrière 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 résultat 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 pd'exclamation (!) à la fin du nombre:

50!> 50!;> length(%);

� Une variable muette est donnée 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 opérateur ou unun warning signalant qu il manque un opérateur 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é rencontrée.> 5x;;

Mais x5 "x attachée à 5" sera considérée comme variable (5 jouera le rôle d'indice)> x5;> x 5;> 5*x;> 5 x;� L'exposant d'une variable peut s’écrire de deux manière différentes:> y:=x**2; z:=y^3;

� U blè M l t là id Aid li� Un problème: Maple est là pour vous aider Aide en ligne.Maple dispose d'une aide en ligne (très 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 après cette commande.

> ?sinou encoreou 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). Parcommande (: ) (comme dans le langage Pascal). Par exemple, supposons que l'on veuille donner à x la valeur de5, on procède comme suit :>x:=5; v:=8;�Le maple mémorise tout ce qui a été exécuté.> y; z;> y; z;�Jusqu'à la fin des calculs, x sera égal à 5. Pour supprimer la valeur affectée à x, on se sert de la commande unassign(..),valeur affectée à 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é-initialisationOn ré-initialise une feuille de calcul, par la commande restart, pour , p , psupprimer la valeur de x, et aussi de toutes les autres variables.> restart;>> x; y; z; v;

CommentairesCommentairesLorsqu'on veut écrire un commentaire dans ses calculs, on écrit une dièse (#) suivi du commentaire. Tout ce qui sera après la dièse 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 laPARESSE.# Suggestion au commentaire : on ne fera plus de CALCUL.gg p# Réponse à 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 numériques Evaluation

�� La commande evalf(...), qui signifie "evaluate foating" permet d’évaluer une approximation numérique des calculs effectués.> 5/3;> 5/3;

evalf(%);� Maple donne les résultats dans leur forme la plus formelle. p pPour les calculs numériques 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 réel (et nonMaple pense alors que le nombre en question est un réel (et non plus un entier ou un rationnel) et donnera le résultat sous forme d'un nombre réel. Lorsqu'on écrit 1., cela signifie pour Maple le q , g p pnombre 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'intérieur d'une parenthèse d'une fonction circulaire est en radiansfonction circulaire est en radians.

> ln(exp(-5));exp(ln(-5));exp(ln(-5));exp(ln(-5.));

Trop de chiffres après la virguleCe n'est pas un problème: Il existe une commande Maple pour fi l b d hiff à ffi h il ' it d l dfixer le nombre de chiffre à afficher, il s'agit de la commande Digits:=n. Par défaut, Maple affiche 15 chiffres au total (partie entière et partie décimale)entière et partie décimale).> sin(0.2);

n:=4; Digits:=n;; g ;sin(0.2);

T l hiff i i t è ' ffi h t à hiffTous les chiffres qui viennent après s'afficheront à n chiffres après la virgule> sin(0 2); evalf(% 8);> sin(0.2); evalf(%,8);> 5/7.;

Calcul symbolique � Pour développer 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 mathématiques� Maple connait un grand nombre de fonctions mathématiques de base (certainement beaucoup plus que vous même en connaissez) et il est possible d’évaluer ces fonctions à un point ) p pdonné.

> restart;> restart;x:=Pi; ln(x); exp(x); sin(x); sinh(x); tan(x);

Représentations graphiques

� Maple permet également de tracer n'importe quelle fonction, aussi bien sur le plan que dans l'espaceaussi 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 (Série1)

Solutions

Solutions

Solutions

1. Nombres complexes.2 Operations d'arithmétiques2. Operations d arithmétiques.3. Calculs sur les polynômes.4 Equations4. Equations.

Nombres complexes

� Maple sait faire à peu près n'importe quel calcul sur les nombres complexes. p� En langage Maple, I (i majuscule) désigne une racine carré du nombre -1, c'est à dire le nombre tel que I2 = -1.�� Maple peut décomposer toujours le résultat sous la forme habituelle a+ib, dans le cas d'une représentation numérique.> 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 possède des commandes spécifique aux calculs sur le b lnombres 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 d’évaluer une approximation numérique 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 complexe6 j t ( 5) # S j éz6:=conjugate(z5); # Son conjugué

� La commande Re(...) donne la partie réelle d'une expression complexe.p

� La commande Im(...) donne la partie imaginaire d'une iexpression.

> z5:=sqrt(3)+I; # Un nombre complexe> z5:=sqrt(3)+I; # Un nombre complexerez5:=Re(z5); # Sa partie réelleimz5:=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 complexeabsz5:=abs(z5); # Son moduleargz5:=argument(z5); # Son argumentargz6:=argument(z6);

D’autres 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 lEncore 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(%);

Représentation usuelle et représentation polaire

� Un complexe peut être également représenté de façon polaire, c'est à dire sous la forme �e(I�) , où � est son module et � son � , �argument.

�� Pour avoir une telle représentation, on utilise la commande polar(�, �)

> 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 ); pnombre sqrt(3)-I

evalc(zp2);

> # On met sous forme polaire le nombre 3-4*Iconvert(3 4*I polar);convert(3-4 I,polar);

> # Réciproquement, pour passer de la forme polaire à la forme p q , p p pusuelle, on utilise la commande evalc(...), que nous avons déjà vu.

l (%)evalc(%);

> zp3:=polar(2 Pi/3); evalc(zp3);> zp3:=polar(2,Pi/3); evalc(zp3);

Operations d'arithmétiques

� Maple sait également faire de nombreuses opérations� Maple sait également faire de nombreuses opérations d'arithmétique.

� 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,

� déterminer le nième nombre premier etc� déterminer 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 grâce à 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 premiersentiers 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 méthode 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-même.

� 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 lacommande isprime(...).

� P ît l l tit b i i èd� Pour connaître le plus petit nombre premier qui succède 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 connaître le plus petit nombre premier qui succède un b d énombre donné :

> nextprime(29); nextprime(275); nextprime(8723);

� Pour connaître le plus petit nombre premier qui précède un nombre donné :> prevprime(29); prevprime(275); prevprime(8723);> prevprime(7); nextprime(7);

Calculs sur les polynômes

� Le travail le plus simple sur les expressions symboliques concerne: les polynômes.� V i i t i b d l l élé t i l� Voici un certains nombres de calculs élémentaires sur les polynômes :> P1:= 3 * x^2 + 4 * x + 7; # On assigne à P1 un polynôme> P1:= 3 x 2 + 4 x + 7; # On assigne à P1 un polynôme.

P2:= x^3 - 1; # On assigne à P2 un polynôme.� 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 même on peut développer, factoriser, simplifier et ordonner des polynômes, grâce aux commandes expand(...), factor(...), collect(...), simplify(...) et sort(...).

La commande expand(...)

La commande expand(...) permet de développer un polynôme.( ) 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 polynôme.> 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 polynôme. Remarquons la différence 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 polynôme� Cette commande permet également de factoriser un polynôme à 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 donnée, 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 résultat voulu (Maple oublie parfois certaines simplificationsle résultat 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 polynôme suivant la valeur décroissante 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 blPol:=sort(Pol); # On trie le polynôme à une seule variable.

� Si l'on a un polynôme à plusieurs variables on peut bien sûr� Si l on a un polynôme à plusieurs variables, on peut bien sûr préciser l'ordre dans lequel on veut classer le polynôme.

> poly2:= x*y^3 - 2*x^2*y^5 + 4*x*y^4 + y^8+x^7; # On trie polynôme à deux variables.

pol 2 sort(pol 2 [ ]) # On trie pol 2 s i ant p ispoly2:=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 deLa commande normal(...) permet de mettre des fractions de polynômes au même dénominateur.

> ploy1:=1/(1+2*x^2) + 2*x/(1+x) + 3*x^2/(4-x^3) -2*x^3/(3+x+x^4); # Un polynôme à plusieurs variables

ploy1:=normal(%);

> poly2:=y/(1+2*y^2) + 2*x*y/(1+x); # Un polynôme à plusieurs> poly2:=y/(1+2 y 2) + 2 x y/(1+x); # Un polynôme à plusieurs variables

ploy2:=normal(%);p y ( );

La commande degree(...)

� La commande degree(...) permet d'obtenir le degré d'un polynômepolynôme.

� Si le polynôme a plusieurs variables, on peut préciser suivant � p y p , p pquelles variable on veut le degré.

�� Si l'on ne précise 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 polynôme considéré. 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, polynômes se calcule à l'aide de la commande gcd(...)(pour « Greatest Common Divisor »).

� Le Plus Petit Commun Multiple (ppcm) de deux, trois ou plus polynômes entiers se calcule grâce à la commande lcm( )plus, polynômes entiers se calcule grâce à la commande lcm(...)(pour « Less Common Multiple »).

> P:= 1/2*x^3 - 1/2; Q:= x^2 - 1;> gcd(P Q) lcm(P Q)> gcd(P,Q); lcm(P,Q);

EquationsEquations

� En Maple, la résolution des équations se fait avec les� En Maple, la résolution des équations se fait avec les commandes solve(...) (effectivement quand la méthode analytique le permet).

� Notez que si l'on met l'inconnue entre accolades ({ }), alors Maple précise de quelle variable on parle par exemple dansMaple précise de quelle variable on parle par exemple dans l'équation suivant c'est x et non pas y.

� La précision des variables est importante dans des expressions théoriques, sinon Maple peut réserver des drôles 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 définie comme une équation et non pas comme une variable.

Systèmes d’équationsSystèmes d équations

� Maple ne se limite pas à la résolution des systèmes linéaires, mais bien au contraire, il peut résoudre des systèmes nettement plus compliquésplus compliqués.

> 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 précise à 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 considéré par Maple comme des variable sans valeur précisedes variable, sans valeur précise> u,v;

� Si on veut donner à u et v les valeurs solution du système précédent, 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 réinitialiser Maple ce� Note: la commande restart permet de réinitialiser Maple, ce qui peut être utile, parfois.

La commande allvalues( )La commande allvalues(…)

� Parfois,.........pour un système un peu plus complexe.........� , p y p p p> sys:={x^2+y=1,x^2-y^2=2};> solve(sys,{x,y});

La réponse n'est que partielle!plutôt que de calculer une solution Maple donne un résultat enplutôt que de calculer une solution, Maple donne un résultat 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 numériques

> 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 ( ) pnumériques ('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 polynôme, par exemple), fsolve(...) ne donnera pas obligatoirement toutes les solutions elle ne donne par défaut queobligatoirement toutes les solutions, elle ne donne par défaut que les racines réelles.

� 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 spécifier dans quel intervalle on veut la solution:

> fsolve(poly1, x, 2..8); # Ses racines entre 2 et 8.

� ou bien spécifier que l'on veut les racines complexes:

> fsolve(poly2, {x}, complex); # Ses racines complexes.

Ell bi ill d llElle est bien gentille cette commande; elle me retrouve toutes mes solutions

La commande isolve(...)

� Ces commandes sont utiles lorsqu'on cherches des solutions entières de certaines équations [pour la relation de Bezout, par

l + + + d( )]exemple: a0 n0 + a1 n1 + a2 n2 +... = pgcd( n0 , n1 ,n2 , ...)].

� La commande isolve(...) permet de donner des solutions� La commande isolve(...) permet de donner des solutions entières d'une équation.

> isolve({5*x-3*y=4}); # Solutions entières de 5x - 3y = 4> solve({x+7*y=1,3*x+2*y=2});

Exercices (Série2)Exercices (Série2)

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'exerciceb)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 considéré comme un paramètre

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 variables1.1 Fonctions à plusieurs variables,1.2 Fonctions composées,1 3 Suites1.3 Suites,

2. Limites.3 Dérivés3. Dérivés.

3.1 Dérivées partielles,3 2 La commande D3.2. La commande D,

4. Intégrales.

Remarques préliminaires

� On peut, avec Maple, afficher quelque chose sans le calculer. Il suffit de mettre des apostrophes (') au début et à la fin de ce qu'on écrit.

� Si l'on veut insérer une espace il faut alors créer une� Si l'on veut insérer une espace, il faut alors créer une chaine. Pour ce faire, il faut utiliser les guillemets anglais (").

Par exemple :> 'sin(Pi)' = sin(Pi);

"ça marche";

� Pour plus de détail utilisez l'aide du Maple� Pour plus de détail, utilisez l aide du Maple> ?'> ?"?> restart;

FonctionsFonctions

� Une fonction sous Maple se défini de la façon suivante :

nom de la fonction:= variable(s) > definition de la fonctionnom_de_la_fonction:= variable(s)-> definition_de_la_fonction

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

� Il est possible de définir 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 définie 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 variablesFonctions à plusieurs variables

� Une fonction à plusieurs variables est défini de la même manière 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 composées

� Maple sait composer des fonctions entres-elles. On se sert de l'opérateur @:

( 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-même. 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 composée:> (sin@arcsin)(x);

� L'operateur @@(-1) permet également de définir 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 définies par des fonctionsp

� Les suites définies par des fonctions sont des fonctions "comme les autres", si ce n'est qu'elles sont définies dans �au lieu de �.> u := n > 3*ln(n) + 4;> u := n -> 3 ln(n) + 4;

� Les suites sont en générales indexées (un ), pour indiquer g ( n ), p ql'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 définie la suite par u0 et un=f (un-1) alors on a un = (f(n))(u0 )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 ensuffit 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 dernières 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 gpas définie.> 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 même 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});

Dérivées

Dérivée d'une fonction usuelle

� L dé i é " di i " ti l t êt f it� Les dérivées "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 dérivée ordinaire

diff(f(x,y,z), x )où f(x,y,z) est la fonction à dériver et x la variable par rapport à laquelle on dérive.

� Notez que si vous écrivez Diff(f(...), ... ) à la place de diff(f(...), ... ) , Maple n’évaluera pas la dérivée (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 dérivées multiples peuvent être évaluées en répétant la variable plusieurs fois:

> Diff(sin(x^2), x, x)= diff(sin(x^2), x, x);

� Ou bien, de manière équivalente en écrivant x$n, où n est le , q $ ,nombre de fois où l'on dérive:

Diff( i ( ^2) $2) diff( i ( ^2) $2)> Diff(sin(x^2), x$2)= diff(sin(x^2), x$2);

Dérivées partiellesDérivées partielles

� De manière similaire, Maple évalue les dérivées partielles , p pd'une fonction à plusieurs variables :> 'Diff(cos(x*tan(y)), x)'= diff(cos(x*tan(y)), x);

� Notez que l'ordre dans lequel Maple dérive les fonctions est de gauche à droite (dans l'ordre où vous les écrivez) Parfoisde 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 dériver 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 à spécifier 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 itéré 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 dérivée partielle par rapport à la ième variable:

> D[1]((x y) > x^7*y^3); # dérivée partielle par rapport à x> D[1]((x,y)-> x^7*y^3); # dérivée partielle par rapport à x> D[2]((x,y)-> x^7*y^3); # dérivée partielle par rapport à y

� Pour des dérivées partielles, on utilise une indexation par rapport à l'ordre dont on veut dériver 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);

Intégrales

� Maple sait calculer les intégrales, grâce à la commande Int.

� La syntaxe pour les intégrales indéfinies (les "primitives") est :

int(expr x)int(expr, x)où expr est l'expression que vous intégrez et x la variable par rapport à laquelle vous intégrez.rapport à laquelle vous intégrez.

� Pour les intégrales définies, la syntaxe est la suivante :int(expr, x=a..b)

où expr est l'expression que vous intégrez et a..b l'intervalle sur lequel vous intégrezlequel vous intégrez.

�Note: Comme pour la dérivée, si on écrit Int(expr, x) à la place�Note: Comme pour la dérivée, si on écrit Int(expr, x) à la place de int(expr, x), vous aurez la forme non évaluée.

> 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 intégrales définies 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 intégrales multiples sont faites par itération de l'intégrale :

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 (Série3)Exercices (Série3)

Solutions

Exercice 1.

a) Définissez la fonction f (x) = sin(x)cos(x)a) Définissez la fonction f1(x) = sin(x)cos(x). Tracer la fonction entre 0 et �. Calculez f1(0) et f1(�)Calculez f1(0) et f1(�)

> f[1]:=x-> sin(x)*cos(x);> plot(f[1](x), x=0..Pi);> f[1](0); f[1](Pi);

b) Définissez la fonction f (x y) = e(xy)cos(x)sin(y)b) Définissez la fonction f2(x,y) = e(xy)cos(x)sin(y). Tracer sa courbe représentative 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) Définissez la fonction g(x) =3x/ ln(x). Que vaut eg ? 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 un définie par u0 = 3 et un = ln(un�1) + 5. Calculez les 5ème, 10ème et 100ème termes en fonction de u0.Refaites le calcul si u0 = 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 f3 = 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 f4 = 4cos(x)/(1 � x2)?> 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 dérivée de u(x)/v(x)? Calculez la dérivée 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 dérivées partielles d'ordre 1 de f ( ) ( ) ( ) i ( )f2(x, y) = e(xy)cos(x)sin(y).

Donnez toutes les dérivées partielles d'ordre 2 de f2 . Ecrivez ces formules de deux façons différentesEcrivez ces formules de deux façons différentes

> f[2] := (x,y) -> exp(x*y)*cos(x)*sin(y);> "première écriture";p ;> "dérivées premières";> 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)

> "dérivées 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";> "dérivées premières";> dérivées premières ;> D[1](f[2]); D[2](f[2]);> "dérivées 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) Définissez la fonction g(x) = x2 + ln(3x). Puis, en une seule lignec) Définissez la fonction g(x) x ln(3x). Puis, en une seule ligne de commande, tracez sur un même graphe la fonction g, ainsi que ses deux premières dérivées, 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.

2a) Soit f5(x) = e(�x2)

Calculez l'intégrale de f5 entre 0 et l'infini. C l l l'i té l d f t + tCalculez l'intégrale de f5 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 intégrales de ces deux fonctions entre 0 et 16

4xCalculez les intégrales de ces deux fonctions entre 0 et 16.

Puis, par un calcul d'intégrale, 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 fonctionc) Cherchez une primitive en x de la fonction f6(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. Vérifiez vos résultats.

> 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 dimensions1. Graphiques en deux dimensions1.1 Introduction aux graphiques1.2 Package "plots"

2. D'autres type de graphes en 2-d2.1 Courbes paramétrées2 2 Ch d t 2 d2.2 Champs de vecteurs en 2-d2.3 Graphes de courbes définies implicitement

2 3 1 Fonctions implicites2.3.1 Fonctions implicites2.3.2 Graphes de points

2.4 D'autres systèmes de coordonnéesy2.5 Inégalités2.6 Echelles logarithmiques

3 G hi t i di i3. Graphiques en trois dimensions4. 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 générale suivante :générale 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 mathématique ou un ensemble d'expression définissant la (les) fonctions à tracerd expression définissant la (les) fonctions à tracer.

-intervalle est de la forme x = a..b avec a et b des nombres réels et a < b ou une liste d'intervalles de la même formeet a < b, ou une liste d intervalles de la même forme.

- option correspond à une ou plusieurs spécifications optionnelles qui déterminent l'apparence du graphe (titreoptionnelles qui déterminent 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 différents type de graphiques. � Il existe même un package (un librairie) pour tracer certains

hi C k ' ll l t t i lgraphiques. Ce package s'appelle plots, et pour pouvoir le charger en mémoire il faut avoir recours à la commande : with(plots):(plots):.� Si on charge tout le package en mémoire on peut faire appel à la commande en tapant commande Mais si tout le packagela commande en tapant commande. Mais si tout le package n'est pas chargé on peut toujours écrire plots[command] qui donnera le même résultat. � Remarquons que si l'on remplace le deux-points final par un point virgule, càd with(plots);, Maple va afficher l'ensemble des nouvelles fonctions et commandes qu'il a chargé en mémoire.

>?plots# N'oubliez pas que l'aide est toujours là pour vous aider et vous rappeler des différentes 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 dépendantes de la variable réelle 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 utilisées.> ?plot[options]p [ p ]

� Voici un exemple de la commande plot qui vous donne l t l' ll d' f ti t l i lseulement l'allure d'une fonction courante par exemple exp, sin, ln

... > plot(sin*ln);> plot(sin ln);

� Attention si on introduit la variable x:> plot(sin(x)*ln(x),x);

� Le Maple est incapable d'évaluer les valeurs numériques de la fonction par défaut de la région des valeurs de la variable x;fonction par défaut de la région 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 séquence 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 spécification des caractères et du style de la police utilisée.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 défaut de joindre les points de discontinuitésessayer par défaut de joindre les points de discontinuités.

� Ce qui peut éviter en mettant l'option discont = true, Maple va déterminer les points de discontinuités de l'expression et séparera l'intervalle de définition en sous intervalles où la fonction est contin efonction 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 même é h ll l d d héchelle sur les deux axes du graphe.

� Attention par défaut ce n'est pas le cas !� Attention, par défaut 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 défaut, Maple calcule un minimum de 50 points par graphe, mais dans le cas où il est nécessaire d'augmenter ce nombre de points; pour optimiser, on utilise alors l'option

i tnumpoints.

� Considérons l'exemple d'une fonction d'amplitude très petite� Considérons l exemple d une fonction d amplitude très 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);

Spécification d'un graphe

� Voici deux façon de spécifier 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 définir a ssi le st le de lastyle = [line, point ]); # on peut définir aussi le style de la courbe

� En utilisant l'option style=point on trace un graphe de façon discrète.

Tracé de plusieurs fonctions

� On peut tracer plusieurs graphes séparément 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 différencier entre les graphes: on pe t imposer différentes options tels q e la co le r le st le etcpeut imposer différentes 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 manière générale, plusieurs courbes peuvent être tracées simultanément avec la syntaxe générale 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 même temps est d'utiliser la commande display. Cette commande fait partie d k l tdu package plots.

�Cette commande peut donc soit être utilisée sous la forme�Cette commande peut donc soit être utilisée sous la forme plots[display] soit sous la forme display en chargeant d'abord en mémoire 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 affichés).> display([plot1,plot2,plot3]);> plots[display] ([plot1,plot2,plot3]);# Affichage des trois graphes. display([plot1,plot2,plot3]);

ETUDE LOCALE DES FONCTIONS NUMÉRIQUES

Développements

� Pour les développements limités ou de Taylor:

l ( )taylor(expr ,x=a,n)

� Pour des développements asymptotiques plus généraux:� Pour des développements asymptotiques plus généraux:

series(expr ,x=a ,n) ou asympt(expr , x=a , n).( p , , ) y p ( p , , )

�L'ordre n est facultatif et vaut 6 par défaut .

> 'taylor(sin(x),x)' = taylor(sin(x),x); # x=0 par défaut

>'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 défaut> series(exp(x)/x,x,9) =series(exp(x)/x,x,9); # a=0 par défaut

> '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 série

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 série:

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

Conversion en polynôme de Taylorp y y

Pour convertir un développement en polynôme, 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 SYSTÈMES DIFFÉRENTIELSEquations du premier ordreEquations du premier ordre

� Avec MAPLE; nous pouvons résoudre directement les é ti d t l i li é i f t i té téquations de type classique - linéaire - avec facteur intégrant -séparable - homogène - résolue en x - de Bernoulli – de Clairaut -de Riccatide Riccati.

� Pour cela on utilise la commande dsolve(eq,y(x)) où eqdésigne l'expression de l'équation à résoudredésigne l'expression de l'équation à résoudre.É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 résolution le terme du type _C1 désignera la Constante réelle arbitraireConstante réelle arbitraire.Pour tenir compte et définir cette constante, on introduit la condition initiale de la manière 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 treprésenter les courbes intégrales, voir exemple suivant:> plot(y(x),x);Warning unable to evaluate the function to numeric values inWarning, unable to evaluate the function to numeric values inthe region; see the plotting command's help page to ensure thecalling sequence is correctg qPlotting error, empty plot

fff( ) ^2+1 fff(2)> fff(x):=x^2+1; fff(2);> ggg:=x->x^2+1; ggg(2);

Représentation des courbes intégrales

� 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'unevariable libre x ( ou couple de variables libres (x,y)), retourne la fonction qui à la variable x (x y) associe Pfonction 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 régulièrement espacées du paramètres , on peut utiliser la commande seq(y(x C1) C1=a b) combinée à la commande { }commande seq(y(x,_C1),_C1=a..b) combinée à 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 préciser des options de résolution par exemple : series (chercher les solutions sous forme de séries)( )

> 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 représenter les solutions d'une équation p g p p p qdifférentielle.� La solution pourra être visualisée graphiquement avec la f ti d l t ( di diff ti l ti l t) d lfonction odeplot (pour ordinary differential equation plot) de la bibliothèque graphique plots: � Le premier argument est le nom de la procédure� Le premier argument est le nom de la procédure, � Le deuxième une liste qui donne la ou les représentations choisies (f(x) en fonction de x ou x en fonction de f(x)).( ( ) ( ))� Le troisième 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 résoudre également les équations de second ordre de type classique - linéaire - d'Euler - de Bessel

� Pour cela on utilise la commande dsolve(eq,y(x)) où eqdésigne l'expression de l'équation à résoudre.g p q

� Les options de résolution sont les mêmes 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 même avec conditions initiales:> dsolve({eq2,y(0)=0,D(y)(0)=-1},y(t));

SYSTÈMES DIFFÉRENTIELS

� Pour cela on utilise la commande dsolve(eq,y(x)) où eqdésigne l'expression de l'équation à résoudre.

Exemple: résoudre x ' =x- 2 y , y ' = 2 x+ 3 y . Représenter la solution vérifiant 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));

Résolution d'équations aux dérivées partielles

� Pour cela on utilise la commande dsolve(eq,y(x)) où eqdésigne l'expression de l'équation à résoudre.

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

> pdsolve(edp U(x y));

( , ) ( , ) 0y U x y x U x yx y

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

2 2( , ) 1( )U x y F x y �

où _F1 désigne une fonction arbitraire de classe C1 de la variable

( , ) _ 1( )U x y F x y

-x^2+y^2 .

1) Définir un vecteur, matrice en Maple

2) Opérations sur les vecteurs et matrices: Somme, multiplication, matrice inverse, puissance,…p , , p ,

3) Etude d’une 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)

TESTSStructures BoolennesStructures Boolennes

� Ce sont des structures concernant des variables booléennes i t d l i (t ) f (f l )qui ne prennent que deux valeurs : vrai (true) ou faux (false).

� L'évaluation des Booléens se fait par l'intermédiaire de la commande evalb( ): La fonction evalb permet de tester cettecommande evalb(......): La fonction evalb permet de tester cette égalité.� Les opérations logiques permettant de construire des p g q pexpressions booléennes plus élaborées sont utilisés à partir des opérateurs : négation not(......) , et conjonction (...and...) etdi 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 d’effectuer des groupes de commandes si certaines conditions sont vérifiées ou non.

� La syntaxe peut se présenter 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 aisément l'écriture suivante (sachant que ifsignifie 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 à effectuerelse 2 choix de commande à effectuer fi commande à effectuer( if signifie si, then signifie alors, else signifie sinon. )

�if condition then 1 choix de commande à effectuerelse 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 à effectuerif condition then 1ier choix de commande à effectuerelif condition then 2ième choix de commande à effectuerelif condition then 3ième choix de commande à effectuer...........................................................................................................................................................................................................................elif condition then nième choix de commande à effectuerelse (n+1)ième choix de commande à effectuerelse (n+1)ième 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 inférieur à 3" fi;

> a := 4; if a < 3 then "a est inférieur à 3" fi;

f fé à f> a := 4; if a < 3 then "a est inférieur à 3" fi;if a>3 then "a est supérieur à 3" fi;

> a := 4; if a < 3 then "a est inférieur à 3" else "a est supérieur à 3" fi;;

> a := 3; if a < 3 then "a est inférieur à 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 supérieur à 4" fi;

BOUCLESBoucle forBoucle for

� Une boucle permet la répétition du calcul d'une expression ou d' it d' id'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 débute la boucle avec la valeur qui suit le mot clé from, puis est incrémentée de la valeur ( p ) suivant le mot clé byt i t t ' ll t i fé i é l à l l i t let ceci tant qu'elle reste inférieure ou égale à la valeur suivant le

mot clé to.

� La variable de comptage (p) n’est pas muette : elle vaut la dernière valeur calculée avant le test arrêtant la boucle.

� Un groupe 'formé d'une expression ou plusieurs expressions ( ensemble d'instructions) est placé entre les mots clés do et endd ( d) t é é l t tido (ou od) et séparées par la ponctuation ; ou :

� Ici il n'y a trois expressions: La première est une liste de deux� Ici il n y a trois expressions: La première est une liste de deux nombres, la deuxième une mise en facteur premiers et la troisième 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 numericmais pas de type constant comme ou Dans ce dernier il faut2 �mais pas de type constant comme ou . Dans ce dernier il faut utiliser evalf

2 �

> 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 lExemple : 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 factorielExemple : 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 doyx:=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 plutôt p q pque mathématique. Il ne signifie pas qu'un objet est nul (égal à 0), mais qu'il n'existe pas.

X NULL ' '> X:=NULL; 'x'= x;

Création d'une séquence 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 Sfor k in L do S:=S, 2*k: od: S ;

> restart;> tot := 0; for z in 1, x, y, q2, 3 do tot := tot+z end do; tot;> tot := 0; for z in [1, x, y, q2, 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 booléenne) ( =, � ,

)<=, >=, <, >).

� Le mot anglais while signifiant "tant que" la boucle sera� Le mot anglais while signifiant tant que , la boucle sera effectuée tant que la condition demandée est vraie.

� La boucle while permet d’arrêter en cours de route les itérations dès qu’une certaine condition est vérifiée: c’est ce qu’on

ll l t t d’ êt d l b lappelle le test d’arrêt 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 2while i<100 do

tot:= tot+itot:= tot+i end do; tot;tot;

> k := 1: while k2<=50 dowhile k < 50 do

k2; 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 dend do:

L; Somme;

> Somme:=0 :for i in [ 3 2 5 -1 6 -2] dofor i in [ 3, 2, 5, 1, 6, 2] do

if i<=0 thenbreak

end if;Somme:=Somme+ln(i) ;

d dend do;Somme;

> Somme:=0 :for i in [ 3, 2, 5,-1, 6,-2] do

if i<=0 thennextd ifend if;

Somme:=Somme+ln(i) ;end do;end do;Somme;