Informatique
Appliquée
3
Chapitre 3 : Programmation MatLab
Sommaire
3.1. Entrée dans un fichier script ................................................................................... 5
3.1.1.1. La variable est définie et affectée dans le fichier script .................................. 5
3.1.1.2. La variable est définie et affectée dans la fenêtre de commande .................... 5
3.1.1.3. La variable est définie dans le script, mais la valeur est entrée dans la fenêtre
de commande lorsque le script est exécuté ......................................................................... 6
3.2. Commandes de Sortie .............................................................................................. 7
3.2.1. La commande disp ............................................................................................... 7
3.2.2. La commande fprintf ........................................................................................... 8
3.3. Structures de contrôle ........................................................................................... 12
3.3.1. Branchement conditionnel (if … elseif … else…end)........................................ 12
3.3.2. Branchement multiple (switch … case) ............................................................. 13
3.3.3. Boucle conditionnelle (while … ) ....................................................................... 13
3.3.4. Boucle itérative (for … ) .................................................................................... 14
4
3.1. Entrée dans un fichier script
Lorsqu'un fichier script est exécuté, les variables utilisées dans les calculs au sein du
fichier doivent avoir des valeurs affectées. En d'autres termes, les variables doivent se
trouver dans l'espace de travail. L'affectation d'une valeur à une variable peut se faire
de trois manières, selon où et comment la variable est définie.
3.1.1.1.La variable est définie et affectée dans le fichier script
Dans ce cas, l'affectation d'une valeur à la variable fait partie du fichier script. Si
l'utilisateur souhaite exécuter le fichier avec une valeur de variable différente, le
fichier doit être modifié en réaffectant la variable. Ensuite, une fois le fichier
enregistré, il peut être exécuté à nouveau.
Voici un exemple d'un tel cas. Le fichier script (enregistré sous Chapitre3_Example1)
calcule la moyenne obtenue en trois années.
% Le programme calcule la moyenne obtenue dans trois années.
% L'affectation des moyennes des années fait partie du fichier
script
moy_annee1=14.54;
moy_annee2=12.71;
moy_annee3=13.74;
moyenne_generale=(moy_annee1+moy_annee2+moy_annee3)/3
L'affichage dans la fenêtre de commande lorsque le fichier script est exécuté est :
>> Chapitre3_Example1
moyenne_generale =
13.6633
3.1.1.2.La variable est définie et affectée dans la fenêtre de commande
Dans ce cas, l'affectation d'une valeur à la variable se fait dans la fenêtre de
commande. Si l'utilisateur souhaite exécuter le fichier script avec une valeur
différente pour la variable, la nouvelle valeur est affectée dans la fenêtre de
commande et le fichier est à nouveau exécuté. Pour l'exemple précédent dans lequel le
fichier script a un programme qui calcule la moyenne obtenue en trois années, le
fichier script (enregistré sous Chapitre3_Example2) est :
% Le programme calcule la moyenne obtenue dans trois années.
% L'affectation des moyennes des années aux variables
% moy_annee1, moy_annee2 et moy_annee3 se fait dans la fenêtre de
commande
moyenne_generale = (moy_annee1+moy_annee2+moy_annee3)/3
Pour exécuter ce nouveau programme, dans la fenêtre de commande on doit taper les
variables puis le nom du script :
5
>> moy_annee1=14.54;
>> moy_annee2=12.71;
>> moy_annee3=13.74;
>> Chapitre3_Example2
moyenne_generale =
13.6633
>> moy_annee1=13.72;
>> moy_annee2=13.76;
>> moy_annee3=14.19;
>> Chapitre3_Example2
moyenne_generale =
13.8900
3.1.1.3.La variable est définie dans le script, mais la valeur est entrée dans la
fenêtre de commande lorsque le script est exécuté
Dans ce cas, la variable est définie dans le fichier script et lorsque le fichier est
exécuté, l'utilisateur est invité à attribuer une valeur à la variable dans la fenêtre de
commande. Cela se fait en utilisant la commande input pour créer la variable.
La forme de la commande (d’entrée) input est :
nom_variable = input ('un message affiché dans la fenêtre de commande')
Lorsque la commande input est exécutée lors de l'exécution du fichier script, la chaîne
de caractères (message) s'affiche dans la fenêtre de commande. La chaîne est un
message invitant l'utilisateur à entrer une valeur affectée à la variable. L'utilisateur
saisit la valeur et appuie sur la touche Entrée. Cela affecte la valeur à la variable.
Comme pour toute variable, la variable et sa valeur affectée seront affichées dans la
fenêtre de commande, sauf si un point-virgule est tapé à la fin de la commande
d'entrée.
Un fichier script qui utilise la commande input pour entrer les moyennes des trois
années pour le programme qui calcule la moyenne générale est illustré ci-dessous :
% Le programme calcule la moyenne générale de trois années
% La moyenne de chaque année est attribuée aux variables
% à l'aide de la commande input
moy_annee1=input('Entrer la moyenne de la 1ère année ');
moy_annee2=input('Entrer la moyenne de la 2ère année ');
moy_annee3=input('Entrer la moyenne de la 3ère année ');
moyenne_generale=(moy_annee1+moy_annee2+moy_annee3)/3
Ce qui suit montre la fenêtre de commande lorsque ce script (enregistré en tant que
Chapitre3_Example3) est exécuté :
>> Chapitre3_Example3
Entrer la moyenne de la 1ère année 14.54
Entrer la moyenne de la 2ère année 12.71
Entrer la moyenne de la 3ère année 13.74
moyenne_generale =
13.6633
En général, des vecteurs et des matrices peuvent également être attribués. Cela se fait
en tapant le tableau de la même manière habituelle (crochet gauche, puis en tapant
ligne par ligne et enfin un crochet droit).
6
Exemple :
% Le programme lit un
V = input('Entrer votre vecteur')
Ce qui suit montre la fenêtre de commande lorsque ce script (enregistré en tant que
Chapitre3_Example4) est exécuté :
>> Chapitre3_Example4
Entrer votre vecteur
[1 2 3]
V=
1 2 3
La commande input peut également être utilisée pour affecter une chaîne de caractères
à une variable. Cela peut être fait de deux manières :
- Utiliser la commande sous la même forme que celle illustrée ci-dessus où la
chaîne est tapée entre deux guillemets simples « ' ' » de la même manière
qu'une chaîne est affectée à une variable sans la commande input.
- Utiliser une option dans la commande d'entrée qui définit les caractères entrés
sous forme de chaîne. La forme de la commande est :
nom_variable = input (' message ' , 's')
où le «s» à l'intérieur de la commande définit les caractères qui seront saisis
sous forme de chaîne. Dans ce cas, lorsque le message d'invite apparaît, le
texte est saisi sans les guillemets simples, mais il est affecté à la variable sous
forme de chaîne.
Exemples :
>> jour = input (' entrer le jour de la semaine ')
entrer le jour de la semaine 'lundi'
jour =
'lundi'
>> jour = input (' entrer le jour de la semaine ' , 's')
entrer le jour de la semaine lundi
jour =
'lundi'
3.2. Commandes de Sortie
Les deux commandes disp et fprintf sont fréquemment utilisées pour générer la sortie.
La commande disp affiche la sortie à l'écran, tandis que la commande fprintf peut être
utilisée pour afficher la sortie à l'écran ou pour enregistrer la sortie dans un fichier.
Les commandes peuvent être utilisées dans la fenêtre de commande, dans un fichier
script ou dans un fichier de fonction. Lorsque ces commandes sont utilisées dans un
fichier script, la sortie d'affichage qu'elles génèrent est affichée dans la fenêtre de
commande.
3.2.1. La commande disp
7
La commande disp est utilisée pour afficher les éléments d'une variable (sans afficher
le nom de la variable) et pour afficher du texte. Le format de la commande disp est :
disp (nom d'une variable)
Ou
disp ('texte sous forme de chaîne de caractères')
Chaque fois que la commande disp est exécutée, l'affichage qu'elle génère apparaît sur
une nouvelle ligne.
Exemple:
>> Mat=[8 3 1; 9 5 8];
>> disp(Mat)
831
958
>> disp('L''équation n''a pas de solution')
L'équation n'a pas de solution
L'exemple suivant montre l'utilisation de la commande disp dans le fichier script qui
calcule la moyenne des trois années :
% Le programme calcule la moyenne générale des trois années
% La moyenne de chaque année est attribuée aux variables
% à l'aide de la commande input
% La commande disp est utilisée pour afficher la sortie.
moy_annee1=input('Entrer la moyenne de la 1ère année ');
moy_annee2=input('Entrer la moyenne de la 2ère année ');
moy_annee3=input('Entrer la moyenne de la 3ère année ');
moyenne_generale=(moy_annee1+moy_annee2+moy_annee3)/3;
disp(' ')
disp('la moyenne générale de trois années est : ')
disp(' ')
disp(moyenne_generale)
Lorsque ce fichier (enregistré sous Chapitre3_Example5) est exécuté, l'affichage dans
la fenêtre de commande est :
>> Chapitre3_Example5
Entrer la moyenne de la 1ère année 14.54
Entrer la moyenne de la 2ère année 12.71
Entrer la moyenne de la 3ère année 13.74
la moyenne générale de trois années est :
13.6633
Une seule variable peut être affichée dans une commande disp. Si des éléments de
deux variables doivent être affichés ensemble, une nouvelle variable (qui contient les
éléments à afficher) doit d'abord être définie puis affichée.
3.2.2. La commande fprintf
8
En plus d'afficher la sortie à l'écran (texte et données), la commande fprintf peut être
utilisée pour enregistrer la sortie dans un fichier. Les données enregistrées peuvent
ensuite être utilisées par MATLAB ou d'autres logiciels.
a- La commande fprintf pour afficher du texte
Pour afficher du texte, la commande fprintf a la forme :
fprintf ('texte sous forme de chaîne de caractères')
Exemple :
>> fprintf('L''équation n''a pas de solution')
L’équation n’a pas de solution
Avec la commande fprintf, il est possible de démarrer une nouvelle ligne au milieu de
la chaîne. Cela se fait en insérant \n devant le caractère qui va commencer la nouvelle
ligne.
Pour afficher le caractère % dans le texte, tapez %%.
Exemples :
>> fprintf('L''équation n''a pas \n de solution')
L’équation n’a pas
de solution
>> fprintf('Le chapitre est finalisé à 100%%')
Le chapitre est finalisé à 100%
Lorsqu'un programme possède plusieurs commandes fprintf, l'affichage généré est
continu (la commande fprintf ne démarre pas automatiquement une nouvelle ligne).
Cela est vrai même s'il existe d'autres commandes entre les commandes fprintf. Pour
commencer une nouvelle ligne avec la commande fprintf, \n doit être tapé au début de
la chaîne.
b- La commande fprintf pour afficher un mélange de texte et de données
numériques
Pour afficher un mélange de texte et de nombre (valeur d'une variable), la commande
fprintf a la forme :
fprintf('texte %format texte supplémentaire', var1,var2,...)
où format est une chaîne de caractères décrivant le format d'écriture des variables
var1,var2,... que l'on souhaite afficher. Les principaux types de formats d'écriture
sont:
- %d : entier ou %Nd (N est la largeur du champ, qui spécifie le nombre
minimum de chiffres à l'écran. Si le nombre à afficher est plus court que la
largeur du champ, des espaces ou des zéros sont ajoutés devant le nombre).
%N.nf : réel de longueur N avec n chiffres après la virgule, par exemple 32.42
- %e : notation exponentielle utilisant un e minuscule (par exemple, 1.709098e
+ 001).
- %E : notation exponentielle utilisant E majuscule (par exemple, 1.709098E +
001).
9
- %g : la plus courte des notations e ou f.
- %G : la plus courte des notations E ou f.
- %s : chaîne de caractères.
Exemple :
Voici le Script suivant :
% Le programme calcule la moyenne générale des trois années
% La moyenne de chaque année est attribuée aux variables
% à l'aide de la commande input
% La commande fprintf est utilisée pour afficher la sortie.
moy_annee1=input('Entrer la moyenne de la 1ère année ');
moy_annee2=input('Entrer la moyenne de la 2ère année ');
moy_annee3=input('Entrer la moyenne de la 3ère année ');
moyenne_generale=(moy_annee1+moy_annee2+moy_annee3)/3;
fprintf('la moyenne générale est : %5.2f \n', moyenne_generale)
Lorsque ce fichier est exécuté, l'affichage dans la fenêtre de commande est :
>> Chapitre3_Example6
Entrer la moyenne de la 1ère année 14.54
Entrer la moyenne de la 2ère année 12.71
Entrer la moyenne de la 3ère année 13.74
la moyenne générale est : 13.66
Avec la commande fprintf, il est possible d'insérer plusieurs valeurs de variables dans
le texte. Cela se fait en tapant %format (ou % suivi de tout élément de mise en forme)
aux endroits du texte où les nombres doivent être insérés. Ensuite, après la fin du texte
(après la virgule), les noms des variables sont saisis dans l'ordre dans lequel ils sont
insérés dans le texte. En général, la commande ressemble à :
fprintf('texte ...%f ...%g ...%f ...', variable1, variable2, variable3)
c- La commande fprintf pour enregistrer la sortie dans un fichier
La commande fprintf peut être utilisée pour enregistrer la sortie dans un fichier.
L'écriture d'une sortie dans un fichier nécessite trois étapes :
1) Ouverture d'un fichier à l'aide de la commande fopen
Le fichier doit être ouvert. Cela se fait avec la commande fopen, qui crée un nouveau
fichier (le fichier créé est enregistré dans le répertoire courant) ou ouvre un fichier
existant :
fid = fopen(' nom_fichier ', ' autorisation ')
fid est une variable appelée identificateur de fichier. Une valeur scalaire est affectée à
fid lorsque fopen est exécuté. Le nom du fichier est écrit (y compris son extension)
entre guillemets simples sous forme de chaîne. L'autorisation est un code (également
écrit sous forme de chaîne) qui indique comment le fichier est ouvert :
- ' r ' : Ouvrir le fichier en lecture (par défaut).
- ' w ' : Ouvrir le fichier en écriture. Si le fichier existe déjà, son contenu est supprimé.
Si le fichier n'existe pas, un nouveau fichier est créé.
10
- ' a ' : Identique à 'w', mais si le fichier existe, les données écrites sont ajoutées à la
fin.
- 'r+' : Ouvrir (ne pas créer) un fichier pour la lecture et l’écriture.
- 'w+' : Ouvrir un fichier pour la lecture et l’écriture. Si le fichier existe déjà, son
contenu est supprimé. Si le fichier n'existe pas, un nouveau fichier est créé.
- 'a+' : Identique à 'w+', mais si le fichier existe, les données écrites sont ajoutées à la
fin.
Si aucun code d'autorisation n'est inclus dans la commande, le fichier s'ouvre avec le code
par défaut ' r '.
2) Écriture de la sortie dans le fichier ouvert à l'aide de la commande fprintf
Une fois le fichier ouvert, la commande fprintf peut être utilisée pour écrire la sortie
dans le fichier. La commande fprintf est utilisée exactement de la même manière
qu'elle est utilisée pour afficher la sortie dans la fenêtre de commande, sauf que la
variable fid est insérée à l'intérieur de la commande. La commande fprintf a donc la
forme suivante :
fprintf (fid,'texte %format texte supplémentaire', nom_variable)
3) Fermeture du fichier à l'aide de la commande fclose
Une fois l'écriture des données dans le fichier est terminée, le fichier est fermé à l'aide de
la commande fclose. La commande fclose a la forme :
fclose (fid)
Exemple :
Le programme dans le fichier génère deux tables de conversion d'unité. Une table
convertit les unités de vitesse, miles par heure en kilomètres par heure, et l'autre table
convertit les unités de force, livres en newtons. Chaque table de conversion est
enregistrée dans un fichier texte différent (extension .txt).
% Fichier script dans lequel fprintf est utilisé pour écrire la sortie dans des
%fichiers. Deux tables de conversion sont créées et enregistrées dans deux
%fichiers différents. L'un convertit mi/h en km/h, l'autre convertit lb en N.
clear all
Vmph=10:10:100;
Vkmh=Vmph.*1.609;
TBL1=[Vmph; Vkmh];
Flb=200:200:2000;
FN=Flb.*4.448;
TBL2=[Flb; FN];
fid1=fopen('VmphtoVkm.txt','w');
fid2=fopen('FlbtoFN.txt','w');
fprintf(fid1,'Velocity Conversion Table\n \n');
fprintf(fid1, ' mi/h km/h \n');
fprintf(fid1,' %8.2f %8.2f\n',TBL1);
fprintf(fid2,'Force Conversion Table\n \n');
fprintf(fid2, ' Pounds Newtons \n');
fprintf(fid2,' %8.2f %8.2f\n',TBL2);
fclose(fid1);
fclose(fid2);
11
3.3. Structures de contrôle
Dans sa forme la plus simple, le déroulement d’un programme est linéaire dans le
sens où les instructions qui le composent s’exécutent successivement. Les structures
de contrôle sont des mécanismes qui permettent de modifier la séquence d’exécution
des instructions. Plus précisément, lors de l’exécution, en fonction des conditions
réalisées certaines parties précises du code seront exécutées.
3.3.1. Branchement conditionnel (if … elseif … else…end)
Cette structure permet d’exécuter un bloc d’instructions en fonction de la valeur
logique d’une expression. Un test est une alternative entre deux commandes (ou
groupe de commandes ) Matlab sélectionnées suivant le résultat d'une opération
logique. Le résultat d'une opération logique (voir ci-dessus) est une variable logique
ou booléenne qui vaut 1 pour VRAI et 0 pour FAUX. Dans Matlab, on dispose de
plusieurs possibilités :
if expression
instructions …
end
L’ensemble des instructions « instructions » est exécuté seulement si « expression »
est vraie. Plusieurs tests exclusifs peuvent être combinés.
if expression
instructions1…
else
instructions2…
end
if expression1
instructions1 …
elseif expression2
instructions2 …
else instructions3 …
end
Plusieurs elseif peuvent être concaténés. Leur bloc est exécuté si l’expression
correspondante est vraie et si toutes les conditions précédentes n’ont pas été
satisfaites. Le bloc « instruction3 » associé au else est quant à lui exécuté si aucune
des conditions précédentes n’a été réalisées.
Exemple :
if x > 0
disp(‘x est positif’);
elseif x == 0
disp(‘x est nul’);
else
x = 1;
end
12
Bien évidement, la variable x doit être définie auparavant. La fonction disp permet
d’afficher une chaîne de caractère spécifiée entre apostrophes. Si x n’est ni positif ni
nul, il reçoit la valeur 1.
3.3.2. Branchement multiple (switch … case)
Dans cette structure, une expression numérique est comparée successivement à
différentes valeurs. Dès qu’il y a identité, le bloc d’instructions correspondant est
exécuté. Sa syntaxe est :
switch expression
case valeur1
instructions1 …
case valeur2
instructions2 …
case valeur3
instructions3 …
otherwise
instructions …
end
L’expression testée, expression, doit être un scalaire ou une chaîne de caractère. Une
fois qu’un bloc instructions est exécuté, le flux d’exécution sort de la structure et
reprend après le end. Si aucun case vérifie l’égalité, le bloc qui suit otherwise est
exécuté.
Exemple
switch x
case 0
resultat = a + b;
case 1
resultat = a * b;
case 2
resultat = a/b;
case 3
resultat = a^b;
otherwise
resultat = 0;
end
En fonction de la valeur de x, une opération particulière est effectuée. Par défaut,
resultat prend la valeur 0.
3.3.3. Boucle conditionnelle (while … )
Ce mécanisme permet de répéter une série d’instructions tant qu’une condition est
vérifiée. Sa syntaxe est :
13
while expression
instructions …
end
Le terme expression est une expression logique. Si cette dernière est vraie, le bloc
instructions est exécuté. Puis, expression est de nouveau testée. L’exécution du bloc
est répétée tant que le test est vrai.
Exemple
compteur = 0;
while compteur < 10
disp(’toujours dans la boucle’) ;
compteur = compteur + 1;
end
Cet exemple affiche 10 fois la chaîne de caractère « toujours dans la boucle ».
3.3.4. Boucle itérative (for … )
Cette boucle exécute le bloc interne autant de fois que spécifié par une variable jouant
un rôle de compteur. Sa syntaxe est :
for variable = debut:pas:fin
instructions …
end
Le compteur variable est initialisé à la valeur debut et évolue jusqu’à la valeur fin par
pas. A chaque itération, le bloc instructions est exécuté. Généralement, variable est un
scalaire, et souvent un entier.
Exemple
N=5;
for k = 1:N
x(k)= 1/k;
end
Cet exemple construit élément par élément un vecteur x de dimension 5.
14
