Informatique

Appliquée

3
 Chapitre 2 : Les vecteurs et les
matrices
Sommaire
2.1. Les types de base ...................................................................................................... 5
2.1.1. Le type complexe .............................................................................................. 5
2.1.2. Le type chaîne de caractères ............................................................................ 5
2.1.3. Le type logique ................................................................................................. 6
2.2. Les variables ............................................................................................................ 7
2.2.1. Les vecteurs ...................................................................................................... 8
[Link]. Création d'un vecteur à partir d'une liste de nombres connue ............... 8
[Link]. Création d'un vecteur à espacement constant ......................................... 9
2.2.2. Les matrices ................................................................................................... 12
[Link]. Création d’une matrice .............................................................................. 12
[Link]. Matrices spéciales ....................................................................................... 13
2.2.3. Opérateur de transposition «’» ...................................................................... 14
2.2.4. Indexation....................................................................................................... 15
[Link]. Utilisation de l’opérateur ‘:’ pour l'indexation ......................................... 16
2.2.5. Ajouter des éléments aux variables existantes .............................................. 18
2.2.6. Supprimer des éléments ................................................................................. 20
2.2.7. Opérations mathématiques sur les matrices ................................................. 20
[Link]. Addition et soustraction ............................................................................. 20
[Link]. Multiplications ........................................................................................... 21
[Link]. Divisions ..................................................................................................... 23
[Link]. Multiplication, Division et l'exponentiation élément par élément ............ 24
2.2.8. Fonctions intégrées pour la manipulation des tableaux ................................ 24

4
2.1. Les types de base

Les trois principaux types de variables utilisés par Matlab sont les types : réel,
complexe et chaîne de caractères. Le type logique est associé au résultat de certaines
fonctions.

Parfois, il est nécessaire de pouvoir déterminer le type de variable issu des différents
calculs. Pour cela, il existe les commandes : ischar, islogical et isreal.
- La commande isreal (x) est à utiliser avec discernement : elle retourne 1 si x est réel
ou de type chaîne de caractères et 0 sinon (x est complexe à partie imaginaire non
nulle ou n’est pas un tableau de valeurs réelles ou de caractères).
- La commande islogical retourne 1 si x est de type logique et 0 sinon.
- La commande ischar retourne 1 si x est de type chaîne de caractères et 0 sinon.

Exemples :

>> x = 2 ; z = 2+i ; r = 'oui'; >> isreal(x)

>> ischar(r) ans =
ans = logical
logical 1
1
>> ischar(x) >> isreal(r)
ans = ans =
logical logical
0 1
>> isreal(z)
ans =
logical
0

2.1.1. Le type complexe

L’unité imaginaire est désignée par i ou j. Les nombres complexes peuvent être écrits
sous forme cartésienne a + ib ou sous forme polaire reit. Les différentes écritures
possibles sont a+ib, a+i*b, a+b*i, a+bi et r*exp(it) ou r*exp(i*t) avec a, b, r et t des
variables de type réel. Les commandes imag, real, abs, angle permettent de passer
aisément de la forme polaire à la forme cartésienne et réciproquement.
Si z est de type complexe, les instructions imag(z) et real(z) retournent la partie
imaginaire et la partie réelle de z.
Les instructions abs(z) et angle(z) retournent le module et l’argument de z.

2.1.2. Le type chaîne de caractères

Une chaîne de caractères est un tableau de caractères. Une donnée de type chaîne de
caractères (char) est représentée sous la forme d’une suite de caractères encadrée
d’apostrophes simples (‘ ’).

Exemples :

5
>> ch1 = 'bon' >> ch(1), ch(7), ch(1:3)
ch1 = ans =
'bon' 'b'
>> ch2 = 'jour' ans =
ch2 = 'r'
'jour' ans =
>> whos 'bon'
Name Size Bytes Class Attributes >> ch3 = 'soi'
ch1 1x3 6 char Ch3 =
ch2 1x4 8 char
'soi'
>> ch = [ch1,ch2] >> ch = [ch(1:3), ch3, ch(7)]
ch = ch =
'bonjour' 'bonsoir'

Si une chaîne de caractères doit contenir le caractère apostrophe (’) celui-ci doit être
doublé dans la chaîne.

>> rep = ’aujourd’hui’ >> rep = ’aujourd’’hui’

rep = 'aujourd'hui' rep =
↑ 'aujourd'hui'
Error: Invalid expression…

La chaîne de caractères vide s’obtient par 2 apostrophes ‘ ’. La commande isempty

permet de tester si une variable de type chaîne de caractères est vide ou non. La
commande strcmp permet de tester si deux chaines de caractères sont égales ou non.

>> a = ’ ’ >> b = ’bonjour’

a = b =
0×0 empty char array 'bonjour'
>> isempty(a) >> strcmp(a,b)
ans = ans =
logical logical
1 0

2.1.3. Le type logique

Le type logique (logical) possède 2 formes : 0 pour faux et 1 pour vrai. Un résultat de
type logique est retourné par certaines fonctions ou dans le cas de certains tests.
Dans l’exemple qui suit on considère une variable x = 123 et une variable y définie
par l’expression mathématique y = 100+20+3. On teste si les variables x et y
contiennent les mêmes valeurs. La variable tst est une variable de type logique qui
vaut 1 (vrai) si les valeurs sont égales et 0 (faux) sinon. Suivant la valeur de tst, on
affiche la phrase x est égal à y ou la phrase x est diffèrent de y.

>> x = 123; >> if 'tst==1'

>> y = 100+20+3; disp('x est égal à y ')
>> tst = ( x==y ) else
tst = disp('x est différent de y ')
logical end
1 x est égal à y

6
2.2. Les variables

Avec Matlab, on travaille essentiellement avec un type d’objet : les matrices. Une
variable scalaire est une matrice de dimension 1 x 1 (un nombre est considéré comme
une matrice 1 × 1) et un vecteur est une matrice de dimension 1 x n ou n x 1.

Une variable peut être nommée en respectant les règles suivantes :

- Doit commencer par une lettre.
- Peut contenir jusqu'à 63 caractères.
- Peut contenir des lettres, des chiffres et le caractère de soulignement ( _ ).
- Ne peut pas contenir de signes de ponctuation (par exemple, point, virgule, point-
virgule).
- MATLAB fait la distinction entre les majuscules et les minuscules. Par exemple :
AA, Aa, aA et aa sont les noms de quatre variables différentes.
- Aucun espace n'est autorisé entre les caractères (utilisez le trait de soulignement là
où un espace est souhaité).
- Évitez d'utiliser le nom d'une fonction intégrée pour une variable (c'est-à-dire, évitez
d'utiliser cos, sin, exp, sqrt, etc.). Une fois qu'un nom de fonction est utilisé pour un
nom de variable, la fonction ne peut pas être utilisée.
- Comme tous les langages, MATLAB dispose de mots-clés. Certains mots-clés ne
peuvent être utilisés comme variables. Ce sont les mots réservés du langage. Une fois
tapés, ces mots apparaissent en bleu. Un message d'erreur s'affiche si l'utilisateur
essaie d'utiliser un mot-clé comme nom de variable. (Les mots clés peuvent être
affichés en tapant la commande iskeyword). Il y a 20 mots, appelés mots-clés, qui
sont réservés par MATLAB à diverses fins et ne peuvent pas être utilisés comme
noms de variables. Ces mots sont:
break case catch classdef continue else elseif end for function global if otherwise
parfor persistent return spmd switch try while
Les variables sont définies au fur et à mesure que l’on donne leurs noms
(identificateur) et leurs valeurs numériques ou leurs expressions mathématiques.
L’utilisation de variables avec MATLAB ne nécessite pas de déclaration de type ou
de dimension.

nom_variable = Une valeur numérique ou une expression arithmétique

Exemples :
>> x=15
x =
15
>> x=3*x-12
x =
33
>> a=12
a =
12
>> B=4
B =
4
>> C=(a-B)+40-a/B*10
C =
18

7
Une fois qu'une variable est définie, elle peut être utilisée comme argument dans les
fonctions. Par exemple :

>> x=0.75;
>> E=sin(x)^2+cos(x)^2
E =
1

2.2.1. Les vecteurs

Dans MATLAB, un vecteur est créé en affectant les éléments du vecteur à une
variable.

[Link]. Création d'un vecteur à partir d'une liste de nombres connue

Le vecteur est créé en tapant les éléments (nombres) entre crochets [ ].

nom_variable = [les éléments du vecteur]

Nous distinguons deux types de vecteurs :

- Vecteur ligne : On définit un vecteur ligne en donnant la liste de ses éléments

séparés au choix par des espaces ou par des virgules.

- Vecteur colonne : On définit un vecteur colonne en donnant la liste de ses éléments

séparés au choix par des points virgules ( ;) ou par des retours chariots (saisissez le
crochet gauche [ puis entrez le premier élément, appuyez sur la touche Entrée, entrez
le deuxième élément, appuyez sur la touche Entrée,…, Tapez le crochet droit ] après
le dernier élément).

Remarques :
- On peut transformer un vecteur ligne x en un vecteur colonne et
réciproquement en tapant x’ (’ est le symbole de transposition).
- On peut obtenir la longueur d’un vecteur v par la commande length(v).

Exemples :
>> v1 =[1 2.5 pi] Vecteurs lignes dont les éléments
v1 = sont rangés entre crochets et
1.0000 2.5000 3.1416 séparés d’un espace pour v1 et
d’une virgule pour v2.
>> v2 = [1, 2.5, pi] Le dernier élément est la constante
v2 = prédéfinie π, représentée par « pi
1.0000 2.5000 3.1416 »

8
>>v3=[1;sqrt(2);cos(1-2*sin(pi/4))] Vecteurs colonnes dont les
v3 = éléments sont rangés entre crochets
1.0000 et espacés d’un point-virgule « ; »
1.4142 pour v3.
0.9154
>> v4 = [1.0 Saisi un par un et Entrée à la fin
sqrt(2.0) de chacun pour v4.
cos(1-2*sin(pi/4))]
v4 = Les éléments des vecteurs peuvent
1.0000 contenir des opérations et des
1.4142 fonctions mathématiques
0.9154
>> v4’ v4’ est la transposée du vecteur
v4 = v4
1.0000 1.4142 0.9154

[Link]. Création d'un vecteur à espacement constant

a. Utilisation de l’opérateur :
Dans un vecteur à espacement constant, la différence entre les éléments est la même.
Par exemple, dans le vecteur v = 2 4 6 8 10, l'espacement entre les éléments est 2. Un
vecteur dans lequel le premier terme est d (début), l'espacement est p (pas) et le
dernier terme est f (fin) (séparés par l’opérateur « : ») est créé en tapant :

nom_variable = [d:p:f] Les crochets [ ] sont facultatifs

Ou :

nom_variable = d:p:f

Remarques :

- Si le pas p est omis (ex : nom_variable = d:f), le pas d’incrémentation est par
défaut est 1.
- Le pas peut être un nombre décimal, positif ou négatif.
- Pour l’espacement positif, le dernier nombre généré est toujours inférieur ou égale à f.
- Pour l’espacement négatif, le dernier nombre généré est toujours supérieur ou égale à f.
- La commande colon(d,f) est identique à d:f et colon(d,p,f) est identique à
d:p:f.

Exemples :
>> V1 =[Link] Les crochets [ ] sont facultatifs
v1 =
0 1 2 3 4 5 6
>> V2 =[Link]
V2 =
0 1 2 3 4 5 6
>> V3=-3:3 Si l'espacement n’est pas précisé, la valeur par
V3 = défaut est 1
-3 -2 -1 0 1 2 3

9
>> V4 =[Link] Le dernier élément du vecteur sera le dernier
V4 = nombre qui ne dépasse pas f
0 2 4 6 8 10
>> V5 =[Link]
V5 =
0 3 6 9
>> V6=0:0.1:0.4 Le début, le pas et la fin du vecteur peuvent
V6 = être définit par des expressions
0 0.1000 0.2000 0.3000
0.4000
mathématiques ou des commandes
>> V7=0:1/10:0.4
V7 =
0 0.1000 0.2000 0.3000
0.4000
>> V8=21:-3:pi La valeur de l’espacement peut être négative
V8 =
21 18 15 12 9 6
>> V9=[1 2 4:6 5:0.1:5.5] Il est possible de mixer différentes formes
V9 = d'initialisation
1.0000 2.0000 4.0000 5.0000 6.0000
5.0000 5.1000 5.2000 5.3000 5.4000
5.5000

b. Générer un vecteur espacé linéairement

Il est également possible de créer des vecteurs dont les éléments sont uniformément
répartis avec la fonction linspace (équivalent de l’opérateur « : »). Cette fonction
prend en argument, le premier élément xi et le dernier élément xf de la répartition
ainsi que le nombre d'éléments n à générer. L'espacement entre les points est
déterminé automatiquement par MATLAB par la relation :

( − )/( −1).

nom_variable =
linspace(xi,xf,n)

Ou :
Si « n » n’est pas défini, le nombre
nom_variable = d’éléments par défaut est de 100 points
linspace(xi,xf) régulièrement espacés entre xi et xf.

Il est possible de générer un vecteur décroissant (lorsque xf < xi), ou un vecteur de

nombres complexes régulièrement espacés (lorsque xi et xf sont des nombres
complexes).

Exemples :
>> v1=linspace(0,6,5) 5 éléments, premier élément 0, dernier
v1 = élément 6
0 1.5000 3.0000 4.5000 6.0000
>> v2=linspace(6,0,5) 5 éléments, premier élément 6, dernier
v2 = élément 0 (vecteur décroissant)
6.0000 4.5000 3.0000 1.5000 0
>> v3=linspace(0.5,3,5) 5 éléments, premier élément 0.5, dernier
v3 = élément 3
0.5000 1.1250 1.7500 2.3750 3.0000

10
>> v4=linspace(-3,3,4) 4 éléments, premier élément -3, dernier
v4 = élément 3
-3 -1 1 3
>> v5=linspace(0,10) 100 éléments (n : non spécifié), premier
v5 = élément 0, dernier élément 10
Columns 1 through 5
0 0.1010 0.2020 0.3030 0.4040
...
Columns 97 through 100
9.6970 9.7980 9.8990 10.0000
>> y = linspace(1+2i,10+5i,3) Vecteur de nombres complexes de 3
y = éléments :
1.0000+2.0000i 5.5000+3.5000i
10.0000+5.0000i
partie réelle : premier élément 1, dernier
élément 10
partie imaginaire : premier élément 2,
dernier élément 5

Remarques :

Le nombre d’éléments n doit être spécifié comme un scalaire numérique réel :

- Si n vaut 1, linspace renvoie xf.
- Si n est zéro ou négatif, linspace renvoie une matrice 1 par 0 vide.
- Si n n'est pas un entier, linspace arrondit n vers le bas en utilisant la commande
floor(n) (par exemple : si n =5.9, linspace renvoie 5 éléments).

c. Générer un vecteur espacé logarithmiquement

Il est également possible de créer des vecteurs uniformément répartis avec des
intervalles logarithmiques en utilisant logspace. Cette fonction est particulièrement
utile pour montrer sur un petit espace une large gamme de valeurs.

nom_variable = logspace(a,b,n) Si « n » n’est pas spécifié, le nombre

d’éléments par défaut est de 50 points
Ou : logarithmiquement espacés entre les
décades 10^a et 10^b
nom_variable = logspace(a,b)

De la même manière que linspace, logspace permet de générer des vecteurs

décroissants (lorsque b < a), ou des vecteurs de nombres complexes
logarithmiquement espacés (lorsque a et b sont des nombres complexes).

Exemples :

>> V1=logspace(0,3,5) 5 éléments, logarithmiquement espacés

V1 = entre 10^0 et 10^3
0.00 5.62 31.62 177.83 1000.00
>> V2=logspace(3,0,5) 5 éléments, logarithmiquement espacés
V2 = entre 10^3 et 10^0
1000.00 177.83 31.62 5.62 1.00
>> V3 = logspace(0.1,pi,4) 4 éléments, logarithmiquement espacés
V3 = entre 10^0.1 et π
1.26 1.71 2.32 3.14

11
>> V4=logspace(0.1,pi)
V4 = 50 éléments (n : non spécifié),
Columns 1 through 5
1.26 1.28 1.31 1.33 1.36
logarithmiquement espacés entre 10^0.1 et
... π
Columns 46 through 50
2.92 2.97 3.03 3.08 3.14
>> V5 = logspace(1+1i,2+2i,3) Vecteur de nombres complexes de 3
V5 = éléments : logarithmiquement espacés
-6.682+7.4398i -30.093-9.7156i -
10.701-99.426i
entre 10^(1+1i) et 10^(2+2i)

2.2.2. Les matrices

Un tableau à deux dimensions, également appelé matrice, a des nombres dans les
lignes et les colonnes. Les matrices peuvent être utilisées pour stocker des
informations et jouent un rôle important dans l'algèbre linéaire et sont utilisées en
science et en ingénierie pour décrire de nombreuses quantités physiques.

Dans une matrice carrée, le nombre de lignes m et le nombre de colonnes n sont

égaux. Par exemple, la matrice :

Matrice (3 x 3) est carré, avec trois lignes et trois colonnes. En général, le nombre de
lignes et de colonnes peut être différent. Par exemple, la matrice :

Matrice (3 x 6) à trois lignes et six colonnes. Pour une matrice à m lignes et n

colonnes, (m par n) est appelée la taille de la matrice.

[Link]. Création d’une matrice

Une matrice est créée en affectant les éléments de la matrice à une variable. Cela se
fait en tapant les éléments, ligne par ligne, entre crochets [ ]. Tapez d'abord le crochet
gauche [ puis tapez la première ligne, en séparant les éléments par des espaces ou des
virgules. Pour taper la ligne suivante, tapez un point-virgule « ; » ou appuyez sur
Entrée. Tapez le crochet droit ] à la fin de la dernière ligne.

nom_variable = [Éléments de la 1ère ligne; Éléments de 2ème

ligne; Éléments de 3ème ligne; ...; éléments de la dernière
ligne]

Les éléments entrés peuvent être des nombres ou des expressions mathématiques
pouvant inclure des nombres, des variables prédéfinies et des fonctions. Toutes les
lignes doivent avoir le même nombre d'éléments. Si un élément est nul, il doit être
12
saisi comme tel. MATLAB affiche un message d'erreur en cas de tentative de
définition d'une matrice incomplète. Des exemples de matrices définies de différentes
manières sont présentés dans l’exemple suivant :

>> a=[5 35 43; 4 76 81; 21 32 40]

a =
5 35 43
4 76 81
21 32 40
>> a=[5 35 43
4 76 81
21 32 40]
a =
5 35 43
4 76 81
21 32 40
>> c=6; e=3; h=4;
>> Mat=[e, c*h, cos(pi/3); h^2, sqrt(h*h/c), 14]
Mat =
3 24 0.5
16 1.633 14

Les lignes d'une matrice peuvent également être entrées en tant que vecteurs en
utilisant la saisie, la notation pour créer des vecteurs à espacement constant « : », ou
la commande linspace. Par exemple :

A=[Link]; [Link]; linspace(10,60,6); 67 2 43 68 4 13]

A =
1 3 5 7 9 11
0 5 10 15 20 25
10 20 30 40 50 60
67 2 43 68 4 13

Dans cet exemple, les deux premières lignes ont été saisies en tant que vecteurs en
utilisant la notation d'espacement constant, la troisième ligne a été saisie à l'aide de la
commande linspace, et dans la dernière ligne, les éléments ont été saisis
individuellement.
Il est également possible de construire une matrice à partir de vecteurs existants, que
ce soit par ligne ou par colonne comme sur l’exemple suivant :

>> v1=[1 2 3] >> M1=[v1 ; v2 ; v3] >> M2=[v1' v2' v3']

v1 = M1 = M2 =
1 2 3 1 2 3 1 4 7
>> v2=[4 5 6] 4 5 6 2 5 8
v2 = 7 8 9 3 6 9
4 5 6
>> v3=[7 8 9]
v3 =
7 8 9

[Link]. Matrices spéciales

Les commandes zeros (m, n), ones (m, n) et eye (n) peuvent être utilisées pour créer
des matrices qui ont des éléments avec des valeurs spéciales.

13
eye(n) : crée une matrice carrée (nombre de lignes égal au nombre de colonnes) avec
n lignes et n colonnes dans laquelle les éléments diagonaux sont égaux à 1 et les
autres éléments sont 0. Cette matrice est appelée matrice identité.
ones(m,n) : la matrice à m lignes et n colonnes dont tous les éléments valent 1
zeros(m,n) : la matrice à m lignes et n colonnes dont tous les éléments valent 0
magic(n) : permet d’obtenir une matrice magique de dimension n x n (avec n≥3).

Exemples :
>> zr=zeros(3,4)
zr =
0 0 0 0
0 0 0 0
0 0 0 0
>> un=ones(4,3)
un =
1 1 1
1 1 1
1 1 1
1 1 1
>> idn=eye(4)
idn =
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
>> magic(4)
ans =
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1

Si l’un des entiers m ou n est égal à 1, les commandes zeros (m, n), et ones (m, n) vont
générer des vecteurs : lignes si m=1 ou colonnes si n=1.
Les commandes rand (m, n) et randn (m, n) permettent de générer des matrices (ou
vecteurs) dont les colonnes contiennent des variables aléatoires réparties selon les lois
uniforme (entre 0 et 1) et normale (centrée et réduite), respectivement.

2.2.3. Opérateur de transposition «’»

L'opérateur de transposition «’», lorsqu’il est appliqué à un vecteur, il bascule un

vecteur ligne (colonne) vers un vecteur colonne (ligne). Lorsqu'il est appliqué à une
matrice, il bascule les lignes (colonnes) en colonnes (lignes). L’opérateur de
transposition est appliqué en tapant un guillemet simple ou l’apostrophe «’» après la
variable à transposer.

14
Exemples :

>> v1=[2 9 3]
v1 =
2 9 3
>> v2=v1'
v2 =
2
9
3
>> Mat1=[2 55 14 8; 21 5 32 11
;... 41 64 9 1]
Mat1 =
2 55 14 8
21 5 32 11
41 64 9 1
>> Mat2=Mat1'
Mat2 =
2 21 41
55 5 64
14 32 9
8 11 1

2.2.4. Indexation

Les éléments d'un vecteur ou d’une matrice peuvent être indexés individuellement ou
en sous-groupes. Ceci est utile lorsqu'il est nécessaire de redéfinir uniquement
certains éléments, lorsque des éléments spécifiques doivent être utilisés dans les
calculs ou lorsqu'un sous-groupe des éléments est utilisé pour définir une nouvelle
variable.

- Indexation de vecteur

L'adresse d'un élément dans un vecteur est sa position dans la ligne (ou colonne). Pour
un vecteur nommé v, v(k) fait référence à l'élément en position k. La première position
est 1.

Exemple :
v =[25 36 68 13 -5 4 71 -7 45];
>> v(2)
ans =
36
>> v(5)
ans =
-5
>> v(9)
ans =
45
>> v(end)
ans =
45

Un élément vectoriel unique, v(k), peut être utilisé uniquement comme variable. Par
exemple, il est possible de modifier la valeur d'un seul élément d'un vecteur en
affectant une nouvelle valeur à une adresse spécifique. Cela se fait en tapant : v (k) =
15
valeur. Un seul élément peut également être utilisé comme variable dans une
expression mathématique.
Exemples :
>> A=v(4)
A =
13
>> v(6)= 176
v =
25 36 68 13 -5 176 71 -7 45
>> v(2)+v(8)
ans =
29
>> v(5)*v(8)+ sqrt(v(2))
ans =
41

- Indexation de Matrice

L'adresse d'un élément dans une matrice est sa position, définie par le numéro de ligne
et le numéro de colonne où il se trouve. Pour une matrice affectée à une variable M,
M(k, p) fait référence à l'élément de la ligne k et de la colonne p. Par exemple, si la
matrice est :

M(1,1) = 3 et M(2,3) = 10

Comme pour les vecteurs, il est possible de modifier la valeur d'un seul élément d'une
matrice en attribuant une nouvelle valeur à cet élément. De plus, des éléments uniques
peuvent être utilisés comme des variables dans les expressions et fonctions
mathématiques.

Exemples :
>> M=[3 11 6 5; 4 7 10 2; 13 9 0 8]
M =
3 11 6 5
4 7 10 2
13 9 0 8
>> M(3,1)=20
M=
3 11 6 5
4 7 10 2
20 9 0 8
>> M(2,4)- M(1,2)
ans =
-9

[Link]. Utilisation de l’opérateur ‘:’ pour l'indexation

Un deux-points peut être utilisé pour adresser une gamme d'éléments dans un vecteur
ou une matrice.

16
 - Pour un vecteur :

v (:) Fait référence à tous les éléments du vecteur v (soit un vecteur ligne ou colonne).
v (m: n) Fait référence aux éléments m à n du vecteur v.

Exemple :
>> v = [4 15 8 12 34 2 50 23 11]
v =
4 15 8 12 34 2 50 23 11
>> u = v(3:7)
u =
8 12 34 2 50

- Pour une matrice :

A(:, n) : Fait référence aux éléments de toutes les lignes de la colonne n de la matrice
A.
A(n,:) : Fait référence aux éléments dans toutes les colonnes de la ligne n de la
matrice A.
A(:, m: n) : Fait référence aux éléments de toutes les lignes entre les colonnes m et n
de A.
A(m: n, :) : Fait référence aux éléments dans toutes les colonnes entre les lignes m et
n de A.
A(m: n, p: q) : Fait référence aux éléments des lignes m à n et des colonnes p à q de
A.

Exemples :
>> A = [1 3 5 7 9 11; 2 4 6 8 10 12; 3 6 9 ...
12 15 18;4 8 12 16 20 24; 5 10 15 20 25 30]
A =
1 3 5 7 9 11
2 4 6 8 10 12
3 6 9 12 15 18
4 8 12 16 20 24
5 10 15 20 25 30
>> B = A(:,3)
B =
5
6
9
12
15
>> C = A(2,:)
C =
2 4 6 8 10 12
>> E = A(2:4,:)
E =
2 4 6 8 10 12
3 6 9 12 15 18
4 8 12 16 20 24
>> F = A(1:3,2:4)
F =
3 5 7
4 6 8
6 9 12

17
Il est possible de sélectionner uniquement des éléments spécifiques ou des lignes et
colonnes spécifiques de variables existantes pour créer de nouvelles variables. Cela se
fait en tapant les éléments ou lignes ou colonnes sélectionnés entre crochets.

Exemples :
>> v = [Link]
v =
4 7 10 13 16 19 22 25 28 31 34
>> u = v([3, 5, 7:10])
u =
10 16 22 25 28 31
>>A = [10:-1:4; ones(1,7); [Link]; zeros(1,7)]
A =
10 9 8 7 6 5 4
1 1 1 1 1 1 1
2 4 6 8 10 12 14
0 0 0 0 0 0 0
>> B = A([1,3],[1,3,5:7])
B =
10 8 6 5 4
2 6 10 12 14

2.2.5. Ajouter des éléments aux variables existantes

Une variable qui existe en tant que vecteur ou matrice peut être modifiée en y ajoutant
des éléments. Un vecteur peut être modifié pour avoir plus d'éléments, ou il peut être
modifié pour être une matrice à deux dimensions. Des lignes et/ou des colonnes
peuvent également être ajoutées à une matrice existante pour obtenir une matrice de
taille différente. L'ajout d'éléments peut être effectué en attribuant simplement des
valeurs aux éléments supplémentaires ou en ajoutant des variables existantes.

- Ajout d'éléments à un vecteur :

Des éléments peuvent être ajoutés à un vecteur existant en attribuant des valeurs aux
nouveaux éléments. Par exemple, si un vecteur a 4 éléments, le vecteur peut être
allongé en affectant des valeurs aux éléments 5, 6, etc. Si un vecteur a n éléments et
qu'une nouvelle valeur est affectée à un élément avec une adresse de n + 2 ou plus,
MATLAB attribue des zéros aux éléments qui se trouvent entre le dernier élément
d'origine et le nouvel élément.

Exemples :
>> v=1:4
v =
1 2 3 4
>> v(5:10) = [Link]
v =
1 2 3 4 10 15 20 25 30 35
>> a = [5 7 2]
a =
5 7 2
>> a(7) = 4
a =
5 7 2 0 0 0 4
>> a2(5) = 24
a2 =

18
 0 0 0 0 24

>> C = [3 8 1 24];
>> D = [Link];

>> Rh = [C D]
Rh =
3 8 1 24 4 7 10 13 16
>> Rv = [C'; D']
Rv =
3
8
1
24
4
7
10
13
16

- Ajout d'éléments à une matrice :

Des lignes et/ou des colonnes peuvent être ajoutées à une matrice existante en
attribuant des valeurs aux nouvelles lignes ou colonnes. Cela peut être fait en
attribuant de nouvelles valeurs ou en ajoutant des variables existantes. Cela doit être
fait avec soin car la taille des lignes ou colonnes ajoutées doit correspondre à la
matrice existante.

Exemples :
>> E = [1 2 3 4; 5 6 7 8]
E =
1 2 3 4
5 6 7 8
>> E(3,:) = [Link]
E =
1 2 3 4
5 6 7 8
10 14 18 22
>> K = eye(3)
K =
1 0 0
0 1 0
0 0 1
>> G = [E K]
G =
1 2 3 4 1 0 0
5 6 7 8 0 1 0
10 14 18 22 0 0 1

Si une matrice a une taille m x n et qu'une nouvelle valeur est affectée à un élément
avec une adresse au-delà de la taille de la matrice, MATLAB augmente la taille de la
matrice pour inclure le nouvel élément. Des zéros sont attribués aux autres éléments
ajoutés.

19
Exemples :
>> A = [3 6 9; 8 5 11]
A =
3 6 9
8 5 11
>> A(4,5) = 17
A =
3 6 9 0 0
8 5 11 0 0
0 0 0 0 0
0 0 0 0 17
>> B(3,4) = 15
B =
0 0 0 0
0 0 0 0
0 0 0 15

2.2.6. Supprimer des éléments

Un élément ou une plage d'éléments d'une variable existante peut être supprimé en ne
réaffectant rien à ces éléments. Cela se fait en utilisant des crochets avec rien tapé
entre eux. En supprimant des éléments, un vecteur peut être raccourci et une matrice
peut être réduite.

Exemples :
>> k = [2 7 12 1 3 23 29 19 76 93]
k =
2 7 12 1 3 23 29 19 76 93
>> k(5) = []
k =
2 7 12 1 23 29 19 76 93
>> k(3:6) = []
k =
2 7 19 76 93
>> M = [5 78 4 24 9; 4 0 36 60 12 ; 56 13 5 89 3]
M =
5 78 4 24 9
4 0 36 60 12
56 13 5 89 3
>> M(:,2:4) = []
M =
5 9
4 12
56 3

2.2.7. Opérations mathématiques sur les matrices

Une fois les variables créées dans MATLAB, elles peuvent être utilisées dans une
grande variété d'opérations mathématiques. 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.

[Link]. Addition et soustraction

Les opérations + (addition) et - (soustraction) peuvent être utilisées pour ajouter

(soustraire) des tableaux de taille identique (le même nombre de lignes et de
20
colonnes) et pour ajouter (soustraire) un scalaire à un tableau. Lorsque deux tableaux
sont compatibles, la somme, ou la différence, des tableaux est obtenue en ajoutant ou
en soustrayant leurs éléments correspondants.

Exemples :
>> v1=[8 5 4 -1]; v2=[4 10 2 7];
>> v3=v1+v2
v3 =
12 15 6 6
>> A=[6 -4 7; 8 3 11]
A =
6 -4 7
8 3 11
>> B=[9 6 5; -12 13 1]
B =
9 6 5
-12 13 1
>> A-B
ans =
-3 -10 2
20 -10 10
>> C=A+B
C =
15 2 12
-4 16 12
>> v1+A
Matrix dimensions must agree
>> v1=[2 7 9 -8 4]
v1 =
2 7 9 -8 4
>> v1+6

ans =
8 13 15 -2 10
>> A=[5 17 -11; 3 -7 9]
A =
5 17 -11
3 -7 9
>> A-4
ans =
1 13 -15
-1 -11 5

[Link]. Multiplications

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 de la matrice A est égal au nombre de
lignes de la matrice B. Le résultat est une matrice qui a le même nombre de lignes que
A et le même nombre de colonnes que B.
Le produit de la multiplication de deux matrices 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 (A ^ n) ne peut être exécutée qu'avec une matrice carrée.

21
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.

Exemples :
>> A=[1 4 3; 2 6 1; 5 2 8]
A =
1 4 3
2 6 1
5 2 8
>> B=[5 4;1 3;2 6]
B =
5 4
1 3
2 6
>> C=A*B
C =
15 34
18 32
43 74
>> D=B*A
Error using *
Incorrect dimensions for matrix multiplication. Check that the
number of columns in the first matrix matches the number of rows
in the second matrix.

>> F=[1 3; 5 7]
F =
1 3
5 7
>> G=[4 2; 1 6]
G =
4 2
1 6
>> F*G
ans =
7 20
27 52
>> G*F
ans =
14 26
31 45

>> v1=[2 5 1]
v1 =
2 5 1
>> v2=[3; 1; 4]
V2 =
3
1
4

22
>> v1*v2
ans =
15
>> v2*v1
ans =
6 15 3
2 5 1
8 20 4

>> A=[2 5 7 0; 10 1 3 4; 6 2 11 5]
A =
2 5 7 0
10 1 3 4
6 2 11 5
>> b=3
b =
3
>> b*A
ans =
6 15 21 0
30 3 9 12
18 6 33 15
>> C=A*5
C =
10 25 35 0
50 5 15 20
30 10 55 25

[Link]. Divisions

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). Certaines matrices n'ont pas d'inverse. Une matrice n'a un inverse
que si elle est carrée et que son déterminant n'est pas égal à zéro. Le déterminant est
généralement désigné par det (A) ou | A |.

MATLAB a deux types de division de matrice, la division à droite et la division à

gauche.

- Division à droite « / »
La bonne division est utilisée pour résoudre l'équation matricielle . Dans cette
équation, X et B sont des vecteurs lignes. Cette équation peut être résolue en
multipliant, à droite, les deux côtés par l'inverse de A : A A− =B A−
Ce qui donne : =B A−
Dans MATLAB, la dernière équation peut être écrite en utilisant le caractère de
division droite : = /

- Division à gauche « \ »
La division à gauche est utilisée pour résoudre l'équation matricielle = . Dans
cette équation, X et B sont des vecteurs colonnes. 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 \ : = \ .

23
 Exemple : soit le système linéaire suivant :

4 +2 + 6 =8
2 +8 + 2 =4
6 +10 + 3 =0

Le système d'équations ci-dessus peut être écrit sous la forme matricielle = ou

sous la forme = :

[Link]. Multiplication, Division et l'exponentiation élément par élément

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. Les opérations élément par élément ne peuvent être
effectuées qu'avec des tableaux de même taille.

Symbole Description
.* Multiplication
.^ Exponentiation
./ Division à droite
.\ Division à gauche

Dans l'exemple précèdent = 2−4 . Le fonctionnement élément par élément est

nécessaire pour le calcul de x au carré.

2.2.8. Fonctions intégrées pour la manipulation des tableaux

MATLAB possède de nombreuses fonctions intégrées pour gérer et manipuler les

tableaux.

Fonction Description Exemple

length(A) Renvoie le nombre d'éléments >> A=[5 9 2 4];
dans le vecteur A length(A)
ans =
4
size(A) Renvoie un vecteur ligne [m, >> A=[6 1 4 0 12; 5
n], où m et n sont la taille 19 6 8 2]
(m * n) de la matrice A A =
6 1 4 0 12
5 19 6 8 2
>> size(A)
ans =
2 5

24
reshape(A,m,n) Crée une matrice m par n à >> A=[5 1 6; 8 0 2]
partir des éléments de la A =
matrice A. Les éléments sont 5 1 6
pris colonne après colonne. 8 0 2
La matrice A doit avoir m >> B =reshape(A,3,2)
fois n éléments B =
5 0
8 6
1 2
diag(v) Lorsque v est un vecteur, >> v = [7 4 2];
diag(v) crée une matrice >> A = diag(v)
carrée avec les éléments de A =
v dans la diagonale 7 0 0
0 4 0
0 0 2
diag(A) Lorsque A est une matrice, >> A = [1 2 3; 4 5 6
diag(A) crée un vecteur à ;7 8 9]
partir des éléments A =
diagonaux de A 1 2 3
4 5 6
7 8 9
>> vec = diag(A)
vec =
1
5
9
mean(A) -Si A est un vecteur, renvoie la >> A=[5 9 2 4];
moyenne des éléments du vecteur. >> mean(A)
-Si A est une matrice, retourne ans =
un vecteur ligne qui contient la 5
moyenne de chaque colonne
-Si A est un vecteur, C est le >> A=[5 9 2 4 11 6 11
plus grand élément de A. -Si A 1];
est une matrice, C est un >> C=max(A)
vecteur ligne contenant le plus C =
grand élément de chaque colonne 11
-Si A est un vecteur, d est le >> [d,n]=max(A)
[d,n]=max(A) plus grand élément de A et n est d =
la position de l'élément (le 11
n =
premier si plusieurs ont la
5
valeur max).
-Si A est une matrice, d est un
vecteur ligne contenant le plus
grand élément de chaque colonne
et n est un vecteur ligne
contenant leurs positions
-Identique à max (A), mais pour >> A=[5 9 2 4];
[d,n]=min(A) le plus petit élément >> min(A)
-Identique à [d, n]= max(A), ans =
mais pour le plus petit élément 2

25
 sum(A) -Si A est un vecteur, >> A=[5 9 2 4];
retourne la somme des >> sum(A)
éléments du vecteur. ans =
-Si A est une matrice, 20
retourne un vecteur ligne
qui contient la somme de
chaque colonne
median(A) -Si A est un vecteur, >> A=[5 9 2 4];
renvoie la valeur médiane >> median(A)
des éléments du vecteur ans =
Si A est une matrice, 4.5
retourne un vecteur ligne
qui contient la médiane de
chaque colonne
std(A) -Si A est un vecteur, >> A=[5 9 2 4];
renvoie l'écart-type des >> std(A)
éléments du vecteur ans =
-Si A est une matrice, 2.9439
retourne un vecteur ligne
qui contient l'écart type de
chaque colonne
det(A) Renvoie le déterminant d'une >> A=[2 4; 3 5];
matrice carrée A >> det(A)
ans =
-2
dot(a,b) Calcule le produit scalaire >> a=[1 2 3];
de deux vecteurs a et b. Les >> b=[3 4 5];
vecteurs peuvent chacun être >> dot(a,b)
vecteur ligne ou colonne ans =
26
inv(A) Calcule l'inverse d'une >>A=[2 -2 1;3 2 -1;2
matrice carrée A -3 2];
>> inv(A)
ans =
0.2 0.2 0
-1.6 0.4 1
-2.6 0.4 2

Il existe d’autres fonctions pour la manipulation des tableaux Par exemple, soit la
matrice A :

Fonction Description Exemple

sort Pour les vecteurs, sort(A) trie les >>sort(A)
éléments de A dans l'ordre croissant. ans =
Pour les matrices, sort(A) trie 3 1 2
chaque colonne de A dans l'ordre 6 7 4
croissant. 9 8 5

26
sortrows Trier les lignes de la matrice >>sortrows(A)
ans =
3 7 4
6 8 5
9 1 2
flip Pour les vecteurs, flip(v) inverse >> flip(A)
l'ordre des éléments. ans =
Pour les matrices, flip(A) inverse 3 7 4
chaque colonne verticalement 6 8 5
9 1 2
fliplr Retourner la matrice de gauche à >> fliplr(A)
droite ans =
2 1 9
5 8 6
4 7 3
flipud Retourner la matrice de haut en bas >> flipud(A)
ans =
3 7 4
6 8 5
9 1 2
rot90 Faire pivoter la matrice de 90 degrés >> rot90(A)
ans =
2 5 4
1 8 7
9 6 3
transpose Transposer un vecteur ou une matrice >> transpose(A)
ans =
9 6 3
1 8 7
2 5 4
circshift Décaler le tableau de façon >> B =
circulaire. circshift(A,1)
Pour les vecteurs, circshift(v,N) B =
décale de façon circulaire les 3 7 4
éléments N fois. 9 1 2
Pour les matrices, circshift(A,N) 6 8 5
décale circulairement les valeurs des
colonnes vers le bas N fois.

27