Matrices et calcul matriciel

Introduction

Ce cours traite de la manipulation de matrices en Python avec la bibliothèque numpy, en explorant la création, la lecture, la modification, les opérations, et des fonctions personnalisées.

import numpy as np

---

1. Écriture matricielle

1.1 Création de matrices

M = np.array([[2,3,4],[-1,4,5],[-5,6,7],[1,0,2]])
print(M)

1.2 Dimensions et taille

np.size(M)         # Nombre total de coefficients
np.shape(M)[0]     # Nombre de lignes
np.shape(M)[1]     # Nombre de colonnes

1.3 Extraction de coefficients

M[0,1]         # Accès à un coefficient
M[0,1:3]       # Tranche (slicing)
M[0,:]         # Ligne entière
M[:,1]         # Colonne entière

1.4 Modification des coefficients

M[2,:] = [2,4,6]
M[1,:] = 2 * M[2,:]
M[0,:] = 0

1.5 Copie de matrices

Attention, comme pour le type liste, le type array ne permet pas la copie par simple utilisation du $=$. Si on veut une nouvelle matrice $N$, copie de $M$, nous devons utliser la commande np.copy.

N = np.copy(M)
N[0,0] = 88  # Ne modifie pas M

1.6 Fonctions utiles

np.zeros((3,5))     # Matrice de zéros
np.ones((3,5))      # Matrice de uns
np.eye(3)           # Matrice identité

Remarque : on pourra aller voir les arguments optionnels supplémentaires de ces fonctions dans la documentation

---

2. Multiplication matricielle

2.1 Produit matriciel

Le produit matriciel $M_1 \times M_2$ est donné par :

np.dot(M1, M2)  # Produit M1 x M2

Que renvoie la commande np.dot(M,P) et pourquoi ?

2.1 Matrice identité

Vérifier que la matrice identité de taille $n$ est neutre pour la multiplication matricielle.

P = np.array([[2,3,3,5],[-1,4,5,6],[-5,2,7,8],[1,0,-2,9]])
I = np.eye(4)
np.dot(P,I)
np.dot(I,P)

2.2 Puissance de matrices

Soit $A$ une matrice carrée. Créer une fonction puissance(A,p) qui calcule $A^p$ pour $p > 0$.

Exemple :

A = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(puissance(A, 5))

array([[121824, 149688, 177552],
       [275886, 338985, 402084],
       [429948, 528282, 626616]])

---

3. Exercices d'application

3.1 Diagonale montante

Créer une fonction diagInv(n) qui retourne une matrice carrée de taille $n$, dont les coefficients sont nulles, sauf sur la diagonale montante qui ne contient que des 1.

print(diagInv(4))

array([[0., 0., 0., 1.],
       [0., 0., 1., 0.],
       [0., 1., 0., 0.],
       [1., 0., 0., 0.]])

🔍 Réponse

def diagInv(n):
    M = np.zeros((n,n))
    for i in range(n):
        M[i,n-i-1] = 1
    return M

3.2 Remplacer les négatifs par 0

Créer une fonction negatifzero(M) qui change tous les coefficients négatifs M de la matrice en 0.

P = np.array([[ 2,  3,  3,  5],
              [-1,  4,  5,  6],
              [-5,  2,  7,  8],
              [ 1,  0, -2,  9]])
print(negatifzero(P))

array([[2, 3, 3, 5],
       [0, 4, 5, 6],
       [0, 2, 7, 8],
       [1, 0, 0, 9]])

🔍 Réponse

def negatifzero(M):
    M = np.copy(M)
    M[M < 0] = 0
    return M

3.3 Matrice de puissances

Construire une fonction matriceliste(v,n) qui renvoie une matrice ayant en ligne 0 les valeurs de $v$ en ligne 1 les valeurs de $v^2$, etc... en dernier ligne les valeurs de $v^n$.

matriceliste( [2,3,4], 4)

array([[  2,   3,   4],
       [  4,   9,  16],
       [  8,  27,  64],
       [ 16,  81, 256]])

🔍 Réponse

def matriceliste(v, n):
    return np.array([np.array(v)**i for i in range(1, n+1)])

3.4 Addition ligne précédente

Construire une fonction plusligneprecedente(M) qui renvoie une matrice où chaque ligne correspond à celle de $M$, plus la ligne précédente. Pour la 1ère, on prendra la 1ère de $M$ + la dernière.

M = np.array([[ 2,  3,  4],
              [-1,  4,  5],
              [-5,  6,  7],
              [ 1,  0,  2]])
plusligneprecedente(M)

array([[ 3,  3,  6],
       [ 1,  7,  9],
       [-6, 10, 12],
       [-4,  6,  9]])

🔍 Réponse

def plusligneprecedente(M):
    L = len(M)
    R = np.zeros_like(M)
    for i in range(L):
        R[i] = M[i] + M[i-1] if i > 0 else M[i] + M[-1]
    return R

---

4. Bonus

Créer votre propre fonction produit(A,B) qui calcule le produit matriciel de $A$ par $B$ (on introduira un test qui autorise la multiplication que si la condition $\text{nombre de colonnes de A} = \text{nombre de lignes de B}$ est respectée).

---