Matrices

---

Remarque : nous aurons besoin du package numpy de python.

import numpy as np

Ce package permet de manipuler des tableaux multidimensionnels sous la forme d'objets de type array. Vous trouverez la documentation de ce package ici : documentation de Numpy

1. Ecriture matricielle

1.1 Création de matrices

Les matrices seront représentées par un array de NumPy.

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

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

#nombre de coefficients de M
np.size(M)

12

La commande np.shape(M) renvoie un couple (l,c) où lest le nombre de lignes de M, et c le nombre de colonnes.

np.shape(M)[0] #nombre de lignes de M

4

np.shape(M)[1] #nombre de colonnes de M

3

1.2 Extraction de coefficients

On peut extraire les coefficients d'une matrice, et utilisant les commandes de slicing.

M[0,1]

3

M[3,2]

2

M[0,1:3]

array([3, 4])

M[0,0:3]

array([2, 3, 4])

M[0,:]

array([2, 3, 4])

M[1,:]

array([-1,  4,  5])

M[:,1]

array([3, 4, 6, 0])

# affectation à une ligne
M[2,:] = [2,4,6]
M[1,:]=2*M[2,:]
M[0,:]=0
M

array([[ 0,  0,  0],
       [ 4,  8, 12],
       [ 2,  4,  6],
       [ 1,  0,  2]])

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.

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

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

N

array([[88,  3,  4],
       [-1,  4,  5],
       [-5,  6,  7],
       [ 1,  0,  2]])

1.3 Fonctions np.zeros(), np.eye(), np.ones().

# que font les fonctions suivantes ?
np.zeros((3,5))
np.eye(3)
np.ones((3,5))

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

2. Multiplication matricielle

Le produit matriciel $M_{1} \times M_{2}$ est donné par np.dot(M1,M2).

Exemple :

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

array([[ -9,  36,  54],
       [-25,  43,  63],
       [-39,  35,  55],
       [ 21,  -9,   8]])

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

2.1 Exercice : 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 Exercice : 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]])
A

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

puissance(A,5)

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

3. Exercices d'applications

• 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.

diagInv(4)

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

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

P

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

negatifzero(P)

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

• 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$, ..., en dernière ligne les valeurs de $v^n$.

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

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

• 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

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]])

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 "nombre de colonne de A = nombre de ligne de B" est respectée).