m210 : calcul scientifique

Université des Sciences et Technologies de LilleU.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 31.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.2 Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.2.1 Barre de commandes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.2.2 Barre d’outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.2.3 La feuille MAPLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.3 Objets MAPLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.3.1 Les nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.3.2 Autres objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.3.3 Affectation pour les variables . . . . . . . . . . . . . . . . . . . . . . . . 61.3.4 Listes et ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61.3.5 Tables et tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.4 Premières commandes en Maple . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.4.1 Conseils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.4.2 Bibliothèques (librairies ou packages) . . . . . . . . . . . . . . . . . . . . 81.4.3 Manipulation d’expression . . . . . . . . . . . . . . . . . . . . . . . . . . 81.4.4 Arranger, simplifier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.4.5 Substitution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

1.5 Eléments de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101.5.1 Représentation de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . 101.5.2 $ : variation de la variable . . . . . . . . . . . . . . . . . . . . . . . . . . 111.5.3 Booléens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121.5.4 Résolution d’équations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121.5.5 Structure de controle conditionnelle . . . . . . . . . . . . . . . . . . . . . 121.5.6 Print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

1.6 Procédure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131.6.1 Variables locales et variables globales . . . . . . . . . . . . . . . . . . . . 13

2 Graphisme et géométrie 162.1 Graphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.1.1 Les courbes du plan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162.1.2 Surfaces dans l’espace . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222.1.3 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252.1.4 Animations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302.1.5 Autres options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

2.2 Géométrie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372.2.1 Définitions et manipulation . . . . . . . . . . . . . . . . . . . . . . . . . 38

2.3 Tests géométriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

2

3 Algébre linéaire 443.1 Vecteurs et matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

3.1.1 Construction élémentaire . . . . . . . . . . . . . . . . . . . . . . . . . . . 443.1.2 Assignation et extraction . . . . . . . . . . . . . . . . . . . . . . . . . . . 473.1.3 Affichage de grandes matrices . . . . . . . . . . . . . . . . . . . . . . . . 503.1.4 Génération automatique des composantes . . . . . . . . . . . . . . . . . . 513.1.5 Types et opérandes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513.1.6 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

3.2 Algébre Linéaire élémentaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603.2.1 Opérations élémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . 603.2.2 Autres opérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623.2.3 Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663.2.4 Recherche de valeurs propres . . . . . . . . . . . . . . . . . . . . . . . . . 673.2.5 Recherche de vecteurs propres . . . . . . . . . . . . . . . . . . . . . . . . 68

4 Approximation 694.1 Sens étymologique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 694.2 Interpolation polynômiale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

4.2.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 704.2.2 Formulation du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . 704.2.3 Résultat d’expérience . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 704.2.4 Gestion de l’erreur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

4.3 Autres interpolations polynomiales . . . . . . . . . . . . . . . . . . . . . . . . . 734.3.1 Approximation au sens des moindres carrés (cas discret) . . . . . . . . . 734.3.2 Approximation au sens des moindres carrés (cas continu) . . . . . . . . . 73

4.4 Polynômes trigonométriques : séries de Fourier . . . . . . . . . . . . . . . . . . . 744.4.1 Approximation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 744.4.2 Illustration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

5 Intégration 755.1 Régle des trapèzes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

5.1.1 Exemples introductifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 755.1.2 La régle des trapèzes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

5.2 La régle de Simpson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 825.2.1 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

6 "Révisions" 846.1 expand-simplify-normal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 846.2 Séquences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 846.3 sum et product . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 856.4 Construction de tables de groupes avec array . . . . . . . . . . . . . . . . . . . . 86

7 Equations différentielles 887.1 Fonction dsolve, équations différentielles et conditions initiales . . . . . . . . . 887.2 Divers aspects de l’intégration des équations différentielles . . . . . . . . . . . . 91

7.2.1 Résolution par transformations intégrales . . . . . . . . . . . . . . . . . . 917.2.2 Fonctions discontinues définissant les équations différentielles . . . . . . . 917.2.3 Solutions explicites et implicites . . . . . . . . . . . . . . . . . . . . . . . 927.2.4 Classes des équations différentielles . . . . . . . . . . . . . . . . . . . . . 94

4

7.2.5 Développement en série de la solution . . . . . . . . . . . . . . . . . . . . 957.2.6 Equations linéaires homohènes à coefficients polynomiaux . . . . . . . . . 96

7.3 Système d’équations différentielles . . . . . . . . . . . . . . . . . . . . . . . . . . 967.4 Résolutions numériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

7.4.1 Création d’une procédure (fonction) solution . . . . . . . . . . . . . . . . 987.4.2 Systèmes d’équations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

8 Equations différentielles (cours 2) 1008.1 Introduction et rappels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1008.2 Exemples d’utilisation de DEplot . . . . . . . . . . . . . . . . . . . . . . . . . . 101

8.2.1 Comportement des solutions d’un système linéaire 2× 2 . . . . . . . . . 1028.2.2 Exemples d’utilisation pour le package DETools . . . . . . . . . . . . . . 102

9 Un peu de programmation 1039.1 Procédure récursive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1039.2 Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

A Correction du partiel du lundi 31 mars 2008 116A.1 Enoncé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116A.2 Corrigé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

B TP d’entrainement pour l’examen 123B.1 Transformation d’un nombre en une liste et vice et versa . . . . . . . . . . . . . 123B.2 [Plus difficile] Groupes de permutations . . . . . . . . . . . . . . . . . . . . . . . 123

Chapitre 1

Introduction à Maple

1.1 IntroductionMAPLE 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 InterfaceL’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 debase, il existe des bibliothèques crées par les utilisateurs qui permettent de faire plus de choseque normalement. Bien que développé au Canada, l’interface de MAPLE est en anglais. Commetout 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 ouexporter un document sous un autre format.• Edit : permet d’atteindre les fonctions de copier/coller, de rechercher un terme dans lafeuille MAPLE et le modifier.• View : zoomer sur la feuille• Insert : permet d’insérer des commandes maples grâce à > (chevron), du texte, des sectionsou des sous-sections• Format : changer la police de caractères.• Tools• Window : il est conseillé de travailler sur plusieurs fenetres (une de brouillon et unenormale). 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’outilsC’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, despolices, d’aligement).

1.2.3 La feuille MAPLELa 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 commandesMaple 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 ;

55413

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 a

btel que

PGCD(a, b) = 1. Ici comme PGCD(41, 3) = 1 alors 413 n’est plus simplifiable donc renvoie le

même résultat que ce qu’on a indiqué 413 . 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, fraction, float]

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 .. Unevirgule , 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 nombrede 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 lenombre 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 objetsOn 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 cesymbole, dito).


1.3.3 Affectation pour les variablesOn peut assigner des variables grâce à la commande :=.

> whattype(a) ; a :=5 ; whattype(a) ; assigned(b) ; assigned(a) ;

symbol

a := 5integer

false

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

false

– 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

false

1.3.4 Listes et ensemblesDans 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

1212

l[2] et op(2,l) permet de trouver un élément de la liste. On peut aussi assigner à une variableune 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. Elleest 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 enordre rigoureusement la suite de nombres tapée par l’utilisateur. On peut convertir une liste enun 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])

10symbol

Pour atteindre une valeur du tableau, on utilise la notation []. On peut aussi assigner untableau de variables quelconques.> t := array(1..6), whattype(t) ; eval(t) ;

t := array(1..6, [])

symbol

[′?′1,′ ?′2,′ ?′3,′ ?′4,′ ?′5,′ ?′6]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 Conseils1. Enregistrer régulièrement votre travail, les problèmes arrivent toujours au mauvais mo-

ment2. 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 additionnelsgrâce à la commande with(Bibliothèque).

1.4.3 Manipulation d’expressionOn 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 − 15x4 + 85x3 − 225x2 + 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 pasdévelopper certaines expression :> expand(1/(x+2)ˆ3)

1(x+ 2)3

Alors que :> 1/(expand((x+2)ˆ3))

1(x3 + 6x2 + 12x+ 8)

Ici, Maple developpe le polynôme au dénominateur. Pour la trigonométrique, Maple neconnait 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, simplifierOn peut aussi développer, factoriser, arranger et simplifier des expressions.

> a := expand((x^2+x+1)^6) ;

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

> sort(a,x) ;

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

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

1.4.5 SubstitutionOn 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 fonctionsOn 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 expression(x1, ..., xn)".> f := x -> exp(-x^2) ;

f := x 7→ e−x2

> f(0) ;1

> diff(f(x),x) ;−2xe−x2

> f(y) ;f(x[i]) ;e−y

2


e−xi2

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) ;

f := e−x2

> f(0) ;e−x

2 (0)

> g := unapply(f,x) ;g := x 7→ e−x

2

> 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éensIl y a trois types d’expressions booléens1. or : “ou2. and : “et3. not : “non

et trois résultats :1. true : “vrai2. false : “faux3. FAIL : “échec

Il y a aussi des connecteurs binaires comme <,<=,>,>=,<>,=.

1.5.4 Résolution d’équationsOn 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 := 1true

1.5.5 Structure de controle conditionnelleCe sont une structure qui se déclenche quand une condition ou des conditions sont vérifiés.

Elle s’écrit comme çaif ... then ... else ... fi ;

i := 9 ;if irem(i,2) = 0 theni := i/2 ;elsei := 3*i+1 ;fi ;

i := 9i := 28

1.5.6 PrintLa commande print force Maple à mettre le résultat.

> i := 1 : j :=y : k :=3 : print(i,j,k) ;

i := 1j := y

k := 31, y, 3


1.6 ProcédureUne 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ées4. 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 globalesOutre 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 doif floor(n/i) = n/i thenprint(i, " est un diviseur de ", n) ;


comp := comp+1end ifend 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 ;> 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 ;Warning, ‘i‘ is implicitly declared local to procedure ‘iter‘iter := proc(n)local comp, i ;comp := 0 ;for i to n doif floor(n/i) = n/i thenprint(i, " est un diviseur de ", n) ;comp := comp+1end ifend do ;print("On compte ", comp, " diviseurs de ", n)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 ;> 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 i ;global comp ;comp := 0 ;for i to n doif floor(n/i) = n/i thenprint(i, " est un diviseur de ", n) ;comp := comp+1end ifend do ;print("On compte ", comp, " diviseurs de ", n)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ésgraphiques 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 lignede 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’aidede 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 < 10 x ≤ 3

− sin (3x) + 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 syntaxessuiantes :

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 displayde 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,cyan,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 pointspar 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). PourHELVETICA 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 AnimationsMaple 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 optionsInequal

Après le changement de plots, la commande inequal permet de visualer les solutions d’unsystè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 labibliothè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 syntaxeest :

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 estpossible 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,grid=[10,10]) ;


> 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 ; lasyntaxe 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 deshistogrammes ; 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, onutilise 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) ;

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étrieOn 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 manipulationLes 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 Aform of the object point2dcoordinates 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) ;

Apoint2d[−2,−3]

> VerticalCoord(A) ;−3

Droites Syntaxe :

line(l,[A,B]) ; # Définit par deux droitesline(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) ;FAIL

Procédure :

form(l) # Désigne la forme de l’objet lEquation(l) # Désigne l’équation de la droite l

HorizontalName(l) # Désigne le nom de l’axe des abscissesVerticalName(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) ;

x

y

> detail(l) ;l

line2d−3− 3 x+ 2 y = 0

> line(ll,2*x-5*y) :> Equation(ll) ;

2x− 5 y = 0


Triangles Syntaxe :

triangle(nom,[p1,p2,p3]) ; # Défini par trois pointstriangle(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

bAline2d(

−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,1) :> square(Qu,[A,B,C,F]) ;

Qu

> diagonal(Qu) ; detail(Qu) ;sqrt (5)


>

Qusquare2d

[[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 polygform of the object RegularPolygon2dthe side of the polygon 2 sin

(π5

)the center of the polygon [0 , 0]the radius of the circum-circle 1the radius of the in-circle cos

(π5

)the interior angle 3π

5the exterior angle 2π

5the 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 pointscircle(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 C1form of the object circle2dname of the center center_C1coordinates of the center [−1, 2]radius of the circle

√5

equation of the circle _x2 + _y2 + 2 ∗ _x− 4 ∗ _y = 0

> circle(C2,[center(C1),radius(C1)]) ;

C2

> Equation(C2) ;m2 + n2 + 2m− 4n = 0


2.3 Tests géométriquesIl 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]) : intersection(At,BC,M1) :triangle(T1,[At,B,C]) :> rotation(R2,C,t,clockwise,A) : PerpenBisector(M2,A,C) : line(AC,[C,R2]) : intersection(Bt,AC,M2) :triangle(T2,[A,Bt,C]) :> rotation(R3,A,t,clockwise,B) : PerpenBisector(M3,A,B) : line(AB,[A,R3]) : intersection(Ct,AB,M3) :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/2

√3(5 + 3

√3)

15 + 16√

3, 1/2 39

√3 + 17

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 anciennesstructures 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èreconsiste en une écriture symbolique de la suite (sequence) des composantes du vecteur entouréedes caractères < et >> with(LinearAlgebra) :> v := <1,2,3>

v :=

123

> whattype(v) ;

Vectorcolumn

Les matrices sont définies colonne par colonne en juxtaposant les "vecteurs colonnes" avecle caractère | et entourant le tout par < et >> M := <<1,2,3>|<4,5,6>|<7,8,9>> ;

M :=

1 4 72 5 83 6 9

> MM := <M|<-1,2,1>> ;

MM :=

1 4 7 −12 5 8 23 6 9 1

46

Chapitre 3. Algébre linéaire 47

> MMM := <M|<-1,-2,3>|<-4,-5,-6>> ;

MMM :=

1 4 7 −1 −42 5 8 −2 −53 6 9 3 −6

> N := <<a,b,c>|<d,e,f>|<g,h,i>> ;

N :=

a d g

b e h

c f i

> MN := <M|N> ;

MN :=

1 4 7 a d g

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]) ;

V :=

123

> M := Matrix([[1,2,3],[4,5,6],[7,8,9]]) ;

M :=

1 2 34 5 67 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 34 5 67 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) ;

v, vv := 0

0

,

111

Pareil pour des matrices :

M,MM := Matrix(2,4),Matrix(2,4,1) ;

M, MM := 0 0 0 0

0 0 0 0

, 1 1 1 1

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’iln’existe pas de deuxième paramétre, c’est une matrice carrée nullle de taille de le premièrevariable.> Matrix(3,-1) ; Matrix(3) ; Matrix(3,1) ;

−1 −1 −1−1 −1 −1−1 −1 −1

0 0 00 0 00 0 0

000

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 des0.> 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][1 2 3 4 5 6

]Quelques commandes d’opérations sur la matrice.

> M := Matrix(3,3,4) ;

M :=

4 4 44 4 44 4 4

> Determinant(M) ;

0> Permanent(M) ;

384On peut convertir une matrix et Matrix

> convert(matrix(2,3,2),Matrix) ; 2 2 22 2 2

> whattype(%) ;

Matrix

3.1.2 Assignation et extractionOn peut extraire des éléments d’un vecteur et d’une matrice.

> v := <a,b,c,d> ; # Pour des vecteursa

b

c

d

> v[2] ; v[2..3] ;

b


b

c

> whattype(v[2]) ;

symbol

> whattype(v[2..3]) ;Vectorcolumn

> v[-3..3] ; b

c

> whattype(%) ;

Vectorcolumn

> M := <<a,b,c,d> | <a,b,c,e> | <a,b,c,0>> ; # Pour des matrices

M :=

a a a

b b b

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] ;

C := b b

c c

> whattype(B) ; whattype(C) ;

symbol

Matrix

> AA := M[1..2,1..1] ; BB := M[1..2,1] ;

AA := a

b

BB := a

b

> whattype(AA) ; whattype(BB) ;

Matrix

Vectorcolumn

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 := [−α, α]

v2...3 :=[

[−α, α]]

a

[−α, α]0d

>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 ;

M2...3,1...2 := a c

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 matricesQuand 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 à diversoptions.> M_grande := Matrix(25,25,4) ; # Faire un clic droit pour accéder aux options

M_grande :=

" 25 x 25 " (Matrix)

"Data Type : " anything"Storage : " rectangular"Order : "Fortran_order

> M_grande := RandomMatrix(25,25) ; # Faire un clic droit pour accéder aux options

M_grande :=

"25 x 25 " (Matrix)

"Data Type :" anything"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 utiliserala 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 pasaffichés.> M := Matrix(4,0) ;

M :=

" 4 x 0 " (Matrix)

"Data Type :" anything"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 composantesLes 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 valeurs1,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 !) ;

v_1, v_2 :=

−14−9

,

11/2 t1/6 t2

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]−14−9

11/2 t1/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 lesdeux variables devant la flèche)> M := Matrix(2,3,(i,j)->(-1)^(i+j)*(i+j)) ;

M := 2 −3 4−3 4 −5

> M := Matrix(2,3,(i,j)->(-1)^(i+j)*x^(i+j)) ;

M := x2 −x3 x4

−x3 x4 −x5

3.1.5 Types et opérandes

La fonction Vector admet une option, orientation qui définit la carctéristique column ourow, c’est-à-dire colonne ou ligne. L’orientation par défaut est column (voir aussi la fonctionTranspose 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 !) ;

l_1, l_2 :=[

1 2 3],[

1 1/2 t 1/6 t2]

ou encore> <1|2|t|t^2/2> ; [

1 2 t 1/2 t2]


Les vecteurs construits précédement ont le type Vector auquel est associé la caractéristiquerow ou column.> v_1 ; whattype(v_1) ; Transpose(v_1) ; whattype(%) ;

−14−9

Vectorcolumn[−1 4 −9

]Vector row

Attention aux Majuscules, Maple ne signifie pas d’erreur de syntaxe car les types vectoret matrix existent aussi.> type(M,matrix) ; type(v_1,vector[column]) ;

false

falseLes 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 duvecteur, la seconde l’ensemble des composantes. La troisième donne d’autres caractéristiquessur 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 latroisiè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]) ;

3

Vectorcolumn, 3, {1 = −1, 2 = 4, 3 = −9} , datatype = anything,storage = rectangular , order = Fortran_order , shape = []

exprseqanything

Il est de même pour les matrices. La première opérande (qui est ici la suite 2,3) donne lenombre de lignes puis le nombre de colonnes.> nops(M) ; op(M) ; op(1,M) ;

32, 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, 3L’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) ;Vectorcolumn

MatrixPour 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 etMatrixOptions.> 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’utiliserla nouvelle forme, sauf pour raison de compatibilité.> v_ancien := vector([1,2,3]) ;

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 Optionsshape

L’option shape permet de caractériser le ”profil" d’une matrice. L’option identity créeune 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) ;

Id :=

1 0 0 00 1 0 00 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) ;

S :=

−λ 0 0 00 −λ 0 00 0 −λ 0

[scalar−λ]

Ici aussi, toute tentative pour changer un des éléments, même diagonal, ferait perdre à lamatrice 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 matricediagonale identique à la précédente, elle n’aura pas pour autant la caractéristique scalar−λ etles modifications des composantes seront possibles.> Sp := lambda*Id ; MatrixOptions(Sp,shape) ;

Sp :=

λ 0 0 00 λ 0 00 0 λ 0

[]

> Sp[2,2] := x ; Sp ;Sp2,2 := xλ 0 0 00 x 0 00 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 etprotégé par MAPLE, Dérivation)Di := Matrix(3,4,-1,shape=diagonal) ;

Di :=

−1 0 0 00 −1 0 00 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

Di3,3 := 2


−1 0 0 00 −1 0 00 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) ;

v :=

2−1123

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 à partird’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 lamatrice.> 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) ;

M, Ma :=

a b c

d e f

i j k

,a d i

d e j

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écessitepas la construction d’une matrice intermédiaire. Pour la troisième forme, se reporter auparagraphe suivant relatif à l’option scan.> Mb,Mc,Md := Matrix(M,shape=symmetric), Matrix(Matrix(L),shape=symmetric),Matrix(Matrix(L,scan=columns),shape=symmetric) ;

Mb, Mc, Md :=

a b c

b e f

c f k

,a b c

b e f

c f k

,a d i

d e j

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 estinterprétée par défaut comme une ligne de matrie. On peut modifier cette interprétation avecl’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 00 β 00 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 dela matrice ne sont pas renseignés.> Matrix([a,b,c],scan=diagonal) ; Matrix([a,b,c]) ;

a 0 00 b 00 0 c

[a b c

]fill

Cette option permet de compléter les termes manquants dans la liste de listes par un termefixé. Les dimensions sont ici fixés par défaut par les listes des éléments (on rappelle que $ estl’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

α β γ δ

t2 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 := Xa 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éesde la liste et les éléments de celle-ci sont remplacées par des 0. Ainsi l’élément (1,3) est nulainsi 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 00 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 lesdimensions de la matrice (qui n’est pas carrée bien que triangulaire) sont définies par la taillemaximale des bandes données en entrée et que les éléments manquants sont remplacés par lavaleur 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 0x y 0 0 0Z 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 vecteurou 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]) ;

v_exotique :=

1−1 . . . 3e−t

12

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) ;

v :=

000

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 nombresentiers 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) ;

v1, v2 :=

12

3/21.414213562

,

1.02.0

1.500000000000000001.41421356200000004

evalhf : Precision liée au processeur (plus précis que evalf)> evalhf(-1/2) ; evalf(-1/2) ;

−0.500000000000000000

−0.5000000000On 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)

T :=

−1 1 X X

_ −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émentsne 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 ;

M := 1 2−1 3

2

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êmepour les vecteurs).


> A :=Matrix([[1,2],[0,-1]]) :> B :=A :> A,B ; 1 2

0 −1

, 1 2

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 depointer sur le même tableau de données (une mêm structure rtable). Autrement dit, on créedeux symboles, A et B, pour une même matrice.> A[2,1] :=-3 :A,B ; 1 2

−3 −1

, 1 2−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 souventles 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

A := 1 0 0

0 2 0

B := 1 0 0

0 2 0

−1 0 0

0 2 0

, 1 0 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émentairesL’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 desvecteurs pour les exemples qui vont suivre.> v1,v2 := Vector(3,1),Vector(3,2) ; v1+v2 ;

v1, v2 :=

111

,

222

333

> M1,M2 := Matrix(3,3,(i,j) -> i^2-j^2), IdentityMatrix(3) ; M1+M2 ;

M1, M2 :=

0 −3 −83 0 −58 5 0

,

1 0 00 1 00 0 1

1 −3 −83 1 −58 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 vecteurdont 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 −2415 −24 −89

1 0 00 1 00 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érentesError, (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 matricesError, (in rtable/Product) invalid arguments> # et pleins d’autres

Cependant, la logique n’est pas toujours évidente et doit inciter à la prudence. Ainsi MAPLEautorise l’addition d’un scaire à une matrice, mais l’opération consiste à ajouter à la matrice leproduit de ce scalaire avec l’identité.> M1, M1-3, M1-3*Matrix(3,shape=identity) ;

0 −3 −83 0 −58 5 0

,−3 −3 −83 −3 −58 5 −3

,−3 −3 −83 −3 −58 5 −3

Il sera cependant facile d’écrire pour ajouter -3 à chacun des éléments de M1.

> M1+Matrix(3,3,-3) ; −3 −6 −110 −3 −85 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−213

0 −3 −83 0 −58 5 0

> v1.M1 ;Error, (in LinearAlgebra :-VectorMatrixMultiply) invalid input : LinearAlgebra :-VectorMatrixMultiplyexpects 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érationsAdd, 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 commeindiqué au paragraphe précédent. Il sera donc inutile de les appler explicitement sauf si l’onsouhaite pouvoir utiliser les options de ces fonctions (on en donnera quelques exemples et oncomplé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

M1, M2 := 1 2

3 4

, −1 3−2 1


0 51 5

, 0 5

1 5

> MatrixMatrixMultiply(M1,M2) , M1.M2 ; # 2 écritures identiques −5 5

−11 13

, −5 5−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 évidemmentlié à un souci d’économie de l’espace mémoire de l’ordinateur quand on travaille avec de grossesmatrices. Ici, le résultat de la somme est une matrice 2× 2 et le premier argument compatibleest la matrice M1 initiale qui sera remplacée par la somme.> M1,M2 := Matrix([[a,b],[b,a]]),Matrix([[alpha,beta],[gamma,delta]]) : Add(M2,M1,inplace) ;> M1,M2 ; MatrixOptions(M2,shape) ; α + a β + b

γ + b δ + a

a b

b a

, α + a β + b

γ + 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 à M1 fait perdre à cette matrice sonprofil 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 M1 est différent puisqu’ilest incompatible avec le profil. Le calcul tient compte de la symétrie et la somme est calculéesuivant la première colonne suivit de la définition de la première ligne par symétrie, puis de ladeuxiè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 ;

M1, M2 := 1 2

2 1

, −1 0

2 1

0 2

4 2

, −1 0

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" à M1 et la matrice M2 contient alors la sommeréelle des matrices.M1,M2 :=Matrix([[1,2],[2,1]],shape=symmetric),Matrix([[-1,0],[2,1]]) ;> Add(M1,M2,inplace) :> M1,M2 ;> MatrixOptions(M1,shape) ;

M1, M2 := 1 2

2 1

, −1 0

2 1

0 4

4 2

, −1 0

2 1

[symmetric]

L’opération d’addition avec Add(...,inplace) n’est donc pas toujours commutative et laprudence doit être de mise avec la conjugaison des options shape et inplace. L’opération estmême impossible avec le produit de matrices (MatrixMatrixMultiply) puisqu’on ne peut plusréliser la commutation.> M1,M2 :=Matrix([[1,2],[2,1]],shape=symmetric),Matrix([[-1,0],[2,1]]) ;> Add(M2,M1,inplace) :> M1,M2 ;> MatrixOptions(M1,shape) ;

M1, M2 := 1 2

2 1

, −1 0

2 1

1 2

2 1

, 0 2

4 2

[symmetric]

Accès aux fonctions de LinearAlgebra

Pour l’instant toutes les fonctions de LinearAlgebra ont été rendues accessibles avec withet sont toutes disponibles. On peut, par exemple, réaliser la transposé d’un vecteur (ou d’unematrice) 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) ;

V :=

a

b

c

[a b c

][

conjugate (a) conjugate (b) conjugate (c)]

Après un ordre restart ces fonctions ne seront plus disponibles et Transpose devient le nomd’une fonction non définie. On rappelle qu’en tant que calculateur symbolique, il est normaleque MAPLE accepte cette situation et ne signale aucune erreur.> restart :> V :=Vector([a,b,c],orientation=row) ;> Transpose(V) ;

V :=[a b c

]Transpose (V )

La fonction with permet d’avoir accès à la ou les fonctions de la bibliothèque qui sont utilespour le travail en cours.> with(LinearAlgebra,HermitianTranspose,Transpose) ;

[HermitianTranspose,Transpose]

> Transpose(V,inplace) ;> HermitianTranspose(V,inplace) ;

a

b

c

[


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é. Ilexiste é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éationd’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 ; [


Une troisième forme identique à la prcédente est utilisable, mais seulement avec les nouvellesbibliothèques telle que LinearAlgebra. Elle utilse l’opérateur :-> V := Vector([a,b,c],orientation=row) ; LinearAlgebra :-HermitianTranspose(V,inplace) :V ;[



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]) ;

A, b :=

1 2 −10 1 2−2 3 1

,−344

La solution peut être obtenue en écrivant A−1b mais cette opération est déconseillée car

trop peu efficace. On utilisera la fonction LinearSolve qui utilise des algorithmes appropriésdont le résultat est un vecteur anonyme solution du système. Si on veut donner un nom à cettesolution, il faudra effectuer une assignation> x :=LinearSolve(A,b) ;

x :=

−102

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 lessystèmes de grandes tailles.> LinearSolve(A,b,inplace) : b ;

−102

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 multiplesdu types AX = B, où B est une matrice (Xi,j est la composante i de la colonne Xj solution deA. (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 := LinearSolve(A,B) ;

A, B :=

1 2 03 2 12 1 1

,

2 03 13 2

X :=

−2 −22 15 5

3.2.3 TestsEqual : vérifie si deux entités sont égales. Avec l’option compare=’all’, MAPLE dit si les deuxentité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) ;

R :=[

1/2 3/2 −1/5 3/5]


> F := Vector[row]([0.5,1.5,-0.2,0.6],datatype=sfloat) ;

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 propresLe 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]]

A :=

−1 1 −21 −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) ;

A :=

−3 −2 −3 3 −11 0 −2 −2 23 −3 0 −2 −3−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 propresLes 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ésaux valeurs propres.> A := Matrix([[-1,0,2],[3,1,0],[3,0,0]]) ;Eigenvectors(A) ;

A :=

−1 0 23 1 03 0 0

−312

,−1 0 2/33/4 1 21 0 1

Chapitre 4

Approximation

4.1 Sens étymologiqueEn 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’unnombre 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 à "joindreles points" donnés. À partir d’une table trigonométrique, elle peut servir à estimer les valeurssitué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ômede degré d. C’est une approximation local au voisinage d’un point x0 à un certain ordre d etavec un certain reste (erreur). Mots clés : taylor, series, infnorm.> developmt := series(exp(x),x=0,3) ;

developmt := 1 + x+ 1/2x2 +O(x3)

> developmt := convert(developmt,polynom) ;

developmt := 1 + x+ 1/2x2

> plot([exp(x),developmt],x=-2..2,color=[red,blue]) ;

71

72 Chapitre 4. Approximation

4.2 Interpolation polynômiale

4.2.1 MotivationVisualiser 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 unintervalle de temps t, ces choses concrètes continuellement. On va alors approcher ce continupar une fonction polynôme qui passe par les points qu’on a trouvé.

4.2.2 Formulation du problèmeSoit 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’interpolationpolynomiale 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 despoints de I, on parle d’interpolation de Lagrange.

2) Lorsque les (φi, ψi) sont des fonmes linéaires du type φi : f → f(xi) et ψi : f → ∂f∂xi

, onparle d’interpolation d’Hermite.

4.2.3 Résultat d’expérienceLagrange

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 αiune suite quelconque de n+ 1 termes. Alors il existe un unique polynôme P de degré inférieurou égal à n tel que :

P (xi) = αi pour i = 1, ..., n+ 1En particulier, pour toute fonction f continue sur un intervalle contenant les xi, il existe ununique polynôme P de degré inférieur ou égal à n tel que :

P (xi) = f(xi) pour i = 1, ..., n+ 1

Hermite

On rappelle le résultat suivant :

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 :

P (x1) = αi et(dP

dx

)(xi) = bi pour i = 1, ..., n+ 1

En particulier, pour toute fonction f dérivable sur un intervalle contenant les xi, il existe ununique polynôme P de degré inférieur ou égal à 2n+ 1 tel que :

P (xi) = f(xi) et(dP

dx

)(xi) =

(df

dx

)(xi) pour i = 1, ..., n+ 1

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’erreurOn rappelle le résultat suivant :


Theorème 4.2.3. Soit f une fonction de classe C(n+1)([a, b]). Soient x1, ..., xn+1, n + 1 réelsdeux à deux distincts. On note P le polynôme d’interpolation de f aux points xi. Alors pourtout x dans [a, b], il existe un ξ dans [a, b] tel que :

f(x)− p(x) =n+1∏i=1

(x− xi)D(n+1)(f)(ξ)

(n+ 1)!

Majoration de l’erreur : de la relation précédente, on en déduit :

max[a,b]|f(x)− p(x)| ≤ max

[a,b]

∣∣∣∣∣n+1∏i=1

(x− xi)∣∣∣∣∣max

[a,b]

|D(n+1)(f)(x)|(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 ladifférence entre les points et la courbe. Soit P la courbe qui approche globalement les points :

minn∑i=1

(P (xi)− yi)2

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é :∫ b

a(f(x)− p(x))p2dx


soit minimale. On montre qu’il existe un unique polynôme P ayant cette propriété et que P estcaractérisé par : ∫ b

aq(x)(f(x)− p(x))dx = 0

pour tout polynôme q de degré inférieur ou égal à n.

4.4 Polynômes trigonométriques : séries de FourierSoit f une fonction continuement dérivable par morceaux et périodique de période T . la

série de Fourier de f s’écrit :

SF (f) := a(0)2 +

(∑n=1

a(n) cos(2πnx

T

))+(∑n=1

b(n) sin(2πnx

T

))

où l’on définit les suites an et bn par :

an :=2∫ T

0 f(x) cos 2nπxTdx

Tet bn :=

2∫ T

0 f(x) sin(2nπxT

)dxT

4.4.1 ApproximationUne 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 IllustrationVoir 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 7→ 1/2π +∞∑n=1

(2 (−1)n − 2) cos (nx)π n2

> Sf :-graphe(1,3,-1,1) ;

Chapitre 5

Intégration

5.1 Régle des trapèzes

5.1.1 Exemples introductifsConsidérons l’intégrale indéfinie

∫ 11+exdx. Puisque

11+ex = 1+ex

1+ex −ex

1+ex = 1− ex

1+ex∫ 11 + ex

dx =∫ (

1− 11 + ex

)dx = x−

∫ ex

1 + exdx

L’intégrale restante peut être calculée à l’aide d’un changement de variables en posant u = 1+ex.∫ ex

1 + exdx = 1

udu

Ainsi on a : ∫ 11 + ex

dx = x− ln(1 + ex) + c

Ce résultat peut être directement obtenu par MAPLE. La commande Int est de la formeinerte de int. La conjonction de Int de value permet l’afficahge de l’intégrale non évaluéenumériquement.> with(plots) : > Int(1/(1+exp(x)),x) ;∫

(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) ; ∫

(1 + ex)−1 dx

> ’%’ = simplify(value(%),symbolic)+c ;∫(1 + ex)−1 dx = x− ln (1 + ex) + c

Maintenant considérons l’intégrale définie∫ 1

0

11 + ex

dx. Pour une réprésentation graphique,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) ; ∫ 1

0(1 + ex)−1 dx

> 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}) ;

Maintenant on considére l’intégrale indéfinie∫ 1x+exdx. Il n’est pas possible d’obtenir une

expression analytique de cette intégrale impliquant des fonction élementaires. Maple ne peutmê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(%) ;

∫(x+ ex)−1 dx

∫(x+ ex)−1 dx

Formellement, ∫ 1

0

1x+ ex

dx = limδx→0

1∑x=0

1x+ ex

C’est ce que MAPLE calcule quand on lui demande evalf(Int(f(x)),x=0..1). On peut êtreplus précis dans la précision :> Int(1/(x+exp(x)),x=0..1) ; value(%) ; evalf(%) ;

∫ 1

0(x+ ex)−1 dx

∫ 1

0(x+ ex)−1 dx

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

Revenons à notre première intégrale :∫ 1

0

11 + ex

dx et on calcule la surface :> 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èzesLa 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.

Soit l’intégrale définie∫ b

af(x)dx peut être approximée par la somme des aires des trapèzes

formés par les points :(x0, f(x0)), ..., (xn, f(xn))

sur la courbe y = f(x). Ainsi :∫ b

af(x)dx ' [f(x0) + 2f(x1) + 2f(x2) + ...+ 2(f(xn−1) + f(xn)]h2

où h = b−an

est le pas de la subdivision de l’intervalle [a, b]. En posnant : xi = a+ih = a+i(b−an

),

on a : ∫ b

af(x)dx ' h

2

(f(a) + 2

(n−1∑i=1

f(a+ ih))

+ f(b))

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 trouvedans la bibliothèque student.> Int(f(x),x=a..b)=student[trapezoid](f(x),x=a..a+n*h,n) ;

∫ b

a(x+ ex)−1 dx = 1/2h

((a+ ea)−1 + 2

5∑i=1

(a+ ih+ ea+ih

)−1+(a+ 6h+ ea+6h

)−1)

Un cas précis :> n := 6 :> student[trapezoid](f(x),x=a..a+n*h,n) ;

1/2h(

(a+ ea)−1 + 25∑i=1

(a+ ih+ ea+ih

)−1+(a+ 6h+ ea+6h

)−1)

> value(%) ;

1/2h((a+ ea)−1 + 2(a+ h+ ea+h

)−1+ 2

(a+ 2h+ ea+2h

)−1+ 2

(a+ 3h+ ea+3h

)−1

+2(a+ 4h+ ea+4h

)−1+ 2

(a+ 5h+ ea+5h

)−1+(a+ 6h+ ea+6h

)−1)

> 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) ;

5 +3∑i=1

2 (1 + i)2 − 1/3 (1 + i)3

> value(%) ;30

> Int(2*x^2-x^3/3,x=1..5) ; ∫ 5

12x2 − 1/3x3dx

> value(%) ;923

> student[trapezoid](2*x^2-x^3/3,x=1..5,8) ;

5/2 + 1/27∑i=1

2 (1 + 1/2 i)2 − 1/3 (1 + 1/2 i)3


> value(%) ;612

> student[trapezoid](2*x^2-x^3/3,x=1..5,16) ;

5/4 + 1/415∑i=1

2 (1 + 1/4 i)2 − 1/3 (1 + 1/4 i)3

> value(%) ;2458

Exemple 2 : Erreur absolue et erreur relative dans l’évaluation d’une intégralenumérique

On cherche à évaluer numériquement∫ 3π

4

π4

sin(x)dx en utilisant la méthode des trapèzes avec

4 sous-intervalles.> student[trapezoid](sin(x),x=Pi/4..3*Pi/4) ;

1/16 π(sqrt (2) + 2

3∑i=1

sin (1/4 π + 1/8 iπ))

> 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égraleavec 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 estdonné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

On cherche une approximation de∫ 1

0e−x

2dx en utilisant la règle des trapèzes avec 32 sous-

intervalles et 64 sous-intervalles.> student[trapezoid](exp(-x^2),x=0..1,32) ;

164 + 1/32

31∑i=1

e−1

1024 i2 + 1

64 e−1

> trap32 := evalf(%) ;trap32 := 0.7467642547

> student[trapezoid](exp(-x^2),x=0..1,64) ;

1128 + 1

64

63∑i=1

e−1

4096 i2 + 1

128 e−1

> trap64 := evalf(%) ;trap64 := 0.7468091636

On calcule la valeur exacte de l’intégrale.> Int(exp(-x^2),x=0..1) ; ∫ 1

0e−x

2dx

> 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 enutilisant la régle des trapèzes est approximativement proportionnelle au carré de la longueurdes 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 subdivisionrégulière a = x0, x1, ..., xn = b où yi = f(xi) pour chaque (i). On a alors :∫ b

af(x)dx ' h

3 (y0+4y1+y2)+...+(yn−2+4yn−1+yn)h3 = [(y0+yn)+4(y1+y3 = ...+yn−1)+2(y2+y4+...+yn−2)]h

3

La régle de Simpson peut être appliquée en invoquant la commande simpson du packagestudent> Int(f(x),x=a..b)=student[simpson](f(x),x=a..a+n*h,n) ;

∫ b

af (x) dx = 1/3h

f (a) + f (a+ nh) + 41/2n∑i=1

f (a+ (2 i− 1)h) + 21/2n−1∑i=1

f (a+ 2 ih)

Les lignes de code suivantes générent les différences instances des formules de la régle deSimpson :> n := 6 :> student[simpson](f(x),x=a..a+n*h,n) ;

1/3h(f (a) + f (a+ 6h) + 4

3∑i=1

f (a+ (2 i− 1)h) + 22∑i=1

f (a+ 2 ih))

> value(%) ;

1/3h (f (a) + f (a+ 6h) + 4 f (a+ h) + 4 f (a+ 3h) + 4 f (a+ 5h) + 2 f (a+ 2h) + 2 f (a+ 4h))

> for i from 0 to n do subs(f(a+i*h)=y[i],%) end do :

1/3h (y0 + y6 + 4 y1 + 4 y3 + 4 y5 + 2 y2 + 2 y4)

5.2.1 ExemplesInté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) ;

−1− 3/2π + 916 π

3

> evalf(%) ;11.72864166


> int(cos(x)-(1-x^2/2+x^4/24),x=0..3*Pi/2) ;

−1− 811280 π

5 − 3/2 π + 916 π

3

> evalf(%) ;−7.63666653

> int(cos(x)-(1-x^2/2+x^4/24-x^6/6 !),x=0..3*Pi/2) ;

−1− 811280 π

5 − 3/2π + 24371680 π

7 + 916 π

3

> 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-normalSi 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 x4y + 10x3y2 + 10x2y3 + 5xy4 + y5

> Ex := (x+y)^5-% ; expand(%) ;

Ex := (x+ y)5 − x5 − 5x4y − 10x3y2 − 10x2y3 − 5xy4 − y5

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

x− y+(x−1 + y−1

) (x−1 − y−1

)−1

> normal(%) ;0

Attention :. normal est moins efficace que simplify et on est quelquefois obligé de faireplusieurs fois la commande normal.simplify simplifie l’expression de façon automatique.> ’log(tan(Pi/4))’ ;

log (tan (1/4 π))

> %0

6.2 SéquencesDeux 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, x, 1/2x2, 1/6x3, 1/24x4,1

120 x5

> term := 1 : s := term :> for r from 1 to 5 do> term := term*x/r :> s := s, term end do :> s ;

1, x, 1/2x2, 1/6x3, 1/24x4,1

120 x5

> convert([s],‘+‘) ;

1 + x+ 1/2x2 + 1/6x3 + 1/24x4 + 1120 x

5

> ‘+‘(s) ;1 + x+ 1/2x2 + 1/6x3 + 1/24x4 + 1

120 x5

6.3 sum et productFormule de Taylor à l’ordre 5 pour exp(x).

> unassign(’term’,’s’,’r’) ;> Sum(x^r/r !,r=0..5) ; % = value(%) ;

5∑r=0

xr

r!5∑r=0

xr

r! = 1 + x+ 1/2x2 + 1/6x3 + 1/24x4 + 1120 x

5

> e1 := rhs(%) ;

e1 := 1 + x+ 1/2x2 + 1/6x3 + 1/24x4 + 1120 x

5

> e2 := expand(subs(n=5,(1+x/n)^n)) ;

e2 := 1 + x+ 2/5x2 + 225 x

3 + 1125 x

4 + 13125 x

5

> plot([exp(x),e1,e2],x=-2..2,title="Approximation exp(x)",legend=["exp(x)","Taylor","Binomial"]) ;

88 Chapitre 6. "Révisions"

sin x ∼ x, sin(x) est proportionnelle à :

∞∏r=−∞

(x− rπ) = x

( ∞∏r=1

(x2 − (rπ)2))

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

S := (n, x) 7→ xn∏r=1

(x2 − (rπ)2

x(x2 − π2

) (x2 − 4 π2

) (x2 − 9 π2

) (x2 − 16π2

) (x2 − 25 π2

)> k := (-1)^3*(S(3,-Pi/2)) ;

k := −1575128 π7

> plot([k*sin(x),S(3,x)],x=-2..2) ;

6.4 Construction de tables de groupes avec arrayConstruction 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 32 || 2 0 23 || 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 maisil 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érateurdsolve. On définit les termes différentiels des équations à l’aide de l’opérateur diff. La fonctiondsolve 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çantpar 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 uneconstante d’intégration.> restart :> eqd :=diff(y(x),x)-k*x*y(x) = x : eqd ;> sol :=dsolve(eqd) ;

d

dxy (x)− kxy (x) = x

sol := y (x) = −k−1 + e1/2 kx2_C1

On peut vérifier la réponse à l’aide de la fonction odetest qui doit répondre 0 si la solutionest juste. Quelquefois il peut être nécessaire d’éffectuer quelques simplifications sur la réponsepour obtenir ce résultat.> odetest(sol,eqd) ;

0

La donnée du nom de la fonction inconnue comme argument peut être nécessaire car dsolveest capable de résoudre formellement une équation pour des termes contenant des fonctions nonexplicité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 employerindifféremment Diff ou diff.> eqd :=Diff(h(x)+y(x),x)-k*x*y(x) = G(x) : eqd ;

d

dx(h (x) + y (x))− kxy (x) = G (x)

90

Chapitre 7. Equations différentielles 91

> dsolve(eqd,y(x)) ;

y (x) =(∫ (

− d

dxh (x) +G (x)

)e−1/2 kx2

dx+ _C1)e1/2 kx2

> dsolve(eqd,h(x)) ;

h (x) =∫− d

dxy (x) + kxy (x) +G (x) dx+ _C1

S’il n’y a pas d’ambiguité, MAPLE chosit pour fonction solution celle sur laquelle s’appliquel’opérateur diff> eqd :=diff(h(x),x)-2*x*y(x)=x : eqd ;> dsolve(eqd) ;

d

dxh (x)− 2xy (x) = x

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). MAPLEcalcule (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

dxy (x)− 2xy (x) = x

y (0) = 1

sol := y (x) = −1/2 + 3/2 ex2

> odetest(sol,eqd) ;0

Attention :. La fonction y n’existe pas, sinon de façon symbolique. On rappelle qu’une écriturecomme y(x) possède le type function en raison de sa syntaxe. La réponse de dsolve estseulement 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 simplementcomme un nom qui point sur l’expression de la solution.> assign(sol) ;# Cette commande ne renvoie aucun message> y(x) ;

−1/2 + 3/2 ex2

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) ;

y := x 7→ −1/2 + 3/2 ex2

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}) ;> odetest(sol,eqd) ;> assign(sol) ;> y :=unapply(y(x),x) ;

d

dxy (x)− 2xy (x) = x

sol := y (x) = −1/2 + 3/2 ex2

y := x 7→ −1/2 + 3/2 ex2

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

dx2y (x)− 3 d

dxy (x) + 2 y (x) = 0

sol := y (x) = _C1 e2x + _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) + 2D (y) (x) + y (x) = 0

sol := y (x) = _C1 e−x + _C2 e−xx

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

D(2))

(y) (x)− 3D (y) (x) + 2 y (x) = 0


d2

dx2y (x) + 2 d

dxy (x) + y (x) = 0

L’opérateur D peut être utilisé en même temps que diff ou Diff. Mais il permet surtoutd’introduire des conditions initiales sur les derivées comme ici y′(0) = 0. On notera aussi la pos-sibilité (non nécessaire) d’utiliser l’opérateur union pour rassemble l’équation et les conditionsinitiales.> 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

dx2y (x)− 3D (y) (x) + 2 y (x) = 0

{y (0) = 1,D (y) (0) = 0}sol := y (x) = −e2x + 2 ex

>convert({eqd} union c_i,D) ;{y (0) = 1,

(D(2)

)(y) (x)− 3D (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égralesOn 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 pourrésoudre une équation. Ici l’équation différentielle est à coefficients constants et l’utilisation destrransformé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 ; {

y (0) = 1,D (y) (0) = 0, d2

dx2y (x) + 4 d

dxy (x) + 8 y (x) = sin (x)

}

On peut imposer à MAPLE de chercher la solution par cette méthode en utilisant commetroisième argument, le mot clé method. Cette troisième position impose donc de spécifier lafonction inconnue y(x).> sol :=dsolve(eqd_ci,y(x),method=laplace) ;

sol := y (x) = − 465 cos (x) + 7

65 sin (x) + 1130 e

−2x (138 cos (2x) + 131 sin (2x))

7.2.2 Fonctions discontinues définissant les équations différentiellesLa 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

dx2y (x)− 2 y (x) = Heaviside (x)x


{D (y) (0) = 0, y (0) = 0}

sol := y (x) = −1/8 Heaviside (x)(4x− 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)) ;> odetest(sol,eqd) ;

sol := y (x) = −1/4 Heaviside (x) (2x− sqrt (2) sinh (sqrt (2)x))

0

On montre ici comment on peut se dispenser de la fonction assign pour créer le fonctionsolution.> y :=’y’ :> eqd :=diff(y(x),x)+y(x) = piecewise(x<=0,1,exp(-x))+k*cos(x) : eqd ;

d

dxy (x) + y (x) =

1 x ≤ 0exp(−x) + k ∗ cos(x) otherwise

Les fonctions définies par morceaux avec piecewise peuvent aussi entrer dans l’écriture d’uneéquation différentielle.> sol :=dsolve({eqd,y(0)=1}) ;

sol := y (x) =

1/2 k cos (x) + 1/2 k sin (x) + 1− 1/2 e−xk x < 01/2 k cos (x) + 1/2 k sin (x)− 1/2 e−xk + e−x + e−xx 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−xk + Heaviside (x) e−x + e−xHeaviside (x)x

De façon générale, et si c’est possible, on préféra convertir l’équation elle-même avant dechercher la solution (souvent, c’est plus efficace).> eqd :=convert(eqd,Heaviside) ;

eqd := d

dxy (x) + y (x) = k cos (x) + 1− Heaviside (x) + Heaviside (x) e−x

> sol :=dsolve({eqd,y(0)=1}) ;

sol := y (x) = 1/2 k cos (x) + 1/2 k sin (x) + 1− Heaviside (x)− 1/2 e−xk + Heaviside (x) e−x + e−xHeaviside (x)x

7.2.3 Solutions explicites et implicitesQuelquefois 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érateurdsolve tente alors de résoudre cette équation et présente la ou les solutions explicites. Si cetterésolution n’est pas possible, seule la forme et renvoyée. On remarquera ici que la solution estsous 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

dxy (x) = sin

((y (x))2

)x−

∫ y(x)(sin

(_a2

))−1d_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

dxy (x) = −y (x) + (y (x))3

y (x) =(sqrt

(1 + e2x_C1

))−1, y (x) = −

(sqrt

(1 + e2x_C1

))−1

On notera que les solutions étant alors renvoyées sous forme de suite (séquence) on devraformer 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− e2x_C1 = 0

Les solutions précédentes sont bien les racines de la solution-équation implicite.> solve(%,y(x)) ; (

sqrt(1 + e2x_C1

))−1, −

(sqrt

(1 + e2x_C1

))−1

On ne sera donc pas surpris si les solutions explicites font souvent apparaître la fonction Wde Lambert.> eqd :=(1+x*y(x)+x^2)*diff(y(x),x)+1+x*y(x)+y(x)^2=0 : eqd ;> dsolve(eqd,implicit) ;> dsolve(eqd) ;

(1 + xy (x) + x2

) d

dxy (x) + 1 + xy (x) + (y (x))2 = 0

−_C1 + 1 + xy (x)− ln(−9

(1 + xy (x) + x2

)−1)

+ ln(

9/2 x (y (x) + x)1 + xy (x) + x2

)− ln (x) = 0

y (x) = −x2 − LambertW

(−2x_C1 e−1ex

2)

x

Dans l’exemple suivant la solution explicite est d’un intérêt relatif. La solution implicitemontre que la difficulté rencontrée vient de ce que MAPLE ne "connait" pas de définition pourla fonction réciproque de la fonction de Frsnel-sinus.


> eqd := diff(y(x),x)=sin(y(x)^2)^(-1) : eqd ;> dsolve(eqd) ;> dsolve(eqd,implicit) ;

d

dxy (x) =

(sin

((y (x))2

))−1

y (x) = 1/2 sqrt (2) sqrt (π) RootOf (−FresnelS (_Z ) sqrt (π) + sqrt (2)x+ sqrt (2)_C1)

x− 1/2 sqrt (2) sqrt (π) FresnelS(

sqrt (2) y (x)sqrt (π)

)+ _C1 = 0}

7.2.4 Classes des équations différentiellesLa 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

dxy (x) = −xy (x) + (y (x))3

_BernoulliIci 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 ;> DEtools[odeadvisor](eqd) ;

d

dxy (x) + (2x+ 1) y (x) + 1 + x+ x2 + (y (x))2 = 0

[[_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) ;

y (x) = −−1 + xex_C1− xex_C1− 1

MAPLE "connaît" la plupart des fonctions dites spéciales, ce qui lui permet de résoudrecertains types> eqd :=x^2*diff(y(x),x$2)+x*diff(y(x),x)+(x^2-n^2)*y(x)=0 : eqd ;> DEtools[odeadvisor](eqd) ;> dsolve(eqd) ;

x2 d2

dx2y (x) + xd

dxy (x) +

(x2 − n2

)y (x) = 0

[_Bessel]y (x) = _C1BesselJ (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 ;> DEtools[odeadvisor](eqd) ;> dsolve({eqd,op(c_i)},y(x)) ;

d2

dx2y (x) = 3 cos (2x) y (x)− y (x)


{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’ellene s’exprime pas de façon symbolique et exacte). La réponse est alors soit NULL, soit uneré-écriture de l’équation avec la fonction DESol (cette fonction est aux équations différentiellesce que RootOf est aux équations ordinaires). L’apparente simplicité d’une équation n’est pas ungage sur la possibilité d’expliciter la solution... (ici une équation voisine du premier transcendantde Painlevé ; remplacer y(x)2 par 6y(x)2)> eqd :=Diff(y(x),x$2)=y(x)^2+x : eqd ;> DEtools[odeadvisor](eqd) ;> sol :=dsolve(eqd) ;

d2

dx2y (x) = (y (x))2 + x

[NONE ]

sol :=

7.2.5 Développement en série de la solutionLorsque 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 positionce 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) + (2x+ 1) y (x) +(1 + x+ x2

)(y (x))3 = 0

y (1) = 1

sol := y (x) = 7 − 6x+ 672 (x− 1)2 − 661

3 (x− 1)3 + 124718 (x− 1)4 +O

((x− 1)5

)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) ;

y_ap := x 7→ 7 − 6x+ 672 (x− 1)2 − 661

3 (x− 1)3 + 124718 (x− 1)4

L’équation précédente peut être résolue exactement par dsolve.


7.2.6 Equations linéaires homohènes à coefficients polynomiauxLa 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 ;

(x3 + x

) d3

dx3y (x) +(x2 − 1

) d2

dx2y (x)− y (x) = 0

Avec l’option formal_solution on peut obtenir l’expression de la solution sous forme desérie entière> dsolve({eqd,y(0)=0},y(x),formal_solution) ;

y (x) = _C1∞∑

_n1=1

((−1)_n1+1 2−2 _n1+2

_n1−1∏l=1

(−1 + 4 l2 + 8 l3)x2 _n1+1

l (3 + 5 l + 2 l2)

)

7.3 Système d’équations différentiellesMAPLE 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

dtx (t)− x (t) + 2 y (t) = 0, d

dty (t) + x (t)− 2 y (t) = 0

}

{x (0) = 0, y (1) = 1}

{x (t) , y (t)}

> sol :=dsolve(eqd union c_init,fct) ;

sol :={y (t) =

(1 + 2 e3

)−1+ 2 e3 t

1 + 2 e3 , x (t) = −2 e3 t

1 + 2 e3 + 2(1 + 2 e3

)−1}

>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) ;

xf := t 7→ −2 e3 t

1 + 2 e3 + 2(1 + 2 e3

)−1

yf := t 7→(1 + 2 e3

)−1+ 2 e3 t

1 + 2 e3


7.4 Résolutions numériquesLorsque 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 ettoutes 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

dx2f (x) = x− f (x)1 + x2 + (f (x))2

f (0) = 1, D (f) (0) = −1On 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) ;

sol := proc (x_rkf45) ... endproc

On construit maintenant, avec la même équation, un problème aux conditions aux limitesen 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 demê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 commandesdsolve 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 parexemple ceux des équilibres chimiques) sont caractérisées par des coefficients ayant des ordresde grandeur relatifs importants. On laisse dsolve choisir la méthode (Rosenbrock), mais onpourrait 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) ;

eqd_stiff := d2

dt2f (t) + 1000.0 d

dtf (t) + 0.010 (f (t))2 = 0

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) ;

[x = 1.5, f (x) = −0.498964712481904938, ddxf (x) = −0.683454657349700678]

La solution pourra être visualisée graphiquement avec la fonction odeplot de la bibliothquegraphique plots. Le premier argument est le nom de la procédure, le deuxième une liste quidonne la ou les représentations choisies (f(x) en fonction de x ou x en fonction de f(x)). Letroisiè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) solutionLa 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) ;

Ls :=(x = proc (x) ... endproc, f (x) = proc (x) ... endproc, d

dxf (x) = proc (x) ... endproc

)

On peut associer à des noms ces procédures d’intégration numérique (la fonction subs admetdes 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’équationsLa 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) ;

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 := proc (x_rkf45) ... endproc

> 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 rappelsPour 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’onconnait 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

dtxi(t) = f(t, x1(t), x2(t), ..., xn(t)) (i = 1..n)

Ce dernier système peut être vu comme une équation du premier ordre dans Rn.

d

dtX(t) = f(t,X(t))

Lorsque f ne dépend pas de t, on dit qu’on est en précense d’un système autonome ; dans lecas 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 ontbeaucoup de place pour s’entremeler (par exemple dans R3 une courbe fermé n’englobe rien etd’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 fonctionsde R dans R2), leurs graphes sont dans l’espace (t, x, y) (R3).

Un champ de directions associé à une équation différentielle ddtx(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 solutionpassant par ce point.

Le champ de direction d’une équation différentielle réelle :

d

dtx(t) = f(t, x(t))

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

dtx(t) = f(t, x(t), y(t))

d

dty(t) = g(t, x(t), y(t))

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 dansles plans (t, x) et (t, y), c’est-à-dire les graphes des solutions ne sont pas d’une lecture aisée etparlantes, 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é (selonles é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 DEplotExemple 8.2.1. x′(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 = PAP−1 diagonale

On a alors :X ′(t) = PDP−1X(t)P−1X ′ = DP−1X(t)

On pose : Y = P−1X(t), on aura alors :

Y ′(t) = DY (t)

y′i(t) = αiyi(t)yi(t) = cie

αit

On définit l’exponentielle de matrice par :

eA =∞∑j=0

Ajj!

eD =∞∑j=0

Dj

j! =∞∑j=0

1j!

αji

. . .αji

Autrement dit :

eD =

∞∑j=0

αjij!

. . .∞∑j=0

αjij!

On a aussi : Aj = PDjP−1 donc :

eA =∞∑j=0

Aj

j! =∞∑j=0

PDjP−1

j! = P

∞∑j=0

Dj

j!

P−1

eA = PeDP−1

et donc :X(t) = ceAt = cPeDtP−1

104 Chapitre 8. Equations différentielles (cours 2)

8.2.1 Comportement des solutions d’un système linéaire 2× 2Soit un système différentiel X ′ = 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 pointd’é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]]) ;

F := 1 0

0 3

> Eigenvectors(F) ; 3

1

, 0 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)=-2],[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)]) ;{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écursiveBeaucoup 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éduresrécursives jouent un rôle important dans le calcul scientifique, car elles fournissent des solutionscompactes et élégantes à des problèmes de programmation. Le revers de la médaille est que lesprocé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 factorieln est défini comme étant le produit de tous les entiers positifs inférieurs ou égal n :

n! =n∏k=1

k

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 deuxcô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 nousne voulons pas 6(5(4(3(2(1(0(−1))))))) à l’étape suivante, en plus en appliquant cette formule leré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, nousfaisons appel à la procédure elle-même. L’autre partie de la définition apparait en premier, sousforme d’une structure conditionnelle.

On calcule quelques factoriels à l’aide de cette procédure.> factoriel_recursive(4) ;

24

> factoriel_recursive(10) ;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’espacepour 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

2853748015316465763033211492513250392815533600345432581191352206540862813929610390630223789

674919885[...346421digits...]0000000000000000000000000000000000000000000000000000000000000000

000000000000000000000000000000000000

Voici une astuce qui va nous permettre de visualiser comment fonctionne la procédurerécursive. Dans le corps de la procédure, on va utiliser l’apostrophe "’" pour différer l’évalutionde l’appel de la procédure réccursive.> restart ;> factoriel_recursive := proc(n)> 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.> factoriel_recursive(6) ;

6 factoriel_recursive (5)

> % ;30 factoriel_recursive (4)

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 MAPLEemprunte.> restart ;> factoriel_recursive := proc(n)> option trace ;> if n=0 then> 1> else> n*factoriel_recursive(n-1)> fi ;> end :

On appelle la procédure et nous avons sous les yeux ce qui se passe.> factoriel_recursive(6) ;{–> enter factoriel_recursive, args = 6{–> enter factoriel_recursive, args = 5{–> enter factoriel_recursive, args = 4{–> enter factoriel_recursive, args = 3{–> enter factoriel_recursive, args = 2{–> enter factoriel_recursive, args = 1{–> enter factoriel_recursive, args = 0

1

<– exit factoriel_recursive (now in factoriel_recursive) = 1}

1


2


6


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’onutilise littéralement la définition de factoriel n! = n(n− 1)!, nous avons :> restart ;> factoriel_recursive := proc(n)> n*factoriel_recursive(n-1)> end :> factoriel_recursive(6) ;Error, (in factoriel_recursive) too many levels of recursion

Ca ne marche pas ! Pourquoi la définition mathématique du factoriel n’engendre pas deré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)aQuelle 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 lacondition 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]) ;

15Voici une version de la procédure add_liste avec une évalution différée de la réccurence.

> restart ;> add_liste := proc(x)> if nops(x) = 0 then> 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’appelreccursif de la procédure, pour rendre plus parlant de ce qui se passe.> add_liste([1,2,3,4,5]) ;

′′′′′′[1, 2, 3, 4, 5][1]′′′′′′ + add_liste([1, 2, 3, 4, 5][2..− 1])

> % ;′′′′′[1, 2, 3, 4, 5][1]′′′′′ +′′′′′′ [2, 3, 4, 5][1]′′′′′′ + add_liste([2, 3, 4, 5][2..− 1])

> % ;

′′′′[1, 2, 3, 4, 5][1]′′′′ +′′′′′ [2, 3, 4, 5][1]′′′′′ +′′′′′′ [3, 4, 5][1]′′′′′′ + add_liste([3, 4, 5][2..− 1])

> % ;

′′′[1, 2, 3, 4, 5][1]′′′ +′′′′ [2, 3, 4, 5][1]′′′′ +′′′′′ [3, 4, 5][1]′′′′′ +′′′′′′ [4, 5][1]′′′′′′ + add_liste([4, 5][2..− 1])

> % ;

′′[1, 2, 3, 4, 5][1]′′ +′′′ [2, 3, 4, 5][1]′′′ +′′′′ [3, 4, 5][1]′′′′ +′′′′′ [4, 5][1]′′′′′ +′′′′′′ [5][1]′′′′′′ + add_liste([5][2..− 1])

> % ;′[1, 2, 3, 4, 5][1]′ +′′ [2, 3, 4, 5][1]′′ +′′′ [3, 4, 5][1]′′′ +′′′′ [4, 5][1]′′′′ +′′′′′ [5][1]′′′′′

> % ;[1, 2, 3, 4, 5][1] +′ [2, 3, 4, 5][1]′ +′′ [3, 4, 5][1]′′ +′′′ [4, 5][1]′′′ +′′′′ [5][1]′′′′

> % ;1 + [2, 3, 4, 5][1] +′ [3, 4, 5][1]′ +′′ [4, 5][1]′′ +′′′ [5][1]′′′

> % ;3 + [3, 4, 5][1] +′ [4, 5][1]′ +′′ [5][1]′′

> % ;6 + [4, 5][1] +′ [5][1]′

> % ;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


<– exit add_liste (now in add_liste) = 5}

9


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)> if nops(x) = 2 then> grand(x[1],x[2]) ;> else> grand(x[1],plus_grand(x[2..-1])) ;> fi ;> end :> plus_grand([1,2,49,29,10,20]) ;

49On 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é.> plus_grand := proc(x)> if nops(x) = 2 then> 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 versionsuivante de la procédure grand doit nous retourner des évaluations différées, quand l’argumentn’est de type numérique.> grand := proc(a,b)> if type(a,numeric) and type(b,numeric) then> if a >= b then> a> else> b> fi ;> else> ’grand(a,b)’> fi ;> end :> plus_grand := proc(x)> if nops(x) = 2 then> 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 ;> grand := proc(a,b)> 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 :> plus_grand := proc(x)> option trace ;> if nops(x) = 2 then> 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

5

<– exit grand (now in plus_grand) = 55


<– exit plus_grand (now in plus_grand) = 5}{–> enter grand, args = 2, 5

5

<– exit grand (now in plus_grand) = 5}5

<– exit plus_grand (now in plus_grand) = 5}{–> enter grand, args = 1, 5

5

<– exit grand (now in plus_grand) = 5}5

<– exit plus_grand (now at top level) = 5}

5

Si on enlève l’option trace dans grand, on a moins d’informations...> restart ;> grand := proc(a,b)if type(a,numeric) and type(b,numeric) then> if a >= b then> a> else> b> fi ;> else> ’grand(a,b)’> fi ;> end :> plus_grand := proc(x)> option trace ;> if nops(x) = 2 then> 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 in plus_grand) = 5}

5


<– exit plus_grand (now in plus_grand) = 5}

5

<– exit plus_grand (now at top level) = 5}

5

9.2 ApplicationUne 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 enterme d’elle-même. Mais cette définition n’est pas réccursive car elle ne contient pas de conditiond’arrêt. Voici comme on adapte cette définition pour en faire une définition recursive. Soit gune fonction définie sur un intervalle [a, b], a < b et b − a = p. On définit f comme étant leprolongement périodique de g à l’axe réel :

f(x) =

g(x) a ≤ x et x < b

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) ;

g := x 7→

4x2 − 4x+ 1 − 1 ≤ x

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) ;00

0.36Comme 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 := 1g := x 7→ cos (π x)

On remarque que nous n’avons pas à redéfinir f. Nous avons besoin seulement de redéfinira,b et g, ensuite f va être automatiquement le prolongement périodique de g avec la périodep=b-a.


> f(2) ;1

> plot(g(x),x=-1..1) ;

> plot(f,-3..3) ;

Annexe A

Correction du partiel du lundi 31 mars2008

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 secondecontenant les entiers non premiers inférieurs ou égaux à n. Il est demandé de ne pas utiliser lescommandes : nextprime, prevprime, ithprime ; seule la commande isprime est autorisée.

Exercice 2. Ecrire une procédure AdditionMatrices qui pour deux matrices renvoie leursomme 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 :

Bk,n : x→ n!k!(n− k)!x

k(−x+ 1)(n−k) pour k = 0...n

1) Vérifier pour quelques valeurs de n que :n∑k=0

Bk,n(x) = 1 et quen∑k=0

kBk,n(x) = nx

2) Ecrire une procédure Bernsteinf qui pour une fonction f et un entier n renvoie le polynômede Bernstein associé à f et défini par :

x→n∑k=0

f

(k

n

)Bk,n(x)

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 4On 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’instructionsvé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 pendantl’examen.

Exercice 1Dans 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 false 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) thenL1 := [op(L1),k];

elseL2 := [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, 49, 50, 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, 91, 92,

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 lesmatrices.

Pour additionner deux matrices, il faut au mieux que les deux matrices aient les mêmesdimensions. Dans la procédure qui va suivre, on doit tester si les dimensions des matrices sontidentiques. AdditionMatrices(A,B) qui prend A et B, deux matrices, en paramètre additionneA 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ètreLa 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 :=

a b c

d e f

g h i

> B := Matrix(3,3,[[1,1,1],[2,0,1],[1,1,1]]) ;

B :=

1 1 12 0 11 1 1

> AdditionMatrices(A,B) ;

a+ 1 b+ 1 c+ 1d+ 2 e f + 1g + 1 h+ 1 i+ 1

> C := Matrix(2,2,[[1,2],[2,1]])

C := 1 2

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 :

B := (k, n, x) 7→ n!xk (−x+ 1)n−k

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∑k=0

Bk,n(x) = 1n∑k=0

kBk,n(x) = nx

pour n = 3 et n = 5 :> n := 3 ;

n := 3> sum(B(k,n,x),k=0..n) ;

(−x+ 1)3 + 3x (−x+ 1)2 + 3x2 (−x+ 1) + x3

> expand(%) ;1

> sum(k*B(k,n,x),k=0..n) ;

3x (−x+ 1)2 + 6x2 (−x+ 1) + 3x3

> expand(%) ;3x

> n := 5 ;n := 5

> sum(B(k,n,x),k=0..n) ;

(−x+ 1)5 + 5x (−x+ 1)4 + 10x2 (−x+ 1)3 + 10x3 (−x+ 1)2 + 5x4 (−x+ 1) + x5

> expand(%) ;1

> sum(k*B(k,n,x),k=0..n) ;

5x (−x+ 1)4 + 20x2 (−x+ 1)3 + 30x3 (−x+ 1)2 + 20x4 (−x+ 1) + 5x5;

> expand(%) ;5x

Les propriétés sont donc vérifiées. On peut résumer tout ça dans une procédure et de testercette 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/5x (−x+ 1)4 + 10 e2/5x2 (−x+ 1)3 + 10 e3/5x3 (−x+ 1)2 + 5 e4/5x4 (−x+ 1) + e1x5

3) Dans cet question, on veut tracer la fonction f définie précédemment et quelques polynômesde Bernstein qui lui est associé. Dans mon exemple, j’ai tracé les polynômes de Bernsteindéfinies par Bernsteinf(f,3) et Bernsteinf(f,5) et la fonction f sur l’intervalle [0, 1] (trèsimportant 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 courbesque 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 lespolynômes de Bernstein associés à f considéres dans la question précédente et la fonctionf . 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 4Le 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 (notammentle placement des points A, B, C, D, E, F ), deuxièment, l’interprétation de ce qu’on a construitet 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 commanderandpoint 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, onconstruit 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é, utilespour 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 aisnifaire 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 etversa

Le but de ce TP est de voir comment on peut transformer une liste de chiffres en un nombreet vice et versa.

Question B.1.1. Ecrire une procédure listeennombre qui a comme paramètre L une liste dechiffres entre 0 et 9 et qui renvoie le nombre entier positif composé par les chiffres de L. Parexemple, 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 nombreentier 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 permutationsOn 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

σ(1) σ(2) σ(3) · · · σ(n)

)(P )

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 metsquelques informations pour les tableaux/matrices de taille supérieure). Rechercher dans le coursla 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 listeL et un nombre k tel que k est inférieur ou égale à la taille de la liste. Cette procédure aurapour 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 quirenvoie true si L représente effectivement une permutation dans Snops(L) et false 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 (commeplus en haut).

Question B.2.4. Ecrire une procédure matpermu qui prend en paramètre un nombre entier net qui renvoie une matrice de permutations de Sn. Bien sûr, il faut que la deuxième ligne de lamatrice 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 62 3 1 4 6 5

)= (56)(123)

On a ainsi :

(123) =(

1 2 3 4 5 62 3 1 4 5 6

)

(56) =(

1 2 3 4 5 61 2 3 4 6 5

)

Question B.2.5. Ecrire une procédure DecompCyclesDisjoints qui prend comme paramètreM 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 êtresous 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,4 =(

1 2 3 4 5 64 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 DecompTranspositionqui prend comme paramètre M une matrice de permutation et renvoie la décomposition entranspositions de la permutation (la décomposition de transpositions pourra aussi être sous laforme d’une liste de listes).

On a ainsi des décompositions de permutations en transpositions ou en cycles disjoints maison peut faire l’inverse : on peut à partir d’un ensemble de transpositions ou de cycles disjointsreconstruire la matrice de permutations qui lui est associé.

Question B.2.7. Ecrire une procédure RecompTransposition qui prend comme paramètreL une liste de transpositions et renvoie la matrice de permutations qui lui est associé. Parexemple,> RecompTransposition([[1,4],[2,3],[3,2],[4,1]])(

1 2 3 44 3 2 1

)

m210 : calcul scientifique

Documents

introduction et rappels

vecteurs et matrices

graphisme et gomtrie

tables et tableaux71

dnitions et manipulation

types et oprandes

listes et ensembles61

sciences et technologies