Cours Intégré de Maple

Université Louis Pasteur
L2 MPC/LPA
Cours Intégré de Maple
2007-2008
2
Table des matières
1 Une introduction et sa suite
1.1 Accès . . . . . . . . . . . . .
1.2 Instruction(s), exécution(s) et
1.3 Sauvegarde de fichier . . . . .
1.4 Aide . . . . . . . . . . . . . .
1.5 Quelques suites avec Maple .
.
.
.
.
.
5
5
5
7
7
7
.
.
.
.
.
.
.
.
9
9
11
11
11
12
12
13
14
.
.
.
.
.
.
15
15
15
16
16
17
17
4 Quelques compléments
4.1 Résolution d’équations différentielles . . . . . . . . . . . . . . . . . . . . . . .
4.2 Partiel janvier 2007 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3 Partiel septembre 2007 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
19
21
23
. . . . . .
résultat(s)
. . . . . .
. . . . . .
. . . . . .
2 Variables, fonctions, tableaux et
2.1 Les variables . . . . . . . . . .
2.2 Les fonctions . . . . . . . . . .
2.2.1 Fonctions et expressions
2.2.2 Procédures . . . . . . .
2.3 Les tableaux . . . . . . . . . .
2.3.1 La commande array . .
2.3.2 Les listes . . . . . . . .
2.4 Boucles et tests . . . . . . . . .
3 Graphiques
3.1 La commande plot . . . . . .
3.1.1 Des fonctions . . . . .
3.1.2 Un ensemble de points
3.1.3 Faire une animation .
3.2 Autres commandes . . . . . .
3.3 Exercices . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
boucles
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4
TABLE DES MATIÈRES
Chapitre 1
Une introduction et sa suite
Maple est un logiciel de calcul formel : il peut traiter des données numériques (entier, réels,
complexes...) de précision arbitraire et aussi des données symboliques (polynômes,expressions...).
Ce logiciel est également doté de capacités graphiques.
1.1
Accès
Maple est un logiciel (payant). Il est installé sur un système (linux, mac, windows). Il y a
plusieurs versions ; actuellement la version 11 existe. Sur Univ-R (avez vous un compte ent ?),
il y a (normalement) 2 versions : 7 et 9.5. On préfèrera la version 7 qui est moins lourde. On
y accède en cliquant sur Application pédagogique puis Mathematiques et enfin Maple 7 (s’il y
a écrit Mapple 7, c’est une erreur d’orthographe : Maple vient du Canada et veut dire érable,
dont la feuille est d’ailleurs l’emblême de ce pays ; rien-à-voir avec une pomme, donc ; cliquez
quand même sur l’icône, mais ne faites pas la faute d’orthographe !).
1.2
Instruction(s), exécution(s) et résultat(s)
Après un certain temps, vous voyez apparaı̂tre une interface graphique avec un fichier
nommé Untitled(1) et un curseur qui attend que vous tapiez votre première instruction :
>2+2;
N’oubliez pas le ;, car il signifie la fin de l’instruction et que le résultat sera affiché. Ne rajouter
par l’invite de commande > : il est déjà écrit et correspond à un bloc d’instructions qui est
exécuté dès que l’on appuie sur la touche entree.
A la place du ;, on peut aussi utiliser le :. Dans ce cas l’instruction sera exécutée, mais non
affichée. Cela peut être pratique si l’on ne veut pas que l’ordinateur affiche plein de résultats
intermédiaires qui ne sont pas utiles.
Lorsque l’on appuie sur la touche shift entree, on va à la ligne sans exécuter. Cela permet
d’écrire un bloc d’instructions de manière plus claire et évite de devoir appuyer de nombreuses
fois sur la touche entree pour arriver au résultat final.
Le résultat de la dernière instruction est donné par % et celui de l’avant-dernier résultat est
donné par %% (on peut aussi avoir le résultat de l’avant-avant-dernière opération par %%%).
Pour bien comprendre comment les instructions sont exécutées, écrivez :
5
6
CHAPITRE 1. UNE INTRODUCTION ET SA SUITE
>1:1:
>%+%%;
Vous devez voir affiché 2. Revenez au deuxième bloc et réappuyez sur entree. 3 est alors
affiché. Recommencez un certain nombre de fois. Vous êtes en train d’afficher les nombres
successifs de la suite de Fibonacci définie par
u1 = 1, u2 = 1,
un+1 = un + un−1 ,
n = 2, . . .
Revenez maintenant au premier bloc, appuyez sur entree, puis allez au deuxième bloc et
appuyez sur entree. Quel est le résultat affiché, pourquoi ?
Pour éviter d’avoir à répétér les mêmes instructions, on peut utiliser une boucle
>1:1:for i to 10 do %+%%;od;
i est une variable qui va de 1 (valeur par défaut) à 10 ; tout ce qui est écrit entre le do et le
od va donc être exécuté 10 fois. A la sortie de la boucle (après le od), la variable i vaut 11.
C’est le ; après le od qui dicte s’il y a écriture ou non. Faites plusieurs essais, en changeant
les ; en : et vice-versa, pour bien comprendre.
Pour afficher seulement le 100 ième terme de la suite de Fibonacci, on peut donc écrire
>1:1:for i to 98 do %+%%;od:%;
Une des particularités de Maple est que ce logiciel utilise des valeurs exactes et non approchées.
Ainsi si l’on tape
>3/2;sqrt(2);Pi;
√
on n’obtient guère d’informations sur la valeur numérique de 3/2, 2 ou P i (pensez bien à
mettre une majuscule). Pour forcer à évaluer numériquement, on peut remplacer les entiers
utilisés par des réels. Cela se fait en écrivant par exemple 3. (avec un point) au lieu de 3
(sans le point). On peut aussi utiliser la fonction evalf.
>3./2;sqrt(2.);
ou alors
>evalf(3/2);evalf(sqrt(2));evalf(Pi);
Par défaut, MAPLE utilise 10 chiffres significatifs ; on peut changer cette valeur en écrivant
par exemple
>Digits:=20:
Cela veut dire que l’on a affecté 20 à Digits, la variable interne (i.e. définie dans Maple,
comme Pi), et cela se traduit par le fait que les calculs vont se faire avec une précision de 20
chiffres significatifs. Nous voyons donc que Maple nous permet de faire des calculs avec une
précision arbitraire, ce qui n’est pas le cas pour la plupart des langages de programmation
tels que C, Fortran, Scilab ou Matlab.
√
,
Exercice 1. Le nombre d’or est donné par 1+2 5 . Il est aussi donné comme la limite de uun+1
n
où (un ) est la suite de Fibonacci précédement décrite. Ecrivez des instructions pour observer
ce phénomène numériquement.
1.3. SAUVEGARDE DE FICHIER
1.3
7
Sauvegarde de fichier
Vous avez tapé quelques lignes de Maple et vous voulez garder la trace de ce que vous avez
fait. Vous voulez également rajouter des commentaires, i. e. du texte non exécuté par Maple.
Un commentaire s’écrit avec #. Ainsi toute la fin de ligne après ce symbole ne sera plus lue
par Maple. Votre feuille Maple peut se présenter ainsi de la manière suivante :
>#Suite de Fibonacci
1:1:for i to 100 do %+%%;od:%;
>#Nombre d’Or (exercice 1)
1.:1.:for i to 100 do %+%%;od:%/%%;(1+sqrt(5.))/2;
Sauvegarder alors le fichier sous la forme NOM.tp1.mws ou NOM.tp1.mw, suivant la version
de Maple utilisée (pour Maple7, c’est .mws). Utilisez toujours la meme version pour un meme
fichier ; ainsi si on passe de la version 7 à la version 9.5, il est possible que le fichier ne soit
plus lisible en version 7 par la suite.
Sous linux/mac, il est aussi possible d’utiliser Maple sans mode graphique : les commandes
Maple sont enregistrées dans un fichier (par exemple tp1.maple) et exécutées dans un terminal
par
maple -q tp1.maple
Un intérêt est que l’exécution est plus rapide, car en mode graphique, l’exécution peut être très
ralentie, notamment lors de l’ouverture de la session Maple. Par contre, on perd l’interactivité
qui peut être retrouvée en lançant maple et non xmaple depuis un terminal. Dans ce cas
néanmoins, on ne peut pas faire de sauvegardes. Enfin, en mode non graphique, il est plus
difficile d’obtenir des figures (qui sont affichées avec des caractères dans le terminal). On peut
parer à cet inconvénient en créant par exemple des fichiers jpg.
N’oubliez pas de sauvegarder régulièrement votre fichier.
1.4
Aide
Le logiciel Maple peut être vu comme une grosse calculatrice et offre de nombreuses
possibilités. N’hésitez pas à consulter l’aide (en anglais : cela ne doit pas vous rebuter !). On
peut obtenir de l’aide sur un mot, en tapant ? suivi du mot (tout attaché et sans ;). Par
exemple, pour tracer une fonction
?plot
1.5
Quelques suites avec Maple
Exercice 2. Une grenouille assoifée cherche une mare pour se désalterer. Son premier saut
la porte 1 mètre plus loin. Comme elle se fatigue à chaque saut, le suivant ne fait que 90%
de la longueur précédente. Sachant que la mare la plus proche est à 9 mètres de son point de
départ, arrivera-t-elle à l’atteindre ? si oui, en combien de sauts ?
Exercice 3. La fonction rand() renvoie un entier positif à 12 chiffres (au plus), choisi de
manière aléatoire. Pour N assez grand, calculer la moyenne obtenue de N appels de cette
fonction. Que remarque-t-on ?
8
CHAPITRE 1. UNE INTRODUCTION ET SA SUITE
Exercice 4. Les polynômes de Chebyshev sont définis par la formule de récurrence suivante :
T0 (x) = 1, T1 (x) = x,
Tn+1 (x) = 2xTn (x) − Tn−1 (x),
n ≥ 1.
La fonction simplify permet de simplifier des expressions algébriques. Ainsi, par exemple
> simplify(2*x*(2*x^2-1)-x);
donne pour résultat 4x3 − 3x. En utilisant la fonction simplify, calculer alors T9 . Vérifier
le résultat à l’aide de la commande
>orthopoly[T](9,x);
P
Exercice 5. Calculer N
k=0
exp(1).
1
k! ,
pour N = 5, 10, 20 et comparer avec une valeur approchée de
Exercice 6. La formule de Machin fut découverte en 1706 et relie le nombre π à la fonction
arctangente :
π
1
1
= 4 arctan − arctan
.
4
5
239
P
k x2k+1
D’autre part, on a arctan(x) = ∞
k=0 (−1) 2k+1 . En déduire un algorithme pour calculer une
valeur approchée de π, en n’utilisant que des opérations élémentaires (+, −, ∗, /), et comparer
avec une valeur numérique de P i. On pourra tester différentes valeurs de la variable Digits.
Chapitre 2
Variables, fonctions, tableaux et
boucles
Dans le chapitre précédent, nous avons vu que Maple nous permet de faire des calculs
numériques de précision arbitraire, en réglant la variable Digits convenablement. Nous avons
aussi aperçu que les calculs peuvent être faits sur des objets plus formels tels que les polynômes. Pour l’instant les calculs ont été faits dans la foulée grâce à l’utilisation des résultats
précédents obtenus par les symboles %,%% et %%%. Cela a déjà permis de faire de nombreux
calculs sur les suites, mais reste néanmoins limité, car pour faire un calcul on peut avoir
besoin d’autres valeurs que celles que l’on vient juste d’utiliser ! Nous allons maintenant donc
introduire d’autres notions qui vont permettre de faire des calculs plus évolués : les variables,
les fonctions, les tableaux et les boucles.
2.1
Les variables
Nous avons déjà rencontré quelques variables : Pi,Digits, l’indice de boucle i. Contrairement à d’autres langages de programmation, comme le C ou le Fortran, les variables ne sont
pas déclarées à l’avance et l’utilisateur n’a pas besoin de préciser le type (réel,entier,caractère,
pointeur...).
Il existe des variables prédéfinies :
>Pi,Digits,I;
I est le nombre complexe i (on a i2 = −1). Certaines de ces variables peuvent être modifiées
(comme Digits) et d’autres non (comme I et Pi).
Les autres variables sont définies à partir du moment où elles sont affectées. L’affectation d’une
variable se fait par l’instruction := (comme nous l’avons déjà vu pour la variable Digits).
>a:=1:a;
La valeur 1 est mise dans la variable a. Il peut parfois être intéressant de libérer une variable,
c’est-à-dire d’enlever la valeur qu’elle contenait. Cela se fait à l’aide de la fonction unassign.
>a:=1:a;unassign(’a’):a;
Ainsi, dans cet exemple, a redevient une variable formelle (on pourrait ainsi définir par
exemple des polynômes en fonction de a, comme cela avait été fait pour les polynômes de
9
10
CHAPITRE 2. VARIABLES, FONCTIONS, TABLEAUX ET BOUCLES
Chebychev).
Pour réinitialiser toutes les variables et tout ce qui a été fait auparavant, on utilise la commande
>restart;
Reprenons l’exemple de la suite de Fibonacci
>n:=10:u:=1:v:=1:
for i to n-2 do w:=u+v:u:=v:v:=w:od:w;
Remarquez qu’il a été nécessaire d’utiliser ici une variable temporaire w.
Lorsque l’on cherche à résoudre un problème, celui-ci va généralement dépendre de quelques
paramètres (paramètres physiques, de simulation,. . .), qu’il est important de bien identifier. Il
est conseillé de définir ces variables paramètres une fois pour toutes au début, pour la clarté
et afin de pouvoir les modifier facilement.
Exemple 1. On souhaite comparer l’erreur obtenue pour le calcul de
Z π
Z 1
sin(x)dx.
exp(x)dx,
0
0
par la méthode des rectangles et la méthode des trapèzes. L’intégrale exacte pour l’exponentielle
est donnée par
>int(exp(x),x=0..1):evalf(%);
La méthode des rectangles d’une fonction f sur un intervalle [a, b] est donnée par la formule
N −1
b−a
b−a X
),
f (a + k
N
N
k=0
tandis que la méthode des trapèzes est donnée par
N
−1
X
b−a b−a
) .
f (a) + f (b) + 2
f (a + k
2N
N
k=1
On peut écrire alors le code Maple suivant
>f:=exp:a:=0:b:=1: #cas1
#f:=sin:a:=0:b:=Pi:#cas2
N:=10:
int(f(x),x=a..b):Iexact:=evalf(%);
a:=evalf(a):b:=evalf(b):dx:=(b-a)/N:
#methode des rectangles
0.:a:for i to N do %%+f(%):%%+dx:od:
Irect:=%%*dx;Irect-Iexact;
#methode des trapezes
0.5*(f(a)+f(b)):a+dx:for i to N-1 do %%+f(%):%%+dx:od:
Itrap:=%%*dx;Itrap-Iexact;
Ainsi, en commentant/décommentant la deuxième ligne (i.e. en laissant ou en enlevant le
premier # de la deuxième ligne), on peut passer de la première à la deuxième intégrale.
2.2. LES FONCTIONS
2.2
2.2.1
11
Les fonctions
Fonctions et expressions
Supposons que l’on veuille définir la fonction f (x) = x2 + 1, afin de calculer par exemple
son intégrale, comme dans l’exemple précédent. Pour cela, il y a deux manières de faire : soit
on écrit
>f:=x->x^2+1:
et dans ce cas, pour évaluer la fonction en un point, par exemple pour x = 0.1, on écrit
>f(0.1):
soit, on considère l’expression
>f:=x^2+1:
et dans ce cas, pour évaluer l’expression en x = 0.1, on écrit
>subs(x=0.1,f);
Remarquons que l’on peut passer d’une forme à l’autre :
>f:=x^2+1:f:=unapply(f,x);
>f:=x->x^2+1:f:=f(x);
Notons que dans le cas d’une fonction la variable est muette ; on peut la changer sans changer la définition (on aurait pu écrire par exemple f :=y->y^ 2 ;). Ceci n’est pas vrai pour
une expression où il faut faire attention que la variable utilisée soit libre (on peut toujours
libérer une variable avec unassign, comme nous l’avons déjà vu). En général, on préfèrera les
expressions qui sont des objets plus simples.
Exercice 7. Modifier l’Exemple 1, pour pouvoir traiter le calcul de
Z 1
Z 1
1
exp(−x2 )dx.
dx,
2
1
+
x
−1
−1
On traitera le cas où l’on utilise des fonctions et le cas où l’on utilise des expressions.
2.2.2
Procédures
Lorsque l’on veut faire plusieurs calculs avec des paramètres différents, il peut être intéressant
d’englober le calcul dans une procédure. Cet objet se présente de la manière suivante :
>toto:=proc(f,N)
local i,tmp;
tmp=0.;
for i to N do tmp:=tmp+evalf(subs(x=i/N,f)):od:
tmp/N;
end proc:
> f:=x^2:N:=10:toto(f,N);N:=20:toto(f,N);f:=exp(-x^2):toto(f,N);N:=40:toto(f,N);
12
CHAPITRE 2. VARIABLES, FONCTIONS, TABLEAUX ET BOUCLES
Pour le premier >, on définit la fonction ; toto est le nom, f,N sont des variables paramètres
qui sont utilisées dans la procédure, i et tmp sont des variables locales c’est-à-dire qu’elles
n’existent qu’ à l’intérieur de la procédure. Le dernier résultat avant la fin de la procédure
(matérialisé par end proc :) est ce qui sera renvoyé par la procédure lors de l’appel.
Pour le deuxième >, on appelle la fonction avec différents paramètres.
Exercice 8. Ecrire une procédure rect(f,a,b,N) et trap(f,a,b,N) qui calcule l’intégrale
d’une fonction f sur un intervalle [a, b], avec respectivement la méthode des rectangles et des
trapèzes. La tester pour différents paramètres.
2.3
Les tableaux
On a vu que pour l’on pouvait calculer les termes d’une suite à l’aide de variables.
Considérons maintenant la suite définie de la manière suivante :
1
c1 = ,
7
k−1
k−1
X
1 X
5k + 9
jcj ck−j + −
cj ,
ck =
6
3
j=1
j=1
k ≥ 2.
Nous voyons que pour calculer le kième terme ck , nous avons besoin de tous les termes
précédents ck−1 , . . . , c1 . Nous avons donc besoin de stocker ces valeurs une fois qu’elles sont
calculées.
2.3.1
La commande array
Pour cela, nous pouvons utiliser un tableau par la commande
>N:=100:c:=array(1..N):
Cela veut dire que l’on a réservé des variables c1 , . . . , cN que l’on pourra affecter par la suite.
On peut écrire ainsi :
c[6]:=1:
Notons que les variables peuvent être de n’importe quel type ; en particulier, l’espace occupé
par les variables non encore affectées n’est pas alloué, mais sera alloué lors de l’affectation.
Remarque 1. Lorsque l’on connait la taille des objects, on peut parfois réserver à l’avance
la place mémoire. Cela peut augmenter les performances pour le temps d’accès au tableau.
Néanmoins, on ne connait pas toujours la place occupée par les variables (par exemple, certains entiers peuvent être très grands et nécessiteront donc beaucoup de stockage). Le lecteur
intéressé pourra consulter l’aide sur la commande rtable.
Un intérêt de la commande array est que l’on peut faire commencer et terminer les indices
où l’on souhaite. Ainsi, on peut écrire
>deb:=-10:fin:=15:c:=array(deb..fin):
On peut également indicer les tableaux en plusieurs dimensions
>N:=10:M:=12:L:=array(1..N,1..M):
2.3. LES TABLEAUX
13
L’accès se fait alors par L[i,j]. Pour calculer la suite précédente, on peut donc écrire.
N:=30:L:=array(1..N):L[1]:=1/7:
for k from 2 to N do
S:=add(L[j],j=1..k-1):T:=add(j*L[j]*L[k-j],j=1..k-1):
L[k]:=(6/(5*k+9))*(T-S+1/3);
od:evalf(%);
On a utilisé ici la commande add qui fait la somme des éléments de la liste (on aurait aussi
pu utiliser la commande for) et on a utilisé from, pour faire commencer k par 2 et non la
valeur 1 par défaut.
Pour afficher tous les éléments du tableau, on peut écrire
>eval(L);
2.3.2
Les listes
On peut aussi définir des tableaux par des listes de la manière suivante :
L:=[1,4,7];
Un intérêt est la déclaration qui est plus simple. On peut aussi accéder au nombre d’éléments
à l’aide de la commande nops
>nops(L);
La fonction nops compte le nombre d’opérandes de l’ objet L et les opérandes sont données
par la fonction op. L’affichage de toute la liste se fait tout simplement en écrivant
>L;
Attention, dans une liste, les indices commencent par 1 :
>L:=[3,6,7]:L[1];op(1,L);
La valeur 3 est ici affichée, puisque c’est le premier élément de la liste, qui est aussi la première
opérande de L.
Notons aussi qu’une liste est une séquence entre crochets et pour générer une séquence, il est
commode d’utiliser la commande seq
L:=[seq(i*i,i=1..5)];
Exercice 9. Calculer c200 lorsque c1 vaut 1/7 et 1./7, en mettant ces deux valeurs initiales
dans une liste et on souhaite avoir le résultat sous forme d’une liste.
De manière générale (aussi en voyant l’exercice précédent), on préferera utiliser array pour
des grands tableaux et des listes pour des petits tableaux (qui peuvent être une liste de
paramètres à tester, que l’on mettra de préférence au début du programme ).
Remarquons aussi la commande map qui applique une fonction à une liste (ou un array) :
>N:=10:L:=[seq(k/N,k=0..N)]:f:=x->exp(x):fL:=map(f,L):
14
2.4
CHAPITRE 2. VARIABLES, FONCTIONS, TABLEAUX ET BOUCLES
Boucles et tests
Pour diverses raisons, on peut avoir besoin d’exécuter une instruction que sous certaines
conditions.
Prenons l’exemple de la recherche dichotomique. On se donne une fonction continue sur
un intervalle [a, b] tel que f (a) > 0 et f (b) < 0. On sait alors qu’il existe une racine de
f sur l’intervalle [a, b], c’est-à-dire un nombre x ∈ [a, b] tel que f (x) = 0. La recherche
dichotomique permet alors de trouver une racine notée x dans cet intervalle. On regarde
le signe de f ((a + b)/2), afin de savoir si x ∈ [a, (a + b)/2] ou si x ∈ [(a + b)/2, b]. On
recommence ensuite ce procédé jusqu’à l’obtention d’un intervalle assez petit pour avoir une
bonne approximation de x. On peut alors définir la procédure suivante.
>dicho:=proc(aa,bb,eps,Nmax,f)
local fa,fb,err,i,c,a,b;a:=evalf(aa):b:=evalf(bb):
fa:=evalf(subs(x=a,f));fb:=evalf(subs(x=b,f));err:=fa;i:=0:
if(fa*fb>0) then error "Mauvais intervalle\n";end;
while((abs(err)>eps) and (i<Nmax)) do
c:=0.5*(a+b):err:=evalf(subs(x=c,f)):
if(err<0) then b:=c:fb:=err:else a:=c:fa:=err:fi:
i:=i+1:
od:
i,c,evalf(subs(x=c,f));
end proc:
On a ici utilisé l’instruction conditionnelle if, la boucle while. Notez la syntaxe :
if (..) then .. else .. fi:
while (..) do .. od:
On a aussi utilisé l’instruction error suivie d’une chaı̂ne de caractères qui est le message
d’erreur. Lorsque l’on est dans cette situation, le message d’erreur est renvoyé et le reste de la
procédure n’est pas exécuté (on sort de la procédure). Le symbole après ”intervalle” signifie
que l’on va à la ligne. On a aussi utilisé le signe logique and (et). Dans ce contexte, on pourra
aussi utiliser les symboles ou, différent, égal, négation :
or,<>,=,not
En particulier, on ne confondra pas le symbole = de test d’égalité entre deux objets avec le
symbole := qui est l’affectation d’une variable.
Exercice 10. Grâce à la fonction précédente, trouver une approximation de l’unique solution
de l’équation
tan(x) = x,
pour x ∈]π/2, 3π/2[. Modifier le code précédent pour pouvoir traiter le cas où f (a) < 0 et
tester sur un exemple. Comparer avec le résultat obtenu par fsolve.
Chapitre 3
Graphiques
Dans le chapitre précédent, nous avons vu les principales bases pour faire un calcul. Avec
certains paramètres d’entrée, on est capable de faire une suite d’instructions qui aboutit à
un résultat qui se présente généralement sous la forme d’un ou plusieurs nombres ou d’une
expression formelle (comme un polynôme). Pour répondre à un problème donné, le résultat
peut se présenter come une suite importante de nombres qu’il est alors commode de visualiser
à l’aide d’un outil graphique. Nous allons voir ici comment visualiser de résultats en 1D,
2D, 3D et comment faire des animations. Un autre point est de savoir comment stocker des
informations.
3.1
3.1.1
La commande plot
Des fonctions
On peut visualiser des fonctions par :
>f:=sin(4*x):plot(f,x=0..2*Pi);
>f:=x->sin(4*x):plot(f,0..2*Pi);
Dans le premier cas, on utilise la forme expression tandis que dans le deuxième cas, il s’agit
de la forme fonction. On peut aussi visualiser plusieurs graphiques en même temps ; cela peut
être extrêmement utile lorsque l’on veut faire une comparaison. Pour cela, on utilise
>plot([sin,cos],x=0..Pi,color=[red,blue],legend=["sin","cos"]);
Remarquez les options utilisées pour bien distinguer les courbes, grâce aux couleurs et à la
légende.
Exercice 11. A l’aide de la fonction plot, localiser le 5ième zéro strictement positif de la
fonction x − tan(x), à 10−2 près ; vérifier le résultat avec fsolve.
Un autre moyen de dessiner deux courbes en même temps est d’utilise la fonction display
qui fait partie de la libraire plots. Pour cela, on charge d’abord la librairie en écrivant
>with(plots):
Puis, on définit les deux graphiques de chaque courbe avant de créer la graphique qui contiendra les deux courbes.
>G1:=plot(sin,0..Pi,color=red,legend="sin"):G2:=plot(cos,0..Pi,color=blue,legend="cos"):
display(G1,G2);
15
16
CHAPITRE 3. GRAPHIQUES
3.1.2
Un ensemble de points
On peut aussi dessiner un ensemble de points, ce qui peut être utilisé si on connait la
fonction cherchée seulement en un nombre fini de points. Pour cela, la commande est la
suivante
>plot([[0,0.5],[1,0.2]]);
Ainsi les points (0, 0.5) et (1, 0.2) sont reliés par un segment (on peut ne tracer que les points
en rajoutant l’option style=point).
Exercice 12. Tracer sur un même graphique la fonction sin avec une résolution de 10 points
et de 20 points, avec une légende. Comparer avec
plot(sin,0..2*Pi,adaptive=false,numpoints=10);
On peut également tracer des courbes paramétrées de la forme (x(t), y(t)) ; par exemple,
pour dessiner le cercle de centre (0, 0) et de rayon 1, on écrit
plot([cos(t),sin(t),t=0..2*Pi],scaling=constrained);
L’option est mise pour que les axes soient les mêmes (sinon, on aurait une ellipse !).
3.1.3
Faire une animation
Il peut être intéressant de vouloir dessiner l’évolution d’un graphique ; cela s’obtient facilement avec la fonction display, en rajoutant l’option insequence=true : on définit tout
d’abord la liste d’images et on appelle ensuite la fonction display que l’on applique à cette
suite. En cliquant sur l’image, on voit ensuite apparaı̂tre des boutons play, pause,. . . qui permettent de contrôler l’animation.
Prenons l’exemple de la cycloide : il s’agit du mouvement d’un point fixé à un cercle qui roule
sans glisser sur une droite. Regardez ce que fait ce code et cherchez à comprendre toutes les
instructions.
n:=50:R:=5:nbt:=2:
t:=0:dt:=nbt*2*Pi/n:
G:=[seq(0,k=1..n)]:G0:=plot([[0,0],[nbt*2*Pi*R,0]],color=black):
for k to n do t:=t+dt:
G1:=plot([R*(cos(s)+t),R*(sin(s)+1),s=0..2*Pi],color=red):
G2:=plot([R*(s-sin(s)),R*(1-cos(s)),s=0..t],color=blue):
G3:=plot([[R*(t-sin(t)),R*(1-cos(t))]],thickness=2,style=point,color=red):
G[k]:=display([G0,G1,G2,G3]):
od:display(G,insequence=true,scaling=constrained,axes=none);
Exercice 13. Hypo/épicycloides
1. Tracez un cercle de rayon 1 et de centre (0, 0).
2. Soit R 6= 0 un nombre et t ∈ [0, 2π]. On considère le cercle de rayon |R| et de centre
((R + 1) cos(t), (R + 1) sin(t)). Que représente ce cercle par rapport au cercle de la question
1, suivant le signe de R ? Que se passe-t-il lorsque t varie ? Faites une animation.
3. On considère la courbe définie sur [0, t] par
x(s) = (1 + R) cos(s) − R cos((1/R + 1)s),
y(s) = (1 + R) sin(s) − R sin((1/R + 1)s).
17
3.2. AUTRES COMMANDES
Rajoutez cette courbe à l’animation précédente.
4. Comme dans le cas de la cycloide, rajoutez le point rouge.
Exercice 14. On cherche un nombre L > 0 vérifiant
L=
gT 2
2πd tanh
,
2π
L
avec g = 9.81, tandis que T et d sont des paramètres qui varient.
1. Pour un jeu de paramètres T, d, trouvez L à l’aide de la fonction dicho (que l’on pourra
légèrement modifier).
2. Calculez l’erreur maximale commise par rapport à la solution ”exacte” obtenue à l’aide de
fsolve.
3. Pour une valeur de T donnée, faı̂tes une représentation de L en fonction de d.
4. Pour une valeur de d donnée, faı̂tes une représentation de L en fonction de T .
5. Superposez plusieurs graphiques précédents pour des valeurs de T différentes.
3.2
Autres commandes
Il existe de nombreuses autres possibilités pour faire des graphiques : implicitplot,plot3d.
Il peut être utile également de sauvegarder des informations dans un fichier pour pouvoir les
utiliser plus tard, soit avec le même logiciel ou même avec d’autres logiciels.
Pour cela, on consultera la commande fprintf.
On peut aussi sauvegarder des graphiques en format eps ou jpg.
Voici quelques instructions qui peuvent être utiles si l’on veut par exemple utiliser Maple
sans mode graphique et avoir quand même la possibilité de visionner des graphiques (sans
animations néanmoins).
interface(plotdevice=ps,plotoutput=‘toto.ps‘);
with(plots):
plotsetup(ps);
plot(sin,x=0..2*Pi);
quitplotsetup():
system("xv toto.ps&"):
la dernière ligne permet de visualiser le fichier ps avec le logiciel xv (qui doit être installé).
3.3
Exercices
Exercice 15. Polynômes de Lagrange Etant donnés un intervalle I = [a, b], une fonction
f définie sur I et un ensemble de k + 1 points {xn }n=0...k avec xn ∈ I ∀n = 0 . . . k ; on définit
l’interpolée de Lagrange de f sur l’ensemble {xn }n=0...k comme l’unique fonction polynômiale
P de degré inférieur ou égal à k vérifiant
P (xn ) = f (xn )
∀n = 0 . . . k.
Le programme suivant calcule l’interpolation de Lagrange, grâce à la fonction interp.
18
CHAPITRE 3. GRAPHIQUES
>restart:with(plots):
>f:=exp(x):N:=3:a:=0:b:=1:#parametres
h:=(b-a)/N:L:=[seq(a+k*h,k=0..N)]:
g:=unapply(f,x):Pf:=interp(L,map(g,L),x):
seq(subs(x=L[k],Pf-f),k=1..N+1);
plot(f-Pf,x=a..b);
>G1:=plot(f,x=a..b,color=blue):G2:=plot(Pf,x=a..b,color=red):
display([G1,G2]);
Que représentent h, le premier et le deuxième graphique ? Essayer avec d’autres paramètres.
Modifier le programme pour pouvoir faire une animation suivant le nombre de points de
discrétisation.
Exercice 16. : La marche de l’ivrogne
Supposons qu’un ivrogne marche dans une rue droite et fait un pas à chaque seconde :
tantôt vers la gauche et tantôt vers la droite de manière aléatoire. On va aussi supposer qu’il
peut rester immobile. Les 100 premiers pas de l’ivrogne peuvent se modéliser ainsi :
> hasard:=rand(-1..1):
> positionivrogne:=0:
> for k from 1 to 100 do
a:=hasard():
positionivrogne:= positionivrogne + a:
enddo;
> positionivrogne;
Voir l’aide sur la fonction rand() si nécessaire. Modifions le programme précédent afin de
conserver en mémoire chacune des positions de l’ivrogne :
> hasard:=rand(-1..1):
> positionivrogne:=0:
> for k from 1 to 100 do
a:=hasard():
positionivrogne:= positionivrogne + a:
position[k]:=positionivrogne:
enddo;
> positionivrogne;
> l:=[seq([n,position[n]],n=1..100)]:
> plot(l,0..100);
Modéliser une marche aléatoire dans le plan. On stockera les positions successives de
l’ivrogne pour en tracer un graphique. Quelle est alors la distance parcourue par l’ivrogne ?
Quelle distance le sépare de son point d’origine ?
Chapitre 4
Quelques compléments
4.1
Résolution d’équations différentielles
On souhaite simuler le déplacement x(t) d’une masse accrochée à un ressort. Par application du théorème de Newton, on obtient l’équation différentielle :
d
d2
x(t) + α x(t) + kx(t) = 0
2
dt
dt
Maple possède différents outils permettant la résolution d’équations différentielles, comme la
commande dsolve ou encore la fonction odeplot pour la visualisation des solutions (voir
l’aide sur ces deux fonctionnalités).
Dans un premier temps, on définit l’équation différentielle. Il existe plusieurs manières de
définir une dérivée. On utilisera de préférence les commandes D ou diff. La dérivée d’une
fonction f(x) est alors : diff(f,x) ou D(f). La dérivée de f en x=0 est D(f)(0). La dérivée
seconde s’écrit par exemple diff(f(f,x,x) ou encore diff(f,x$2) (d’autres formulations
sont données dans l’aide).
L’équation différentielle est donnée ainsi :
m
ressort:={m*diff(x(t),t,t)+alpha*diff(x(t),t)+k*x(t)=0};
Puis les différents paramètres sont fixés : la masse m, le coefficient de frottement α et la
raideur du ressort k :
m:=2:alpha:=0.5:k:=5:
On définit également les conditions initiales. A l’instant initial, le ressort a une longueur l
(soit x(0) = l) et une vitesse nulle (soit dx(0)
dt = 0). De manière à changer plus facilement les
conditions initiales, on peut définir une fonction CI telle que :
CI:=(a,b)->{x(0)=a, D(x)(0)=b};
On constatera que l’équation différentielle et ses conditions initiales sont définies comme des
ensembles (entourés de {}), la commande dsolve nécessitant cette syntaxe.
Enfin on peut résoudre l’équation différentielle :
sol:=dsolve(ressort union CI(0.5,0), x(t), numeric);
19
20
CHAPITRE 4. QUELQUES COMPLÉMENTS
L’option numeric indique que la solution de l’équation est approchée par une méthode
numérique
Grâce à la commande odeplot, on peut représenter le mouvement du ressort dans le temps :
odeplot(sol, [t, x(t)], 0..10, numpoints=400);
et aussi modéliser l’état du système dans l’espace des phases :
odeplot(sol, [x(t), diff(x(t),t)], 0..10, numpoints=400);
Exercice 17 (Le pendule simple rigide). On souhaite simuler le mouvement d’un pendule
simple. On rappelle que l’équation différentielle régissant le mouvement est :
d
d2
θ(t) + 2f θ(t) + w02 sin(θ(t)) = 0
2
dt
dt
où w0 est la pulsation propre du pendule et f le coefficient de frottement (on donnera w0 = 1
et f = 0.1).
De plus on suppose qu’à l’instant initial, le pendule est forme un angle de 1.5rad avec l’axe
vertical et que la vitesse angulaire vaut 2.
Comme précédemment, résoudre l’équation différentielle et donner une représentation graphique de la trajectoire et de l’état du système dans l’espace des phases.
Exercice 18 (Attracteurs de Lorenz). On considère un fluide chauffé (par exemple, de l’air
au dessus d’un radiateur). L’air chaud étant moins dense que l’air froid, il monte. En montant, il se refroidit et redescend. Le mouvement du fluide s’organise autour de rouleaux dits
de convection. D’après le modèle de Lorenz, ces rouleaux sont parallèles et tournent en sens
inverse l’un de l’autre.
La position (x(t), y(t), z(t)) d’un élément du fluide est décrite par le système différentiel suivant :
d
dt x(t) = s(y(t) − x(t))
d
dt y(t) = rx(t) − y(t) − x(t)z(t)
d
dt z(t) = x(t)y(t) − bz(t)
où s, r et b dépendent du volume chauffé et du mode de chauffage (on choisit s = 10, r = 28,
b = 38 ).
On souhaite visualiser la trajectoire d’un élément. Pour ce faire :
1. Utiliser le package DEtools, qui offre plus de fonctionnalités quant à la manipulation
d’équations différentielles
2. Définir le système d’équations différentielles (comme une suite, et non plus comme un
ensemble, i. e., on ne met pas les accolades) et stocker cette suite dans la variable Lorenz
3. Définir les conditions initiales (également comme une suite) en posant x(0) = y(0) =
z(0) = 1 et stocker cette suite dans la variable CI
4. Utiliser la fonction DEplot3d pour représenter la trajectoire :
DEplot3d({Lorenz},[x(t), y(t), z(t)], t=0..100, stepsize=0.01, [[CI]],
orientation=[-35,75], linecolor=t, thickness=1);
21
4.2. PARTIEL JANVIER 2007
4.2
Partiel janvier 2007
c
Exercice 19. Réécrire les fonctions suivantes en MAPLE
:
- abs, la valeur absolue d’un réel.
- max, qui détermine le maximum entre deux réels.
- Heaviside, la fonction de Heaviside qui vaut 0 quand x < 0 et 1 quand x ≥ 0.
Ecrire une version
Pn simplifiée de sum qui prenne en argument une fonction f et un entier n
et qui retourne i=1 f (i).
c
Comment calculer en MAPLE
limx→0
sin x
x
?
Exercice 20. On donne la procédure
fact:=proc(n::nonnegint)
local resu,y;
y:=n;
while y>0 do
resu:=resu*y;
y:=y-1;
end do;
return resu;
end proc;
Pourquoi cette procédure ne retourne-t-elle pas n! (la factorielle de n) ? (justifier)
Modifier cette procédure pour que celle-ci retourne n! si n est pair et −n! si n est impair.
Donner une version de la factorielle en utilisant l’instruction for.
Exercice 21. On définit les polynômes de Chebyshev par la formule suivante pour n ≥ 0 :
Tn (x) = cos(n arccos(x)).
On démontre que ces polynômes vérifient la relation de récurrence suivante :
Tn (x) = 2xTn−1 (x) − Tn−2 (x).
En utilisant cette relation, écrire une procédure récursive qui permette de calculer Tn (x).
Exercice 22. Définissez à l’aide des commandes maple la fonction f suivante :
f (t) =
∞
X
2(−1)n+1 sin(nt)
n=1
n
Quelle ligne de commandes permet de tracer cette fonction sur l’intervalle [−π, π].
Exercice 23. Soit les trois fonctions de trois variables :
f [1](x[1], x[2], x[3]) = x[1] + 2x[2] + 5x[3] − 1
f [2](x[1], x[2], x[3]) = x[2]x[3]2 − 2
f [3](x[1], x[2], x[3]) = x[3]5 − 5
22
CHAPITRE 4. QUELQUES COMPLÉMENTS
On définit la matrice Jacobienne (MJ ) associée à ces trois fonctions par :
(MJ )i,j =
df [i]
dx[j]
et le système d’équations suivant :

 f [1](x, y, z) = 0
f [2](x, y, z) = 0

f [3](x, y, z) = 0
Le but de l’exercice est d’utiliser la méthode de Newton-Raphson pour résoudre ce système
d’équations.
La méthode de Newton-Raphson est une méthode itérative distinée à résoudre les systèmes
d’équations non-linéaire.
On décrit l’algorithme de la méthode de Newton-Raphson comme suit :
– Soient (x0 , y0 , z0 ) une donnée initiale.
t (X , Y , Z ) :
– Résoudre le système
matriciel
n n
n

(S) d’inconnues 

Xn
f [1](xn , yn , zn )
MJ (xn , yn , zn )  Yn  = −  f [2](xn , yn , zn ) ,
f [3](xn , yn , zn )
Zn
où MJ (xn , yn , zn ) désigne l’évaluation de la matrice Jacobienne MJ en (xn , yn , zn )
– (xn+1 , yn+1 , zn+1 ) = (xn , yn , zn ) + (Xn , Yn , Zn )
– arrêt de l’algorithme si |(xn+1 , yn+1 , zn+1 ) − (xn , yn , zn )| < ǫ,
où ǫ désigne un paramètre ayant pour vocation à être petit.
c
1. Définir en MAPLE
les trois fonctions f 1, f 2 et f 3 ;
2. Ecrire une procédure qui, prenant pour arguments ces trois fonctions, retourne la matrice Jacobienne MJ .
3. Ecrire une procédure qui, prenant pour arguments les trois fonctions , la matrice Jacobienne et un triplet (xn , yn , zn ), résoud le système S.
c
4. Ecrire finalement une succession de commandes MAPLE
, utilisant les procédures
préalablement définies, pour résoudre le système E par l’algorithme de la méthode de
Newton-Raphson.
23
4.3. PARTIEL SEPTEMBRE 2007
4.3
Partiel septembre 2007
Exercice 24.
1. Expliquez quelle est la différence entre les commandes suivantes :
(a) > P:=x^3-2*x^2+3*x;
(b) > solve(x^2-x-1,x);
2. Pourquoi les commandes suivantes renvoient-elles un message d’erreur ?
(a) > I:=matrix(3,3,[a,b,c,d,e,f,g,h,i]);
(b) > i:=matrix(3,3,[a,b,c,d,e,f,g,h,i]);
Exercice 25. Ecrire une boucle qui affiche à l’écran la somme
k
X
n=1
1 + 2 + ··· + n
1n + 2n + · · · + nn
pour les k paires de 1 à 100
Exercice 26. On considère la procédure suivante
>blob:=proc(S)
>global T:
>local i,n,temp:
>n:=nops(S):
>temp:=S[n]:
>for i from n to 2 by -1 do
>T[i]:=S[i-1]:
>end do:
>T[1]:=temp:
>return T:
>end proc;
Quels seront les résultats des commandes suivantes :
i. >T:=[1,2,3,4];
>blob(T);
ii. >T:=[1,2,3,4];
>blob(blob(T));
iii. >T:=[1,2,3,4];
>blob(T);
>blob(blob(T));
Exercice 27. Ecrire une procédure SecDeg(a, b, c) qui résout l’équation du second degré à
coefficients réels ax2 + bx + c = 0 en distinguant 3 cas selon le signe du discriminant.
Exercice 28. On définit des entiers truc(k, n), où n est un entier positif ou nul et k est un
entier quelconque, par la procédure récursive suivante :
>truc:=proc(k,n)
>option remember:
>local i,n,temp:
24
CHAPITRE 4. QUELQUES COMPLÉMENTS
>if (n=0) then
>return k;
>else
>truc(k,n-1)+truc(k-5,n-1);
>end if
>end proc;
Que vaut truc(2, 3).
Exercice 29.
On appelle suite récurrente d’ordre 2 toute suite définie de la manière suivante

 un = aun−1 + bun−2 , n ≥ 2
u = x0
 0
u1 = x1
où a, b, x0 et x1 sont des réels donnés (b 6= 0).
1. Ecrire une boucle qui permet de stocker dans une séquence les 101 premiers termes
d’une telle suite.
2. On appelle polynôme caractéristique associé à la suite le polynôme
X 2 − aX − b.
Si ce polynôme admet deux racines réelles distinctes r1 et r2 alors un est aussi determiné
explicitement sous la forme
un = λr1n + µr2n
où λ et µ sont deux réels à déterminer à partir des données initiales x0 et x1 ; plus
précisément λ et µ sont solutions du système
λ
+µ
= x0
.
λr1 +µr2 = x1
Donner une succession de commandes MAPLE qui permet :
(a) de déterminer les racines du polynôme caractéristique (la commande solve(eqn,var)
renvoie les solutions de l’equation eqn en fonction de la variable var sous la forme
d’une structure de liste),
(b) de déterminer λ et µ (pour assigner les solutions d’un système utiliser la commande
assign(S), où S désigne la solution du système),
(c) de vérifier si la suite définie de manière explicite est bien égale (pour les 101
premiers termes) à la suite définie par récurrence.
3. Déterminer à la main r1 , r2 , λ et µ pour la suite de Fibonacci et vérifier que les deux
formes (explicite et récurrente) correspondent sur u0 , u1 et u2 .