Initiation à Mathematica: Compléments

Le but de ce chapitre est d’introduire quelques fonctions supplémentaires permettant de réaliser de la programmation légèrement plus avancée et de présenter certaines applications de Mathematica aux chapitres du cours de mathématiques de base.

§    Quelques fonctions supplémentaires

§ -   Module

Lorsqu’on désire que plusieurs instructions soient effectuées successivement par Mathematica sans que les variables de ces instructions n’entrent en conflit avec les variables du reste du document, on peut regrouper ces commandes dans une structure appelée Module. 
La structure de Module est la suivante: 

Module[
	{var1,var2,...},
	expr1;
	expr2;
	...
]

Les variables var1,var2,... sont les variables locales du module, c’est-à-dire qu’il s’agit de variables utilisées uniquement à l’intérieur du module. Si une de ces variables a déjà été défini à l’extérieur du module, Mathematica en fait abstraction à l’intérieur du module et inversement, Mathematica ne tiendra pas compte des définitions de ces variables faites à l’intérieur du module lorsqu’on se trouve à l’extérieur du module. 
Les expressions expr1;expr2;... sont les instructions à effectuer par Mathematica; Mathematica n’affichera que le résultat de l’évaluation de la dernière expression. Attention: il est important de terminer chaque ligne sauf la dernière par le symbole ;.
Si on souhaite créer un output contenant plusieurs éléments, on peut aisément le faire en les rassemblant dans une liste.

Lorsque l’on a défini un module, il est indispensable de le tester dans des situations connues afin de s’assurer qu’il fonctionne bien comme prévu.

Dans le cas de modules plus complexes, il est utile de ne pas définir directement le module voulu, mais de commencer par un module plus simple et d’ajouter des complications à fur et à mesure en le testant à chaque étape.

Exemple 1

Connaissant le nombre de côtés n d’un polygone régulier ainsi que le rayon r de son cercle circonscrit, on souhaite calculer le périmètre de ce polygone. Définissez un module perimetrePolygone qui calcule ce périmètre en fonction de n et r.

perimetrePolygon[r_,n_]:=Module[
{a,c},
a=((2Pi)/n);   (* angle au centre *)
c=2 r Sin[a/2];    (* côté *)
n c   (* Output: le perimètre *)
]

perimetrePolygon[x,6]   (* test: perimètre d'un hexagone inscrit dans un cercle de rayon x *)

Nous pouvons constater qu’aucune valeur n’a été affecté aux variables a et c en dehors du module:

a
c

Modifiez le module de telle sorte qu’on obtienne le périmètre ainsi qu’une représentation graphique du polygone inscrit dans le cercle comme output.

perimetreImagePolygon[r_,n_]:=Module[
{a,c,image},
a=((2Pi)/n);   (* angle au centre *)
c=2 r Sin[a/2];    (* côté *)
image=Graphics[{Circle[{0,0},r],Red,Polygon[CirclePoints[r,n]]}];
{n c,image}   (* output: liste contenant le périmètre et la représentation graphique *)
]

perimetreImagePolygon[2,6]   (* Test avec l'hexagone inscrit dans un cercle de rayon 2 *)

Et on a bien sûr la possibilité de n’afficher qu’un seul élément de l’output:

perimetreImagePolygon[2,6][[2]]   (* on extrait l'image de l'output *)

Clear[perimetrePolygon,perimetreImagePolygon]

§ -   Print

Lorsque l’on crée des modules plus sophistiqués, il peut être utile d’afficher les valeurs de certaines variables locales à un moment précis de l’exécution des instructions afin de chercher une éventuelle erreur de programmation. La commande Print permet de le faire:

Exemple

perimetrePolygon[r_,n_]:=Module[
{a,c},
a=((2Pi)/n);   (* angle au centre *)
Print[a];
c=2 r Sin[a/2];    (* côté *)
n c   (* perimètre *)
]

perimetrePolygon[x,6]

§ -   If et Which

Dans certaines situations on souhaite spécifier sous quelles conditions une instruction (ou une suite d’instructions) doit être exécutée. Les commandes suivantes permettent de le faire:

If[condition,t,f] retourne l’expression t si l’expression condition est vraie et f si elle est fausse.

Which[condition1,expression1,condition2,expression2,...] retourne la première expression pour laquelle la condition est vraie et ne retourne rien si toutes les conditions sont fausses.

Exemple 2

Modifiez le module perimetrePolygon de l’exemple 1 de telle sorte qu’il retourne un message d’erreur lorsque l’utilisateur donne un rayon négatif.

perimetrePolygonMessage[r_,n_]:=Module[
{a,c},
If[r≥0,
(* Instructions à exécuter lorsque r≥0: *)
a=((2Pi)/n);   (* angle au centre *)
c=2 r Sin[a/2];    (* côté *)
n c ,  
(* Instruction à exécuter lorsque r<0: *)
"ERREUR: Le rayon doit être positif"
]
]

(* Tests: *)
perimetrePolygonMessage[2,6]
perimetrePolygonMessage[-2,6]

Clear[perimetrePolygonMessage]

Exercices

Exercice -

Nous considérons que la liste d’instructions ci-dessous a été évaluée par Mathematica:

Clear[a,b,c,d,f,x]
a=3;
b=10;
f[x_]:=Module[
{a,d},
a=100;
c=1000;
d=10000;
x+a+b
]

Devinez ce que retourne Mathematica lors de l’évaluation de {a,b,c,d}. Expliquez.

Devinez ce que retourne Mathematica si vous évaluez ensuite f[1]. Expliquez.

Devinez ce que retourne Mathematica si vous évaluez finalement f[{a,b,c,d}]. Expliquez.

Devinez ce que retourne Mathematica si vous évaluez d’abord c=2, puis f[c]. Expliquez.

Exercice -

Créez un module aireImagePolygone[r_,n_,couleur_] qui, pour r, n, et couleur donnés par l’utilisateur, retourne l’aire du polygone à n côtés inscrit dans un cercle de rayon r ainsi qu’une représentation graphique du polygone avec sons cercle circonscrit, la couleur du polygone pouvant être choisi par l’utilisateur.
Testez votre module pour un hexagone bleu inscrit dans un cercle de rayon 2.

Indication: Pour la représentation du polygone, utilisez la commande Polygon.

Exercice -

Définissez une fonction appreciation[note_] qui retourne insuffisant si note est inférieure à 4 et suffisant sinon. Définissez cette fonction une fois à l’aide de la commande If et une fois à l’aide de la commande Which.

Modifiez les deux fonctions de la partie précédente de telle sorte que le message d’erreur “la note doit être une nombre entre 0 et 6” est affiché si on applique la fonction à un nombre trop grand ou trop petit.

Exercice -

Soit la fonction f(x)=2sin(x)-x.
Tracez le graphe de cette fonction en y ajoutant en point à la position de chacun de ses zéros se trouvant entre a=-3 et b=3.
Prenez garde à définir vous différentes variables de telle façon à ce qu’une modification des définitions de f, a ou b modifie automatiquement le résultat lors d’une réévaluation du cahier.

Définissez un module grapheZeros[g_,{min_,max_}] qui trace le graphe d’une fonction g entre min et max en y ajoutant un point à la position de chacun de ses zéros. Testez votre module avec différentes fonctions dont vous connaissez les zéros.

Définissez un module grapheZeros2[g_,{min_,max_}] dont l’output contient la même représentation graphique que le module grapheZeros ainsi que les valeurs des différents zéros de g en code à virgule.

Définissez un module grapheZeros3[g_,{min_,max_}] qui retourne le même graphe que grapheZeros2 ainsi que les valeurs des zéros de g situés dans l’intervalle [min;max] lorsque g possède des zéros dans cet l’intervalle. Si g ne possède pas de zéros dans cet intervalle, le module retournera uniquement le graphe de g agrémenté du message “g ne possède pas de zéros dans l’intervalle donné” sur fond jaune.

Indication: la commande Text permet d’afficher un texte et “fond” se dit “background” en anglais.

Exercice -

Déterminez la fonction cubique dont le graphe passe par les points (-1;1), (0;-1), (1;1) et (2;-1). Tracez le graphe de cette fonction et positionnez les points en rouge sur le graphe.

Définissez un module cubique[listePoints_] qui détermine l’équation de la fonction cubique dont le graphe passe par quatre points donnés par l’utilisateur dans listePoints et trace le graphe de la fonction ainsi que les quatre points dans un intervalle approprié. Les points doivent être rouges et bien visibles. L’output sera constitué du polynôme cubique et de la représentation graphique.

§ 	Polynômes et fonctions rationnelles

§ -   Fonctions définies par morceaux

Définition à l’aide de Piecewise

Mathematica offre une commande spécialement dédiée à la définition d’une fonction définie par morceaux: Piecewise[{{val1,cond1},{val2,cond2},...}]

Exemple 1

Soit la fonction f définie sur ℝ avec  f(x)=({{{, ({{(x^2), si x≤1,}, {-x, si x>1.}})}})

On peut la définir de la manière suivante à l’aide de Piecewise:

f[x_]:=Piecewise[{{x^2,x≤1},{-x,x>1}}]

On peut contrôler qu’il s’agit bien de la fonction voulue:

Map[f,{-2,1,3}]

Plot[f[x],{x,-4,5}]

Si nous voulons mettre en évidence graphiquement où est situé f(1), nous devons le faire manuellement:

Plot[f[x],{x,-4,5},
(* On prescrit la couleur du graphe afin de pouvoir choisir la même couleur pour les points: *)
PlotStyle->Blue,   
Epilog->{
(* On place un point plein à l'endroit de l'image de 1: *)
Blue,PointSize[0.02],Point[{1,1}],
(* Afin d'obtenir le rendu habituel d'un point vide, on superpose un point bleu d'un point blanc plus petit: *)
Blue,PointSize[0.02],Point[{1,-1}],
White,PointSize[0.01],Point[{1,-1}]
}
]

Clear[f]

Exemple 2

Attention néanmoins si la fonction n’est pas définie sur ℝ, par exemple f(x)=({{{, ({{(x^2), si  -2≤ x≤1,}, {-x, si x>1.}})}})

f[x_]:=Piecewise[{{x^2,-2≤ x≤1},{-x,x>1}}]
Map[f,{-3,-2,4}]
Plot[f[x],{x,-4,5},PlotStyle->{Red,Thickness[0.01]}]

Clear[f]

Nous constatons que Piecewise attribue par défaut la valeur 0 aux domaine où aucune valeur n’a été spécifiée. Pour y remédier, on y attribue la valeur Null:

f[x_]:=Piecewise[{{x^2,-2≤ x≤1},{-x,x>1}},Null]
Map[f,{-3,-2,4}]
Plot[f[x],{x,-4,5},PlotStyle->{Red,Thickness[0.01]}]

Clear[f]

Méthodes alternatives pour définir des fonctions par morceaux: If, Which, /;

On aurait également pu utiliser les commandes If ou Which ou la notation raccourcie /;, comme illustré dans les exemples ci-dessous.

Exemple 3

On souhaite à nouveau définir la fonction  f(x)=({{{, ({{(x^2), si  -2≤ x≤1,}, {-x, si x>1.}})}})

Définition à l’aide de la commande If:

Clear[f]
f[x_]:=If[-2≤x≤1,x^2,If[x>1,-x]]
Map[f,{-3,-2,4}]
Plot[f[x],{x,-4,5},PlotStyle->{Red,Thickness[0.01]}]

Définition à l’aide de la commande Which:

Clear[f]
f[x_]:=Which[-2≤x≤1,x^2,x>1,-x]
Map[f,{-3,-2,4}]
Plot[f[x],{x,-4,5},PlotStyle->{Red,Thickness[0.01]}]

Définition à l’aide de /;

Clear[f]
f[x_]:=x^2/;-2≤x≤1
f[x_]:=-x/;x>1
Map[f,{-3,-2,4}]
Plot[f[x],{x,-4,5},PlotStyle->{Red,Thickness[0.01]}]

Nous pouvons constater qu’avec cette méthode, Plot gère mal le le comportement en x=1. Afin d’obtenir un meilleur rendu, nous pouvons recourir à une astuce: au lieu d’afficher le graphe de la fonction f, on affiche le graphe d’une fonction g égale à f à l’exception près qu’elle n’est pas définie dans un petit intervalle autour de la valeur problématique:

g[x_]:=f[x]/;x<0.99||x>1.01
Plot[g[x],{x,-4,5},PlotStyle->{Red,Thickness[0.01]}]

Clear[f,g]

La valeur absolue

La valeur absolue pourrait être définie par morceaux, mais elle est déjà implémentée dans Mathematica. Il s’agit de la fonction Abs.

§ -   Division euclidienne

Les fonctions PolynomialQuotient et PolynomialRemainder permettent d’obtenir le quotient, respectivement le reste de la division euclidienne de polynômes. Les arguments sont le dividende, le diviseur et la variable.

Exemple

On détermine le quotient et le reste de la division (((x^2) - 3x + 5)/(x - 2)):

PolynomialQuotient[x^2-3x+5,x-2,x]
PolynomialRemainder[x^2-3x+5,x-2,x]

Pour rappel: ceci signifie que (x^2) - 3x + 5 = (x-1)(x-2) +5, c’est-à-dire que (((x^2) - 3x + 5)/(x - 2))=x-1+(3/(x-2)).

§ -   Limites

L’instruction Limit[f[x],x->a] calcule la limite (lim_(x->a))f(x), où a peut être un nombre, une expression algébrique, Infinity (∞) ou -Infinity (-∞). 
Lorsque a est fini, Limit[f[x],x->a] détermine la limite lorsque x s’approche de a par la droite; on obtiendrait le même résultat par Limit[f[x],x->a,Direction->-1]. Si on souhaite calculer la limite à gauche, il faut le spécifier: Limit[f[x],x->a,Direction->1].

Exemple

Déterminez le comportement de la fonction f(x)=(x/(2x-4)) au bords de son domaine de définition.

Puisque (Subscript[D, f])=ℝ\{2}, on commence par calculer les limites de f(x) lorsque x tend vers 2:

f[x_]:=(x/(3x-6))
Limit[f[x],x->2,Direction->1]
Limit[f[x],x->2,Direction->-1]

La fonction f possède donc une asymptote verticale d’équation x=2 du type “puits infini”.

On détermine ensuite le comportement de f à l’infini:

Limit[f[x],x->-Infinity]
Limit[f[x],x->Infinity]

La fonction f admet donc une asymptote d’équation y=(1/3) à gauche et à droite.

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

Depuis Mathematica 11, les problèmes d’affichage des fonctions comportant des asymptotes verticales ont été résolus et il est possible de spécifier les style d’affichage de ces asymptotes à l’aide de ExclusionsStyle:

Plot[f[x],{x,-5,5},ExclusionsStyle->Dashed]

Il faut en revanche ajouter l’asymptote horizontale à la main:

xMin=-5;
xMax=5;
Plot[f[x],{x,xMin,xMax},ExclusionsStyle->Dashed,Epilog->{Dashed,Line[{{xMin,1/3},{xMax,1/3}}]}]

Deuxième possibilité: on ajoute l’asymptote horizontale en tant que graphe d’une fonction:

Plot[{f[x],(1/3)},{x,xMin,xMax},ExclusionsStyle->Dashed,PlotStyle->{Automatic,Dashed},PlotRange->{-2,2}]

Clear[f,xMin,xMax]

Exercices

Exercice -

Tracez le graphe de la fonction f(x)=({{{, ({{-1, si x≤-1,}, {(x^2), si -1<x<1,}, {1, si x≥1.}})}}) 
Pour ce faire, procédez de quatre manières différentes.

Exercice -

Tracez le graphe de la fonction g(x)=|sin(x)| pour x∈[-4π;4π] en graduant l’axe des abscisses tous les (π/2).

Exercice -

Jusqu’à la version 10, Mathematica gère mal l’affichage du graphe d’une fonction rationnelle: Mathematica calcule les coordonnées d’un grand nombre de points puis relie ceux-ci. Aux abscisses où f possède une asymptote verticale, ceci donne lieu à une droite verticale étant interprétée comme faisant partie du graphe, alors qu’une asymptote verticale n’en fait bien sûr pas partie. Pour éviter ce problème, il suffit de ne pas définir la fonction dans un petit intervalle autour de la valeur interdite. Si par exemple -2 est une valeur interdite, on définit f uniquement sur ℝ\]-2.1;-1.9[.
Dans Mathematica 11, le problème a été corrigé et on peut spécifier la représentation de l’asymptote à l’aide de la commande ExclusionsStyle (voir l’exemple du paragraphe sur les limites).

Tracez le graphe de la fonction f(x)=(x/(x-1)) à l’aide de Mathematica 10 en tenant compte de la remarque ci-dessus, puis à l’aide de Mathematica 11. Dans les deux cas, affichez l’asymptote verticale en traitillés.

Exercice -

On considère la fonction f(x)=((sin(x))/x).

Calculer (lim_(x->-∞))f(x) et  (lim_(x->+∞))f(x) et interprétez les résultats graphiquement.

Calculez  (lim_(x↑0))f(x) et  (lim_(x↓0))f(x) et interprétez les résultats graphiquement.

Affichez le graphe de f en y ajoutant les interprétations graphiques trouvées ci-dessus.

Exercice -

Rappelez et justifiez comment la division euclidienne permet de déterminer l’éventuelle asymptote affine d’une fonction rationnelle.

On considère la fonction f(x)=(((x^2)-2x+1)/(x-3)).

Déterminez l’équation de chacune des asymptotes de la fonction f.

Illustrez votre résultat graphiquement.

Exercice -

Définissez un module asymptoteAffine[f_,{a_,b_}] dont l’argument f est une fonction rationnelle. Le module décidera si la fonction f admet une asymptote affine. Si tel est le cas, il fournira un output contenant l’équation de cette asymptote ainsi qu’une représentation graphique de f sur l’intervalle [a;b] avec son asymptote affine en traitillés. Si la fonction f n’admet pas d’asymptote affine, le module fournira comme output uniquement le graphe de f avec le message “la fonction f n’admet pas d’asymptote affine” sur fond jaune.

Indications:

Commencez par créer un module qui fonctionne lorsque l’asymptote affine existe.

La commande Exponent permet de déterminer le degré d’un polynôme.

Exercice -

Définissez des fonctions booléennes fctPaireQ[f_] et fctImpaire[f_] qui déterminent si la fonction f est paire, respectivement impaire.

Indication: Travaillez avec Reduce et TrueQ.

Utilisez les fonctions précédentes pour déterminer la parité des fonctions f(x)=sin(x)cos(10x) et g(x)=((sin(x)+1)^(1/5)).

Indication: Pour la racine cinquième, il est nécessaire d’utiliser la commande Surd car Mathematica calcule la racine cinquième de nombres négatifs dans les nombres complexes si on travaille avec des exposants rationnels. Par exemple l’expression (((-32))^(1/5)) retourne 2(((-1))^(1/5)). Si on demande à Mathematica de développer cette expression (avec la fonction ComplexExpand), on peut constater que ce nombre possède bien une partie imaginaire.

Définissez une fonction pariteFct[f_] qui retourne la réponse “paire” si f est paire, la réponse “impaire” si f est impaire et la réponse “ni paire, ni impaire” sinon.

§ 	Composition de fonctions et fonction réciproque

§ -   Composition de fonctions

Une composition de deux fonctions se réalise de manière tout à fait naturelle à l’aide de Mathematica:

Exemple

Déterminez l’équation de la fonction h=f∘g pour g(x)=(Sqrt[x+3]) et f(x)=(4/((x^2)-1)).

f[x_]:=(4/((x^2)-1))
g[x_]:=Sqrt[x+3]
h[x_]:=f[g[x]]
h[x]

Rappel: La détermination du domaine de définition d’une composition de deux fonctions doit se faire avant de simplifier la nouvelle équation.
Afin qu’un nombre x appartienne au domaine de définition de h=f∘g, les deux étapes de la composition x-> g(x)-> f(g(x)) doivent être réalisables, c’est-à-dire x doit remplir deux conditions:

x∈(Subscript[𝒟, g])   et   g(x)∈(Subscript[𝒟, f]).

Pour les fonctions définies ci-dessus, (Subscript[𝒟, g])=[-3;+∞[ et (Subscript[𝒟, f])=ℝ\{-1;1}. On peut facilement déterminer les valeurs exclues du domaine de définition de h en raison de la deuxième étape:

Reduce[g[x]^2-1==0]

Ainsi, (Subscript[𝒟, h])=[-3;+∞[ \ {-2}.

Nous pouvons constater que Mathematica gère mal le domaine de définition d’une composition:

h[-5]

FunctionDomain[h[x],x]

Clear[f,g,h]

§ -   Fonction réciproque

Mathematica propose une commande permettant de déterminer la réciproque d’une fonction bijective: Il s’agit de la commande InverseFunction

Exemple

Déterminez la fonction réciproque de la fonction bijective f(x)=3x+5.

f[x_]:=3x+5
rf[x_]:=InverseFunction[f][x]
rf[x]

Clear[f,rf]

Exercices

Exercice -

On considère la fonction g(x)=((x-1)/(x+2)).

Déterminez l’ensemble de départ A et l’ensemble d’arrivée B tels que la fonction g:A-> B soit bijective.

Déterminez la fonction réciproque h de g sans utiliser la commande InverseFunction.

Montrez que la fonction h de l’item précédent est bien la réciproque de g en montrant que h∘g(x)=x et g∘h(y)=y.

Définissez une fonction reciproque[f_] qui retourne l’équation de la fonction réciproque d’une fonction bijective f.

§ 	Fonctions exponentielles et logarithmes

§ -   Logarithmes

Calculer un logarithme se fait à l’aide de la commande Log[b,x] ou b est la base et x est l’argument. Si on ne précise pas la base, Mathematica calcule par défaut le logarithme naturel ln. 
On peut constater que puisque Mathematica calcule avec des nombres complexes, des arguments strictement négatifs ne sont pas interdits.

Exemples 1

Log[3,(1/81)]

Log[E]

Log[-3]

§ -   Fonctions exponentielles

Les fonctions exponentielles se définissent de manière tout à fait naturelle:

Exemple 2

f[x_]:=(2)^x
Plot[f[x],{x,-4,3}]

La fonction exponentielle en base e, c’est-à-dire la fonction exp, est déjà définie dans Mathematica, mais on peut également obtenir l’expression (e^x) en utilisant le nombre e (qui s’écrit évidemment en majuscule dans Mathematica...):

Exp[x]
E^x

Lorsque nous résolvons des équations exponentielles, nous devons nous rappeler que par défaut, Mathematica calcule avec des nombres complexes. Si nous ne nous intéressons qu’aux solutions réelles d’une équation, nous devons le préciser.

Exemple 3

Reduce[2^x==3,x]
Solve[2^x==3,x]

Pour n’obtenir que la solution réelle:

Reduce[2^x==3,x,Reals]
Solve[2^x==3,x,Reals]

Mathematica donne la solution en utilisant le logarithme naturel ln que Mathematica désigne par Log. Mais depuis le chapitre sur les fonctions exponentielles et logarithmes du cours de mathématiques de base nous savons que ((ln(3))/(ln(2)))=(Subscript[log, 2])(3),

Exercices

Exercice -

A l’aide de Mathematica, résolvez les équations suivantes dans ℝ après avoir déterminé leurs domaines de définition. Donnez à chaque fois l’ensemble des solutions sous forme exacte (si possible) et sous forme arrondie à 3 chiffres significatifs.

(e^x)=(15/(e^(2x)))

8·(2^( 3x))-(2^(2x))-40·(2^x)+5=0

ln((x^2)-81)=2

(Subscript[log, 5])(((x+2)/(10-x)))+(Subscript[log, 5])(x-1)=(Subscript[log, 5])((x^2))-1

log((Subscript[log, (1/10)])(x))=2

§ 	Fonctions trigonométriques

Nous avons déjà utilisé les fonctions trigonométriques Sin, Cos et Tan dans Mathematica, tout en constatant que par défaut, Mathematica calcule en radians.

Mathematica est capable de résoudre des équations trigonométriques:

Exemples

Reduce[Cos[x]==1/2,x,Reals]
Solve[Cos[x]==1/2,x,Reals]

Mathematica nous donne bien les deux familles infinies de solutions: S={-(π/3)+k·2π|k∈ℤ}⋃{(π/3)+k·2π|k∈ℤ}.

Nous pouvons déterminer des solutions particulières en choisissant une valeur précise de C[1] dans les solutions données par Mathematica:

Solve[Cos[x]==1/2,x,Reals]/.C[1]->1

Mais Mathematica ne nous donne pas toujours l’ensemble des solutions sous la forme la plus simple:

Reduce[Sin[x]==0,x,Reals]

Dans ce cas-ci nous pouvons regrouper les deux familles de solutions: S={k·π|k∈ℤ}.

Exercices

Exercice -

Déterminez l’ensemble des solutions de l’équation   sin(x)(cos^2)(x)=(1/4)sin(x).

Représentez le cercle trigonométrique dans son repère orthonormé en y ajoutant les points associés aux solutions de l’équation de la partie 1 bien visibles en rouge. A l’aide de cette représentation, déterminez l’ensemble des solutions sous sa forme la plus simple.

§ 	Suites et séries

§ -   Suites

Intuitivement, une suite numérique est une liste ordonnée de nombres réels  (Subscript[a, 0]), (Subscript[a, 1]), (Subscript[a, 2]), (Subscript[a, 3,]) ...

Elle peut être finie (c’est-à-dire comporter un nombre fini d’éléments) ou infinie (c’est-à-dire comporter un nombre infini d’éléments). Mais on peut définir la notion de suite de manière plus précise:

Définition:

Une suite numérique est une fonction

a:  ℕ  ->  ℝ                          
n  ↦  a(n) = (Subscript[a, n])

Le nombre (Subscript[a, n]) est appelé le n-ième terme de la suite. La suite entière est dénotée par (Subscript[((Subscript[a, n])), n ∈ ℕ]) ou simplement ((Subscript[a, n])).

L’expression algébrique décrivant le terme (Subscript[a, n]) en fonction de n s’appelle terme général de la suite.

Parfois une suite peut être décrite par une relation de récurrence, c’est-à-dire par le procédé permettant de calculer un terme à partir de son (ou ses) prédécesseur(s):

(Subscript[a, 0]) (valeur initiale),   (Subscript[a, n+1])=f((Subscript[a, n])) pour n≥ 0.

Exemple

Soit (Subscript[((Subscript[a, n])), n ∈ ℕ]) la suite des nombres pairs supérieurs ou égaux à 0, c’est-à-dire

(Subscript[a, 0])=0, (Subscript[a, 1])=2, (Subscript[a, 2])=4, (Subscript[a, 3])=6,...

Le terme général de cette suite est   (Subscript[a, n])=2n.

La relation de récurrence permettant de définir cette suite est   (Subscript[a, 0])=0,   (Subscript[a, n+1])=(Subscript[a, n])+2  pour n≥0.

§ -   Calcul des termes d’une suite à l’aide de Mathematica

Lorsque la suite est définie par son terme général, on peut facilement déterminer autant de termes que souhaité à l’aide de la fonction Table:

Exemple

Déterminez les 10 premiers termes de la suite (Subscript[((Subscript[a, n])), n ∈ ℕ]) avec (Subscript[a, n])=2n.

suite=Table[2n,{n,0,9}]

Nous pouvons également représenter ces termes graphiquement à l’aide de ListPlot. Attention néanmoins: si nous ne spécifions pas les abscisses, Mathematica considère que la première abscisse vaut 1:

ListPlot[suite]

Mais nous pouvons facilement y remédier:

points=Transpose[{Range[0,9],suite}];
ListPlot[points]

Clear[suite,points]

Si la suite est défini par une relation de récurrence, nous pouvons travailler avec la fonction NestList que nous connaissons déjà: nous avons vu que la fonction NestList[f,expr,n] retourne la liste des résultats de l’application de la fonction f à expr de 0 à n fois. Si nous nous intéressons uniquement au dernier terme, nous utilisons Nest.

Exemple 1

Nous considérons la suite (Subscript[((Subscript[a, n])), n ∈ ℕ]) définie par récurrence de la manière suivante:

(Subscript[a, 0])=3,      (Subscript[a, n+1])=((2+((Subscript[a, n])^2))/(2(Subscript[a, n])))   pour n≥0.

On a donc (Subscript[a, 1])=((2 + ((Subscript[a, 0])^2))/(2(Subscript[a, 0])))=((2 + (3^2))/(2·3))=(11/6),   (Subscript[a, 2])=((2+((Subscript[a, 1])^2))/(2 (Subscript[a, 1])))=((2+(11/6))/(2·(11/6)))=(193/132)   et ainsi de suite, chaque terme se calcule à partir du précédent.

Donnez la liste des termes (Subscript[a, 0]) jusqu’à (Subscript[a, 10]) puis définir la fonction a[n_] donnant la valeur du terme (Subscript[a, n]) (donner les résultats sous forme de code à virgule).

succ[x_]:=((2+x^2)/(2x))   (* Fonction permettant de calculer le successeur d'un terme x *)
NestList[succ,3.,10]   (* génération des termes d'indices 0 à 10 *)

a[n_]:=Nest[succ,3.,n]   (* Fonction déterminant uniquement le terme d'indice n *)
a[4]   (* test *)

Plutôt que de spécifier le nombre de fois qu’une fonction doit être appliquée à une expression, on peut imposer une condition sur le nombre d’applications. Ceci se fait avec la fonction NestWhile[f,expr,test] qui applique la fonction f à l’expression expr tant que (“while” en anglais) la valeur de la fonction booléenne test appliquée au dernier résultat est vrai. Mathematica retourne alors le résultat de la dernière application de f. Si on souhaite connaître tous les termes calculés, Mathematica propose la fonction NestWhileList. Ces deux fonctions nous seront par exemple utiles dans le chapitre suivant lorsque nous allons définir des suites permettant d’approcher les solutions d’une équation: nous allons arrêter la procédure lorsque la qualité de l’approximation sera suffisamment bonne.

Exemple 2

Déterminez le premier terme qui est inférieur à 2 dans la suite (Subscript[((Subscript[a, n])), n ∈ ℕ]) définie de la façon suivante:

(Subscript[a, 0])=1000,      (Subscript[a, n+1])=(Sqrt[(Subscript[a, n])]).

(* Critère d'arrêt: x<2; on doit continuer tant que x≥2 *)
crit[x_]:=x≥ 2   
NestWhile[Sqrt,1000.,crit]

NestWhileList[Sqrt,1000.,crit]

Clear[crit]

§ -   Limite d’une suite

Dans le cas d’une suite définie par son terme général, le calcul de sa limite se fait de la même façon que pour le calcul de la limite à l’infini d’une fonction (ce qui est normal puisqu’une suite n’est rien d’autre qu’une fonction définie sur ℕ).

Dans le cas où la suite est définie par récurrence, c’est-à-dire en donnant une valeur initiale (Subscript[a, 0]) et une fonction f telle que (Subscript[a, n+1])=f((Subscript[a, n])), on ne peut pas utiliser la commande Limit. Mais si la fonction f est continue, la limite L de la suite (si elle existe) est un point fixe de la fonction f, c’est-à-dire que

L=f(L)         car   (Subscript[a, n+1])=f((Subscript[a, n]))   ⟹  (lim_(n -> +∞))(Subscript[a, n+1])= (lim_(n -> +∞))f((Subscript[a, n]))

La fonction FixedPoint permet d’obtenir une estimation numérique de la valeur de la limite. La fonction FixedPointList donnera en plus tous les termes avant l’approximation de la limite. Il ne faut pas oublier de faire travailler Mathematica avec des nombres en code à virgule lors de l’utilisation de FixedPoint ou FixedPointList, sinon le point fixe ne sera jamais atteint.
Si un tel calcul ne s’arrête pas, il est parfois possible de forcer l’arrêt en sélectionnant Abort evaluation dans le menu Evaluation.

ATTENTION!!! L’évaluation de FixedPoint ou FixedPointList peut saturer la mémoire de l’ordinateur lorsque la limite n’existe pas ou que la suite converge trop lentement. Parfois il est impossible de forcer l’arrêt. Avant d’évaluer ces fonctions, mieux vaut se convaincre que la suite converge vraiment, soit par un raisonnement mathématique, soit en calculant d’abord un nombre déterminé de termes. Et avant chaque évaluation de ses deux fonctions, on s’assure qu’on a bien sauvegardé son cahier!!!

Exemple

Déterminer une approximation de la limite de la suite (Subscript[((Subscript[a, n])), n ∈ ℕ]) définie par

(Subscript[a, 0])=1000,      (Subscript[a, n+1])=(Sqrt[(Subscript[a, n])]).

a=FixedPointList[Sqrt,1000.]

Pour mieux comprendre la situation, affichons toutes les décimales calculées par Mathematica:

NumberForm[a,16]

Nous constatons que Mathematica calcule des termes de la suite jusqu’à ce que la différence de deux termes consécutifs soient égaux (à la précision par défaut de 16 chiffres significatifs près). Nous en déduisons que (lim_(n -> +∞))(Subscript[a, n])=1.

Si on avait utilisé la commande FixedPointList[Sqrt,1000], c’est-à-dire qu’on avait donné la valeur initiale sous forme exacte, Mathematica aurait produit une liste de la forme suivante (voici les 20 premiers termes):

NestList[Sqrt,1000,20]

Puisque tous les termes sont différents, FixedPointList ne s’arrêterait jamais et il aurait fallu interrompre l’évaluation manuellement (ce qui peut s’avérer impossible si la mémoire de l’ordinateur est complètement saturée).

§ -   Sommes et séries

La fonction Sum[a[k],{k,min,max}] retourne la valeur de la somme (∑_(k=min)^max)(Subscript[a, k]). Il est à noter que max peut prendre la valeur Infinity, ce qui permet de déterminer la série correspondante. Pour calculer la valeur d’une somme il est aussi possible d’utiliser le symbole de sommation se trouvant dans une des palettes.

Exemple

Calculer la série 1-(1/2)+(1/3)-(1/4)+⋯

Sum[(((-1)^(k+1))/k),{k,1,Infinity}]

Le résultat signifie que la série harmonique alternée converge vers ln(2).

La fonction Sum peut seulement être appliquée lorsque le terme général de la suite est connue. Si on dispose uniquement d’une relation de récurrence, il est toujours possible de calculer des sommes finies, par exemple à l’aide de la fonction Total:

Exemple

Calculer la somme des 20 premiers termes de la suite définie par la relation de récurrence suivante:

(Subscript[a, 0])=2,   (Subscript[a, n+1])=((Subscript[a, n])/2)+3

On commence par créer la suite des 20 premiers termes:

succ[x_]:=(x/2)+3
suite=NestList[succ,2,19];

Ensuite on calcule leur somme:

Total[suite]

Une deuxième possibilité serait d’utiliser Apply et Plus (comme nous avions vu précédemment):

Apply[Plus,suite]

Clear[succ,suite]

Exercices

Exercice -

Pour chacune des suites suivantes, déterminez la relation de récurrence ainsi que le terme général. Déterminez ensuite les 15 premiers termes en utilisant Table et en utilisant NestList et calculez la limite de chacune des deux suites.

La suite (Subscript[((Subscript[a, n])), n ∈ ℕ]) décrit le nombre d’allumettes nécessaires à la construction de chacune des figures de la séquence ci-dessous:

La suite  (Subscript[((Subscript[c, n])), n ∈ ℕ]) décrit la mesure des côtés des carrés grisés (Subscript[C, n]) représentés ci-dessous:

Exercice -

Soit la suite (Subscript[((Subscript[a, n])), n ∈ ℕ]) définie de la façon suivante:

(Subscript[a, 0])=1,      (Subscript[a, n+1])=((2+2((Subscript[a, n])^3))/(3((Subscript[a, n])^2)))

Calculez (Subscript[a, 10]) avec une précision de 15 chiffres significatifs.

Représentez graphiquement les 10 premiers termes de cette suite.

Déterminez une estimation numérique de la limite de cette suite.

Définissez un module a[n_] donnant la valeur exacte de (Subscript[a, n]).

Exercice -

Soit la suite (Subscript[((Subscript[a, n])), n ∈ (SuperStar[ℕ])]) définie de la façon suivante:

(Subscript[a, 1])=1,      (Subscript[a, n])=(1/(1+(Subscript[a, n-1])))

(Attention: cette fois-ci l’indice du premier terme est 1 et non 0 !)

Définissez un module a[n_] donnant la valeur exacte de (Subscript[a, n]).

Représentez graphiquement les 10 premiers termes de cette suite (graduer l’axe des abscisses toutes les unités). Que peut-on supposer à partir de ce graphe?

Déterminez une estimation numérique de la limite de cette suite.

Calculer la valeur exacte de la limite de cette suite.

Exercice -

On considère la suite (Subscript[((Subscript[a, n])), n ∈ (SuperStar[ℕ])]) définie de la façon suivante:

(Subscript[a, 1])=150,      (Subscript[a, n+1])=(2/3)·(Subscript[a, n]).

Calculez les 15 premiers termes de la suite (Subscript[((Subscript[a, n])), n ∈ (SuperStar[ℕ])]) en code à virgule.

Déterminez le premier terme de la suite qui est inférieur à 0.1 à l’aide de la fonction NestWhile.

Déterminez le terme général de la suite, puis, en utilisant le terme général, déterminez le premier terme de la suite qui est inférieur à 0.1 d’abord sans Mathematica et ensuite avec Mathematica.

Exercice -

On considère la somme suivante:

(4/3)+(4/9)+(4/27)+...+(4/59049).

Calculer cette somme à l’aide du terme général et à l’aide de la relation de récurrence.

Calculer la série vers laquelle converge cette somme lorsque le nombre de termes tend vers l’infini.

Exercice -

On considère la somme suivante:

1-(1/3)+(1/5)-(1/7)+⋯-(1/99).

Approximez la valeur de cette somme.

Calculer la série vers laquelle converge cette somme lorsque le nombre de termes tend vers l’infini.

Exercice -

Un jardinier doit arroser 32 arbres alignés et distants les uns des autres de 8 m. Chaque arbre doit recevoir un arrosoir d’eau. Quelle distance le jardinier parcourra-t-il pour réaliser sa tâche s’il n’a qu’un arrosoir à disposition et que son périple commence et se termine au bassin d’eau se trouvant à 5 m du premier arbre?

Résolvez le problème de deux manières différentes: d’une part à l’aide d’une relation de récurrence, d’autre part à l’aide du terme général.

Exercice -

Soit la suite (Subscript[((Subscript[a, n])), n ∈ (SuperStar[ℕ])]) définie de la façon suivante:

(Subscript[a, 1])=7,   (Subscript[a, 2])=10,      (Subscript[a, n])=(Subscript[a, n-1])+(Subscript[a, n-2])   pour n>2.

Définissez un module a[n_] donnant la valeur exacte de (Subscript[a, n]). Pour ceci, utilisez la fonction next[{a_,b_}]:={b,a+b} et Nest.

Construisez la liste aa contenant les 30 premiers termes de la suite  (Subscript[((Subscript[a, n])), n ∈ (SuperStar[ℕ])]).

On définit une nouvelle suite (Subscript[((Subscript[b, n])), n ∈ (SuperStar[ℕ])]) par (Subscript[b, n])=((Subscript[a, n+1])/(Subscript[a, n])). 
A partir de la liste aa, construisez la liste bb contenant les 29 premiers termes de la suite (Subscript[((Subscript[b, n])), n ∈ (SuperStar[ℕ])]) en code à virgule. Que peut-on supposer à partir de cette liste?

Rappel: le nombre d’or ϕ est défini par ϕ=((1+(Sqrt[5]))/2). Affichez ce nombre en code à virgule. Que pouvez-vous constater?

Que se passe-t-il si vous changez les valeurs initiales (Subscript[a, 1]) et (Subscript[a, 2])?

Pour x,y∈ℝ on définit la suite (Subscript[((Subscript[u, n])), n ∈ (SuperStar[ℕ])]) par (Subscript[u, n])=x·(ϕ^n)+y·(((((-1)/ϕ)))^n), où ϕ=((1+(Sqrt[5]))/2) est le nombre d’or.

Montrez à l’aide de Mathematica que la suite (Subscript[((Subscript[u, n])), n ∈ (SuperStar[ℕ])]) est une suite de Fibonacci, c’est-à-dire que tout terme est la somme de ses deux prédécesseurs.

Soit (Subscript[c, 1]) et (Subscript[c, 2]) deux nombres réels. Montrez à l’aide de Mathematica qu’il existe deux nombres x et y tels que (Subscript[u, 1])=(Subscript[c, 1]) et (Subscript[u, 2])=(Subscript[c, 2]). Que peut-on déduire de cet énoncé?

Soit la suite (Subscript[((Subscript[p, n])), n ∈ (SuperStar[ℕ])]) définie par (Subscript[p, n])=((Subscript[u, n+1])/(Subscript[u, n])). Calculez (lim_(n -> +∞))(Subscript[p, n]) à l’aide de Mathematica, puis démontrez votre résultat. Que peut-on déduire de cet énoncé?