UE Transversale 1XM02 Mathematica — 2014
UPMC—L1 MIPI
TP
no
2 : Éléments de langage Mathematica
Table des matières
1 Préparations pour ce TP
1.1 Deux types d’exercices . . . . .
1.2 Séparer deux notebooks . . . .
1.3 Raccourcis clavier . . . . . . . .
1.4 Exemples de code Mathematica
.
.
.
.
2
2
2
2
2
2 Langage naturel et Step-by-step
2.1 Langage naturel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Step-by-step . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
3
3
3 Définition et utilisation de
3.1 Introduction . . . . . . .
3.2 = ou := . . . . . . . . .
3.3 == . . . . . . . . . . . .
3.4 Substitution avec règles .
3.4.1 ReplaceRepeated
3.5 Expressions . . . . . . .
.
.
.
.
.
.
4
4
5
6
6
7
7
.
.
.
.
7
7
9
9
9
.
.
.
.
.
.
.
.
variables
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
.
.
.
.
.
.
.
.
ou
. .
. .
. .
. .
. .
. .
4 Définition et utilisation de fonctions
4.1 Introduction . . . . . . . . . . . . . .
4.2 = ou := . . . . . . . . . . . . . . . .
4.3 Notation fonctionnelle, Postfix, Prefix
4.4 Fonctions anonymes ou pures . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
d’expressions
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . .
. . . . .
et Infix
. . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
en
. .
. .
. .
. .
. .
. .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
général
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
5 Listes
5.1 Introduction . . . . . . . . . . . . . . . . . . . . . .
5.2 Adressage d’un élément d’une liste . . . . . . . . .
5.3 Fonctions qui génèrent des listes . . . . . . . . . . .
5.4 Appliquer une fonction à chaque élément d’une liste
5.5 Sélectionner dans une liste . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
10
10
10
11
11
12
6 Plot
6.1 Introduction . . . . . . .
6.2 Plot . . . . . . . . . . .
6.2.1 Introduction . . .
6.2.2 Options de Plot .
6.2.3 Utiliser Plot pour
6.3 Manipulate . . . . . . .
6.4 ListPlot . . . . . . . . .
6.5 ParametricPlot . . . . .
6.6 ContourPlot . . . . . . .
6.7 RegionPlot . . . . . . . .
6.8 PolarPlot . . . . . . . .
. . . . .
. . . . .
. . . . .
. . . . .
équation
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
12
12
12
12
13
13
13
14
14
14
15
15
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
estimer les solutions d’une
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
Préparations pour ce TP
1.1
Deux types d’exercices
Ce TP comporte deux types d’exercices :
1. Exercices numérotés : A rendre à la fin de la séance en tant que compte rendu.
2. Exercices non numérotés : A garder pour vous-même, mais pas à rendre avec le
compte rendu, car il s’y agit uniquement de copier&coller les exemples de l’énoncé
pour voir les résultats dans Mathematica.
Pour bien séparer les deux types d’exercices, il faut de créer (Ctrl+N, puis Ctrl+S) deux
notebooks différents, un pour chaque type d’exercice. Le notebook qui répond aux exercices numérotés doit être envoyé via email à l’enseignant à la fin de la séance. Ce sera le
compte rendu de la séance.
1.2
Séparer deux notebooks
Par défaut, les expressions (variables, fonctions, ...) définies dans un notebook sont
aussi connues dans un autre notebook. Pour bien séparer deux notebooks on peut changer
cette option avec le Options Inspector :
1. Ouvrir le Options Inspector via (Ctrl + Maj + O) ou sous Mac OS X : (Cmd +
Maj + O)
2. Dans le Options Inspector choisir tout en haut dans la liste nommée Show option
values, choisir Global Preferences
3. Chercher CellContext dans la case Lookup en dessous
4. Changer la valeur de CellContext en cliquant sur la flèche à droite de la valeur de
CellContext, puis choisir Notebook à la place de “Global”.
5. Pour finir appuyer sur le button Apply, puis fermer le Options Inspector.
1.3
Raccourcis clavier
A part ces préparatifs, n’oubliez pas le feuille avec les raccourcis clavier et essayez
d’utiliser la souris le moins possible. Un raccourci clavier qui n’est pas encore dans la
liste et qui est utile quand on a plusieurs fenêtres dans une même application (comme
Mathematica) est Ctrl+F6 (sous Mac OS X : ? ?). Ce raccourci clavier change de fenêtre
à l’intérieur d’une application. Pour fermer une fenêtre à partir du clavier : Ctrl+F4.
1.4
Exemples de code Mathematica
Tous les exemples de code Mathematica montrés dans l’énoncé ne contiennent que
des cellules de type Input. C’est pour cela que c’est indispensable de tester ces exemples
soi-même avec Mathematica. Chaque ligne d’un exemple est une nouvelle cellule de type
Input et doit être évaluée dans l’ordre. Les exemples peuvent être copié&collé (Ctrl+C
puis Ctrl+V) dans Mathematica depuis la version PDF de l’énoncé présent, mais attention
de séparer la commande Quit dans une cellule à part.
2
2
2.1
Langage naturel et Step-by-step
Langage naturel
Depuis l’introduction de Wolfram Alpha (www.wolframalpha.com), Mathematica peut
aussi être utilisé en langage naturel, c’est-à-dire des instructions écrites avec des phrases
en anglais. Voir la feuille raccourcis clavier pour des exemples. Si on ne se rappelle plus
de la syntaxe d’une fonction en Mathematica, on peut soit chercher dans l’aide (F1), soit
essayer de décrire ce qu’on veut faire en anglais après un signe = (voir raccourcis clavier)
depuis Mathematica. Avec un peu de chance Wolfram Alpha comprend votre demande et
ne donne non seulement la solution, mais aussi la traduction de votre demande en syntaxe
Mathematica.
2.2
Step-by-step
Wolfram Alpha Pro (la version payante de Wolfram Alpha) a introduit une nouvelle
fonctionnalité : le step-by-step :
http ://www.wolframalpha.com/pro/step-by-step-math-solver.html
Le step-by-step permet d’obtenir une déduction mathématique avec toutes les étapes
intermédiaires de presque n’importe quel problème, comme par exemple :
. Résolution d’un système d’équations
. Calcul d’une dérivée ou d’une primitive
. Transformations algébriques et trigonométriques (moins évident, à tester)
Ceci est une petite révolution, car Mathematica ne permettait jusqu’ici que d’avoir le résultat final, sans donner automatiquement les étapes intermédiaires. Grâce à l’intégration
de Wolfram Alpha dans Mathematica, on peut avoir ces étapes intermédiaires directement
dans un notebook et ceci sans payer un abonnement pour la version Pro de Wolfram Alpha ! Pour cela on peut faire appel à la fonction WolframAlpha avec une petite fonction
ShowSteps qui filtre les résultats step-by-step :
ShowSteps[exp_] :=
WolframAlpha[ToString@HoldForm@InputForm@exp,
TimeConstraint -> Infinity,
IncludePods -> {"Input", "Indefinite Integral", "Root", "Result"},
PodStates -> {"Step-by-step solution", "Show all steps"}]
SetAttributes[ShowSteps, HoldAll]
Ceci est une version améliorée de la fonction ShowSteps trouvée ici :
http ://mathematica.stackexchange.com/questions/148/get-a-step-by-step-evaluationin-mathematica
Sans rentrer dans les détails de cette fonction, il suffit de soit copier&coller cette
fonction dans son notebook puis l’évaluer avec Maj+Entrée, soit l’importer avec :
<< showsteps.m
Le fichier showsteps.m est sur SAKAI, il suffit de le copier dans le dossier où se trouve
le notebook actuel (choisir le dossier lors de la première sauvegarde avec Ctrl+S).
1.
On peut vérifier, si la fonction ShowSteps est bien définie avec la commande ?ShowSteps,
puis en la testant avec par exemple :
D[Sin[x^2], x] // ShowSteps
3
3
3.1
Définition et utilisation de variables ou d’expressions en général
Introduction
En Mathematica le nom d’une variable doit respecter à peu près les mêmes règles
que dans d’autres langages de programmation, comme ne pas commencer avec un chiffre
(ex : 2x) et ne pas contenir des caractères spéciaux (ex : %, #, {, [) ni des accents. Un
nom de variable ne peut pas contenir des espaces. En Mathematica il ne peut non plus
contenir des underscores (tiret bas) (ex : x_point), car ce symbole est réservé. Toutes les
expressions (variables, fonctions, ...) qu’on définit soi-même doivent commencer avec une
minuscule pour éviter une confusion avec les expressions déjà définies de Mathematica, qui
commencent toutes avec un majuscule, par contre on peut mettre des majuscules ailleurs
qu’au début (ex : xPoint). Mais attention ’xPoint’ est différent de ’xpoint’.
Le signe = permet d’affecter une valeur à une variable. Tester ces exemples et observer
le changement de couleur des variables. Qu’est-ce qu’indique la couleur noir ? et la couleur
bleue ?
x=3
y=4
x^2 + y^2
Sqrt[x^2 + y^2]
Ouvrir un nouveau notebook (Ctrl+N) et tester si les préparatifs du TP fonctionnent
bien, c’est-à-dire les variables x et y ne devrait pas être connues dans le nouveau notebook.
On peut tester cela tout simplement en évaluant le nom de la variable :
x
y
Si l’évaluation de ces deux inputs renvoie le nom de chaque variable, alors les préparatifs du TP ont bien été pris en compte, car ces deux variables sont alors encore non-définies
dans le nouveau notebook. Si jamais on obtient une valeur, il faut refaire les préparatifs
du TP décrits en haut.
Pour ne pas devoir ouvrir un nouveau notebook avec chaque nouveau exemple, il est
fortement conseillé de commencer tout nouveau exemple avec la commande Quit. La
commande Quit permet de redémarrer le Kernel et donc d’effacer toute la mémoire sur
les variables déjà définies dans tous les notebooks.
Si on ne veut pas que le résultat de l’évaluation d’une cellule Input soit affiché ou encore
si on veut mettre plusieurs instructions sur une même ligne, on utilise le point-virgule.
Tester ceci :
Quit
x
x=3; y=4;
x
y
L’ordre des évaluations des cellules est très important. L’ordre est indiqué par les
numéros après In et Out. Essayer cet exemple :
4
Quit
x^2 + y^2
x=3; y=4;
Dans cet exemple, la cellule x^2 + y^2 doit être évaluée en dernier, autant la placer en
dessous des autres cellules. D’une manière générale il est préférable de placer les cellules
dans l’ordre de l’évaluation, au moins après avoir terminé les essais et erreurs dans un
notebook.
3.2
= ou :=
En plus du signe = pour l’affectation immédiate, il existe aussi le signe :=. Tester ces
deux exemples pour comprendre la différence entre = et := (attention à bien respecter
l’ordre des évaluations d’en haut en bas, ligne par ligne) :
Quit
x=5; y=x+2;
y
x=10
y
?y
Changer le y=x+2 en y:=x+2 donne un autre comportement :
Quit
x=5; y:=x+2;
y
x=10
y
?y
Qu’est-ce qui a changé ?
On voit bien ici que le signe = affecte la valeur de x+2 à y, tandis que le signe := définie
la règle comment on obtient y avec n’importe quelle valeur de x. Les deux opérateurs, =
et :=, ont une direction : du côté droit vers le côté gauche (left hand side (lhs) et right
hand side (rhs) en anglais), par exemple on ne peut pas écrire 5=x. La différence entre =
et := est à quel moment donné rhs est évalué :
. lhs = rhs
rhs est évalué immédiatement et le résultat est copié à lhs
. lhs := rhs
rhs est évalué à chaque fois que lhs est utilisé
Comme dans le premier exemple la valeur de x est déjà connue au moment de l’affectation
y=x+2, le rhs x+2 est évalué et donne 7. C’est cette valeur qui sera copié sur y et non
x+2. Le fait de changer x après coup ne change rien à y qui est toujours égale à 7. La
commande ?y à la fin donne plus d’information sur la définition de y.
Si on veut que y dépende de x tout le temps, on peut utiliser le signe :=. Mais il est
possible aussi d’avoir cette dépendance avec le signe =, comme montré dans cet exemple :
Quit
y=x+2
x=5
y
x=10
y
?y
5
On voit ici que y est égale à x+2 et non à une valeur, car au moment de l’affectation x
n’a pas encore de valeur, donc l’évaluation de x+2 donne x+2. Du coup à chaque fois que
la valeur de x change, on obtient une autre valeur pour y.
Un autre exemple qui illustre la différence entre = et :=. Pour savoir ce que fait la
fonction Random[], placer le curseur sur Random[] puis appuyer sur F1.
Quit
x=Random[]
x
x
x:=Random[]
x
x
x
Ces exemples ont seulement un but pédagogique ici. S’il y a une dépendance entre
deux variables, il est préférable d’indiquer la dépendance d’une variable sur une autre en
écrivant une fonction (voir en bas).
3.3
==
Comme le signe = est déjà utilisé pour l’affection, on teste avec un double signe égal
== l’égalité entre deux expressions. Par exemple :
Quit
x=3
x==6
x==3
Le résultat du teste d’égalité est donné en valeur booléenne, soit True (Vrai), soit
False (Faux).
3.4
Substitution avec règles
Au lieu de définir des variables globalement pour tout le notebook on peut aussi remplacer localement une variable par une valeur sans jamais faire une affectation du type
x=2. Ce remplacement est effectué avec une règle qui s’écrit : x -> 2. Il suffit d’appliquer cette règle à l’expression souhaité avec l’opérateur /. (qui correspond à la fonction
ReplaceAll) :
Quit
x + y /. x -> 2
x
Comme on voit dans cet exemple, x est remplacé dans l’expression x + y par la valeur
2, sans affecter réellement une valeur à x.
Si on veut remplacer plusieurs variables à la fois, on utilise une liste de règles :
Quit
x + y /. {x -> a, y -> b}
6
La fonction Solve permet de résoudre des équations et fournit les solutions sous forme
d’une liste de règles. Pour convertir cette liste de règles en liste de valeurs, il suffit de
l’appliquer à la variable des règles, ici à x :
Quit
solutions = Solve[x^3 - 2*x + 1 == 0]
x /. solutions
3.4.1
ReplaceRepeated
L’opérateur /. ou la fonction correspondante ReplaceAll applique les règles qu’une
seule fois à l’expression. Ceci peut être observé avec cet exemple, car il reste un y après
l’application des règles :
Quit
x + 2*y /. {x -> y, y -> a}
Si on veut que les règles soient appliquées plusieurs fois, jusqu’à ce qu’aucun remplacement n’est plus possible, on utilise la fonction ReplaceRepeated ou encore l’opérateur
//. Essayer l’opérateur //. sur l’exemple au dessus pour voir l’effet.
ReplaceRepeated permet aussi de limiter le nombre d’itérations de remplacement, ce
qui peut être pratique pour construire certains types de fonctions, comme par exemple :
ReplaceRepeated[1/(1+x), x -> 1/(1+x), MaxIterations -> 4]
On peut ajouter la fonction Quiet pour éviter l’affichage de messages :
Quiet[ReplaceRepeated[1/(1+x), x -> 1/(1+x), MaxIterations -> 4]]
3.5
Expressions
Tout objet en Mathematica (valeur, formule, graphique, ...) peut être mis en mémoire
dans une variable en utilisant l’affectation =
3
2 −x−2
Exemple : fraction= xx3 +2x
+x2 −4x−4
Si on veut évaluer cette fraction pour une valeur de x donnée (par exemple 4), on peut
appliquer la règle x -> 4 à la variable fraction :
Quit
fraction = (x^3 + 2*x^2 - x - 2) / (x^3 + x^2 - 4*x - 4)
fraction /. x -> 4
4
4.1
Définition et utilisation de fonctions
Introduction
On avait utilisé en haut l’exemple y:=x+2, qui définit une dépendance de y par rapport
à x. Pour indiquer une dépendance clairement, on utilise plutôt des fonctions avec des
arguments. Pour cet exemple on écrit :
Quit
f[x_] := x+2
7
On remarque le même signe := pour la définition, c’est-à-dire la fonction est seulement
définie à ce moment sans être évaluée pour une valeur donnée. C’est pour cela qu’on
n’obtient pas de cellule Out ici.
Pour l’évaluer, on fait appel à la fonction en lui donnant une valeur pour x_ :
f[2]
Dans la définition de la fonction, il faut faire attention à quatre particularités de
syntaxe :
1. Utiliser := de préférence. Même si = peut fonctionner aussi, il y a des cas où uniquement := est adapté. Voir section 4.2 pour plus de détail.
2. La séquence des arguments est entourée avec des crochets [ ]
3. Chaque nom d’argument doit être terminé avec un tiret bas x_ dans la séquence
des arguments. Ce tiret bas indique que l’argument peut prendre n’importe quel
nom d’objet et n’importe quel type d’objet. Mathematica indique avec la couleur
verte qu’il s’agit d’un argument d’une fonction. On dit aussi que c’est une variable
muette.
4. Le nom de la fonction doit être conforme aux mêmes règles que pour les variables
(voir en haut), notamment commencer avec une lettre minuscule pour éviter des
confusions avec les fonctions intégrées dans Mathematica.
Voici un exemple d’une fonction avec deux arguments :
Quit
f[x_, y_] := Sqrt[x^2 + y^2]
f[1, 1]
Il est très simple en Mathematica de faire des fonctions composées :
Quit
f[x_] := x^2 + 2
g[x_] := Sin[x] + Cos[x]
f[f[x]]
f[g[x]]
g[f[x]]
2.
Définir f (x) =
√
1 + x dans Mathematica et montrer que :
r
f (f (f (x))) =
3.
1+
q
1+
√
1+x
En utilisant la fonction Simplify[] et une fonction composée, montrer avec Mathematica
que
3 + 2x
1
=
1
5 + 3x
1 + 1+ 1
1
1+ 1+x
8
4.2
= ou :=
Comme avec les variables, on peut définir une fonction soit avec =, soit avec :=
Pour les variables on avait déjà vu que :
. lhs = rhs
rhs est évalué immédiatement et le résultat est copié à lhs
. lhs := rhs
rhs est évalué à chaque fois que lhs est utilisé
Pour bien choisir entre les deux, voici quelques règles générales pour les fonctions :
. Choisir lhs = rhs si lhs est la “valeur finale” de rhs (exemple : f[x_]=1-x^2)
. Choisir lhs := rhs si rhs donne une “commande” ou un “programme” à exécuter à
chaque fois qu’on demande la valeur de lhs (exemple : f[x_]:=Expand[1-x^2])
. Choisir lhs := rhs si f[x] ne peut pas être évalué tant que x n’a pas une valeur particulière, comme pour les fonctions récursives ou les fonctions définies par morceau.
. Choisir lhs := rhs si lhs = rhs donne des messages d’erreur.
. Choisir lhs := rhs en cas de doute.
Voici un exemple pour illustrer la différence entre = et :=
Quit
ex[x_]:=Expand[(1+x)^2]
?ex
iex[x_]=Expand[(1+x)^2]
?iex
ex[y+2]
iex[y+2]
Plus d’information sur le sujet dans l’aide de Mathematica sous :
tutorial/ImmediateAndDelayedDefinitions
4.3
Notation fonctionnelle, Postfix, Prefix et Infix
On peut appeler/utiliser une fonction avec quatre notations différentes :
f[x] notation fonctionnelle standard
f@x
notation Prefix
x//f
notation Postfix
x~f~y
notation Infix
Exemples :
Quit
f@x+y
f@(x+y)
x+y//f
(x+y)//f
4/6//N
{a,b,c}~Join~{d,e}
4.4
Fonctions anonymes ou pures
Il peut être parfois utile de définir une fonction uniquement localement dans une
expression. Ceci est possible en Mathematica avec les fonctions anonymes ou pures. Ces
fonctions n’ont pas de nom, mais on définit uniquement le corps de la fonction. La syntaxe
est un peu particulière. Par exemple la fonction pure équivalent à f (x) = x2 + 4 s’écrit :
9
(#^2 + 4)&
L’argument de la fonction pure est noté # et la fin de la définition de la fonction pure
est marquée avec &. Pour une meilleure lecture, il est préférable d’entourer une fonction
pure avec des parenthèses.
On peut appliquer cette fonction à n’importe quelle donnée en utilisant les crochets
après le signe & :
(#^2 + 4)&[3]
4.
Réécrire ces fonctions pures en fonction classique avec nom et crochets :
PrimeQ[#! + 1] &@4
18//2^#+#&
Si on a plus qu’un seul argument dans √
une fonction pure, on adresse ces arguments
avec #1, #2, ..., exemple pour f (x, y) = x2 + y 2 :
Sqrt[#1^2 + #2^2]&[3,4]
5
Listes
5.1
Introduction
Une liste en Mathematica est une collection ordonnée d’objets. Les objets dans une
liste peuvent être de n’importe quel type et n’ont pas besoin d’être du même type, comme
c’est souvent le cas dans d’autres langages de programmation. Un exemple d’une liste
(accolades sur le clavier : AltGr + 4 ou AltGr + +) :
{4/6, x^2+2, bonjour, 1.01}
La syntaxe est la même que pour un ensemble mathématique, mais les listes se distinguent des ensembles par deux différences majeures :
1. L’ordre des éléments d’une liste est important, tester par exemple : {1, 2} == {2, 1}
2. Le même objet peut être contenu plusieurs fois dans une liste, tester par exemple :
{1, 2, 1} == {1, 2}
5.2
Adressage d’un élément d’une liste
Pour accéder à un élément d’une liste on ne peut pas utiliser les simples crochets,
comme dans le langage C, car ils sont déjà réservés pour la séquence des arguments d’une
fonction. Mais la syntaxe est très similaire : on utilise des doubles crochets.
5.
Tester ces exemples et répondre aux questions suivantes :
a) Quel est le premier indice d’une liste ?
b) Qu’est-ce que signifie un indice négatif ?
c) Comment est-ce qu’on accède à un élément d’une liste qui est elle-même dans une liste ?
d) Comment est-ce qu’on obtient d’une liste plusieurs éléments à la fois ?
10
Quit
liste = {4/6, x^2+2, bonjour, {a, b, c}, 1.01}
liste[[1]]
liste[[5]]
liste[[-1]]
liste[[4,1]]
liste[[4,2]]
liste[[{-2,2}]]
liste[[4,{2,3}]]
Pour plus d’informations sur les listes, entrer ceci dans la barre de recherche de l’aide
de Mathematica : tutorial/ListsOverview
5.3
Fonctions qui génèrent des listes
Regarder l’aide de Mathematica (F1) sur la fonction Range pour comprendre ces
exemples :
Range[10]
Range[3, 11]
Range[2, 17, 4]
Une fonction très utilisée pour générer une liste est la fonction Table, elle prend deux
arguments :
1. Une fonction
2. Une recette similaire à la fonction Range pour générer une suite d’arguments pour
la fonction donnée en premier argument
Exemples :
Quit
Table[2*n+1, {n, 1, 13}]
Table[x^i + y^i, {i, 2, 17, 4}]
6.
La fonction Fibonacci[i] donne le i-ème nombre de Fibonacci. Générer une liste avec
les 30 premier nombres de Fibonacci en utilisant la fonction Table et Fibonacci.
5.4
Appliquer une fonction à chaque élément d’une liste
On peut vouloir appliquer une fonction f à chaque élément d’une liste {a,b,c} pour
obtenir ceci : {f[a],f[b],f[c]}. La plupart des fonctions Mathematica sont listable,
c’est-à-dire on peut appliquer la fonction directement sur une liste, comme par exemple :
Sqrt[{a,b,c}]. Toutes les fonctions arithmétiques sont listable :
1 +
3 *
{a,
1 /
7.
{a, b, c}
{a, b, c}
b, c} ^ 3
{a, b, c}
En utilisant les fonctions Table et Sqrt, démontrer que n(n + 1)(n + 2)(n + 3) + 1 est
toujours un nombre carré pour n entier et positif. On peut se limiter ici pour 1 ≤ n ≤ 10.
Pas toutes les fonctions sont listable, mais on peut toujours appliquer la fonction à
chacun des éléments d’une liste avec la fonction Map :
11
Quit
f[{a, b, c}]
Map[f, {a, b, c}]
f /@ {a, b, c}
Comme l’exemple montre, on peut écrire Map avec une notation Infix raccourcie : /@
5.5
Sélectionner dans une liste
On utilise ici la fonction Select pour sélectionner des éléments d’une liste qui satisfont
certains critères. La fonction Select[list,f] retourne tous les éléments xi d’une liste
pour lesquelles f[xi ] donne True. f doit alors être une fonction booléenne, qui retourne
soit True, soit False. Exemples :
Quit
Select[{1,2,3,4,5,6}, EvenQ]
Select[{1,2,3,4,5,6}, (# > 2)&]
On voit dans le deuxième exemple l’intérêt des fonctions pures (voir en haut) : définir
une fonction localement pour un usage unique.
8.
En utilisant les fonctions Select, PrimeQ, Length, Table essayer de résoudre le problème suivant : Combien de nombres de la forme 3n5 + 11 sont des nombres premiers pour
a) 1 ≤ n ≤ 20
b) 1 ≤ n ≤ 2000
9.
En utilisant une fonction pure et les fonctions Select, PrimeQ, Range essayer de répondre à la question suivante : Pour quels n entre 1 et 1000 la formule 2n + 1 produit un
nombre premier ?
6
Plot
6.1
Introduction
On introduit ici quelques fonctions de base pour tracer des graphes avec Mathematica.
On se limite dans ce TP au cas 2D, sachant que la plupart des fonctions traitées ont leur
équivalent en 3D en Mathematica.
Voici un tableau qui regroupe différents types de fonctions ou questions et les fonctions
“Plot” adapté :
Fonction/Question
Exemple
Commande
f (x)
sin (x) /x
Plot
x = f (t), y = g(t) x = sin(3t), y = cos(4t) ParametricPlot
f (x, y) = 0
x4 − (x2 − y 2 ) = 0
ContourPlot
4
2
f (x, y) ≥ 0
x + (x − 2y ) > 0
RegionPlot
r = f (θ)
r = 3 cos(5θ)
PolarPlot
6.2
6.2.1
Plot
Introduction
Quand on cherche l’aide (F1) sur Plot, on obtient la séquence des ses arguments :
Plot[f, {x, xmin , xmax }]
Plot[{f1 , f2 , ...}, {x, xmin , xmax }]
12
1. En premier argument une fonction f ou plusieurs fonctions dans une liste
2. En deuxième argument il faut lui donner l’intervalle en x
Essayer ces exemples :
Quit
Plot[Sin[x], {x, 0, 2*Pi}]
Plot[Tan[x], {x, -3, 3}]
Plot[Tan[x], {x, -3, 3}, Exclusions -> Cos[x] == 0]
Plot[Tan[x], {x, -3, 3}, Exclusions -> Automatic]
Plot[Tan[x], {x, -3, 3}, Exclusions -> None]
Plot[{Sin[x], Sin[2*x]}, {x, 0, 2*Pi}]
6.2.2
Options de Plot
En plus des deux arguments montrés en haut, on peut changer des options dans Plot
avec une séquence de règles :
Plot[f, {x, xmin , xmax }, option1->value, option2->value, ...]
Regarder le tutoriel de Mathematica sur le sujet en ouvrant le documentation center
(F1) puis dans la barre de recherche :
tutorial/Options
10.
Qu’est-ce que fait l’option Exclusions dans l’exemple en haut ? Tracer f (x) = 1/ sin(x)
sans les discontinuités. Ajouter l’option ExclusionsStyle -> Dotted
11.
(a) Sur le plot de la question précédente, ajouter des labels sur les axes. (b) Refaire un
deuxième plot, mais avec un cadre (Frame) et une grille (Grid). Ici, il faut changer l’option
AxesLabel en FrameLabel. (c) Ajouter AspectRatio -> 1.
6.2.3
Utiliser Plot pour estimer les solutions d’une équation
12.
Montrer avec Plot qu’il y a 11 solutions à l’équation 2 cos2 (2 ∗ x) − sin(x/2) = 1 dans
l’intervalle [0, 3π]. Adapter l’intervalle si nécessaire.
13.
Chercher les solutions de cosh (πx) cos (πx) = −1. Tester différents intervalles pour x et
utiliser après l’option PlotRange pour adapter l’intervalle des valeurs en y.
6.3
Manipulate
Manipulate permet de créer des graphiques ou interfaces interactives. Sa syntaxe est
très similaire à la fonction Table, tester ces deux commandes :
Table[n, {n, 1, 20}]
Manipulate[n, {n, 1, 20}]
Comme avec Table on peut mettre n’importe quel fonction en premier argument,
comme par exemple Plot :
Manipulate[Plot[Sin[n*x], {x, 0, 2*Pi}], {n, 1, 20}]
On peut aussi créer un Manipulate avec plusieurs paramètres à changer :
Manipulate[Plot[Sin[n1*x] + Sin[n2*x], {x, 0, 2*Pi}, PlotRange -> 2],
{n1, 1, 20}, {n2, 1, 20}]
14.
Étudier le comportement du graphe de sin(x) − cos(nx) entre 0 et π quand n change entre
1 à 100.
13
6.4
ListPlot
Quand on veut tracer des données numériques et non une fonction analytique, on peut
utiliser ListPlot ou ListLinePlot :
t = Table[i^2, {i,10}]
ListPlot[t]
ListLinePlot[t]
ListPlot[{t, 2*t}]
Si on a une liste de points (x,y), on peut utiliser ListPlot sans modification :
t = Table[{i^2, i^3}, {i, 10}]
ListPlot[t]
On peut utiliser ListPlot pour illustrer la différence entre = et :=
x=Random[];
ListPlot[Table[x,{200}]]
y:=Random[]
ListPlot[Table[y,{200}]]
6.5
ParametricPlot
Plot trace y en fonction x. Dans un graphe paramétrique chaque point (x,y) dépend
d’un paramètre t par exemple. En regardant sur
tutorial/ParametricPlots
on obtient la syntaxe de ParametricPlot :
ParametricPlot[{fx , fy }, {t, tmin , tmax }]
Tester un exemple avec x = sin(t), y = sin(2t) :
ParametricPlot[{Sin[t], Sin[2*t]}, {t, 0, 2*Pi}]
Dessiner la courbe du “papillon” , découvert par Temple H. Fay :
x[t_] := Sin[t] (E^Cos[t] - 2 Cos[4*t] - Sin[t/12]^5)
y[t_] := Cos[t] (E^Cos[t] - 2 Cos[4*t] - Sin[t/12]^5)
ParametricPlot[{x[t], y[t]}, {t, -50, 50}]
6.6
ContourPlot
Pour trouver tous les points (x,y) qui satisfont l’équation x4 − (x2 − y 2 ) = 0 on peut
utiliser ContourPlot :
ContourPlot[x^4 - (x^2 - y^2) == 0, {x, -1, 1}, {y, -1, 1}]
ContourPlot ou DensityPlot sont utilisées surtout pour afficher des données 3D sur
un plan 2D, comme les lignes de hauteur sur une carte. Essayer ces exemples sur la fonction
f (x, y) = sin(x) sin(y) :
ContourPlot[Sin[x]*Sin[y], {x, -2, 2}, {y, -2,
ColorFunction -> ColorData["Rainbow"],
Plot3D[Sin[x]*Sin[y], {x, -2, 2}, {y, -2, 2},
ColorFunction -> ColorData["Rainbow"],
DensityPlot[Sin[x]*Sin[y], {x, -2, 2}, {y, -2,
ColorFunction -> ColorData["Rainbow"],
14
2},
PlotLegends -> Automatic]
PlotLegends -> Automatic]
2},
PlotLegends -> Automatic]
6.7
RegionPlot
Pour marquer la région sur le plan 2D où les points (x,y) satisfont une inégalité, comme
x + (x − 2y 2 ) > 0, on peut utiliser RegionPlot :
4
RegionPlot[x^4 + (x - 2*y^2) >= 0, {x, -2, 2}, {y, -2, 2}]
Ou encore :
RegionPlot[x^2 + y^2 < 1, {x, -1, 1}, {y, -1, 1}, Mesh -> 10,
MeshShading -> {{Automatic, None}, {None, Automatic}},
ColorFunction -> "DarkRainbow"]
6.8
PolarPlot
Pour faire des graphes en coordonnées polaires, il existe la fonction PolarPlot. Exemple
appliqué à r = 3 cos(6θ) :
PolarPlot[3*Cos[6*t], {t, 0, 2*Pi}]
15
© Copyright 2024 ExpyDoc
