M210: Calcul Scientifique

Université des Sciences et Technologies de Lille
U.F.R. de Mathématiques Pures et Appliquées
M210 : Calcul scientifique
Notes de cours par Clément Boulonne
L2 Mathématiques 2007 - 2008

Table des matières
1 Introduction à Maple 3
1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.1 Barre de commandes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.2 Barre d’outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.3 La feuille MAPLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Objets MAPLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3.1 Les nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3.2 Autres objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.3 Affectation pour les variables . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3.4 Listes et ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3.5 Tables et tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.4 Premières commandes en Maple . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.4.1 Conseils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.4.2 Bibliothèques (librairies ou packages) . . . . . . . . . . . . . . . . . . . . 8
1.4.3 Manipulation d’expression . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4.4 Arranger, simplifier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4.5 Substitution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.5 Eléments de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.5.1 Représentation de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.5.2 $ : variation de la variable . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.5.3 Booléens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.5.4 Résolution d’équations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.5.5 Structure de controle conditionnelle . . . . . . . . . . . . . . . . . . . . . 12
1.5.6 Print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.6 Procédure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.6.1 Variables locales et variables globales . . . . . . . . . . . . . . . . . . . . 13
2 Graphisme et géométrie 16
2.1 Graphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.1.1 Les courbes du plan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.1.2 Surfaces dans l’espace . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.1.3 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.1.4 Animations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.1.5 Autres options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.2 Géométrie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
2.2.1 Définitions et manipulation . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.3 Tests géométriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
2
3 Algébre linéaire 44
3.1 Vecteurs et matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.1.1 Construction élémentaire . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.1.2 Assignation et extraction . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
3.1.3 Affichage de grandes matrices . . . . . . . . . . . . . . . . . . . . . . . . 50
3.1.4 Génération automatique des composantes . . . . . . . . . . . . . . . . . . 51
3.1.5 Types et opérandes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.1.6 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.2 Algébre Linéaire élémentaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.2.1 Opérations élémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.2.2 Autres opérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
3.2.3 Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
3.2.4 Recherche de valeurs propres . . . . . . . . . . . . . . . . . . . . . . . . . 67
3.2.5 Recherche de vecteurs propres . . . . . . . . . . . . . . . . . . . . . . . . 68
4 Approximation 69
4.1 Sens étymologique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.2 Interpolation polynômiale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.2.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.2.2 Formulation du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.2.3 Résultat d’expérience . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.2.4 Gestion de l’erreur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.3 Autres interpolations polynomiales . . . . . . . . . . . . . . . . . . . . . . . . . 73
4.3.1 Approximation au sens des moindres carrés (cas discret) . . . . . . . . . 73
4.3.2 Approximation au sens des moindres carrés (cas continu) . . . . . . . . . 73
4.4 Polynômes trigonométriques : séries de Fourier . . . . . . . . . . . . . . . . . . . 74
4.4.1 Approximation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
4.4.2 Illustration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
5 Intégration 75
5.1 Régle des trapèzes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
5.1.1 Exemples introductifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
5.1.2 La régle des trapèzes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
5.2 La régle de Simpson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
5.2.1 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
6 "Révisions" 84
6.1 expand-simplify-normal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
6.2 Séquences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
6.3 sum et product . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
6.4 Construction de tables de groupes avec array . . . . . . . . . . . . . . . . . . . . 86
7 Equations différentielles 88
7.1 Fonction dsolve, équations différentielles et conditions initiales . . . . . . . . . 88
7.2 Divers aspects de l’intégration des équations différentielles . . . . . . . . . . . . 91
7.2.1 Résolution par transformations intégrales . . . . . . . . . . . . . . . . . . 91
7.2.2 Fonctions discontinues définissant les équations différentielles . . . . . . . 91
7.2.3 Solutions explicites et implicites . . . . . . . . . . . . . . . . . . . . . . . 92
7.2.4 Classes des équations différentielles . . . . . . . . . . . . . . . . . . . . . 94
4
7.2.5 Développement en série de la solution . . . . . . . . . . . . . . . . . . . . 95

7.2.6 Equations linéaires homohènes à coefficients polynomiaux . . . . . . . . . 96
7.3 Système d’équations différentielles . . . . . . . . . . . . . . . . . . . . . . . . . . 96
7.4 Résolutions numériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
7.4.1 Création d’une procédure (fonction) solution . . . . . . . . . . . . . . . . 98
7.4.2 Systèmes d’équations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
8 Equations différentielles (cours 2) 100

8.1 Introduction et rappels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
8.2 Exemples d’utilisation de DEplot . . . . . . . . . . . . . . . . . . . . . . . . . . 101
8.2.1 Comportement des solutions d’un système linéaire 2×2 . . . . . . . . . 102
8.2.2 Exemples d’utilisation pour le package DETools . . . . . . . . . . . . . . 102
9 Un peu de programmation 103

9.1 Procédure récursive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
9.2 Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
A Correction du partiel du lundi 31 mars 2008 116

A.1 Enoncé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
A.2 Corrigé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
B TP d’entrainement pour l’examen 123

B.1 Transformation d’un nombre en une liste et vice et versa . . . . . . . . . . . . . 123
B.2 [Plus difficile] Groupes de permutations . . . . . . . . . . . . . . . . . . . . . . . 123
Chapitre 1
Introduction à Maple
1.1 Introduction
MAPLE est un logiciel de calcul scientifique developpé par l’Université de Waterloo au
Canada. En cours, on utilisera la version 9.5 (malgré que les versions 10 et 11 sont disponibles).
Le logiciel permet d’étabilr un dialogue avec une machine. Il “comprend les nombres mais aussi,
d’infini, de fonctions, d’intervalles, de limites.
1.2 Interface
L’interface du logiciel est assez simple. Mais savoir les 3500 commandes de MAPLE par
coeur serait complétement impossible. En plus des 3500 commandes que fournit MAPLE de
base, il existe des bibliothèques crées par les utilisateurs qui permettent de faire plus de chose
que normalement. Bien que développé au Canada, l’interface de MAPLE est en anglais. Comme
tout logiciel, l’interface est divisé en 4 parties :
1. La barre des commandes (File, Edit, Insert...)
2. La barre d’outilis (barre de boutons permettant de faire des actions dans la feuille de
MAPLE)
3. La feuille de MAPLE où on écrit les commandes ou le texte.
4. La barre de bas de fenêtre indiquant le temps de calcul (CPU) de la feuille.
1.2.1 Barre de commandes

• File : permet d’ouvrir un document existant ou un nouveau document, enregistrer ou
exporter un document sous un autre format.
• Edit : permet d’atteindre les fonctions de copier/coller, de rechercher un terme dans la
feuille MAPLE et le modifier.
• View : zoomer sur la feuille
• Insert : permet d’insérer des commandes maples grâce à > (chevron), du texte, des sections
ou des sous-sections
• Format : changer la police de caractères.
• Tools
• Window : il est conseillé de travailler sur plusieurs fenetres (une de brouillon et une
normale). On peut aussi séparer les fenêtres horizontalement ou verticalement.
• Help : permet d’accéder à la section Aide.
5
6 Chapitre 1. Introduction à Maple
1.2.2 Barre d’outils

C’est la barre qui permet d’accéder aux options de mise en page de la feuille Maple. On y
retrouve quelques boutons :
1. Dans la barre du haut :
– Le bouton T permet de taper du texte
– Le bouton chevron ([>) permet d’insérer des commandes MAPLE.
– Le bouton main permet d’arrêter un calcul trop long (cas d’une boucle infinie).
– Les boutons zoom permettent de zoomer sur la feuile.
2. Dans la barre du bas : ce sont les boutons de mise en forme (format de la ligne, des
polices, d’aligement).
1.2.3 La feuille MAPLE

La feuille MAPLE peut être composé de plusieurs sections ou de sous-sections. On peut en
ajouter grâce à Insert > Section (sections) et Insert > Subsection. Dans ces sections ou sous-
sections, on peut trouver des zones de textes (en noir et italique), des zones de commandes
Maple et ses résultats.
Exemple 1.2.1. Voici un exemple de texte qu’on peut taper sur le logiciel MAPLE
> x := 1 : 2*x+1 ;
3
1.3 Objets MAPLE

1.3.1 Les nombres
> 52+3 ; 41/3 ; 0.001234555E-2 ;
55
41
3
0.00001234555
52+3 est une addition de nombres entiers, MAPLE renvoie alors un résultat en nombre entier :
55. 41/3 est considéré comme un nombre rationnel donc le résultat est la fraction ab tel que
P GCD(a, b) = 1. Ici comme P GCD(41, 3) = 1 alors 41 3
n’est plus simplifiable donc renvoie le
même résultat que ce qu’on a indiqué 41 3
. 0,001234555E-2 est un nombre flottant. Dans ce qui
va suivre, on va savoir quel est le type de nombre qu’on écrit :
> map(whattype,[52+3,41/3,0.0012345555E-2]) ;
[integer, f raction, f loat]
map est la commande d’attribution.

> 3.22222225-3.22222226 ;
−1.10−8
Une virgule pour dire au logiciel que ceci est un nombre décimal n’est pas , mais .. Une
virgule , sert à séparer deux paramétres pour une fonction ou une procédure.
> L := [1,2,3,4] ; op(2,L) ;
L := [1, 2, 3, 4]
Chapitre 1. Introduction à Maple 7
2
Un nombre rationnel ou réel n’est pas évalué directement par MAPLE.
> Pi ;
π
Pour palier à ce problème, on utilise la commande evalf
> evalf(Pi,50) ;
3.1415926535897932384626433832795028841971693993751
Si on omet le deuxième paramétres de evalf, MAPLE evalue le nombre avec comme nombre
de chiffres significatifs, la valeur du paramétre Digits.
> Digits ; evalf(Pi) ; Digits := 50 ; evalf(Pi) ;
10
3.141592654
50
3.1415926535897932384626433832795028841971693993751
On remaque que quand on change la valeur Digits, la précision de MAPLE est aussi changée.
Maintenant, on peut représenter toutes sortes de nombres, même les complexes. I represente le
nombre imaginaire pure.
> a+b*I
a+I ∗b
Attention : on ne pourra pas assignier la variable I sinon :
> I := [1,2,3,4]
Error, illegal use of an object as a name
1.3.2 Autres objets

On peut aussi taper des chaines de caractères.
>sjd2cm ;
sjd2cm
>whattype(sjd2cn) ;
symbol
mais aussi des lettres indicées :
> a[1] ;
a1
> whattype(%) ;
indexed
Le % n’indique pas le pourcentage d’un nombre mais le résultat précédent (on appelle ce
symbole, dito).
1.3.3 Affectation pour les variables

On peut assigner des variables grâce à la commande :=.
> whattype(a) ; a :=5 ; whattype(a) ; assigned(b) ; assigned(a) ;
symbol
a := 5
integer
f alse
true
Mais on peut aussi désaffecter les variables de deux manières :
– par la commande : ’ ’ qui est un retour aux chaines de caractères.
> a := 15 ; assigned(a) ; a :=’a’ ; assigned(a) ;
a := 15
true
a := a
f alse
– par la commande : evaln qui evalue la variable en tant que chaine de caractères.
> a := 15 ; assigned(a) ; a := evaln(a) ; assigned(a) ;
a := 15
true
a := a
f alse
1.3.4 Listes et ensembles

Dans MAPLE, une liste est une structure de données représentée syntaxiquemet par une
suite d’éléments encadrée par des crochets.
> l := [11,12,13,20] ; whattype(l) ; ’l[2]’ :=l[2] ; op(2,l) ;
[11, 12, 13, 20]
list
12
12
l[2] et op(2,l) permet de trouver un élément de la liste. On peut aussi assigner à une variable
une liste grâce à la commande seq. Attention, seq doit être fonction d’une variable muette.
> s := [seq(x[i],i=1..4)] ; whattype(s) ; s[2] ;
s := [x1 , x2 , x3 , x4 ]
list
x2
Un ensemble (set) est une liste d’élément qui ne permet pas la répétition d’éléments. Elle
est déclarée par {...}.
> x := [1,2,3,4,4] ; y :={1,2,3,4,4} ; map(whattype,[x,y]) ;
x := [1, 2, 3, 4, 4]
y := {1, 2, 3, 4}
[list, set]
Contrairement à un ensemble, la liste tolère les répétitions d’éléments. De plus, elle met en
ordre rigoureusement la suite de nombres tapée par l’utilisateur. On peut convertir une liste en
un ensemble ou un ensemble en une liste grâce à la commande convert.
> z := convert(y,list) ; w := convert(z,set) ;
z := [1, 2, 3, 4]
w := {1, 2, 3, 4}
1.3.5 Tables et tableaux

> restart :
Elle permet de vider toutes les assignations faites avant la déclaration de cette commande.
> t := table([10,11,12,13,14,15]) ; t[1] ; whattype(t) ;
t := table([1 = 10, 2 = 11, 3 = 12, 5 = 14, 4 = 13, 6 = 15])
10
symbol
Pour atteindre une valeur du tableau, on utilise la notation []. On peut aussi assigner un
tableau de variables quelconques.
> t := array(1..6), whattype(t) ; eval(t) ;
t := array(1..6, [])
symbol
[0 ?01 ,0 ?02 ,0 ?03 ,0 ?04 ,0 ?05 ,0 ?06 ]
Si on met la valeur des cellules en deuxième argument, le tableau est rempli :
> t := array(1..6,[10,11,12,13,14,15])
t := [10 11 12 13 14 15]
1.4 Premières commandes en Maple

1.4.1 Conseils
1. Enregistrer régulièrement votre travail, les problèmes arrivent toujours au mauvais mo-
ment
2. Ne vous fiez pas aveuglement à Maple, exercez toujorus votre esprit critique, reflechissez
avant tout.
1.4.2 Bibliothèques (librairies ou packages)

Les bibliothèques sont des ensembles de procédeures que l’on a regroupé ensemble. Quand
Maple est lancée, elle utilise la bibliothèque stantard. On peut accéder aux packages additionnels
grâce à la commande with(Bibliothèque).
1.4.3 Manipulation d’expression

On peut sommer ou faire le produit d’un certain nombre d’éléments grâce à la commande
sum et product
> sum(k, k=1..100), ifactor(%)
5050
2 ∗ 52 ∗ 101
Ici, la commande ifactor(n) permet d’avoir la décomposition en facteurs premiers de n.

> product((x-k),(k=1..5) ; expand(%) ; factor(%)
(x − 1) (x − 2) (x − 3) (x − 4) (x − 5)
x5 − 15 x4 + 85 x3 − 225 x2 + 274 x − 120
(x − 1) (x − 2) (x − 3) (x − 4) (x − 5)
expand permet de développer une expression tandis que factor la réduit. Mais on ne peut pas
développer certaines expression :
> expand(1/(x+2)ˆ3)
1
(x + 2)3
Alors que :
> 1/(expand((x+2)ˆ3))
1
(x3 + 6 x2 + 12 x + 8)
Ici, Maple developpe le polynôme au dénominateur. Pour la trigonométrique, Maple ne
connait pas certaines simplifications trigonométriques :
> simplify(sin(x)ˆ2) ; simplify(cos(x)ˆ2) ; simplify(sh(x)ˆ2) ;
> simplify(tan(x)ˆ2) ; simplify(cos(x)ˆ2+sin(x)ˆ2) ;
sin(x)2
cos(x)2
sinh(x)2
tan(x)2
1
Combiner
On peut combiner des fonctions trigonométriques grâce à la fonction combine.
> expr := sin(a+b) ; devel := expand(expr) ; factor(expr) ;
expr := sin (a + b)
devel := sin (a) cos (b) + cos (a) sin (b)

sin (a + b)
> combine(devel,trig) ;
sin (a + b)
1.4.4 Arranger, simplifier

On peut aussi développer, factoriser, arranger et simplifier des expressions.
> a := expand((x^2+x+1)^6) ;
a := 1 + 6 x + 126 x5 + 90 x8 + 126 x7 + x12 + 6 x11 + 21 x10 + 50 x9 + 141 x6 + 21 x2 + 90 x4 + 50 x3
> sort(a,x) ;
x12 + 6 x11 + 21 x10 + 50 x9 + 90 x8 + 126 x7 + 141 x6 + 126 x5 + 90 x4 + 50 x3 + 21 x2 + 6 x + 1
La commande sort permet d’ordonner un polynôme en fonction de sa variable.
1.4.5 Substitution
On peut substituer une variable dans une fonction.
> subs(t=exp(x),ln(t)) ;
ln (ex )
> ln(exp(x)) ;
ln (ex )
> subs(t=ln(x),exp(t)) ; simplify(%) ;
eln(x)
x
> assume(x>0) ; simplify(%%) ;
x
On peut aussi substituer un élément dans une liste :
> restart ; A := x+y+z ; op(1,A) ;
A := x + y + z
x
> subsop(2=a,A) ;
x+a+z
B := cos(x+y) ; op([1,1],B) ; op([0,1],B) ; op([1,0],B) ; op([1,2],B) ;
B := cos (x + y)
x
proc (x :: algebraic) ... endproc
‘+‘
y
> subsop([1,2]=t,B) ;
cos (x + t)
> op([1,1],B) ;
x
> subsop([1,1]=v,B) ;
cos (v + y)
On peut aussi substituer toutes les occurences d’une sous-expression.
> f := sin(x)^3-cos(x)*sin(x)^2+cos(x)^2*sin(x)+cos(x)^3 ;
f := (sin (x))3 − (sin (x))2 cos (x) + sin (x) (cos (x))2 + (cos (x))3
> algsubs(sin(x)^2 = 1-cos(x)^2,f) ;
sin (x) − cos (x) + 2 (cos (x))3
> subs(sin(x)^2 = 1-cos(x)^2,f) ;

(sin (x))3 − 1 − (cos (x))2 cos (x) + sin (x) (cos (x))2 + (cos (x))3
> simplify(%) ;
sin (x) − cos (x) + 2 (cos (x))3
1.5 Eléments de programmation

1.5.1 Représentation de fonctions
On peut fabriquer très facilement des fonctions en Maple de la manière suivante :
f := (x1 , x2 , ..., xn ) -> expression(x1 , x2 , ..., xn )
ce qui signifie littéralement "on définit f comme le fonction qui aux variables (x1 , ..., xn ) associe express
> f := x -> exp(-x^2) ;
2
f := x 7→ e−x
> f(0) ;
1
> diff(f(x),x) ;
2
−2 xe−x
> f(y) ;f(x[i]) ;
2
e−y
2
e−xi
Mais :
> f ; whattype(f) ;
f
symbol
On peut construire une fonction en utilisant des structures de contrôles (voir Section 1.5.5.
pour quelques structures de contrôles)
> restart ; > f := x -> if x > 0 then ln(x) else 0 fi ;
f := x → if 0 < x then ln (x) else 0 endif
> f(2) ; f(-2) ; ;

ln (2)
0
On peut aussi transformer une expression en une fonction :
> restart ; > f := exp(-x^2) ;
2
f := e−x
> f(0) ;
2
e−x (0)
> g := unapply(f,x) ;
2
g := x 7→ e−x
> g(0) ;
1
1.5.2 $ : variation de la variable

$ permet d’évaluer une expression en faisant varier un paramétre.
> x^3 $ x=0..10 ;
0, 1, 8, 27, 64, 125, 216, 343, 512, 729, 1000
ou
> f := x -> sin(x) ;
f := x 7→ sin (x)
> g := x -> (10^(-x)) ;
g := x 7→ 10−x
> f(g(x)) ;
sin 10−x
evalf(f(g(x))) $ x = 1..10 ;
0.09983341665, 0.009999833334, 0.0009999998333, 0.00009999999983,
0.00001000000000, 0.000001000000000, 0.0000001000000000, 0.00000001000000000,

0.000000001000000000, 0.0000000001000000000
1.5.3 Booléens
Il y a trois types d’expressions booléens
1. or : “ou
2. and : “et
3. not : “non
et trois résultats :
1. true : “vrai
2. f alse : “faux
3. F AIL : “échec
Il y a aussi des connecteurs binaires comme <,<=,>,>=,<>,=.
1.5.4 Résolution d’équations

On peut resoudre une équation soit avec la commande solve ou evalb (evaluer en booléen).
> solve(x=x^2) ;
0, 1
> evalb(x=x^2) ;
false
> x :=1 ; evalb(x=x^2) ;
x := 1
true
1.5.5 Structure de controle conditionnelle

Ce sont une structure qui se déclenche quand une condition ou des conditions sont vérifiés.
Elle s’écrit comme ça
if ... then ... else ... fi ;
i := 9 ;
if irem(i,2) = 0 then
i := i/2 ;
else
i := 3*i+1 ;
fi ;
i := 9
i := 28
1.5.6 Print
La commande print force Maple à mettre le résultat.
> i := 1 : j :=y : k :=3 : print(i,j,k) ;
i := 1
j := y
k := 3
1, y, 3
1.6 Procédure
Une procédure est un ensemble d’instructions ordonnées. Un programme est une procédure
qui en appelle d’autres. On construit une procédure de la manière suivante :
proc ... RETURN ... end
La ligne de commande proc ne contient pas de virgules.

Il y a 4 temps pour une procédure :
1. Les arguments de la procédure sont évalués séquentiellement.
2. Les valeurs obtenues sont utilisées pour remplacer les différentes occurences des pra-
maètres utilisés lors de la définition de la procédure.
3. Les différentes instructions de la procédure sont évaluées
4. La valeur obtenue lors de l’évaluation de la dernière instruction est retournée
> produit := proc(a,b)
> a*b ;
> end :
> produit(17+3,5*2) ;
200
> restart ;
> bonjour := proc(nom,jour) ;
> print("Bonjour", nom, "on est le ",jour) ;
> end :
bonjour(Clément, Jeudi) ;
"Bonjour", Clément, "on est le ", jeudi
1.6.1 Variables locales et variables globales

Outre les variables transmises comme paramétres, il peut exister différentes variables.
1. Les variables locales (local) sont les variables qui sont utilisés uniquement dans une
procédure.
> iter := proc(n)
> local comp,i ;
> comp := 0 ;
> for i from 1 to n do
> if floor(n/i) = n/i then
> print(i," est un diviseur de ",n) ; comp := comp+1 ;
> fi ;
> od ;
> print("On compte ",comp," diviseurs de ",n) ; > end ;
iter := proc(n)
local comp, i ;
comp := 0 ;
for i to n do
if floor(n/i) = n/i then
print(i, " est un diviseur de ", n) ;
comp := comp+1
end if
end do ;
print("On compte ", comp, " diviseurs de ", n)
end proc
1, “ est un diviseur de , 34
“On compte , 4, “ diviseurs de , 34
Et pourtant MAPLE ne connait pas comp
> comp ;
comp
MAPLE peut déclarer implicitement des variables locales.
> iter := proc(n)
> local comp
> comp := 0 ;
> fi ;
> od ;
Warning, ‘i‘ is implicitly declared local to procedure ‘iter‘
iter := proc(n)
local comp, i ;
comp := 0 ;
for i to n do
comp := comp+1
end if
end do ;
end proc
2. Les variables globales (global) peuvent être appelés à l’extérieur des procédures
> iter := proc(n)
> local i
> global comp
> comp := 0 ;
> fi ;
> od ;

iter := proc(n)
local i ;
global comp ;
comp := 0 ;
for i to n do
comp := comp+1
end if
end do ;
end proc
> iter(20) ;
1, “ est un diviseur de ”, 20
“On compte ”, 6, “ diviseurs de ”, 20
> comp ;
6
Chapitre 2
Graphisme et géométrie
2.1 Graphisme
La visualisation est une étape importante dans l’élaboration des preuves en mathématiques.
L’avènement des logicles de calcul formel conviviaux possédant une interface graphique évo-
luée a rendu cette phrase assez attrayante et intéressante. Nous allons explorer les possiblités
graphiques ainsi que certains aspects des capacités géométriques offertes par MAPLE.
2.1.1 Les courbes du plan

La première commande à connaitre est plot dont la syntaxe est :
plot(expr(var),var=min..max,option) ;
Cordonnées cartésiennes
> plot(x^3+1,x=-3..3) ;
> plot(tan(x),x=-3..3) ;
18
Chapitre 2. Graphisme et géométrie 19
Ce n’est pas très parlant, il faut préciser à Maple le “range" vertical, soit
> plot(tan(x),x=-3..3,-3..3) ;
Une syntaxe plus simple :

> plot(cos) ;
Ici par défaut, le range est fixé à [−10, 10], on peut le changer
> plot(cos(x),x=-20..20) ;
20 Chapitre 2. Graphisme et géométrie
Maple permet de tracer des courbes paramétrées (attention aux crochets).

> plot([sin(1.5*t),cos(1.7*t),t=-2*Pi..2*Pi]) ;
On peut faire figurer plusieurs courbes sur un même graphique

> plot({x^2,x^3},x=-3..3) ;
On peut aussi avoir recours à la commande display qui se trouve dans le package plots à
l’aide des syntaxes suivantes :
display(plot_1,plot_2,...,plot_n,options) ;
display([plot_1, plot_2,...,plot_n],options) ;
display(plot_1,plot_2,...,plot_n,options) ;
où plot_i a une structure de plot et il est préférable de mettre deux points à la fin de la ligne
de commande de plot_i.
> with(plots) :
> plot1 := plot(x^2,x=-3..3) :
> plot2 := plot(x^3,x=-3..3) :
> display(plot1,plot2) ;
On peut aussi définir les couleurs de la courbes

> plot([sin,cos],color=[blue,magenta]) ;
les formes de la courbe :

> plot(sin,style=point) ;
Maple peut aussi tracer des courbes implicites (c’est-à-dire des courbes f (x, y) = 0) à l’aide
de la commande implicitplot du package plots dont la syntaxe est :
implicitplot(expr,x=a..b,y=α..β,options)
> implicitplot(y^2=x^3+3*x^2+2,x=-10..10,y=-10..10) ;
Maple permet de représenter des fonctions plus compliquées :

> combine(piecewise(x<1,exp(x)*exp(-2*x),x>3,4*sin(x)^3)) ;



 e−x x<1

0 x≤3


− sin (3 x) + 3 sin (x) 3 < x
> plot(combine(piecewise(x<1,exp(x)*exp(-2*x),x>3,4*sin(x)^3)),x=-3..10,-10..10) ;
On peut aussi produire une liste de points reliés entre eux ou non :
> l := [[-1,0],[0,1],[2,3],[3,8],[9,1]] ;
l := [[−1, 0], [0, 1], [2, 3], [3, 8], [9, 1]]
> plot(l) ;
> plot(l,style=point) ;
Coordonnées polaires
Pour obtenir le graphe d’une courbe en coordonnées polaires, on peut utiliser les syntaxes
suiantes :
polarplot(rho(theta),theta=a..b,options).
plot(rho(theta),theta = a..b, coords = polar, options) ;
où ρ est le rayon polaire et θ l’angle polaire.

> plot(sin(5*theta/3),theta=-3*Pi..3*Pi,coords=polar,scaling = constrained) ;
> polarplot(sin(7*theta/3),theta=-3*Pi..3*Pi,scaling = constrained) ;
2.1.2 Surfaces dans l’espace

Ici la commande à tout faire est plot3d, sa syntaxe est :
plot3d(expr(x,y), x=a1..b1,y=a2..b2,options)
Coordonnées cartésiennes
> plot3d(cos(x*y)+sin(x*y),x=-1..1,y=-1..1) ;
Nappe paramétree à l’aide de la syntax :
plot3d([x(s,t),y(s,t),z(s,t)],s=a1..b1,t=a2..b2,options) ;
> plot3d([t^2,s^2*sin(t),cos(t)-sin(t)],t=-5..5,s=-5..5) ;
On peut aussi représenté plusieurs courbes sur une même image avec la commande display
de la bibliothèque plots.
Coordonnées cylindriques
On peut aussi créer des courbes en coordonnées cynlidriques :
cylinderplot(rayon,angle=a1..b1,z=a2..b2,options) ;
plot3d(rayon,angle=a1..b1,z=a2..b2,coords=cylindrical,options) ;
> with(plots) : cylinderplot(z^2,theta=0..2*Pi,z=1..2) ;
Nappe paramétrée en coordonnées cylindriques :
cylinderplot([rayon,angle,cote],para1=a1..b1,para2=a2..b2,options) ;
> cylinderplot([t,sin(t),cos(s)],s=0..2*Pi,t=-2..2) ;
Coordonnées sphériques
Enfin, on peut créer des courbes en coordonnées sphériques :
sphereplot(rayon,theta=a1..b1,phi=a2..b2,options) ;
plot3d(rayon,theta=a1..b1,phi=a2..b2,coords=spherical,options) ;
Attention MAPLE considère le premier intervalle (respectivement le deuxième) comme va-
leurs attribuées à l’angle polaire (respectivement à la colatitude).
> sphereplot(theta*sin(2*phi),theta=0..2*Pi, phi=Pi..2*Pi) ;
Nappe paramétrée en coordonnées sphériques

> sphereplot([sin(2*t),cos(s),t],s=0..2*Pi,t=-Pi..Pi) ;
2.1.3 Options
Graphiques en 2D
option color = couleur. Maple offre les couleurs suivantes : aquamarine,black, blue,navy,coral,
brown,gold, green,gray,grey,khaki,magenta,maroon,
orange,pink,plum,red,sienna,tan,turquois,violet,vheat,white,yellow
> plot({x^2,x^3,x^4,x^6},x=-10..10,y=-10..10,color=[cyan,green,red,pink]) ;
On peut définir sa propre couleur en dosant les trois couleurs de base de MAPLE :
> macro(macouleur = COLOR(RGB,0.3456,0.8000,0.1000)) ;
macouleur
> textplot([10,1,"voici ma couleur"],color=macouleur) ;
On peut avoir une palette de couleurs d’une façon aléatoire.

> p := seq(seq(plots[polygonplot]([[i,j],[i+1,j],[i+1,j+1],[i,j+1]],
color=COLOR(RGB,rand()/10^12,rand()/10^12,rand()/10^12)),
i=1..10),j=1..10) :plots[display]([p]) ;
MAPLE ne calcule pas toujours suffisament de points, par défaut MAPLE calcule 39 points
par courbe, on peut augementer le nombre de points à l’aide de l’option numpoints=nbre.
Toutefois plus le nombre de points à calculer est grand plus le temps de calcul est long.
Si l’on désire tracer une courbe dans un repère orthonormé, on utilise l’option scaling=CONSTRAINED.
> plot(sin(x)) ;plot(sin(x),scaling=CONSTRAINED) ;
On peut indiquer à Maple de ne pas afficher les axes en prenant l’option axes=NONE
> plot(cos,axes=NONE) ;
On peut préciser l’affichage des graduations sur les axes en entrant l’option tickmarks=[n,m]
où n et m représentent le nombre de graduations sur l’axe des abscisses et celui des ordonnées.
> plot(cos,tickmarks=[0,0]) ;
> plot(cos,tickmarks=[4,3]) ;
Il est possible de représenter des points à l’aide de l’option style=point et on peut spé-
cifier le symbole qui représente ces points avec la commande symbol=... comme options
(BOX,CROSS,CIRCLE,POINT,DIAMOND).
> plot([[-1,2],[2,-1],[3,0],[4,1]], style=point, symbol=DIAMOND) ;)
Les légendes rendent les graphiques beaucoup plus parlant, ceci est fait avec l’option title.
On peut choisir la police à l’aide de titlefont (TIMES,COURIER,HELVETICA ou SYMBOL). Pour
HELVETICA et COURIER, le sytle peut être BOLD, OBLIQUE ... et SYMBOL n’accepte pas de sytle.
> aa :=textplot([1,1.2,"maximum local"],font=[HELVETICA,BOLD,8]) :
> bb :=textplot([Pi,-1.2,"minimum local"],font=[HELVETICA,BOLD,8]) :
> cc :=plot(cos(x),x=-Pi/2..3*Pi/2) :
> display(aa,bb,cc) ;
L’option labels = [nom_abscisse,nom_ordonnée] permet de donner un nom aux axes.

> plot(cos(x),x=-2*Pi..2*Pi,title="Fonction cosinus",titlefont=[HELVETICA,normal,20],
labels=[abscisses,ordonnes]) ;
Graphiques en 3D
Quelques options :
> plot3d(x^3+y^3+2,x=-5..5,y=-5..5,style=patchnogrid) ;
axes = BOXED/NORMAL/FRAME/NONE
> plot3d(cos(x+y),x=-2..2,y=-2..2,axes=boxed) ;
> plot3d(cos(x+y),x=-2..2,y=-2..2,axes=frame) ;
> plot3d(cos(x+y),x=-2..2,y=-2..2,axes=none) ;
view permet de réduire l’intervalle de variation de l’ordonnée :

> plot3d(1/(s]2+t]2),s=-2..2,t=-2..2,view=0..3,axes=boxed) ;
2.1.4 Animations
Maple permet aussi de céer des graphiques animées à l’aide de la commande animate dont
la syntaxe est :
animate(expr(x,t),x=a1..b1,t=a2..b2,options) ;
> with(plots) :
> animate(cos(t*x^2+1),x=-2..2,t=-2..2) ;
> animate(sin(t*x^2+1),x=-2..2,t=-2..2,coords=polar) ;
> animate3d(cos(x+y+t),x=-2..2,y=-2..2,t=-10..10) ;
2.1.5 Autres options

Inequal
Après le changement de plots, la commande inequal permet de visualer les solutions d’un
système d’inéquations (affines ! ! ! !).
> inequal({y<x+4,x>0,y>=2*x+1},x=-1..5,y=-10..10,optionsexcluded=(color=white)) ;
Courbes et sa tangente
Si on veut montrer la courbe et sa tangente en un point, on utilise showtagent avec la
bibliothèque student
> with(student)
> showtangent(x^2+3*x+1,2) ;
Courbes de niveau
La commande contourplot permet de tracer les courbes de niveau et la syntaxe est :
contourplot(expr1,x=a..b,y=c..d) ;
countourplot3d([f,g,h],a..b,c..d) ;
où les paramétres f, g, h sont des fonctions à tracer, expr1 des expressions en x et y.

> with(plots) : contourplot(y^(1/2)-cos(x),x=-15..15,y=0..15) ;
> contourplot3d([r,t,(r-1/r)*sin(t)-ln(r)], r=1..4, t=0..2*Pi, coords=cylindrical,

contours=150, grid=[50,50],style=polygonoutline) ;
Champs de vecteurs
La commande fieldplot permet de tracer un champ de vecteur dans le plan. La syntaxe

est :
fieldplot(f, x=r1, y=r2, options) fieldplot(f, r1, r2, options)
où f vecteur, r1 intervalle de la première variable, r2 intevalle de la deuxième variable. Il est

possible d’intégrer des procédures dans la commande. Il y a aussi des options.
> with(plots) :
> fieldplot([y^2*exp(x/100),-x^2*exp(y/100)],x=-1..1,y=-1..1,arrows=SLIM,color=x*y,gri
> f := (x,y) -> x/(x^2+y^2+4) : g := (x,y) -> -y/(x^2+y^2+4)^(1/2) :

> fieldplot([f,g],-2..2,-2..2,arrows=thick,color=f,grid=[15,15]) ;
Les courbes dans l’espace

spacecurve permet de tracer des courbes dans l’espace, la syntaxe est :
spacecurve(L,options)
où L est un ensemble de courbes dans l’espace.

> spacecurve({[sin(t),0,cos(t),t=0..2*Pi],[cos(t)+1,sin(t),0,numpoints=100]},
t=-Pi..Pi,axes=FRAME) ;
Les courbes tube
A l’aide la commande tubeplot, on peut donner du volume aux courbes dans l’espace ; la
syntaxe est :
tubeplot(C,options)
où C est un ensemble de courbes dans l’espace.

> F := (x,y) -> cos(x*y) :
> tubeplot({[sin(t),0,cos(t),t=0..2*Pi],[cos(t)+1,sin(t),0,numpoints=100]},
t=-Pi..Pi,axes=FRAME,radius=1/4,color=F,style=patch) ;
Graphe densité
La commande densityplot colore le plan en fonction des valeurs prises par une fonction à
deux variables.
densityplot(expr1,x=a..b,y=c..d)
> densityplot(sin(x+y),x=-1..1,y=-1..1,colorstyle=RGB) ;
> densityplot(binomial,0..5,0..5,grid=[10,10],colorstyle=HUE) ;
> densityplot(sin(x*y),x=-Pi..Pi,y=-Pi..Pi,axes=boxed,colorstyle=RGB) ;
> densityplot(x*exp(-x^2-y^2),x=-2..2,y=-2..2,grid=[49,49],colorstyle=HUE) ;
Matrixplot
La commande matrixplot permet de représenter les coefficients d’une matrice par des
histogrammes ; la syntaxe est :
matrixplot(A,options)
> M :=LinearAlgebra[RandomMatrix](20,20,density=0.1,generator=0..3)
+Matrix(20,20,shape=diagonal,fill=5)
> plots[matrixplot](M,heights=histogram,orientation=[-10,20],axes=normal) ;
Graphe de la solution d’une équation différentielle

Quand on a une équation différentielle, si on veut visualiser la solution graphiquement, on
utilise odeplots
odeplots(s,vars,r,<options>)
> p := dsolve({D(y)(x) = y(x),y(0)=1},y(x),type=numeric) :

> odeplot(p,[x,y(x)],-1..1) ;
> p := dsolve({diff(y(x),x) = sin(x*y(x)),y(0)=2},y(x),type=numeric) :

> odeplot(p,[x,y(x)],0..6) ;
> eqnl :={D(x)(t)-x(t)^2+2*y(t)=0,D(y)(t)+x(t)-2*y(t)=0,x(0)=1,y(0)=0} ;

sol :=dsolve(eqnl,{x(t),y(t)},numeric) :
plots[odeplot](sol,[[t,x(t)],[t,y(t)]],0..0.5,color=black) ;
n o
eqnl := D (x) (t) − (x (t))2 + 2 y (t) = 0, D (y) (t) + x (t) − 2 y (t) = 0, x (0) = 1, y (0) = 0
sol := proc (x_rkf45) ... endproc
2.2 Géométrie
On peut utiliser le package geometry.
> with(geometry) ;
[Apollonius, AreCollinear, AreConcurrent, AreConcyclic, AreConjugate, AreHarmonic
, AreOrthogonal, AreParallel, ArePerpendicular, AreSimilar, AreTangent, CircleOfSimilitude

, CrossProduct, CrossRatio, DefinedAs, Equation, EulerCircle, EulerLine
, ExteriorAngle, ExternalBisector, FindAngle, GergonnePoint, GlideReflection, HorizontalCoord
, HorizontalName, InteriorAngle, IsEquilateral, IsOnCircle, IsOnLine, IsRightTriangle
, MajorAxis, MakeSquare, MinorAxis, NagelPoint, OnSegment, ParallelLine
, PedalTriangle, PerpenBisector, PerpendicularLine, Polar, Pole, RadicalAxis, RadicalCenter
, RegularPolygon, RegularStarPolygon, SensedMagnitude, SimsonLine, SpiralRotation, StretchReflection
, StretchRotation, TangentLine, VerticalCoord, VerticalName, altitude, apothem, area
, asymptotes, bisector, center, centroid, circle, circumcircle, conic, convexhull
, coordinates, detail, diagonal, diameter, dilatation, directrix, distance, draw
, dsegment, ellipse, excircle, expansion, foci, focus, form, homology
, homothety, hyperbola, incircle, inradius, intersection, inversion, line, medial
, median, method, midpoint, orthocenter, parabola, perimeter, point, powerpc
, projection, radius, randpoint, reciprocation, reflection, rotation, segment, sides
, similitude, slope, square, stretch, tangentpc, translation, triangle
, vertex, vertices]
2.2.1 Définitions et manipulation

Les choses se passent en deux étapes, on définit les objets et ensuite on les dessine.
> point(A,2,3) ;
A
La commande detail permet d’afficher les propriétés d’un objet géométrque

> detail(A) ;
name of the object A
form of the object point2d
coordinates of the point [2, 3]
On peut calculer chacun des arguments
> form(A) ;
point2d
> coordinates(A) ;
[2, 3]
L’affichage des objets géométriques se fait à l’aide de draw dont la syntaxe est :
draw([obj_1,obj_2,...,obj_n],options) ;
draw({obj_1,obj_2,...,obj_n},options) ;
> point(B,-1,-3) ;
B
> point(C,1,1) ;
C
draw([A,B,C]) ;
Formes géométriques
Point Syntaxe :
point(P,Px,Py) ;
point(P,[Px,Py]) ;
form(P) retourne la forme de l’objet et coordinates(P) retourne les coordonnées du point.

> with(geometry) :
> point(A,-2,-3) :
detail(A) ;
A
point2d
[−2, −3]
> VerticalCoord(A) ;
−3
Droites Syntaxe :
line(l,[A,B]) ; # Définit par deux droites
line(l,eqn,n) ; # Définit par une équation
> with(geometry) :
> point(A,-1,0) :
> point(B,1,3) :
> line(l,[A,B]) ;
l
> HorizontalName(l) ;
F AIL
Procédure :
form(l) # Désigne la forme de l’objet l
Equation(l) # Désigne l’équation de la droite l
HorizontalName(l) # Désigne le nom de l’axe des abscisses
VerticalName(l) # Désigne le nom de l’axe des ordonnées
detail(l) # Donne le détail de l’objet l
On définit les axes horizontales et verticales par : _EnvHorizontalName et _EnvVerticalName
> _EnvHorizontalName := x ; _EnvVerticalName := y ;
_EnvHorizontalName := x
_EnvVerticalName := y
> point(A,-1,0) : point(B,1,3) :
> line(l,[A,B]) :
> HorizontalName(l) ; VerticalName(l) ;
y
> detail(l) ;
l
line2d
−3 − 3 x + 2 y = 0
> line(ll,2*x-5*y) :
> Equation(ll) ;
2x − 5y = 0
Triangles Syntaxe :
triangle(nom,[p1,p2,p3]) ; # Défini par trois points

triangle(nom,[l1,l2,l3]) ; # Défini par trois droites
> restart ;
> with(geometry) :
> point(A,-1,0) : point(B,0,3) : point(C,1,3) :
> triangle(T,[A,B,C]) ;
T
> draw(T,axes=NORMAL) ;
> area(T) ;
3/2
> bisector(bA,A,T) ;
bA
> detail(bA) ;
assume that the names of the horizontal and vertical axes are _x and _y, respectively
bA
line2d
√ √ √ √
−3 13 − 3 10 _x + 2 10 + 13 _y
√ √
−3 13 − 3 10 = 0
Quadrilatère droit Syntaxe :
square(nom,[p1,p2,p3,p4]) ;
Bien sûr il faut que p1, p2, p3 et p4 forme un quadrilatère et non deux triangles superposés.
> restart ; > with(geometry) : > point(A,0,0) : point(B,2,0) : point(C,2,1) : point(F,0
> square(Qu,[A,B,C,F]) ;
Qu
> diagonal(Qu) ; detail(Qu) ;
sqrt (5)
Qu
square2d
>
[[0, 0] , [2, 0]√, [2, 1] , [0, 1]]
5
> draw(Qu,axes=none) ;
Polygone régulier Syntaxe :
RegularPolygon(p,n,cen,rad) ;
> restart :
> with(geometry) :
> RegularPolygon(polyg,5,point(o,0,0),1) ;
polyg
> draw(polyg) ;
> detail(polyg) ;
name of the object polyg

form of the object RegularP
olygon2d
the side of the polygon 2 sin π5
the center of the polygon [0 , 0]
the radius of the circum-circle 1
the radius of the in-circle cos π5
3π
the interior angle 5
2π
the exterior angle 5
π
the perimeter 10 sin
5
the area 5 sin π5 cos π5
the vertices of the polygon [[1, 0], [cos (2/5 π) , sin (2/5 π)], [− cos (1/5 π) , sin (1/5 π)],
[− cos (1/5 π) , − sin (1/5 π)], [cos (2/5 π) , − sin (2/5 π)]]
Cercle Syntaxe :
circle(nom,[p1,p2,p3]) ; # défini par trois points

circle(nom,[center,rayon]) ; # défini par son centre et son rayon
circle(nom,equation) ; # défini par une équation de cercle
> restart ;
> with(geometry) :
> _EnvHorizontalName := m ; _EnvVerticalName := n ;
_EnvHorizontalName := m
_EnvVerticalName := n
> point(c1,0,0) : point(c2,1,3) : point(c3,0,4) :

> circle(C1,[c1,c2,c3]) ;
C1
detail(C1) ;
name of the object C1

form of the object circle2d
name of the center center_C1
coordinates of the center [−1,
√ 2]
radius of the circle 5
equation of the circle _x2 + _y 2 + 2 ∗ _x − 4 ∗ _y = 0
> circle(C2,[center(C1),radius(C1)]) ;
C2
> Equation(C2) ;
m2 + n2 + 2 m − 4 n = 0
2.3 Tests géométriques

Il existe un certain nombre de tests sur les objets géométriques avec le package geometry
> line(l1,2*x+3*y+1=0,[x,y]) : line(l2,4*sqrt(2)*x+6*sqrt(2)*y-1=0,[x,y]) :
> AreParallel(l1,l2) ; true > ArePerpendicular(l1,l2) ; false
Exercice 2.3.1 (TD4). > construc := proc(t)

> local d1,d2,d3,d4 ;
> point(A,-1,1) : point(B,0,2) : point(C,1,-2) : triangle(T,[A,B,C]) :
> rotation(R1,B,t,clockwise,C) : PerpenBisector(M1,B,C) : line(BC,[B,R1]) : intersecti
triangle(T1,[At,B,C]) :
> rotation(R2,C,t,clockwise,A) : PerpenBisector(M2,A,C) : line(AC,[C,R2]) : intersecti
triangle(T2,[A,Bt,C]) :
> rotation(R3,A,t,clockwise,B) : PerpenBisector(M3,A,B) : line(AB,[A,R3]) : intersecti
triangle(T3,[A,B,Ct]) :
> line(A1,[At,A]) : line(B1,[Bt,B]) : line(C1,[C,Ct]) : intersection(Ot,C1,A1) :
> print(AreConcurrent(A1,B1,C1)) ;
> print(coordinates(Ot)) ;
> d1 := draw(T,T1,T2,T3,A1,B1,C1,Ot,axes=none) ;
> d2 := textplot([coordinates(A)[1],coordinates(A)[2],A]) ;
> d3 := textplot([coordinates(B)[1],coordinates(B)[2],B]) ;
> d4 := textplot([coordinates(C)[1],coordinates(C)[2],C]) ;
> display(d1,d2,d3,d4) ;
> end :
> construc(Pi/3) ;
true
 √ √ √ 
3 5+3 3 39 3 + 17
−3/2 √ , 1/2 √ 
15 + 16 3 15 + 16 3
Chapitre 3
Algébre linéaire
Dans la version 6, le chapitre algébre linéaire a été considérablement modifié. LEs anciennes
structures et notations ont été conservées dans les versions actuelles, pour des raisons de com-
patibilité. Dans ce qui suit, on décrit les structures de la version 9.5.
3.1 Vecteurs et matrices

3.1.1 Construction élémentaire
MAPLE possède deux formes de constructions de vecteurs et de matrices. La première
consiste en une écriture symbolique de la suite (sequence) des composantes du vecteur entourée
des caractères < et >
> with(LinearAlgebra) :
> v := <1,2,3>
 
1
 
v :=  2 
 
 
3
> whattype(v) ;
Vector column
Les matrices sont définies colonne par colonne en juxtaposant les "vecteurs colonnes" avec
le caractère | et entourant le tout par < et >
> M := <<1,2,3>|<4,5,6>|<7,8,9>> ;
 
1 4 7
 
M :=  2 5 8 
 
 
3 6 9
> MM := <M|<-1,2,1>> ;
 
1 4 7 −1
 
MM :=  2 5 8 2 


 
3 6 9 1
46
Chapitre 3. Algébre linéaire 47
> MMM := <M|<-1,-2,3>|<-4,-5,-6>> ;

 
1 4 7 −1 −4
 
MMM :=  2 5 8 −2 −5 
 
 
3 6 9 3 −6
> N := <<a,b,c>|<d,e,f>|<g,h,i>> ;
 
a d g
 
N :=  b e h 
 
 
c f i
> MN := <M|N> ;  
1 4 7 a d g
 
MN :=  2 5 8 b e h 
 
 
3 6 9 c f i
On peut utiliser Vector et Matrix pour respectivement construire des vecteurs et des ma-
trices.
> V := Vector([1,2,3]) ;  
1
 
V :=  2 
 
 
3
> M := Matrix([[1,2,3],[4,5,6],[7,8,9]]) ;
 
1 2 3
 
 4 5 6 
M :=  
 
7 8 9
On peut faire des assignations multiples :

> v,w,M := Vector([1,sqrt(x),x]),<1,sqrt(y),y>,Matrix([[1,2,3],[4,5,6],[7,8,9]]) :
> v; w; M;  
1
 √ 

 x 

 
x
 
1
 √ 

 y 

 
y
 
1 2 3
 

 4 5 6 

 
7 8 9
On peut créer des vecteurs de même composantes
48 Chapitre 3. Algébre linéaire
> v,vv := Vector(2),Vector(3,1) ;

 
  1
0  
v, vv :=  , 
 1 

0  
1
Pareil pour des matrices :

M,MM := Matrix(2,4),Matrix(2,4,1) ;
   
0 0 0 0 1 1 1 1
M, MM :=  ,  
0 0 0 0 1 1 1 1
Attention, si le deuxième paramétre de Matrix est négatif, il est compté pour l’élément du
tableau (ainsi la matrice obtenue est la matrice carré de taille de la première variable). S’il
n’existe pas de deuxième paramétre, c’est une matrice carrée nullle de taille de le première
variable.
> Matrix(3,-1) ; Matrix(3) ; Matrix(3,1) ;
 
−1 −1 −1
 

 −1 −1 −1 

 
−1 −1 −1
 
0 0 0
 

 0 0 0 

 
0 0 0
 
0
 

 0 

 
0
Si le premier paramètre est négatif, MAPLE produit une erreur.
> Matrix(-3) ;
Error, (in Matrix) dimension parameters are required for this form of initializer
Si il manque des composantes dans les matrice, MAPLE remplace ces composantes par des
0.
> LV,LM := [a,b], [[a,b,c],[d]] ;
LV , LM := [a, b], [[a, b, c], [d]]
> Vector(LV) ; Matrix(LM) ;  

a
 
b
 
a b c
 
d 0 0
> Vector(3,LV) ;  
a
 

 b 

 
0
On peut convertir une matrice en liste avec la fonction listlist
> convert(M,listlist) ;
[[0, 0, 0, 0], [0, 0, 0, 0]]
> convert(V,list) ;
[1, 2, 3]
On peut définir une matrice par une simple liste mais cela donner une matrice ligne.
> L := [1,2,3,4,5,6] ; Matrix(L) ;
L := [1, 2, 3, 4, 5, 6]
h i
1 2 3 4 5 6
Quelques commandes d’opérations sur la matrice.
> M := Matrix(3,3,4) ;  
4 4 4
 
 4 4 4 
M :=  
 
4 4 4
> Determinant(M) ;
0
> Permanent(M) ;
384
On peut convertir une matrix et Matrix
> convert(matrix(2,3,2),Matrix) ;
 
2 2 2
 
2 2 2
> whattype(%) ;
Matrix
3.1.2 Assignation et extraction

On peut extraire des éléments d’un vecteur et d’une matrice.
> v := <a,b,c,d> ; # Pour des vecteurs
a
 
 

 b 

 
c 
 

 
d
> v[2] ; v[2..3] ;

b
 
b
 
c
> whattype(v[2]) ;
symbol
> whattype(v[2..3]) ;
Vector column
> v[-3..3] ;  
b
 
c
> whattype(%) ;
Vector column
> M := <<a,b,c,d> | <a,b,c,e> | <a,b,c,0>> ; # Pour des matrices
a a a
 
 

 b b b 

M :=  
c c c 
 

 
d e 0
> A := M[1..2,1..2] ;  
a a
A :=  
b b
> B := M[1,1] ;
B := a
> C := M[2..3,1..2] ;  
b b
C :=  
c c
> whattype(B) ; whattype(C) ;
symbol
Matrix
> AA := M[1..2,1..1] ; BB := M[1..2,1] ;
 
a
AA :=  
b
 
a
BB :=  
b
> whattype(AA) ; whattype(BB) ;
Matrix
Vector column
Assignation :
> v[2] :=x ; v ;

v2 := x
a
 
 

 x 

 
c 
 

 
d
>v[2..3] := <alpha,beta> ; v ;  
α
v2...3 :=  
β
a
 
 

 α 

 
β 
 

 
d
> L := [-alpha,alpha] ; v[2..3] := <[L]> ; v ;
L := [−α, α]
h i
v2...3 := [−α, α]
a
 
 

 [−α, α] 

 
0
 
 
 
d
>v[2..3] := <op(L)> ;  
−α
v2...3 :=  }
α
> v;
a
 
 

 −α 

 
α
 
 
 
d
> M := Matrix([[1,sqrt(a),a],[1,sqrt(b),b],[1,2,3]]) : M ;
 √ 
1 a a
 √ 
 1 b b 
 
 
1 2 3
> M[2..3,1..2] := <<a,b>|<c,d>> ; M ;

 
a c
M2...3,1...2 :=  
b d
 √ 
1 a a
 

 a c b 

 
b d 3
> M[2..3,1..2] := 0 : M ;  √ 
1 a a
 

 0 0 b 

 
0 0 3
3.1.3 Affichage de grandes matrices

Quand on produit une grande matrice, MAPLE ne peut pas afficher tous les éléments. Alors
si on fait un clic droit sur le résultat de MAPLE pour une grande matrice, on a accès à divers
options.
> M_grande := Matrix(25,25,4) ; # Faire un clic droit pour accéder aux options
" 25 x 25 " (Matrix)

 
 

 "Data Type : " anything 

M _grande :=  
"Storage : " rectangular 
 

 
"Order : " Fortran_order
> M_grande := RandomMatrix(25,25) ; # Faire un clic droit pour accéder aux options
"25 x 25 " (Matrix)

 
 

 "Data Type :" anything 

M _grande :=  
"Storage : " rectangular 
 

 
"Order :" Fortran_order
On trouvera des informations sur le fonctionnement de l’afficheur avec la commande ? structuredview.

Pour modifier la taille maximale par défaut que MAPLE est autorisée à afficher on utilisera
la commande suivante (la réponse affichée correspond à la valeur précédente).
> interface(rtablesize=3) ;
10
Maintenant les objets dont au moins une des dimensions est supérieure à 3 ne seront pas
affichés.
> M := Matrix(4,0) ;
" 4 x 0 " (Matrix)
 
 

 "Data Type :" anything 

M :=  
"Storage :" rectangular 
 

 
"Order :" Fortran_order
On revient maintenant à une dimension maximale d’affichage de 10
> interface(rtablesize=10) ;
3
3.1.4 Génération automatique des composantes

Les fonctions Vector et Matrix permettent la génération automatique de composantes avec
l’introduction d’un opérateur. Dans le premier exemple, i va prendre successivement les valeurs
1,2 et 3 et l’opérateur leur fera correspondre les valeurs (−1)i × i2 .
> v_1,v_2 := Vector(3,i->(-1)î*i^2), Vector(3,k->t^(k-1)/k !) ;
   
−1 1
   
 4  ,  1/2 t 
v_1, v_2 := 
  
   
2
−9 1/6 t
mais d’autre formes d’écriture peuvent être utilisées.

> L := [seq(tî/(i+1),i=0..2)] ; <seq((-1)î*i^2,i=1..3)> ; <op(L)> ;
L := [1, 1/2 t, 1/3 t2 ]

 
−1
 

 4 

 
−9
 
1
 

 1/2 t 

 
1/3 t2
Pour les matrices, on utilisera un opérateur à deux variables qui représenteront respective-
ment l’indice de ligne puis l’indice de colonne (on prendra soin de mettre entre parenthèses les
deux variables devant la flèche)
> M := Matrix(2,3,(i,j)->(-1)^(i+j)*(i+j)) ;
 
2 −3 4
M :=  
−3 4 −5
> M := Matrix(2,3,(i,j)->(-1)^(i+j)*x^(i+j)) ;
 
x2 −x3 x4
M :=  3 4 5

−x x −x
3.1.5 Types et opérandes

La fonction Vector admet une option, orientation qui définit la carctéristique column ou
row, c’est-à-dire colonne ou ligne. L’orientation par défaut est column (voir aussi la fonction
Transpose de la bibliothèque LinearAlgebra examinée plus loin dans ce chapitre).
> l_1,l_2 := Vector([1,2,3],orientation=row),Vector[row](3,i->t^(i-1)/i !) ;
h i h i
l_1, l_2 := 1 2 3 , 1 1/2 t 1/6 t2
ou encore
> <1|2|t|t^2/2> ; h i
1 2 t 1/2 t2
Les vecteurs construits précédement ont le type Vector auquel est associé la caractéristique
row ou column.
> v_1 ; whattype(v_1) ; Transpose(v_1) ; whattype(%) ;
 
−1
 

 4 

 
−9
Vector column
h i
−1 4 −9
Vector row
Attention aux Majuscules, Maple ne signifie pas d’erreur de syntaxe car les types vector
et matrix existent aussi.
> type(M,matrix) ; type(v_1,vector[column]) ;
false
false
Les objets construits avec Vector ou Matrix ont leur structure propre, rtable, que l’on
peut découvrir avec les opérandes. Pour les vecteurs, la première opérande est la dimension du
vecteur, la seconde l’ensemble des composantes. La troisième donne d’autres caractéristiques
sur lesquelles nous reviendrons.
> op(v_1) ;
3, {1 = −1, 2 = 4, 3 = −9} , datatype = anything, storage = rectangular, order = Fortran_order, shape
Remarque. Contrairement aux apparences, le nombre d’opérandes est seulement de 3 et la

troisième opérande qui donne les caractéristiques d’une suite (datatype = ...shape = []).
> nops(v_1) ; seq(op(j,v_1),j=0..3) ; whattype(op(3,v_1)) ; op(2,op(3,v_1)[1]) ;
Vector column , 3, {1 = −1, 2 = 4, 3 = −9} , datatype = anything,

storage = rectangular, order = Fortran_order, shape = []
exprseq
anything
Il est de même pour les matrices. La première opérande (qui est ici la suite 2,3) donne le
nombre de lignes puis le nombre de colonnes.
> nops(M) ; op(M) ; op(1,M) ;
3
n o
2, 3, 1, 1 = x2 , 1, 2 = −x3 , 1, 3 = x4 , 2, 1 = −x3 , 2, 2 = x4 , 2, 3 = −x5
, datatype = anything, storage = rectangular, order = Fortran_order, shape = []
2, 3
L’opérande 0 indique le type du vecteur ou de la matrice. C’est le résultat renvoyé par
whattype
> op(0,v_1) ; op(0,M) ;

Vector column
Matrix
Pour extraire les caractéristiques d’un vecteur ou d’une matrice (sur lesquelles nous revien-
drons dnas les prochains paragraphes), MAPLE dispose de deux fonctions VectorOptions et
MatrixOptions.
> VectorOptions(v_1,orientation) ; MatrixOptions(M,datatype,shape) ;
column
anything, []
Comme il a déjà été indiqué les objects construits avec la fonction vector (v minuscule) ou
matrix (m minuscule) ont une structure différente (stucture array) Il est préférable d’utiliser
la nouvelle forme, sauf pour raison de compatibilité.
> v_ancien := vector([1,2,3]) ;
h i
v_ancien := 1 2 3
> whattype(eval(v_ancien)) ;
array
> type(v_ancien,vector) ;
true
> op(eval(v_ancien)) ;
1 . . . 3, [1 = 1, 2 = 2, 3 = 3]
3.1.6 Options
shape
L’option shape permet de caractériser le ”profil" d’une matrice. L’option identity crée
une vraie matrice identité, non nécessairement
√ carrée (on rappelle que le nom I est, par défaut,
reservé par MAPLE pour désigner −1).
> Id := Matrix(3,4,shape=identity) ;
 
1 0 0 0
 
Id :=  0 1 0 0 
 
 
0 0 1 0
On entend par ”vraie“ le fait que l’on ne peut modifier aucun des éléments, diagonal ou
non, de cette matrice qui perdrait sinon son caractére de matrice identité.
> Id[2,2] := 3 ; Id[2,3] := 1 ; MatrixOptions(Id,shape) ;
Error, invalid assignment to identity diagonal
Error, invalid assignment of non-zero to identity off-diagonal
[identity]
L’option shpae = scalar[n] définit une matrice diagonal non nécessairement carrée, dont
les éléments diagonaux sont égaux à n.
> S := Matrix(3,4,shape=scalar[-lambda]) ; MatrixOptions(S,shape) ;

 
−λ 0 0 0
 
 0
S :=  −λ 0 0 

 
0 0 −λ 0
[scalar −λ ]
Ici aussi, toute tentative pour changer un des éléments, même diagonal, ferait perdre à la
matrice sa caractéristique.
> S[3,2] = t ; S[2,2] := 2 ;
0=t
Error, scalar matrices cannot be changed
Remarque. Si le produit d’une matrice identité par un scalaire (ici −λ) peut donner une matrice
diagonale identique à la précédente, elle n’aura pas pour autant la caractéristique scalar−λ et
les modifications des composantes seront possibles.
> Sp := lambda*Id ; MatrixOptions(Sp,shape) ;
 
λ 0 0 0
 
 0 λ 0 0 
Sp :=  
 
0 0 λ 0
[]
> Sp[2,2] := x ; Sp ;
Sp2,2 := x
 
λ 0 0 0
 

 0 x 0 0 

 
0 0 λ 0
L’option shape=diagonal construit des matrices diagonales. Ici encore on notera que de
telles matrices ne sont pas nécessairement carrés (on rappelle que D est un nombre prédéfini et
protégé par MAPLE, Dérivation)
Di := Matrix(3,4,-1,shape=diagonal) ;
 
−1 0 0 0
 
 0
Di :=  −1 0 0 

 
0 0 −1 0
Seuls les éléments diagonaux de ces matrices peuvent être changés.

Di[3,2] := 1 ; Di[3,3] :=2 ; Di ;
Error, attempt to assign non-zero to off-diagonal entry of a diagonal Matrix
Di 3,3 := 2
 
−1 0 0 0
 

 0 −1 0 0 

 
0 0 2 0
Lorsque les éléments de la diagonales sont différents, ils doivent être spécifices à l’aide d’un
veteur (une simple liste ne convient pas).
> v := Vector([2,-1,1,2,3]) ; Matrix(3,4,v[2..4],shape=diagonal),
Matrix(3,4,Vector([-1,1,2]),shape=diagonal) ;
 
2
 
−1
 
 
 
 
v := 
 1 

 

 2 

 
3
L’option shape=symmetric permet la construction de matrices symétriques. On notera les
différences de fonctionnement de cette option suivant que la matrice est construite à partir
d’une liste de listes ou d’une matrice.
1) La matrice symétrique est construite à partir d’une liste de listes. On remarque que lce
sont les colonnes (en partant de la première) qui définissent les éléments symétriques de la
matrice.
> L := [[a,b,c],[d,e,f],[i,j,k]] ;
L := [[a, b, c], [d, e, f ], [i, j, k]]
> M,Ma := Matrix(L), Matrix(L,shape=symmetric, scan=columns) ;
   
a b c a d i
   
 d e f ,  d e j 
M, Ma :=    
   
i j k i j k
2) La matrice symétrique est construire à partir d’une matrice. Ce sont alors les lignes qui
définissent les éléments symétriques. La deuxième construction est directe et ne nécessite
pas la construction d’une matrice intermédiaire. Pour la troisième forme, se reporter au
paragraphe suivant relatif à l’option scan.
> Mb,Mc,Md := Matrix(M,shape=symmetric), Matrix(Matrix(L),shape=symmetric),
Matrix(Matrix(L,scan=columns),shape=symmetric) ;
     
a b c a b c a d i
     
 b e f ,  b e f ,  d e j 
Mb, Mc, Md :=      
     
c f k c f k i j k
Naturellement ces matrices sont de "vraies" matrices symétriques et tout changement d’un
de ces éléments entraîne celui de son symétrique.
> Mb[1,2] := t : Mb ;  
a t c
 

 t e f 

 
c f k
scan
L’option scan permet d’indiquer comment les éléments de la liste de listes donnée en ar-
gument de la fonction Matrix doivent être interprétés. Sans cette option, chaque liste est
interprétée par défaut comme une ligne de matrie. On peut modifier cette interprétation avec
l’option scan = colomns
> Matrix([[alpha,beta,gamma],[delta,epsilon,tau],[omega,rho,phi]], scan=columns) ;
 
α δ ω
 

 β ρ 

 
γ τ ϕ
> Matrix([[alpha,beta,gamma],[delta,epsilon,tau],[omega,rho,phi]]) ;
 
α β γ
 

 δ τ 

 
ω ρ ϕ
> Matrix([alpha,beta,gamma],scan=diagonal) ;
 
α 0 0
 

 0 β 0 

 
0 0 γ
Ici scan=diagonal indique que les éléments de la liste simple sont les éléments diagonaux
de la matrice.
Remarque. En l’absence de scan=diagonal, la matrice n’aura pas ce profil. Les dimensions de
la matrice ne sont pas renseignés.
> Matrix([a,b,c],scan=diagonal) ; Matrix([a,b,c]) ;
 
a 0 0
 

 0 b 0 

 
0 0 c
h i
a b c
fill
Cette option permet de compléter les termes manquants dans la liste de listes par un terme
fixé. Les dimensions sont ici fixés par défaut par les listes des éléments (on rappelle que $ est
l’opérateur de répétition qui est donné ici à titre d’exemple).
> Matrix([[a$3],[alpha,beta,gamma,delta],[t^2]],fill=T) ;
 
a a a T
 

 α β γ δ 

 
2
t T T T
Mais naturellement les dimensions peuvent être fixés par deux entiers donnés en premier
arguments.
> X := ’X’ ; Matrix(3,4,[[a,b,c],[x]],fill=-X) ;
X := X
 
a b c X
 

 x X X X 

 
X X X X
La fonction Matrix autorise des combinaison complexes de constructions grâce à ses fonc-
tions d’indexation comme le montre ces exemples.
> Matrix([[a,b,c],[d,e,f],[g,h,i]], scan=columns, shape=triangular[upper]) ;
 
a d g
 

 0 e h 

 
0 0 i
Ici le profil shape = band[0,1] crée une matrice "bande" avec sa diagonale normale, aucune
(0) diagonale inférieure et une (1) diagonale supérieure. Le profil (shape) prévaut sur les données
de la liste et les éléments de celle-ci sont remplacées par des 0. Ainsi l’élément (1,3) est nul
ainsi que les éléments sous la diagonale normale.
> Matrix([[a,b,c],[d,e,f],[g,h,j]],shape=band[0,1],scan=columns) ;
 
a d 0
 

 0 e h 

 
0 0 j
> Matrix([[1$3],[2$2],[3$4],[4]],shape=triangular[upper],scan=band[0,3],fill=Z) ;
1 2 3 4 Z Z
 
 

 0 1 2 3 Z Z 

 
0 0 1 Z 3 Z 
 

 
0 0 0 Z Z 3
La matrice est maintenant triangulaire supérieure et les listes d’entrée sont inerprétées par
scan=band[0,3] comme la diagonale et les 3 bandes supérieures successives. On notera que les
dimensions de la matrice (qui n’est pas carrée bien que triangulaire) sont définies par la taille
maximale des bandes données en entrée et que les éléments manquants sont remplacés par la
valeur donnée par fill.
> Matrix(3,5,[[x$2],[y$3],[3,-2,1]], shape=triangular[lower],scan=band[1,1],fill=Z)
 
y 0 0 0 0
 

 x y 0 0 0 

 
Z x y 0 0
Et toutes les possibilités de combinaisons compatibles sont autoriées. Le profil "triangulaire

inférieure" prévaut ici et fait disparaître la bande supérieure définie par la liste [3, −2, 1] :
datatype
Une autre option importante est datatype qui définit le type des composantes d’un vecteur
ou d’une matrice.
> Vector(2,3) ; VectorOptions(%,datatype) ;
 
3
 
3
anything
En effet on peut construire des vecteurs de n’importe quels types de structures mathéma-
tiques.
v_exotique := Vector([1,-1..3,exp(-t),(1,2),3*t^2+1=0]) ;
 
1
 

 −1 . . . 3 

 
e−t
 
 
v_exotique :=
 
 

 1 

 
2
 
 
 
3 t2 + 1 = 0
Mais on peut dans MAPLE définir le type des éléments dans un vecteur ou une matrice.
> v := Vector(3,datatype=integer) ;v[2] := sqrt(3) ;
 
0
 
v :=  0 
 
 
0
Error, unable to store ’3^(1/2)’ when datatype=integer
Maintenant on utilise l’option float pour datatype. Comme on peut le voir tous les nombres
entiers sont mis automatiquement sous la forme d’un flottant.
> v1,v2 := Vector([1,2,3/2,sqrt(2.)]), Vector([1,2,3/2,sqrt(2.)],datatype=float) ;
1 1.0
   
   

 2 


 2.0 

v1, v2 :=  ,  
3/2 1.50000000000000000
   
   
   
1.414213562 1.41421356200000004
evalhf : Precision liée au processeur (plus précis que evalf)

> evalhf(-1/2) ; evalf(-1/2) ;
−0.500000000000000000
−0.5000000000
On peut faire des datatype pour des matrices.
storage
L’option storage sera utilisée exclusivement pour des matrices de grandes tailles.
> T :=Matrix(3,4,[[-1$3],[1$3]],storage=triangular[upper], scan=band[0,1],fill=X)
 
−1 1 X X
 
T :=  _

−1 1 X 

 
_ _ −1 1
Cette option permet d’économiser l’espace mémoire en ne mémorisant que les éléments
significatifs.
> T[2,3] ; T[3,2] ;
1
Error, unable to lookup index (3, 2) – not in storage
readonly
L’option readonly est un état logique qui, par défaut, vaut false et marque que les éléments
ne peuvent pas être modifiés (ceux autorisés par l’option shape). En posnant readonly=true,
les éléments du vecteur ou de la matrice ne pourront être que lus.
> M :=Matrix([[1,2],[-1,3]],readonly=true) ; M[1,2] ; M[1,2] :=3 ;
 
1 2
M :=  
−1 3
Error, cannot assign to a read-only Matrix
copy
Les matrices et les vecteurs ont un comportement particulier relativement à l’assignation.
Rappelons tout d’abord le comportement habituel : lors de l’assignation de a à b, a est évalué.
restart : with(LinearAlgebra) :
> a :=[x,y,z] :
> b :=a :
> a,b ;
[x, y, z], [x, y, z]
Si l’on modifie l’un des éléments de l’une des listes, l’autres reste inchangée
> a[1] :=0 :
> a,b ;
[0, y, z], [x, y, z]
Construisons un schéma d’assignation identique avec des matrices (il en serait de même
pour les vecteurs).
> A :=Matrix([[1,2],[0,-1]]) :
> B :=A :
> A,B ;    
1 2 1 2
 ,  
0 −1 0 −1
Modifions un des éléments de la matrice A. On peut constanter que les deux ont été modi-
fiées. En effet, lorsque l’on écrit B := A, MAPLE demande aux deux identificateurs A et B de
pointer sur le même tableau de données (une mêm structure rtable). Autrement dit, on crée
deux symboles, A et B, pour une même matrice.
> A[2,1] :=-3 :
A,B ;    
1 2 1 2
 ,  
−3 −1 −3 −1
Pour obtenir deux matrices indépendantes, il faut utiliser la fonction copy. La raison de cette
différence de traitement vient d’un souci d’économiser la mémoire de l’ordinateur car souvent
les matrices et les vecteurs sont des objets encombrants. La fonction copy oblige l’utilisateur à
être attentif à ce problème.
> A :=Matrix(2,3,<1,2>,shape=diagonal) ;
> B :=copy(A) ;
> A[1,1] :=-1 : # On modifie un élément de A
> A,B ; # Les deux matrices sont distinctes
 
1 0 0
A :=  
0 2 0
 
1 0 0
B :=  
0 2 0
   
−1 0 0 1 0 0
 ,  
0 2 0 0 2 0
On notera que la fonction copy conserve les options de la matrice copiée.
> MatrixOptions(A,shape) ;
> MatrixOptions(B,shape) ;
> B[1,2] :=1 ;
[diagonal]
[diagonal]
Error, attempt to assign non-zero to off-diagonal entry of a diagonal Matrix
3.2 Algébre Linéaire élémentaire

3.2.1 Opérations élémentaires
L’algèbre des vecteurs et des matrices peut être symbolisée d’une façon très voisine de
celle des quantités scalaires à l’exception du produit standard qui n’est pas une opération
commutative (et qui peut aussi avoir plusieurs significations). Construisons des matrices et des
vecteurs pour les exemples qui vont suivre.
> v1,v2 := Vector(3,1),Vector(3,2) ; v1+v2 ;
   
1 2
   
v1, v2 :=  1  ,  2 
   
   
1 2
 
3
 

 3 

 
3
> M1,M2 := Matrix(3,3,(i,j) -> i^2-j^2), IdentityMatrix(3) ; M1+M2 ;
   
0 −3 −8 1 0 0
   
M1, M2 :=  3

0 −5 
,  0 1 0 
 
   
8 5 0 0 0 1
 
1 −3 −8
 

 3 1 −5 

 
8 5 1
L’addition (ou la soustraction se traite comme pour les scalaires. on notera que le produit
d’une matrice ou d’un vecteur par un scalaire est autorisé et fournit une matrice ou un vecteur
dont tous les éléments sont multipliés par ce scalaire.
De même pour les puissances. L’expression M2^(-2) calcule le carré de l’inverse de M2.
> M1^2 ; M2^(-2) ;  
−73 −40 15
 

 −40 −34 −24 

 
15 −24 −89
 
1 0 0
 

 0 1 0 

 
0 0 1
On peut faire des opérations plus complexes.
> M1^2-2*M1+IdentityMatrix(3) ;
 
−72 −34 31
 

 −46 −33 −14 

 
−1 −34 −88
Opérations interdites : addition d’un vecteur par une matrice, vecteur de dimensions diffé-
rentes, multiplication de deux matrices de dimensions différentes, division de matrice.
> M1+Matrix(2,2,-3) ; # Addition de matrices de tailles différentes
Error, (in rtable/Sum) invalid arguments
> v1+3 ; # Addition d’un vecteur par un scalaire
Error, (in rtable/Sum) invalid arguments

> M1/M2 ; # Division de deux matrices
Error, (in rtable/Product) invalid arguments
> # et pleins d’autres
Cependant, la logique n’est pas toujours évidente et doit inciter à la prudence. Ainsi MAPLE
autorise l’addition d’un scaire à une matrice, mais l’opération consiste à ajouter à la matrice le
produit de ce scalaire avec l’identité.
> M1, M1-3, M1-3*Matrix(3,shape=identity) ;
     
0 −3 −8 −3 −3 −8 −3 −3 −8
     

 3 0 −5 
,  3

−3 −5 
,  3

−3 −5 

     
8 5 0 8 5 −3 8 5 −3
Il sera cependant facile d’écrire pour ajouter -3 à chacun des éléments de M1.
> M1+Matrix(3,3,-3) ;  
−3 −6 −11
 

 0 −3 −8 

 
5 2 −3
La multiplication par une matrice est .. C’est une opération non commutative. Il faut aussi
respecter les régles de la multiplication des matrices.
> M1.v1 ; M1.M2 ;  
−11
 

 −2 

 
13
 
0 −3 −8
 

 3 0 −5 

 
8 5 0
> v1.M1 ;
Error, (in LinearAlgebra :-VectorMatrixMultiply) invalid input : LinearAlgebra :-VectorMatrixMultiply
expects its 1st argument, v, to be of type Vector[row] but received Vector(3, {(1) = 1, (2) = 1,
(3) = 1}
3.2.2 Autres opérations

Add, MatrixMatrixMultiply
Add (addition) et MatrixMatrixMultiply (multiplication) réaliser des opérations d’algèbre ma-
tricielle (vectorielle) qui sont automatiquement invoquées par l’analyseur syntaxique comme
indiqué au paragraphe précédent. Il sera donc inutile de les appler explicitement sauf si l’on
souhaite pouvoir utiliser les options de ces fonctions (on en donnera quelques exemples et on
complétera l’information avec l’aide en ligne).
> M1,M2 :=Matrix([[1,2],[3,4]]),Matrix([[-1,3],[-2,1]]) ;
> Add(M1,M2) , M1+M2 ; # 2 écritures identiques
   
1 2 −1 3
M1, M2 :=  ,  
3 4 −2 1
   
0 5 0 5
 ,  
1 5 1 5
> MatrixMatrixMultiply(M1,M2) , M1.M2 ; # 2 écritures identiques
   
−5 5 −5 5
 ,  
−11 13 −11 13
Implace
Certaines fonctions de LinearAlgebra autorisent l’option inplace. Elle indique que la fonc-
tion va remplacer par le résultat le premier argument compatible. Son intérêt est évidemment
lié à un souci d’économie de l’espace mémoire de l’ordinateur quand on travaille avec de grosses
matrices. Ici, le résultat de la somme est une matrice 2 × 2 et le premier argument compatible
est la matrice M 1 initiale qui sera remplacée par la somme.
> M1,M2 := Matrix([[a,b],[b,a]]),Matrix([[alpha,beta],[gamma,delta]]) : Add(M2,M1,inpl
> M1,M2 ; MatrixOptions(M2,shape) ;
 
α+a β+b
 
γ+b δ+a
   
a b α+a β+b
 , 
b a γ+b δ+a
[]
On aurait pu écrire M1 := M1+M2. Pourtant ce n’est pas toujours équivalent. On peut consta-
ter dans cet exemple que la réassignation de la somme à M 1 fait perdre à cette matrice son
profil symétrique.
>M1,M2 := Matrix([[a,b],[b,a]]),Matrix([[alpha,beta],[gamma,delta]]) : M1+M2 ;
>M1,M2 ; MatrixOptions(M1,shape) ;
 
α+a β+b
 
γ+b δ+a
   
a b α β
 , 
b a γ δ
[]
Realisée avec la fonction Add et l’option implace la matrice M1 conserve son profil. Ce-
pendant le résultat de l’addition contenu dans la nouvelle matrice M 1 est différent puisqu’il
est incompatible avec le profil. Le calcul tient compte de la symétrie et la somme est calculée
suivant la première colonne suivit de la définition de la première ligne par symétrie, puis de la
deuxième colonne, etc. et par conséquent :
> M1,M2 ;    
a + 2α 2β + b α β
 ,  
c + 2γ d + 2δ γ δ
> MatrixOptions(M1,shape) ;
[]
> M1,M2 :=Matrix([[1,2],[2,1]]),Matrix([[-1,0],[2,1]]) ;

Add(M1,M2,inplace) :
M1,M2 ;    
1 2 −1 0
M1, M2 :=  ,  
2 1 2 1
   
0 2 −1 0
 ,  
4 2 2 1
On échange maintenant l’ordre des matrices par rapport à l’exemple précédent. L’opération
conserve la propriété de "matrice symétrique" à M 1 et la matrice M 2 contient alors la somme
réelle des matrices.
M1,M2 :=Matrix([[1,2],[2,1]],shape=symmetric),
Matrix([[-1,0],[2,1]]) ;
> Add(M1,M2,inplace) :
> M1,M2 ;
   
1 2 −1 0
M1, M2 :=  ,  
2 1 2 1
   
0 4 −1 0
 ,  
4 2 2 1
[symmetric]
L’opération d’addition avec Add(...,inplace) n’est donc pas toujours commutative et la
prudence doit être de mise avec la conjugaison des options shape et inplace. L’opération est
même impossible avec le produit de matrices (MatrixMatrixMultiply) puisqu’on ne peut plus
réliser la commutation.
> M1,M2 :=Matrix([[1,2],[2,1]],shape=symmetric),
Matrix([[-1,0],[2,1]]) ;
> Add(M2,M1,inplace) :
> M1,M2 ;
   
1 2 −1 0
M1, M2 :=  ,  
2 1 2 1
   
1 2 0 2
 ,  
2 1 4 2
[symmetric]
Accès aux fonctions de LinearAlgebra

Pour l’instant toutes les fonctions de LinearAlgebra ont été rendues accessibles avec with
et sont toutes disponibles. On peut, par exemple, réaliser la transposé d’un vecteur (ou d’une
matrice) ainsi que son transposé conjugé (la barre de surlignement indique le complexe conjugué
des composantes).
> restart ; with(LinearAlgebra) :

> > V :=Vector([a,b,c]) ;
> Transpose(V) ;
> HermitianTranspose(V) ;  
a
 
V :=  b 
 
 
c
h i
a b c
h i
conjugate (a) conjugate (b) conjugate (c)
Après un ordre restart ces fonctions ne seront plus disponibles et Transpose devient le nom
d’une fonction non définie. On rappelle qu’en tant que calculateur symbolique, il est normale
que MAPLE accepte cette situation et ne signale aucune erreur.
> restart :
> V :=Vector([a,b,c],orientation=row) ;
> Transpose(V) ; h i
V := a b c
Transpose (V )
La fonction with permet d’avoir accès à la ou les fonctions de la bibliothèque qui sont utiles
pour le travail en cours.
> with(LinearAlgebra,HermitianTranspose,Transpose) ;
[HermitianTranspose, Transpose]
> Transpose(V,inplace) ;
> HermitianTranspose(V,inplace) ;  
a
 

 b 

 
c
h i
Seules les deux fonctions désignées deviennent disponibles. Ces exemples montrent comment,
avec l’option inplace, le vecteur V devient son propre transpose puis son transposé conjugué. Il
existe également une deuxième forme qui permet l’utilisation d’une fonction sans utiliser with.
Elle est utilisée, soit lorsqu’une fonction n’est invoquée que peu de fois, soit lors de la création
d’opérateurs ou de procédures. La forme générale est
Bibliothèque[fonction](Argument_1,...,Argument_n)
La fonction n’est pas accésible de façon permanente avec cette forme d’appel.
> restart : V :=Vector[row]([a,b,c]) ; LinearAlgebra[HermitianTranspose](V,inplace) :
V; h i
Une troisième forme identique à la prcédente est utilisable, mais seulement avec les nouvelles
bibliothèques telle que LinearAlgebra. Elle utilse l’opérateur :-
> V := Vector([a,b,c],orientation=row) ; LinearAlgebra :-HermitianTranspose(V,inplace)
h i
LinearSolve
Soit à resoudre : Ax = b avec A et b définis par :
> restart ; with(LinearAlgebra) :
> A,b := Matrix([[1,2,-1],[0,1,2],[-2,3,1]]),Vector([-3,4,4]) ;
   
1 2 −1 −3
   
A, b :=  0 1 ,  4 
2 
  
   
−2 3 1 4
La solution peut être obtenue en écrivant A−1 b mais cette opération est déconseillée car
trop peu efficace. On utilisera la fonction LinearSolve qui utilise des algorithmes appropriés
dont le résultat est un vecteur anonyme solution du système. Si on veut donner un nom à cette
solution, il faudra effectuer une assignation
> x :=LinearSolve(A,b) ;  
−1
 
x :=  0 
 
 
2
Sans assignation et avec l’option inplace, la solution est assignée au vecteur b. C’est un
exemple de l’utilité de cette option qui permet d’économiser ainsi l’espace mémoire pour les
systèmes de grandes tailles.
> LinearSolve(A,b,inplace) : b ;  
−1
 

 0 

 
2
La fonction LinearSolve contient de nombreuses options permettant par exemple de choisir
la méthode de résolution. Elle permet également de résoudre des systèmes matriciels multiples
du types AX = B, où B est une matrice (Xi,j est la composante i de la colonne Xj solution de
A. (Xj ) = Bj où Bj désigne la j-ième colonne de B).
A,B := Matrix([[1,2,0],[3,2,1],[2,1,1]]),Matrix([[2,0],[3,1],[3,2]]) ; X := LinearSolv
   
1 2 0 2 0
   
 3 2 1 ,  3 1 
A, B :=    
   
2 1 1 3 2
 
−2 −2
 
X :=  2 1 


 
5 5
3.2.3 Tests
Equal : vérifie si deux entités sont égales. Avec l’option compare=’all’, MAPLE dit si les deux
entités sont égales et leurs éléments sont de même nature.
> with(LinearAlgebra) : R := Vector[row]([1/2,3/2,-1/5,3/5],datatype=rational) ;
h i
R := 1/2 3/2 −1/5 3/5
> F := Vector[row]([0.5,1.5,-0.2,0.6],datatype=sfloat) ;
h i
F := 0.5 1.5 −0.2 0.6
> Equal(R,F) ;
true
> Equal(R,F,compare=all) ;
false
verify : permet de vérifier si deux entités sont égales et de la nature définie par l’utilisateur.
> verify([a,b,x*(x-1)],[a,b,x^2-x],’list’) ;
false
> verify(A,B,’Matrix’) ;
false
3.2.4 Recherche de valeurs propres

Le résultat de la fonction Eigenvalues est par défaut, un vecteur dont les composantes sont
les valeurs propres.
> A :=Matrix([[-1,1,-2],[1,-2,-1],[-2,-1,1]]
 
−1 1 −2
 
A :=  1

−2 −1 

 
−2 −1 1
> lambda :=Eigenvalues(A) ;

−2
 
 √ 
λ := 
 7 

 √ 
− 7
Il existe aussi une fonction CharacteristicPolynomial pour afficher le polynôme caracté-
ristique.
> A := RandomMatrix(5,5,generator=-3..3) ;
 
−3 −2 −3 3 −1
 
1 0 −2 −2 2 
 

 
 
A := 
 3 −3
−2 −3 
 0
 

 −3 −1 −1 0 −2 
 
−3 1 3 −3 −2
lambda := ’lambda’ ; CharacteristicPolynomial(A,lambda) ;
λ := λ
14.0 λ3 + 5.0 λ4 + 39.0 λ2 − 17.0 λ + 194.0 + λ5

3.2.5 Recherche de vecteurs propres

Les vecteurs propres sont calculés avec la fonction Eigenvectors. A gauche, MAPLE donne
les valeurs propres sous forme de vecteur ligne. A droite, il donne les vecteurs propres associés
aux valeurs propres.
> A := Matrix([[-1,0,2],[3,1,0],[3,0,0]]) ;Eigenvectors(A) ;
 
−1 0 2
 
A :=  3 1 0 


 
3 0 0
   
−3 −1 0 2/3
   

  ,  3/4 1
1  
2 

   
2 1 0 1
Chapitre 4
Approximation
4.1 Sens étymologique

En analyse numérique (et dans son application algorithmique discrète pour le calcul numé-
rique), l’interpolation est une opération mathématique permettant de construire une courbe
à partir de la donnée d’un nombre fini de points, ou une fonction à partir de la donnée d’un
nombre fini de valeurs. La solution du problème d’interpolation passe par les points prescrits,
et, suivant le type d’interpolation, il lui est demandé de vérifier des propriétés supplémentaires.
Ainsi le type le plus simple d’interpolation est l’interpolation linéaire, qui consiste à "joindre
les points" donnés. À partir d’une table trigonométrique, elle peut servir à estimer les valeurs
situées entre les données de la table.
On rencontre de l’interpolation de polynômiale quand on voit les développements limités.
Les développements limités sont une approximation d’une fonction f : R → R par un polynôme
de degré d. C’est une approximation local au voisinage d’un point x0 à un certain ordre d et
avec un certain reste (erreur). Mots clés : taylor, series, infnorm.
> developmt := series(exp(x),x=0,3) ;

developmt := 1 + x + 1/2 x2 + O x3
> developmt := convert(developmt,polynom) ;
developmt := 1 + x + 1/2 x2
> plot([exp(x),developmt],x=-2..2,color=[red,blue]) ;
71
72 Chapitre 4. Approximation
4.2 Interpolation polynômiale

4.2.1 Motivation
Visualiser des résultats d’une expérience discrète telle les puissnaces d’un rayon, les courbes
des bénéfices ou encore les concentrations d’un produit à un instant t. On veut voir dans un
intervalle de temps t, ces choses concrètes continuellement. On va alors approcher ce continu
par une fonction polynôme qui passe par les points qu’on a trouvé.
4.2.2 Formulation du problème

Soit f une fonction continue sur l’intervalle I = [a, b] et à valeurs dans R. Soit φi , i = 1...n,
n formes linéaires définies sur un espace vectoriel V de fonctions. Le problème de l’interpolation
polynomiale consiste à trouver un polynôme P (on supposera que V contient les polynômes)
tel que :
φi (P ) = φi (f ) i = 1, ..., n
Exemple 4.2.1. 1) Lorsque les φi sont les formes linéaires φi : f → f (xi ), où les xi sont des
points de I, on parle d’interpolation de Lagrange.
∂f
2) Lorsque les (φi , ψi ) sont des fonmes linéaires du type φi : f → f (xi ) et ψi : f → ∂x i
, on
parle d’interpolation d’Hermite.
4.2.3 Résultat d’expérience

Lagrange
On rappelle le résultat suivant :
Theorème 4.2.1. Soit xi , i = 1, ..., n+1 une suite de n+1 points deux à deux distincts. Soit αi
une suite quelconque de n + 1 termes. Alors il existe un unique polynôme P de degré inférieur
ou égal à n tel que :
P (xi ) = αi pour i = 1, ..., n + 1
En particulier, pour toute fonction f continue sur un intervalle contenant les xi , il existe un
unique polynôme P de degré inférieur ou égal à n tel que :
P (xi ) = f (xi ) pour i = 1, ..., n + 1
Hermite
Theorème 4.2.2. Soit xi , i = 1, ..., n+1 une suite de n+1 points deux à deux distincts. Soient
αi et βi deux suites quelconques de n + 1 termes. Alors il existe un unique polynôme P de degré
inférieur ou égal à 2n + 1 tel que :
!
dP
P (x1 ) = αi et (xi ) = bi pour i = 1, ..., n + 1
dx
En particulier, pour toute fonction f dérivable sur un intervalle contenant les xi , il existe un
unique polynôme P de degré inférieur ou égal à 2n + 1 tel que :
! !
dP df
P (xi ) = f (xi ) et (xi ) = (xi ) pour i = 1, ..., n + 1
dx dx
Chapitre 4. Approximation 73
Illustration (interpolation de Lagrange)

On peut faire de l’interpolation de Lagrange avec la fonction interp
interp([x(t)],[y(t)],t)
> restart ;
> with(CurveFitting) :
> with(plots) :
> x := [1/4,3/4,5/4,7/4] ;
x := [1/4, 3/4, 5/4, 7/4]

> nb_points := nops(x) ;
nb_points := 4
> f := t->exp(-t)*sin(2*Pi*t) ;
f := t 7→ e−t sin (2 π t)
> F := map(f,x) ;
F := [e−1/4 , −e−3/4 , e−5/4 , −e−7/4 ]
> p := unapply(interp(x,F,t),t) :
> l := [[x[k],F[k]] $ k=1..nb_points] ;
[[1/4, e−1/4 ], [3/4, −e−3/4 ], [5/4, e−5/4 ], [7/4, −e−7/4 ]]
> points := plot(l,0..2,style=point,color=black,symbol=circle) :

> fonction := plot(f,0..2,color=red) :
> polynome := plot(p,0..2,color=blue) :
> display(points,fonction,polynome) ;
4.2.4 Gestion de l’erreur

Theorème 4.2.3. Soit f une fonction de classe C (n+1) ([a, b]). Soient x1 , ..., xn+1 , n + 1 réels
deux à deux distincts. On note P le polynôme d’interpolation de f aux points xi . Alors pour
tout x dans [a, b], il existe un ξ dans [a, b] tel que :
n+1
Y D(n+1) (f )(ξ)
f (x) − p(x) = (x − xi )
i=1 (n + 1)!
Majoration de l’erreur : de la relation précédente, on en déduit :

n+1

Y
|D(n+1) (f )(x)|
max |f (x) − p(x)| ≤ max (x − xi ) max
[a,b] [a,b]
i=1
[a,b] (n + 1)!
Illustration (interpolation de Lagrange)

On reprend l’exemple précédent, la différence entre la fonction et le polynôme d’interpola-
tion :
> x := [0,1/5,2/5,3/5,4/5,1] ;
x := [0, 1/5, 2/5, 3/5, 4/5, 1]
> nb_points := nops(x) ;

nb_points := 6
> F := map(f,x) ;
0, e−1/5 sin (2/5 π) , e−2/5 sin (1/5 π) , −e−3/5 sin (1/5 π) , −e−4/5 sin (2/5 π) , 0]
> p := unapply(interp(x,F,t),t) :
> l := [[x[k],F[k]]] $k=1..nb_points] ;
l := [[0, 0], [1/5, e−1/5 sin (2/5 π)], [2/5, e−2/5 sin (1/5 π)],
[3/5, −e−3/5 sin (1/5 π)], [4/5, −e−4/5 sin (2/5 π)], [1, 0]]
> points := plot(l,0..1,style=point,color=black,symbol=circle) :
> fonction := plot(f,0..1,color=red) :
> polynome := plot(p,0..1,color=blue) :
> display(points,fonction,polynome) ;
> plot(f(t)-p(t),t=0..1) ;
Chapitre 4. Approximation 75
La majorant de l’erreur est :

> plot(abs(f(t)-p(t)),t=0..1) ;
4.3 Autres interpolations polynomiales

4.3.1 Approximation au sens des moindres carrés (cas discret)
C’est un problème d’approximation. On a un ensemble de points (xi )i=1..n et on veut trouver
une fonction qui passe "globalement" par tous les points. On veut minimiser le carré de la
différence entre les points et la courbe. Soit P la courbe qui approche globalement les points :
n
(P (xi ) − yi )2
X
min
i=1
P peut être une fonction ou un polynôme. On peut choisir le degré du polynôme.

Le minimal est atteint si les dérivées partielles aux points données est nul.
4.3.2 Approximation au sens des moindres carrés (cas continu)

Soit f une fonction continue sur l’intervalle [a, b]. On désire déterminer le polynôme P de
degré inférieur ou égal à n tel que la quantité :
Z b
(f (x) − p(x))p2dx
a
soit minimale. On montre qu’il existe un unique polynôme P ayant cette propriété et que P est
caractérisé par : Z b
q(x)(f (x) − p(x))dx = 0
a
pour tout polynôme q de degré inférieur ou égal à n.
4.4 Polynômes trigonométriques : séries de Fourier

Soit f une fonction continuement dérivable par morceaux et périodique de période T . la
série de Fourier de f s’écrit :
! !
a(0) 2πnx 2πnx
X X
SF (f ) := + a(n) cos + b(n) sin
2 n=1 T n=1 T
où l’on définit les suites an et bn par :

RT RT
2 0 f (x) cos 2nπx
T
dx 2 0 f (x) sin( 2nπx
T
)dx
an := et bn :=
T T
4.4.1 Approximation
Une idée naturelle pour approcher une fonction développable en série de Fourier est de
tronquer la dite série et de ne considérer donc que les N premiers termes.
4.4.2 Illustration
Voir la procédure Serie_Foruier sur http ://alamanya.free.fr/themes/fouriermodule.htm
> Sf :=Serie_Fourier(2*Pi,[-Pi,0,Pi],[x->abs(x),x->abs(x)],x) :
> Sf :-serieR() ;
X∞
(2 (−1)n − 2) cos (nx)
x 7→ 1/2 π +
n=1 π n2
> Sf :-graphe(1,3,-1,1) ;
Chapitre 5
Intégration
5.1 Régle des trapèzes

5.1.1 Exemples introductifs
1 1 1+ex ex ex
− =1−
R
Considérons l’intégrale indéfinie 1+ex
dx. Puisque 1+ex
= 1+ex 1+ex 1+ex
1 1 ex
Z Z Z
dx = 1− dx = x − dx
1 + ex 1 + ex 1 + ex
L’intégrale restante peut être calculée à l’aide d’un changement de variables en posant u = 1+ex .
Z
ex 1
x
dx = du
1+e u
Ainsi on a :
1Z
dx = x − ln(1 + ex ) + c
1 + ex
Ce résultat peut être directement obtenu par MAPLE. La commande Int est de la forme
inerte de int. La conjonction de Int de value permet l’afficahge de l’intégrale non évaluée
numériquement.
> with(plots) : > Int(1/(1+exp(x)),x) ;
Z
(1 + ex )−1 dx
> value(%) ;
ln (ex ) − ln (1 + ex )
> simplify(%,symbolic) ;
x − ln (1 + ex )
Voici une lègere modification qui donne une meilleure présentation du précédent résultat.
> Int(1/(1+exp(x)),x) ; Z
(1 + ex )−1 dx
> ’%’ = simplify(value(%),symbolic)+c ;
Z
(1 + ex )−1 dx = x − ln (1 + ex ) + c
Z 1
1
Maintenant considérons l’intégrale définie dx. Pour une réprésentation graphique,
0 1 + ex
on procéde de la façon suivante.
77
78 Chapitre 5. Intégration
> f := x->1/(1+exp(x)) : ’f(x)’=f(x) ;
f (x) = (1 + ex )−1
On peut calculer cette intégrale par les méthodes habituelles.

> Int(1/(1+exp(x)),x=0..1) ;
Z 1
(1 + ex )−1 dx
0
> value(%) ;
ln (2) − ln 1 + e1 + 1
> evalf(%) ;
0.3798854936
> d1 := plot(f(x),x=0..1,color=blue) :
> d2 := plot(f(x),x=0..1,color=aquamarine,filled=true) :
> display({d1,d2}) ;
1R
Maintenant on considére l’intégrale indéfinie x+e x dx. Il n’est pas possible d’obtenir une
expression analytique de cette intégrale impliquant des fonction élementaires. Maple ne peut
même pas donner une expression de cette intégrale en terme de fonction spéciales.
> d1 := plot(f(x),x=-10..10) :
> d2 := plot(f(x),x=-10..10,color=red,filled=true) :
> display({d1,d2}) ;
Chapitre 5. Intégration 79
> Int(1/(x+exp(x)),x) ; value(%) ;

Z
(x + ex )−1 dx
Z
(x + ex )−1 dx
Formellement,
1
Z 1
1 X 1
x
dx = lim x
0 x+e δx→0
x=0 x + e
C’est ce que MAPLE calcule quand on lui demande evalf(Int(f(x)),x=0..1). On peut être
plus précis dans la précision :
> Int(1/(x+exp(x)),x=0..1) ; value(%) ; evalf(%) ;
Z 1
(x + ex )−1 dx
0
Z 1
(x + ex )−1 dx
0
0.5163007634
> evalf[20](Int(1/(x+exp(x)),x=0..1)) ;
0.51630076336901667193
On peut calculer l’aire du rectangle et du trapèze pour les intégrales :

> f := x -> 1/(x+exp(x)) :
> rectangle_area := evalf(f(1)) ;
rectangle_area := 0.2689414214
> trapezoid_area := evalf((1+f(1))/2) ;
trapezoid_area := 0.6344707107
Z 1
1
Revenons à notre première intégrale : dx et on calcule la surface :
0 1 + ex
> evalf(Int(1/(1+exp(x)),x=0..1)) ;
0.3798854930
> evalf(int(1/(1+exp(x)),x=0..1)) ;
0.379885494
int : évaluation symbolique en calculant l’intégrale Int : évaluation numérique.

5.1.2 La régle des trapèzes

La régles des trapèzes est basé sur l’idée de remplacer la fonction par son polynôme d’in-
terpolation de degré 1 sur chacun sous-intervalle.
Z b
Soit l’intégrale définie f (x)dx peut être approximée par la somme des aires des trapèzes
a
formés par les points :
(x0 , f (x0 )), ..., (xn , f (xn ))
sur la courbe y = f (x). Ainsi :
Z b
h
f (x)dx ' [f (x0 ) + 2f (x1 ) + 2f (x2 ) + ... + 2(f (xn−1 ) + f (xn )]
a 2

b−a b−a
où h = n
est le pas de la subdivision de l’intervalle [a, b]. En posnant : xi = a+ih = a+i n
,
on a :
n−1
Z b ! !
h X
f (x)dx ' f (a) + 2 f (a + ih) + f (b)
a 2 i=1
Exemple 1 : la régle des trapèzes via student[trapezoid]

La régle des trapèzes peut être appliquée à l’aide de la commande trapezoid qui se trouve
dans la bibliothèque student.
> Int(f(x),x=a..b)=student[trapezoid](f(x),x=a..a+n*h,n) ;
5
Z b !
a+ih −1 a+6 h −1

x −1 a −1
X
(x + e ) dx = 1/2 h (a + e ) +2 a + ih + e + a + 6h + e
a i=1
Un cas précis :
> n := 6 :
> student[trapezoid](f(x),x=a..a+n*h,n) ;
5
!
a+ih −1 a+6 h −1

a −1
X
1/2 h (a + e ) +2 a + ih + e + a + 6h + e
i=1
> value(%) ;
−1 −1 −1
1/2 h((a + ea )−1 + 2 a + h + ea+h + 2 a + 2 h + ea+2 h + 2 a + 3 h + ea+3 h
−1 −1 −1
+2 a + 4 h + ea+4 h + 2 a + 5 h + ea+5 h + a + 6 h + ea+6 h )
> for k from 1 to n do subs(f(a+i*h)=y[i],%) od :
On peut vérifier le résultat :

> intergtrap := proc(f,a,b,n)
> local h,k1,k2,p,P,s,L,T ;
> h := (b-a)/n ;
> k1 := a ; s := 1 ;
> while k1 < b do
> p := interp([k1,k2],[f(k1),f(k2)],x) ;
> P[s] := plot(p(x),x=k1..k2,color=blue) ;
> T[s] := plot([[k1,0],[k1,f(k1)]],color=blue) ;
> L[s] := plot([[k2,0],[k2,f(k2)]],color=blue) ;
> k1 := k2 ;
> s := s+1 ;
> od ;
> P[0] := plot(f(x),x=a..b) ;
> display({seq(P[k],k=0..s-1),seq(L[k],k=1..s-1),seq(T[k],k=1..s-1)}) ;
> end :
> intergtrap(f,0,1,n) ;
On peut affiner la méthode des trapèzes.

> student[trapezoid](2*x^2-x^3/3,x=1..5,4) ;
3
2 (1 + i)2 − 1/3 (1 + i)3
X
5+
i=1
> value(%) ;
30
> Int(2*x^2-x^3/3,x=1..5) ; Z 5
2 x2 − 1/3 x3 dx
1
> value(%) ;
92
3
7
2 (1 + 1/2 i)2 − 1/3 (1 + 1/2 i)3
X
5/2 + 1/2
i=1
> value(%) ;
61
2
15
2 (1 + 1/4 i)2 − 1/3 (1 + 1/4 i)3
X
5/4 + 1/4
i=1
> value(%) ;
245
8
Exemple 2 : Erreur absolue et erreur relative dans l’évaluation d’une intégrale

numérique
Z 3π
4
On cherche à évaluer numériquement π
sin(x)dx en utilisant la méthode des trapèzes avec
4
4 sous-intervalles.
> student[trapezoid](sin(x),x=Pi/4..3*Pi/4) ;
3
!
X
1/16 π sqrt (2) + 2 sin (1/4 π + 1/8 iπ)
i=1
> trap4 := evalf(%) ;

trap4 := 1.395992554
> intergtrap(f,evalf(Pi/4),evalf(3*Pi/4),4) ;
Comme nous pouvons observer sur la figure, ici nous avons une estimation de l’intégrale
avec la méthode des trapèzes.
Nous allons d’abord calculer la valeur exacte de l’intégrale. > int(sin(x),x=Pi/4..3*Pi/4) ;
sqrt (2)
> area := evalf(%) ;http ://img120.imageshack.us/img120/262/elsafayerfortboyard0508fi7.jpg
area := 1.414213562
On calcule l’erreur absolue comise avec la régle des trapèzes avec 4 sous-intervalles est
donnée par :
> abserr := abs(trap4-area) ;
abserr := 0.018221008
et erreur relative est :

> relerr := abserr/abs(area) ;
relerr := 0.01288419832
qui est de l’ordre de 1,3%.
Exemple 3 : Résultat empirique sur l’erreur absolue

Z 1
2
On cherche une approximation de e−x dx en utilisant la règle des trapèzes avec 32 sous-
0
intervalles et 64 sous-intervalles.
> student[trapezoid](exp(-x^2),x=0..1,32) ;
31
1 1 2 1 −1
e− 1024 i +
X
+ 1/32 e
64 i=1 64

trap32 := 0.7467642547
> student[trapezoid](exp(-x^2),x=0..1,64) ;
63
1 1 X 1 2 1 −1
+ e− 4096 i + e
128 64 i=1 128

trap64 := 0.7468091636
On calcule la valeur exacte de l’intégrale.
> Int(exp(-x^2),x=0..1) ; Z 1 2
e−x dx
0
> value(%) ;
1/2 erf (1) sqrt (π)
> area := evalf(%) ;
area := 0.7468241330
On calcule les erreurs.
> abserr32 := evalf[20](abs(trap32-area)) ;
abserr32 := 0.0000598783
> abserr64 := evalf[20](abs(trap64-area)) ;
abserr64 := 0.0000149694
On montre dans le cas général, l’erreur absolue commise dans l’évalution d’une intégrale en
utilisant la régle des trapèzes est approximativement proportionnelle au carré de la longueur
des sous-intervalles.
5.2 La régle de Simpson
Soit un nombre impair de points (x0 , y0 ), ..., (xn , yn ) sur la courbe y = f (x), une subdivision
régulière a = x0 , x1 , ..., xn = b où yi = f (xi ) pour chaque (i). On a alors :
Z b
h h
f (x)dx ' (y0 +4y1 +y2 )+...+(yn−2 +4yn−1 +yn ) = [(y0 +yn )+4(y1 +y3 = ...+yn−1 )+2(y2 +y4 +...+yn
a 3 3
La régle de Simpson peut être appliquée en invoquant la commande simpson du package
student
> Int(f(x),x=a..b)=student[simpson](f(x),x=a..a+n*h,n) ;
 
Z b 1/2 n 1/2 n−1
X X
f (x) dx = 1/3 h f (a) + f (a + nh) + 4 f (a + (2 i − 1) h) + 2 f (a + 2 ih)
a i=1 i=1
Les lignes de code suivantes générent les différences instances des formules de la régle de
Simpson :
> n := 6 :
> student[simpson](f(x),x=a..a+n*h,n) ;
3 2
!
X X
1/3 h f (a) + f (a + 6 h) + 4 f (a + (2 i − 1) h) + 2 f (a + 2 ih)
i=1 i=1
> value(%) ;
1/3 h (f (a) + f (a + 6 h) + 4 f (a + h) + 4 f (a + 3 h) + 4 f (a + 5 h) + 2 f (a + 2 h) + 2 f (a + 4 h))
> for i from 0 to n do subs(f(a+i*h)=y[i],%) end do :
1/3 h (y0 + y6 + 4 y1 + 4 y3 + 4 y5 + 2 y2 + 2 y4 )
5.2.1 Exemples
Intégrales du développement de Taylor de cos(x) en x = 0. Utilisation de la méthode des
trapèzes et de Simpson.
> int((cos(x)-(1-x^2/2)),x=0..3*Pi/2) ;
9 3
−1 − 3/2 π + π
16
> evalf(%) ;
11.72864166
> int(cos(x)-(1-x^2/2+x^4/24),x=0..3*Pi/2) ;
81 5 9 3
−1 − π − 3/2 π + π
1280 16
> evalf(%) ;
−7.63666653
> int(cos(x)-(1-x^2/2+x^4/24-x^6/6 !),x=0..3*Pi/2) ;
81 5 243 7 9 3
−1 − π − 3/2 π + π + π
1280 71680 16
> evalf(%) ;
2.60232977
> intergSimpson := proc(f,a,b,n)
> local h,k1,k2,p,P,s,L,T ;
> h := (b-a)/n ;
> k1 := a ; s := 1 ;
> while k1 < b do
> k2 := k1+h ;
> p := interp([k1,(k2-k1)/2,k2],[f(k1),f((k2-k1)/2),f(k2)],x) ;
> P[s] := plot(p(x),x=k1..k2,color=blue) ;
> T[s] := plot([[k1,0],[k1,f(k1)]],color=blue) ;
> L[s] := plot([[k2,0],[k2,f(k2)]],color=blue) ; > k1 := k2 ;
> s := s+1 ;
> od ;
> P[0] := plot(f(x),x=a..b) ;
> display({seq(P[k],k=0..s-1),seq(L[k],k=1..s-1),seq(T[k],k=1..s-1)}) ;
> end :
> f := x -> cos(x)*exp(x) ;
f := x 7→ cos (x) ex
> intergSimpson(f,0,6,3) ;
Chapitre 6
"Révisions"
6.1 expand-simplify-normal
Si on veut effectuer la distributivité de la multiplication par rapport à l’addition on utilise
la fonction expand
> P := (x+y)^5 ;
P := (x + y)5
> expand(%) ;
x5 + 5 x4 y + 10 x3 y 2 + 10 x2 y 3 + 5 xy 4 + y 5
> Ex := (x+y)^5-% ; expand(%) ;
Ex := (x + y)5 − x5 − 5 x4 y − 10 x3 y 2 − 10 x2 y 3 − 5 xy 4 − y 5
0
normal a comme paramètre une expression, normal renvoie l’expression développée et simplifiée.
> (x+y)/(x-y)+(1/x+1/y)/(1/x-1/y) ;
x + y −1 −1
+ x + y −1 x−1 − y −1
x−y
> normal(%) ;
0
Attention :. normal est moins efficace que simplify et on est quelquefois obligé de faire
plusieurs fois la commande normal.
simplify simplifie l’expression de façon automatique.
> ’log(tan(Pi/4))’ ;
log (tan (1/4 π))
> %
0
6.2 Séquences
Deux façons de construire des séquences seq, for et deux façons pour les convertir en
somme.
86
Chapitre 6. "Révisions" 87
> seq(x^r/r !,r=0..5) ;

1 5
1, x, 1/2 x2 , 1/6 x3 , 1/24 x4 , x
120
> term := 1 : s := term :
> for r from 1 to 5 do
> term := term*x/r :
> s := s, term end do :
> s;
1 5
1, x, 1/2 x2 , 1/6 x3 , 1/24 x4 , x
120
> convert([s],‘+‘) ;
1 5
1 + x + 1/2 x2 + 1/6 x3 + 1/24 x4 + x
120
> ‘+‘(s) ;
1 5
1 + x + 1/2 x2 + 1/6 x3 + 1/24 x4 + x
120
6.3 sum et product

Formule de Taylor à l’ordre 5 pour exp(x).
> unassign(’term’,’s’,’r’) ;
> Sum(x^r/r !,r=0..5) ; % = value(%) ;
5
X xr
r=0 r!
5
xr 1 5
= 1 + x + 1/2 x2 + 1/6 x3 + 1/24 x4 +
X
x
r=0 r! 120
> e1 := rhs(%) ;
1 5
e1 := 1 + x + 1/2 x2 + 1/6 x3 + 1/24 x4 + x
120
> e2 := expand(subs(n=5,(1+x/n)^n)) ;
2 3 1 4 1
e2 := 1 + x + 2/5 x2 +
x + x + x5
25 125 3125
> plot([exp(x),e1,e2],x=-2..2,title="Approximation exp(x)",legend=["exp(x)","Taylor","
88 Chapitre 6. "Révisions"
sin x ∼ x, sin(x) est proportionnelle à :

∞ ∞
!
2 2
Y Y
(x − rπ) = x (x − (rπ) )
r=−∞ r=1
> S := (n,x) -> x*product(x^2-(r*Pi)^2,r=1..n) ; S(5,x) ;

n
(x2 − (rπ)2
Y
S := (n, x) 7→ x
r=1

x x2 − π 2 x2 − 4 π 2 x2 − 9 π 2 x2 − 16 π 2 x2 − 25 π 2
> k := (-1)^3*(S(3,-Pi/2)) ;
1575 7
k := − π
128
> plot([k*sin(x),S(3,x)],x=-2..2) ;
6.4 Construction de tables de groupes avec array

Construction de la table de groupe Z/3Z.
> restart ;
> m := 4 ;
m := 4
> mx := m-1 ; shift := 2 ;
> MT := array(1..mx+shift,1..mx+shift,[(1,1)=‘x‘, (1,2)=‘||‘, (2,1)=‘–-‘,(2,2)=‘-||-‘]
> for j to mx do
> MT[1,j+shift] := j ;
> MT[2,j+shift] := ‘–-‘
> end do ;
mx := 3
shift := 2
MT 1,3 := 1
MT 2,3 := −–
MT 1,4 := 2
Chapitre 6. "Révisions" 89
MT 2,4 := −–
MT 1,5 := 3
MT 2,5 := −–
> for i to mx do
> MT[i+shift,1] := i ;
> MT[i+shift,2] := ‘||‘ ;
> end do ;
MT 3,1 := 1
MT 3,2 := ||
MT 4,1 := 2
MT 4,2 := ||
MT 5,1 := 3
MT 5,2 := ||
> for i to mx do
> for j to mx do
> MT[i+shift,j+shift] := i*j mod m ;
> end do
> end do ;
> eval(MT) ;  
x || 1 2 3
− − − −||− − − − − − − − − −
 
 
 1
 || 1 2 3 
 2

|| 2 0 2 
3 || 3 2 1
Chapitre 7
Equations différentielles
Ce chapitre ne donne qu’un bref aperçu des possibilités de MAPLE dans ce domaine mais
il sera peut-être suffisant pour une première approche.
7.1 Fonction dsolve, équations différentielles et condi-

tions initiales
MAPLE permet de résoudre beaucoup d’équations différentielles à l’aide de l’opérateur
dsolve. On définit les termes différentiels des équations à l’aide de l’opérateur diff. La fonction
dsolve génère avec la solution les noms de constantes d’intégration sous la forme _C1, _C2...
On peut donner un nom à l’équation différentielle ainsi qu’à la solution.
On rapelle que s’il est possible à l’utilisateur de créer des noms de variables commençant
par un caractère de soulignement (_) ceci est très fortement déconseillé et doit être laissé à
l’initiative de MAPLE. Néanmoins, dsolve n’utilisera pas un nom assigné pour désigner une
constante d’intégration.
> restart :
> eqd :=diff(y(x),x)-k*x*y(x) = x : eqd ;
> sol :=dsolve(eqd) ;
d
y (x) − kxy (x) = x
dx
2
sol := y (x) = −k −1 + e1/2 kx _C1
On peut vérifier la réponse à l’aide de la fonction odetest qui doit répondre 0 si la solution
est juste. Quelquefois il peut être nécessaire d’éffectuer quelques simplifications sur la réponse
pour obtenir ce résultat.
> odetest(sol,eqd) ;
0
La donnée du nom de la fonction inconnue comme argument peut être nécessaire car dsolve
est capable de résoudre formellement une équation pour des termes contenant des fonctions non
explicitées. Les deux réponses suivantes sont différentes car on ne résout pas la même équa-
tion, les fonctions solutions étant différentes. On remarque également que l’on peut employer
indifféremment Diff ou diff.
> eqd :=Diff(h(x)+y(x),x)-k*x*y(x) = G(x) : eqd ;
d
(h (x) + y (x)) − kxy (x) = G (x)
dx
90
Chapitre 7. Equations différentielles 91
> dsolve(eqd,y(x)) ;
! !
Z
d 2 2
y (x) = − h (x) + G (x) e−1/2 kx dx + _C1 e1/2 kx
dx
> dsolve(eqd,h(x)) ;
Z
d
h (x) = − y (x) + kxy (x) + G (x) dx + _C1
dx
S’il n’y a pas d’ambiguité, MAPLE chosit pour fonction solution celle sur laquelle s’applique
l’opérateur diff
> eqd :=diff(h(x),x)-2*x*y(x)=x : eqd ;
> dsolve(eqd) ;
d
h (x) − 2 xy (x) = x
dx
Z
h (x) = x (2 y (x) + 1) dx + _C1
Lorsque l’on fixe une ou plusieurs conditions initiales, elles forment avec l’équation diffé-
rentielle un ensemble d’équations à résoudre (doù la mise entre {} de ces équations). MAPLE
calcule (si elle existe) la (les) valeur(s) des constante(s) d’intégration.
> eqd :=diff(y(x),x)-2*x*y(x) = x : eqd ;
> c_i :=y(0)=1 : c_i ;
> sol :=dsolve({eqd,c_i}) ;
d
y (x) − 2 xy (x) = x
dx
y (0) = 1
2
sol := y (x) = −1/2 + 3/2 ex
0
Attention :. La fonction y n’existe pas, sinon de façon symbolique. On rappelle qu’une écriture
comme y(x) possède le type f unction en raison de sa syntaxe. La réponse de dsolve est
seulement une équation.
> whattype(y(x)), whattype(sol) ;
function, ‘=‘
et y n’est pas ssocie à une fonction explicitée :

> eval(y) ;
> y(0) ;
y
y (0)
On peut assigner la solution à y(x). Il faut alors comprendre que y(x) se compote simplement
comme un nom qui point sur l’expression de la solution.
> assign(sol) ;# Cette commande ne renvoie aucun message
> y(x) ;
2
−1/2 + 3/2 ex
92 Chapitre 7. Equations différentielles
Mais y n’est toujours pas une fonction...

> y(t),y(3) ;
> type(eval(y),operator) ;
y (t) , y (3)
false
Maintenant on peut transformer la solution en une fonction en écrivant :
> y :=unapply(y(x),x) ;
2
y := x 7→ −1/2 + 3/2 ex
Résumé :
1) On résout l’équation différentielle (après avoir déassigné y) et on teste la validité de la
solution.
2) (Facultatif) on assigne à y(x) la solution.
3) (Facultatif) on transforme y(x) en une fonction y.
> y :=’y’ :
> eqd ;
> sol :=dsolve({eqd,y(0)=1}) ;
> assign(sol) ;
> y :=unapply(y(x),x) ;
d
y (x) − 2 xy (x) = x
dx
2
sol := y (x) = −1/2 + 3/2 ex
2
y := x 7→ −1/2 + 3/2 ex
Pour définir les derivées d’ordres supérieurs, on peut utiliser l’opérateur diff.
> y :=’y’ :
> eqd :=diff(y(x),x$2)-3*diff(y(x),x)+2*y(x) = 0 : eqd ;
> sol :=dsolve(eqd,y(x)) ;
d2 d
2
y (x) − 3 y (x) + 2 y (x) = 0
dx dx
sol := y (x) = _C1 e2 x + _C2 ex

L’opérateur D permet une écriture équivalente.
> eqD :=(D@@2)(y)(x)+2*D(y)(x)+y(x) = 0 : eqD ;
sol :=dsolve(eqD,y(x)) ;

D(2) (y) (x) + 2 D (y) (x) + y (x) = 0
sol := y (x) = _C1 e−x + _C2 e−x x

On peut d’ailleurs convertir un type d’écriture vers l’autre :
> convert(eqd,D) ;
> convert(eqD,diff) ;

D(2) (y) (x) − 3 D (y) (x) + 2 y (x) = 0
d2 d
2
y (x) + 2 y (x) + y (x) = 0
dx dx
L’opérateur D peut être utilisé en même temps que diff ou Diff. Mais il permet surtout
d’introduire des conditions initiales sur les derivées comme ici y 0 (0) = 0. On notera aussi la pos-
sibilité (non nécessaire) d’utiliser l’opérateur union pour rassemble l’équation et les conditions
initiales.
> eqd :=Diff(y(x),x$2)-3*D(y)(x)+2*y(x)=0 : eqd ;
c_i :={y(0)=1,D(y)(0)=0 } : c_i ;
sol :=dsolve({eqd} union c_i,y(x)) ;
d2
y (x) − 3 D (y) (x) + 2 y (x) = 0
dx2
{y (0) = 1, D (y) (0) = 0}
sol := y (x) = −e2 x + 2 ex
>convert({eqd} union c_i,D) ;
n o
y (0) = 1, D(2) (y) (x) − 3 D (y) (x) + 2 y (x) = 0, D (y) (0) = 0
7.2 Divers aspects de l’intégration des équations diffé-

rentielles
7.2.1 Résolution par transformations intégrales
On peut demander à dsolve d’appliquer une méthode de résolution par transformations
intégrales de Laplace ou de Fourier si l’on sait que l’une de ces méthodes est efficace pour
résoudre une équation. Ici l’équation différentielle est à coefficients constants et l’utilisation des
trransformées de Laplace est bien adptée à sa résolution.
> restart :
> eqd_ci :={ diff(y(x),x$2)+4*diff(y(x),x)+8*y(x) = sin(x) , y(0)=1 , D(y)(0)=0
} : eqd_ci ;
( )
d2 d
y (0) = 1, D (y) (0) = 0, 2 y (x) + 4 y (x) + 8 y (x) = sin (x)
dx dx
On peut imposer à MAPLE de chercher la solution par cette méthode en utilisant comme
troisième argument, le mot clé method. Cette troisième position impose donc de spécifier la
fonction inconnue y(x).
> sol :=dsolve(eqd_ci,y(x),method=laplace) ;
4 7 1 −2 x
sol := y (x) = − cos (x) + sin (x) + e (138 cos (2 x) + 131 sin (2 x))
65 65 130
7.2.2 Fonctions discontinues définissant les équations différentielles

La fonction dsolve sait traiter la fonction de Heaviside.
> eqd :=diff(y(x),x$2)-2*y(x)=Heaviside(x)*x : eqd ;
> c_i :={y(0)=0,D(y)(0)=0} : c_i ;
> sol :=dsolve({eqd} union c_i) ;
d2
y (x) − 2 y (x) = Heaviside (x) x
dx2
{D (y) (0) = 0, y (0) = 0}

sol := y (x) = −1/8 Heaviside (x) 4 x − sqrt (2) esqrt(2)x + sqrt (2) e−sqrt(2)x
Quelques manipulations peuvent être utilies pour éventuellement simplifier l’expression de
la solution.
> sol :=factor(convert(sol,trig)) ;
sol := y (x) = −1/4 Heaviside (x) (2 x − sqrt (2) sinh (sqrt (2) x))
0
On montre ici comment on peut se dispenser de la fonction assign pour créer le fonction
solution.
> y :=’y’ :
> eqd :=diff(y(x),x)+y(x) = piecewise(x<=0,1,exp(-x))+k*cos(x) : eqd ;

d 1 x≤0
y (x) + y (x) =
dx exp(−x) + k ∗ cos(x) otherwise
Les fonctions définies par morceaux avec piecewise peuvent aussi entrer dans l’écriture d’une
équation différentielle.

1/2 k cos (x) + 1/2 k sin (x) + 1 − 1/2 e−x k x<0
sol := y (x) = −x −x
1/2 k cos (x) + 1/2 k sin (x) − 1/2 e k+e + e−x x 0≤x
Cette solution peut être exprimée à l’aide de la fonction Heaviside.

> sol :=convert(sol,Heaviside) ;
sol := y (x) = 1/2 k cos (x) + 1/2 k sin (x) + 1 − Heaviside (x) − 1/2 e−x k + Heaviside (x) e−x + e−x Hea
De façon générale, et si c’est possible, on préféra convertir l’équation elle-même avant de

chercher la solution (souvent, c’est plus efficace).
> eqd :=convert(eqd,Heaviside) ;
d
eqd := y (x) + y (x) = k cos (x) + 1 − Heaviside (x) + Heaviside (x) e−x
dx
sol := y (x) = 1/2 k cos (x) + 1/2 k sin (x) + 1 − Heaviside (x) − 1/2 e−x k + Heaviside (x) e−x + e−x Hea
7.2.3 Solutions explicites et implicites

Quelquefois la méthode de résolution utilisée par dsolve conduit à une forme implicite
de la solution, c’est-à-dire une solution sous la forme d’une équation ordinaire. L’opérateur
dsolve tente alors de résoudre cette équation et présente la ou les solutions explicites. Si cette
résolution n’est pas possible, seule la forme et renvoyée. On remarquera ici que la solution est
sous cette forme F (x, y(x), Cte) = 0. De plus, la solution implicite contient un terme exprimé
à l’aide de l’opérateur Intat
> y :=’y’ :
> eqd := diff(y(x),x)=sin(y(x)^2) :eqd ;
> dsolve(eqd) ;
d
y (x) = sin (y (x))2
dx
Z y(x) −1
x− sin _a 2 d_a + _C1 = 0
La fonction odetest fonctionne malgré tout :
> odetest(%,eqd) ;
0
Pour l’équation suivante, MAPLE renvoie normalement deux solutions :
> eqd := diff(y(x),x)=-y(x)+y(x)^3 : eqd ;
dsolve(eqd) ; # 2 solutions explicites
d
y (x) = −y (x) + (y (x))3
dx
−1 −1
y (x) = sqrt 1 + e2 x _C1 , y (x) = − sqrt 1 + e2 x _C1
On notera que les solutions étant alors renvoyées sous forme de suite (séquence) on devra
former l’ensemble des solutions pour odetest et on obtiendra un ensemble de 2 zéros.
> odetest({%},eqd) ;
{0}
On peut demander à solve de donner la solution sous une forme implicite avec le mot clé
implicit
> dsolve(eqd,implicit) ;
(y (x))−2 − 1 − e2 x _C1 = 0
Les solutions précédentes sont bien les racines de la solution-équation implicite.
> solve(%,y(x)) ;
−1 −1
sqrt 1 + e2 x _C1 , − sqrt 1 + e2 x _C1
On ne sera donc pas surpris si les solutions explicites font souvent apparaître la fonction W
de Lambert.
> eqd :=(1+x*y(x)+x^2)*diff(y(x),x)+1+x*y(x)+y(x)^2=0 : eqd ;
> dsolve(eqd) ;
d
1 + xy (x) + x2 y (x) + 1 + xy (x) + (y (x))2 = 0
dx
!
x (y (x) + x)

2 −1

−_C1 + 1 + xy (x) − ln −9 1 + xy (x) + x + ln 9/2 − ln (x) = 0
1 + xy (x) + x2
2

x2 − LambertW −2 x_C1 e−1 ex
y (x) = −
x
Dans l’exemple suivant la solution explicite est d’un intérêt relatif. La solution implicite
montre que la difficulté rencontrée vient de ce que MAPLE ne "connait" pas de définition pour
la fonction réciproque de la fonction de Frsnel-sinus.
> eqd := diff(y(x),x)=sin(y(x)^2)^(-1) : eqd ;

> dsolve(eqd) ;
d −1
y (x) = sin (y (x))2
dx
y (x) = 1/2 sqrt (2) sqrt (π) RootOf (−FresnelS (_Z ) sqrt (π) + sqrt (2) x + sqrt (2) _C1)
!
sqrt (2) y (x)
x − 1/2 sqrt (2) sqrt (π) FresnelS + _C1 = 0}
sqrt (π)
7.2.4 Classes des équations différentielles

La fonction odeadvisor de la bibliothèque DEtools peut indiquer à quelle classe appartient
une équation différentielle.
> eqd := diff(y(x),x)=-x*y(x)+y(x)^3 : eqd ;
> DEtools[odeadvisor](eqd) ;
d
y (x) = −xy (x) + (y (x))3
dx
_Bernoulli
Ici on rencontre une équation du type Ricatti mais avec une propriété supplémentaire :
> eqd :=Diff(y(x),x)+(2*x+1)*y(x)+(1+x+x^2)+y(x)^2=0 : eqd ;
d
y (x) + (2 x + 1) y (x) + 1 + x + x2 + (y (x))2 = 0
dx
[[_homogeneous, ‘class C‘], _Riccati]
Il n’y a pas de méthode générale pour résoudre les équations de Ricatti mais dsolve trouve
la solution de cette équation grâce à la propriété d’homogénéité.
> dsolve(eqd) ;
−1 + xex _C1 − x
y (x) = −
ex _C1 − 1
MAPLE "connaît" la plupart des fonctions dites spéciales, ce qui lui permet de résoudre
certains types
> eqd :=x^2*diff(y(x),x$2)+x*diff(y(x),x)+(x^2-n^2)*y(x)=0 : eqd ;
> dsolve(eqd) ;
d2 d
x2 2 y (x) + x y (x) + x2 − n2 y (x) = 0
dx dx
[_Bessel]
y (x) = _C1 BesselJ (n, x) + _C2 BesselY (n, x)
> eqd :=Diff(y(x),x$2)=3*cos(2*x)*y(x)-y(x) : eqd ;
> c_i :={y(0)=1,D(y)(0)=0} : c_i ;
> dsolve({eqd,op(c_i)},y(x)) ;
d2
y (x) = 3 cos (2 x) y (x) − y (x)
dx2
{y (0) = 1, D (y) (0) = 0}
[_ellipsoidal]
y (x) = MathieuC (1, 3/2, x)
Enfin, dsolve ne sera pas toujours capable de donner une solution (souvent parce qu’elle
ne s’exprime pas de façon symbolique et exacte). La réponse est alors soit N U LL, soit une
ré-écriture de l’équation avec la fonction DESol (cette fonction est aux équations différentielles
ce que RootOf est aux équations ordinaires). L’apparente simplicité d’une équation n’est pas un
gage sur la possibilité d’expliciter la solution... (ici une équation voisine du premier transcendant
de Painlevé ; remplacer y(x)2 par 6y(x)2 )
> eqd :=Diff(y(x),x$2)=y(x)^2+x : eqd ;
> sol :=dsolve(eqd) ;
d2
2
y (x) = (y (x))2 + x
dx
[NONE]
sol :=
7.2.5 Développement en série de la solution

Lorsque MAPLE ne trouve pas de solution ou si la solution est trop complique, on peut lui
demander un développement en série autour des conditions initiales avec le mot clé series.
L’ordre du développement dépend comme pour la fonction series de la variable globle Order
(6 par défaut et que l’on a changé ici en 5). Le mot clé series doit être en troisième position
ce qui nécessite d’expliciter la fonction inconnue.
> eqd :=D(y)(x)+(2*x+1)*y(x)+(1+x+x^2)*y(x)^3=0 : eqd ;
> C_init :=y(1)=1 : C_init ;
> Order :=5 ;
> sol :=dsolve({eqd,C_init},y(x),series) ;

D (y) (x) + (2 x + 1) y (x) + 1 + x + x2 (y (x))3 = 0
y (1) = 1
67 661 12471
sol := y (x) = 7 − 6 x + (x − 1)2 − (x − 1)3 + (x − 1)4 + O (x − 1)5
2 3 8
Voici comment transformer ce type de solution en une fonction, solution approchée au
voisinage de la condition initiale :
> y_ap :=unapply(convert(rhs(sol),polynom),x) ;
67 661 12471
y_ap := x 7→ 7 − 6 x + (x − 1)2 − (x − 1)3 + (x − 1)4
2 3 8
L’équation précédente peut être résolue exactement par dsolve.

7.2.6 Equations linéaires homohènes à coefficients polynomiaux

La solution explicite de ce type d’équation, comme le lecteur pourra le tester avec cet
exemple, peut être compliquée et difficilement exploitable.
> eqd :=(x^3+x)*diff(y(x),x$3)+(x^2-1)*diff(y(x),x$2)-y(x)=0 :
> eqd ;
d3 d2
x3 + x y (x) + x 2
− 1 y (x) − y (x) = 0
dx3 dx2
Avec l’option formal_solution on peut obtenir l’expression de la solution sous forme de
série entière
> dsolve({eqd,y(0)=0},y(x),formal_solution) ;
∞ _n1−1
!
X _n1+1 −2 _n1+2
Y (−1 + 4 l2 + 8 l3 ) x2 _n1+1
y (x) = _C1 (−1) 2
_n1=1 l=1 l (3 + 5 l + 2 l2 )
7.3 Système d’équations différentielles

MAPLE peut aussi résoudre des systèmes d’équations différentielles.
> eqd :={diff(x(t),t)-x(t)+2*y(t)=0,diff(y(t),t)+x(t)-2*y(t)=0} : eqd ;
> c_init :={x(0)=0,y(1)=1} : c_init ;
> fct :={x(t),y(t)} : fct ;
( )
d d
x (t) − x (t) + 2 y (t) = 0, y (t) + x (t) − 2 y (t) = 0
dt dt
{x (0) = 0, y (1) = 1}
{x (t) , y (t)}
> sol :=dsolve(eqd union c_init,fct) ;
e3 t e3 t
( )
3 −1 3 −1

sol := y (t) = 1 + 2 e +2 , x (t) = −2 + 2 1 + 2e
1 + 2 e3 1 + 2 e3
>odetest(sol,eqd) ;
{0}
On peut maintenant construire les fonctions solutions.

> xf :=unapply(subs(sol,x(t)),t) ;
> yf :=unapply(subs(sol,y(t)),t) ;
e3 t
3 −1

xf := t 7→ −2 + 2 1 + 2 e
1 + 2 e3
−1 e3 t
yf := t 7→ 1 + 2 e3 +2
1 + 2 e3
7.4 Résolutions numériques

Lorsque MAPLE ne trouve pas de solutions exactes, il est possible de trouver une solution
numérique en utilisant le mot clé numeric. MAPLE détectera la nature du problème posé, c’est-
à-dire avec conditions initiales ou conditions aux limites afin de choisir un algorithme adapté.
Pour de telles résolutions les équations ne doivent pas dépendre de paramètres non définis et
toutes les conditions (initiales ou aux limites) qui fixent la solution doivent être données.
> eqd :=diff(f(x),x$2)=(x-f(x))/(1+x^2+f(x)^2) : eqd ;
> c_i :=f(0)=1,D(f)(0)=-1 : c_i ;
d2 x − f (x)
f (x) =
dx 2
1 + x2 + (f (x))2
f (0) = 1, D (f ) (0) = −1
On construit une équation différentielle avec conditions initiales au point x = 0.
dont l’intégrateur dsolve ne trouve pas de solution exacte
> sol :=dsolve({eqd,c_i},f(x)) ;
sol :=
Avec le mot clé numeric, dsolve crée une procédure d’intégration numérique en utilisant,
par défaut, une méthode du type Runge-Kutta-Fehlberg d’ordre 4
> sol :=dsolve({eqd,c_i},f(x),numeric) ;
On construit maintenant, avec la même équation, un problème aux conditions aux limites
en x = 0 et x = 1 :
> c_1 :=f(0)=1,f(1)=1 : c_1 ;
f (0) = 1, f (1) = 1
dsolve détecte la nature du problème psé, choisit un algorithme adapté (bvp) et construit de
même une procédure :
> sol_1 :=dsolve(eqd,c_1,f(x),numeric) ;
sol_l := proc(x_bvp)...endproc;
Attention :. Il existe un très grand nombre de possibilités et d’options pour les commandes
dsolve et numeric.
On donne comme exemple un problème aux conditions initiales avec une équation déclarée
"raide" (stiff) avec l’option stiff=true. Ces équations (ou systèmes d’équations comme par
exemple ceux des équilibres chimiques) sont caractérisées par des coefficients ayant des ordres
de grandeur relatifs importants. On laisse dsolve choisir la méthode (Rosenbrock), mais on
pourrait l’imposer, etc.
> eqd_stiff :=diff(f(t),t$2)+1.0e3*diff(f(t),t)+1.0e-2*f(t)^2=0 ;
> sol_stiff :=dsolve({eqd_stiff,f(0)=1,D(f)(0)=0},f(t),
numeric,stiff=true,range=0..10,relerr=1.0e-6) ;
d2 d
eqd_stiff := 2
f (t) + 1000.0 f (t) + 0.010 (f (t))2 = 0
dt dt
sol_stiff := proc (x_rosenbrock) ... endproc
On peut utiliser la procédure comme une fonction qui donne comme résultat un liste d’équa-
tions. On reprend la solution du premier problème du paragraphe.
> sol(1.5) ;
d
[x = 1.5, f (x) = −0.498964712481904938, f (x) = −0.683454657349700678]
dx
La solution pourra être visualisée graphiquement avec la fonction odeplot de la bibliothque
graphique plots. 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.
> plots[odeplot](sol,[[x,f(x),color=black], [x,diff(f(x),x),color=blue]],0..5) ;
> plots[odeplot](sol,[f(x),x],0..5,color=black) ;
7.4.1 Création d’une procédure (fonction) solution

La fonction dsolve(...,numeric) possède l’option output=listprocedure qui renvoie une
liste de procédure :
> Ls :=dsolve({eqd,c_i},f(x),numeric,output=listprocedure) ;
!
d
Ls := x = proc (x) ... endproc, f (x) = proc (x) ... endproc, f (x) = proc (x) ... endproc
dx
On peut associer à des noms ces procédures d’intégration numérique (la fonction subs admet
des ensembles de subsitutions mais aussi des listes).
> f_n :=subs(Ls,f(x)) :

fp_n :=subs(Ls,diff(f(x),x)) :
Ces noms s’utilisent alors comme des fonctions
> f_n(2),fp_n(2) ;
−0.772248842748144981, −0.416113275412975436
Par exemple, si on cherche une approximation de l’abcisse du minimum de la solution :

> fsolve(fp_n(x)=0,x=2..4) ;
2.976436817
On peut aussi écrire pour construire les fonctions solutions :
> f_n :=rhs(Ls[2]) :
fp_n :=rhs(Ls[3]) :
7.4.2 Systèmes d’équations

La fonction dsolve permet de traiter de la même façon les systèmes d’équations (avec
conditions initiales ou aux bornes).
> eqnl :={D(x)(t)-x(t)^2+2*y(t)=0,D(y)(t)+x(t)-2*y(t)=0,
> x(0)=1,y(0)=0} ;
> sol :=dsolve(eqnl,{x(t),y(t)},numeric) ;
n o
eqnl := D (x) (t) − (x (t))2 + 2 y (t) = 0, D (y) (t) + x (t) − 2 y (t) = 0, y (0) = 0, x (0) = 1

> sol(0) ;sol(0.1) ;sol(0.5) ;
[t = 0.0, x (t) = 1.0, y (t) = 0.0]
[t = 0.1, x (t) = 1.12302576462700898, y (t) = −0.116830127033903872]

[t = 0.5, x (t) = 2.82877723007522119, y (t) = −1.24673998693011656]
Ayant cette solution, on obtiendra une représentation des fonctions x(t) et y(t) avec odeplot.
On peut, comme pour une équation simple, obtenir les approximations numériques des
solutions sous forme de fonctions.
> sol :=dsolve(eqnl,{x(t),y(t)},numeric,output=listprocedure) :
> xf :=subs(sol,x(t)) ;
> yf :=subs(sol,y(t)) ;
> xf(0.5) , yf(0.5) ;
xf := proc (t) ... endproc
yf := proc (t) ... endproc
2.82877723007522119, −1.24673998693011656}
Chapitre 8
Equations différentielles (cours 2)
8.1 Introduction et rappels

Pour décrire un système physique, nous avons besoin d’information sur l’état du système,
un tel état et généralement traduit par les valeurs de plusieurs fonctions (xi (t), i = 1..n). Si l’on
connait les relations entre les diff(x[i](t),t) et les x[i](t) et t, l’évolution du sytème peut
être décrit par un système d’équations différentielles :
d
xi (t) = f (t, x1 (t), x2 (t), ..., xn (t)) (i = 1..n)
dt
Ce dernier système peut être vu comme une équation du premier ordre dans Rn .
d
X(t) = f (t, X(t))
dt
Lorsque f ne dépend pas de t, on dit qu’on est en précense d’un système autonome ; dans le
cas contraire le système est dit non autonome.
Le comportement qualitatif des solutions d’une équation différentielle de Rn est plus com-
pliqué que celui d’une équation différentielle scalaire. En dimension supérieure, les solutions ont
beaucoup de place pour s’entremeler (par exemple dans R3 une courbe fermé n’englobe rien et
d’autre courbes peuvent se faufiler pour lui tourner autour :
– les équations scalaires, les graphes de leurs solutions dans le plan (t, x)(R2 ).
– les systèmes de R2 , les solutions sont des couples de fonctions (x(t), y(t)) (des fonctions
de R dans R2 ), leurs graphes sont dans l’espace (t, x, y) (R3 ).
Un champ de directions associé à une équation différentielle dtd x(t) = f (t, x(t)) est, en chaque
point (t, x) du plan, la pente f (t, x) qui sera la pente de la tangente au graphe d’une solution
passant par ce point.
Le champ de direction d’une équation différentielle réelle :
d
x(t) = f (t, x(t))
dt
se dessine dans le plan.
Le champ de direction d’un système différentielle 2 × 2 se dessine dans l’espace.
Soit le système différentiel suivant :
d
x(t) = f (t, x(t), y(t))
dt
d
y(t) = g(t, x(t), y(t))
dt
102
Chapitre 8. Equations différentielles (cours 2) 103
dont les solutions sont notées : x(t) = u(t) et y(t) = v(t). Les projections des solutions dans
les plans (t, x) et (t, y), c’est-à-dire les graphes des solutions ne sont pas d’une lecture aisée et
parlantes, comme c’est le cas pur les équations différentielles scalaires.
C’est pour cela qu’on a recours à une autre projection dans le plan des (x, y) appelé (selon
les écoles) plan de phase ou plan d’état ou encore paln dynamique.
La projection d’une solution est la courbe paramétrée x(t) = u(t), y(t) = v(t).
On appelle portrait de phase l’ensemble des projections des solutions dans le plan de phase.
8.2 Exemples d’utilisation de DEplot

Exemple 8.2.1. x0 (t) = kx(t) a pour solution x(t) = cekt
Exemple 8.2.2. Si X ∈ Rn et A ∈ Mn (R). Si A est diagonalisable, ∃P inversible tel que :
D = P AP −1 diagonale
On a alors :
X 0 (t) = P DP −1 X(t)
P −1 X 0 = DP −1 X(t)
On pose : Y = P −1 X(t), on aura alors :
Y 0 (t) = DY (t)
yi0 (t) = αi yi (t)

yi (t) = ci eαi t
On définit l’exponentielle de matrice par :
∞
Aj
eA =
X
j=0 j!
 j 
∞ j ∞
αi
D 1 ...
eD =
X X  
=  
j=0 j! j=0 j!
 
αij
Autrement dit :
αij
∞ 
X
 

j=0 j! 

eD =
 .. 

 . 

 ∞ j


X αi 

j=0 j!
On a aussi : Aj = P Dj P −1 donc :
 
∞ j ∞ j −1 ∞ j
A PD P D  −1
eA =
X X X
= =P P
j=0 j! j=0 j! j=0 j!
eA = P eD P −1
et donc :
X(t) = ceAt = cP eDt P −1
104 Chapitre 8. Equations différentielles (cours 2)
8.2.1 Comportement des solutions d’un système linéaire 2 × 2

Soit un système différentiel X 0 = AX, où A est une matrice 2 × 2 à coefficients costants
et X = V ect(2, [x, y]). nous allons étudier le comportement des trajectiores dans le plans
(x, y) lorsque A est à coefficients réels. L’origine (0, 0) est toujours un point critique (ou point
d’équilibre) c’est le seul si det(A) 6= 0
Rappelons que le polynôme caractéristique det(A − λ id) = λ2 − tr(A)λ + det(A)
8.2.2 Exemples d’utilisation pour le package DETools

> restart ;
> with(LinearAlgebra) :
> with(DETools) :
> F := Matrix(2,2,[[1,0],[0,3]]) ;
 
1 0
F :=  
0 3
> Eigenvectors(F) ;    
3 0 1
 ,  
1 1 0
> phaseportrait({D(x)(t)=x(t),D(y)(t)=3*y(t)},[x(t),y(t)],t=-5..0.5,[[x(0)=1,y(0)=1],
[x(0)=1,y(0)=-1],[x(0)=-1,y(0)=1],[x(0)=-1,y(0)=-1],[x(0)=-0.5,y(0)=2],[x(0)=-0.5,y(0)
,[x(0)=0.5,y(0)=2],[x(0)=0.5,y(0)=-2]]) ;
> dsolve({D(x)(t)=x(t),D(y)(t)=3*y(t)},[x(t),y(t)]) ;
n o
y (t) = _C2 e3 t , x (t) = _C1 et
> simplify(C1*exp(3*t)/(C2*exp(t))) ;
C1 e2 t
C2
> limit(%,t=-infinity) ;
0
On peut ainsi calquer cet exemple pour étudier des systèmes d’équations différentielles.
Chapitre 9
Un peu de programmation
9.1 Procédure récursive

Beaucoup d’idées mathématiques sont définies de manière récursive. Une procédure récursive
est une procédure qui fait appel à elle-même dans le corps de la procédure. Les procédures
récursives jouent un rôle important dans le calcul scientifique, car elles fournissent des solutions
compactes et élégantes à des problèmes de programmation. Le revers de la médaille est que les
procédures récursives ont un prix excessif pendant leur exécution, ces procédures ont tendance
à être lentes et à consommer beaucoup de place de mémoire.
On commence avec un exemple classique : si n entier positif le symbole n! désigne le factoriel
n est défini comme étant le produit de tous les entiers positifs inférieurs ou égal n :
n
Y
n! = k
k=1
Une autre façon de définir n!, une façon recursive est :
n! = n(n − 1)!
Cette définition définit le factoriel en terme de factoriel. Le symbole ! apparit dans les deux
côtés. Suivant pas à pas le calcul de 6! à l’aide cette définition :
6! = 6(5!) = 6(5(4!)) = ... = 6(5(4(3...(1))))
La question qui se pose est comment dire à la machine d’arreter les calculs ; certainement nous
ne voulons pas 6(5(4(3(2(1(0(−1))))))) à l’étape suivante, en plus en appliquant cette formule le
résultat sera nul. Nous devons introduire un moyen pour arrêter la réccurence. Pour le factoriel :
0! = 1. On a alors : 
0! = 1
n! = n(n − 1)!
On peut maintenant implémenter une procédure reccursive MAPLE à l’aide de cette définition :
> restart ;
> factoriel_recursive := proc(n)
> if n=0 then
> 1
> else
> n*factoriel_recursive(n-1)
105
106 Chapitre 9. Un peu de programmation
> fi ;
> end :
Remarquons que nous mimons l’écriture mathématique et que à la cinquième ligne, nous
faisons appel à la procédure elle-même. L’autre partie de la définition apparait en premier, sous
forme d’une structure conditionnelle.
On calcule quelques factoriels à l’aide de cette procédure.
> factoriel_recursive(4) ;
24
3628800
Maple dispose d’une commande "factoriel".
> 10 ! ;
3628800
Malheureusement, la réccurence n’est pas le meilleur moyen d’implementer une procédure.
Par exemple :
> time(factoriel_recursive(10000)) ; time(10000 !) ;
0.408
0.020
La réccurence force MAPLE à utiliser sa mémoire de calcul, que MAPLE n’a plus d’espace
pour stocker les résultats.
Mais la commande native de MAPLE n’a pas de problème pour calculer 77777!
> factoriel_recursive(77777) ; 77777 ! ;
Error, (in factoriel_recursive) too many levels of recursion
285374801531646576303321149251325039281553360034543258119135220654086281392961039063022378
674919885[...346421digits...]0000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000
Voici une astuce qui va nous permettre de visualiser comment fonctionne la procédure
récursive. Dans le corps de la procédure, on va utiliser l’apostrophe "’" pour différer l’évalution
de l’appel de la procédure réccursive.
> restart ;
> if n=0 then
> 1
> else
> n*’factoriel_recursive(n-1)’
> fi ;
> end :
Maintenant l’appel de la procdéure et on réitère l’évalution jusqu’au bout.
6 factoriel_recursive (5)
> %;
Chapitre 9. Un peu de programmation 107
> %;
> %;
> %;
> %;
> %;
720
Voici un autre moyen pour observer la réccurence se déployer. Nous insérons dans la procé-
dure l’option trace, ceci permet de suivre à la trace toutes les étapes de calculs que MAPLE
emprunte.
> restart ;
> option trace ;
> if n=0 then
> 1
> else
> fi ;
> end :
On appelle la procédure et nous avons sous les yeux ce qui se passe.
{–> enter factoriel_recursive, args = 6
1
<– exit factoriel_recursive (now in factoriel_recursive) = 1}
24
120
720
<– exit factoriel_recursive (now at top level) = 720}
720
Lorsqu’on écrit une procédure récursive, il faut toujours évité les boucles infinies. Si l’on
utilise littéralement la définition de factoriel n! = n(n − 1)!, nous avons :
> restart ;
> end :
Error, (in factoriel_recursive) too many levels of recursion
Ca ne marche pas ! Pourquoi la définition mathématique du factoriel n’engendre pas de

réccurence infinie ? Inconsciement, nous avons en tête la règle 0! = 1.
Comme exercice, on peut programmer réccursivement la puissance :
an = aan−1
na = a + (n − 1)a
Quelle est la condition d’arrêt pour ces deux définition ?
Voici un autre exemple, cette procédure ajoute tous les éléments d’une liste, observer la
condition d’arrêt :
> restart ;
> add_liste := proc(x)
> if nops(x) = 0 then
> 0
> else
> x[1] + add_liste(x[2..-1]) ;
> fi ;
> end :
> add_liste([1,2,3,4,5]) ;
15
Voici une version de la procédure add_liste avec une évalution différée de la réccurence.
> restart ;
> add_liste := proc(x)
> 0
> else
> ’’’’’’’x[1]’’’’’’’ + ’add_liste(x[2..-1])’
> fi ;
> end :
Remarquons que nous avons différé plusieurs fois l’évalution du terme x[1] devant l’appel
reccursif de la procédure, pour rendre plus parlant de ce qui se passe.
> add_liste([1,2,3,4,5]) ;
000000
[1, 2, 3, 4, 5][1]000000 + add_liste([1, 2, 3, 4, 5][2.. − 1])
> %;
00000
[1, 2, 3, 4, 5][1]00000 +000000 [2, 3, 4, 5][1]000000 + add_liste([2, 3, 4, 5][2.. − 1])
> %;
0000
[1, 2, 3, 4, 5][1]0000 +00000 [2, 3, 4, 5][1]00000 +000000 [3, 4, 5][1]000000 + add_liste([3, 4, 5][2.. − 1])
> %;
000
[1, 2, 3, 4, 5][1]000 +0000 [2, 3, 4, 5][1]0000 +00000 [3, 4, 5][1]00000 +000000 [4, 5][1]000000 + add_liste([4, 5][2.. − 1])
> %;
00
[1, 2, 3, 4, 5][1]00 +000 [2, 3, 4, 5][1]000 +0000 [3, 4, 5][1]0000 +00000 [4, 5][1]00000 +000000 [5][1]000000 + add_liste([5][2.. − 1])
> %;
0
[1, 2, 3, 4, 5][1]0 +00 [2, 3, 4, 5][1]00 +000 [3, 4, 5][1]000 +0000 [4, 5][1]0000 +00000 [5][1]00000
> %;
[1, 2, 3, 4, 5][1] +0 [2, 3, 4, 5][1]0 +00 [3, 4, 5][1]00 +000 [4, 5][1]000 +0000 [5][1]0000
> %;
1 + [2, 3, 4, 5][1] +0 [3, 4, 5][1]0 +00 [4, 5][1]00 +000 [5][1]000
> %;
3 + [3, 4, 5][1] +0 [4, 5][1]0 +00 [5][1]00
> %;
6 + [4, 5][1] +0 [5][1]0
> %;
10 + [5][1]
> %;
15
Ici nous présentons une version de la procédure add_liste avec l’option trace.
> restart ; > add_liste := proc(x)
> option trace ; > if nops(x) = 0 then > 0 > else > x[1] + add_liste(x[2..-1]) >
fi ; > end : > add_liste([1,2,3,4,5]) ;
{–> enter add_liste, args = [1, 2, 3, 4, 5]
{–> enter add_liste, args = [2, 3, 4, 5]
{–> enter add_liste, args = [3, 4, 5]
{–> enter add_liste, args = [4, 5]
{–> enter add_liste, args = [5]
{–> enter add_liste, args = []
0
<– exit add_liste (now in add_liste) = 0}
5
12
14
15
<– exit add_liste (now at top level) = 15}

On se propose d’écrire une procédure récursive plus_grand. Mais d’abord écrivons une
procédure qui retourne le plus grand élément d’une liste à deux éléments.
> restart ;
> grand := proc(a,b)
> if a>=b then a else b fi ;
> end :
En utilisant la procédure grand, on utilise une version récursive de la procédure plus_grand.
> plus_grand := proc(x)
> grand(x[1],x[2]) ;
> else
> grand(x[1],plus_grand(x[2..-1])) ;
> fi ;
> end :
> plus_grand([1,2,49,29,10,20]) ;
49
On peut tester la procédure plus_grand sur des listes aléatoires.
> L := [seq(rand(),i=0..200)] ;
L := [395718860534, 193139816415, 22424170465, 800187484459
, 427552056869, 842622684442, 412286285840, 996417214180

, 386408307450, 694607189265, 773012980023, 730616292946
, 106507053657, 396412723003, 944913350029, 210936428922
, 750072072199, 454744396973, 736602622344, 329844591802
, 615732069248, 847018765388, 471077852198, 392554592838
, 836404711117, 474259255346, 224085044619, 78606118334
, 720683829593, 559705322288, 759661297346, 430137169252
, 867557918169, 866818474138, 966905297479, 497201520366
, 556157845064, 363627416872, 988383200003, 735342248716
, 627285198089, 610041870015, 36115225337, 49211688700

, 450144918128, 385283366673, 730156545395, 784736497772
, 170269515792, 848067203379, 346921332438, 693953992184
, 914298711176, 450147686083, 352263656572, 819571010915
, 849634041635, 704117256457, 169276113729, 371184667791
, 419107017642, 224017151548, 200840106267, 868571906562
, 570413466477, 992088146026, 44377527460, 478029137226
, 12943051994, 640883156519, 248710237660, 970011783018
, 47051442205, 574575990559, 171744831347, 648830381647
, 411430368778, 97042653864, 771946492543, 247799138370
, 895038201152, 844225460865, 151217500860, 358747328735
, 950923834782, 894868300574, 230179425858, 991986977089
, 597663762096, 431192847449, 147692311310, 660252243043
, 504180068247, 583804136382, 332585592470, 642614553072
, 683413251297, 36386777396, 10051167073, 294333430140
, 561421377608, 927663025828, 806253380205, 403351449011
, 66595608988, 217146110850, 998593597356, 835209967015
, 302995305320, 315454972976, 806828723396, 676451096448
, 906151880584, 446823990522, 274779131434, 791833856435
, 814667333805, 542652940396, 875554316808, 707209828183
, 447247812388, 876097567582, 580230132315, 557495823712
, 185016698632, 127248646797, 463891231054, 311530870548
, 332596541488, 494513950222, 237865308740, 621749865108
, 176267481236, 430583167236, 796736924674, 368605281525
, 785900516576, 16421615963, 194569866737, 923623887777
, 208495133372, 489144059156, 916304813609, 17322756596
, 687894297804, 420380077031, 795472189409, 980424008860
, 276992929180, 546420427938, 517501904412, 145835371329
, 737239591739, 905196585503, 362646618851, 290137415540
, 799092205607, 873263534186, 942337219622, 622376983290
, 213928615501, 632469564945, 623327944498, 504136820595
, 333798286729, 220279445091, 54217242966, 55026579748
, 941940049376, 293714390205, 710146770875, 746533043661
, 260572595535, 559975339975, 203832692104, 173102703917
, 334623328628, 697883299056, 518642168407, 335471571481
, 663115419126, 875615784786, 783233932834, 308881669470

, 543501506147, 537472825200, 782542495312, 377914644627
, 65455627792, 837589578089, 886432352431, 835270800353
, 367392095230, 940677083593, 691061024757, 782519399184
, 654730069341, 649174982459, 864317081744, 59269059083
, 335393236607]
> plus_grand(L) ;
998593597356
On peut donner une version plus_grand différé.
> grand(x[1],x[2]) ;
> else
> ’grand(x[1],plus_grand(x[2..-1]))’ ;
> fi ;
> end :
On teste la version.
> plus_grand([1,2,3,4,5]) ;
grand ([1, 2, 3, 4, 5]1 , plus_grand ([1, 2, 3, 4, 5]2...−1 ))
> %;
Error, (in grand) cannot determine if this expression is true or false : grand([2, 3, 4, 5][1],
plus_grand([2, 3, 4, 5][2 .. -1])) <= 1
On peut arranger ce problème en modifiant la définition de la procédure grand la version

suivante de la procédure grand doit nous retourner des évaluations différées, quand l’argument
n’est de type numérique.
> if type(a,numeric) and type(b,numeric) then
> if a >= b then
> a
> else
> b
> fi ;
> else
> ’grand(a,b)’
> fi ;
> end :
> grand(x[1],x[2]) ;
> else
> ’grand(x[1],plus_grand((x[2..-1])))’ ;
> fi ;
> end :
> plus_grand([1,2,3,4,5]) ;
grand ([1, 2, 3, 4, 5]_1, plus_grand ([1, 2, 3, 4, 5]_2 . . . − 1))
> %;
grand (1, grand ([2, 3, 4, 5]_1, plus_grand ([2, 3, 4, 5]_2 . . . − 1)))
> %;
grand (1, grand (2, grand ([3, 4, 5]_1, plus_grand ([3, 4, 5]_2 . . . − 1))))
> %;
5
On peut utiliser l’option trace dans grand et plus_grand.
> restart ;
> option trace ;
> if type(a,numeric) and type(b,numeric) then
> if a >= b then
> a
> else
> b
> fi ;
> else
> ’grand(a,b)’
> fi ;
> end :
> option trace ;
> grand(x[1],x[2]) ;
> else
> grand(x[1],plus_grand((x[2..-1]))) ;
> fi ;
> end :
> plus_grand([1,2,3,4,5]) ;
{–> enter plus_grand, args = [1, 2, 3, 4, 5]
{–> enter plus_grand, args = [2, 3, 4, 5]
{–> enter plus_grand, args = [3, 4, 5]
{–> enter plus_grand, args = [4, 5]
{–> enter grand, args = 4, 5
5
<– exit grand (now in plus_grand) = 5}
5
<– exit plus_grand (now in plus_grand) = 5}{–> enter grand, args = 3, 5
<– exit grand (now in plus_grand) = 5

5

5

5
<– exit plus_grand (now at top level) = 5}
Si on enlève l’option trace dans grand, on a moins d’informations...

> restart ;
if type(a,numeric) and type(b,numeric) then
> if a >= b then
> a
> else
> b
> fi ;
> else
> ’grand(a,b)’
> fi ;
> end :
> option trace ;
> grand(x[1],x[2]) ;
> else
> grand(x[1],plus_grand((x[2..-1]))) ;
> fi ;
> end :
> plus_grand([1,2,3,4,5])
{–> enter plus_grand, args = [1, 2, 3, 4, 5]
{–> enter plus_grand, args = [2, 3, 4, 5]
{–> enter plus_grand, args = [3, 4, 5]
{–> enter plus_grand, args = [4, 5]
5
<– exit plus_grand (now in plus_grand) = 5}
5
<– exit plus_grand (now at top level) = 5}
9.2 Application
Une fonction f défine sur l’axe réel est dite périodique de période p si 0 < p et f (x+p) = f (x)
pour tout x réel. On remarque que cette définition est presque récursive car f est définie en
terme d’elle-même. Mais cette définition n’est pas réccursive car elle ne contient pas de condition
d’arrêt. Voici comme on adapte cette définition pour en faire une définition recursive. Soit g
une fonction définie sur un intervalle [a, b], a < b et b − a = p. On définit f comme étant le
prolongement périodique de g à l’axe réel :

g(x)

 a ≤ x et x < b
f (x) = f (x − p) b≤x


f (x + p) x<a
La définition de f récursive car f définie en terme de f et g joue le rôle de la condition d’arrêt.

Donnons un exemple précis pour illustrer comment cette définition fonctionne.
> restart ;
> a := 0 ; b :=1 ;
a := 0
b := 1
> p := ’b’-’a’ ;
p := b − a
> g := x->piecewise(a<=x and x<b,4*x^2-4*x+1) ;

4x2 − 4x + 1 −1≤x
g := x 7→ 
otherwise x<1
> g(x) 
4x2 − 4x + 1 −1≤x
otherwise x<1
> f := proc(x) > if a<=x and x<b then
> g(x)
> elif b<=x then
> f(x-p)
> elif x<a then
> f(x+p)
> fi ;
> end :
Maintenant on peut évaluer f
> f(5.5) ; f(-3.5) ; f(127.8) ;

0
0
0.36
Comme f est définie d’une manière recursive, il y a une limite à la valeur de son argument.
> f(1027000.8) ;
Error, (in f) too many levels of recursion
Voici le graphe de g et f
> plot(g(x),x=0..1) ;
> plot(f,-2..2) ;
On peut essayer f pour des fonctions g périodiques.*

> a := -1 ; b := 1 ; g := x -> cos(Pi*x) ;
a := −1
b := 1
g := x 7→ cos (π x)
On remarque que nous n’avons pas à redéfinir f. Nous avons besoin seulement de redéfinir
a,b et g, ensuite f va être automatiquement le prolongement périodique de g avec la période
p=b-a.
> f(2) ;
1
> plot(g(x),x=-1..1) ;
> plot(f,-3..3) ;
Annexe A
Correction du partiel du lundi 31 mars

2008
Remarque. N’oubliez pas de commenter tout ce que vous faites sinon vous perdez des points !
A.1 Enoncé
Exercice 1. Ecrire une procédure ListesPremiers qui pour entier n revoie la liste formée
de deux liste : la première contenant les nombres premiers inférieurs ou égaux à n, la seconde
contenant les entiers non premiers inférieurs ou égaux à n. Il est demandé de ne pas utiliser les
commandes : nextprime, prevprime, ithprime ; seule la commande isprime est autorisée.
Exercice 2. Ecrire une procédure AdditionMatrices qui pour deux matrices renvoie leur
somme si elle existe ou un message d’erreur lorsqu’il y a une incompatibilité.
Exercice 3. On considère sur l’intervalle [0, 1] les polynômes de Bernstein :
n!
Bk,n : x → xk (−x + 1)(n−k) pour k = 0...n
k!(n − k)!
1) Vérifier pour quelques valeurs de n que :

n
X n
X
Bk,n (x) = 1 et que kBk,n (x) = nx
k=0 k=0
2) Ecrire une procédure Bernsteinf qui pour une fonction f et un entier n renvoie le polynôme
de Bernstein associé à f et défini par :
n
!
X k
x→ f Bk,n (x)
k=0 n
3) Afficher sur un même graphe la fonction f et quelques polynômes de Bernstein associés à f .

4) Afficher sur un même graphe les différences entre la fonction f et quelques polynômes de
Bernstein associés à f .
Exercice 4
On se donne dans le plan quatre points A, C, D et F .
118
Annexe A. Correction du partiel du lundi 31 mars 2008 119
Choisir deux points B et E respectivement sur les segments [AC] et [DF ]

On construit les points P , Q, R respectivement intersections des droites (AE) et (BD),
(AF ) et (CD) et (BF ) et (CE).
Le théorème de Pappus affirme que les points P , Q et R sont alignés.
On demande de mettre en place ces constructions au hasard les points A, C, D et F , puis les
points B et E (le choix de la méthode est laissé au candidat). Néamoins, la suite d’instructions
vérifiera l’exactitude des hypothèses.
Afficher la figure correspondant à votre exemple.
A.2 Corrigé
Remarque. Ici, je détaille les commandes utilisés dans la procédure. Ne pas le faire pendant
l’examen.
Exercice 1
Dans cet exercice, on nous demande d’écrire une procédure ListesPremiers qui a un pa-
ramètre n revoie :
– L1 : la liste des nombres premiers inférieurs ou égaux à n
– L2 : la liste des nombres non premiers inférieurs ou égaux à n
Les commandes utilisés :
– isprime(k) renvoie true si k est un nombre premier et f alse sinon.
– print(L1) affiche la liste L1 .
Voici la procédure codée en MAPLE :
ListesPremiers := proc(n)
local L1,L2,k;
L1 := [];
L2 := [];
for k from 1 to n do
if isprime(k) then
L1 := [op(L1),k];
else
L2 := [op(L2),k];
fi;
od;
print(L1);
print(L2);
end:
et un exemple avec n = 100

> ListesPremiers(100) ;
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
[1, 4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22, 24, 25, 26, 27, 28, 30, 32, 33, 34, 35, 36, 38, 39, 40, 42, 44, 45, 46, 48
, 51, 52, 54, 55, 56, 57, 58, 60, 62, 63, 64, 65, 66, 68, 69, 70, 72, 74, 75, 76, 77, 78, 80, 81, 82, 84, 85, 86, 87, 88, 90
93, 94, 95, 96, 98, 99, 100]
Exercice 2
120 Annexe A. Correction du partiel du lundi 31 mars 2008
Attention, dans cet exercice, il faut utiliser le package LinearAlgebra pour définir les
matrices.
Pour additionner deux matrices, il faut au mieux que les deux matrices aient les mêmes
dimensions. Dans la procédure qui va suivre, on doit tester si les dimensions des matrices sont
identiques. AdditionMatrices(A,B) qui prend A et B, deux matrices, en paramètre additionne
A et B si les dimensions de A et B sont égales.
Les commandes utilisés :
– RowDimension(A) retourne le nombre de lignes de A.
– ColumnDimension(A) retourne le nombre de colonnes de A.
– error("Char") renvoie en sortie d’erreur la chaîne de caractère mis en paramètre
La procédure AdditionMatrices
AdditionMatrices := proc(A,B)
if RowDimension(A) <> RowDimension(B) or ColumnDimension(A) <> ColumnDimension(B) then
error("Les dimensions ne sont pas les mêmes");
else
A+B;
fi;
end:
et quelques résultats :
> A := Matrix(3,3,[[a,b,c],[d,e,f],[g,h,i]]) ;
 
a b c
 
A :=  d e f 
 
 
g h i
> B := Matrix(3,3,[[1,1,1],[2,0,1],[1,1,1]]) ;
 
1 1 1
 
B :=  2 0 1 
 
 
1 1 1
> AdditionMatrices(A,B) ;  
a+1 b+1 c+1
 

 d+2 e f +1 

 
g+1 h+1 i+1
> C := Matrix(2,2,[[1,2],[2,1]])
 
1 2
C :=  
2 1
> AdditionMatrices(A,C) ;
Error, (in AdditionMatrices) Les dimensions ne sont pas les mêmes
Exercice 3
Le polynôme de Bernstein est défini comme suivant :
n! xk (−x + 1)n−k
B := (k, n, x) 7→
k! (n − k)!
On doit utiliser le package plots pour tracer les graphiques pour les dernières questions.
1) On vérifie les propriétés :
n
X n
X
Bk,n (x) = 1 kBk,n (x) = nx
k=0 k=0
pour n = 3 et n = 5 :
> n := 3 ;
n := 3
> sum(B(k,n,x),k=0..n) ;
(−x + 1)3 + 3 x (−x + 1)2 + 3 x2 (−x + 1) + x3
> expand(%) ;
1
> sum(k*B(k,n,x),k=0..n) ;
3 x (−x + 1)2 + 6 x2 (−x + 1) + 3 x3
> expand(%) ;
3x
> n := 5 ;
n := 5
> sum(B(k,n,x),k=0..n) ;
(−x + 1)5 + 5 x (−x + 1)4 + 10 x2 (−x + 1)3 + 10 x3 (−x + 1)2 + 5 x4 (−x + 1) + x5
> expand(%) ;
1
> sum(k*B(k,n,x),k=0..n) ;
5 x (−x + 1)4 + 20 x2 (−x + 1)3 + 30 x3 (−x + 1)2 + 20 x4 (−x + 1) + 5 x5 ;
> expand(%) ;
5x
Les propriétés sont donc vérifiées. On peut résumer tout ça dans une procédure et de tester
cette procédure pour tout n entier variant dans un intervalle pas trop grand.
sumBernstein = proc(n)
local S1,S2;
S1 := expand(B(k,n,x),k=0..n);
S2 := expand(k*B(k,n,x),k=0..n);
print([S1,S2]);
end;
2) La procédure qu’on va construire, Bernsteinf, retourne le polynôme de Bernstein associé

à f de degré n.
Voici la procédure :
Bernsteinf := proc(f,n)
local k;
sum(f(k/n)*B(k,n,x),k=0..n);
end:
et un exemple avec f : x 7→ ex
> f := x -> exp(x) ;
f := x 7→ ex
> Bernsteinf(f,5) ;
(−x + 1)5 + 5 e1/5 x (−x + 1)4 + 10 e2/5 x2 (−x + 1)3 + 10 e3/5 x3 (−x + 1)2 + 5 e4/5 x4 (−x + 1) + e1 x5
3) Dans cet question, on veut tracer la fonction f définie précédemment et quelques polynômes
de Bernstein qui lui est associé. Dans mon exemple, j’ai tracé les polynômes de Bernstein
définies par Bernsteinf(f,3) et Bernsteinf(f,5) et la fonction f sur l’intervalle [0, 1] (très
important car les polynômes de Bernstein approxime bien la fonction f sur l’intervalle [0, 1]).
J’ai aussi ajouté une légende pour montrer au correcteur à quoi correspondent les courbes
que MAPLE à tracer.
> plot([f(x),Bernsteinf(f,3),Bernsteinf(f,5)],x=0..1,legend=["f(x)"
,"Bernsteinf(f,3)","Bernsteinf(f,5)"]) ;
4) La question suivante nous demande de représenter graphiquement les différences entre les
polynômes de Bernstein associés à f considéres dans la question précédente et la fonction
f . La commande est la suivante :
> plot([f(x)-Bernsteinf(f,3),f(x)-Bernsteinf(f,5)],x=0..1,legend=[
"f(x)-Bernsteinf(f,3)","f(x)-Bernsteinf(f,5)"]) ;
Exercice 4
Le problème de géométrie de ce partiel est peut-être le plus difficile entre tous. Il demandait
premièrement la mise en place d’une construction géométrique totalement aléatoire (notamment
le placement des points A, B, C, D, E, F ), deuxièment, l’interprétation de ce qu’on a construit
et enfin, la visualisation de la figure à la fin.
> restart ;
> with(geometry) :
Pour générer des points aléatoires dans un domaine de R2 , il fallait utiliser la commande
randpoint qui s’utilise de la manière suivante :
> randpoint(A,-10..10,-10..10) :
> randpoint(C,-10..10,-10..10) :
> randpoint(D2,-10..10,-10..10) :
> randpoint(F,-10..10,-10..10) :
Ici, on a remplacé D par D2 car D est reservé pour l’opérateur différentiel. Ensuite, on
construit les points B et E qui sont sur les segments [A, C] et [D2, F ] :
> OnSegment(B,A,C,2) :
> OnSegment(E,F,D2,2) :
On trace maintenant toutes les droites qui passent par certains points qu’on a tracé, utiles
pour la suite de la construction géométrique :
> line(AE,[A,E]) :
> line(BD2,[B,D2]) :
> line(AF,[A,F]) :
> line(CD2,[C,D2]) :
> line(BF,[B,F]) :
> line(CE,[C,E]) :
On trace enfin P , Q et R qui sont respectivement intersections des droites (AE) et (BD),
(AF ) et (CD) et (BF ) et (CE).
> intersection(P,AE,BD2) :
> intersection(Q,AF,CD2) :
> intersection(R,BF,CE) :
Le théorème de Pappus dit que P , Q et R sont alignés. Vérifions-le :
> AreCollinear(P,Q,R) ;
true
Mais peut-être que le test est faux. Ceci est dû à la précision de MAPLE. Il faudra aisni
faire le dessin de P , Q et R en montrant qu’ils sont effectivement bien sur une même droite.
Pour conclure, on peut tracer la figure géométrique qu’on a construit :

> draw({A,B,C,D2,E,F,AE,AF,BD2,CD2,BF,CE,P,Q,R}) ;
Annexe B
TP d’entrainement pour l’examen
B.1 Transformation d’un nombre en une liste et vice et

versa
Le but de ce TP est de voir comment on peut transformer une liste de chiffres en un nombre
et vice et versa.
Question B.1.1. Ecrire une procédure listeennombre qui a comme paramètre L une liste de
chiffres entre 0 et 9 et qui renvoie le nombre entier positif composé par les chiffres de L. Par
exemple, listennombre([1,2,3,4]) renvoie comme résultat 1234.
Question B.1.2. Ecrire une procédure nombreenliste qui a comme paramètre n un nombre
entier positif et qui renvoie la liste L des chiffres que composent n. Par exemple, nombreenliste(1234)
renvoie comme résultat [1, 2, 3, 4]
B.2 [Plus difficile] Groupes de permutations

On appelle le groupe de n-permutation Sn , l’ensemble des bĳections de {1, ..., n} à {1, ..., n}.
On peut représenter une permutation comme suivant :
!
1 2 3 ··· n
(P )
σ(1) σ(2) σ(3) · · · σ(n)
Question B.2.1. Par défaut, MAPLE restreint la taille d’un tableau ou d’une matrice (c’est-
à-dire que MAPLE affiche complétement les tableaux ou matrices de tailles 10 × 10 et mets
quelques informations pour les tableaux/matrices de taille supérieure). Rechercher dans le cours
la commande qui permet de définir la taille maximale d’affichage d’un tableau/matrice.
Question B.2.2. Ecrire une procédure supp_element_liste qui prend en paramètre une liste
L et un nombre k tel que k est inférieur ou égale à la taille de la liste. Cette procédure aura
pour effet d’enlever le kième élément de la liste L.
Une liste peut représenté la permutation dans Sn . Par exemple :

> L := [1,3,2,5,4,6]
L est une permutation dans S6 mais par contre :
> S := [1,3,2,3,5,6]
S n’est pas une permutation dans S6
125
126 Annexe B. TP d’entrainement pour l’examen
Question B.2.3. Ecrire une procédure ispermu qui prend en paramètre une liste L et qui
renvoie true si L représente effectivement une permutation dans Snops(L) et f alse sinon
Après avoir testé si L est une permutation, on peut construire une matrice de deux lignes.
Sur la première ligne contient les nombres de 1 à n et sur la deuxième, la permutation (comme
plus en haut).
Question B.2.4. Ecrire une procédure matpermu qui prend en paramètre un nombre entier n
et qui renvoie une matrice de permutations de Sn . Bien sûr, il faut que la deuxième ligne de la
matrice représente une permutation.
Un théorème dit que toute permutation est le produit de cycles de disjoints. Par exemple :
!
1 2 3 4 5 6
= (56)(123)
2 3 1 4 6 5
On a ainsi :
!
1 2 3 4 5 6
(123) =
2 3 1 4 5 6
!
1 2 3 4 5 6
(56) =
1 2 3 4 6 5
Question B.2.5. Ecrire une procédure DecompCyclesDisjoints qui prend comme paramètre
M une matrice de permutations définie par la procédure matpermu et qui renvoie la décompo-
sition en cycles disjoints de la permutation (la décomposition en cycles disjoints pourra être
sous la forme d’une liste de listes).
Une transposition est une application τ qui échange seulement deux éléments dans l’inter-
valle [|1, ..., n|]. Exemple, dans S6 :
!
1 2 3 4 5 6
τ1,4 =
4 2 3 1 5 6
Un autre théorème dit que toute permutation est le produit de transpositions.

Question B.2.6. En utilisant DecompCyclesDisjoints, écrire une procédure DecompTransposition
qui prend comme paramètre M une matrice de permutation et renvoie la décomposition en
transpositions de la permutation (la décomposition de transpositions pourra aussi être sous la
forme d’une liste de listes).
On a ainsi des décompositions de permutations en transpositions ou en cycles disjoints mais
on peut faire l’inverse : on peut à partir d’un ensemble de transpositions ou de cycles disjoints
reconstruire la matrice de permutations qui lui est associé.
Question B.2.7. Ecrire une procédure RecompTransposition qui prend comme paramètre
L une liste de transpositions et renvoie la matrice de permutations qui lui est associé. Par
exemple,
> RecompTransposition([[1,4],[2,3],[3,2],[4,1]])
!
1 2 3 4
4 3 2 1

M210: Calcul Scientifique

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

M210: Calcul Scientifique

Transféré par

Droits d'auteur :

Formats disponibles

Université des Sciences et Technologies de Lille

U.F.R. de Mathématiques Pures et Appliquées

M210 : Calcul scientifique

Notes de cours par Clément Boulonne

L2 Mathématiques 2007 - 2008

7.2.5 Développement en série de la solution . . . . . . . . . . . . . . . . . . . . 95

8 Equations différentielles (cours 2) 100

9 Un peu de programmation 103

A Correction du partiel du lundi 31 mars 2008 116

B TP d’entrainement pour l’examen 123

1.2.1 Barre de commandes

1.2.2 Barre d’outils

1.2.3 La feuille MAPLE

1.3 Objets MAPLE

[integer, f raction, f loat]

map est la commande d’attribution.

1.3.2 Autres objets

1.3.3 Affectation pour les variables

1.3.4 Listes et ensembles

[11, 12, 13, 20]

1.3.5 Tables et tableaux

t := table([1 = 10, 2 = 11, 3 = 12, 5 = 14, 4 = 13, 6 = 15])

1.4 Premières commandes en Maple

1.4.2 Bibliothèques (librairies ou packages)

1.4.3 Manipulation d’expression

Ici, la commande ifactor(n) permet d’avoir la décomposition en facteurs premiers de n.

x5 − 15 x4 + 85 x3 − 225 x2 + 274 x − 120

devel := sin (a) cos (b) + cos (a) sin (b)

1.4.4 Arranger, simplifier

a := 1 + 6 x + 126 x5 + 90 x8 + 126 x7 + x12 + 6 x11 + 21 x10 + 50 x9 + 141 x6 + 21 x2 + 90 x4 + 50 x3

x12 + 6 x11 + 21 x10 + 50 x9 + 90 x8 + 126 x7 + 141 x6 + 126 x5 + 90 x4 + 50 x3 + 21 x2 + 6 x + 1

La commande sort permet d’ordonner un polynôme en fonction de sa variable.

B := cos(x+y) ; op([1,1],B) ; op([0,1],B) ; op([1,0],B) ; op([1,2],B) ;

> algsubs(sin(x)^2 = 1-cos(x)^2,f) ;

sin (x) − cos (x) + 2 (cos (x))3

> subs(sin(x)^2 = 1-cos(x)^2,f) ;

1.5 Eléments de programmation

f := x → if 0 < x then ln (x) else 0 endif

> f(2) ; f(-2) ; ;

1.5.2 $ : variation de la variable

0.09983341665, 0.009999833334, 0.0009999998333, 0.00009999999983,

0.00001000000000, 0.000001000000000, 0.0000001000000000, 0.00000001000000000,

1.5.4 Résolution d’équations

1.5.5 Structure de controle conditionnelle

proc ... RETURN ... end

La ligne de commande proc ne contient pas de virgules.

"Bonjour", Clément, "on est le ", jeudi

1.6.1 Variables locales et variables globales

> print("On compte ",comp," diviseurs de ",n) ; > end ;

2.1.1 Les courbes du plan

Une syntaxe plus simple :

Maple permet de tracer des courbes paramétrées (attention aux crochets).

On peut faire figurer plusieurs courbes sur un même graphique

On peut aussi définir les couleurs de la courbes

les formes de la courbe :

Maple permet de représenter des fonctions plus compliquées :

où ρ est le rayon polaire et θ l’angle polaire.

> polarplot(sin(7*theta/3),theta=-3*Pi..3*Pi,scaling = constrained) ;

2.1.2 Surfaces dans l’espace

Nappe paramétree à l’aide de la syntax :

On peut aussi créer des courbes en coordonnées cynlidriques :

> with(plots) : cylinderplot(z^2,theta=0..2*Pi,z=1..2) ;

Nappe paramétrée en coordonnées cylindriques :

> polarplot(sin(7theta/3),theta=-3Pi..3*Pi,scaling = constrained) ;

> contourplot3d([r,t,(r-1/r)sin(t)-ln(r)], r=1..4, t=0..2Pi, coords=cylindrical,

> eqnl :={D(x)(t)-x(t)^2+2y(t)=0,D(y)(t)+x(t)-2y(t)=0,x(0)=1,y(0)=0} ;