Vous êtes sur la page 1sur 19

MATLAB

APPROCHE ALGORITHMIQUE
PLAN DU COURS

1. INTRODUCTION
1.1 Présentation d'un ordinateur
1.2 Software et hardware
1.3 Utilisation des ordinateurs
1.4 Vie d'un programme

2. NOTIONS DE BASE
2.1 Notion d’algorithme
2.2 Le type entier
2.3 Le type réel
2.4 Le type caractère
2.5 Le type booléen
2.6 Le type complexe
2.7 Les actions de base
2.8 Les structures de contrôle

3. LES TABLEAUX
3.1 Description
3.2 Manipulation de tableaux unidimensionnels
3.3 Tri de tableaux
3.4 Tableaux bidimensionnels
3.5 Construction des tableaux bidimensionnels
3.6 Manipulation des tableaux bidimensionnels

4. L’ACTION PARAMETREE
4.1 Description
4.2 Objets Manipulés par une action paramétrée
4.3 Les actions paramétrées sous Matlab
4.4 Visibilité dans Matlab
4.5 Fonctions Matlab utiles

Bibliographie :
1. Matlab Help 7.0 (R14).
2. A. Biran et M.Breiner « Matlab pour l’ingénieur », 2006. Pearson Education.
3. M. Postel « Introduction au logiciel Matlab », 2004. internet.

1
CHAPITRE 1

INTRODUCTION

1.1 PRESENTATION D'UN ORDINATEUR, ASPECT HARDWARE


Les composants d’un ordinateur sont en général :
1. un processeur central;
2. une mémoire centrale (dite mémoire vive ou RAM);
3. un clavier;
4. un moniteur;
5. un lecteur DVD;
6. des interfaces de connexion à des périphériques tels que : imprimante, scanneur, réseaux, … etc.
Ces composants forment la partie hardware de l'ordinateur qui peut être classifiée en trois catégories :
1. Le processeur central ou CPU : réalise les opérations de base.
2. La mémoire principale : contient les programmes spécifiant les opérations à exécuter et les informations
ou données traitées par les opérations.
3. Les périphériques ou organes d'entrée-sortie : utilisés pour introduire programmes et informations à la
mémoire principale et pour communiquer les résultats des activités réalisées.
1.2 SOFTWARE
L'ensemble des composants hardware n'est qu'un simple ‘tas de ferraille’ sans aucune utilité (le mot anglais
hardware veut dire quincaillerie). Pour devenir utile, il faut associer à cette partie hardware une autre
partie dite software (si hardware était un mot connu, software a été créé pour les besoins en remplaçant

Processeur Mémoire
Périphériques principale
central

Figure 1.2 Architecture de Von Newman


hard i.e. dur par soft qui veut dire souple). En effet, l’utilisateur d’un ordinateur demande essentiellement
deux types de services :
1. Créer et nommer des fichiers ; conserver ces fichiers dans des disquettes ; transférer de l’information
entre les fichiers et les organes d’entrée-sortie (écran, clavier, imprimante).
2. Exécuter des programmes existants déjà ou introduits à l’ordinateur; les données sont introduites au
clavier ou prélevées dans un fichier ; les résultats sont affichés à l’écran, listées sur imprimante ou copiées
dans un fichier.

2
Aucun de ces traitements n'est possible sans l'aide du software. De façon générale le software se divise en
deux parties : le système d'exploitation et les logiciels d'application.
Le système d'exploitation tel que Linux et Windows permet de réaliser les deux fonctions suivantes :
1. Gérer les travaux de l'utilisateur en dissimulant à celui-ci les détails de fonctionnement : Par exemple,
pour réaliser une opération de lecture d'un fichier, l’utilisateur n’a pas à se soucier du positionnement du
bras de lecture du disque dur ni du réglage de la vitesse du moteur de ce bras.
2. Gérer les ressources de l’ordinateur en contrôlant et affectant celles-ci aux différentes applications
(programmes) en exécution de façon raisonnable : Par exemple si deux programmes demandent une
impression en même temps, le résultat de l’impression pourrait être un mélange de lignes issues des deux
programmes. Le système d'exploitation sert à éviter ces cas de fonctionnement anormal en autorisant, dans
une première étape, l’un des programmes à effectuer son impression tout en sauvegardant les données à
imprimer du deuxième sur disque dur. L’imprimante devenue libre, le système d'exploitation lancera
l’impression des informations sauvegardées.
1.3 UTILISATION DES ORDINATEURS
1. Calcul scientifique : Historiquement, ce fut la première application. La tâche de l'ordinateur consistait
au calcul de certaines fonctions mathématiques telles que celles de l'analyse numérique et des
statistiques.
2. Systèmes d'informations : L'ordinateur est utilisé pour fournir rapidement des informations stockées
en mémoire. Le volume des informations peut être très volumineux rendant la manipulation manuelle
trop fastidieuse. Des exemples de systèmes d'information sont les systèmes de réservation des
compagnies aériennes et les systèmes bancaires.
3. Process Control : L'ordinateur est utilisé pour surveiller et commander des dispositifs industriels ou
autres. Parmi les applications nous trouvons les systèmes de contrôle des centrales nucléaires, des
usines de fabrication de produits chimiques, des chaînes de montage robotisées, de surveillance
médicale, … etc.
1.4 PRISE EN CHARGE DES PROGRAMMES PAR ORDINATEUR
Les programmes utilisateur sont en général écrits dans un langage de programmation de haut niveau
proche du langage humain, tel que Pascal et C++. Pour être exécuté, ces programmes sont transformés par
des outils logiciels. Ces outils qui peuvent être séparés ou intégrés sont décrits comme suit :
1.4.1 Editeur de texte
C'est un programme permettant de saisir du texte et de le sauvegarder dans un fichier de type texte. Il sert
à écrire le code source du programme utilisateur écrit dans un langage de haut niveau.
Exemple : L'éditeur de texte de MS-DOS lancé par la commande Edit ou Notepad (bloc note) de Windows.
1.4.2 Compilateur
C'est un programme permettant de traduire le programme source écrit dans un langage évolué, en un
programme binaire compris par la machine.
Le programme binaire obtenu est appelé programme objet.
3
Exemple : TCC compilateur C++ de Borland sous DOS ou GCC compilateur C sous UNIX.

Programme Programme Programme Programme


source Editeur Compilateur objet Editeur
source objet Exécution
de texte de lien
Support Support fichier Extension OBJ Extension EXE
papier

Interpréteur

Figure 1.3 Vie d'un programme utilisateur


1.4.3 Editeur de liens
C'est un programme qui permet d'assembler le code objet du programme utilisateur et celui des procédures
et fonctions prédéfinies en un seul et unique programme exécutable.
Cette étape réalisée, le programme utilisateur est en fin prêt à être chargé en mémoire centrale pour être
exécuté.
1.4.4 Interpréteur
A la différence d’un compilateur, l’interpréteur traduit une instruction du programme puis l’exécute avant de passer à
l’instruction suivante.

4
CHAPITRE 2

NOTIONS DE BASE

2.1 NOTION D’ALGORITHME


Définition : Un algorithme est une suite d’instructions (ou d’actions) écrite dans un langage qui se situe
entre le langage naturel et le langage machine.
Une action est soit impérative ou conditionnelle.
Exemple : A+B est une action impérative, par contre Si X >= 0 Alors Z=A+B constitue une action
conditionnelle.
2.1.1 Structure d’un algorithme
La structure de base d’un algorithme est fondée sur deux concepts fondamentaux : la partie déclarations
et la partie actions agencées comme suit :

Algorithme < nom de l’algorithme > ;


< Partie déclarations >
Debut
< Partie actions >
Fin.

Figure 3 Structure d’un algorithme.


Les mots « Debut » et « Fin » indiquent les limites d’un ensemble d’instruction qui est dans ce cas la partie
action. Les instructions manipulent des objets devant être déclarés dans la partie déclaration.
Pour être complètement défini un objet doit en général avoir :
1. Un nom qui est l’identificateur de l’objet.
2. Un type décrivant l’objet.
3. Une valeur qui est une information liée à l’objet à un instant donné.
Les deux premiers éléments, nom et type sont associés à la déclaration, le troisième est précisé dans la
partie action.
2.1.2 Notion de déclaration
La déclaration d’une variable dans un algorithme consiste à associer à cette variable un identificateur et
un type.
La forme de la déclaration algorithmique est :
Var < identificateur > : < type > ;
L’identificateur permet de donner une appellation à cette variable. Il doit être une chaîne
alphanumérique, dont le premier caractère est alphabétique.
Exemple : Mat, prenom, MG1, X2 sont des noms d’identificateurs par contre 1B, A-X et prénom ne peuvent
être des identificateurs.

5
Pour Matlab :
• on peut utiliser dans cette chaîne le tiret bas.
• la vérification de la validité d’un identificateur est possible grâce à la commande isvarname.
• la casse est importante : MAT, Mat et mat sont trois identificateurs différents.
• le nombre de caractères pris en compte est déterminé par namelengthmax qui vaut en général 63.
Le type décrit l’ensemble des valeurs que peut prendre la variable.
2.2 LE TYPE ENTIER
Ce type caractérise une partie des nombres entiers. Les opérations arithmétiques possibles sur ce type sont :
L’addition, la soustraction, la multiplication, la division (notées respectivement : +, -, *, /) . Appliquées sur
des opérandes de type entier, elles fournissent un résultat entier sauf pour la division qui fournit un
résultat réel.
Les opérations de relation notées par : ==, < , <= ,> ,>= ,~= fournissent un résultat logique (booléen) .
Une constante entière s’écrit à l’aide d’une suite de chiffres précédée ou non d’un (+ ou - ).
Exemple : 25 ou -450.
Pour Matlab, il y a plusieurs types entiers. Ils sont regroupés dans la table suivante :
Type entier Valeurs possibles Fonction
Signé 8-bit -128 à 127 int8()
Non nsigné 8-bit 0 à 255 uint8()
Signé 16-bit -32,768 à 32,767 int16()
Non signé 16-bit 0 à 216 – 1 uint16()
Signé 32-bit -231 to 231 – 1 int32()
Non signé 32-bit 0 to 232 -1 uint32()
Exemple : si on exécute x=int8(200) on obtient 127 comme valeur de x.
2.3 LE TYPE REEL
Ce type représente une partie des nombres réels. Les opérations : + , - , * , / , fournissent un résultat réel .
Les opérations : ==, > , >= , < , < = , ~= fournissent un résultat logique.
Une constante réelle a la forme < Signe > < Partie entière > . < Partie décimale> qui est la représentation à
virgule fixe ( ‘’.‘’ est le point décimal). Une autre forme est aussi possible qui est la représentation à virgule
flottante utilisant une mantisse et un exposant.
Exemple : 125.45 et -0.0065 sont deux nombres réels représentés par virgule fixe. En virgule flottante ils
sont représentés en base 10 par 1.2545 e+2 et -6.5 e -3 respectivement.
MATLAB utilise deux types réels : double précision et simple précision notés double et single. Un réel
double précision est codé sur 64 bits et est compris entre -1.79769 × 10+308 à -2.22507 × 10-308 et 2.22507 × 10-
308 à 1.79769 × 10+308. D’autre part, un réel simple précision est codé sur 32 bits et est comprises entre
-3.40282 × 10+38 à -1.17549 × 10-38 et 1.17549 × 10-38 à 3.40282 × 10+38.
Pour créer une variable réelle on peut utiliser les fonctions double() et single().
Exemple : x=single(10) crée une variable simple précision initialisée par la valeur 10. D’autre part,
x=double(10) (ou x=10 car double par défaut) crée une variable double précision initialisée par la valeur 10.

6
2.4 LE TYPE CARACTERE
Il est noté dans Matlab char. Il caractérise l’ensemble des caractères alphabétiques « A, B, C, D, … , Z, a, b, c,
d, … , z », les caractères numériques « 0,1,2,…,9 », les séparateurs « , ; ( ) [ ] . », le blanc « » (ou b) les
opérateurs arithmétiques et logiques « +, -, < , > , <, = » ; c’est à dire tous les caractères nécessaires à
l’écriture d’un texte.
Une constante de type caractère sera écrite entre cotes.
Exemple : ’A’ et ’ ; ’ et ’7’ sont trois constantes de type caractère. 7 ne l’est pas.
Deux variables de type caractère peuvent être comparées à l’aide des opérateurs de relation, car l’ensemble
des caractères est muni d’une relation d’ordre décrite par le code ASCII (American Standard Code for
Information Interchange) étendu.
Exemple : En exécutant le code suivant
x='a';
y='A';
if x<y
disp(1);
else
disp(0);
end;
le résultat affiché est 0 car le code ASCII de ‘a’ est 97 alors que celui de ‘A’ est 65.
La fonction char() retourne le caractère dont le code ASCII correspond à l’argument.
Exemple : x=char(77) définit une variable caractère de valeur ’M’.
2.5 LE TYPE BOOLEEN
Ce type se caractérise par un ensemble de valeurs réduit à deux valeurs (vrai et faux). Pour Matlab, ce type
et appelé logical (logique) et ces valeurs sont true et false également représentées par 1 et 0.
Les opérateurs logiques ET, OU, NON appliqués à des opérandes de type booléen fournissent un résultat
booléen. Il sont notés en Matlab par &&, || et ~ respectivement.
Exemple : l’exécution du code suivant :
x=true ; else
y=~x; disp(0);
if (x && y) || (~x && y) end;
disp(1);
donne la valeur 0.
Pour créer une variable logique, on peut utiliser la fonction logical().
Exemple : x=logical(1) crée une variable booléenne initialisée par true.
2.6 LE TYPE COMPLEXE
Les nombre complexes sont constitués de deux parties: une partie réelle et une autre imaginaire. L’unité
imaginaire basique est égale à la racine carrée de -1. Ceci est représenté dans MATLAB par la lettre i ou j.
Pour créer des complexes deux méthode peuvent être utilisées : la méthode directe par affectation et celle
utilisant la fonction complex().

7
Exemple : l’affectation x = 2 + 3*i ; (ou x = 2 + 3i) associe à x le nombre complexe dont la partie réelle vaut 2
et celle imaginaire 3. Le même effet peut être obtenue par x=complex(2,3) ;
On peut scinder un nombre complexe en ses deux parties réelle et imaginaire en utilisant les fonctions real()
et imag().
Exemple : si x est égal à 2+3i alors xr=real(x) affecte à xr la valeur 2 et xi=imag(x) affecte à xi la valeur 3.
2.7 LES ACTIONS DE BASE
2.7.1 L’affectation
Cette action permet d’affecter une valeur à une variable. Sa forme en Matlab est :
< identificateur > = < expression > ;
Le symbole « = » représente le signal de l’affectation et le résultat de l’évaluation de la partie notée
<expression> est affectée à la variable située à gauche du symbole d’affectation.
2.7.2 La lecture
Cette action permet la lecture d’informations ou données à partir du clavier. Sa forme en Matlab est :
x=input( <message>) ;
Exemple :
x=input (‘Donner une valeur’) ;
Cette action a le même effet que l’action d’affectation, mais les valeurs affectées sont des données lues au
moment de l’exécution de l’action.
2.7.3 L’écriture
Cette action permet d’afficher sur écran la valeur de variables ou de constantes. Sa forme est :
disp( < résultat > ) ;
où <résultat> peut être un message écrit entre cotes.
Exemple :
disp ('Le résultat est : ') ; disp (x) ;

2.8 LES STRUCTURES DE CONTROLE


On appelle structure de contrôle toute action qui permet d’effectuer un groupe d’actions sous conditions.
Les structures de contrôle sous Matlab sont :
2.8.1 L’action conditionnelle ou alternative
Sa forme est :
if < condition >
< action >
end ;

Si la condition < condition > est vérifiée il faut exécuter l’action (ou le groupe d’actions) défini dans le bloc < action
>, puis les actions qui suivent le « end ; ». Si cette condition n’est pas vérifiée il faut sauter ce bloc pour exécuter les
actions qui suivent le « end ; ».
Il existe une autre forme de cette action conditionnelle :

if < condition >


< action 1 >
else
< action 2 >
end ; 8
Dans ce cas si la condition <condition > est vérifiée, l’action (ou le groupe d’actions) < action1 > est
exécutée puis les actions qui suivent le « end ». Par contre, si la condition n’est pas vérifiée, l’action (ou le
groupe d’actions) < action2 > est exécutée puis les actions qui suivent le « end ».
Une troisième forme composée est définie comme suit :
Exemple :
if < condition 1 >
if A < B < action 1 >
min = A ; elseif < condition 2 >
elseif B < C < action 2 >
min = B ; else
else < action 3 >
min = C ; end;
end ;
if C < min
min = C ;
end;
2.8.2 L’action « switch »

Lorsque le nombre d’alternatives est consistant, il sera peut être préférable d’utiliser l’action switch dont la
forme est : switch <expression>
case <val1>
<action 1>
case <val2>
<action 2>
...
otherwise
<action n>
end ;

Le bloc du premier case qui vérifie <expression>==<val i> sera exécuté pour ensuite sauter aux instructions
suivant le end. Si aucune des expressions <val i> n’est validée, on exécutera le bloc d’action de otherwise.
Exemple :
switch val
case -1
disp('un negatif');
case 0
disp('nul');
case 1
disp('un positif');
otherwise
disp('une autre valeur');
end

2.8.3 L’action répétitive « while »

while <condition >


< action >
end ;

Cette instruction spécifie qu’une action (ou un groupe d’actions) doit être répétée tant que la condition reste
vérifiée.

9
Remarque : L’action <action> étant répétée jusqu'à ce que la condition devienne fausse, il faut que celle-ci soit capable de
modifier les paramètres intervenant dans la condition afin de sortir de la boucle.
2.8.4 L’action répétitive « for »

for < comp > = < val_init > : [ <incr> :] < val_finale >
< action >
end ;
Cette action permet de répéter une action (ou un groupe d’actions) un nombre de fois déterminé par les
valeurs initiale et finale du paramètre < comp >, que l’on appelle compteur.
La partie action est exécutée la première fois en affectant au paramètre <comp > la valeur initiale
<val_init>. après chaque exécution on ajoute au compteur la valeur 1 ou celle de l’incrément lorsque celui-ci
est spécifié. L’action < action > est répétée jusqu'à ce que la valeur du compteur dépasse < val_finale > .

10
Chapitre 3
LES TABLEAUX

• Les types de données sont répartis en deux familles : les types simples et les types structurés.
• Les types structurés sont organisés à base de types simples. La ≠ à un instant donné ils possèdent plusieurs
valeurs.
3.1 DESCRIPTION
Un tableau est une structure homogène constituée d’un nombre fixe, appelé taille (par abus de langage le
terme dimension est aussi utilisé), de composants de même type, appelé type de base. Chaque composant du

tableau est directement accessible au moyen d’une variable indice.


Exemple : Soit le tableau Vect de dimension 7 suivant :
Vect = 5 2 4 8 2 3 6

Nous avons Vect(1) = 5 et Vect(4)=8 qui représentent le premier et le quatrième élément du tableau. Le type
de base de Vect étant Entier ces deux éléments sont manipulés comme toute autre variable entière.

3.2 MANIPULATION DE TABLEAUX UNIDIMENSIONNELS


En algorithmique, Une variable de type tableau est déclarée de la manière suivante :
Var < identif_tab > : Tableau (< taille>) < type_base> ;
Pour Matlab, on construit une instance d’un tableau en énumérant ses éléments séparés par des blancs (à
éviter) ou des virgules le tout entre crochets.
Exemple : Vect = [1 2 8 3] ; ou Vect = [1,2,8,3] ; donne le même résultat.
La taille d’un tableau est donnée par la fonction length.
Exemple : Pour l’exemple précédent, length(Vect) donne 4.
Si deux tableaux A=[a1,…,an] et B=[b1,…bn] ont même taille, les opérations d’addition et de soustraction
peuvent leur être appliquées et sont définies comme suit :
A+B=[a1+b1,…,an+bn] et A-B=[a1-b1,…,an-bn]
Matlab permet de définir des tableaux d’éléments à intervalle fixe en indiquant le premier élément,
l’incrément et la valeur finale ; le second étant facultatif si égal à un.
Exemple : >> impair = 1 : 2 : 12 définie impair=[1 3 5 7 9 11]. Le vecteur contenant les 10 premiers entiers
positifs s’obtient par Vect=1 : 10.
Les tableaux précédents sont des vecteurs ligne. Matlab permet de définir aussi des vecteurs colonnes en
les séparant par des points-virgules ‘;’ au lieu de virgules.
⎛ 11 ⎞
⎜ ⎟
⎜12 ⎟
Exemple : VectCol = [11 ; 12 ; 18 ; 13] ; définit le vecteur colonne ⎜ ⎟ .
18
⎜ ⎟
⎜13 ⎟
⎝ ⎠
On peut inverser un vecteur ligne en un vecteur colonne et vice-versa par transposition.
⎛1⎞
⎜ ⎟
⎜ 2⎟
Exemple : Si Vect = [1 2 8 3] alors VectTrans = Vect’ définit le vecteur colonne ⎜ ⎟ .
8
⎜ ⎟
⎜ 3⎟
⎝ ⎠

11
Un vecteur ligne et un vecteur colonne ayant le même nombre d’éléments peuvent être multipliés par
l’opérateur ‘*’ qui définit dans ce cas leur produit scalaire.
⎛1⎞
⎜ ⎟
⎜ 2⎟
Exemple : Si Vect = [1 2 8 3] et VectTrans = ⎜ ⎟ , alors Vect * VectTrans=(1x1)+(2x2)+(8x8)+(3x3) = 78.
8
⎜ ⎟
⎜ 3⎟
⎝ ⎠
Pour multiplier deux vecteurs de même taille élément par élément, on utilise l’opérateur « .* ».
Exemple : Si Vect1 = [1 2 8 3] et Vect2 = [9 3 1 5] alors leur produit élément-par-élément est donné par
Vect1 .* Vect2 = [1x9 2x3 8x1 3x5] = [9 6 8 15] (Vect1 * Vect2 conduira à une erreur qu’on expliquera après) .
3.3 TRI DE TABLEAUX
Le tri d’un tableau consiste à ordonner les éléments de celui-ci (dans un ordre croissant en général). Parmi
les méthodes, le tri à bulles consiste à déterminer le minimum des éléments, celui-ci est inséré ensuite en
première position. Puis le minimum du restant des éléments pour le mettre en deuxième position et ainsi
de suite jusqu’à ce que tout le tableau soit trié. L’algorithme de tri à bulles est le suivant :

Algorithme TriBulle ; Pour J := I+1 à N


Var Faire
N,I ,J: Integer ; Si Vect(j) < Vect(i) Alors
Vect : Tableau (50) Entier ; VI :=Vect(i) ;
Vect(i) :=Vect(j) ;
Début Vect(j) :=VI ;
{Lecture} Fsi ;
Lire(N) ; fait ;
Pour I := 1 à N fait ;
faire
Lire(Vect(i)) ; {Affichage}
fait ; Pour I := 1 a N
{Tri à Bulles} faire
Pour I := 1 à N-1 Ecrire(Vect(i)) ;
faire fait ;
Fin.

Exercice : Traduire l’algo TriBulle en MatLab.


3.4 TABLEAUX BIDIMENSIONNELS
Les tableaux bidimensionnels servent à représenter ce que les mathématiciens appellent Matrices. Pour ce
faire, on attribue à ce tableau un identificateur. Chaque élément est désigné par cet identificateur auquel on
associe deux indices : un indice pour les lignes et un autre pour les colonnes.
Exemple :
2 4 2 5 Mat est un tableau bidimensionnel et Mat(2,3) est l’élément situé à
Mat = 3 8 9 0 l’intersection de la deuxième ligne et troisième colonne. Donc
5 1 7 4 Mat(2,3)=9. On dit que Mat est d’ordre 3x4. (tailles et dimensions used too)

3.5 DECLARATION DES TABLEAUX BIDIMENSIONNELS


Ils sont déclarés en algorithmique sous la forme :
Var < identif_Mat > : Tableu (< nbr_ligne >, < nbr_col> ) < type_base> ;
Exemple : Var Mat : Tableau (3,4) Entier ;

12
Remarque : <nbr_ligne> et <nbr_col> doivent être des constantes.
Pour Matlab, une matrice peut être construite par l’énumération de ses éléments en séparant les vecteurs
lignes par des points-virgules.
⎛2 0 1⎞
⎜ ⎟
⎜5 4 1⎟
Exemple : >> Mat=[2 0 1 ; 5 4 1 ; 8 9 1 ; 5 1 0] construit la matrice Mat= ⎜ .
8 9 1⎟
⎜ ⎟
⎜5 1 0 ⎟⎠

La taille d’une matrice peut être obtenue par la fonction size().
Exemple : Pour le précédent exemple size(Mat) donne ans= 4 3.
On peut construire une matrice dont les valeurs sont toutes nulles, égales à un ou aléatoires uniformément
réparties sur l’intervalle [0,1] par les fonctions zeros(), ones() et rand() respectivement.
Exemples : MatZero = zeros(2,4) définit une matrice de zéros ayant 2 lignes et 4 colonnes. D’autre part
MatUn = ones(size(Mat)) définit une matrice de même taille que Mat. Enfin, rand(2,3) crée une matrice avec
des entrées aléatoires.
• Pour construire une matrice → Utiliser zeros ou ones puis remplir la matrice.
Exercice : Construire une matrice de nombres aléatoires uniformément répartis sur [4,7].
3.6 MANIPULATION DES MATRICES
L’addition et la soustraction peuvent être appliquées à des matrices de même taille.
⎛1 2 0⎞ ⎛ 2 0 4⎞ ⎛3 2 4⎞ ⎛ − 1 2 − 4⎞
Exemple : Si A= ⎜⎜ ⎟⎟ et B= ⎜⎜ ⎟⎟ alors A+B= ⎜⎜ ⎟⎟ et A-B= ⎜⎜ ⎟.
⎝ 0 3 1 ⎠ ⎝ 1 3 0 ⎠ ⎝ 1 6 1 ⎠ ⎝−1 0 1 ⎟⎠
La multiplication de deux matrices est définie si le nombre de colonnes de la première équivaut au nombre
de ligne de la deuxième. Un element d’indices (i,j) de la matrice résultat est égal au produit scalaire de la
i-ième ligne de la première par la j-ième colonne de la deuxième.
⎛2 7⎞
Exemple : A*B’= ⎜⎜ ⎟⎟ .
⎝4 9⎠
Deux matrices peuvent être concaténées en largeur si elles ont même nombre de ligne ou en longueur si
elles ont même nombre de colonnes.
⎛1 2 0⎞
⎜ ⎟
⎛1 2 0 2 0 4⎞ ⎜0 3 1⎟
Exemple : C=[A,B] crée la matrice ⎜⎜ ⎟⎟ , tandis que D=[A ;B] crée la matrice ⎜ .
⎝ 0 3 1 1 3 0 ⎠ 2 0 4⎟
⎜ ⎟
⎜1 0 ⎟⎠
⎝ 3
Une sous-matrice peut être extraite d’une autre.
⎛ 0 3⎞
Exemple : E=D(2:3,1:2) crée la matrice ⎜⎜ ⎟⎟ . VectLigne=D(4, :) crée le vecteur (1 3 0) et VectCol=D(:,2) crée
⎝ 2 0⎠
⎛ 2⎞
⎜ ⎟
⎜ 3⎟
le vecteur ⎜ ⎟ .
0
⎜ ⎟
⎜ 3⎟
⎝ ⎠
Exercice : En supposant la non existence des opérations de multiplication, de concaténation et d’extraction
matricielles, écrire les programmes Matlab qui permettent de les réaliser.

13
Chapitre 4
L’ACTION PARAMETREE

• Principe Æ décomposer un problème en sous problèmes afin d’en rendre la résolution facile.
• L’analyse de chacun des sous-problèmes de façon indépendante permet de réduire la complexité du problème
global.
• A chaque sous problème nous déterminons un algorithme de résolution que nous appelons action paramétrée.

4.1 DEFINITION
Une action paramétrée est une structuration d'une ou de plusieurs actions en une seule en lui associant un
identificateur qui permet de la référencer en tout point de l’algorithme.
La syntaxe de l’action paramétrée est :
Action <NomAction> [(<ListParam>)] ;
<Partie Déclaration>
Début
<Partie action>
Fin ;

• Remarquer la ressemblance avec celle d'un algorithme. Seul différence l'entête.


<NomAction> correspond au nom qu’on donne à l’action paramétrée pour qu’on puisse l'appeler
(l'exécuter). <ListParam> représente l’ensemble des paramètres servant de relais entre l’action paramétrée
et l’extérieur en précisant le mode de transmission.
Exemples :
1.
Action Additionner (E / X,Y : Entier ; S / Som : Entier) ;
Début
Som := X + Y ;
Fin ;
Algorithme Addition ;{algorithme principal}
Var
A,B,somme : Entier ;
Début
Lire(A,B) ;
Additionner(A,B,somme) ;{appel de l’action paramétrée Addition}
Ecrire(somme) ;
Fin.
2.
Action Addit (E / N : Entier ; S / Som : Entier) ;
Var
I : Entier ;
Début
Som :=0 ;
Pour i := 1 à N
Faire
Som := Som + i ;
Fait ;
Fin ;
Algorithme Addition ;{algorithme principal}
Var
N,somme : Entier ;
Début
Lire(n) ;
14
Addit(n,somme) ;{appel de l’action paramétrée Addit}
Ecrire(somme) ;
Fin.

Remarques :
1. L’action paramétrée doit être définie avant l’algorithme ou le sous-algorithme qui l’appelle.
2. Le découpage d’un algorithme en actions paramétrées permet :
• D’abréger l’écriture de l’algorithme puisque la séquence d’instructions utilisées en plusieurs endroits n’est
écrite qu’une seule fois.
• Une approche plus synthétique des problèmes complexes et une économie en temps d’analyse.
3. L’utilisation de l’action paramétrée en un point de l’algorithme se fait par appel de celle-ci. L’algorithme appelant
peut être soit l’algorithme principal, soit une autre action paramétrée.

4.2 OBJETS MANIPULES PAR UNE ACTION PARAMETREE


L’action paramétrée peut agir sur un ensemble d’objets qui sont :
• les paramètres.
• les objets déclarés dans l’action paramétrée dits objets locaux.

• les objets déclarés dans l’algorithme appelant dits objets globaux. (cette partition n’est pas exclusive)
4.2.1 Les paramètres
Les paramètres sont le relais usuel entre l’algorithme appelant et l’action paramétrée. Ceux introduits dans
l’entête par <listParam> de l’action paramétrée sont appelés paramètres formels ou fictifs.
L’utilisation de l’action paramétrée dans un appel se fait par le biais de paramètres substitués aux
paramètres formels. Ceux-ci sont dits paramètres effectifs ou réels.
Exemple : Dans l’exemple précédant x, y et som sont les paramètre formels ou fictifs ; alors que A,B et
somme sont des paramètres effectifs ou réels.
La déclaration des paramètres fictifs doit porter la spécification du mode de transmission que nous
supposons avoir trois valeurs possibles.
4.2.2 Mode de transmission
Pour le mode Entrée et lors de l’appel, la valeur du paramètre effectif est copiée dans le paramètre fictif
correspondant. Et lors du retour le paramètre effectif de l’algorithme appelant n’est pas modifié. Dans
l’entête de l’action paramétrée un tel paramètre est précédé par E/.
• Les variables transmises par ce mode servent à communiquer les données nécessaires à l’accomplissement de la
tache de l’action paramétrée.

Le mode Sortie est l’inverse du mode Entrée. Lors de l’appel le paramètre fictif ne reçoit pas de valeur
initiale. Par contre lors du retour la valeur de celui-ci est recopiée sur le paramètre effectif. Dans l’entête de
déclaration de l’action paramétrée un tel paramètre est précédé par S/.
• Les variables transmises par ce mode servent à communiquer à l’algorithme appelant les résultats fournis par
l’action paramétrée.

Enfin, dans le mode mixe ou entrée sortie, la valeur du paramètre fictif est initialisée lors de l’appel par
celle du paramètre effectif et lors du retour la valeur du paramètre fictif est recopiée sur le paramètre
effectif.

15
4.2.3 Visibilité d’un objet
A
Les objets déclarés dans une action paramétrée sont dits locaux à la mesure où ceux
ci ne sont pas reconnus dans l’algorithme appelant. D’autre part les objets déclarés
dans l’algorithme appelant sont dits globaux car ils sont reconnus dans celui-ci et SA1

dans l’action paramétrée appelée (ceci n’est pas le cas pour Matlab). Cependant,
cette notion est relative : en effet, dans l’exemple ci-contre où un algorithme A fait SA2
appel à une action paramétrée SA1 (sous-algorithme1) qui à son tour fait appel à
une deuxième action paramétrée SA2, les objets déclarés dans SA1 sont locaux par
rapport à A, mais par rapport à SA2 ils sont globaux.
De ce fait on parle de visibilité (ou de portée) d’un objet qui est la spécification de l’ensemble des
algorithmes dans lesquels il est reconnu.
Objets déclarés dans Portée
A A, SA1, SA2
SA1 SA1, SA2
SA2 SA2
• Globalité absolue (objets de A) et localité absolue (ceux de SA2) .
• Eviter la modification des variables globales qui ne sont pas des paramètres localement.

4.3 LES ACTIONS PARAMETREES SOUS MATLAB


Sous Matlab une action paramétrée est dite fonction et possède la forme suivante :

Function <ListParamOut> =<NomFonct> (<ListParamIn>)


<Partie action>
<NomFonct> est le nom donné à l’AP pour l’appeler. <ListParamIn> spécifie les paramètres en mode entrée
et <ListParamOut> spécifie les paramètres en mode sortie.
Pour pouvoir utiliser une fonction en Matlab, il faut la sauvegarder dans un fichier ayant le même nom.
Exemple 1:
On crée le script suivant
A=input(‘ Donner un nombre ’) ;
B=input(‘ Donner un autre nombre ’) ;
Somme = Additionner(A,B) ;
disp(Somme) ;
Ensuite, on crée la fonction Additionner comme suit
function Som=Additionner(X,Y)
Som = X+Y ;
Cette fonction doit être sauvegardée dans un fichier appelé ‘Additionner.m’.
Exemple 2:
La fonction stat reçoit un vecteur x et renvoie sa moyenne et son écart-type.
function [mean,stdev] = stat(x)
n = length(x);
mean = sum(x)/n;
stdev = sqrt(sum(((x-mean).^2)/n));
On récupère le résultat dans un script qui a la forme
16
[moy,ecartyp] = stat(x) ;

4.4 VISIBILITE DANS MATLAB


Pour Matlab les variables sont locales par défaut. Chaque fonction possède ses propres variables qui sont
détruites entre les exécutions de celle-ci. Les scripts par contre utilisent l’espace propre du programme
appelant. Par conséquent, si un script est appelé par la ligne de commande, il partage l’espace de travail de
base et s’il est appelé par une fonction, il utilise l’espace propre à cette fonction.
Exemple : On définit le script tmpscript.m x=x+1 et la fonction function fct x=100 ; tmpscript ; ensuite on
exécute clear ; x=10 ; tmpscript dans la ligne de commande. On aura x=11. Si ensuite on appelle fct, on aura
x=101. Une exécution de tmpscript par la suite donnera x=12.
Si on veut qu’un ensemble de fonctions partage avec la ligne de commande la même variable, il faut la
déclarer global dans tous les modules.
Exemple : Pour l’exemple précédent, on doit déclarer x globale par la commande global x ; dans la ligne de
commande et modifier la fonction fct comme suit : function fct global x ; x=100 ; tmpscript ; En exécutant
les mêmes commandes (clear ; global x ; x=10 ; tmpscript ; fonction ; tmpscript), on aura x=102 au lieu de 12.
• It is usually best to put global declarations toward the beginning of the function.
• Eviter d’utiliser les variables globales (2 fonction utilisant 2 var globale de même nom ou en cas de changement de
nom) mais si vous y êtes tentés : use long identif. en MAJUSCULES.

Pour voir les variables qui ont été déclarées globales, on peut utiliser les commandes who ou whos avec le
terme global.
Exemple : Pour le cas précédent en tapant who global on obtient : Your variables are: x.
4.5 FONCTIONS MATLAB UTILES
Matlab dispose d’une grande bibliothèque de fonctions prédéfinies. Parmi celles-ci :
1. sum : calcule la somme d’éléments.
S = sum(X) est la somme des éléments du vecteur X. Si X est une matrice, S est un vecteur ligne contenant la
somme de chaque colonne.
Exemple : Si X = [0,1,2; 3,4,5] alors sum(X) donne [3 5 7].
2. prod : calcule le produit d’elements.
Pour des vecteurs, prod(X) est le produit des elements de X. Pour des matrices, prod(X) est un vecteur ligne
du produit de chaque colonne.
Exemple : Si X = [0,1,2 ; 3,4,5] alors prod(X) est [0 4 10].
4. sort : trie des éléments.
Pour des vecteurs, sort(X) trie les éléments de X dans un ordre croissant. Pour des matrices, sort(X) trie
chaque colonne de X dans un ordre croissant.
Exemple : If X = [3,7,5;0,4,2] alors sort(X) est [0,4,2 ;3,7,5].
5. mean : calcule la valeur moyenne d’éléments.
Pour des vecteurs, mean(X) est la moyenne des elements de X. Pour des matrices, mean(X) est le vecteur
ligne contenant la moyenne de chaque colonne.

17
Exemple : Si X = [0,1,2; 3,4,5] alors mean(X) est [1.5,2.5,3.5].
6,7 tic, toc : tic démarre un chronomètre et toc détermine le temps écoulé depuis que tic a été utilisée.
La séquence de commandes : TIC ; <action> ; TOC affiche le nombre de secondes nécessaires pour exécuter
le bloc <action>.
10000

Exemple : Si on exécute le code suivant : 9000

tic; 8000

j=1; 7000

for i=-100:100 6000

y(j)=i*i; 5000
j=j+1;
4000
end;
x=-100:100; 3000

plot(x,y); 2000

toc 1000

On peut obtenir dans la ligne de commande : « Elapsed time is 0


-100 -80 -60 -40 -20 0 20 40 60 80 100

0.547000 seconds. »
Exercice : peut on écrire un programme équivalent au code précédent sans boucles.

8. plot : trace des courbes en deux dimensions. 1

0.8

Exemple : le code suivant trace la courbe sinus entre -pi et pi : 0.6

x = -pi:.1:pi; 0.4

y = sin(x); 0.2

plot(x,y)
0

-0.2

-0.4

-0.6

-0.8

-1
-4 -3 -2 -1 0 1 2 3 4

18
Chapitre 5

NOTIONS MATLAB AVANCEES


5.1 DEBOGUEUR
5.2 GUI

19

Vous aimerez peut-être aussi