Programmation en Python

Matrices et calcul matriciel avec pylab



Pylab: bibliothèque scientifique pour python

La bibliothèque pylab permet d'utiliser les bibliothèques numpy et matplotlib qui forunissent des fonctions scientifiques avancées à python.
Il suffit d'importer pylab via la commande
from pylab import *
On peut alors, entre autre, définir, manipuler, calculer, … des matrices.

Définition d'une matrice

La définition est l'utilisation des matrices, le calcul matriciel notamment, est très proche de la syntaxe Matlab.

Matrice ligne

On définit une matrice ligne par la commande suivante:
M = array([1,2,3])
On accède alors aux éléments de la matrice comme on ceux d'une liste, par exemple
print(M[1])
M[1]=18
print(M)
Attention: en python la numérotation commence à 0 et ainsi, M[1] est le 2ème élément de la matrice.

Matrice 2D, ou tableau bidimensionnel

Une matrice, ou tableau de nombres, en 2D est une liste de listes donnée en argument de la fonction array(), par exemple
M = array([[1,2,3], [4,5,6]])
On manipule les éléments de la matrice comme ceux d'une liste de listes, par exemple
M = array([[1,2,3], [4,5,6]])
print(M)
print(M[1][2])
M[1][2]=18
print(M)
# ou
print(M[0,1])
M[0,1]=27
print(M)

Dimension d'une matrice: size & shape

La commande size renvoie le nombre d'éléments de la matrice, tandis que shape renvoie les dimensions (nombre de lignes, colonnes, …), par exemple
M = array([1,2,3])
print(size(M))
print(shape(M))

print('-----')
M = array([[1,2,3], [4,5,6]])
print(size(M))
print(shape(M))

Pour une matrice 2D, le nombre d'éléments d'une matrice est aussi simplement le produit de ses dimensions:
M = array([[1,2,3], [4,5,6]])
print(size(M))
n,m=shape(M)
print(n*m)

Manipulation de matrices et tableaux, extraction, slicing

On peut avoir besoin d'extraire d'une matrice une seulement de celle-ci.
On a vu juste avant comment extraire un seul élément, en indiquant sa position, ligne et colonne.
On peut aussi en extraire une plus grande partie, un certain nombre de lignes et de colonnes. On indique pour ce faire la liste des lignes et colonnes à extraire, par exemple pour extraire les colonnes 1 et 3 de la 1ère ligne seulement:
M = array([[1,2,3,4], [5,6,7,8]])
print(M)
C=[1,3]
L=1
print(M[L,C])
Pour extraire (presque) toutes les lignes entre deux entiers, on peut programmer:
M = array([[1,2,3,4], [5,6,7,8],[9,10,11,12]])
print(M)
C=[1,3]
print(M[0:2,C])
enfin, si on veut que notre sélection s'étende depuis le début ou jusqu'à la fin on n'indique rien resperctivement à gauche ou à droite des deux points:
M = array([[1,2,3,4,5], [6,7,8,9,10],[11,12,13,14,15]])
print(M)
print(M[:2,3:])
On extrait ainsi des sous-matrices, des "tranches" de matrices ("slice" en anglais, on fait donc du "slicing" pour le néologisme).

Somme des éléments, en ligne, en colonne

On calcule des sommes avec la fonction sum (qui existe déjà en python, et dont une autre version, plus efficace, se trouve dans la bibliothèque pylab. Au chargement de pylab, cette version écrasera donc la version standard de python et sera utilisée par défaut).
Par exemple, on calcule facilement la somme de tous les éléments d'une matrice:
M = array([[1,2,3], [4,5,6],[7,8,9]])
print(M)
print(sum(M))
et, en combinant avec les méthodes de manipulation, extraction, slicing de matrices, on peut additionner tous les termes suivant une ligne ou une colonne par exemple.
Ici, on calcule les sommes des éléments suivant la première ligne puis la somme suivant la deuxième colonne:
M = array([[1,2,3], [4,5,6],[7,8,9]])
print(M)

#Somme de la 1ère ligne
print(sum(M[0,:]))

#Somme de la 2ème colonne
print(sum(M[1,:]))

Enfin, on peut calculer toutes les sommes en ligne et en colonne (en fait suivant chaque dimension de la matrice qui peut être de dimension plus que 2), en ajoutant en argument à la fonction sum la dimension suivant laquelle on effectue la somme. Ainsi,
M = array([[1,2,3], [4,5,6],[7,8,9]])
print(M)

print(sum(M,0))
# Somme suivant les lignes,
# retourne [12 15 18]

print(sum(M,1))
# Somme suivant les colonnes,
# retourne [ 6 15 24]

Remarque: les fonctions mean, min et max s'utilisent exactement de la même façon que sum pour calculer des moyennes, minimums ou maximums plutôt que des sommes.

Calcul matriciel

L'addition et la multiplication usuelles sont effectuées terme à terme. Il faut bien sûr dans ce cas que les matrices aient les mêmes dimensions.
Par exemple
M = array([[1,2,3], [4,5,6]])
N = array([[7,8,9], [-1,-2,-3]])
print(M*N)
print(M*N)

Le produit matriciel se calcule en utilisant la fonction dot, par exemple,
M = array([[1,2,3], [4,5,6]])
N = array([[7,8], [9,10],[11,12]])
print(dot(M,N))
Il faut bien sûr là aussi que les dimensions des matrices permettent ce produit.

Puissance d'une matrice

On peut calculer les puissances successives d'une matrice (tant utilisées par exemple dans les graphes et chaînes de Markov), par la boucle:
M = array([[1,2], [3,4]])
print(M)

n=10 #puissance voulue
Mp=eye(2)
for i in range(n):
    Mp=dot(Mp,M)

print(Mp)
où on a initialisé les calculs par la matrice identité eye

Matrices particulières

Trois matrices particulières peuvent être bien utiles: la matrice identité et les matrices de 0 et de 1 pour éventuellement initialiser des calculs. La matrice identité d'ordre n est la matrice carrée avec des 1 sur la diagonale et des 0 partout ailleurs:
I=eye(3)
retourne donc la matrice
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

Les matrices zeros(n) et ones(n) retournent des matrices carrées d'ordre n et remplies respectivement de 0 ou de 1.

Déterminant et inverse d'une matrice

Le déterminant d'une matrice se calcule en utilisant la fonction det(), par exemple
M = array([[1,2], [3,4]])
print(det(M))
et, lorsque ce déterminant n'est pas nul, on peut calculer la matrice inverse par la fonction inv(), par exemple
M = array([[1,2], [3,4]])
print(inv(M))
Savoir calculer l'inverse d'une matrice permet par exemple de résoudre matriciellement des systèmes d'équations.
La résolution d'un système écrit sous la forme matriciel AX=B se fait simplement, lorsque la matrice A est inversible et en multipliant alors à gauche par la matrice inverse, pour obtenir X=A−1B.
Numériquement ce n'est pas la meilleure façon de procéder (la plus rapide, plus efficace, plus précise, …). Dans la bibliothèque pylab, il existe une fonction plus adéquate de résoudre un tel système: solve, qui s'utilise ainsi,

#X solution de AX=B
X=solve(A,B)

Algèbre linéaire

Les éléments propres d'une matrices s'obtiennent avec la fonction eig:
M=array([[5,2],[2,8]])
print(M)
D,V=eig(M)
print(D)
D=diag(
Le vecteur D contient les valeurs propres et la matrice V les vecteurs propres.
En particulier, si la matrice est diagonalisable (ce qui est le cas pour la matrice symétrique réelle précédente, cf. théorème spectral), on peut vérifier numériquement la théorie:

M=array([[5,2],[2,8]])
print(M)
D,V=eig(M)

# on retrouve la matrice de départ
# M=P-1DP

print(dot(dot(V,D),inv(V)))

# et inversement
# et on trouve la matrice de diagonale
# avec les valeurs propores
# D=PAP-1

print(dot(dot(inv(V),M),V))