\chapter{Les modules importants }

Nous allons voir dans ce chapitre les modules importants que l'on peut utiliser en mathématiques au lycée.


\newpage
\pagestyle{main}

\section{Le module \texttt{math}}
\index{math (module)}
\enlargethispage*{3em}
\begin{center}
\begin{tabular}{|>{\ttfamily}Sc|>{\centering\arraybackslash}S{m{4.7cm}}|S{m{4cm}}|>{\centering\arraybackslash}S{m{3.2cm}}|}
\hline
\rowcolor{titrecolor}\color{white}Fonction & \color{white}Exemple & \color{white}Explication & \color{white}Niveau\\
\hline
ceil(n) 
& 
\begin{console}
>>> ceil(pi)
4
\end{console}
&
Renvoie la partie entière supérieure de $n$.
&
Tout niveau
\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
comb(n,k)\index{Combinaisons}
& 
\begin{console}
>>> comb(10,3)
120
\end{console}
&
Renvoie le nombre de façons de choisir $k$ éléments parmi $n$ de manière non-ordonnée et sans répétition.
&
Terminale\\
\hline %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
factorial(n)\index{Factorielle}
&
\begin{console}
>>> factorial(5)
120
\end{console}
&
Renvoie la factorielle de $n$ sous forme d'entier, c'est-à-dire\linebreak $1\times2\times3\times\cdots\times n$.
&
Terminale\\
\hline %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
floor(n)
&
\begin{console}
>>> floor(pi)
3
\end{console}
&
Renvoie la partie entière inférieure de $n$.
&
Tout niveau\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
fsum(liste)\index{Liste!Somme exacte de tous les nombres}
&
\begin{console}
>>> fsum([0.1]*10)
1.0
\end{console}
&
Renvoie la somme exacte de tous les nombres de la liste.\newline
À noter que \texttt{sum([0.1]*10)} renvoie \texttt{0.99999...} et non 1.
&
Tout niveau
\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
gcd(a,b)\index{PGCD}
&
\begin{console}
>>> gcd(45,35)
5
\end{console}
&
Renvoie le plus grand diviseur commun aux deux nombres $a$ et $b$, donc \pgcd{a}{b}.
&
Seconde,\linebreak Terminale\linebreak (complémentaire)\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
perm(n,k)\index{Permutations}
&
\begin{console}
>>> perm(10,3)
720
\end{console}
&
Renvoie le nombre de façons de choisir $k$ éléments parmi $n$ de manière ordonnée sans répétition.
&
Terminale\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
exp(x)\index{Exponentielle}
&
\begin{console}
>>> exp(1)
2.718281828459045
\end{console}
&
Renvoie l'image de $x$ par la fonction exponentielle ($\e^x$).
&
Première,\linebreak Terminale\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
log(x)\index{Logarithme népérien}
&
\begin{console}
>>> log(exp(1))
1.0
\end{console}
&
Renvoie l'image de $x$ par la fonction\linebreak logarithme népérien ($\ln(x)$).
&
Terminale\\
\hline
\end{tabular}

\newpage

\begin{tabular}{|>{\ttfamily}Sc|>{\centering\arraybackslash}S{m{4.7cm}}|S{m{4cm}}|>{\centering\arraybackslash}S{m{3.2cm}}|}
\hline
\rowcolor{titrecolor}\color{white}Fonction & \color{white}Exemple & \color{white}Explication & \color{white}Niveau\\
\hline
cos(x)\index{Cosinus}
&
\begin{console}
>>> cos(pi)
-1.0
\end{console}
&
Renvoie l'image de $x$ (exprimé en radians) par la fonction cosinus ($\cos(x)$).
&
Tout niveau\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
sin(x)\index{Sinus}
&
\begin{console}
>>> sin(pi/2)
1.0
\end{console}
&
Renvoie l'image de $x$ (exprimé en radians) par la fonction sinus ($\sin(x)$).
&
Tout niveau\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
tan(x)\index{Tangente}
&
\begin{console}
>>> tan(pi/4)
0.9999999999999999
\end{console}
&
Renvoie l'image de $x$ (exprimé en radians) par la fonction tangente ($\tan(x)$).
&
Tout niveau\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
degrees(a)\index{Angles!Conversion en degrés}
&
\begin{console}
>>> degrees(pi/4)
45.0
\end{console}
&
Renvoie l'angle $a$ (exprimé en radians) converti en degrés.
&
Tout niveau\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%%%%
radians(a)\index{Angles!Conversion en radians}
&
\begin{console}
>>> radians(30)
0.5235987755982988
\end{console}
&
Renvoie l'angle $a$ (exprimé en degrés) converti en radians.
&
Tout niveau\\
\hline%%%%%%%%%%%%%%%%%%%%%%%
\hline
pi\index{Pi (constante)}\index{Constantes!pi} & 
\begin{console}
>>> pi
3.141592653589793
\end{console}
&
Renvoie la valeur approchée de $\pi$.
&
Tout niveau\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%%%
e\index{e (constante)}\index{Constantes!e}
&
\begin{console}
>>> e
2.718281828459045
\end{console}
&
Renvoie la valeur approchée de $\e^1$.
&
Première,\linebreak Terminale\\
\hline
\end{tabular}
\end{center}

\newpage

\section{Le module \texttt{cmath}}
\index{cmath (module)}
\index{Nombres complexes}

\begin{center}
\begin{tabular}{|>{\ttfamily}Sc|>{\centering\arraybackslash}S{m{4.7cm}}|S{m{4cm}}|>{\centering\arraybackslash}S{m{3.2cm}}|}
\hline
\rowcolor{titrecolor}\color{white}Fonction & \color{white}Exemple & \color{white}Explication & \color{white}Niveau\\
\hline
complex(a,b)
&
\begin{console}
>>> z = complex(3,-2)
>>> z
(3-2j)
\end{console}
&
Définit un nombre complexe $z=a+b\i$. Remarquez que le \og $\i$ \fg{} est noté \og \texttt{j} \fg.
&
Terminale\linebreak complémentaire\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%
z.real, z.imag
&
\begin{console}
>>> z = complex(3,-2)
>>> z.real, z.imag
(33., -2.0)
\end{console}
&
Renvoie respectivement la partie réelle et imaginaire d'un nombre complexe $z$. 
&
Terminale\linebreak complémentaire\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%
phase(z)
&
\begin{console}
>>> z = complex(3,-2)
>>> phase(z)
\end{console}
&
Renvoie l'argument de $z$ compris entre \intervOF{-\pi}{\pi}.
&
Terminale\linebreak complémentaire\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%
polar(z)
&
\begin{console}
>>> z = complex(3,-2)
>>> polar(z)
(3.6055512754639896, -0.5880026035475675)
\end{console}
&
Renvoie le module et un argument de $z$, exprimé sous forme algébrique.
&
Terminale\linebreak complémentaire\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%
abs(z)
&
\begin{console}
>>> z = complex(1,1)
>>> abs(z)
1.4142135623730951
\end{console}
&
Renvoie le module de $z$.
&
Terminale\linebreak complémentaire\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%
\end{tabular}
\end{center}

\newpage

\section{Le module \texttt{random}}
\index{random (module)}

Ce module est indispensable pour simuler l'aléatoire.

\medskip

\begin{tabular}{|>{\ttfamily}Sc|>{\centering\arraybackslash}S{m{4.7cm}}|S{m{4cm}}|>{\centering\arraybackslash}S{m{3.2cm}}|}
\hline
\rowcolor{titrecolor}\color{white}Fonction & \color{white}Exemple & \color{white}Explication & \color{white}Niveau\\
\hline
random()
&
\begin{console}
>>> random()
0.6939528690800718
\end{console}
&
Nombre réel pseudo-aléatoire dans $\intervFO{0}{1}$.
&
Tout niveau\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%
randint(a,b)
&
\begin{console}
>>> randint(1,6)
5
\end{console}
&
Nombre entier choisi pseudo-aléatoirement dans \intervFF{a}{b}.
&
Tout niveau\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
choice(itérable)
&
\begin{console}
>>> choice('math')
'a'
\end{console}
&
\'Elément choisi pseudo-aléatoirement dans l'itérable (liste ou chaîne de caractères par exemple).
&
Tout niveau\\
\hline%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
shuffle(liste)
&
\begin{console}
>>> L = [5,6,9,3]
>>> shuffle(L)
>>> L
[3, 6, 5, 9]
\end{console}
&
Mélange pseudo-aléatoirement les éléments de liste.
&
Tout niveau\\
\hline
uniform(a,b)
&
\begin{console}
>>> uniform(5,8)
7.211930684444784
\end{console}
&
Nombre réel pseudo-aléatoire dans \intervFF{a}{b}.
&
Terminale\linebreak complémentaire\\
\hline
sample(L,k)
&
\begin{console}
>>> L = [1,5,8,9]
>>> sample(L,k=2)
[5, 1] 
\end{console}
&
Sous-ensemble à $k$ éléments de la liste \texttt{L} (donc sans répétition).
&
Tout niveau\\
\hline
expovariate($\lambda$)
&
\begin{console}
>>> expovariate(1/5)
3.2173147579260983
\end{console}
&
Renvoie une valeur d'une variable aléatoire suivant la loi exponentielle de paramètre \texttt{lambda} (dans l'exemple, $\lambda=5)$.
&
Terminale\linebreak complémentaire\\
\hline
gauss(m,s)
&
\begin{console}
>>> gauss(5,1)
4.431843559533477
\end{console}
&
Renvoie une valeur d'une variable aléatoire suivant la loi normale de moyenne \texttt{m} et d'écart-type \texttt{s}.
&
Pour les profs
\\
\hline
\end{tabular}


\newpage
\section{Le module \texttt{numpy.random}}
\index{numpy.random (module)}

Ce module peut être utilisé pour les simulations en probabilités.

Il n'est pas à proprement parlé indispensable dans l'enseignement des mathématiques au lycée, mais il est très rapide sur des échantillons de grandes tailles.

\subsection*{Nombres réels aléatoires compris entre 0 et 1}
\index{Loi uniforme}

Pour simuler $n$ expériences consistant à choisir $k$ nombres aléatoires compris entre 0 (inclus) et 1 (exclus), on pourra écrire:

\begin{console}
>>> from numpy.random import rand
>>> n, k = 3, 5
>>> rand(n,k)
array([[0.60959633, 0.00612091, 0.05768334, 0.69935151, 0.90727144],
       [0.45152059, 0.52681808, 0.03733788, 0.28459394, 0.54482874],
       [0.44492722, 0.99139342, 0.62421932, 0.45552632, 0.6757296 ]])
\end{console}

Le résultat est un tableau (\texttt{array}) que l'on peut exploiter à l'aide de boucles.

\begin{exemple}
On souhaite simuler 100 expériences consistant à choisir \numprint{1000} nombres réels au hasard compris entre 0 et 1, à voir le nombre de nombres supérieurs à 0,5 pour chaque expérience puis représenter les résultats sur un graphique.

On peut alors utiliser le code suivant :

\begin{python}
from numpy.random import rand
from matplotlib.pyplot import plot, show

n, k = 100, 1000

L = rand(n,k)
X = range(1,n+1)
Y = []

for i in L:
    y = 0
    for j in i:
        if j > 0.5:
            y +=1
    Y.append(y)
    
plot(X,Y,marker='+', linestyle='')
show()
\end{python}
\end{exemple}

Cet exemple produit un graphique semblable à celui de la page suivante.

\newpage

\begin{center}
\begin{tikzpicture}
\node[inner sep=0pt,outer sep=0pt] (img) {\includegraphics[scale=0.9]{exemple_numpy_random.jpg}};
\drawshadow{img}{black}
\end{tikzpicture}
\end{center}

\medskip

On voit alors que le nombre de nombres supérieurs à 0,5 de chaque expérience fluctue dans un intervalle \intervFF{500-30}{500+30} (sur l'exemple présenté ici).

\subsection*{Simuler une loi binomiale}
\index{Loi binomiale}

Si $X$ est une variable aléatoire suivant la loi binomiale $\mathcal{B}\coord{n}{p}$, simuler $t$ de ces variables est possible en écrivant:
\begin{console}
>>> from numpy.random import binomial
>>> L = binomial(n,p,t)
\end{console}

Ici aussi, le résultat est un tableau à $t$ éléments.
\enlargethispage*{4em}

\begin{exemple}
On souhaite simuler 300 variables aléatoires suivant la loi binomiale $\mathcal{B}\coord{100}{0,37}$ et visualiser les résultats sur un graphique.

\begin{python}
from numpy.random import binomial
from matplotlib.pyplot import plot, show
n, p, t = 100, 0.37, 300
Y = binomial(n,p,t)
X = range(1,t+1)  
plot(X,Y)
show()
\end{python}
\end{exemple}

\begin{center}
\begin{tikzpicture}
\node[inner sep=0pt,outer sep=0pt] (img) {\includegraphics[scale=0.9]{exemple_numpy_binomial.jpg}};
\drawshadow{img}{black}
\end{tikzpicture}
\end{center}

\medskip


D'après le cours de terminale, la moyenne est $n\times p=100\times0,37=37$ et on constate en effet que la variable fluctue autour de cette valeur (dans un intervalle qui semble être \intervFF{37-14}{37+14} sur notre exemple).

\subsection*{Simuler une loi géométrique}
\index{Loi geometrique@Loi géométrique}

Le module contient une fonction permettant de simuler $t$ fois une variable aléatoire suivant la loi géométrique de paramètre $p$ :

\begin{console}
>>> from numpy.random import geometric
>>> L = geometric(p,t)
\end{console}

À mes yeux, cette fonction n'a pas un grand intérêt dans l'enseignement des mathématiques au lycée, mais j'ai tout de même préféré l'insérer ici au cas où certain·e·s enseignant·e·s en auraient besoin.

En mathématiques complémentaires, le programme demande de simuler une loi géométrique à partir d'une loi binomiale: c'est ce que je présente à la page \ref{loi-geometrique}.
