====== Exercice 1 : Tracé d'une courbe avec matplotlib ======

Divers modules permettent de tracer des courbes d'équation $y = f(x)$. On utilisera ici le module ''pyplot'' de ''matplotlib'' -- [[https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.html|voir documentation]].

<WRAP tip>D'autres préfèrent le module ''pylab'' de la même bibliothèque.</WRAP>

Pour représenter graphiquement une fonction $f$ sur un segment $[a, b]$ on peut construire une subdivision  $(a_i)_{0\leqslant i\leqslant n}$ de $[a,b]$ avec $a_i= a +i \,\frac{b-a}{n}$, soit en Python :
<code python>
X = [a+i*(b-a)/n for i in range(n+1)]
</code>

{{ :itc:tps:tp3:subdivision.png?direct&600 |}}

<WRAP tip>N'oubliez qu'il faut $n+1$ bornes pour délimiter $n$ intervalles !</WRAP>

À partir de la subdivision précédente, on peut calculer les images $f(x)$ correspondantes, ce qui est immédiat en Python :
<code python>
Y = [f(x) for x in X]
</code>

Il reste à demander l'affichage. Pour cela on fournit les tableaux ''X'' et ''Y'' à la fonction ''plot'' et on peut également ajouter des options de mise en forme : ''plot(X, Y, options)''.

On obtient la ligne brisée reliant les points de coordonnées $(a_i\,;\,f(a_i))_{0 \leqslant i \leqslant n}$. Bien sûr, si on choisit ''n = len(X)'' assez grand, cette ligne donne l'illusion d'une courbe douce.

<code python linenums>
import matplotlib.pyplot as plt

def dessin(f, a, b, n):
    """
    Affiche la représentation graphique de f sur [a;b]
    """
    X = [a + i*(b-a)/n for i in range(n+1)]
    Y = [f(x) for x in X]
    plt.figure()
    plt.plot(X, Y, 'r')
    plt.show()

# Création d'une fonction
f1 = lambda x: x**3 - 3*x**2 + x - 5

# On aurait aussi bien pu faire :
'''
def f1(x):
    return x**3 - 3*x**2 + x - 5
'''

dessin(f1, -3, 5, 100)
</code>

==== Des remarques ====

  * En ligne 1, ''as plt'' est un alias (pseudonyme) : On n'a pas envie d'écrire ici et là ''matplotlib.pyplot'' alors on crée l'alias ''plt'', ainsi on n'aura qu'à écrire ''plt'' à la place.
  * En ligne 9, ''plt.figure()'' ouvre une nouvelle figure. Cela peut servir suivant si on souhaite placer plusieurs courbes sur un même graphique ou pas.
  * En ligne 10, ''%%'r'%%'' indique que la courbe sera en rouge -- //r pour red//
  * En ligne 11, ''plt.show()'' provoque l'affichage d'une fenêtre pour la figure -- graphique -- ou plusieurs si on en a créé plusieurs figures. Notez bien que :
    * rien ne s'affiche si on n'appelle pas ''plt.show()''
    * ''plt.show()'' ouvre la fenêtre graphique et suspend l'exécution du programme. Il faut fermer la fenêtre pour que le programme reprenne son cours.
    * La fenêtre dispose de commandes permettant de sauvegarder le résultat, ajuster la vue... Pensez-y : Python et matplotlib vous permettront de produire des graphiques très nettement supérieurs à ceux d'un tableur !

===== Le module numpy =====

[[https://numpy.org/doc/stable/reference/index.html|Numpy]] est un module incontournable de Python. Il contient énormément de fonctions très puissantes. Numpy propose notamment des tableaux très performants utilisés en analyse de données -- data science -- traitement d'images...

  * ''arrange(a, b, h)'' crée la subdivision démarrant en ''x = a'' et poursuivant par pas ''h'' avec ''x  <= b''. Par exemple en posant ''h = (b-a)/n'', on obtient la subdivision de la partie précédente.
  * ''linspace(a,b,n)'' crée une subdivision de ''n'' points, ce qui revient à faire ''n-1'' intervalles de ''(a-b)/(n-1)''. Pour obtenir la subdivision précédente, il faudrait donc ''linspace(a,b,n+1)''. Mais en ce ''+1'' ne change en général pas grand chose -- si on prend 600 points, un de plus ou de moins...

**Exemple**

<code python linenums>
import matplotlib.pyplot as plt
import numpy as np

def f(x):
    if x == 0:
        return 1
    return np.sin(x)/x

plt.figure()
X = np.linspace(-15, 15, 600)
Y = [f(x) for x in X]
plt.plot(X, Y, 'b')
plt.axhline(linewidth=2, color='k')
plt.axvline(linewidth=2, color='k')
plt.title('la fonction f(x)= sin(x)/x')
plt.axis([-15, 15, -0.5, 1.3])
plt.show()
</code>

==== Des remarques ====

  * Ligne 7, Numpy fournit les fonctions usuelles comme ''sin'', pas besoin d'aller chercher ''sin'' dans le module ''math''.
  * Ligne 10, ''X'' est un tableau mais un tableau spécial, un tableau Numpy. Pour un usage basique, on ne verra pas la différence avec un tableau de type ''list''.

==== Vectorialisation ====

''X'' est un tableau spécial, un tableau Numpy.

En ligne 11, on crée ''Y'' comme dans l'exemple précédent, ''%%Y = [f(x) for x in X]%%''.

On aurait pu faire plus court en écrivant ''%%Y = f(X)%%''. C'est possible car dans ''f'', on utilise ''np.sin'' qui est fait exprès pour des données vectorialisée -- sous forme de tableau.

Si ''f'' n'avait pas déjà été vectorialisée (par exemple si ''f'' utilisait des calculs inadaptés à un tableau Numpy) on pourrait la vectorialiser en créant une version : ''fvec = np.vectorialize(f)''.

On pourrait penser que vectorialiser ne change pas grand chose, que ce n'est qu'un gadget typographique. Eh bien c'est plus que cela : Numpy est optimisé dans un langage plus rapide que Python si bien que si on utilise les mécanismes de Numpy, l'exécution sera beaucoup plus rapide.

===== À faire =====

À vous de représenter quelques fonctions bien choisies sur des intervalles pertinents, après interaction
visuelle avec les retours du logiciel, en utilisant de manière pertinente et efficace les fonctions et les méthodes du module pyplot.

On peut aussi, représenter, pour ceux qui savent ce que c’est, des arcs paramétrés, des courbes planes définies par une équation cartésienne, des courbes et des surfaces, en perspective, dans l’espace à trois dimensions, des lignes de niveaux, des figures géométriques de toutes sortes. Tout ceci est désormais en dehors du programme de mathématiques.

<WRAP box>
Exemple d'une courbe paramétrée :
<code python linenums>
import matplotlib.pyplot as plt
import numpy as np
plt.figure()
T = np.linspace(0, 6.28, 100)
X = np.cos(2*T)
Y = np.sin(3*T)
plt.plot(X, Y, 'b')
plt.show()
</code>
</WRAP>