8.1.1 Espaces de vecteurs, de matrices
De la même façon que pour les polynômes, les vecteurs et les matrices sont manipulés comme des objets algébriques appartenant à un espace. Si les coefficients appartiennent à un corps K, c’est un espace vectoriel sur K ; s’ils appartiennent à un anneau, c’est un K-module libre.
On construit ainsi l’espace M2,3(Z) et l’espace vectoriel (F32)3par
sage: MS = MatrixSpace(ZZ,2,3); MS
Full MatrixSpace of 2 by 3 dense matrices over Integer Ring
Espaces de matrices
construction MS = MatrixSpace(K, nrows, ncols)
construction (mat. creuses) MS = MatrixSpace(K, nrows, ncols, sparse = True) anneau de base K MS.base_ring()
extension de l’anneau MS.base_extend(B) changement de l’anneau MS.change_ring(B) groupe engendré MatrixGroup([A,B])
base de l’espace MS.basis() ou MS.gens() Construction de matrices
matrice nulle MS() ou MS.zero() ou matrix(K,nrows,ncols) matrice avec coefficients MS([1,2,3,4] ou matrix(K,2,2,[1,2,3,4]) ou
matrix(K,[[1,2],[3,4]])
matrice identité MS.one() ou MS.identity_matrix() ou
identity_matrix(K,n) matrice aléatoire MS.random_element() ou
random_matrix(K,nrows,ncols) bloc de Jordan jordan_block(x,n)
matrice par blocs block_matrix([A,1,B,0]) ou block_diagonal_matrix Manipulations de base
accès à un coefficient A[2,3]
accès à une ligne, colonne A[-1,:], A[:,2] accès aux colonnes paires A[:,0:8:2]
sous-matrices A[3:4,2:5], A[:,2:5], A[:4,2:5] A.matrix_from_rows([1,3]), A.matrix_from_columns([2,5]),
A.matrix_from_rows_and_columns([1,3],[2,5]) A.submatrix(i,j,nrows,ncols)
concaténation par lignes A.stack(B) concaténation par colonnes A.augment(B)
Tableau 8.1– Constructeurs de matrices et de leurs espaces.
Vector space of dimension 3 over Finite Field in x of size 3^2
Un système générateur pour ces espaces est donné par la base canonique ; elle peut être obtenue indifféremment par les méthodes MS.gens() ou MS.basis().
sage: MatrixSpace(ZZ,2,3).basis() h 1 0 0 0 0 0 , 0 1 00 0 0 , 0 0 10 0 0 , 0 0 01 0 0 , 0 0 00 1 0 , 0 0 00 0 1 i
Groupes de matrices. On pourra par ailleurs définir des sous-groupes de l’espace total des matrices. Ainsi le constructeur MatrixGroup([A,B,...]) ren- voie le groupe engendré par les matrices passées en argument, qui doivent être inversibles.
sage: A = matrix(GF(11), 2, 2, [1,0,0,2])
sage: B = matrix(GF(11), 2, 2, [0,1,1,0])
sage: MG.cardinality() 200
sage: identity_matrix(GF(11),2) in MG
True
Le groupe général linéaire de degré n sur un corps K, noté GLn(K), est le groupe formé par les matrices n × n inversibles de Mn,n(K). Il se construit naturellement en Sage avec la commande GL(n,K). Le groupe spécial linéaire SLn(K) des éléments de GLn(K) de déterminant 1 se construit avec la commande SL(n,K).
8.1.2 Construction des matrices et des vecteurs
Les matrices et les vecteurs peuvent naturellement être générés comme des éléments d’un espace en fournissant la liste des coefficients en arguments. Pour les matrices, ceux-ci seront lus par ligne :
sage: MS = MatrixSpace(ZZ,2,3); A = MS([1,2,3,4,5,6]); A
1 2 3
4 5 6
Le constructeur vide MS() renvoie une matrice nulle, tout comme la méthode MS.zero(). Plusieurs constructeurs spécialisés permettent de produire les ma- trices usuelles, comme random_matrix, identity_matrix, jordan_block (voir tableau 8.1). En particulier on pourra construire des matrices et des vecteurs avec les constructeurs matrix et vector, sans devoir construire l’espace associé préalablement. Par défaut une matrice est construite sur l’anneau des entiers Z et a pour dimensions 0 × 0.
sage: a = matrix(); a.parent()
Full MatrixSpace of 0 by 0 dense matrices over Integer Ring
On peut naturellement spécifier un domaine pour les coefficients ainsi que les dimensions, pour créer ainsi une matrice nulle, ou remplie d’une liste de coefficients passée en argument.
sage: a = matrix(GF(8,'x'),3,4); a.parent()
Full MatrixSpace of 3 by 4 dense matrices over Finite Field in x of size 2^3
Le constructeur matrix accepte aussi comme argument des objets admettant une transformation naturelle en matrice. Ainsi, il peut être utilisé pour obtenir la matrice d’adjacence d’un graphe, sous la forme d’une matrice à coefficients dans Z.
sage: g = graphs.PetersenGraph()
sage: m = matrix(g); m; m.parent() [0 1 0 0 1 1 0 0 0 0]
[1 0 1 0 0 0 1 0 0 0] [0 1 0 1 0 0 0 1 0 0] [0 0 1 0 1 0 0 0 1 0]
[1 0 0 1 0 0 0 0 0 1] [1 0 0 0 0 0 0 1 1 0] [0 1 0 0 0 0 0 0 1 1] [0 0 1 0 0 1 0 0 0 1] [0 0 0 1 0 1 1 0 0 0] [0 0 0 0 1 0 1 1 0 0]
Full MatrixSpace of 10 by 10 dense matrices over Integer Ring
Matrices par blocs. Pour construire une matrice par blocs à partir de sous- matrices, on peut utiliser la fonction block_matrix.
sage: A = matrix([[1,2],[3,4]])
sage: block_matrix([[A,-A],[2*A, A^2]]) 1 2 −1 −2 3 4 −3 −4 2 4 7 10 6 8 15 22
La structure est carrée par blocs par défaut mais le nombre de blocs ligne ou colonne peut être spécifié par les arguments optionnels ncols et nrows. Lorsque cela est possible, un coefficient comme 0 ou 1 est interprété comme un bloc diagonal (ici zéro ou identité) de dimension appropriée.
sage: A = matrix([[1,2,3],[4,5,6]])
sage: block_matrix([1,A,0,0,-A,2], ncols=3) 1 0 1 2 3 0 0 0 1 4 5 6 0 0 0 0 −1 −2 −3 2 0 0 0 −4 −5 −6 0 2
Pour le cas particulier des matrices diagonales par blocs, on passe simplement la liste des blocs diagonaux au constructeur block_diagonal_matrix.
sage: A = matrix([[1,2,3],[0,1,0]])
sage: block_diagonal_matrix(A, A.transpose()) 1 2 3 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 2 1 0 0 0 3 0
La structure par blocs n’est qu’une commodité d’affichage, et Sage traite la matrice comme toute autre matrice. On peut par ailleurs désactiver cet affichage en ajoutant l’argument subdivide=False au constructeur block_matrix.
8.1.3 Manipulations de base et arithmétique sur les
matrices
Indices et accès aux coefficients. L’accès aux coefficients ainsi qu’à des sous-matrices extraites se fait de façon unifiée par l’opérateur crochet A[i,j],
selon les conventions usuelles de Python. Les indices de ligne i et de colonne j peuvent être des entiers (pour l’accès à des coefficients) ou des intervalles sous la forme 1:3 (on rappelle que par convention, en Python les indices commencent à 0, et les intervalles sont toujours inclusifs pour la borne inférieure et exclusifs pour la borne supérieure). L’intervalle « : » sans bornes correspond à la totalité des indices possibles dans la dimension considérée. La notation a:b:k permet d’accéder aux indices compris entre a et b − 1 par pas de k. Enfin, les indices négatifs sont aussi valides, et permettent de parcourir les indices à partir de la fin. Ainsi A[-2,:] correspond à l’avant dernière ligne. L’accès à ces sous-matrices se fait aussi bien en lecture qu’en écriture. On peut par exemple modifier une colonne donnée de la façon suivante :
sage: A = matrix(3,3,range(9))
sage: A[:,1] = vector([1,1,1]); A
0 1 23 1 5 6 1 8
L’indice de pas k peut aussi être négatif, indiquant un parcours par valeurs décroissantes.
sage: A[::-1], A[:,::-1], A[::2,-1] 6 1 8 3 1 5 0 1 2 , 2 1 0 5 1 3 8 1 6 , 2 8
Extraction de sous-matrices. Pour extraire une matrice à partir d’une liste d’indices de ligne ou de colonne non nécessairement contigus, on utilise les méthodes A.matrix_from_rows, A.matrix_from_columns, ou dans le cas général la méthode A.matrix_from_rows_and_columns. sage: A = matrix(ZZ,4,4,range(16)); A 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 sage: A.matrix_from_rows_and_columns([0,2,3],[1,2]) 1 2 9 10 13 14
Pour extraire une sous-matrice de lignes et de colonnes contiguës, on pourra aussi utiliser la méthode submatrix(i,j,m,n) formant la sous-matrice de dimen- sion m × n dont le coefficient supérieur gauche se trouve en position (i, j).
Plongements et extensions. Lorsque l’on veut plonger un espace de matrices dans l’espace des matrices de même dimension mais à coefficients dans une extension de l’anneau de base, on pourra utiliser la méthode base_extend de l’espace de matrice. Cette opération n’est toutefois valide que pour les opérations d’extension de corps ou d’anneau. Pour effectuer le changement de l’anneau de base suivant un morphisme (lorsqu’il existe), on utilise plutôt la méthode change_ring.
sage: MS = MatrixSpace(GF(3),2,3)
sage: MS.base_extend(GF(9,'x'))
Full MatrixSpace of 2 by 3 dense matrices over Finite Field in x of size 3^2
sage: MS = MatrixSpace(ZZ,2,3)
sage: MS.change_ring(GF(3))
Full MatrixSpace of 2 by 3 dense matrices over Finite Field of size 3 Mutabilité et mise en cache. Les objets représentant les matrices sont par défaut mutables, c’est-à-dire que l’on peut librement en modifier leurs membres (ici leurs coefficients) après leur construction. Si on souhaite protéger la matrice contre les modifications, on utilise la fonction A.set_immutable(). Il est alors toujours possible d’en tirer des copies mutables par la fonction copy(A). À noter que le mécanisme de mise en cache des résultats calculés (tels que le rang, le déterminant...) reste toujours fonctionnel, quel que soit l’état de mutabilité.
8.1.4 Opérations de base sur les matrices
Les opérations arithmétiques sur les matrices se font avec les opérateurs usuels +,-,*,^. L’inverse d’une matrice A peut s’écrire aussi bien A^-1 que ~A. Lorsque
a est un scalaire et A une matrice, l’opération a*A correspond à la multiplication
externe de l’espace de matrices. Pour les autres opérations où un scalaire a est fourni en lieu et place d’une matrice (par exemple l’opération a+A), il est considéré comme la matrice scalaire correspondante aIn si a 6= 0 et les dimensions le permettent. Le produit élément par élément de deux matrices s’effectue avec l’opération elementwise_product.