Des articles

12.2 : Multiplication de matrices


La prochaine opération matricielle importante que nous allons explorer est la multiplication de matrices. L'opération de multiplication matricielle est l'une des opérations matricielles les plus importantes et les plus utiles. Tout au long de cette section, nous montrerons également comment la multiplication matricielle est liée aux systèmes d'équations linéaires.

Tout d'abord, nous proposons une définition formelle des vecteurs ligne et colonne.

Définition (PageIndex{1}) : vecteurs de lignes et de colonnes

Les matrices de taille (n imes 1) ou (1 imes n) sont appelées vecteurs. Si (X) est une telle matrice, alors nous écrivons (x_{i}) pour désigner l'entrée de (X) dans la ligne (i^{th}) d'une matrice de colonnes, ou la colonne (i^{th}) d'une matrice de lignes.

La matrice (n imes 1) [X=left[ egin{array}{c} x_{1} vdots x_{n} end{array} ight]] est appelé un vecteur colonne. La matrice (1 imes n) [X = left[ egin{array}{ccc} x_{1} & cdots & x_{n} end{array} ight]] est appelée un vecteur de ligne.

On peut simplement utiliser le terme vecteur tout au long de ce texte pour faire référence à un vecteur de colonne ou de ligne. Si nous le faisons, le contexte indiquera clairement à quoi nous nous référons.

Dans ce chapitre, nous utiliserons à nouveau la notion de combinaison linéaire de vecteurs comme dans la définition [def:linearcombination]. Dans ce contexte, une combinaison linéaire est une somme constituée de vecteurs multipliés par des scalaires. Par exemple, [left[ egin{array}{r} 50 122 end{array} ight] = 7left[ egin{array}{r} 1 4 end{array} ight] +8left[ egin{array}{r} 2 5 end{array} ight] +9left[ egin{array}{r} 3 6 end{array} ight]] est une combinaison linéaire de trois vecteurs.

Il s'avère que nous pouvons exprimer n'importe quel système d'équations linéaires comme une combinaison linéaire de vecteurs. En fait, les vecteurs que nous utiliserons ne sont que les colonnes de la matrice augmentée correspondante !

Définition (PageIndex{2}) : la forme vectorielle d'un système d'équations linéaires

Supposons que nous ayons un système d'équations donné par [egin{array}{c} a_{11}x_{1}+cdots +a_{1n}x_{n}=b_{1} vdots a_{m1}x_{1}+cdots +a_{mn}x_{n}=b_{m} end{array}] On peut exprimer ce système en forme vectorielle qui est la suivante : [x_1 left[ egin{array}{c} a_{11} a_{21} vdots a_{m1} end{array} ight] + x_2 left[ egin{array}{c} a_{12} a_{22} vdots a_{m2} end{array} ight] + cdots + x_n left[ egin{array }{c} a_{1n} a_{2n} vdots a_{mn} end{array} ight] = left[ egin{array}{c} b_1 b_2 vdots b_m end{array} ight]]

Notez que chaque vecteur utilisé ici est une colonne de la matrice augmentée correspondante. Il y a un vecteur pour chaque variable dans le système, ainsi que le vecteur constant.

La première forme importante de multiplication matricielle est la multiplication d'une matrice par un vecteur. Considérons le produit donné par [left[ egin{array}{rrr} 1 & 2 & 3 4 & 5 & 6 end{array} ight] left[ egin{array}{r} 7 8 9 end{array} ight]] Nous verrons bientôt que cela équivaut à [7left[ egin{array}{c} 1 4 end{array} ight] + 8left[ egin{array}{c} 2 5 end{array} ight] +9left[ egin{array}{c} 3 6 end{array} ight] = left[ egin{array}{c} 50 122 end{array} ight]]

En termes généraux, [egin{aligned} left[ egin{array}{ccc} a_{11} & a_{12} & a_{13} a_{21} & a_{22} & a_{ 23} end{array} ight] left[ egin{array}{c} x_{1} x_{2} x_{3} end{array} ight] &=& x_ {1}left[ egin{array}{c} a_{11} a_{21} end{array} ight] +x_{2}left[ egin{array}{c} a_{ 12} a_{22} end{array} ight] +x_{3}left[ egin{array}{c} a_{13} a_{23} end{array} ight] &=&left[ egin{array}{c} a_{11}x_{1}+a_{12}x_{2}+a_{13}x_{3} a_{21}x_{ 1}+a_{22}x_{2}+a_{23}x_{3} end{array} ight] end{aligned}] Ainsi vous prenez (x_{1}) fois la première colonne , ajoutez à (x_{2}) fois la deuxième colonne, et enfin (x_{3}) fois la troisième colonne. La somme ci-dessus est une combinaison linéaire des colonnes de la matrice. Lorsque vous multipliez une matrice à gauche par un vecteur à droite, les nombres constituant le vecteur ne sont que les scalaires à utiliser dans la combinaison linéaire des colonnes comme illustré ci-dessus.

Voici la définition formelle de la façon de multiplier une matrice (m imes n) par un vecteur colonne (n imes 1).

Définition (PageIndex{3}): Multiplication du vecteur par la matrice

Soit (A=left[ a_{ij} ight]) une matrice (m imes n) et soit (X) une matrice (n imes 1) donnée par [ A=left[ A_{1} cdots A_{n} ight], X = left[ egin{array}{r} x_{1} vdots x_{n} end{array } droite]]

Alors le produit (AX) est le vecteur colonne (m imes 1) qui est égal à la combinaison linéaire suivante des colonnes de (A): [x_{1}A_{1}+x_{2 }A_{2}+cdots +x_{n}A_{n} = sum_{j=1}^{n}x_{j}A_{j}]

Si nous écrivons les colonnes de (A) en fonction de leurs entrées, elles sont de la forme [A_{j} = left[ egin{array}{c} a_{1j} a_{2j} vdots a_{mj} end{array} ight]] Ensuite, nous pouvons écrire le produit (AX) comme [AX = x_{1}left[ egin{array}{ c} a_{11} a_{21} vdots a_{m1} end{array} ight] + x_{2}left[ egin{array}{c} a_{12} a_{22} vdots a_{m2} end{array} ight] +cdots + x_{n}left[ egin{array}{c} a_{1n} a_ {2n} vdots a_{mn} end{array} ight]]

Notez que la multiplication d'une matrice (m imes n) et d'un vecteur (n imes 1) produit un vecteur (m imes 1).

Voici un exemple.

Exemple (PageIndex{1}) : un vecteur multiplié par une matrice

Calculer le produit (AX) pour [A = left[ egin{array}{rrrr} 1 & 2 & 1 & 3 0 & 2 & 1 & -2 2 & 1 & 4 & 1 end{array} ight], X = left[ egin{array}{r} 1 2 0 1 end{array} ight]]

Solution

Nous utiliserons la définition [def:multiplicationvectormatrix] pour calculer le produit. Par conséquent, nous calculons le produit (AX) comme suit. [egin{aligned} & 1left[ egin{array}{r} 1 0 2 end{array} ight] + 2left[ egin{array}{r} 2 2 1 end{array} ight] + 0left[ egin{array}{r} 1 1 4 end{array} ight] + 1 left[ egin{array }{r} 3 -2 1 end{array} ight] &= left[ egin{array}{r} 1 0 2 end{array} ight] + left[ egin{array}{r} 4 4 2 end{array} ight] + left[ egin{array}{r} 0 0 0 end{array } ight] + left[ egin{array}{r} 3 -2 1 end{array} ight] &= left[ egin{array}{r} 8 2 5 end{array} ight]end{aligned}]

En utilisant l'opération ci-dessus, nous pouvons également écrire un système d'équations linéaires dans forme matricielle. Sous cette forme, nous exprimons le système sous la forme d'une matrice multipliée par un vecteur. Considérez la définition suivante.

Définition (PageIndex{4}): La forme matricielle d'un système d'équations linéaires

Supposons que nous ayons un système d'équations donné par [egin{array}{c} a_{11}x_{1}+cdots +a_{1n}x_{n}=b_{1} a_{21} x_{1}+ cdots + a_{2n}x_{n} = b_{2} vdots a_{m1}x_{1}+cdots +a_{mn}x_{n}=b_{ m} end{array}] On peut alors exprimer ce système en forme matricielle comme suit. [left[ egin{array}{cccc} a_{11} & a_{12} & cdots & a_{1n} a_{21} & a_{22} & cdots & a_{2n} vdots & vdots & ddots & vdots a_{m1} & a_{m2} & cdots & a_{mn} end{array} ight] left[ egin{array}{c} x_{1} x_{2} vdots x_{n} end{array} ight] = left[ egin{array}{c} b_{1} b_{2} vdots b_{m} end{array} ight]]

L'expression (AX=B) est également connue sous le nom de Forme matricielle du système d'équations linéaires correspondant. La matrice (A) est simplement la matrice de coefficients du système, le vecteur (X) est le vecteur colonne construit à partir des variables du système, et enfin le vecteur (B) est le vecteur colonne construit à partir les constantes du système. Il est important de noter que tout système d'équations linéaires peut être écrit sous cette forme.

Notez que si nous écrivons un système homogène d'équations sous forme matricielle, il aurait la forme (AX=0), pour le vecteur zéro (0).

Vous pouvez voir à partir de cette définition qu'un vecteur [X = left[ egin{array}{c} x_{1} x_{2} vdots x_{n} end{array} right]] satisfera l'équation (AX=B) uniquement lorsque les entrées (x_{1}, x_{2}, cdots, x_{n}) du vecteur (X) sont solutions au système d'origine.

Maintenant que nous avons examiné comment multiplier une matrice par un vecteur, nous souhaitons considérer le cas où nous multiplions deux matrices de tailles plus générales, bien que ces tailles doivent encore être appropriées comme nous le verrons. Par exemple, dans l'exemple [exa:vectormultbymatrix], nous avons multiplié une matrice (3 imes 4) par un vecteur (4 imes 1). Nous voulons étudier comment multiplier d'autres tailles de matrices.

Nous n'avons pas encore donné de conditions sur le moment où la multiplication matricielle est possible ! Pour les matrices (A) et (B), pour former le produit (AB), le nombre de colonnes de (A) doit être égal au nombre de lignes de (B.) Considérons un produit (AB) où (A) a la taille (m imes n) et (B) a la taille (n imes p). Ensuite, le produit en termes de taille des matrices est donné par [(m imesoverset{ ext{ces doivent correspondre !}}{widehat{n);(n} imes p})=m fois p]

Notez que les deux chiffres extérieurs donnent la taille du produit. L'une des règles les plus importantes concernant la multiplication matricielle est la suivante. Si les deux nombres du milieu ne correspondent pas, vous ne pouvez pas multiplier les matrices !

Lorsque le nombre de colonnes de (A) est égal au nombre de lignes de (B) les deux matrices sont dites conforme et le produit (AB) est obtenu comme suit.

Définition (PageIndex{4}) : Multiplication de deux matrices

Soit (A) une matrice (m imes n) et soit (B) une matrice (n imes p) de la forme [B=left[ B_{1} cdots B_{p} ight]] où (B_{1},...,B_{p}) sont les (n imes 1) colonnes de (B). Alors la matrice (m imes p) (AB) est définie comme suit : [AB = A left[ B_{1} cdots B_{p} ight] = left[ (AB)_ {1} cdots (AB)_{p} ight]] où ((AB)_{k}) est une matrice (m imes 1) ou un vecteur colonne qui donne le (k^ {th}) colonne de (AB).

Considérez l'exemple suivant.

Exemple (PageIndex{2}) : Multiplication de deux matrices

Trouvez (AB) si possible. [A = left[ egin{array}{rrr} 1 & 2 & 1 0 & 2 & 1 end{array} ight], B = left[ egin{array}{rrr} 1 & 2 & 0 0 & 3 & 1 -2 & 1 & 1 end{array} ight]]

Solution

La première chose que vous devez vérifier lors du calcul d'un produit est de savoir si la multiplication est possible. La première matrice a la taille (2 imes 3) et la deuxième matrice a la taille (3 imes 3). Les nombres intérieurs sont égaux, donc (A) et (B) sont des matrices conformes. Selon la discussion ci-dessus, (AB) sera une matrice (2 imes 3). La définition [def:multiplicationoftwomatrices] nous donne un moyen de calculer chaque colonne de (AB), comme suit.

[left[ overset{ ext{Première colonne}}{overbrace{left[ egin{array}{rrr} 1 & 2 & 1 0 & 2 & 1 end{array} ight] left[ egin{array}{r} 1 0 -2 end{array} ight] }},overset{ ext{Deuxième colonne}}{overbrace{left[ egin{ array}{rrr} 1 & 2 & 1 0 & 2 & 1 end{array} ight] left[ egin{array}{r} 2 3 1 end{array} ight ] }},overset{ ext{Troisième colonne}}{overbrace{left[ egin{array}{rrr} 1 & 2 & 1 0 & 2 & 1 end{array} ight] left[ egin{array}{r} 0 1 1 end{array} ight] }} ight]] Vous savez comment multiplier une matrice par un vecteur, en utilisant la définition [def:multiplicationvectormatrix] pour chacune des trois colonnes. Ainsi [left[ egin{array}{rrr} 1 & 2 & 1 0 & 2 & 1 end{array} ight] left[ egin{array}{rrr} 1 & 2 & 0 0 & 3 & 1 -2 & 1 & 1 end{array} ight] = left[ egin{array}{rrr} -1 & 9 & 3 -2 & 7 & 3 end{tableau} ight]]

Puisque les vecteurs sont simplement des matrices (n imes 1) ou (1 imes m), on peut aussi multiplier un vecteur par un autre vecteur.

Exemple (PageIndex{3}): Multiplication de vecteurs de temps

Multipliez si possible (left[ egin{array}{r} 1 2 1 end{array} ight] left[ egin{array}{rrrr} 1 & 2 & 1 & 0 end{tableau} ight] .)

Solution

Dans ce cas, nous multiplions une matrice de taille (3 imes 1) par une matrice de taille (1 imes 4.) Les nombres intérieurs correspondent donc le produit est défini. Notez que le produit sera une matrice de taille (3 imes 4). En utilisant la définition [def:multiplicationoftwomatrices], nous pouvons calculer ce produit comme suit (:) [left[ egin{array}{r} 1 2 1 end{array} ight] left[ egin{array}{rrrr} 1 & 2 & 1 & 0 end{array} ight] = left[ overset{ ext{Première colonne}}{overbrace{left[ egin{array }{r} 1 2 1 end{array} ight] left[ egin{array}{r} 1 end{array} ight] }},overset{ ext{Deuxième colonne }}{overbrace{left[ egin{array}{r} 1 2 1 end{array} ight] left[ egin{array}{r} 2 end{array} right] }},overset{ ext{Troisième colonne}}{overbrace{left[ egin{array}{r} 1 2 1 end{array} ight] left[ egin {array}{r} 1 end{array} ight] }}, overset { ext{Quatrième colonne}}{overbrace{left[ egin{array}{r} 1 2 1 end{array} ight] left[ egin{array}{r} 0 end{array} ight]}} ight]]

Vous pouvez utiliser la définition [def:multiplicationvectormatrix] pour vérifier que ce produit est [left[ egin{array}{cccc} 1 & 2 & 1 & 0 2 & 4 & 2 & 0 1 & 2 & 1 & 0 end{tableau} ight]]

Exemple (PageIndex{4}) : une multiplication qui n'est pas définie

Trouvez (BA) si possible. [B = left[ egin{array}{ccc} 1 & 2 & 0 0 & 3 & 1 -2 & 1 & 1 end{array} ight], A = left[ begin{array}{ccc} 1 & 2 & 1 0 & 2 & 1 end{array} ight]]

Solution

Vérifiez d'abord si c'est possible. Ce produit est de la forme (left( 3 imes 3 ight) left( 2 imes 3 ight) .) Les nombres intérieurs ne correspondent pas et vous ne pouvez donc pas faire cette multiplication.

Dans ce cas, on dit que la multiplication n'est pas définie. Notez que ce sont les mêmes matrices que nous avons utilisées dans l'exemple [exa:multiplicationoftwomatrices]. Dans cet exemple, nous avons essayé de calculer (BA) au lieu de (AB). Cela démontre une autre propriété de la multiplication matricielle. Alors que le produit (AB) peut être défini, nous ne pouvons pas supposer que le produit (BA) sera possible. Il est donc important de toujours vérifier que le produit est défini avant d'effectuer tout calcul.

Auparavant, nous avons défini la matrice de zéros (0) comme étant la matrice (de taille appropriée) contenant des zéros dans toutes les entrées. Considérons l'exemple suivant pour la multiplication par la matrice zéro.

Exemple (PageIndex{5}): Multiplication par la matrice zéro

Calculer le produit (A0) pour la matrice [A= left[ egin{array}{rr} 1 & 2 3 & 4 end{array} ight]] et le (2 fois 2) matrice nulle donnée par [0= left[ egin{array}{rr} 0 & 0 0 & 0 end{array} ight]]

Solution

Dans ce produit, nous calculons [left[ egin{array}{rr} 1 & 2 3 & 4 end{array} ight] left[ egin{array}{rr} 0 & 0 0 & 0 end{array} ight] = left[ egin{array}{rr} 0 & 0 0 & 0 end{array} ight]]

D'où (A0=0).

Notez que nous pourrions aussi multiplier (A) par le vecteur zéro (2 imes 1) donné par (left[ egin{array}{r} 0 0 end{array} ight] ). Le résultat serait le vecteur zéro (2 imes 1). Par conséquent, c'est toujours le cas (A0=0), pour une matrice ou un vecteur zéro de taille appropriée.


12.2 : Multiplication de matrices

Étant donné deux matrices éparses (Matrice éparse et ses représentations | Ensemble 1 (à l'aide de tableaux et de listes chaînées)), effectuez des opérations telles que l'addition, la multiplication ou la transposition des matrices sous leur forme éparse elle-même. Le résultat devrait consister en trois matrices creuses, une obtenue en additionnant les deux matrices d'entrée, une en multipliant les deux matrices et une obtenue par transposition de la première matrice.

Exemple: Notez que les autres entrées de matrices seront nulles car les matrices sont clairsemées.


Si vous avez une liste de matrices, vous pouvez appliquer une multiplication de points à toutes les matrices en changeant le Head of the list en Dot . Pour illustrer cela, je vais d'abord définir un ensemble de matrices symboliquement :

Cela ne contient que deux matrices pour des raisons d'affichage, mais vous pouvez changer numberOfMatrices en ce que vous voulez.

Maintenant, la réponse à votre question est simplement :

J'ai remarqué qu'il y a une accélération significative par rapport à la méthode ci-dessus, ainsi qu'à l'approche équivalente utilisant Fold mentionnée par J.M., si je partitionne la liste des matrices au préalable et fais les produits scalaires en deux étapes :

Le gain de vitesse est plus spectaculaire pour les plus grandes listes de matrices, et on peut être amené à jouer avec la taille de la partition. J'ai utilisé la commande UpTo in Partition pour permettre à la partition restante d'être de taille variable.

Si vous souhaitez tester cela pour des listes plus grandes, je suggère d'omettre le test sur la dernière ligne car il sera très lent (j'ai déjà essayé de l'accélérer en utilisant des nombres aléatoires à la place des éléments de matrice symboliques).

L'idée originale était d'utiliser ParallelMap sur la partition, mais la surcharge due à la parallélisation consomme le gain de vitesse avec l'exemple testé.


Exemple : Multiplier deux matrices sans utiliser de fonctions

Dans ce programme, il est demandé à l'utilisateur d'entrer d'abord la taille de deux matrices.

La colonne de la première matrice doit être égale à la ligne de la deuxième matrice pour la multiplication. Si cette condition n'est pas satisfaite, la taille de la matrice est à nouveau demandée à l'aide de la boucle while.

Ensuite, l'utilisateur est invité à entrer deux matrices et enfin la sortie de deux matrices est calculée et affichée.

Comme le programme est long et difficile à déboguer, il est préférable de résoudre ce programme en le passant à une fonction.


Opérations vectorielles et matricielles pour l'analyse multivariée

2.6.2 Matrices diagonale, scalaire, de signe et d'identité

Un cas particulier d'une matrice symétrique est une matrice diagonale. Une matrice diagonale est définie comme une matrice carrée dans laquelle toutes les entrées hors diagonale sont nulles. (Notez qu'une matrice diagonale est nécessairement symétrique.) Les entrées sur la diagonale principale peuvent être nulles ou non.

Des exemples de matrices diagonales sont

Si toutes les entrées sur la diagonale principale sont des scalaires égaux, alors la matrice diagonale est appelée un matrice scalaire.

Des exemples de matrices scalaires sont

Si certaines des entrées sur la diagonale principale sont -1 et les autres sont +1, la matrice diagonale est appelée un matrice de signe. Des exemples de matrices de signes sont

Si les entrées sur la diagonale d'une matrice scalaire sont chacune égales à l'unité, alors ce type de matrice scalaire est appelé un matrice d'identité, noté je. Les exemples sont

Un certain nombre de propriétés utiles sont associées aux matrices diagonales et, par conséquent, aux cas particuliers des matrices scalaires, de signe et d'identité.

La transposée d'une matrice diagonale est égale à la matrice originale.

Les sommes et les différences des matrices diagonales sont également des matrices diagonales.

Prémultiplication d'une matrice UNE par une matrice diagonale résulte en une matrice dans laquelle chaque entrée d'une ligne donnée est le produit de l'entrée d'origine dans UNE correspondant à cette ligne et l'élément diagonal dans la ligne correspondante de la matrice diagonale. Pour illustrer,

Postmultiplication d'une matrice UNE par une matrice diagonale résulte en une matrice dans laquelle chaque entrée dans une colonne donnée est le produit de l'entrée originale dans UNE correspondant à cette colonne et l'élément diagonal dans la colonne correspondante de la matrice diagonale. Pour illustrer,

Pré- et post-multiplication d'une matrice UNE par matrices diagonales 1 et 2 aboutir à une matrice dont jel'entrée est le produit de la jeème entrée dans la diagonale du prémultiplicateur, le jel'entrée de UNE, et le jème entrée du postmultiplicateur. Par example,

Le produit d'un nombre quelconque de matrices diagonales est une matrice diagonale, dont chacune des entrées est le produit des entrées diagonales correspondantes des matrices. Par example,

La multiplication matricielle diagonale, en supposant la conformabilité, est commutative.

Les puissances des matrices diagonales sont trouvées simplement en élevant chaque entrée diagonale à la puissance en question. 8 (Les racines se trouvent de manière analogue.)

La pré- ou post-multiplication d'une matrice A par une matrice scalaire multiplie toutes les entrées de A par l'entrée constante dans la matrice scalaire. C'est équivalent à la multiplication scalaire de la matrice, par ce scalaire apparaissant sur la diagonale.

Comme cas particulier, la pré- ou post-multiplication d'une matrice A par I, la matrice identité, laisse la matrice d'origine inchangée.

Les puissances d'une matrice identité sont égales à la matrice d'origine.

Bien que les propriétés ci-dessus ne soient en aucun cas exhaustives des caractéristiques des matrices diagonales, ou des cas particuliers des matrices scalaires, de signes et d'identité, elles représentent les principales propriétés d'intérêt pour les chercheurs appliqués.


Multiplication matricielle en Python

dans ce tutoriel, nous verrons deux segments pour résoudre la matrice

Voici le tutoriel complet de multiplication de deux matrices à l'aide d'une boucle imbriquée : Multiplier deux matrices en Python

La multiplication de deux matrices X et Y n'est définie que si le nombre de colonnes dans X est égal au nombre de lignes Y .sinon cela conduira à une erreur dans le résultat de sortie.

Si X est une matrice (n X m) et Y est une matrice (m x 1) alors, XY est défini et a la dimension (n x 1).

suivez le code ci-dessous pour implémenter l'opération matricielle entre deux matrices.

nous allons maintenant nous concentrer sur la deuxième partie de ce tutoriel qui est :


12.2 : Multiplication de matrices

Les matrices et les vecteurs ont des similitudes et des différences les opérations sur les matrices et les vecteurs ont beaucoup en commun.

Vecteur est un objet mathématique qui a à la fois une magnitude et une direction, par opposition aux scalaires, qui n'ont qu'une magnitude.

Tous les nombres réels sont des scalaires.   Nous pouvons représenter graphiquement un vecteur à deux dimensions par une flèche avec la queue de la flèche à l'origine, et la tête de la flèche à une paire ordonnée dans le plan cartésien.

De manière équivalente, nous pouvons représenter un vecteur à deux dimensions comme une paire ordonnée dans le plan cartésien, en supposant que la queue est à l'origine et la tête est à la paire ordonnée.   Un vecteur à n dimensions est d'ordre n, s'il a n éléments.

Nous désignons les vecteurs par des lettres majuscules et notons qu'ils peuvent avoir n'importe quelle dimension ou ordre fini, n, par exemple comme dans :

Les vecteurs sont ordonnés, c'est-à-dire : deux les vecteurs sont égaux si et seulement si elles ont la même dimension et les mêmes éléments correspondants dans le même ordre.

Si A = ( un1, une2, une3, . . ., unem )
et B = ( b1, b2, b3, . . ., bm ),
ensuite A = B si et seulement si
pour chaque je de 1 à n, uneje = bje.

Chaque vecteur a un ordre de grandeur , ou alors longueur , noté par | A | , qui est donné par :

| A | = sqrt [ ( un1 ) 2 + ( un2 ) 2 + ( un3 ) 2 + . . . + ( unm ) 2 ]

qui est dérivé par des applications successives du théorème de Pythagore.

Compatible pour l'ajout Deux vecteurs sont compatibles pour l'addition s'ils ont le même ordre, c'est-à-dire le même nombre d'éléments. Ajout de vecteur s'effectue entre deux vecteurs compatibles pour l'addition, en ajoutant dans l'ordre les éléments élémentaires correspondants.   Si UNE et B sont comme ci-dessus, alors

A + B = ( un1 + b1, une2 + b2, une3 + b3, . . ., unem + bm )

Multiplication vectorielle un scalaire, k (où est une constante, un nombre réel quelconque), s'effectue en multipliant chaque élément par k si UNE est comme ci-dessus, alors

Équation 5 : Multiplication de vecteurs par un scalaire

kA = ( ka1, ka2, ka3, . . ., kam )
Soustraction vectorielle désigné par A – B , s'effectue en ajoutant – 1 fois B à UNE c'est-à-dire si UNE et B sont comme ci-dessus, alors

A – B = A + – B
Produit scalaire s'effectue de la manière suivante :

A · B = a1b1 + un2b2 + un3b3 + . . . + unmbm

Notez que le produit scalaire est une somme des produits des éléments de vecteurs correspondants UNE et B

Notez également que le produit scalaire de deux vecteurs n'est PAS un vecteur - c'est plutôt un scalaire, un nombre réel.

Nous utilisons une opération très similaire au produit scalaire lorsque nous nous tournons vers la multiplication de deux matrices.

Insérer des exercices vectoriels

EXEMPLE 1: Laisser A = ( 2, – 3, 0, 4 ) et B = ( 2, – 1, 3, x )
A + B = ( 2 + 2, – 3 – 1, 0 + 3, 4 + x )
A + B = ( 4, – 4, 3, 4 + x )
3A = 3 · ( 2, – 3, 0, 4 )
3A = ( 3 · 2, 3 · – 3, 3 · 0, 3 · 4 )
3A = ( 6, – 9, 0, 12 )
2A – 3B = 2 · ( 2, – 3, 0, 4 ) – 3 · ( 2, – 1, 3, x )
2A – 3B = ( 2 · 2, 2 · – 3, 2 · 0, 2 · 4 ) – ( 3 · 2, 3 · &# 150 1, 3 · 3, 3 · x )
2A – 3B = ( 4, – 6, 0, 8 ) – ( 6, – 3, 9, 3x )
2A – 3B = ( 4 – 6, – 6 – [– 3], 0 – 9, 8 – 3x )
2A – 3B = ( – 2, – 3, – 9, 8 – 3x )
2A + 3B = 2 · ( 2, – 3, 0, 4 ) + 3 · ( 2, – 1, 3, x )
2A + 3B = ( 2 · 2, 2 · – 3, 2 · 0, 2 · 4 ) + ( 3 · 2, 3 · – 1, 3 · 3, 3 · x )
2A + 3B = ( 4, – 6, 0, 8 ) + ( 6, – 3, 9, 3x )
2A + 3B = ( 4 + 6, – 6 + – 3, 0 + 9, 8 + 3x )
2A + 3B = ( 10, – 9, 9, 8 + 3x )
A · A = ( 2, – 3, 0, 4 ) · ( 2, – 3, 0, 4 )
A · A = 2 · 2 + – 3 · – 3 + 0 · 0 + 4 · 4
A · A = 4 + 9 + 0 + 16
A · A = 29
A · B = ( 2, – 3, 0, 4 ) · ( 2, – 1, 3, x )
A · B = 2 · 2 + – 3 · – 1 + 0 · 3 + 4 · x
A · B = 4 + 3 + 0 + 4x
A · B = 7 + 4x
– A · A = – ( 2, – 3, 0, 4 ) · ( 2, – 3, 0, 4 )
– A · A = ( – 2, 3, 0, – 4 ) · ( 2, – 3, 0, 4 )
– A · A = – 2 · 2 + 3 · – 3 + 0 · 0 + – 4 · 4
– A · A = – 4 + – 9 + 0 + – 16
– A · A = – 29
2A · B = 2 ( 2, – 3, 0, 4 ) · ( 2, – 1, 3, x )
2A · B = ( 2 · 2, 2 · – 3, 2 · 0, 2 · 4 ) · ( 2, – 1, 3, x )
2A · B = ( 4, – 6, 0, 8 ) · ( 2, – 1, 3, x )
2A · B = 4 · 2 + – 6 · – 1 + 0 · 3 + 8 · x
2A · B = 8 + 6 + 0 + 8x
2A · B = 14 + 8x

Définitions basiques

Une matrice est généralement désignée par une lettre majuscule, par exemple UNEmxn est une matrice UNE avec cote m rangées et m Colonnes.

Les éléments d'une matrice sont désignés par une lettre minuscule, sous-titrés avec le numéro de ligne auquel il appartient et le numéro de colonne auquel il appartient, par exemple uneje est l'élément qui appartient à la ligne i et à la colonne j.

UNEmxn &l'écran
|
&létage
 a11   a12    .   .   .    a1n  &rceil
|
&rétage
une21 une22 .   .   . une2n
.
.
.
.
.
.
.
.
.
unem1 unem2 .   .   . unemn
Matrice Carrée est une matrice avec le même nombre de lignes et de colonnes, c'est-à-dire UNEnxn , qui peut également être désigné comme UNEm .

UNEnxn &l'écran
|
&létage
 a11   a12    .   .   .    a1n  &rceil
|
&rétage
 = Unm
une21 une22 .   .   . une2n
.
.
.
.
.
.
.
.
.
unen1 unen2 .   .   . unenn
Matrice de lignes est une matrice à une ligne.

UNE1xn [  a11   a12    .   .   .    a1n  ]
Matrice de colonnes est une matrice à une colonne.

UNEmx1 &l'écran
|
&létage
 a11  &rceil
|
&rétage
une21
.
.
.
unem1
Matrices égales sont deux matrices de même dimension et tous les éléments correspondants sont égaux.
EXEMPLE 2 : UNE2x3 &l'écran
&létage
㺦  و  㺜  &rceil
&rétage
  et   B2x3 &l'écran
&létage
㺦  و  㺜  &rceil
&rétage
49  15  49  15 

Ajout de matrices Matrices conformes pour l'ajout sont des matrices de mêmes dimensions, c'est-à-dire deux matrices UNEpxq et Brxs sont dits conforme pour l'ajout (ou simplement conforme ) si et seulement si p = r et q = s . Addition matricielle ne peut être effectué qu'entre des matrices conforme pour l'ajout , c'est-à-dire donné UNEmxn = ( unje ) et Bmxn = ( bje ) , ensuite UNEmxn + Bmxn = Cmxn , où Cmxn = ( cje ) , C'est,

( uneje + bje ) = ( cje )
EXEMPLE 3 : &l'écran
&létage
㺲  ف  㺖  &rceil
&rétage
  +   &l'écran
&létage
 – 51  ه  ى  &rceil
&rétage
  =   &l'écran
&létage
  50 + ( – 51 )    1 + 7     22 + 9   &rceil
&rétage
  =   &l'écran
&létage
 – 1  و  㺟  &rceil
&rétage
53  – 54  53 + ( – 54)  4 + 5   9 + 7   – 1  16 

Multiplication scalaire Scalaire est un seul nombre réel. Multiplication matricielle scalaire est le produit d'une valeur scalaire k et une matrice UNE , noté par kA , où chaque élément de la matrice UNE est multiplié par la valeur scalaire k .

( c + d ) · A = c · A + d · A
c · ( A + B ) = c · A + c · B
( c · A ) · d = ( c · d ) · A
( c · d ) · A = c · ( d · A )

Soustraction de matrices Soustraction de matrices ne peut être effectué qu'entre des matrices conforme pour l'ajout , c'est-à-dire donné UNEmxn = ( unje ) et Bmxn = ( bje ) , ensuite

A – B = A + ( – 1 ) · B
EXEMPLE 5 : &l'écran
&létage
  50     1     22   &rceil
&rétage
 –  &l'écran
&létage
  – 51     7     9   &rceil
&rétage
 =  &l'écran
&létage
  50 – ( – 51 )     1 – 7     22 – 9   &rceil
&rétage
 =  &l'écran
&létage
  101     – 6     13   &rceil
&rétage
53   4   9   – 54   5   7   53 – ( – 54 )   4 – 5   9 – 7   109   – 1   2  

Matrices de multiplication [7:58] Matrices conformes pour la multiplication sont deux matrices où le nombre de lignes de la première matrice est égal au nombre de colonnes de la deuxième matrice, c'est-à-dire deux matrices UNEpxq et Brxs sont dits conforme à la multiplication (ou alors compatible ) si et seulement si q = r. Multiplication matricielle ne peut être effectué qu'entre des matrices conforme à la multiplication , c'est-à-dire donné UNEmxp = ( unje ) et Bpxn = ( bje ) , ensuite UNEmxp ·Bpxn = Cmxn , où Cmxn = ( cje ) , C'est,

En anglais, laissez UNE haricot mxp matrice et laissez B être un pxn matrice.   Le produit C = AB est un nxm matrice où chaque entrée cje de C est obtenu en multipliant les entrées correspondantes du je e ligne de matrice UNE par ceux de la j e colonne de matrice B puis additionner les résultats.

( A · B ) · C = A · ( B · C )
A · ( B + C ) = A · B + A · C
( B + C ) · A = B · A + C · A

Matrices spéciales Matrice zéro est une matrice ne contenant que zéro élément, généralement notée O .

Par la propriété inverse additive des nombres réels, chaque nombre réel une a un inverse additif – un .

De même, étant donné une matrice UNE , il existe une matrice ( – 1 ) · A = – A , appelé le inverse additif tel que A + ( – 1 ) · A = A – A = O .

AFFECTATION REQUISE:   Consultez le calendrier dans le syllabus pour connaître la date limite.

Matrices égales
Vecteurs égaux
Équation 1 : Vecteur
Équation 2 : Vecteurs égaux
Équation 3 : Magnitude du vecteur
Équation 4 : Addition de vecteurs
Équation 5 : Multiplication vectorielle par un scalaire
Équation 6 : Soustraction vectorielle
Équation 7 : Produit scalaire
Équation 8 : Produit scalaire
Équation 9 : Matrice
Équation 10 : Matrice carrée
Équation 11 : Matrice de lignes
Équation 12 : Matrice de colonnes
Équation 13 : Addition matricielle
Équation 14 : Soustraction matricielle
Équation 15 : Multiplication matricielle

Figure 1 : vecteur 2-D
Figure 2 : vecteur 3-D
Figure 3 : Ajout de vecteurs

Tableau 1 : Propriétés de la multiplication scalaire
Tableau 2 : Propriétés de la multiplication matricielle

Source des problèmes d'exercice pour les exemples :   College Algebra and Trigonometry par Lial, Hornsey, Schneider, Daniels, Fifth Edition, Section 9.7, pp. 891-904


12.2 Multiplication de matrices

Multiplication matricielle Le produit de deux matrices, Am×pand Bp×n, est la matrice AB de dimensions m × n. Tout élément de la ième rangée et de la jième colonne de cette matrice de produits est la somme des produits des éléments correspondants de la ième rangée de A et de la jième colonne de B. Lorsque vous multipliez des matrices, elles doivent être conformes pour la multiplication. Cela signifie : # de colonnes dans la 1ère matrice = # de lignes dans la 2ème matrice Ex 1) Pour obtenir chaque élément : c'est la première ligne, première colonne donc nous prenons la 1ère ligne de A × 1ère colonne de B 3 × 2 2 × 2 correspondent aux dimensions du produit 3 × 2 (4)(2) + (5)(5) = 8 + 25 = 33 (4)(3) + (5)(6) = 12 + 30 = 42 (7)(2 ) + (2)(5) = 14 + 10 = 24 écrivez vous-même comment obtenir cet élément

Ex 2) Trouver A2 (même A que Ex 1) Attendez! Vous ne pouvez pas ! Donc… indéfini 3 × 2 3 × 2 Nous pouvons résoudre des éléments inconnus dans une équation matricielle. Ex 3) Résoudre pour x et y. 3x – 4 = 2 3x = 6 x = 2 12 + 5y = –3 5y = –15 y = –3

La matrice d'identité La matrice identité est l'équivalent de la matrice algébrique 1. La multiplier par elle ne change pas l'original. etc. Motif : 1 le long de la diagonale et 0 partout ailleurs * Si le produit de deux matrices est I, alors elles sont inverses l'une de l'autre. Vous pouvez également multiplier par une matrice 0 pour obtenir une matrice O.

Quelles propriétés ne sont pas ici ?? Commutatif ! Lorsque nous «stockons» des informations dans des matrices, nous pouvons être amenés à les transposer (changer de lignes et de colonnes) pour les rendre conformes à la multiplication. Ex : Par 3 Par 4 Garçons Filles C'est toujours pareil !

Ex 4) Un propriétaire de stand de fruits emballe des fruits dans trois manières pour les paquets-cadeaux. Le forfait économique, E, contient 6 pommes, 3 oranges et 3 poires. L'emballage standard, S, contient 5 pommes, 4 oranges et 4 poires. L'emballage de luxe, L, contient 6 types de chaque fruit. Les coûts sont de 0,50 $ pour une pomme, 1,10 $ pour une orange et 0,80 $ pour une poire. Quel est le coût total de préparation de chaque paquet de fruits ? Nombre d'articles pomme orange poire Coût pomme orange poire Si nous multiplions dans cet état… les étiquettes ne correspondent pas au coût par emballage de fruit par fruit coût par fruit fruit par emballage Emballage E S L 1 × 3 3 × 3 1 × 3

Devoirs #1202 page 608 #1, 3, 5, 8, 15, 16, 18, 19, 20, 29, 31, 34, 41, 42


Contenu

peut être partitionné en quatre blocs 2×2

La matrice partitionnée peut alors s'écrire sous la forme

Il est possible d'utiliser un produit matriciel partitionné par blocs qui ne fait intervenir que l'algèbre sur les sous-matrices des facteurs. The partitioning of the factors is not arbitrary, however, and requires "conformable partitions" [4] between two matrices A and B such that all submatrix products that will be used are defined. [5] Given an ( m × p ) matrix A with q row partitions and s column partitions

that are compatible with the partitions of A , the matrix product

Or, using the Einstein notation that implicitly sums over repeated indices:

If a matrix is partitioned into four blocks, it can be inverted blockwise as follows:

UNE et are square of arbitrary size, and B et C are conformable for partitioning. Par ailleurs, UNE and the Schur complement of UNE dans P: P/UNE = Californie −1 B must be invertible. [6]

Equivalently, by permuting the blocks:

Ici, and the Schur complement of dans P: P/ = UNEBD −1 C must be invertible.

Si UNE et are both invertible, then:

By the Weinstein–Aronszajn identity, one of the two matrices in the block-diagonal matrix is invertible exactly when the other is.

If the blocks are square matrices of the même size further formulas hold. For example, if C and D commute (i.e., C D = D C ), then there holds [8]

We can use the formulas for the determinant of block matrices to obtain the eigenvalue of the matrix using the characteristic polynomial. For instance, if A is invertible the characteristic polynomial of

UNE block diagonal matrix is a block matrix that is a square matrix such that the main-diagonal blocks are square matrices and all off-diagonal blocks are zero matrices. That is, a block diagonal matrix UNE has the form

UNEk is a square matrix for all k = 1, . m. In other words, matrix UNE is the direct sum of UNE1, . UNEm. It can also be indicated as UNE1UNE2 ⊕ . ⊕ UNEm or diag(UNE1, UNE2, . UNEm) (the latter being the same formalism used for a diagonal matrix). Any square matrix can trivially be considered a block diagonal matrix with only one block.

For the determinant and trace, the following properties hold

A block diagonal matrix is invertible if and only if each of its main-diagonal blocks are invertible, and in this case its inverse is another block diagonal matrix given by

UNE block tridiagonal matrix is another special block matrix, which is just like the block diagonal matrix a square matrix, having square matrices (blocks) in the lower diagonal, main diagonal and upper diagonal, with all other blocks being zero matrices. It is essentially a tridiagonal matrix but has submatrices in places of scalars. A block tridiagonal matrix UNE has the form

UNEk, Bk et Ck are square sub-matrices of the lower, main and upper diagonal respectively.

Block tridiagonal matrices are often encountered in numerical solutions of engineering problems (e.g., computational fluid dynamics). Optimized numerical methods for LU factorization are available and hence efficient solution algorithms for equation systems with a block tridiagonal matrix as coefficient matrix. The Thomas algorithm, used for efficient solution of equation systems involving a tridiagonal matrix can also be applied using matrix operations to block tridiagonal matrices (see also Block LU decomposition).

UNE block Toeplitz matrix is another special block matrix, which contains blocks that are repeated down the diagonals of the matrix, as a Toeplitz matrix has elements repeated down the diagonal. The individual block matrix elements, Aij, must also be a Toeplitz matrix.

A block Toeplitz matrix UNE has the form

For any arbitrary matrices UNE (of size m × m) and B (of size p × q), we have the direct sum de UNE et B, denoted by UNEB and defined as

This operation generalizes naturally to arbitrary dimensioned arrays (provided that UNE et B have the same number of dimensions).

Note that any element in the direct sum of two vector spaces of matrices could be represented as a direct sum of two matrices.

In linear algebra terms, the use of a block matrix corresponds to having a linear mapping thought of in terms of corresponding 'bunches' of basis vectors. That again matches the idea of having distinguished direct sum decompositions of the domain and range. It is always particularly significant if a block is the zero matrix that carries the information that a summand maps into a sub-sum.

Given the interpretation via linear mappings and direct sums, there is a special type of block matrix that occurs for square matrices (the case m = m). For those we can assume an interpretation as an endomorphism of an m-dimensional space V the block structure in which the bunching of rows and columns is the same is of importance because it corresponds to having a single direct sum decomposition on V (rather than two). In that case, for example, the diagonal blocks in the obvious sense are all square. This type of structure is required to describe the Jordan normal form.

This technique is used to cut down calculations of matrices, column-row expansions, and many computer science applications, including VLSI chip design. An example is the Strassen algorithm for fast matrix multiplication, as well as the Hamming(7,4) encoding for error detection and recovery in data transmissions.


Contenu

The fundamental idea behind array programming is that operations apply at once to an entire set of values. This makes it a high-level programming model as it allows the programmer to think and operate on whole aggregates of data, without having to resort to explicit loops of individual scalar operations.

Kenneth E. Iverson described the rationale behind array programming (actually referring to APL) as follows: [2]

most programming languages are decidedly inferior to mathematical notation and are little used as tools of thought in ways that would be considered significant by, say, an applied mathematician.

The thesis is that the advantages of executability and universality found in programming languages can be effectively combined, in a single coherent language, with the advantages offered by mathematical notation. it is important to distinguish the difficulty of describing and of learning a piece of notation from the difficulty of mastering its implications. For example, learning the rules for computing a matrix product is easy, but a mastery of its implications (such as its associativity, its distributivity over addition, and its ability to represent linear functions and geometric operations) is a different and much more difficult matter.

Indeed, the very suggestiveness of a notation may make it seem harder to learn because of the many properties it suggests for explorations.

[. ]

Users of computers and programming languages are often concerned primarily with the efficiency of execution of algorithms, and might, therefore, summarily dismiss many of the algorithms presented here. Such dismissal would be short-sighted since a clear statement of an algorithm can usually be used as a basis from which one may easily derive a more efficient algorithm.

The basis behind array programming and thinking is to find and exploit the properties of data where individual elements are similar or adjacent. Unlike object orientation which implicitly breaks down data to its constituent parts (or scalar quantities), array orientation looks to group data and apply a uniform handling.

Function rank is an important concept to array programming languages in general, by analogy to tensor rank in mathematics: functions that operate on data may be classified by the number of dimensions they act on. Ordinary multiplication, for example, is a scalar ranked function because it operates on zero-dimensional data (individual numbers). The cross product operation is an example of a vector rank function because it operates on vectors, not scalars. Matrix multiplication is an example of a 2-rank function, because it operates on 2-dimensional objects (matrices). Collapse operators reduce the dimensionality of an input data array by one or more dimensions. For example, summing over elements collapses the input array by 1 dimension.

Array programming is very well suited to implicit parallelization a topic of much research nowadays. Further, Intel and compatible CPUs developed and produced after 1997 contained various instruction set extensions, starting from MMX and continuing through SSSE3 and 3DNow!, which include rudimentary SIMD array capabilities. Array processing is distinct from parallel processing in that one physical processor performs operations on a group of items simultaneously while parallel processing aims to split a larger problem into smaller ones (MIMD) to be solved piecemeal by numerous processors. Processors with two or more cores are increasingly common today.

The canonical examples of array programming languages are Fortran, APL, and J. Others include: A+, Analytica, Chapel, IDL, Julia, K, Klong, Q, Mata, MATLAB, MOLSF, NumPy, GNU Octave, PDL, R, S-Lang, SAC, Nial, ZPL and TI-BASIC.

Scalar languages Edit

In scalar languages such as C and Pascal, operations apply only to single values, so une+b expresses the addition of two numbers. In such languages, adding one array to another requires indexing and looping, the coding of which is tedious.

In array-based languages, for example in Fortran, the nested for-loop above can be written in array-format in one line,

or alternatively, to emphasize the array nature of the objects,

While scalar languages like C do not have native array programming elements as part of the language proper, this does not mean programs written in these languages never take advantage of the underlying techniques of vectorization (i.e., utilizing a CPU's vector-based instructions if it has them or by using multiple CPU cores). Some C compilers like GCC at some optimization levels detect and vectorize sections of code that its heuristics determine would benefit from it. Another approach is given by the OpenMP API, which allows one to parallelize applicable sections of code by taking advantage of multiple CPU cores.

Array languages Edit

In array languages, operations are generalized to apply to both scalars and arrays. Ainsi, une+b expresses the sum of two scalars if une et b are scalars, or the sum of two arrays if they are arrays.

An array language simplifies programming but possibly at a cost known as the abstraction penalty. [3] [4] [5] Because the additions are performed in isolation from the rest of the coding, they may not produce the optimally most efficient code. (For example, additions of other elements of the same array may be subsequently encountered during the same execution, causing unnecessary repeated lookups.) Even the most sophisticated optimizing compiler would have an extremely hard time amalgamating two or more apparently disparate functions which might appear in different program sections or sub-routines, even though a programmer could do this easily, aggregating sums on the same pass over the array to minimize overhead).

Ada Edit

The previous C code would become the following in the Ada language, [6] which supports array-programming syntax.

APL Edit

APL uses single character Unicode symbols with no syntactic sugar.

This operation works on arrays of any rank (including rank 0), and on a scalar and an array. Dyalog APL extends the original language with augmented assignments:

Analytica Edit

Analytica provides the same economy of expression as Ada.

BASIC Edit

Dartmouth BASIC had MAT statements for matrix and array manipulation in its third edition (1966).

Mata Edit

Stata's matrix programming language Mata supports array programming. Below, we illustrate addition, multiplication, addition of a matrix and a scalar, element by element multiplication, subscripting, and one of Mata's many inverse matrix functions.

MATLAB Edit

The implementation in MATLAB allows the same economy allowed by using the Fortran language.

A variant of the MATLAB language is the GNU Octave language, which extends the original language with augmented assignments:

Both MATLAB and GNU Octave natively support linear algebra operations such as matrix multiplication, matrix inversion, and the numerical solution of system of linear equations, even using the Moore–Penrose pseudoinverse. [7] [8]

The Nial example of the inner product of two arrays can be implemented using the native matrix multiplication operator. If a is a row vector of size [1 n] and b is a corresponding column vector of size [n 1].

The inner product between two matrices having the same number of elements can be implemented with the auxiliary operator (:) , which reshapes a given matrix into a column vector, and the transpose operator ' :

Rasql Edit

The rasdaman query language is a database-oriented array-programming language. For example, two arrays could be added with the following query:

R Edit

The R language supports array paradigm by default. The following example illustrates a process of multiplication of two matrices followed by an addition of a scalar (which is, in fact, a one-element vector) and a vector:

The matrix left-division operator concisely expresses some semantic properties of matrices. As in the scalar equivalent, if the (determinant of the) coefficient (matrix) A is not null then it is possible to solve the (vectorial) equation A * x = b by left-multiplying both sides by the inverse of A : A −1 (in both MATLAB and GNU Octave languages: A^-1 ). The following mathematical statements hold when A is a full rank square matrix:

A^-1 *(A * x)==A^-1 * (b) (A^-1 * A)* x ==A^-1 * b (matrix-multiplication associativity) x = A^-1 * b

where == is the equivalence relational operator. The previous statements are also valid MATLAB expressions if the third one is executed before the others (numerical comparisons may be false because of round-off errors).

If the system is overdetermined - so that A has more rows than columns - the pseudoinverse A + (in MATLAB and GNU Octave languages: pinv(A) ) can replace the inverse A −1 , as follows:

pinv(A) *(A * x)==pinv(A) * (b) (pinv(A) * A)* x ==pinv(A) * b (matrix-multiplication associativity) x = pinv(A) * b

However, these solutions are neither the most concise ones (e.g. still remains the need to notationally differentiate overdetermined systems) nor the most computationally efficient. The latter point is easy to understand when considering again the scalar equivalent a * x = b , for which the solution x = a^-1 * b would require two operations instead of the more efficient x = b / a . The problem is that generally matrix multiplications are not commutative as the extension of the scalar solution to the matrix case would require:

(a * x)/ a ==b / a (x * a)/ a ==b / a (commutativity does not hold for matrices!) x * (a / a)==b / a (associativity also holds for matrices) x = b / a

The MATLAB language introduces the left-division operator to maintain the essential part of the analogy with the scalar case, therefore simplifying the mathematical reasoning and preserving the conciseness:

A (A * x)==A b (A A)* x ==A b (associativity also holds for matrices, commutativity is no more required) x = A b

This is not only an example of terse array programming from the coding point of view but also from the computational efficiency perspective, which in several array programming languages benefits from quite efficient linear algebra libraries such as ATLAS or LAPACK. [9]

Returning to the previous quotation of Iverson, the rationale behind it should now be evident:

it is important to distinguish the difficulty of describing and of learning a piece of notation from the difficulty of mastering its implications. For example, learning the rules for computing a matrix product is easy, but a mastery of its implications (such as its associativity, its distributivity over addition, and its ability to represent linear functions and geometric operations) is a different and much more difficult matter. Indeed, the very suggestiveness of a notation may make it seem harder to learn because of the many properties it suggests for explorations.

The use of specialized and efficient libraries to provide more terse abstractions is also common in other programming languages. In C++ several linear algebra libraries exploit the language's ability to overload operators. In some cases a very terse abstraction in those languages is explicitly influenced by the array programming paradigm, as the Armadillo and Blitz++ libraries do. [10] [11]


Voir la vidéo: Traditional Algebra 2 Matrix Multiplication (Décembre 2021).