Vecteurs et matrices
Un vecteur est une liste simple de nombres représentant, par exemple, une direction dans l’espace ou un ensemble de quantités. Une matrice est une liste de lignes. Cette page présente les produits scalaires et vectoriels, la multiplication matricielle, les déterminants et les inverses, la résolution de systèmes d’équations linéaires, ainsi que les outils numériques de l’algèbre linéaire : valeurs propres, décompositions QR, LU et en valeurs singulières.
Utilisez ces outils en algèbre linéaire, en géométrie, pour les transformations ou pour un problème dont plusieurs inconnues sont reliées par des équations linéaires. Vecteurs et matrices sont des listes ordinaires : les règles de Listes et statistiques, notamment l’indexation, s’appliquent aussi.
Vecteurs
dot([1, 2, 3], [4, 5, 6]) donne 32dot([3, 4], [4, -3]) donne 0cross([1, 0, 0], [0, 1, 0]) donne [0, 0, 1]cross([1, 2, 3], [4, 5, 6]) donne [-3, 6, -3]v = [3, 4]sqrt(dot(v, v)) donne 5dot multiplie les éléments correspondants puis additionne les produits. Un produit scalaire nul signifie que les vecteurs sont orthogonaux, comme [3, 4] et [4, -3]. cross donne un vecteur perpendiculaire aux deux vecteurs fournis : le produit vectoriel de la direction x par la direction y donne la direction z. La norme d’un vecteur est la racine carrée de son produit scalaire avec lui-même.
dot exige deux vecteurs ayant le même nombre d’éléments, et cross deux vecteurs de trois éléments. Pour additionner des vecteurs ou les multiplier par un scalaire, utilisez les opérations habituelles sur les listes : [1, 2] + [3, 4] donne [4, 6], et 2 * [3, 4] donne [6, 8].
Écrire et multiplier des matrices
Écrivez une matrice sous forme de liste de lignes, chaque ligne entre ses propres crochets :
shape([[1, 2, 3], [4, 5, 6]]) donne [2, 3]transpose([[1, 2, 3], [4, 5, 6]]) donne [[1, 4], [2, 5], [3, 6]]identity(3) donne [[1, 0, 0], [0, 1, 0], [0, 0, 1]][[1, 2], [3, 4]] * [[5, 6], [7, 8]] donne [[19, 22], [43, 50]]shape donne [rows, columns], soit le nombre de lignes et de colonnes. transpose échange lignes et colonnes. identity(n) est la matrice identité de dimensions n par n : la multiplication par cette matrice laisse l’autre matrice inchangée.
Entre deux matrices, * effectue une multiplication matricielle. Le nombre de colonnes à gauche doit être égal au nombre de lignes à droite. Pour multiplier une matrice par un vecteur, écrivez le vecteur en colonne, avec un élément par ligne :
# Rotate the point (3, 1) by 90° anticlockwiserotate = [[0, -1], [1, 0]]rotate * [[3], [1]] donne [[-1], [3]]rotate * rotate donne [[-1, 0], [0, -1]]Deux rotations de 90° donnent un demi-tour : rotate * rotate inverse donc les deux signes. Une liste simple comme [3, 1] n’est pas acceptée à droite d’une matrice. Si un nom contient une liste simple, transpose([v]) la transforme en colonne.
Les matrices de mêmes dimensions peuvent être additionnées et soustraites. Comme les autres listes, elles peuvent aussi être multipliées ou divisées par un nombre.
Quelques règles s'appliquent à chaque opération matricielle :
- Chaque ligne doit avoir le même nombre d'éléments.
- Les éléments doivent être des nombres sans unité. Les unités et les montants monétaires ne sont pas acceptés.
- Une matrice peut avoir au plus 32 lignes et 32 colonnes.
- Il n’existe pas de notation abrégée avec un point-virgule. Écrivez
[[1, 2], [3, 4]], et non[1, 2; 3, 4].
Déterminant, inverse, trace et rang
M = [[2, 1], [5, 3]]det(M) donne 1inverse(M) donne [[3, -1], [-5, 2]]M * inverse(M) donne [[1, 0], [0, 1]]trace(M) donne 5inverse([[2, 1], [1, 3]]) donne [[0.6, -0.2], [-0.2, 0.4]]det([[1, 2], [2, 4]]) donne 0rank([[1, 2, 3], [2, 4, 6]]) donne 1det, inverse et trace (la somme de la diagonale) exigent une matrice carrée. Un déterminant nul indique une matrice singulière : ses lignes ne sont pas indépendantes, elle n’a donc pas d’inverse, et inverse([[1, 2], [2, 4]]) produit une erreur. rank donne le nombre de lignes indépendantes et accepte aussi les matrices non carrées. Dans la dernière ligne de l’exemple, la deuxième ligne de la matrice est le double de la première : le rang vaut donc 1.
Ces quatre fonctions utilisent des fractions exactes plutôt que des nombres décimaux. C’est pourquoi M * inverse(M) donne exactement la matrice identité.
Résoudre un système linéaire
Supposons que trois cafés et deux thés coûtent 13,50 £, et un café et quatre thés 11,50 £. Pour chaque équation, écrivez sur une ligne le nombre de boissons, avec les colonnes dans un ordre fixe (café, thé), puis les totaux dans une liste correspondante :
solve_system([[3, 2], [1, 4]], [13.5, 11.5]) donne [3.1, 2.1]Le résultat suit l’ordre des colonnes : un café coûte 3,10 £ et un thé 2,10 £. N’indiquez pas les symboles monétaires dans la matrice, car ses éléments doivent être des nombres sans unité.
solve_system(A, b) résout A * x = b pour trouver x. Il faut une matrice carrée avec une ligne par inconnue, et une liste simple de seconds membres de même longueur. Le calcul utilise des fractions exactes : le résultat ne comporte donc pas d’erreur d’arrondi.
Si les équations ne déterminent pas une solution unique, une erreur le signale. Ainsi, solve_system([[1, 2], [2, 4]], [3, 6]) échoue parce que la seconde équation est le double de la première. solve_system accepte uniquement les équations linéaires. Pour une équation telle que x^2 = 2, utilisez solve, présenté dans Sommation, résolution d’équations et analyse.
Valeurs propres
eigenvalues([[2, 1], [1, 2]]) donne [1, 3]eigenvalues([[4, 1], [2, 3]]) donne [5, 2]eigenvalues([[0, -1], [1, 0]]) donne [i, -i]eigenvalues accepte une matrice carrée et renvoie une liste simple. Une rotation de 90° ne laisse aucune direction inchangée : ses valeurs propres sont donc les deux nombres complexes i et -i ; voir Nombres complexes. Ne vous fiez pas à l’ordre des éléments de la liste.
Décompositions QR, LU et SVD
Chaque décomposition renvoie une liste de matrices. Utilisez les indices pour en extraire les facteurs :
A = [[3, 0], [4, 5]]parts = qr(A)q = parts[0] donne [[0.6, -0.8], [0.8, 0.6]]r = parts[1] donne [[5, 4], [0, 3]]q * r donne [[3, 0], [4, 5]]Multiplier les facteurs redonne A, ce qui permet de vérifier rapidement une décomposition. Les calculs en virgule flottante binaire laissent de petits résidus d’arrondi, de l’ordre de 10⁻¹⁵, que Varlig affiche comme 0 dans les listes et matrices. Les valeurs mémorisées conservent tous leurs chiffres : comparez donc les résultats visuellement ou en examinant leur différence, pas avec ==.
lu([[2, 1], [4, 3]]) donne [[[0, 1], [1, 0]], [[1, 0], [0.5, 1]], [[4, 3], [0, -0.5]]]lu renvoie [P, L, U], où P enregistre tous les échanges de lignes et P * A est égal à L * U. Ici, les lignes ont été échangées de sorte que le plus grand nombre, 4, soit utilisé en premier.
B = [[3, 1], [4, 7]]f = svd(B)u = f[0]s = f[1]vt = f[2]u * [[s[0], 0], [0, s[1]]] * vt donne [[3, 1], [4, 7]]svd([[3, 4]]) donne [[[1]], [5], [[0.6, 0.8]]]svd renvoie [U, s, Vt], où s est la liste simple des valeurs singulières, dans l’ordre décroissant. Dans la notation des manuels, B vaut U * diag(s) * Vt. La fonction diag n’existe pas ici : construisez vous-même la matrice diagonale, par exemple [[s[0], 0], [0, s[1]]].
| Fonction | Entrées et résultat |
|---|---|
identity(n) |
La matrice identité de taille n par n |
shape(A) |
[rows, columns] |
transpose(A) |
Lignes et colonnes échangées |
det(A) |
Déterminant d'une matrice carrée |
inverse(A) |
Inverse d'une matrice carrée avec un déterminant non nul |
trace(A) |
Somme de la diagonale d'une matrice carrée |
rank(A) |
Nombre de lignes indépendantes ; toute matrice rectangulaire |
solve_system(A,b) |
Solution de A * x = b pour une matrice carrée avec une seule solution |
eigenvalues(A) |
Valeurs propres d’une matrice carrée, éventuellement complexes, sans ordre particulier |
qr(A) |
[Q, R] avec Q * R approximativement égal à A ; toute matrice rectangulaire |
lu(A) |
[P, L, U] avec P * A approximativement égal à L * U ; matrice carrée |
svd(A) |
[U, s, Vt], où s est une liste plate ; toute matrice rectangulaire |
Pour une matrice non carrée, qr et svd renvoient les facteurs d’une décomposition réduite : pour une matrice de dimensions 3 par 2, Q mesure aussi 3 par 2, et non 3 par 3.
Calculs exacts et cas refusés
L’addition, la soustraction et la multiplication matricielles, la multiplication par un nombre, transpose, det et inverse utilisent des fractions exactes pour toutes les matrices acceptées par Varlig. Aucun arrondi n’est effectué à l’entrée ni lors de la transmission à un autre calcul : multiplier une matrice par son inverse donne donc exactement la matrice identité.
[[1, 2], [3, 4]] + [[10, 20], [30, 40]] donne [[11, 22], [33, 44]][[1, 2], [3, 4]] - [[1, 1], [1, 1]] donne [[0, 1], [2, 3]]3 * [[1, 2], [3, 4]] donne [[3, 6], [9, 12]][[1, 2], [3, 4]] * [[0, 1], [1, 0]] donne [[2, 1], [4, 3]]det([[1, 2], [3, 4]]) donne -2inverse([[1, 2], [3, 4]]) donne [[-2, 1], [1.5, -0.5]]inverse([[1, 2], [3, 4]]) * [[1, 2], [3, 4]] donne [[1, 0], [0, 1]]Chaque condition est vérifiée avant qu'une réponse n'apparaisse, et le message indique laquelle a échoué :
det([[1, 2, 3], [4, 5, 6]]) donne Unsupported: Expected a square matrixinverse([[1, 2], [2, 4]]) donne Unsupported: Singular matrix has no inverse[[1, 2], [3, 4]] + [[1, 2, 3], [4, 5, 6]] donne Unsupported: List dimensions do not match[[1, 2, 3], [4, 5, 6]] * [[1, 2], [3, 4]] donne Unsupported: Matrix inner dimensions do not matchLes éléments d’une matrice doivent être des nombres sans unité. La présence d’une unité, d’un montant monétaire ou d’un nombre complexe interrompt le calcul : aucune opération matricielle ne les conserverait.
det([[1 kg, 2], [3, 4]]) donne Unsupported: Matrix entries must be plain numbers; units, money and complex values are not supportedSeule une liste de lignes est interprétée comme une matrice. Une liste simple conserve son sens : [1, 2] + [3, 4] donne toujours [4, 6] par addition terme à terme, et [1, 2] * [3, 4] produit toujours une erreur suggérant dot.
Les règles d’exactitude des équations, matrices et statistiques sont regroupées dans Garanties du moteur.
Algorithmes et limites
det, inverse, rank et solve_system utilisent des fractions exactes, dans les limites de taille des nombres du calculateur. eigenvalues, qr, lu et svd utilisent la virgule flottante binaire : leurs résultats sont des approximations précises. Leurs itérations s’arrêtent après 10 000 étapes.
Les matrices dont les lignes sont presque dépendantes, comme [[1, 1], [1, 1.0000001]], sont dites mal conditionnées. De petites erreurs d’arrondi peuvent s’y amplifier fortement : leurs décompositions et valeurs propres risquent donc de perdre en précision. Les cas extrêmes peuvent dépasser les limites numériques et produire une erreur.
Les règles complètes figurent dans la référence des mathématiques avancées.
Combiner les opérations
Trois reçus d'un stand de marché répertorient le nombre de pommes, de bananes et d'oranges achetées et le total payé, mais pas les prix individuels :
# Each row: apples, bananas, orangesbaskets = [[2, 3, 1], [1, 2, 3], [4, 1, 2]]paid = [2.15, 2.70, 3.05]det(baskets) donne 25prices = solve_system(baskets, paid) donne [0.4, 0.25, 0.6]# Check the prices against every receiptbaskets * transpose([prices]) donne [[2.15], [2.7], [3.05]]# What would 5 apples, 2 bananas and 4 oranges cost?dot([5, 2, 4], prices) donne 4.9Le déterminant non nul confirme que les reçus suffisent à déterminer des prix uniques : 40 pence pour les pommes, 25 pour les bananes et 60 pour les oranges. Multiplier la matrice des paniers par les prix en colonne redonne les totaux, et dot calcule un nouveau panier à 4,90 £.