Introduction à l’animation

avec Maple

Faouzi LAKRAD
 Avant propos

Il va sans dire que les animations numériques peuvent aider énormément à

mimer les phénomènes physiques. Certes ces animations ne peuvent pas
remplacer la réalité, mais elles constituent un pas vers sa compréhension surtout
lorsqu’elles sont basées sur des lois physiques théoriques et empiriques.

Dans le présent travail on utilise le logiciel Maple pour générer des animations.
Le présent rapport est composé de trois parties.

La première partie, composée de quatre ateliers complémentaires, contient des

notions de cours avec exemples et des exercices à faire.
Dans le premier atelier les possibilités de dessins dans Maple sont présentées.
Dans le deuxième atelier les techniques de traçage des courbes ainsi que la
résolution des équations différentielles ordinaires sont présentées.
Dans le troisième atelier des lois de comportements imposées ainsi que les
solutions des EDOs sont utilisées pour animer les dessins faits dans le premier
atelier.
Dans le quatrième atelier les résultats des simulations numériques ainsi que les
animations sont enregistrés dans des fichiers externes.

La deuxième partie contient le listing de tous les programmes des quatre ateliers
y compris les solutions des exercices.

La troisième partie contient le listing de deux projets didactiques : le pendule

simple et le système masse-ressort-amortisseur.

Toutes les animations traitées dans le présent rapport sont dans le plan. Les
animations en 3D feront l’objet de nos prochains travaux.

Note : tous les programmes contenus dans ce rapport ont été testés uniquement
sur Maple 6 et Maple 8 et pas sur les autres versions.

2
Table des matières
Atelier 1 : les dessins avec Maple …………………………………….. 4

Atelier 2 : Résolution des EDOs avec Maple ……………………………... 6

Atelier 3 : Introduction à l’animation avec Maple ………………………... 9

Atelier 4 : Exportation des données et des animations de Maple ………... 12

Solution de l’atelier 1 ……………………………………………….. 14

Solution de l’atelier 2 ……………………………………………….. 16

Solution de l’atelier 3 ……………………………………………….. 18

Solution de l’atelier 4 ………………………………………………... 21

Projet1 : le pendule simple ……………………………………………….. 22

Projet2 : le système masse-ressort-amortisseur …………………………. 23

3
 Atelier1 : les dessins avec Maple

Objectifs :
 Initiation au dessin avec Maple.
 Dessiner un compas avec Maple.
 Dessiner une bicyclette avec Maple.

Comment tracer des lignes sous Maple ?

Pour tracer une ligne droite qui relie deux points ( x1 , y1 ) et ( x2 , y 2 )
> restart: with(plots): # ici on a effacé la mémoire et on a fait
appel à la librairie « plots »
> plot([[0,0],[1,1]]); # on a tracé une ligne entre les points (0,0)
et (1,1)

Exercice1 :
1- Exécuter la commande plot([[0,0],[1,1],[0,1]]);
2- Tracer un rectangle de sommets (0,0), (0,1), (1,0),(1,1).
3- Tracer un triangle équilatéral.

Dessiner un compas
Pour tracer un compas symétrique qui
modéliserait les deux pieds d’un bipède, on a
deux façons de faire:
1. définir un seul dessin:
plot([[x,y],[z,w],[t,y]]);
2. superposer deux dessins:
pied1:= plot([[x,y],[z,w]]):
pied2:=plot([[z,w],[t,y]]):
display(pied1,pied2);

4
Comment tracer un cercle sous Maple ?
Pour tracer un cercle on fait appel à la librairie
> with(plottools):
> c := circle([xc,yc], R); # xc et yc: les coordonnées du centre de
cercle et R le rayon
> display(c); # visualiser le cercle.

Exemple
> with(plottools):
c := circle([1,1], 1, color=green):
display(c);

Exercice2:
1- Dessiner deux cercles de rayon 1 et de centres respectifs (0,0) et (0,4).
2- Chercher sur le help la fonctionnalité de la commande « thickness »
3- Donner aux deux roues une « thickness=5 » et une couleur noir.

Dessiner une bicyclette en combinant des lignes et des cercles

Exercice 3:
Dessiner un système {ressort + amortisseur} au bout duquel est attaché un bloc rectangulaire
(une masse).

5
 Atelier2 : Résolution des EDOs avec Maple

Objectifs :
 Introduction à la résolution des équations différentielles ordinaires avec
Maple.
 Traçage des courbes.

Comment résoudre une EDO sous Maple ?

Il y a plusieurs façons pour écrire les EDOs sous Maple. On prend le cas d’un
système masse-ressort-amortisseur comme exemple. L’EDO régissant ce
système est :
m y(t )  c y (t )  k y(t )  F cos( t )
m : la masse du système,
k : la raideur du ressort,
c : le coefficient d’amortissement,
F : l’amplitude de la force harmonique externe,
 : la fréquence (pulsation) de la force harmonique externe.

 Cas où l’EDO est solvable analytiquement :

On commence avec le cas F  0 :
1> restart:
2> m:=1: c:=0.1: k:=1: # les paramètres
3> eq:=m*diff(y(t),t$2)+c*diff(y(t),t)+k*y(t)=0; # EDO
4> CI:={y(0)=1,D(y)(0)=1}; # Conditions initiales
5> solution:=dsolve({eq} union CI,y(t)); # Résolution de l'EDO
6> y:=unapply(rhs(solution),t); # extraction de l’expression de la
solution pour pouvoir l'utiliser dans d'autres calculs.
7> plot(y(t),t=0..30); # traçage de la solution.

 Méthode numérique pour la résolution des EDOs:

On applique les méthodes numériques pour résoudre l’EDO du système masse-
ressort-amortisseur. Utiliser les 4 premières commandes du programme
précedent, par la suite écrire :
5> solution:=dsolve({eq} union CI,y(t),numeric); # avec “numeric”,
dsolve crée une procedure d’intégration numérique en utilisant, par défaut,
une méthode du type Runge-Kutta-Fehlberg d’ordre 4(rkf)
Pour visualiser la solution à l’instant t=2, on écrit
> solution(2); # extrait la liste temps t=2, y(2), diff(y(2),t)
> solution(2)[2] ; # extrait y(2)
La solution de l’EDO pourra être visualisée graphiquement avec la fonction
odeplot de la bibliothèque graphique plots (il faut utiliser with(DEtools) et
with(plots)). Le premier argument est le nom de la procédure, le deuxième une
liste qui donne la ou les représentations choisies (y(t) en fonction de t ou t en

6
fonction de y(t)). Le troisième argument donne l’intervalle des valeurs choisies
pour t. Les autres arguments sont optionnels.

>figure1:=odeplot(solution,[t,y(t)],0..70,numpoints=100,color=b
lue):display(figure1);
On veut tracer sur la même figure la solution y(t) et sa dérivée en fonction du
temps:
>figure2:=odeplot(solution,[[t,y(t),color=green],[t,diff(y(t),t
),color=blue]],0..70): display(figure2);
On peut tracer les deux figures séparément et les regrouper dans la commande
display.
Exercice1 :
4- Résoudre numériquement l’EDO de Duffing y  0.2 y  y  0.1y 3  cos(t )
5- Résoudre numériquement l’EDO d’un pendule inversé :
y  0.2 y  sin( y)  0
6- Résoudre numériquement l’EDO d’un pendule simple :
y  0.2 y  sin( y)  0
7- Comparer les solutions des deux types de pendules.

Comment résoudre un système d’EDO sous Maple ?

La fonction dsolve permet de traiter de la même façon les systèmes d’équations.

En 1963 E. Lorenz publia un article où il donna un modèle réduit en trois

dimensions de la convection atmosphérique. Ce modèle fut le premier modèle
mettant en évidence numériquement l’existence d’un attracteur étrange ou
chaotique.
Le système de Lorenz est donné par :
x'   ( y  x)
y'   x  y  xz
z '    z  xy
où  ,  et  sont des paramètres positifs. Dans ce qui suit on prend
  10,   8 / 3,   28.

> restart: with(DEtools): with(plots):

> sigma:=10: beta:=8/3: rho:=35:
> Eq1:=diff(x(t),t)=sigma*(y(t)-x(t)):
> Eq2:=diff(y(t),t)=rho*x(t)-y(t)-x(t)*z(t):
> Eq3:=diff(z(t),t)=x(t)*y(t)-beta*z(t):
> lorenz:={Eq1,Eq2,Eq3,x(0)=5,y(0)=5,z(0)=5};
> solution:=dsolve(lorenz,{x(t),y(t),z(t)},type=numeric);
> solution(10);

7
> odeplot(solution,[t,x(t)],0..70);

Une autre façon de faire est d’utiliser DEplot3d (voir le help de Maple). On
redéfinie le système de Lorenz pour se conformer à l’écriture de DEplot3d :
lorenz:={Eq1,Eq2,Eq3}:
>DEplot3d(lorenz,{x(t),y(t),z(t)},t=120..180,[[x(0)=5,y(0)=5,z(
0)=5],[x(0)=5.0001,y(0)=5,z(0)=5]],scene=[x(t),y(t),z(t)],step
size=0.01);

Exercice2
Soit l’équation de Rossler suivante
 x   y  z

 y  x  a y avec a=0.2, b=0.2, c=5.7
 z  b  z ( x  c)

Résoudre ce système d’EDOs pour les conditions initiales suivantes :
x(0)  y(0)  z(0)  0.0001 .

Règle d’or : utiliser le help de Maple

8
 Atelier3 : Introduction à l’animation avec Maple

Objectifs :
 Introduction à l’animation des résultats des EDOs.
 Introduction à l’animation des modèles physiques.

Comment animer les résultats d’une EDO sous

Maple ?
Soit l’équation d’un pendule simple. On veut tracer le portrait de phase. Pour ce
faire il faut faire varier les conditions initiales pour les mêmes valeurs des
paramètres du pendule. Soit l’EDO d’un pendule simple:
g
y(t )  sin( y (t ))  0
l
y (t ) : L’angle de déviation du pendule par rapport à la verticale.
g : L’accélération de la pesanteur,
l : La longueur du pendule.
On écrit l’EDO du pendule :
> pendule:=diff(y(t),t$2)+(g/l)*sin(y(t))=0:
Par la suite on entre les conditions initiales sous forme de vecteurs :
> CI:=[[{y(0)=-
1,D(y)(0)=0}],[{y(0)=0,D(y)(0)=1}],[{y(0)=2,D(y)(0)=0}],[{y(0)
=0,D(y)(0)=2}],[{y(0)=-3,D(y)(0)=2.5}],[{y(0)=3,D(y)(0)=-
2.5}],[{y(0)=-3.14,D(y)(0)=0}],[{y(0)=-3.16,D(y)(0)=0}]];
Si on veut visualiser le contenu (ou l’opérande) du premier vecteur des
conditions initiales :
> op(CI[1]);
On fait une boucle avec l’instruction for, pour pouvoir prendre en compte tous
les vecteurs conditions initiales :
> Q:=[]:
for i from 1 to 8 do
CCI:=op(CI[i]):
solution:=dsolve({pendule} union CCI,y(t),type=numeric):
plt1:=odeplot(solution,[y(t),diff(y(t),t)],0..20,view=[-4..4,-
4..4],numpoints=100):
Q:=[op(Q),plt1]:
end do:

Pour pouvoir visualiser la superposition de toutes les courbes correspondantes à

toutes les conditions initiales:
> display(Q);
Lorsqu’on visualise les solutions de l’EDO pour différentes conditions initiales
dans le plan ( y(t ), y (t )) , on obtient le portrait de phase de l’EDO. Maple permet

9
d’obtenir les portrait de phase via l’instruction prédéfinie phaseportrait. Le
portrait de phase d’un pendule simple s’obtient comme suit :
> restart:with(DEtools):
> phaseportrait([D(x)(t)=y(t),D(y)(t)=-sin(x(t))],[x(t),y(t)],
t=-3.5..3.5,[[x(0)=0,y(0)=2],[x(0)=0,y(0)=-2],[x(0)=2*Pi,y(0)=2],
[x(0)=2*Pi,y(0)=-2],[x(0)=-2*Pi,y(0)=2],[x(0)=-2*Pi,y(0)=-2],
[x(0)=2*Pi,y(0)=1],[x(0)=2*Pi,y(0)=-1],[x(0)=-2*Pi,y(0)=1],
[x(0)=-2*Pi,y(0)=-1],[x(0)=0,y(0)=1],[x(0)=0,y(0)=-1],[x(0)=0,y(0)=3],
[x(0)=0,y(0)=-3]],stepsize=0.05,linecolor=blue);

Si on veut visualiser les courbes l’une après l’autre sous forme d’une animation:
> display(Q, insequence=true);

Comment animer un modèle physique sous Maple ?

> restart: with(DEtools): with(plots): with(plottools):

> l:=10: g:=10:

> CI:={y(0)=-1,D(y)(0)=0}:
> ODE:=diff(y(t),t$2)+(g/l)*sin(y(t))=0:
> solution:=dsolve({ODE} union CI,y(t),type=numeric);
solution(1);

Animation du modèle physique:

> Q:=[]:
> for j from 0 by 0.1 to 10 do
a:=rhs(solution(j)[2]):
mass:=disk([l*sin(a),-l*cos(a)],1,color=blue):
tige:=plot([[0,0],[l*sin(a),-l*cos(a)]],thickness=4,color=blue):
traj:=circle([0,0],l,color=cyan):
pendule:=display(mass,tige,traj):
Q:=[op(Q),pendule]:
end do:
> display(Q, insequence=true);

10
Exercices
1. Animer une roue qui roule sans glissement avec une vitesse constante.
2. Animer le modèle de la bicyclette dans le cas d’un mouvement suivant une
direction fixe.

Règle d’or : utiliser le help de Maple

11
Atelier4 : Exportation des données et des animations
de Maple

Objectifs :
 Exportation des données de Maple.
 Exportation des animations de Maple..

Comment écrire les résultats de la résolution

numérique d’une EDO dans un fichier ?
La fonction à utiliser est writedata. Elle s’écrit :
writedata(nom du fichier de destination, données à écrire, format)
 Nom du fichier de destination : il donne l’adresse de destination, il est
peut être soit un affichage sur l’écran si on utilise terminal, ou une
écriture dans un fichier dans le répertoire actif si on écrit par exemple
"donnees.dat",ou une écriture dans un fichier dans un répertoire à
préciser.
 Données à écrire : un tableau ou une liste à écrire.
 Format : la forme sous laquelle les nombres sont écrits, décimale pour
float, et entière pour integer.

Exemples
1. > for i to 3 do
writedata(terminal,[[I,evalf(exp(i)),cos(i*Pi)]],float)
end do:
2. > restart:
> A:=array([[3,-2.5,-1.0],[9.9e-1,-3.9,5.2],[-1,3.0,2.0]]):
> writedata("data.dat",A,float);
3. Ecriture des Solutions de l’EDO d’un pendule simple dans un fichier
“pendule.dat”:
> restart: with(DEtools):
> l:=10: g:=10: # paramètres du pendule
> CI:={y(0)=-3.,D(y)(0)=0}: # conditions initiales
> ODE:=diff(y(t),t$2)+(g/l)*sin(y(t))=0: # EDO d'un pendule simple
> solution:=dsolve({ODE} union CI,y(t),type=numeric): # solution
de l'EDO
> solution(1);
> for j from 0 by 0.1 to 30 do
a:=rhs(solution(j)[2]): # y(t)
b:=rhs(solution(j)[3]): # la vitesse diff(y(t),t)
writedata[APPEND]("pendule.dat",[[j,a,b]],float): # écrire les
solutions de l'EDO dans le fichier "pendule.dat" dans le fichier en cours.
end do:

12
Pour savoir le répertoire courant ou actif, on écrit currentdir();
Il est conseillé de sauvegarder le programme dans un répertoire autre que celui
donné par défaut.

Comment lire les données d’un fichier de données?

Une fois l’animation faite sous Maple, elle peut être enregistrée sous forme
.GIF. Par la suite on peut l’inclure dans une page web.

Règle d’or : utiliser le help de Maple

13
 Solution de l’Atelier1
© Faouzi Lakrad & Adil Boutaiyeb
-mercredi 31 janvier 2007-

Comment tracer des lignes sous Maple?

ligne droite:
> restart: with(plots):
> plot([[0,0],[1,1]]);
Exercice 1:
question 1:
> plot([[0,0],[1,1],[0,1]]);
question 2:
>
plot([[0,0],[1,0],[1,1],[0,1],[0,0]],color=green,thickness=6);
question 3:
>plot([[0,0],[0.5,sin(1/3*Pi)],[1,0],[0,0]],color=blue,thicknes
s=6);
Dessin d'un compas:
définition d'un seul dessin
> plot([[0,0],[2,5],[4,0]]);
superposer deux dessins
> pied1:=plot([[0,0],[2,5]]):
> pied2:=plot([[2,5],[4,0]]):
> display(pied1,pied2);
Comment tracer un cercle sous Maple?
> c:=circle([1,1],1,color=green):
> display(c);
Exercice 2:
question 1:
> c1:=circle([0,0],1):
> c2:=circle([0,4],1):
> display(c1,c2);
question 2:
> ?thickness
question 3:
> display(c1,c2,thickness=5,color=black);
Dessin d'une bicyclette en combinant des lignes et des
cercles:
> with(plottools):
> roue1:=circle([0,0],1,color=black,thickness=5):
> roue2:=circle([4,0],1,color=black,thickness=5):
> c:=circle([1.5,0],0.25,color=red,thickness=3):
> L1:=plot([[0,0],[0.75,2]],color=blue,thickness=4):
> L2:=plot([[0,0],[1.5,0]],color=blue,thickness=4):
> L3:=plot([[1.5,0],[0.625,2.25]],color=blue,thickness=4):

14
> L4:=plot([[0.75,2],[3,2]],color=blue,thickness=4):
> L5:=plot([[1.5,0],[3.125,1.75]],color=blue,thickness=4):
> L6:=plot([[4,0],[2.75,2.5]],color=blue,thickness=4):
> L7:=plot([[2.75,2.5],[2.5,2.35]],color=blue,thickness=4):
> L8:=plot([[0.5,2.25],[1,2.25]],color=blue,thickness=4):
> L9:=plot([[0,0],[0,1]],color=green,thickness=3):
> L10:=plot([[0,0],[-cos(1/6*Pi),-
sin(1/6*Pi)]],color=green,thickness=3):
> L11:=plot([[0,0],[cos(1/6*Pi),-
sin(1/6*Pi)]],color=green,thickness=3):
> L12:=plot([[4,0],[4,1]],color=green,thickness=3):
> L13:=plot([[4,0],[4-cos(1/6*Pi),-
0.5]],color=green,thickness=3):
> L14:=plot([[4,0],[4+cos(1/6*Pi),-
0.5]],color=green,thickness=3):
>display(roue1,roue2,c,L1,L2,L3,L4,L5,L6,L7,L8,L9,L10,L11,L12,L
13,L14);
Dessin d'un système {ressort + amortisseur} au bout
duquel est attaché un bloc rectangulaire:
> with(plottools):
> l1:=plot([[0,0],[0,5]],color=black,thickness=5):
> l2:=plot([[0,2],[3,2]],color=blue,thickness=4):
> l3:=plot([[3,1.5],[3,2.5]],color=blue,thickness=4):
> l4:=plot([[2.75,2.75],[3.5,2.75]],color=blue,thickness=4):
> l5:=plot([[2.75,1.25],[3.5,1.25]],color=blue,thickness=4):
> l6:=plot([[3.5,2.75],[3.5,1.25]],color=blue,thickness=4):
> l7:=plot([[3.5,2],[10.5,2]],color=blue,thickness=4):
>l8:=plot([[0,4],[2.5,4],[3,5],[4,3],[5,5],[6,3],[7,5],[8,3],[9
,5],[10,3],[10.5,4]],color=red,thickness=4):
>l9:=plot([[10.5,1],[10.5,5.5],[16,5.5],[16,1],[10.5,1]],color=
black,thickness=4):
> c1:=circle([11.5,0.5],0.5,color=green,thickness=3):
> c2:=circle([15,0.5],0.5,color=green,thickness=3):
> display(l1,l2,l3,l4,l5,l6,l7,l8,l9,c1,c2);

15
 Solution de l’atelier 2
© Faouzi Lakrad & Adil Boutaiyeb
-Vendredi 02 Fevrier 2007-

Le système masse-ressort-amortisseur: méthode analytique

> restart:
> m:=1: c:=0.1: k:=1:
> eq:=m*diff(y(t),t$2)+c*diff(y(t),t)+k*y(t)=0;
> CI:={y(0)=1,D(y)(0)=1};
> solution:=dsolve({eq} union CI,y(t));
> y:=unapply(rhs(solution),t);
> plot(y(t),t=0..30);
Le système masse-ressort-amortisseur: méthode numérique
> restart:
> m:=1: c:=0.1: k:=1:
> eq:=m*diff(y(t),t$2)+c*diff(y(t),t)+k*y(t)=0;
> CI:={y(0)=1,D(y)(0)=1};
> solution:=dsolve({eq} union CI,y(t),numeric);
> solution(2);
> solution(2)[2];
> with(plots):
>figure1:=odeplot(solution,[t,y(t)],0..70,numpoints=100,color=b
lue): display(figure1);
>figure2:=odeplot(solution,[[t,y(t),color=green],[t,diff(y(t),t
),color=blue]],0..70): display(figure2);
EDO de Duffing
> restart:
> a:=0.2: b:=1: c:=0.1:
> eq:=diff(y(t),t$2)+a*diff(y(t),t)+b*y(t)+c*y(t)^3=cos(t);
> CI:={y(0)=1,D(y)(0)=0};
> sol:=dsolve({eq} union CI,y(t),numeric);
> with(plots):
> fig:=odeplot(sol,[t,y(t)],0..70,numpoints=100,color=red):
display(fig);
Pendule simple
> restart:
> with(plots):
> a:=0.2: b:=1:
> eq1:=diff(y(t),t$2)+a*diff(y(t),t)+b*sin(y(t))=0;
> CI:={y(0)=0,D(y)(0)=0.1};
> sol1:=dsolve({eq1} union CI,y(t),numeric);
>fig1:=odeplot(sol1,[y(t),diff(y(t),t)],0..100,numpoints=500,co
lor=blue): display(fig1);

16
Pendule inversé
> restart:
> with(plots):
> a:=0.2: b:=-1:
> eq2:=diff(y(t),t$2)+a*diff(y(t),t)+b*sin(y(t))=0;
> CI:={y(0)=0,D(y)(0)=0.1};
> sol2:=dsolve({eq2} union CI,y(t),numeric);
>fig2:=odeplot(sol2,[y(t),diff(y(t),t)],0..100,numpoints=500,co
lor=red): display(fig2);
Système de Lorenz
> restart: with(DEtools): with(plots):
> sigma:=10: beta:=8/3: rho:=35:
> Eq1:=diff(x(t),t)=sigma*(y(t)-x(t)):
> Eq2:=diff(y(t),t)=rho*x(t)-y(t)-x(t)*z(t):
> Eq3:=diff(z(t),t)=x(t)*y(t)-beta*z(t):
> lorenz:={Eq1,Eq2,Eq3,x(0)=5,y(0)=5,z(0)=5};
> solution:=dsolve(lorenz,{x(t),y(t),z(t)},type=numeric);
> solution(10);
> odeplot(solution,[t,x(t)],0..70);
> lorenz:={Eq1,Eq2,Eq3}:
>DEplot3d(lorenz,{x(t),y(t),z(t)},t=120..180,[[x(0)=5,y(0)=5,z(
0)=5],[x(0)=5.0001,y(0)=5,z(0)=5]],scene=[x(t),y(t),z(t)],step
size=0.01);
Système de Rossler
> restart: with(DEtools): with(plots):
> a:=0.2: b:=0.2: c:=5.7:
> eq1:=diff(x(t),t)=-y(t)-z(t):
> eq2:=diff(y(t),t)=x(t)+a*y(t):
> eq3:=diff(z(t),t)=b+z(t)*(x(t)-c):
> rossler:={eq1,eq2,eq3,x(0)=0.0001,y(0)=0.0001,z(0)=0.0001};
> sol:=dsolve(rossler,{x(t),y(t),z(t)},type=numeric);
> rossler:={eq1,eq2,eq3}:
>DEplot3d(rossler,{x(t),y(t),z(t)},t=120..180,[[x(0)=0.0001,y(0
)=0.0001,z(0)=0.0001],[x(0)=1.0001,y(0)=0,z(0)=0]],scene=[x(t)
,y(t),z(t)],stepsize=0.01);

17
 Solution de l’atelier 3
©Faouzi Lakrad & Adil Boutaiyeb
-lundi 05 Fevrier 2007-

Animation des résultas d'une EDO sous Maple:

> restart: with(plots):
> l:=10: g:=10:
> pendule:=diff(y(t),t$2)+(g/l)*sin(y(t))=0:
> CI:=[[{y(0)=-
1,D(y)(0)=0}],[{y(0)=0,D(y)(0)=1}],[{y(0)=2,D(y)(0)=0}],[{y(0)
=0,D(y)(0)=2}],[{y(0)=-3,D(y)(0)=2.5}],[{y(0)=3,D(y)(0)=-
2.5}],[{y(0)=-3.14,D(y)(0)=0}],[{y(0)=-3.16,D(y)(0)=0}]];
> op(CI[1]);
> Q:=[]:
> for i from 1 to 8 do
> CCI:=op(CI[i]):
> solution:=dsolve({pendule} union CCI,y(t),type=numeric):
> plt1:=odeplot(solution,[y(t),diff(y(t),t)],0..20,view=[-
4..4,-4..4],numpoints=100):
> Q:=[op(Q),plt1]:
> end do:
> display(Q);
> display(Q, insequence=true);
Animation d'un modèle physique sous Maple:
> restart: with(DEtools): with(plots): with(plottools):
> l:=10: g:=10:
> CI:={y(0)=-1,D(y)(0)=0}:
> ODE:=diff(y(t),t$2)+(g/l)*sin(y(t))=0:
> solution:=dsolve({ODE} union CI,y(t),type=numeric);
> solution(1);
> Q:=[]:
> for j from 0 by 0.1 to 10 do
> a:=rhs(solution(j)[2]):
> mass:=disk([l*sin(a),-l*cos(a)],1,color=blue):
> tige:=plot([[0,0],[l*sin(a),-
l*cos(a)]],thickness=4,color=blue):
> traj:=circle([0,0],l,color=cyan):
> pendule:=display(mass,tige,traj):
> Q:=[op(Q),pendule]:
> end do:
> display(Q, insequence=true);
Le portrait de phase d'un pendule simple:
> restart:with(DEtools):

18
> phaseportrait([D(x)(t)=y(t),D(y)(t)=-
sin(x(t))],[x(t),y(t)],t=-
3.5..3.5,[[x(0)=0,y(0)=2],[x(0)=0,y(0)=-
2],[x(0)=2*Pi,y(0)=2],[x(0)=2*Pi,y(0)=-2],[x(0)=-
2*Pi,y(0)=2],[x(0)=-2*Pi,y(0)=-
2],[x(0)=2*Pi,y(0)=1],[x(0)=2*Pi,y(0)=-1],[x(0)=-
2*Pi,y(0)=1],[x(0)=-2*Pi,y(0)=-
1],[x(0)=0,y(0)=1],[x(0)=0,y(0)=-
1],[x(0)=0,y(0)=3],[x(0)=0,y(0)=-
3]],stepsize=0.05,linecolor=blue);
Animation d'une roue qui roule sans glissement avec une
vitesse constante:
> restart: with(plots): with(plottools):
> R:=1:
> Q:=[]:
> for j from 0 by 0.1 to 10 do
roue:=circle([j,0],R,color=blue,thickness=5):
rayon1:=plot([[j,0],[j-R*sin(j/R),-R*cos(j/R)]],thickness=5):
rayon2:=plot([[j,0],[j-R*sin((j/R)+(2*Pi/3)),-
R*cos((j/R)+(2*Pi/3))]],thickness=5):
rayon3:=plot([[j,0],[j-R*sin((j/R)+(4*Pi/3)),-
R*cos((j/R)+(4*Pi/3))]],thickness=5):
systeme:=display(roue,rayon1,rayon2,rayon3):
Q:=[op(Q),systeme]:
end do:
> display(Q, insequence=true);
Animation d'une bicyclette:
> restart: with(plots): with(plottools):
> R:=1:
> Q:=[]:
> for j from 0 by 0.1 to 10 do
> roue1:=circle([j,0],R,color=black,thickness=5):
> roue2:=circle([4+j,0],R,color=black,thickness=5):
> c:=circle([1.5+j,0],0.25,color=red,thickness=5):
> L1:=plot([[j,0],[0.75+j,2]],color=blue,thickness=4):
> L2:=plot([[j,0],[1.5+j,0]],color=blue,thickness=4):
> L3:=plot([[1.5+j,0],[0.625+j,2.25]],color=blue,thickness=4):
> L4:=plot([[0.75+j,2],[3+j,2]],color=blue,thickness=4):
> L5:=plot([[1.5+j,0],[3.125+j,1.75]],color=blue,thickness=4):
> L6:=plot([[4+j,0],[2.75+j,2.5]],color=blue,thickness=4):
> L7:=plot([[2.75+j,2.5],[2.5+j,2.35]],color=blue,thickness=4):
> L8:=plot([[0.5+j,2.25],[1+j,2.25]],color=blue,thickness=4):
> rayon1:=plot([[j,0],[j-R*sin(j/R),-
R*cos(j/R)]],color=green,thickness=5):
rayon2:=plot([[j,0],[j-R*sin((j/R)+(2*Pi/3)),-
R*cos((j/R)+(2*Pi/3))]],color=green,thickness=5):

19
rayon3:=plot([[j,0],[j-R*sin((j/R)+(4*Pi/3)),-
R*cos((j/R)+(4*Pi/3))]],color=green,thickness=5):
rayon4:=plot([[4+j,0],[4+j-R*sin(j/R),-
R*cos(j/R)]],color=green,thickness=5):
rayon5:=plot([[4+j,0],[4+j-R*sin((j/R)+(2*Pi/3)),-
R*cos((j/R)+(2*Pi/3))]],color=green,thickness=5):
rayon6:=plot([[4+j,0],[4+j-R*sin((j/R)+(4*Pi/3)),-
R*cos((j/R)+(4*Pi/3))]],color=green,thickness=5):
bicyclette:=display(roue1,roue2,c,L1,L2,L3,L4,L5,L6,L7,L8,rayo
n1,rayon2,rayon3,rayon4,rayon5,rayon6):
> Q:=[op(Q),bicyclette]:
> end do:
> display(Q, insequence=true);

20
 Solution de l’atelier4
©Faouzi Lakrad & Adil Boutaiyeb
-Mardi 06 Fevrier 2007-

comment écrire les résultas de la résolution numérique

d'une EDO dans un fichier?
exemple1:
> for i to 3 do
writedata(terminal,[[i,evalf(exp(i)),cos(i*Pi)]],float)
end do:
exemple2:
> restart:
> A:=array([[3,-2.5,-1.0],[9.9e-1,-3.9,5.2],[-1,3.0,2.0]]):
> writedata("data.dat",A,float);
exemple3: Ecriture des solutions de l'Edod'un pendule simple dans un fichier
"pendule.dat"
> restart: with(DEtools):
> l:=10: g:=10:
> CI:={y(0)=-3,D(y)(0)=0}:
> ODE:=diff(y(t),t$2)+(g/l)*sin(y(t))=0:
> solution:=dsolve({ODE} union CI,y(t),type=numeric):
> solution(1);
> for j from 0 by 0.1 to 30 do
a:=rhs(solution(j)[2]):
b:=rhs(solution(j)[3]):
writedata[APPEND]("pendule.dat",[[j,a,b]],float):
end do:

21
 Projet 1 : Pendule Simple
Ce projet consiste à résoudre numériquement l’EDO régissant le mouvement
d’un pendule simple. Les solutions (temps, angle, vitesse angulaire) de la
résolution numérique sont stockées dans le fichier « pendule.dat ». Par la suite,
dans la même animation on regroupe l’animation physique du pendule, l’angle
en fonction du temps, le plan de phase ainsi que l’affichage numérique de la
variation de l’angle.

> restart: with(DEtools): with(plots): with(plottools):

> l:=10: g:=10: # paramètres du pendule
> CI:={y(0)=-3.,D(y)(0)=0}: # conditions initiales
> ODE:=diff(y(t),t$2)+(g/l)*sin(y(t))=0: # EDO d'un pendule
simple
> solution:=dsolve({ODE} union CI,y(t),type=numeric): #
solution de l'EDO
> solution(1);
> figure:=odeplot(solution,[t,y(t)],0..30): # l'historique
> plan_phase:=odeplot(solution,[y(t),diff(y(t),t)+5],0..30):
# plan de phase
> Q:=[]: Z:=[]: p:=[]:
> for j from 0 by 0.1 to 30 do
a:=rhs(solution(j)[2]): # y(t)
b:=rhs(solution(j)[3]): # la vitesse diff(y(t),t)
writedata[APPEND]("pendule.dat",[[j,a,b]],float): # écrire
les solutions de l'EDO dans le fichier "pendule.dat" dans le
fichier en cours.
mass:=disk([l*sin(a),-l*cos(a)],1,color=blue):
tige:=plot([[0,0],[l*sin(a),-
l*cos(a)]],thickness=4,color=blue,title=cat("y(t)=",convert(a,
string))):
traj:=circle([0,0],l,color=cyan): # cercle de rayon l
pendule:=display(mass,tige,traj):
particule:=disk([j,a],0.4,color=green): #disque qui se
déplacera avec l'historique
trajectoire:=display(particule,figure): # l'historique
particule1:=disk([a,b+5],0.3,color=green): #disque qui se
déplace dans le plan de phase
phase1:=display(particule1,plan_phase): # plan de phase
dynamique
Z:=[op(Z),trajectoire]:
Q:=[op(Q),pendule]:
pp:=display(trajectoire,pendule,phase1):
p:=[op(p),display(pp)]:
end do:
> display(p,insequence=true);

22
 Projet 2 : le Système Masse-Ressort-
Amortisseur

> restart: with(DEtools): with(plots): with(plottools):

> CI:={x(0)=1,D(x)(0)=-.1}:
> m:=1: c:=0.0: k:=10:
> ODE:=m*diff(x(t),t$2)+c*diff(x(t),t)+k*x(t)=0:
> sol:=dsolve({ODE} union CI,x(t),type=numeric);
> figure_v:=odeplot(sol,[t,diff(x(t),t)],0..20,numpoints=500):
> figure:=odeplot(sol,[t,x(t)],0..20,numpoints=500):
>phase:=odeplot(sol,[x(t),5+diff(x(t),t)],0..20,numpoints=500):
> Q:=[]:
> for j from 0 by 0.1 to 20 do
> a:=rhs(sol(j)[2]):
b:=rhs(sol(j)[3]):
> l1:=plot([[0,-3],[0,-8],[20,-8]],color=black,thickness=6):
> l2:=plot([[0,-6],[3,-6]],color=blue,thickness=4):
> l3:=plot([[3,-5.5],[3,-6.5]],color=blue,thickness=4):
> l4:=plot([[1.5+a,-5.25],[5.5+a,-
5.25]],color=blue,thickness=4):
> l5:=plot([[1.5+a,-6.75],[5.5+a,-
6.75]],color=blue,thickness=4):
> l6:=plot([[5.5+a,-5.25],[5.5+a,-
6.75]],color=blue,thickness=4):
> l7:=plot([[5.5+a,-6],[10+a,-6]],color=blue,thickness=4):
> ressort:=plot([[0,-4],[1,-4],[2+(1/8*a),-3],[3+(2/8*a),-
5],[4+(3/8*a),-3],[5+(4/8*a),-5],[6+(5/8*a),-3],[7+(6/8*a),-
5],[8+(7/8*a),-3],[9+(8/8*a),-4],[10+a,-
4]],color=red,thickness=4):
> rectangle1:=plot([[10+a,-7],[14+a,-7],[14+a,-2],[10+a,-
2],[10+a,-7]],color=black,thickness=4):
rectangle_ref:=rectangle([10,-7],[14,-2],color=yellow):
> c1:=disk([11+a,-7.5],0.5,color=green):
> c2:=disk([13+a,-7.5],0.5,color=green):
mass1:=disk([j,a],0.2,color=blue):
mass2:=disk([a,5+b],0.2,color=blue):
mass3:=disk([j,b],0.2,color=green):

>systeme:=display(l1,l2,l3,l4,l5,l6,l7,ressort,rectangle1,c1,c2
,figure,mass1,rectangle_ref,phase,mass2,figure_v,mass3):
> Q:=[op(Q),systeme]:
> end do:
> display(Q, insequence=true);

23