P3 S6 Pa Chap3-1

CHAPITRE 3
Les librairies essentielles en sciences physiques
3.1 Calcul matriciel avec NumPy
NumPy, qui est le dimunitif de Numerical Python, est l'une des bibliothèques les plus fondamentales pour le calcul
numérique dans Python . La plupart des bibliothèques des calcul scientiques utilisent des ob jets de NumPy. Parmi
les fonctionnalités oertes par cette bibliothèque, on a :
1. La fonctionnalité ndarray qui permet de créer des matrices multidimensionnelles pour des calculs arithmétiques.
2. Des fonctions mathématiques pour des opérations rapides dans des tableaux entières sans utiliser des boucles.
3. Des outils pour écrire et lire des données sous des formats tableaux dans un disque sans avoir à utiliser des
boucles.
4. Faire de l'algèbre linéaire, générer des nombres aléatoires ou encore des capacités de faire des transformées de
Fourier ou de l'analyse spectrale et du traitement du signal d'une manière générale.
3.1.1 Les matrices et vecteurs

En tant que mathématiciens, nous sommes le plus souvent appelé à stocker des données sous forme de matrices ou
de vecteurs. Puisqu'il s'agit des listes particulières de données (listes homogènes), on serait tenté de les stocker dans des
listes, mais certaines opérations spéciques aux matrices et vecteurs, telles que la transposition, l'inversion, seraient
alors inapplicables. D'où l'introduction d'une manière diérente de créer ces structures particulières. Le vecteur étant
une matrice particulière (avec une seule ligne ou une colonne), nous n'allons pas trop nous attarder sur leur création.
La création de ces tableaux particuliers se fait avec la fonction numpy.array().
Pour créer une matrice (un tableau à deux dimensions), il faut transmettre à numpy.array() une liste de listes grâce
à des crochets imbriqués selon comme suit :
✿ Les éléments d'une ligne sont séparés d'une virgule.
✿ Chaque ligne s'ouvre par un crochet et se ferme par un crochet.
✿ Les lignes sont séparées d'une virgule et la matrice est entourée des crochets.
1 import numpy as np
2 a = np . array ([4 ,7 ,9]) # Cr é ation d ' une matrice d ' une ligne ( un vecteur ligne )
3 a = np . array ([[1 , 2 , 3] , [4 , 5 , 6]]) # Cr é ation d ' une matrice de 2 lignes et 3 colonnes
Des opérations spéciques dans les matrices, telles que la transposition, la multiplication élément par élément, le
changement de forme d'une matrice, la taille d'une matrice, la matrice conjuguée, peuvent être appliquées comme le
montre l'exemple suivant.
2 a = np . array ([[1 , 2 , 3] , [4 , 5 , 6]])
3 np . size ( a ) # Renvoie le nombre d 'é l é ments de la matrice
18
4 np . shape ( a ) # Renvoie la taille de la matrice ( nombre de lignes et nombre de colonnes )
5 b = np . array ([[2 , 1 , 3] , [3 , 2 , 1]])
6 a * b # Renvoie la matrice obtenue en multipliant les deux matrices , él é ment par é l é ment
7 2 * a # Renvoie la matrice obtenue en multipliant chaque é l é ment de a par 2
8 a + b # Renvoie la matrice obtenue en additionnant les deux matrices , é l é ment par é l é ment
9 2 + a # Renvoie la matrice obtenue en additionnant 2 à tous les é l é ments de a
10 1 / a # Renvoie la matrice obtenue en calculant l ' inverse de chaque é lé ment de a
11 a / 2 # Renvoie une matrice obtenue en divisant par 2 chaque é l é ment de a
12 a **2 # Renvoie une matrice obtenue en é levant chaque él é ment de a au carr é
13 np . dot (a , b ) # Renvoie le produit matriciel des deux matrices
14 a . T # Renvoie la transpos é e de la matrice a .
15 u = np . array ([[2 j ,4+3 j ] ,[2+5 j ,5] ,[3 ,6+2 j ]]) # D é finition d ' une matrice complexe
16 v = np . conj ( u ) # Renvoie la conjugu é e de la matrice u
Remarque. Certaines opérations matricielles précédentes ne sont possibles que sous certaines conditions, selon
l'algèbre linéaire :
1. Le produit élément par élément de deux matrices n'est possible que si les deux matrices ont la même forme
(même nombre de ligne et même nombre de colonnes).
2. Le produit matriciel, obtenu par num.dot, n'est possible que si le nombre de colonnes de la première matrice est
égal au nombre des lignes de la deuxième matrice.
3. Pour créer un vecteur colonne, on peut soit créer un vecteur ligne puis le transposer, soit en mettant chaque
élément entre crochets comme dans l'exemple suivant
1 v = array ([[1] ,[2] ,[3] ,[4] ,[5]]) # Cr é ation d ' un vecteur colonne
2 v = array ([1 ,2 ,3 ,4 ,5]) # Cr é ation d ' un vecteur ligne
3 v = v . T # Transposition pour avoir un vecteur colonne
4. On peut trouver la matrice adjointe (la matrice transposée de la matrice conjuguée) d'une matrice complexe u,
en cherchant la conjuguée de la transposée ou la transposée de la conjuguée.
La dénition d'une matrice (un vecteur) ne fait pas que par énumération. Comme les listes, une matrice peut se dénir
par compréhension. Dans ce cas, on utilise la fonctionarange ou la fonction linspace. La fonction arange est similaire
à la fonction range vue dans le cas des listes mais génère des array au lieu d'une liste. Ces deux fonctions arange
et linspace servant à créer des vecteurs lignes, numpy propose le redimensionnement avec la fonction reshape ou
shape. Il faut tout de même respecter une condition : le nombre d'éléments doit être le même ! On peut aussi créer,
le plus simplement possible, une matrice en utilisant la fonction mat qui agit comme dans la programmation sous
Matlab : les lignes sont séparées d'un espace et les colonnes d'un point-virgule.
2 a = np . arange (10) # cr é e un vecteur ligne de 0 à 9 avec un pas de 1
3 a = np . arange (2 , 3 , 0.1) # cr é e un vecteur ligne de 2 à 3 avec un pas de 0.1
4 a = np . linspace (1. , 4. , 6) # cr é e un vecteur de 6 é l é ments compris entre 1 et 4.
5 a = np . arange (16)
6 b = a . reshape (4 ,4) # Cr ée une matrice b de 4 lignes et 4 colonnes
7 a . shape = (4 ,4) # Transforme le vecteur a en une matrice de 4 lignes et 4 colonnes
8 a = np . mat ( ' [1 2 3; 4 5 6; 7 8 9] ') # Cr é ation d ' une matrice avec numpy . mat
Dans certains cas, comme lorsqu'on veut tracer la courbe représentative d'une fonction à deux variables, on a besoin
de créer deux matrices de coordonnées à partir de deux vecteurs axiaux. On utilise alors la fonction meshgrid de
numpy. La syntaxe est alors la suivante

2 nx , ny = (5 ,4)
3 x = np . linspace (0 ,1 , nx )
4 y = np . linspace ( -1 ,1 , ny )
5 xv , yv = np . meshgrid (x , y ) # Cr é ation des vecteurs xv et yv de 4 lignes et 5 colonnes
19
Indexation de base ou slicing. Lors de la manipulation des matrices, on a souvent besoin de récupérer un élément
ou une partie d'une matrice. Pour cela, Python permet d'extraire des tranches d'une matrice grâce une technique
appelée slicing (tranchage, en français). Elle consiste à indiquer entre crochets des indices pour dénir le début et la
n de la tranche et à les séparer par deux-points. Dans la tranche [n : m], l'élément d'indice n est inclus, mais pas
celui d'indice m.
1 a = np . array ([12 , 25 , 34 , 56 , 87 ,100]) # D é finition d ' un vecteur ligne
2 a [3] # Extrait le 4 e él é ment du vecteur a , ici 56
3 a [1:3] # Extrait le 2 e et 3 e é l é ment du vecteur a
4 a [0:6:2] # Extrait les él é ments de a , du premier au 5 e avec un pas de 2.
5 In []: M = np . array ([[1 , 2 , 3] ,[4 , 5 , 6]]) # Cr é ation d ' une matrice de 2 lignes et 3
colonnes
6 M [0 ,1] # Extrait l 'é l é ment qui est à la 1 re ligne , 2 e colonne , ici 2
7 M [: ,1:3] # Extrait la 2 e et 3 e colonne de M
8 M [: ,1] # Extrait la deuxi è me colonne de M
9 M [0 ,:] # Extrait la 1 re ligne de M
Remarque. En Python modier une donnée d'une extraction d'une matrice entraîne aussi une modication de la
matrice initiale ! Si nécessaire la fonction np.copy(a) ou a.copy() permet de faire une copie d'une matrice a.
1 a = np . array ([1 , 2 , 3 , 4 , 5]) # Cr é ation d ' un vecteur a
2 c = np . array ([1 , 2 , 3 , 4 , 5]) # Cr é ation d ' un vecteur c
3 b = a [1:3] # Extraction d ' une partie de a
4 b [1]=0 # On modifie le 2 e é l é ment de b
5 a
6 array ([1 , 2 , 0 , 4 , 5]) # le vecteur a a é t é modifi é
7 b = np . copy ( c [1:3]) # copie d ' une partie de c
8 b [1]=0 # On modifie le 2 e é l é ment de b
9 c
10 array ([1 , 2 , 3 , 4 , 5]) # le vecteur c n 'a pas é t é modifi é
Matrices particulières. On peut parfois être amené à créer des matrices particulières telles que la matrice nulle
(ayant des zéros partout), la matrice ayant des 1 partout ou la matrice unité (matrice identité). Ces matrices sont
créées par les fonctions zeros, ones, identity ou encore eye.

1 a =
np . zeros (5) # Cr é e un vecteur ligne de 5 z é ros
2 a =
np . zeros ((5 ,4) ) # Cr é e une matrice des z é ros de 5 lignes et 4 colonnes
3 a =
np . ones (7) # Cr é e un vecteur ligne ayant 7 é l é ments tous é gaux à 1
4 a =
np . ones ((5 ,6) ) # Cr é e une matrice 5 lignes et 6 colonnes avec des 1 partout
5 a =
np . eye (9) # Cr é e une matrice identit é ( carr é e ) de taille 9
6 a =
np . identity (5) # Cr é e une matrice identit é ( carr é e ) de taille 5
7 a =
np . diag ( v ) # Cr é e une matrice diagonale dont la diagonale est le vecteur v
8 a =
np . diag (v , k ) # Cr é e une matrice dont la " diagonale " d é cal é e de k est le vecteur v ( k
dans Z )
9 a = np . random . rand ( n ) # Cr é e un vecteur ( taille n ) à coefficients al é atoires uniformes sur
[0 ,1]
10 a = np . random . rand (n , p ) # Cr é e matrice ( taille n , p ) à coefficients al é atoires uniformes
sur [0 ,1]
3.1.2 Algèbre linéaire

En mathématiques, les opérations sur les matrices et les vecteurs sont vues comme des opérations d'algèbre linéaire.
Il s'agit par exemple du calcul du déterminant d'une matrice, de son inverse, de ses valeurs et vecteurs propres, de son
conditionnement ou encore de sa norme. Ces opérations son dénies dans le module linalg (pour Linear Algebra
20
en anglais) qui est contenu dans le paquet numpy. On peut alors charger tout le paquet, ou seulement le module pour
l'utilisation. Ici, nous chargerons tout le paquet comme nous l'avons fait depuis le début.
1 import numpy as np # On peut charger le module en faisant import numpy . linalg

2 A = np . random . rand ((5 ,5) )
3 trA = np . trace ( A ) # Trace de la matrice A
4 ranA = np . ndim ( A ) # Rang de la matrice A
5 detA = np . linalg . det ( A ) # D é terminant de A
6 invA = np . linalg . inv ( A ) # Inverse de A
7 pinvA = np . linalg . pinv ( A ) # Pseudo - inverse de A
8 D , V = np . linalg . eig ( A ) # Valeurs et vecteurs propres de A
On peut aussi résoudre le système linéaire d'équations Ax = b en utilisant la fonction solve du module linalg. Dans
ce cas, on a besoin de dénir la matrice A et le vecteur b.
2 A = np . random . rand (5 ,5)
3 b = np . random . rand (5)
4 x = np . linalg . solve (a , b ) # R é sout le syst è me Ax = b
5 np . allclose ( np . dot (a , x ) , b ) # V é rifie si on a bien Ax = b
On peut aussi calculer la décomposition en valeurs singulières, la décomposition QR, ou encore la résolution d'un
système linéaire en utilisant la méthode des moindres carrées.
2 a = np . random . randn (5 ,5)
3 b = np . random . randn (5)
4 x = np . linalg . solve (a , b )
Pour calculer la norme vectorielle/matricielle, on utiliser la fonction norm(x,ord) dénie dans le module linalg de
numpy et où ord représente la norme que l'on veut obtenir. Il prend alors les valeurs de :
✿ 'fro' pour la norme de Frobenius dénie par
✿ numpy.inf pour la norme innie dénie par
✿ -numpy.inf qui donne la norme dénie par
✿ 1 pour la norme 1 dénie par
✿ -1 qui donne la norme dénie par
✿ 2 qui donne la norme 2 ou la norme euclidienne
✿ -2 qui donne la plus petite valeur singulière.
Le calcul du conditionnement d'une matrice A se fait en utilisant la fonction cond(A, ord) dénie, elle aussi, dans le
module linalg de numpy et où ord peut prendre la même valeur que précédemment pour préciser sous quelle norme
le conditionnement est calculé. Si l'option est omise, Python renvoie par défaut la norme 2 en utilisant l'algorithme
de SVD.
1 import numpy . linalg as la
2 A = np . array ([[1 , 0 , -1] , [0 , 1 , 0] , [1 , 0 , 1]])
3 la . cond ( A ) # Conditionnement de A selon la norme 2
4 la . cond (A , ' fro ') # Conditionnement de A selon la norme de Frobenius
5 la . norm (a , ' fro ') # Norme de Frobenius
6 la . cond (a , np . inf ) # Conditionnement de A selon la norme infinie
7 la . norm (a , -2) # La plus petite valeur singuli è re de A
3.1.3 Les nombres pseudoaléatoires

Comme on l'a déjà fait à plusieurs reprises, on peut générer des nombres aléatoires avec la bibliothèque NumPy.
On peut générer ces nombres aléatoires suivantes diérentes distributions de lois de probabilité telles les lois uniforme,
normale, gaussienne ou encore la loi chi-deux.
21
2 samples = np . random . normal (0 ,4) # un nombre suivant la loi normale
3 samples = np . random . randn (4 ,4) # matrice suivant la loi normale centr é e r é duite
4 samples = np . random . normal ( size =(4 , 4) ) # matrice suivant la loi normale centr é e r é duite .
5 samples = np . random . uniform (0 ,4) # un nombre suivant la loi uniforme ( entre 0 et 4)
6 samples = np . random . rand (4 ,4) # matrice suivant la loi uniforme ( entre 0 et 1)
7 samples = np . random . randint (0 ,4) # Renvoie un entier entre 0 et 4
8 samples = np . random . gamma (1 ,4) # Un nombre suivant la loi Gamma
9 samples = np . random . chisquare (1 ,4) # Un vecteur suivant la loi Chi - deux
10 samples = np . random . beta (4 ,4) # Un nombre suivant la loi beta
Toutefois, il existe une bibliothèque plus spécique aux nombres aléatoires appelée random qui regroupe toutes les
gestions aléatoires dont on pourrait avoir besoin en utilisant diérentes distributions (gaussienne, uniforme, . . .).
Fonctions dénies dans le module random

nom de la fonction Python Rôle de la fonction
randrange(a,b) Renvoie un entier entre a et b
randint(a,b) renvoie un entier entre a et b
choice(liste) renvoie au hasard un élément de la liste
random() renvoie aléatoirement un réel entre 0 et 1

uniform(a, b) renvoie aléatoirement un réel entre a et b
betavariate(alpha, beta) renvoie un nombre aléatoire entre 0 et 1 suivant la loi β
expovariate(lambd) Renvoie une valeur aléatoire suivant la loi exponentielle
gammavariate(alpha, beta) Renvoie un nombre aléatoire suivant la loi Gamma
Marche aléatoire. Prenons un exemple de simulation de la marche aléatoire par l'utilisation des tableaux des
nombres pseudo-aléatoires. On considère une marche aléatoire commençant par 0 et dont la position suivante est
déterminée en a joutant +1 ou −1 avec une équiprobabilité. On fait alors 1000 marches (1000 pas) avec la bibliothèque
random.
1 import random
2
3 position =0
4 walk = [ position ]
5 steps = 1000
6 for i in range ( steps ) :
7 if random . randint (0 ,1) == True :
8 step = 1
9 else :
10 step = -1
11 position += step
12 walk . append ( position )
3.2 Visualisation des données avec Matplotlib
Comme sous Matlab, Python propose aussi un module pour la gestion des courbes représentatives des fonctions
à une ou plusieurs variables. matplotlib est une bibliothèque graphique de visualisation 2D (avec un support pour
la 3D, l'animation et l'interactivité), permettant des sorties de haute qualité prêtes à publier . C'est à la fois
une bibliothèque de haut niveau, fournissant des fonctions de visualisation clés en main (échelle logarithmique,
histogramme, courbes de niveau, etc.) et de bas niveau, permettant de modier tous les éléments graphiques de la
gure (titre, axes, couleurs et styles des lignes, etc.) Nous allons essentiellement utilisé le module pylab ou le sous-
modulepyplot de Matplotlib. L'avantage de pylab est qu'il charge à la fois les fonctions de numpy et celles de
Matplotlib que l'on peut donc utiliser directement.
22
3.2.1 Courbe représentative d'une fonction à une variable
On suppose dans un premier temps que l'on a une ou plusieurs fonctions fi d'une seule variable réelle dénies sur
des intervalles bien connus. Nous présenterons les diérentes fonctions Python prévues pour le tracé de leurs courbes
représentatives. Nous étudierons précisément les graphiques en coordonnées cartésiennes. Commençons par la fonction
sinus.
1 # Version standard 1 # Version pylab

2 import matplotlib . pyplot as plt 2 import pylab as pl
3 import numpy as np 3 import numpy as np
4 x = np . linspace ( -5 ,5 ,100) 4 x = np . linspace ( -5 ,5 ,100)
5 plt . plot (x , np . sin ( x ) ) 5 pl . plot (x , np . sin ( x ) )
6 plt . ylabel ( ' fonction sinus ') 6 pl . ylabel ( ' fonction sinus ')
7 plt . xlabel ( " l ' axe des abcisses " ) 7 pl . xlabel ( " l ' axe des abcisses " )
8 plt . title ( " Trac é de la fonction sinus " ) 8 pl . title ( " Trac é de la fonction sinus " )
Ici, les méthodes ylabel, xlabel et title xent respectivement la description de l'axe des ordonnées, l'axe des abscisses
et le titre de la gure. Il est aussi possible xer indépendamment les domaines des abscisses et des ordonnées en utilisant
les fonctions xlim(xmin,xmax) et ylim(ymin,ymax) où xmin, xmax, ymin, ymax sont les valeurs limites que l'on
souhaite aecter à notre gure. On peut aussi a jouter une légende à la courbe en appelant la fonction legend() après
qu'on ait utilisé l'option label dans la fonction plot. Dans la fonction legend, on peut utiliser l'option loc pour dénir
dans quelle partie de la gure on veut acher la légende (au coin haut à droite, au coin haut à gauche, ...). Il y a
plusieurs valeurs à donner pour la location parmi lesquelles :
✿ 'best' ou 0 qui permet de matplotlib de choisir le meilleur endroit où placer la légende (celle-ci est l'option par
défaut).
✿ 'upper right' ou 1 qui ache la légende en haut à droite de la gure.

✿ 'upper left' ou 2 qui ache la légende en haut à gauche de la gure.
✿ 'lower left' ou 3 qui ache la légende en bas à gauche de la gure.
✿ 'lower right' ou 4 qui ache la légende en bas à droite de la gure.
1 import pylab as pl
3 x = np . linspace ( -10 ,10 ,100)
4 y = np . sinc ( x )
5 pl . plot (x ,y , label = " sinc ( x ) " )
6 pl . xlabel ( " l ' axe des abscisses " )
7 pl . ylabel ( " axe des ordonn é es " )
8 pl . title ( " La fonction sinus cardinal ")
9 pl . xlim ( -5 ,5)
10 pl . legend ( loc = ' best ')
De plus, il est possible de préciser la couleur, le style de ligne et de symbole ('marker') en a joutant une chaîne de
caractères dans la fonction plot de la façon suivante plot(x,f,'marker'). Le choix du type et de la couleur du tracé
peut se faire avec le paramètre facultatif 'marker' qui est une chaîne composée de 1 à 3 caractères parmi ce qui suit.
Les diérents styles de ligne, les diérentes couleurs et les diérentes marker sont donnés dans les tableaux suivants :
Style de ligne
- ligne continue - - ligne discontinue : pointillés
Type de marqueurs Couleurs

. point o cercle x croix b bleu g vert
+ plus * étoile s carré r rouge c cyan
v losange < triangle gauche > triangle droit m magenta y jaune
p pentagone h hexagone d diamant k noir w blanc
23
1 import matplotlib . pyplot as plt
3 x = np . linspace ( -2* np . pi , 2* np . pi , 200)
4 y = np . sinc ( x )
5 plt . plot (x , y , " r : o " , label = " sinc ( x ) " )
6 plt . title ( " Fonction sinus cardinal " )
7 plt . xlabel ( " Axe des abscisses " )
8 plt . ylabel ( " Axe des ordonn é es " )
9 plt . legend ( loc = ' best ')
On peut aussi changer la largeur de la courbe en changeant la valeur de l'argument linewidth. Par défaut, la valeur
de cet argument est xé à 1. Il est aussi possible d'acher plusieurs courbes sur un même graphe en appelant autant
de fois la fonction plot qu'il y a des fonctions à acher.

3
4 x = np . linspace ( -10 ,10 ,500)

5 y = np . sin ( x )
6 plt . plot (x ,y , 'r - ', label = " sin (x ) " , linewidth
=3.0)
7 plt . plot (x , np . cos ( x ) , 'k -. ' , label = " cos ( x ) " )
8 plt . xlabel ( " l ' axe des abscisses " )
9 plt . ylabel ( " axe des ordonn é es " )
10 plt . title ( " Sinus et cosinus " )
11 plt . xlim ( -5 ,5)
12 plt . legend ( loc =0)
Les courbes paramétriques sont des courbes dont l'axe des abscisses n'est pas le vecteur de coordonnées T mais une
fonction de t, c'est-à-dire que leur tracé est une fonction y(t) qui se trace en fonction d'une autre fonction x(t). La
procédure de tracé de courbes paramétriques est identique à celles de courbes de fonctions mais on précise comme
premier vecteur (le vecteur des abscisses) la fonction x(t).

1 # courbes param é triques
4 1.0
5 def x ( t ) :
6 return np . sin (2* t )
0.5
8 def y ( t ) :
9 return np . sin (3* t ) 0.0
10
11 T = np . arange (0 ,2* np . pi ,0.01)

−0.5
12 X = x (T )
13 Y = y (T )
14 pl . plot (X ,Y , 'k - ') −1.0
−1.0 −0.5 0.0 0.5 1.0
15 pl . axis ( ' equal ')

16 pl . xlabel ( ' axe des abscisses ')
17 pl . ylabel ( ' axe des ordonn é es ')
Le tracé de courbes en coordonnées polaires sera réalisé par la fonction polar, qui obéit à la syntaxe suivante :
polar(theta, rho, 'type'). Le type de courbe correspond à la nature du tracé (continu, discontinu, etc.) et à sa
couleur. Les diérentes possibilités sont identiques à celles de la fonction plot. Nous allons dans ce qui suit, tracer les
graphiques en coordonnées polaires suivants : une rosace à quatre lobes et la spirale d'Archimède.
24
3
4 # Une rosace à quatre lobes

5 fig1 = pl . figure ()
6 t = np . arange (0 ,2* np . pi ,0.01)
7 pl . polar (t , np . sin (2* t )* np . cos (2* t ) , '
-k ')
8
9 # La spirale d ' Archim è de

10 fig2 = pl . figure ()
11 theta = np . arange (0 ,15* np . pi , np . pi
/20)
12 rho = np . arange (0 ,10 ,1/30)
13 pl . polar ( theta , rho , 'r -. ')
On peut sauvegarder directement notre image sous le format que l'on désire en appelant la fonction saveg après avoir
appelée toutes les fonctions liées à la gure en cours (titre, légende, axes, ...). Par exemple saveg("mongraphe.png")
enregistre le graphique sous le nom mongraphe.png dans le dossier courant. Les diérents formats possibles sont eps,
png, pdf, ps ou svg. Il est toujours conseillé de préciser, en plus de l'extension aux noms de chier, le format que l'on
désire comme saveg('toto.pdf',format='pdf').
Les sous-gures. On peut utiliser un système des sous-gures pour juxtaposer plusieurs graphiques dans la même
gure, sans qu'ils soient superposés sur la même fenêtre. On utilise la méthode subplot dont les arguments sont le
nombre des sous-gures par ligne, le nombre de sous-gures par colonne et le numéro de la sous-gure choisi.
3
4 fig = plt . figure ()

5 fig1 = fig . add_subplot (2 , 2 , 1)
Lorsqu'on appelle la fonction plot, matplotlib dessine cette gure sur la dernière sous-gure appelée, par exemple
3
4 fig = plt . figure ()

8 plt . plot ( np . random . randn (50) . cumsum () , 'k - - ')
va tracer la fonction en question dans la troisième sous-gure que l'on a appelée ici g3. Pour tracer alors des gures
sur les diérentes sous-gures créées, on trace la gure juste après la création de la sous-gure :
25
1 import matplotlib . pylab as plt
3
4 def f ( t ) :
5 return np . exp ( - t ) * np . cos (2* np . pi * t )
6
7 t1 = np . arange (0.0 , 5.0 , 0.1)

8 t2 = np . arange (0.0 , 5.0 , 0.02)
9 fig = plt . figure (1)
10 fig1 = fig . add_subplot (211)
11 plt . plot ( t1 , f ( t1 ) , ' bo ' , t2 , f ( t2 ) , 'k '
)
12 plt . title ( ' Cosinus amorti ')
13 fig2 = fig . add_subplot (212)
14 plt . plot ( t2 , np . cos (2* np . pi * t2 ) , 'r - - ')
15 plt . title ( ' Cosinus ')
Échelle logarithmique. Certains graphiques (évolution de l'erreur dans une approximation numérique) demandent
une échelle logarithmique (simple ou double). Les commandes semilogx(), semilogy() et loglog() mettent respec-
tivement le graphe à l'échelle logarithmique simple en x, logarithmique simple en y et double échelle logarithmique.
3
4 x = np . linspace (1 ,1000 ,50)

5
6 plt . loglog ()
7 plt . plot (x ,1./ x , 'r -* ' , label = 'f ( x ) = 1/ x ')
8 plt . plot (x ,1./ x **2 , 'b : ' , label = 'f ( x ) = 1/ x ^2 ')
9 plt . legend ()
10 plt . savefig ( " loglog . png " , format = ' png ')
3.2.2 Les diagrammes et les histogrammes
Pour créer un histogramme on utilise la méthode hist du module pylab ou matplotlib.pyplot. On peut lui donner
des données brutes et il s'occupera de faire les calcules nécessaires à la présentation du graphique. On a prit ici
l'exemple de 1000 tirage au sort (random) de valeur entre 0 et 150 et voici le résultat :

2 import random as rn
3
4 # 1000 tirages entre 0 et 150

5 x = [ rn . randint (0 ,150) for i in range (1000) ]
6 n , bins , patches = plt . hist (x , 50 , density
=1 ,\
7 facecolor = 'b ' , alpha =0.5)
8 plt . axis ([0 , 150 , 0 , 0.02])
9 plt . grid ( True )
10 plt . xlabel ( ' Mise ')
11 plt . ylabel ( ' Probabilit é s ')
Remarque. La valeur 50 donné en deuxième paramètre de la méthode hist indique le nombre de barres à acher.
Si vous lui passer une liste par exemple [25, 50] une seule barre sera achée comprenant l'intervalle 25; 50.
26
Diagramme circulaire. Une des graphiques les plus utilisés en statistiques doit être le diagramme circulaire (ou
camembert). On peut l'obtenir dans Python en utilisant la méthode pie de matplotlib.pyplot.

2
3 name = [ ' -18 ' , ' 18 -25 ' , ' 25 -50 ' , ' 50+ ']
4 data = [5000 , 26000 , 21400 , 12000]
5 explode =(0 , 0. , 0 , 0)
6 plt . pie ( data , explode = explode , labels = name ,\
7 autopct = ' %1.1 f %% ' , startangle =90 , shadow =
True )
8 plt . axis ( ' equal ')
Le paramètre autopct indique le pourcentage réel par rapport aux données fournies et la méthode axis("equal") rend
le diagramme parfaitement circulaire. En son absence lorsque vous rédimensionnez le graphique celui-ci s'adapte au
conteneur ce qui peut lui donner une forme elliptique. L'utilisation des données dans un vecteur explode indiquent
les espaces entre les parts. Nous prendre un exemple dans lequel on fera en sorte dans cet exemple, représentant la
population des grandes villes comoriennes, de séparer la plus grande part des autres parts.

2
3 villes = ' Moroni ' , ' Mutsamudu ' , ' Mitsamiouli ' ,\
4 ' Fomboni ' , ' Foumbouni '
5 habitants = [100 , 80 , 60 , 40 ,50]
6 couleurs = [ ' yellowgreen ' , ' gold ' , ' lightskyblue '
,\
7 ' lightcoral ' , ' blue ']
8 sep = (0.15 , 0 , 0 , 0 , 0)
9
10 plt . pie ( habitants , explode = sep , labels = villes ,\

11 colors = couleurs , autopct = ' %1.1 f %% ' ,\
12 shadow = True , startangle =90)
13 plt . axis ( ' equal ')
14 plt . savefig ( ' PieChart02 . png ')
La méthode bar permet de tracer un diagramme en barres sous Python . Il prend comme argument, les vecteurs x et
y width et la couleur des barres dans un paramètre color. Enn, la
à tracer, la taille des barres dans un paramètre
méthode stem, dont les arguments sont les vecteurs x, y et la lettre correspondant à la couleur, permet de tracer un
diagramme en bâtons.
3
4 x = np . linspace ( -2* np . pi ,2* np . pi ,51)

5 y = np . sinc ( x )
6 pl . figure ()
7 pl . subplot (211)
8 pl . bar (x , y , width =0.1 , color = 'k ')
9 pl . title ( " Diagramme en barres " )
10 pl . grid ( True )
11 pl . subplot (212)
12 pl . stem (x , y , 'k ')
13 pl . title ( u " Diagramme en b â tons " )
27
3.2.3 Surfaces tridimensionnelles et contours
Les courbe 3D. Le tracé de courbes dans l'espace se fera à l'aide de l'instruction plot comme dans le cas 2D mais
on tâchera d'importer la méthode Axes3D du module mpl_toolkits.mplot3d). Nous proposons comme exemple,
le tracé d'une hélice circulaire dénie par une équation paramétrique.
Hélice circulaire
3 from mpl_toolkits . mplot3d import Axes3D 80
4 60
5 ax = Axes3D ( pl . figure () ) 40
Axe des cotes

6 T = np . arange ( -10* np . pi ,10* np . pi ,0.001) 20
7 X = np . cos ( T ) 0
8 Y = np . sin ( T ) −20
9 Z = 2* T −40
10 ax . plot (X ,Y , Z ) −60
11 ax . set_xlabel ( " Axe des abscisses " ) −80
1.0
12 ax . set_ylabel ( u " Axe des ordonn é es " )
0.5
13 ax . set_zlabel ( " Axe des cotes " ) s
−1.0 ée
14 ax . set_title ( u " H é lice circulaire " ) 0.0 onn
−0.5 rd
o
15 pl . grid ( True ) Axe d 0.0 −0.5 des
es abs e
cisses 0.5 Ax
1.0 −1.0
Les surfaces On peut tracer une surface d'une fonction à deux variables, en utilisant la fonction plot_surface, qui
prend pour arguments de base la matrice des abscisses x, la matrice des ordonnées y et la matrice des images de chaque
point de l'espace. En plus de ces arguments obligatoires, on peut préciser à Python quelle forme de couleur veut-on
cmap. Il existe plusieurs types de palettes des couleurs et les plus

pour la courbe que on renseigne avec le paramètre
utilisées sont :Accent, Blues, BrBG, BuGn, BuPu, CMRmap, Dark2, GnBu, Greens, Greys, OrRd,
Oranges, PRGn, Paired, Pastel1, Pastel2, PiYG, PuBu, PuBuGn, PuOr PuRd, Purples, RdBu, RdGy,
RdPu, RdYlBu, RdYlGn, Reds, Set1, Set2, Set3, Spectral, Wistia, YlGn, YlGnBu, YlOrBr, YlOrRd,
afmhot, autumn, binary, bone, brg, bwr, cool, coolwarm, copper, cubehelix, gnuplot, gnuplot2, gray,
hot, hsv, jet, ocean, pink, prism, rainbow, seismic, spectral, spring, summer, terrain, winter.
3 from mpl_toolkits . mplot3d import Axes3D
4 ax = Axes3D ( pl . figure () )
5
8
Axe des cotes
6 X = np . linspace ( -5 ,5 ,200) 6
7 Y = X 4
8 X ,Y , = np . meshgrid (X , Y )
2
9 Z = 10* np . exp ( -( X **2+ Y **2) )
10 ax . plot_surface (X ,Y ,Z , cmap = ' GnBu_r ')
11 ax . set_xlabel ( " Axe des abscisses " ) 4
2 e s
12 ax . set_ylabel ( u " Axe des ordonn é es " ) né
−4 0
r don
13 ax . set_zlabel ( " Axe des cotes " ) −2 −2 es o
Axe de 0
pl . savefig ( ' GnSurf . eps ') s abscis 2 −4 Axe d
14 ses 4
Lignes de niveau. Avec les fonctions de tracé de surfaces nous avons abordé la possibilité de visualiser une pro jection
des contours de la surface sur le plan (Ox, Oy). Python fournit une fonction spéciale pour dessiner les lignes de niveau.
Il s'agit de la fonction contour qui prend en arguments les matrices x, y et z et le nombre de lignes de niveau à tracer.
28
2 import numpy as np 200 contours de la fonction sinc(x) +sinc(y)
3
4
4 def f (x , y ) :
5 return np . sinc ( x ) + np . sinc ( y )
6 2
X = np . linspace ( -5 ,5 ,200)
Axe des ordonnées

7
8 Y = X
0
9 X ,Y , = np . meshgrid (X , Y )
10 Z = f (X , Y )
11 pl . contour (X ,Y ,Z ,100) −2
12 pl . xlabel ( " Axe des abscisses " )

13 pl . ylabel ( u " Axe des ordonn é es " ) −4
14 pl . title ( u ' 200 contours de la fonction \
−4 −2 0 2 4
15 $ \ sinc ( x ) + \ sinc ( y ) $ ') Axe des abscisses
3.3 Modélisation numérique avec SciPy
SciPy est une librairie Python pour des fonctions et procédures mathématiques. La plupart de ces fonctions sont
des fonctions dérivées des bibliothèques numériques écrites initialement en Fortran, C ou C++ pour le calcul numérique
en sciences et en ingénierie. C'est une libraire assez complète dont il est quasi-impossible de faire un tour complet. Ici,
on fera surtout un tour d'horizon sur les fonctions spéciales, l'algèbre linéaire, l'intégration numérique, la résolution
des équations nonlinéaire, les transformées de Fourier et les équations diérentielles. Ce tour d'horizon ne fera pas un
détail extensive sur les méthodes numériques employées. Toute la théorie de l'analyse numérique ne sera pas considérée
dans ce cours. Seules les méthodes de résolution des problèmes seront présentées. L'ob jectif étant d'arriver à résoudre
numériquement un problème sans se focaliser sur les théories de convergence et de précision.
Il faut noter que SciPy utilise souvent les tableaux et matrices de NumPy. Il faut alors importer NumPy avec Scipy
à chaque utilisation.
3.3.1 Systèmes d'équations linéaires

La librairie SciPy, tout comme NumPy, permet de résoudre des problèmes d'algèbre linéaire. On se xe ici sur
deux problèmes qui interviennent souvent dans des applications : Les systèmes d'équations linéaires et les problèmes
aux valeurs propres. Ces outils sont dénis dans la sous-bibliothèque scipy.linalg comme pour numpy. Rappelons
des fonctions déjà rencontrées en NumPy mais qui sont aussi dénies dans SciPy :
2 import scipy as sp
3 A = np . array ([[1 ,2 ,3] ,[3 ,2 , -1] ,[0 ,1 ,3]])
4 detA = sp . linalg . det ( A )
5 invA = sp . linalg . inv ( A )
6 pinvA = sp . linalg . pinv ( A )
7 eigval , eigvec = sp . linalg . eig ( A )
La résolution des systèmes d'équations linéaires demande simplement la construction de la matrice des coecients et
le vecteur du second membre. Supposons que nous avons le système suivant d'équations linéaires à résoudre :


 2x1 +4x2 +6x3 = 12
x1 −3x2 −9x3 = −11


8x1 +5x2 −7x3 = 6
29
On peut réécrire ce système sous la forme matricielle Ax = b avec
     
2 4 6 x1 12
     
A = 1 −3 −9 , x = x2  , b = −11 .
8 5 −7 x3 6
Ensuite, on peut résoudre ce système sur Python à l'aide de la fonction solve du NumPy ou de SciPy.
3 A = np . array ([[2 , 4 , 6] , [1 , -3 , -9] , [8 , 5 , -7]])
4 b = np . array ([12 , -11 , 6])
5 x = sp . linalg . solve (A , b )
On peut aussi résoudre ce problème en calculant l'inverse de la matrice A. En eet, si Ax = b, alors x = A−1 b.
L'inverse d'une matrice est calculée avec la fonction inv. On aura alors
3 A = np . array ([[2 , 4 , 6] , [1 , -3 , -9] , [8 , 5 , -7]])
4 b = np . array ([12 , -11 , 6])
5 invA = sp . linalg . inv ( A )
6 x = np . dot ( invA , b )
Toutefois, il faut noter que l'utilisation de la méthode scipy.linalg.solve est plus rapide et numériquement plus
stable que l'utilisation de la méthode scipy.linalg.inv. Il est donc préférable d'utiliser la fonction solve pour la
résolution des systèmes d'équations linéaires.
Activité 3.3.1 :
L'une des applications les plus importantes de l'algèbre linéaire à l'élec-
tronique est d'analyser des circuits électroniques qui ne peuvent pas être
décrits en utilisant les règles des résistances en série ou en parallèle comme
celle illustrée à droite. Le but est de calculer le courant circulant dans
chaque branche du circuit ou de calculer la tension à chaque n÷ud du
circuit.
Connaissant les courants de dérivation, les tensions nodales peuvent être facilement calculées, et connaissant les
tensions nodales, les courants de dérivation peuvent facilement être calculés. L'analyse de boucle trouve direc-
tement les courants et l'analyse nodale trouve les tensions directement. La méthode la plus simple dépend du
circuit donné. L'analyse nodale est importante car ses réponses peuvent être directement comparées aux mesures
de tension prises dans un circuit, alors que les courants ne sont pas si faciles à mesurer dans un circuit (il faut
couper les ls électriques pour mesurer les courants)
On peut résoudre le problème posé ci-dessus soit en utilisant Analyse du courant de boucle des circuits électriques
ou encore L'analyse des tensions nodales d'un circuit. Pour la méthode d'analyse du courant des boucles dans un
circuit, nous mettons en place et résolvons un système d'équations dans lequel les inconnues sont des courants de
boucle. Les courants dans les diérentes branches du circuit sont alors facilement déterminés à partir des courants
de boucle.
Les étapes de la méthode du courant de boucle sont les suivantes :
1. Compter le nombre de courants de boucle requis. On appellera ce nombre m.

2. Choisir m courants de boucle indépendants, on les notera i1 , i2 , . . . , im puis les dessiner sur le schéma de
circuit.
3. Écrire la loi de tension de Kircho pour chaque boucle. Le résultat, après simplication, est un système de
m équations linéaires dans les n courants de boucle inconnus sous cette forme
30


R11 i1 + R12 i2 + · · · + R1m im = V1




R21 i1 + R22 i2 + · · · + R2m im = V2
.

 .

 .


R + Rm2 i2 + · · · + Rmm im = Vm
m1 i1
avec Rij et Vi des constantes.
4. Finalement, on pourra résoudre le système d'équations linéaires ainsi formé en utilisant la fonction np.linalg.solve
de numpy.
5. Finalement, déduire l'intensité du courant qui passe par chaque branche du circuit.
En appliquant ceci dans le circuit électrique ci-haut, on obtient la gure
ci-contre qui nous donne 3 boucles de circuits. En écrivant les équations
dans chaque boucle, on obtient le système suivant que l'on peut résoudre
par n'importe quelle méthode numérique, puis distribuer les intensités des
courants dans chaque branches du circuit.
 

 1i + 25(i1 − i2 ) + 50(i1 − i3 ) = 10 
76i − 25i2 − 50i3 = 10

 1 
 1
25(i2 − i1 ) + 30i2 + 1(i2 − i3 ) = 0 =⇒ −25i1 + 56i2 − 1i3 =0

 


50(i − i ) + 1(i − i ) + 55i = 0, 
−50i + 56i + 106i
3 1 3 2 3 1 2 3 = 0,
1. Écrire le système linéaire précédent sous sous matriciel, c'est-à-dire sous la forme Ax = b avec A une matrice
carrée et b un vecteur que l'on déterminera.
2. Écrire un programme Python dans lequel on dénira la matrice A et le vecteur b précédemment établis.
3. Résoudre le système linéaire Ax = b en utilisant la fonction numpy appropriée. En déduire la valeur de i1 ,

i2 et i3 .
3.3.2 Résolution des équations nonlinéaires

Très souvent dans des problèmes en physique, on est appelé à résoudre des équations de la forme f(x) = y, c'est-
à-dire trouver des valeurs de x pour lesquelles une fonction numérique f donnée atteigne une certaine valeur connue.
On peut alors faire appel à l'outil root du module scipy.optimize qui cherche la racine d'une fonction donnée. Par
exemple, pour résoudre l'équation
x2 + 5 sin(x) = 2,
on peut la transformer en un problème de calcul de racines par
x2 + 5 sin(x) − 2 = 0.
3 from scipy import optimize as opt
4
5 def f ( x ) :
6 return x * x + 5* np . sin ( x ) - 2
7
8 x = np . linspace ( -4 , 4 , 40)
9 x0 = 0
10
11 sol = opt . root (f , x0 )

12
13 print ( " La racine de f est x = {:.2 f } "
31
14 . format ( sol . x [0]) )
15
16 plt . plot (x , f ( x ) , 'r - ')

17 plt . plot ( sol .x , sol . fun , " ok " )
On peut utiliser d'autres fonctions telle que scipy.optimize.bisect qui est basée sur la méthode de bissection (de
dichotomie) pour la résolution d'une équation nonlinéaire, ou encore la fonction scipy.optimize.newton qui est une
méthode de type point xe pour la recherche des racines d'une fonction. La fonction bisect prend en arguments la
fonction f ainsi que les bornes d'un intervalle [a, b] sur lequel on cherche les racines tandis que la fonction newton
prend en argument la fonction f et un point de départ x0 . Par exemple, On peut alors résoudre cette équation en
cherchant les racines de la nouvelle fonction
1 import numpy as np 1 import numpy as np

2 import matplotlib . pyplot as plt 2 import matplotlib . pyplot as plt
3 from scipy import optimize as opt 3 from scipy import optimize as opt
4 4
5 def f ( x ) : 5 def f ( x ) :
6 return x * x + 5* np . sin ( x ) - 2 6 return x * x + 5* np . sin ( x ) - 2
7 7
8 x = np . linspace ( -4 , 4 , 40) 8 x = np . linspace ( -4 , 4 , 40)

9 a , b = 0 ,2 9 x0 = 0
10 10
11 xopt = opt . bisect (f , a , b ) 11 xopt = opt . newton (f , x0 )

12 12
13 print ( " La racine de f est x = {:.2 f } " 13 print ( " La racine de f est x = {:.2 f } "
14 . format ( xopt ) ) 14 . format ( xopt ) )
15 15
16 plt . plot (x , f ( x ) , 'r - ') 16 plt . plot (x , f ( x ) , 'r - ')

17 plt . plot ( xopt , f ( xopt ) , " ok " ) 17 plt . plot ( xopt , f ( xopt ) , " ob " )
On peut aussi se servir de la fonction root pour la résolution des systèmes d'équations nonlinéaires. Prenons par
exemple le système

x + 1
(x − y)
=0
3
2
 1 (y − x)3 + y = 0
2
On peut alors recherche une racine de cette fonction bidimensionnelle avec le code suivant :
2 from scipy import optimize as opt

3
4 def f ( x ) :
5 return [ x [0] + 0.5 * ( x [0] - x [1]) **3 - 1.0 ,
6 0.5 * ( x [1] - x [0]) **3 + x [1]]
7
8 sol = opt . root (f , [0 , 0] , method = ' hybr ')

9 print ( sol . x)
3.3.3 Résolution des équations diérentielles

La plupart des problèmes en physique sont régis par des équations diérentielles ou des équations aux dérivées
partielles dont on ne connaît pas la solution. Pour résoudre ces équations à l'aide de Python, on peut se servir de
la fonction odeint du module integrate. La syntaxe est odeint(f,y0,t) où f est le second membre de l'équation
diérentielle, y0 la condition initiale et t est l'intervalle du temps dans lequel on veut résoudre le problème
32
Prenons par exemple, l'équation diérentielle dénie sur [−2π, 2π] par

y ′ (t) = sin(t) sin(y),
y = 1.
0
On aura alors le résultat suivant
3 from scipy . integrate import odeint
4 # Initialiser les donnees ici . On
prendre N = 200
5 y0 = 1
6 def f (t , y ) :
7 return np . sin ( t ) * np . sin ( y )
8 # definir le vecteur temps en utilisant
linspace
9 t = np . linspace ( -2* np . pi ,2* np . pi ,100)
10 y = odeint (f , y0 ,t )
11 plt . plot (t ,y , 'k -* ')
La résolution des systèmes diérentielles se fait de la même façon en dénissant la fonction f et la condition initiale sous
forme vectorielle. Prenons l'exemple du système de Lotka-Volterra, qui modélise la dynamique de deux populations
données dans un écosystème fermé. La population y est considérée comme prédatrice et x comme des proies. Les seules
causes de mortalité des proies et l'absence de nourriture (manque de proies) tandis que la seule cause de mortalité des
proies et l'abondance des prédateurs. C'est un système diérentiel du premier ordre déni par :

x = x(a − by)
(3.1)
y = y(−c + dx)
x(0) et y(0) donnés, a, b, c et d des paramètres strictement positifs. Ce système peut s'écrire sous la forme matricielle
! !
x(t) x(t)(a − by(t))
Y(t) = F(t, Y), avec Y(t) = et F(t, Y) = .
y(t) y(t)(−c + dx(t))
Dans toute la suite, on prendra a = b = c = d = 1, x(0) = 4, y(0) = 2, Tmax = 30 et N = 1000.
Le code suivant dénit la fonction F, puis se sert de la fonction odeint pour résoudre le problème
1 import matplotlib . pylab as plt

3 from scipy . integrate import odeint
4
5 x0 , y0 = 4. ,2
6
7 def F (Y , t ) :
8 [x , y ] = Y
9 xp = x *(1 - y)
10 yp = y *( -1 + x )
11 return [ xp , yp ]
12 N ,T , t0 = 1000 ,30 ,0
13 t = np . linspace (0. , T , N )
14 Y0 = [ x0 , y0 ]
15
16 # Solution numerique
17 Y = odeint (F , Y0 , t )
33
18
19 # Evolution des populations en fonction du temps

20 plt . figure ()
21 plt . grid ()
22 plt . title ( " Lotka - Volterra " )
23 plt . plot (t , Y [: ,0] , ' - xb ' , label = ' Proie ')
24 plt . plot (t , Y [: ,1] , '+ - k ' , label = " Pr é dateur " )
25 plt . xlabel ( ' Temps t , [ jours ] ')
26 plt . ylabel ( ' Population ')
27 plt . legend ()
28 plt . show ()
29
30 # Courbe des phases ( les pr é dateurs en fonction des proies )

31 plt . figure ()
32 plt . grid ()
33 plt . title ( " Lotka - Volterra " )
34 plt . plot ( Y [: ,0] , Y [: ,1] , ' -b ' , label = ' Courbe des phases ')
35
36 plt . xlabel ( ' Proies ')

37 plt . ylabel ( ' Pr é dateurs ')
38 plt . legend ()
39 plt . show ()
Activité 3.3.2 :
Considérons le circuit électronique de la gure ci-contre, composé d'une résistance R
et d'une bobine d'inductance L (on néglige r) alimenté par une tension e(t). Comme
il n'y a qu'une seule boucle, l'intensité i est la même dans tout le circuit. Il y a en
revanche 3 tensions : e, UR et UL .
L'objectif de cet exercice est de trouver l'expression au cours du temps de i(t) connaissant e(t). On considérera
que i(0) = 0 et que e(t) est un échelon de tension, c'est-à-dire qu'il existe E > 0 tel que

0 si t<0
e(t) =
E sinon.
34
1. En appliquant la loi des mailles, montrer que l'intensité i est solution de l'équation diérentielle
di(t) R E
+ i(t) = .
dt L L
2. Déterminer la solution analytique de cette équation diérentielle et montrer qu'elle peut se mettre sous la
forme
E t

i(t) = 1 − e− τ ,
R
avec τ une constante à déterminer.
3. En déduire la limite de i(t) lorsque t tend vers l'inni.
4. Exprimer la formule permettant de résoudre numériquement cette équation diérentielle par la méthode
d'Euler explicite (avec un pas de h = 0.02s).

5. En donnant à L, R et à E des valeurs de votre choix, calculer l'intensité approchée par numériquement
6. Tracer la courbe de la solution exacte et celle de la solution approchée dans la même gure.
35

P3 S6 Pa Chap3-1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

P3 S6 Pa Chap3-1

Transféré par

Droits d'auteur :

Formats disponibles

CHAPITRE 3

Les librairies essentielles en sciences physiques

3.1 Calcul matriciel avec NumPy

les fonctionnalités oertes par cette bibliothèque, on a :

Fourier ou de l'analyse spectrale et du traitement du signal d'une manière générale.

3.1.1 Les matrices et vecteurs

La création de ces tableaux particuliers se fait avec la fonction numpy.array().

à des crochets imbriqués selon comme suit :

✿ Les éléments d'une ligne sont séparés d'une virgule.

✿ Chaque ligne s'ouvre par un crochet et se ferme par un crochet.

montre l'exemple suivant.

(même nombre de ligne et même nombre de colonnes).

élément entre crochets comme dans l'exemple suivant

numpy. La syntaxe est alors la suivante

créées par les fonctions zeros, ones, identity ou encore eye.

3.1.2 Algèbre linéaire

1 import numpy as np # On peut charger le module en faisant import numpy . linalg

système linéaire en utilisant la méthode des moindres carrées.

✿ numpy.inf pour la norme innie dénie par

✿ -numpy.inf qui donne la norme dénie par

✿ 1 pour la norme 1 dénie par

✿ -1 qui donne la norme dénie par

✿ 2 qui donne la norme 2 ou la norme euclidienne

✿ -2 qui donne la plus petite valeur singulière.

3.1.3 Les nombres pseudoaléatoires

normale, gaussienne ou encore la loi chi-deux.

Fonctions dénies dans le module random

random() renvoie aléatoirement un réel entre 0 et 1

gammavariate(alpha, beta) Renvoie un nombre aléatoire suivant la loi Gamma

3.2 Visualisation des données avec Matplotlib

1 # Version standard 1 # Version pylab

plusieurs valeurs à donner pour la location parmi lesquelles :

✿ 'upper right' ou 1 qui ache la légende en haut à droite de la gure.

Type de marqueurs Couleurs

+ plus * étoile s carré r rouge c cyan

v losange < triangle gauche > triangle droit m magenta y jaune

p pentagone h hexagone d diamant k noir w blanc

de fois la fonction plot qu'il y a des fonctions à acher.

1 import matplotlib . pyplot as plt

4 x = np . linspace ( -10 ,10 ,500)

premier vecteur (le vecteur des abscisses) la fonction x(t).

11 T = np . arange (0 ,2* np . pi ,0.01)

15 pl . axis ( ' equal ')

4 # Une rosace à quatre lobes

9 # La spirale d ' Archim è de

désire comme saveg('toto.pdf',format='pdf').

4 fig = plt . figure ()

4 fig = plt . figure ()

7 t1 = np . arange (0.0 , 5.0 , 0.1)

4 x = np . linspace (1 ,1000 ,50)

3.2.2 Les diagrammes et les histogrammes

1 import matplotlib . pyplot as plt

4 # 1000 tirages entre 0 et 150

camembert). On peut l'obtenir dans Python en utilisant la méthode pie de matplotlib.pyplot.

1 import matplotlib . pyplot as plt

10 plt . pie ( habitants , explode = sep , labels = villes ,\

4 x = np . linspace ( -2* np . pi ,2* np . pi ,51)

Axe des cotes

cmap. Il existe plusieurs types de palettes des couleurs et les plus

Axe des ordonnées

12 pl . xlabel ( " Axe des abscisses " )

3.3 Modélisation numérique avec SciPy

numériquement un problème sans se focaliser sur les théories de convergence et de précision.

les fonctionnalités oertes par cette bibliothèque, on a :

✿ numpy.inf pour la norme innie dénie par

✿ -numpy.inf qui donne la norme dénie par

✿ 1 pour la norme 1 dénie par

✿ -1 qui donne la norme dénie par

Fonctions dénies dans le module random

✿ 'upper right' ou 1 qui ache la légende en haut à droite de la gure.

de fois la fonction plot qu'il y a des fonctions à acher.

désire comme saveg('toto.pdf',format='pdf').

couper les ls électriques pour mesurer les courants)

En appliquant ceci dans le circuit électrique ci-haut, on obtient la gure

3.3.3 Résolution des équations diérentielles

3. En déduire la limite de i(t) lorsque t tend vers l'inni.