#Calcul scientifique en Python

NumPy : manipulation de vecteurs et de matrices

NumPy est une bibliothèque sous Python, destinée à manipuler des matrices ou tableaux
multidimensionnels ainsi que des fonctions mathématiques opérant sur ces tableaux.

Les tableaux numpy sont sous-jacents à de nombreux packages dédiés au calcul scientifique
sous Python.

Le manuel ede référence : http://docs.scipy.org/doc/numpy/reference/index.html

Pour commencer, il faut importer Numpy au début du programme et ensuite on peut utiliser les
fonctions qu'y sont pre-définies. Par exemple, on définit des tableaux et on fait des opérations
arithmetiques avec les valeurs qu'ils contiennent.

Attention, les tableaux « numpy » ne gèrent que les objets de même type (ci dessous des
entiers).

import numpy as np #par la suite on utilisera l'alias np pour numpy

# définir un vecteur
v = np.array([1, 12, 3, 18],dtype=float)
print(v)
print(type(v))
print(v.size)

[ 1. 12. 3. 18.]
<class 'numpy.ndarray'>
4

On peut facilement définir des arrays contenants des séquences de valeurs numériques avec la
fonction arange() :

# 1 parametre : donne la longueur de la sequence(en partant de zero)

v = np.arange(3)
print(v)

# 2 parametres : debut et fin de la sequence (attention, les indices

commencent a zero, la derniere valeur est donc exclue)
v = np.arange(3,9)
print(v)

# 3 parametres : début, fin de la sequence et increment (ici le pas

est de deux)
v = np.arange(3,9,2)
print(v)

# egalement avec des valeurs non entieres

v = np.arange(0, 11*np.pi, np.pi)
print (v)

[0 1 2]
[3 4 5 6 7 8]
[3 5 7]
[ 0. 3.14159265 6.28318531 9.42477796 12.56637061
15.70796327
18.84955592 21.99114858 25.13274123 28.27433388 31.41592654]

La fonction linspace() permet d’obtenir un array allant d’une valeur de départ à une valeur de fin
avec un nombre donné d’éléments (elle sera utilisé dans la section suivante sur Matplotlib).

# de 3 a 9 avec 10 elements equidistants

np.linspace(3, 9, 10)

array([3. , 3.66666667, 4.33333333, 5. , 5.66666667,

6.33333333, 7. , 7.66666667, 8.33333333, 9. ])

Rajouter/supprimer une valeur dans un array :

a = np.array([1.2,2.5,3.2,1.8])
a = np.append(a,10)
print(a)

#concatenation 2 vecteurs
x = np.array([1,2,5,6])
y = np.array([2,1,7,4])
z = np.append(x,y)
print(z)

#suppression via indice

b = np.delete(a,2)
print(b)
a = np.array([1,2,3])

[ 1.2 2.5 3.2 1.8 10. ]

[1 2 5 6 2 1 7 4]
[ 1.2 2.5 1.8 10. ]

Accès aux valeurs par indice :

v = np.array([1.2,7.4,4.2,8.5,6.3])
print(v[0]) # le 1er indice est 0 (zéro)

#dernière valeur
print(v[v.size -1]) #v.size est ok parce que v est un vecteur
# ou aussi
print(v[-1])
#du début à l'indice 3 (non-inclus)
print(v[:3])

#de l'indice 2 à la fin

print(v[2:])

#plage d'indices contigus

print(v[1:5])

#de l'indice 1 à 5 avec un pas de 2

print(v[1:5:2])

1.2
6.3
6.3
[1.2 7.4 4.2]
[4.2 8.5 6.3]
[7.4 4.2 8.5 6.3]
[7.4 8.5]

Tri et recherche :

v = np.array([1.2,7.4,4.2,8.5,6.3])

#recherche valeur max

print(np.max(v))

#recherche valeur min

print(np.min(v))

#recherche indice de valeur max

print(np.argmax(v))

# somme des valeurs

print(np.sum(v))

#tri des valeurs

print(np.sort(v))

#valeurs distinctes
a = np.array([1,2,2,1,1,2])
print(np.unique(a))

8.5
1.2
3
27.6
[1.2 4.2 6.3 7.4 8.5]
[1 2]

Opérations élément par élément :

# définir un premier vecteur

a = np.array([1, 2, 3])
print(a)

# définir un second vecteur

b = np.array([1, 2, 3])
print(b)

# addition
c = a + b
print(c)

# multiplication
c = a * b
print(c)

[1 2 3]
[1 2 3]
[2 4 6]
[1 4 9]

a = np.array([1, 2, 3])
print(a)

b = np.array([2.5, 2.5, 2.5])

print(b)

# soustraction
c = a - b
print(c)

[1 2 3]
[2.5 2.5 2.5]
[-1.5 -0.5 0.5]

a = np.array([2, 8, 3])
print(a)

b = np.array([1, 2, 3])
print(b)

# division
c = a / b
print(c)

Multiplication vecteur-scalaire
a = np.array([1, 2, 3])
print(a)
# définir un scalaire
s = 0.5
print(s)
# multiplication vecteur-scalaire
c = s * a
print(c)

[1 2 3]
0.5
[0.5 1. 1.5]

Produit scalaire

a = np.array([1, 2, 3])
print(a)

b = np.array([1, 2, 3])
print(b)

# produit scalaire
c = a.dot(b)
print(c)

[1 2 3]
[1 2 3]
14

Matrices
Une matrice est un tableau (array) à 2 dimensions.

import numpy as np

# creation d'une matrice

A = np.array([[1, 2, 3], [4, 5, 6]])
print(A)
print(type(A))
print(A.dtype) #type des éléments de la matrice
print(A.shape) # renvoie un tuple (num.lignes,num.colonnes)
print(A.size) #nombre totale de valeurs

B= np.array([[1.2,2.5],[3.2,1.8],[1.1,4.3]])
print(B)
print(type(B))
print(B.dtype)
print(B.shape)
#matrices de valeurs identiques, par ex. pour une initialisation
A = np.zeros((2, 1)) #attention, double parentèse
print("A=",A)

B= np.ones((1,3))
print("B=",B)

#plus generalement
C = np.full((2,4),fill_value=0.3)
print("C=",C)

# creation d'une matrice 3x3 de valeurs aleatoirs d'une distribution

uniforme sur [0, 1)
D = np.random.rand(3,3)
print("D=",D)

#creation d'une matrice 2x4 d'entiers aleatoires entre 0 et 5 exclu.

E = np.random.randint(5, size=(2, 4))
print("E=",E)

A= [[0.]
[0.]]
B= [[1. 1. 1.]]
C= [[0.3 0.3 0.3 0.3]
[0.3 0.3 0.3 0.3]]
D= [[0.71104492 0.1536572 0.94428984]
[0.14618699 0.48768625 0.66219456]
[0.43780373 0.55732102 0.08415505]]
E= [[4 3 0 3]
[4 2 2 3]]

Redimensionnement : ajout ligne ou colonne

#matrice de valeurs
A = np.array([[1.2,2.5],[3.2,1.8],[1.1,4.3]])

#ajouter une ligne : Accoler le vecteur b en tant que nouvelle ligne

(axis = 0) de la matrice A
b = np.array([[4.1,2.6]])
C = np.append(A,b, axis=0)
print("C=",C)

#ajouter une colonne : Accoler le vecteur d en tant que nouvelle

colonne (axis = 1) de la matrice A
d = np.array([[7.8],[6.1],[5.4]])
D= np.append(A,d,axis=1)
print("D=",D)

#insertion : Insertion de b en tant que nouvelle ligne (axis = 0) à la

position n°1
E = np.insert(A,1,b,axis=0)
print("E=",E)

#suppression
F = np.delete(A,1,axis=0)
print("F=",F)

#modifier la dimension d'une matrice existante

#parcourt les données lignes par ligne
G = np.resize(A,(2,3))
print("G=",G)

C= [[1.2 2.5]
[3.2 1.8]
[1.1 4.3]
[4.1 2.6]]
D= [[1.2 2.5 7.8]
[3.2 1.8 6.1]
[1.1 4.3 5.4]]
E= [[1.2 2.5]
[4.1 2.6]
[3.2 1.8]
[1.1 4.3]]
F= [[1.2 2.5]
[1.1 4.3]]
G= [[1.2 2.5 3.2]
[1.8 1.1 4.3]]

Opérations avec les matrices :

# définir une première matrice

A = np.array([
[1, 2, 3],
[4, 5, 6]])

# définir une seconde matrice

B = np.array([
[1, 2, 3],
[4, 5, 6]])

# addition
C = A + B
print("C=",C)

# division
D = A / B
print("D=",D)

E = np.array([
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5]])

# soustraction
F = A - E
print("F=",F)

Multiplication (produit matriciel) :

A = np.array([
[1, 2],
[3, 4],
[5, 6]])

B = np.array([
[1, 2],
[3, 4]])

# multiplication matricielle
C = A.dot(B)
print("C=",C)

# idem : multiplication matricielle avec @

D = A @ B # la notation C = A * B par contre correspond au
produit de Hadamard
print("D=",D)

C= [[ 7 10]
[15 22]
[23 34]]
D= [[ 7 10]
[15 22]
[23 34]]

Multiplication matrice-vecteur :

A = np.array([
[1, 2],
[3, 4],
[5, 6]])

# définir un vecteur
B = array([0.5, 0.5])

# multiplication vecteur-matrice
C = A.dot(B)
print(C)

Multiplication matrice-scalaire :
A = np.array([[1, 2], [3, 4], [5, 6]])

# définir un scalaire
b = 0.5

# multiplication matrice-scalaire
C = A * b
print(C)

Il existe plusieurs types de matrices avec des proprietés particulières (carrées, symétriques,
triangulaires,...).

• Matrice symétrique
# création d'une matrice A aleatoire
A = np.random.rand(3,3)

#création d'une matrice A symétrique (en multiplicant A par sa

transposee)
A= A.dot(A.T) # T est la transposé de A, voir plus bas
print(A)

• Matrice triangulaire
# définir une matrice carrée
M = np.array([
[1, 2, 3],
[1, 2, 3],
[1, 2, 3]])

# matrice triangulaire inférieure

lower = np.tril(M)
print("l=", lower)

# matrice triangulaire supérieure

upper = np.triu(M)
print("u=",upper)

l= [[1 0 0]
[1 2 0]
[1 2 3]]
u= [[1 2 3]
[0 2 3]
[0 0 3]]

• Matrice diagonale
# définir une matrix carrée
M = np.array([
[1, 2, 3],
[1, 2, 3],
[1, 2, 3]])

# extraire la diagonale
d = np.diag(M)
print("d=",d)

# créer une matrice diagonale à partir du vecteur

D = np.diag(d)
print("D=",D)

• Matrice identité
I = np.identity(3)
print(I)

Opérations sur des matrices

A = np.array([
[1, 2],
[3, 4],
[5, 6]])

# calculer la matrice transposé

C = A.T
print(C)

# calculer la trace
B = np.trace(A)
print(B)

On utilise le sous-module linalg contenu dans Numpy pour les calculs d'algèbre linéaire.

A = array([
[1.0, 2.0],
[3.0, 4.0]])

# inverse
B = np.linalg.inv(A)
print(B)

# calculer le determinant
B = np.linalg.det(A)
print(B)

Resolution d'équations linéaires de type A.x = b, où A est une matrice, b et x deux vecteurs.

#résolution d'équation
A = array([
[1.0, 2.0],
[3.0, 4.0]])

b = np.array([1.7,1.0])

x = np.linalg.solve(A,b)
print(x)

Parcours d’une matrice : double boucle sur les indices

A = array([
[1.0, 2.0],
[3.0, 4.0]])

#somme des valeurs d'une matrice

s = 0.0
for i in range(0,A.shape[0]):
for j in range(0,A.shape[1]):
print(A[i,j])
s = s + A[i,j]
print("Somme = ",s)

##Visualisation avec Matplotlib

Matplotlib est une librairie graphique pour générer des figures scientifiques en 2D et 3D. Parmi
les avanatges de cette librairie, on peut citer :

• prise en main facile,

• des figures de haute qualité et plusieurs formats PNG, PDF, SVG, EPS, and PGF,
• le texte peut être formatté en $\LaTeX$.

Tout d'abord, il faut importer le module matplotlib pour pouvoir utiliser dans votre
programme.

import matplotlib.pyplot as plt #par la suite on utilisera l'alias

plt

# pour l'affichage des graphiques sur Jupyter notebook

%matplotlib inline

D’une manière générale les fonctions plt.plot attendent des vecteurs/matrices, c'est à dire des
tableaux de points du plan.

On commence par afficher la fonction sinus.

import matplotlib.pyplot as plt

import numpy as np

x=np.linspace(-5,5,100)
plt.plot(x,np.sin(x)) # on utilise la fonction sinus de Numpy
plt.ylabel('fonction sinus')
plt.xlabel("l'axe des abcisses")
plt.show()

** Graphique "Scatter plot" (nuage de points)**

Commençons par créer des points à afficher.

xs = range(1, 25) # creéation en abscisse d'un ensemble de points sur

l'intervalle 1-25.
ys = [1 / x for x in xs] # en ordonné, pour chaque point x dans
l'ensemble xs, j'affiche la valeur 1/x

Pour dessiner un "scatter plot" (nuage de point), on utilise la méthode scatter.

plt.scatter(xs, ys);
On peut combiner ce graphique avec un deuxième nuage de points. Créons d'autres points.

zs = [1 / (25 - x) for x in xs] # cette fois pour chaque point x dans

xs, j'affiche la valeur 1/(25-x) (en vert ci-dessous)

Afficher les deux ensembles de points dans un même graphique.

plt.scatter(xs, ys)
plt.scatter(xs, zs)

<matplotlib.collections.PathCollection at 0x7fc6cce68a90>
Pour ajouter une légende, des axes et un titre à notre graphique (qui peuvent inclure du code $\
LaTeX$) :

plt.scatter(xs, ys, label="$y=\\frac{1}{x}$")

plt.scatter(xs, zs, label="$y=\\frac{1}{25 - x}$")

plt.xlabel("$x$")
plt.ylabel("Valeur")
plt.title("Mon premier \"scatter plot\" ")

plt.legend();
Il est possible d'enregistrer la figure dans un fichier.

plt.savefig("mongraphe.png") #format png par default

#ou bien
plt.savefig('mongraphe.pdf',format='pdf') #format pdf possible

Un système de sous-figures plt.subplot() permet de juxtaposer différents graphiques

def f(t):
return np.exp(-t) * np.cos(2*np.pi*t)

#definition des vecteurs de points

t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)
plt.figure(1)

plt.subplot(221) #numero du graphique

plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k') # 'bo' = ronds bleu , 'k' =
couleur noir

plt.subplot(222)
plt.plot(t2, np.cos(2*np.pi*t2), 'r--') # 'r--' = petis traits rouges

plt.subplot(223)
plt.plot(t2, np.sin(2*np.pi*t2), 'b-') # 'b-' = trait continu bleu
Scipy : librairie d'algorithmes scientifiques sous Python
SciPy est un projet visant à unifier et fédérer un ensemble de bibliothèques Python à usage
scientifique. Scipy utilise les tableaux et matrices du module NumPy.

Les algorithmes et les fonctions de Scipy couvrent :

Fonctions spéciales (scipy.special)

Intégration (scipy.integrate)
Optimization (scipy.optimize)
Interpolation (scipy.interpolate)
Transformées de Fourier (scipy.fftpack)
Traitement du signal (scipy.signal)
Algèbre linéaire (scipy.linalg)
Statistiques (scipy.stats)

Chacun des ces sous-modules fournit un ensemble de fonctions et de classes qui peuvent être
utilisées pour résoudre des problèmes variés en lien avec le calcul scientifique.

Importer le module Scipy pour accéder à la libraire :

from scipy import * # '*' = tout les modules

Au cas où un seul sous-module sera utilisé, il est possible de l'importer comme suit :

# importer le sous module algèbre linéaire

import scipy.linalg

Intégration

On sintéresse maintenant au calcul numérique d'une intégrale du type :

b

∫ f ( x )d x .
a

Plusieurs méthodes fournissant une valeur approchée d'une intégrale sont implémentées dans
Scipy.

Par exemple romberg calcule une valeur approchée de l'intégral à l’aide de la méthode de
Romberg, trapz calcule une valeur approchée de l'intégral à l’aide de la méthode des trapèzes,
simps calcule une intégrale à l'aide de la méthode de Simpson.

Dans nos exemples on utilisera quad, (dblquad and tplquad) qui permettent de calculer des
intégrales simples, (doubles ou triples respectivement) avec une méthode non spécifiée,
optimisée par Python.

Une façon de calculer une intégrale avec Scipy, est donc de définr une fonction et puis lui
appliquer la méthode quad.
from scipy import integrate

# definir une fonction simple à intégrer

def f(x):
return x

x_lower = 0 # borne inférieure de l'intégrale

x_upper = 1 # borne supérieure de l'intégrale

val, abserr = integrate.quad(f, x_lower, x_upper)

print("valeur de l'intégrale =", val, ", erreur en valeur absolue =",

abserr)

Si on a besoin de passer d'autres paramètres à la fonction à intégrer, on peut utiliser l'argument

args de la fonction quad. Par exemple pour
1

∫ a x 2 +b d x .
0

def f(x, a, b):

return a*x**2 + b

a = 2
b = 1
I = integrate.quad(f, 0, 1, args=(a,b))
I

On peut avoir besoin d'utiliser le symbol o o comme borne d'un intégral. Par exemple
oo
f n ( x )=∫ e
− xt n
/t d t .
1

def f(t, n, x):

return np.exp(-x*t) / t**n

def expint(n, x):

return integrate.quad(f, 1, np.inf, args=(n, x))

print(expint(3, 1.0))

PS. ll existe déjà une fonction predéfinie expn(n,x) dans le paquetage scipy.special (on
pourrait donc l'importer import scipy.special as special et utiliser
special.expn(3, 1.0) dans l'exemple ci-dessus pour obtenir le même résultat.

Double intégration :
 oo oo
I ( n )=∫ ∫ e
− xt n
/t d t d x .
0 1

def I(n):

return integrate.dblquad(lambda t, x: np.exp(-x*t)/t**n, 0, np.inf,

lambda t: 1, lambda t: np.inf)

print(I(3)) # la valeur de l'intégral est egal a 1/n

print(I(4))