OPERATEURS DE COMPARAISON, OPERATEURS LOGIQUES ET INSTRUCTIONS DE CONTROLE

1 Opérateurs de comparaison

== : égal à (x = = y)
> : strictement plus grand que (x >y)

ard
< : strictement plus petit que (x <y)
> = : plus grand ou égal à (x ≥ y)
< = : plus petit ou égal à (x ≤ y)
˜= : différent de (x ˜= y)

aff
2 Opérateurs logiques

& : et (x & y)
| : ou (x | y)
˜ : non (˜ x)

Dj
Les opérateurs de comparaison et les opérateurs logiques sont utilisés essentiellement dans
les instructions de contrôle.

3 Instructions de contrôle
L
Les instructions de contrôle sous matlab sont très proches de celles existant dans
d’autres langages de programmation.

Boucle for : parcours d’un intervalle

EL
3.1
Une première possibilité pour exécuter une séquence d’instructions de manière répétée
consiste à effectuer une boucle pour les valeurs d’un indice, incrémenté à chaque itération,
variant entre deux bornes données. Ce processus est mis en œuvre par la « boucle for ».

Syntaxe :
W

for indice = borne_inf : borne_sup

séquence d’instructions

end
AX

où
– indice est une variable appelée l’indice de la boucle ;
– borne_inf et borne_sup sont deux constantes réelles (appelées paramètres de la
boucle) ;
– séquence d’instructions est le traitement à effectuer pour les valeurs d’indices variant
entre borne_inf et borne_sup avec un incrément de 1. On parle du corps de la
boucle.
M

Interprétation :

Si borne_infest plus petit ou égalà borne_sup, le traitement séquence d'instructions est exécuté
(borne_sup - borne_inf +1) fois pour les valeurs de la variable indice égales à borne_inf, borne_inf +1,...,
Pr

borne_sup -1, borne_sup. Si borne_inf est strictementplus grand que borne_sup, on passe à l'instrucction
qui suit immédiatement l'instruction de fin de boucle (end)

UMG / ISSTM / L2 GC GE GI GEINF GINF GT 1

 Remarque :
L’indice de boucle ne prend pas nécessairement des valeurs entières. D’autre part il n’est
pas nécessaire que l’indice de la boucle apparaisse dans le corps de la boucle ; par contre il
est interdit de modifier sa valeur s’il apparaît. Il est possible d’imbriquer des boucles mais

ard
elles ne doivent pas se recouvrir. On peut utiliser un incrément (pas) autre que 1 (valeur
par défaut). La syntaxe est alors borne_inf : pas : borne_sup. Le pas peut être négatif.
Attention a bien gérer la borne supérieure ! Voici un exemple (idiot) venant illustrer les
possibilités de variations de l’indice de la boucle

>> for r=1.1:-0.1:0.75

aff
disp(['r = ', num2str(r)]);
end
r = 1.1
r = 1
r = 0.9
r = 0.8

Dj
>>

Voici un exemple d’utilisation d’une boucle pour calculer n!3

>> n = 4;
>> nfac = 1;
>> for k = 1:n
nfac = nfac*k;
L
end
EL
>> nfac
nfac =
24
>>
W

3.2 Boucle while : tant que . . . faire

Une seconde possibilité pour exécuter une séquence d’instructions de manière répétée
consiste à effectuer une boucle tant qu’une condition reste vérifiée. On arrête de boucler
dès que cette condition n’est plus satisfaite. Ce processus est mis en œuvre par la « boucle
AX

while ».

Syntaxe :
while expression logique

séquence d’instructions
M

end
où
– expression logique est une expression dont le résultat peut être vrai ou faux ;
– séquence d’instructions est le traitement à effectuer tant que expression logique est
vraie.
Pr

UMG / ISSTM / L2 GC GE GI GEINF GINF GT 2

 Interprétation :
Tant que expression logique est vraie le traitement séquence d’instructions est exécuté sous
forme d’une boucle. Lorsque expression logique devient faux, on passe à l’instruction qui suit
immédiatement l’instruction de fin de boucle (end).

ard
Remarque :
expression logique est en général le résultat d’un test (par exemple i < Imax) ou le ré-
sultat d’une fonction logique (par exemple all(x)). Il est impératif que le traitement de
la séquence d’instructions agisse sur le résultat de expression logique sans quoi on boucle
indéfiniment (-:.

aff
Voici comment calculer n! avec une boucle while :

>> n = 4;
>> k = 1; nfac = 1;
>> while k <= n

Dj
nfac = nfac*k;
k = k+1;
end
>> nfac
nfac =
24
>>
L
EL
3.3 L’instruction conditionnée if

On a parfois besoin d’exécuter une séquence d’instructions seulement dans le cas où

une condition donnée est vérifiée au préalable. Différentes formes d’instruction conditionnée
existent sous matlab.

L’instruction conditionnée la plus simple a la forme suivante :

W

Syntaxe :
if expression logique

séquence d’instructions
AX

end
où
– expression logique est une expression dont le résultat peut être vrai ou faux ;
– séquence d’instructions est le traitement à effectuer si expression logique est vraie.

Interprétation :
M

la séquence d’instructions n’est exécutée que si le résultat de l’évaluation de l’expression

logique est vraie (c’est-à-dire vaut 1). Dans le cas contraire on exécute l’instruction qui
suit le mot clé end. Dans le cas où l’expression logique est vraie, après exécution de la
séquence d’instructions on reprend le programme à l’instruction qui suit le mot clé end.
Pr

UMG / ISSTM / L2 GC GE GI GEINF GINF GT 3

 Remarque :
Contrairement à certains langages de programmation, il n’y a pas de mot clé « then » dans
cette instruction conditionnée. Notez également que la marque de fin de bloc conditionné
est le mot clé end et non pas « endif ».

ard
Il existe une séquence conditionnée sous forme d’alternatives :
Syntaxe :
if expression logique

séquence d’instructions 1

aff
else

séquence d’instructions 2

end

Dj
où
– expression logique est une expression dont le résultat peut être vrai ou faux ;
– séquence d’instructions 1 est la séquence d’instructions à exécuter dans le cas où
expression logique est vraie et séquence d’instructions 2 est la séquence d’instructions
à exécuter dans le cas où expression logique est faux.
L
Interprétation :
Si expression logique est vraie la séquence d’instructions 1 est exécutée, sinon c’est la
séquence d’instructions 2 qui est exécutée. Le déroulement du programme reprend ensuite
EL
à la première instruction suivant le mot clé end.

Il est bien entendu possible d’imbriquer des séquences d’instructions conditionnées (au
sens où la séquence d’instruction conditionnée contient des séquences d’instructions condi-
tionnée). Pour une meilleure lisibilité, il est recommandé d’utiliser des indentations afin de
mettre en évidence l’imbrication des séquences d’instructions conditionnées.
W

Il est possible d’effectuer un choix en cascade :

Syntaxe :
if expression logique 1
AX

séquence d’instructions 1

elseif expression logique 2

séquence d’instructions 2
..
.
M

elseif expression logique N

séquence d’instructions N

else
Pr

séquence d’instructions par défaut

end

UMG / ISSTM / L2 GC GE GI GEINF GINF GT 4

 Interprétation :
Si expression logique 1 est vraie la séquence d’instructions 1 est exécutée et le programme
reprend ensuite à la première instruction suivant le mot clé end, sinon si expression logique
2 est vraie la séquence d’instructions 2 est exécutée et le programme reprend ensuite à la
première instruction suivant le mot clé end, etc. Si aucune des expressions logiques 1 à N
n’est vraie alors séquence d’instructions par défaut est exécutée.

ard
Remarque :
Attention à ne pas laisser d’espace entre else et if ; le mot clé est elseif.
On utilise fréquemment un choix en cascade lors d’initialisation de données. Par exemple,
on initialise une matrice A en fonction de la valeur d’une variable numex (numéro d’exemple)

aff
de la manière suivante :
for numex=1:6;
numex
if numex == 1
A = ones(n);
elseif numex == 2

Dj
A = magic(n);
elseif numex == 3 | numex == 4
A = rand(n);
else
error(’numero d’’exemple non prevu ...’);
end
3.4
L
Choix ventilé, l’instruction switch

Une alternative à l’utilisation d’une séquence d’instructions conditionnées pour effec-

EL
tuer un choix en cascade existe. Il s’agit de l’instruction switch.

Syntaxe :
switch var

case cst_1 ,
W

séquence d’instructions 1

case cst_2 ,
AX

séquence d’instructions 2
..
.

case cst_N ,

séquence d’instructions N
M

otherwise

séquence d’instructions par défaut

end
Pr

où
– var est une variable numérique ou une variable chaîne de caractères ;
– cst_1, . . ., cst_N, sont des constantes numérique ou des constantes chaîne de carac-
tères ;
– séquence d’instructions i est la séquence d’instructions à exécuter si var==cst_i.

UMG / ISSTM / L2 GC GE GI GEINF GINF GT 5

 Interprétation :
Si la variable var est égale à l’une des constantes cst_1, . . ., cst_N, (par exemple cst_i)
alors la séquence d’instructions correspondante (ici séquence d’instructions i) est exécutée.

ard
Le programme reprend ensuite à la première instruction suivant le mot-clé end. Si la
variable var n’est égale à aucune des constantes la séquence d’instructions par défaut est
exécutée.

aff
Remarque :
La variable var doit bien entendu être du même type que les constantes cst_1, . . ., cst_N.
Il n’est pas nécessaire de prévoir un cas par défaut (bien que cela soit préférable). S’il n’y
a pas de cas par défaut et si la variable var n’est égale à aucune des constantes cst_1, . . .,

Dj
cst_N, alors le programme continue à la première instruction suivant le mot-clé end.
Si la séquence d’instructions à exécuter est la même pour différents cas il est possible de les
regrouper. La syntaxe est alors,
case { cst_k , cst_l , ...}

séquence d’instructions commune

L
Reprenons l’exemple où l’on souhaite initialiser une matrice A en fonction de la valeur
prise par une variable numérique numex (numéro d’exemple). En utilisant un choix
EL
ventilé on obtient :

switch numex
case 1,
A = ones(n)
case 2,
W

A = magic(n);
case {3,4},
A = rand(n);
otherwise
AX

error(’numero d’’exemple non prevu ...’);

end

Voici un exemple de choix ventilé portant sur une variable de type chaîne de caractères.

rep = input(’Votre reponse (oui, non, chepas) :’);

M

switch rep
case {’oui’,’o’},
disp(’bravo ...’);
case {’non’,’n’}
disp(’perdu ...’);
Pr

case ’chepas’
disp(’c’’est pourtant facile ...’);
end

UMG / ISSTM / L2 GC GE GI GEINF GINF GT 6

 3.5 Interruption d’une boucle de contrôle

ard
Il est possible de provoquer une sortie prématurée d’une boucle de contrôle. L’instruc-

tion break permet de sortir d’une boucle for ou d’une boucle while. L’exécution se

poursuit alors séquentiellement à partir de l’instruction suivant le mot clé end

aff
fermant la boucle. En cas de boucles imbriquées, on interrompt seulement l’exécution de la
boucle intérieure contenant l’instruction break.

Dj
L’instruction return provoque un retour au programme appelant (ou au clavier).

Les instructions suivant le return ne sont donc pas exécutées. L’instruction return
est souvent utilisée conjointement avec une instruction conditionnée par exemple pour
tester dans le corps d’une fonction si les paramètres d’entrée ont les valeurs attendues.
L
EL
L’instruction error permet d’arrêter un programme et d’afficher un message

d’erreur :
syntaxe :

error(' message d”erreur ’).

W

L’instruction warning permet d’afficher un message de mise en garde sans

suspendre l’exécution du programme :

syntaxe :
AX

warning(' message de mise en garde ’).

Il est possible d'indiqer à MATLAB de ne pas afficher les message de mise en garde d’un

programme en tapant warning off dans la fenêtre de commandes. On rétablit l’affichage en

tapant warning on.

M
Pr

UMG / ISSTM / L2 GC GE GI GEINF GINF GT 7