Cours d'introduction à
Mathematica 3.0

par
Nicolas Martignoni
Collège Sainte-Croix
1700 Fribourg (Suisse)
Version 2.0

© Copyright 1992-1998 Nicolas Martignoni.
Tous droits réservés.

Chapitre deuxième:

Utilisation de Mathematica

Dans ce chapitre, nous allons revoir en détail quelques aspects abordés dans le premier chapitre. Sauf mention explicite du contraire, toutes les opérations que nous allons décrire peuvent être effectuées sur des listes.

2.1. Formatage de l'input et de l'output

2.1.1. Les différentes formes des expressions

Mathematica propose plusieurs façons ou plusieurs formats pour écrire les expressions. Il s'agit des formats appelés Inputform, StandardForm, OutputForm et TraditionalForm.

Inputform

Le format InputForm peut être tapé directement à l'aide des caractères d'un clavier standard. Il sert principalement, comme son nom l'indique, à permettre de saisir un input, notamment dans les front ends de type non graphique. Son écriture est strictement linéaire, c'est-à-dire qu'il n'y a ni indice, ni exposant, ni autres formes 2-dimensionnelles, telles que les fractions. L'expression suivante est en InputForm.

((3 Sin[x]^2 + 2 Sin[x] -4)/(Cos[x]^2 + 2))^(1/2)

StandardForm

Le format InputForm est de plus en plus remplacé par StandardForm, qui autorise des caractères non standard et des notations plus élégantes, en deux dimensions. Voici la même expression que ci-dessus, mais en StandardForm. On remarque que cette forme est parfaitement univoque dans sa signification pour l'ordinateur (voir les crochets pour dénoter les arguments d'une fonction).

OutputForm

Le format OutputForm est un compromis entre les deux formats ci-dessus. Il affiche une représentation bidimensionnelle de l'expression, mais se restreint aux caractères d'un clavier standard. Voici l'expression déjà rencontrée plus haut, en InputForm.

         2
 3 Sin[x]  + 2 Sin[x] - 4 1/2
(------------------------)
             2
       Cos[x]  + 2

TraditionalForm

Le format TraditionalForm est un format qui tente d'approcher au mieux, à l'aide de routines heuristiques, la notation mathématique traditionnelle. On remarquera que cette notation peut être ambiguë, comme ci-dessus. Il est impossible de prévoir si un input en TraditionalForm sera compris de la façon désirée par l'utilisateur. L'expression ci-dessous est toujours la même, mais cette-fois en TraditionalForm. Remarquez les parenthèses pour délimiter les arguments des fonctions, ainsi que les initiales des noms de fonctions en minuscules.

Si vous tentez d'évaluer une expression en TraditionalForm, Mathematica vous avertit que le resultat peut être erroné. En général, l'interprétation est cependant correcte. L'exemple ci-dessous montre une expression équivoque, interprétée comme une fonction, alors que l'intention était peut-être de représenter une multiplication.

a[b + c]

Le format utilisé normalement est StandardForm, puisqu'il présente le double avantage d'être élégant et complètement univoque.

La commande Convert To... du menu Cell permet de convertir une cellule d'un format à un autre. Les différents formats des cellules sont indiqués par une marque de cellule différente (voir les exemples ci-dessus).

Pour voir comment Mathematica traite réellement une expression, il suffit d'exécuter la commande

Power[Times[Power[Plus[2, Power[Cos[x], 2]], -1], 
  Plus[-4, Times[2, Sin[x]], Times[3, Power[Sin[x], 2]]]],
 Rational[1, 2]]

Le kernel ne connaît en fait que des expressions sous cette forme. Nous n'utiliserons bien sûr que très rarement ce type d'expression.

2.1.2. Saisir des formules sous forme bidimensionnelle

Saisie à l'aide des palettes

Il y a plusieurs manières d'introduire des formules ou des structures sous forme bidimensionnelle. La plus simple et la plus rapide utilise les palettes. Il existe des palettes standard, que l'on peut ouvrir avec la commande Palettes du menu File. On peut aussi mettre en place un hyperlien pour ouvrir une palette prédéfinie.

Une fois la palette ouverte, il suffit de placer le pointeur où l'on veut écrire la formule, puis de cliquer sur le bouton approprié de la palette. La forme choisie apparaît, par exemple une fraction, avec au numérateur et au dénominateur des cases vides que l'on peut remplir à son aise. On passe d'une case à l'autre avec la touche de tabulation et on revient à une case précédente avec

Raccourcis-clavier

La deuxième façon de saisir des formes particulières utilise des raccourcis-clavier. Je ne ferai pas ici une liste exhaustive de ces raccourcis. Une telle liste est disponible dans l'aide, en cherchant dans l'index «Formulas, entering with keyboard». Voici toutefois les principaux de ces raccourcis, sous la forme d'exemples.

La combinaison de touches (contrôle-espace) permet de sortir de la structure bidimensionnelle, afin de continuer la saisie de la suite de l'expression mathématique.

On remarque que le raccourci pour l'exposant avec un indice est différente de celle avec un exposant seul. En effet, si l'on saisit x_2^3, comme on en a envie, on obtient . Le raccourci 5 permet en fait de passer de l'indice à l'exposant ou vice-versa, ou encore du radical à l'exposant d'une n-ième racine, ou vice-versa.

Les vecteurs et les matrices peuvent aussi être saisis manuellement. Pour cela, on choisira la commande Create Table/Matrix/Palette (C, C) du menu Input. Il suffit de choisir alors le nombre de lignes (rows) et de colonnes (columns) désirés et de cliquer le bouton Ok. Cette manipulation affiche à l'endroit du pointeur la matrice avec une case vide à chaque position. Il suffit ici encore de remplir les cases en se déplaçant entre chacune d'elles avec ou .

On peut aussi introduire directement les vecteurs et matrices au clavier, avec les raccourcis suivants. Ces raccourcis permettent également de modifier un vecteur ou une matrice existante.

Pour supprimer une ligne ou une colonne, on utilise la touche d'effacement habituelle.

Ici encore, pour sortir de la structure bidimensionnelle, il suffit de taper la combinaison de touches .

Exportation de formules

On peut facilement exporter dans d'autres programmes les formules fabriquées par Mathematica. La meilleure façon de procéder est d'utiliser la commande Copy As du menu Edit.

Si l'on veut un bon résultat lors de l'impression, il faut choisir le format PICT with Embedded PostScript. Il ne reste plus qu'à coller la formule dans le document désiré.

Exercice 10 [voir la solution]

Saisissez l'expression ci-dessous à l'aide d'une palette, puis au moyen des raccourcis-clavier, dans le format StandardForm.

N'oubliez pas la combinaison pour sortir d'une structure.

Exercice 11 [voir la solution]

Saisissez la matrice suivante avec les trois possibilités que nous connaissons, à savoir la commande Create Table/Matrix/Palette, une palette et le clavier .

2.1.3. Lettres grecques et autres symboles

Mathematica offre aussi de nombreux symboles particuliers (plus de 700) afin de présenter des textes mathématiques. En premier lieu, divers alphabets complets sont disponibles, à savoir le grec (, , , ...), l'anglaise (, , ,...), le gothique (, , , ...) et le «double-struck» ou «blackboard» (, , , ..., , , ,...).

Sont également disponibles des symboles techniques, des icônes, des flèches , ainsi qu'un grand nombre d'opérateurs mathématiques. La palette CompleteCharacters en contient une liste exhaustive.

Ceux qui existent tels quels sur les claviers standards, comme , , ou , sont interprétés directement.

On peut saisir tous les caractères spéciaux à l'aide du clavier. En fait, ils possèdent tous un nom Mathematica bien déterminé et plusieurs alias destinés à en faciliter la saisie. Ainsi le caractère porte le nom impossible \[DoubleLongLeftRightArrow]. Pour saisir ce caractère, il suffit cependant de taper <==> (le caractère désigne la touche ).

Les personnes connaissant le langage TeX ou HTML peuvent utiliser les mêmes commandes, entourées par des touches . Par exemple, \delta devient et &infin devient . Le tableau suivant montre encore quelques exemples:

Des informations exhaustives concernant la saisie de caractères spéciaux sont données aux sections 1.10.1 et 3.10 du Mathematica Book.

Nous verrons plus loin que certains symboles ont une signification mathématique pour Mathematica, comme , ° ou encore , alors que d'autres n'ont pas de signification et peuvent être utilisés par l'utilisateur pour ses propres constructions.

Exercice 12 [voir la solution]

Saisissez l'expression ci-dessous au moyen des raccourcis-clavier, en StandardForm.

2.2. Variables, précision des nombres

2.2.1. Utilisation de résultats déjà obtenus, variables

Il est souvent nécessaire d'effectuer des calculs en plusieurs étapes. On a alors besoin de se référer à des résultats déjà obtenus lors de la session. L'on dispose pour cela des notations %, %%, %%%, etc. et %n, comme on l'a déjà vu dans le premier chapitre.

Cependant, une meilleure façon de procéder est de définir des variables. Pour cela, on utilise le signe =, qui signifie que l'on assigne une valeur à la variable, comme dans les mathématiques standard.

x = 5

5

x2

25

Dans de nombreux langages de programmation, par exemple en Pascal, l'assignation se dénote par le signe :=. Il faut absolument éviter de confondre ces deux notations. En Mathematica, cette dernière écriture a une autre signification, que nous verrons plus loin.

Mathematica permet les assignations multiples, à l'aide des listes. La commande suivante assigne la valeur 2 à x et la valeur 4 à y:

{x, y} = {2, 4}

{2, 4}

Il faut faire attention à plusieurs choses lorsque l'on définit des variables: la première est que Mathematica considère que dès l'instruction x = 5, je veux que x prenne toujours la valeur 5, à moins que je ne spécifie explicitement le contraire. Il s'agit donc d'une variable globale.

Une des sources d'erreur les plus communes est d'oublier que l'on a fait une telle définition. La meilleure stratégie pour éviter cette erreur est donc de retirer l'assignation à une variable dès que l'on ne l'utilise plus, ce que l'on fait de la façon suivante:

x = .

y = .

{x, y}

{x, y}

On peut également utiliser la syntaxe Clear[a, b, ...], pratique si l'on veut désassigner plusieurs variables à la fois.

{x, y} = {2, 4}

{2, 4}

Clear[x, y]

{x, y}

{x, y}

D'autres points délicats sont à considérer au niveau de la dénomination des variables:

• xy signifie x fois y;
• xy signifie la variable de nom xy;
• x2 signifie la variable de nom x2;
• 2x signifie 2 fois x, tout comme 2x;
• x^2y signifie (x^2) y, et non x^(2y). Mieux vaut utiliser ici x²y ou x^{2 y}.

Exercice 13 [voir la solution]

Assignez à la variable la liste constituée des 10 premiers nombres de Fibonacci. Mettez au cube chacun des nombres de cette liste en une seule opération.
Indication: utilisez la fonction prédéfinie de Mathematica pour calculer les nombres de la suite.

2.2.2 Précision numérique des nombres

Les résultats donnés par Mathematica ont toujours une précision plus petite ou égale à celle des arguments donnés par l'utilisateur. Si tous les arguments de l'opération sont entiers ou rationnels (précision infinie), le résultat sera de précision infinie. Ce sera un autre nombre entier ou rationnel, ou encore un nombre réel (éventuellement imaginaire) non évalué, comme 3^(1/2), , ou encore Log[2]. La fonction Precision donne le nombre de chiffres significatifs d'un nombre

Si au contraire l'un des arguments au moins est donné sous une forme approximative, comme N[, 25] ou 1.7320508, le résultat aura une précision finie, plus petite ou égale à celle du nombre le moins précis donné comme argument. La précision minimale de tout nombre est donnée par la constante $MachinePrecision.

Precision[N[, 25]]

25

Precision[(N[, 25] + 1.7320508) Log[2]]

16

La précision vaut 16, car le nombre 1.7320508 possède la précision minimale.

$MachinePrecision

16

Il ne faut pas oublier qu'un nombre entier suivi du point décimal a une précision finie, à savoir 16.

{Precision[1.], Precision[1]}

{16, }

Il peut être parfois nécessaire de passer d'un nombre de précision finie à un nombre entier ou rationnel exact. Diverses possibilités se présentent. En premier lieu la fonction Round calcule l'entier le plus proche d'un nombre donné.

{Round[2.3], Round[-2.3], Round[]}

{2, -2, 3}

Les commandes apparentées Floor[x] et Ceiling[x] donnent respectivement le plus grand entier inférieur ou égal à x, et le plus petit entier supérieur ou égal à x.

{Floor[2.3], Floor[-2.3], Floor[]}

{2, -3, 3}

{Ceiling[2.3], Ceiling[-2.3], Ceiling[]}

{3, -2, 4}

La fonction Rationalize convertit les nombres réels suffisamment proches d'un nombre rationnel en nombres rationnels exacts. Il est possible de donner comme deuxième argument l'erreur maximale permise lors de la conversion. Si le nombre donné n'est pas assez proche, Mathematica ne le modifie pas.

{Rationalize[Log[2]], Rationalize[Log[2], 10-5]}

         253
{Log[2], ---}
         365

Enfin la fonction Chop permet de transformer les nombres approximatifs proches de zéro en la valeur exacte zéro. Le deuxième argument (optionnel) spécifie ici encore l'erreur maximale permise lors de la conversion.

Exp[N[ I]]

-1. + 0. I

Chop[%]

-1.

N[3] - 31

0.00627668

Chop[%, 10-2]

0

Exercice 14 [voir la solution]

Comment peut-on retrouver l'approximation = 22/7? Donnez une meilleure approximation rationnelle de .

2.3. Calcul numérique

Nous ne reviendrons pas sur l'opération puissance et les quatre opérations élémentaires. Il ne faut cependant pas oublier les règles de priorité des opérations, c'est-à-dire de placer suffisamment de parenthèses pour lever toute ambiguïté lors d'une évaluation.

3 + 5/7

26
--
7

(3 + 5)/7

8
-
7

Ces deux inputs peuvent bien sûr être écrites en 2 dimensions, ce qui résout partiellement le problème.

 26  8
{--, -}
 7   7

2.3.1. Fonctions et constantes mathématiques classiques

Mathematica contient toutes les fonctions mathématiques classiques, telles que les racines, l'exponentielle, les logarithmes et toutes les fonctions trigonométriques.

Il est à remarquer que les noms des objets Mathematica sont clairs: ce sont exactement les noms admis par la communauté mathématique internationale. Ainsi, le logarithme naturel s'écrit Log, la fonction exponentielle Exp et les fonctions trigonométriques Sin, Cos et Tan. De même, la valeur absolue s'appelle Abs, et la factorielle s'écrit ! (point d'exclamation).

Les noms Mathematica des objets n'ayant pas de dénomination standard dans la communauté scientifique sont parfois longs. Cependant ils reflètent exactement leur fonction. Cette convention a l'avantage de ne pas encombrer la mémoire de l'utilisateur avec des abréviations. En effet, il n'est pas difficile de deviner que la matrice identité se nomme IdentityMatrix, par exemple.

Exercice 15 [voir la solution]

Effectuez les opérations suivantes: racine cubique de 2197, 10 factorielle, logarithme naturel de 10 (approximation), logarithme décimal de 1025 (approximation), exponentielle de 5 (approximation), sinus, cosinus et tangente de /3 et de 3/4 radians.
Essayez dans la mesure du possible d'utiliser la notation bidimensionnelle.
N'oubliez pas que les arguments d'une fonction se placent entre crochets. Attention aux conventions de Mathematica (majuscules, etc.)!

Les constantes Mathematica suivent la règle des majuscules, comme on l'a déjà dit. On note ainsi Pi, I, E les constantes , i (unité imaginaire) et e (base du logarithme népérien). Ces constantes sont également représentées par des caractères spéciaux: la lettre grecque , le symbole , saisi ii, pour l'unité imaginaire, et le symbole , saisi ee, pour la base du logarithme. Mathematica connaît bien sûr d'autres constantes mathématiques, entre autres Degree, qui vaut /180 et s'écrit °, Infinity, qui se note (inf) et GoldenRatio, qui comme son nom l'indique représente la section d'or.

Exercice 16 [voir la solution]

Calculez en arithmétique exacte les sinus, cosinus et tangente des angles de 30° et 45°.

2.3.2. Nombres complexes

Il est facile d'introduire les nombres complexes à l'aide de la constante . Ainsi un nombre complexe de partie réelle x et de partie imaginaire y s'écrit x + y.

2 I

En suivant la convention décrite ci-dessus, on pourra deviner quelles sont les fonctions Mathematica pour les parties réelle et imaginaire, le complexe conjugué, la valeur absolue et l'argument d'un nombre complexe.

Re[EI /3]

1
-
2

Im[EI /3]

Sqrt[3]
-------
   2

Conjugate[EI /3]

E-I /3

Arg[EI /3]

-
3

Exercice 17 [voir la solution]

Calculez le produit de 2 + 4 et 5 - 3. Calculez ensuite le quotient de ces deux nombres complexes, puis l'argument de ce quotient et son complexe conjugué.

2.3.3. Nombres aléatoires

La génération des nombres aléatoires se fait à l'aide de la commande Random. Le premier paramètre de cette commande indique le type de nombre voulu, c'est-à-dire Integer, Real ou Complex; le deuxième paramètre désigne l'intervalle dans lequel doit être choisi le nombre aléatoire. Les deux paramètres sont optionnels. Leur valeur par défaut est Real, respectivement {0, 1}.

Voici quelques exemples d'utilisation de la fonction Random. Le premier donne un nombre réel entre 0 et 1, le deuxième un nombre entier entre 0 et 1 (un bit), le troisième un complexe compris dans le rectangle défini par 0 et 2+ et le dernier un entier entre 1 et 6, comme le résultat d'un jet de dé.

{Random[], Random[Integer], Random[Complex, 2 + I],
   Random[Integer, {1, 6}]}

{0.741412, 1, 0.232878 + 0.588784 I, 5}

On s'aperçoit, en évaluant à plusieurs reprises la ligne ci-dessus, que le résultat change à chaque fois. Si l'on veut obtenir un comportement répétitif à des fins de test, par exemple, il est possible d'initialiser le générateur de nombres aléatoires avec la commande SeedRandom. On obtiendra alors après initialisation une suite identique de nombres aléatoires.

SeedRandom[314152];
Table[Random[Integer], {16}]

{1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1}

Table[Random[Integer], {16}]

{0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0}

SeedRandom[314152];
Table[Random[Integer], {16}]

{1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1}

Exercice 18 [voir la solution]

Construisez une liste de 5 points situés dans le cube dont les coordonnées extrêmes sont {0, 0, 0} et {10, 10, 10}.

2.3.4. Vecteurs et matrices

Les vecteurs et les matrices ne sont rien d'autre que des tableaux de nombres. Mathematica utilise les listes pour rendre ce genre de structures. Une matrice 3×2 sera ainsi une liste de 3 listes, chacune comprenant 2 éléments:

m = {{1, 2}, {3, 4}, {5, 6}}

{{1, 2}, {3, 4}, {5, 6}}

Les vecteurs peuvent être interprétés comme des matrices, par exemple 3×1 pour un vecteur-colonne, ou 1×3 pour un vecteur-ligne.

{{1}, {2}, {3}}

{{1, 2, 3}}

Pour présenter les matrices de façon plus claire, on utilisera la commande MatrixForm.

MatrixForm[m]

Les doubles crochets sont utilisés pour extraire un élément d'une matrice. Voici l'élément (3,1) de la matrice m:

m3, 1

5

On remarque au passage que les doubles crochets s'écrivent aussi par des caractères spéciaux, à savoir et , que l'on saisit respectivement par [[ et ]].

Il est bien sûr possible d'extraire une sous-matrice de m:

m[[{2, 3}, {1, 2}]]

{{3, 4}, {5, 6}}

Le produit de matrices s'écrit simplement avec un point. Les autres opérations élémentaires s'écrivent de façon ordinaire.

n = {{4, 3}, {2, 1}};

m . n

{{8, 5}, {20, 13}, {32, 21}}

{{1, 2, 3}, {2, 4, 6}, {3, 6, 9}}

{{14}}

Lorsqu'il n'y a pas besoin de distinguer vecteur-ligne et vecteur-colonne, il est judicieux de représenter un vecteur comme une simple liste de nombres.

u = {a, b, c};
v = {d, e, f};

Le produit scalaire de deux vecteurs sous cette forme s'écrit alors avec un simple point.

u . v

a d + b e + c f

Le produit vectoriel de deux vecteurs tridimensionnels est calculé par la fontion Cross, équivalente à la notation , saisie cross. Il ne faut pas confondre (*), qui est un signe de multiplication, et (cross).

{-c e + b f, c d - a f, -b d + a e}

Clear[u, v]

Toutes les fonctions mathématiques sur les matrices sont disponibles: la transposition, l'inverse, le déterminant, la puissance et l'exponentielle d'une matrice s'obtiennent par les commandes Transpose, Inverse, Det, MatrixPower et MatrixExp. Les quatre dernières ne fonctionnent évidemment que sur des matrices carrées.

Transpose[m] // MatrixForm

MatrixForm[m = Table[1/(i + j), {i, 3}, {j, 3}]]

Inverse[m]

{{72, -240, 180}, {-240, 900, -720}, {180, -720, 600}}

Det[m]

  1
-----
43200

MatrixPower[m, 3]

  533   2839   983     2839   2689   291     983   291   2449
{{----, -----, ----}, {-----, -----, ----}, {----, ----, -----}}
  1440  10800  4800    10800  14400  2000    4800  2000  21600

Clear[m, n]

Exercice 19 [voir la solution]

Vérifiez que le produit vectoriel w de deux vecteurs tridimensionnels quelconques u et v est normal aux deux vecteurs u et v.

Exercice 20 [voir la solution]

Calculez le polynôme caractéristique et les valeurs propres de la matrice m ci-dessous, en utilisant la définition mathématique standard.

2.4. Calcul symbolique

2.4.1. Principe de base

Le calcul d'une expression symbolique n'est en fait que la transformation de l'expression sous une forme différente de celle qu'elle a initialement. Le principe de base de Mathematica est exactement cela: pour toutes les évaluations, il utilise ce que l'on appelle le principe du point fixe:

appliquer un certain nombre de règles de transformation
à l'expression évaluée jusqu'à ce que plus rien ne change.

Par exemple, lorsque l'on fait évaluer l'expression y + x - 2 y, la première règle que Mathematica applique est y - 2 y = -y, ce qui donne l'expression -y + x. Ensuite, il utilise l'ordre standard (ici l'ordre alphabétique) pour arranger les éléments et retourne x - y, puisqu'à ce point, plus rien ne change.

2.4.2. Remplacements

Nous avons vu plus haut la méthode pour définir des variables. Une assignation x = 3 indique à Mathematica de remplacer x par 3 partout où x apparaît. On a souvent besoin de faire des remplacements de ce type de façon plus contrôlée, par exemple sur une seule expression.

On obtient exactement ce comportement en tapant /. x -> 3 après l'expression à évaluer. Le signe /. est formé d'une barre oblique et d'un point (sans espace). La flèche -> s'obtient en tapant au clavier un signe moins et un «plus grand que». Elle peut être remplacée par le caractère spécial , que l'on obtient par ->. L'expression x -> 3 est appelée une règle (rule). Elle indique au programme de remplacer x par 3 dans l'expression qui la précède. Voici un autre exemple, où l'on remplace y par 1 + a.

1 + y2 /. y -> 1 + a

1 + (1 + a)2

L'avantage de cette méthode est que la variable y n'a pas reçu de valeur globale:

y

y

Lorsqu'une expression algébrique contient plusieurs variables, on peut faire des remplacements multiples à l'aide d'une liste de règles:

(x + y) (x - y)2 /. {x -> 2, y -> a - 1}

(3 - a)2 (1 + a)

On peut aussi mélanger les assignations et les remplacements.

t = 1 + x2

1 + x2

t /. x -> 2 a

1 + 4 a2

t

1 + x2

N'oublions pas de retirer la valeur de cette variable:

t = .

2.4.3. Expressions algébriques

Le principe du point fixe que nous venons de décrire s'applique tout particulièrement aux expressions algébriques. Toutefois, si l'on donne comme input une expression algébrique quelconque, elle ne sera pas immédiatement transformée, par exemple sous la forme factorisée. La raison en est que Mathematica ne peut pas deviner sous quelle forme l'utilisateur désire obtenir l'expression.

Polynômes, fractions, expression irrationnelles

Pour factoriser un polynôme, il faudra donc le spécifier explicitement à l'aide de la fonction Factor. De façon analogue, on utilisera Expand pour développer un produit de facteurs.

Expand[(x + 1)8]

1 + 8 x + 28 x2 + 56 x3 + 70 x4 + 56 x5 + 28 x6 + 8 x7 + x8

Factor[%]

(1 + x)8

La factorisation a lieu sur le corps des rationnels. Pour cette raison, l'expression suivante n'est pas automatiquement factorisée par Mathematica.

Factor[x2 - 3]

-3 + x2

Il y a deux façons de résoudre ce problème. La première consiste à factoriser sur le corps des réels, en écrivant par exemple:

Factor[x2 - 3.]

1. (-1.73205 + x) (1.73205 + x)

La deuxième solution met en jeu les extensions algébriques du corps des fractions. Il s'agit ici d'ajouter à la commande Factor une option Extension, où l'on indique les nombres algébriques susceptibles de faire partie de la factorisation.

Voici un autre exemple intéressant, qui montre la factorisation d'un polynôme strictement positif.

Bien entendu, les autres fonctions utilisant la factorisation sont aussi affectées par cette propriété, notamment Cancel.

On voit sur cet exemple que si l'extension est mise à Automatic, cela signifie que les coefficients sont ajoutés à l'extension automatiquement.

Exercice 21 [voir la solution]

Effectuez la multiplication (x - 2) (x - 1) x (x + 1) (x + 2).
Factorisez le polynôme x⁴ + 35 x² - 50 x - 10 x³ + 24.

Les opérations décrites ci-dessus ne sont pas les seules disponibles pour la manipulation des expressions algébriques. On dispose encore de fonctions telles que: Together qui met une expression au même dénominateur, Cancel qui utilise l'algorithme d'Euclide pour éliminer les facteurs communs du dénominateur et du numérateur (ce que l'on appelle en français la simplification), Apart qui décompose une expression en somme de fractions partielles et Collect qui permet de rassembler les facteurs contenant une même expression (mise en évidence). Dans ce dernier cas, le deuxième argument indiquera quelle(s) variable(s) mettre en évidence.

La fonction Simplify essaie de chercher la forme la plus simple possible d'une expression en appliquant une série de transformations algébriques.

Expand[e]

        2                  3 x                 x3
----------------- - ----------------- + -----------------
(-3 + x)2 (1 + x)   (-3 + x)2 (1 + x)   (-3 + x)2 (1 + x)

Together[%]

  2 - 3 x + x3
-----------------
(-3 + x)2 (1 + x)

Apart[%]

        5           19           1
1 + --------- + ---------- + ---------
    (-3 + x)2   4 (-3 + x)   4 (1 + x)

Simplify[%]

  2 - 3 x + x3
-----------------
(-3 + x)2 (1 + x)

FullSimplify[%]

  2 - 3 x + x3
-----------------
(-3 + x)2 (1 + x)

1 + x
-----
2 + x

Collect[x + 3 x2 + n x + m + k x2, {x, x2}]

m + (1 + n) x + (3 + k) x2

La fonction FullSimplify utilise un ensemble de transformations plus étendu pour effectuer le même travail que Simplify. Elle donne de meilleurs résultats dès que l'expression contient des racines ou des fonctions spéciales. Le travail de FullSimplify peut être long! L'exemple suivant montre un cas où Simplify ne suffit pas.

f = Sqrt[5 + 2 Sqrt[6]];

Simplify[f]

Sqrt[5 + 2 Sqrt[6]]

FullSimplify[f]

Sqrt[2] + Sqrt[3]

Clear[e, f]

D'autres opérations peuvent être effectuées, notamment la division euclidienne des polynômes. Il est bien sûr nécessaire d'indiquer alors l'indéterminée comme troisième argument. Le résultat est une liste comprenant le quotient et le reste.

PolynomialDivision[x3 - 1, x - 1, x]

{1 + x + x2, 0}

Exercice 22 [voir la solution]

Effectuez le quotient .
Mettez l'expression au même dénominateur.
Simplifiez au maximum les expressions et .

Expressions trigonométriques

Le cas des expressions trigonométriques est particulier. En effet

Expand[Sin[x]2 + Cos[x]2]

Cos[x]2 + Sin[x]2

ne livre aucune réponse, car Mathematica traite les fonctions trigonométriques comme des objets indivisibles. Pour obtenir un résultat, il faut utiliser la fonction TrigExpand.

TrigExpand[Sin[x]2 + Cos[x]2]

1

Cette fonction décompose les sommes et multiples entiers apparaissant en argument des fonctions trigonométriques, et développe ensuite les produits de fonctions trigonométriques en sommes de puissances.

TrigExpand[Cos[ + ]]

Cos[] Cos[] - Sin[] Sin[]

TrigExpand[Cos[2 x]]

Cos[x]2 - Sin[x]2

Le pendant de TrigExpand est TrigFactor. Après avoir décomposé les sommes et multiples entiers apparaissant en argument des fonctions trigonométriques, cette dernière fonction factorise si possible les polynômes résultants.

tr = TrigExpand[Cos[4 x]]

Cos[x]4 - 6 Cos[x]2 Sin[x]2 + Sin[x]4

TrigFactor[tr]

(Cos[2 x] - Sin[2 x]) (Cos[2 x] + Sin[2 x])

Parfois, on a besoin d'une forme plus réduite. La fonction TrigReduce doit être utilisée dans ce cas. Elle transforme les produits et puissances des fonctions trigonométriques en d'autres fonctions trigonométriques aux arguments combinés.

TrigReduce[tr]

Cos[4 x]

TrigReduce[Cos[x]2 - Sin[x]2]

Cos[2 x]

tr = .

Exercice 23 [voir la solution]

Calculez (cos(x) + I sin(x))² et exprimez le résultat en terme de sinus et de cosinus de multiples entiers de x. Déduisez-en les égalités sin (2 x) = 2 cos x sin x et cos (2 x) = cos² x - sin² x.

Lorsqu'il est nécessaire de transformer les fonctions trigonométriques en combinaisons d'exponentielles ou le contraire, on utilisera les commandes TrigToExp et ExpToTrig.

TrigToExp[Sin[x]]

1
- I (E-I x - EI x)
2

ExpToTrig[1/2 (-E-z + Ez]

Sinh[z]

2.5. Analyse mathématique

2.5.1. Équations

Les équations mathématiques peuvent être traitées de plusieurs manières. En effet il existe parfois une ou des solutions calculables explicitement (équations polynomiales de degré inférieur à 5), d'autres fois non (autres équations polynomiales, équations transcendantes, etc.). En outre, il convient parfois d'obtenir les solutions sous forme exacte, d'autres fois sous forme approximative. Nous allons voir comment traiter ces différents cas à l'aide de Mathematica.

Mais voyons d'abord comment l'on représente les équations. Le symbole d'égalité s'écrit à l'aide d'un signe égal répété ==. Ce signe indique que l'on veut tester si l'égalité est vraie ou fausse. Le double-égal peut aussi être écrit ==, ce qui donne le caractère plus élégant .

2 + 2 == 4

True

La notation 2 + 2 = 4 est incorrecte et provoquera un message d'erreur. En effet, le signe égal simple signifie une assignation, comme on l'a vu plus haut. On sera donc particulièrement attentif à ne pas confondre ces deux notations aux significations différentes.

Solutions exactes et approximations numériques

La résolution d'équations polynomiales s'effectue avec la commande Solve. Cette commande calcule chaque fois que cela est possible un résultat exact. À noter dans l'exemple ci-dessous l'utilisation du double égal, ainsi que la spécification de la variable par rapport à laquelle on résout l'équation.

Solve[2 x + 3 == 4, x]

       1
{{x -> -}}
       2

S'il n'y a pas d'ambiguïté possible pour la variable, il est possible de l'omettre.

Solve[2 x + 3 == 4]

       1
{{x -> -}}
       2

La fonction Solve peut résoudre des équations polynomiales à coefficients littéraux. La spécification de la variable inconnue est ici primordiale.

Solve[s2 + 2 b s + 1 == 0, s]

{{s -> -b - Sqrt[-1 + b2]}, {s -> -b + Sqrt[-1 + b2]}}

Solve[s2 + 2 b s + 1 == 0, b]

        1 + s
{{b2-> -------}}
         2 s

Lorsqu'il n'existe pas de formule fermée pour le calcul des solutions, par exemple pour des polynômes de degré supérieur à 4, Mathematica donne une forme spéciale, comprenant parfois une ou plusieurs solutions exactes (voir ci-dessous). Cette forme signifie que Mathematica connaît les autres solutions, mais que celles-ci ne peuvent pas être représentées exactement.

Solve[x6 + 5 x5 + 2 x2 + 9 x == 5]

{{x -> -5}, {x -> Root[-1 + 2 #1 + #15 &, 1]},
  {x -> Root[-1 + 2 #1 + #15 &, 2]},
  {x -> Root[-1 + 2 #1 + #15 &, 3]},
  {x -> Root[-1 + 2 #1 + #15 &, 4]},
  {x -> Root[-1 + 2 #1 + #15 &, 5]}}

Dans ce cas, il est possible d'obtenir une approximation de toutes les racines à l'aide de la fonction N:

N[Solve[x6 + 5 x5 + 2 x2 + 9 x == 5]]

{{x -> -5.}, {x -> 0.486389},
  {x -> -0.945068 - 0.854518 I}, {x -> -0.945068 + 0.854518 I},
  {x -> 0.701874  - 0.8796978 I}, {x -> 0.701874  + 0.8796978 I}}

Cependant cette méthode n'est pas optimale. Pour obtenir directement des approximations numériques des racines, il existe la fonction NSolve, qui donne exactement le même résultat que la combinaison de Solve et N, et cela de façon plus efficiente.

NSolve[x6 + 5 x5 + 2 x2 + 9 x == 5]

{{x -> -5.}, {x -> -0.945068 - 0.854518 I}, 
  {x -> -0.945068 + 0.854518 I}, {x -> 0.486389},
  {x -> 0.701874 - 0.879697 I}, {x -> 0.701874 + 0.879697 I}}

Les équations irrationnelles peuvent être résolues à l'aide de Solve. Dans ce cas, les solutions parasites sont automatiquement éliminées.

Solve[x2 - 3 == Sqrt[5 - x2]]

{{x -> -2}, {x -> 2}}

Solve[1/x + 1/Sqrt[x] == 1]

       1
{{x -> - (3 + Sqrt[5])}}
       2

Pour obtenir tous les candidats de solution, avant vérification, on demandera

Solve[x2 - 3 == Sqrt[5 - x2], VerifySolutions -> False]

{{x -> -2}, {x -> -1}, {x -> 1}, {x -> 2}}

Solve[1/x + 1/Sqrt[x] == 1, VerifySolutions -> False]

       1                  1
{{x -> - (3 - Sqrt[5])}, {x -> - (3 + Sqrt[5])}}
       2                       2

Les fonctions Solve et NSolve permettent aussi de résoudre certaines équations comprenant des fonctions transcendantes.

Solve[Log[Sqrt[x]] == Sqrt[Log[x]], x]

{{x -> 1}, {x -> E4}}

Lorsque des fonctions réciproques sont utilisées pour la résolution, un message d'avertissement apparaît. Mathematica indique par ce biais que toutes les solutions n'ont peut-être pas été trouvées.

Solve[Sin[x] == 1/2, x]

Solve :: ifun :  Inverse functions are being used by Solve, so
  some solutions may not be found.

       {{x -> -}}
       6

Le nombre des équations transcendantes que Solve permet de résoudre est faible. Dans la plupart des cas, il faudra utiliser une méthode numérique pour résoudre l'équation.

Solve[Sin[x] == x, x]

Solve :: tdep :  The equations appear to involve transcendental
  functions of the variables in an essentially non-algebraic way.

Solve[Sin[x] == x, x]

Méthodes numériques de résolution des équations

La fonction FindRoot permet, comme son nom l'indique, de trouver la ou les racines d'une équation quelconque, à l'aide de méthodes numériques. Sa syntaxe est identique à celle de Solve. Il faudra spécifier avec la variable inconnue une valeur initiale de calcul, à l'aide d'une liste.

FindRoot[Sin[x] == x2, {x, 1}]

{x -> 0.876726}

L'output de FindRoot est toujours la première solution qu'il trouve, même s'il existe plusieurs solutions. La valeur initiale de calcul doit donc être bien choisie. La méthode utilisée dans ce cas par FindRoot est ici la méthode de Newton. Si une dérivée apparaissant lors de l'application de l'algorithme est nulle, un message d'erreur apparaît.

FindRoot[x2 - 1 == 0, {x, 0}]

FindRoot :: jsing :  Encountered a singular Jacobian at the
  point x = 0.`. Try perturbing the initial point(s).

FindRoot[x2 - 1 == 0, {x, 0}]

Il faut alors choisir un autre point initial.

FindRoot[x2 - 1 == 0, {x, .1}]

{x -> 1.}

Il est parfois nécessaire d'utiliser un autre algorithme. On spécifie dans ce cas deux valeurs initiales pour l'inconnue. La méthode de la sécante sera utilisée pour calculer la solution.

FindRoot[Sin[x] == x2, {x, {1/2, 1}}]

{x -> 0.876726}

Systèmes d'équations

L'utilisateur avec un peu d'expérience devinera certainement comment résoudre les systèmes d'équations. Il s'agit simplement d'indiquer l'ensemble des équations à résoudre et celui des variables par des listes. Cela marche aussi bien avec Solve qu'avec NSolve ou FindRoot. Dans ce dernier cas, il faut spécifier pour chaque inconnue une ou deux valeurs initiales.

Solve[{33 x + 2 y - 2 == 0, 7 x + 5 y + 4 == 0}, {x, y}]

       18          146
{{x -> ---, y -> - ---}}
       151         151

NSolve[{33 x + 2 y - 2 == 0, 7 x + 5 y + 4 == 0}, {x, y}]

{{x -> 0.119205, y -> -0.966887}}

FindRoot[{x2 + y2 == 1, y == x Exp[x]}, {x, 0}, {y, 1}]

{x -> 0.513489, y -> 0.858096}

FindRoot[{x2 + y2 == 1, y == x Exp[x]}, {x, {0, 1}}, {y, {2, 3}}]

{x -> 0.513489, y -> 0.858096}

FindRoot[{Cos[x y] == x2, Sin[x y] == y2}, {x, 1}, {y, 1}]

{x -> 0.873738, y -> 0.803682}

Comparaison de coefficients

Il existe des cas où l'on aimerait connaître les valeurs des inconnues pour lesquelles l'équation est toujours satisfaite. Un de ces cas est celui de la comparaison de coefficients de deux polynômes. Étant donnés deux polynômes, l'un de coefficients connus, on peut ainsi savoir quelles équations résoudre pour que les coefficients soient identiques. La fonction permettant de résoudre ce problème est SolveAlways.

SolveAlways[(a - 2 b + 3) x2 + (b + 2 c) x + (2 c - 2 a + 3) == 3 x2 - 2 x + 7, x]

         12         6         2
{{a -> - --, b -> - -, c -> - -}}
         5          5         5

Utilisation des solutions

Chaque fois qu'une équation est résolue, les solutions sont données sous la forme de règles. Pour remplacer les valeurs trouvées dans une équation, par exemple pour une vérification, on utilisera les remplacements.

Solve[2 x2 + 3 == 4, x]

            1               1
{{x -> - -------}, {x -> -------}}
         Sqrt[2]         Sqrt[2]

2 x2 + 3 == 4 /. %

{True, True}

Il peut être utile d'assigner directement à une variable une solution trouvée. Voici, à l'aide d'un exemple, une manière pratique de procéder.

On résout d'abord l'équation pour obtenir la solution sous forme de règle. On remarque que la règle est un élément d'une liste de listes. Ici, pour faciliter la manipulation, la règle est assignée à une variable appelée rule.

rule = Solve[2 x2 + 3 == 4, x]

            1               1
{{x -> - -------}, {x -> -------}}        
         Sqrt[2]         Sqrt[2]

On applique alors cette règle au moyen d'un remplacement de la forme ci-dessous. Il est à noter que l'on doit spécifier l'élément correct de la liste, c'est-à-dire rule2,1 (deuxième liste, premier et unique élément).

sol = x /. rule [[ 2, 1 ]]

  1
-------
Sqrt[2]

La variable sol possède bien la valeur voulue, tandis que x ne possède pas de valeur globale.

{sol, x}

    1
{-------, x}
 Sqrt[2]

Clear[sol, rule]

Exercice 24 [voir la solution]

Calculez les solutions exactes de l'équation y³ - 2 y + 1 == 0. Donnez une approximation numérique de ces solutions.
Le système des équations x² + y² == 8 et (x - 7)² + (y + 1)² == 4 possède-t-il des solutions réelles?

Exercice 25 [voir la solution]

Trouvez une solution de l'équation cos(x) == 3 Sqrt[2]/5 entre 0 et 1 à l'aide de FindRoot. Essayez la méthode de Newton, puis celle de la sécante.

2.5.2. Limites

On pourrait penser que pour calculer des limites, il suffit d'utiliser le remplacement de la manière suivante:

Cos[x2] /. x -> 0

1

Bien sûr dans ce cas, où la fonction est continue en 0, tout marche bien. Dans la plupart des cas, il faut être toutefois plus prudent:

Sin[x]/x /. x -> 0

                                     1
Power :: infy :  Infinite expression - encountered.
                                     0

Infinity :: indet :  Indeterminate expression 0 ComplexInfinity
  encountered.

Indeterminate

ne fonctionne évidemment pas. Dans ce cas, il faut utiliser la fonction Limit qui livre le bon résultat:

Limit[Sin[x]/x, x -> 0]

1

Limit[x Log[x], x -> 0]

0

Le caractère se saisit inf.

Limit[(2 x2)/(x2 - 3 x + 1), x -> -]

2

Il est possible de spécifier la direction dans laquelle on veut la limite, comme dans l'exemple suivant:

Limit[E1/x, x -> 0, Direction -> 1]

0

Limit[E1/x, x -> 0, Direction -> -1]

L'option Direction -> 1 indique qu'il s'agit de la limite lorsque x tend vers 0 en croissant, c'est-à-dire par en-dessous. On l'appelle aussi limite à gauche. De façon analogue, Direction -> -1 indique que x tend vers 0 en décroissant, c'est-à-dire par en-dessus (limite à droite).

Lorsque la fonction possède une singularité essentielle, l'output de la fonction Limit est un intervalle.

Limit[Sin[1/x], x -> 0]

Interval[{-1, 1}]

2.5.3. Calcul différentiel

Mathematica est capable de calculer la dérivée d'expressions symboliques. La fonction permettant ce calcul est dénotée, comme en mathématiques habituelles, par la lettre D. Il s'agit d'une dérivée partielle: on considère que les autres symboles sont indépendants de la variable par rapport à laquelle on dérive.

Par exemple, si l'on veut dériver xⁿ, cette opération suppose que n ne dépend pas de x.

D[xn, x]

n x-1 + n

D[ArcTan[s], s]

  1
------
1 + s2

Bien sûr, il est possible de dériver par rapport à une autre variable

D[ArcTan[s], a]

0

On peut également écrire, s'il n'y a pas d'ambiguïté sur la variable,

ArcTan'[s]

  1
------
1 + s2

Si l'on veut au contraire une dérivée totale, on utilisera la fonction Dt:

Dt[xn, x]

n x-1 + n + xn Dt[n, x] Log[x]

Pour calculer des dérivées multiples, on utilisera la notation de l'exemple suivant (la troisième dérivée du logarithme par rapport à x):

D[Log[x], {x, 3}]

2
--
x3

ou encore, lorsqu'il n'y a pas d'ambiguïté,

Log'''[x]

2
--
x3

Les dérivées partielles de fonctions à plusieurs variables se calculent de la même manière:

D[(x2 + y2)/(2 x y), {x, 2}, {y, 3}]

 6       6     6 (x2 + y2)
---- + ----- - -----------
x y4    x3 y2      x3 y4

De la même façon qu'il traite des variables symboliquement, Mathematica peut traiter des fonctions symboliquement. On peut ainsi trouver les formules de dérivation d'une fonction quelconque, par exemple la règle de la dérivée des fonctions composées:

D[f[g[x]], x]

f'[g[x]] g'[x]

La dérivée partielle possède aussi une notation plus classique. Elle utilise le caractère , qui se saisit pd (pour «partial d»). La dérivée de xⁿ par rapport à x s'écrit par exemple

n x-1 + n

La troisième dérivée partielle de log(x) s'écrit

2
--
x3

Voici encore un exemple:

 6       6     6 (x2 + y2)
---- + ----- - -----------
x y4    x3 y2      x3 y4

Exercice 26 [voir la solution]

Calculez la deuxième dérivée par rapport à t de et vérifiez qu'elle s'annule en t1.
Retrouvez les règles de la dérivée du produit et du quotient de deux fonctions quelconques f et g.

2.5.4. Calcul intégral

Primitives

La fonction Integrate[f, x] calcule l'intégrale indéfinie de la fonction f par rapport à x. En fait, on obtient à l'aide de cette commande une primitive de f.

Integrate[s2, s]

s3
--
3

La notation mathématique standard est interprétée correctement par Mathematica. Elle se saisit à l'aide d'une palette, ou bien avec le clavier par int.

s3
--
3

Le symbole d qui termine l'intégrale en spécifiant la variable d'intégration n'est pas une lettre d normale. Il s'agit du symbole , que l'on saisit dd (pour «differential d»). On pourrait imaginer en effet une intégrale de la forme suivante:

d3
--
3

qui est traitée correctement par le logiciel.

Evidemment, en dérivant l'expression trouvée plus haut, on retrouve f:

D[s3/3, s]

s2

On peut ainsi calculer des intégrales assez compliquées:

1               1
- Log[-1 + x] - - Log[1 + x]
2               2

Simplify[D[%, x]]

   1
-------
-1 + x2

a y1 + n
-------
 1 + n

D[%, y]

a yn

Exercice 27 [voir la solution]

Cherchez une primitive de (x² + 1)/^{2 x}. Utilisez la notation bidimensionnelle.

Intégrales définies

Pour calculer maintenant des intégrales définies, il suffit d'ajouter un argument à la fonction. Cet argument est de la forme {x, xmin, xmax}. On l'appelle un itérateur. Les itérateurs sont très souvent utilisés dans Mathematica. Nous les avons vus à plusieurs reprises et les rencontrerons encore de nombreuses fois.

Integrate[1/x2, {x, 1, 2}]

1
-
2

La notation mathématique habituelle fonctionne encore ici. Il suffit d'ajouter les bornes d'intégration en indice et en exposant du symbole d'intégration. La solution la plus simple est la palette. Avec le clavier, il est nécessaire d'entrer d'abord la borne inférieure avec _, puis la borne supérieure avec 5 (voir le positionnement simultané d'un indice et d'un exposant).

1
-
2

On peut aussi calculer des intégrales impropres.

-
2

Integrate[Exp[-x],{x, 0, }]

1

On sait qu'en mathématiques, il est beaucoup plus difficile de calculer des intégrales que des dérivées. En outre, les intégrales de certaines fonctions n'ont pas de forme explicite. Mathematica peut calculer symboliquement ou de façon exacte les intégrales contenant des fonctions simples, c'est-à-dire polynomiales, rationnelles, logarithmiques, exponentielles et trigonométriques. Il peut aussi calculer d'autres intégrales, notamment celles qui s'expriment en termes de fonctions spéciales.

Integrate[Log[Log[x]], x]

x Log[Log[x]] - LogIntegral[x]

Il existe malgré tout un grand nombre de fonctions impossibles à intégrer de façon symbolique ou exacte.

Integrate[Sin[Sin[x]], x]

Integrate[Sin[Sin[x]], x]

Il est cependant toujours possible d'obtenir une approximation numérique d'une intégrale définie, à l'aide de la fonction NIntegrate. Cette fonction ne possède pas de notation particulière.

NIntegrate[Sin[Sin[x]], {x, 0, 3 /2}]

0.893244

Lors du calcul numérique d'une intégrale définie, Mathematica vérifie si une singularité est présente aux bornes de l'intervalle d'intégration. Les singularités éventuelles à l'intérieur de cet intervalle sont parfois détectées automatiquement.

NIntegrate[1/Sqrt[Abs[x]], {x, -2, 1}]

NIntegrate :: slwcon :  Numerical integration converging too
   slowly; suspect singularity, value of the integration is 0,
   oscillatory integrand, or insufficient WorkingPrecision. If
   your integrand is oscillatory try using the option
   Method->Oscillatory in NIntegrate.

NIntegrate :: ncvb :  NIntegrate failed to converge to prescribed
   accuracy after 7 recursive bisections in x near x = 0.00390625`.

4.79343

Afin d'être sûr qu'une singularité soit traitée correctement, il faut utiliser une version particulière de l'itérateur, comprenant les points où peut avoir lieu une singularité. L'intégration se fera sur chaque sous-intervalle spécifié et les singularités seront prises en compte correctement. En reprenant l'exemple ci-dessus, cela donne:

NIntegrate[1/Sqrt[Abs[x]], {x, -2, 0, 1}]

4.82843

L'intégration a été faite de -2 à 0, puis de 0 à 1.

Il est à noter que Mathematica peut calculer analytiquement cette intégrale

Integrate[1/Sqrt[Abs[x]], {x, -2, 1}]

2 + 2 Sqrt[2]

Exercice 28 [voir la solution]

Calculez les intégrales doubles et . Saississez ces deux intégrales en notation bidimensionnelle.

2.5.5. Polynômes de Taylor, séries entières

La construction du polynôme de Taylor d'une fonction s'effectue par la fonction Series, qui permet plus généralement de développer une fonction en série entière.

Voici le polynôme de Taylor d'ordre 5 de la fonction exponentielle autour de 0.

taylor = Series[Ex, {x, 0, 5}]

        x2   x3    x4    x5
1 + x + -- + -- + -- + --- + O[x]6        2    6    24   120

Pour obtenir le polynôme de Taylor autour d'un autre nombre, par exemple 2, on procédera ainsi:

Series[Ex, {x, 2, 5}]

On reconnaît la notation en O[x], qui représente les termes de degrés supérieurs omis. Pour manipuler le polynôme de Taylor, il faut enlever ce terme inutile avec la fonction Normal. L'expression obtenue peut être alors utilisée comme n'importe quelle autre expression.

Normal[taylor]

        x2   x3    x4    x5
1 + x + -- + -- + -- + ---
        2    6    24   120

Together[%]

 1
--- (120 + 120 x + 60 x2 + 20 x3 + 5 x4 + x5)
120

Exercice 29 [voir la solution]

Calculez le polynôme de Taylor d'ordre 10 de la fonction sinus. Factorisez ensuite ce polynôme.

Clear[taylor]

2.6. Fonctions, éléments de programmation

Nous allons maintenant traiter de la façon de définir nos propres fonctions dans le système Mathematica.

Nous aimerions pour commencer définir une fonction nommée f qui élève au carré son argument. Voici la manière correcte de le faire:

f[x_] := x2

Les choses nouvelles qui apparaissent dans cette ligne sont d'une part le caractère _ (souligné) et d'autre part le symbole :=.

2.6.1. Pattern et Blank

Le x_ qui apparaît dans f[x_] est un objet très important de Mathematica appelé pattern (terme que l'on peut traduire approximativement par «modèle» ou «motif»). Les patterns constituent un moyen de représenter une certaine classe d'expressions. L'objet de base d'une pattern est le _, que l'on appelle blank, c'est-à-dire un blanc.

La règle fondamentale dit qu'un blank représente n'importe quelle expression. Par exemple, si j'écris f[_], cela signifie f de n'importe quoi. La pattern x^_ représente n'importe quelle puissance de x, et _^_ n'importe quelle puissance de n'importe quelle expression.

Dans le cas de la fonction f[x_], la pattern x_ est mise pour n'importe quel objet (ce qui est la signification de _), auquel on donne le nom x pour plus de commodité. Ainsi on peut utiliser le symbole x pour représenter l'expression dans la partie droite de la définition.

La signification exacte de f[x_] := x² est donc: «f est une fonction qui prend n'importe quelle expression comme argument et l'élève au carré». On remarque que le nom x n'a aucune importance.

Nous pouvons maintenant observer ce qui se passe avec notre fonction:

f[2]

4

f[1 + 23]

81

f[y]

y2

f[x]

x2

Que se passe-t-il si on omet le blank ? Faisons une petite expérience:

g[x] := x2

g[2]

g[2]

g[1 + 23]

g[9]

g[y]

g[y]

g[x]

x2

Mathematica n'applique la règle que lorsque l'expression correspond exactement à celle qui est donnée dans la définition, ce qui n'est le cas que pour g[x]. La définition signifie ici: «g est une fonction qui prend x comme argument et l'élève au carré.»

Il est à noter qu'il n'est pas possible de placer des blanks dans la partie droite d'une assignation. Cela entraînerait en effet des récursions infinies.

Pour ôter les définitions (valeurs) attachées à un symbole, on utilise comme pour les variables la fonction Clear. Ici encore, il est conseillé d'ôter les définitions des fonctions que l'on n'utilise plus, afin d'éviter tout conflit ultérieur.

Clear[f, g]

Exercice 30 [voir la solution]

Définissez une fonction f qui additionne ses deux arguments et testez-la.
Définissez une fonction g comme f, mais qui ne s'applique que lorsque ses deux arguments sont identiques.

2.6.2. Assignation et assignation retardée

Parlons maintenant du symbole :=. Son action est presque la même que =, puisqu'il s'agit aussi d'une assignation. En fait, la seule différence entre les deux est le moment où l'expression à droite du symbole est évaluée.

Avec =, l'expression à droite est évaluée au moment de l'assignation. Avec :=, l'expression à droite est évaluée chaque fois que l'on demande la valeur de l'expression de gauche. C'est une assignation retardée. Voyons un exemple:

ex1[x_] = Expand[(1 + x)2]

1 + 2 x + x2

Dans ce cas la partie droite a été évaluée. Si je demande des informations sur ex1, j'obtiens

? ex1

Global`ex

ex1[x_] = 1 + 2 * x + x2

C'est exactement comme si j'avais défini ex1[x_] = x² + 2x + 1. En effet:

ex1[y + 1]

1 + 2 (1 + y) + (1 + y)2

Si maintenant j'utilise :=

ex2[x_] := Expand[(1 + x)2]

? ex2

Global`ex2

ex2[x_] := Expand[(1 + x)2]

je remarque que la partie droite de la définition n'a pas encore été évaluée. Elle le sera en revanche chaque fois que j'utiliserai la fonction.

ex2[y + 1]

4 + 4 y + y2

En résumé, il faut utiliser cette deuxième solution si l'expression à droite est une sorte de programme à exécuter. Si au contraire on assigne à une variable sa valeur définitive, on utilise =, comme on l'a déjà vu. Dans le doute, il vaut mieux utiliser :=.

Clear[ex1, ex2]

Exercice 31 [voir la solution]

Définissez une fonction de trois variables qui calcule le discriminant d'un polynôme du second degré en fonction de ses coefficients. Utilisez cette fonction pour en construire une autre qui donne les deux zéros de ce polynôme.

2.6.3. Une première approche de programmation

Nous venons de voir par quelques exemples que la frontière entre définition de fonction et programmation est très floue. Les fonctions définies dans le dernier exercice sont-elles déjà des programmes? Dans un langage de programmation classique (Pascal, C, Ada, etc.), la réponse à cette question serait à coup sûr oui. En Mathematica, les termes programme et fonction désignent la même notion.

Notre première approche de la programmation est donc déjà faite. Continuons cependant dans cette direction.

Il est possible de définir des fonctions qui «retiennent» les valeurs déjà calculées, ce qui est utile pour les fonctions récursives. Voici un exemple que nous avons déjà vu dans le premier chapitre, celui des nombres de Fibonacci.

fib[0] = fib[1] = 1 ;
fib[n_Integer] := fib[n] = fib[n - 1] + fib[n - 2];

fib[5]

8

Le calcul de fib[5] nécessite suivant cette fonction le calcul des valeurs de fib[4], fib[3], etc. Les définitions ci-dessus permettent de conserver en mémoire toutes les valeurs déjà calculées, ce qui peut être pratique, puisqu'on les utilisera éventuellement dans des calculs ultérieurs.

? fib

Global`fib

fib[0] = 1
fib[1] = 1
fib[2] = 2
fib[3] = 3
fib[4] = 5
fib[5] = 8
fib[n_Integer] := fib[n] = fib[n - 1] + fib[n - 2]

Ceci permet également d'éviter un grand nombre de calculs inutiles lors d'une récursion. Par contre, la mémoire devient vite très encombrée.

Clear[fib]

Nous remarquons pour terminer qu'en définissant une fonction exactement avec la même notation qu'en mathématique, nous obtenons un programme.

Le sujet de la programmation sera le thème principal du troisième chapitre.

2.7. Graphiques

Une des plus importantes caractéristiques de Mathematica est sa capacité de produire des graphiques de grande qualité. En effet les graphiques sont produits par le kernel de Mathematica directement dans le langage de description graphique PostScript, ce qui permet d'obtenir à l'impression une qualité exceptionnelle.

2.7.1. Représentation graphique de fonctions

Pour dessiner la représentation graphique d'une fonction, on utilisera la fonction Plot de la manière suivante

Plot[Sin[x], {x, 0, 2 }]

- Graphics -

Le deuxième argument de la fonction est un itérateur, objet déjà rencontré avec la fonction Integrate et ailleurs. Bien sûr cela fonctionne de la même manière pour les fonctions définies par l'utilisateur.

f[x_] := x3 - x

Plot[f[x], {x, -2, 2}]

- Graphics -

Pour dessiner plusieurs fonctions sur le même système d'axes, on utilisera une liste de fonctions comme premier argument:

Plot[{Sin[x], Sin[2 x], Sin[3 x]}, {x, -, }]

- Graphics -

La fonction Plot évalue ses arguments de façon inhabituelle: elle calcule d'abord les valeurs de x nécessaires pour dessiner la fonction, puis seulement évalue la fonction en ces valeurs. Cette approche a l'avantage suivant: Mathematica ne doit calculer la valeur de la fonction que sur un ensemble relativement restreint de valeurs numériques.

Il y a certains cas où ce comportement est indésirable. Un cas typique est celui du dessin d'une table de fonctions.

sintable = Table[Sin[n x], {n, 1, 3}]

{Sin[x], Sin[2 x], Sin[3 x]}

Strictement, pour Mathematica, la fonction à dessiner est Table, fonction dont le résultat n'est pas un nombre, et Mathematica s'en plaint.

Plot[sintable, {x, 0, 2 }]

Plot :: plnr :  sintable is not a machine-size real number
   at x  = 2.61799387799149396`*^-7.

Plot :: plnr :  sintable is not a machine-size real number
   at x = 0.254889925407422568`.

Plot :: plnr :  sintable is not a machine-size real number
   at x = 0.532869405195950918`.

General :: stop :  Further output of Plot :: plnr will be
   suppressed during this calculation.

- Graphics -

Pour remédier à cela, on force l'évaluation de la fonction d'abord, puis le calcul des valeurs pour le dessin, à l'aide de la fonction Evaluate.

Plot[Evaluate[sintable], {x, 0, 2 }]

- Graphics -

Clear[f, sintable]

La représentation de fonctions de deux variables dans l'espace tridimensionnel se fait de façon analogue avec la commande Plot3D.

Plot3D[x2 y2, {x, -3, 3}, {y, -3, 3}]

- SurfaceGraphics -

Exercice 32 [voir la solution]

Représentez graphiquement la fonction tan(x) sur l'intervalle de - à . Même question pour la fonction de deux variables sin(x y) sur le carré [-, ] x [-, ].

2.7.2. Options

Quand Mathematica dessine un graphique, il doit faire de nombreux choix: échelle des axes, échantillonnage des points à évaluer, proportions du dessin, etc. La plupart du temps, Mathematica fera des choix tout à fait valables. Toutefois, lorsque l'on veut obtenir les meilleurs résultats selon ses goûts particuliers, il est possible d'aider Mathematica à faire ces choix, ou encore d'imposer ses propres préférences.

Le mécanisme utilisé est un principe général de Mathematica, la spécification des options. Nous avons déjà rencontré les options, notamment avec les fonctions Factor et Limit. Chaque option a un nom déterminé. Comme dernier argument de Plot, on peut spécifier une séquence de règles, qui donnera les valeurs aux différentes options. Lorsqu'on ne donne aucune valeur explicite pour une option, elle prend une valeur prédéfinie. On dit de cette valeur prédéfinie qu'elle est prise par défaut. Considérons la représentation graphique suivante:

Plot[Sin[t2], {t, 0, 3}]

- Graphics -

L'option PlotLabel permet de donner un titre au dessin:

Plot[Sin[t2], {t, 0, 3}, PlotLabel -> Sin[t2]]

- Graphics -

On peut également donner, en même temps ou non, des titres aux axes:

Plot[Sin[t2], {t, 0, 3}, AxesLabel -> {t, f[t]},
  PlotLabel -> Sin[t2] ]

- Graphics -

Pour encore améliorer le résultat, il est possible de choisir le format et la police d'affichage des légendes.

Plot[Sin[t2], {t, 0, 3}, AxesLabel -> {t, f[t]},
  PlotLabel -> Sin[t2], DefaultFont -> {"Times", 10},
  FormatType -> TraditionalForm]

- Graphics -

La fonction Plot possède un grand nombre d'options. Il est donc difficile de les connaître toutes ou de s'en souvenir. Il y a deux remèdes à ce problème. Le premier et le meilleur est de consulter le manuel de référence ou l'aide en ligne. Le deuxième et souvent le plus rapide est de demander au kernel quelles sont les options disponibles pour cette fonction, ce que l'on fait avec la commande Options.

Options[Plot]

                     1
{AspectRatio -> -----------, Axes -> Automatic, AxesLabel -> None, 
                GoldenRatio
   AxesOrigin -> Automatic, AxesStyle -> Automatic,
   Background -> Automatic, ColorOutput -> Automatic,
   Compiled -> True, DefaultColor -> Automatic, Epilog -> {},
   Frame -> False, FrameLabel -> None, FrameStyle -> Automatic,
   FrameTicks -> Automatic, GridLines -> None,
   ImageSize -> Automatic, MaxBend -> 10., PlotDivision -> 30.,
   PlotLabel -> None, PlotPoints -> 25, PlotRange -> Automatic,
   PlotRegion -> Automatic, PlotStyle -> Automatic, Prolog -> {},
   RotateLabel -> True, Ticks -> Automatic, DefaultFont :> $DefaultFont,
   DisplayFunction :> $DisplayFunction, FormatType :> $FormatType,
   TextStyle :> $TextStyle}

Options[Plot3D]

{AmbientLight -> GrayLevel[0], AspectRatio -> Automatic,
   Axes -> True, AxesEdge -> Automatic, AxesLabel -> None,
   AxesStyle -> Automatic, Background -> Automatic,
   Boxed -> True, BoxRatios -> {1, 1, 0.4}, BoxStyle -> Automatic,
   ClipFill -> Automatic, ColorFunction -> Automatic,
   ColorOutput -> Automatic, Compiled -> True, DefaultColor -> Automatic,
   Epilog -> {}, FaceGrids -> None, HiddenSurface -> True,
   ImageSize -> Automatic, Lighting -> True,
   LightSources -> {{{1., 0., 1.}, RGBColor[1, 0, 0]},
      {{1., 1., 1.}, RGBColor[0, 1, 0]},
      {{0., 1., 1.}, RGBColor[0, 0, 1]}}, Mesh -> True,
   MeshStyle -> Automatic, Plot3Matrix -> Automatic, PlotLabel -> None,
   PlotPoints -> 15, PlotRange -> Automatic, PlotRegion -> Automatic,
   Prolog -> {}, Shading -> True, SphericalRegion -> False,
   Ticks -> Automatic, ViewCenter -> Automatic,
   ViewPoint -> {1.3, -2.4, 2.}, ViewVertical -> {0., 0., 1.},
   DefaultFont :> $DefaultFont, DisplayFunction :> $DisplayFunction,
   FormatType :> $FormatType, TextStyle :> $TextStyle}

De cette manière on obtient non seulement le nom de toutes les options, mais encore leur valeur par défaut. Ce mécanisme fonctionne évidemment pour toutes les fonctions qui ont des options, même celles qui ont été définies par l'utilisateur.

Si l'on veut des informations quant à la signification de telle ou telle option, il faut consulter le manuel de référence ou l'aide en ligne.

Exercice 33 [voir la solution]

Reprenez le premier dessin de l'exercice précédent, et enrichissez-le de légendes sur les axes. Entourez-le en outre d'un cadre (cadre se dit «frame» en anglais).

2.7.3. Redessiner et combiner des dessins

En utilisant les options pour obtenir un dessin avec des réglages différents, on recalcule chaque fois tout le dessin, ce qui peut prendre du temps. On peut éviter cela en manoeuvrant de la façon suivante. On définit d'abord une variable qui contiendra tout le dessin (il est important d'utiliser le symbole =, et non :=, puisqu'il s'agit de ne pas tout recalculer à chaque fois),

myplot = Plot[Sin[t2], {t, 0, 3}]

- Graphics -

puis on spécifie les options désirées à l'aide de la commande Show:

Show[myplot, AxesLabel -> {t, f[t]}, PlotLabel -> Sin[t2]]

- Graphics -

Mathematica prend alors le dessin déjà produit et change les paramètres voulus.

Voici encore trois exemples d'options fréquemment utilisées dans les dessins.

Tout d'abord l'option DisplayFunction permet d'empêcher l'affichage à l'écran d'un dessin intermédiaire lorsqu'elle a la valeur Identity. Elle est particulièrement utile quand on fabrique plusieurs dessins que l'on désire recombiner plus tard. Pour que l'affichage fonctionne à nouveau, il faut donner la valeur $DisplayFunction à cette option.

invisible =
  Plot[x2, {x, -1, 1}, DisplayFunction -> Identity]

- Graphics -

Show[invisible, DisplayFunction -> $DisplayFunction]

- Graphics -

L'option PlotRange permet de spécifier l'intervalle des valeurs en abscisse et en ordonnée, ou en ordonnée seulement.

Show[myplot, PlotRange -> {{0, 2}, {0, 1.2}}]

- Graphics -

Show[myplot, PlotRange -> {0, 1.2}]

- Graphics -

La dernière option dont je parlerai ici est AspectRatio. Elle définit le rapport entre la hauteur et la largeur du dessin. Sa valeur par défaut est 1/GoldenRatio, c'est-à-dire l'inverse de la section d'or, afin de donner au dessin les proportions d'un rectangle d'or. Si l'on veut garder des proportions exactes (même échelle, repère orthonormé) entre les valeurs en abscisse et en ordonnée, on doit donner à cette option la valeur Automatic.

Show[myplot, AspectRatio -> Automatic]

- Graphics -

Clear[myplot, invisible]

La fonction Show n'est pas seulement utile pour redessiner un graphique. Elle permet aussi d'en combiner plusieurs.

plot1 = Plot[x2, {x, -5, 5}, DisplayFunction -> Identity]

- Graphics -

plot2 = Plot[-x2, {x, -5, 5}, DisplayFunction -> Identity]

- Graphics -

Show[plot1, plot2, DisplayFunction -> $DisplayFunction]

- Graphics -

On remarquera que l'échelle s'ajuste automatiquement.

Clear[plot1, plot2]

2.7.4. Représentation paramétrique

Avec la fonction Plot, on dessine des courbes où la coordonnée y est donnée en fonction de la coordonnée x. Mathematica peut aussi être utilisé pour faire des représentations paramétriques, où l'on donne les coordonnées x et y en fonction d'un paramètre t. La syntaxe est essentiellement la même que pour les dessins en représentation cartésienne. Les fonctions coordonnées sont mises dans une liste.

ParametricPlot[{Sin[t], Sin[2 t]}, {t, 0, 2 }]

- Graphics -

ParametricPlot[{Sin[t], Cos[t]}, {t, 0, 2 }]

- Graphics -

Avec ce genre de dessins, on peut utiliser les mêmes options que celles décrites ci-dessus. En particulier, en fixant le rapport hauteur/largeur à Automatic, on préserve l'allure naturelle de la courbe:

Show[%, AspectRatio -> Automatic]

- Graphics -

On peut bien entendu dessiner plusieurs fonctions en même temps,

ParametricPlot[{{Sin[t], Sin[2 t]}, {Sin[t], Cos[t]}},
  {t, 0, 2 }, AspectRatio -> Automatic]

- Graphics -

ainsi qu'en 3 dimensions avec ParametricPlot3D (courbes ou surfaces):

ParametricPlot3D[{Sin[t], Cos[t], t/}, {t, 0, 4 }]

- Graphics3D -

ParametricPlot3D[
  {Cos[t] (2 + Cos[u]), Sin[t] (2 + Cos[u]), Sin[u]},
  {t, 0, 2 }, {u, 0, 2 }]

- Graphics3D -

Exercice 34 [voir la solution]

Dessinez le trèfle d'équations paramétriques x = cos(t) cos(3 t) et y = sin(t) cos(3 t) en préservant l'allure de la courbe. Mettez comme titre au dessin le mot «Trèfle».

2.7.5. Représentation de points

Nous avons jusqu'ici discuté comment représenter graphiquement des fonctions. Il est aussi possible de représenter des listes de données grâce à la fonction ListPlot. Tout fonctionne de façon analogue à ce qui a été dit pour les autres fonctions graphiques. Il suffit de spécifier une liste de valeurs:

premiers = Table[Prime[i], {i, 25}]

{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}

ListPlot[premiers]

- Graphics -

Si l'on ne spécifie comme ci-dessus qu'une seule liste de nombres, Mathematica interprète les membres de la liste comme les ordonnées et fixe les abscisses à 1, 2, 3, etc.

On peut donner explicitement les abscisses et les ordonnées en spécifiant une liste de couples:

data = Table[{2 i, i2 + Random[Integer, {-2, 2}]}, {i, 10}]

{{2, -1}, {4, 3}, {6, 11}, {8, 17}, {10, 26}, {12, 37}, {14, 51},
  {16, 65}, {18, 81}, {20, 100}}

ListPlot[data]

- Graphics -

Bien sûr avec ListPlot on peut utiliser pratiquement toutes les options de Plot. En outre ListPlot possède l'option PlotJoined qui permet de relier les points:

ListPlot[data, PlotJoined -> True]

- Graphics -

Il y a cependant un défaut: les points représentant les couples ont disparu. Pour remédier à cela, on peut utiliser l'option Epilog. Cette option permet de spécifier des fonctions graphiques à appliquer à la fin de l'évaluation du dessin proprement dit. Ici, on fixe la grandeur des points avec PointSize, et on applique la fonction graphique Point à chacun des points de Data. Pour des informations concernant cette syntaxe, on consultera le chapitre 3.

ListPlot[data, PlotJoined -> True,
  Epilog -> {PointSize[.02], Point /@ data}]

- Graphics -

Clear[premiers, data]

2.7.6. Graphiques: quelques trucs utiles

Exportation des graphiques

Les graphiques produits par Mathematica sont souvent utilisés pour illustrer des textes ou d'autres documents. Il est donc nécessaire de pouvoir les transporter d'une application à une autre. Pour cela, on se sert comme pour les formules de la commande Copy As du menu Edit, qui permet de spécifier le format graphique désiré.

Si le document final est destiné à l'impression, il faut choisir le format PICT with Embedded PostScript ou le format EPS. Dans le cas où il est destiné à être lu à l'écran, on choisira plutôt le format PICT. Le format QuickTime permet de copier une animation Mathematica dans le format adéquat.

On colle ensuite le dessin ou l'animation dans l'application désirée.

Il est aussi possible d'enregistrer le dessin directement dans un fichier. Pour cela, on sélectionne le dessin et on choisit la commande Save Selection As... du menu Edit. On choisit ensuite le format désiré.

Possibilités graphiques du front end

Le front end graphique de Mathematica permet diverses manipulations sur les dessins.

Lorsqu'on a produit un graphique et que l'on clique dans le dessin, un cadre apparaît autour de celui-ci. On voit sur ce cadre 8 repères carrés, appelées les poignées.

Le pointeur se transforme en croix avec des flèches au bout de chaque branche. En cliquant sur le dessin et le faisant glisser, on peut alors le déplacer où l'on veut.

Lorsque le pointeur est sur l'une des poignées, il prend la forme d'une flèche à deux pointes. En cliquant et faisant glisser la poignée, il est alors possible de modifier les dimensions du dessin. La modification préserve les proportions. Si l'on ne veut changer que la hauteur ou la largeur du dessin, on enfonce la touche en glissant le pointeur.

Si l'on veut retourner à la grandeur standard du dessin, on sélectionne l'article Make Standard Size du menu Graph.

En pressant la touche lorsqu'un dessin produit par Mathematica est sélectionné, le pointeur change encore de forme. Il ressemble à une mire. On peut alors lire dans la barre d'états, en bas à gauche de la fenêtre active, les coordonnées du pointeur dans le repère du dessin.

Si l'on clique, toujours en maintenant la touche commande enfoncée, un point apparaît sous le curseur. On peut répéter l'opération pour voir plusieurs de ces points.

On peut alors exécuter la commande Copy (c, c) du menu Edit, et le presse-papier contient la liste des coordonnées des points que l'on vient de dessiner. Après l'avoir collée, on peut utiliser cette liste pour des calculs ultérieurs.

On a souvent besoin d'imprimer un dessin, et rien d'autre. Dans ce cas, plutôt que d'imprimer tout le document ouvert, on préférera utiliser la commande Print Selection... du menu File après avoir sélectionné la ou les cellules à imprimer.

Exercice 35 [voir la solution]

Dessinez la représentation graphique de la fonction partie entière en gardant les mêmes échelles pour l'axe des abscisses et celui des ordonnées.
Fabriquez une liste de points de la manière décrite ci-dessus, et faites une représentation graphique de ces points.

2.7.7. Animation

Mathematica permet l'animation des graphiques. Il permet en fait de produire des images se suivant avec de légères modifications, à la manière des dessins animés, puis de les faire se succéder rapidement, afin de donner comme au cinéma l'illusion du mouvement.

La première étape pour fabriquer une telle animation est de produire les dessins. Pour ce faire, il est pratique de charger un package qui a été mis en oeuvre spécialement pour cela.

Needs["Graphics`Animation`"]

Ce package définit une nouvelle fonction appelée Animate. Cette fonction s'utilise comme Plot, mais nécessite un argument supplémentaire, sous la forme d'un itérateur, qui indique les bornes, ainsi que le pas du paramètre d'animation.

La ligne suivante indique que l'on veut la suite des dessins sin(x), sin(x + /6), sin(x + /3), ..., sin(x + 2 - /6), tous sur l'intervalle de 0 à 2.

MoviePlot[Sin[x + t], {x, 0, 2 },
  {t, 0, 2  - /6, /6}]

MoviePlot3D[Sin[x y t], {x, -2, 2}, {y, -2, 2},
  {t, 0, 2.5, .3}, PlotRange -> {-1, 1}]

Les dessins ainsi obtenus sont groupés dans une seule grande cellule. Pour voir le dessin animé, il faut cliquer sur cette grande cellule pour la sélectionner (la barre devient contrastée), et ensuite actionner la commande Animate Selected Graphics (y, y) du menu Cell.

On voit alors les dessins produits se succéder au même endroit. Il est possible de contrôler la vitesse et le sens de déroulement du film à l'aide du petit tableau de commande qui apparaît en bas à gauche de la fenêtre active.

On peut également régler la vitesse de défilement en frappant simplement les chiffres 1 (très lent) à 9 (très rapide) sur le clavier, et 0 pour stopper l'animation.

La production des images servant à faire une animation est possible sans le package Animation. Nous verrons plus tard comment procéder, à l'aide de la fonction Do, qui sert à faire des boucles.

Exercice 36 [voir la solution]

Fabriquez une animation de la famille de fonctions a x² sur l'intervalle [-3, 3], le paramètre a allant de 0 à 2 par pas de 1/4. Ajustez avec l'option PlotRange les intervalles de dessin, afin d'obtenir une animation montrant le rôle de a de façon convaincante.
Mettez comme titre à chacun des dessins de l'animation la valeur actuelle du paramètre.

© 1992-1998 Nicolas Martignoni, nicolas.martignoni@mcnet.ch