Matrices

I) Cours

1) Définition et exemple

En informatique, une matrice de nombres (entiers ou flottants) est une liste de listes de même longueur  de nombres.

a = [[1,2,3,4],[4,5,6,7],[7,8,9,10]]        # On définit une matrice 3x4
print(a[1])                                            # Deuxième ligne de a
print(a[1][2])                                        # Elément a 23
#renvoie
[4, 5, 6, 7]
6

Toutes les fonctions  et méthodes utilisables sur les listes permettent de travailler sur les matrices.

print(len(a), len(a[1])) → 3,4    # Nombre de lignes et de colonnes de a

2) Attention

• A l'indiçage à partir de 0 pour les matrices informatiques et de 1 pour les matrices mathématiques
• A la copie d'une matrice : utiliser copy.deepcopy(), après avoir importé le module copy.
• Pour créer une matrice m remplie de 0 et composée de lignes indépendantes: m = [[0]*n for i in range(n)]

3) Créer une matrice de terme général donné

m = [[0]*n for i in range(n)] crée une matrice m remplie de 0 et composée de lignes indépendantes

m = [[f(i, j) for j in range(p)] for i in range(n)]  crée la matrice m de taille n×p et de terme général m ij = f ( i - 1 , j - 1 )

II) Exercices

Dans tous les exercices une matrice de nombres est une liste de listes de même longueur de nombres.

1) Affichage d'une matrice

Ecrire une fonction affiche_matrice(a) affichant une matrice ligne par ligne.

a = [[1,2,3,4],[4,5,6,7],[7,8,9,10]]
affiche_matrice(a)
#renvoie
[1, 2, 3, 4]
[4, 5, 6, 7]
[7, 8, 9, 10]

2) Quelques matrices particulières

Ecrire des fonctions calculant les matrices de taille  n×n  (n ∈ N * ) suivantes:

a) identite(n) = I n ;       b)  j(n) =   ( 0 1 1 1 0 1 1 1 0 )          c) suite(n) =   ( 1 2 n n + 1 n + 2 2 n n 2 - n + 1 n 2 - n + 2 n 2 )

d) diag1(n)  =   ( 1 2 3 n 2 1 2 3 2 3 2 n 3 2 1 )   e) diag2(n)  =   ( n n - 1 2 1 n - 1 2 1 2 2 n - 1 1 2 n - 1 n )   f) tri_diag(n) =   ( 1 - 2 0 0 - 2 1 - 2 0 - 2 0 - 2 0 0 - 2 1 )

3) Transposition

  Ecrire une fonction transpose(a) calculant la transposée d'une matrice a. Par exemple, affiche_matrice(transpose(suite(4))) renvoie:

[1, 5, 9, 13]
[2, 6, 10, 14]
[3, 7, 11, 15]
[4, 8, 12, 16]

4) Somme

  Ecrire une fonction somme(a, b) (avec a, b matrices) calculant si c'est possible la matrice a + b et retournant un message d'erreur sinon.  Par exemple: affiche_matrice(somme(diag1(5), diag2(5))) renvoie:

[6, 6, 6, 6, 6]
[6, 4, 4, 4, 6]
[6, 4, 2, 4, 6]
[6, 4, 4, 4, 6]
[6, 6, 6, 6, 6]

5) Produit

a) Ecrire une fonction produit(a, b) (avec a, b matrices) calculant si c'est possible la matrice a × b et retournant un message d'erreur sinon.  Par exemple, affiche_matrice(produit(diag1(5), diag2(5))) renvoie:

[35, 30, 33, 42, 55]
[30, 26, 28, 34, 42]
[33, 28, 27, 28, 33]
[42, 34, 28, 26, 30]
[55, 42, 33, 30, 35]

b) Lorsque a et b sont des matrices n×n, quel est  (en fonction de n) le nombre d'opérations élémentaires (somme ou produit) nécessaires pour faire le produit a × b ?

6) Puissance

  Ecrire une fonction puissance(a, p) (avec p ∈ N * ) calculant la matrice a p pour une matrice carrée a. On utilisera la fonction produit. Par exemple, affiche_matrice(puissance(j(3), 4)) renvoie

[6, 5, 5]
[5, 6, 5]
[5, 5, 6]

7) La biblothèque Numpy

  Cette immense bibliothèque (des centaines de fonctions et de méthodes, le document de référence fait 1200 pages) permet entre autres de manipuler les matrices.

import numpy as np        # Importation de la bibliothèque avec un alias

a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
b = np.array(a)     # Conversion en ndarray (objet de base numpy)
print(a, type(a))
print(b, type(b))
# renvoie
[[1, 2, 3], [4, 5, 6], [7, 8, 9]] <class ‘list'>
[[1 2 3]
[4 5 6]
[7 8 9]] <class ‘numpy.ndarray'>

Beaucoup de fonctions évoluées sont accessibles; par exemple:

np.dot(b,c)                     # Produit de matrices
np.linalg.matrix_power(b, 3)     # Puissance de matrice
np.linalg.det(b)                 # Déterminant
np.linalg.inv(b)                 # Inverse
np.transpose(b)                    # Transposée

Un autre intérêt est que l'on peut directement opérer sur les matrices ou sur les lignes des matrices

b[1] + 2*[2]- 3*b[0]                # Calcul sur les lignes de la matrice b
b - 2*c                          # Somme, produit par un nombre

a) Refaire les exemples sur les fonctions somme, produit, puissance avec numpy.

b) Ecrire avec numpy trois fonctions echange(a, i, j), transvection(a, i, j, x) , dilatation(a, i, x) renvoyant la matrice a sur laquelle on a fait l'opération élémentaire L i L j , L i L i + x L j , L i x L i .

La matrice (entrée et sortie) a doit être une matrice de type ndarray . Attention pour l'échange des lignes de a: il faut utiliser une copie indépendante d'une des lignes (np.copy(a[i]) est une copie indépendante de a[i]). Par exemple:

a = np.array(suite(5))
echange(a, 1, 3)
print(a)
renvoie
[[ 1  2  3  4  5]
[16 17 18 19 20]
[11 12 13 14 15]
[ 6  7  8  9 10]
[21 22 23 24 25]]

a = np.array(diag2(4))
print(dilatation(a, 2, 4))
renvoie
[[ 4  3  2  1]
[ 3  2  1  2]
[ 8  4  8 12]
[ 1  2  3  4]]

a = np.array(diag2(4))
print(transvection(a, 0, 3, -4))
renvoie
[[  0  -5 -10 -15]
[  3   2   1   2]
[  2   1   2   3]
[  1   2   3   4]]

© 2014 - Eric Obermeyer      Powered by      Corrigé