Cours Mat Lab 2022

Introduction à Matlab
Pr. Oussama Bourihane
Septembre 2022
2
Table des matières
1 Premiers pas avec l’environnement Matlab 1

1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 L’environnement Matlab . . . . . . . . . . . . . . . . . . . . . . . . 1
1.3 La Calculatrice Matlab . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.4 Expressions logiques et opérateurs . . . . . . . . . . . . . . . . . . . . 6
1.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2 Variables et structures de données 11

2.1 Variables et affectation . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Tableaux de doubles . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.3 Tableau de suites équidistantes . . . . . . . . . . . . . . . . . . . . . 16
2.4 Indexation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.5 Arithmétique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.6 Chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.7 Tableaux de structures . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.8 Tableau de cellules . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.9 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3 Scripts et Fonctions 39
3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.2 M-files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.2.1 Fichiers Script . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.2.2 Fichiers de type Fonction . . . . . . . . . . . . . . . . . . . . . 42
3.3 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.3.1 Principes de base d’une fonction . . . . . . . . . . . . . . . . . 44
3.3.2 Espace de travail des fonctions . . . . . . . . . . . . . . . . . . 49
3.3.3 Chemin de Matlab . . . . . . . . . . . . . . . . . . . . . . . 52
3.3.4 Sous-fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.3.5 Fonctions de manipulation . . . . . . . . . . . . . . . . . . . . 55
3.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4 Boucles et contrôle de flux 61

4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.2 Conditions : Instructions de branchement . . . . . . . . . . . . . . . . 61
4.2.1 Condition ’if’ . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.2.2 Condition ’switch’ . . . . . . . . . . . . . . . . . . . . . . . . . 67
i
ii TABLE DES MATIÈRES
4.3 Boucles : Itérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

4.3.1 Boucles finies . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.3.2 Boucles imbriquées . . . . . . . . . . . . . . . . . . . . . . . . 72
4.3.3 Boucle indéfinie . . . . . . . . . . . . . . . . . . . . . . . . . . 73
4.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
5 Visualisation et traçage 79
5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
5.2 Graphique 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
5.3 Graphique 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
5.3.1 Courbes paramétriques . . . . . . . . . . . . . . . . . . . . . . 85
5.3.2 Surfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
5.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Chapitre 1
Premiers pas avec l’environnement

Matlab
1.1 Introduction
Ce chapitre vous permet de démarrer avec le logiciel Matlab, en l’utilisant
comme calculatrice. Comme vous le verrez, Matlab possède une grande biblio-
thèque de fonctions mathématiques intégrées que vous pouvez utiliser pour effectuer
toute opération disponible sur une calculatrice scientifique ou graphique. À la fin de
ce chapitre, vous devez être familiarisés avec l’environnement Matlab, la manière
d’exécuter des commandes dans Matlab et les fonctionnalités mathématiques de
base de Matlab.
1.2 L’environnement Matlab

L’environnement Matlab est un outil de visualisation textuel qui vous per-
met d’interagir avec Matlab en question-repense. Cet environnement est constitué
d’une bande d’outils (toolstrip), le répertoire actuel (Current Folder) ainsi que trois
fenêtres : Fenêtre de commande (Command Window), Fenêtre du répertoire actuel
(Current Folder Window) et l’espace de travail (Workspace).
Le répertoire actuel est le dossier de votre ordinateur où les fichiers seront
enregistrés et où les fichiers auxquels vous aurez un accès direct sont stockés. Vous
pouvez modifier le répertoire actuel en cliquant sur la flèche vers le bas ou sur le
bouton avec un symbole de dossier plus flèche verte. Le répertoire courant sera
expliqué plus en détail à la section 4 de ce chapitre qui porte sur les fonctions.
La fenêtre de commande est la fenêtre de l’environnement Matlab où les
commandes sont exécutées et les réponses de Matlab sont affichées. L’invite de
commande est l’endroit où vous pouvez taper vos commandes dans la fenêtre de
commande et est indiquée par le symbole >>. Lorsque vous voyez ce symbole dans
le texte ou dans des exemples, cela signifie que l’action se déroule dans la fenêtre de
commande. La fenêtre du répertoire courant est la fenêtre de l’environnement
Matlab qui liste tous les fichiers actuellement stockés dans le répertoire courant.
La fenêtre de l’espace de travail est la fenêtre de l’environnement Mat-
1
2 CHAPITRE 1. Premiers pas avec l’environnement Matlab
Figure 1.1 – Interface graphique de l’environnement Matlab R2017a
lab qui liste toutes les variables actuellement utilisées dans l’espace de travail. Les
détails de l’espace de travail seront également expliqués à la section 4 sur les fonc-
tions. Dans les versions antécédentes, une fenêtre appelée fenêtre d’historique des
commandes (command history window) était comme un répertoire de toutes
les commandes précédentes exécutées à l’invite de commandes, ce qui est utile pour
rappeler le travail effectué lors d’une session précédente. Dans les nouvelles versions,
il suffit de cliquer sur la flèche HAUT du clavier afin d’afficher cette fenêtre cachée.
Vous pouvez réorganiser la taille et la forme de chaque fenêtre en cliquant et en
maintenant le curseur de la souris sur les bordures des fenêtres, puis en les faisant
glisser vers un emplacement qui vous convient le mieux. Vous pouvez également mo-
difier l’emplacement des fenêtres en cliquant et en maintenant le curseur de la souris
sur la barre de titre de la fenêtre et en le faisant glisser vers un autre emplacement. Si
vous souhaitez supprimer une fenêtre, cliquez sur le symbole de triangle dans le coin
supérieur droit de la fenêtre et choisir fermer. Pour le remettre, cliquez sur l’icône
Layout sur la bande d’outils puis cochez la fenêtre souhaitée. Vous pouvez changer
la couleur d’arrière-plan ainsi que la couleur et le style de police en fonction de vos
préférences personnelles. Les options peuvent être modifiées dans l’icône Préférences
sur la bande d’outils.
1.3 La Calculatrice Matlab

Nous vous présenterons Matlab dans cette section en démontrant les fonc-
tionnalités de n’importe quelle calculatrice graphique standard. Une opération
arithmétique est soit l’addition, la soustraction, la multiplication, la division ou
les puissances entre deux nombres. Un opérateur arithmétique est un symbole
que Matlab a réservé pour désigner l’une des opérations susmentionnées. Ces sym-
boles sont + pour l’addition, − pour la soustraction, ∗ pour la multiplication, / pour
la division et ∧ pour l’exponentiation.
Une instruction ou une opération est dite exécutée lorsqu’elle est résolue par
1.3. LA CALCULATRICE MATLAB 3
l’ordinateur. Une instruction est exécutée à l’invite de commande en la tapant là où

vous voyez le symbole >>, puis en appuyant sur Entrée.
Essayer ! : Calculer la somme de deux entiers

>> 15 + 28
ans =
43
Les opérations ont un ordre de priorité standard que différentes opérations ont
les unes par rapport aux autres. Matlab utilise le même ordre d’opérations que vous
avez appris à l’école primaire. Les puissances sont exécutées avant la multiplication
et la division, qui sont exécutées avant l’addition et la soustraction. Les parenthèses,
(), peuvent également être utilisées dans Matlab pour imposer un ordre autre que
l’ordre standard des opérations. Dans le cas de deux opérations ayant le même ordre
de priorité, Matlab commence de gauche à droite.
Essayer ! : Calculer (40/5) × (5 × 23 + 4)/(2 + 3)

>> 40/5∗(5∗2ˆ3+4)/(2+3)
ans =
70.4000
Remarquez que Matlab stock la valeur de l’exécution de chaque commande

dans la variable ans. Cette variable peut être réutilisée pour la prochaine opération.
Essayer ! : Calculer le produit précédent d’une autre façon !

>> 40/5∗(5∗2ˆ3+4)
ans =
352
>> ans /(2+3)
ans =
70.4000
Matlab possède de nombreuses fonctions arithmétiques de base, telles que :

sin, cos, tan, asin, acos, atan, exp, log, log10 et sqrt. Les entrées de ces fonctions
mathématiques sont toujours placées entre parenthèses liées au nom de la fonction.
Pour les fonctions trigonométriques, il est utile d’avoir la valeur de π facilement
disponible. Vous pouvez appeler cette valeur à tout moment en tapant >> pi dans
l’invite de commande. Notez que la valeur de π est stockée dans Matlab à 16
chiffres après la virgule.
Essayer ! : Utiliser des fonction prédéfinis :

>> sqrt(25)
ans =
5
>> sin(pi/2)
ans =
1
Astuce ! : Parfois, vous souhaiterez peut-être afficher plus ou moins de

chiffres que le nombre par défaut de Matlab de quatre décimales. Il existe de
nombreuses options d’affichage des nombre dans Matlab, mais pour les besoins
de ce texte, nous limiterons ces options à « short », « long » et « banque
». Le format short est le paramètre par défaut de Matlab. Il affiche tous les
nombres jusqu’à quatre chiffres significatifs. Le format long affiche le nombre
maximum de chiffres que Matlab peut stocker, soit 16. Le format bank en
affiche exactement deux.
Essayer ! :
>> format long
>> pi
ans =
3.141592653589793
>> format bank

>> ans
ans =
3.14
>> format short

>> ans
ans =
3.1416
Astuce ! : L’utilisation de la flèche HAUT dans l’invite de commande rappelle

les commandes précédentes qui ont été exécutées. Si vous tapez par erreur une
commande de manière incorrecte, vous pouvez utiliser la flèche HAUT pour la
rappeler, puis la modifier au lieu de retaper toute la ligne.
La fonction help est une commande très intéressante qui peut être utilisée pour
afficher la description de n’importe quelle fonction dans Matlab. Vous pouvez ap-
peler la fonction d’aide en tapant >> help à l’invite de commande suivie du nom
de la fonction. Si vous voyez une fonction avec laquelle vous n’êtes pas familier, il est
recommandé d’utiliser la fonction d’aide avant de demander à quoi sert une fonction
spécifique.
1.3. LA CALCULATRICE MATLAB 5
Essayer ! : Utiliser la commande

>> help cos
cos Cosine of argument in radians.
cos(X) is the cosine of the elements of X.
See also acos, cosd.
Reference page for cos

Other functions named cos
Matlab peut gérer l’expression 1/0, qui est l’infini : Inf ou −1/0 = −∞ −Inf.
Notez que Matlab renverra 0/0 comme n'est pas un nombre ou NaN. Vous pouvez
taper Inf à l’invite de commande pour désigner l’infini ou NaN pour désigner quelque
chose qui n’est pas un nombre et que vous souhaitez la traiter comme un nombre.
Enfin, Matlab
√ peut également gérer les nombres imaginaires, en utilisant la variable
i, qui est −1. √
Attention, la valeur −1 est stockée dans les variables i et j, mais si vous réutilisez
ces variables pour stocker une autre valeur vous allez écrasez leur valeur initiale.
Essayer ! : Calculer des valeurs infinies ou pas nombres.

>> 53 / 0
ans =
Inf
>> 3 + Inf
ans =
Inf
>> 2 / Inf
ans =
0
>> Inf/Inf
ans =
NaN
Essayer ! : Calculer des valeurs imaginaires.

>> sqrt(-4)
ans =
0.0000 + 2.0000i
Matlab peut également gérer la notation scientifique en utilisant la lettre e

entre deux nombres qui signifie ×10.
Essayer ! : Utiliser la notation scientifique pour le nombre 1537.5.

>> format shortG
>> 1.e3 + 5.e2 + 3.e1 + 7.e0 + 5.e-1

ans =
1537.5
1.4 Expressions logiques et opérateurs

Une expression logique (logical expression) est une déclaration qui peut être
vraie ou fausse. Par exemple, a < b est une expression logique. Il peut être vraie ou
fausse selon les valeurs de a et b données. Notez que cela diffère d’une expression
mathématique qui dénote une déclaration de vérité. Dans l’exemple précédent, l’ex-
pression mathématique a < b signifie que a est inférieur à b, et les valeurs de a et b
où a ≥ b ne sont pas autorisées. Les expressions logiques forment la base du calcul,
donc toutes les déclarations sont supposées être logiques plutôt que mathématiques,
sauf indication contraire.
Dans Matlab, une expression logique qui est vraie sera calculée à la valeur «
TRUE ». Une fausse expression calculera la valeur « FALSE ». Pour les convention
de Matlab, « TRUE » est équivalent à 1 et « FALSE » est équivalent à 0. Les ex-
pressions logiques sont utilisées pour poser des questions à Matlab. Par exemple,
l’expression 3 < 4 est équivalente à « 3 est-il inférieur à 4 ? », tant que cette décla-
ration est vraie, Matlab la calculera comme 1. Cependant, 3 > 4 est faux, donc
Matlab la calculera comme 0.
Les opérateurs de comparaison (Comparison operators) comparent la valeur
de deux nombres et sont utilisés pour créer des expressions logiques. Matlab réserve
les symboles >, >=, <, <=, ∼=, == pour désigner supérieur à, supérieur ou égal,
inférieur à, inférieur ou égal, différent de et égal, respectivement.
Essayer ! : Obtenir des expressions logiques.

>> (2 + 3) == 5
ans =
logical
1
>> (7 + 8) < (9 + 3)
ans =
logical
0
A noter ! : Les opérateurs de comparaison :

1.4. EXPRESSIONS LOGIQUES ET OPÉRATEURS 7
Opérateur Signification
> Supérieur
>= Supérieur ou égal
< inférieur
<= inférieur ou égal
== Égal
∼= Différent de
Attention ! :
L’opérateur ′ =′ avec un seul symbol est un opérateur d’affectation.
Les opérateurs logiques (Logical operators) sont des opérations entre deux
expressions logiques que, pour des raisons de discussion, nous appelons P et Q.
Les opérateurs logiques fondamentaux que nous utiliserons ici sont AND, OR et
NOT, qui sont notés dans Matlab par &&, ||, et ∼ , respectivement. Il existe
d’autres opérateurs logiques, mais ils sont équivalents à des combinaisons de ces
trois opérateurs. P AND Q n’est vraie que si P et Q sont toutes les deux vraies. P
OR Q est vraie si une des deux expressions P ou Q est vraie ou si P et Q sont vraies
toutes les deux. Il est important de noter que OR dans Matlab est une inclusif
OR, ce qui signifie qu’il est vrai si P et Q sont tous deux vrais aussi. En revanche,
exclusif OR ou XOR est vraie si P ou Q est vraie, mais fausse si P et Q sont
toutes les deux vraies. Si P est vraie, alors NOT P est fausse, et si P est fausse,
alors NOT P est vraie.
Essayer ! : Utiliser des opérateurs logiques.

>> (1 == 0) && (3 < 7)
ans =
logical
0
>> (2 < 5) && (9 == 4 + 5)
ans =
logical
1
>> (3 ≤ 1) || ∼(3 ∼= 1)
ans =
logical
0
Tout comme les opérateurs arithmétiques, les opérateurs logiques ont un ordre
d’opérations les uns par rapport aux autres et par rapport aux opérateurs arith-
métiques. Toutes les opérations arithmétiques seront exécutées avant les opérations
de comparaison, qui seront exécutées avant les opérations logiques. Les parenthèses
peuvent être utilisées pour modifier l’ordre des opérations.
Même lorsque l’ordre des opérations est connu, il est généralement utile pour vous
et ceux qui lisent votre code d’utiliser des parenthèses pour rendre vos intentions
plus claires.
Essayer ! : Tester l’effet de l’ordre des opérations.

>> 5 > 3 + 2 == 2
ans =
logical
0
>> (5>3) + (2 == 2)
ans =
2
Attention ! : Comme le montre l’exemple précédent, dans l’implémentation

logique de Matlab, 1 est utilisé pour indiquer vrai et 0 pour faux. Cependant,
1 et 0 sont toujours des nombres. Par conséquent, Matlab autorisera ce type
abus : 5 > 3 + 2 = 3 ! ! !
Attention ! : Bien qu’en logique formelle, 1 soit utilisé pour indiquer vrai et
0 pour indiquer faux, Matlab abuse légèrement de la notation et prendra tout
nombre différent de 0 comme vrai logique lorsqu’il est utilisé dans une opération
logique. Par exemple, 3 && 1 sera calculé vrai. N’utilisez pas cette fonctionnalité
de Matlab. Utilisez toujours 1 pour désigner une déclaration vraie.
1.5 Exercices
L’environnement Matlab
1. Depuis l’historique des commandes, exécuter respectivement les trois dernière
récentes commandes.
2. Redimensionner l’invite de commande d’une manière qui vous convient.
3. Dans l’anglet ’préférence’ choisir la taille de police que vous souhaitez ainsi
que la couleur de fond (Noir) et la couleur de police (Blanc).
4. Taper sur l’invite de commande >> travel et tester le programme Traveling
Salesman.
5. Taper sur l’invite de commande >> pdetool et tester l’outil de résolution des
équations aux dérivées partielles.
La Calculatrice Matlab
6. Calculez la surface d’un trapèze de base inférieure B = 6, base supérieure b = 4
et de hauteur h = 2. Rappelons que la surface d’un trapèze vaut : S = B+b 2
×h
7. Calculez la surface complète ainsi que le volume d’un cylindre de rayon r = 3
et hauteur h = 6.
8. Calculez la distance entre les points de coordonnées (2, 3), (1, 4).
9. Calculez la pente entre les deux dits points.
10. Calculez la valeur de 5! en utilisant la commande factorial.
1.5. EXERCICES 9
11. Écrivez une instruction Matlab qui génère l’erreur suivante :

Undefined function or variable ’arctan’.
conseil : arctan est une faute d’orthographe de la fonction Matlab atan.
12. Écrivez une instruction Matlab qui génère l’erreur suivante :
Error: Expression or statement is incorrect–possibly unbalanced (,
{, or [.
13. Si P est une expression logique, la loi de non-contradiction stipule que P ET
(NON P) est toujours fausse. Vérifiez ceci pour P vraie et P fausse.
14. Soient P et Q des expressions logiques. La règle de De Morgan stipule que
NON (P OU Q) = (NON P) ET (NON Q) et NON (P ET Q) = (NON P) OU
(NON Q). Vérifier les différentes combinaisons possibles de P et Q.
Chapitre 2
Variables et structures de données
2.1 Variables et affectation

Lors de la programmation, il est utile de pouvoir stocker des informations dans
des variables. Une variable est une chaîne de caractères et de nombres associée
à une information. L’opérateur d’affectation, désigné par le symbole ′ =′ , est
l’opérateur utilisé pour affecter des valeurs aux variables dans Matlab. La ligne >>
x = 1 prend la valeur connue, 1 et attribue cette valeur à la variable portant le nom
« x ». Après avoir exécuté cette ligne, vous verrez une nouvelle variable apparaître
dans la fenêtre de l’espace de travail. Jusqu’à ce que la valeur soit modifiée ou la
variable supprimée, le caractère x se comporte comme la valeur 1.
Essayer ! : Affectez la valeur 2 à la variable a. Multipliez a par 3 pour montrer

qu’il se comporte comme la valeur 2.
>> a = 2
a =
2
>> a * 3
ans =
6
L’espace de travail workspace est une abstraction de l’espace dans la mémoire

de l’ordinateur utilisé pour stocker des variables. Pour l’instant, il suffit de savoir
que la fenêtre de commande possède son propre espace de travail, dont le contenu
est rendu visuellement disponible dans la fenêtre de l’espace de travail. À la suite de
l’exemple précédent, vous verrez la variable a apparaître dans la fenêtre de l’espace
de travail. Vous pouvez afficher une liste de toutes les variables dans l’espace de
travail de la fenêtre de commande en utilisant la fonction whos.
Notez que le symbol égal en programmation n’a pas le même rôle qu’en énoncé de
vérité en mathématiques. En mathématiques, la déclaration x = 2 déclare la vérité
universelle dans le cadre donné, x vaut 2. En programmation, la déclaration x = 2
signifie qu’une valeur connue est associée à un nom de variable, stockez 2 dans x.
Bien qu’il soit parfaitement valable de dire 1 = x en mathématiques, les affectations
dans Matlab vont toujours à gauche : ce qui signifie que la valeur à droite du signe
11
12 CHAPITRE 2. Variables et structures de données
égal est affectée à la variable à gauche du signe égal. Par conséquent, >> 1 = x
générera une erreur dans Matlab. L’opérateur d’affectation est toujours le dernier
dans l’ordre des opérations relatives aux opérateurs mathématiques, logiques et de
comparaison.
Essayer ! : L’énonce mathématique x = x+1 n’a pas de solution pour aucune

valeur de x. En programmation, si nous initialisons la valeur de x à 1, alors la
déclaration prend tout son sens. Cela signifie « Ajoutez 1 à la valeur stockée
dans x, qui donnera 2, puis attribuez cette valeur à la variable x ». Notez que
cette opération écrase la valeur précédente stockée dans x.
>> x = 1
x =
1
>> x = x + 1
x =
2
Il existe certaines restrictions sur les noms que les variables peuvent prendre. Les
variables ne peuvent contenir que des caractères alphanumériques (lettres et chiffres)
ainsi que des traits de soulignement. Cependant, le premier caractère d’un nom de
variable doit être une lettre. La longueur maximale d’un nom de variable est de 255
caractères, ce qui est rarement un problème. Les espaces dans un nom de variable
ne sont pas autorisés et les noms de variable sont sensibles à la casse (par exemple,
x et X seront considérés comme des variables différentes).
Notez que lorsqu’une variable est affectée, elle n’a aucune mémoire de la façon
dont elle a été affectée. C’est-à-dire que si la valeur d’une variable, a, est construite
à partir d’autres variables, comme x, la réaffectation de la valeur de x ne changera
pas la valeur de a.
Essayer ! : Quelle valeur la variable a aura-t-elle après l’exécution des lignes

de commandes suivantes ?
>> x = 2
x =
2
>> a = x
a =
2
>> x = x * 3
x =
6
>> a
a =
2
2.1. VARIABLES ET AFFECTATION 13
Attention ! : Vous pouvez écraser des variables ou des fonctions intégrées qui
ont été stockées dans Matlab. Par exemple, la commande >> pi = 2 stockera
la valeur 2 dans la variable nommée >> pi. Après cette affectation, >> pi se
comportera comme la valeur 2 au lieu de la valeur π. Par conséquent, vous devez
toujours faire attention à ne pas donner à vos variables le même nom que les
fonctions ou valeurs intégrées. Un moyen simple de vérifier si un nom est déjà
utilisé est d’utiliser la fonction d’aide : help.
Vous pouvez effacer une variable de l’espace de travail à l’aide de la commande

clear. Taper clear x effacera la variable x de l’espace de travail. Taper clear ou
clear all supprimera toutes les variables de l’espace de travail. Taper clc effacera
la fenêtre de commandes, mais ne supprimera aucune de vos variables.
En mathématiques, les variables sont généralement associées à des nombres in-
connus ; en programmation, les variables sont associées à une valeur d’un certain
type. De nombreux types de données peuvent être affectés aux variables. Un type de
données Data type est une classification du type d’informations stockées dans une
variable. Les types de données de base que vous utiliserez tout au long de ce cours
sont logical, double, char, struct, cell. Une description formelle de ces types de
données est donnée dans les sections suivantes.
Tout d’abord, nous donnons un bref aperçu des matrices et de leurs parties.
Une matrice ou un tableau peut être considéré comme un tableau rectangulaire
de valeurs, pas nécessairement de valeurs numériques. Un élément d’une matrice
est une unité d’information contenue dans une matrice. Un indice d’une matrice
est une adresse dans ce tableau. Pour ce cours, nous traiterons exclusivement des
tableaux à une et deux dimensions. Pour les tableaux à une dimension, l’indice est
un entier positif indiquant la position de l’élément considéré. Pour les tableaux à
deux dimensions, l’indice est une paire d’entiers positifs qui désigne la ligne et la
colonne de l’élément considéré.
En mathématiques, les matrices sont généralement associées à des tableaux de
nombres. Cependant, dans Matlab, chaque valeur est considérée comme une ma-
trice. Les mots sont définis comme une matrice de lettres. Même un seul nombre est
considéré comme une matrice 1 × 1.
Astuce ! : Certaines des structures de données que vous créerez et avec les-
quelles vous travaillerez seront très volumineuses, comportant des milliers ou des
millions d’entrées. Puisqu’il n’est pas utile pour un humain de visualiser phy-
siquement le contenu de ces structures de données, un point-virgule peut être
utilisé après la création d’une variable pour supprimer l’affichage. Par exemple,
>> x = 2; n’affichera pas l’affectation résultante à l’écran, mais l’affectation à
x sera toujours exécutée. Vous pouvez le vérifier en regardant dans la fenêtre de
l’espace de travail.
>> x = 2;
>> x
x =
2.2 Tableaux de doubles

Un « double » est un type de données Matlab utilisé pour désigner des
nombres. Le double est le type de données le plus important que vous découvri-
rez, car les ingénieurs travaillent le plus souvent avec des nombres. Il existe d’autres
types de données utilisés pour désigner les nombres, mais tous les nombres seront
des doubles aux fins de ce texte, sauf indication contraire. Double signifie « double
précision », qui sera prochainement décrit plus en détail, sur la représentation des
nombres.
Essayer ! : Affectez la valeur 1 à la variable x. Vérifiez que x est un double

en utilisant la fonction class.
>> x = 1;
>> class(x)
ans =
’double’
Vous pouvez créer des tableaux de doubles dans Matlab en utilisant des cro-
chets [ ]. Le terme technique pour la fonction fournie par des crochets est appelé
concaténation (nom) ou concaténer (verbe). Il est courant de séparer les colonnes par
des virgules ou espace et les lignes par des point-virgules dans une concaténation.
Vous pouvez créer un tableau vide en plaçant des crochets autour de rien.
Essayer ! : Créez les tableaux suivants :

x= 1 5 9

1 5 9
y=
2 4 8
>> x = [1 5 9]
x =
1 5 9
>> y = [1 5 9 ; 2 4 8]
y =
1 5 9
2 4 8
Ou :
>> y = [x; 2 4 8]
y =
1 5 9
2 4 8
2.2. TABLEAUX DE DOUBLES 15
Ou :
>> y = [[1; 2] [5; 4] [9; 8]]
y =
1 5 9
2 4 8
Essayer ! : Créez un tableau vide

>> T = [ ]
T =
[ ]
>> class(T)
ans =
’double’
Notez, encore une fois, que Matlab résout toujours les crochets les plus internes
en premier. La ligne de commande >> y = [[1; 9], [4; 2], [3; 7]] concaté-
nera [1;9] avant les crochets externes.
Attention ! : Si vous essayez de concaténer des matrices qui ne s’emboîtent

pas (c’est-à-dire qu’elles ne forment pas un rectangle), vous obtiendrez une erreur
indiquant que la concaténation horizontale ou verticale est incorrecte.
>> a = [1 2 3; 4 5 ]
Dimensions of matrices being concatenated are not consistent.
Plusieurs fois, nous aimerions connaître la taille ou la longueur d’un tableau.

La fonction size est appelée sur un tableau M et renvoie un tableau 1 × 2 où le
premier élément est le nombre de lignes dans la matrice M et le deuxième élément
est le nombre de colonnes dans M. Notez que la sortie de la fonction size est aussi
un tableau. La fonction size vous permet également de spécifier la taille d’une seule
dimension à l’aide de l’entrée size(M, dim). Ainsi size(M,1) renverrait le nombre
de lignes dans M, et size(M,2) renverrait le nombre de colonnes dans M. La fonction
length est appelée sur un tableau M et renvoie le nombre d’éléments dans un vecteur
v si v est unidimensionnel. Si l’entrée est une matrice M de plus d’une dimension, alors
il renvoie la longueur de la plus grande dimension de M. Essayez de ne pas utiliser
cette fonctionnalité de length (c’est-à-dire, utilisez la length sur des tableaux à
une dimension uniquement).
Essayer ! : Calculez la taille et la longueur des tableaux x et y données

dans l’exemple précédent. Utilisez la fonction size pour obtenir uniquement le
nombre de lignes dans y et uniquement le nombre de colonnes dans y.
>> length(x)
ans =
3
>> size(x)
ans =
1 3
>> size(y)
ans =
2 3
>> length(y)
ans =
3
>> rows = size(y, 1)
rows =
2
>> cols = size(y, 2)
cols =
3
2.3 Tableau de suites équidistantes

Très souvent, nous aimerions générer des tableaux qui ont une structure ou un
ordre bien précis. Par exemple, nous pouvons souhaiter créer le tableau z = [1 2
3 ... 2000]. Il serait très fastidieux de taper la description complète de z dans
l’invite de commande. Pour générer, alors, des tableaux qui sont dans l’ordre et
régulièrement espacés, il est utile d’utiliser l’opérateur deux-points, ′ :′ .
Important ! : Opérateur deux-points ′ :′

Valeur initiale : incrément : Valeur finale
Essayer ! : Créez le tableau z = [1, 2, 3, ..., 2000]

>> z = 1:1:2000;
Comme il est très courant d’avoir un incrément de 1, si un incrément n’est

pas spécifié, Matlab utilisera une valeur par défaut de 1. Par conséquent, on
peut créer le tableau z par :
>> z = 1:2000;
Des incréments négatifs ou non entiers peuvent également être utilisés :

Essayer ! : Créez le tableau T = [2, 1.5, 1, 0.5, 0]
>> t = 2:-0.5:0
t =
2 1.5 1 0.5 0
2.3. TABLEAU DE SUITES ÉQUIDISTANTES 17
Parfois, nous voulons garantir un point de début et de fin pour un tableau, tout
en ayant des éléments régulièrement espacés. Par exemple, nous pouvons vouloir un
tableau qui commence à 1, se termine à 8 et a exactement 10 éléments. Pour cela,
vous pouvez utiliser la fonction linspace. Contrairement aux fonctions avec les-
quelles vous avez travaillé auparavant qui ne prennent qu’une seule entrée, linspace
prend trois valeurs d’entrée séparées par des virgules. Donc A = linspace(a,b,n)
génère un tableau de n éléments équidistants partant de a et se terminant en b.
Essayer ! : Utilisez linspace pour générer un tableau commençant à 3, se

terminant à 8 et contenant 5 éléments.
>> linspace(3,8,5)
t =
3.0000 4.2500 5.5000 6.7500 8.0000
Un autre type de tableau très structuré est une matrice dans laquelle chaque
élément porte le même nombre. A cet effet, les fonctions zeros et ones sont utiles.
Ces fonctions prennent en arguments le nombre de lignes et ce de colonnes et ren-
voient une matrice de la dimension d’entrée rempli des zéros ou des uns. De même,
la fonction eye permet d’avoir une matrice identité selon une démarche identique. Si
le nombre de colonnes n’est pas spécifié, alors Matlab va considéré que la matrice
est carrée.
Essayer ! : Générez une matrice 3 × 2 remplie des uns, une matrice 2 remplie
des zéros et une matrice identité de dimension 3 × 3 :
>> M = ones(3, 2)
M =
1 1
1 1
1 1
>> N = zeros(2, 4)
N =
0 0 0 0
0 0 0 0
0 0 0 0
>> I = eye(3)
I =
1 0 0
0 1 0
0 0 1
Toutes les fonctions ou opérations de création de tableaux peuvent être combinées

pour créer des tableaux complexes. Gardez à l’esprit que Matlab évaluera toujours
la fonction ou les crochets les plus internes en premier.
 
0 0 0 1 1 1
 0 0 0 1 1 1 
Essayer ! : Créez la matrice suivante : M = 
 
 1 0 0 1 2 3 

 0 1 0 4 5 6 
0 0 1 9 8 7
>> M = [zeros(2,3) ones(2,3); eye(3) [1:3; 4:6; 9:-1:7]]
M =
0 0 0 1 1 1
0 0 0 1 1 1
1 0 0 1 2 3
0 1 0 4 5 6
0 0 1 9 8 7
2.4 Indexation
Dans Matlab, les indices d’un tableau sont indiqués par des parenthèses atta-
chées au nom de la variable. Si A est un tableau dans l’espace de travail courant,
nous pouvons obtenir l’élément de la ligne row et de la colonne col en utilisant la
notation A(row, col). C’est ce qu’on appelle l’indexation de tableau : array in-
dexing. Vous pouvez spécifier un tableau d’indices pour obtenir plusieurs éléments
d’un tableau. En d’autres termes, r et c peuvent être des tableaux et vous pouvez
utiliser des opérations de création de tableau dans l’indexation. Si vous voulez une
ligne ou une colonne entière, vous pouvez raccourcir cette opération avec la com-
mande deux-points (:). Si vous voulez aller à la fin d’un tableau lors de l’indexation,
vous pouvez utiliser le mot end.

3 7 −2 1
Essayer ! : Soit le tableau A = :
−3 4 5 0
Retrouver l’élément de la deuxième ligne et de la troisième colonne (i.e. 5).
>> A(2,3)
ans =
5
Vous pouvez affecter l’élément à une seconde variable.
Essayer ! : Soit A le tableau de l’exemple précédent. Retrouver les éléments

de la deuxième ligne et des première et quatrième colonnes.
>> a = A(2,[1 4])
a =
-3 0
2.4. INDEXATION 19
Essayer ! : Soit A le tableau de l’exemple précédent. Récupérez tous les

éléments de la première ligne de A.
>> a = A(1,1:4)
a =
3 7 -2 1
Ou :
>> a = A(1,1:size(A,2))
a =
3 7 -2 1
Ou :
>> a = A(1,1:end)
a =
3 7 -2 1
Ou :
>> a = A(1,:)
a =
3 7 -2 1
Pour les tableaux unidimensionnels, vous pouvez raccourcir en n’incluant qu’un

seul index.
Essayer ! : Soit le tableau A = 1.5 2.4 0.5 8.3 4.7 3.9 :

Écrivez des commandes afin de récupérer le troisième élément de A, les troi-

sième, cinquième et sixième éléments de A et les troisième, quatrième et cin-
quième éléments de A.
>> a = A(3)
a =
0.5000
>> a = A([3 5 6])
a =
0.5000 4.7000 3.9000
>> a = A(3:5)
a =
0.5000 8.3000 4.7000
Vous pouvez réaffecter une valeur d’un tableau à l’aide de l’indexation de ta-
bleau et de l’opérateur d’affectation. Vous pouvez réaffecter plusieurs éléments à un
seul numéro en utilisant l’indexation de tableau sur le côté gauche. Vous pouvez
également réaffecter plusieurs éléments d’un tableau tant que le nombre d’éléments
à affecter et le nombre d’éléments affectés sont identiques. Vous pouvez aussi créer
un tableau en utilisant l’indexation de tableau.
Essayer ! : Soit A le tableau suivant : A = 1 2 3 1 4 5 :

Remplacer le troisième élément par 7. Réaffectez 1 aux premier, deuxième

et troisième éléments. Réaffectez 9, 8 et 7 aux deuxième, troisième et quatrième
éléments de A.
>> A(3) = 7
A =
1 2 7 4 5
>> A(1:3) = 1
A =
1 1 1 4 5
>> A(2:4) = [9, 8, 7]
A =
1 9 8 7 5

1 2
Essayer ! : Créez une matrice A = à l’aide de l’indexation.
3 4
>> A(1,1) = 1;
>> A(1,2) = 2;
>> A(2,1) = 3;
>> A(2,2) = 4
A =
1 2
3 4
Attention ! : Bien que vous puissiez créer un tableau en utilisant l’indexa-

tion, nous vous le déconseillons. Cela peut vous dérouter et les erreurs seront
plus difficiles à trouver dans votre code plus tard.
Par exemple :
>> B(2,1) = 3
B =
0 0
3 0
ce qui est étrange car on a pas affecté la valeur 0 aux éléments A(1,1), A(1,2)
et A(2,2).
2.5 Arithmétique
Dans la section 1.3, on a déjà parlé de l’arithmétique de base dans Matlab.
Dans la présente section, on parlera de l’arithmétique matricielle. En effet, Matlab
fait la différence entre les opérations arithmétique entre tableaux (par case) et les
opérations entre matrices comme le produit matriciel par exemple.
2.5. ARITHMÉTIQUE 21
Commençant par le cas le plus simple, où l’opération est entre scalaire et tableau.
Soit T un tableau et a un scalaire. T + a rajoute la valeur a à chaque élément de T ,
T − a soustrait la valeur a de chaque élément de T , T *a multiplie chaque élément
de T fois la valeur de a et T /a divise chaque élément de T par la valeur de a.

1 2
Essayer : Soit le tableau T = . Additionnez et soustrayez la valeur
3 4
2 de T . Multipliez et divisez T par 2. Vérifiez par vous-même la commutativité
de l’addition et de la multiplication scalaires :
T + a = a + T et aT = T a.
>> T + 2
ans =
3 4
5 6
>> T * 2
ans =
2 4
6 8
>> T − 2
ans =
−1 0
1 2
>> T / 2
ans =
0.5000 1.0000
1.5000 2.0000
Décrire les opérations entre deux matrices est plus compliqué. Prenons d’abord
les opérations d’addition et de soustraction + et −, car elle ne présente aucun pro-
blème. Soit deux tableaux T1 et T2 de même taille. T1 + T2 fait l’addition de chaque
élément de T1 à son correspondant dans T2 . De même T1 − T2 soustrait chaque
élément de T2 de son correspondant dans T1 .

1 3 0 1
Essayer : Soit deux tableaux T1 = , T2 = . Additionnez et
5 7 2 3
soustrayez les valeurs de T2 de celles de T1 :
>> T1 + T2
ans =
1 4
7 10
>> T1 − T2
ans =
1 2
3 4
Pour les opérations de multiplication, division et puissance, on distingue entre

les opérations élément-par-élément et les opérations matricielles standards. Les sym-
boles (∗ / ∧ ) sont réservés aux opérations matricielles standards ainsi les opérateurs
(.∗ ./ .∧ ) sont utilisés pour les opérations par éléments.
Essayer : Considérons les deux tableaux T1 et T2 de l’exemple précédent.

Multipliez, divisez et calculez la puissance de chaque élément de T1 par son
correspondant dans T2 :
>> T1 .* T2
ans =
0 3
10 21
>> T1 ./ T2
ans =
Inf 3.0000
2.5000 2.3333
>> T1 .^ T2
ans =
2.5. ARITHMÉTIQUE 23
1 3
25 343
Essayer : Considérons les deux tableaux T1 et T2 de l’exemple précédent.

Multipliez la matrice T1 par T2 et calculez le carré de la matrice T1 :
>> T1 * T2
ans =
6 10
14 26
>> T1 ^ 2
ans =
16 24
40 64
Le transposé d’une matrice est évalué à l’aide de l’opérateur ’.
Essayer : Considérant le tableau T1 de l’exemple précédent. Calculez le trans-

posé de T1 :
>> T1'
ans =
1 5
3 7
Les détails des opérations matricielles vont être discutés dans ce qui suit.
Toutes les fonctions arithmétiques intégrées de Matlab, telles que sin, peuvent
accepter des tableaux comme arguments d’entrée. La sortie est la fonction évaluée
pour chaque élément du tableau d’entrée. Une fonction qui prend un tableau en
entrée et exécute la fonction dessus est dite vectorisée.
Essayer ! : Calculez la racine carré de x = :

1 4 9 16
>> sqrt(x)
ans =
1 2 3 4
Les opérations logiques ne sont définies qu’entre un scalaire et un tableau et entre

deux tableaux de même taille. Entre un scalaire et un tableau, l’opération logique
est effectuée entre le scalaire et chaque élément du tableau. Entre deux tableaux,
l’opération logique s’effectue élément par élément.
Essayer ! : Vérifiez quels éléments du tableau x = 1 2 3 4 5 6 sont

plus grands que 3. Vérifiez quels éléments de

x sont plus grands que l’élément
correspondant de y = −2 1 9 7 2 5 .

>> x > 3
ans =
1*6 logical array
0 0 0 1 1 1
>> x > y
ans =
1*6 logical array
1 1 0 0 1 1
Matlab peut indexer les éléments d’un tableau qui satisfont une expression
logique.
Essayer ! : Soit x le même tableau que dans l’exemple précédent. Créez une
variable y contenant tous les éléments de x strictement supérieurs à 3. Attribuez
à toutes les valeurs de x supérieures à 3 la valeur 0.
>> y = x(x>3)
y =
4 5 6
>> x(x>3) = 0
2.6. CHAÎNES DE CARACTÈRES 25
x =
1 2 3 0 0 0
2.6 Chaînes de caractères

Char est un type de données pour stocker des caractères alphanumériques. Un
tableau de caractères, généralement unidimensionnel, est appelé une chaîne de ca-
ractères : string. Les chaînes de caractères sont assemblées à l’aide d’apostrophes
des deux côtés, mais les crochets peuvent également être utilisés pour concaténer
des chaînes.
Essayer ! : Attribuez le caractère S à la variable portant le nom s. Attri-

buez la chaîne Hello World à la variable w. Créez la variable w en utilisant la
concaténation. Vérifiez que s et w ont le même type char en utilisant la fonction
class.
>> S = 's'
S =
's'
>> w = 'Hello World'
w =
'Hello World'
>> w = ['Hello' 'World']
w =
'HelloWorld'
>> class(S)
ans =
'char'
>> class(w)
ans =
'char'
Attention ! l’espace, ’ ’, entre ’Hello’ et ’Word’ est aussi un caractère indépendant.

Matlab n’insère pas automatiquement les espaces ! Tout symbole peut être un
caractère Char, même ceux qui ont été réservés aux opérateurs. Notez qu’en tant que
caractère, ils n’exécutent pas la même fonction. Bien qu’ils se ressemblent, Matlab
les interprète complètement différemment.
Essayer ! : Vérifiez que le caractère ’+’ ne se comporte pas comme l’opérateur

d’addition +.
>> 5 '+' 6
5 '+' 6
|
Error: Unexpected Matlab expression.
Vous pouvez vous retrouver dans une situation où vous aimeriez utiliser une
apostrophe comme caractère. Ceci est problématique car une apostrophe est utilisée
pour désigner des chaînes. Heureusement, une apostrophe peut être créée en utilisant
deux apostrophes.
Essayer ! : Créez la chaîne ’Aujourd’hui’.

>> 'Aujourd''hui'
ans =
Aujourd'hui
Comme pour les tableaux de doubles, la taille et la longueur d’une chaîne de

caractères correspondent respectivement au nombre de lignes et de colonnes ou au
nombre d’éléments qu’elle contient. Les chaînes peuvent être concaténées ensemble,
verticalement et horizontalement, en utilisant des crochets comme les doubles. Ce-
pendant, pour les besoins de ce cours, les caractères seront toujours unidimension-
nels.
Essayer ! : Créez les chaînes s1 = 'Hello' et s2 = 'World' et utilisez la

concaténation de s1 et s2 pour créer la chaîne s3 = 'Hello World'. N’oubliez
pas l’espace entre les deux mots !
2.6. CHAÎNES DE CARACTÈRES 27
>> s1 = 'Hello';
>> s2 = 'World';
>> s3 = [s1, ' ', s2]
s3 =
'Hello World'
Les tableaux de caractères sont indexés de la même manière que les tableaux de
doubles, y compris l’indexation des tableaux. Une chaîne vide peut être créée avec
deux apostrophes, ''.
Essayer ! : Affectez la chaîne 'Numerical methods' à la variable s. Récu-

pérez uniquement la lettre c et uniquement le mot 'methods' de s en utilisant
l’indexation de tableau.
>> s = 'Numerical methods';
>> s(7)
ans =
'c'
>> s(11:end)
ans =
'methods'
Essayer ! : Créez une chaîne vide. Vérifiez que la chaîne vide est un caractère
de type Char.
>> s = '';
>> class(s)
ans =
'char'
Une fonction très utile dans Matlab est sprintf. La fonction sprintf écrit de
nouvelles données dans une chaîne préformatée.
Essayer ! : Utilisez la fonction sprintf pour créer les chaînes s1 = 'Je m'
'appel Mohammed' et s2 = 'Je m''appel Khadija'.
>> n1 = 'Mohammed';
>> n2 = 'Khadija';
>> s1 = sprintf('Je m''appel %s', n1)
s1 =
Je m'appel Mohammed
>> s1 = sprintf('Je m''appel %s', n2)
s1 =
Je m'appel Khadija
Qu’est ce qui de passe ? Dans l’exemple précédent, la première entrée de sprintf

est une chaîne au format souhaité. Dans chaque cas, l’endroit où le nom doit être
peut être différent. Par conséquent, un '%s' est placé là où le nom devrait être (s
signifie chaîne de caractères dans ce cas).
Vous pouvez également créer des chaînes formatées plus longues avec plusieurs
espaces réservés. Vous pouvez utiliser sprintf pour insérer des chaînes '%s', des
entiers '%d' ou des nombres plus génériques '%f' et '%g'. Vous pouvez également
contrôler le nombre de chiffres insérés dans la chaîne formatée, mais nous vous lais-
serons explorer par vous-même.
Essayer ! : Utilisez la fonction sprintf pour créer la chaîne s = 'Le cours

contient 5 chapitres'.
>> nch = 5;
>> s = sprintf('Le cours contient %d chapitres', nch)
s =
'Le cours contient 5 chapitres'
Notez ! : Certaines fonctions Matlab sont censées accepter des entrées de

type sprintf. Cela signifie que la fonction peut accepter des chaînes formatées
de la même manière que sprintf.
2.7. TABLEAUX DE STRUCTURES 29
2.7 Tableaux de structures

Une structure Struct est un type de données utile lorsque chaque élément d’un
tableau est défini par plusieurs propriétés. Par exemple, vous pouvez souhaiter que
chaque élément d’un tableau représente une personne définie par un nom et un
numéro d’identification personnel. Cependant, chaque personne peut être difficile à
définir par un seul caractère ou double. Dans un tableau Struct, les propriétés de
chaque élément sont définies par ses champs. Le type de données contenu dans un
champ peut être de n’importe quel type de données. Le nom du tableau Struct et le
champ sont séparés par un point. Comme pour les tableaux doubles et char, l’indice
ou les indexes sont spécifiés entre parenthèses à côté du nom du tableau. Il existe
des moyens de créer un tableau de structure en une seule fois. Cependant, il est plus
simple de les créer en utilisant l’indexation de tableau, ce qui n’est pas recommandé
pour les tableaux doubles ou char.
Essayer ! : Définissons une variable ’Person’ par un nom (string), un numéro

d’identification personnel : ID (double) et une nationalité (string).
>> Person.name = 'Mohammed';
>> Person.ID = 25468;
>> Person.nationality = 'Morrocan';
>> Person
Person =
struct with fields:
name: 'Mohammed'
ID: 25468
nationality: 'Morrocan'
Essayer ! : Soit maintenant une liste d’étudiants, chaque étudiant est défini
par un nom (char), un numéro d’identification personnel : ID (double) et un
tableau de notes (double). Remplissez un tableau de structures struct avec les
champs de noms, d’ID et des notes. Vérifiez que le tableau a un type struct à
l’aide de la fonction de class.
>> students(1).name = 'Mohammed';
>> students(1).ID = 25468;
>> students(1).grades = [14 16 15];
>> students(2).name = 'Khadija';
>> students(2).ID = 25327;
>> students(2).grades = [15 13 17];
>> students
students =
1*2 struct array with fields:
name
ID
grades
>> class(students)
ans =
'struct'
Les tableaux de structures peuvent avoir deux dimensions ou plus, mais pour
les besoins de ce cours, les struct seront toujours unidimensionnelles. Puisque les
struct sont des tableaux, ils peuvent être concaténés, mais seulement si les deux
tableaux de struct ont les mêmes champs (et sont de taille compatible). De plus, les
additions et autres opérations arithmétiques ne sont pas autorisées entre les tableaux
de structures ou entre des struct et des nombres.
Essayer ! : Remplissez une nouvelle structure appelée newStudent avec les

mêmes champs que la structure students de l’exemple précédent. Concaténer
newStudent à la structure students.
>> newStudent.name = 'Omar';
>> newStudent.ID = 25405;
>> newStudent.grades = [12 17 16];
>> students = [students newStudent]
students =
name
ID
grades
Les tableaux de structure sont indexés à l’aide de parenthèses entre le nom de

la structure et le point séparant le nom du champ. Vous pouvez utiliser l’indexation
des tableaux struct de la même manière qu’avec les tableaux double et les string.
2.7. TABLEAUX DE STRUCTURES 31
Essayer ! : Récupérez le deuxième élément de la structure students dans

l’exemple précédent. Récupérez également le premier et le troisième élément de
la structure.
>> students(2)
ans =
struct with fields:
name: 'Khadija'
ID: 25327
grades: [15 13 17]
>> students([1 3])
ans =
name
ID
grades
Les informations contenues dans le champ d’un élément d’un tableau struct
peuvent être récupérées en indexant l’élément souhaité, puis en plaçant un point,
puis en tapant le nom du champ. Par exemple, students(2).grades renverra les
informations contenues dans le champ des notes du deuxième élément d’étudiant.
Les valeurs contenues dans les champs des tableaux de struct conservent leur type
de données d’origine ; par conséquent, ils se comportent exactement comme ce type
de données. Par exemple, students(2).grades est un tableau double [89 99 75
100 95]. Ainsi, nous pouvons utiliser l’indexation de tableaux pour obtenir des
éléments spécifiques des notes du deuxième étudiant.
Essayer ! : Récupérez les notes du deuxième étudiant dans le tableau de

structures students de l’exemple précédent. Vérifiez que les notes sont doubles
à l’aide de la fonction de class. Récupérez uniquement le dernier élément des
notes du deuxième étudiant en utilisant l’indexation de tableau sur le champ des
notes.
>> grades = students(2).grades
grades =
15 13 17
>> class(grades)
ans =
'double'
>> last = students(2).grades(end)
last =
17
Comme indiqué précédemment, les champs d’un tableau de structure peuvent

avoir n’importe quel type de données, y compris une structure ou une cellule (définie
dans la section suivante). N’oubliez pas que le champ d’une structure se comporte
exactement comme son type de données.
Essayer ! : Remplissez une structure appelée myActivities avec des champs

de sports, afterSchool et clubs. Attribuez myActivities à un champ appelé
activities au premier élément de la structure précédente students. Affectez
les données contenues dans le champ clubs dans les activités de la structure
students à une variable club.
>> myActivities.sports = 'Football';
>> myActivities.afterSchool = '';
>> myActivities.clubs = 'Matlab programming club';
>> students(1).activities = myActivities
students =
name
ID
grades
activities
>> club = students(1).activities.clubs
club =
'Matlab programming club'

2.8. TABLEAU DE CELLULES 33
Attention ! : Si une structure comporte plusieurs éléments et que vous omet-

tez l’indexation lors de l’appel d’un champ, Matlab traitera la commande
comme si vous appeliez le champ pour chaque élément individuellement. Par
exemple, taper students.name aura le résultat suivant :
>> students.name
ans =
'Mohammed'
ans =
'Khadija'
ans =
'Omar'
Évitez de le faire lors du codage car vous pouvez obtenir des résultats inat-
tendus.
2.8 Tableau de cellules

Une cellule cell est un type de données pour les informations non structurées.
Dans un tableau de cellules, chaque élément peut avoir n’importe quel type de
données, y compris une autre cellule. Cependant, les éléments des tableaux de cellules
sont indexés à l’aide d’accolades, {}, plutôt que de parenthèses. Ils sont également
concaténés à l’aide d’accolades. Vous pouvez également créer un tableau de cellules
à l’aide de la fonction cell, puis remplir les éléments un par un.
Essayer ! : Créez un tableau de cellules 1 × 3 où le premier élément est

la chaîne 'Numerical methods', le deuxième élément est le double 2022 et le
troisième élément est le struct students créé dans une section précédente sur
les tableaux struct. Créez le tableau de cellules à l’aide de la concaténation.
Vérifiez que le tableau de cellules créé est de type cell à l’aide de la fonction
class. Vérifiez que chacun des éléments a le type char, double et struct,
respectivement. Répétez cet exemple en appelant d’abord la fonction cell, puis
en remplissant les éléments un par un.
>> C = {'Numerical methods', 2022, students}
C =
1*3 cell array
'Numerical methods' [2022] [1*3 struct]
>> class(C)
ans =
'cell'
>> C = cell(1,3);
>> C{1} = 'Numerical methods';
>> C{2} = 2022;
>> C{3} = students;
>> class(C{1})
ans =
'char'
>> class(C{2})
ans =
'double'
>> class(C{3})
ans =
'struct'
Une erreur courante lors de l’utilisation de tableaux de cellules consiste à

indexer le tableau de cellules avec des parenthèses plutôt qu’avec des accolades. Si
vous faites cela, vous obtiendrez un tableau de cellules contenant le contenu des
éléments indexés.
Essayer ! : Indexez le tableau de cellules de l’exemple précédent en utilisant

des parenthèses plutôt que des accolades. Vérifiez que le contenu correspond aux
tableaux de cellules plutôt qu’aux types de données attendus.
>> C(1)
2.9. EXERCICES 35
ans =
cell
'Numerical methods'
>> C(2)
ans =
cell
[2022]
Attention ! : Bien que l’utilisation de parenthèses plutôt que d’accolades

puisse être utile, nous vous déconseillons de le faire pendant que vous apprenez
à programmer dans Matlab.
Notez ! : Habituellement, les données auront une sorte de structure. Par

conséquent, il est généralement préférable de stocker les données dans une struc-
ture plutôt que dans une cellule.
Notez ! : Il existe de nombreux comportements bizarres associés aux tableaux
de cellules. Pour ce cours, nous n’utiliserons que les opérations rudimentaires de
création et de manipulation abordées dans cette section.
2.9 Exercices
1. Attribuez la valeur 2 à la variable x et la valeur 3 à la variable y. Effacez juste
la variable x. Ensuite, effacez toutes les variables à l’aide de clear. Effacer
l’écran en utilisant la commande clc.
2. Écrivez une ligne de code qui génère l’erreur suivante :
Undefined function or variable ’x’
3. Écrivez une ligne de code qui génère l’erreur suivante :
The expression to the left of the equals sign is not a valid target
for an assignment.
4. Soit x = 10 et y = 3 définis dans l’espace de travail. Écrivez une ligne de code
qui fera chacune des affectations suivantes :
u = x+y
v = xy
w = x/y
z = sin(x)
r = cos(xy)
s = xy
5. Soit x = 1 4 3 2 9 4 et y = 2 −1 0 3 5 −3 . Calculez les af-

fectations du problème 4. N’oubliez pas d’utiliser des opérations sur tableaux !

6. Rappelez-vous que linspace(a,b,n) génère un tableau de n nombres régu-
lièrement espacés commençant de a et se terminant apr b. Étant donné a, b
et n, écrivez une déclaration en termes de a, b et n en utilisant l’opérateur
deux-points qui produit le même tableau que linspace(a,b,n).
7. Créez la matrice suivante en une seule affectation. Essayez d’utiliser le moins
de chiffres possible :  
0 0 0 0 1
0 0 0 0 1
 
M = 1 2 3 4 1

5 6 7 8 1
9 10 11 12 1
8. Pour la matrice M , dans le problème précédent, utilisez la fonction sum pour
calculer la somme de chacune des lignes de M .
9. Utilisez la fonction rand pour générer un tableau de 1000 nombres distribués de
manière aléatoire entre 0 et 1. La moyenne des nombres distribués de manière
aléatoire entre 0 et 1 doit être de 0.5. Utilisez la fonction mean pour trouver la
moyenne du tableau créé. Vérifiez qu’il est proche de 0.5.
10. Affectez la chaîne '123' à la variable S. Utilisez la fonction str2num pour
transformer S en double. Affectez la sortie de str2num à la variable N . Vérifiez
que S est un char et que N est un double à l’aide de la fonction de class.
11. Affectez la chaîne 'HELLO' à la variable s1 et la chaîne 'hello' à la variable
s2 . Utilisez la fonction strcmp pour comparer s1 et s2 pour montrer qu’ils ne
sont pas égaux. Montrez que s1 et s2 sont égaux si la fonction lower est utilisée
sur s1 . Montrez que s1 et s2 sont égaux si la fonction upper est utilisée sur s2 .
12. Utilisez la fonction sprintf pour générer les chaînes formatées suivantes :
'The word Engineering has 11 letters.'
'The word Book has 4 letters.'
'The word Matlab has 6 letters.'
13. Soit x = 0:10 et y = 10:-1:0. Utilisez l’opérateur de comparaison d’égalité et
la fonction all pour montrer que tous les éléments de x sont égaux à tous les
éléments de y après l’utilisation de la fonction flip sur y. Essayez d’effectuer
la même opération en utilisant la fonction isequal.
14. Écrivez des lignes de code qui génèrent chacune les erreurs suivantes liées aux
tableaux :
2.9. EXERCICES 37
??? Error: Unbalanced or unexpected parenthesis or bracket.

??? Attempted to access A(-1); index must be a positive integer or
logical.
??? Error using ==> horzcat CAT arguments dimensions are not consistent.
??? Error using ==> vertcat CAT arguments dimensions are not consistent.
??? In an assignment A(I) = B, the number of elements in B and I must
be the same.
??? Error using ==> plus Matrix dimensions must agree.
??? Attempted to access A(4); index out of bounds because numel(A)=3.
15. Écrivez des lignes de code qui génèrent chacune les erreurs suivantes liées aux
tableaux de structures :
??? Error using ==> horzcat CAT arguments are not consistent in structure
field names.
??? Undefined function or method ’plus’ for input arguments of type
’struct’.
16. Créez un tableau struct appelé Class avec les champs suivants : title (chaîne),
semestre (chaîne) et inscription (double). Remplissez la structure Class avec
les informations de trois de vos cours préférés.
Exemple du premier élément :
>> Class(1).title = 'CMI';
>> Class(1).semestre = 'S3 2022';
>> Class(1).inscription = 27;
Pour l’exemple du premier élément donné, utilisez la concaténation des valeurs
des champs de la variable Class pour générer la chaîne 'CMI: S3 2022'.
17. Créez un tableau de cellules appelé ’Cars’ où chaque ligne contient des données
sur une voiture. Le premier élément de la ligne doit être le nom de la voiture
(chaîne), le deuxième élément doit être la vitesse maximale (double) et le troi-
sième élément de la ligne doit être le nombre de cheveaux (double). Remplissez
la cellule Cars avec des informations à partir de trois éléments d’information
de vos voitures préférées.
Exemple de la première ligne :
>> Cars{1,1} = 'Jaguar F TYPE';
>> Cars{1,2} = 285;
>> Cars{1,3} = 444;
18.
Chapitre 3
Scripts et Fonctions
3.1 Introduction
Dans les deux premiers chapitres, nous avons limité l’utilisation de Matlab dans
des commandes exécutées directement sur la fenêtre de commandes. Dans l’utilisa-
tion courante de Matlab, il sera ennuyeux de rédiger tout un programme en le
retapant à chaque fois sur la fenêtre de commandes. C’est pour cela, nous allons
organiser nos programmes dans des fichiers appelés ’m-files’. Ces fichiers, qui sont
exécutables sur Matlab, permettent de bien structurer nos programmes. Il y a deux
types de fichier Matlab, les Scripts et les fonctions.
La programmation nécessite souvent de répéter un ensemble de tâches encore et
encore. Par exemple, la fonction sin dans Matlab est un ensemble de tâches (c’est-
à-dire des opérations mathématiques) qui calcule une approximation de la valeur
sin(x).
Plutôt que d’avoir à retaper ou à copier ces instructions chaque fois que vous
voulez utiliser la fonction sin, il est utile de stocker cette séquence d’instructions
sous la forme d’une fonction que vous pouvez appeler encore et encore. L’écriture de
vos propres fonctions est l’objet de ce chapitre, et c’est l’utilisation la plus puissante
de la programmation informatique. À la fin de ce chapitre, vous devriez être capable
de déclarer, d’écrire, de stocker et d’appeler vos propres fonctions.
3.2 M-files
Pour écrire plusieurs instructions à la fois et les exécuter ligne par ligne, il est utile
d’utiliser des fichiers ; scripts ou fonctions appelés M-files. Les fichiers de ce type ont
une extension ’.m’ et doit contenir des instructions Matlab ou des commentaires.
Pour écrire vos propres programmes, vous devrez utiliser une nouvelle partie
de l’environnement Matlab appelée l’éditeur. L’éditeur vous permet de créer, de
modifier et d’enregistrer vos fichiers. Vous pouvez ouvrir l’éditeur en cliquant sur le
bouton ’New script’ ou ’New’ , dans le coin supérieur gauche de l’environnement
Matlab. La figure 3.1 montre l’éditeur Matlab.
Pour enregistrer votre programme, cliquez sur le bouton d’enregistrement, dans le
coin supérieur gauche de l’éditeur. Vous pouvez également enregistrer votre fonction
39
40 CHAPITRE 3. Scripts et Fonctions
Figure 3.1 – Interface graphique de l’éditeur Matlab R2017a
en appuyant sur ctrl + s. Le type de fichier doit être .m, un fichier .m M-file, qui
est le type de fichier standard pour les script et fonctions Matlab. Les fichier .m
doivent se conformer à un schéma de nomenclature similaire aux variables. Ils ne
peuvent contenir que des caractères alphanumériques et des traits de soulignement,
et le premier caractère doit être une lettre. Le nom d’un fichier doit comporter moins
de 255 caractères.
Astuce ! : C’est une bonne pratique de programmation d’enregistrer souvent

pendant que vous écrivez votre fonction. En fait, de nombreux programmeurs
déclarent enregistrer en utilisant le raccourci ctrl+s chaque fois qu’ils arrêtent
de taper !
Attention ! : Ne jamais utiliser des espace dans la nomenclature des fichier

.m ni les dossier où vous enregistrez vos fichiers.
3.2.1 Fichiers Script

Un fichier script est un fichier d’extension .m qui contient une séquence d’ins-
tructions mais n’est pas une fonction. Contrairement à une fonction, un fichier script
partage son espace de travail avec le répertoire courant. Un fichier script est créé en
écrivant des lignes de code comme vous le feriez à l’invite de commande. Un fichier
script est exécuté lorsque vous appuyez sur le bouton d’exécution (Triangle vert)
dans la barre d’outils supérieure. Lorsque le fichier script est exécuté, Matlab exé-
cute les instructions dans l’ordre comme si vous les aviez saisies une par une dans
l’invite de commande.
3.2. M-FILES 41
Avant d’essayer votre premier programme, nous présentons maintenant quelques

bonnes pratiques de codage. Un commentaire est une ligne dans une fonction qui
n’est pas lue comme du code. Autrement dit, Matlab l’ignorera lors de l’exécution
de vos programmes. Vous pouvez indiquer un commentaire en plaçant un symbole
% au début d’une ligne. Vous remarquerez que tous les caractères de cette ligne
deviennent verts. Matlab n’exécutera aucun code vert. Lorsque votre code devient
plus long et plus compliqué, les commentaires vous aident, ainsi que ceux qui lisent
votre code, à le parcourir et à comprendre ce que vous essayez de faire. Prendre
l’habitude de commenter fréquemment vous aidera à éviter de faire des erreurs de
codage, à comprendre où va votre code lorsque vous l’écrivez et à trouver des erreurs
lorsque vous faites des erreurs. Il est également d’usage de mettre une description
de la fonction ainsi que sa définition de type, son auteur et sa date de création dans
un commentaire sous l’en-tête de la fonction. Nous vous recommandons vivement de
commenter abondamment dans votre propre code.
Essayer ! : Écrire un fichier script qui calcule l’aire et le périmètre d’un cercle
pour un rayon donné.
clc
clear
close all
% Declarer le rayon
r = 1.5;
% Le perimetre
p = 2 * pi * r;
% L'air
a = pi * r^2;
Si vous aviez un nouveau cylindre, vous pourriez changer le rayon r et relancer

le fichier script pour calculer les nouvelles propriétés.
ATTENTION ! : Les fichiers script partagent leur espace de travail avec le

répertoire en cours, veillez donc à ce que les variables affectées dans le fichier
script n’écrasent pas d’autres variables portant le même nom.
ATTENTION ! : Ayez toujours un clc, clear et close all au début de

chaque fichier script. En effet, le script partage l’espace de travail avec le réper-
toire actuel et il est recommandé de s’assurer que votre fichier script n’utilise
pas de variables d’anciennes sessions Matlab.
Il est naturel de se demander quand un fichier script est plus approprié qu’une
fonction ou vice versa. Les fonctions sont plus utiles lorsqu’une tâche doit être ef-
fectuée plusieurs fois. Les fichiers script sont utiles lorsque vous devez exécuter une
séquence d’instructions seulement quelques fois dans une situation très spécifique
au contexte. Certains exemples peuvent produire un tracé compliqué ou d’essayer
quelque chose de nouveau pour voir s’il vaut la peine d’écrire une fonction pour cela.
Vous pouvez organiser le code des fichiers script dans des cellules (à ne pas
confondre avec les tableaux de cellules), qui peuvent être exécutées sans exécuter
le reste du script. Cela ne doit pas être confondu avec les tableaux de cellules. Une
cellule est un morceau de code d’un script qui peut être exécuté individuellement.
Les cellules de code peuvent être créées en double commentant ou en utilisant deux
%%. Vous pouvez exécuter une cellule en cliquant sur le bouton évaluer la cellule ou
sur le bouton évaluer la cellule et avancer ou simplement en tappant à la fois sur
’Ctrl’ + ’Enter’ lorsque le curseur est placé dans une cellule.
Essayer ! : Organisez le fichier de script précédent en cellules. Exécutez les

cellules une par une en utilisant le mode cellule.
clc
clear
close all
%% Declarer le rayon
r = 1.5;
%% Le perimetre
p = 2 * pi * r;
%% L'air
a = pi * r^2;
3.2.2 Fichiers de type Fonction

Contrairement à un fichier script, un fichier de type fonction sert à écrire un pro-
gramme que l’on souhaite répéter plusieurs fois et qui prend des arguments d’entrée
et renvoie les résultats comme arguments de sortie.
Un fichier fonction est également un fichier d’extension ‘.m’ il commence par une
ligne de définition ayant la syntaxe suivante : function [ output_arguments ]
= function_name( input_arguments )
Il faut faire attention à ce que le nom de la fonction function_name soit identique
au nom du fichier .m dans lequel la fonction est enregistrée. L’appel de la fonction
peut se faire à travers la saisie de son nom et ses arguments correspondants. Lorsque
les arguments de sorties ne sont nécessaires, ils peuvent être omis lors de l’appel.
3.2. M-FILES 43
Essayer ! : Écrivant maintenant un fichier de type fonction qui reçoit le rayon

d’un cercle et renvoie son aire et son périmètre.
function [a,p] = APDisque(r)
% Cette fonction permet le calcul de l'aire et le perimetre d'un
disque de rayon r
a = pi.*r^2;
p = 2.*pi.*r;
end
L’appel à la fonction dans le ‘prompt’ se fait par :

>> [a,p] = APDisque(2)
a =
12.5664
p =
12.5664
Une fois votre fonction enregistrée dans le répertoire de travail actuel, elle se
comporte exactement comme l’une des fonctions intégrées de Matlab et peut être
appelée à partir de l’invite de commande ou par d’autres fonctions.
Remarquez que cette fonction va permettre par la suite de calculer les caracté-
ristiques d’un disque quelconque, simplement par un appel à la fonction [a,p] =
APDisque(r) en changeant chaque fois la valeur du rayon r.
Notez aussi l’utilisation d’un point-virgule à la fin des deux lignes d’affectation
dans le code a = pi.*r^2; et p = 2.*pi.*r;. C’est une habitude très importante
dans la programmation des fonctions dans Matlab, car les résultats des instructions
d’affectation sans point-virgule s’affichent à l’écran. Comme cela sera démontré plus
tard, cela peut rendre les choses très compliquées, vous devez donc prendre soin de
supprimer toutes les instructions ’d’affectation’ dans une fonction. Utilisez la fonc-
tion d’affichage display ou des fonctions similaires lorsque vous souhaitez qu’une
fonction affiche quelque chose à l’écran.
ATTENTION ! : Supprimez toujours le code dans une fonction en utilisant

un point-virgule à la fin de toutes les instructions d’affectation.
Deuxièmement, notez que le mot end est placé à la fin de la fonction. Le mot
end devient bleu tout comme le mot-clé function. C’est parce que end est aussi
un mot-clé. Dans ce cas, il indique la fin d’une fonction. Plus tard, vous verrez que
cela met également déclare la fin à bien d’autres choses. Cette fonction fonctionnera
toujours si la fin n’y est pas placée, mais cela causera des problèmes plus tard. Par
conséquent, pour notre propos, terminez toujours une fonction avec le mot-clé end.
Attention ! : Terminez toujours une fonction avec le mot-clé end
3.3 Fonctions
3.3.1 Principes de base d’une fonction
En programmation, une fonction (function) est une séquence d’instructions qui
exécute une tâche spécifique. Une fonction peut avoir des arguments d’entrée (input
arguments), qui sont mis à sa disposition par l’utilisateur et présentent l’entité
appelant la fonction. Les fonctions ont également des arguments de sortie (output
arguments), qui sont les résultats de la fonction que l’utilisateur s’attend à recevoir
une fois que la fonction a terminé sa tâche. Par exemple, la fonction Matlab sin a un
argument d’entrée, un angle en radians et un argument de sortie, une approximation
de la fonction sin calculée à l’angle d’entrée (arrondi à 16 chiffres). La séquence
d’instructions pour calculer cette approximation constitue le corps de la fonction
(body of the function), qui jusqu’à présent n’a pas été représenté.
Dans ce cours, nous définirons les fonctions par leurs en-tête (function header).
Un en-tête de fonction est la façon dont la définition d’une fonction est donnée à
Matlab. L’en-tête de la fonction est une liste d’arguments de sortie de la fonction,
entourés de crochets, suivis d’un signe égal, du nom de la fonction, puis des argu-
ments d’entrée de la fonction, entourés de parenthèses. Par exemple, l’en-tête de la
fonction sin ressemble à ceci : [y] = sin(x). L’en-tête de la fonction a un rôle très
important, car il sert, dans le même temps, de déclarer la fonction et de l’appelée.
Pour des fonctions plus compliquées, l’en-tête de la fonction sera généralement
suivis d’une brève description de ce que la fonction doit faire (c’est-à-dire la relation
entre les arguments d’entrée et de sortie).
La première ligne d’une nouvelle fonction doit toujours être le mot function,
suivi de son en-tête.
Construction ! : En-tête de fonction (première ligne de fonction).

function [outputs] = function_name(inputs)
Ensuite, vous devez écrire le corps de la fonction. Il s’agit de la séquence d’ins-

tructions qui produira les sorties souhaitées en fonction des entrées données. S’il y a
plusieurs lignes dans une fonction, Matlab les exécutera dans l’ordre. Puisqu’on va
commencer par des fonctions est très simples, le corps ne nécessitera que quelques
lignes.
Nous commencerons par parcourir la construction d’une fonction très simple
définie par d = myAdder(a,b,c), où d est la somme de a,b et c.
Essayez ! : Construisez une fonction myAdder qui prend 3 arguments est

renvoie leur somme.
3.3. FONCTIONS 45
function out = myAdder(a,b,c)

% out = myAdder(a,b,c)
% out is the sum of a, b and c
out = a + b + c;
end
Vous remarquerez, peut-être, que le mot function devient bleu. Ce mot devient
bleu parce que function est un mot-clé. Les mots-clés sont des mots que Matlab
a réservés pour avoir une signification spécifique. Dans ce cas, le mot function est
réservé pour désigner le début d’une fonction. D’autres mots clés seront définis dans
les chapitres suivants. Les mots-clés ne peuvent pas être attribués en tant que noms
de variables ou de fonctions. Par exemple, >> function = 2 produirait une erreur.
Astuce ! : C’est une bonne pratique de programmation d’enregistrer souvent

pendant que vous écrivez votre fonction. En fait, de nombreux programmeurs
déclarent enregistrer en utilisant le raccourci ctrl + s chaque fois qu’ils arrêtent
de taper.
Afin d’exécuter la fonction, l’utilisateur doit faire appel à la fonction soit direc-
tement sur la ligne de commande soit dans un fichier script.
Attention ! : Ne jamais essayer d’exécuter une fonction par le triangle vert !
Essayez ! : Utilisez votre fonction myAdder à l’invite de commande pour cal-

culer la somme de quelques nombres. Vérifiez que le résultat est correct. Essayez
d’appeler la fonction d’aide sur myAdder.
>> d = myAdder(1,3,10)
d =
14
>> e = myAdder(2,4,6)
e =
12
>> help myAdder

out = myAdder(a,b,c)
out is the sum of a, b and c
Comment ça marche ! : Rappelons d’abord que l’opérateur d’affectation

fonctionne de droite à gauche. Cela signifie que myAdder(1,3,10) est résolu
avant l’affectation à d.
1. Matlab cherche la fonction myAdder dans les arborescents (path).
2. myAdder prend la première valeur d’argument d’entrée 1 et l’affecte à la
variable a (premier nom de variable dans la liste des arguments d’entrée).
3. myAdder prend la deuxième valeur d’argument d’entrée 3 et l’affecte à la
variable b (deuxième nom de variable dans la liste des arguments d’entrée).
4. myAdder prend la troisième valeur d’argument d’entrée 3 et l’affecte à la
variable c (troisième nom de variable dans la liste des arguments d’entrée).
5. myAdder calcule la somme de a, b et c, qui est 1 + 3 + 10 = 14 et l’affecte
à une variable out qui appartient à la fonction.
6. myAdder atteint la fin de la fonction, identifiée par le mot clé end.
7. myAdder vérifie qu’une variable avec le nom out (premier nom de variable
dans la liste des arguments de sortie) a été créée.
8. myAdder génère la valeur contenue dans la variable de sortie out, qui est
14.
9. myAdder(1,3,10) est équivalent à la valeur 14, et cette valeur est assignée
à la variable avec le nom d.
Matlab offre à l’utilisateur une liberté considérable pour affecter des variables
à différents types de données. Par exemple, il est possible de donner à la variable
x une valeur struct ou une valeur double. Dans d’autres langages de programma-
tion, ce n’est pas toujours le cas, vous devez déclarer au début d’une session si x
sera une structure ou un double, puis vous êtes peut être bloqué. Cela peut être
à la fois un avantage et un inconvénient. Par exemple, myAdder a été construit en
supposant que les arguments d’entrée étaient des doubles. Cependant, l’utilisateur
peut accidentellement saisir une structure ou une cellule dans myAdder, ce qui n’est
pas correct. Si vous essayez d’entrer un argument d’entrée non double dans myAdder,
Matlab continuera à exécuter la fonction jusqu’à ce que quelque chose se passe mal
ou jusqu’à ce que la fonction se termine.
Essayez ! : Utilisez des valeurs non doubles dans les arguments de la fonction
myAdder.
>> myAdder(1,'3',10)
ans =
62
>> Ibrahim.age = 14;

>> myAdder(1,Ibrahim,10)
Undefined operator '+' for input arguments of type 'struct'.
3.3. FONCTIONS 47
Error in myAdder (line 5)

out = a + b + c;
Astuce ! : N’oubliez pas de lire les erreurs que Matlab vous donne. Ils
vous disent généralement exactement où était le problème. Dans ce cas, l’erreur
indique Error in myAdder (line 5), ce qui signifie qu’il y a eu une erreur dans
la fonction myAdder sur la cinquième ligne. La raison pour laquelle il y a eu une
erreur est que la variable b a été affectée à une structure puis ajoutée à un double,
qui n’est pas défini.
À ce stade, vous n’avez aucun contrôle sur ce que l’utilisateur attribue à votre
fonction en tant qu’arguments d’entrée et s’ils correspondent à ce que vous vouliez
que ces arguments d’entrée soient. Donc, pour le moment, écrivez vos fonctions
en supposant qu’elles seront utilisées correctement. Vous pouvez aider les autres
utilisateurs à utiliser correctement votre fonction en commentant bien votre code.
Vous pouvez composer des fonctions en attribuant des appels de fonction comme
entrée à d’autres fonctions. Dans l’ordre des opérations, Matlab exécutera d’abord
l’appel de fonction le plus interne. Vous pouvez également affecter des expres-
sions mathématiques comme entrée aux fonctions. Dans ce cas, Matlab exécutera
d’abord les expressions mathématiques.
Essayez ! : Utilisez la fonction myAdder pour calculer la somme de sin(π),

cos(π) et tan(π). Utilisez des expressions mathématiques comme entrée de
myAdder et vérifiez qu’il exécute les opérations correctement.
>> myAdder(sin(pi),cos(pi),tan(pi))
ans =
−1
>> d = myAdder(1*4,2+3,5−8)
d =
6
Les fonctions Matlab peuvent avoir plusieurs arguments de sortie. L’exemple

montre comment écrire et appeler une fonction qui a plusieurs arguments de sortie et
comment effectuer des affectations à toutes ses sorties. Lors de l’appel d’une fonction
avec plusieurs arguments de sortie, vous pouvez placer une liste de variables que vous
souhaitez affecter à l’intérieur de crochets séparés par des virgules.
Construction ! : Considérez la fonction suivante (notez qu’elle a plusieurs

arguments de sortie) :
function [c,d] = myTrigSum(a,b)
% [c,d] = myTrigSum(a,b) computes
% a trigonometric sum of a and b
% c = sin(a) + cos(b);
% d = sin(b) + cos(a);
c = sin(a) + cos(b);
d = sin(b) + cos(a);
end
Essayez ! : Calculez la fonction myTrigSum pour a = 2 et b = 3. Affectez le

premier argument de sortie à la variable A et le deuxième argument de sortie à
la variable B.
>> [A,B] = myTrigSum(1,2)
A =
0.4253
B =
1.4496
Si vous effectuez moins d’affectations qu’il n’y a de variables de sortie, Matlab

n’effectuera que les premières affectations et le reste sera supprimé. Essayez de ne
pas le faire à moins que vous ne sachiez spécifiquement que vous souhaitez que la
valeur de sortie soit ignorée.
Essayez ! : Affectez le premier argument de sortie à la variable A et supprimez

le deuxième argument de sortie dans l’exemple précédent.
>> A = myTrigSum(1,2)
A =
0.4253
Attention ! : Les angles dans Matlab sont généralement exprimés en ra-

dian. Pour cela, les fonctions trigonométriques doit recevoir les valeurs en radian.
Afin de considérer des angles en degré, vous pouvez soit utiliser les fonctions sind
3.3. FONCTIONS 49
, cosd etc. où, simplement, convertir tout angle en degré et éviter toute sources
d’erreur possible.
Lors de l’écriture de fonctions, vous pouvez oublier d’affecter l’une des sorties si
votre fonction est compliquée. Si tel est le cas, Matlab s’arrêtera et vous obtiendrez
une erreur. Considérez le code erroné suivant où la variable de sortie d n’est pas
affectée.
Essayez ! : Exécutez le code erroné précédent pour les mêmes entrées que
dans l’exemple précédent. Prenez note de l’erreur signalée.
>> [A,B] = myTrigSum(1,2)
Output argument d (and maybe others) not assigned during call to
myTrigSum.
Un autre mot-clé utile est return. Lorsque Matlab voit une instruction de
return, il termine immédiatement la fonction comme s’il avait exécuté l’instruction
de fin de la fonction end. Si l’un des arguments de sortie n’a pas été affecté lorsqu’une
instruction de retour est effectuée, vous obtiendrez une erreur.
3.3.2 Espace de travail des fonctions

Nous avons introduit l’idée de l’espace de travail (Workspace) où les variables
créées à l’invite de commande sont stockées. Une fonction possède également un
espace de travail (Function Workspace). Un espace de travail de fonction est un
espace dans la mémoire de l’ordinateur qui est réservé aux variables créées dans
cette fonction. Cet espace de travail n’est pas partagé avec l’espace de travail de
la fenêtre de commande. Par conséquent, une variable portant un nom donné peut
être affectée dans une fonction sans modifier une variable portant le même nom en
dehors de la fonction. Un espace de travail de fonction est ouvert chaque fois qu’une
fonction est appelée.
Essayez ! : Quelle sera la valeur de la variable out après l’exécution des

lignes de code suivantes ? Notez qu’il ne s’agit pas de 14, qui est la valeur de
sortie assignée à l’intérieur de myAdder.
>> out = 1
out =
1
>> d = myAdder(1,3,10);
>> out
out =
1
Dans myAdder, la variable out est une variable locale. C’est-à-dire qu’elle n’est
définie que dans l’espace de travail de la fonction myAdder. Par conséquent, il ne
peut pas affecter les variables dans les espaces de travail en dehors de la fonction, et
les actions effectuées dans les espaces de travail en dehors de la fonction ne peuvent
pas l’affecter, même s’ils portent le même nom. Ainsi, dans l’exemple précédent, il
existe une variable, out, définie dans l’espace de travail de la fenêtre de commande.
Lorsque myAdder est appelé sur la ligne suivante, Matlab ouvre un nouvel espace
de travail pour les variables de cette fonction. L’une des variables créées dans cet
espace de travail est une autre variable, out. Cependant, comme ils ont des espaces
de travail différents, l’affectation à out dans myAdder ne modifie pas la valeur affectée
à out dans l’espace de travail de la fenêtre de commande.
C’est l’une des raisons pour lesquelles il est dangereux de garder des lignes de
code non supprimées dans vos fonctions. Nous modifions la fonction myAdder afin
qu’elle n’ait pas de point-virgule après la ligne out = a + b + c, et ait la commande
additionnelle attribuant la valeur 2 à la variable y (également non supprimée).
Essayez ! : Modifiez votre fonction myAdder de la manière suivante.

function d = myAdder(a,b,c)
% d = myAdder(a,b,c)
% d is the sum of a, b and c
d = a + b + c
y = 2
end
Essayez ! : Avec la fonction myAdder modifiée, quelle est la valeur de out

après l’exécution du code suivant ?
>> out = 1;
>> d = myAdder(1,3,10);
out =
14
y =
2
>> out
out =
1
> y
Undefined function or variable 'y'.
Dans l’exemple précédent, la valeur de out était affichée lorsque la ligne out =
a + b + c était exécutée dans myAdder. Cela signifie que la variable out affichée
est la sortie de l’espace de travail de myAdder, et non de l’espace de travail de la
3.3. FONCTIONS 51
fenêtre de commande où la variable out a la valeur 1. Par conséquent, l’affectation

à out à l’intérieur de la fonction n’a pas affecté la variable out à l’extérieur. De
même, la variable y a été créée à l’intérieur de l’espace de travail de la fonction
et n’est pas une variable de sortie. Par conséquent, il n’existe pas dans l’espace de
travail de l’invite de commande. Donc, pour un dernier avertissement, assurez-vous
de supprimer l’affichage des instructions effectuées à l’intérieur d’une fonction.
Les exemples suivants sont conçus pour être des exercices dans l’espace de travail
des fonctions. Ils sont intentionnellement très déroutants, mais si vous pouvez les
démêler, vous comprenez probablement l’espace de travail des fonctions. Concentrez-
vous sur ce que Matlab fait exactement, dans l’ordre dans lequel Matlab le fait.
Essayez ! : Considérez la fonction suivante :

function [x,y] = myWorkSpaceTest(a,b)
% [x,y] = myWorkSpaceTest(a,b)
x = a + b;
y = x * a;
z = y * b;
end
Essayez ! : Quelle sera la valeur de a, b, x, y et z après l’exécution du code

suivant ?
>> a = 2;
>> b = 3;
>> z = 1;
>> [y,x] = myWorkSpaceTest(b,a)
y =
5
x =
15
>> z
z =
1
Essayez ! : Quelle sera la valeur de a, b, x, y et z après l’exécution du code

suivant ?
>> x = 2;
>> y = 1;
>> [a,b] = myWorkSpaceTest(y,x)
a =
b =
3
>> z
Undefined function or variable 'z'.
3.3.3 Chemin de Matlab

Lorsqu’une fonction est appelée à l’invite de commande ou depuis une fonction,
Matlab doit rechercher le fichier m qui lui indique comment exécuter cette fonc-
tion. Matlab recherche cette fonction via le chemin Matlab (Matlab Path),
qui correspond à l’ordre dans lequel Matlab recherche une fonction lorsqu’elle est
appelée. Lorsque Matlab est invité à exécuter une fonction, il recherche d’abord
cette fonction dans le répertoire de travail ou en tant que sous-fonction (décrit dans
la section suivante). S’il ne se trouve pas dans le répertoire de travail ou dans une
sous-fonction, Matlab recherchera dans les dossiers le long du chemin Matlab
jusqu’à ce qu’il trouve le fichier m approprié à exécuter. Si Matlab arrive à la fin
du chemin sans trouver la fonction demandée, il renvoie une erreur indiquant que la
fonction demandée est introuvable.
Essayez ! : Essayez d’appeler une fonction inexistante pour la valeur d’entrée,

4, et affectez la sortie à la variable, a.
>> a = null_function(4)
Undefined function or variable 'null_function'.
S’il y a deux fonctions avec le même nom dans le chemin de Matlab, Matlab
exécutera la fonction en premier dans le chemin Matlab. Écrire une fonction avec le
même nom qu’une autre fonction et la placer plus haut dans le chemin Matlab s’ap-
pelle surcharger une fonction (Overloading). La surcharge fait également référence
au fait de donner aux variables le même nom que les fonctions que vous avez écrites.
La surcharge est utile lorsque vous souhaitez effectuer une tâche différemment de
la normale au cours d’un projet particulier. Par exemple, vous pouvez surcharger
la fonction sin avec votre propre fonction qui calcule sin avec une précision de
100 chiffres. Cependant, il est facile de surcharger des fonctions que vous n’avez pas
l’intention de faire, comme nommer une fonction ou un gradient de variable, qui est
en fait une fonction Matlab. Par conséquent, il est important de donner à votre
fonction un nom qui sera très probablement unique. Dans ce cours, nous ajoutons le
mot my au début de chaque nom de fonction pour éviter de surcharger les fonctions
Matlab.
Vous pouvez afficher l’éditeur des chemins Matlab en cliquant sur : Home -
> Environement -> Set path. Le chemin est illustré à la figure 3.2. Vous pouvez
3.3. FONCTIONS 53
Figure 3.2 – Éditeur des chemins Matlab R2017a
modifier le chemin sous :set Matlab path. Cependant, pour notre objectif, nous ne
le ferons jamais.
3.3.4 Sous-fonctions
Une fois que vous avez créé et enregistré une nouvelle fonction, elle se comporte
comme n’importe quelle autre fonction intégrée de Matlab. Vous pouvez appeler
la fonction à partir de l’invite de commande, et toute autre fonction peut également
appeler la fonction. Une sous-fonction (subfunction) est une fonction définie dans
le même fichier m que sa fonction parent. Seule la fonction mère est capable d’appeler
la sous-fonction. Cependant, la sous-fonction conserve un espace de travail distinct
de sa fonction parent. Une sous-fonction est déclarée après l’instruction end de sa
fonction parent, et elle doit avoir une instruction end à la fin de sa propre définition.
Essayez ! : Considérez la fonction et la sous-fonction suivantes enregistrées

dans un seul fichier appelé myDist3D.m :
function D = myDist3D(x,y,z)
% D = myDist3D(x,y,z)
% x,y,z are 2D coordinates contained in 1x2 arrays
% D(1) is the distance between x and y
% D(1) is the distance between x and z
% D(1) is the distance between y and z
D(1) = myDist(x,y);
D(2) = myDist(x,z);
D(3) = myDist(y,z);
end
function D = myDist(x,y)
% D = myDist(x,y) subfunction for myDist3D
% x,y are 2D coordinates contained in 1x2 arrays
% D is the distance between x and y
D = sqrt((x(1)−y(1))^2+(x(2)−y(2))^2);
end
Notez que les variables D, x et y apparaissent à la fois dans myDist3D et myDist.

Ceci est permis car une sous-fonction a un espace de travail séparé de sa fonction
parent. Les sous-fonctions sont utiles lorsqu’une tâche doit être exécutée plusieurs
fois dans la fonction mais pas en dehors de la fonction. De cette manière, les sous-
fonctions aident la fonction parent à effectuer sa tâche sans encombrer le répertoire
de travail avec des fichiers m supplémentaires.
Essayez ! : Appelez la fonction myDist3D pour x = [0 0], y = [0 1], z =

[1 1]. Essayez d’appeler la sous-fonction myDist à partir de l’invite de com-
mande :
>> D = myDist3D([0 0],[0 1], [1 1])
D =
1.0000 1.4142 1.0000
>> d = myDist([0 0],[0 1])

Undefined function or variable 'myDist'.
Voici le code répété sans utiliser de sous-fonctions. Remarquez à quel point la

fonction semble plus occupée et encombrée et à quel point il est plus difficile de
comprendre ce qui se passe. Notez également que cette version est beaucoup plus
sujette aux erreurs car vous avez trois chances de mal saisir la formule de distance.
Essayez ! : Appelez la fonction myDist3D pour x = [0 0], y = [0 1], z =

[1 1]. Essayez d’appeler la sous-fonction myDist à partir de l’invite de com-
mande :
function D = myDist3D(x,y,z)
% D = myDist3D(x,y,z)
% x,y,z are 2D coordinates contained in 1x2 arrays
% D(1) is the distance between x and y
% D(1) is the distance between x and z
% D(1) is the distance between y and z
D(1) = sqrt((x(1)−y(1))^2+(x(2)−y(2))^2);
D(2) = sqrt((x(1)−z(1))^2+(x(2)−z(2))^2);
D(3) = sqrt((y(1)−z(1))^2+(y(2)−z(2))^2);
end
3.3. FONCTIONS 55
Notez que Matlab parcourra la liste des sous-fonctions avant d’accéder au che-
min Matlab. Par conséquent, si une sous-fonction surcharge une autre fonction
dans le chemin Matlab, la sous-fonction aura priorité sur cette fonction lorsqu’elle
sera appelée par sa fonction parent.
3.3.5 Fonctions de manipulation

Jusqu’à présent, vous avez affecté différentes structures de données à des noms
de variables. Pouvoir attribuer une structure de données à une variable nous permet
de transmettre des informations aux fonctions et d’en récupérer les informations
de manière propre et ordonnée. Parfois, il est utile de pouvoir passer une fonction
en tant que variable à une autre fonction. En d’autres termes, l’entrée de certaines
fonctions peut être d’autres fonctions. Pour ce faire, nous avons besoin des fonc-
tion de manipulation (Function handles). Les fonctions de manipulation sont des
variables auxquelles des fonctions ont été affectées comme valeur. Une fonction de
manipulation est créée en plaçant un symbole @ devant une fonction dans le chemin
actuel, puis en utilisant l’opérateur d’affectation.
Essayez ! : Affectez la fonction sin à une variable f. Vérifiez que f est de

type Function handle à l’aide de la fonction de class.
>> f = @sin
f =
function_handle with value:
@sin
>> class(f)
ans =
'function_handle'
Dans l’exemple précédent, f est maintenant équivalent à la fonction sin. Tout

comme x = 1 signifie que x et 1 sont interchangeables, f et la fonction sin sont
désormais interchangeables.
Essayez ! : Calculez la valeur sin(π/4) à l’aide de la fonction f. Vérifiez que

cela est correct !
>> f(pi/4)
ans =
0.707106781186547
>> sin(pi/4)
ans =
0.707106781186547
Essayez ! : Programmez une fonction appelée myFunPlusOne qui prend

une fonction de manipulation, F, et une valeur x comme arguments d’entrée.
myFunPlusOne devrait renvoyer F évalué à x, et le résultat ajouté à la valeur 1.
Vérifiez que cela fonctionne pour différentes fonctions et valeurs de x.
function y = plusOne(F,x)
% y = plusOne(F,x)
% F is a function handle and x is a float
% y = F(x) + 1
y = F(x) + 1;
end
>> y = plusOne(@sin, pi/2)

y =
2
>> y = plusOne(@cos, pi/2)

y =
1
>> y = plusOne(@sqrt, 4)
y =
3
L’utilisation des fonctions de manipulation nécessite que la fonction affectée à une

variable soit enregistrée dans le répertoire courant. Une fonction anonyme (Ano-
nymous function) est une fonction de manipulation affecté à une fonction non
stockée. Une fonction anonyme est créée selon la construction suivante :
Construction ! : Déclaration d’une fonction anonyme.

F = @(inputs) Definition
Essayer ! : Créez la fonction polynomiale anonyme suivante : f (x, y) = x2 +

xy + 1. Vérifiez que f se comporte de la même manière que ledit polynôme.
>> F = @(x,y) x^2 + x*y + 1;
3.4. EXERCICES 57
>> F(1,0)
ans =
2
3.4 Exercices
1. Rappelons que le sinus hyperbolique, noté sinh, est exp(x)−exp(−x)
2
. Écrire une
fonction avec l’en-tête y = mySinh(x), où y est le sinus hyperbolique évalué
en x. Supposons que x est un double. Testez votre fonction :
>> sinh(0)
ans =
0
>> sinh(1)
ans =
1.1752
>> sinh(2)
ans =
3.6269
2. Écrivez une fonction avec l’en-tête A = myTriangle(b,h) où A est l’aire d’un

triangle de base b et de hauteur h. Rappelons que l’aire d’un triangle est égale
à la moitié de la base multipliée par la hauteur. Supposons que b et h soient
des doubles.
Testez votre fonction :
>> A = myTriangle(1,1)
A =
0.5000
A =
1
A =
3
3. Écrivez une fonction avec l’en-tête M = myCheckerBoard(n), où M est une ma-

trice n × n de la forme suivante :

 
1 0 1 0 1
0 1 0 1 0
 
M = 1 0 1 0 1
0 1 0 1 0
1 0 1 0 1
Notez que l’élément supérieur gauche doit toujours être 1. Supposons que n
est un entier strictement positif. Testez votre fonction :
>> M = myCheckerBoard(1)
M =
1
M =
1 0
0 1
M =
1 0 1
0 1 0
1 0 1
M =
1 0 1 0
0 1 0 1
1 0 1 0
0 1 0 1
4. Écrivez une fonction avec l’en-tête [S,V] = myCylinder(r,h), où r et h sont

respectivement le rayon et la hauteur d’un cylindre, et S et V sont respective-
ment la surface et le volume du même cylindre. Rappelons que la surface d’un
cylindre est S = 2πr2 + 2πrh et que le volume est V = πr2 h. Supposons que
r et h soient des doubles.
>> [S,V] = myCylinder(1,5)
S =
37.6991
V =
15.7080
>> [S,V] = myCylinder(2,3)

S =
3.4. EXERCICES 59
62.8319
V =
37.6991
5. Écrivez une fonction avec l’en-tête M = myFlippedDiag(n,a), où M est une

matrice carrée définie ci-dessous, n est un entier positive qui représente la
taille de M et a est un double :
 
0 a a a a
a 0 a a a
 
M =a a 0 a a
a a a 0 a
a a a a 0

>> M = myFlippedDiag(2,3)
M =
0 3
3 0
>> M = myFlippedDiag(4,9)
M =
0 9 9 9
9 0 9 9
9 9 0 9
9 9 9 0
6. Écrivez une fonction avec l’en-tête indices = myWithinTolerance(A, a,

tol), où indices est un tableau des indices dans A tel que |A − a| < tol.
Supposons que A est un tableau de doubles unidimensionnel et que a et tol
sont des doubles. Testez votre fonction :
>> I = myWithinTolerance([2 3 4 5], 4, 1)
I =
2 3 4
>> I = myWithinTolerance(0:0.01:1, .5, .02)

I =
50 51 52
Chapitre 4
Boucles et contrôle de flux
4.1 Introduction
Lors de l’écriture de scripts ou fonctions, il est très courant de vouloir que cer-
taines parties du corps du code ne soient exécutées que sous certaines conditions,
en outre, des parties doivent être exécutées plusieurs fois en séries. Par exemple, si
l’argument d’entrée est impair, vous souhaiterez peut-être que la fonction effectue
une opération dessus, et une autre si l’argument d’entrée est pair. Cet effet peut
être obtenu dans Matlab à l’aide d’instructions de branchement (c’est-à-dire l’exé-
cution des branches de la fonction sous certaines conditions), qui font l’objet de ce
chapitre.
Par ailleurs, étant donné que les tâches répétitives apparaissent si fréquemment,
il est naturel que les langages de programmation comme Matlab disposent de
méthodes directes pour effectuer des itérations.
Ce chapitre vous apprend à programmer des tâches itératives. Avec le branche-
ment et l’itération, il est possible de programmer à peu près n’importe quelle tâche
imaginable.
4.2 Conditions : Instructions de branchement

4.2.1 Condition ’if’
Une instruction de branchement if-else ou encore instruction if en abrégé,
est une construction de code qui exécute des blocs de code uniquement si certaines
conditions sont remplies. Ces conditions sont représentées sous forme d’expressions
logiques. Soit P, Q et R des expressions logiques dans Matlab. Ce qui suit montre
une construction d’instruction if.
Construction ! : Syntaxe simple de l’instruction if :

if Logical expression
Code block
end
61
62 CHAPITRE 4. Boucles et contrôle de flux
Le mot if est un mot-clé. Une instruction if se termine par le mot clé end.
Lorsque Matlab voit une instruction if, il détermine si l’expression logique associée
est vraie. Si c’est vrai, alors le code dans le bloc de code sera exécuté par Matlab.
S’il est faux, le code de l’instruction if ne sera pas exécuté. La façon de lire ceci est
’Si l’expression logique est vraie, alors faire le bloc de code’.
Lorsqu’il y a plusieurs conditions à prendre en compte, vous pouvez inclure des
instructions elseif ; si vous voulez une condition qui couvre tout autre cas, vous
pouvez utiliser une instruction else.
Construction ! : Syntaxe étendue de l’instruction if-else :

if Logical expression P
Code block 1
elseif Logical expression Q
Code block 2
elseif Logical expression R
Code block 3
else
Code block 4
end
Dans le code précédent, Matlab vérifiera d’abord si P est vraie. Si c’est le cas,
alors le bloc de code 1 sera exécuté, puis l’instruction if se terminera. En d’autres
termes, Matlab ne vérifiera pas le reste des déclarations une fois qu’il aura atteint
une déclaration vraie. Cependant, si P est fausse, Matlab vérifiera si Q est vraie. Si
Q est vraie, alors le bloc de code 2 sera exécuté et l’instruction if se terminera. S’il est
fausse, alors R sera vérifiée, et ainsi de suite. Si P, Q et R sont toutes fausses, alors le
bloc de code 4 sera exécuté. Vous pouvez avoir n’importe quel nombre d’instructions
elseif (ou aucune) tant qu’il y a au moins une instruction if (la première instruc-
tion). Vous n’avez pas besoin d’une instruction else, mais vous pouvez avoir au plus
une instruction else. Les expressions logiques après if et elseif (c’est-à-dire telles
que P, Q et R) seront appelées des instructions conditionnelles.
Essayé ! : Ecrire une fonction avec l’entête mention = mymention(note), la

valeur de la mention doit être la chaîne 'Excellent' si la note est supérieure
ou égale à 16, 'Bien' si la note est supérieure ou égale à 14, 'Assez Bien' si la
note est supérieure ou égale à 12, 'Passable' si la note est supérieure ou égale
à 10, sinon la mention prend la chaîne 'Ajourne' :
function mention = mymention(note)
% mention = mymention(note) retoune la mention
% d'un etudiant en fonction de sa note
if note >= 16
mention = 'Excellent';
4.2. CONDITIONS : INSTRUCTIONS DE BRANCHEMENT 63
elseif note >= 14

mention = 'Bien';
elseif note >= 12
mention = 'Assez bien';
elseif note >= 10
mention = 'Passable';
else
mention = 'Ajourne';
end % Fin de la condition
end % Fin de la fonction
% Sur la fenetre de commande

>> mention = mymention(13.5)
mention =
'Assez bien'

mention =
'Excellent'

mention =
'Ajourne'
Attention, si une condition est vérifiée, le code ne lira pas les conditions qui se
situent après. Alors, l’ordre de chaque condition doit être bien choisi.
Exemple ! : Quelle sera la valeur de y après l’exécution du code suivant ? :

% Dans un Script
x = 3;
if x > 1
y = 'Sup a 1';
elseif x > 2
y = 'Sup a 2';
else
y = 'Aucune condition n est verifiee';
end

y =
'Sup a 1'
Remarquez que la deuxième condition ne peut être jamais atteinte. Nous pou-
vons également insérer des instructions conditionnelles plus compliquées à l’aide
d’opérateurs logiques.
Exemple ! : Quelle sera la valeur de y après l’exécution du code suivant ? :

% Dans un Script
x = 3;
if x > 1 && x < 2
y = 'Sup a 1 et inf a 2';
elseif x > 2 && x < 4
y = 'Sup a 2 et inf a 4';
else
y = 'Aucune condition n est verifiee';
end

y =
'Sup a 2 et inf a 4'
Attention ! : AU contraire de quelques langages de programmation, la l’ex-

pression logique a < x < b s’écrit par deux expression conditionnelles x < a &&
x > b. Taper a < x < b aura des résultats inattendus et indésirables.
Il existe de nombreuses fonctions logiques conçues pour vous aider à créer des
instructions de branchement. Par exemple, vous pouvez demander si une variable
a un certain type de données ou une certaine valeur avec des fonctions telles que
isreal, isnan, isinf et isa. Il existe également des fonctions qui peuvent vous
donner des informations sur les tableaux de logiques comme any, qui retourne vrai si
un élément d’un tableau est vrai, et faux sinon, et all, qui retourne vrai uniquement
si tous les éléments d’un tableau sont vrais.
Parfois, vous voudrez peut-être concevoir votre fonction pour vérifier les entrées
d’une fonction afin de vous assurer que votre fonction sera utilisée correctement. Par
exemple, la fonction myAdder du chapitre précédent attend des doubles en entrée. Si
l’utilisateur saisit une structure ou un caractère comme l’une des variables d’entrée,
la fonction générera une erreur ou aura des résultats inattendus. Pour éviter cela,
vous pouvez mettre une coche pour indiquer à l’utilisateur que la fonction n’a pas été
utilisée correctement. Cette technique et d’autres techniques de contrôle des erreurs
ne font pas l’objet de ce cours. Pour le moment, vous devez seulement savoir que la
fonction error arrête l’exécution d’une fonction et génère une erreur avec le texte
dans la chaîne d’entrée. La fonction d’erreur prend des entrées de type sprintf.
Exemple ! : Modifiez myAdder pour générer une erreur si l’utilisateur n’entre

pas de doubles. Essayez votre fonction pour les entrées non doubles pour montrer
que la vérification fonctionne. :
function out = myAdder(a,b,c)
% out = myAdder(a,b,c)
% out is the sum of a, b and c
% Verifier les entrees erronees

if ~isa(a,double) || ~isa(b,double) || ~isa(c,double)
error('Inputs a, b and c must be doubles')
end
% Passer a l'objectif de la fonction

out = a + b + c;
end

>> out = myAdder(2,5,−3)
out =
4
>> out = myAdder(2,'5',−3)

Error using myAdder
Inputs a, b and c must be doubles
Essayé ! : Écrivez une fonction appelée isOdd qui renvoie ’impaire’ si l’entrée
est impaire et ’paire’ si elle est paire. Vous pouvez supposer que l’entré sera un
entier positif :
function out = isOdd(in)
% out = isOdd(in)
% returne 'impaire' si in est impaire
% et 'paire' si in est paire

if ~isa(in,double) || mod(in,1) ~=0 || in < 0
error('L entre in doit etre un entier positif')
end
% Evaluer le type de l'entre

if mod(in,2) == 0
out = 'paire';
else
out = 'impaire';
end
end

>> isOdd(3.25)
Error using isOdd
L entre in doit etre un entier positif
>> isOdd(17)
ans =
'impaire'
>> isOdd(32)
ans =
'paire'
La fonction reste, mod(a,b), renvoie le reste d’un nombre a divisé par b. L’énoncé
logique if mod(a, 2)== 0 demande ’est-ce que le reste de in divisé par 2 est
égal à 0 ?’ Si le résultat est vrai alors a est paire, sinon, alors a est impaire.
Essayé ! : Écrivez une fonction appelée myCircCalc qui prend un double

r et une chaîne calc comme arguments d’entrée. Vous pouvez supposer que r
est positif et que calc est soit la chaîne aire soit circumference. La fonction
myCircCalc doit calculer l’aire d’un cercle de rayon r, si la chaîne calc est aire
et la circonférence d’un cercle du même rayon, si calc est circumference. La
fonction doit être vectorisée pour r :
function out = myCircCalc(r, calc)
% out = myCircCalc(r, calc)
% retourne l'aire d'un cercle de rayon r si calc = 'area'
% et retourne la circonfairence du meme cercle si calc = '
circumference'

if ~isa(r, 'double') || r < 0 || ~isa(calc, 'char')
error('r doit etre un double positif et calc un string')
end
% Calcul
if strcmp(calc, 'area')
out = pi*r.^2;
elseif strcmp(calc, 'circumference')
out = 2*pi*r;
else
error('calc doit prendre les valeurs: area ou circumference')
end
end

>> myCircCalc(5, 'Aire')
Error using myCircCalc
calc doit prendre les valeurs: area ou circumference
>> myCircCalc(1, 'area')

ans =
3.1416
>> myCircCalc(2, 'circumference')

ans =
12.5664
4.2.2 Condition ’switch’

Une instruction de branchement switch bascule entre plusieurs cas en fonction
des valeurs d’une variable. Elle permet l’exécution des blocs de code uniquement si
une variable prend certaines valeurs.
La forme générale de l’instruction switch est :
Construction ! : Syntaxe de l’instruction switch :

switch expression
case cas1, Code block
otherwise Code block
end
Reprenons la fonction mymention et réécrivons la moyennant l’instruction switch

:
Essayé ! : Réécrivez la fonction mymention en utilisant l’instruction switch :

function mention = mymention(note)
% mention = mymention(note) retoune la mention
% d'un etudiant en fonction de sa note
switch floor(note/2)
case 9, mention = 'Excellent';
case 8, mention = 'Tres bien';
case 7, mention = 'bien';
case 6, mention = 'assez bien';
case 5, mention = 'Passable';
otherwise, mention = 'Ajourne';
end
>> mymention(19)
ans =
'Excellent'
>> mymention(14.5)
ans =
'bien'
>> mymention(8.75)
ans =
'Ajourne'
Remarquez que l’instruction switch n’utilise pas les relations logiques, mais,
bascule sur de différentes valeurs d’une variable donnée. Dans l’exemple précédent,
la variable choisie est floor(note/2) ce qui a permis de régénérer tous notes ’déci-
males’ entre 10 et 19.99 aux entiers : {5, 6, 7, 8, 9}, cela a facilité la décision de quelle
mention q’on aura. Notez aussi que la fonction Matlab floor retourne la partie
entière d’un double vers moins l’infini.
Essayé ! : Réécrivez la fonction myCircCalc en utilisant l’instruction switch

:
function out = myCircCalc(r, calc)
% out = myCircCalc(r, calc)
% retourne l'aire d'un cercle de rayon r si calc = 'area'
% et retourne la circonfairence du meme cercle si calc = '
circumference'

if ~isa(r, 'double') || r < 0 || ~isa(calc, 'char')
error('r doit etre un double positif et calc un string')
end
% Calcul
switch calc
4.3. BOUCLES : ITÉRATIONS 69
case 'area', out = pi*r.^2;

case'circumference', out = 2*pi*r;
otherwise, error('calc doit prendre les valeurs: area ou
circumference')
end
end

>> myCircCalc(5, 'Aire')
Error using myCircCalc
calc doit prendre les valeurs: area ou circumference
>> myCircCalc(1, 'area')

ans =
3.1416
>> myCircCalc(2, 'circumference')

ans =
12.5664
Notez que l’instruction switch permet de bien gérer les chaînes de caractères
mieux que l’instruction if où on doit utiliser la fonction strcmp pour comparer
deux string.
4.3 Boucles : Itérations

4.3.1 Boucles finies
Une boucle for for loop est une séquence d’instructions qui est répétée, ou itérée,
pour chaque valeur d’un tableau en boucle. La variable qui contient la valeur actuelle
du tableau en boucle est appelée variable en boucle looping variable. Parfois, les
boucles for sont appelées boucles finies definite loops car elles ont un début et une
fin prédéfinis. La syntaxe abstraite d’un bloc de boucle for est la suivante.
Construction ! : Boucle for :

for looping variable = looping array
Code block
end
Une boucle for affecte la variable en boucle au premier élément du tableau en

boucle. Il exécute tout ce qui est dans le bloc de code. Ensuite, il affecte la variable
en boucle à l’élément suivant du tableau et exécute à nouveau le bloc de code.
Il continue ce processus jusqu’à ce qu’il n’y ait plus d’éléments à affecter dans le
tableau en boucle.
Essayer ! : Quelle est la somme de tous les entiers de 1 à 10 ? :

N = 0;
for i = 1:10
N = N + i;
end
Ce qui ce passe ! : Tout d’abord, rappelez-vous que 1 :10 est le tableau [1

2 3 .. 10].
1. La variable N prend la valeur 0
2. La variable i reçoit la valeur 1 (le premier élément du tableau [1 :10])
3. La variable N est affectée de la valeur N + i (0 + 1 = 1)
4. La variable i prend la valeur 2
5. La variable N reçoit la valeur N + i (1 + 2 = 3)
6. La variable i est affectée de la valeur 3
7. La variable N reçoit la valeur N + i (3 + 3 = 6)
8. Ces opérations se répètent jusqu’à la dernière valeur du tableau (10)
Nous présentons plusieurs autres exemples pour vous donner une idée du fonc-
tionnement des boucles for, même si certains de ces exemples pourraient être exécutés
de manière plus concise avec des opérations de tableaux.
Exemple ! : Étant donné un tableau unidimentionnel d’entiers strictement

positifs A, calculez la somme de tous les éléments de A. Rappelez-vous que la
longueur d’un tableau peut être déterminée en utilisant la fonction length. Vous
pouvez supposer que A est défini dans l’espace de travail courant :
S = 0;
for i = 1:length(A)
S = S + A(i);
end
Abstraitement, i représente l’indice de l’élément de A que nous ajoutons à notre

somme totale. S représente la somme des éléments de A jusqu’à l’indice i. Pour A
= [4 1 2], parcourez le code étape par étape et notez chaque action exécutée par
l’ordinateur.
La fonction Matlab sum a déjà été écrite pour gérer l’exemple précédent. Ce-
pendant, supposons que vous souhaitiez ajouter uniquement les nombres pairs d’un
tableau. Qu’ajouteriez-vous au bloc de boucle for précédent pour gérer cette restric-
tion ?
Exemple ! : Étant donné un tableau unidimentionnel d’entiers strictement

positifs, A, n’ajoutez que les éléments pairs de A. Vous pouvez supposer que A
est défini dans l’espace de travail courant. Rappelons qu’un nombre est pair s’il
peut être divisé par 2 sans reste :
S = 0;
for i = 1:length(A)
if mod(A(i), 1) == 0
S = S + A(i);
end
end
Exemple ! : Soit la fonction anyEs de type S (string)-> out (logical).

La variable de sortie, out, doit prendre la valeur 1 s’il y a des E dans la chaîne
d’entrée, S sinon sa valeur prend 0. Supposons que chaque caractère de S est en
minuscule :
function out = anyEs(S)
% out = anyEs(S) retourne 1
% s'il y a une lettre 'E' au minimum
% dans la chaine S, sinon sa retourne 0
% commencer par supposer qu'il n'y a pas de E dans S

out = 0;
% Verifions chaque caractere de S, est ce qu'il est une E

for i = 1:length(S)
if strcmp(S(i), 'e')
% si S(i) est une lettre e, alors il y a au moin un 'e'
out = 1;
% La variable de sortie est affectee, alors ce n'est pas

la peine
% de continuer a boucler
break
end
end % Fin de la boucle
end
La première étape de la fonction anyEs suppose qu’il n’y a pas de E dans S

(c’est-à-dire que la sortie est 0 ou faux). Ce n’est pas une hypothèse triviale, car
nous aurions tout aussi bien pu commencer en supposant qu’il y avait un E dans
S (c’est-à-dire que la sortie est vraie). La raison pour laquelle il est plus facile de
commencer en supposant qu’il n’y a pas de E dans S est que si jamais nous en
trouvons un, alors nous savons que notre hypothèse de départ était fausse et que
la sortie devrait être vraie et nous pouvons arrêter de chercher. Cependant, si nous
commençons par supposer qu’il y a un E dans S, alors si nous trouvons un caractère
qui n’est pas un E, cela ne dit rien quant à savoir si notre hypothèse de départ
était vraie ou non, et nous devons continuer à chercher. Comme exercice, essayez de
réécrire anyEs en partant de l’hypothèse qu’il y a un E dans S (out = 1). Était-ce
plus facile ou plus difficile ? L’expérience en programmation vous aidera à déterminer
quelles hypothèses faciliteront votre tâche de programmation. Le programme utilise
également la fonction strcmp, qui donne 1 si les deux chaînes d’entrée sont identiques
et 0 sinon.
Remarquez le nouveau mot-clé break. S’il est exécuté, le mot-clé break arrête
immédiatement la boucle for la plus immédiate qui le contient ; c’est-à-dire que s’il est
contenu dans une boucle for imbriquée, il n’arrêtera que la boucle for la plus interne.
Dans ce cas particulier, la commande break est exécutée si jamais nous trouvons un
E. Le code fonctionnera toujours correctement sans cette instruction, mais puisque
la tâche est de savoir s’il y a des E dans S, nous n’avons pas à continuer à chercher si
nous en trouvons un. De même, si un humain se voyait confier la même tâche pour
une longue chaîne de caractères, cette personne ne continuerait pas à chercher des
E si elle en avait déjà trouvé un. Les instructions break sont utilisées lorsqu’il se
passe quelque chose dans une boucle for qui vous inciterait à vouloir qu’elle s’arrête
plus tôt. Une commande moins intrusive est le mot-clé continue, qui ignore le code
restant dans l’itération actuelle de la boucle for et continue jusqu’à l’élément suivant
du tableau en boucle.
4.3.2 Boucles imbriquées

Une instruction est dite imbriquée Nested statement si elle est entièrement
contenue dans une autre instruction du même type qu’elle-même. Par exemple, une
boucle for imbriquée est une boucle for entièrement contenue dans une clause d’une
autre boucle for.

2 3 1
Exemple ! : Soit A une matrice bidimentionnelle, A = , défini
1 3 5
dans l’espace de travail courant. Utilisez une boucle for imbriquée pour calculer
la somme de tous les éléments de A. Comment adapteriez-vous ce code pour gérer
A de taille arbitraire ? :
S = 0;
for i = 1:2
for j = 1:3
S = S + A(i,j);
end
end
Attention ! : Bien que cela soit possible, n’essayez pas de modifier la variable
en boucle looping variable à l’intérieur de la boucle for. Cela rendra votre code
très compliqué et entraînera probablement des erreurs.
Exemple ! : Trouver la somme des carrés de chaque nombre de 1 à 10. Deux

exemples sont donnés. Le premier est inapproprié. Le deuxième exemple est
recommandé :
Implémentation inappropriée :
S = 0;
for i = 1:10
i = i^2;
S = S + i;
end
Implémentation propre :
S = 0;
for i = 1:10
S = S + i^2;
end
4.3.3 Boucle indéfinie

Une boucle while ou boucle indéfinie est un ensemble d’instructions qui se répète
tant que l’expression logique associée est vraie. La syntaxe abstraite d’un bloc de
boucle while est la suivante :
Construction ! : Boucle while :

while Logical expression
Code block
end
Lorsque Matlab atteint un bloc de boucle while, il détermine d’abord si l’ex-

pression logique de la boucle while est vraie ou fausse. Si l’expression est vraie, alors
le bloc de code sera exécuté. Si l’expression est fausse, la boucle while se terminera.
Essayer ! : Déterminez le nombre de fois où 8 peut être divisé par 2 jusqu’à

ce que le résultat soit inférieur à 1 :
N = 8;
n = 0;
while N >= 1
N = N / 2;
n = n + 1;
end
n =
4
Ce qui ce passe ! :
1. Tout d’abord, la variable n (compte courant des divisions de N par 2) est
définie sur 0
2. N est défini sur 8 et représente la valeur actuelle que nous divisons par 2
3. La boucle while commence
4. Matlab calcule N >= 1 ou 8 >= 1, ce qui est vrai pour que le bloc de
code soit exécuté
5. N est attribué N = 8/2 = 4
6. n est incrémenté à 1
code soit exécuté
code soit exécuté
code soit exécuté
14. N est attribué N = 1/2 = 0,5
16. Matlab calcule N >= 1 ou 0,5 >= 1, ce qui est faux donc la boucle while
se termine par n = 4
Essayer ! : Une façon amusante de tester la vitesse de votre ordinateur est

de voir jusqu’où il peut compter en une seconde. Notez que la fonction tic dé-
marre une minuterie interne dans Matlab. La fonction toc renvoie le temps en
secondes depuis le dernier tic. Au moment de la rédaction de ce texte, mon or-
dinateur portable Dell Vostro i7 peut compter jusqu’à environ 7 000 000. Pouvez
vous calculer combien s’agit-il d’opérations simples ? :
N = 0;
tic
while toc < 1
N = N + 1;
end
N =
6674322
Vous vous êtes peut-être demandé : ’Et si l’expression logique est vraie et ne
change jamais ?’ et c’est effectivement une très bonne question. Si l’expression logique
est vraie et que rien dans le code de la boucle while ne modifie l’expression, le résultat
est appelé boucle infinie. Les boucles infinies s’exécutent indéfiniment, ou jusqu’à
ce que votre ordinateur tombe en panne ou manque de mémoire.
Exemple ! : Écrire une boucle while qui provoque une boucle infinie :
N = 1;
while N >= 0
N = N + 1;
end
Étant donné que N sera toujours supérieur à 0, quel que soit le nombre d’exé-
cutions de la boucle, ce code ne se terminera jamais. Pouvez-vous changer un seul
caractère pour que la boucle while s’exécute au moins une fois mais ne boucle pas à
l’infini ?
Les boucles infinies ne sont pas toujours faciles à repérer. Considérez les deux
exemples suivants : une boucle infinie et l’autre non. Pouvez-vous déterminer cha-
qu’une ? Au fur et à mesure que votre code devient plus compliqué, il deviendra plus
difficile à détecter.
Exemple ! : Quelle boucle while provoque une boucle infinie ? Rappelons que
la fonction modulo mod(a,b) renvoie le reste de la division a/b :
% 1ere boucle
N = 1;
while N > 0
N = N +/ 2;
end
% 2eme boucle
N = 2;
while N > 0
if mod(N,2) == 0
N = N + 1;
else
N = N − 1;
end
end
Le premier exemple ne fera pas de boucle infinie car finalement N sera si petit
que Matlab ne pourra pas faire la différence entre N et 0.
Que se passe-t-il dans le cas d’une boucle infinie ? Devez-vous forcer Matlab à
s’éteindre, à redémarrer votre ordinateur ou à en acheter un nouveau ? Heureuse-
ment, Matlab vous permet d’arrêter n’importe quel code en appuyant sur ctrl +
c. Si vous pensez que votre code est coincé dans une boucle infinie, ou si vous en avez
juste assez d’attendre qu’il fasse son travail, vous pouvez utiliser cette commande
pour forcer votre code à s’arrêter. Une erreur sera renvoyée à la ligne qui était en
cours d’exécution lorsque ctrl + c a été exécuté.
4.4 Exercices
1. Écrivez une fonction avec l’entête tip = myTipCalc(bill, party), où bill
est le coût total d’un repas et party est le nombre de personnes dans le groupe.
Le pourboire tip doit être calculé comme suit : 15 % pour un groupe stricte-
ment inférieure à six personnes, 18 % pour un groupe strictement inférieure à
huit personnes, 20 % pour un groupe de moins de 11 personnes et 25 % pour
un groupe de 11 personnes ou plus. Testez votre fonction sur des exemples de
même prix et de nombre de personne différent.
2. Écrivez une fonction avec l’entête f = myMultOperation(a,b,operation).
L’argument d’entrée, operation, est une chaîne qui est soit 'plus', 'moins
', 'mult', 'div' ou 'pow', et f doit être calculé comme a+b, a-b, a*b, a/
b, et a^b pour les valeurs respectives des opérations. Assurez-vous de rendre
votre fonction vectorisée. Conseil : si vous utiliser la condition if n’oubliez pas
d’utiliser la fonction strcmp. Testez votre fonction pour toutes les opérations
possibles avec les données suivantes : a = [3 2 1 5], b = [2 4 3 1].
3. Considérez un cercle de rayon r et de centre C(x0 , y0 ) et un point M (x, y),
où C et M sont des vecteurs en 2D contenant les coordonnées dans le plan.
Écrivez une fonction avec l’entête s = myInsideCircle(M,r,C) où s est la
chaîne ’outside’ si le point M est à l’extérieur du cercle, ’border’ si le point M
4.4. EXERCICES 77
est exactement sur le bord du cercle, et ’inside’ si le point est à l’intérieur du

cercle. Testez votre fonction sur les exemples suivants :
— M = [1, 1] ; r = 1 ; C = [0, 0]
— M = [1, 0] ; r = 1 ; C = [0, 0]
— M = [-0.8, 0] ; r = 1 ; C = [0, 0]
4. Écrivez une fonction avec l’entête out = myMakeSize10(x), où x est un ta-
bleau et out est les 10 premiers éléments de x si x a plus de 10 éléments et est
le tableau x rempli avec suffisamment de zéros pour le rendre de taille 10 si x
a moins de 10 éléments. Testez votre fonction sur les deux différents cas.
5. Écrivez une fonction avec l’entête [nRoots, r] = myNRoots(a,b,c) où a, b
et c sont les racines d’un polynôme quadratique Q(x) = ax2 + bx + c, nRoots
vaut 2 si Q a deux racines réelles, 1 si Q a une seule racine et -2 si Q a deux
racines imaginaires, et r est un tableau contenant les racines de Q. Testez votre
fonction sur les exemples suivants :
— Q1 (x) = x2 + 2x − 1
— Q2 (x) = 4x2 − 12x + 9
— Q3 (x) = x2 + 3x + 4
Chapitre 5
Visualisation et traçage
5.1 Introduction
La visualisation des données est généralement le meilleur moyen de transmettre
des idées et des informations techniques importantes, en particulier si les informa-
tions sont composées de très nombreux chiffres. La possibilité de visualiser et de
tracer des données rapidement et de différentes manières est l’une des fonctionnali-
tés les plus puissantes de Matlab.
Matlab dispose de nombreux générateurs graphiques qui vous permettent d’af-
ficher efficacement des tracés, des surfaces, des volumes, des champs vectoriels, des
histogrammes, des animations et de nombreux autres tracés de données. À la fin
de ce chapitre, vous devriez être familiarisés avec les techniques de traçage les plus
courants et disposer de suffisamment d’informations pour explorer le reste.
Il convient de noter que l’interface graphique de Matlab utilise un style de
programmation appelé programmation orientée objet (OOP), qui est une école de
pensée différente du type de programmation présenté dans ce cours. Ainsi nous avons
essayé de vous montrer tout ce qu’il faut savoir pour utiliser ces fonctionnalités sans
entrer dans le détail de leur fonctionnement.
5.2 Graphique 2D
La fonction de traçage de base dans Matlab est plot (x,y). La fonction plot
prend deux tableaux comme arguments d’entrée x et y, et produit un affichage visuel
des points (xi , yi ) respectifs reliés par une ligne solide.
Essayer ! : Étant donné les tableaux x = [0 1 2 3] et y = [1 2 4 9],

utilisez la fonction plot pour produire un graphique de y en fonction de x : Voir
figure 5.1
>> x = [0 1 2 3];
>> y = [1 2 4 9];
>> plot(x,y)
79
80 CHAPITRE 5. Visualisation et traçage
1
0 0.5 1 1.5 2 2.5 3
Figure 5.1 – Exemple de l’utilisation de la fonction plot
Vous remarquerez sur la Figure 5.1 que par défaut, la fonction plot relie chaque
point par une ligne bleue. Pour rendre la fonction lisse, vous devez utiliser une
discrétisation des points plus fine.
Essayer ! : Traçons la fonction f (x) = sin(x) dans l’intérvalle [0 2π] : Voir

figure 5.2(a)
>> x = linspace(0,2*pi,100);
>> y = sin(x);
>> plot(x, y)
1 1
0.8 0.8
0.6 0.6
0.4 0.4
0.2 0.2
0 0
-0.2 -0.2
-0.4 -0.4
-0.6 -0.6
-0.8 -0.8
-1 -1
0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
(a) Tracé de la fonction f (x) = sin(x) (b) Tracé de la fonction f (x) = sin(x) avec un
style modifié
Pour changer le marqueur ou le type de ligne, vous pouvez mettre un troisième

argument d’entrée dans la fonction plot, qui est une chaîne qui indique la couleur
5.2. GRAPHIQUE 2D 81
et le style de ligne à utiliser dans le tracé. Par exemple, plot (x,y,'ro') tracera
les éléments de x contre les éléments de y en utilisant la couleur rouge ’red’ : r, par
des petits cercles : o. Les couleurs et tailles de marqueurs possibles sont indiquées
dans le tableau 5.1.
Color Ligne Marker
b blue - solid o circle
g green . point x x-mark
r red -. dashdot + plus
c cyan : dotted * star
m magenta – dashed s square
y yellow none no line d diamond
k black v triangle
w white ^ triangle
< triangle
> triangle
p pentagram
h hexagram
Table 5.1 – Symboles de couleur et de style de trait.
Essayer ! : Retraçons la courbe précédente avec un style différent 5.2(b) :

>> x = linspace(0,2*pi,100);
>> y = sin(x);
>> plot(x, y, '−.rs')
La courbe est alors tracée avec une ligne ’tiret pointillé’ -., une couleur rouge :
r en plus d’un marqueur carré : s.
Vous pouvez tracer plusieurs ensembles de données dans un seul graphique à
l’aide de la commande hold on. Taper hold on placera tous les tracés suivants sur
le même graphique jusqu’à ce que hold off soit tapé.
Essayer ! : Retraçons les courbes des deux fonctions sin, cos dans un seul
graphe avec des styles différents : Voir figure 5.2(a)
>> hold on
>> plot(x, sin(x), 'bo')
>> plot(x, cos(x), '−g*')
>> hold off
ou, tout simplement :

>> plot(x, sin(x), 'bo', x, cos(x), '−g*')
Il est de coutume en ingénierie de toujours donner à votre tracé un titre et des

étiquettes d’axe afin que les gens sachent de quoi il s’agit. Vous pouvez ajouter un
Traces des courbes sin et cos dans l intervalle [0 6.280000e+00]

1 1
sin
0.8 0.8 cos
0.6 0.6
0.4 0.4
0.2 0.2
f(x)
0 0
-0.2 -0.2
-0.4 -0.4
-0.6 -0.6
-0.8 -0.8
-1 -1
0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
x
(a) Sans annotations (b) Avec annotations
Figure 5.2 – Tracés des fonctions sin, cos dans un seul graphe.
titre à votre tracé à l’aide de la fonction title, qui prend en entrée une chaîne et
place cette chaîne comme titre du tracé. Les fonctions xlabel et ylabel fonctionnent
de la même manière pour nommer vos étiquettes d’axe.
Vous pouvez ajouter également une légende à votre tracé en utilisant la fonction
legend. La fonction legend prend le même nombre de chaînes en entrée que le
nombre d’ensembles de données en cours de tracé. C’est à vous de mettre le nombre
approprié. Si, trop peu, laissera certains de vos ensembles de données sans étiquette,
et s’il est trop nombreux, ignorera les extras et vous donnera un avertissement (figure
5.2(b)).
Essayer ! : Ajoutons un titre, des étiquettes d’axes et une légende à la tracée

précédente : Voir figure 5.2(b)
>> x = linspace(0,2*pi,100);
title(sprintf('Traces des courbes sin et cos dans l intervalle [%d
%0.3g]', x(1), x(end)))
>> xlabel('x')
>> ylabel('f(x)')
>> legend('sin', 'cos')
Astuce ! : Vous pouvez utiliser la fonction sprintf avec la fonction title

pour créer des titres personnalisés. Par exemple, vous pouvez inclure du contenu
spécifique aux données dans votre titre.
Enfin, vous pouvez personnaliser davantage l’apparence de votre tracé à l’aide de

la fonction axis et de la commande de grid. La fonction axis prend un tableau 1
× 4 de la forme [xmin xmax ymin ymax], qui dénote les limites de chaque axe. La
commande grid on ajoute une grille à l’axe, et grid off la supprime. Vous pouvez
également utiliser des options avec la commande axis, telles que axis equal, axis
square, axis tight et plusieurs autres. La description de ces options se trouve
dans la fonction d’aide de la fonction axis
Essayer ! : Utilisez la fonction axis pour modifier les limites de la figure

précédente. Des axes égaux, par exemple 5.3(a) 5.3(b) :
...
>> axis equal
ou des limites d’axes 5.3(b)

>> axis([0 6.28 −1.2 1.2])
Traces des courbes sin et cos dans l intervalle [0 6.28]
sin
2 cos
1.5
Traces des courbes sin et cos dans l intervalle [0 6.28]
1 1 sin
cos
0.5 0.5
f(x)
f(x)
0 0
-0.5 -0.5
-1 -1
0 1 2 3 4 5 6
-1.5
x
-2
0 1 2 3 4 5 6
x
(a) Axes égaux (b) Limites d’axes
Figure 5.3 – Tracés des fonctions sin, cos dans un seul graphe.
Pour ouvrir une nouvelle figure sans écraser la figure actuelle, tapez >> figure.
Pour fermer toutes les figures actuelles, tapez >> close all. Pour effacer le contenu
d’une figure sans fermer la figure, tapez >> clf.
Vous pouvez créer une table de tracés sur une seule figure à l’aide de la fonction
subplot. La fonction subplot prend trois entrées : le nombre de lignes de tracés, le
nombre de colonnes de tracés et sur quel tracé l’appel à la fonction de traçage doit
tracer.
Il existe plusieurs autres fonctions de traçage qui tracent les données x par rap-
port à y. Certains d’entre eux sont scatter, bar, loglog, semilogx et semilogy.
scatter fonctionnent exactement de la même manière que plot sauf qu’il utilise par
défaut des cercles bleus (c’est-à-dire que plot(x,y,'bo') est équivalent à scatter
(x,y)). La fonction bar trace des barres centrées en x avec une hauteur y. Les
fonctions loglog, semilogx et semilogy tracent les données en x et y avec une
échelle logarithmique, l’axe x sur une échelle logarithmique et l’axe y sur une échelle
linéaire, et l’axe y sur une échelle logarithmique et l’axe des x sur une échelle linéaire,
respectivement.
Astuce ! : Lors de la création de tracés compliqués, il est utile de créer un

fichier script qui génère le tracé plutôt que de le générer à partir de l’invite de
commande. Si et quand vous faites une erreur, vous devrez ressaisir de nom-
breuses commandes, chacune vous donnant de nouvelles opportunités de faire
d’autres erreurs. Avec un fichier de script, vous pourrez changer la ligne erronée
puis relancer le script pour faire l’intrigue.
Essayer ! : Créez un subplot 2 × 3 où chaque sous-tracé trace x par rapport

à y à l’aide des fonctions citées ci-dessus. Intitulez et étiquetez chaque sous-tracé
de manière appropriée. Utilisez une grille, mais la légende n’est pas nécessaire.
Utilisez les données suivante ; x = [1 2 3 4] et y = exp(x). Voir figure 5.4
% Script for generating subplots
%% Clean start
clear
clc
close all
%% Define data
x = 0:4;
y = exp(x);
%% Create subplots
subplot(2,3,1)
plot(x,y)
title(plot)
grid on
subplot(2,3,2)
scatter(x,y)
title(scatter)
grid on
subplot(2,3,3)
bar(x,y)
title(bar)
grid on
subplot(2,3,4)
semilogx(x,y)
title(semilogx)
grid on
plot scatter bar

60 60 60
40 40 40
20 20 20
0 0 0
0 1 2 3 4 0 1 2 3 4 0 1 2 3 4
semilogx semilogy loglog

60 102 102
40
101
20 101
0 100
1 2 3 4 0 1 2 3 4 1 2 3 4
Figure 5.4 – Exemple de l’utilisation de la fonction subplot
subplot(2,3,5)
semilogy(x,y)
title(semilogy)
grid on
subplot(2,3,6)
loglog(x,y)
title(loglog)
grid on
5.3 Graphique 3D
5.3.1 Courbes paramétriques
La fonction de traçage 3D de base est plot3, qui a l’en-tête : H = plot3(x,y,z)
où x, y et z sont des vecteurs. La fonction plot3 tracera toutes les coordonnées (x,
y, z) et l’appel par défaut à plot3 relie les points suivants par une ligne bleue. Les
commandes telles que grid, hold, axis, title, xlabel, ylabel, legend et subplot
fonctionnent de la même manière que lors du traçage en deux dimensions.
Figure 5.5 – Tracé d’un hélice par la fonction plot3
Essayer !: Traçons l’hélice à pas constant dont l’équation paramétrique est
 x = cos(t)
la suivante : y = sin(t)
z = 2t

Créez un tracé tridimensionnel de l’ensemble de données (x, y, t) à l’aide de la
fonction plot3. Activez la grille, rendez les axes égaux et mettez des étiquettes
d’axe et un titre. Voir figure 5.5
% Script for generating helix 3D plot
% Data
t = 0:pi/50:10*pi;
x = cos(t);
y = sin(t);
z = 2 * t;
% 3D plot
plot3(x,y,z)
xlabel('x')
ylabel('y')
zlabel('z')
title('Helice a pas constant')
axis square
grid on
5.3.2 Surfaces
Souvent, nous aimerions un tracé de surface plutôt qu’une courbe lors du tra-
çage en trois dimensions. Dans le tracé de surface tridimensionnel, nous souhaitons
créer un graphique d’une fonction f (x, y). Dans le tracé de surface, toutes les paires
(x, y) doivent être données. Ce n’est pas simple à faire en utilisant des vecteurs. Par
conséquent, dans le traçage de surface, la première structure de données que vous
devez créer s’appelle un maillage. Étant donné les vecteurs de valeurs x et y, un
maillage est une liste de toutes les combinaisons possibles de x et y. Dans Mat-
lab, le maillage est donné sous la forme de deux matrices X et Y où X(i, j) et
Y (i, j) définissent des paires (x, y) possibles. Une troisième matrice, Z, peut alors
être créée telle que Z(i, j) = f (X(i, j), Y (i, j)). Un maillage peut être créé à l’aide
de la fonction meshgrid dans Matlab. La fonction meshgrid a l’en-tête [X,Y]
= meshgrid(x,y), où x et y sont des vecteurs contenant l’ensemble de données
indépendantes. Les variables de sortie X et Y sont telles que décrites précédemment.
Essayer ! : Créer un maillage des vecteurs x = 1 2 3 4 et y = 3 4 5

en utilisant la fonction meshgrid :

>> x = 1:4;
>> y = 3:5;
>> [X,Y] = meshgrid(x,y)
X =
1 2 3 4
1 2 3 4
1 2 3 4
Y =
3 3 3 3
4 4 4 4
5 5 5 5
Il existe plusieurs fonctions dans Matlab pour tracer des surfaces. Chaque fonc-
tion a un aspect différent, mais elles ont le même en-tête de fonction de base comme
H = surf (X,Y,Z), où X, Y et Z sont les tableaux discutés ci-dessus. Les fonctions
de traçage de surface les plus courantes sont surf et mesh. Il y a aussi des fonc-
tions pour tracer une fonction z = f (x, y) en tant que contours comme : contour et
contourf. Toutes les commandes telles que hold, axis, grid et autres, fonctionnent
également avec ces tracés.
Essayer ! : Faire un ’subplot’ 2 × 2 de la fonction f (x, y) = sin(x)cos(y)

dans l’intervalle [−5 5] × [−5 5] en utilisant les fonction Matlab : surf, mesh,
contour et contourf (Voir figure 5.6).
% Script for generating 3D plots

% Data
x = −5:0.2:5;
y = −5:0.2:5;
[X,Y] = meshgrid(x,y);
Z = sin(X) .* cos(Y);
% 3D surfaces and contours subplots

subplot(2,2,1)
surf(X,Y,Z)
title('surf')
subplot(2,2,2)
mesh(X,Y,Z)
title('surf')
subplot(2,2,3)
contour(X,Y,Z)
title('surf')
subplot(2,2,4)
contourf(X,Y,Z)
title('surf')
Vous remarquerez que les tracés de surface affiche différentes couleurs pour diffé-
rentes élévations, rouge pour supérieur et bleu pour inférieur. La palette de couleurs
d’un tracé de surface peut être modifiée à l’aide de fonctions telles que caxis et
colormap. Ceux-ci sont laissés en exercices.
Il existe de nombreuses autres fonctions liées au traçage dans Matlab et il ne
s’agit en aucun cas d’une liste exhaustive. Cependant, cela devrait être suffisant pour
vous aider à démarrer afin que vous puissiez trouver les fonctions de traçage dans
Matlab qui vous conviennent le mieux et vous fournir suffisamment de connais-
sances pour apprendre à les utiliser lorsque vous les rencontrez. Par exemple, bar3
et isosurface sont des fonctions de traçage 3D plus avancées qui sont données
comme des problèmes. De plus, la boîte à outils de visualisation de Matlab est très
avancée et expliquer toutes les méthodes de personnalisation des tracés dépasse le
cadre de ce cours. Cependant, il suffit de lire l’aide de Matlab pour diverses fonc-
tions de traçage pour savoir comment faire bon nombre de choses que vous devrez
faire dans votre carrière d’ingénieur.
5.4 Exercices
1. Tracez les courbes des fonctions sin(x), cos(x) et sin(x)cos(x) dans une même
figure. Donnez un titre à votre graphe, des étiquettes pour les axes et une
5.4. EXERCICES 89
Figure 5.6 – Tracés de surfaces 3D
légende. Choisissez des valeurs convenables pour les limites d’axes.

2. Une cycloïde est la courbe tracée par un point situé sur le bord d’une roue
roulant sur une surface plane. Les coordonnées (x, y) d’une cycloïde générée à
partir d’une roue de rayon r peuvent être décrites par les équations paramé-
triques :
x = r(ϕ − sin(ϕ))
y = r(1 − cos(ϕ))
où ϕ est le nombre de radians parcourus par la roue. Générez un tracé de la
cycloïde pour 0 ≤ ϕ ≤ 2π en utilisant 1000 incréments et r = 3. Donnez à
votre tracé un titre et des étiquettes. Activez la grille et modifiez les limites
des axes pour rendre le tracé net.
3. Créez deux vecteurs de nombres aléatoires uniformes x1 et y1 de taille 1 × 1000
à l’aide de la fonction rand et deux autres vecteurs de nombres aléatoires
normales x2 et y2 de même taille. A m’aide des fonctions subplot et scatter
tracez les courbes (x1 , y1 ) et (x2 , y2 ) dans une même fenêtre et comparez la
distribution des points sur chaque figure. Utilisez la fonction hist avec l’en-
tête [N,X] = hist (Y) pour répartir les nombres générés aléatoirement par
chaque fonction dans 10 barres. N’oubliez pas d’utiliser la commande help
pour bien manipuler les nouvelles fonctions !
4. Considérons que le nombre d’étudiants dans votre classe est réparti selon l’al-
phabet comme suit : ’A’ : 25, ’B’ : 16, ’C’ : 5, ’D’ : 18 et ’E’ : 30. En utilisant la
fonction pie, créez un diagramme circulaire qui contient la répartition des étu-
diant en fonction de l’alphabet. Mettez un titre et une légende sur le graphique
circulaire. Note : mettez le tableau des alphabets en format Cell !

5. Écrivez une fonction avec en-tête [] = myPolygon(n) qui trace un polygone
régulier avec n côtés et rayon 1. Rappelez-vous que le rayon d’un polygone ré-
gulier est la distance entre son centre et les sommets. Utilisez axis equal pour
rendre le polygone régulier. N’oubliez pas de donner aux axes des étiquettes
et un titre. Vous pouvez utiliser title et sprintf pour appeler la figure en
fonction du nombre de côtés. Utilisez la fonction axis pour faire passer l’axe
des x et l’axe des y de -1 à 1. Astuce : Ce problème est beaucoup plus facile
si vous pensez en coordonnées polaires. Rappelons qu’une révolution complète
autour d’un cercle unitaire est de 2π radians. Remarque : Le premier et le der-
nier point du polygone doivent être le point associé aux angles de coordonnées
polaires, 0 et 2π, respectivement. Figure 5.7 montre un exemple de n = 6.
Regular polygon with 6 sides

1
0.8
0.6
0.4
0.2
0
y
-0.2
-0.4
-0.6
-0.8
-1
-1 -0.5 0 0.5 1
x
Figure 5.7 – Polygone de 6 côtés
6. Écrivez une fonction avec l’en-tête [] = mySurfacePlotter(F, x, y) où F

est un manipulateur (handle) de la fonction F(x,y). La fonction mySurfacePlotter
devrait produire un ’subplot’ de deux tracés de surface 3D de F(x,y) en uti-
lisant surf et un contour avec la fonction contour. Supposons que x et y sont
des tableaux unidimensionnels. N’oubliez pas de donner au tracé un titre et
des étiquettes d’axe.
Exemple : (Voir figure 5.8
>> x = −3*pi:pi/10:3*pi;
>> y = −3*pi:pi/10:3*pi;
>> F = @(X,Y)sin(sqrt(X.^2 + Y.^2)+eps)./(sqrt(X.^2 + Y
.^2)+eps);
>> mySurfacePlotter(F, x, y);
5.4. EXERCICES 91
Figure 5.8 – Tracés de surface et contour

Table des figures
1.1 Interface graphique de l’environnement Matlab R2017a . . . . . . . 2
3.1 Interface graphique de l’éditeur Matlab R2017a . . . . . . . . . . . 40

3.2 Éditeur des chemins Matlab R2017a . . . . . . . . . . . . . . . . . 53
5.1 Exemple de l’utilisation de la fonction plot . . . . . . . . . . . . . . . 80

5.2 Tracés des fonctions sin, cos dans un seul graphe. . . . . . . . . . . . 82
5.3 Tracés des fonctions sin, cos dans un seul graphe. . . . . . . . . . . . 83
5.4 Exemple de l’utilisation de la fonction subplot . . . . . . . . . . . . . 85
5.5 Tracé d’un hélice par la fonction plot3 . . . . . . . . . . . . . . . . . 86
5.6 Tracés de surfaces 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
5.7 Polygone de 6 côtés . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
5.8 Tracés de surface et contour . . . . . . . . . . . . . . . . . . . . . . . 91
93
94 TABLE DES FIGURES
Liste des tableaux
5.1 Symboles de couleur et de style de trait. . . . . . . . . . . . . . . . . 81
95

Cours Mat Lab 2022

Transféré par

Informations du document

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

Cours Mat Lab 2022

Transféré par

Droits d'auteur :

Formats disponibles

Introduction à Matlab

Pr. Oussama Bourihane

1 Premiers pas avec l’environnement Matlab 1

2 Variables et structures de données 11

4 Boucles et contrôle de flux 61

4.3 Boucles : Itérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

Premiers pas avec l’environnement

1.2 L’environnement Matlab

Figure 1.1 – Interface graphique de l’environnement Matlab R2017a

1.3 La Calculatrice Matlab

l’ordinateur. Une instruction est exécutée à l’invite de commande en la tapant là où

Essayer ! : Calculer la somme de deux entiers

Essayer ! : Calculer (40/5) × (5 × 23 + 4)/(2 + 3)

Remarquez que Matlab stock la valeur de l’exécution de chaque commande

Essayer ! : Calculer le produit précédent d’une autre façon !

Matlab possède de nombreuses fonctions arithmétiques de base, telles que :

Essayer ! : Utiliser des fonction prédéfinis :

Astuce ! : Parfois, vous souhaiterez peut-être afficher plus ou moins de

>> format bank

>> format short

Astuce ! : L’utilisation de la flèche HAUT dans l’invite de commande rappelle

Essayer ! : Utiliser la commande

See also acos, cosd.

Reference page for cos

Essayer ! : Calculer des valeurs infinies ou pas nombres.

Essayer ! : Calculer des valeurs imaginaires.

Matlab peut également gérer la notation scientifique en utilisant la lettre e

Essayer ! : Utiliser la notation scientifique pour le nombre 1537.5.

>> 1.e3 + 5.e2 + 3.e1 + 7.e0 + 5.e-1

1.4 Expressions logiques et opérateurs

Essayer ! : Obtenir des expressions logiques.

A noter ! : Les opérateurs de comparaison :

Essayer ! : Utiliser des opérateurs logiques.

Essayer ! : Tester l’effet de l’ordre des opérations.

Attention ! : Comme le montre l’exemple précédent, dans l’implémentation

11. Écrivez une instruction Matlab qui génère l’erreur suivante :

Variables et structures de données

2.1 Variables et affectation

Essayer ! : Affectez la valeur 2 à la variable a. Multipliez a par 3 pour montrer

L’espace de travail workspace est une abstraction de l’espace dans la mémoire

Essayer ! : L’énonce mathématique x = x+1 n’a pas de solution pour aucune

Essayer ! : Quelle valeur la variable a aura-t-elle après l’exécution des lignes

Vous pouvez effacer une variable de l’espace de travail à l’aide de la commande

2.2 Tableaux de doubles

Essayer ! : Affectez la valeur 1 à la variable x. Vérifiez que x est un double

Essayer ! : Créez les tableaux suivants :

Essayer ! : Créez un tableau vide

Attention ! : Si vous essayez de concaténer des matrices qui ne s’emboîtent

Plusieurs fois, nous aimerions connaître la taille ou la longueur d’un tableau.

Essayer ! : Calculez la taille et la longueur des tableaux x et y données

2.3 Tableau de suites équidistantes

Important ! : Opérateur deux-points ′ :′

Essayer ! : Créez le tableau z = [1, 2, 3, ..., 2000]

Comme il est très courant d’avoir un incrément de 1, si un incrément n’est

Des incréments négatifs ou non entiers peuvent également être utilisés :

Essayer ! : Utilisez linspace pour générer un tableau commençant à 3, se

Toutes les fonctions ou opérations de création de tableaux peuvent être combinées

Vous pouvez affecter l’élément à une seconde variable.

Essayer ! : Soit A le tableau de l’exemple précédent. Retrouver les éléments

Essayer ! : Soit A le tableau de l’exemple précédent. Récupérez tous les

Pour les tableaux unidimensionnels, vous pouvez raccourcir en n’incluant qu’un

Essayer ! : Soit le tableau A = 1.5 2.4 0.5 8.3 4.7 3.9 :

Écrivez des commandes afin de récupérer le troisième élément de A, les troi-

Essayer ! : Soit A le tableau suivant : A = 1 2 3 1 4 5 :