Cours Informatique 3 (Matlab)

Cours du Module AP-45 pour l’Année Préparatoire II
–Cours d’Informatique 3–
Prise en main du logiciel Matlab
Mohamed ADDAM
Professeur de Mathématiques
École Nationale des Sciences Appliquées d’Al Hoceima

–ENSAH–
Année Universitaire 2023/2024
addam.mohamed@gmail.com
m.addam@uae.ac.ma
c Mohamed ADDAM.
16 février 2024
2
Table des matières
1 Pour débuter 5
1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2 Opérateurs de bases où Opérations élémentaires sous MATLAB . . . . . . . . . . . . . . 7
1.3 Définitions de scalaires et variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4 Définitions de vecteurs et de matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.5 Création de matrices particulières . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.6 Effacement et liste des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.7 Fonctions sur les scalaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.8 Fonctions sur les matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.9 Opérations élément par élément . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.10 Constantes prédéfinies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.11 Le typage de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.12 Fonctions prédéfinies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2 Matrices et tableaux 15
2.1 Définition d’un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2 Accès à un élément d’un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.3 Extraction de sous-tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.4 Construction de tableaux par blocs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.5 Opérations sur les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.5.1 Addition et soustraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.5.2 Multiplication, division et puissance terme à terme . . . . . . . . . . . . . . . . . 19
2.5.3 Multiplication, division et puissance au sens matriciel . . . . . . . . . . . . . . . 21
2.5.4 Listes de valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.6 Longueurs de tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3 Fichiers SCRIPT et FUNCTION 23

3.1 Fichiers SCRIPT et FUNCTION . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.1.1 Fichiers SCRIPT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.1.2 Fichiers FUNCTION . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3
4 TABLE DES MATIÈRES
4 Les entrées-sorties 27
4.1 Les formats d’affichage des réels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.2 Affichage simple, la commande disp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.3 Lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.4 Impressions dirigées par format . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5 Graphisme 33
5.1 Gestion des fenêtres graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.2 Graphisme 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.2.1 Tracer le graphe d’une fonction ; la commande fplot . . . . . . . . . . . . . . . . 33
5.2.2 La commande plot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.2.3 La commande loglog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.3 Améliorer la lisibilité d’une figure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.3.1 Légender une figure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.3.2 Afficher plusieurs courbes dans une même fenêtre . . . . . . . . . . . . . . . . . 38
5.3.3 Sauvegarder une figure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.4 Graphisme 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.4.1 Tracer les lignes de niveau d’une fonction de 2 variables . . . . . . . . . . . . . . 40
5.4.2 Représenter une surface d’équation z = g(x, y) . . . . . . . . . . . . . . . . . . . 42
5.4.3 Représenter une surface paramétrée . . . . . . . . . . . . . . . . . . . . . . . . . 44
6 Programmation avec MATLAB 47

6.1 Opérateurs logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
6.2 Boucles if-elseif-else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
6.3 Boucles for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
6.4 Boucles while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
6.5 Boucles switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
6.6 Entrées / sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.6.1 Utilisateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.6.2 Disques : Importer et exporter des données . . . . . . . . . . . . . . . . . . . . . 54
Chapitre 1
Pour débuter
1.1 Introduction
MATLAB (MATrix LABoratory) comprend de nombreuses fonctions graphiques, un système puissant
d’opérateurs s’appliquant à des matrices, des algorithmes numériques (EDOs, zeros d’une fonction, inté-
gration, interpolation), ainsi qu’un langage de programmation extrêmement simple à utiliser.
Il fut conçu initialement (vers 1984-1985) pour manipuler aisément des matrices à l’aide de fonctions
pré-programmées (addition, multiplication, inversion, décompositions, déterminants ...), en s’affranchissant
des contraintes des langages de proprammation classique :
– Plus de déclarations de variables.
– Plus de phase d’édition-compilation-exécution.
Cette orientation calcul matriciel a depuis évolué vers un outil pouvant être vu comme une super-calculatrice
graphique et regroupant dans la version de base la quasi-majorité des problèmes numériques (hormis les
EDP qui sont aussi diversifiées que délicates à résoudre). Plusieurs extensions plus «pointues» ont été
con¸cues sous la forme de «TOOLBOXes», qui sont des paquets (payants) de fonctions supplémentaires
dédiées à un domaine particulier :
– CONTROL pour l’automatique,
– SIGNAL pour le traitement du signal,
– OPTIMIZATION pour l’optimisation,
– NEURAL NETWORK pour les réseaux de neurones.
Cet aspect modulaire est l’un des plus grands atouts de MATLAB : l’utilisateur peut lui-même définir
ses propres fonctions, en regroupant des instructions MATLAB dans un fichier portant le suffixe ”.m”.
La syntaxe est bien plus abordable que dans les langages classiques et devrait éliminer les r´eticences
habituelles des programmeurs débutants pour écrire des fonctions.
En termes de vitesse d’exécution, les performances sont inférieures à celles obtenues avec un langage
de programmation classique. L’emploi de MATLAB devrait donc être restreinte à des problèmes peu gour-
mands en temps calcul, mais dans la plupart des cas, il présente une solution élégante et rapide à mettre en
oeuvre.
Notons enfin que MATLAB est disponible sur tous types de plates-formes (toutes les stations sous UNIX
y compris LINUX, Windows7, Windows10 et Macintosh).
MATLAB est beaucoup plus qu’un langage de programmation. Il s’agit d’une console d’exécution
(shell) au même titre que les consoles DOS ou UNIX. Comme toutes les consoles, MATLAB permet d’exé-
cuter des fonctions, d’attribuer des valeurs à des variables, etc. Plus spécifiquement, la console MATLAB
permet d’exéctuer des opérations mathématiques, de manipuler des matrices, de tracer facilement des gra-
phiques. La figure 1 présente l’écran MATLAB de base.
5
6 CHAPITRE 1. POUR DÉBUTER
F IGURE 1.1 – Cette figure montre l’interface du Logiciel Matlab

1.2. OPÉRATEURS DE BASES OÙ OPÉRATIONS ÉLÉMENTAIRES SOUS MATLAB 7
1.2 Opérateurs de bases où Opérations élémentaires sous MATLAB

Les opérateurs ci-dessous sont valables pour les scalaires comme pour les matrices. Matlab effectuera
la bonne opération en fonction du type des termes de l’opérateur. L’élément le plus important ici est l’in-
vite MATLAB où l’utilisateur peut affecter des valeurs à des variables et effectuer des opérations sur ces
variables.
>> x = 4
x =
4
>> y = 2
y =
2
>> x + y
ans =
6
>> x ∗ y
ans =
8
>>
Ici, il faut noter que lorsque l’utilisateur ne fixe pas de variable de sortie, MATLAB place le résultat d’une
opération dans ans. Il est toujours possible de connaître les variables utilisées et leur type à l’aide de la
fonction whos. Par exemple, pour les manipulations précédentes :
>> whos
Name Size Bytes Class
ans 1 x1 8 double array
x 1 x1 8 double array
y 1 x1 8 double array
>>
Grand t o t a l i s 3 e l e m e n t s u s i n g 24 b y t e s
La fonction whos affiche le nom de variables Name, la taille de variables Size, le nombre de bits Bytes et
le genre de variables Class.
La solution de x + y a donc été perdue. Il est donc préférable de toujours donner des noms aux variables
de sortie :
>> x = 4;
>> y = 2;
>> a = x + y
a =
6
>> b = x ∗ y
b =
8
>> whos
a 1 x1 8 double array
b 1 x1 8 double array
>>
Grand t o t a l i s 4 e l e m e n t s u s i n g 32 bytes
Notons au passage que le point-virgule permet de ne pas afficher la valeur à l’écran, ce qui permettra éven-
tuellement des programmes plus rapides. La fonction clear permet d’effacer des variables. Par exemple :
>> c l e a r x % on e f f a c e x de l a mémoire
>> whos
>>
Le signe de pourcentage (%) permet de mettre ce qui suit sur une ligne en commentaire (MATLAB n’en
tiendra pas compte à l’éxécution).
Les opérateurs ci-dessous sont valables pour les scalaires comme pour les matrices. Matlab effectuera la
bonne opération en fonction du type des termes de l’opérateur.
%−−−−−−−−D é f i n i t i o n s d ’ O p é r a t e u r s de b a s e s −−−−−−−−−−−−−−−−−− %
’ % Transposition ( matrice )
+ % Addition
− % Soustraction
∗ % Multiplication
/ % Division à droite
\ % D i v i s i o n à gauche
^ % Puissance
1.3 Définitions de scalaires et variables

La définition d’éléments est assez intuitive. Il est cependant toujours recommandé d’utiliser des conven-
tions pour la nomenclature des variables. Par exemple, que tous les noms des scalaires commencent par
une minuscule et tous les noms des matrices par une majuscule, etc.
De plus, il est vivement conseillé de choisir des noms de variables explicites sans pour autant les rendre
trop long (exemple : MatriceDeDilatation, nombre d’itaration, ...)
Remarque 1.3.1 Il très important de prendre en considération que

– Matlab est sensible à la case des variables.
– Un nom de variable doit commencer par une lettre. Il peut ensuite contenir des chiffres et d’autres
symboles.
Un dernier point sur les variables :

1.4. DÉFINITIONS DE VECTEURS ET DE MATRICES 9
F IGURE 1.2 – Définitions de scalaires
– MATLAB fait la différence entre les minuscules et les majuscules.

– Les noms de variables peuvent avoir une longueur quelconque.
– Les noms de variables doivent commencer par une lettre.
Variables prédéfinies : les variables prédéfinies sont des mots composés d’une lettre ou plusieurs lettres
que lorsqu’on l’écrit sur la console MATLAB, alors elle nous affiche une explication scalaire à cette variable
prédéfinie précédée par ans. Il existe un certain nombre de variables pré-existantes.
√ Nous avons déjà vu ans
qui contient le dernier résultat de calcul, ainsi que i et j qui représentent −1.
Il existe aussi pi, qui représente π, et quelques autres. Retenez que eps, nom que l’on a souvent tendance
à utiliser est une variable prédéfinie.
>> j
ans =
0.0000 + 1.0000 i
>> p i
ans =
3.1416
>> e p s
ans =
2 . 2 2 0 4 e −16
ATTENTION : ces variables ne sont pas protégées, donc si vous les affectez, elles ne gardent pas leur
valeur. C’est souvent le problème pour i et j que l’on utilise souvent spontanément comme indices de
boucles, de telle sorte qu’on ne peut plus ensuite définir de complexe ! !
1.4 Définitions de vecteurs et de matrices

Pour définir un vecteur ligne sous Matlab, il suffit de mettre ses valeurs entre crochets et de les séparer
par un espace. Pour obtenir un vecteur colonne, il suffit de le transposer
√ via l’ajout d’un apostrophe après
le crochet fermant. On peut aussi faire des calculs en complexe. −1 s’écrit indifféremment i ou j, donc
pour définir un complexe :
>> a+ b ∗ i
ans =
1.2000 + 8.4000 i
Le symbole ∗ peut être mis si la partie imaginaire est une constante numérique. Tous les opérateurs précé-
dents fonctionnent en complexe.
%−−−−−−−−−−− D é f i n i t i o n s de v e c t e u r s e t m a t r i c e s −−−−−−−−−−−−%
V e c t e u r _ L i g n e =[1 2 3 4 5 ] ; % Vecteur li gn e
V e c t e u r _ C o l o n n e =[1 2 3 4 5 ] ’ ; % V e c t e u r c o l o n n e
Vecteur_Colonne = [ 1 ; 2 ; 3 ; 4 ; 5 ] ; % Vecteur colonne
m a t r i c e =[1 2 3 ; % Ligne 1
4 5 6]; % Ligne 2
%−−−−−−−−−−− D é f i n i t i o n de m a t r i c e s co m p l ex es −−−−−−−−−−−−%
Z=[1 2 ; 3 4 ] + i ∗ [ 5 6 ; 7 8 ]
1.5 Création de matrices particulières
Matlab permet de créer de manière automatique simplifiée des matrices spéciales comme, par exemple,
des matrices remplies de 1 ou de 0, etc. (m et n sont les dimensions de la matrice souhaitée et A est une
matrice)
%−−−−−−−−−−−−−− D é f i n i t i o n s de m a t r i c e s s p é c i a l e s −−−−−−−−−−−−−−−%
ey e (m, n ) % Matrice unité
o n e s (m, n ) % M a t r i c e d o n t t o u s l e s é l é m e n t s s o n t ég au x à un
z e r o s (m, n ) % M a t r i c e d o n t t o u s l e s é l é m e n t s s o n t ég au x à z é r o
r a n d (m, n ) % Matrice d ’ éléments a l é a t o i r e s
d i a g (m, n ) % Matrice diagonale
m e s h g r i d (m : n , k : l ) % R e n v o i e deux m a t r i c e s de g r i l l e s d é f i n i s s a n t
un q u a d r i l l a g e
1.6 Effacement et liste des variables
La commande clear permet d’effacer une partie ou toutes les variables définies jusqu’à présent. Il est
conseillé de placer cette commande au début de vos fichiers de commandes, en particulier lorsque vous
manipulez des tableaux. Syntaxe :
clear var1 var2 var3 . . .
Si aucune variable n’est spécifiée, toutes les variables seront effacées.
La commande who affiche les noms de toutes les variables en cours.
1.7 Fonctions sur les scalaires
Voici une liste non-exhaustive des fonctions de bases sur les nombres scalaire. (Dans l’exemple : z
représente un nombre complexe).
1.8. FONCTIONS SUR LES MATRICES 11
%−−−−−−−−−F o n c t i o n s s u r l e s s c a l a i r e s −−−−−−−−−−−−−%
abs ( z ) % V a l e u r a b s o l u e ou module co m p l ex e
conj ( z ) % Complexe c o n j u g u é
imag ( z ) % Partie imaginaire
real (z) % Partie réelle
norm ( z ) % Norme
prod ( z ) % P r o d u i t de t o u s l e s é l é m e n t s d ’ un a r g u m e n t v e c t o r i e l
sum ( z ) % Somme de t o u s l e s é l é m e n t s d ’ un a r g u m e n t v e c t o r i e l
round ( z ) % A r r o n d i t t o u s l e s é l é m e n t s aux e n t i e r s l e s p l u s p r o c h e s
1.8 Fonctions sur les matrices
Voici une liste non-exhaustive des fonctions de bases sur les vecteurs et matrices. (Dans l’exemple : V
et A représentent des vecteurs ou des matrices).
%−−−−−−−F o n c t i o n s s u r l e s m a t r i c e s −−−−−−−−−−%
cumsum (V) % Somme cu m u l ée
cumprod (V) % P r o d u i t cumulé
sum (V) % Soustraction
p r o d (V) % Multiplication
t r i l (A) % E x t r a c t i o n de l a p a r t i e t r i a n g u l a i r e i n f é r i e u r e d ’ une m a t r i c e
t r i u (A) % E x t r a c t i o n de l a p a r t i e t r i a n g u l a i r e s u p é r i e u r e d ’ une m a t r i c e
s o r t (A) % Trie la matrice
f l i p l r (A) % R e t o u r n e l a m a t r i c e h o r i z o n t a l e m e n t
f l i p u d (A) % R e t o u r n e l a m a t r i c e v e r t i c a l e m e n t
r a n k (A) % Rang de l a m a t r i c e
t r a c e (A) % Somme d e s é l é m e n t s d i a g o n a u x
1.9 Opérations élément par élément
Ajouter un point devant un des opérateurs classiques signifie que l’on effectue l’opération élément par
élément. ( Exemple A, B, C étant des matrice, C = A. + B équivalent
C(i, j) = A(i, j) + B(i, j)).
%−−−−−−−−−−−O p é r a t i o n s é l é m e n t p a r é l é m e n t −−−−−−−−−−−%
.+ % Addition
.− % Soustraction
.∗ % Multiplication
./ % Division
.^ % Puissance
1.10 Constantes prédéfinies
Matlab dispose de constantes prédéfinies. En voici la liste :

%−−−−−−−−−−−C o n s t a n t e s p r é d é f i n i e s −−−−−−−−−−−%
eps % F l o a t i n g −p o i n t r e l a t i v e a c c u r a c y
j % Imaginary u ni t
Inf % Infinity
intmax % Largest value of s p e c i f i e d i n t e g e r type
intmin % Smallest value of s p e c i f i e d i n t e g e r type
j % Imaginary u ni t
NaN % Not−a−Number
pi % Ratio of c i r c l e ’ s circumference to i t s diameter
realmax % L a r g e s t p o s i t i v e f l o a t i n g −p o i n t number
realmin % S m a l l e s t p o s i t i v e n o r m a l i z e d f l o a t i n g −p o i n t number
1.11 Le typage de données
Matlab effectue ce que l’on appel du typage dynamique, autrement dit il adapte le type des opérateurs de
manière à permettre aux opérations de s’effectuer. Cette pratique à des avantages comme des inconvénients
d’un coté cela évite au programmeur de devoir définir à l’avance le type de chaque variable et d’être coincé
tout au long de l’exécution par ce type. D’un autre coté, lorsque le typage est dynamique, Matlab effectue
des conversions de type implicites sans le signaler, ce qui peut augmenter le temps d’exécution et parfois
mener à des résultats surprenant.
Il est cependant possible de forcer Matlab à faire des conversions explicites.
Fonctions de conversion :
%−−−−−−−−−−−F o n c t i o n s de c o n v e r s i o n −−−−−−−−−−−%
cast % Cast v a r i a b l e to d i f f é r e n t d at a type
double % Convert to double p r e c i s i o n
int8 , int16 , int32 , int64 % Convert to signed i n t e g e r
single % Convert to s i n g l e p r e c i s i o n
typecast % Convert d at a t y p es without
changing underlying data
uint8 , uint16 , uint32 , u i n t 6 4 % Convert to unsigned i n t e g e r
%−−−−−−−F o n c t i o n s de c o n v e r s i o n s t r i n g v e r s nombre−−−−−−−−−−−%
base2dec % C o n v e r t b a s e N number s t r i n g t o d e c i m a l number
bin2dec % C o n v e r t b i n a r y number s t r i n g t o d e c i m a l number
cast % Cast v a r i a b l e to d i f f é r e n t d at a type
hex2dec % C o n v e r t h e x a d e c i m a l number s t r i n g t o d e c i m a l number
hex2num % C o n v e r t h e x a d e c i m a l number s t r i n g t o
d o u b l e −p r e c i s i o n number
str2double % C o n v e r t s t r i n g t o d o u b l e −p r e c i s i o n v a l u e
str2num % C o n v e r t s t r i n g t o number
u n i c o d e 2 n a t i v e % C o n v e r t U n i co d e c h a r a c t e r s t o n u m e r i c b y t e s
1.12. FONCTIONS PRÉDÉFINIES 13
1.12 Fonctions prédéfinies

Toutes les fonctions courantes et moins courantes existent. La plupart d’entre elles fonctionnent en
complexe. On retiendra que pour appliquer une fonction à une valeur, il faut mettre cette dernière entre
parenthèses. Exemple :
>> r = s i n ( p i / 1 2 )
r =
0.16589613269342
Voici une liste non exhaustive :

– fonctions trigonométriques et inverses : sin, cos, tan, asin, acos, atan
– fonctions hyperboliques (on rajoute ”h”) : sinh, cosh, tanh, asinh, acosh, atanh
– racine, logarithmes et exponentielles : sqrt, log, log10, exp
– fonctions erreur : erf, erfc
– fonctions de Bessel et Hankel : besselj, bessely, besseli, besselk, besselh. Il faut deux paramètres :
l’ordre de la fonction et l’argument lui-même. Ainsi J1 (3) s’écrira besselj(1,3)
La notion de fonction est plus générale dans MATLAB, et certaines fonctions peuvent avoir plusieurs en-
trées (comme besselj par exemple) mais aussi plusieurs sorties.
Chapitre 2
Matrices et tableaux
Dans cette section, on verra les fonctionnalités de MATLAB pour décrire les matrices et tableaux. En
effet, MATLAB ne fait pas de différence entre les deux. Le concept de tableau est important car il est à la
base du graphique : typiquement pour une courbe de n points, on définira un tableau de n abscisses et un
tableau de n ordonnées. Mais on peut aussi définir des tableaux rectangulaires à deux indices pour définir
des matrices au sens mathématique du terme, puis effectuer des opérations sur ces matrices.
2.1 Définition d’un tableau

On utilise les crochets
 [ et ] pour définir
 le début et la fin de la matrice. Ainsi pour définir une variable
1 2 3
M contenant la matrice  11 12 13 , on écrira (Le choix de prendre des variables majuscules pour
21 22 23
les matrices est personnel et n’est nullement imposé par MATLAB)
>> M=[1 2 3
11 12 13
21 22 2 3 ]
M=
1 2 3
11 12 13
21 22 23
Le passage d’une ligne de commande à la suivante s’effectuant par la frappe de la touche «Entrée».
On peut également utiliser le symbole , qui sert de séparateur de colonne et ; de séparateur de ligne.
Ainsi pour définir la matrice précédente on aurait pu taper :
>> M= [ 1 , 2 , 3 ; 1 1 , 1 2 , 1 3 ; 2 1 , 2 2 , 2 3 ]
M=
1 2 3
11 12 13
21 22 23
où bien, en remplaçant la virgule par des blancs :

15
16 CHAPITRE 2. MATRICES ET TABLEAUX
>> M=[1 2 3 ; 1 1 12 1 3 ; 2 1 22 2 3 ]
M=
1 2 3
11 12 13
21 22 23
Remarque 2.1.1 On peut utiliser la notion de décrire une matrice pour décrire un vecteur puisque un
vecteur est aussi une matrice :
– Un vecteur ligne est une matrice à une seule ligne et plusieurs colonnes.
– Un vecteur colonne est une matrice à plusieurs lignes et une seule colonne.
2.2 Accès à un élément d’un tableau
Il suffit d’entre le nom du tableau suivi entre parenthèses du ou des indices dont on veut lire ou écrire la
valeur. Exemple si je veux la valeur de M32 :
>>M( 3 , 2 )
ans=
22
Pour modifier seulement un élément d’un tableau, on utilise le même principe. Par exemple, je veux que
M32 soit égal à 32 au lieu de 22 :
>> M( 3 , 2 ) = 3 2
M=
1 2 3
11 12 13
21 32 23
Vous remarquerez que MATLAB réaffiche du coup toute la matrice, en prenant en compte la modifica-
tion. On peut de demander se qui se passe si on affecte la composante d’une matrice qui n’existe pas encore.
Exemple :
>> P ( 2 , 3 ) = 3
P=
0 0 0
0 0 3
Voilà la réponse : MATLAB construit automatiquement un tableau suffisamment grand pour arriver jus-
qu’aux indices spécifiés, et met des zéros partout sauf au terme considéré. Vous remarquerez que contraire-
ment aux langages classiques, inutile de dimensionner les tableaux à l’avance : ils se construisent au fur et
à mesure !
2.3. EXTRACTION DE SOUS-TABLEAUX 17
2.3 Extraction de sous-tableaux

Il est souvent utile d’extraire des blocs d’un tableau existant. Pour cela on utilise le caractère :. Il faut
spécifier pour chaque indice la valeur de début et la valeur de fin. La syntaxe générale est donc la suivante
(pour un tableau à deux indices) :
tableau ( début : fin , début : f i n )

2 3
Ainsi pour extraire le bloc on tapera :
12 13
>> M( 1 : 2 , 2 : 3 )
ans=
2 3
12 13
Si on utilise le caractère : seul, ¸ca veut dire prendre tous les indices possibles. Exemple :
>> M( 1 : 2 , : )
ans=
1 2 3
11 12 13
C’est bien pratique pour extraire des lignes ou des colonnes d’une matrice. Par exemple, pour obtenir la
deuxième ligne de M :
>> M( 2 , : )
ans=
11 12 13
Le double point ( :) est l’opérateur d’incrémentation dans MATLAB. Ainsi, pour créer un vecteur ligne des
valeurs de 0 à 1 par incrément de 0.2, il suit d’utiliser (notez le nombre d’éléments du vecteur) :
>> V = [ 0 : 0 . 2 : 1 ]
V =
Columns 1 t h r o u g h 6
0 0.2000 0.4000 0.6000 0.8000 1.0000
Par défaut, l’incrément est de 1. Ainsi, pour créer un vecteur ligne des valeurs de 0 à 5 par incrément de 1,
il suffit d’utiliser :
>> V = [ 0 : 5 ]
V =
0 1 2 3 4 5
On peut accéder à un élément d’un vecteur et même modifier celui-ci directement (Notez que contrairement
au C/C++, il n’y a pas d’indice 0 dans les vecteurs et matrices en MATLAB) :
>> a = V ( 2 )
a=
1
>> V ( 3 ) = 3∗ a
V =
0 1 3 3 4 5
2.4 Construction de tableaux par blocs

Vous connaissez ce principe en mathématiques. Par exemple, à partir des matrices et vecteurs précé-
demment définis, on peut définir la matrice
 
M V
N = 
U 0
qui est une matrice 4 × 4. Pour faire ça sous MATLAB, on fait comme si les blocs étaient des scalaires, et
on écrit tout simplement :
>> U=[1 2 3 ] ;
>> V = [ 1 1 ; 1 2 ; 1 3 ] ;
>> M=[1 2 3 ;
11 12 1 3 ;
21 32 2 3 ] ;
>> N=[M V ; U 0 ]
N=
1 2 3 11
11 12 13 12
21 32 23 13
1 2 3 0
Il y a d’autre syntaxe pour écrire la matrice N ci-dessus, mais cette syntaxe est très utilisée pour allonger
des vecteurs ou des matrices, par exemple si je veux ajouter une colonne à M, constituée par V :
>> V = [ 1 1 ; 1 2 ; 1 3 ] ;
>> M=[1 2 3 ;
11 12 1 3 ;
21 32 2 3 ] ;
>> N=[M V]
N=
1 2 3 11
11 12 13 12
21 32 23 13
Si je veux lui ajouter une ligne, constituée par U :
>> U=[1 2 3 ] ;
>> M=[1 2 3 ;
11 12 1 3 ;
21 32 2 3 ] ;
>> N=[M; U]
N=
1 2 3
11 12 13
21 32 23
1 2 3
On rappelle toujours que les matrices classiques sont générées en utilisant des commandes prédéfinies de
MATLAB. Dans ce cas, On peut définir des matrices de taille donnée ne contenant que des 0 avec la fonction
zeros, ou ne contenant que des 1 avec la fonction ones. Il faut spécifier le nombre de lignes et le nombre de
colonnes. ATTENTION, pour engendrer des vecteurs lignes (resp. colonnes), il faut spécifier explicitement
«1» pour le nombre de lignes (resp. colonnes).
2.5. OPÉRATIONS SUR LES TABLEAUX 19
2.5 Opérations sur les tableaux
2.5.1 Addition et soustraction
Les deux opérateurs sont les mêmes que pour les scalaires. A partir du moment où les deux tableaux
concernés ont la même taille, Le tableau résultant est obtenu en ajoutant ou soustrayant les termes de chaque
tableau. Les opérations usuelles d’addition, de soustraction et de multiplication par scalaire sur les vecteurs
sont définis dans MATLAB :
>> V1 = [ 1 2 ] ;
>> V2 = [ 3 4 ] ;
>> V = V1 + V2 % a d d i t i o n de v e c t e u r s
V =
4 6
>> V = V2 − V1 % s o u s t r a c t i o n de v e c t e u r s
V =
2 2
>> V = 2∗V1 % m u l t i p l i c a t i o n p a r un s c a l a i r e
V =
2 4
2.5.2 Multiplication, division et puissance terme à terme
Dans le cas de la multiplication et de la division, il faut faire attention aux dimensions des vecteurs en
cause. Ces opérateurs sont notés
.∗ , . / et .^ ( a t t e n t i o n à ne p a s o u b l i e r l e p o i n t ) .
Ils sont prévus pour effectuer des opérations termes à terme sur deux tableau de même taille. Ces symboles
sont fondamentaux lorsque l’on veut tracer des courbes.
Pour la multiplication et la division élément par élément, on ajoute un point devant l’opérateur (.* et ./). Par
exemple :
>> V = V1 . ∗ V2 % m u l t i p l i c a t i o n é l é m e n t p a r é l é m e n t
V =
3 8
>> V = V1 . / V2 % d i v i s i o n é l é m e n t p a r é l é m e n t
V =
0.3333 0.5000
Cependant, MATLAB lance une erreur lorsque les dimensions ne concordent pas (remarquez les messages
d’erreur, ils sont parfois utiles pour corriger vos programmes) :
>> V3 = [ 1 2 3 ]
V3 =
1 2 3
>> V = V1 . ∗ V3
? ? ? E r r o r u s i n g ==> . ∗ M a t r i x d i m e n s i o n s must a g r e e .
La multiplication de deux vecteurs est donnée par (*). Ici, l’ordre a de l’importance :
>> V1 = [ 1 2 ] ; % v e c t e u r 1 x2
>> V2 = V1 ’ ; % v e c t e u r 2 x1
>> V = V1∗V2
V =
5
>> V = V2∗V1
V =
1 2
2 4
Il est aussi possible de concaténer des vecteurs. Par exemple :
>> V1 = [ 1 2 ] ;
>> V2 = [ 3 4 ] ;
>> V = [ V1 V2 ]
V =
1 2 3 4
De même, pour les vecteurs colonnes :
>> V1 = [ 1 ; 2 ] ;
>> V2 = [ 3 ; 4 ] ;
>> V = [ V1 ; V2 ]
V =
1
2
3
4
On peut aussi créer des matrices, par exemple,
>> V1 = [ 1 2 ] ;
>> V2 = [ 3 4 ] ;
>> V = [ V1 ; V2 ]
V =
1 2
3 4
qui n’est pas équivalent à :
>> V1 = [ 1 ; 2 ] ;
>> V2 = [ 3 ; 4 ] ;
>> V = [ V1 V2 ]
V =
1 3
2 4
Il faut donc être très prudent dans la manipulation des vecteurs. Par exemple, une mauvaise concaténation :
>> V1 = [ 1 2 ] ;
>> V2 = [ 3 ; 4 ] ;
>> V = [ V1 ; V2 ]
? ? ? E r r o r u s i n g ==> v e r t c a t A l l rows i n t h e b r a c k e t e d e x p r e s s i o n
must h av e t h e same number o f co l u m n s .
2.5. OPÉRATIONS SUR LES TABLEAUX 21
2.5.3 Multiplication, division et puissance au sens matriciel

Puisque l’on peut manipuler des matrices, il paraît intéressant de disposer d’un multiplication matri-
cielle. Celle-ci se note simplement * et ne doit pas être confondue avec la multiplication terme à terme. Il
va de soi que si l’on écrit A ∗ B le nombre de colonnes de A doit être égal au nombre de lignes de B pour
que la multiplication fonctionne (voir les propriétés d’algèbre linéaire).
La division a un sens vis-à-vis des inverses de matrices. Ainsi A/B représente A multiplié (au sens des
matrices) à la matrice inverse B −1 de B. ATTENTION : même si la matrice B est régulière, elle peut être
mal conditionnée, et la méthode numérique utilisée pour calculer son inverse peut renvoyer des résultats
faux (on peut référer au cours d’analyse numérique sur la résolution de systèmes linéaires).
Il existe aussi une division à gauche qui se note \. Ainsi A\B signifie l’inverse A−1 de A multiplié
par B. Ce symbole peut être aussi utilisé pour résoudre des systèmes linéaires : si v est un vecteur A\v
représente mathématiquement A−1 v c’est-à-dire la solution du système linéaire A x = v.
La puissance nème d’une matrice représente cette matrice multipliée n fois au sens des matrices par
elle-même.
entre les opérateurs .∗ et ∗, un petit exemple faisant intervenir la matrice
Pour bien montrer la différence
1 2
identité multipliée à la matrice . Voici la multiplication au sens des matrices :
3 4
>> [ 1 0 ; 0 1 ] ∗ [ 1 2 ; 3 4 ]
ans =
1 2
3 4
et maintenant la multiplication terme à terme :
>> [ 1 0 ; 0 1 ] . ∗ [ 1 2 ; 3 4 ]
ans =
1 0
0 4
L’opérateur transposition est le caractère ’ et est souvent utilisé pour transformer des vecteurs lignes en
vecteurs colonnes et inversement.
2.5.4 Listes de valeurs

Cette notion est capitale pour la construction de courbes. Il s’agit de générer dans un vecteur une liste
de valeurs équidistantes entre deux valeurs extrêmes. La syntaxe générale est :
v a r i a b l e = v a l e u r début : pas : v a l e u r f i n
Cette syntaxe crée toujours un vecteur ligne. Par exemple pour créer un vecteur x de valeurs équidistantes
de 0.1 entre 0 et 1 :
>> x = 0 : 0 . 1 : 1
x =
0 0.1000 0.2000 0.3000 0.4000 0.5000 0.6000
0.7000 0.8000 0.9000 1.0000
Il est conseillé de mettre un point-virgule à la fin de ce type d’instruction pour éviter l’affichage fastidieux
du résultat. Donc, on peut donc placer le caractère ; à la fin d’une ligne de commande pour indiquer à
MATLAB qu’il ne doit pas afficher le résultat.
2.6 Longueurs de tableau

La fonction size appliquée à une matrice renvoie un tableau de deux entiers : le premier est le nombre
de lignes, le second le nombre de colonnes.
>> N=[1 2 3 ;
11 12 1 3 ;
21 32 2 3 ;
1 2 3]
>> s i z e (N)
4 x3 % 4 lignes et 3 colonnes
La commande fonctionne aussi sur les vecteurs et renvoie 1 pour le nombre de lignes (resp. colonnes) d’un
vecteur ligne (resp colonne).
Pour les vecteurs, la commande length est plus pratique et renvoie le nombre de composantes du vecteur,
qu’il soit ligne ou colonne.
>> V=[1 2 3 11 12 13 21 32 23 1 2 3 ]
V=1 2 3 11 12 13 21 32 23 1 2 3
>> l e n g t h (V)
1 x12 % 1 l i g n e s e t 12 c o l o n n e s
>> l e n g t h (V’ )
Autre exemple, pour créer 101 valeurs équiréparties sur l’intervalle [0, 2π] :
>>x = 0 : 2 ∗ p i / 1 0 0 : 2 ∗ p i ; %l e p a s e s t é g a l à 2∗ p i / 1 0 0
>> l e n g t h ( x )
Chapitre 3
Fichiers SCRIPT et FUNCTION
Les classes les plus utiles pour l’utilisateur débutant sont le double tel que présenté plus haut et les
variables char, pour le texte, et les variables symboliques, que nous présenteront par la suite de ce cours.
Pour les variables char, la déclaration se fait entre apostrophe :
>> mot1 = ’ h e l l o ’
mot1 =
hello
Il est possible de concaténer des mots à l’aide des parenthèses carrées (la fonction strcat de MATLAB
permet d’exéctuer sensiblement la même tâche) :
>> mot1 = ’ h e l l o ’ ;
>> mot2 = ’ world ’ ;
>> mot1_2 = [ mot1 ’ ’ mot2 ] % l ’ e m p l o i de ’ ’ p e r m e t
%d ’ i n t r o d u i r e un e s p a c e
mot1_2 =
hello world
Supposons que l’on veuille écrire un programme qui calcul la racine carrée d’un nombre entré par l’utili-
sateur et qui affiche le résultat dans une phrase. On peut convertir les nombres en chaîne de caractères en
utilisant la fonction num2str.
a= i n p u t ( ’ E n t r e z un nombre : ’ ) ; % u t i l i s a t i o n de i n p u t , l ’ u t i l i s a t e u r
% d o i t e n t r e r un nombre .
b= s q r t ( a ) ;
s t r = [ ’ La r a c i n e c a r r é e de ’ num2str ( a ) ’ est ’ num2str ( b ) ] ;
% c o m p o s i t i o n de l a p h r a s e de s o r t i e
disp ( s t r ) % u t i l i s a t i o n de d i s p l a y p o u r a f f i c h e r l e r é s u l t a t à l ’ é c r a n
Le résultat serait le suivant :

E n t r e z un nombre : 23 % 23 e s t e n t r é p a r l ’ u t i l i s a t e u r
La r a c i n e c a r r é e de 23 e s t 4 . 7 9 5 8 % s o r t i e à l ’ écran
La prochaine section montre comment réaliser de courts programmes comme celui utilisé dans le dernier
exemple.
23
24 CHAPITRE 3. FICHIERS SCRIPT ET FUNCTION
3.1 Fichiers SCRIPT et FUNCTION

Jusqu’à présent, l’utilisation que nous avons faite de MATLAB s’apparente beaucoup à celle d’une
calculatrice. Pour des tâches repétitives, il s’avère beaucoup plus pratique et judicieux d’écrire de courts
programmes pour exéctuer les calculs désirés. Il existe deux types de fichiers qui peuvent être programmés
avec MATLAB : les fichiers SCRIPT et FUNCTION. Dans les deux cas, il faut lancer l’éditeur de fichier
et sauvegarder le fichier avec l’extension .m.
3.1.1 Fichiers SCRIPT
Le fichier SCRIPT permet de lancer les mêmes opérations que celles écrites directement à l’invite MAT-
LAB. Toutes les variables utilisées dans un SCRIPT sont disponibles à l’invite MATLAB. Par exemple, le
fichier test.m qui reprend l’exemple précédent (assurez-vous que le fichier test.m se trouve bel et bien dans
le répertoire indiqué dans la fenêtre Répertoire courant) :
% t e s t .m
clear all
x = 4;
y = 2;
a = x + y
b = x ∗ y
whos
produit la sortie suivante lorsque qu’appelé :

>> t e s t
a =
6
b =
8
>>
Habituellement, on utilise les fchiers SCRIPT afin de :

– Initialiser le système (fonctions clear)
– Déclarer les variables
– Exéctuer les opérations algébriques
– Appeler les fonctions
– Tracer les figures
Il est utile ici de noter que le langage MATLAB n’est pas un langage compilé (contrairement au langage
C/C++, par exemple). À chaque appel d’un SCRIPT (ou d’une FUNCTION), le logiciel lit et exécute les
programmes ligne par ligne. Lorsque MATLAB détecte une erreur, le logiciel arrête et un message d’erreur
ainsi que la ligne où l’erreur est détectée s’affichent à l’écran. Apprendre à lire les messages d’erreur est
donc important pour "déboguer" vos programmes rapidement et efficacement.
3.1. FICHIERS SCRIPT ET FUNCTION 25
3.1.2 Fichiers FUNCTION

L’idée de base d’une fonction est d’exéctuer des opérations sur une ou plusieurs entrées ou arguments
pour obtenir un résultat qui sera appelé sortie. Il est important de noter que les variables internes ne sont
pas disponibles à l’invite MATLAB. Par exemple, la fonction suivante (avec une seule sortie, le résultat de
l’addition) :
function a = ma_function ( x , y )
a = x + y;
b = x ∗ y;
produit la sortie suivante :
>> a= m a _ f o n c t i o n ( 4 , 2 )
a=
6
>> whos
Grand t o t a l i s 1 e l e m e n t u s i n g 8 b y t e s
>>
Le résultat de la multiplication n’est plus disponible. On peut cependant modier les sorties de la manière
suivante :
function [ a , b ] = ma_function ( x , y )
a = x + y;
b = x ∗ y;
pour obtenir :
>> [ a , b ]= m a _ f o n c t i o n ( 4 , 2 )
a=
6
b=
8
>> whos
Grand t o t a l i s 2 e l e m e n t u s i n g 16 bytes
>>
On peut éviter l’affichage des sorties en utilisant le point-virgule :
>> [ a , b ]= m a _ f o n c t i o n ( 4 , 2 ) ;
>> whos
Grand t o t a l i s 2 e l e m e n t u s i n g 16 bytes
>>
Habituellement, on utilise les fichiers FUNCTION afin de :
– Programmer des opérations répétitives.
– Limiter le nombre de variables dans l’invite MATLAB.
– Diviser le programme (problème) de manière claire.
26 CHAPITRE 3. FICHIERS SCRIPT ET FUNCTION
Chapitre 4
Les entrées-sorties
4.1 Les formats d’affichage des réels

Matlab dispose de plusieurs formats d’affichage des réels. Par défaut le format est le format court à 5
chiffres. Les autres principaux formats sont :
format long : format long à 15 chiffres.
format short e : format court à 5 chiffres avec notation en virgule flottante.
format long e : format long à 15 chiffres avec notation en virgule flottante.
Matlab dispose également des formats format short g et format long g qui utilise la « meilleure » des
deux écritures à virgule fixe ou à virgule flottante. On obtiendra tous les formats d’affichage possibles en
tapant help format.
On impose un format d’affichage en tapant l’instruction de format correspondante dans la fenêtre de contrôle,
par exemple format long. Pour revenir au format par défaut on utilise la commande format ou format
short.
>> clear all ; % on e f f a c e t o u t e s l e s v a r i a b l e s , f o n c t i o n s , . . .
>> format co m p act ; % s u p r e s s i o n d e s r e t o u r s de c h a r i o t s s u p e r f l u s
>> format short e ; % é v i t e r qu ’ une p e t i t e q u a n t i t é e s ’ a f f i c h e comme 0 . 0 0 0 0
>> dbstop if error % f a c i l i t e r l ’ i m p r e s s i o n d ’ une v a r i a b l e en c a s d ’ e r r e u r
Exemple :
>> p i
ans =
3.1416
>> format long
>> pi
ans =
3.14159265358979
>> format s hor t e
>> p i ^3
ans =
3 . 1 0 0 6 e +01
>> format s hor t g
>> p i ^3
ans =
31.006
27
28 CHAPITRE 4. LES ENTRÉES-SORTIES
>> f o r m a t s h o r t
>>
4.2 Affichage simple, la commande disp

La commande disp permet d’afficher un tableau de valeurs numériques ou de caractères. L’autre façon
d’afficher un tableau est de taper son nom. La commande disp se contente d’afficher le tableau sans écrire
le nom de la variable ce qui peut améliorer certaines présentations.
>> A = magic ( 4 ) ;
>> d i s p (A)
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1
>> A
A =
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1
On utilise fréquemment la commande disp avec un tableau qui est une chaîne de caractères pour affi-
cher un message. Par exemple disp(’Calcul du déterminant de la matrice A’). On utilise également la
commande disp pour afficher un résultat. Par exemple disp([’Le déterminant de la matrice A vaut ’,
num2str(det(A))]). On remarque que l’usage de la commande disp est alors un peu particulier. En effet
un tableau doit être d’un type donné, les éléments d’un même tableau ne peuvent donc être des chaînes de
caractères et des valeurs numériques. On a donc recours à la commande num2str (« number to string »)
pour convertir une valeur numérique en une chaîne de caractères. Par défaut la commande num2str affiche
4 décimales mais il est possible de lui spécifier le nombre de décimales souhaité en second paramètre. De
même, il est possible de lui spécifier un format d’affichage particulier de la valeur numérique ; on consultera
la documentation matlab pour plus de détails. Attention, si la chaîne de caractères contient une apostrophe
il est impératif de doubler l’apostrophe
4.3 Lecture
La commande input permet de demander à l’utilisateur d’un programme de fournir des données. La
syntaxe est var = input(’ une phrase ’). La phrase une phrase est affichée et matlab attend que l’utilisateur
saisisse une donnée au clavier. Cette donnée peut être une valeur numérique ou une instruction matlab. Un
retour chariot provoque la fin de la saisie. Une valeur numérique est directement affectée à la variable var
tandis qu’une instruction matlab est évaluée et le résultat est affecté à la variable var. Il est possible de
provoquer des sauts de ligne pour aérer le présentation en utilisant le symbole \n de la manière suivante :
var = input(’ \n une phrase : \n ’). Pensez à mettre un point virgule ( ;) à la fin de l’instruction si vous ne
souhaitez pas voir s’afficher var = .
Sous cette forme il est impossible d’avoir une donnée de type chaîne de caractères dans la mesure où
matlab essaie d’interpréter cette chaîne de caractères comme une instruction. Si l’on souhaite saisir une
4.4. IMPRESSIONS DIRIGÉES PAR FORMAT 29
réponse de type chaîne de caractères on utilise la syntaxe var = input(’ une phrase ’,’s’). Signalons qu’un
retour chariot (sans autre chose) initialise la variable var au tableau vide [ ]. Voici un exemple d’utilisation
de la commande input (on suppose que la variable res contient une valeur numérique).
r e p = i n p u t ( ’ A f f i c h a g e du r e s u l t a t ? o / n [ o ] ’ , ’ s ’ ) ;
i f i s e m p t y ( r e p ) , r e p = ’ o ’ ; end
i f r e p == ’ o ’ | r e p == ’ y ’
d i s p ( [ ’ Le r e s u l t a t v a u t ’ , n u m 2 s t r ( r e s ) ] )
end
4.4 Impressions dirigées par format
La commande sprintf permet l’impression de variables selon un modèle donné. Un modèle d’édition
se présente sous la forme du symbole pourcent (%) suivi d’indications permettant de composer le contenu
du champ à imprimer, en particulier sa longueur en nombre de caractères. Le modèle d’édition utilisé par
matlab est le modèle d’édition du langage C.
La syntaxe de la commande sprintf est :
sprintf(format, variables)
où
– variables est le nom des variables à imprimer suivant le modèle d’édition spécifié dans format ;
– format est le format d’édition. Il s’agit d’une chaîne de caractères contenant les modèles d’éditions
des variables à imprimer.
Modèle d’édition de caractères :
Un modèle d’édition de caractères est de la forme %Ls où % est le symbole de début de format et s le
symbole précisant que la donnée est de type chaîne de caractères. L est un entier donnant la longueur total
du champ (en nombre de caractères). Par défaut le champ est justifié à droite (si la longueur de la chaîne
de caractères est plus petite que la longueur L du champ, des espaces sont insérés avant la chaîne de
caractères). Le symbole - (moins) juste après le symbole % permet de justifier à gauche. En l’absence de
l’entier L la longueur totale du champ est égale au nombre de caractères de la chaîne.
>> s p r i n t f ( ’% s ’ , ’ i l f e r a b eau a BOUKIDAREN’ )
ans =
i l f e r a b eau a BOUKIDAREN
>> t em p s = ’ i l f e r a b eau a BOUKIDAREN’ ; s p r i n t f ( ’% s ’ , t em p s )
ans =
>> s p r i n t f ( ’%30 s ’ , t em p s )
ans =
>> s p r i n t f (’%−30 s ’ , t em p s )
ans =
>> s p r i n t f ( ’ meteo : %s ’ , t em p s )
ans =
meteo : i l f e r a b eau a BOUKIDAREN
>>
Modèle d’édition des réels :

Un modèle d’édition de réel est de la forme %±L.Dt, où % est le symbole de début de format, L est un
entier donnant la longueur total du champ (en nombre de caractères, point virgule compris), D est le nombre
de décimales à afficher et t spécifie le type de notation utilisée. Par défaut le champ est justifié à droite (si
la longueur de la variable est plus petite que la longueur du champ L, des espaces sont insérés à gauche).
Le symbole - (moins) permet de justifier à gauche. Le symbole + (plus) provoque l’affichage systématique
d’un signe + devant les réels positifs. Les principales valeurs possibles pour t sont les suivantes :
d : pour l e s e n t i e r s
e : p o u r une n o t a t i o n à v i r g u l e f l o t t a n t e où l a p a r t i e e x p o s a n t e s t
d é l i m i t é e p a r un e m i n u s c u l e ( ex : 3 . 1 4 1 5 e +0 0 )
E : même n o t a t i o n m ai s E r e m p l a c e e ( ex : 3 . 1 4 1 5 E +0 0 )
f : p o u r une n o t a t i o n à v i r g u l e f i x e ( ex : 3 . 1 4 1 5 )
g : l a n o t a t i o n l a p l u s compacte e n t r e l a n o t a t i o n à v i r g u l e f l o t t a n t e
et la notation à virgule fixe est u t i l is é e
>> x = p i / 3 ; y = s i n ( x ) ;
>> s p r i n t f ( ’ s i n (% 8 . 6 f ) = %4.2 f ’ , x , y )
ans =
sin (1.047198) = 0.87
>> s p r i n t f ( ’ s i n (% 8 . 6 f ) = %4.2E ’ , x , y )
ans =
exp ( 1 . 0 4 7 1 9 8 ) = 8 . 6 6 E−01
>>
Utilisations particulières :
La commande sprintf est « vectorielle » : si la variable n’est pas scalaire le format d’impression est
réutilisé pour tous les éléments du tableau, colonne par colonne.
>> x = [ 1 : 1 0 ] ;
>> s p r i n t f ( ’ %d , ’ , x )
ans =
1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ,
>>
Il est possible d’utiliser les symboles suivant dans les chaînes de caractères
\n : p r o v o q u e l e p a s s a g e à une n o u v e l l e l i g n e
\t : i n s è r e une t a b u l a t i o n h o r i z o n t a l e
\b : d é c a l e l ’ i m p r e s s i o n du champ s u i v a n t d ’ un c a r a c t è r e v e r s l a g a u c h e
\r : saut horizontal
>> z = [ ] ; x = [ 1 : 1 0 ] ; f o r i = 1 : l e n g t h ( x ) , z = [ z , x ( i ) , l o g ( x ( i ) ) ] ; end ;
>> s = s p r i n t f ( ’ % 4 . 1 f | %8.6E \ n ’ , z )
ans =
1.0 | 0 . 0 0 0 0 0 0E+00
2.0 | 6 . 9 3 1 4 7 2E−01
3.0 | 1 . 0 9 8 6 1 2E+00
4.0 | 1 . 3 8 6 2 9 4E+00
5.0 | 1 . 6 0 9 4 3 8E+00
4.4. IMPRESSIONS DIRIGÉES PAR FORMAT 31
6.0 | 1 . 7 9 1 7 5 9E+00
7.0 | 1 . 9 4 5 9 1 0E+00
8.0 | 2 . 0 7 9 4 4 2E+00
9.0 | 2 . 1 9 7 2 2 5E+00
10.0 | 2 . 3 0 2 5 8 5E+00
>>
Si l’on a besoin d’afficher le caractère %, on le doublera %% pour qu’il ne soit pas interprété comme
le début d’un format. La commande fprintf est l’analogue de sprintf pour imprimer de variables selon un
modèle donné dans un fichier.
Chapitre 5
Graphisme
5.1 Gestion des fenêtres graphiques

Une instruction graphique ouvre une fenêtre dans laquelle est affiché le résultat de cette commande.
Par défaut, une nouvelle instruction graphique sera affichée dans la même fenêtre et écrasera la figure
précédente. On peut ouvrir une nouvelle fenêtre graphique par la commande figure. Chaque fenêtre se voit
affecter un numéro. Ce numéro est visible dans le bandeau de la fenêtre sous forme d’un titre. Le résultat
d’une instruction graphique est par défaut affiché dans la dernière fenêtre graphique ouverte qui est la fenêtre
graphique active. On rend active une fenêtre graphique précédemment ouverte en exécutant la commande
figure(n), où n désigne le numéro de la figure. La commande close permet de fermer la fenêtre graphique
active. On ferme une fenêtre graphique précédemment ouverte en exécutant la commande close(n), où n
désigne le numéro de la figure. Il est également possible de fermer toutes les fenêtres graphiques en tapant
close all. La figure 5.1 représente la fenêtre graphique numéro 1 où est affiché le graphe de la fonction
cosinus entre 0 et 2p, résultat de la commande fplot(’cos’,[0 4*pi]). L’apparence de la fenêtre graphique
peut varier légèrement suivant le système informatique utilisé.
F IGURE 5.1 – Fenêtre graphique et résultat de la commande fplot(’cos’,[0 4*pi]).
5.2 Graphisme 2D
5.2.1 Tracer le graphe d’une fonction ; la commande fplot
La commande fplot permet de tracer le graphe d’une fonction sur un intervalle donné. La syntaxe est :
33
34 CHAPITRE 5. GRAPHISME
fplot(’nomf’, [xmin , xmax])
où
– nomf est soit le nom d’une fonction matlab incorporée, soit une expression définissant une fonction
de la variable x, soit le nom d’une fonction utilisateur.
– [xmin , xmax] est l’intervalle pour lequel est tracé le graphe de la fonction.
Illustrons par des exemples les trois façons d’utiliser la commande fplot. On obtient le graphe de la
fonction incorporée sinus entre −2π et 2π par l’instruction :
fplot(’sin’,[-2*pi 2*pi]).
Pour tracer le graphe de la fonction h(x) = xsin(x) entre −2π et 2π, on peut définir la fonction
utilisateur h dans le fichier h.m de la manière suivante (em attention de bien lire x. ∗ sin(x) et non pas
x ∗ sin(x)) :
f u n c t i o n y=h ( x )
y=x . ∗ s i n ( x ) ;
On obtient alors le graphe de la fonction h par l’instruction :
fplot(’h’,[-2*pi 2*pi]).
L’autre façon de procéder est d’exécuter l’instruction (là on a le choix entre écrire x. ∗ sin(x) ou x ∗
sin(x)) :
fplot(’x*sin(x)’,[-2*pi 2*pi]).
Dans les deux cas on obtient le dessin représenté à la figure 5.2
−1
−2
−3
−4
−5
−6 −4 −2 0 2 4 6
F IGURE 5.2 – Fenêtre graphique et résultat de la commande fplot(’x*sin(x)’,[-2*pi 2*pi]). Graphe de la

fonction h(x) = x sin(x) entre −2π et 2π.
Il est possible de tracer plusieurs fonctions sur la même figure. Il faut pour cela utiliser la commande
fplot de la manière suivante : fplot(’[nomf 1 , nomf 2 , nomf 3 ]’, [xmin , xmax ]) où nomff 1, nomf 2, nomf 3
est soit le nom d’une fonction matlab incorporée, soit une expression définissant une fonction de la variable
x, soit le nom d’une fonction utilisateur.
Il est également possible de gérer les bornes des valeurs en ordonnées. Pour limiter le graphe aux
ordonnées comprises entre les valeurs ymin et ymax on passera comme second argument de la commande
fplot le tableau [xmin , xmax , ymin , ymax ].
Voici un exemple dont le résultat est affiché à la figure 5.3
fplot(’[sin(x)/x , cos(x)/x]’, [−5, 5, −1, 1])
On comprend très vite l’intérêt de gérer les bornes des valeurs en ordonnées si l’on exécute la commande
fplot(’cos(x)/x’, [−5, 5]) pour tracer le graphe de la fonction cos(x)/x entre −5 et 5. La figure, qui n’est
pas vraiment esthétique, n’est pas reproduite ici.
5.2. GRAPHISME 2D 35
0.8
0.6
sin(x)/x
0.4
0.2
0
cos(x)/x
−0.2
−0.4
−0.6
−0.8
−1
−5 0 5
F IGURE 5.3 – Graphe des fonctions f (x) = sin(x)/x et g(x) = cos(x)/x entre −5 et 5.
5.2.2 La commande plot

La commande plot permet de tracer un ensemble de points de coordonnées (xi , yi ) i = 1, . . . , N. La
syntaxe est plot (x, y) où x est le vecteur contenant les valeurs xi en abscisse et y est le vecteur contenant
les valeurs yi en ordonnée. Bien entendu les vecteurs x et y doivent être de même dimension mais il peut
s’agir de vecteurs lignes ou colonnes.
Par défaut, les points (xi , yi ) sont reliés entre eux par des segments de droites.
Voici par exemple une autre façon de tracer le graphe de la fonction h(x) = x sin(x) entre −2π et 2π,
>> x=[−2∗ p i : 0 . 0 1 : 2 ∗ p i ] ; y = x . ∗ s i n ( x ) ;
>> p l o t ( x , y )
>>
Essayez aussi
>> x=[−2∗ p i : 1 : 2 ∗ p i ] ; y = x . ∗ s i n ( x ) ;
>> p l o t ( x , y )
>>
Dans cet exemple on a défini un vecteur x de valeurs équi-réparties entre −2π et 2π (avec un pas de 0.01
dans le premier cas et de 1 dans le deuxième cas) et on a calculé l’image par la fonction h de ces valeurs
(vecteur y). On affiche les points de coordonnées (x(i), y(i)).
On peut spécifier à matlab quelle doit être la couleur d’une courbe, quel doit être le style de trait et/ou
quel doit être le symbole à chaque point (xi , yi ). Pour cela on donne un troisième paramètre d’entrée à la
commande plot qui est une chaîne de 3 caractères de la forme ’cst’ avec c désignant la couleur du trait, s le
symbole du point et t le style de trait. Les possibilités sont les suivantes :
y jaune . point − t r a i t plein
m m ag en t a o cercle : po int illé court
c cy an x marque x − p o i n t i l l é long
r rouge + plus −. p o i n t i l l é mixte
g vert ∗ étoile
b bleu s carré
w blanc d losange
k noir v t r i a n g l e ( bas )
^ t r i a n g l e ( haut )
< t r i a n g l e ( gauche )
> triangle ( droit )
p pentagone
h hexagone
Les valeurs par défaut sont c = b, s = . et t = − ce qui correspond à un trait plein bleu reliant les points
entre eux. Il n’est pas obligatoire de spécifier chacun des trois caractères. On peut se contenter d’en spécifier
un ou deux. Les autres seront les valeurs par défaut.
La commande grid permet d’obtenir un quadrillage de la figure, voir par exemple la figure 5.2.
Il est possible de tracer plusieurs courbes sur la même figure en spécifiant plusieurs tableaux x1, y1,
x2, y2,...., comme paramètres de la commande plot. Si l’on souhaite que les courbes aient une apparence
différente, on utilisera des options de couleurs et/ou de styles de traits distincts après chaque couple de
vecteurs x, y.
Voici un exemple dont le résultat est affiché à la figure 5.4. On trace sur l’intervalle [−5, 5] la fonction
2
x cos(x) en trait plein bleu et la fonction x cos(x) en trait pointillé rouge.
>> x = [ − 5 : 0 . 0 1 : 5 ] ;
>> y = x . ^ 2 . ∗ c o s ( x ) ;
>> z = x . ∗ c o s ( x ) ;
>> p l o t ( x , y , ’ b − ’ , x , z , ’ r : ’ ) ;
>> g r i d
>>
4
x.*cos(x)
2
−2
−4
x.2.*cos(x)
−6
−8
−10
−12
−5 0 5
F IGURE 5.4 – Graphe des fonctions f1 (x) = x2 cos(x) et f2 (x) = x cos(x) entre −5 et 5. Résultat de la
commande plot(x,y,’b-’,x,z,’r :’).
Voici un autre exemple amusant (La commande whitebg permet de passer la fenêtre graphique en
inverse vidéo)
>> N= 2 0 0 ;
>> x = r a n d ( 1 ,N ) ; y = r a n d ( 1 ,N ) ;
>> p l o t ( x , y , ’ bd ’ ) , w h i t e b g
>>
5.3. AMÉLIORER LA LISIBILITÉ D’UNE FIGURE 37
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0
0 0.2 0.4 0.6 0.8 1
F IGURE 5.5 – Résultat de la commande plot(x,y,’bd’), whitebg.
5.2.3 La commande loglog

Si x et y sont deux vecteurs de même dimension, la commande loglog(x, y) permet d’afficher le vecteur
log(x) contre le vecteur log(y). La commande loglog s’utilise de la même manière que la commande plot.
Voici un exemple dont le résultat est affiché à la figure 5.6. Quelle est la pente de la droite ?
>> x = [ 1 : 1 0 : 1 0 0 0 ] ; y = x . ^ 3 ;
>> l o g l o g ( x , y )
>> g r i d
10
10
8
10
6
10
4
10
2
10
0
10
0 1 2 3
10 10 10 10
F IGURE 5.6 – Résultat de la commande loglog(x,y).
5.3 Améliorer la lisibilité d’une figure
5.3.1 Légender une figure

Il est recommandé de mettre une légende à une figure. La commande xlabel permet de mettre un texte
en légende sous l’axe des abscisses. La syntaxe est
xlabel(’ légende ’)
pour obtenir le mot légende en légende. La commande ylabel fait de même pour l’axe des ordonnées.
La commande title permet de donner un titre à la figure. La syntaxe est title(’ le titre ’) pour obtenir
comme titre le titre.
On peut aussi écrire un texte donné à une position précise sur la figure grâce à la commande text. La
syntaxe est text(posx,posy,’ un texte ’) où posx et posy sont les coordonnées du point (dans le système
associé au déssin) où doit débuter l’écriture du texte un texte. La commande gtext permet quant à elle de
placer le texte à une position choisie sur la figure à l’aide de la souris. La syntaxe est gtext(’ un texte ’).
Une mire, que l’on déplace en utilisant la souris, apparaît. Il suffit d’un « clic-souris » pour que le texte
apparaisse à la position sélectionnée.
Il est possible avec ces commandes d’afficher une valeur contenue dans une variable au milieu de texte.
Pour cela on construit un tableau de type chaîne de caractères en convertissant la valeur contenue dans la
variable en une chaîne de caractères grâce à la commande num2str. Par exemple, supposons que la variable
numex contienne le numéro de l’exemple traité, disons 8. On obtiendra pour titre de la figure Exemple
numero 8 par l’instruction : title([’Exemple numero ’, num2str(numex)]).
>> P = 8 ;
>> t = [ 0 : . 0 1 : 2 ] ;
>> c = 12∗ exp (−2∗ t ) − 8∗ exp (−6∗ t ) ;
>> p l o t ( t , c ) ; g r i d
>> x l a b e l ( ’ Temps en m i n u t e s ’ )
>> y l a b e l ( ’ C o n c e n t a t i o n en gramme p a r l i t r e ’ )
>> t i t l e ( [ ’ e v o l u t i o n de l a c o n c e n t r a t i o n du p r o d u i t ’ , n u m 2 s t r ( P ) , . . . ’ au c o
>> g t e x t ( ’ c o n c e n t r a t i o n maximale ’ )
>>
evolution de la concentration du produit8au cours du temps

6
concentration maximale
5
Concentation en gramme par litre
0
0 0.5 1 1.5 2
Temps en minutes
F IGURE 5.7 – Résultat de la commande gtext(’concentration maximale’).
5.3.2 Afficher plusieurs courbes dans une même fenêtre

Il est possible d’afficher plusieurs courbes dans une même fenêtre graphique grâce à la commande hold
on. Les résultats de toutes les instructions graphiques exécutées après appel à la commande hold on seront
superposés sur la fenêtre graphique active. Pour rétablir la situation antérieure (le résultat d’une nouvelle
instruction graphique remplace dans la fenêtre graphique le dessin précédent) on tapera hold off.
Voici un exemple d’utilisation de la commande hold on. Le résultat est présenté à la figure 5.8.
5.3. AMÉLIORER LA LISIBILITÉ D’UNE FIGURE 39
>> e = exp ( 1 ) ;
>> figure
>> h o l d on
>> f p l o t ( ’ exp ’ , [ −1 1 ] )
>> f p l o t ( ’ log ’ , [ 1 / e e ] )
>> plot ([ −1:0.01:e ] ,[ −1:0.01: e ])
>> grid
>> hold o ff
>>
2.5 y=exp(x)
2
y=x
axe des ordonnées
1.5
1
y=log(x)
0.5
−0.5
−1
0.5 1 1.5 2 2.5
axe des abscisses
F IGURE 5.8 – Résultat de la commande gtext(’.....’).
On dispose donc de deux façons de superposer plusieurs courbes sur une même figure. On peut soit
donner plusieurs couples de vecteurs abscisses/ordonnées comme argument de la commande plot, soit avoir
recours à la commande hold on. Suivant le contexte on privilégiera l’une de ces solutions plutôt que l’autre.
Il est possible de décomposer une fenêtre en sous-fenêtres et d’afficher une figure différente sur chacune
de ces sous-fenêtres grâce à la commande subplot. La syntaxe est
subplot(m,n,i)
où
– m est le nombre de sous-fenêtres verticalement ;
– n est le nombre de sous-fenêtres horizontalement ;
– i sert à spécifier dans quelle sous-fenêtre doit s’effectuer l’affichage. Les fenêtres sont numérotées de
gauche à droite et de haut en bas.
L’exemple suivant dont le résultat apparaît à la figure 5.9 illustre l’utilisation de la commande subplot.
>> figure
>> subplot (2 ,3 ,1) , fplot ( ’ cos ’ , [ 0 4∗ p i ] ) , t i t l e ( ’ c o s i n u s ’ ) , g r i d
>> subplot (2 ,3 ,2) , fplot ( ’ s i n ’ , [ 0 4∗ p i ] ) , t i t l e ( ’ s i n u s ’ ) , g r i d
>> subplot (2 ,3 ,3) , fplot ( ’ tan ’ ,[ − p i / 3 p i / 3 ] ) , t i t l e ( ’ t a n g e n t e ’ ) , g r i d
>> subplot (2 ,3 ,4) , fplot ( ’ aco s ’ , [ −1 1 ] ) , t i t l e ( ’ a r c −c o s i n u s ’ ) , g r i d
>> subplot (2 ,3 ,5) , fplot ( ’ a s i n ’ , [ −1 1 ] ) , t i t l e ( ’ a r c −s i n u s ’ ) , g r i d
>> subplot (2 ,3 ,6) , fplot ( ’ atan ’ ,[ − s q r t ( 3 ) s q r t ( 3 ) ] ) , . . .
t i t l e ( ’ a r c −t a n g e n t e ’ ) , g r i d
>>
cosinus sinus tangente

1 1 2
0.5 0.5 1
0 0 0
−0.5 −0.5 −1
−1 −1 −2
0 5 10 0 5 10 −1 0 1
arc−cosinus arc−sinus arc−tangente

4 2 2
3 1 1
2 0 0
1 −1 −1
0 −2 −2
−1 0 1 −1 0 1 −1 0 1
F IGURE 5.9 – Résultat de la commande subplot(m,n,i).
5.3.3 Sauvegarder une figure

La commande print permet de sauvegarder la figure d’une fenêtre graphique dans un fichier sous divers
formats d’images. La syntaxe de la commande print est :
print -f<num> -d<format> <nomfic>
où
– <num> désigne le numéro de la fenêtre graphique. Si ce paramètre n’est pas spécifié, c’est la fenêtre
active qui est prise en compte.
– <nomfic> est le nom du fichier dans lequel est sauvegardée la figure. Si aucune extension de nom
n’est donnée, une extension par défaut est ajoutée au nom du fichier en fonction du format choisi (.ps
pour du PostScript, .jpg pour du jpeg, par exemple).
– <format> est le format de sauvegarde de la figure. Ces formats sont nombreux. On pourra obtenir la
liste complète en tapant help plot. Les principaux sont :
ps : PostScript noir et blanc
psc : PostScript couleur
eps : P o s t S c r i p t Encapsulé noir et blanc
epsc : P o s t S c r i p t Encapsulé couleur
jpeg : Fo rm at d ’ image JPEG
tiff : Fo rm at d ’ image TIFF
5.4 Graphisme 3D
5.4.1 Tracer les lignes de niveau d’une fonction de 2 variables

La commande contour permet de tracer les lignes de niveau d’une fonction de 2 variables réelles. Cette
fonction peut être définie par une expression matlab (par exemple x∗exp(−x2 −y 2)), ou être définie comme
une fonction utilisateur. Pour tracer les lignes de niveau de la fonction g(x, y) pour x ∈ [xmin, xmax] et
y ∈ [ymin, ymax] on procède de la manière suivante :
– création d’un maillage, de maille de longueur h, du domaine [xmin, xmax] × [ymin, ymax] grâce à
la commande meshgrid, [X, Y ] = meshgrid(xmin : h : xmax , ymin : h : ymax ).
– Évaluation de la fonction aux nœuds de ce maillage, soit par appel à la fonction utilisateur définissant
la fonction, Z = g(X, Y ) soit directement en définissant la fonction par une expression matlab.
– Affichage des lignes de niveau grâce à la commande contour, contour(X,Y,Z)

2 2
Ainsi, pour tracer les lignes de niveau de la fonction (x, y) 7→ x e−(x +y ) sur le domaine [−2, 2] × [−2, 2]
en prenant un maillage de maille de longueur h = 0.2, on exécute :
>> [X , Y] = m e s h g r i d ( − 2 : . 2 : 2 , −2:.2:2);
>> Z = X. ∗ exp (−X.^2 −Y . ^ 2 ) ;
>> c o n t o u r (X, Y , Z )
>>
On peut également écrire une fonction utilisateur g.m,

f u n c t i o n x3=g ( x1 , x2 )
x3=x1 . ∗ exp (−x1 .^2 − x2 . ^ 2 ) ;
et exécuter
>> [X , Y] = m e s h g r i d ( − 2 : . 2 : 2 , −2:.2:2);
>> Z = g (X , Y ) ;
>> c o n t o u r (X, Y , Z )
>>
Dans les 2 cas on obtient le résultat présenté à la figure 5.10.
1.5
0.5
−0.5
−1
−1.5
−2
−2 −1.5 −1 −0.5 0 0.5 1 1.5 2
F IGURE 5.10 – Exemple de visualisation des lignes de niveau par la commande contour.
Le nombre de lignes de niveau est déterminé de manière automatique à partir des valeurs extrêmes prises
par la fonction sur le domaine considéré. Pour imposer le nombre n de lignes de niveau à afficher, il suffit
d’appeler la fonction contour avec la valeur n comme quatrième paramètre, contour(X,Y,Z,n).
Il existe deux manières d’afficher les valeurs des lignes de niveau sur la figure. Si l’on souhaite afficher
les valeurs pour toutes les lignes de niveau, on utilise la commande clabel de la manière suivante :
>> [ C , h ] = c o n t o u r (X, Y, Z , n )
>> c l a b e l ( C , h )
>>
Si l’on souhaite afficher uniquement les valeurs de quelques lignes de niveau, on utilise la commande
clabel de la manière suivante :
>> [ C , h ] = c o n t o u r (X, Y, Z , n )
>> c l a b e l ( C , h , ’ manual ’ )
>>
On peut alors grâce à la souris sélectionner les lignes de niveau pour lesquelles on souhaite afficher la valeur.
Ainsi pour tracer 30 lignes de niveau de la fonction (x, y) 7→ (x − 1)2 + 10(x2 − y)2 sur le domaine
[−1, 1] × [−1, 1] et pour choisir à l’aide de la souris les lignes de niveau pour lesquelles l’isovaleur doit être
affichée, on exécute :
>> [X , Y] = m e s h g r i d ( − 2 : . 2 : 2 , − 2 : . 2 : 2 ) ;
>> Z = (X− 1 ) . ^ 2 + 1 0 ∗ (X.^2 −Y ) . ^ 2 ;
>> [ C , h ] = c o n t o u r (X, Y, Z , 3 0 ) ;
>> c l a b e l ( C , h , ’ manual ’ )
>>
Le résultat est présenté à la figure 5.11.
1
8.5161
0.8 7.0968
5.6774
0.6 4.2581
0.4 2.8387
0.2 194
1.4
0
−0.2
4.
25
−0.4 5. 81
67
74
−0.6
9.9
−0.8 35
5
−1
−1 −0.5 0 0.5 1
Il est possible de modifier la palette des couleurs en utilisant la commande colormap. En tapant help
graph3d dans la fenêtre de contrôle matlab, vous obtiendrez toutes les palettes de couleurs disponibles. A
vous de les tester pour obtenir le meilleur effet. La commande colormap(gray) permet d’utiliser une palette
en dégradé de gris, ce qui est très utile si l’on souhaite une impression de la figure sur une imprimante noir
et blanc.
La commande contourf s’utilise de la même manière que la commande contour. Elle permet d’afficher,
en plus des lignes de niveau, un dégradé continu de couleurs qui varie en fonction des valeurs prises par la
fonction. La figure 5.12 présente un exemple d’utilisation de la commande contourf obtenu de la manière
suivante :
>> [X , Y] = m e s h g r i d ( − 2 : . 2 : 2 , − 2 : . 2 : 2 ) ;
>> Z = (X− 1 ) . ^ 2 + 1 0 ∗ (X.^2 −Y ) . ^ 2 ;
>> c o n t o u r f (X, Y , Z , 3 0 ) ;
>> colormap ( co o l ) ;
>>
5.4.2 Représenter une surface d’équation z = g(x, y)

La commande mesh permet de tracer une surface d’équation z = g(x, y). La fonction g peut être définie
directement par une expression matlab ou être définie comme une fonction utilisateur. Pour tracer la surface
d’équation z = g(x, y) pour x ∈ [xmin , xmax ] et y ∈ [ymin , ymax ] on procède de la manière suivante :
0.8
0.6
0.4
0.2
−0.2
−0.4
−0.6
−0.8
−1
−1 −0.5 0 0.5 1
– création d’un maillage, de maille de longueur h, du domaine [xmin , xmax ] × [ymin , ymax ] grâce à la
commande meshgrid,
[X, Y] = meshgrid(xmin : h : xmax , ymin : h : ymax ).
la fonction,
Z = g(X, Y )
soit directement en définissant la fonction par d’une expression matlab.
– Affichage de la surface grâce à la commande mesh,
mesh(X, Y, Z).
2 +y 2 )
Ainsi pour tracer la surface d’équation z = xe−(x sur le domaine [−2, 2] × [−2, 2] avec un maillage de
maillage de longueur h = 0.2, on exécute :
>> [X , Y] = m e s h g r i d ( − 2 : . 2 : 2 , −2:.2:2);
>> Z = X. ∗ exp (−X.^2 −Y . ^ 2 ) ;
>> mesh (X, Y, Z )
>>
Si la fonction est définie comme une fonction utilisateur dans le fichier g.m,
f u n c t i o n x3 = g ( x1 , x2 )
x3 = x1 . ∗ exp (−x1 .^2 − x2 . ^ 2 ) ;
on exécute :
>> [X , Y] = m e s h g r i d ( − 2 : . 2 : 2 , −2:.2:2);
>> Z = g (X , Y ) ;
>> c o n t o u r (X, Y , Z )
>>
Dans les 2 cas on obtient le résultat présenté figure 5.13.

Par défaut les valeurs extrêmes en z sont déterminées automatiquement à partir des extremums de la
fonction sur le domaine spécifié. Il est possible de modifier ces valeurs (et également les valeurs extrêmes
en abscisses et ordonnées) par la commande axis dont la syntaxe est axis(xmin xmax ymin ymax zmin zmax ).
0.5
−0.5
2
1 2
0 1
0
−1 −1
−2 −2
F IGURE 5.13 – Exemple de visualisation d’une surface d’équation z = g(x, y) grâce à la commande mesh.
−1
−2
2
1 2
0 1
0
−1 −1
−2 −2
F IGURE 5.14 – Exemple d’utilisation de la commande axis.
Si vous n’êtes pas satisfait du résultat, l’instruction axis auto restaure la figure originale. La figure 5.14
montre par exemple le résultat de l’instruction axis([ -2 2 -2 2 -2 2]).
Il est également possible de modifier le point de vision grâce à la commande view. La commande view
a deux arguments qui sont l’angle de vision horizontal et l’angle de vision vertical en degré. Par défaut ces
angles ont repectivement les valeurs −37.5o C et 30o C. La figure 5.15 montre par exemple le résultat de
l’instruction view(37.5,30).
Les commandes meshc et meshz s’utilisent de la même manière que la commande mesh. La commande
meshc permet d’afficher des lignes de niveau sous la surface dans le plan z = zmin . La commande meshz
permet de tracer une boite sous la surface. Un exemple d’utilisation de ces commandes est présenté à la
figure 5.16.
5.4.3 Représenter une surface paramétrée
La commande surf permet de tracer une surface paramétrée d’équations,


 x = g1 (u, v),
(E) y = g2 (u, v),
z = g3 (u, v),

0.5
2
−0.5
−2 1
−1 0
0
1 −1
2 −2
F IGURE 5.15 – Exemple de modification de l’angle de vision par la commande view.
0.5 0.5
0 0
−0.5 −0.5
2 2
1 2 1 2
0 1 0 1
0 0
−1 −1 −1 −1
−2 −2 −2 −2
F IGURE 5.16 – Exemple de visualisation d’une surface d’équation z = g(x, y) grâce au commandes meshc
(à gauche) et meshz (à droite).
La fonction G = (g1 , g2 , g3 ) peut être définie directement par une expression matlab ou être définie
comme une fonction utilisateur. Pour tracer la surface paramétrée d’équation (E) pour u ∈ [umin , umax ] et
v ∈ [vmin , vmax ] on procède de la manière suivante :
– création d’un maillage de maille de longueur h du domaine de paramétrisation [umin , umax ]×[vmin , vmax ]
grâce à la commande meshgrid,
[U, V] = meshgrid(umin : h : umax , vmin : h : vmax ).
la fonction
[X, Y, Z] = G(U, V)
soit directement en définissant la fonction par d’une expression matlab.
– Affichage de la surface grâce à la commande surf,
surf(X, Y, Z).
Ainsi pour tracer la surface paramétrée d’équations

 x = v cos(u),
y = v sin(u),
z = 2 u,

sur le domaine [0, 2π] × [0, 2] avec un maillage de maillage de longueur h = 0.2, on exécute :
>> [U , V] = m e s h g r i d ( 0 : . 2 : 2 ∗ p i , 0 : . 2 : 2 ) ;
>> X = V. ∗ c o s (U ) ;
>> Y = V. ∗ s i n (U ) ;
>> Z = 2∗U ;
>> s u r f (X, Y, Z )
Si la fonction est définie comme une fonction utilisateur dans le fichier G.m,
f u n c t i o n [ x1 , x2 , x3 ] = G( u , v )
x1 = v . ∗ c o s ( u ) ;
x2 = v . ∗ s i n ( u ) ;
x3 = 2∗ u ;
on exécute :
>> [U , V] = m e s h g r i d ( 0 : . 2 : 2 ∗ p i , 0 : . 2 : 2 ) ;
>> [X , Y, Z ] = G(U, V ) ;
>> s u r f (X, Y, Z )
Dans les 2 cas on obtient le résultat présenté figure 5.17.
15
10
0
2
1 2
0 1
0
−1 −1
−2 −2
F IGURE 5.17 – Exemple de visualisation d’une surface paramétrée grâce à la commande surf.
Chapitre 6
Programmation avec MATLAB
Cette section présente les différentes structures de programmation avec MATLAB. Pour l’étudiant fa-
milier avec la programmation C/C++ ou Fortran, il ne s’agit que de se familiariser avec la syntaxe propre
à MATLAB. Pour l’étudiant moins familier avec les structures de base en programmation pour devenir
fonctionnels.
TABLE 6.1 – Opérateurs de comparaisons sous MATLAB
Opérateur Description
a NOT - retourne 1 si a égal 0, 1 si a égal 0
a == b retourne 1 si a égal b, 0 autrement
a<b retourne 1 si a est plus petit que b, 0 autrement
a>b retourne 1 si a est plus grand que b, 0 autrement
a <= b retourne 1 si a est plus petit ou égal à b, 0 autrement
a >= b retourne 1 si a est plus grand ou égal à b, 0 autrement
a =b retourne 1 si a est différent de b, 0 autrement
6.1 Opérateurs logiques

Avant de débuter la présentation des boucles de programmation conditionnelles, il est important de se
familiariser avec les opérateurs logiques. Le premier type de ces opérateurs permet de comparer des valeurs
entre elles (Tableau 6.1). Par exemple, on veut comparer deux valeurs entre elles :
>> a = s i n ( 2 ∗ p i ) ;
>> b = c o s ( 2 ∗ p i ) ;
>> b o o l = ( a >b )
bool =
0
>> a
a =
−2.4493 e −016 % i c i a d e v r a i t é g a l e r 0 , l a p r é c i s i o n e s t l i m i t é e !
>> b
b =
1
47
48 CHAPITRE 6. PROGRAMMATION AVEC MATLAB
Il faut noter ici que l’emploie de l’opérateur ’==’ est très risqué lorsque l’on compare des valeurs
numériques. En efiet, la précision de l’ordinateur étant limitée, il est préférable d’utiliser une condition
sur la différence comme dans le code suivant :
i f a b s ( a−b ) < e p s % e p s e s t l a p r é c i s i o n m ach i n e ( 2 . 2 2 0 4 e −016)
bool = 1;
else
bool = 0;
end
TABLE 6.2 – La vérité sur l’opérateur ET
P Q P ET Q
1 1 1
1 0 0
0 1 0
0 0 0
TABLE 6.3 – La vérité sur l’opérateur OU
P Q P OU Q
1 1 1
1 0 1
0 1 1
0 0 0
Il est aussi possible de lier entre elles des conditions par l’opérateur ’et’ (&) et ’ou’ (|). Les tables de
vérités sur les liens logiques de ces deux opérateurs sont présentées aux tableaux (6.2) et (6.3). Ces notions
seront utiles pour la construction des conditions des prochaines sections
6.2 Boucles if-elseif-else

Ce type de structure de programmation est très utile pour vérifler des conditions. En pseudo-code, on
peut résumer par le schéma suivant :
s i CONDITION1 , FAIRE ACTION1 . % c o n d i t i o n 1 r e m p l i e
s i n o n e t s i CONDITION2 , FAIRE ACTION2 . % c o n d i t i o n 1 non−r e m p l i e ,
% m ai s c o n d i t i o n 2 r e m p l i e
s i n o n , FAIRE ACTION3 % c o n d i t i o n s 1 e t 2 non−r e m p l i e s
En MATLAB, l e p s eu d o−co d e p r é c é d e n t d e v i e n t :
i f CONDITION1
ACTION1 ;
e l s e i f CONDITION2
ACTION2 ;
else
ACTION3 ;
6.3. BOUCLES FOR 49
Par exemple, on reçoit un entier a, s’il est impair négatif, on le rend positif. S’il est impair positif, on lui
ajoute 1. S’il est pair, on ajoute 2 à sa valeur absolue. La courte fonction suivante permet de réaliser cette
transformation (notez ici, l’emploi du modulo pour déterminer si l’entier est divisible par 2).
function b = transf_entier (a)
if a < 0 & mod ( a , 2 ) ~= 0 % mod p e r m e t de t r o u v e r
b = −a ; % l e r e s t e d ’ une d i v i s i o n
elseif a >= 0 & mod ( a , 2 ) ~= 0
b = a + 1;
else
b = abs ( a )+2;
end
Exemple :
n = 5 ;
m = 8 ;
i f ( n >0 ) % Gardien 1
i f ( n >5 && m<0 ) % G a r d i e n 1 e t g a r d i e n 2
disp ( ’ i c i 1 ’) % Affichage
e l s e i f ( n ==5) % S i g a r d i e n 1 e t non g a r d i e n 2 e t g a r d i e n 3
else % S i g a r d i e n 1 e t non g a r d i e n 2 e t non g a r d i e n 3
end
else % Si g ard i en 1 e s t faux
end %
6.3 Boucles for

Les boucles for sont très utiles dans la plupart des applications mathématiques (par exemple, pour
efiectuer un calcul sur tous les éléments d’un vecteur). En MATLAB, il est parfois beaucoup plus efficace
d’utiliser les opérateurs algébriques usuels déflnis plus tôt (par exemple, le ’.*’). Dans les cas où il est
impossible de se soustraire à l’utilisation de ces boucles, voici le prototype en pseudo-code de ces boucles.
incrément = valeur i n i t i a l e
Po u r i n c r é m e n t = v a l e u r _ i n i t i a l e j u s q u ’ à v a l e u r f i n a l e
ACTION1 . . . N
AJOUTER 1 à i n c r é m e n t
end
En MATLAB, ce pseudo-code devient :

for i = 0: va le ur_finale
ACTION1 ;
ACTION2 ;
...
ACTIONN ;
end
Remarquez que l’incrément peut être différent de 1, par exemple si l’on veut calculer les carrés des
nombres pairs entre 0 et 10 :
for i =0:2:10
c a r r e = i ^2
end
6.4 Boucles while
Une boucle while permet de répéter une opération tant qu’une condition n’est pas remplie. En pseudo-
code, elle peut être schématisée de la façon suivante :
T a n t que CONDITION e s t VRAIE
ACTION1 . . N
En MATLAB, on écrit ce type de boucle de la manière suivante :

w h i l e CONDITION
ACTION1 ;
ACTION2 ;
...
ACTIONN ;
end
Ce type de boucle est très souvent utilisé pour converger vers une valeur désirée. Par exemple, on veut
trouver le nombre d’entiers positifs nécessaires pour avoir une somme plus grande que 100. On pourrait
réaliser cette tâche de la manière suivante :
function n = nombre_entier
n = 0; % i n i t i a l i s a t i o n des v a l e u r s
somme = 0 ;
w h i l e somme < 100
n=n + 1 ; % i t é r a t i o n de n
somme = somme + n ; % n o u v e l l e somme
end
Exemple :
n = 5;
m = 8;
w h i l e ( n < 10 && m > 0 ) % B o u c l e t a n t que n e s t i n f é r i e u r à 10
% et m est supérieur à 0
n = n + 1; % Incrémente n
m = m − 1; % Décrémente m
disp (n ) ; % Affichage
d i s p (m ) ; % Affichage
end % F i n de b o u c l e
6.5. BOUCLES SWITCH 51
6.5 Boucles switch

Les boucles switch permettent parfois de remplacer les boucles if-elseif-else, particulièrement dans le
cas de menus. Le prototype de ce type de boucle en pseudo-code est le suivant :
D é t e r m i n e r CAS
CAS c h o i s i e s t CAS1
ACTION1
CAS c h o i s i e s t CAS2
ACTION2
AUTREMENT
ACTION3
En MATLAB, on obtient le code suivant :

s w i t c h (CAS )
c a s e {CAS1}
ACTION1
c a s e {CAS2}
ACTION2
otherwise
ACTION3
end
Par exemple, on veut faire une calculatrice simple en MATLAB, pour déterminer l’exponentielle ou le
logarithme en base e d’un nombre entré par l’utilisateur. Une manière simple de rendre le programme
interactif serait d’utiliser le SCRIPT suivant :
o p e r a t i o n = i n p u t ( ’ O p é r a t i o n : ( 1 ) exp ; ( 2 ) l o g ? ’);
nombre = i n p u t ( ’ V a l e u r : ’ ) ;
switch operation
case 1
b = exp ( nombre )
case 2
b = l o g ( nombre )
otherwise
d i s p ( ’ m a u v a i s c h o i x −−o p e r a t i o n ’ )
end
Avec la sortie (par exemple) suivante :

>> c a l c u l _ r a p i d e
O p é r a t i o n : ( 1 ) exp ; ( 2 ) l o g ?
Valeur : 0.5
b =
1.6487
>>
Exemple :
n= i n p u t ( ’ Po u r s a u v e r j a c k t a p e z 1 , % Demande de s a i s i e de l ’ u t i l i s a t e u r
Jessy tapez 2 , Brian tapez 3 : ’ ) ;
switch n
case 1 % Si n vaut 1
d i s p ( ’ J a c k e s t s au v é ’ )
break
case 2
d i s p ( ’ J e s s y e s t s au v é ’ ) % S i n v a u t 2
break
case 3
d i s p ( ’ B r i a n e s t s au v é ’ ) % S i n v a u t 3
break
otherwise
d i s p ( ’ Vous n ’ ’ a v e z s a u v é p e r s o n n e ’ ) % S i n e s t d i f f é r e n t de 1 , 2 , 3
end
Exercice 1
En utilisant la fonction xor de MATLAB, construisez la table de vérité de l’opérateur OU EXCLUSIF.
Exercice 2
On veut comparez le temps de calcul nécessaire à MATLAB avec une boucle for versus le temps nécessaire
avec une opération vectorielle. Pour ce faire, on utilise les commandes tic et toc :
>> t i c
>> OPERATION
>> t o c
MATLAB affiche alors le temps utilisé pour réaliser l’opération. Dans un flchier SCRIPT, efiectuez le
calcul suivant :
et
x(t) =
1 + et
Utilisez le vecteur [0 : 0 : 001 : 1]. Dans un premier temps, solutionnez à l’aide des opérateurs vectoriels.
Ensuite, utilisez la boucle for :
clear x
f o r i =1: l e n g t h ( t ) % i n crém en t dans t o u t l e v e c t e u r t
x ( i ) = exp ( t ( i ) ) / ( 1 + exp ( t ( i ) ) ;
end
Essayez ensuite en mettant la ligne clear x en commentaire.
Exercice 3
Soit l’équation quadratique suivante :
a x2 + b x + c = 0
On désire déterminer, pour des paramètres a, b et c donnés, de quels types sont les racines de x. Il s’agit,
selon la valeur du discriminant, d’afficher à l’utilisateur le type des racines (réelles identiques, réelles dis-
tinctes, complexes). Pour l’affichage, utilisez :
m es s ag e = ( [ ’ Les r a c i n e s de l ’ é q u a t i o n s o n t . . . . ’ ] ) ;
6.6. ENTRÉES / SORTIES 53
Utilisez une fonction qui prend les paramètres a, b et c comme argument et qui renvoie le diagnostic.
Exercice 4
La fonction arctan(x) peut être approchée par :
M
X x2k+1
tan (x) =
−1
(−1)k (|x| < 1)
k=0
2k + 1
On désire savoir le nombre M qui permet, pour une valeur de x donnée, d’approcher avec une erreur
inférieure à 10−6 . Réalisez une fonction MATLAB qui prend comme argument, le nombre x, qui vérifle si
la condition est remplie et, à l’aide d’une boucle while, détermine le nombre d’itérations M. Le programme
doit lancer un message d’erreur si la condition n’est pas remplie.
Exercice 5
La méthode de Newton-Raphson permet de déterminer les racines d’une équation algébrique non-linéaire.
L’algorithme est le suivant :
0. Poser x (0) % d o n n ée i n i t i a l e
1 . T a n t que f ( k ) − 0 p l u s g r a n d qu ’ un c r i t è r e
1 . 1 . C a l c u l e r x ( k +1)= x ( k)− f ( x_k ) / f ’ ( x_k )
1.2. k = k + 1
2. Sortie
À l’aide de cet algorithme, déterminer les racines de l’équation :
2 x − 2x = 0.
Vériflez l’efiet de la donnée initiale sur le nombre d’itérations.
6.6 Entrées / sorties
6.6.1 Utilisateurs
Les commandes suivantes permettent l’interaction avec l’utilisateur lors de l’exécution d’un script.
L’utilisateur peut dans l’exemple ci-dessous saisir un nombre que le script pourra alors utiliser. Dans le
sens inverse la commande disp permet d’afficher des variables à l’utilisateur.
n = i n p u t ( ’ S a i s i s s e z un nombre : ’ ) ; % S a i s i e de l ’ u t i l i s a t e u r
disp (n ) ; % S o r t i e v e r s l ’ a f f i c h a g e Matlab
6.6.2 Disques : Importer et exporter des données
Dans plusieurs cours, il vous sera nécessaire de conserver vos solutions numériques d’une session de
travail à l’autre. La méthode la plus facile est d’utiliser les fonctions save et load de MATLAB. Les flchiers
créés porte l’extension ’.mat’ par défaut (ceux-ci ne sont accessibles qu’avec MATLAB). Pour exporter ou
importer des données sur le disque dur, on utilise les les fonctions commandes suivantes.
s a v e ’D : . . . save . t xt ’ % Sauvegarde l e workspace
l o a d ’D : . . . save . t xt ’ % Ch arg e l e w o r k s p a c e
Voici un exemple d’utilisation simple.

>> A = o n e s ( 3 ) ; % matrice
>> b = z e r o s ( 3 , 1 ) ; % v e c t e u r
>> s a v e m a _ s e s s i o n % l e f i c h i e r m a _ s e s s i o n . mat e s t c r é é d a n s
% le ré pert oi re courant
>> c l e a r
>> whos % l e s v a r i a b l e s ne s o n t p l u s d a n s l a mémoire
>> l o a d m a _ s e s s i o n % On va c h e r c h e r t o u s l e s é l é m e n t s de l a s e s s i o n
>> whos
A 3 x3 72 d o u b l e a r r a y
b 3 x1 24 d o u b l e a r r a y
Il est aussi possible de sauvegarder les variables dans un flchier ASCII et lui donner un format désiré. Elles
pourront ensuite être lues par d’autres logiciels (par exemple, EXCEL) et avec MATLAB (en utilisant aussi
la fonction load). Dans le cas suivant, on ne sauvegarde que la matrice A de l’exemple précédent.
>> s a v e m a _ s e s s i o n . d a t −ASCII A
>> l o a d ma_session . dat
La fonction xlsread permet de charger en MATLAB des flchiers EXCEL.

>> x l s r e a d c l a s s e u r . x l s
Pour plus d’information à ce sujet, vous pouvez consulter help flleformats.

Exercice 6
1. On veut tracer avec MATLAB la fonction
2 +0.5(x−y)2 )
z(x, y) = e−0.5(x
pour x et y entre −4 et 4. A l’aide de deux boucles for imbriquées , calculez la valeur de la fonction
à chaque point du domaine (utilisez des incréments de 0.05 dans les deux directions). Tracez ensuite
la courbe obtenue à l’aide de la fonction mesh(vecteurX, vecteurY, matriceZ). Vériflez l’appel à
cette fonction en tapant help mesh à l’appel MATLAB. Tracez ensuite les mêmes valeurs à l’aide des
fonctions surf(vecteurX, vecteurY, matriceZ) et contour((vecteurX, vecteurY, matriceZ).
2. Sauvegardez la matrice z(x, y) calculez à la question 1. dans un flchier ASCII (.dat). Ouvrez le flchier
à l’aide d’EXCEL.
6.6. ENTRÉES / SORTIES 55
Exercice 7
MATLAB permet de déflnir différentes formes de structures. Une structure associe un nom de variable
(une chaîne de caractère) à la variable dans une cellule (type générique de variable- voir help cell pour plus
d’information). Supposons que l’on utilise la fonction de l’exercice 6 :
2 +b(x−y)2 )
z(x, y) = e−a(x
avec a = 0.5 et b = 0.5 dans l’exercice précédent. On pourrait stocker cet essai dans une seule et unique
variable :
OBJET_ESSAI = s t r u c t ( ’ m a t r i c e ’ , { z } , ’ a ’ , { a } , ’ b ’ , { b } ) % {}: c e l l u l e s
Avec la sortie suivante :

OBJET_ESSAI =
z : [ 1 6 1 x161 d o u b l e ]
a : 0.5000
b : 0.5000
On peut accéder aux différentes variables de cette structure par :

>> OBJET_ESSAI . a
ans =
0.5000
>>
On désire organiser la sauvegarde des variables x, y, z, a et b dans un flchier .mat à l’aide d’une structure.
Créez une forme plus complète de la structure présentée. Sauvegardez ensuite cet objet dans un flchier .mat.

Cours Informatique 3 (Matlab)

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Informatique 3 (Matlab)

Transféré par

Droits d'auteur :

Formats disponibles

Cours du Module AP-45 pour l’Année Préparatoire II

École Nationale des Sciences Appliquées d’Al Hoceima

3 Fichiers SCRIPT et FUNCTION 23

6 Programmation avec MATLAB 47

F IGURE 1.1 – Cette figure montre l’interface du Logiciel Matlab

1.2 Opérateurs de bases où Opérations élémentaires sous MATLAB

1.3 Définitions de scalaires et variables

Remarque 1.3.1 Il très important de prendre en considération que

Un dernier point sur les variables :

F IGURE 1.2 – Définitions de scalaires

– MATLAB fait la différence entre les minuscules et les majuscules.

1.4 Définitions de vecteurs et de matrices

1.5 Création de matrices particulières

1.6 Effacement et liste des variables

Si aucune variable n’est spécifiée, toutes les variables seront effacées.

La commande who affiche les noms de toutes les variables en cours.

1.7 Fonctions sur les scalaires

1.8 Fonctions sur les matrices

1.9 Opérations élément par élément

C(i, j) = A(i, j) + B(i, j)).

1.10 Constantes prédéfinies

Matlab dispose de constantes prédéfinies. En voici la liste :

1.11 Le typage de données

1.12 Fonctions prédéfinies

Voici une liste non exhaustive :

2.1 Définition d’un tableau

où bien, en remplaçant la virgule par des blancs :

2.2 Accès à un élément d’un tableau

2.3 Extraction de sous-tableaux

2.4 Construction de tableaux par blocs

2.5 Opérations sur les tableaux

2.5.1 Addition et soustraction

2.5.2 Multiplication, division et puissance terme à terme

2.5.3 Multiplication, division et puissance au sens matriciel

2.5.4 Listes de valeurs

2.6 Longueurs de tableau

Fichiers SCRIPT et FUNCTION

Le résultat serait le suivant :

3.1 Fichiers SCRIPT et FUNCTION

3.1.1 Fichiers SCRIPT

produit la sortie suivante lorsque qu’appelé :

Habituellement, on utilise les fchiers SCRIPT afin de :

3.1.2 Fichiers FUNCTION

4.1 Les formats d’affichage des réels

4.2 Affichage simple, la commande disp

4.4 Impressions dirigées par format

Modèle d’édition des réels :

5.1 Gestion des fenêtres graphiques

F IGURE 5.1 – Fenêtre graphique et résultat de la commande fplot(’cos’,[0 4*pi]).

fplot(’nomf’, [xmin , xmax])

F IGURE 5.2 – Fenêtre graphique et résultat de la commande fplot(’x*sin(x)’,[-2*pi 2*pi]). Graphe de la

5.2.2 La commande plot

F IGURE 5.5 – Résultat de la commande plot(x,y,’bd’), whitebg.

5.2.3 La commande loglog

F IGURE 5.6 – Résultat de la commande loglog(x,y).

5.3 Améliorer la lisibilité d’une figure

5.3.1 Légender une figure

evolution de la concentration du produit8au cours du temps

F IGURE 5.7 – Résultat de la commande gtext(’concentration maximale’).

5.3.2 Afficher plusieurs courbes dans une même fenêtre

F IGURE 5.8 – Résultat de la commande gtext(’.....’).

cosinus sinus tangente

arc−cosinus arc−sinus arc−tangente

F IGURE 5.9 – Résultat de la commande subplot(m,n,i).

F IGURE 5.2 – Fenêtre graphique et résultat de la commande fplot(’xsin(x)’,[-2pi 2*pi]). Graphe de la