Chapitre 6 Programmation Dans MATLAB

107 Chapitre 6 Programmation dans MATLAB
Programmation dans MATLAB
Table des matières
Programmation dans MATLAB ........................................................................... 107
Table des matières .............................................................................................................. 107
Introduction ........................................................................................................................ 108
6.1 Opérateurs relationnels et logiques .............................................................................. 109
6.2 Expressions conditionnelles ......................................................................................... 116
6.2.1 La structure if-end ................................................................................................. 116
6.2.2 La structure if-else-end.......................................................................................... 118

A
6.2.3 La structure if-elseif-else-end ................................................................................ 119
6.3 L’instruction switch-case ............................................................................................. 120

LM
6.4 Boucles ......................................................................................................................... 122
6.4.1 Boucles for-end ..................................................................................................... 123
6.4.2 Boucles while-end ................................................................................................. 125
6.5 Boucles imbriquées et expressions conditionnelles imbriquées .................................. 126
6.6 Les commandes break et continue ............................................................................... 127
6.6.1 Commande break ................................................................................................... 127
6.6.2 Commande continue ............................................................................................. 128
107
Introduction
Un programme informatique est une séquence de commandes informatiques. Dans un

programme simple, les commandes sont exécutées les unes après les autres dans l'ordre de leur
saisie.
Dans ce cours, par exemple, tous les programmes qui ont été présentés jusqu'à présent dans des
fichiers script sont de simples programmes. Cependant, de nombreuses situations nécessitent
des programmes plus sophistiqués dans lesquels les commandes ne sont pas nécessairement
exécutées dans l'ordre dans lequel elles sont tapées, ou des commandes (ou groupes de
commandes) différentes sont exécutées lorsque le programme s'exécute avec différentes
variables d'entrée.
MATLAB fournit plusieurs outils qui peuvent être utilisés pour contrôler le flux d'un
programme. Les instructions conditionnelles (Section 6.2) et la structure du commutateur
(Section 6.3) permettent d'ignorer des commandes ou d'exécuter des groupes spécifiques de
A
commandes dans différentes situations. Les boucles for et les boucles while (Section 6.4)
permettent de répéter plusieurs fois une séquence de commandes.
Il est évident que changer le flux d'un programme nécessite une sorte de processus décisionnel
LM
au sein du programme. L'ordinateur doit décider d'exécuter la commande suivante ou d'ignorer
une ou plusieurs commandes et de continuer sur une ligne différente du programme. Le
programme prend ces décisions en comparant les valeurs des variables. Cela se fait en utilisant
des opérateurs relationnels et logiques, qui sont expliqués dans la section 6.1.
108
6.1 Opérateurs relationnels et logiques
Un opérateur relationnel compare deux nombres en déterminant si une déclaration de

comparaison (par exemple, 5 < 8) est vraie ou fausse. Si l'instruction est vraie, une valeur de 1
lui est attribuée. Si l'instruction est fausse, une valeur de 0 lui est attribuée. Un opérateur logique
examine les instructions vrai / faux et produit un résultat qui est vrai (1) ou faux (0) selon
l'opérateur spécifique. Par exemple, l'opérateur logique AND ne donne 1 que si les deux
déclarations sont vraies. Les opérateurs relationnels et logiques peuvent être utilisés dans des
expressions mathématiques et, comme nous le verrons dans ce chapitre, sont fréquemment
utilisés en combinaison avec d'autres commandes pour prendre des décisions qui contrôlent le
flux d'un programme informatique.
Opérateurs relationnels :
Les opérateurs relationnels dans MATLAB sont :
<
>
A
Opérateurs relationnels Description
Inférieur à
Supérieur à
LM
<= Inférieur ou égal à
>= Supérieur ou égal à
== Égal à
~= Pas égal à
Notez que l'opérateur relationnel « égal à » se compose de deux signes = (sans espace entre eux
= =), car un signe = est l'opérateur d'affectation. Dans d'autres opérateurs relationnels composés
de deux caractères, il n'y a pas non plus d'espace entre les caractères (<=,>=, ~=).
- Les opérateurs relationnels sont utilisés comme opérateurs arithmétiques dans une
expression mathématique. Le résultat peut être utilisé dans d'autres opérations
mathématiques, dans l'adressage de tableaux, et avec d'autres commandes MATLAB (par
exemple, if) pour contrôler le flux d'un programme.
- Lorsque deux nombres sont comparés, le résultat est 1 (logique vrai) si la comparaison,
selon l'opérateur relationnel, est vrai, et 0 (logique faux) si la comparaison est fausse.
- Si deux scalaires sont comparés, le résultat est un scalaire 1 ou 0. Si deux tableaux sont
comparés (seuls les tableaux de même taille peuvent être comparés), la comparaison est
effectuée élément par élément et le résultat est un tableau logique de même taille avec 1 et
0 selon le résultat de la comparaison à chaque adresse.
109
- Si un scalaire est comparé à un tableau, le scalaire est comparé à chaque élément du tableau
et le résultat est un tableau logique avec 1 et 0 selon le résultat de la comparaison de chaque
élément.
Quelques exemples sont :
>> 5>8 Vérifie si 5 est supérieur à 8

ans =
logical Puisque la comparaison est fausse (5 n'est
0 pas supérieur à 8), la réponse est 0
>> a=5<10 Vérifie si 5 est inférieur à 10 et attribue la

a = réponse à a
logical
1
>> y=(6<10) + (7>8) + (5*3==60/4)

y =
2 Égal à 1 puisque 5*3
Égal à 1 puisque 6 Égal à 0 puisque 7 est égale à 60/4
est inférieur à 10 est inférieur à 8
>> d=c>=b
d =
A
>> b=[15 6 9 4 11 7 14];c=[8 20 9 2 19 7 10]; Définir les vecteurs b et c
Vérifie quels éléments c sont supérieurs ou égaux aux éléments b

LM
1×7 logical array Attribue 1 lorsqu'un élément de c est supérieur ou égal
0 1 1 0 1 1 0 à un élément de b
>> b == c Vérifie quels éléments c sont égaux aux éléments b

ans =
1×7 logical array Attribue 1 lorsqu'un élément de c est égal à un élément de b
0 0 1 0 0 1 0
>> b~=c
Vérifie quels éléments b ne sont pas égaux aux éléments c
ans =
1×7 logical array
1 1 0 1 1 0 1
>> f=b-c>0 Soustrait c de b, puis vérifie quels éléments sont supérieurs à zéro
f =
1×7 logical array
1 0 0 1 0 0 1
>> A=[2 9 4; -3 5 2; 6 7 -1] Définir une matrice A de taille (3x3)

A =
2 9 4
-3 5 2
6 7 -1
>> B=A<=2 Vérifie quels éléments de A sont plus petits
B = que ou égal à 2. Les résultats sont affectés à
3×3 logical array la matrice B
1 0 0
1 0 1
0 0 1
110
Les résultats d'une opération relationnelle avec des vecteurs, qui sont des vecteurs avec 0 et 1,
sont appelés vecteurs logiques et peuvent être utilisés pour adresser des vecteurs. Lorsqu'un
vecteur logique est utilisé pour adresser un autre vecteur, il extrait de ce vecteur les éléments
aux positions où le vecteur logique a des 1. Par exemple :
>> r = [8 12 9 4 23 19 10] Définir un vecteur r

r =
8 12 9 4 23 19 10
>> s=r<=10 Vérifie quels r éléments sont inférieurs ou égaux à 10

s =
1×7 logical array Un vecteur logique s avec des 1 aux positions où
1 0 1 1 0 0 1 les éléments de r sont inférieurs ou égaux à 10
>> t=r(s) Utilisez s pour les adresses du vecteur r pour créer le vecteur t
t =
8 9 4 10
>> w=r(r<=10) La même procédure peut être effectuée en une seule étape
w = A
8 9 4 10
- Les vecteurs et tableaux numériques avec les nombres 0 et 1 ne sont pas les mêmes que les
vecteurs et tableaux logiques avec 0 et 1. Les vecteurs et tableaux numériques ne peuvent
LM
pas être utilisés pour l'adressage. Les vecteurs et les tableaux logiques, cependant, peuvent
être utilisés dans les opérations arithmétiques. La première fois qu'un vecteur logique ou un
tableau est utilisé dans des opérations arithmétiques, il est changé en un vecteur ou un
tableau numérique.
- Ordre de priorité : dans une expression mathématique qui inclut des opérations
relationnelles et arithmétiques, les opérations arithmétiques (+, -, *, /, \) ont la priorité sur
les opérations relationnelles. Les opérateurs relationnels eux-mêmes ont une priorité égale
et sont évalués de gauche à droite. Les parenthèses peuvent être utilisées pour modifier
l'ordre de priorité. Voici des exemples :
>> 3+4<16/2 + et / sont exécutés en premier

ans =
logical
La réponse est 1 puisque 7 <8 est vrai
1
>> 3+(4<16)/2 4 <16 est exécuté en premier et est égal à 1, car il est vrai
ans =
3.5000 3,5 est obtenu à partir de 3 + 1/2
111
Opérateurs logiques :
Les opérateurs logiques dans MATLAB sont :

Opérateurs logiques Nom Description
& Fonctionne sur deux opérandes (A et B). Si les deux sont
AND
Example : A&B vrais, le résultat est vrai (1) ; sinon le résultat est faux (0)
Fonctionne sur deux opérandes (A et B). Si l'un ou les
|
OR deux sont vrais, le résultat est vrai (1); sinon (les deux
Example : A|B
sont faux) le résultat est faux (0).
Fonctionne sur un opérande (A). Donne l'opposé de
~
NOT l'opérande ; vrai (1) si l'opérande est faux et faux (0) si
Example : ~A
l'opérande est vrai.
- Les opérateurs logiques ont des nombres comme opérandes. Un nombre différent de zéro
est vrai et un nombre nul est faux.
- Les opérateurs logiques (comme les opérateurs relationnels) sont utilisés comme opérateurs
arithmétiques dans une expression mathématique. Le résultat peut être utilisé dans d'autres
-
A
opérations mathématiques, dans l'adressage de tableaux et avec d'autres commandes
MATLAB (par exemple, if) pour contrôler le flux d'un programme.
Les opérateurs logiques (comme les opérateurs relationnels) peuvent être utilisés avec des
LM
scalaires et des tableaux.
- Les opérations logiques AND et OR peuvent avoir les deux opérandes en tant que scalaires,
les deux en tant que tableaux ou l'un en tant que tableau et l'autre en tant que scalaire. Si les
deux sont des scalaires, le résultat est un scalaire 0 ou 1. Si les deux sont des tableaux, ils
doivent être de la même taille et l'opération logique est effectuée élément par élément. Le
résultat est un tableau de la même taille avec 1 et 0 selon le résultat de l'opération à chaque
position. Si un opérande est un scalaire et que l'autre est un tableau, l'opération logique est
effectuée entre le scalaire et chacun des éléments du tableau et le résultat est un tableau de
la même taille avec 1 et 0.
- L'opération logique NOT a un seul opérande. Lorsqu'il est utilisé avec un scalaire, le résultat
est un scalaire 0 ou 1. Lorsqu'il est utilisé avec un tableau, le résultat est un tableau de la
même taille avec 0 dans des positions où le tableau a des nombres non nuls et des uns (1)
dans des positions où le tableau a des zéros (0).
Voici quelques exemples :
>> 3&7 3 ET 7 (3 AND 7)

ans =
112
logical
1 3 et 7 sont tous deux vrais (différents de zéro), le résultat est donc 1
>> a=5|0 5 OU 0 (5 OR 0), attribuer à la variable a

a =
logical 1 est affecté à « a » car au moins un nombre est vrai (différent de zéro)
1
>> ~25 PAS 25 (NOT 25)

ans =
logical Le résultat est 0 puisque 25 est vrai (différent de zéro) et l'inverse est faux
0
>> t=25*((12&0)+(~0)+(0|5)) Utilisation d'opérateurs logiques dans une expression

t = mathématique
50
Égal à 0 Égal à 1 Égal à 1
>> x=[9 3 0 11 0 15]; y=[2 0 13 -11 0 4]; Définir deux vecteurs x et y

>> x&y
ans = Le résultat est un vecteur avec 1 dans chaque position
1×6 logical array A
où x et y sont vrais (éléments non nuls), et 0 sinon
1 0 0 1 0 1
>> z=x|y
z = Le résultat est un vecteur avec 1 dans chaque position où l’un
1×6 logical array (x ou y) ou les deux sont vrais (éléments non nuls), et 0 sinon
1 1 1 1 0 1
LM
>> ~(x+y)
ans = Le résultat est un vecteur avec 0 dans chaque position
1×6 logical array où le vecteur x + y est vrai (éléments non nuls) et 1
0 0 0 1 1 0 dans chaque position où x + y est faux (éléments zéro)
Ordre de priorité :
Les opérateurs arithmétiques, relationnels et logiques peuvent être combinés dans des
expressions mathématiques. Lorsqu'une expression a une telle combinaison, le résultat dépend
de l'ordre dans lequel les opérations sont effectuées. Le Tableau 6.1 montre l'ordre de priorité
utilisé par MATLAB :
Priorité Opération
Parenthèses (s'il existe des parenthèses imbriquées, les parenthèses
1 (le plus élevé)
internes ont priorité)
2 Exponentiation
3 NOT : NON logique (~)
4 Multiplication, division
5 Addition, soustraction
6 Opérateurs relationnels (>, <,> =, <=, = =, ~ =)
113
7 AND : ET logique (&)

8 (le plus bas) OR : OU logique (|)
Tableau 6.1 - Ordre de priorité utilisé par MATLAB
- Si deux opérations ou plus ont la même priorité, l'expression est exécutée dans l'ordre de
gauche à droite.
- Il convient de noter ici que l'ordre indiqué ci-dessus est celui utilisé depuis MATLAB 6.
Les versions précédentes de MATLAB utilisaient un ordre légèrement différent (& n'avait
pas priorité sur |), donc l'utilisateur doit être prudent. Les problèmes de compatibilité entre
différentes versions de MATLAB peuvent être évités en utilisant des parenthèses même
lorsqu'elles ne sont pas nécessaires.
Voici des exemples d'expressions qui incluent des opérateurs arithmétiques, relationnels et
logiques :
>> x=-2; y=5;
>> -5<x<-1
ans =
A Définir les variables x et y
Cette inégalité est correcte mathématiquement. La réponse est

cependant fausse car MATLAB s'exécute de gauche à droite.
LM
logical –5 <x est vrai (= 1) puis 1 <–1 est faux (0)
0
L'énoncé mathématiquement correct est obtenu en utilisant
>> -5<x & x<-1
l'opérateur logique &. Les inégalités sont exécutées en
ans =
logical premier. Puisque les deux sont vrais (1), la réponse est 1
1
>> ~(y<7) y <7 est exécuté en premier, il est vrai (1) et ~ 1 est 0
ans =
logical
0
>> ~y<7 ~ y est exécuté en premier, y est vrai (1) (puisque y est
ans = différent de zéro), ~ 1 est 0 et 0 <7 est vrai (1)
logical
1
y> = 8 (faux) et x <–1 (vrai) sont exécutés en premier.
>> ~((y>=8)|(x<-1)) OR est exécuté ensuite (vrai). ~ est exécuté en dernier
ans = et donne faux (0)
logical
0
>> ~(y>=8)|(x<-1) y> = 8 (faux) et x <–1 (vrai) sont exécutés en premier.

ans = NOT de (y> = 8) est exécuté ensuite (vrai). OR est
logical exécuté en dernier et donne vrai (1)
1
114
Fonctions logiques intégrées
MATLAB a des fonctions intégrées équivalentes aux opérateurs logiques. Ces fonctions sont:
- and (A, B) équivalent à A&B

- or (A, B) équivalent à A|B
- not (A) équivalent à ~A
De plus, MATLAB possède d'autres fonctions logiques intégrées, dont certaines sont décrites
dans le Tableau 6.2 :
Fonction Description Exemple

Exclusif OR. Renvoie vrai (1) si un >> xor(8, -1)
opérande est vrai et que l'autre est faux ans =
logical
xor(a,b) 0
>> xor(8, 0)
A ans =
logical
1
Renvoie 1 (vrai) si tous les éléments d'un >> A = [15 1 6 10 2 9];
>> all(A)
vecteur A sont vrais (différents de zéro). ans =
LM
Renvoie 0 (faux) si un ou plusieurs logical
éléments sont faux (zéro). 1
all(A) Si A est une matrice, traite les colonnes de >> B = [13 6 9 7 0 13];
A comme des vecteurs et renvoie un >> all(B)
ans =
vecteur avec 1 et 0. logical
0
Renvoie 1 (vrai) si l'un des éléments d'un >> A = [9 0 0 2 0 15];
>> any(A)
vecteur A est vrai (différent de zéro). ans =
Renvoie 0 (faux) si tous les éléments sont logical
faux (zéro). 1
any(A) Si A est une matrice, traite les colonnes de >> B = [0 0 0 0 0 0 ];
A comme des vecteurs et renvoie un >> any(B)
ans =
vecteur avec 1 et 0. logical
0
Si A est un vecteur, retourne les indices >> A = [2 0 5 0 0 8 0 7];
>> find(A)
find(A) des éléments non nuls. ans =
Si A est un vecteur, renvoie l'adresse des 1 3 6 8
find(A>d) éléments qui sont plus grands que d (tout >> find(A > 3)
opérateur relationnel peut être utilisé). ans =
3 6 8
Tableau 6.2 - Fonctions logiques intégrées supplémentaires
Les opérations des quatre opérateurs logiques and, or, xor et not peuvent être résumées dans
une table de vérité (Tableau 6.3) :
115
ENTRÉE SORTIE
AND OR XOR NOT NOT
A B A&B A|B (A,B) ~A ~B
faux faux faux faux faux vrai vrai
faux vrai faux vrai vrai vrai faux
vrai faux faux vrai vrai faux vrai
vrai vrai vrai vrai faux faux faux
Tableau 6.3 - Table de vérité
6.2 Expressions conditionnelles
Une instruction conditionnelle est une commande qui permet à MATLAB de décider d'exécuter
un groupe de commandes qui suit l'instruction conditionnelle ou d'ignorer ces commandes.
Dans une instruction conditionnelle, une expression conditionnelle est indiquée. Si l'expression
est vraie, un groupe de commandes qui suivent l'instruction sont exécutées. Si l'expression est
fausse, l'ordinateur ignore le groupe. La forme de base d'une instruction conditionnelle est la
suivante :
>>
A
if expression conditionnelle composée d'opérateurs
relationnels and/or logiques
LM
Exemples :
if a < b
if c >= 5 Toutes les variables doivent avoir des valeurs
if a == b
assignées
if a ~= 0
if (d<h)&(x>7)
if (x~=13)|(y<0)
- Les instructions conditionnelles peuvent faire partie d'un programme écrit dans un
fichier script ou une fonction définie par l'utilisateur.
- Comme indiqué ci-dessous, pour chaque instruction if, il existe une instruction end.
L'instruction if est couramment utilisée dans trois structures, if-end, if-else-end et if-elseif-else-
end, qui sont décrites ci-après
6.2.1 La structure if-end
L'instruction conditionnelle if-end est représentée schématiquement dans la Figure 6.1. La
figure montre comment les commandes sont tapées dans le programme et un organigramme qui
montre symboliquement le flux ou la séquence dans laquelle les commandes sont exécutées.
Lorsque le programme s'exécute, il atteint l'instruction if. Si l'expression conditionnelle dans
116
l'instruction if est vraie (1), le programme continue d'exécuter les commandes qui suivent
l'instruction if jusqu'à l'instruction de fin end.
Organigramme ........
........ % Programme Matlab
........
if expression conditionnelle
........
Faux
If ........ % Groupes d’instructions
instruction
........
end
Vrai
........
Commandes ........ % Programme Matlab

........
end
A
Figure 6.1 - La structure de l'instruction conditionnelle if-end
Si l'expression conditionnelle est fausse (0), le programme ignore le groupe de commandes
entre if et end et continue avec les commandes qui suivent end.
LM
Les mots if et end apparaissent à l'écran en bleu, et les commandes entre l'instruction if et
l'instruction end sont automatiquement mises en retrait, ce qui facilite la lecture du programme.
Un exemple d'utilisation de l'instruction if-end dans un fichier script est présenté dans l'exemple
suivant :
Exemple : Calcul du salaire du travailleur
Un travailleur est payé selon son volume horaire hebdomadaire de 40 heures, et 50% de plus
pour les heures supplémentaires. Écrivez un programme dans un fichier script qui calcule le
salaire hebdomadaire du travailleur. Le programme demande à l'utilisateur de saisir le nombre
d'heures par semaine et le salaire par heure. Le programme affiche ensuite le salaire
hebdomadaire.
Solution :
Le programme est illustré ci-dessous. Le programme calcule d'abord le salaire en multipliant le
nombre d'heures par le salaire horaire. Ensuite, une instruction if vérifie si le nombre d'heures
est supérieur à 40. Si c'est le cas, la ligne suivante est exécutée et la rémunération
supplémentaire pour les heures supérieures à 40 est ajoutée. Sinon, le programme saute à la fin.
117
t=input('Veuillez saisir le nombre d’’heures travaillées ');

h=input('Veuillez entrer le salaire horaire en DA ');
Paye=t*h;
if t>40
Paye=Paye+(t-40)*0.5*h;
end
fprintf('Le salaire hebdomadaire du travailleur est %5.2f DA \n',Paye)
L'application du programme (dans la fenêtre de commande) pour deux cas est illustrée ci-
dessous (le fichier a été enregistré sous le nom de Salaire) :
>> Salaire
Veuillez saisir le nombre d'heures travaillées 40
Veuillez entrer le salaire horaire en DA 200
Le salaire du travailleur est 8000.00 DA
>> Salaire
Veuillez saisir le nombre d'heures travaillées 60
Veuillez entrer le salaire horaire en DA 200
A
Le salaire du travailleur est 14000.00 DA
6.2.2 La structure if-else-end

LM
La structure if-else-end permet de choisir un groupe de commandes, parmi deux groupes
possibles, pour l'exécution. La structure if-else-end est illustrée à la Figure 6.2.
........
.......
faux
If ....... % Groupe 1 d’instructions
instruction
.......
else
Vrai
.......
Commandes Commandes ....... % Groupe 2 d’instructions
Groupe 2 Groupe 1
.......
end
end ........
........
Figure 6.2 - La structure de l'instruction conditionnelle if-else-end
118
La figure montre comment les commandes sont tapées dans le programme et comprend un
organigramme qui illustre le flux ou la séquence, dans laquelle les commandes sont exécutées.
La première ligne est une instruction if avec une expression conditionnelle. Si l'expression
conditionnelle est vraie, le programme exécute le groupe 1 de commandes entre les instructions
if et else, puis passe à la fin. Si l'expression conditionnelle est fausse, le programme passe à
l'autre (else), puis exécute le groupe 2 de commandes entre else et end.
6.2.3 La structure if-elseif-else-end

La structure if-elseif-else-end est illustrée à la Figure 6.3. La figure montre comment les
commandes sont tapées dans le programme et donne un organigramme qui illustre le flux, ou
la séquence, dans laquelle les commandes sont exécutées. Cette structure comprend deux
instructions conditionnelles (if et elseif) qui permettent de sélectionner un groupe de
commandes sur trois pour exécution. La première ligne est une instruction if avec une
expression conditionnelle. Si l'expression conditionnelle est vraie, le programme exécute le
A
groupe 1 de commandes entre if et elseif, puis passe à la fin. Si l'expression conditionnelle dans
l'instruction if est fausse, le programme passe à l'instruction elseif. Si l'expression
conditionnelle dans l'instruction elseif est vraie, le programme exécute le groupe 2 de
LM
commandes entre elseif et else, puis saute à la fin. Si l'expression conditionnelle dans
l'instruction elseif est fausse, le programme passe à else et exécute le groupe 3 de commandes
entre else et end.
.......
faux if ....... % Groupe 1 d’instructions
instructi
on .......
elseif expression conditionnelle
Vrai
faux elseif .......
instructi
Commandes ....... % Groupe 2 d’instructions
on
Groupe 1
.......
Vrai else
Commandes Commandes .......

Groupe 3 Groupe 2 ....... % Groupe 3 d’instructions
.......
end end
........
Figure 6.3 - La structure if-elseif-else-end

119
Il convient de noter ici que plusieurs instructions elseif et groupes de commandes associés
peuvent être ajoutés. De cette façon, plus de conditions peuvent être incluses. En outre,
l'instruction else est facultative. Cela signifie que dans le cas de plusieurs instructions elseif et
aucune instruction else, si l'une des instructions conditionnelles est vraie, les commandes
associées sont exécutées; sinon rien n'est exécuté.
L'exemple suivant utilise la structure if-elseif-else-end dans un programme.
Exemple : Fonction définie par morceaux

Soit la fonction 𝑦 = 𝑓(𝑥) :
𝑦=0 𝑝𝑜𝑢𝑟 ∶ 𝑥<0
𝑦 = −1 + 𝑒𝑥𝑝(𝑥) 𝑝𝑜𝑢𝑟 ∶ 0≤𝑥<1
1
𝑦= 2 𝑝𝑜𝑢𝑟 ∶ 𝑥≥1
𝑥
- Écrivez un programme MATLAB qui permet de déterminer la valeur de la fonction f
selon les valeurs de la variable x allant de -2 à 4 avec un pas de 0.01.
- Tracer cette fonction
A
Solution : Le programme est illustré ci-dessous. Le tracé généré est illustré à la Figure 6.4
LM
x=-2:0.1:4; %
y=zeros(size(x));
for k = 1:length(x)
if x(k)<0
y(k)=0;
elseif (x(k)>=0) & (x(k)<1)
y(k)=-1+exp(x(k));
else
y(k)=(1/(x(k).^2));
end
end
plot(x,y)
title('fonction définie par morceaux')
Figure 6.4 - Fonction définie par morceaux
6.3 L’instruction switch-case
L'instruction switch-case est une autre méthode qui peut être utilisée pour diriger le flux d'un
programme. Il fournit un moyen de choisir un groupe de commandes à exécuter parmi plusieurs
groupes possibles. La structure de l'instruction est illustrée à la Figure 6.5. La première ligne
est la commande switch, qui a la forme :
switch switch expression
120

........
switch switch expression
case value1
........ % Groupe 1 d’instructions
........
case value2
........
case value3
........
otherwise
........
end
...... % Programme Matlab
......
A
Figure 6.5 - La structure d'une instruction switch-case
L'expression switch peut être un scalaire ou une chaîne. Il s'agit généralement d'une variable à
laquelle un scalaire ou une chaîne est affecté. Cependant, il peut également s'agir d'une
LM
expression mathématique qui inclut des variables pré-assignées et peut être évaluées.
- Après la commande switch se trouvent une ou plusieurs commandes case. Chacun a une
valeur (peut être un scalaire ou une chaîne) à côté (valeur1, valeur2, etc.) et un groupe de
commandes associé en dessous.
- Après la dernière commande case, il y a une commande otherwise (sinon) facultative suivie
d'un groupe de commandes.
La dernière ligne doit être l’instruction de fin end.
Fonctionnement de l'instruction switch-case

La valeur de l'expression switch dans la commande switch est comparée aux valeurs qui se
trouvent à côté de chacune des instructions case. Si une correspondance est trouvée, le groupe
de commandes qui suit l'instruction case en question est exécuté. (Un seul groupe de
commandes - celui entre case correspondant et case suivant, otherwise ou l'instruction end
suivante - est exécuté).
- S'il existe plusieurs correspondances, seul le premier cas correspondant est exécuté.
- Si aucune correspondance n'est trouvée et que l'instruction otherwise (facultative) est
présente, le groupe de commandes entre otherwise et end est exécuté.
121
- Si aucune correspondance n'est trouvée et que l'instruction otherwise n'est pas présente,
aucun des groupes de commandes n'est exécuté.
- L'instruction case ne peut pas inclure d'opérateurs relationnels tels que > ou < pour la
comparaison avec switch-case. Pour tester l'inégalité, utilisez les instructions if-elseif-else-
end.
Exemple :
n = input('Entrer un nombre : ');

switch n
case -1
disp(' nombre négatif ')
case 0
disp(' zero ')
case 1
disp(' nombre positif ’)
otherwise
disp(' autre valeur ')
end
A
L'application du programme (dans la fenêtre de commande) pour différents cas est illustrée ci-
dessous (le fichier a été enregistré sous le nom de exemple_6_3)
>> exemple_6_3 >> exemple_6_3

LM
Entrer un nombre : 1 Entrer un nombre : 0
nombre positif zero
>> exemple_6_3 >> exemple_6_3
Entrer un nombre : -1 Entrer un nombre : -9
nombre négatif autre valeur
6.4 Boucles
Une boucle est une autre méthode pour modifier le flux d'un programme informatique. Dans
une boucle, l'exécution d'une commande, ou d'un groupe de commandes, est répétée plusieurs
fois de suite. Chaque ronde d'exécution est appelée passe. Dans chaque passage, au moins une
variable, mais généralement plus d'une, voire toutes les variables définies dans la boucle, se
voient attribuer de nouvelles valeurs. MATLAB a deux types de boucles. Dans les boucles for-
end (Section 6.4.1), le nombre de passes est spécifié au démarrage de la boucle. Dans les
boucles while-end (Section 6.4.2), le nombre de passes n'est pas connu à l'avance et le processus
de bouclage se poursuit jusqu'à ce qu'une condition spécifiée soit satisfaite. Les deux types de
boucles peuvent être interrompus à tout moment avec la commande break (Section 6.6.1).
122
6.4.1 Boucles for-end
Dans les boucles for-end, l'exécution d'une commande, ou d'un groupe de commandes, est
répétée un nombre prédéterminé de fois. La forme d'une boucle est illustrée à la Figure 6.6.
for k = f:s:t Avec:

........ k : indice de la boucle
........% Groupe de commandes f : valeur initiale de k
........ s : l’incrément en k à chaque passage
........ t : valeur finale de k
end
Figure 6.6 - La structure d'une boucle for-end

- La variable d'index de boucle peut avoir n'importe quel nom de variable (généralement i, j,
k, m et n sont utilisés, mais i et j ne doivent pas être utilisés si MATLAB est utilisé avec des
nombres complexes).
-
A
Dans la première passe k = f et l'ordinateur exécute les commandes entre les commandes
for et end. Ensuite, le programme revient à la commande for pour la deuxième passe, k
obtient une nouvelle valeur égale à k = f + s, et les commandes entre les commandes for et
LM
end sont exécutées avec la nouvelle valeur de k. Le processus se répète jusqu'à la dernière
passe, où k = t. Ensuite, le programme ne revient pas à for, mais continue avec les
commandes qui suivent la commande end. Par exemple, si k = 1: 2: 9, il y a cinq passes et
les valeurs correspondantes de k sont 1, 3, 5, 7 et 9.
- L'incrément s peut être négatif (c'est-à-dire que k = 25: –5: 10 produit quatre passes avec k=
25, 20, 15, 10).
- L'incrément s peut être non entier (c'est-à-dire que k = 1: 0.5: 3 produit cinq passes avec
k=1, 1.5, 2, 2.5, 3).
- Si la valeur d'incrément s est omise, la valeur est 1 (par défaut) (c'est-à-dire que k = 3: 7
produit cinq passes avec k = 3, 4, 5, 6, 7).
- Si f = t, la boucle est exécutée une fois.
- Si f> t et s > 0, ou si f < t et s < 0, la boucle n'est pas exécutée.
- Si les valeurs de k, s et t sont telles que k ne peut pas être égal à t, alors si s est positif, la
dernière passe est celle où k a la plus grande valeur inférieure à t (c'est-à-dire k = 8 : 10: 50
produit cinq passes avec k = 8, 18, 28, 38, 48). Si s est négatif, la dernière passe est celle où
k a la plus petite valeur supérieure à t.
123
- Dans la commande for, k peut également se voir attribuer une valeur spécifique (saisie
comme vecteur). Exemple : pour k = [7 9 –1 3 3 5].
- La valeur de k ne doit pas être redéfinie dans la boucle.
- Chaque commande for dans un programme doit avoir une commande end.
- La valeur de la variable d'index de boucle (k) ne s'affiche pas automatiquement. Il est
possible d'afficher la valeur dans chaque passe (ce qui est parfois utile pour le débogage) en
tapant k comme l'une des commandes de la boucle.
- Lorsque la boucle se termine, la variable d'index de boucle (k) a la dernière valeur qui lui a
été affectée.
Un exemple simple de boucle for-end (dans un fichier script) est :
for k=1:3:10
x = k^2
end A
Lorsque ce programme est exécuté, la boucle est exécutée quatre fois. La valeur de k dans les
quatre passes est k = 1, 4, 7 et 10, ce qui signifie que les valeurs affectées à x dans les passes
LM
sont x = 1, 16, 49 et 100, respectivement. Puisqu'un point-virgule n'est pas tapé à la fin de la
deuxième ligne, la valeur de x est affichée dans la fenêtre de commande à chaque passage.
Lorsque le fichier script est exécuté, l'affichage dans la fenêtre de commande est :
x=
1
x=
16
x=
49
x=
100
- Note sur les boucles for-end et les opérations élément par élément :
Dans certaines situations, le même résultat final peut être obtenu en utilisant des boucles for-
end ou en utilisant des opérations élément par élément. Les opérations élément par élément avec
les tableaux sont l'une des fonctionnalités supérieures de MATLAB qui fournissent les moyens
de calculer dans des circonstances qui nécessitent autrement des boucles. En général, les
opérations élément par élément sont plus rapides que les boucles et sont recommandées lorsque
l'une ou l'autre méthode peut être utilisée.
124
6.4.2 Boucles while-end
Les boucles while-end sont utilisées dans les situations où une boucle est nécessaire mais le
nombre de passes n'est pas connu à l'avance. Dans les boucles while-end, le nombre de passes
n'est pas spécifié lorsque le processus de bouclage démarre. Au lieu de cela, le processus de
bouclage continue tant qu'une condition indiquée est satisfaite. La structure d'une boucle while-
end est illustrée à la Figure 6.7
while expression conditionnelle

........
........% Groupe de commandes
........
end
Figure 6.7 - La structure d'une boucle while-end

La première ligne est une instruction while qui inclut une expression conditionnelle. Lorsque
A
le programme atteint cette ligne, l'expression conditionnelle est vérifiée. Si elle est fausse (0),
MATLAB passe à l'instruction de fin et continue avec le programme. Si l'expression
conditionnelle est vraie (1), MATLAB exécute le groupe de commandes qui suit entre les
LM
commandes while et end. MATLAB revient ensuite à la commande while et vérifie l'expression
conditionnelle. Ce processus de bouclage se poursuit jusqu'à ce que l'expression conditionnelle
soit fausse.
Pour qu'une boucle while-end s'exécute correctement :
- L'expression conditionnelle dans la commande while doit inclure au moins une variable.
- Les variables de l'expression conditionnelle doivent avoir des valeurs affectées lorsque
MATLAB exécute la commande while pour la première fois.
- Au moins une des variables de l'expression conditionnelle doit se voir attribuer une nouvelle
valeur dans les commandes comprises entre while et end. Sinon, une fois le bouclage
démarré, il ne s'arrêtera jamais, car l'expression conditionnelle restera vraie.
Un exemple d'une simple boucle while-end est présenté dans le programme suivant. Dans ce
programme, une variable x avec une valeur initiale de 1 est doublée à chaque passage tant que
sa valeur est inférieure ou égale à 15.
125
x=1 % valeur initiale de x est 1

while x<=15 % La commande suivante n'est exécutée que si x<=15
x=2*x % Dans chaque passe x double
end
Lorsque ce programme est exécuté, l'affichage dans la fenêtre de commande est :
x =
1 Valeur initiale de x
x =
2
x = Dans chaque passe x double
4
x =
8 Lorsque x = 16, l'expression conditionnelle dans la
x =
16 commande while devient fausse et le bouclage
s'arrête
Note importante :
A
Lors de l'écriture d'une boucle while-end, le programmeur doit être sûr que la variable (ou
les variables) qui se trouvent dans l'expression conditionnelle et auxquelles de nouvelles valeurs
LM
sont affectées pendant le processus de bouclage se verront éventuellement attribuer des valeurs
qui rendent l'expression conditionnelle dans la commande while fausse. Sinon, le bouclage se
poursuivra indéfiniment (boucle indéfinie). Dans l'exemple ci-dessus, si l'expression
conditionnelle est modifiée en x> = 0.5, le bouclage se poursuivra indéfiniment. Une telle
situation peut être évitée en comptant les passes et en arrêtant la boucle si le nombre de passes
dépasse une valeur importante. Cela peut être fait en ajoutant le nombre maximum de passes à
l'expression conditionnelle, ou en utilisant la commande break (Section 6.6).
Une situation de boucle indéfinie peut se produire malgré une programmation minutieuse.
Si cela se produit, l'utilisateur peut arrêter l'exécution d'une boucle indéfinie en appuyant sur
les touches Ctrl + C ou Ctrl + Break (Ctrl+ Pause/Attn : touche de pause ou touche d'attente,
notée en anglais Break).
6.5 Boucles imbriquées et expressions conditionnelles imbriquées
Les boucles et les instructions conditionnelles peuvent être imbriquées dans d'autres boucles ou
instructions conditionnelles. Cela signifie qu'une boucle et / ou une instruction conditionnelle
peut commencer (et se terminer) dans une autre boucle ou instruction conditionnelle. Il n'y a
pas de limite au nombre de boucles et d'instructions conditionnelles qui peuvent être
126
imbriquées. Il faut cependant se rappeler que chaque instruction if, switch-case, for et while
doit avoir une instruction end correspondante. La Figure 6.8 montre la structure d'une boucle
for-end imbriquée dans une autre boucle for-end. Dans les boucles illustrées sur cette figure, si,
par exemple, n = 3 et m = 4, alors d'abord k = 1 et la boucle imbriquée s'exécute quatre fois avec
h = 1, 2, 3, 4. Ensuite k = 2 et le la boucle imbriquée s'exécute à nouveau quatre fois avec h =
1, 2, 3, 4. Enfin k = 3 et la boucle imbriquée s'exécute à nouveau quatre fois.
for k = 1:n Chaque fois que k

for h = 1:m augmente de 1, la
....... boucle imbriquée
....... Groupe de Boucle s'exécute m fois.
Boucle
....... commandes imbriquée Globalement, le groupe
....... de commandes est
end exécuté n * m fois
end
Figure 6.8 - Structure des boucles imbriquées
Exemple :
A
L’exécution du programme suivant, donne une matrice v (3x5).
LM
for k=1:3
for m=1:5
a=k*1.2 ; w=m*0.5;
v(k,m)=a*sin(w);
end
end
6.6 Les commandes break et continue
6.6.1 Commande break

À l'intérieur d'une boucle (for ou while), la commande break met fin à l'exécution de la boucle
(la boucle entière, pas seulement la dernière passe). Lorsque la commande break apparaît dans
une boucle, MATLAB passe à la commande de fin end de la boucle et continue avec la
commande suivante (elle ne revient pas à la commande for de cette boucle).
- Si la commande break se trouve dans une boucle imbriquée, seule la boucle imbriquée est
terminée.
- Lorsqu'une commande break apparaît en dehors d'une boucle dans un fichier script ou une
fonction, elle met fin à l'exécution du fichier.
- La commande break est généralement utilisée dans une instruction conditionnelle. Dans les
boucles, elle met fin au processus de bouclage si une condition est remplie - par exemple,
127
si le nombre de boucles dépasse une valeur prédéterminée, ou si une erreur dans une
procédure numérique est inférieure à une valeur prédéterminée. Lorsqu'elle est tapée en
dehors d'une boucle, la commande break fournit un moyen de mettre fin à l'exécution d'un
fichier, par exemple lorsque les données transférées dans un fichier fonction (function) ne
correspondent pas à ce qui est attendu.
Le programme suivant permet d’additionnez une séquence de nombres aléatoires jusqu'à ce
que la somme s soit supérieur à une limite supérieure. Ensuite, la boucle est interrompue à
l'aide d'une instruction break.
limit = 2;
s = 0; count = 0;
while 1
tmp = rand;
s = s + tmp ;
count = count + 1 ; % nombre d'itérations
if s > limit
break
end
end
Notes :
-
-
A
L'instruction break quitte complètement une boucle for ou while.
Pour ignorer le reste des instructions dans une boucle for ou while et commencer la
LM
prochaine itération, utilisez l’instruction continue.
6.6.2 Commande continue

La commande continue peut-être utilisée à l'intérieur d'une boucle (for ou while) pour arrêter la
l’itération actuelle et démarrer la suivante dans le processus de bouclage.
La commande continue fait généralement partie d'une instruction conditionnelle. Lorsque
MATLAB atteint la commande continue, il n'exécute pas les commandes restantes dans la
boucle, mais passe à la commande de fin de la boucle, puis démarre une nouvelle itération.
Dans les boucles imbriquées, continue ignore les instructions restantes uniquement dans le
corps de la boucle dans laquelle elle est inséré.
Le programme suivant, permet d’affichez les multiples de 3 de 1 à 20. Si un nombre n'est pas
divisible par 3, utilisez continue pour ignorer l'instruction disp et passer le contrôle à l'itération
suivante de la boucle for.
for n = 1:20
if mod(n,3)
continue
end
disp(['Divisible par 3: ' num2str(n)])
end
128
Lorsque ce programme est exécuté, l'affichage dans la fenêtre de commande est :
Divisible par 3: 3
Divisible par 3: 6
Divisible par 3: 9
Divisible par 3: 12
Divisible par 3: 15
Divisible par 3: 18
Notes
- L'instruction continue ignore le reste des instructions dans une boucle for ou while et
commence l'itération suivante. Pour quitter complètement la boucle, utilisez break.
- L'instruction continue n'est pas défini en dehors d'une boucle for ou while. Pour quitter une
fonction, utilisez return.
A
LM
129

Chapitre 6 Programmation Dans MATLAB

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 6 Programmation Dans MATLAB

Transféré par

Droits d'auteur :

Formats disponibles

107 Chapitre 6 Programmation dans MATLAB

Programmation dans MATLAB

Table des matières

Programmation dans MATLAB ........................................................................... 107

Table des matières .............................................................................................................. 107

Introduction ........................................................................................................................ 108

6.1 Opérateurs relationnels et logiques .............................................................................. 109

6.2 Expressions conditionnelles ......................................................................................... 116

6.2.1 La structure if-end ................................................................................................. 116

6.2.2 La structure if-else-end.......................................................................................... 118

6.3 L’instruction switch-case ............................................................................................. 120

6.4.1 Boucles for-end ..................................................................................................... 123

6.4.2 Boucles while-end ................................................................................................. 125

6.5 Boucles imbriquées et expressions conditionnelles imbriquées .................................. 126

6.6 Les commandes break et continue ............................................................................... 127

6.6.1 Commande break ................................................................................................... 127

6.6.2 Commande continue ............................................................................................. 128

Un programme informatique est une séquence de commandes informatiques. Dans un

6.1 Opérateurs relationnels et logiques

Un opérateur relationnel compare deux nombres en déterminant si une déclaration de

>> 5>8 Vérifie si 5 est supérieur à 8

>> a=5<10 Vérifie si 5 est inférieur à 10 et attribue la

>> y=(6<10) + (7>8) + (5*3==60/4)

Vérifie quels éléments c sont supérieurs ou égaux aux éléments b

>> b == c Vérifie quels éléments c sont égaux aux éléments b

>> A=[2 9 4; -3 5 2; 6 7 -1] Définir une matrice A de taille (3x3)

>> r = [8 12 9 4 23 19 10] Définir un vecteur r

>> s=r<=10 Vérifie quels r éléments sont inférieurs ou égaux à 10

>> 3+4<16/2 + et / sont exécutés en premier

Les opérateurs logiques dans MATLAB sont :

Voici quelques exemples :

>> 3&7 3 ET 7 (3 AND 7)

>> a=5|0 5 OU 0 (5 OR 0), attribuer à la variable a

>> ~25 PAS 25 (NOT 25)

>> t=25*((12&0)+(~0)+(0|5)) Utilisation d'opérateurs logiques dans une expression

>> x=[9 3 0 11 0 15]; y=[2 0 13 -11 0 4]; Définir deux vecteurs x et y

7 AND : ET logique (&)

Tableau 6.1 - Ordre de priorité utilisé par MATLAB

>> x=-2; y=5;

Cette inégalité est correcte mathématiquement. La réponse est

>> ~(y>=8)|(x<-1) y> = 8 (faux) et x <–1 (vrai) sont exécutés en premier.

Fonctions logiques intégrées

- and (A, B) équivalent à A&B

Fonction Description Exemple

Tableau 6.2 - Fonctions logiques intégrées supplémentaires

Tableau 6.3 - Table de vérité

6.2 Expressions conditionnelles

Commandes ........ % Programme Matlab

t=input('Veuillez saisir le nombre d’’heures travaillées ');

6.2.2 La structure if-else-end

Figure 6.2 - La structure de l'instruction conditionnelle if-else-end

6.2.3 La structure if-elseif-else-end

Commandes Commandes .......

Figure 6.3 - La structure if-elseif-else-end

Exemple : Fonction définie par morceaux

6.3 L’instruction switch-case

switch switch expression

........ % Programme Matlab

Fonctionnement de l'instruction switch-case

n = input('Entrer un nombre : ');

>> exemple_6_3 >> exemple_6_3

6.4.1 Boucles for-end

for k = f:s:t Avec: