Introduction à la programmation scientifiqueMuPAD

Damien Olivier

21 octobre 2005

Table des matières

1 Résolution de problèmes à l’aide de l’informatique 41.1 Identification du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .41.2 Modèle mathématique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .41.3 Algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .51.4 Analyse des résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .61.5 Quelques conseils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .61.6 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7

2 Découverte de MuPAD 72.1 Commandes de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .72.2 Calculer avec MuPAD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9

2.2.1 Calcul numérique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .92.2.2 Les nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .102.2.3 Calcul symbolique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .122.2.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15

3 Fonctions 173.1 Dérivées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .19

3.1.1 Dérivées partielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .203.1.2 L’opérateur différentielD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .20

3.2 Intégrales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .213.3 Développements limités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .223.4 Graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .23

3.4.1 Tracés de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .233.4.2 Champs de vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .273.4.3 Représentation graphique à l’aide de points . . . . . . . . . . . . . . . . . . . . . .28

3.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .30

4 Résolution d’équations 354.1 Système d’équations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .374.2 Equations différentielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .38

5 Programmation en MuPAD 475.1 Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .475.2 Objets structurés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .48

5.2.1 Expressions symboliques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .495.2.2 Expressions booléennes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .515.2.3 Séquences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .515.2.4 Les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .535.2.5 Les ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .545.2.6 Tableaux et tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .565.2.7 Les chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .57

5.3 Programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .585.3.1 Les procédures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .58

2

5.3.2 Les instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .595.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .66

6 MuPAD emacs LATEX and co 76

7 Récréation 76

3

Avertissement

Ce document est en cours de rédaction, il est donc incomplet et contient sans aucun doute des coquilleset des erreurs. Je compte à la fois sur votre indulgence et sur votre collaboration.

Ce document ne reflète pas avec exactitude le contenu des cours proposés et dispensés lors de la premièrepartie du semestre 1. "Ses" oublis seront ajoutés au fil du temps et ses suppléments sont là pour ceux quisouhaiteraient ou auraient besoin d’approfondir.

Bon courage à tous.Ce document s’est largement inspiré de deux sources : la page web de Sylvain Damour [?] et le tutorial

MuPAD [?].

Remerciements

Merci à tous les relecteurs attentifs qui ont corrigé les coquilles, les foteset autres maladresses.

4

1 Résolution de problèmes à l’aide de l’informatique

Le processus de résolution d’un problème ne commence pas par écrire un programme ou utiliser di-rectement un logiciel, mais passe par des étapes d’analyses. On peut le décomposer idéalement en cinqétapes :

– Identifier le problème ;– Poser le problème sous la forme d’un modèle mathématique/informatique ;– Déterminer une méthode informatique pour résoudre le modèle (algorithme) ;– Implanter (programmer) le modèle et la méthode ;– Évaluer les résultats.Il est clair que ces différentes étapes ne sont pas indépendantes, et qu’elles ne sont pas irrévocables. En

effet, l’évaluation des résultats peut remettre en cause le modèle par exemple.Intéressons nous au problème posé par Leornado Pisano connu sous le nom de Fibonacci (1170-1250)

dans son ouvrage Liber Abaci. Dans une population idéale de lapins, on suppose que :– Toutes les saisons un couple de lapins met au monde un couple de lapins ;– Le nouveau couple grandit durant la saison ;– Il est en âge de procréer la saison d’après.Quelle sera la population à la saisonn ?

1.1 Identification du problème

Au début (annéen = 0) nous avons un couple de lapins qui grandit l’année suivante (n = 1) et procréel’année d’après (n = 2) et ainsi de suite, on peut donc construire le tableau suivant :

n Lapereaux * 2 =Ln Adolescents * 2= an Adultes * 2 = An Total * 2 = Tn

0 1 0 0 11 0 1 0 12 1 0 1 23 1 1 1 34 2 1 2 55 3 2 3 86 5 3 5 137 8 5 8 218 13 8 13 34

1.2 Modèle mathématique

La population est constituée des lapereaux, des adolescents et des adultes

Tn = Ln + an + An (1)

et les lapereaux de la saison précédente sont les adolescents de la saison courante.

an = Ln−1 (2)

La population d’adultes est constituée des anciens et des adolescents de la génération précédente :

An = An−1 + an−1 (3)

5

et il y a autant de lapereaux que de parents.An = Ln (4)

(2) et (3) dans (1) Tn = Ln + Ln−1 + an−1 + An−1︸ ︷︷ ︸Tn−1

(5)

(3) et (4) Ln = An−1 + an−1 (6)

De (3) An−1 = An−2 + an−2 (7)

Dans (6) Ln = An−2 + an−2 + Ln−2 = Tn−2 (8)

Dans (5) Tn = Tn−2 + Tn−1 (9)

Ceci définit donc une suite de Fibonacci dont la relation de récurrence est la suivante :∀n > 0, Tn+2 = Tn + Tn+1

Conditions initiales :T0 = T1 = 1(10)

1.3 Algorithme

Fonction Fibonacci( n :entier) : entier[n ≥ 3]fibNPlus2, fibN, fibNPlus1, i :entierfibN← 1fibNPlus1← 1i ← 3Tant que (i ≤ n) faire

fibNPlus2← fibN + fibNPlus1fibN← fibNPlus1fibNPlus1← fibNPlus2i ← i + 1 ;

FaitRetourner fibNPlus2 ;

Fin

Algorithme 1: Suite de Fibonacci

Le programme sous MuPAd ou une méthode de résolution sera détaillé dans la suite.

6

Suite de Fibonacci

>> Fibonacci := proc(n:Type::NonNegInt) : Type::Integerlocal fibNPlus2, fibN, fibNPlus1, i;begin

fibN := 1;fibNPlus1 := 1;i := 3;while i <= n do

fibNPlus2 := fibN + fibNPlus1;fibN := fibNPlus1;fibNPlus1 := fibNPlus2;i := i + 1;

end_while;fibNPlus2;

end_proc:

1.4 Analyse des résultats

Ainsi que l’a remarqué Johannes Kepler, le taux de croissanceTnTn−1

des nombres de Fibonacci convergevers le nombre d’or notéΦ. Le nombre d’or est la racine positive de l’équation du second degré :

x2 − x− 1 = 0

. De façon approchéeTn ≈ 1, 618 ∗ Tn−1. Le modèle ne prend pas en compte les phénomènes de décès,pour cela on pourrait utiliser une loi logistique.

1.5 Quelques conseils

Il y a bien entendu de nombreuses façons de résoudre un problème. Toutefois, quelques stratégies etméthodes générales peuvent être conseillées d’après Miguel de Guzman [?] :

– avant d’agir, essayez de comprendre ;– recherchez des stratégies ;

– cherchez des ressemblances avec d’autres problèmes ;– commencez par ce qui est facile ;– faîtes des expériences et cherchez des traits communs, des règles ;– faîtes un schéma ;– modifiez le problème pour trouver un autre chemin possible ;– choisissez une bonne notation ;– exploitez les propriétés (symétrie, . . . ) ;– raisonnez par l’absurde ;– pensez à des techniques générales : récurrence, induction . . ..

– menez à terme votre stratégie ;– menez à terme les meilleures idées ;– ne vous découragez pas ;– analysez bien les résultats avant de les admettre ;

– tirez profit de votre expérience ;

7

– analysez votre propre stratégie ;– essayez de comprendre la solution et son pourquoi ;– regardez si l’on ne peut pas faire plus simplement ;– examinez si la méthode peut être utilisée à d’autres fins ;– réfléchissez sur votre manière de raisonner.

1.6 Exercice

I Exercice n◦1

Une grenouille saute sur des nénuphars, elle saute soit sur le nénuphar suivant ou sur celui d’après. Ily a n nénuphars alignés, sachant que la grenouille part du premier quel est le nombre de possibilitéspour atteindre le dernier ?

2 Découverte de MuPAD

MuPAD1 est un logiciel decalcul symboliqueou encore decalcul formel. La majorité des logicielsmathématiques travaillent avec des valeurs numériques pour toutes les variables alors que MuPAD manipuledes symboles, cela permet en particulier d’obtenir des solutions analytiques à de nombreux problèmes.Attention, cependant cela ne résout pas tout ! D’autre part MuPAD possède des possibilités de visualiser desfonctions en deux ou trois dimensions ainsi qu’un langage de programmation (figure 1). L’objectif de cetteprésentation est de découvrir ces différentes fonctionalités.

stdlib numliblinalg plotlib

Bibliothèques de MuPAD

notebook graphique système d’aide débogueur

Interfaces utilisateur

noyau MuPAD

Module Module

FIG. 1 – Architecture de MuPAD

2.1 Commandes de base

Dans l’environnement Linux, la première opération consiste à lancer MuPAD, ceci est possible soit enmode console ($ mupad) ou en mode graphique ($ xmupad &) avec possibilité d’utilisation de la souris,c’est cette dernière méthode que nous choisissons pour la suite de cette présentation.

1Il existe des logiciels similaires à MuPAD comme Maple, Mathematica, MatLab . . .

8

FIG. 2 – Écran de démarrage de xmupad

damien@astrolabe2:~/enseignement/l1/prg_scien/Mupad$ xmupad &

Une ligne de commande se termine soit par un; (facultatif) ou par: et vous validez votre ligne par←↩(entrée). Le point virgule (ou son absence) affiche le résultat alors qu’avec deux points le calcul est effectuémais n’est pas affiché, cela peut être utile lorsque l’on a de longues feuilles de calcul. Si une ligne de calculne tient par sur une seule ligne↑←↩ (shift entrée) permet de passer à la ligne suivante sans effectuer le calcul.

9

Exemple :

>> 111!

1762952551090244663872161047107075788761409536026565516041574063347346955087248316436555574598462315773196047662837978913145847497199871623320096254145331200000000000000000000000000>> 111!;

1762952551090244663872161047107075788761409536026565516041574063347346955087248316436555574598462315773196047662837978913145847497199871623320096254145331200000000000000000000000000>> 111:>> 111!

1762952551090244663872161047107075788761409536026565516041574063347346955087248316436555574598462315773196047662837978913145847497199871623320096254145331200000000000000000000000000>>

Le dernier calcul est représenté par%, l’avant dernier par%%(ou %2), l’antépénultième par%%%(%3). . . et un commentaire figure entre deux# ou /* et */ . Si vous voulez tout réinitialiser, il faut utiliserreset() .

Exemple :

>> 100:>> length(%)

3>> 100!:>> length(%) #longueur de factorielle 100#

158>>

Attention MuPAD fait une différence entre les majuscules et les minuscules. Si vous avez besoin d’aide?viendra à votre secours en particulier pour une fonction, par exemple on pourra taper?sin .

2.2 Calculer avec MuPAD

MuPAD permet de calculer à la fois avec des nombres, de réaliser soit des calculs exacts ou approchéset d’effectuer des calculs symboliques.

2.2.1 Calcul numérique

Il est possible d’utiliser MuPAD comme une calculette retournant des résultats exacts ou approchés.MuPAD privilégie les résultats exacts.

10

Exemple :

>> 1 + 7/3;

10/3>> float(%)

3.333333333>>

Pour montrer la différence, nous nous proposons de traiter un problème simple : la population de laTerre sera d’environ (estimation) de 7 516 000 000 d’habitants en 2020, si l’on décide de partager la surfacedes continents équitablement, quelle sera la taille du carré de terre que pourra occuper chaque habitant ? Onsuppose que la Terre est une sphère de rayon 6378 km occupée par 70% d’eau.

Solution exacte :

>> /* Surface des continents */>> SurfaceContinents := 4 * PI * 6378^2 * 30/100

244073304 PI------------

5>> /* Chaque habitant aura un carré de coté : ">> sqrt(SurfaceContinents/7516000000)*1000; /* m^2 */

1/2 1/2 1/2PI 4697500000 30509163-------------------------------

4697500>> float(%); /* On évalue la solution exacte */

142.842252

Solution numérique :

>> AireContinents := float(4 * PI * 6378^2 * 30/100);

153355779.8>> /* On a obtenu un réel, le calcul est fait en réel */>> sqrt(AireContinents/7516000000)*1000

142.842252

2.2.2 Les nombres

MuPAD peut manipuler des entiers, des rationnels, des réels et des complexes (cf. tab. 1, et 2). Les en-tiers ont une taille arbitraire limitée par la mémoire. Les rationnels sont définis par deux entiers (fraction)

11

sans diviseur commun dont le deuxième est strictement positif. Les réels (float) sont représentés par deuxentiers : lamantisseet l’exposant. La valeur estmantisse ∗ 10exposant, la valeur de l’exposant est bornéepar231.

Entiers ! factorielle d’un nombre 12! = 479001600^ puissance d’un entier 30 = 1isprime() vérifie si un entier positif est premier isprime(2110805449) = trueifactor() factorisation en nombres premiers ifactor(123456789101112) = [23 2437 2110805449]

Réels DIGITS fixe le nombre de chiffre décimaux DIGITS = 10 (par défaut)float() valeur de son arg. en flottant float(sqrt(2) = 1.414213562

TAB . 1 – Quelques opérations concernant les entiers et les réels

MuPAD manipule également les nombres complexes,√−1 est représenté parI.

Nombres complexes :

>> sqrt(-1), I^2I, -1

>>

Complexes Re () partie réelleIm() partie imaginaireconjugate() conjugué complexeabs() modulerectform() met un nombre complexe sous la formea + ib

TAB . 2 – Quelques opérations sur les nombres complexes

12

Exemple d’opérations sur les complexes :

>> z := (1+I)^2 / (1-2*I)- 4/5 + 2/5 I

>> Re(z)-4/5

>> Im(z)2/5

>> abs(z)1/2

(4/5)>> conjugate(z)

- 4/5 - 2/5 I>> w:=-1/2 * sqrt(2 + 2*I*sqrt(3))

1/2 1/2(2 I 3 + 2)

- -----------------2

>> rectform(w)1/2

3- ---- - 1/2 I

2>>

2.2.3 Calcul symbolique

Considérons un problème simple. Imaginons que nous ayons à notre disposition :– Un tas de bouts de bois, tous d’égale longueur (10 cm par exemple) et d’égale densité uniforme ;– Une table solidement ancrée dans le sol.

À l’aide de ces éléments il faut construire la plus large pile de bouts de bois possible à l’extérieur de la table,sachant que le premier bout de bois doit reposer sur la table et le suivant sur le précédent et ainsi de suite(fig 3). Au nieme bout de bois posé, quelle est la largeur maximale de la pile à l’extérieur de la table ?

FIG. 3 – Trois bouts de bois en équilibre (non optimal)

Il s’agit d’un problème d’équilibre et donc deposition du centre de gravitéde chaque objet. Nos boutsde bois de taille et de densité uniforme ont leur centre de gravité au milieu. D’autre part un bout de bois seulest en équilibre tant que son centre de gravité est supporté par la table ou un autre bout de bois.

Cherchons tout d’abord la solution avec deux bouts de bois. Lorsque l’on a deux bouts bois posés l’unsur l’autre on peut les considérer comme un seul, mais alors quel est le centre de gravité de ce "nouvel

13

(a) Deux bouts de bois (b) Trois bouts de bois

(c) Quatre bouts de bois

FIG. 4 – Position du centre de gravité

14

objet" ? Pour déterminer cela, il suffit simplement de faire la moyenne des centres de gravité puisqu’ilssont de même poids. Si les deux bouts de bois sont en équilibre, celui qui se situe au dessus doit être enéquilibre sur celui au dessous et l’ensemble doit l’être également. Pour simplifier, on considère uniquementla coordonnée du centre de gravité des bouts de bois. On a donc établi :

12

+14

(11)

On rajoute maintenant un troisième bout de bois à l’ensemble. Pour commencer l’extrémité droite de cenouveau bout de bois (appelons leC) est située au bord de la table et on va chercher à déplacer l’ensemblele plus possible vers l’extérieur. Le centre de gravité deC est situé à3/6 du bord de la table. L’ensembledes bouts de bois (B et A) situés au-dessus pèse deux fois plus lourd que le bout de boisA. Le centre degravité doit être proportionnellement plus proche de l’ensembleBC que deA.

36

=26

+16

d’où en complétant (11)12

+14

+16

FIG. 5 – Équilibre optimal avec quatre bouts de bois

et en généralisant

12

+14

+16

+18

+ .... +1

2 ∗ n(12)

On a donc obtenu une suite (équation 12) qui diverge voisine de la suite harmonique (équation 13).

12

+13

+14

+15

+ .... +1n

(13)

Étude de la suite :

>> sum(1/(2*i),i=1..infinity)

infinity

ce que nous montre le calcul symbolique.

15

2.2.4 Exercices

II Exercice n◦2

II.1 Montrer que pour tout entier natureln ∈ N, n(n6 − 1) est divisible par7 (raisonner par récur-rence).– Définir une fonction MuPADf := n -> n * (n^6 -1) .– Factoriser à l’aide de la commandefactor() .

Exercice 2 :

>> f := n -> n * (n^6 -1)

n -> n*(n^6 - 1)>> f(n-1) - f(n)

6 6(n - 1) ((n - 1) - 1) - n (n - 1)

>> factor(%)

2 2(-7) n (n - 1) (- n + n + 1)

III Exercice n◦3

Utiliser MuPAD pour déterminer les limites suivantes. Consultez au préalable l’aide concernant lafonction limit .

limx→0

sin(x)x , lim

x→0

1−cos(x)x , lim

x→0+ln(x),

limx→0

xsin(x), limx→∞

(1 + 1x)x lim

x→∞ln(x)ex

limx→0

xln(x), limx→0−

21+e−1/x lim

x→0sin(x)1/x

Expliquer le dernier résultat, que faut-il faire ?

16

Exercice 3 :

>> limit(sin(x)/x, x=0)

1>> limit((1 - cos(x))/x, x=0)

0>> limit(ln(x), x=0, Right)

-infinity>> limit(x^sin(x), x=0)

1>> limit((1 + 1/x)^x, x= +infinity)

exp(1)>> limit(ln(x)/exp(x),x=+infinity)

0>> limit(x^ln(x), x = 0, Right)

infinity>> limit(2/(1 + exp(-1/x)), x = 0, Left)

0>> limit(sin(x)^(1/x), x = 0, Right)

0

IV Exercice n◦4

En utilisant la commandesum et la commandebinomial simplifier les expressions :

IV.1

(n0

)+

(n1

)+

(n2

)+ . . . +

(nn

)IV.2

(n1

)+ 2

(n2

)+ 3

(n3

)+ . . . + n

(nn

)IV.3

(n1

)− 2

(n2

)+ 3

(n3

)+ . . . + (−1)n+1n

(nn

)avec (

np

)=

n!p!(n− p)!

qui représente les coefficients du triangle de Pascal

(ij

)est le coefficient situé à la lignei et à la

colonnej :

11 11 2 11 3 3 11 4 6 4 11 5 10 10 5 1

17

et on a par exemple :

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

Exercice 4

>> sum(binomial(n,k), k = 0..n)n

2>>>> sum(k * binomial(n, k), k = 1..n)

nn 2----

2>> sum((-1)^(k+1) * k * binomial(n, k), k = 1..n)

n 2 n- n (-1) binomial(n, n + 1) - n (-1) binomial(n, n + 1)----------------------------------------------------------

n - 1>> expand(%)

0

3 Fonctions

MuPAD manipule desfonctionset desexpressions. On définit une fonction avec une notation proche decelle traditionnellement utilisée en mathématiques.

Fonction f et expression e

>> f := x -> x^2 + 1 /* Fonction f */

x -> x^2 + 1>> f(4) /* Évaluation de la fonction en un point */

17>> e := x^2 + 1 /* Expression e */

2x + 1

>> subs(e, x=4) /* Valuation de l’expression */

17

C’est donc l’opérateur-> qui génère des objets qui représentent des fonctions mathématiques. La fonc-tion peut alors être appelée comme n’importe quelle fonction prédéfinie.

18

Fonction f

>> f := (x,y) -> abs(x) - abs(sqrt(y))

(x, y) -> abs(x) - abs(sqrt(y))>> f(a, a^2)

2 1/2abs(a) - (abs(a) )

>> simplify(%)

0

La composition de fonction est réalisée à l’aide de l’opérateur@et l’opérateur@@réalise la compositionitérée de la fonction avec elle-même.

Composition de fonction

>> f := x -> (1 / (1 + x))

x -> 1/(1 + x)>> g := sin(x^2)

2sin(x )

>> f@g(a)

(x -> 1/(1 + x))@sin(x^2)(a)>> h := f@g

(x -> 1/(1 + x))@sin(x^2)>> h(a)

1--------------

2sin(x )(a) + 1

>> fff := f@@3

(x -> 1/(1 + x))@(x -> 1/(1 + x))@(x -> 1/(1 + x))>> fff(a)

1-------------

1--------- + 1

1----- + 1a + 1

>>

Il est possible de passer d’une fonction à une expression et inversement, il suffit dans le premier casd’affecter la fonction à une expression et dans le second cas d’utiliser la fonctionfp::unapply() 2.

2fonctionunapply() de la bibliothèquefp

19

fonction ↔ expression

>> f := x -> x^2

x -> x^2>> e := f(x)

2x

>> g := fp::unapply(e)

x -> x^2>>

3.1 Dérivées

La dérivée d’une fonction en un point peut être vue comme la mesure de la vitesse à laquelle cette fonc-tion change lorsque sa variable change. La fonction croît lorsque la dérivée est positive et décroît lorsqu’elleest négative. Pour une fonction à plusieurs variables, on parle de dérivée partielle par rapport à l’une de sesvariables.

Les dérivées partielles ou non peuvent être effectuées à l’aide de la fonctiondiff . L’appeldiff(expression,x) calcule la dérivée de l’expression par rapport àx .

Dérivée d’une fonction

>> diff(sin(x),x)

cos(x)>> diff(f(x) + f(x)*sin(x),x)

f(x) cos(x) + diff(f(x), x) + sin(x) diff(f(x), x)

On remarquera que la dérivée def n’est pas connue, le résultat est retourné symboliquement. Il estégalement possible de réaliser des dérivées multiples en répétant la variable plusieurs fois ou en utilisantl’opérateur de séquence$.

20

Dérivées multiples

>> diff(sin(x^2),x,x)

2 2 22 cos(x ) - 4 x sin(x )

>> diff(sin(x^2), x$2)

2 2 22 cos(x ) - 4 x sin(x )

>> diff(diff(sin(x^2),x),x)

2 2 22 cos(x ) - 4 x sin(x )

3.1.1 Dérivées partielles

À l’aide de diff() on peut également calculer une dérivée partielle d’une fonction à plusieurs va-riables.

Dérivées partielles

>> diff(cos(x*tan(y)),x)

-tan(y) sin(x tan(y))>> diff(cos(x+y^2),x,y)

2- 2 y cos(x + y )

>> diff(cos(x+y^2),y,x)

2- 2 y cos(x + y )

>> diff((x^2 + y^2) * (ln(x) - ln(y)),x$2,y)

2 2 y- - - ---

y 2x

>> diff((x^2 + y^2) * (ln(x) - ln(y)), y, x$2)

2 2 y- - - ---

y 2x

>>

3.1.2 L’opérateur différentiel D

L’opérateurDs’applique à une fonction sans spécifier obligatoirement ses arguments.

21

L’opérateur différentiel

>> D(sin)

cos>> D(f+g)

D(f) + D(g)>> D(f*g)

f D(g) + g D(f)>> D(f@g)

D(g) D(f)@g

On peut itérer en utilisant@@nou indexer en une formeD[i] qui retourne la dérivée partielle parrapport à la ieme variable.

Composition de D

>> f := (x,y) -> sqrt(x*y^5)

(x, y) -> sqrt(x*y^5)>> D([2],f)

(x, y) -> 5/2*x*y^4/(x*y^5)^(1/2)>> D([2,1],f)

(x, y) -> 5/2*y^4/(x*y^5)^(1/2) - 5/4*x*y^9/(x*y^5)^(3/2)>> D([1,2$2],f)

(x, y) -> 10*y^3/(x*y^5)^(1/2) - 35/2*x*y^8/(x*y^5)^(3/2) + 75/8*x^2*y^13/ (x*y^5)^(5/2)>> (D@@1)(sin)

cos>> (D@@2)(sin)

-sin

3.2 Intégrales

La fonction int() représente à la fois l’intégration définie et indéfinie. Ainsi pour le calcul d’uneprimitive, on ne spécifie pas les bornes :

22

Primitive

>> int(sin(x),x)

-cos(x)>> int(x/(x^2+x+1),x)

/ / 1/2 \ \1/2 | | 2 3 (x + 1/2) | |

2 3 | PI - 2 arctan| ---------------- | |ln((x + 1/2) + 3/4) \ \ 3 / /-------------------- + ------------------------------------------

2 6

Pour le calcul d’une intégrale, on spécifie les bornes.

Intégrale

>> int(sin(x), x = 0..PI/2)

1>> int(x/(x^2+x+1), x = 0..1)

1/2ln(3) PI 3----- - -------

2 18

3.3 Développements limités

Soit a ∈ R et f une fonction définie dans un voisinage dea. On appelle développement limité def àl’ordre n au voisinage dea un polynômePn de degré inférieur ou égal àn tel que :

f(x) = Pn(x) + (x− a)nε(x) où limx→0

= 0

Avec les notations de Landau :f(x) = Pn(x) + O((x− a)n)

Il est possible de déterminer à l’aide de MuPAD le développement limité ou asymptotique d’une expres-sion en un point. On utilise pour celataylor() pour obtenir un développement en série de Taylor.

Développement limité

>> taylor(1/(1-x), x=0, 9)

2 3 4 5 6 7 8 91 + x + x + x + x + x + x + x + x + O(x )

23

Certaines fonctions ne possèdent pas de développement en série de Taylor, la fonction renvoie alors uneerreur, la fonctionseries() permet de calculer des développements plus généraux.

Développement généralisé

>> taylor(cos(x)/x, x=0)Error: does not have a Taylor series expansion, try ’series’ [taylor]>> series(cos(x)/x, x = 0)

31 x x 5- - - + -- + O(x )x 2 24

3.4 Graphiques

MuPAD offre de nombreuses possibilités pour montrer les objets mathématiques dans un espace à deuxou trois dimensions, nous nous contenterons d’aborder ici le tracé de fonctions et de champs de vecteur.

3.4.1 Tracés de fonctions

La fonctionplotfunc2d() permet de tracer des fonctions à une variable.

Tracé de fonctions à une variable

>> plotfunc2d(sin(x), x = -2*PI..2*PI)

52,50-2,5-5

1

0,5

0

-0,5

-1

x

y

x

y

sin(x)

De nombreuses fonctionalités sont offertes, entre autre la possibilité de tracer plusieurs fonctions sur un

24

même graphe.

Tracé de plusieurs fonctions

>> polynomeOrdre9 := expr(taylor(sin(x),x=0,9))

3 5 7 9x x x x

x - -- + --- - ---- + ------6 120 5040 362880

>> polynomeOrdre13 := expr(taylor(sin(x),x=0,13))

3 5 7 9 11 13x x x x x x

x - -- + --- - ---- + ------ - -------- + ----------6 120 5040 362880 39916800 6227020800

>> polynomeOrdre15 := expr(taylor(sin(x),x=0,15))

3 5 7 9 11 13 15x x x x x x x

x - -- + --- - ---- + ------ - -------- + ---------- - -------------6 120 5040 362880 39916800 6227020800 1307674368000

>> polynomeOrdre17 := expr(taylor(sin(x),x=0,17))

3 5 7 9 11 13 15x x x x x x x

x - -- + --- - ---- + ------ - -------- + ---------- - ------------- +6 120 5040 362880 39916800 6227020800 1307674368000

17x

---------------355687428096000

>> plotfunc2d(sin(x),polynomeOrdre9, polynomeOrdre13, polynomeOrdre15, polynomeOrdre17,x= -10..10,YRange=-5..5)

1050-5-10

5

2,5

0

-2,5

-5

x

y

x

y

sin(x), x - 1/6*x^3 + 1/120*x^5 - 1/5040*x^7 + 1/362880*x^9, x

25

Il est possible de tracer des fonctions avec des singularités :

Fonctions avec singularités

>> plotfunc2d(1/x, 1/(1 - x) + 1/(1 + x), x = -2..2)

210-1-2

20

10

0

-10

-20

x

y

x

y

1/x, 1/(x + 1) + 1/(1 - x)

On peut également choisir une échelle logarithmique.

26

Échelle semi-log

>> plotfunc2d(exp(x), x = -100..100, Scaling = LinLog)

100500-50-100

2,688e+43

5,185e+21

1

1,929e-22

3,72e-44

x

y

x

y

exp(x)

Il est également possible de tracer des fonctions de deux variables à l’aide deplotfunc3d() .

27

fonction à deux variables

>> plotfunc3d((1.3)^x*sin(y), x = -1..2*PI, YRange=0..PI)

6,25

5

3,75

2,5

1,25

0

3

2,5

2

1,5

1

0,5

0

5

3,75

2,5

1,25

0

x

y

z

sin(y)*1.3^x

3.4.2 Champs de vecteurs

Pour les mécaniciens en herbe, il est également possible de tracer un champ de vecteurs. On définit aupréalable le champ de vecteurs, puis on l’affiche. Pour l’exemple, on a :

(x, y)→ (−y2, x2)

28

Champ de vecteur

>> champ := plot::VectorField2d([-y^2, x^2], x = -4..4, YRange = -4..4)

plot::Group()>> plot(champ)

−4 −3 −2 −1 1 2 3 4

−4

−3

−2

−1

1

2

3

4

x

y

3.4.3 Représentation graphique à l’aide de points

MuPad permet de manipuler des listes (voir 5.2.4) qui sont constituées d’une séquence ordonnée d’objetsMuPAD entre crochets.

Exemples de listes

>> liste1 := [1, 2, 3, 4, 5, 6]

[1, 2, 3, 4, 5, 6]>> liste2 := [liste1, PI, cos(x)^2, Coucou ]

2[[1, 2, 3, 4, 5, 6], PI, cos(x) , Coucou]

et l’on peut également générer une suite d’éléments à l’aide de $.

29

Utilisation du générateur d’éléments

>> premier := [ithprime(i) $i = 1..79] //utilisation de $

[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, 101, 103, 107, 109, 113, 127, 131, 137, 139,

149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223,

227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293,

307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383,

389, 397, 401]>>

On peut alors construire des listes de pointsplot::Pointlist() que l’on affiche. Si on veut tracerl’évolution de la largeur en dehors des bouts de bois (voir 2.2.3), on peut tracer la suite en fonction den.

Suite :nP

i=1

12∗i

>> PlotPoints := plot::PointList2d([[n, sum(1/(2*i), i=1..n)] $n = 1 .. 3000])// Ce n’est pas la bonne méthode

plot::PointList2d()>> plot(PlotPoints)

300025002000150010005000

4

3,5

3

2,5

2

1,5

1

0,5

x

y

x

y

30

3.5 Exercices

V Exercice n◦5

V.1 Calculer la limite de la suite :un = 3 ∗ 2

1n − 2 ∗ 3

1n

Solution

>> u := 3 * 2^(1/n) - 2 * 3^(1/n)

1 1- -n n

3 2 - 2 3>> limit(u, n=infinity)

1

VI Exercice n◦6

On considère la suite récurrente définie par :

un = un−1 + un−2, u0 =√

(5)− 1 etu1 =√

(5)− 3

VI.1 Calculer la valeur exacte deu100. Vous utiliserez la composition de fonctions.

VI.2 Calculer les valeurs approchées deu100 avec 10, 20, 30, 40, 50 et 100 chiffres significatifs.

Solution:Calculons quelques termes de la suite :

u2 = u1 + u0

u3 = u2 + u1

= 2u1 + u0

u4 = u3 + u2

= 3u1 + 2u0

u5 = 5u1 + 3u0

u6 = 8u1 + 5u0

Si l’on définitf(u1, u0) = (u1 + u0, u1)

f(u1, u0) = (u1 + u0, u1)f(f(u1, u0)) = f(u1 + u0, u1)

= (2u1 + u0, u1 + u0) = (u3, u2)f(f(f(u1, u0) = f(2u1 + u0, u1 + u0)

= (3u1 + 2u0, 2u1 + u0) = (u4, u3)

31

Solution

>> f := (x, y) -> (x + y, x)

(x, y) -> (x + y, x)>> u0 := sqrt(5) - 1

1/25 - 1

>> u1 := sqrt(5) - 3

1/25 - 3

>> u100 := (f@@100)(u1, u0)

1/2927372692193078999176 5 - 2073668380220713167378,

1/2573147844013817084101 5 - 1281597540372340914251>> float(u100[2])

-128.0>> DIGITS := 20

20>> float(u100[2])

-0.0000000298023223876953125//etc

VII Exercice n◦7

VII.1 Calculer la dérivée de la fonction f :

f : t 7→ arcsin(2t√

1− t2)

VII.2 Simplifier l’expression en supposantt > 1√2, puis quet ∈] − 1√

2, 1√

2[. Vous utiliserez la

commandeassume() .

32

Solution

>> f := arcsin(2 * t * sqrt(1 - t^2))

2 1/2arcsin(2 t (1 - t ) )

>> d := diff(f,t)

22 1/2 2 t

2 (1 - t ) - -----------2 1/2

(1 - t )---------------------------

2 2 1/2(1 - 4 t (1 - t ))

>> simplify(d)

22 1/2 2 t

2 (1 - t ) - -----------2 1/2

(1 - t )---------------------------

2 2 1/2((2 t - 1) )

>> assume(t, Type::Real) : assume(t > 1/sqrt(2), _and)

> 1/2*2^(1/2)>> simplify(d)

22 1/2 2 t

2 (1 - t ) - -----------2 1/2

(1 - t )---------------------------

22 t - 1

>> assume(t, Type::Real) : assume(t < 1/sqrt(2), _and) : assume( t > -1/sqrt(2), _and)

]-1/2*2^(1/2), 1/2*2^(1/2)[>> simplify(d)

22 1/2 2 t

2 (1 - t ) - -----------2 1/2

(1 - t )---------------------------

21 - 2 t

VIII Exercice n◦8

VIII.1 Tracer le graphe de la fonction f et de sa dérivée :

f : t 7→ arcsin(t +√

1− t2

2)

33

Solution

>> f := t-> arcsin((t + sqrt(1 - t^2))/2)

t -> arcsin((t + sqrt(1 - t^2))/2)>> d := diff(f(t),t)

t1/2 - -------------

2 1/22 (1 - t )

-------------------------------/ / 2 1/2 \2 \1/2| | t (1 - t ) | || 1 - | - + ----------- | |\ \ 2 2 / /

>> plotfunc2d(f(t),d(t), t=-1..1, YRange=-1..1)

IX Exercice n◦9

A l’aide de MuPAD, étudiez la fonction :

f(x) = x2 arctan1

1 + x

IX.1 Quel est son domaine de définition dansR? Vous pourrez utiliser la fonctiondiscont() .

IX.2 Donnez sous une forme simplifiée la dérivée def .

IX.3 Calculerf(2).

IX.4 Étudier les limites de la fonctionf .

IX.5 Tracer la fonction à l’aide de MuPAD.

IX.6 Déterminer le développement de rang 3 de Taylor à droite et à gauche de−1.

IX.7 Tracer la fonction, sa dérivée et les développements limités sur un même graphe.

Pour résoudre cet exercice, on va créer un fichier contenant la résolution, la fonction qui permet de lireun fichier contenant des fonctions MuPAD est la fonctionread() .

34

Solution

print(NoNL,"Fonction f :"): f:=x^2*arctan(1/(1+x));//// Domaine de définition//print(NoNL,"Positions des discontinuités :"): discont(f,x,Dom::Real);// Dérivéeg:=diff(f,x):print(NoNL,"Dérivée :"): simplify(g);//// Calcul de f(2)//print(NoNL,"valeur en 2 :"): eval(subs(f,x=2)),float(eval(subs(f,x=2)));//// Étude des limites//print(NoNL,"limite en +infini :"): limit(f,x=infinity);print(NoNL,"limite en -infini :"): limit(f,x=-infinity);print(NoNL,"limite en -1 :"): limit(f,x=-1);print(NoNL,"limite à droite en -1 :"): limit(f,x=-1,Right);print(NoNL,"limite à gauche en -1 :"): limit(f,x=-1,Left);//// Graphe de la fonction//plotfunc2d(f, x = -5..5);input();//// Développement limités//print(NoNL,"Développement de Taylor à droite en x=-1,

3 termes sont demandés :"):poly3d := expr(series(f,x=-1,3,Right));print(NoNL,"Développement de Taylor à gauche en x=-1,

3 termes sont demandés :"):poly3g := expr(series(f,x=-1,3,Left));//// Graphe de la fonction et des développements limités et de la dérivée//enMoins1 := piecewise([x < -1, poly3g], [x > -1, poly3d]);plotfunc2d(f, enMoins1, g, x = -5..5, YRange= -6..6);

35

Trace de la solution

>> read("ex9.mu")Fonction f :

2 / 1 \x arctan| ----- |

\ x + 1 /Positions des discontinuités :

-1Dérivée :

2/ 1 \ x

2 x arctan| ----- | - ------------\ x + 1 / 2

2 x + x + 2valeur en 2 :

4 arctan(1/3), 1.287002218limite en +infini :

infinitylimite en -infini :

-infinitylimite en -1 :

undefinedlimite à droite en -1 :

PI--

2limite à gauche en -1 :

PI- --

2

Développement de Taylor à droite en x=-1, 3 termes sont demandés :PI 2 / PI \-- + (x + 1) (- PI - 1) + (x + 1) | -- + 2 |

2 \ 2 /Développement de Taylor à gauche en x=-1, 3 termes sont demandés :

PI 2 / PI \(x + 1) (PI - 1) - -- + (x + 1) | 2 - -- |

2 \ 2 /

/ PI 2 / PI \piecewise| - -- + (x + 1) (PI - 1) + (x + 1) | - -- + 2 | if x < -1,

\ 2 \ 2 /

PI 2 / PI \ \-- + (x + 1) (- PI - 1) + (x + 1) | -- + 2 | if -1 < x |

2 \ 2 / /

4 Résolution d’équations

MuPAD par l’intermédiaire de la fonctionsolve() permet de résoudre des équations ou même desinéquations. Cette résolution peut être formelle ou numérique.

36

Équation du 1er et 2nd degré

>> solve(a*x + b = c, x)

/ { - b + c }piecewise| { ------- } if a <> 0, C_ if a = 0 and - b + c = 0,

\ { a }

\{} if a = 0 and - b + c <> 0 |

/

>> solve(a*x^2 + b*x +c = 0, x)

/|||

piecewise| C_ if a = 0 and b = 0 and c = 0,\

{ c }{} if a = 0 and b = 0 and c <> 0, { - - } if a = 0 and b <> 0,

{ b }

{ 2 1/2 2 1/2 } \{ b (- 4 a c + b ) b (- 4 a c + b ) } |{ - - - ----------------- - - + ----------------- } |{ 2 2 2 2 } |{ -----------------------, ----------------------- } if a <> 0 |{ a a } /

Si l’équation a un nombre infini de solutions le domaine est défini. Ainsi dans l’exemple suivantX2, X4 ∈Z.

>> solve(sin(x)+cos(x) = 1)

PIx in 2 PI k | k in Z_ union -- + 2 PI k | k in Z_

2

Pour calculer numériquement les solutions d’une équation, on obtient toutes les solutions de l’équa-tion, puis on peut utiliser la fonctionfloat() pour obtenir une approximation. Dans l’exemple qui suitRootOf représente l’ensemble des racines solutions du polynôme et la fonctionmap() applique la fonctionfloat() à l’ensemble des solutions.

37

Solution numérique

>> solve(x^7 + x^2 + x, x)

6{0} union RootOf(X5 + X5 + 1, X5)

>> map(last(1),float)

{- 0.1547351445 + 1.038380754 I, - 0.1547351445 - 1.038380754 I,

- 0.7906671888 - 0.3005069203 I, - 0.7906671888 + 0.3005069203 I,

0.9454023333 + 0.6118366938 I, 0.9454023333 - 0.6118366938 I, 0.0}

Terminons par une inéquation :

Inéquation

>> solve(x^4 > 15, x)

]15^(1/4), infinity[ union ]-infinity, -15^(1/4)[

4.1 Système d’équations

Pour résoudre un système d’équation on spécifie les équations et les inconnues sous la forme d’unensemble.

Considérons le problème suivant : Le père Olivier éleveur d’ânes de son état possède un terrain de formecarrée. Il décide de créer sur son terrain une carrière sous la forme d’un enclos carré pour entraîner ses ânesau saut d’obstacles, pour les prochains jeux olympiques. Pour clôturer le terrain et l’enclos, il lui faut6000mètres de lisses en bois et il y a 3 lisses par hauteur. La partie non occupée par la carrière est mise en herbeet cette surface ensemencée est de150000m2, quelle est la taille du champ, quelle est la taille de la carrière ?

Système d’équations

>> equations := {4 * x + 4 * y = 2000, x^2 - y^2 = 150000}

2 2{4 x + 4 y = 2000, x - y = 150000}

>> solve(equations, {x, y})

{[x = 400, y = 100]}

38

4.2 Equations différentielles

Même s’il n’est pas dans notre propos, d’étudier les équations différentielles commençons par situer leproblème en termes de systèmes dynamiques qui conduisent généralement à des modèles mathématiquesutilisant des équations différentielles. La notion de système dans ce cadre correspond au processus que l’oncherche à modéliser, il évolue dans le temps et le système est alors décrit par des variables qui varienten fonction du temps. Le système est ouvert s’il y a des échanges (matière/énergie) avec l’extérieur. Leséchanges s’effectuent par l’intermédiaire des entrées et des sorties du système. Les entrées du systèmecorrespondent aux variations expérimentales que le système subit. Les sorties sont les réponses du systèmec’est-à-dire les échanges avec le milieu extérieur et également les variables modifiées.

Les paramètres d’un modèle interviennent dans les équations du modèle et sont des grandeurs fixées.Les fonctions utilisées sont fréquemment non-linéaires soit par rapport aux paramètres, soit par rapport auxvariables :

– Par rapport aux paramètres, un exemple simple est donné par l’équation :

y = a2x (14)

Si la valeur dea est modifiée d’un facteurn celle dey sera modifiée d’un facteurn2. Il n’y pasproportionalité entre la cause qui est la modification dea et son effet qui se traduit par la modificationde la valeur dey.

– Par rapport aux variables. On considère qu’une fonction est non linéaire si l’une au moins de sesdérivées premières n’est pas constante. Considérons par exemple l’équation

f(x1, x2, x3) = ax1 + bx2x3 aveca, b constantes (15)

Exemple

>> f := (x1, x2, x3) -> a*x1 + b*x2*x3

(x1, x2, x3) -> a*x1 + b*x2*x3>> diff(f(x1,x2,x3),x1)

a>> diff(f(x1,x2,x3),x2)

b x3>> diff(f(x1,x2,x3),x3)

b x2>>

∂f(x1,x2,x3)∂x2

6= constante l’équation n’est donc pas linéaire.Schématiquement, un système dynamique est décrit par une loi d’évolution qui, à partir de conditions

initiales permet de déterminer le futur ; l’évolution temporelle est décrite par une ou plusieurs équationsdifférentielles. Ces équations peuvent être ordinaires (ODE ordinary differential equation) si elles font in-tervenir uniquement les variables et leurs dérivées par rapport par rapport au temps. Si vos équations diffé-rentielles contiennent des dérivées par rapport à plusieurs grandeurs, le temps et une distance par exemple,il s’agit d’une équations aux dérivées partielles. Enfin l’ordre d’une équation différentielle désigne l’ordrede la dérivée de plus haut rang qu’elle contient. Une équation du premier ordre ne contient que des dérivées

39

premières de ses variables. L’équation linéaire de premier ordre la plus simple s’écrit sous la forme :

dy

dt= ky (16)

Equation différentielle ordinaire du premier ordre

>> equa_diff1 := ode(diff(y(t),t) = k*y(t), y(t))

ode(- k y(t) + diff(y(t), t), y(t))>> solve(equa_diff1)

C1 exp(k t)>> equa_diff2 := ode(y’(t) = k*y(t), y(t))

ode(- k y(t) + diff(y(t), t), y(t))>> solve(equa_diff2)

C2 exp(k t)

La fonctionode() définit une équation différentielle ordinaire, on précise une équation et une fonction.On peut alors chercher la solution générale à l’aide desolve() .

Examinons maintenant un exemple, selon Thomas Malthus3, la vitesse de croissance d’une populationest proportionnelle à son effectif présent. Soitk la constante qui exprime le pourcentage d’augmentation dela population pendant la période considérée (ex :k = 1, 25 si la population a connu une augmentation de25%). Si l’effectif initial est den0 à t = 0, il devient à∆t défini comme unitaire :

n1 = kn0 (17)

De même au pas de temps suivant :n2 = kn1 (18)

De proche en proche, on obtient l’équation (19) de Malthus :

n(t) = kn(t−1) (19)

L’accroissement de la population pendant le temps∆t est de :

∆n(t) = n(t+1) − n(t) = kn(t) − n(t) = (k − 1)n(t) (20)

La figure 6 montre la suite des valeursn(t). Un système dynamique évolue en fonction du temps maisla représentation proposée il n’apparaît pas de façon explicite. On le réintroduit en représentant (figure 7) lasuite des valeurs successives den(t) en fonction du temps (suite chronologique).

L’accroissement que nous venons d’établir (20) correspond à l’accroissement durant un pas de temps∆t. Si cette période est deux fois plus grande, la valeur obtenue pour∆n(t) serait deux fois plus grande etainsi de suite. On peut écrire :

∆n(t)

∆t= (k − 1)n(t) (21)

3Le principe des populations, 1798

40

n t

n t+1

n 0

n 1

n 2

n 3

n 4

t+1n

=

n t

t+1

n

=

k n

t

FIG. 6 – Équation de Malthus dans le plan(nt+1, nt)

n t

n t+1

n 0

n 1

n 2

n 3

n 4

t+1n

=

n t

t+1

n

=

k n

t

n t

n 0

2 3 41 tδ

FIG. 7 – Série chronologique

41

En passant des différences finies aux différentielles :

dn(t)

dt= (k − 1)n(t) (22)

On résout cette équation différentielle en utilisant MuPAD :

Résolution de l’équation de Malthus

>> equa_malthus := ode({diff(n(t),t) = (k - 1) * n(t), n(0) = n0}, n(t))

ode({n(0) = n0, diff(n(t), t) - n(t) (k - 1)}, n(t))>> solve(equa_malthus)

{n0 exp(k t) exp(-t)}

Cela conduit donc à une croissance exponentiellen(t) = n0e(k−1)t, on parle alors de loi exponentielle.

La représentation ainsi que la résolution nous montre que l’effectif de la population ne croît pas de façonlinéaire. Les intervalles de temps sont constants et la différence entreni etni+1 est plus petite que celle entrenj etnj+1 aveci < j. La loi d’évolution est linéaire par contre la série chronologique ne l’est pas.

Si n0 = 0, la population reste nulle, quel que soit la valeur dek. Ce point particulier (singulier) qui resteinvariant suite à l’application de la règle d’évolution est un point fixe et correspond à un état stationnaire dusystème dynamique.

Les propriétés de l’état stationnaire dépendent de celles de la règle d’évolution. Lorsquek > 1, lapopulation augmente quel que soit l’effectifn0 initial. Toute perturbation apportée au système provoquel’éloignement de ce point fixe. L’état stationnaire est instable, il est appelé répulseur (cf. fig. 8). Par contre,

10007505002500

2000

1500

1000

500

0

x

y

x

y

FIG. 8 – Equation de Malthusk > 1

lorsquek < 1, la population diminue de façon irrémédiable vers 0. L’état stationnaire est stable, il est appeléattracteur (cf. fig. 9).

42

32,521,510,5

3

2,5

2

1,5

1

0,5

0

x

y

x

y

FIG. 9 – Equation de Malthusk < 1

Le modèle malthusien ne reflète pas réellement la réalité, puisque la croissance est sans fin. Un demi-siècle après, Darwin reprend le principe énoncé par Malthus et ajoute la notion de compétition entre espèces.Verhulst avait proposé (eq. 23) auparavant à partir du modèle Malthusien un modèle bornant la croissanceexponentielle.

n(t+1) = λn(t)(1−n(t)

K) (23)

Ce modèle correspond à la loi logistique. On peut utiliser MuPAD pour étudier ce modèle.

Solution de l’équation logistique

>> equa_logistique := n -> lambda * n * (1 - n/K)

n -> lambda*n*(1 - n/K)>> solve(equa_logistique(n), n)

piecewise({} if K = 0 and lambda = 0, C_ if K <> 0 and lambda = 0,

{} if K = 0 and lambda <> 0, {K, 0} if K <> 0 and lambda <> 0)

L’effectif n varie entre0 etK lorsqueλ 6= 0 etK 6= 0.

43

Graphe de l’équation logistique

>> lambda := 2.5

2.5>> K := 12>> plotfunc2d(equa_logistique(n),n, n = -1.. 13)

12,5107,552,50

12,5

10

7,5

5

2,5

0

-2,5

n

y

n

y

2.5*n*(1 - 1/12*n), n

L’équation logistique avec0 ≤ x ≤ K présente un comportement intéressant en fonction de la valeurdeλ. Pour des faibles valeurs deλ, la courbe se situe en dessous de la première bissectrice et quelle que soitla valeur initialen0 le système converge vers l’attracteur(0, 0) (figure 10).

D’une façon générale, lorsqueλ < 3, le système converge vers un état stationnaire qui révèle la présenced’un attracteur ponctuel (figure : 11).

Si λ = 3.1, le système oscille entre deux valeurs (figure 12).et si l’on augmente encoreλ < 3.5699456718 (figure 13) le système va osciller entre 4, 8, 16, 32

. . . valeurs. On est en présence d’attracteurs cycliques, l’augmentation deλ provoquant des dédoublementsde la période.

Lorsqueλ > 3.5699456718, c’est le chaos (figure 14), le système se comporte de façon désordonnée etmanifeste la présence d’un attracteur étrange.

La démarche pour l’établissement d’un modèle pour un système dynamique comporte donc les phasessuivantes4 :

– Identification des variables, de leur interaction et des boucles de régulation qui les relient ;– Établissement du système d’équations décrivant l’évolution temporelle des variables ;– Identification des états stationnaires, leurs nombres et leurs conditions d’existence et leurs valeurs

(analytique ou numérique) ;– Étude de la stabilité des états stationnaires ;

4Remarque : les deux derniers points n’ont pas été traités dans ce qui précède car il sorte du contenu de ce cours.

44

107,552,50

10

7,5

5

2,5

0

x

y

x

y

FIG. 10 – Loi logistiqueλ = 0.7

107,552,50

10

7,5

5

2,5

0

x

y

x

y

FIG. 11 – Loi logistiqueλ = 2.5

45

107,552,50

10

7,5

5

2,5

0

x

y

x

y

FIG. 12 – Loi logistiqueλ = 2.5

107,552,50

10

7,5

5

2,5

0

x

y

x

y

FIG. 13 – Loi logistiqueλ = 3.569

46

107,552,50

10

7,5

5

2,5

0

x

y

x

y

FIG. 14 – Loi logistiqueλ = 3.6

– Intégration (numérique) éventuelle du système d’équations différentielles ;– Étude du chaos éventuel à l’aide du diagramme de bifurcation.

X Exercice n◦10

On considère la suite récurrente définie par :

un = un−1 + un−2, u0 =√

(5)− 1 etu1 =√

(5)− 3

X.1 Calculer la valeur exacte deu100. Vous utiliserez la composition de fonction.

X.2 Calculer les valeurs approchées deu100 avec 10, 20, 30, 40, 50 et 100 chiffres significatifs.

X.3 Résoudre cette récurrence, c’est-à-dire trouver la valeur deuk en fonction dek. Vérifier quel’on retrouve la même valeur queu100 que précédemment.

X.4 Quelle est la limite de la suite(uk)k∈N ?

47

Solution

>> r := rec(v(k) = v(k - 1) + v(k - 2), v(k), {v(0) = sqrt(5) - 1, v(1) = sqrt(5) - 3})

1/2 1/2rec(v(k) - v(k - 1) - v(k - 2), v(k), {v(0) = 5 - 1, v(1) = 5 - 3})

>> res := solve(r)

{ / 1/2 \ k }{ 1/2 | 5 | }{ (5 - 1) | 1/2 - ---- | }{ \ 2 / }

>> u := fp::unapply(res[1], k)

k -> (5^(1/2) - 1)*(1/2 - 1/2*5^(1/2))^k

>> u(100)

/ 1/2 \ 1001/2 | 5 |

(5 - 1) | 1/2 - ---- |\ 2 /

>> float(%)

1.560552308e-21>> limit(u(k), k = +infinity)

0

XI Exercice n◦11

XI.1 Trouver les extrema de la fonction :

f : (x, y) 7→ x ey + y ex

XII Exercice n◦12

XII.1 Résoudre l’équation différentielle :

y′ − 2y = 1

XII.2 Tracer sur le même graphe les solutions correspondant aux conditions initialesy(0) = 1, 0,−1 et−2.

5 Programmation en MuPAD

MuPAD permet de réaliser des programmes. Il utilise pour cela des objets, des instructions, des fonctionsdu logiciel et des fonctions définies par l’utilisateur.

5.1 Les variables

Tout d’abord commençons par la notion d’identificateur. Les identificateurs sont des noms qui repré-sentent des variables, des inconnues, des fonctions ou des procédures. C’est une combinaison quelconque

48

de lettres, de chiffres et du caractère _. Le premier caractère ne peut pas être un chiffre. Un identificateur apour valeur l’objet qui lui a été affecté par l’intermédiaire de l’opérateur d’affectation:= . Si aucune valeurn’a été affectée alors le nom correspond à la valeur.

Dans la plupart des langages informatiques, on utilise des variables, c’est-à-dire que l’on associe à unidentificateur (un nom) un contenu. On pourra ainsi appeler une variablevariable et y stocker la valeurdu nombre complexe1 + 5i.

Exemple de variables

>> variable

variable>> domtype(variable)

DOM_IDENT>> variable := 1 + 5*I

1 + 5 I>> domtype(variable)

DOM_COMPLEX>> x := 3: y:=4

4>> tmp := x : x := y : y := tmp

3>> x; y

4

3>> delete tmp

>>

Toute variable a une durée de vie et une portée. En MuPAD cela définit deux types de variables :– Lesvariables locales: ce sont toutes les variables qui sont déclarées à l’intérieur des procédures ou en

tant que paramètres. La portée de ces variables est la procédure et la durée de vie est limitée à la duréed’exécution de la procédure. En dehors de la procédure, elles ne sont plus accessibles puisqu’ellesn’existent plus.

– Les variables globales: cela doit être exceptionnel, mais vous pouvez avoir besoin d’une variablequi soit accessible depuis n’importe quelle procédure. Dans ce cas la variable existe tant que vous nel’avez pas détruite soit pardelete ou parreset() ou encore en quittant votre session MuPAD .

La définition de telles variables est précisée dans le paragraphe 5.3.1.

5.2 Objets structurés

Nous avons déjà rencontré de nombreux objets comme les nombres et les expressions symboliques, nousles présentons ici dans une optique de programmation. Tout objet MuPAD possède un type qui correspondà sa représentation interne, définit son domaine de valeur et les opérations possibles.

49

Type d’un objet MuPAD

>> domtype(1 - 2*I)DOM_COMPLEX

>> domtype(x + y)

DOM_EXPR

5.2.1 Expressions symboliques

Une expression est composée d’opérandes, d’opérateurs et d’appels de fonctions. Une expression peutelle-même contenir une sous-expression.

L’équationf(x, y, z)

g(x)∗ PI ∗ ex = 0 est une expression.

L’expressiona + b est composée de deux opérandesa et b et de l’opérateur+.Il peut être nécessaire de décomposer une expression en composants pour pouvoir les manipuler. Les

fonctions MuPAD qui permettent cela sont en particuliernops() et op() . La première fonction retournele nombre d’opérandes contenues dans l’expression.

Utilisation de nops()

a := x + Y + sin(x)

Y + x + sin(x)>> nops(a)

3

La seconde fonctionop() permet de récupérer un ou plusieurs opérandes donnés.

Utilisation de op()

>> op(a)

Y, x, sin(x)>> op(a,1)

Y>> op(a,2..3)

x, sin(x)>>

MuPAD permet l’utilisation d’opérateurs et les transforme en fonctions. Les différents opérateurs sontprésentés dans le tableau 3.

50

Opérateur Signification Exemple+ addition somme := a + b− soustraction soustrac := a− b∗ multiplication mult := a ∗ b/ division division := a/b

div division entière quotient := a div bmod reste division entière reste := a mod b

ˆ puissance puissance := a b! factorielle fact := n!$ génération de séquence sequence := i 2 $i = 5..7, concaténation de séquence seq := seq1, seq2

union union de deux ensembles s := s1 union s2intersect intersection de deux ensembless := s1 intersect s2minus différence de deux ensembles s := s1 minus s2

= équation equation = a ∗ x + b = 0<> inégalité condition := a <> b< inférieur strictement condition := a < b

<= inférieur condition := a <= b> supérieur strictement condition := a > b

>= supérieur condition := a >= bnot négation contraire := not conditionand et logique condition := a < b and b < cor ou logique condition := a < b or b < c→ application f := x→ a ∗ x 2′ différentielle derivee := f ′(x)@ composition de fonction h := f@g

@@ itération g := f@@4.. intervalle intervalle := a..b. concaténation nouveauNom := nouveau.Nom

identificateur() appel de fonction sin(1), f(x)

TAB . 3 – Principaux opérateurs

51

La forme fonctionnelle des opérateurs est précisée dans l’aide de MuPAD pour chaque opérateur. Cetteforme permet d’appliquer l’opérateur à plusieurs arguments.

Utilisation de la fonction à la place de l’opérateur

>>_plus(i^2 $ i = 0..100)

338350

ou encore de l’appliquer à l’aide de la fonctionmap() aux éléments d’une liste.

Utilisation de la fonction à la place de l’opérateur

>> map([1, 2 , 3], fact)

[1, 2, 6]

Des règles de priorité et d’associativité sont définies, elles sont précisées dans l’aide en consultant"Quick Reference" [?].

5.2.2 Expressions booléennes

Les expressions booléennes sont souvent importantes en programmation car elles permettent de testersi quelque chose est vrai ou de répéter un traitement jusqu’à ce qu’une condition devienne vraie. MuPADmanipule trois valeurs logiquesTRUE, FALSE, et UNKNOWNet utilise les opérateursand , or et not . Lafonctionbool() évalue les expressions booléennes.

Exemple d’expressions booléennes

>> a := PI; b := 3.14

PI3.14

>> bool(a = b), bool(a <> b), bool(float(a) <= b) or not bool(float(a) > b)

FALSE, TRUE, FALSE

5.2.3 Séquences

Une séquence (suite) est simplement une suite d’expressions séparées par des virgules.

52

Exemple de séquences

>> sequence := 1, a, sin(x), f(x)

1, a, sin(x), f(x)>> domtype(sequence)

DOM_EXPR

La séquence vide est créée par la fonctionnull() et il est possible de récupérer un élément d’uneséquence en précisant sa place dans l’énumération. La concaténation de séquences est réalisée à l’aide del’opérateur, (virgule).

Manipulation de séquences

>> sequence1 := a , b, f(x), PI, sin(x)

a, b, f(x), PI, sin(x)>> sequence2 := 1, 2, null(), 8

1, 2, 8>> sequence := sequence1, sequence2

a, b, f(x), PI, sin(x), 1, 2, 8>> sequence[4]

PI

L’opérateur de génération de séquence $ permet la création de grandes séquences rapidement. Ainsi sim etn sont des entiersobjet(i) $ i = m..n génère la séquence :objet(m), objet(m + 1), ...., objet(n) .

Génération de séquences

>> x$6

x, x, x, x, x, x>> suite := sin(k*PI/5) $k=1..5

1/2 1/2 1/2 1/2 1/2 1/2 1/2 1/2 1/22 (5 - 5 ) 2 (5 + 5) 2 (5 + 5)------------------, ------------------, ------------------,

4 4 4

1/2 1/2 1/22 (5 - 5 )------------------, 0

4>> map(suite, float)

0.5877852523, 0.9510565163, 0.9510565163, 0.5877852523, 0.0

53

5.2.4 Les listes

Une liste est une suite ordonnée d’objets MuPAD quelconques séparés par des virgules et le tout placéentre crochets.

Exemple de liste

>> ex := [ceci, est, une, liste, 4, sin(x)^2, [sous, liste]]

2[ceci, est, une, liste, 4, sin(x) , [sous, liste]]

La liste vide est représentée par[] et nops() permet de connaître le nombre d’opérandes. Le ieme

élément de la liste peut être obtenu par la fonctionop() ou avec l’opération d’indexation[ index ] . Uneséquence entre crochets est donc une liste.

Manipulation d’une liste

>> nops(ex)

7>> op(ex,4)

liste>> ex[4]

liste

Il existe plusieurs fonctions pour manipuler les listes (cf. tab. 4).

Fonction Signification_concat() ou . Concaténation de listes

append() Ajout d’élémentscontains(liste, x) La liste contient-elle des élémentsx ?

liste[i] Accès auieme élémentmap(objet, f) Application d’une fonctionf àobjet

nops() Nombre d’éléments de la listeop() Accès aux éléments

select() Sélection d’éléments suivant une propriétésort() Tri de la listesplit() Coupe la liste en fonction d’une propriété

subsop() Remplace des éléments de la listedelete() Supprime des élémentszip() Combine deux listes

TAB . 4 – Fonctions sur les listes

54

Exemples sur une liste de différentes fonctions

>> a := [0, PI/2, PI, 3*PI/2]: map(a, sin)

[0, 1, 0, -1]>> select([i $ i = 1..20], isprime)

[2, 3, 5, 7, 11, 13, 17, 19]>>>> split([i $ i = 1..20], isprime)

[[2, 3, 5, 7, 11, 13, 17, 19], [1, 4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20], []]

Exemple développé

>> l := [i $i=-7..7]

[-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7]>> //On cherche à enlever les éléments positifs>> negatif := x -> is(x < 0)

x -> is(x < 0)>> select(l, negatif)

[-7, -6, -5, -4, -3, -2, -1]>> >> // Ajout d’un élément à une liste>> l1 := [i $i=0..9]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]>> l1 := [op(l1), dix]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, dix]>> l1 := l1.[onze]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, dix, onze]

5.2.5 Les ensembles

Un ensemble est une suite d’objets MuPAD séparés par des virgules et encadrés par des accolades. Dansun ensemble, il n’y a pas d’ordre et de répétition.

Ensemble

>> ensemble := {a, b, c, a}

{a, b, c}>> op(ensemble)

c, b, a

55

L’ensemble vide est représenté par{}. Il existe différentes opérations possibles sur les ensembles (cf.tab. 5).

Opérateur Fonction Significationcontains(E, x) L’ensembleE contient-il l’élémentx ?

intersect _intersect() Intersectionunion _union() Unionminus _minus() Différence

nops() Cardinalmap() Application d’une fonction aux éléments

[indice] Accès à l’élément d’indiceindiceselect() Sélection en fonction de propriétéssplit() Découpe l’ensemble en fonction de propriétés

combinat :: subsets :: list() Sous-ensembles de n éléments d’un ensemblecombinat :: cartesianProduct :: list() Produit cartésien

TAB . 5 – Opérations sur les ensembles

Exemple d’opérations sur les ensembles

>> {x, 1, 5} intersect {x, 1, 3, 4}, {x, 1, 5} union {x, 1, 3, 4}, {x, 1, 5} minus {x, 1, 3, 4}

{x, 1}, {x, 1, 3, 4, 5}, {5}>> x := 8;

{x, 1, 5} intersect {x, 1, 3, 4}, {x, 1, 5} union {x, 1, 3, 4}, {x, 1, 5} minus {x, 1, 3, 4}

8

{1, 8}, {1, 3, 4, 5, 8}, {5}>> L := [{a, b}, {1, 2, a, c}, {3, a, b}, {a, c}]: _intersect(op(L))

a>> map({1, 2, 3}, float@sin)

{0.1411200081, 0.8414709848, 0.9092974268}>> combinat::subsets::list({a,b,c,d,e},3)

[{c, d, e}, {b, d, e}, {a, d, e}, {b, c, e}, {a, c, e},{a, b, e}, {b, c, d}, {a, c, d}, {a, b, d}, {a, b, c}]

>> combinat::cartesianProduct::list({Pique, Carreau, Coeur, Trefle},{7,8,9,10})

[[Trefle, 10], [Trefle, 9], [Trefle, 8], [Trefle, 7],[Coeur, 10], [Coeur, 9], [Coeur, 8], [Coeur, 7],[Carreau, 10],[Carreau, 9], [Carreau, 8], [Carreau, 7],[Pique, 10], [Pique, 9], [Pique, 8], [Pique, 7]]

56

5.2.6 Tableaux et tables

Un tableau de taillem1 ×m2 × . . . ×mp est une structure qui contientm1m2m3 . . .mp entrées, nu-mérotées par lep-uplet(i1, i2, . . . , ip). Un tableau est donc une structure indexée, de plusieurs dimensions,dont les indices sont des entiers appartenant à un intervallea..b. Un tableau sert à stocker des données et sataille est fixe. La fonctionarray() permet de créer un tableau. Un tableau peut donc être de dimension 1,ou 2 ou mêmen avecn > 2. On accède à un élément donné d’un tableau à l’aide de ses indices, lorsque letableau est de dimension 1 il y a un unique indice pour repérer un élément, de dimension 2, il y a 2 indices,de dimensionn il y a n indices.

Manipulation d’un tableau

>> tab := array(5..7) /* Tableau indicé à partir de 5 jusqu’à 7*/

+- -+| ?[5], ?[6], ?[7] |+- -+

>> tab[2] /* L’indice n’existe pas ! */Error: Illegal argument [array]> tab[5] := 1: tab[6] := "milieu" : tab

+- -+| 1, "milieu", ?[7] |+- -+

Il est possible d’initialiser partiellement ou totalement un tableau lors de sa création.

Initialisation d’un tableau

>> tab2 := array(1..5, 1 = "initialisation", 2= "incomplete")

+- -+| "initialisation", "incomplete", ?[3], ?[4], ?[5] |+- -+

>> tab3 := array(1..5, i = sqrt(i) $i=1..4)

+- 1/2 1/2 -+| 1, 2 , 3 , 2, ?[5] |+- -+

>> tab4 := array(1..5, ["ini","tia","lis", "ation", "complete"])

+- -+| "ini", "tia", "lis", "ation", "complete" |+- -+

57

Exemple d’un tableau de dimension 3

>> A := array(1..8, 1..8, 1..8,(1, 1, 1) = 111,(8, 8, 8) = 888)

array(1..8, 1..8, 1..8,(1, 1, 1) = 111,(8, 8, 8) = 888

)

>> A[1,2,3]

A[1, 2, 3]>> A[8,8,8]

888

Une table est une structure indexée dont les indices (ou index ) peuvent être de n’importe quel type. Lafonctiontable() permet de créer une table.

Utilisation d’une table

>> newton := table(objet = "pomme", acceleration = "9.81 m/s^2", hauteur ="Dans l’arbre",poids=0.12)

table(poids = 0.12,hauteur = "Dans l’arbre",acceleration = "9.81 m/s^2",objet = "pomme"

)>> newton[objet], newton[poids]

"pomme", 0.12

5.2.7 Les chaînes de caractères

Une chaîne de caractères est une suite de caractères encadrés par des guillemets."Ceci est unexemple" . La concaténation de deux chaînes de caractères se fait à l’aide de l’opérateur. et on peutégalement utiliser la fonction_concat() . L’opérateur d’indexation[i] extrait le caractère d’indicei de lachaîne. Le premier indice est 1. Pour afficher une chaîne de caractères on peut utiliser la fonctionprint() .

58

Manipulation de chaînes

>> endroit:="esope reste ici et se repose"

"esope reste ici et se repose">> envers :="esoper es te ici etser epose"

"esoper es te ici etser epose">> stringlib::subs(endroit, " " = "")

"esoperesteicietserepose">> stringlib::subs(envers, " " = "")

"esoperesteicietserepose">> endroit.envers

"esope reste ici et se reposeesoper es te ici etser epose">> endroit[1]:="E"

"E">> endroit

"Esope reste ici et se repose">> print(endroit)

"Esope reste ici et se repose"

5.3 Programmation

MuPAD fournit les éléments indispensables d’un langage de programmation. Il y a, à la fois les instruc-tions conditionnelles, les boucles et les procédures. L’aspect programmation que nous considérons ici, estcelui qui consiste à définir des procédures en utilisant les instructions et les différentes fonctions prédéfiniesou définies par l’utilisateur.

5.3.1 Les procédures

Les procédures comme les fonctions MuPAD retournent des valeurs. Une procédure est appelée commeune fonction.

nom_de_la_procedure(arguments)

Les procédures sont généralement définies dans un fichier que l’on charge à l’aide de la fonctionread()par exemple. Une procédure est composée de :

– Une en-tête qui correspond à l’identificateur (le nom) de la procédure, sa déclaration à l’aide deprocet la liste de ses paramètres ;

– La déclaration des variables appartenant uniquement à la procédure (variables locales) ;– Le corps de la procédure qui contient les instructions qui constituent la procédure. Ce corps est déli-

mité parbegin etend_proc .

59

Exemple de procédure

>> ExempleDeProcedure := proc (a, b) // En tête de la procédure// a et b sont les paramètres de la procédure

local variable1, variable2; // Variables localesbegin // Début du corps

if a < b // Instructionthen return (b)else return (a)

end_ifend_proc : // Fin du corps

Les variables peuvent être locales ou globales, pour qu’une variable soit locale elle doit avoir été déclaréedans la procédure précédée du mot cleflocal . Sinon toute variable non déclarée locale ou non déclaréeest considérée comme globale.

Les instructions entrebegin et end_proc peuvent être des commandes MuPAD quelconques, autre-ment dit cela peut être des fonctions MuPAD, des instructions de programmation, ou des appels de procé-dures. La commandereturn termine la procédure et transmet la valeur de son argument comme valeur desortie qui correspond au résultat.

Une procédure peut retourner un objet MuPAD quelconque (expression, séquence, liste, ensemble, fonc-tion, ou même une autre procédure).

Procédure qui retourne une fonction

>> creeFonctionPuissance := proc(puissance)option escape;begin

x -> (x^puissance)end_proc:

>> f := creeFonctionPuissance(7)

x -> x^puissance>> f(a)

7a

>> f(2)

128

Lorsque la procédure ou la fonction retournée utilise une variable locale ou un paramère d’entrée on doitutiliser l’optionescape .

5.3.2 Les instructions

Il existe deux catégories d’instructions :– Les instructions conditionnelles ;– Les boucles itératives et les boucles conditionnelles.

60

Les instructions conditionnellesIl existe en MuPAD deux instructions conditionnelles :if et case . La syntaxe de l’instruction condition-nelle if est la suivante :

if conditionthen

instruction1;instruction2;....

end_ifsuiteinstruction;

Lorsquecondition est vraie (TRUE), la suite d’instructions "instruction1 , instruction2 , ... "est exécutée, puis ensuitesuiteinstruction . Si lacondition est fausse on passe àsuiteinstruc-tion . condition est une expression booléenne.

if conditionthen

instruction_alors1;instruction_alors2;....

elseinstruction_sinon1;instruction_sinon2;....

end_ifsuiteinstruction;

Lorsquecondition est vraie (TRUE), la suite d’instructions "instruction_alors1 , instruction-_alors2 , ... " est exécutée, puis ensuitesuiteinstruction . Si la condition est fausse la suited’instructions "instruction_sinon1 , instruction_sinon2 , ... " est exécutée puis ensuitesuiteinstruction .

Exemple de if

>> p := proc(i)begin

if isprime(i)then print(Unquoted, NoNL, expr2text(i)." est ")else print(Unquoted, NoNL, expr2text(i)." n’est pas ")

end_if:print(Unquoted, NoNL,"premier.");

end_proc:

proc p(i) ... end>> p(6)6 n’est pas premier

Il existe une autre instruction conditionnelle qui permet des choix multiples. C’est l’instructioncase .

61

case objet_MuPADof valeur1 do instructions_1....of valeurn do instructions_n

end_case

ou son autre forme :

case objet_MuPADof valeur1 do instructions_1....of valeurn do instructions_notherwise intructions_autrement

end_case

Si la valeur deobjet_MuPAD est égale à l’une des valeursvaleur1, valeur2, ..., valeurntoutes les instructions qui suivent sont exécutées jusqu’à rencontrer une instructionbreak ou return .

Utilisation du case

>> x := 2:case x

of 1 do print(1)of 2 do print(4)of 3 do print(9)otherwise print("autrement")

end_case:

4

9

"autrement">> case x

of 1 do print(1); breakof 2 do print(4); breakof 3 do print(9); breakotherwise print("autrement")

end_case:

4

Si aucune brancheof ne correspond c’est la brancheotherwise qui est exécutée.

62

Utilisation du case et otherwise

>> questCequeCest := proc(x)begin

case domtype(x)of DOM_INT doof DOM_RAT doof DOM_FLOAT do print(x,"est un nombre réel"); breakof DOM_COMPLEX do print(x, "est un nombre complexe"); breakotherwise print(x," est ni un réel, ni un complexe");

end_caseend_proc:

>> questCequeCest(-6), questCequeCest(3/7), questCequeCest(sqrt(-1)),questCequeCest(questCequeCest)

-6, "est un nombre réel"

3/7, "est un nombre réel"

I, "est un nombre complexe"

proc questCequeCest(x) ... end, " est ni un réel, ni un complexe"

Les bouclesIl existe deux sortes de boucles, les boucles itératives (for ) et les boucles conditionnelles (repeat

et while ). Les boucles itératives sont effectuées un nombre de fois fixé à l’avance alors que les bouclesconditionnelles sont effectuées en fonction d’une condition satisfaite ou non.

Commençons par décrire la bouclefor . La syntaxe est la suivante :

for variableDeBoucle from valeurInitiale to valeurFinale doinstructions_1 /* Corps de la boucle */....instructions_n

end_for

variableDeBoucle est donc une variable (généralement locale) qui sert à contrôler la boucle. La va-leur initiale est fixée parvaleurInitiale et la valeur finale parvaleurFinale . La variable debouclevariableDeBoucle va prendre successivement de façon croissante et de 1 en 1 les valeursvaleurInitiale jusqu’àvaleurFinale .

63

Boucle for croissante

>> for i from 1 to 4 dox := i^2;print(Unquoted,expr2text(i)."^2=".expr2text(x))

end_for:

1^2=1

2^2=4

3^2=9

4^2=16

Il est possible de spécifier le pas de variation (pas ) de la boucle à l’aide destep .

for variableDeBoucle from valeurInitiale to valeurFinale step pas doinstructions_1 /* Corps de la boucle */....instructions_n

end_for

Boucle for croissante avec pas

>> for i from 1 to 4 step 2 dox := i^2;print(Unquoted,expr2text(i)."^2=".expr2text(x))

end_for:

1^2=1

3^2=9

On pourra remarquer que la boucle s’arrête dès quevariableDeBoucle > valeurFinale .Les bouclesfor que nous avons présentées sont croissantes, elles peuvent être décroissantes.

for variableDeBoucle from valeurInitiale downto valeurFinale doinstructions_1 /* Corps de la boucle */....instructions_n

end_for

64

Boucle for décroissante

>> for i from 4 downto 1 dox := i^2;print(Unquoted,expr2text(i)."^2=".expr2text(x))

end_for:

4^2=16

3^2=9

2^2=4

1^2=1

for variableDeBoucle from valeurInitiale downto valeurFinale step pas doinstructions_1 /* Corps de la boucle */....instructions_n

end_for

Boucle for décroissante avec pas

>> for i from 4 downto 1 step 2 dox := i^2;print(Unquoted,expr2text(i)."^2=".expr2text(x))

end_for:

4^2=16

2^2=4

La variable de boucle peut également prendre les valeurs des objets contenus dans un objet structuré.

for variableDeBoucle in objetStructure doinstructions_1 /* Corps de la boucle */....instructions_n

end_for

65

Boucle for et objet structuré

>> liste :=[i $i=1..5, a*y^2]

2[1, 2, 3, 4, 5, a y ]

>> for i in liste doprint(i)

end_for:

1

2

3

4

5

2a y

Les boucleswhile et repeat sont des boucles conditionnelles, la première est effectuée tant que lacondition est vraie alors que la seconde jusqu’à ce que la condition devienne vraie. La syntaxe de la bouclewhile est la suivante :

while condition doinstruction 1 /* Corps de la boucle */....instruction_n

end_while

Le corps de la boucle est effectué tant quecondition est vraie.

Utilisation de while - algorithme d’Euclide -

>> n := 12: m:= 18

18>> b := n: r := m

18

>> while r <> 0 doa := b;b := r;r := a mod b;

end_while:print(Unquoted,"PGCD(".expr2text(n,m).") = ".expr2text(b));

PGCD(12, 18) = 6

66

La syntaxe de la bouclerepeat est la suivante :

repeatinstruction 1 /* Corps de la boucle */....instruction_n

until condition end_repeat

Utilisation de repeat - algorithme d’Euclide -

>> n := 12: m:= 18

18>> b := n : r := m

18>> repeat

a := b;b := r;r := a mod b;

until r=0 end_repeat:print(Unquoted,"PGCD(".expr2text(n,m).") = ".expr2text(b));

PGCD(12, 18) = 6

Le corps de la boucle est effectué tant que la condition est fausse.

5.4 Exercices

XIII Exercice n◦13

XIII.1 Utiliser une commande simple pour créer la somme double :

10∑i=1

i∑j=1

1i + j

Solution

>> _plus((1/(i + j) $j= 1..i) $i= 1..10)

1464232069/232792560>>

XIV Exercice n◦14

XIV.1 Créez deux listes avec des élémentsun, deux, trois, quatre et 1, 2, 3, 4. Concaténer leslistes. Multiplier les listes deux à deux.

67

Solution

>> l1 := [un, deux, trois, quatre]: l2 := [1, 2, 3, 4]:>> l1.l2, zip(l1, l2, _mult)

[un, deux, trois, quatre, 1, 2, 3, 4], [un, 2 deux, 3 trois, 4 quatre]

XV Exercice n◦15

SoitX = [x1, . . . , xn] etY = [y1, . . . , yn] deux listes de même longueur avecn fixé. Déterminer :

XV.1 Leur produit internex1y1 + . . . + xnyn

XV.2 Leur produit matriciel

[[x1y1, x1y2, . . . , x1yn], [x2y1, x2y2, . . . , x2yn] . . . [xny1, xny2, . . . , xnyn]

Solution

>> X := [x.i $i=1..7]: Y := [y.i $i=1..7]

[y1, y2, y3, y4, y5, y6, y7]>> _plus(op(zip(X, Y, _mult)))

x1 y1 + x2 y2 + x3 y3 + x4 y4 + x5 y5 + x6 y6 + x7 y7>> f := x -> (map(Y, _mult, x)): map(X, f)

[[x1 y1, x1 y2, x1 y3, x1 y4, x1 y5, x1 y6, x1 y7],[x2 y1, x2 y2, x2 y3, x2 y4, x2 y5, x2 y6, x2 y7],[y1 x3, x3 y2, x3 y3, x3 y4, x3 y5, x3 y6, x3 y7],[y1 x4, y2 x4, x4 y3, x4 y4, x4 y5, x4 y6, x4 y7],[y1 x5, y2 x5, y3 x5, x5 y4, x5 y5, x5 y6, x5 y7],[y1 x6, y2 x6, y3 x6, y4 x6, x6 y5, x6 y6, x6 y7],[y1 x7, y2 x7, y3 x7, y4 x7, y5 x7, x7 y6, x7 y7]]

>>

XVI Exercice n◦16

Liste et produit :

XVI.1 Calculer le produit desx1/i pouri variant de -5 à 7 aveci 6= 0

68

Solution

l := [x^(1/i) $i=-5..-1].[x^(1/i) $i=1..7]

-- 1 1 1 1 1 1/2 1/3 1/4 1/5 1/6 1/7 --| ----, ----, ----, ----, -, x, x , x , x , x , x , x || 1/5 1/4 1/3 1/2 x |-- x x x x --

>> _mult(op(l))

13/42x

XVII Exercice n◦17

Listes et ensembles :

XVII.1 Construisez une liste ordonnée des 100 premiers nombres premiers.

XVII.2 Diviser tous les éléments de la liste par 13 et déterminer la partie décimale à l’aide defrac() .

XVII.3 Multiplier tous les éléments par 13 et construisez une nouvelle liste qui sera le résultatordonné de la liste.

XVII.4 Convertissez la liste en un ensemble et donnez le cardinal de l’ensemble.

69

Solution

>> liste := [ithprime(i) $i=1..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, 101, 103, 107, 109, 113, 127, 131, 137, 139,

149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223,

227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293,

307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383,

389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463,

467, 479, 487, 491, 499, 503, 509, 521, 523, 541]>> map(liste, frac@_divide, 13)

[2/13, 3/13, 5/13, 7/13, 11/13, 0, 4/13, 6/13, 10/13, 3/13, 5/13, 11/13,

2/13, 4/13, 8/13, 1/13, 7/13, 9/13, 2/13, 6/13, 8/13, 1/13, 5/13,

11/13, 6/13, 10/13, 12/13, 3/13, 5/13, 9/13, 10/13, 1/13, 7/13, 9/13,

6/13, 8/13, 1/13, 7/13, 11/13, 4/13, 10/13, 12/13, 9/13, 11/13, 2/13,

4/13, 3/13, 2/13, 6/13, 8/13, 12/13, 5/13, 7/13, 4/13, 10/13, 3/13,

9/13, 11/13, 4/13, 8/13, 10/13, 7/13, 8/13, 12/13, 1/13, 5/13, 6/13,

12/13, 9/13, 11/13, 2/13, 8/13, 3/13, 9/13, 2/13, 6/13, 12/13, 7/13,

11/13, 6/13, 3/13, 5/13, 2/13, 4/13, 10/13, 1/13, 7/13, 2/13, 6/13,

8/13, 12/13, 11/13, 6/13, 10/13, 5/13, 9/13, 2/13, 1/13, 3/13, 8/13]>> sort(map(%,_mult,13))

[0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,

3, 3, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6,

6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9,

9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11,

11, 11, 12, 12, 12, 12, 12, 12, 12]>> {op(%)}

{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}>> nops(%)

13

XVIII Exercice n◦18

Listes et ensembles :

XVIII.1 Créer une listeN2 constituée des carrés des nombres entiers compris entre 1000 et 10000,une listeN3 contituée des cubes, une listeN4 constituée des puissances 4ieme et une listeN5

70

constituée des puissances 5ieme.

XVIII.2 Déterminer les élements en commun et leur nombre entre les listes prises deux à deux.

Solution

>> N2 := [i^2 $i = 1000..10000] : N3 := [i^3 $i = 1000..10000]:N4 := [i^4 $i = 1000..10000] : N5 := [i^5 $i = 1000..10000]:

>> //etc>> N3etN4 := {op(N3)} intersect {op(N4)} :

{1000000000000}>> nops(N3etN4)

1>> // etc

XIX Exercice n◦19

Nombres premiers racines d’un polynôme :

XIX.1 Mettre dans un ensemble les valeurs du polynômex2 + x + 41, x ∈ N, et − 21 < x < 21.

XIX.2 Combien y a t-il d’éléments dans l’ensemble ? Pourquoi ?

XIX.3 Sélectionner en utilisant une boucle les éléments de l’ensemble qui sont des nombres pre-miers. Que constatez-vous ?

XIX.4 Ne pouvait-on pas écrire plus simple ?

71

Solution

>> polynome := x^2 + x + 41

2x + x + 41

>> ensemble := {subs(polynome, x = i) $i = -20..20}

{41, 43, 47, 53, 61, 71, 83, 97, 113, 131, 151, 173, 197, 223, 251, 281,313, 347, 383, 421, 461}

>> nops(ensemble)

21

>> premier := {}:for p in ensemble do

if isprime(p)then premier := {p} union premier

end_ifend_for:premier;if premier = ensemble

then print("Ils sont identiques !!")else print("Ils sont différents")

end_if;

{41, 43, 47, 53, 61, 71, 83, 97, 113, 131, 151, 173, 197, 223, 251, 281,313, 347, 383, 421, 461}

"Ils sont identiques !!"

>> if ensemble = select(ensemble, isprime)then print("Ils sont identiques !!")

end_if

"Ils sont identiques !!"

XX Exercice n◦20

Nombres de Fermat :

XX.1 Écrire une procédure qui calcule les premiers nombres de Fermat :

2(2k) + 1, k ∈ N

en s’arrêtant dès que le nombre n’est plus premier.

1 f e r m a t : = proc ( )2 l o c a l k , p remier , n ;3 beg in4 k : = 0 ;5 p rem ie r : = TRUE;6 whi le p rem ie r do7 n : = 2^(2^ k ) + 1 ;8 i f i s p r i m e ( n ) = TRUE

72

9 t hen p r i n t ( n , " e s t p rem ie r " )10 e l s e11 p r i n t ( n , "n ’ e s t pas p rem ie r " , i f a c t o r ( n ) ) ;12 p rem ie r : = FALSE;13 e n d _ i f ;14 k : = k + 1 ;15 end_wh i le;16 r e t u r n ( n ) ;17 end_proc:

XXI Exercice n◦21

Il y a 4000 ans, les Sumériens connaissaient déjà un algorithme qui permettait de calculer√

a à partirdea.

Pourx0 > 0, xn+1 =12(xn +

a

xn) et lim

n→∞xn =

√a

XXI.1 Soitf(x) = x+a/x2 , résoudre l’équationf(x) = x.

XXI.2 Écrire une procédureracineCarree qui prend en entréea etn et calcule√

a.

1 >> f : = x −> ( x + a / x ) / 2 ;2

3 x −> ( x + a / x ) / 24 >> s o l v e ( x= f ( x ) , x )5

6 1 /2 1 /27 p i e c e w i s e ( { } i f a = 0 , {a , − a } i f a <> 0)8

9 r a c i n e C a r r e e : = proc( a , n )10 l o c a l x , i ;11 beg in12 x : = (1 + a ) / 2 ;13 f o r i from 1 t o n do14 x : = ( x + a / x ) / 2 ;15 end_ fo r;16 r e t u r n ( x ) ;17 end_proc:

XXII Exercice n◦22

Calcul deΠ par la méthode de Monte-Carlo.

XXII.1 n gouttes de pluie tombent sur un carré de coté égal à 1 et on compte le nombrer de gouttesqui tombent à l’intérieur du quart de cercle inscrit dans le carré. Alors

r

n' Π

4

En utilisantfrandom() écrire une procédure qui connaissantn approche la valeur deΠ.

1 c a l c u l P i : = proc( n )2 l o c a l r , i , g o u t t e ;3 beg in

73

4 r : = 0 ;5 f o r i from 1 t o n do6 g o u t t e : = [ f random ( ) , f random ( ) ] ;7 i f g o u t t e [ 1 ] ^ 2 + g o u t t e [ 2 ] ^ 2 < 18 t hen r : = r + 1 ;9 e n d _ i f ;

10 end_ fo r;11 r e t u r n ( f l o a t (4∗ r / n ) ) ;12 end_proc:

XXIII Exercice n◦23

Nombres premiers jumeaux

XXIII.1 Deux nombres premiersp et q sont jumeaux siq = p + 2. Écrire une procédure qui déter-mine tous les entiers naturels premiers jumeaux dans un intervalle donné[a, b].

XXIII.2 Que peut-on dire de la répartition des nombres premiers jumeaux ? On s’aidera d’un graphe.

1 jumeaux : = proc( a , b )2 l o c a l i , tw in ;3 beg in4 tw in : = [ ] ;5 f o r i from a t o b do6 i f i s p r i m e ( i ) and i s p r i m e ( i +2)7 t hen tw in : = tw in . [ [ i , i + 2 ] ] ; / / append ( twin , [ i , i +2])8 e n d _ i f ;9 end_ fo r;

10 r e t u r n ( tw in ) ;11 end_proc:12

13 f : = x −> nops ( jumeaux ( 1 , x ) ) ;14 p l o t f u n c 2 d ( f , x=1 . . 1 0 0 0 ) ;

XXIV Exercice n◦24

Fonction de tracé graphique pour étudier les suites récurrentes.

XXIV.1 Écrire une procédureescargot() qui trace les termes de la suite réccurenteun+1 =f(un). La procédure doit avoir comme argument : la fonctionf , le nombre de termes à calculern et le premier terme de la suiteu0.

XXIV.2 Tester votre procédure pour la fonctioncos(x) .

XXIV.3 Tester votre procédure pour la fonctiong : x 7→√

x + 2 etn = 8.

1 e s c a r g o t : = proc( f , u0 , n )2 l o c a l l i s t e , i , u , v , minimum , maximum , i n t e r v a l l e x ;3 beg in4 l i s t e : = [ [ u0 , 0 ] ] ;5 u : = f l o a t ( u0 ) ;6 minimum : = u ;7 maximum : = u ;8 f o r i from 1 t o n do9 v : = f ( u ) ;

74

10 l i s t e : = [ op ( l i s t e ) , [ u , v ] , [ v , v ] ] ;11 u : = v ;12 minimum : = min ( minimum , u ) ;13 maximum : = max ( maximum , u ) ;14 end_ fo r;15 i n t e r v a l l e x : = minimum − 0 .1 ∗ ( maximum− minimum )16 . . maximum + 0 .1 ∗ ( maximum− minimum ) ;17 p l o t ( p l o t : : Func t i on2d ( f ( x ) , x = i n t e r v a l l e x , Co lo r = RGB: : Blue ) ,18 p l o t : : Func t i on2d ( x , x = i n t e r v a l l e x , Co lo r = RGB: : Black ) ,19 p l o t : : Polygon ( op ( l i s t e ) ) , S c a l i n g= C o n s t r a i n e d ) ;20 end_proc:21

22 e s c a r g o t B o r n e : = proc( f , u0 , n , i n t e r v a l l e x )23 l o c a l l i s t e , i , u , v ;24 beg in25 l i s t e : = [ [ u0 , 0 ] ] ;26 u : = f l o a t ( u0 ) ;27 f o r i from 1 t o n do28 v : = f ( u ) ;29 l i s t e : = [ op ( l i s t e ) , [ u , v ] , [ v , v ] ] ;30 u : = v ;31 end_ fo r;32 p l o t ( p l o t : : Func t i on2d ( f ( x ) , x = i n t e r v a l l e x , Co lo r = RGB: : Blue ) ,33 p l o t : : Func t i on2d ( x , x = i n t e r v a l l e x , Co lo r = RGB: : Black ) ,34 p l o t : : Polygon ( op ( l i s t e ) ) , S c a l i n g= C o n s t r a i n e d ) ;35 end_proc:

75

>> escargot(cos, 3, 10)

3210-1

3

2

1

0

-1

x

y

x

y

>> g := x -> sqrt(x + 2)

x -> sqrt(x + 2)>> escargot(g, -1, 8)

21,510,50-0,5-1

2

1,5

1

0,5

0

-0,5

-1

x

y

x

y

76

6 MuPAD emacs LATEX and co

Emacs peut servir d’environnement d’utilisation de MuPAD, en utilisant le copier/coller ou en lisant unfichier.

À SUIVRE ....

génération de code Latex

>> print(Unquoted,generate::TeX(solve( b*x + c = 0, x))

{− c

b

}if b 6= 0

C if b = 0 ∧ c = 0{} if b = 0 ∧ c 6= 0

7 Récréation

Les L-systems, abréviation de Lindenmayer-systems, du nom du biologiste Aristid Lindenmayer ontété créés en 1968 pour étudier la croissance des plantes. Przemyslaw Prusinkiewicz les a étendus à troisdimensions et a développé un système informatique pour visualiser des L-systèmes. Pour cela, il s’est inspirédu langage LOGO créé dans les années 1960 par Seymour Papert, pour apprendre la programmation auxenfants.

Imaginons une tortue (turtle) qui regarde vers le nord ; pour la faire tourner vers la droite, il suffit delui donner l’ordre +, pour la faire tourner vers la gauche, l’ordre -, et l’ordre F pour faire un pas. Ainsi,F+F+F+F permet de tracer un rectangle et F-F+F+F-F permet de tracer la courbe 15.

FIG. 15 – Exemple de L-system

Chaque L-système a une règle d’axiome et de production, qui décrit comment la dessiner. Ainsi le floconde Von Koch peut être décrit de la façon suivante :

Axiome FRégle de productionF → F + F −−F + FAngle 60◦

ChaqueF est donc remplacé par la partie droite de la régle de production. En MuPAD on peut écrire :

77

Flocon de Von Koch

>> for i from 2 to 7 doL := plot::Lsys(60, "F", "F"= "F+F--F+F"):L::generations := i:plot(L, Axes = None);input();

end_for:

Pour permettre des représentations proches des plantes, on introduit deux opérateurs[ et ]. [ permet degarder en mémoire la position de la tortue (empile la position) et de commencer une nouvelle branche qui setermine par] (dépile la position au sommet de la pile). Le tracé reprend reprend alors à partir de la positiondépilée.

78

L-system

>> L := plot::Lsys(22.5, "X", "F"= "FF", "X"="F-[[X]+X]+F[+FX]-X"):L::generations := 7:plot(L, Axes = None)

On l’aura constaté on utiliseplot::Lsys() . Le premier argument correspond à l’angle de développe-ment, le deuxième à l’axiome de départ et les suivants aux règles de production.

79

L-system

>> ornament4 := plot::Lsys(30, "F","F"="AF[---BF++++BF++++BF]AF[+++BF----BF----BF]AF","A"=RGB::Red,"B"=RGB::Blue):

ornament4::generations := 4:plot(ornament4, Axes = None, Scaling=Constrained)

80

L-system

>> ornament5 := plot::Lsys(90, "F","F"="BF[-AF][+AF]BF[+AFF][-AFF]BF[-AF][+AF]BF","A"=RGB::Beige,"B"=RGB::Blue):

ornament5::generations := 4:plot(ornament5, Axes = None, Scaling=Constrained)

81