Maple Licence Creative

Commons

Une année de
MPSI 2 2010-2011

MAPLE en MPSI

Guillaume C ONNAN
une année de
maple en mpsi
tp maple en mpsi
 TA B L E D E S M AT I È R E S

1 Premiers pas en Maple 11

1.1 Avant de commencer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.1.1 Entrée des instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.1.2 Aide en ligne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.1.3 Affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.1.4 Dangers de la modification d’une cellule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.1.5 Différents types de nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.1.6 Fonction et expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.1.7 Opérations mathématiques de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.1.8 Résolutions d’équations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.2 Les graphes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.2.1 En dimension 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.2.2 Animations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.3 Quelques erreurs types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.4 EXERCICES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2 Programmer avec Maple 20

2.1 Quelques rappels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2 Listes et séquences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2.1 Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2.2 Les séquences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.3 Algorithme et programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.4 Quelques types prédéfinis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.4.1 Les entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.4.2 Les flottants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.4.3 Les caractères et chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.4.4 Les booléens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.5 Les structures conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.6 Procédures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.7 La programmation impérative : au plus près de la machine . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.7.1 Structures itératives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.8 Au plus près de l’humain : la programmation récursive . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.8.1 Qu’est-ce que c’est ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.9 EXERCICES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

3 Tableaux et matrices 33
3.1 Étoiles et espaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.2 Fabriquons nos outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.2.1 Création d’une matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.2.2 Somme de matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.2.3 Produit de matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.2.4 Matrice identité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.2.5 Puissances d’une matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.2.6 Trace d’une matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.2.7 Transposée d’une matrice, matrices orthogonales . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.3 Avec les outils MAPLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

5
6

3.4 EXERCICES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.4.1 Mini-chaînes de Markov... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

4 Courbes de Bézier 39
4.1 Renault et Citroën . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.2 Algorithme de Casteljau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.2.1 Avec 3 points de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.2.2 Espace affine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.2.3 Avec 4 points de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.3 Avec un nombre quelconque de points de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4.4 Courbe de Bézier du 3e degré avec un nombre quelconque de points de contrôle . . . . . . . . . . . . 42
4.5 B-splines uniformes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4.5.1 Cas général . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4.5.2 Fonctions B-splines d’ordre 3 avec 4 points de contrôle . . . . . . . . . . . . . . . . . . . . . . . 43

5 Tapis, arbres, brocolis et lapins 44

5.1 Polygones de S IERPINSKI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.1.1 Jouons aux dés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.1.2 Tapis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.1.3 Les mites de S IERPINSKI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.1.4 Dentelle de Varsovie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.2 Végétation récursive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.3 Ensembles de J ULIA et de M ANDELBROT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 AU PROGRAMME

Voici quelques extraits du programme officiel :

L’informatique en classes préparatoires a pour principaux objectifs d’offrir dans le tronc com-
mun :
– Une familiarisation avec l’utilisation d’outils informatiques évolués (logiciel de calcul formel
et numérique, logiciels d’acquisition et de traitement de données, logiciels de modélisation,
logiciels de simulation...) en vue de permettre l’approfondissement des disciplines scientifiques
et techniques ;
– Une introduction à l’informatique en tant que discipline, par une initiation élémentaire au
traitement automatique de l’information, à l’algorithmique et à la programmation structurée
(illustrée à l’aide du langage du logiciel de calcul formel retenu).
[...]
On habituera les élèves à se servir de logiciels, qui fournissent un support au raisonnement par la
confrontation rapide et commode des hypothèses et résultats, et permettent :
– D’enrichir la compréhension des phénomènes mathématiques et des modèles physiques par la
simulation de leurs comportements en fonction de divers paramètres ;
– De mieux cerner la notion de domaine de validité d’une hypothèse ou d’une méthode par
l’étude de cas limites ;
– D’étudier certains problèmes par la mise en oeuvre de modèles dont la résolution numérique
manuelle serait trop lourde ou trop complexe ;
– D’alléger la part de calcul systématique au profit de l’intuition mathématique ou du sens phy-
sique.
[...]
La mise en œuvre de la programmation n’est pas séparée de l’utilisation du logiciel de calcul for-
mel en tant qu’outil et s’effectue à l’occasion des séances de travaux pratiques, appliquées à la
résolution de problèmes de mathématiques, de physique, de chimie, de mécanique et automa-
tique.
[...]
L’outil informatique n’est pas une fin en soi mais un moyen efficace pour faire des mathéma-
tiques, des sciences physiques ou des sciences industrielles.
8

À CENTRALE
Voici extrait du rapport du jury 2010 concernant l’oral de mathématiques II en série MP :

Présentation de l’épreuve
L’épreuve de Maths II est une épreuve de mathématiques assistée par ordinateur, en l’occurrence par l’usage d’un logiciel
de calcul formel. Elle comporte un seul exercice qui est préparé pendant 30 minutes avec accès libre à l’ordinateur ; puis le
candidat vient présenter pendant 30 minutes ses résultats et poursuivre la résolution de l’exercice au tableau. Une fois au
tableau, il est souhaitable d’indiquer succinctement les questions qui ont été élucidées pendant la préparation et ensuite de ne
pas trop perdre de temps sur les questions élémentaires, pour arriver au coeur du sujet. De façon générale, le candidat doit être
très attentif aux conseils et a fortiori aux indications données oralement, et surtout de ne pas s’enfermer dans une tentative
de résolution si l’examinateur lui indique qu’elle risque de conduire à une impasse : on aboutit à un échec donc à une perte
de temps qui empêchera la résolution d’autres questions. Il est essentiel que l’oral reste un dialogue, et une très bonne note
peut être attribuée à un candidat qui, sans avoir résolu l’exercice lors de la préparation, aura montré une bonne réactivité aux
indications proposées. Une des difficultés de cette épreuve est de savoir gérer l’aide que peut apporter le logiciel pour résoudre
la question mathématique posée. Les exercices comportent pour la plupart au moins une question à résoudre avec l’outil
informatique. Il est souvent attendu de pouvoir émettre une conjecture, qui sera démontrée dans la suite de l’exercice. Parfois,
l’énoncé conseille d’utiliser le logiciel à bon escient au cours de l’exercice, sans qu’il soit imposé pour une question précise : il
revient alors au candidat d’évaluer les questions où l’ordinateur lui apportera une aide précieuse. C’est par exemple le cas pour
des calculs auxiliaires de développements limités ou d’intégrales élémentaires (coefficients de Fourier ...), ou des résolutions
d’équations lors d’un exercice de géométrie : le logiciel permet d’alléger les calculs et d’éviter les erreurs liées au stress de
l’épreuve. Il faut par contre savoir être circonspect sur certaines réponses du logiciel : que penser d’un candidat qui ne réagit
pas face à l’affichage de valeurs propres « complexes » pour une matrice symétrique réelle, alors qu’une demande de valeurs
approchées montre que leurs parties imaginaires sont des 10^(-6)*I ? Il ne s’agit pas là de savoir comment fonctionne le
logiciel mais d’avoir un minimum de recul ou de prudence sur l’affichage de certains résultats.
[...]

Commentaires et conseils concernant l’usage du logiciel de calcul formel

L’impression générale est ici un peu mitigée. Et il semble utile de redonner une liste de « savoir-faire » déjà publiée dans le rap-
port 2009 et qui figure en Annexe. Le jury a vu avec plaisir environ un quart des candidats très bien préparés, très à l’aise avec
cet aspect de l’épreuve. Une majorité a montré l’habitude de côtoyer le logiciel et la connaissance des commandes usuelles.
Signalons qu’il n’est d’ailleurs attendu ni dextérité ni connaissance savante des options possibles d’une fonction prédéfinie ; et
il est normal et raisonnable qu’un candidat s’assure du bon emploi d’une fonction du logiciel en ayant recours à l’aide en ligne
(encore faut-il en connaître le nom... : alors pourquoi se priver très souvent de l’affichage à l’écran des fonctions résidant dans
une librairie, par un with(...): au lieu d’un with(...); du logiciel Maple ?). Par contre, il faut constater et regretter qu’un
trop grand nombre –même si c’est une minorité– continue à espérer découvrir les fonctions de base avec un usage fébrile de
l’aide en ligne pendant la préparation : cela se traduit par une lourde perte de temps, et le bilan est en général catastrophique :
aucun résultat ne sort d’une succession de lignes de code dont la plupart ont été rejetées par le logiciel.... À la moindre sol-
licitation de l’examinateur pour apporter les premières modifications permettant l’obtention d’au moins un résultat partiel
(faute de temps, il ne peut être question de corriger les fautes accumulées), la réponse « je n’ai pas pratiqué le logiciel cette
année » ne peut constituer une excuse. L’usage d’un logiciel de calcul formel figure pour tous, au programme des deux années
de classes préparatoires, et les candidats savent qu’ils en auront besoin lors de l’épreuve de maths II du concours Centrale. Le
jury sanctionnera plus nettement cette attitude désinvolte : on ne peut pas arriver à cette épreuve si on ne sait pas utiliser ef-
ficacement le logiciel. Le peu de programmation attendue ne dépasse pas l’écriture de boucles avec d’éventuelles instructions
conditionnelles ! Il ne s’agit pas d’un exercice d’algorithmique. Relevons quelques pratiques maladroites. On regrette d’abord
un recours trop systématique à l’écriture de nombreuses et inutiles procédures, quelle que soit la complexité de 32 Épreuves
orales Rapport du jury 2010 - Filière MP la question posée : cette démarche peut sembler tout à fait honorable, mais conduit
trop souvent hélas à un échec, et donc à l’absence de résultats effectifs ; or c’est le but attendu. Et puis c’est une mauvaise
compréhension de l’intérêt d’un logiciel de calcul formel : les fonctions prédéfinies sont là pour gagner du temps, et écrire une
procédure pour définir la fonction « factorielle » (exemple caricatural mais vu cette année) n’a aucun intérêt ici. En fait, il est
rarement indispensable d’écrire une procédure lors des questions proposées, ce qui ne signifie pas qu’elles sont parfois bien-
venues ; mais l’écriture directe d’une boucle est souvent suffisante. Il est nécessaire de savoir distinguer la manipulation des «
fonctions » et des « expressions », et d’estimer quand l’usage des unes ou des autres est plus favorable. Signalons que l’usage
des expressions est souvent plus souple lorsqu’il doit se doubler de la création d’un opérateur mathématique qui manipule ces
expressions. Certains ne savent d’ailleurs pas créer une suite, ou une fonction ; l’usage des crochets ou des parenthèses est mal
compris : u[n] ou u(n) ? Et plus gênant encore est de voir écrire des tentatives du type u(n):= ... ou f(x):= ... pour fabriquer

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 9

une fonction, et des candidats qui sont surpris que le logiciel ne réponde pas à leur attente ! ! Le logiciel met à disposition des
outils commodes pour créer des séquences de résultats. Combien de fois on a vu le recours à des copier-coller quand l’énoncé
demandait une séquence d’une dizaine ou d’une vingtaine de résultats (nécessaires à l’ébauche d’une conjecture « fiable ») ?
Il faut enfin savoir indiquer au logiciel qu’une variable est par exemple entière, réelle positive, etc... Et connaître quelques
commandes qui simplifient ou convertissent ou transforment des expressions sous une forme souhaitée.
Mais voici quelques points encore trop mal maîtrisés :
– la construction de matrices de taille variable. Il faut savoir fabriquer une fonction « définissante » des coefficients. On a ainsi
vu régulièrement des candidats contraints d’écrire une matrice 10*10 en tapant les 100 coefficients (dont beaucoup étaient
nuls heureusement) !
– savoir obtenir des valeurs approchées des racines d’une équation, savoir que l’affichage d’un seul résultat numérique ne se
traduit pas nécessairement par l’unicité d’une solution... ;
– pour le graphisme, il faut savoir superposer sur un même schéma divers types de graphes ;
– dans le cas particulier des équations différentielles, beaucoup ne savent pas visualiser le graphe d’une solution, lorsque le
logiciel n’en donne pas une expression exacte.
– proscrire l’ouverture et l’usage simultanés des librairies Maple linalg ET LinearAlgebra ;
– connaître les inconvénients ou avantages respectifs des commandes « sum » et « add » ...
[...]

Liste de savoir-faire conseillés pour l’épreuve assistée par un logiciel de calcul formel

Calcul algébrique (entiers, polynômes, équations)

– savoir calculer le quotient, le reste dans une division euclidienne dans Z, dans Q[X] ;
– savoir tester qu’un entier est premier, savoir travailler modulo n ;
– savoir factoriser (dans Q[X] et éventuellement dans une extension simple suggérée par l’énoncé), développer, ordonner un
polynôme ;
– savoir obtenir tous les coefficients, ou des coefficients précis d’un polynôme ;
– savoir calculer le pgcd de deux entiers, de deux polynômes ;
– savoir obtenir un couple donnant la relation de Bézout ;
– savoir déterminer les racines d’une équation (algébrique ou non) de façon exacte, de façon approchée ; savoir déterminer
une valeur approchée d’une racine localisée dans un intervalle ;
– savoir décomposer une fraction rationnelle en éléments simples dans Q(X) (éventuellement dans une extension simple de Q
suggérée par l’énoncé).

Calcul matriciel
– savoir construire une matrice dont les coefficients sont donnés par une formule fonction du couple (i, j), et dont la taille peut
être variable (il ne peut être question de se limiter à savoir entrer une matrice 3x3 par ses neuf coefficients) ;
– savoir calculer des produits matriciels, créer une matrice diagonale et a fortiori la matrice identité, former la transposée ;
– savoir calculer le rang, le noyau ou l’image (en obtenant une base de ces sous-espaces) ;
– savoir calculer le déterminant, éventuellement l’inverse, la comatrice (ou sa transposée) d’une matrice carrée ;
– savoir calculer le polynôme caractéristique d’une matrice carrée, ses valeurs propres, ses vecteurs propres ;
– savoir résoudre une équation d’inconnue matricielle (après l’avoir transformée en un ensemble d’équations scalaires d’in-
connues les coefficients) ;
– savoir calculer le produit scalaire, le produit vectoriel de deux vecteurs de R3 .

Fonctions d’une ou plusieurs variables réelles, calcul différentiel, calcul intégral

– savoir composer des fonctions (ou des opérateurs), calculer des dérivées d’ordre supérieur à un ;
– savoir calculer un développement limité, savoir extraire la partie régulière d’un tel développement ;
– savoir calculer une intégrale de façon exacte, de façon approchée, faire un changement de variable ou une intégration par
parties ;
– comprendre pourquoi le logiciel n’affiche pas toujours une limite explicite, ou le résultat d’un calcul d’intégrale, par manque
d’information sur la nature d’un paramètre introduit : savoir préciser à quelle partie de R il appartient (entier, réel positif... )

Suites et séries numériques, suites et séries de fonctions

– savoir expliciter les premiers termes (de façon exacte ou approchée) d’une suite numérique ou d’une suite de fonctions, en
particulier lorsqu’elle est définie par récurrence ;
– savoir obtenir un développement asymptotique d’une suite (fonction explicite de n) ;
– savoir calculer les coefficients de Fourier d’une fonction périodique ;
– savoir visualiser sur un même schéma les premiers termes d’une suite de fonctions.

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
10

Équations différentielles
– savoir résoudre une équation différentielle, un système d’équations différentielles, avec ou sans conditions initiales ;
– savoir récupérer une fonction solution et la tracer ;
– savoir tracer directement le graphe d’une solution obtenue par résolution numérique.

Graphisme
On a déjà évoqué le tracé de graphes de fonctions d’une variable réelle, de solutions d’une équation différentielle.
– savoir tracer une courbe du plan, définie par une équation cartésienne (de façon implicite), ou par un paramétrage, peut-être
en coordonnées polaires, et gérer les discontinuités ;
– savoir tracer une courbe paramétrée de l’espace ;
– savoir tracer une surface définie par un paramétrage, ou par une équation cartésienne ;
– savoir visualiser un ensemble de points, sous forme d’une ligne polygonale ou non.

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 1
CHAPITRE

Premiers pas en
Maple
12 1.1. AVANT DE COMMENCER

1 Avant de commencer

1 1 Entrée des instructions

Maple 12 offre pas mal de fioritures d’écriture qui peuvent être perturbantes.
Nous choisiront le mode le plus basique qui nous permettra plus facilement de repérer
nos erreurs. Pour cela, il faut aller dans le menu Tool/Options onglet Display op-
tion Input display où on choisira Maple Input. On peut aussi basculer en mode
« Text » avec la touche F5 .
Toutes les instructions sont tapées devant un « prompt » (invite en french) rouge : >. Elles
s’affichent en rouge. On termine son instruction obligatoirement par un point-virgule ( ;)
si l’on veut que la réponse de MAPLE soit affichée, ou par deux points ( :) si l’on veut que
MAPLE exécute notre instruction sans l’afficher.
Toutes les instructions entre deux prompts représentent une cellule.

Changer de ligne sans valider

Remarque On presse en même temps sur ⇑ et Entrée .

Pour faire exécuter l’ensemble d’une expression, on positionne le curseur sur n’importe
quelle ligne de la cellule et on presse la touche Entrée .
MAPLE répond en bleu.
Pour utiliser le dernier résultat renvoyé par Maple (au sens chronologique), on utilise %,
pour le pénultième, %%, pour l’antépénultième %%%, etc.
Par exemple, que répond la dernière instruction ?

> 2*3; %*5; %%-2; %%-2;

Vous avez perdu le curseur

Remarque
Réduisez votre fenêtre puis maximisez-la à nouveau.

1 2 Aide en ligne
Pour obtenir de l’aide, il y a trois possibilités :
– Tapez la commande qui vous intéresse, par exemple plot, puis selectionnez-la et tapez
F1 ;
– Tapez ?plot; puis Entrée ;
– Cliquez sur Topic search du menu Help.

1 3 Affectation
Pour stocker une valeur ( un nombre, une fonction, un graphique, etc. ) en mémoire, on
l’affecte à un nom de variable ( une étiquette ) en utilisant le symbole :=
Par exemple, si l’on veut affecter la valeur 2 à la variable « a », on tape :

> a:=2;

et on obtient
Réponse du logiciel

a:=2

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 CHAPITRE 1. PREMIERS PAS EN MAPLE 13

Pour ne pas afficher le résultat, on utilise « : » au lieu de « ; ».

On peut évaluer toute fonction de la variable « a » :

> a; a^2; cos(a); a/2;

On peut être amené à libérer une variable de son contenu.

On utilise unassign(’variable’) :

> unassign(’a’);
> a; a^2;

Pour libérer toutes les variables, on utilise restart.

Que se passe-t-il ici :

> x:=1; y:=2;

> x:=x+y;
> y:=x-y;
> x:=x-y;

et là :

> x:=100000; y:=0.0000002;

> x:=x+y;
> y:=x-y;
> x:=x-y;

1 4 Dangers de la modification d’une cellule

Avec Maple, vous pouvez revenir sur une cellule précédente et la modifier.

> a:=2;
> b:=a+3;
> c:=b^2;
> a+1;

Ah ! Vous vous êtes trompé sur la valeur de a qui vaut en fait −1 : vous la modifiez puis
validez avec ←- . Qu’observez-vous ?
Conclusion : l’ordre chronologique ne correspond pas toujours au sens de lecture de haut
en bas de l’écran.

1 5 Différents types de nombres

Comparez :

> 1+1/2+1/3;
> 1.+1/2+1/3;
> 1+1/2.+1/3;
> 1.+sqrt(2);
> 1+sqrt(2.);

Il n’y a rien de très rigoureux là-dedans : c’est du 100% subjectif made in Maple mais il faut
savoir comment Maple choisit de traiter les nombres.
Pour plus de sûreté, on utilisera evalf :

> evalf(sqrt(2));
> evalf[100](sqrt(2));

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
14 1.1. AVANT DE COMMENCER

1 6 Fonction et expression
On rentre une fonction comme on l’écrit. On utilise - et > pour faire ->

> f:=x->2*x+5;
> f(5);
> (f(a+h)-f(a))/h;

Il ne faudra pas confondre avec l’expression associée.

> restart;
> f:=2*x+1;
> f(5);
> (f(a+h)-f(a))/h;

Pour transformer une expression en fonction, on utilise :

unapply(expression,variable)

> f:=2*x+1;
> f(5);
> f:=unapply(f,x);
> f(5);

1 7 Opérations mathématiques de base

La multiplication s’obtient avec *, la division avec /, les puissances avec ^, la racine carrée
( SQuare RooT en anglais... ) avec sqrt(nombre).
On peut de plus résoudre des équations avec solve(équation,inconnue), calcu-
ler des limites avec limit(expression,x=a,direction) avec a un réel ou l’infini,
direction prenant les valeurs left ou right.
On calcule des dérivées avec diff(f(x),x), des intégrales avec int(g(x),x) ou bien
avec int(g(x),x=-a..b).
Avec les entiers, on utilisera irem(a,b) pour obtenir le reste entier. On obtient le même
résultat avec a mod b. Pour le quotient, c’est iquo(a,b) :

> irem(1258478957,12547);

On aura parfois besoin de simplifier une expression renvoyée par Maple. On utilisera alors
simplify ou bien parfois normal s’il s’agit d’une fraction rationnelle.

> g:=x->1/(1+x);
> e:=(g@@7)(x);
> normal(e);

L’opérateur de composition itérée est @@

1 8 Résolutions d’équations
La commande magique est solve(equation,variable) :

> solve(x^2-2*x+2,x);
> solve(x^2+x+1,x);
> solve(x^2+b*x+c,x);
> solve(x^2+b*x+c,b);

Il peut cependant y avoir quelques problèmes :

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 CHAPITRE 1. PREMIERS PAS EN MAPLE 15

> solve(x^5+x^3-5*x+1,x);
> solve(ln(x)=cos(exp(x)),x);

On peut cependant demander une valeur approchée des solutions avec fsolve.
Pour résoudre une équation dans Z, on utilise isolve (i comme integer) :

> isolve(51*x+44*y=1)

Pour les systèmes, on utilise les mêmes commandes mais avec une syntaxe adaptée :

> solve({x+y=1,x-y=2},{x,y});

La commande allvalues permet parfois de remplacer RootOf par sa valeur :

> e1:=x+y+z=1;
> e2:=x-y+z=2;
> e3:=x^2+1/y-1/z=2;
> sa:=fsolve({e1,e2,e3},{x,y,z});
> se:=solve({e1,e2,e3},{x,y,z});
> sv:=allvalues(se);

2 Les graphes

2 1 En dimension 2
La commande à utiliser est plot(expression,xmin..xmax,options). Les options
sont nombreuses...

> plot(sin(x),x=-4*Pi..5*Pi);
> plot(sin(x),x=-4*Pi..5*Pi,y=-2..5,color=wheat,labels=[’abscisse’,’
ordonnee’],title=’le beau dessin’);

L’accent grave
Remarque L’apostrophe utilisée s’obtient avec Alt Gr + 7 + Espace

Modifier la fenêtre peut être très utile. Par exemple, comment remédier à ce problème :

> plot(tan(x),x=-2*Pi..2*Pi);

On peut superposer des graphes :

> plot([sin(x),cos(x)],x=-3*Pi..2*Pi);
> plot([sin(x),cos(x)],x=-3*Pi..2*Pi,color=[navy,wheat],linestyle
=[2,3]);

pour plus de précisions, allez voir l’aide de plot.

Pour des fonctions définies par morceaux, on utilise piecewise. Par exemple :

restart:
> f:=x->piecewise(x<2,x*sin(x),x>=2,3*x^2+1);
> plot(f(x),x=-4..4,y=-10..30,discont=true);

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
16 1.3. QUELQUES ERREURS TYPES

Certaines courbes sont définies implicitement par une équation qui ne correspond pas à
une fonction. Par exemple, pour un cercle d’équation x 2 + y 2 + x − 3 = 0 :

> with(plots):
> implicitplot(x^2+y^2+x-3=0,x=-5..5,y=-2..2,color=blue);

On peut définir des fonctions à l’aide de procédures (que nous étudierons bientôt...)

> F:=proc(x)
if x<=0 then x+1
else sin(x)/x
fi
end:

On peut alors obtenir le graphe avec au choix :

> plot(F,-3..3)

ou

> plot(evaln(F(x)),x=-3..3)

Notez la différence...evaln signifiant « evaluate as a name »

Pour les courbes en polaire, on utilise l’option coords=polar :

plot(3*cos(t)-4*sin(t),t=0..2*Pi,coords=polar)

2 2 Animations
On peut créer une animation en créant une séquence de graphes dépendant d’un para-
mètre.
On va utiliser seq(expression dépendant de a, valeurs prises par a)
Par exemple :

> g:=seq(plot(sin(a*x),x=-5..5),a=[-1,0,1,2,3,4,5]):

Pour afficher l’animation, on doit aller chercher la commande display dans la biblio-
thèque plots qui n’est pas chargée par défaut avec la commande with et lui indique
l’option insequence=true pour ne pas afficher tous les graphes en même temps :

> with(plots):
> display(g,insequence=true);

Vous cliquez sur le graphe et une barre d’icône apparaît pour lancer l’animation.
Il n’y a pas assez de valeurs de a. On peut en créer toute une série avec seq :

> g:=seq(plot(sin(a*x),x=-5..5),a=[seq(-1+0.01*h,h=0..100)]):

3 Quelques erreurs types

Voici une série d’erreurs que l’on retrouve souvent : il faut savoir les corriger seul(e)...
Partons d’un code correct :

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 CHAPITRE 1. PREMIERS PAS EN MAPLE 17

> f:=x->sin(x)/x;
> a:=20;
> plot(f(x),x=-a..a);

Ça marche.
Mais

> restart;
> f:=x->sin(x)/x;
> a=20;
> plot(f(x),x=-a..a);

ne marche plus : pourquoi ?

Et pour ceci :

> restart;
> f=x->sin(x)/x;
> a:=20;
> plot(f(x),x=-a..a);

Le message d’erreur est différent mais c’est le même type d’erreur.

La plus fréquente des erreurs :

> a:=20

à égalité avec celle-ci :

> restart;
> f:=x->sin(x)/x;
> a:=20;
> plt(f(x),x=-a..a);

Sans oublier celle-ci :

> restart;
> f:=x->sin(x)/x;
> a:=20;
> plot(,x=-a..a);

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
18 1.4. EXERCICES

EXERCICES
1 -1 1 -5
Explorez les fonctions Parmi les exercices d’analyse faits en classe, reprenez
ceux où MAPLE aurait pu vous aider.
f : x 7→ x 4 − 2x 2 + 3
s 1 -6
x 2 − 2x + 2 On considère la fonction f : x 7→ x 3 − 2x 2 + 1. Créez
g : x 7→
x2 + 4 une animation permettant de comparer différentes sé-
h : x 7→ arcsin(x) − ln(x) cantes passant par le point de coordonnées (2, f (2)) et
la tangente à C f en ce même point.
(limites, dérivées, signe de la dérivée, graphe...)
On peut procéder ainsi : 1 -7
Trouvez le dernier chiffre de l’écriture décimale de
> f:=x->1/(x-1/2):
2013
> valx:=[1,2,3,5,10,15,20,100]: 20072011
> valfx:=seq([x,f(x)],x=valx):
> titre:=[’x’,’f(x)’]: 1 -8
> array([titre,valfx]); Vous savez que Giralomo C ARDANO a établi en 1547
qu’une solution de l’équation x 3 + px + q = 0 est :
sachant que array(liste) crée un tableau. v s v s
q2 p3 q2 p3
u u
Définissez également un tableau de valeurs pour les 3 −q
u
t 3 −q
u
t
trois fonctions. + + + − +
2 4 27 2 4 27
1 -2 Sans utiliser la touche solve, résolvez les équations :
La position d’un mobile en mouvement harmonique
a. (E1 ) : x 3 − 36x − 91 = 0
amorti est donné par l’équation :
b. (E2 ) : x 3 − 15x − 4 = 0
2 4
µ ¶
x(t ) = e−0,1t sin(10t ) + cos(10t ) Vous pouvez essayer de prouver la formule en posant
3 5
x = u + v et en résolvant un système d’équations d’in-
Déterminez les trois premiers instants où la vitesse du connues u et v.
corps est nulle.
1 -9
x
1 -3 Dérivez x (x ) deux fois puis intégrez deux fois.
Trouvez les constantes a et b qui rendent la fonction Faites de même avec (x x )x .
suivante continue sur R à l’aide de MAPLE :
1 - 10
 À l’aide de la fonction sum, vérifiez que
x 2 + bx + 1 si x < 5 7 1 13 135

p
 µ ¶
2 = 1+

 + + +···
f (x) = 8 si x = 5 5 100 100200 100200300



ax + 3 si x > 5

1 - 11

La cycloïde est la courbe paramétrée définie par
Vous utiliserez piecewise, solve, limit. (
x(t ) = t − sin(t )
Pour avoir la limite à gauche en xo on entre .
limit(f(x),x=xo,left). y(t ) = 1 − cos(t )
a. Tracer cette courbe pour t ∈ [0, T], avec T = 15.
1 -4
Trouvez les constantes a, b et c telles que le graphe de b. Construire une animation de paramètre t ∈ [0, T]
f : x 7→ 3x 4 + ax 3 +bx 2 +c x +d ait des tangentes hori- dont le graphique au temps t est constitué du
zontales en (2 ; −3) et (0 ; 7). Tracez le graphe associé. cercle de rayon 1 et de centre (t , 1).
Il y a un troisième point où la tangente est horizon- c. Construire une animation de paramètre t ∈ [0, T]
tale : trouvez-le ! Vérifiez ensuite s’il s’agit de maxima dont le graphique au temps t est constitué du
ou de minima relatifs ou ni l’un ni l’autre. cercle de rayon ε = 0.08 et de centre (x(t ), y(t )).

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 CHAPITRE 1. PREMIERS PAS EN MAPLE 19

d. Construire une animation de paramètre t ∈ [0, T]

dont le graphique au temps t est constitué du mor-
ceau de cycloïde délimité par les points (0, 1) et
(x(t ), y(t )).
e. Afficher les trois animations sur un même gra-
phique (à l’aide de la fonction display).
f. Comment interpréter la cycloïde en terme de tra-
jectoire ?

Merci à Magali H ILLAIRET pour ce bel exercice...

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 2
CHAPITRE

Programmer avec
Maple
 CHAPITRE 2. PROGRAMMER AVEC MAPLE 21

1 Quelques rappels
Quelques rappels avant de travailler. Commencez chaque nouvel exercice par un

> restart;

pour « désaffecter » toutes les variables éventuellement utilisées dans un calcul précédent.
Si vous avez lancé un calcul qui a l’air de ne pas vouloir se terminer, cliquez sur l’icône
STOP qui n’est active que lorsqu’un calcul est en cours.
Chacune de vos entrées débute après un pr ompt >, se termine par un ; a ou un : b puis
appuyez sur la touche Entrée . Si vous voulez passer à la ligne sans valider la ligne pré-
cédente, tapez ⇑ + Entrée . Pour revenir plus haut, utilisez la souris ou les flèches de
déplacement.

2 Listes et séquences

2 1 Listes
Les listes sont un type de variable particulier que peut manipuler MAPLE. Une liste se pré-
sente sous la forme d’une suite d’objets séparés par des virgules entre crochets :

> L:=[1,2,a,g,maman,ln(5),3/2,x->3*x+2,[7,9]]

Cette suite est ORDONNÉE. Ses éléments sont donc numérotés. On peut en extraire un
élément particulier :

> L[5]

> L[9]

> L[9][1]

ou bien tous les éléments de la liste :

op(L)

ou bien une sous-liste :

> L[3..6];

On peut connaître la taille d’une liste :

> nops(L);

On peut ajouter un élément à une liste :

> L:=[op(L),nouveau]

On peut concaténer deux listes :

a. si vous voulez que le résultat soit affiché.
b. si vous voulez que MAPLE exécute sans afficher.

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
22 2.3. ALGORITHME ET PROGRAMME

> L1:=[1,2,3,4];
> L2:=[a,b,c];
> L:=[op(L1),op(L2)]

La liste vide se note :

> V:=[];
> nops(V);

On peut effectuer des opérations sur une liste car c’est un type de variable comme un autre :

> S:=L1+[op(L2),d];
> P:=3*L1;

2 2 Les séquences
Elles ressemblent aux listes mais sans les crochets. La différence majeure est pourtant qu’on
ne peut pas créer des séquences de séquences alors qu’on peut créer des listes de listes.
Plus accessoirement, on peut modifier un élément d’une liste à l’aide d’une affectation mais
ce n’est pas possible pour une séquence :

> S:=a,b,c,d,e,f;
> S[3];
> S[3]:=4;
> L:=[S];
> L[3]:=4;
> L;

En général, elles servent à fabriquer des listes...

> S1:=10,20,30,40,50,60;
> S2:=seq(10*k,k=3..10);
> S3:=10*k $ k=2..9;
> S4:= m $ 5;

3 Algorithme et programme

Un algorithme est une description rigoureuse en un nombre fini

d’étapes de la résolution d’un problème.
La notion d’algorithme existe depuis bien avant l’existence des ordi-
nateurs et même bien avant la naissance du mot lui-même puisqu’il
est tiré du nom du célèbre mathématicien persan ‫دمحم هللا دبع وبأ‬
‫ یمزراوخلا یسوم نب‬ou si vous préférez Abu ’Abdallah Muhammad ibn
Musa al-Khwarizmi qui vécut au IXe siècle de notre ère, c’est-à-dire
près de 3000 ans après les premiers algorithmes de calcul connus
mis au point en Mésopotamie.
Vous utilisez depuis longtemps des algorithmes, à la manière de M. Jourdain, sans toujours
le savoir, par exemple lorsque vous lisez une recette de cuisine, lorsque vous recherchez un
mot dans le dictionnaire, lorsque vous effectuez une addition posée.
Cependant, cette année, nous nous contenterons d’algorithmes destinés à être utilisés par
un ordinateur. Nous introduirons donc un langage algorithmique le moins ambiguë pos-

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 CHAPITRE 2. PROGRAMMER AVEC MAPLE 23

sible et le plus standard afin de pouvoir mettre en œuvre ces algorithmes sur n’importe
quelle machine.
Même si nos algorithmes doivent être indépendants de tout langage de programmation, il
sera enrichissant de les tester « en vrai » sur machine. Nous serons donc amenés à parler à
la machine. Pour cela nous utiliserons un langage servant d’interface entre la machine et
nous car tout être humain normalement constitué ne peut décemment entamer une longue
conversation avec un ordinateur en langage machine.
C’est bien sûr Maple qui sera notre langage. Ceux d’entre vous qui choisirons l’option info
utiliseront plutôt le langage Pascal.

4 Quelques types prédéfinis

Les variables, les constantes, les arguments introduits dans les algorithmes peuvent être de
types différents. Tous les langages ont des types prédéfinis à peu près communs.
Sur Maple, les principaux types sont float, integer, negint, nonnegint, fraction,
list, etc.
Consultez l’aide : ?type;

4 1 Les entiers
Un entier naturel est un entier positif ou nul. Le choix à faire (c’est-à-dire le nombre de
bits c à utiliser) dépend de la fourchette des nombres que l’on désire utiliser. Pour coder
des nombres entiers naturels compris entre 0 et 255, il nous suffira de 8 bits (un octet) car
28 = 256. D’une manière générale un codage sur n bits pourra permettre de représenter
des nombres entiers naturels compris entre 0 et 2n−1 . Les processeurs disponibles actuel-
lement proposent des codages sur 32 ou 64 bits. Cependant, les logiciels ne tiennent pas
toujours compte des 64 bits et vous avez beau disposer d’un processeur 64 bits, il sera uti-
lisé comme s’il était de type 32 bits (notamment si le système d’exploitation est microsoft-
windows...).
Pour représenter un nombre entier naturel après avoir défini le nombre de bits sur lequel
on le code, il suffit de ranger chaque bit dans la cellule binaire correspondant à son poids
binaire de la droite vers la gauche, puis on « remplit » les bits non utilisés par des zéros.
Pour les entiers relatifs, le bit situé à l’extrême gauche (le bit de poids fort), représentera le
signe : 0 pour un nombre positif, 1 pour un nombre négatif. Cela restreint donc l’étendue
des nombres disponibles.
Un entier relatif positif est donc codé comme un entier naturel mais avec un 0 à gauche.
Pour les entiers négatifs, on utilise une petite ruse : le complément à 2 que nous étudierons
à titre d’exercice.
Ainsi, sur les ordinateurs qui sont à notre disposition, tout introduction d’un entier dépas-
sant 231 − 1 = 2 147 483 647 engendrera une erreur.

4 2 Les flottants
La norme IEEE définit la façon de coder un nombre réel. Cette norme se propose de coder
le nombre sur 32 bits et définit trois composantes :
– le signe est représenté par un seul bit, le bit de poids fort (celui le plus à gauche) ;
– l’exposant est codé sur les 8 bits consécutifs au signe ;
– la mantisse, c’est-à-dire le nombre « sans la virgule », sur les 23 bits restants.
La précision des nombres réels est approchée. Elle dépend du nombre de positions déci-
males, suivant le type de réel elle sera au moins :
– de 6 chiffres après la virgule pour un système 32 bits ;
– de 15 chiffres après la virgule pour un système 64 bits.
c. Le mot « bit » est la contraction des mots anglais binary digit, qui signifient « chiffre binaire », avec un jeu de mot sur bit, « morceau ». Il
ne faut pas confondre avec le mot « byte », en français « multiplet », qui désigne un assemblage de bits, en général 8 (un octet).

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
24 2.4. QUELQUES TYPES PRÉDÉFINIS

Ces limitations peuvent causer quelques surprises. Par exemple, vous pouvez tester sur
Maple :

> 100000+0.0000002;

Réponse du logiciel

100000

Ces problèmes d’implémentation des entiers et des flottants ne concernent pas l’algo-
Remarque
rithmique mais la programmation dans un certain langage, sur un certain système.

4 3 Les caractères et chaînes de caractères

Le type « caractère » permet de stocker le code d’un caractère, c’est-à-dire un nombre entier.
Une chaîne de caractères est une suite ordonnée de caractères. La représentation d’une
chaîne de caractères dépend d’un système à un autre.

4 4 Les booléens
Avant d’étudier les structures conditionnelles, il nous faut nous habituer aux tests, aux boo-
léens et à leurs opérateurs, qui ne sont pas d’un usage aussi naturel que les types flottants
et entiers.
– Une variable de type booléen n’a que deux valeurs possibles : VRAI ou FAUX.
– Ces booléens sont en particulier les valeurs retournées par les opérateurs de comparai-
son : =, <, <=, >, >=, <>.
– Ils ont en général 4 opérateurs : ET, OU, OUEX, NON.

Par exemple, quelle sera la réponse à :

– 3 > 2 ET 2 > 2 ?
>
– 3 > 2 ET 2 2 ?
– 3 > 2 OU 2 > 2 ?
Recherche >
– 3 > 2 OU 2 2 ?
– 3 > 2 OUEX 2 2 ? >
– 3 > 2 OUEX 2 > 2 ?
– NON 2 > 2 ?
– NON 3 > 2 ?

Sur Maple, les opérateurs logiques sont and et or. Il y a aussi not qui donne la négation.

Recherche Que dire du or de Maple ?

Il existe une bibliothèque dédiée à la logique qui logiquement s’appelle logic.

Quand une expression ne contient pas and, or ou not, il faut utiliser evalb ou is :

> evalb(3>2);

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 CHAPITRE 2. PROGRAMMER AVEC MAPLE 25

type de nombre
On ne peut comparer que des nombres de type numeric (i.e. integer, float et
fraction) :

> evalb(3>2.);
Danger > evalb(3>7/2);
> evalb(sqrt(2)>1);
> evalb(sqrt(2.)>1);

Cependant, cela fonctionne avec is mais cela ne fonctionnera pas avec les tests de
boucles et de structures conditionnelles.

5 Les structures conditionnelles

Elles sont communes aux deux types de programmation que nous étudierons. C’est le fa-
meux SI...ALORS...SINON...
Voici un bel algorithme :

Fonction zorg( a,b,c : entier ) : chaîne

Début
Si a<>b Alors
Si a+1=b Alors
Retourner ’aarrgh’
Sinon
Si c<>7 Alors
Retourner ’glurp’
Sinon
Retourner ’pas glop’
FinSi
FinSi
Sinon
Retourner ’eviv bulgroz’
FinSi
Fin

Que répond
– zorg(4,5,7) ?
Recherche
– zorg(4,5,8) ?
– zorg(4,6,7) ?

Sur Maple, on utilise la valeur d’un test pour exécuter une instruction conditionnelle dont
la syntaxe est :

if condition then instruction1 else instruction2 fi ;

Par exemple :

> if (3>2) then print(’bonjour’) else print(’salut’) fi;

> if (3<2) then print(’bonjour’) else print(’salut’) fi;

On peut écrire des instructions conditionnelles en cascade :

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
26 2.6. PROCÉDURES

if condition1 then instruction1 elif condition2 then instruction2 else instruction3 fi ;

Par exemple :

> a:=1; b:=1; c:=1;

> if (b^2-4*a*c>0)
then print(‘2 solutions reelles‘)
elif (b^2-4*a*c=0)
then print(‘1 solution reelle‘)
else print(‘2 solutions complexes conjuguees‘)
fi;

6 Procédures
Une procédure est une fonction à la syntaxe précise dépendant de la donnée d’une série
d’arguments et d’une série d’instructions.
La syntaxe générale est :

> nom:=proc(argument1::type1,argument2::type2,.....)
local var1, var2,... ;
instructions
end:

Les variables locales sont celles introduites dans la procédure et dont les noms seront « désaf-
fectés » à la fin de la procédure.

première ligne
Danger
Pas de point-virgule sur la première ligne contenant proc !

Par exemple :

> Table:=proc(n::posint)
local T,k;
T:=[seq(n*k,k=1..10)];
printf("La table de %a est %a",n,T)
end:

Vous pourrez regarder la syntaxe de printf. L’usage des %a indique qu’on va les remplacer
dans l’ordre par les variables formelles qui sont listées après les guillemets. Pour avoir des
nombres flottants on utilise %f.
Par exemple, pour obtenir la table de 5 on tape :

> Table(5);

On a souvent besoin du résultat d’une procédure et la petite phrase « pour faire joli » peut
être gênante.
On préférera une procédure de cette forme :

> Table:=proc(n::posint)
local k;
RETURN([seq(n*k,k=1..10)])
end:

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 CHAPITRE 2. PROGRAMMER AVEC MAPLE 27

On peut ainsi afficher le deuxième élément de la table de 5 :

> Table(5)[2];

Recherche Que donne Table(-5) ?

On peut utiliser une structure conditionnelle :

> parite:=proc(n::integer)
if (irem(n,2)=0)
then RETURN(‘pair‘)
else RETURN(‘impair‘)
fi
end:

Recherche À votre avis, que renvoie irem(a,b) ?

7 La programmation impérative : au plus près de la machine

Un algorithme impératif va modifier chronologiquement l’état de la mémoire (voir la sec-
tion 1.1.3 page 12). Les valeurs des variables vont sans cesse évoluer. Cependant, la plupart
du temps, les notations des structures itératives utilisées n’expriment pas clairement l’état
des variables. Il faudra donc, pour bien maîtriser l’algorithme, le commenter pour décrire
les états parcourus par le système.

On veillera à ne pas modifier les arguments d’une fonction avec quelque chose du
style :

> non:=proc(a,b,c)
a:=a+1;
RETURN(a);
end:

Il faut introduire une variable locale prenant au départ la valeur de l’argument puis la
Danger
modifier :

> oui:=proc(a,b,c)
local temp;
temp:=a;
temp:=temp+1;
RETURN(temp);
end:

7 1 Structures itératives

Exemple
Soit deux entiers naturels n et N tels que n 6 N. On voudrait calculer la somme des
entiers de n à N.

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
28 2.7. LA PROGRAMMATION IMPÉRATIVE : AU PLUS PRÈS DE LA MACHINE

Les notations mathématiques peuvent ici nous guider. En effet, cette somme S(n, N) s’écrit :

k=N
k = n + (n + 1) + (n + 2) + · · · + (N − 1) + N
X
S(n, N) =
k=n

7 1 a Tant que

Fonction somme( n,N : entier ) : entier

{ On doit avoir n<=N. On obtient la somme des entiers successifs de n à N
compris }
{ Nous allons créer une variable provisoire qui contiendra la somme en
construction ainsi que l’entier provisoire qui va être itéré. }
Variable
Stemp,ktemp :
Début
Stemp← 0
ktemp ← n
{ On choisit d’initialiser la somme à 0 et l’indice d’itération à n. }
TantQue ktemp <= N Faire
{ On entre dans la boucle jusqu’à la valeur N comprise }
Stemp← Stemp+ktemp
{ À l’état initial on commence donc par rajouter n à 0 }
ktemp← ktemp+1
{ ktemp est incrémenté après la somme. }
{ À la dernière étape, ktemp vaut N, }
{ est rajouté à Stemp puis ktemp reçoit N+1 }
{ et on sort donc de la boucle. }
{ Dans l’état final on a donc la somme des entiers de n à N. }
FinTantQue
Retourner Stemp
Fin

Avec Maple :

> Somme:=proc(n,N)
local Stemp,ktemp;
Stemp:=0;
ktemp:=n;

while ktemp<=N do
Stemp:=Stemp+ktemp;
ktemp:=ktemp+1;
od;

RETURN(Stemp)
end:

Vérifions que notre algorithme fait bien ce qu’on attend de lui.

La propriété P (ktemp) : « Stemp= S(n,ktemp) et ktemp 6 N » est l’invariant de boucle.
Au départ, on a bien P (n) : Stemp= S(n, n) = n et n 6 N.
À chaque fin d’occurrence de la boucle, cette propriété reste vraie ainsi qu’en sortie.

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 CHAPITRE 2. PROGRAMMER AVEC MAPLE 29

On modifie légèrement l’ordre des instructions de cet algorithme :

ktemp← ktemp+1
Recherche
Stemp← Stemp+ktemp

Y a-t-il d’autres choses à modifier ?

7 1 b Pour
En anglais, c’est « for » :

for var from debut to fin by increment do

instructions;
od;

Par exemple :

> Somme:=proc(n::posint)
local S,k;
S:=0;
for k from 1 to n by 1 do
S:=S+k;
od;
RETURN(S)
end:

On peut arrêter l’itération dès qu’une condition a été réalisée (et se passer du to) :

> Somme:=proc(n::posint)
local S,k;
S:=0;
for k from 1 while P<=n do
S:=S+k;
od;
RETURN(S)
end:

Expliquez....

8 Au plus près de l’humain : la programmation récursive

8 1 Qu’est-ce que c’est ?

La récursion est un mécanisme puissant permettant, comme l’itération, d’exprimer la ré-
pétition des opérations, mais de manière plus concise et en ayant la possibilité de se passer
d’affectation et ainsi éviter les problèmes de surveillance de l’état de la mémoire.
Il ne se limite pas au cas des suites numériques définies par une relation de récurrence.
Par exemple, définissons un n caractère comme
o un élément de l’ensemble constitué des 26
0 0 0 0
lettres de l’alphabet latin : a , b , · · · , 0 z0
On peut donner une définition récursive d’un mot :
Un mot est soit un caractère, soit un caractère suivi d’un mot.
Sur Maple, reprenons un exemple du paragraphe précédent :

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
30 2.8. AU PLUS PRÈS DE L’HUMAIN : LA PROGRAMMATION RÉCURSIVE

> Somme_r:=proc(n::posint)
if n=1 then 1
else Somme_r(n-1)+n;
fi;
end:

Il faut connaître un cas simple et un moyen de simplifier un cas compliqué...

On peut obtenir les résultats intermédiaires avec l’option remember et en demandant le
quatrième opérande de la procédure :

> Somme_r:=proc(n::posint)
option remember;
if n=1 then 1
else Somme_r(n-1)+n;
fi;
end:

Puis :

Somme_r(9);
op(4,eval(Somme_r));

Cette option est malgré tout plus intéressante dans le cas de récursions multiples : les cal-
culs intermédiaires étant stockés, ils n’ont pas à être recalculés et cela gagne du temps.
Par exemple, pour la suite de Fibonacci u n+2 = u n+1 + u n avec u 0 = u 1 = 1 :

> fibo:=proc(n::nonnegint)
option remember;
if n=0 then RETURN(1);
elif n=1 then RETURN(1);
else RETURN(fibo(n-1)+fibo(n-2));
fi
end:

Sans l’option remember, fibo(30) prend pas mal de temps mais est instantané quand on
l’ajoute : à ne pas oublier...

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 CHAPITRE 2. PROGRAMMER AVEC MAPLE 31

EXERCICES
2 -1 Valeur absolue continue sur un intervalle [a; b] par la méthode des
rectangles puis celle des trapèzes.
Écrivez un algorithme qui renvoie la valeur absolue
d’un réel x. 2 -8 Suite

2 -2 Système On veut étudier la suite de terme général u n = n12 ainsi

n
u k , avec n ∈ N∗ .
X
que la suite v n =

k=1

a
11 x + a 12 y = b 1
Soit un système . Proposez un algorithme qui affiche u n et v n pour une

a
21 x + a 22 y = b 2 valeur de n donnée.
Déterminez un algorithme qui renvoie la solution de
ce système si elle est unique. 2 -9 Maximum

2 -3 Années bissextiles Donner des procédures impératives et récursives don-

nant le maximum d’une liste de nombres réels quel-
Une année bissextile est une année dont le millésime, conques.
supérieur à 1583, est divisible par 4, sauf les limites de
siècles qui ne sont pas multiples de 400. 2 - 10 Tête et queue
Ainsi 2 000 et 2 008 sont bissextiles mais 2 100 et 2 011
ne le sont pas. La tête d’une liste est son premier élément. La queue
Définissez alors un algorithme qui reconnaît si un mil- d’une liste est la sous-liste créée en lui coupant
lésime est celui d’une année bissextile. Vous pourrez la tête. Donnez deux procédures tete(liste) et
utiliser la fonction irem qui donne le reste de la divi- queue(liste).
sion euclidienne.
2 - 11 test de croissance
2 -4 Conversion
Donner des procédures impératives et récursives dé-
Déterminez un algorithme qui reçoit un nombre en- terminant si une liste donnée est croissante. On pourra
tier de secondes et qui renvoie quatre entiers corres- éventuellement utiliser tete et queue.
pondant à sa conversion en jours, heures, minutes et
secondes. On pourra utiliser une fonction « quo » qui 2 - 12 Dichotomie
renvoie le quotient entier de la division de deux en-
tiers. Pour résoudre une équation du type f (x) = 0, on re-
cherche graphiquement un intervalle [a, b] où la fonc-
2 -5 Partie entière
tion semble changer de signe.
On note ensuite m le milieu du segment [a, b]. On éva-
Donnez un algorithme impératif et récursif renvoyant lue le signe de f (m).
la partie entière d’un réel x. Si c’est le même que celui de f (a) on remplace a par
2 -6 Division euclidienne m et on recommence. Sinon, c’est b qu’on remplace et
on recommence jusqu’à obtenir la précision voulue.
Donner une procédure récursive puis une procédure
Déterminer un algorithme impératif et récursif qui
impérative prenant comme arguments une fonction f ,
renvoie le quotient de deux entiers naturels non nuls
les bornes de l’intervalle d’étude a et b et une précision
a et b.
de calcul eps.
Déterminer un algorithme qui renvoie le reste entier
de a et b. 2 - 13 Héron
2 -7 Intégration numérique
H ÉRON d’Alexandrie a trouvé une méthode permettant
Déterminez un algorithme qui donne une valeur ap- de déterminer une approximation de la racine carrée
Z t =b d’un nombre positif vingt siècles avant l’apparition des
prochée de f (t ) dt pour une certaine fonction f ordinateurs.
t =a

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
32 2.9. EXERCICES

Si x n est une approximation strictement positive par 2 - 18 Algorithme glouton

p
défaut de a, alors a/x n est une approximation par ex-
p
cès de a (pourquoi ?) et vice-versa. On dispose d’au moins deux types de pièces de valeurs
La moyenne arithmétique de ces deux approximations premières entre elles et on veut rendre la monnaie en
est 12 x n + xan et constitue une meilleure approxima-
³ ´
utilisant le moins de pièces possibles.
tion que les deux précédentes. Une première idée est de répéter le choix de la pièce de
On peut montrer c’est une approximation par excès plus grande valeur qui ne dépasse pas la somme res-
¡ p ¢2 tante puis de répéter le test avec le pièce de valeur in-
(en développant x n − a par exemple).
On obtient naturellement un algorithme... Donnez férieure : c’est un exemple d’algorithme glouton.
une version récursive puis impérative prenant en argu- Écrivez une procédure MAPLE
ment le nombre dont on cherche la racine carrée, une piece_glouton:=proc(n,L)
première approximation x 0 et une précision eps. qui donnera la décomposition de la somme d’argent n
en utilisant les pièces de monnaies dont les montants
2 - 14 Décimales de e appartiennent à la liste L.
Vous utiliserez des boucles while, les opérateurs and,
+, - et >.
Posons e n = 1 + 11! + 21! + · · · + n!
1
Ainsi, pour savoir comment former 39 centimes avec
Alors on a aussi
nos pièces européennes, on entrera sur MAPLE :
1 1 1 1 1
µ µ µ µ µ ¶¶¶¶¶
en = 1 + 1 + 1 + 1 + · · · 1+ > piece_glouton
2 3 4 n −1 n
(39,[1,2,5,10,20,50,100,200])

Un exercice classique montre que e − e n n+2 1 6

n+1 (n+1)! . et on obtient [20,10,5,2,2].
Ainsi, pour n = 167, on obtiendra 300 bonnes déci-
On rappelle que nops(L) renvoie le nombre d’élé-
males au moins : trouvez-les !
ments d’une liste L, et que L[k] renvoie son k-eme
2 - 15 Somme de chiffres élément.

2 - 19 Base 2
Proposez un algorithme qui prend en argument un en-
tier écrit en base 10 et qui calcule la somme des chiffres Donnez une procédure MAPLE base_deux:=proc(n)
composant cet entier. qui renvoie la liste des chiffres de la décomposition de
On pourra utiliser la fonction irem n en base 2.
On pourra utiliser les commandes iquo(a,b) et
2 - 16 Trapèzes irem(a,b) qui donnent respectivement le quotient
et le reste de la division euclidienne de l’entier a par
Soit f une fonction continue sur un intervalle [a, b]. l’entier b.
On suppose que cette fonction f est définie sur On rappelle qu’on rajoute un élément e à la fin d’une
MAPLE. liste L en tapant [op(L),e]
Déterminez une procédure trap:=proc(f,a,b,dx)
qui donne l’approximation de l’intégrale sur [a, b] de
f par la méthode des trapèzes en utilisant une subdi-
vision de largeur dx.
Vous en donnerez une version récursive et une version
impérative.

2 - 17 tests

On définit simultanément deux fonctions truc et

machin :

truc(n):=n<>1 and (n=0 or machin(n-1))

and
machin(n):=n<>0 and (n=1 or truc(n-1))

Spécifiez au mieux ces deux fonctions.

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 3
CHAPITRE

Tableaux et
matrices
34 3.1. ÉTOILES ET ESPACES

1 Étoiles et espaces
La commande array(1..n,1..m) construit un tableau de n lignes et m colonnes.
Que fait cette procédure :

> mystere:=proc(n)
local T,j,i;
T:=array(1..n,1..n);
for j from 1 to n do
for i from 1 to n do
if j>i then T[i,j]:=‘‘;
fi;
od;
od;
print(T);
end:

Transformez-la un peu pour obtenir ceci avec n = 10 par exemple :

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1

Complétez cette dernière procédure afin de remplacer chaque nombre pair par une espace
‘ ‘ et chaque nombre impair par une étoile ‘*‘. Lancez-la pour n = 48 : incroyable,
non ?

2 Fabriquons nos outils

2 1 Création d’une matrice

Dans cette section, nous créerons nos matrices à l’aide de la commande array(1..n,1..m)
vue lors du TD précédent ou directement comme une liste de listes représentant les lignes.
 
1 2
 
3
Par exemple,  4
 sera rentré avec :
5 6
> M:=[[1,2],[3,4],[5,6]];

Comment faire calculer le nombre de lignes et le nombre de colonnes de M à MAPLE ?

2 2 Somme de matrices
Créez une procédure qui prend comme arguments deux matrices et renvoie leur somme.
Elle commencera par :

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 CHAPITRE 3. TABLEAUX ET MATRICES 35

> somm:=proc(A,B)
local C,i,j,k;
C:=[[0$nops(A[1])]$nops(A)];
?...?
RETURN(C);
end:

2 3 Produit de matrices
Soit A = (a i j ) 16i 6n et B = (b i j ) 16i 6m .
16i 6m 16i 6p
Alors AB = C avec C = (c i j ) 16i 6n et
16i 6p

m
∀(i , j ) ∈ N∗n N∗p ,
X
ci j = ai k · bk j
k=1

Créez alors une procédure qui prend comme arguments deux matrices et renvoie leur pro-
duit. Elle commencera par :

> prodm:=proc(A,B)
local C,i,j,k;
C:=[[0$nops(B[1])]$nops(A)];
?...?
RETURN(C);
end:

Vous n’utiliserez que des boucles (pas de fonctions de calcul formel !).

2 4 Matrice identité
Créer une procédure Id:=proc(n) qui crée la matrice identité d’ordre n.

2 5 Puissances d’une matrice

Tout est dans le titre...

> puim:=proc(A,n)
?...?
end:

2 6 Trace d’une matrice

Tout est dans le titre...

> Tracem:=proc(A)
?...?
end:

2 7 Transposée d’une matrice, matrices orthogonales

Tout est dans le titre...

> Transm:=proc(A)
?...?
end:

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
36 3.3. AVEC LES OUTILS MAPLE

On appelle matrice orthogonale une matrice carrée dont les vecteurs colonne sont de norme
1 et orthogonaux deux à deux.
Construisez une procédure testant si une matrice est orthogonale.
Calculez le produit d’une telle matrice par sa transposée.

3 Avec les outils MAPLE

Pour utiliser toute la puissance de calcul de MAPLE, on définit en fait une matrice par

Matrix(nb lignes, nb colonnes, [a11,a12,a13,...,a1n,a21,a22,a23,...a

Par exemple

> A:=Matrix(2,2,[1,2,3,4]);

On peut additionner, multiplier, élever à une puissance, appliquer une fonction à une ma-
trice selon la syntaxe habituelle, sauf pour le produit où il faudra taper · (le point). Il existe
une centaine de fonctions dans la bibliothèque LinearAlgebra plus celles déjà pré-
sentes sur Maple : nous ne les explorerons pas toutes ! Nous allons les découvrir à travers
des petits exercices.

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 CHAPITRE 3. TABLEAUX ET MATRICES 37

EXERCICES
3 -1 Noyau, image cours du temps. Nous allons les découvrir à travers
l’étude d’un exemple simple.
Qu’est-ce que l’endomorphisme de R2 d’expression Zlot, Brzxxz et Morzgniouf sont trois villes situées res-
analytique canonique pectivement en Syldavie, Bordurie et Bouzoukstan.
Des trafiquants de photos dédicacées du groupe ABBA
1 2

 x0 = − x − y
 prennent leur marchandise le matin dans n’importe la-
5 5 quelle de ces villes pour l’apporter le soir dans n’im-
 y0 3 6 porte quelle autre. On notera pour simplifier V1 , V2 et
= x+ y

5 5 V3 ces villes et p i j la probabilité qu’une marchandise
Vous aurez besoin de déterminer la matrice A associée, prise le matin dans la ville Vi soit rendue le soir dans la
le noyau de A grâce à NullSpace(A) qui en renvoie une ville V j . La matrice (p i j ) 16i 63 est appelée matrice de
base, l’image avec ColumnSpace(A). Ensuite, à vous 16 j 63
transition de la chaîne de Markov. Que s’attend-on à
d’essayer des petits calculs sur A pour deviner sa na-
observer sur les colonnes d’une matrice de transition ?
ture.
Supposons que P soit connue et vaille
3 -2 Puissances de matrices  
0, 8 0, 3 0, 2
 
P= 0, 1 0, 2 0, 6
  
0 −2 −2
1
2
 0, 1 0, 5 0, 2
1. Soit A = 0 −1
.
3
Les trafiquants se promenant de ville en ville, il peut
2 1 0
être utile de visualiser leurs déplacements par le dia-
a. Calculer A2 , A3 et A4 . gramme de transition suivant
b. Montrez que {A, A2 , A3 , A4 } est un groupe
pour le produit matriciel de M3 (R). 0,8

2. Pour chacune des matrices A suivantes, calculer

V1
An pour tout n ∈ N.
à !
1 a
a. avec a ∈ R.
0 1
b. La matrice Jp de Mp (R) dont tous les coeffi-
cients sont égaux à 1. 0,3 0,1
0,1 0,2
3 -3 Matrice orthogonale

 
3 4 c
A = 51  0,6
 
a −3 0

0 b d V2 V3
Déterminez a, b, c et d pour que A soit une matrice 0,5
0,2 0,2
orthogonale (A−1 = t ).
On notera x i(k)
la proportion de trafiquants qui se
Mini-chaînes de Markov... trouvent au matin du jour k dans la ville Vi . En
probabilités, on appelle vecteur d’état tout élément
³ R tel que ´x 1 + · · · + x n = 1.
+n
3 -4 Aidons la mafia (x 1 , · · · , x n ) de
Ainsi, x (k) = x 1(k) , x 2(k) , x 3(k) est un vecteur d’état.
Les chaînes de Markov sont issues de la théorie des On montre que les vecteurs d’état de la chaîne sont liés
probabilités et utilisent des outils d’algèbre linéaire par la relation
qui nous intéressent aujourd’hui. Elles permettent de
simuler des phénomènes aléatoires qui évoluent au x (k) = P · x (k−1)

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
38 3.4. EXERCICES

et donc

x (k) = P k · x (0)
Supposons que le chef de la mafia locale dispose de
1000 trafiquants qui partent tous le matin du jour 0 de
la ville de Zlot. Quelle sera la proportion de trafiquants
dans chacune des villes au bout d’une semaine ? d’un
mois ? d’un an ?

Le parrain voudrait que la proportion moyenne de

trafiquants soit stable d’un jour sur l’autre. Il re-
cherche donc les vecteurs d’état x vérifiant l’équa-
tion P · x = x. Vous apprendrez après l’été à ré-
soudre de manière systématique ce genre de pro-
blème. Nous allons pour l’heure nous débrouiller sans
appui théorique mais avec Maple et NullSpace
Comment procéder ? La matrice identité s’écrit
Matrix(3,3,shape=identity).

3 -5 Météo

À Morzgniouf, les jours sont soit secs, soit pluvieux. On

désigne par E1 l’état sec et E2 l’état pluvieux et par p i j
la probabilité qu’un jour soit dans l’état Ei sachant que
le jour précédent était dans l’état E j . Les scientifiques
Bouzouks ayant observé les phénomènes météorolo-
giques des trent-deux dernières années à Morzgniouf
ont établi la matrice de transition suivante
à !
0, 750 0, 338
P=
0, 250 0, 662
Sachant qu’il fait beau aujourd’hui, quelle est la proba-
bilité qu’il pleuve dans dix jours ?

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 4
CHAPITRE

Courbes de Bézier
40 4.1. RENAULT ET CITROËN

1 Renault et Citroën

Dans les années 60, les ingénieurs Pierre B ÉZIER et Paul D E C ASTEL -
JAU travaillant respectivement chez Renault et Citroën, réfléchissent
au moyen de définir de manière la plus concise possible la forme
d’une carrosserie.
Le principe a été énoncé par B ÉZIER mais l’algorithme de construc-
tion par son collègue de la marque aux chevrons qui n’a d’ailleurs
été dévoilé que bien plus tard, la loi du secret industriel ayant primé
sur le développement scientifique...
Pour la petite histoire, alors que Pierre B ÉZIER (diplômé de l’E NSAM et de S UPÉLEC), à l’ori-
gine des premières machines à commandes numériques et de la C AO ce qui n’empêcha pas
sa direction de le mettre à l’écart : il se consacra alors presque exclusivement aux mathé-
matiques et à la modélisation des surfaces et obtint même un doctorat en 1977.
Paul D E C ASTELJAU était lui un mathématicien d’origine, ancien élève de la Rue d’U LM, qui
a un temps été employé par l’industriel automobile.
Aujourd’hui, les courbes de Bézier sont très utilisées en informatique.
Une Courbe de Bézier est une courbe paramétrique aux extrémités imposées avec des points
de contrôle qui définissent les tangentes à cette courbe à des instants donnés.

2 Algorithme de Casteljau

2 1 Avec 3 points de contrôle

Soit t un paramètre de l’intervalle [0, 1] et P1 , P2 et P3 les trois points de contrôle.
On construit le point M1 barycentre du système {(P1 , 1 − t ), (P2 , t )} et M2 celui du système
{(P2 , 1 − t ), (P3 , t )}.
On construit ensuite le point M, barycentre du système {(M1 , 1 − t ), (M2 , t )}.
Exprimez M comme barycentre des trois points P1 , P2 et P3 .
Faites la construction à la main avec t = 1/3 par exemple.
Commentez le programme suivant :

bezier1:=proc(p1,p2,p3)
local m,m1,m2,P,S,B,k,t;
P:=plot([p1,p2,p3],color=green);
B:=NULL;
for k from 0 to 1 by 0.01 do
m1:=(1-k)*p1+k*p2;
m2:=(1-k)*p2+k*p3;
m:=(1-k)*m1+k*m2;
B:=B,m;
od;
B:=plot([B],color=blue);
S:=seq(plots[display](B,P,plot([(1-t*0.01)*p1+t*0.01*p2,(1-t*0.01)*p2+t
*0.01*p3],color=red)),t=0..100);

plots[display](S,insequence=true,axes=none,scaling=constrained);
end:

puis le résultat de son lancement :

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 CHAPITRE 4. COURBES DE BÉZIER 41

bezier1([0,0],[3,2],[5,-2]);

Il s’agit d’une animation ! Il faut donc cliquer sur l’image et lancer l’animation à l’aide de
l’icône appropriée.

2 2 Espace affine
Un espace affine c’est en gros une sorte d’espace vectoriel « pointé ». Si un point A et un
vecteur u sont donnés, B = A + u est un autre élément de l’espace affine. Plus clairement,
dans le contexte du plan vectoriel vu au lycée, on écrit :

−→
B = A + AB

Cela nous permet de faire des calculs sur les points. D’ailleurs MAPLE calcule lui aussi de
cette manière.
−−−→ −−−→ −−−→
Ainsi M1 (t ) = (1 − t )P1 + t P2 (ou si vous préférez OM1 (t ) = (1 − t )OP1 + t OP2 ) et M2 (t ) =
(1 − t )P2 + t P3 puis

M(t ) = (1 − t )M1 (t ) + t M2 (t ) = (1 − t )2 P1 + 2t (1 − t )P2 + t 2 P3

−−→
On peut dériver M(t ) par rapport à t (ou OM (t ) par rapport à t ) comme en physique (vous
verrez ça de manière rigoureuse en maths plus tard) ce qui nous donnera le vecteur vitesse
instantanée (c’est-à-dire un vecteur directeur de la tangente).
Vérifiez que M0 (t ) = 2(M2 (t ) − M1 (t )). Comment l’interpréter ?

2 3 Avec 4 points de contrôle

Faites une étude similaire (« à la main ») avec 4 points de contrôle.
On pourra introduire les polynômes de Bernstein définis par :
à !
n j
Bnj (t ) = t (1 − t )n− j
j

et utiliser une représentation similaire aux arbres de probabilité.

Créez une procédure bern:=proc(j,n,t) qui calcule Bnj (t ).
Commentez le script suivant :

bezier3:=proc(p)
local Vi,Vf,B,k,j,M;
Vi:=plot([p[1],p[2]],color=green);
Vf:=plot([p[3],p[4]],color=green);
B:=p[1];
for k from 0.01 to 0.99 by 0.01 do
M:=sum(bern(j,3,k)*p[j+1],j=0..3);
B:=B,M;
od;
B:=plot([B,p[4]],color=blue);
plots[display](B,Vi,Vf,axes=none,scaling=constrained);
end:

et testez :

bezier3([[0,0],[1,0],[3,-3],[3,0]]);

Quel est le rôle des points de contrôle 2 et 3 ?

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
42 4.3. AVEC UN NOMBRE QUELCONQUE DE POINTS DE CONTRÔLE

3 Avec un nombre quelconque de points de contrôle

Généralisez les procédures précédentes pour traiter un nombre quelconque de points de
contrôle.
Testez avec [[1, 1], [2, 3], [5, 5], [6, 2], [7, 7], [10, 5], [10, 2], [8, 0], [4, 0], [5, 1]].

Courbe de Bézier du 3e degré avec un nombre quelconque

4 de points de contrôle
Il est pratique de travailler avec des polynômes de degré trois pour avoir droit à des points
d’inflexion.
Augmenter le nombre de points de contrôle implique a priori une augmentation du degré
de la fonction polynomiale.
Pour remédier à ce problème, on découpe une liste quelconque en liste de listes de 4 points.
Cependant, cela est insuffisant pour obtenir un raccordement de classe C 1 (pourquoi ?
pourquoi est-ce important d’avoir un raccordement de classe C 1 ?)
Pour assurer la continuité tout court, il faut que le premier point d’un paquet soit le dernier
du paquet précédent.
−−−→
Le dernier « vecteur vitesse » de la liste [P1 , P2 , P3 , P4 ] est P3 P4 . Il faut donc que ce soit le
premier vecteur vitesse du paquet suivant pour assurer la continuité de la dérivée.
Appelons provisoirement le paquet suivant [P10 , P20 , P30 , P40 ]. On a d’une part P10 = P4 et d’autre
−−−→ −−−→ −−−→
part P3 P4 = P10 P20 , i.e. P20 = P4 + P3 P4 .
0 0
On a donc P3 = P5 et P4 = P6 .
Connaissant bezier3, construire une procédure qui trace une courbe de Bézier cubique
avec un nombre quelconque de points de contrôle (on prendra un nombre pair de points
pour se simplifier la vie).
Testez avec [[1, 1], [2, 3], [5, 5], [6, 2], [7, 7], [10, 5], [10, 2], [8, 0], [4, 0], [5, 1]].
Dessinez un cœur....

5 B-splines uniformes

5 1 Cas général
Tout ceci est très beau mais il y a un hic : en changeant un point de contrôle, on modifie
grandement la figure.

On considère m nœuds t 0 , t 1 , · · · , t m de l’intervalle [0, 1].

Introduisons une nouvelle fonction :

X1
m−n−
S(t ) = Pi b i ,n (t ) , t ∈ [0, 1]
i =0

les Pi étant les points de contrôle et les fonctions b j ,n étant définies récursivement par

6 t < t j +1
(
1 si t j
b j ,0 (t ) =
0 sinon
et pour n >1
t − tj t j +n+1 − t
b j ,n (t ) = b j ,n−1 (t ) + b j +1,n−1 (t ).
t j +n − t j t j +n+1 − t j +1

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 CHAPITRE 4. COURBES DE BÉZIER 43

k
On ne considérera par la suite que des nœuds équidistants : ainsi on aura t k = m .
On parle de B-splines uniformes et on peut simplifier la formule précédente en remarquant
également des invariances par translation.

5 2 Fonctions B-splines d’ordre 3 avec 4 points de contrôle

À l’aide des formules précédentes, on peut prouver que dans le cas de 4 points de contrôles
on obtient :

1³
(1 − t )3 P0 + (3t 3 − 6t 2 + 4)P1 + (−3t 3 + 3t 2 + 3t + 1)P2 + t 3 P3
´
S(t ) =
6
Calculez S(0), S(1) puis S 0 (0) et S 0 (1) : que peut-on en conclure ?
Reprenez l’étude faite avec les courbes de Bézier et comparez les résultats.

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 5
CHAPITRE

Tapis, arbres,
brocolis et lapins
 CHAPITRE 5. TAPIS, ARBRES, BROCOLIS ET LAPINS 45

1 Polygones de Sierpinski

Waclaw S IERPINSKI (1882 - 1969) fut un mathématicien polonais qui

travailla sur des domaines mathématiques très ardus : fondements
des mathématiques, construction axiomatique des ensembles, hy-
pothèse du continu, topologie, théorie des nombres...
Il a également travaillé sur les premiers objets fractals qu’étudiera
plus tard Benoît M ANDELBROT, mathématicien français d’origine
polonaise connu pour ses travaux dans ce domaine.

1 1 Jouons aux dés

Prenez un dé à 6 faces, un triangle ABC et un point G quelconque à l’intérieur du triangle.
Vous lancez le dé :
– si la face supérieure est 1 ou 2, vous faites une petite croix au niveau du milieu de G et de
A;
– si la face supérieure est 3 ou 4, vous faites une petite croix au niveau du milieu de G et de
B;
– si la face supérieure est 5 ou 6, vous faites une petite croix au niveau du milieu de G et de
C;
Ah, zut, on n’a pas de dé dans la salle d’info...mais on a Maple.
– rand() renvoie un entier aléatoirement choisi entre 0 et 999 999 999 999 ;
– rand(n..p) renvoie un entier aléatoirement choisi entre n et p inclus.

> dede:=proc(n)
local P,r,t,d,G,L,k;
P:=[[0,0],[1,0],[0.5,0.5*sqrt(3)]];
r:=10.^(-12)*rand();
t:=r();
d:=rand(1..3);
G:=t^2*P[1]+2*t*(1-t)*P[2]+(1-t)^2*P[3];

...

end:

Expliquez le début de cette procédure, achevez-la et testez-la.

1 2 Tapis
Considérons les huit transformations de C dans C suivantes :

1 1 1 1 2 1 2 1
T1 (z) = z T2 (z) = z+ T3 (z) = z+ T4 (z) = z+ + i
3 3 3 3 3 3 3 3

1 2 2 1 1 2 1 2 1 1
T5 (z) = z+ + i T6 (z) = z+ + i T7 (z) = z+ i T8 (z) = z+ i
3 3 3 3 3 3 3 3 3 3

Soit E0 le carré unité.

– Dessinez E0 ;
– Dessinez E1 = T1 (E0 ) ∪ T2 (E0 ) ∪ · · · ∪ T8 (E0 ) ;
– Identifiez les Tk .

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
46 5.1. POLYGONES DE SIERPINSKI

Comment obtenir ce joli dessin avec MAPLE ?

0.8

0.6

0.4

0.2

0 0.2 0.4 0.6 0.8 1

Une possibilité est d’introduire une liste d’applications :

T:=[z->z/3,z->z/3+1/3,z->z/3+2/3,z->z/3+1/3+2*I/3,z->z/3+2/3+2*I/3,z->z
/3+2/3+I/3,z->z/3+I/3,z->z/3+2*I/3];

1 3 Les mites de Sierpinski

Monsieur S IERPINSKI avait ramené d’un voyage en Orient un tapis carré de 1 mètre de côté
dont il était très content. Jusqu’au jour où les mites s’introduisirent chez lui.

En 24 heures, elles dévorèrent dans le tapis un carré de côté trois fois plus petit, situé exac-
tement au centre du tapis. En constatant les dégats, Monsieur S IERPINSKI entra dans une
colère noire ! Puis il se consola en se disant qu’il lui restait huit petits carrés de tapis, chacun
de la taille du carré disparu. Malheureusement, dans les 12 heures qui suivirent, les mites
avaient attaqué les huit petits carrés restants : dans chacun, elles avaient mangé un carré
central encore trois fois plus petit. Et dans les 6 heures suivantes elles grignotèrent encore
le carré central de chacun des tout petits carrés restants. Et l’histoire se répéta, encore et
encore ; à chaque étape, qui se déroulait dans un intervalle de temps deux fois plus petit
que l’étape précédente, les mites faisaient des trous de taille trois fois plus petite...

– Calculer le nombre total de trous dans le tapis de Monsieur S IERPINSKI après n étapes.
Calculer la surface S n de tapis qui n’a pas encore été mangée après n étapes. Trouver la
limite de la suite (S n )n≥0 . Que reste-t-il du tapis à la fin de l’histoire ?
– Calculer la durée totale du festin « mitique »...

Merci à Frédéric Le Roux

1 4 Dentelle de Varsovie

Nous voudrions obtenir le joli napperon en dentelle suivant :

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 CHAPITRE 5. TAPIS, ARBRES, BROCOLIS ET LAPINS 47

0.6

0.4

0.2

-0.4 -0.2 0 0.2 0.4 0.6

-0.2

-0.4

-0.6

Déterminez le rapport des similitudes qui transforment le grand pentagone en un des penta-
gones plus petit.

En vous inspirant de ce qui a été fait pour le triangle de S IERPINSKI, faites tracer à MAPLE
ce joli napperon.

1
En fait on peut montrer que pour un nombre c > 5 de côtés, le rapport est de £c¤
4 cos 2kπ
³ ´
2
P
k=0 c

2 Végétation récursive

Analysez cet algorithme :

arbre:=proc(A,B,Rap,Ang,n)
if n>0
then [[Re(A),Im(A)],[Re(B),Im(B)]],seq(arbre(B,B+Rap[q]*exp(Ang[q
]*I)*(B-A),Rap,Ang,n-1),q=1..nops(Rap))
else [[Re(A),Im(A)],[Re(B),Im(B)]]
fi
end:

sachant que

plot([arbre(0,I,[0.7,0.8],[Pi/5,-Pi/5],9)],axes=none,scaling=
constrained,color=green);

donne

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
48 5.2. VÉGÉTATION RÉCURSIVE

Comment obtenir cette fougère et ce brocolis ?

Ce n’est plus un arbre mais un beau flocon (le flocon de Helge V ON KOCH(1870-1924)) : com-
ment le générer avec MAPLE ?

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
 CHAPITRE 5. TAPIS, ARBRES, BROCOLIS ET LAPINS 49

3 Ensembles de Julia et de Mandelbrot

Gaston J ULIA (1893 - 1978) est un des plus grands mathématiciens

français. Ses travaux ont été largement utilisé par Benoît M ANDEL -
BROT (né en 1924) au début des années 1970. Nous allons survoler
certains de leurs résultats les plus populaires.
Nous allons étudier les suites (z n ) définies par z 0 et z n+1 = z n2 + c
pour tout entier naturel n avec c un nombre complexe quelconque.
Nous avons déjà exploré une suite réelle semblable lors de notre in-
cursion dans la dynamique des populations.
Le cas c = 0 est assez simple à étudier : faites-le !
Comment ce que vous avez obtenu est en lien avec cette procédure MAPLE et son utilisa-
tion ?

> julia:=proc(x,y)
global c;
local z,j;
z:=evalf(x+I*y);
for j from 0 to 50 while abs(z)<4 do
z:=z^2+c
od;
j
end:

> c:=0:

> plot3d(0,-2..2,-1.2..1.2,orientation=[-90,0],grid=[150,150],style=
patchnogrid,scaling=constrained,color=julia);

Je vous dois une petite explication au sujet de la dernière instruction. Afin de gagner du
temps, on utilise une petite ruse pour pallier aux carences de MAPLE en géométrie.
On utilise plot3d avec la fonction f : (x, y) 7→ 0 afin de tracer le plan d’équation z = 0. Ses
points sont colorés selon la procédure julia. L’option grid indique la taille de la grille
tracée. On précise également qu’on veut un repère orthonormé, pas de maillage apparent
et on place les axes de coordonnées dans l’orientation usuelle.
Testez différentes valeurs de c : −1, 0, 32 + 0, 043i, −0, 122561 + 0, 744862i.
Quelles sont vos interprétations ?

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\
50 5.3. ENSEMBLES DE JULIA ET DE MANDELBROT

Plutôt que de testez les valeurs de c une par une, Benoît M ANDEL -
BROT a cherché à représenter las valeurs de c qui faisaient converger
la suite avec z 0 = 0 : c’est l’ensemble de M ANDELBROT.
Tracez-le !

C
Guillaume Connan, Licence Creative Commons BY: $ , 2010-2011
\