15 minutes de Python

Commandes essentielles de numpy.linalg

Les commandes du module numpy.linalg permettent d’étudier les principales propriétés des matrices : calcul du rang, recherche d’un inverse, résolution de systèmes linéaires, détermination des valeurs propres, calcul de puissances de matrices, etc.

Dans cette page, on travaille avec des matrices numpy, c’est-à-dire des objets np.array à deux dimensions. On importera systématiquement les bibliothèques numpy et numpy.linalg de la façon suivante :

import numpy as np
import numpy.linalg as al

import numpy as np
import numpy.linalg as al

Les commandes du module numpy.linalg permettent d’effectuer rapidement les calculs fondamentaux d’algèbre linéaire : inverse, résolution de systèmes, valeurs propres, rang, puissances de matrices.

Inverse d’une matrice : al.inv

Si \(A\in\mathcal{M}_n(\mathbb{R})\) est inversible, la commande

al.inv(A)

renvoie l’inverse de la matrice \(A\), ou plus précisément une approximation numérique de la matrice \(A^{-1}\). En effet, les calculs sont effectués par l’ordinateur avec un nombre fini de décimales : les coefficients affichés ne sont donc pas exacts, mais approchés.

Par exemple, si l’on définit

A = np.array([[1,1],[1,2]])

alors la commande

al.inv(A)

renvoie

array([[ 2., -1.],  [-1.,  1.]])

ce qui correspond bien à la matrice \[ A^{-1}=\begin{pmatrix}2 & -1 \\ -1 & 1\end{pmatrix}. \]

En pratique, on peut vérifier le résultat par exemple avec :

np.dot(A, al.inv(A))

qui doit renvoyer un résultat proche de la matrice identité.

Résolution de système : al.solve

Si \(A\in\mathcal{M}_n(\mathbb{R})\) est inversible et \(B\in\mathcal{M}_{n,p}(\mathbb{R})\), la commande

al.solve(A, B)

renvoie la matrice \(X\) solution du système linéaire \[ AX = B. \]

Autrement dit, al.solve s’applique exactement au cas où le système admet une solution unique.

En particulier, si \(B\) est un vecteur colonne, on obtient la solution d’un système linéaire classique.

Mathématiquement, on a \(X=A^{-1}B\), mais l’algorithme utilisé n’explicite pas l’inverse.

⚠️ Remarque importante. Si la matrice \(A\) n’est pas inversible, le système n’admet pas de solution unique (absence de solution ou infinité de solutions). Dans ce cas, la commande al.solve provoque une erreur.

Exemple (système avec solution unique).

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

al.solve(A, b)

Python renvoie alors :

array([1., 1.])

ce qui correspond à la solution \((x,y)=(1,1)\).

Exemple (matrice non inversible).

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

al.solve(A, b)

Ici, la matrice \(A\) n’est pas inversible. La commande al.solve provoque une erreur (indiquant que la matrice est singulière) et ne renvoie aucun résultat.

Cela correspond au fait que le système n’admet pas de solution unique.

Valeurs propres et vecteurs propres : al.eig

Exemple 1 : matrice diagonalisable.

A = np.array([[2,0], [0,1]])

al.eig(A)

Python renvoie :

EigResult(eigenvalues=array([2., 1.]),
          eigenvectors=array([[1., 0.], [0., 1.]]))

Les valeurs propres sont 2 et 1. Les colonnes de la matrice eigenvectors sont des vecteurs propres associés. Ici, on reconnaît deux vecteurs propres non colinéaires : \((1,0)\) et \((0,1)\).

Ils sont linéairement indépendants, donc ils forment une base de \(\mathbb{R}^2\). On en déduit que la matrice est diagonalisable.

Exemple 2 : matrice non diagonalisable.

A = np.array([[1,1], [0,1]])

al.eig(A)

Python renvoie :

EigResult(eigenvalues=array([1., 1.]),
          eigenvectors=array([[ 1.00000000e+00, -1.00000000e+00],
                               [ 0.00000000e+00,  2.22044605e-16]]))

La seule valeur propre est 1, de multiplicité 2. Python fournit deux vecteurs propres. Cependant, le deuxième vecteur est numériquement très proche de \((-1,0)\), car \(2.22044605\times10^{-16}\approx 0\).

Les deux colonnes sont donc pratiquement colinéaires. Elles engendrent une droite et non \(\mathbb{R}^2\). La matrice eigenvectors n’est pas inversible.

On en déduit que la matrice n’est pas diagonalisable : elle n’admet qu’une seule direction propre.

Dans ce cas, on peut retrouver facilement un vecteur propre en résolvant \begin{align*} (A-I)v=0 &\Leftrightarrow\; \begin{pmatrix}0&1\\0&0\end{pmatrix} \begin{pmatrix}x\\y\end{pmatrix} =\begin{pmatrix}0\\0\end{pmatrix}\\ &\Longleftrightarrow\; y=0. \end{align*} Un vecteur propre simple est donc par exemple \((1,0)\).

Rang d’une matrice : al.matrix_rank

La commande

al.matrix_rank(A)

renvoie le rang de la matrice \(A\), c’est-à-dire la dimension du sous-espace engendré par ses colonnes (ou, ce qui revient au même, par ses lignes).

Concrètement, elle permet de savoir combien de colonnes de \(A\) sont linéairement indépendantes. On l’utilise notamment pour tester l’inversibilité d’une matrice carrée.

Par exemple, si l’on définit

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

alors la commande

al.matrix_rank(A)

renvoie 2, car la deuxième ligne est le double de la première. La matrice n’est donc pas inversible.

Par ailleurs, si \(A\in\mathcal{M}_n(\mathbb{R})\), la condition

al.matrix_rank(A) == n

est vraie si et seulement si la matrice \(A\) est inversible.

Puissance d’une matrice : al.matrix_power

Si \(A\in\mathcal{M}_n(\mathbb{R})\) et \(k\in\mathbb{N}\), la commande

al.matrix_power(A, k)

renvoie la matrice \(A^k\), c’est-à-dire le produit de \(k\) matrices \(A\) : \[ A^k = \underbrace{A \times A \times \cdots \times A}_{k\ \text{facteurs}}. \]

Cette fonction est particulièrement utile pour étudier des suites de matrices, des systèmes dynamiques discrets, ou des chaînes de Markov (dans un cadre probabiliste).

En pratique, le calcul est effectué par exponentiation rapide, bien plus efficace qu’une boucle naïve.

import numpy as np
import numpy.linalg as al

A = np.array([[2, 1],
              [1, 2]])

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

print("rang(A) =", al.matrix_rank(A))
print("A^{-1} =", al.inv(A))
print("solution de AX=b :", al.solve(A, b))

res = al.eig(A)
print(res)

print("A^3 =", al.matrix_power(A, 3))