Chapitre 2 Les Types de Données Et Variables: Table Des Matières

Chapitre 2 Les types de données et variables
Table des matières
Chapitre 2 Les types de données et variables ........................................................................... 19

Introduction .......................................................................................................................... 20
2.1 Les types de données ...................................................................................................... 20
2.1.1 Le type complexe .................................................................................................... 21
2.1.2 Le type chaîne de caractères.................................................................................... 22
2.1.3 Le type logique ........................................................................................................ 22
2.1.4 Notes sur les variables dans Matlab ........................................................................ 23
2.2 Fonctions mathématiques élémentaires intégrées .......................................................... 23
2.3 Les variables scalaires .................................................................................................... 25
2.3.1 L'opérateur d'affectation « = »................................................................................. 26
A
2.3.2 Règles sur les noms de variables ............................................................................. 27
2.3.3 Mots clés prédéfinis ................................................................................................ 28
2.4 Les vecteurs .................................................................................................................... 28
LM
2.4.1 Création d'un vecteur à partir d'une liste de nombres connue ................................. 28
2.4.2 Création d'un vecteur à espacement constant .......................................................... 29
2.5 Les matrices.................................................................................................................... 32
2.5.1 Création d’une matrice ............................................................................................ 33
2.5.2 Matrices spéciales ................................................................................................... 34
2.6 Opérateur de transposition «‘» ....................................................................................... 35
2.7 Utilisation de l’opérateur « : » (deux-points) pour l'indexation ..................................... 37
2.8 Ajouter des éléments aux variables existantes ............................................................... 39
2.9 Supprimer des éléments ................................................................................................. 40
2.10 Fonctions intégrées pour la manipulation des matrices ............................................... 41
20 Chapitre 2 Les types de données et variables
Introduction
Comme tout langage de programmation Matlab permet de définir des données variables. Une
variable est désignée par un identificateur qui est formé d’une lettre ou d’une combinaison de
lettres et de chiffres. Le premier caractère de l’identificateur doit nécessairement être une lettre.
Attention, Matlab différencie majuscules et minuscules ! Ainsi X1 et x1 désignent deux
variables distinctes. 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. Le type et la
dimension d’une variable sont déterminés de manière automatique à partir de l’expression
mathématique ou de la valeur affectée à la variable. Une variable peut être de type réel,
complexe, chaîne de caractères ou logique.
Pour Matlab toute variable est considérée comme étant un tableau d’éléments d’un type donné.
Matlab différencie trois formes particulières de tableaux. Les scalaires qui sont des tableaux à
A
une ligne et une colonne. Les vecteurs qui sont des tableaux à une ligne ou à une colonne. Les
matrices qui sont des tableaux ayant plusieurs lignes et colonnes. Une variable Matlab est donc
toujours un tableau que l’on appelle variable scalaire, vecteur ou matrice suivant la forme du
LM
tableau.
2.1 Les types de données

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.
Le type de variable est déterminé automatiquement à partir de l’expression mathématique ou à
partir valeurs affectées à la variable. Par exemple les instructions x = 2 ; z = 2+i ; r = ’oui’ ;
définissent une variable x de type réel, une variable z de type complexe et une variable r de type
chaîne de caractères.
>> x = 2 ; z = 2+i ; r = 'oui' ;
>> whos
Name Size Bytes Class Attributes
r 1x3 6 char
x 1x1 8 double
z 1x1 16 double complex
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.
- ischar retourne 1 si x est de type chaîne de caractères et 0 sinon.
- islogical retourne 1 si x est de type logique et 0 sinon.
20
- 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).
>> ischar(r) >> isreal(x)
ans = ans =
logical logical
1 1
>> ischar(x)
ans = >> isreal(r)
logical ans =
0 logical
>> isreal(z) 1
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.
A
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
LM
la partie réelle de z.
Les instructions abs(z) et angle(z) retournent le module et l’argument de z.
Notes :
- Il faut s’assurer que les identificateurs i et j ne sont pas réservés, car il est possible que des
variables de noms i et j aient été redéfinies au cours d’un calcul antérieur et soient toujours
actives. Si c’est le cas, on peut :
- soit effacer ces deux variables (clear i j), i et j redeviennent alors l’unité imaginaire,
- soit réaffecter à i ou à j la valeur unité imaginaire 𝑖 = √−1 par l’instruction i=sqrt(-1).
On se méfiera donc des boucles d’indices i et j dans lesquelles on manipule des variables de
type complexe.
- On fera également attention à ne pas laisser d’espace autour de l’unité imaginaire afin
d’éviter de mauvaises interprétations des données dans certains cas.
>> z = [1+i, 2, 3i]
z =
1.0000 + 1.0000i 2.0000 + 0.0000i 0.0000 + 3.0000i
>> z = [1+i, 2, 3 i]
z =
1.0000 + 1.0000i 2.0000 + 0.0000i 3.0000 + 0.0000i
0.0000 + 1.0000i
21
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
(‘ ’). Une variable de type chaîne de caractères étant interprétée comme un tableau de caractères,
il est possible de manipuler chaque lettre de la chaîne en faisant référence à sa position dans la
chaîne. La concaténation de chaînes de caractères s’effectue selon les règles de manipulation
des matrices, (voir le paragraphe 2.3.3).
L’exemple suivant présente différentes manipulations d’une chaîne de caractères.
>> 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] A >> 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é
LM
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.
22
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) 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
2.1.4 Notes sur les variables dans Matlab

- Toutes les variables dans MATLAB sont des tableaux. Un scalaire est un tableau avec un
élément, un vecteur est un tableau avec une ligne ou une colonne d'éléments, et une matrice
est un tableau avec des éléments en lignes et en colonnes.
- La variable (scalaire, vectorielle ou matrice) est définie par l'entrée lorsque la variable est
A
affectée. Il n'est pas nécessaire de définir la taille du tableau (élément unique pour un
scalaire, une ligne ou une colonne d'éléments pour un vecteur, ou tableau bidimensionnel
d'éléments pour une matrice) avant que les éléments ne soient attribués.
LM
- Une fois qu'une variable existe (en tant que scalaire, vecteur ou matrice), elle peut être
remplacée par n'importe quelle autre taille ou type de variable. Par exemple, un scalaire
peut être changé en vecteur ou en matrice ; un vecteur peut être changé en un scalaire, un
vecteur de longueur différente ou une matrice ; et une matrice peut être modifiée pour avoir
une taille différente, ou être réduite à un vecteur ou à un scalaire. Ces modifications sont
effectuées en ajoutant ou en supprimant des éléments. Ce sujet est traité dans les sections
2.10 et 2.11
2.2 Fonctions mathématiques élémentaires intégrées

En plus des opérations arithmétiques de base, les expressions dans MATLAB peuvent inclure
des fonctions. MATLAB possède une très grande bibliothèque de fonctions intégrées. Une
fonction a un nom et un argument entre parenthèses. Par exemple, la fonction qui calcule la
racine carrée d'un nombre est sqrt (x). Son nom est sqrt et l'argument est x. Lorsque la fonction
est utilisée, l'argument peut être un nombre, une variable à laquelle une valeur numérique a été
attribuée (expliquée à la section 2.3) ou une expression calculable qui peut être composée de
nombres et/ou de variables. Les fonctions peuvent également être incluses dans les arguments,
23
ainsi que dans les expressions. L’exemple suivant montre l'utilisation de la fonction sqrt (x)
lorsque MATLAB est utilisé comme calculatrice avec des scalaires.
>> sqrt(64)
ans = L'argument est un nombre
8
>> sqrt(50+14*3)
ans = L'argument est une expression
9.5917
>> sqrt(54+9*sqrt(100))
ans = L'argument comprend une fonction
12
>> (15+600/4)/sqrt(121)
ans = La fonction est incluse dans une expression
15
Certaines fonctions mathématiques élémentaires MATLAB couramment utilisées sont données

dans les tableauxTableau 2.1,Tableau 2.2 etTableau 2.3. Une liste complète des fonctions
organisées par catégorie se trouve dans la fenêtre d'aide.
Pour obtenir les informations concernant :
-
-
help elfun (voir annexe 1),
A
les fonctions mathématiques élémentaires, entrez dans la fenêtre de commandes >>
les fonctions mathématiques spécialisées, entrez dans la fenêtre de commandes >>

LM
help specfun (voir annexe 2).
Fonction Description Exemple

sqrt(x) Racines carrées >> sqrt(81)
ans =
9
nthroot(x,n) 𝑛
Racine nième réelle d'un nombre réel x : ( √𝑥 ) >> nthroot(80,5)
ans =
(Si x est négatif, n doit être un entier impair) 2.4022
exp(x) Exponentiel (𝑒 𝑥 ) >> exp(5)
ans =
148.4132
abs(x) Valeur absolue >> abs(-24)
ans =
24
log(x) Un algorithme népérien (ou naturel). Logarithme >> log(1000)

(ln) de base e ans =
6.9078
log10(x) Logarithme de base 10 >> log10(1000)

ans =
3
factorial(x) La fonction factorielle x! >> factorial(5)
(x doit être un entier positif) ans =
120
24
Tableau 2.1 - Fonctions mathématiques élémentaires

sin(x) Sinus d'angle x (x en radians) >> sin(pi/6)
sind(x) Sinus d'angle x (x en degrés) ans =
0.5000
>> sind(30)
ans =
0.5000
cos(x) Cosinus d'angle x (x en radians) >> cosd(30)
cosd(x) Cosinus de l'angle x (x en degrés) ans =
0.8660
tan(x) Tangente de l'angle x (x en radians) >> tan(pi/6)
tand(x) Tangente de l'angle x (x en degrés) ans =
0.5774
cot(x) Cotangent of angle x (x in radians) >> cotd(30)
cotd(x) Cotangent of angle x (x in degrees) ans =
1.7321
Tableau 2.2 - Fonctions mathématiques trigonométriques

Les fonctions trigonométriques inverses sont asin (x), acos (x), atan (x), acot (x) pour l'angle
en radians; et asind (x), acosd (x), atand (x), acotd (x) pour l'angle en degrés. Les fonctions
Fonction
round(x)
Description
A
trigonométriques hyperboliques sont sinh (x), cosh (x), tanh (x) et coth (x).
Arrondir vers l'entier le plus proche.

Exemple
>> round(17/5)
LM
Exemple : round (3.4) => 3, round (3.5) => 4 ans =
3
fix(x) Arrondi par défaut un réel positif et par excès un >> fix(13/5)
réel négatif. ans =
Exemple : fix (3.9) => 3, fix (-3.9) => -3 2
ceil(x) Arrondi par excès vers le nombre entier >> ceil(11/5)
supérieur. Exemple : ceil (3.1) => 4 ans =
3
floor(x) Arrondi par défaut vers le nombre entier >> floor(-9/4)
inférieur. Exemple : floor (3.9) => 3 ans =
-3
rem(x,y) Renvoie le reste après que x est divisé par y >> rem(13,5)
ans =
3
sign(x) Fonction Signum. Renvoie : >> sign(5)
1 si x>0, -1 si x<0 et 0 si x=0 ans =
1
Tableau 2.3 - Fonctions d'arrondi
2.3 Les variables scalaires

Une variable est un nom composé d'une lettre ou d'une combinaison de plusieurs lettres (et
chiffres) auxquels est affectée une valeur numérique. Une fois qu'une variable est affectée d'une
valeur numérique, elle peut être utilisée dans les expressions mathématiques, dans les fonctions
et dans toutes les instructions et commandes MATLAB. Une variable est en fait le nom d'un
25
emplacement mémoire. Lorsqu'une nouvelle variable est définie, MATLAB alloue un espace
mémoire approprié dans lequel l'affectation de la variable est stockée. Lorsque la variable est
utilisée, les données stockées sont utilisées. Si une nouvelle valeur est affectée à la variable, le
contenu de l'emplacement mémoire est remplacé.
2.3.1 L'opérateur d'affectation « = »

Dans MATLAB, le signe = est appelé l'opérateur d'affectation. L'opérateur d'affectation affecte
une valeur à une variable.
nom_variable = Une valeur numérique ou une expression calculable
- Le côté gauche de l'opérateur d'affectation ne peut inclure qu'un seul nom de variable. Le
côté droit peut être un nombre ou une expression calculable qui peut inclure des nombres et
/ ou des variables auxquels des valeurs numériques ont été précédemment attribuées.
Lorsque la touche Entrée est enfoncée, la valeur numérique du côté droit est affectée à la
variable et MATLAB affiche la variable et sa valeur affectée dans les deux lignes suivantes.
A
Ce qui suit montre le fonctionnement de l'opérateur d'affectation.
>> x=15 Le nombre 15 est affecté à la variable x

LM
x =
15 MATLAB affiche le nom de la variable et sa valeur
>> x=3*x-12 affectée
x = Une nouvelle valeur est affectée à x. La nouvelle valeur
33 est 3 fois la valeur précédente de x moins 12
- La dernière instruction (x=3*x-12) illustre la différence entre l'opérateur d'affectation et le

signe égal. Si dans cette déclaration le signe = signifiait égal, la valeur de x serait 6
(résolution de l'équation pour x). L'utilisation de variables précédemment définies pour
définir une nouvelle variable est illustrée ci-dessous.
>> a=12
a = Affecter 12 à la variable a
12
>> B=4 Affecter 4 à la variable B
B =
4
>> C=(a-B)+40-a/B*10 Attribuer la valeur de l'expression sur le
C = côté droit à la variable C
18
- Si un point-virgule « ; » est tapé à la fin de la commande, puis lorsque la touche Entrée est
enfoncée, MATLAB n'affiche pas la variable avec sa valeur assignée (la variable existe
toujours et est stockée en mémoire).
26
- Si une variable existe déjà, taper le nom de la variable et appuyer sur la touche Entrée
affichera la variable et sa valeur dans les deux lignes suivantes.
Par exemple, la dernière démonstration est répétée ci-dessous en utilisant des points-virgules.
>> a=12;
>> B=4; Les variables a, B et C sont définies mais ne
>> C=(a-B)+40-a/B*10; sont pas affichées, car un point-virgule est
>> C tapé à la fin de chaque instruction
C =
18
La valeur de la variable C est affichée en
tapant le nom de la variable puis Entrée
- Plusieurs affectations peuvent être saisies sur la même ligne. Les affectations doivent être
séparées par une virgule (des espaces peuvent être ajoutés après la virgule). Lorsque la
touche Entrée est enfoncée, les affectations sont exécutées de gauche à droite et les variables
et leurs affectations sont affichées. Une variable n'est pas affichée si un point-virgule est tapé
au lieu d'une virgule. Par exemple, les affectations des variables a, B et C ci-dessus peuvent
a =
12
A
toutes être effectuées sur la même ligne.
>> a=12, B=4; C=(a-B)+40-a/B*10;

La variable B n'est pas affichée car
LM
un point-virgule est tapé à la fin de
>> C l'affectation
C =
18
- Une variable qui existe déjà peut être réaffectée à une nouvelle valeur. Par exemple :
>> AB=109;
>> AB=7; Une valeur de 109 est affectée à la variable AB
>> AB Une nouvelle valeur de 7 est affectée à la variable AB
AB =
7
La valeur actuelle de la variable s'affiche lorsque le nom de la
variable est tapé et que la touche Entrée est enfoncée
- 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.3.2 Règles sur les noms de variables

Une variable peut être nommée en respectant les règles suivantes :
27
- 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.
2.3.3 Mots clés prédéfinis
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:
A
break case catch classdef continue else elseif end for
function global if otherwise parfor persistent return
spmd switch try while
LM
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)
2.4 Les vecteurs

Dans MATLAB, un vecteur est créé en affectant les éléments du vecteur à une variable. Cela
peut se faire de plusieurs manières en fonction de la source des informations utilisées pour les
éléments du vecteur. Lorsqu'un vecteur contient des nombres spécifiques connus, la valeur de
chaque élément est entrée directement. Chaque élément peut également être une expression
mathématique qui peut inclure des variables, des nombres et des fonctions prédéfinis.
2.4.1 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 ]
- Vecteur ligne : pour créer un vecteur de ligne, tapez les éléments avec un espace ou une
virgule entre les éléments entre crochets.
28
- Vecteur colonne : pour créer un vecteur colonne, saisissez le crochet gauche [ puis entrez
les éléments avec un point-virgule « ; » entre eux, ou appuyez sur la touche Entrée après
chaque élément. Tapez le crochet droit ] après le dernier élément.
On peut obtenir la longueur d’un vecteur v par la commande length(v).
L’exemple suivant montre comment créer des vecteurs ligne et colonne.
>> v1 =[1 2.5 pi]

v1 = Vecteurs lignes dont les éléments sont
1.0000 2.5000 3.1416
rangés entre crochets et séparés d’un
espace pour v1 et d’une virgule pour v2.
Le dernier élément est la constante
>> v2 = [1, 2.5, pi]
v2 =
prédéfinie π, représentée par « pi »
1.0000 2.5000 3.1416
>>v3=[1;sqrt(2);cos(1-2*sin(pi/4))]
v3 = Vecteurs colonnes dont les éléments sont
1.0000 rangés entre crochets et espacés d’un point-
1.4142 virgule « ; » pour v3 saisi un par un avec un
0.9154 point-virgule et Entrée à la fin de chacun
>> v4 = [1.0;
sqrt(2.0); pour v4.
cos(1-2*sin(pi/4))] A Les éléments des vecteurs peuvent contenir
v4 = des opérations et des fonctions
1.0000 mathématiques
1.4142
0.9154
>> v4’
LM
v4 = v4’ est la transposée du vecteur v4
1.0000 1.4142 0.9154
Un vecteur ligne est converti en vecteur colonne et réciproquement à l'aide de l'opérateur de

transposition. L'opération de transposition est indiquée par une apostrophe « ’ ».
2.4.2 Création d'un vecteur à espacement constant

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]
Ou : Les crochets [ ] sont facultatifs
nom_variable = d:p:f
Remarques :
- Si le pas p est négligé (ex : nom_variable = d:f), la valeur par défaut est 1.
29
- 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.
Quelques exemples de création de vecteurs à espacement constant sont illustrés ci-dessous :
>> v1 =[0:1:6]
v1 =
0 1 2 3 4 5 6
>> v2 =0:1:6
Les crochets [ ] sont facultatifs
V2 =
0 1 2 3 4 5 6
>> v3=-3:3
V3 = Si l'espacement n’est pas précisé, la
-3 -2 -1 0 1 2 3 valeur par défaut est 1
>> v4 =0:2:10
V4 = Le dernier élément du vecteur sera
0 2 4 6 8 10
le dernier nombre qui ne dépasse
>> v5 =0:3:10
V5 = pas f
0 3 6 9
>> v6=0:0.1:0.4
V6 =
0 0.1000 0.2000
>> v7=0:1/10:0.4
V7 =
0 0.1000 0.2000
A
0.3000
0.3000
0.4000
0.4000
Le début, le pas et la fin du vecteur
peuvent être définit par des expressions
mathématiques ou des commandes
LM
>> v8=21:-3:pi
V8 = La valeur de l’espacement peut être
21 18 15 12 9 6 négative
Bien entendu, il est possible de mixer différentes formes d'initialisation, comme le montre
l'exemple suivant :
>> v9=[1 2 4:6 5:0.1:5.5]
v = Colonnes 1 à 8
Columns 1 through 8
1.0000 2.0000 4.0000 5.0000 6.0000 5.0000 5.1000 5.2000
Columns 9 through 11 Colonnes 9 à 11
5.3000 5.4000 5.5000
- 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 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).
30
nom_variable = linspace(xi,xf,n)
Si « n » n’est pas défini, le nombre
Ou : d’éléments par défaut est de 100
points régulièrement espacés entre
nom_variable = linspace(xi,xf) xi et xf.
Bien entendu, 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).
>> v1=linspace(0,6,5)
v1 = 5 éléments, premier élément 0,
0 1.5000 3.0000 4.5000 6.0000 dernier élément 6
>> v2=linspace(6,0,5)
v2 = 5 éléments, premier élément 6, dernier
6.0000 4.5000 3.0000 1.5000 0 élément 0 (vecteur décroissant)
>> v3=linspace(0.5,3,5)
v3 = 5 éléments, premier élément 0.5,
0.5000 1.1250 1.7500 2.3750 3.0000 dernier élément 3
>> v4=linspace(-3,3,4) A
v4 = 4 éléments, premier élément -3,
-3 -1 1 3 dernier élément 3
>> v5=linspace(0,10)
v5 =
Columns 1 through 5
LM
0 0.1010 0.2020 0.3030 0.4040 100 éléments (n : non spécifié),
... premier élément 0, dernier élément 10
Columns 97 through 100
9.6970 9.7980 9.8990 10.0000
>> y = linspace(1+2i,10+5i,3)
Vecteur de nombres complexes
y = de 3 é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
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)
(si n =5.9, linspace renvoie 5 éléments.
31
- 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
Ou : d’éléments par défaut est de 50
points logarithmiquement espacés
nom_variable = logspace(a,b) entre les décades 10^a et 10^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).
>> v1=logspace(0,3,5)
v1 = 5 éléments, logarithmiquement
1.00 5.62 31.62 177.83 1000.00 espacés entre 10^0 et 10^3
>> v2=logspace(3,0,5)
V2 =
1000.00 177.83 31.62 5.62 1.00
>> v3 = logspace(0.1,pi,4)
A 5 éléments, logarithmiquement
espacés entre 10^3 et 10^0
LM
V3 = 4 éléments, logarithmiquement
1.26 1.71 2.32 3.14 espacés entre 10^0.1 et π
>> v4=logspace(0.1,pi)
v4 = 50 éléments (n : non spécifié),
Columns 1 through 5
logarithmiquement espacés entre
1.26 1.28 1.31 1.33 1.36
... 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)
V5 = Vecteur de nombres complexes
-6.682+7.4398i -30.093-9.7156i -10.701-99.426i de 3 éléments :
logarithmiquement espacés entre
10^(1+1i) et 10^(2+2i)
2.5 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 :
32
7 4 9
[3 8 1]
6 5 2
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 :
31 26 14 18 5 30
[3 51 20 11 43 65]
28 6 15 61 43 22
Matrice (3 x 6) a trois lignes et six colonnes. Pour une matrice a m lignes et n colonnes, (m par
n) est appelée la taille de la matrice.
2.5.1 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. A
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]
LM
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 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
Un point-virgule est tapé avant
4 76 81 l'entrée d'une nouvelle ligne
21 32 40
>> a=[5 35 43
4 76 81
21 32 40] La touche Entrée est enfoncée
a = avant l'entrée d'une nouvelle
5 35 43
4 76 81 ligne
21 32 40
>> c=6; e=3; h=4;
>> Mat=[e, c*h, cos(pi/3); h^2,... Trois variables sont définies
sqrt(h*h/c), 14]
Mat = Les éléments sont définis par des
3 24 0.5 expressions mathématiques
16 1.633 14
33
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=[1:2:11; 0:5:25; 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] 4A 5 6 2 5 8
v2 = 7 8 9 3 6 9
4 5 6
>> v3=[7 8 9] Concaténation par ligne en Concaténation par
v3 = utilisant l’opérateur : « ; » colonne en utilisant
7 8 9 l’opérateur espace
LM
2.5.2 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. Les commandes zeros(m, n) et ones(m, n) créent
une matrice avec m lignes et n colonnes dans lesquelles tous les éléments sont les nombres 0 et
1, respectivement. La commande 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é. La commande
magic(n) permet d’obtenir une matrice magique de dimension n x n (avec n≥3). Voici des
exemples :
>> zr=zeros(3,4)
zr =
0 0 0 0 Matrice nulle 3 x 4
0 0 0 0
0 0 0 0
>> un=ones(4,3)
un =
1 1 1
1 1 1 Matrice 4 x 3 dont tous les
1 1 1 éléments valent 1
1 1 1
34
>> idn=eye(4)
idn =
1 0 0 0
0 1 0 0 Matrice Identité (4 x 4)
0 0 1 0
0 0 0 1
>> magic(4)
ans = Matrice magique (4 x 4): la somme des
16 2 3 13 éléments de chaque colonne, de chaque
5 11 10 8
9 7 6 12 ligne et de chaque diagonale principale
4 14 15 1 sont identiques
Signalons que 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.
Des matrices peuvent également être créées à la suite d'opérations mathématiques avec des
vecteurs et des matrices. Ce sujet est traité dans le chapitre 3.
2.6 Opérateur de transposition «‘»

A
L'opérateur de transposition «‘ », lorsqu’il est appliqué à un vecteur, il bascule un vecteur
LM
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. Voici des exemples :
>> v1=[2 9 3]
v1 = Vecteur ligne v1
2 9 3
>> v2=v1'
v2 = Vecteur colonne v2 : transposé de v1
2
9
3
>> Mat1=[2 55 14 8; 21 5 32 11 ;...

41 64 9 1] Mat1 : Matrice avec 3 lignes et 4 colonnes
Mat1 =
2 55 14 8
21 5 32 11
41 64 9 1
>> Mat2=Mat1'
Mat2 = Mat2 : Matrice transposée de Mat1 avec 4
2 21 41 lignes et 3 colonnes
55 5 64
14 32 9
8 11 1
35
2.7 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. Par
exemple, si le vecteur v a neuf éléments :
v =[25 36 68 13 -5 4 71 -7 45]; Vecteur ligne contenant 9 éléments

>> v(2)
ans = Affiche le 2ème élément
36
>> v(5)
ans =
-5 A
>> v(9)
ans =
45
>> v(end)
ans = end : correspond au dernier élément du vecteur
LM
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) = valeur. Un seul élément peut
également être utilisé comme variable dans une expression mathématique. Voici des exemples:
>> A=v(4) Attribue la 4ème valeur du vecteur v à la variable A

A =
13
>> v(6)= 176 Attribue une nouvelle valeur au 6ème élément

v = et affiche le vecteur v complet
25 36 68 13 -5 176 71 -7 45
>> v(2)+v(8) Utilisation des éléments du vecteur v dans

ans = des opérations mathématiques
29
>> v(5)*v(8)+ sqrt(v(2))
ans =
41
36
- 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 :
3 11 6 5
𝑀=[4 7 10 2]
13 9 0 8
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. Certains
exemples sont :
>> M=[3 11 6 5; 4 7 10 2; 13 9 0 8]
M = Créer une matrice M (3 x 4)
3 11 6 5
4 7 10 2
13 9 0 8
>> M(3,1)=20
M =
20
3
4
11
7
9
6
10
0
5
2
8
A Attribuer une nouvelle valeur à
l'élément (3,1)
LM
>> M(2,4)-M(1,2)
ans = Utilisez des éléments dans une
-9 expression mathématique
2.8 Utilisation de l’opérateur « : » (deux-points) pour l'indexation

Un deux-points peut être utilisé pour adresser une gamme d'éléments dans un vecteur ou une
matrice.
- 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 = Un vecteur v de 9 éléments est créé
4 15 8 12 34 2 50 23 11
>> u=v(3:7)
u = Un vecteur u est créé à partir des
8 12 34 2 50 éléments 3 à 7 du vecteur v
- 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.
37
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.
L'utilisation du symbole deux-points « : » pour indexer les éléments des matrices est démontrée
dans l’exemple suivant :
>> 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 Créer une matrice A (5 x 6)
3 6 9 12 15 18
4 8 12 16 20 24
5 10 15 20 25 30
>> B=A(:,3)
B =
5 Définir un vecteur colonne B à partir
6 des éléments de toutes les lignes de la
9
12 3ème colonne de A
15
>> C=A(2,:)
C =
2 4
>> E=A(2:4,:)
E =
6 8 10
A 12
Définir un vecteur ligne C à partir des
éléments de toutes les colonnes de la
2ème ligne de A
Définir une matrice E à partir des

LM
2 4 6 8 10 12 éléments des lignes 2 à 4 et de toutes
3 6 9 12 15 18
4 8 12 16 20 24
les colonnes de A
>> F=A(1:3,2:4)
F = Définir une matrice F à partir des
3 5 7 éléments des lignes 1 à 3 et des
4 6 8
6 9 12
colonnes 2 à 4 de la matrice A
Dans l’exemple précédent, de nouveaux vecteurs et matrices sont créés à partir de ceux existants
en utilisant une plage d'éléments ou une plage de lignes et de colonnes (en utilisant « : »).
Cependant, 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, comme indiqué ci-
dessous :
>> v=4:3:34
v = Créer un vecteur v avec 11 éléments
4 7 10 13 16 19 22 25 28 31 34
>> u=v([3, 5, 7:10])
u = Créez un vecteur u à partir des 3e,
10 16 22 25 28 31 5e et 7e à 10e éléments de v
>>A=[10:-1:4; ones(1,7); 2:2:14; zeros(1,7)]
A = Créez une matrice A(4 x 7)
10 9 8 7 6 5 4
1 1 1 1 1 1 1
2 4 6 8 10 12 14
38
0 0 0 0 0 0 0
>> B = A([1,3],[1,3,5:7]) Créez une matrice B à partir des

B = 1ère et 3ème lignes, et des 1ère,
10 8 6 5 4 3ème et 5ème à 7ème colonnes de A
2 6 10 12 14
2.9 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 (rappelez-vous qu'un scalaire est un vecteur avec un élément). Un vecteur (une matrice
avec une seule ligne ou colonne) 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
A
é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
LM
se trouvent entre le dernier élément d'origine et le nouvel élément. Exemples :
>> v=1:4
v = Créer un vecteur v avec 4 éléments
1 2 3 4
>> v(5:10)=10:5:35
v = Ajout de 6 éléments en commençant par le 5
1 2 3 4 10 15 20 25 30 35
>> a=[5 7 2]
a = Créer un vecteur a avec 3 éléments
5 7 2
>> a(7)=4 Attribuer une valeur au 7ème élément
a = MATLAB attribue des zéros aux 4e au 6e éléments
5 7 2 0 0 0 4
Attribuer une valeur au 5ème élément d’un nouveau
>> a2(5)=24
a2 =
vecteur a2. MATLAB attribue des zéros aux 1er au
0 0 0 0 24 4e éléments
Des éléments peuvent également être ajoutés à un vecteur en ajoutant des vecteurs existants :
>> C=[3 8 1 24];

Créer un vecteur C avec 4 éléments
>> D=4:3:16;
Créer un vecteur D avec 5 éléments
>> Rh=[C D]
Rh = Créez un nouveau vecteur ligne Rh en ajoutant C et D
3 8 1 24 4 7 10 13 16
>> Rv=[C'; D']
Rv = Créez un nouveau vecteur colonne Rv en ajoutant C’et D’
3
39
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. Voici des exemples :
>> E=[1 2 3 4; 5 6 7 8]
E = Créez une matrice E (2 x 4)
1 2 3 4
5 6 7 8
>> E(3,:)=[10:4:22]
E = Ajoutez le vecteur 10 14 18 22
1 2 3 4 comme troisième ligne de E
5 6 7 8
10 14 18 22
>> K=eye(3)
K =
1
0
0
>> G=[E K]
0
1
0
0
0
1
A Créez une matrice identité K(3 x 3)
LM
G = Ajoutez la matrice K à la matrice E. Le
1 2 3 4 1 0 0 nombre de lignes dans E et K doit être le
5 6 7 8 0 1 0
même
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. Exemples :
>> A=[3 6 9; 8 5 11]

A =
3 6 9
Créez une matrice A (2 x 4)
8 5 11
>> A(4,5)=17
A = Attribuer une valeur à l’élément (4,5).
3 6 9 0 0 MATLAB modifie la taille de la matrice A à
8 5 11 0 0 4x5 et attribue des zéros aux nouveaux
0 0 0 0 0 éléments
0 0 0 0 17
>> B(3,4)=15
B = Attribuer une valeur à l’élément (3,4) d’une
0 0 0 0 nouvelle matrice B et attribue des zéros à tous
0 0 0 0
les éléments sauf B(3,4)
0 0 0 15
2.10 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.
40
En supprimant des éléments, un vecteur peut être raccourci et une matrice peut être réduite.
Voici des exemples :
>> k=[2 7 12 1 3 23 29 19 76 93]

k = Créez un vecteur k de 10 éléments
2 7 12 1 3 23 29 19 76 93
>> k(5)=[]
k = Éliminer le 5ème élément
2 7 12 1 23 29 19 76 93
>> k(3:6)=[]
k = Éliminer les éléments 3 à 6. Il reste 5 éléments
2 7 19 76 93
>> M=[5 78 4 24 9; 4 0 36 60 12; ...
56 13 5 89 3]
M = Créez une matrice M (3 x 5)
5 78 4 24 9
4 0 36 60 12
56 13 5 89 3
>> M(:,2:4)=[]
M =
5 9 Éliminez toutes les lignes des colonnes 2 à 4
4 12
56 3
2.11 Fonctions intégrées pour la manipulation des matrices
length(A)
Description
A
MATLAB possède de nombreuses fonctions intégrées pour gérer et manipuler les tableaux.
Certains d'entre elles sont énumérés ci-dessous :
Fonction Exemple
>> A=[5 9 2 4];
LM
Renvoie le nombre d'éléments dans le
length(A)
vecteur A ans =
4
size(A) Renvoie un vecteur ligne [m, n], où m et n >> A=[6 1 4 0 12; 5 19 6
8 2]
sont la taille (m * n) de la matrice A A =
6 1 4 0 12
5 19 6 8 2
>> size(A)
ans =
2 5
reshape(A,m,n) Crée une matrice m par n à partir des >> A=[5 1 6; 8 0 2]
A =
éléments de la matrice A. Les éléments sont 5 1 6
pris colonne après colonne. La matrice A 8 0 2
>> B =reshape(A,3,2)
doit avoir m fois n éléments B =
5 0
8 6
1 2
diag(v) Lorsque v est un vecteur, diag(v) crée une >> v=[7 4 2];
>> A=diag(v)
matrice carrée avec les éléments de v dans A =
la diagonale 7 0 0
0 4 0
0 0 2
diag(A) Lorsque A est une matrice, diag(A) crée un >> A=[1 2 3; 4 5 6;7 8 9]
A =
vecteur à partir des éléments diagonaux de 1 2 3
A 4 5 6
7 8 9
>> vec=diag(A)
vec =
41
1
5
9
Tableau 2.4 - Fonctions intégrées pour la gestion des tableaux
Il existe d’autres fonctions pour la manipulation des tableaux Par exemple, soit la matrice A :
9 1 2
𝐴 = [6 8 5]
3 7 4

sort Pour les vecteurs, sort (A) trie les éléments de A dans >> sort(A)
ans =
l'ordre croissant. 3 1 2
Pour les matrices, sort (A) trie chaque colonne de A 6 7 4
dans l'ordre croissant. 9 8 5
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) inverser l'ordre des éléments >> flip(A)
ans =
Pour les matrices, flip (A) inverse chaque colonne
A 3 7 4
verticalement 6 8 5
9 1 2
fliplr Retourner la matrice de gauche à droite >> fliplr(A)
ans =
2 1 9
5 8 6
LM
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 circulaire >> B = circshift(A,1)
B =
Pour les vecteurs, circshift (v,N) décale de façon 3 7 4
circulaire les éléments N fois 9 1 2
6 8 5
Pour les matrices, circshift (A,N) décale circulairement
les valeurs des colonnes vers le bas N fois
Tableau 2.5 - Fonctions intégrées supplémentaires pour la gestion des tableaux
Plus de détails sur les fonctions intégrées pour la manipulation des tableaux sont décrites dans
la fenêtre d'aide (Help Window).
42
Annexe 1 : Elementary math functions

>> help elfun Exponential.
Elementary math functions. exp - Exponential.
expm1 - Compute exp(x)-1 accurately.
Trigonometric. log - Natural logarithm.
sin - Sine. log1p - Compute log(1+x) accurately.
sind - Sine of argument in degrees. log10 - Common (base 10) logarithm.
sinh - Hyperbolic sine. log2 - Base 2 logarithm and dissect floating
asin - Inverse sine. point number.
asind - Inverse sine, result in degrees. pow2 - Base 2 power and scale floating point
asinh - Inverse hyperbolic sine. number.
cos - Cosine. realpow - Power that will error out on complex
cosd - Cosine of argument in degrees. result.
cosh - Hyperbolic cosine. reallog - Natural logarithm of real number.
acos - Inverse cosine. realsqrt - Square root of number greater than or
acosd - Inverse cosine, result in degrees. equal to zero.
acosh - Inverse hyperbolic cosine. sqrt - Square root.
tan - Tangent. nthroot - Real n-th root of real numbers.
tand - Tangent of argument in degrees. nextpow2 - Next higher power of 2.
tanh - Hyperbolic tangent.
atan - Inverse tangent. Complex.
atand - Inverse tangent, result in degrees. abs - Absolute value.
atan2 - Four quadrant inverse tangent. angle - Phase angle.
atan2d - Four quadrant inverse tangent, result in degrees. complex - Construct complex data from real and
atanh - Inverse hyperbolic tangent. imaginary parts.
sec - Secant. conj - Complex conjugate.
secd - Secant of argument in degrees.A imag - Complex imaginary part.
sech - Hyperbolic secant. real - Complex real part.
asec - Inverse secant. unwrap - Unwrap phase angle.
asecd - Inverse secant, result in degrees. isreal - True for real array.
asech - Inverse hyperbolic secant. cplxpair - Sort numbers into complex conjugate
csc - Cosecant. pairs.
cscd - Cosecant of argument in degrees.
LM
csch - Hyperbolic cosecant. Rounding and remainder.
acsc - Inverse cosecant. fix - Round towards zero.
acscd - Inverse cosecant, result in degrees. floor - Round towards minus infinity.
acsch - Inverse hyperbolic cosecant. ceil - Round towards plus infinity.
cot - Cotangent. round - Round towards nearest integer.
cotd - Cotangent of argument in degrees. mod - Modulus (signed remainder after
coth - Hyperbolic cotangent. division).
acot - Inverse cotangent. rem - Remainder after division.
acotd - Inverse cotangent, result in degrees. sign - Signum.
acoth - Inverse hyperbolic cotangent.
hypot - Square root of sum of squares.
deg2rad - Convert angles from degrees to radians.
rad2deg - Convert angles from radians to degrees.
43
Annexe 2 : Specialized math functions
>> help specfun Number theoretic functions.

Specialized math functions. factor - Prime factors.
isprime - True for prime numbers.
Specialized math functions. primes - Generate list of prime numbers.
airy - Airy functions. gcd - Greatest common divisor.
besselj - Bessel function of the first kind. lcm - Least common multiple.
bessely - Bessel function of the second kind. rat - Rational approximation.
besselh - Bessel functions of the third kind (Hankel rats - Rational output.
function). perms - All possible permutations.
besseli - Modified Bessel function of the first kind. nchoosek - All combinations of N elements taken K at
besselk - Modified Bessel function of the second kind. a time.
beta - Beta function. factorial - Factorial function.
betainc - Incomplete beta function.
betaincinv - Inverse incomplete beta function. Coordinate transforms.
betaln - Logarithm of beta function. cart2sph - Transform Cartesian to spherical
ellipj - Jacobi elliptic functions. coordinates.
ellipke - Complete elliptic integral. cart2pol - Transform Cartesian to polar coordinates.
erf - Error function. pol2cart - Transform polar to Cartesian coordinates.
erfc - Complementary error function. sph2cart - Transform spherical to Cartesian
erfcx - Scaled complementary error function. coordinates.
erfinv - Inverse error function. hsv2rgb - Convert hue-saturation-value colors to red-
erfcinv - Inverse complementary error function. green-blue.
expint - Exponential integral function. rgb2hsv - Convert red-green-blue colors to hue-
gamma - Gamma function. saturation-value
gammainc - Incomplete gamma function.
gammaln - Logarithm of gamma function.

psi - Psi (polygamma) function.
legendre - Associated Legendre function.
cross
dot
- Vector cross product.
- Vector dot product.
A
gammaincinv - Inverse incomplete gamma function.
LM
.
44

Chapitre 2 Les Types de Données Et Variables: Table Des Matières

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 2 Les Types de Données Et Variables: Table Des Matières

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre 2 Les types de données et variables

Table des matières

Chapitre 2 Les types de données et variables ........................................................................... 19

2.1 Les types de données

2.1.1 Le type complexe

2.1.2 Le type chaîne de caractères

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

2.1.3 Le type logique

2.1.4 Notes sur les variables dans Matlab

2.2 Fonctions mathématiques élémentaires intégrées

Certaines fonctions mathématiques élémentaires MATLAB couramment utilisées sont données

les fonctions mathématiques spécialisées, entrez dans la fenêtre de commandes >>

Fonction Description Exemple

log(x) Un algorithme népérien (ou naturel). Logarithme >> log(1000)

log10(x) Logarithme de base 10 >> log10(1000)

Tableau 2.1 - Fonctions mathématiques élémentaires

Fonction Description Exemple

Tableau 2.2 - Fonctions mathématiques trigonométriques

Arrondir vers l'entier le plus proche.

Tableau 2.3 - Fonctions d'arrondi

2.3 Les variables scalaires

2.3.1 L'opérateur d'affectation « = »

nom_variable = Une valeur numérique ou une expression calculable

>> x=15 Le nombre 15 est affecté à la variable x

- La dernière instruction (x=3*x-12) illustre la différence entre l'opérateur d'affectation et le

>> a=12, B=4; C=(a-B)+40-a/B*10;

2.3.2 Règles sur les noms de variables

- Doit commencer par une lettre.

2.3.3 Mots clés prédéfinis

2.4 Les vecteurs

2.4.1 Création d'un vecteur à partir d'une liste de nombres connue

nom_variable = [ les éléments du vecteur ]

>> v1 =[1 2.5 pi]

Un vecteur ligne est converti en vecteur colonne et réciproquement à l'aide de l'opérateur de

2.4.2 Création d'un vecteur à espacement constant

Ou : Les crochets [ ] sont facultatifs

- Le pas peut être un nombre décimal, positif ou négatif.

- Générer un vecteur espacé linéairement

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

- Générer un vecteur espacé logarithmiquement

2.5 Les matrices

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

2.6 Opérateur de transposition «‘»

>> Mat1=[2 55 14 8; 21 5 32 11 ;...

v =[25 36 68 13 -5 4 71 -7 45]; Vecteur ligne contenant 9 éléments

>> A=v(4) Attribue la 4ème valeur du vecteur v à la variable A

>> v(6)= 176 Attribue une nouvelle valeur au 6ème élément

>> v(2)+v(8) Utilisation des éléments du vecteur v dans

2.8 Utilisation de l’opérateur « : » (deux-points) pour l'indexation

- Pour une matrice :

Définir une matrice E à partir des

>> B = A([1,3],[1,3,5:7]) Créez une matrice B à partir des

2.9 Ajouter des éléments aux variables existantes

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

>> C=[3 8 1 24];

>> A=[3 6 9; 8 5 11]

2.10 Supprimer des éléments

>> k=[2 7 12 1 3 23 29 19 76 93]

2.11 Fonctions intégrées pour la manipulation des matrices

Tableau 2.4 - Fonctions intégrées pour la gestion des tableaux

Fonction Description Exemple

Annexe 1 : Elementary math functions

Annexe 2 : Specialized math functions