Vous êtes sur la page 1sur 36

Ingénierie numérique et

simulation

1 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


Fonctions utiles de numpy
Créer des tableaux numpy :
La fonction array prend en argument une liste et renvoie un
tableau numpy ayant les mêmes éléments. En cas de liste de listes,
l’opérateur s’applique récursivement à chaque sous–liste : la valeur
de retour est donc un tableau de tableaux.
Dans toute la suite on supposera qu’on a effectué :
Console python
>>>import numpy as np

Console python
>>> np.array([1, 2, 3]) # Un tableau d’entiers
array([1, 2, 3])
>>> np.array([1, 2, 3.0]) # On impose implicitement les flottants
array([ 1., 2., 3.])
>>> np.array([[1, 2], [3, 4]]) # Plus d’une dimensions
array([[1, 2],
[3, 4]])

2 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


arange, reshape :
Console python
>>> np.arange(1,6,2) # Même comportement que range, mais renvoie un
array
array([1, 3, 5])
>>> a = np.arange(25) # Tableau 1D à 25 éléments
>>> a.reshape((5,5)) # Changé en tableau 2D à 5*5 éléments
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19],
[20, 21, 22, 23, 24]])
Utilisation de matrix :
La classe des matrices, permet de faire du calcul matriciel
Console python
>>> import numpy as np
>>> A = np.matrix(np.arange(9).reshape((3,3)))
>>> A # La matrice A
matrix([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
3 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20
Console python(suite)
>>> A**2 # Son carré matriciel,
matrix([[ 15, 18, 21],
[ 42, 54, 66],
[ 69, 90, 111]])
>>> A.transpose() # Sa transposée
matrix([[0, 3, 6],
[1, 4, 7],
[2, 5, 8]])
>>> A*A.transpose() # Le produit matriciel avec la transposée
matrix([[ 5, 14, 23],
[ 14, 50, 86],
[ 23, 86, 149]])

Pour une matrice numpy m, il est possible d’accéder


directement à l’élément de ligne i et de colonne j avec la syntaxe
m[i,j] (alors qu’avec une matrice python “classique” il faudrait
écrire m[i][j]).

4 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


Exemple :
Console python
>>> a = [[2,3],[1,8]]
>>> b = np.array (a)
>>> b[1] # Ligne d’indice 1
array([1, 8])
>>> b[:,0] # Colonne d’indice 0
array([2, 1])
>>> b[:,-1] # Dernière colonne
array([3, 8])
>>> b[1,0] # Elément ligne 1 colonne 0
1

Ones et eye :
ones(n) : crée un tableau de longueur n contenant uniquement des 1.

ones((p,q)) : crée une matrice numpy avec p lignes et q colonnes


composée uniquement de 1.
La fonction eye(n) renvoie la matrice identité de taille n.
5 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20
Exemple :

Console python
>>> import numpy as np
>>> np.ones(2)
array([ 1., 1.])
>>> np.ones((2,3))
array([[ 1., 1., 1.],
[ 1., 1., 1.]])
>>> np.eye(2)
array([[ 1., 0.],
[ 0., 1.]])

Opérations sur les tableaux numpy :


Les opérations usuelles (addition, soustraction, multiplication,
division) s’appliquent aux tableaux Numpy en opérant coefficient
par coefficient.
6 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20
Exemple :
Console python
>>> a=np.array([[1,4],[1,2]])
>>> b=np.ones((2,2))
>>> a*b
array([[ 1., 4.],
[ 1., 2.]])
>>> a/b # Au sens matriciel usuel b n’est pas inversible
array([[ 1., 4.],
[ 1., 2.]])
>>> a**2
array([[ 1, 16],
[ 1, 4]])

Remarque :
Chaque fonction mathématique usuelle possède une fonction Numpy
qui lui est homonyme et qui calcule la même chose sur les objets de type float.
Par exemple il existe math.sin et np.sin L’avantage des fonctions numpy f,
c’est que si a est un tableau numpy a = array[a0, . . . , an-1], l’appel f(a) renvoie
le tableau array[f(a0), . . . , f(an-1)]. Ce mécanisme s’applique aussi aux
matrices.
7 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20
Exemple :
Console python
>>> import numpy as np
>>> x=np.array([3,4])
>>> np.exp(x)
array([ 20.08553692, 54.59815003])

>>> import math


>>> math.exp(x)
TypeError: only length-1 arrays can be converted to Python scalars
Produit matriciel :
dot(A,B) : le produit matriciel A.B
Exemple :
Console python
>>> from numpy.linalg import dot
>>> dot ([[1,2],[3,4]], np.eye(2)) # Syntaxe correcte du produit
matriciel
array([[ 1., 2.],
[ 3., 4.]])
>>> [[1,2],[3,4]] * np.eye(2) # Faux (produit terme a terme)
array([[ 1., 0.],
8 [ 0., 4.]])et simulation-MPSI/TSI/PCSI
Ingénierie numérique 11/04/20
Résolution d’un système de Cramer :
solve(A,B) : le vecteur X solution de A.X = B
Exemple : résolution de :  x  2 y  2

3x  4 y  8
Console python
>>> from numpy.linalg import solve
>>> solve ([[1,2],[3,4]], [2,8])
array([ 4., -1.])

Déterminant :
det(A) : le déterminant de A
Exemple :
Console python
>>> from numpy.linalg import det
>>> det ([[1,2],[3,4]])
-2.0000000000000004

9 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


Trace :
trace (A) : la trace de A.
Exemple :
Console python
>>> from numpy import trace
>>> trace([[1,2],[3,4]])
5

Inverse d’une matrice :


inv(A) : l’inverse de A (A-1)
Exemple :
Console python
>>> from numpy.linalg import inv
>>> inv ([[1,2],[3,4]])
array([[-2. , 1. ],
[ 1.5, -0.5]])

10 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


Puissance d’une matrice :
matrix_power(A,n) : A à la puissance n (An).
Exemple :
Console python
>>> from numpy.linalg import matrix_power
>>> matrix_power ([[1,2],[3,4]], -2)
array([[ 5.5 , -2.5 ],
[-3.75, 1.75]])

Transposée d’une matrice :


transpose (A) : la transposée de A (tA)
Exemple :
Console python
>>> from numpy import transpose
>>> transpose([[1,2],[3,4]])
array([[1, 3],
[2, 4]])
11 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20
rad2deg(), deg2rad() : conversion de radians en dégrées et vice
versa. Notez bien, que partout en Python les angles sont donnés en
radians ;
>>>import numpy as np
>>>np.deg2rad(180)
3.1415926535897931
cos(), sin(), tan() : les fonctions trigonométriques de base ;
arccos(), arcsin(), arctan() : les fonctions inverses de cos, sin et tan ;
ceil(), floor(), round() : arrondir une valeur ;
>>>np.ceil(3.01) # arrondi au plus petit entier supérieur
>>> np.floor(3.99) # arrondi au plus grand entier inférieur
>>> np.round(3.49) # arrondi au plus proche entier
12 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20
sort() : Trier les éléments;
>>>import numpy as np
>>> x = np.array([10, 2, 72, 35, 4, 123, 8])
>>> x.sort() #np.sort(x)
sum() : Somme des éléments de x ;
>>> x.sum() #sum(x)
var() : La variance des éléments ;
>>> x.var() #np.var(x)
std() : L’écart-type des éléments ;
>>> x.std() #np.std(x)
max() : La valeur maximale ;
>>> x. max() #max(x)
min() : La valeur minimale ;
>>> x. min() #min(x)
mean() : La moyenne ;
>>>x.mean() #np.mean(x)

13 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


Résolution d'équation algébrique
Résolution approchée d’une équation :
Dans la mesure où on ne sait pas résoudre de manière exacte toutes les
équations numériques que l’on peut être amené à rencontrer, il est
légitime de mettre au point des démarches permettant d’obtenir une
valeur approchée d’une solution d’équation.
La méthode de la dichotomie et la méthode de Newton sont deux
techniques permettant, de manière algorithmique, de calculer une
approximation d’une solution de l’équation f(x) = 0, où f est une
fonction définie sur un intervalle et à valeurs réelles.

Cadre de travail :
Dans la suite, on notera f une fonction continue sur un intervalle [a, b].
On supposera, en outre, que f s’annule en un unique point de [a, b],
que l’on notera xsol.

14 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


15 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20
Méthode de dichotomie :
Contexte de travail et idée de départ :
On suppose que :
f est continue sur [a, b];
f(a) et f(b) sont de signes contraires.
Démarche :
Technique à répéter :
On divise l’intervalle [a, b] en deux, et on ne garde que la section qui
contient la solution:
Pour cela, on examine le signe de f((a+b)/2):
Si f(a) et f((a+b)/2) sont de signes contraires, on se place alors sur [a,
(a+b)/2] ;
sinon, il faudra travailler sur [(a+b)/2,b].
Puis on recommence.

16 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


Langage python
def rech_solu_dichotomie(fonction,borne_inf,borne_sup,tolerance,nb_iterations_max)
:
milieu=(borne_sup+borne_inf)/2
nombre_iterations=0
while abs(fonction(milieu) ) >tolerance and
nombre_iterations<=nb_iterations_max :
if f(borne_inf)*f(milieu)<0 :
borne_sup=milieu
else :
borne_inf=milieu
milieu=(borne_sup+borne_inf)/2
nombre_iterations=nombre_iterations+1
return (milieu)
Remarques :
Dans Python, la bibliothèque scipy.optimize contient la méthode de
dichotomie ;
Pour l’utiliser, il suffit de charger la bibliothèque, puis d’appliquer la
fonction bisec en précisant (au moins) la fonction f considérée, ainsi que
les bornes borne_inf et borne_sup de l’intervalle de travail.

17 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


Console python
>>> from scipy .optimize import bisect
>>>…….
>>> bisect(f,borne_inf,borne_sup)

Méthode de Newton :
Contexte de travail et idée de départ :
On suppose que :
f est dérivable sur [a, b] ;
f ’ ne s’annule pas sur [a, b].

On va considérer que la représentation graphique Cf de f est «proche»


de sa tangente en un point : l’intersection de cette tangente avec (Ox)
doit nous « rapprocher » de xsol
18 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20
19 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20
Démarche :
Technique à répéter :
On considère un réel x0 dans I ; 
On considère alors la tangente à Cf au point d’abscisse x0, qui a pour
équation cartésienne y = f’(x0)(x−x0)+f(x0).
Le point d’intersection de cette droite et de l’axe des abscisses permet
d’approcher xsol :
on note ainsi x1 le réel vérifiant 0 = f’(x0)(x1−x0)+f(x0), c’est-à-
dire que l’on pose x1 = x0 –(f(x0)/f’(x0)).
Puis on recommence : le réel xn étant construit, on pose :
xLangage
n+1 = xn –(f(x n)/f’(xn))
python
def rech_solu_Newton(fonction,derivee_fonction,position_depart,tolerance,nb_iterations_max) :
xn =position_depart
nombre_iterations=0
while (abs(fonction(xn))>tolerance) and
(nombre_iterations<=nb_iterations_max) :
xn = xn -fonction(xn)/fonction_derivee(xn)
nombre_iterations=nombre_iterations+1
return (xn)
Ingénierie numérique et simulation-MPSI/TSI/PCSI
20 11/04/20
Remarques :
Dans Python, la bibliothèque scipy.optimize contient la méthode de
Newton ;
Pour l’utiliser, il suffit de charger la bibliothèque, puis d’appliquer la
fonction newton en précisant (au moins) la fonction f considérée, sa
dérivée der_f et la valeur initiale position_depart.

Console python
>>> from scipy .optimize import newton
>>>…….
>>> newton(f,position_depart,der_f)

21 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


Résolution approchée(numérique) d'une équation différentielle

De nombreux problèmes conduisent à la résolution d'équations


différentielles du premier ordre du type :

Lorsqu'il n'est pas possible d'obtenir une solution explicite sous


forme de fonctions usuelles, on détermine une solution
approchée(numérique). Il existe plusieurs méthodes permettant de
réaliser ceci. L'une d'entre elles est la méthode d'Euler qui sera
étudiée ici.

22 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


Méthode d'Euler :
On veut déterminer une solution approchée de l’équation
différentielle :

Où est une fonction continue sur l’intervalle [a,b].


avec une condition initiale : y(a)=y0
On considère une subdivision régulière t = (t0, t1, …, tn) de [a,b]
de pas h =(b-a)/n, on a donc : ti =t0+ih =a+ih
Si h est suffisamment petit on a :

Les approximations sont alors calculées de proche en proche par :

23 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


Programmation :
module scipy :
Le module scipy contint une fonction de résolution d'équations
différentielles.

La bibliothèque scipy.integrate contient la fonction odeint, qui


résout numériquement des équations différentielles. On
commence donc par la charger via :

from scipy.integrate import odeint

L'utilisation se fait sous la forme :


odeint(f, y0,T)

24 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


Exemple :

f(t,y)=y; a=0; b=1; T =[0, 0.25, 0.5, 0.75, 1], l'équation est donc :

Console python
>>> from scipy . integrate import odeint
>>>def f(y,t):
return (y)
>>> odeint(f,1,[0,0.25,0.5,0.75,1.0])
array([[ 1. ],
[ 1.28402541],
[ 1.64872127],
[ 2.11700009],
[ 2.7182819 ]])

25 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


Remarques :
Le tableau T peut être généré automatiquement de différentes
manières :
A l'aide d'une boucle for : T = [k/20 for k in range(21)]
T=[0.0,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.65,0.7,0.75,0.8,0.85,0.9,0.95,1.0].

La méthode habituelle est d'utiliser la fonction linspace du


module numpy qui construit un tableau dont les valeurs sont
équidistantes.
T=linspace(a,b,n) construit un tableau de n valeurs équidistantes
dont la première est a et la dernière b.
Console python
>>> from numpy import linspace
>>> T=linspace(0,1,21)
>>> T
array([ 0. , 0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 , 0.45, 0.5 , 0.55, 0.6 ,
0.65, 0.7 , 0.75, 0.8 , 0.85, 0.9 , 0.95, 1. ])

26 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


Il existe également la fonction arange du module numpy qui
s'utilise sous la forme :
arange(a,b,h) ou h est le pas, b étant exclu comme dans le cas de
range. Si on veut un tableau identique aux précédents on écrit :

Console python
>>> from numpy import arange
>>> T=arange(0,1.05,0.05)
>>> T
array([ 0. , 0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 , 0.45, 0.5 , 0.55, 0.6 ,
0.65, 0.7 , 0.75, 0.8 , 0.85, 0.9 , 0.95, 1. ])

27 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


Langage python

from numpy import *


def Phi(x,y):
………
return(z)

def Euler(a,b,Phi,y0,n):
"""Méthode d'Euler d'intégration approchée de
y'=Phi(x,y(x)) sur [a,b] avec condition initiale y0=f(a)
avec n+1 points"""
x=linspace(a,b,n+1)
y=empty(n+1) # tableau vide de n+1 éléments
y[0]=y0
pas=(b-a)/float(n)
for k in range(n):
y[k+1]=y[k]+pas*Phi(x[k],y[k])
return(y)

28 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


Résolution d’EDO 2ème ordre

Langage python

from scipy.integrate import *


def phi(Y,t) :
lamb,w0=0.01,1.0
y,ypoint=Y
return([ypoint,-2*lamb*ypoint-w0**2*y])
Y0=[1.,0.]
t=range(4)
d=odeint(phi,Y0,t)
S=d[:,0]

29 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


Langage python

from scipy.integrate import *


from numpy import *
def phi(Y,t) :
lamb,w0,A,w=0.01,1.0,1.5,2.
y,ypoint=Y
return([ypoint,-2*lamb*ypoint-w0**2*y+A*cos(w*t)])
Y0=[1.,0.]
t=range(4)
d=odeint(phi,Y0,t)
S=d[:,0]

30 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


Matplotlib
>>>import matplotlib.pyplot as plt
plot() : Pour tracer une courbe à partir d’un tableau de valeurs ;
>>> plt.plot(x,y)
show() : Pour ouvrir une fenêtre et afficher l’image crée ;
>>> plt.show()
savefig() : Pour enregistrer la figure dans un fichier image ;
>>> plt.savefig(‘fichier’)
xlabel(), ylabel() : Pour donner un nom aux axes ;
>>> plt.xlabel(‘axe des x’)
>>> plt.ylabel(‘axe des y’)
grid() : Pour ajouter une grille ;
>>> plt. grid(True)
title() : Pour ajouter le titre.
>>> plt. title(‘Le titre’)

31 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


32 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20
Tuples :
Structures de données
Un tuple est une séquence immuable : on ne peut pas modifier ses
éléments ni lui en ajouter ou lui en enlever ;
On crée un tuple en écrivant ses éléments, séparés par des virgules
et encadrés par des parenthèses. Si cela ne crée aucune ambiguïté,
les parenthèses peuvent être omises. Un tuple constitué d’un seul
élément a doit être écrit « a, » ou « (a,) ». Le tuple sans éléments
se note « () ».
Exemple :
Console python
>>> t = 2, ’deux’, 2.0, True, (1, 2, 3, 4)
>>> t
(2, ’deux’, 2.0, True, (1, 2, 3, 4))
>>> t, type(t), len(t)
((2, ’deux’, 2.0, True, (1, 2, 3, 4)), <type ’tuple’>, 5)
>>> t[1]
’deux’
>>> t[-1]
(1, 2, 3, 4)
33 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20
Ensembles :
Les ensembles sont des structures de données avec les
caractéristiques suivantes :
il n’y a pas d’accès indexé aux éléments, ni d’ordre entre ces
derniers ;
il n’y a pas de répétition des éléments : un élément
appartient ou non `a un ensemble, mais cela n’a pas de sens de se
demander s’il s’y trouve plusieurs fois.
On construit un ensemble par une expression de la forme
set(séquence)
où séquence est une donnée parcourable (liste, tuple, chaine de
caractères, etc.).
Exemple :
Console python
>>> s = set("abracadabra")
>>> s
set([’a’, ’r’, ’b’, ’c’, ’d’])

34 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


Dictionnaires :
Un dictionnaire, ou table associative, est une collection de
couples (clé, valeur) telle que :
il n’y a pas deux couples ayant la même clé ;
la structure est implémentée de manière que la recherche
d’une valeur à partir de la clé correspondante soit extrêmement
efficace.

On construit explicitement un dictionnaire par une expression


de la forme {clé1 : valeur1, clé2 : valeur2, ... clék : valeurk}

35 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20


36 Ingénierie numérique et simulation-MPSI/TSI/PCSI 11/04/20