Capacités numériques – TIPE : Fonctions Python utiles en calcul scientifique PSI - Lycée Lapérouse

De nombreuses fonctions utiles pour le scientifique sont progressivement intégrées par scipy.integrate.odeint(arguments). Pour alléger, un alias peut être utilisé : import
les utilisateurs. Elles sont regroupées dans différents modules (appelés également packages scipy.integrate as spi puis spi.odeint(arguments).
ou bibliothèques) complémentaires avec la bibliothèque standard de Python. On peut citer
les bibliothèques suivantes : Conseil : lors de chaque projet, importer Numpy et Matplotlib par les commandes :
— import numpy as np
NumPy Pour la manipulation de matrices et tableaux ; reprend les fonc- import matplotlib.pyplot as plt
tions mathématiques du module math de la bibliothèque standard
— ou éventuellement ravailler dans l’environnement Pylab qui regroupe la bibliothèque
de Python et les rend applicables à un tableau de valeurs (uni-
NumPy et les fonctions de base Matplotlib et les appeler sans sans alias :
versal functions)
from pylab import *
Matplotlib Pour les tracés de figures ; le fonctionnement est assez proche de
celle de Matlab et Scilab Vous travaillez ainsi dans l’environnement Pylab qui regroupe la bibliothèque NumPy
et les fonctions de base Matplotlib. que vous pouvez appeler sans alias
SciPy Pour le calcul scientifique : intégration et résolution d’équa- Vous importerez ensuite les éventuelles fonctions complémentaires (souvent de Scipy)
tions différentielles (scipy.integrate), interpolation de fonc- dont vous avez besoin.
tion (scipy.interpolate), traitement du signal (scipy.signal,
scipy.fftpack etc.), probabilité et statistiques (scipy.stats),
2 Créer et manipuler un tableau de valeurs
résolution d’équations non linéaires (scipy.optimize), algèbre
linéaire (scipy.linalg), etc. Numpy travaille principalement avec le type tableau de valeurs (array). Pour créer un
tableau unidimensionnel contenant les échantillons d’une variable, on peut utiliser une de
SimPy Pour le calcul formel ces deux fonctions du module numpy :
Cette fiche a pour but de présenter les fonctions les plus utiles sans rentrer dans les — linspace(valeur_min,valeur_max,nbr_points) renvoie un tableau comprenant
détails de leur fonctionnement et sans donner tous leurs arguments optionnels mais parfois nbr_points valeurs également espacées entre les valeurs extrêmes valeur_min et
utiles. Elle ne se substitue pas à la documentation de chaque fonction qui vous donnera valeur_max ;
bien plus de précisions sur ses arguments, ses renvois, l’algorithme qu’elle utilise, etc.
>>> t=np.linspace(1,10,10) ; t
array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
1 Importer une bibliothèque ou une fonction
— arange(valeur_min,valeur_max,pas) renvoie un tableau comprenant les valeurs al-
Pour importer une fonction (ici odeint) d’un package (ici scipy.integrate) : lant de valeur_min à valeur_max (non incluse) séparées de la valeur pas.
from scipy.integrate import odeint >>> t=np.arange(1,11,10) ; t
array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
Pour importer la totalité des classes et fonctions du package :
L’indexation, l’affectation et l’extraction d’éléments d’un tableau se fait de la même
from scipy.integrate import * manière qu’avec une liste. Contrairement aux listes, les opérateurs (*, +, ** etc.) et les
fonctions du package Numpy opèrent sur chaque éléments du tableau, ce qui extrêmement
Une fonction du package peut ainsi être appelée en tapant simplement son nom pratique pour le calcul scientifique.
odeint(arguments) sans préfixe.
Remarque : Ce n’est pas la manière la plus propre d’importer une bibliothèque >>> t+2
(conflit avec des fonctions et commandes déjà présentes). Même si ça n’a guère d’im- array([ 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.])
portance pour nous, les puristes préfèreront taper import scipy.integrate et ap- >>> np.cos(t)
peler la fonction en utilisant le nom du module comme préfixe comme préfixe : array([ 0.54030231, -0.41614684, -0.9899925 , -0.65364362, 0.28366219,
0.96017029, 0.75390225, -0.14550003, -0.91113026, -0.83907153])

–1–
Capacités numériques – TIPE : Fonctions Python utiles en calcul scientifique
3 Tracer la courbe représentative d’une fonction à une variable
Pour tracer la courbe représentative d’une fonction à une variable, on utilisera la fonction
plot du module matplotlib.pyplot. Pour les tracés en échelle logarithmique ou semi-
logarithmique, on dispose des fonctions loglog, semilogx et semilog, fonctionnant de la
même façon que plot.
Pour le tracé de fonction de deux variables : voir section ??.
t=np.linspace(0,2*pi,10)
plt.figure() #crée une nouvelle figure
plt.plot(t,np.cos(t))
plt.show()
On peut facilement superposer plusieurs courbes sur une même figure en appelant plu-
sieurs fois la fonction plot (avant affichage avec plt.show() ou création d’une nouvelle
figure avec plt.figure(). De nombreuses options et arguments peuvent être ajoutés pour
afficher les informations indispensables (variables en abscisses et ordonnées, légende) et
"embellir" le graphe (voir exemple ci-contre ou documentation de la fonction plot).
t=np.linspace(0,2*pi,10)
plt.plot(t,np.cos(t),'r-o',linewidth=2,label='f(t)=cos(t)')
plt.plot(t,np.sin(t),'b-x',linewidth=2,label='f(t)=sin(t)')
plt.title('Fonctions cosinus et sinus')
plt.xlabel('t')
plt.ylabel('f(t)')
plt.legend(loc='lower right')
plt.grid('on')
plt.show()
–2–
PSI - Lycée Lapérouse
On peut également utiliser créer une fenêtre graphique avec plusieurs tracés grâce à la
fonction subplot. Un exemple est proposé en section 7.
4 Résoudre un système d’équations linéaires
On utilise la fonction solve du module numpy.linalg :
— Pour un système mis sous forme matricielle M ×X = A, solve(M,A) renvoie le vecteur
des solutions X.
>>> solve([[3,1], [1,2]],[9,8])
array([ 2., 3.])
On peut également utiliser les fonctions d’inversion de matrices comme inv du module
numpy.linalg ou pour des matrices de grande dimension comportant de nombreux zéros,
différentes fonctions de scipy.sparse.
5 Déterminer les zéros d’une fonction
On peut utiliser différentes fonctions du module scipy.optimize pour rechercher les
zéros d’une fonction à valeur réelle :
— bisect(f,a,b,xtol=precision) renvoie une racine de f sur l’intervalle [a,b] en ap-
pliquant la méthode de dichotomie ;
— newton(f,x0,tol=precision) renvoie une racine de f en appliquant la méthode de
Newton initialisée à la valeur x0 de la variable ;
D’autres algorithmes de recherche de zéros sont disponibles via les fonctions brenth,
brentq, ridder etc.
6 Dériver ou intégrer une fonction
Pour intégrer :
— si la fonction f : t → f (t) est définie explicitement, on utilise quad(f,a,b) de
´b
scipy.integrate qui renvoie la valeur de a f (t)dt ;
— si la fonction n’est pas définie explicitement mais qu’on dispose d’un tableau Y de ses
valeurs aux échantillons x, trapz(Y,x) de numpy calcule l’intégrale de la fonction par
la méthode des trapèzes tandis que cumtrapz(Y,x) calcule les valeurs d’une primitive
à chaque échantillon.
D’autres fonctions du module scipy.integrate peuvent également être utilisées.
Pour dériver :
— si la fonction f : t → f (t) est définie explicitement, on utilise derivative(f,t) de
scipy.misc qui renvoie un tableau contenant les valeurs de f ′ aux échantillons t[i] ;
— si la fonction n’est pas définie explicitement mais qu’on dispose d’un tableau Y de ses
valeurs, diff(Y) de numpy calcule les différences entre deux échantillons consécutifs.
Attention : diff(Y) contient un élément de moins que Y.
Capacités numériques – TIPE : Fonctions Python utiles en calcul scientifique PSI - Lycée Lapérouse

7 Résoudre une équation différentielle

#Définition de la fonction second membre
On utilisera la fonction odeint de scipy.optimize qui permet de résoudre des systèmes def fct(X,t):
différentiels du premier ordre. return (X[1], -om0**2*X[0] - 2*k*X[1])
— Pour déterminer la fonction y solution d’une équation différentielle d’ordre 1 mise sous
la forme y ′ = f (y,t) pour y(tmin ) = y0 , on utilisera la syntaxe suivante : #Résolution
X=odeint(fct,CI,t)
y=odeint(f,y0,t)
où t est un tableau contenant les différentes valeurs de variables, la première de ces #Tracés
valeurs étant celle pour laquelle la fonction y vaut y0 ; la fonction renvoie un tableau plt.subplot(211) #1er tracé de cette fenêtre à 2 lignes et 1 colonne
des valeurs y(t). plt.plot(t,X[:,0])
plt.xlabel('t (s)')
— Pour résoudre une équation différentielle du deuxième ordre, il faut ruser en lui pré- plt.ylabel('x (cm)')
sentant le problème sous la forme d’un système de deux équations du premier ordre. plt.subplot(212) #2nd tracé de cette fenêtre à 2 lignes et 1 colonne
Par exemple, l’équation différentielle y ′′ + a(t)y ′ + b(t)y = 0 peut se réécrire en intro- plt.plot(t,X[:,1])
duisant le vecteur Y tel que Y [0] = y et Y [1] = y ′ sous la forme du système suivant : plt.xlabel('t (s)')
plt.ylabel(" v (cm/s)")

 Y [0]′ = y ′ = Y [1]

plt.show()
 Y [1]′ = y ′′ = −aY [0]′ − bY [0] = −aY [1] − bY [0]


Soit :

Y ′ = f (Y,t) avec f : ((x,y),t) → (y, − ay − bx)

On peut alors, après avoir défini f et les conditions initiales, utiliser la syntaxe :
Y=odeint(f,(y0,yprime0),t)
Y[:,0] contient les valeurs de y(t) et Y[:,1] celles de y ′ (t).

#Résolution de x''+ 2*k x'+om0**2x=0

from scipy.integrate import odeint

om0=2*pi*1
k=om0/5

#Conditions initiales sous la forme [x(0), x'(0)]

CI=[5,0] #cm, cm/s

#Tableau des valeurs de variables

tmax=5 #s
t=np.linspace(0,tmax,500)

–3–
Capacités numériques – TIPE : Fonctions Python utiles en calcul scientifique PSI - Lycée Lapérouse

8 Tracer le spectre d’un signal
On utilisera la fonction rfft du package numpy.fft qui calcule la transformée de Fourier
discrète d’un signal numérique s à valeurs réelles, échantillonné à fréquence Fe , pour les
fréquences f ∈ [0; Fe /2]. Pour tracer le spectre en amplitude, on pourra entrer :
N=len(s)
spectre=rfft(s)/N*2.0 #2/N est un facteur de normalisation
freq=np.linspace(0,Fe/2,N//2+1) #Fe frequence d'echantillonnage
plt.plot(freq,abs(spectre)) #trace du spectre en amplitude
plt.show()
— pour tracer l’histogramme de distribution des données :
plt.hist(data,bins='rice')
L’argument optionnel bins permet de contrôler le nombre de classes (les "bâtons" de
l’histogramme), qui peut être défini explicitement (bins=100) ou par une règle de
calcul 1 .
10 Effection une régression linéaire (ou polynomiale)
Considérons les listes (ou tableaux) de valeurs de variables x et d’ordonnées y.

Pour visualiser l’évolution du spectre au cours d’un enregistrement long (phrase, extrait — La fonction polyfit(x, y, deg) de Numpy renvoie les valeurs coefficients polynomi-
musical, etc.), on pourra en tracer le spectrogramme (voir 11.2). naux (par puissance décroissante) du polynôme de degré deg modélisant la relation
y = f (x). Pour une régression linéaire, on prendre deg=1.
9 Effectuer des tirages aléatoires et des études statistiques — La fonction polyval(p,x) de Numpy renvoie les valeurs de la fonction polynomiale de
coefficients p évaluées sur les valeurs de la liste x.
Ces fonctions sont particulièrement utiles dans les simulations Monte-Carlo, utilisées
notamment pour estimer la variabilité d’une grandeur expérimentale. x=[2,4,6,8,10,12] ; y=[0.36, 0.578, 0.782,0.993,1.197,1.41]
Pour effectuer des tirages aléatoires de variables, on utilisera les fonctions de la biblio- p=np.polyfit(x,y,1) #p[0]=pente, p[1]=y(0)
thèque random de Numpy. reg=np.polyval(p,x)
— x=np.random.uniform(a,b) affecte à x un flottant tiré aléatoirement dans l’intervalle
[a,b], en suivant une distribution uniforme ; pour un tirage d’entiers, on utilisera la plt.plot(x,y,'o',label='Mesures')
fonction randint. plt.xlabel('x') ; plt.ylabel('y')
text='Modèle : y =%.2f x + %.2f '%(p[0],p[1])
— x=np.random.normal(moy,ecart_type) affecte à x un flottant, en suivant une loi
plt.plot(x,reg,'-',label=text)
normale ;
plt.grid('on') ; plt.legend(loc='best')
— x=np.random.choice(['gagné','perdu'], p=(0.2,0.8)) attribue à x un des élé- plt.show()
ments de la liste L placée en premier argument, l’élément L[i] ayant la probabilité p(i)
d’être tiré ;
1.4 Mesures
— l’argument optionnel size permet de générer des tableaux de valeurs aléa- 0.10 x + 0.15

toires. Ainsi x=np.random.uniform(0,5,size=10) (ou plus simplement 1.2

x=np.random.uniform(0,5,10)) renvoie :
1.0
array([3.08488813, 1.22666646, 2.73186444, 4.85426599, 1.48692169,
3.44456415, 3.17337008, 3.20115655, 1.69995405, 0.08911664])

y
0.8

Élements d’étude statistique d’un tableau de valeurs data de taille N : 0.6

PN
— np.average(data) et np.std(data) calculent la moyenne m = N1 i=1 mi et l’écart-
q P 0.4
1 N 2
type σ = N i=1 (mi − m) des données d’un tableau. Pour estimer l’écart-type
s 2 4 6 8 10 12
PN x
1 2
expérimental (σexp = N −1 i=1 (mi − m) , égal à l’incertitude-type sur une me-

sure), on écrira np.std(data,ddof=1). 1. La règle de Rice choisie ici donne un nombre de classes k ≈ 2N 1/3 adapté à la plupart des cas.

–4–
Capacités numériques – TIPE : Fonctions Python utiles en calcul scientifique PSI - Lycée Lapérouse

11 Autres fonctions utiles en calcul scientifique
Les outils suivants, dont le fonctionnement n’est pas à connaitre, peuvent vous être très
utiles pour votre TIPE.
11.1 Tracés avec barres d’erreurs
Pour tracer un graphe de données avec les barres d’erreur, on utilisera la fonction
errorbar de Matplotlib, fonctionnant de manière similaire à la fonction plot. Par
exemple, pour T et Ks deux tableaux de valeurs expérimentales avec u_T et u_Ks les
incertitudes-types associées, la commande
plt.errorbar(T,Ks,xerr=u_T,yerr=u_Ks,zorder=2)
permet d’obtenir le graphe Ks (T ) (graphe ci-dessous à droite) avec affichage des barres
d’erreurs de largeur l’incertitude élargie d’un facteur 2 (paramètre zorder). Cela peut
permettre de vérifier la validité d’une modélisation, si la courbe représentative de la loi
modèle passe par toutes les barres d’erreurs (exemple d’une régression linéaire satisfaisante
sur la graphe ci-dessous à droite).
permet d’affecter à Fe la fréquence d’échantillonnage du fichier son et à s un tableau
des valeurs des échantillons sonores.
— Créer une fonction par interpolation à partir de sa valeur en différents points :
interp1d de scipy.interpolate. Par exemple, à partir des tableaux t et x obte-
nus dans le premier exemple :
fct_x=interp1d(t,x,kind='linear')#interpolation lineaire
fct_x(3.6) #estimation de x(t) pour une valeur quelconque de t
— Tracer le spectrogramme d’un signal s avec la fonction specgram de Matplotlib. Par
exemple, en tapant
plt.specgram(s,NFFT=512,Fs=Fe)
le signal, de fréquence d’échantillonnage Fs, est découpé en intervalle de NFFT=512
échantillons chacun. Le spectre du signal sur chaque intervalle est calculé et sa valeur
absolue affichée en fonction de la fréquence et du temps (spectrogramme).

11.2 Traitement de données

Sauf indication contraire, les fonctions présentées sont comprises dans le module NumPy.
— Importer un tableau de valeurs compris dans un fichier text (*.txt, *csv, etc.) :
loadtxt. Par exemple, pour un fichier data.txt à deux colonnes comprenant les
valeurs de t et x(t) :
t,x=np.loadtxt('data.txt', skiprows=0,usecols=(0,1),unpack=True) 11.3 Systèmes linéaires – Filtrage
Les fonctions présentées sont comprises dans la bibliothèque scipy.signal.
— Créer un tableau de valeurs contenant les échantillons d’un fichier son (*wav) : read
du module scipy.io.wavfile. Par exemple, — Définir un système linéaire : lti. On donne en argument les listes des coefficients du
numérateur et du dénominateur donnés par degré décroissant. Par exemple, pour un
from scipy.io.wavfile import read b1 jω + b0
Fe,s=read('son.wav') SLI défini par la fonction de transfert H = , on écrira :
a2 (jω)2 + a1 jω + a0

–5–
Capacités numériques – TIPE : Fonctions Python utiles en calcul scientifique PSI - Lycée Lapérouse

sys=lti([b1,b0],[a2,a1,a0]) 11.4 Représentation graphique d’une fonction de deux variables

— Obtenir son diagramme de Bode : bode. Considérons une fonction de deux variables : f : (x,y) → f (x,y).
f=np.logspace(1e2,1e5,1000) — Définition du maillage :
w,GdB,phi=bode(sys,w=2*pi*f) On créée les tableaux de valeurs d’abscisses X et d’ordonnées Y et on utilise la fonction
meshgrid de NumPy pour obtenir la grille de coordonnées (XX, YY) pour lesquelles
permet d’obtenir le gain et la phase du système sys pour les fréquences définies en
seront estimées les valeurs de la fonction fi,j = f (xmin + ih, ymin + jh).
première ligne. Il ne vous reste plus qu’à tracer le diagramme de Bode grâce à la
fonction semilogx. X = np.arange(xmin, xmax, h)
— Tracer sa réponse indicielle : step. Très simple : Y = np.arange(ymin, ymax, h)
XX, YY = np.meshgrid(X,Y)
t=linspace(0,1e-3,1000)
t,reponse=step(sys,T=t) — Tracé :
plt.plot(t,reponse) Trois principales possibilités s’offrent à nous, grâce à différentes fonctions de
plt.show() matplotlib.pyplot :
— Tracer sa réponse à un signal d’entrée quelconque : lsim. Très utile et similaire à step, → représenter f (x,y) sur un troisième axe (plot_surface) :
sauf qu’il faut bien évidemment préciser les valeurs des échantillons du signal d’entrée.
ax = fig.gca(projection='3d')
t=np.linspace(0,1e-3,1000) surf = ax.plot_surface(XX, YY, f(XX,YY))
entree=2*np.sin(2*pi*10*t) plt.colorbar(surf)
t,sortie,bidon=lsim(sys,entree,T=t) ax.set_zlabel('Grandeur (unité)')
plt.plot(t,sortie) plt.xlabel('x (m)')
plt.show() plt.ylabel('y (m)')
À noter que scipy.signal possède une large bibliothèque de filtres directement utili- plt.show()
sables : butter, bessel, cheby1, cheby2, etc. Exemple de définition d’un filtre de Butter-
worth passe-bas d’ordre 5 et de fréquence de coupure 100 Hz :
B,A=butter(5,2*pi*100,'low', analog=True)
sys=lti(B,A)
Ces filtres numériques permettent de facilement lisser un signal très bruité.
s
sf
1.0

0.5
Signal (unit. arb.)

0.0

−0.5

−1.0

0.0 0.1 0.2 0.3 0.4 0.5

t (s)

–6–
Capacités numériques – TIPE : Fonctions Python utiles en calcul scientifique PSI - Lycée Lapérouse

→ représenter f (x,y) par un dégradé de couleur (pcolor) :

plt.pcolor(X, Y, f(XX,YY))
cbar = plt.colorbar()
cbar.set_label('Grandeur (unité)')
plt.xlabel('x (m)')
plt.ylabel('y (m)')
plt.show()

→ tracer les courbes de niveau de f (contour) :

plt.title('Grandeur (unité)')
liste=np.linspace(0,8,9)#liste des valeurs à afficher
lignes = plt.contour( X, Y, f(XX,YY), liste, colors='black')
plt.clabel(lignes, inline=1, fontsize=10) #pour afficher les
,→ valeurs
plt.contourf( XX, YY, f(XX,YY), liste) #pour colorer les régions
,→ entre les courbes de niveau
plt.xlabel('x (m)')
plt.ylabel('y (m)')
plt.show()

–7–