Chapitre 3 Opérations mathématiques sur les matrices

Table des matières

Chapitre 3 Opérations mathématiques sur les matrices ....................................................... 1
Introduction ............................................................................................................................ 1
3.1 Addition et soustraction ................................................................................................... 3
3.2 Multiplication de matrices ................................................................................................ 4
3.3 Division de matrices ......................................................................................................... 7
3.3.1 Matrice identité ......................................................................................................... 7
3.3.2 Inverse d'une matrice ................................................................................................. 7
3.3.3 Déterminant ............................................................................................................... 8
3.3.3 Division de matrices .................................................................................................. 8
A
3.4 Operations élément par élément ..................................................................................... 10
3.5 Utilisation des matrices dans les fonctions mathématiques Intégrées de Matlab........... 12
3.6 Fonctions intégrées pour analyser les matrices .............................................................. 13
LM
3.7 Générations de nombres aléatoires ................................................................................. 14
3.7.1 La commande rand .................................................................................................. 14
3.7.2 La commande randi ................................................................................................ 15
3.7.3 La commande randn................................................................................................ 16

Introduction

Une fois les variables créées dans MATLAB, elles peuvent être utilisées dans une grande
variété d'opérations mathématiques. Dans le chapitre 1, les variables utilisées dans les
opérations mathématiques ont toutes été définies comme des scalaires. Cela signifie qu'ils
étaient tous des matrices (matrices avec une ligne et une colonne qui n'ont qu'un seul élément)
et les opérations mathématiques ont été effectuées avec des nombres uniques. Cependant, les
matrices peuvent être unidimensionnels (matrices avec une ligne ou avec une colonne),
bidimensionnels (matrices avec plusieurs lignes et colonnes) et même de dimensions
supérieures. Dans ces cas, les opérations mathématiques sont plus complexes.
MATLAB, comme son nom l'indique, est conçu pour effectuer des opérations matricielles
avancées qui ont de nombreuses applications en science et en ingénierie. Ce chapitre présente
les opérations mathématiques de base les plus courantes que MATLAB effectue à l'aide de
matrices.

L'addition et la soustraction sont des opérations relativement simples et sont traitées en premier,
dans la section 3.1. Les autres opérations de base - multiplication, division et exponentiation -
peuvent être effectuées dans MATLAB de deux manières différentes. La première méthode,
qui utilise les symboles standard (*, / et ^), et qui suit les règles de l'algèbre linéaire et est
présentée dans les sections 3.2 et 3.3. La deuxième méthode, appelée opérations élément par
élément, est décrite à la section 3.4. Ces opérations utilisent le .*, ./ et .^ (un point est tapé
devant le symbole de fonctionnement standard).

A
LM
3.1 Addition et soustraction
Les opérations + (addition) et - (soustraction) peuvent être utilisées pour ajouter (soustraire)
des matrices de taille identique (le même nombre de lignes et de colonnes) et pour ajouter
(soustraire) un scalaire à une matrice. Lorsque deux matrices sont compatibles, la somme, ou
la différence, des matrices est obtenue en ajoutant ou en soustrayant leurs éléments
correspondants.

En général, si A et B sont deux matrices (par exemple, des matrices),

𝐴 𝐴12 𝐴13 𝐵 𝐵12 𝐵13

𝐴 = [ 11 ] et 𝐵 = [ 11 ]
𝐴21 𝐴22 𝐴23 𝐵21 𝐵22 𝐵23

Alors la matrice obtenue en ajoutant A et B est :

(𝐴 + 𝐵11 ) (𝐴12 + 𝐵12 ) (𝐴13 + 𝐵13 )

[ 11 ]
(𝐴21 + 𝐵21 ) (𝐴22 + 𝐵22 ) (𝐴23 + 𝐵23 )
Voici des exemples :

>> v1=[8 5 4 -1]; v2=[4 10 2 7];

>> v3=v1+v2
v3 =
12 15 6
>> A=[6 -4 7; 8 3 11]
6
A Créer deux vecteurs v1 et v2
Définir un vecteur v3=v1+v2
LM
A = Définir deux matrices A et B de taille
6 -4 7
8 3 11 (2x3)
>> B=[9 6 5; -12 13 1]
B =
9 6 5
-12 13 1
>> A-B
ans = Soustraire la matrice B de la
-3 -10 2 matrice A
20 -10 10
>> C=A+B
C = Définir une matrice C= A+ B
15 2 12 v3=v1+v2
-4 16 12

>> v1+A Addition des matrices de tailles

Matrix dimensions must agree différentes (un vecteur + matrice)
Un message d'erreur s'affiche

Lorsqu'un scalaire (nombre) est ajouté (ou soustrait) à une matrice, le scalaire est ajouté (ou
soustrait) à tous les éléments du tableau. Voici des exemples :

>> v1=[2 7 9 -8 4]
v1 = Créer un vecteur nommé v1
2 7 9 -8 4
 >> v1+6
Ajouter le scalaire 6 à v1. 6 est ajouté à
ans = chaque élément de v1
8 13 15 -2 10
>> A=[5 17 -11; 3 -7 9]
A =
5 17 -11 Définir une matrice A de taille (2x3)
3 -7 9
>> A-4
ans = Soustraire le scalaire 4 de A.
1 13 -15 4 est soustrait de chaque élément de A
-1 -11 5

3.2 Multiplication de matrices

L'opération de multiplication * est exécutée par MATLAB selon les règles de l'algèbre linéaire.
Cela signifie que si A et B sont deux matrices, l'opération A * B ne peut être effectuée que si le
nombre de colonnes dans la matrice A est égal au nombre de lignes dans la matrice B. Le résultat
est une matrice qui a le même nombre de lignes comme A et le même nombre de colonnes que
B. Par exemple, si A est une matrice (4x3) et B est une matrice (3x2) :

𝐴=[
𝐴11
𝐴21
𝐴31
𝐴41
A𝐴12
𝐴22
𝐴32
𝐴42
𝐴13
𝐴23
𝐴33
𝐴43
𝐵11
] et 𝐵 = [𝐵21
𝐵31
𝐵12
𝐵22 ]
𝐵32
LM
Alors la matrice qui est obtenue avec l'opération A * B a des dimensions (4x2) dont les
éléments sont :
(𝐴11 𝐵11 + 𝐴12 𝐵21 + 𝐴13 𝐵31 ) (𝐴11 𝐵12 + 𝐴12 𝐵22 + 𝐴13 𝐵32 )
(𝐴21 𝐵11 + 𝐴22 𝐵21 + 𝐴23 𝐵31 ) (𝐴21 𝐵12 + 𝐴22 𝐵22 + 𝐴23 𝐵32 )
[ ]
(𝐴31 𝐵11 + 𝐴32 𝐵21 + 𝐴33 𝐵31 ) (𝐴31 𝐵12 + 𝐴32 𝐵22 + 𝐴33 𝐵32 )
(𝐴41 𝐵11 + 𝐴42 𝐵21 + 𝐴43 𝐵31 ) (𝐴41 𝐵12 + 𝐴42 𝐵22 + 𝐴43 𝐵32 )

Un exemple numérique est :

1 4 3 5 4 (1 ∗ 5 + 4 ∗ 1 + 3 ∗ 2) (1 ∗ 4 + 4 ∗ 3 + 3 ∗ 6) 15 34
[2 6 1] [1 3] = [(2 ∗ 5 + 6 ∗ 1 + 1 ∗ 2) (2 ∗ 4 + 6 ∗ 3 + 1 ∗ 6)] = [18 32]
5 2 8 2 6 (5 ∗ 5 + 2 ∗ 1 + 8 ∗ 2) (5 ∗ 4 + 2 ∗ 3 + 8 ∗ 6) 43 74

Le produit de la multiplication de deux matrices carrées (elles doivent être de même taille) est
une matrice carrée de même taille. Cependant, la multiplication des matrices n'est pas
commutative. Cela signifie que si A et B sont tous les deux des matrices carrées, alors :
𝐴 ∗ 𝐵 ≠ 𝐵 ∗ 𝐴. De plus, l'opération de puissance ne peut être exécutée qu'avec une matrice
carrée (puisque A * A ne peut être effectuée que si le nombre de colonnes de la première matrice
est égal au nombre de lignes de la deuxième matrice).
Deux vecteurs ne peuvent être multipliés que s'ils ont le même nombre d'éléments, et l'un est
un vecteur ligne et l'autre est un vecteur colonne. La multiplication d'un vecteur ligne par un
vecteur colonne donne une matrice (1x1), qui est un scalaire. Il s'agit du produit scalaire de
deux vecteurs. (MATLAB a également une fonction intégrée, dot (a, b), qui calcule le produit
scalaire de deux vecteurs) Lorsque vous utilisez la fonction dot, les vecteurs a et b peuvent
chacun être un vecteur ligne ou un vecteur colonne (voir Tableau 3.1). La multiplication d'un
vecteur colonne par un vecteur ligne, chacun avec n éléments, donne une matrice La
multiplication du tableau est démontrée dans l’exemple suivant :

>> A=[1 4 3; 2 6 1; 5 2 8]
A =
1 4 3 Définir une matrice A de taille
2 6 1 (3x3)
5 2 8
>> B=[5 4;1 3;2 6]
B = Définir une matrice B de taille
5 4 (3x2)
1 3
2 6 A
>> C=A*B
C = Multipliez la matrice A par la
15 34 matrice B et affectez le résultat à
18 32
43 74 la variable C
LM
>> D=B*A
Error using * Essayer de multiplier B par A, B * A, donne
Incorrect dimensions for matrix multiplication. une erreur puisque le nombre de colonnes dans
Check that the number of columns in the first B est 2 et le nombre de lignes dans A est 3
matrix matches the number of rows in the second
matrix.

>> F=[1 3; 5 7] Définir une matrice F de taille

F = (2x2)
1 3
5 7
>> G=[4 2; 1 6] Définir une matrice G de taille
G =
4 2 (2x2)
1 6
>> F*G
ans =
Multiplier F * G
7 20
27 52 Multiplier G * F
>> G*F
ans = Note : le résultat de G * F n'est
14 26
31 45 pas la même que F * G
>> v1=[2 5 1]
v1 = Créer un vecteur ligne de 3
2 5 1 éléments nommé v1
>> v2=[3; 1; 4]
V2 = Créer un vecteur colonne de 3
3
1 éléments nommé v2
4
 >> v1*v2
ans = Multiplier v1 par v2. Le résultat est
15 un scalaire. (Produit scalaire de 2
>> v2*v1 vecteurs)
ans = Multiplier v2 par v1. Le résultat est
6 15 3
2 5 1
une matrice de taille (3x3)
8 20 4

Lorsqu'une matrice est multiplié par un nombre, chaque élément du tableau est multiplié par le
nombre. Par exemple :
>> A=[2 5 7 0; 10 1 3 4; 6 2 11 5]
A = Définir une matrice A de taille
2 5 7 0 (3x4)
10 1 3 4
6 2 11 5
>> b=3
Attribuer le chiffre 3 à la variable
b =
3 b
>> b*A
ans = Multiplier la matrice A par b. Cela peut
6 15 21 0 être fait en tapant b * A ou A * b
30 3 9 12
18
>> C=A*5
C =
10
50
30
6

25
5
10
33

35
15
55
15

0
20
25
A Multiplier la matrice A par 5 et affecter
le résultat à une nouvelle variable C.
(Taper C = 5 * A donne le même
résultat)
LM
Les règles d'algèbre linéaire de la multiplication de matrices fournissent un moyen pratique
d'écrire un système d'équations linéaires. Par exemple, le système de trois équations à trois
inconnus :
𝐴11 𝑥1 + 𝐴12 𝑥2 + 𝐴13 𝑥3 = 𝐵1
𝐴21 𝑥1 + 𝐴22 𝑥2 + 𝐴23 𝑥3 = 𝐵2
𝐴31 𝑥1 + 𝐴32 𝑥2 + 𝐴33 𝑥3 = 𝐵3

Peut-être écrit sous forme matricielle comme :

𝐴11 𝐴12 𝐴13 𝑥1 𝐵1
[𝐴21 𝐴22 𝐴23 ] [𝑥2 ] = [𝐵2 ]
𝐴31 𝐴32 𝐴33 𝑥3 𝐵3
et en notation matricielle comme : 𝑨𝑿= 𝑩
où :
𝐴11 𝐴12 𝐴13 𝑥1 𝐵1
𝐴 = [𝐴21 𝐴22 𝐴23 ] , 𝑋 = [𝑥2 ] , 𝐵 = [𝐵2 ]
𝐴31 𝐴32 𝐴33 𝑥3 𝐵3
3.3 Division de matrices
L'opération de division est également associée aux règles de l'algèbre linéaire. Cette opération
est plus complexe et seule une brève explication est donnée ci-dessous. Une explication
complète peut être trouvée dans les livres sur l'algèbre linéaire.
L'opération de division peut être expliquée à l'aide de la matrice d'identité et de l'opération
inverse.
3.3.1 Matrice identité
La matrice identité est une matrice carrée dans laquelle les éléments diagonaux sont 1 et le reste
des éléments sont 0. Comme indiqué dans la section 2.3.2, une matrice d'identité peut être créée
dans MATLAB avec la commande eye. Lorsque la matrice identité multiplie une autre matrice
(ou vecteur), cette matrice (ou vecteur) reste inchangée (la multiplication doit se faire selon les
règles de l'algèbre linéaire). Cela équivaut à multiplier un scalaire par 1. Par exemple :
1 0 0
7 3 8 7 3 8
[ ] [0 1 0] = [ ]
4 11 5 4 11 5
A 0 0 1
1 0 0 8 8
Ou : [0 1 0] [ 2 ] = [ 2 ]
0 0 1 15 15
6 2 9 1 0 0 6 2 9
LM
Ou : [1 8 3] [0 1 0 ] = [1 8 3 ]
7 5 4 0 0 1 7 5 4
Si une matrice A est carrée, elle peut être multipliée par la matrice d'identité I, à gauche ou à
droite : 𝑨𝑰 =𝑰𝑨=𝑨

3.3.2 Inverse d'une matrice

La matrice B est l'inverse de la matrice A si, lorsque les deux matrices sont multipliées, le
produit est la matrice d'identité. Les deux matrices doivent être carrées et l'ordre de
multiplication peut être BA ou AB.
𝑨𝑩 = 𝑩𝑨 = 𝑰

De toute évidence, B est l'inverse de A et A est l'inverse de B. Par exemple :

2 1 4 5.5 −3.5 2 5.5 −3.5 2 2 1 4 1 0 0

[4 1 8 ] [ 2 −1 0] = [ 2 −1 0] [4 1 8] = [0 1 0]
2 −1 3 −3 2 1 −3 2 1 2 −1 3 0 0 1
L'inverse d'une matrice A s'écrit généralement A-1. Dans MATLAB, l'inverse d'une matrice peut
être obtenu soit en élevant A à la puissance de –1, A^-1, soit avec la fonction inv (A). La
multiplication des matrices précédentes avec MATLAB est indiquée ci-dessous :

>> A=[2 1 4; 4 1 8; 2 -1 3]
A =
2 1 4 Définir une matrice carrée A de taille
4 1 8 (3*3)
2 -1 3
>> B=inv(A)
B =
5.5 -3.5 2
Utiliser la fonction inv pour
2 -1 0 trouver l'inverse de A et l'affecter
-3 2 -1 àB
>> A*B
ans =
1 0 0 La multiplication de A et B
0 1 0 donne la matrice identité
0 0 1
>> A*A^-1
ans = Utiliser la puissance –1 pour
1 0 0 trouver l'inverse de A. La
0 1 0 A multiplier par A donne la matrice
0 0 1
identité

Note : Certaines matrices n'ont pas d'inverse. Une matrice n'a d'inverse que si elle est carrée
LM
et que son déterminant n'est pas égal à zéro.

3.3.3 Déterminant
Le déterminant est une fonction associée à des matrices carrées. Un bref examen des
déterminants est donné ci-dessous. Pour une couverture plus détaillée, reportez-vous aux livres
sur l'algèbre linéaire.
Le déterminant est une fonction qui associe à chaque matrice carrée A un nombre, appelé
déterminant de la matrice. Le déterminant est généralement désigné par det (A) ou | A |. Le
déterminant est calculé selon des règles spécifiques. Pour une matrice de second ordre (2 * 2),
la règle est :
𝑎 𝑎12
|𝐴| = [𝑎11 𝑎22 ] = 𝑎11 𝑎22 − 𝑎12 𝑎21
21
6 5
Par exemple : [ ] = 6 ∗ 9 − 5 ∗ 3 = 39
3 9
Le déterminant d'une matrice carrée peut être calculé avec la commande det (Tableau 3.1).

3.3.3 Division de matrices

MATLAB a deux types de division de matrice, la division à droite et la division à gauche.
- Division à gauche « \ »
La division à gauche est utilisée pour résoudre l'équation matricielle 𝑨𝑿 = 𝑩. Dans cette
équation, X et B sont des vecteurs de colonne. Cette équation peut être résolue en multipliant,
à gauche, les deux côtés par l'inverse de A :
𝐴−1 𝐴 𝑋 = 𝐴−1 𝐵
La solution de cette équation est donc :
𝑋 = 𝐴−1 𝐵
Dans MATLAB, cette équation peut être écrite en utilisant le caractère de division gauche \ :
𝑋 = 𝐴\𝐵
Il convient de noter ici que bien que les deux dernières opérations semblent donner le même
résultat, la méthode par laquelle MATLAB calcule X est différente. Dans le premier cas (𝑋 =
𝐴−1 𝐵), MATLAB calcule 𝐴−1 puis le multiplie par B. Dans le second (division à gauche), la
solution X est obtenue numériquement en utilisant une méthode basée sur l'élimination de
Gauss. La méthode de la division à gauche est recommandée pour résoudre un ensemble
A
d'équations linéaires, car le calcul de l'inverse peut être moins précis que la méthode
d'élimination de Gauss lorsque de grandes matrices sont utilisées.
- Division à droite « / »
LM
La bonne division est utilisée pour résoudre l'équation matricielle 𝑿𝑪 = 𝑫. Dans cette équation,
X et D sont des vecteurs ligne. Cette équation peut être résolue en multipliant, à droite, les deux
côtés par l'inverse de C :
𝑿𝑪 𝑪−𝟏 = 𝑫 𝑪−𝟏
Ce qui donne :
𝑿 = 𝑫 𝑪−𝟏

Dans MATLAB, la dernière équation peut être écrite en utilisant le bon caractère de division :

𝑿=𝑫/𝑪

L'exemple suivant montre l'utilisation de la division gauche et droite et de la fonction inv pour
résoudre un ensemble d'équations linéaires.

Exemple : résolution de trois équations linéaires (division de tableau)

Utiliser des opérations matricielles pour résoudre le système d'équations linéaires suivant :

4𝑥 + 2𝑦 + 6𝑧 = 8
2𝑥 + 8𝑦 + 2𝑧 = 4
6𝑥 + 10𝑦 + 3𝑧 = 0
Solution :
En utilisant les règles d'algèbre linéaire démontrées précédemment, le système d'équations ci-
dessus peut être écrit sous la forme matricielle 𝑨 𝑿 = 𝑩 ou sous la forme 𝑿𝑪 = 𝑫 :

4 2 6 𝑥 8 4 2 6
[2 8 2] [𝑦] = [4] Ou [𝑥 𝑦 𝑧] [−2 8 10] = [8 4 0]
6 10 3 𝑧 0 6 2 3

Les solutions pour les deux formes sont présentées ci-dessous :

>> A=[4 -2 6; 2 8 2; 6 10 3];

>> B=[8; 4; 0]; Résolution de la forme AX = B
>> X=A\B
X = Résolution en utilisant la division gauche :
-1.8049
0.29268 X=A\B
2.6341
>> Xb=inv(A)*B
Xb =
-1.8049 Résolution en utilisant l'inverse de A : X =
0.29268 A-1B

>>
>>
>>
Xc
2.6341

C=[4 2 6; -2 8 10; 6 2 3];

D=[8 4 0];
Xc=D/C
=
A Résolution du formulaire XC = D

Résolution en utilisant la bonne division : X = D / C

LM
-1.8049 0.29268 2.6341
>> Xd=D*inv(C) Résolution en utilisant l'inverse de C : X = DC-1
Xd
-1.8049 0.29268 2.6341

3.4 Operations élément par élément

Dans les sections 3.2 et 3.3, il a été démontré que lorsque les symboles réguliers de
multiplication et de division (* et /) sont utilisés avec des matrices, les opérations
mathématiques suivent les règles de l'algèbre linéaire. Il existe cependant de nombreuses
situations qui nécessitent des opérations élément par élément. Ces opérations sont effectuées
sur chacun des éléments du tableau (ou des matrices). L'addition et la soustraction sont par
définition déjà des opérations élément par élément, car lorsque deux matrices sont ajoutées (ou
soustraits), l'opération est exécutée avec les éléments qui se trouvent à la même position dans
les matrices. Les opérations élément par élément ne peuvent être effectuées qu'avec des matrices
de même taille.

La multiplication, la division ou l'exponentiation élément par élément de deux vecteurs ou

matrices est entrée dans MATLAB en tapant un point «.» devant l'opérateur arithmétique.
 Symbole Description Symbole Description
.* Multiplication ./ Division à droite
.^ Exponentiation .\ Division à gauche

Si deux vecteurs a et b sont a = [a1 a2 a3 a4] et b = [b1 b2 b3 b4], alors la multiplication, la division
et l'exponentiation élément par élément des deux vecteurs donne :

𝑎 .∗ 𝑏 = [𝑎1 ∗ 𝑏1 𝑎2 ∗ 𝑏2 𝑎3 ∗ 𝑏3 𝑎4 ∗ 𝑏4 ]
𝑎 ./ 𝑏 = [𝑎1 /𝑏1 𝑎2 /𝑏2 𝑎3 /𝑏3 𝑎4 /𝑏4 ]
𝑎 . ^ 𝑏 = [(𝑎1 )𝑏1 (𝑎2 )𝑏2 (𝑎3 )𝑏3 (𝑎4 )𝑏4 ]

Si deux matrices A et B sont :

𝐴11 𝐴12 𝐴13 𝐵11 𝐵12 𝐵13

𝐴 = [𝐴21 𝐴22 𝐴23 ] et 𝐵 = [𝐵21 𝐵22 𝐵23 ]
𝐴31 𝐴32 𝐴33 𝐵31 𝐵32 𝐵33

𝐴11 𝐵11
𝐴 .∗ 𝐵 = [𝐴21 𝐵21
𝐴12 𝐵12
𝐴22 𝐵22
A
La multiplication et la division élément par élément des deux matrices donne :

𝐴13 𝐵13
𝐴23 𝐵23 ]
𝐴11 /𝐵11
𝐴 ./𝐵 = [𝐴21 /𝐵21
𝐴12 /𝐵12
𝐴22 /𝐵22
𝐴13 /𝐵13
𝐴23 /𝐵23 ]
LM
𝐴31 𝐵31 𝐴32 𝐵32 𝐴33 𝐵33 𝐴31 /𝐵31 𝐴32 /𝐵32 𝐴33 /𝐵33

L'exponentiation élément par élément de la matrice A donne :

(𝐴11 )𝑛 (𝐴12 )𝑛 (𝐴13 )𝑛

𝐴. ^𝑛 = [(𝐴21 )𝑛 (𝐴22 )𝑛 (𝐴23 )𝑛 ]
(𝐴31 )𝑛 (𝐴32 )𝑛 (𝐴33 )𝑛

Dans MATLAB, la multiplication, la division et l'exponentiation élément par élément sont

illustrées dans l’exemple suivant :

>> A=[2 6 3; 5 8 4],B=[1 4 10; 3 2 7]

A =
2 6 3 Définir deux matrices A et B de taille
5 8 4 (2*3)
B =
1 4 10
3 2 7
>> A.*B
ans = Multiplication élément par élément de
2 24 30 la matrice A par B
15 16 28
>> C=A./B
C = Division élément par élément de la matrice
2 1.5 0.3
A par B. Le résultat est affecté à la
1.6667 4 0.57143
variable C
 >> B.^3
ans = Exponentiation élément par élément de la
1 64 1000 matrice B par 3
27 8 343

Les calculs élément par élément sont très utiles pour calculer la valeur d'une fonction pour
plusieurs valeurs de la variable. Pour ce faire, définissez d'abord un vecteur qui contient les
valeurs de la variable indépendante, puis utilisez ce vecteur dans les calculs élément par élément
pour créer un vecteur dans lequel chaque élément est la valeur correspondante de la fonction.

- Exemple 1 :

>> x=[1:8]
x = Créer un vecteur x de huit éléments
1 2 3 4 5 6 7 8
>> y=x.^2-4*x Le vecteur x est utilisé dans les calculs
y =
élément par élément des éléments du
-3 -4 -3 0 5 12 21 32 vecteur y

pour le calcul de x au carré.

- Exemple 2 :
A
Dans l'exemple précèdent 𝑦 = 𝑥 2 − 4𝑥. Le fonctionnement élément par élément est nécessaire
LM
z=[1:2:11] Créer un vecteur z de six éléments
z =
1 3 5 7 9 11
>> y=(z.^3 + 5*z)./(4*z.^2 - 10) Le vecteur z est utilisé dans les calculs
y = élément par élément des éléments du
-1 1.6154 1.6667 2.0323 2.465 2.9241 vecteur y

𝑧 3 +5𝑧
Dans cette exemple 𝑦 = 4𝑧 2−10. Les opérations élément par élément sont utilisées trois fois :

pour calculer z3 et z2, et pour diviser le numérateur par le dénominateur.

3.5 Utilisation des matrices dans les fonctions mathématiques Intégrées de Matlab

Les fonctions intégrées dans MATLAB sont écrites de telle sorte que lorsque l'argument
(entrée) est une matrice, l'opération définie par la fonction est exécutée sur chaque élément du
tableau. (On peut considérer l'opération comme une application élément par élément de la
fonction.) Le résultat (sortie) d'une telle opération est une matrice dans lequel chaque élément
est calculé en entrant l'élément correspondant du tableau d'arguments (entrée) dans la fonction.
Par exemple, si un vecteur à sept éléments est substitué dans la fonction cos (x), le résultat est
un vecteur à sept éléments dans lequel chaque élément est le cosinus de l'élément correspondant
en x. Ceci est illustré ci-dessous :

>> x=[0:pi/6:pi]
x = Créer un vecteur x de six éléments
0 0.5236 1.0472 1.5708 2.0944 2.618 3.1416 entre 0 et π avec un pas de π/6
>> y=cos(x)
y =
1 0.86603 0.5 6.1232e-17 -0.5 -0.86603 -1

Un exemple dans lequel la variable d'argument est une matrice est :

>> d=[1 4 9; 16 25 36; 49 64 81]

Créer une matrice d de taille (3x3)

d =
1 4 9
16 25 36
49 64 81 h est une matrice (3x3) dans laquelle
>> h=sqrt(d) chaque élément est la racine carrée de
h = l'élément correspondant dans la
1 2 3 matrice d
4 5 6
7 8 9
A
La caractéristique de MATLAB dans laquelle les matrices peuvent être utilisés comme
arguments dans les fonctions est appelée vectorisation.
LM
3.6 Fonctions intégrées pour analyser les matrices

MATLAB possède de nombreuses fonctions intégrées pour analyser les matrices. Le Tableau
3.1 répertorie certaines de ces fonctions :

Fonction Description Exemple

mean(A) Si A est un vecteur, renvoie la moyenne des >> A=[5 9 2 4];
éléments du vecteur mean(A)
Si A est une matrice, retourne un vecteur ligne ans =
qui contient la moyenne de chaque colonne 5
C=max(A) Si A est un vecteur, C est le plus grand élément >> A=[5 9 2 4 11 6 11
de A. Si A est une matrice, C est un vecteur 1];
ligne contenant le plus grand élément de chaque C=max(A)
colonne C =
Si A est un vecteur, d est le plus grand élément 11
[d,n]=max(A)
>> [d,n]=max(A)
de A et n est la position de l'élément (le premier
d =
si plusieurs ont la valeur max). Si A est une
11
matrice, d est un vecteur ligne contenant le plus n =
grand élément de chaque colonne et n est un 5
vecteur ligne contenant leurs positions
min(A) Identique à max (A), mais pour le plus petit >> A=[5 9 2 4];
élément >> min(A)
[d,n]=min(A) Identique à [d, n] = max (A), mais pour le plus ans =
petit élément 2
sum(A) Si A est un vecteur, retourne la somme des >> A=[5 9 2 4];
éléments du vecteur. sum(A)
 Si A est une matrice, retourne un vecteur ligne ans =
qui contient la somme de chaque colonne 20
sort(A) Si A est un vecteur, organise les éléments du A=[5 9 2 4];
vecteur dans l'ordre croissant sort(A)
Si A est une matrice, organise les éléments des ans =
colonnes dans l'ordre croissant 2 4 5 9
median(A) Si A est un vecteur, renvoie la valeur médiane A=[5 9 2 4];
des éléments du vecteur median(A)
Si A est une matrice, retourne un vecteur ligne ans =
qui contient la médiane de chaque colonne 4.5
std(A) Si A est un vecteur, renvoie l'écart-type des >> A=[5 9 2 4];
éléments du vecteur std(A)
Si A est une matrice, retourne un vecteur ligne ans =
qui contient l'écart type de chaque colonne 2.9439
det(A) Renvoie le déterminant d'une matrice carrée A >> A=[2 4; 3 5];
det(A)
ans =
-2
dot(a,b) Calcule le produit scalaire (point) de deux >> a=[1 2 3];
vecteurs a et b. Les vecteurs peuvent chacun être b=[3 4 5];
vecteur ligne ou colonne dot(a,b)
ans =
26
inv(A) Calcule l'inverse d'une matrice carrée A
A >>A=[2 -2 1;3 2 -1;2 -3 2];
inv(A)
ans =
0.2 0.2 0
-1.6 0.4 1
-2.6 0.4 2
LM
Tableau 3.1- Fonctions intégrées pour analyser les matrices

3.7 Générations de nombres aléatoires

Les simulations de nombreux processus physiques et applications d'ingénierie nécessitent

souvent l'utilisation d'un nombre (ou d'un ensemble de nombres) avec une valeur aléatoire.
MATLAB a trois commandes - rand, randn et randi - qui peuvent être utilisées pour attribuer
des nombres aléatoires aux variables.

3.7.1 La commande rand

La commande rand génère des nombres aléatoires uniformément distribués avec des valeurs
comprises entre 0 et 1. La commande peut être utilisée pour affecter ces nombres à un scalaire,
un vecteur ou une matrice, comme indiqué dans le Tableau 3.2.

Fonction Description Exemple

rand Génère un seul nombre aléatoire entre 0 >> rand
ans =
et 1 0.24654
rand(1,n) Génère un vecteur ligne à n éléments de >> a=rand(1,4)
a =
nombres aléatoires compris entre 0 et 1 0.8272 0.5181 0.0708 0.0515
 rand(n) Génère une matrice (n x n) avec des >> b=rand(3)
b =
nombres aléatoires compris entre 0 et 1 0.3115 0.9180 0.7791
0.6380 0.0769 0.5123
0.4418 0.4044 0.3498
rand(m,n) Génère une matrice (m x n) avec des >> c=rand(2,4)
c =
nombres aléatoires compris entre 0 et 1 0.0900 0.8980 0.3552 0.9674
0.3086 0.2888 0.9719 0.8176

randperm(n) Génère un vecteur ligne avec n éléments >> randperm(6)

ans =
qui sont une permutation aléatoire 3 2 5 6 4 1
d'entiers 1 à n

Tableau 3.2 - La commande rand

Parfois, il y a un besoin de nombres aléatoires qui sont distribués dans un intervalle autre que
(0,1), ou de nombres qui sont uniquement des entiers. Cela peut être fait en utilisant des
opérations mathématiques avec la fonction rand. Les nombres aléatoires qui sont distribués
dans une plage (a, b) peuvent être obtenus en multipliant le rand par (b - a) et en ajoutant le
produit à a :
A (b – a)*rand + a
Par exemple, un vecteur de 10 éléments avec des valeurs aléatoires comprises entre –5 et 10
peut être créé par (a = –5, b = 10) :
LM
>> v=15*rand(1,10)-5
v =
9.3314 2.4614 -0.1564 -0.2948 0.2193 -4.1306 2.5289 7.5376 -2.2840 9.7325

3.7.2 La commande randi

La commande randi génère un entier aléatoire uniformément distribué. La commande peut être
utilisée pour affecter ces nombres à un scalaire, un vecteur ou une matrice, comme indiqué dans
le Tableau 3.3

Fonction Description Exemple

randi (imax) Génère un seul nombre aléatoire entre >> a=randi(30)
a =
1 et imax 7
(imax est un entier)
randi(imax,n) Génère une matrice (n x n) avec des >> b=randi(30,3)
b =
nombres entiers aléatoires compris 28 9 19
entre 1 et imax 15 30 2
7 8 25
randi(imax,m,n) Génère une matrice (m x n) avec des >> c=randi(30,2,4)
c =
nombres entiers aléatoires compris 4 24 7 26
entre 1 et imax 30 20 7 8
0.4418 0.4044 0.3498

Tableau 3.3 - La commande randi

La plage des entiers aléatoires peut être définie pour être comprise entre deux entiers
quelconques en tapant [imin imax] au lieu de imax. Par exemple, une matrice avec des nombres
entiers aléatoires entre 50 et 90 est créée par :

>> d=randi([50 90],3,4)

d =
57 54 72 82
77 52 85 53
89 54 61 87

3.7.3 La commande randn

La commande randn génère des nombres normalement distribués avec une moyenne de 0 et un
écart type de 1. La commande peut être utilisée pour générer un seul nombre, un vecteur ou une
matrice de la même manière que la commande rand. Par exemple, une matrice de taille (3x4)
est créée par :

>> d=randn(3,4)
d =
0.5840 -1.7223 0.9567 -1.2543
1.7052
0.8717
-2.2666
-2.1847
-1.2964
1.7250
A 0.8879
-0.7403

La moyenne et l'écart type des nombres peuvent être modifiés par des opérations mathématiques
pour avoir n'importe quelle valeur. Cela se fait en multipliant le nombre généré par la fonction
LM
randn par l'écart-type souhaité et en ajoutant la moyenne souhaitée. Par exemple, un vecteur de
six nombres avec une moyenne de 50 et un écart type de 6 est généré par :

>> v=4*randn(1,6)+50
v =
44.8335 48.8710 47.1801 44.2338 46.6165 46.7118

Des nombres entiers de nombres normalement distribués peuvent être obtenus en utilisant la
fonction round

>> w=round(4*randn(1,6)+50)
w =
47 49 48 50 43 57