Introduction à Matlab

Matlab est un logiciel de calcul et de visualisation, dont les entités de base sont des matrices :
Matlab est une abréviation de Matrix Laboratory.
Matlab est un langage interprété : il propose des facilités de programmation et de visualisation,
ainsi qu’un grand nombre de fonctions réalisant diverses méthodes numériques.

1- Explorer l’environnement Matlab

Après ouverture, une fenêtre graphique apparaît (suivant les versions de Matlab, elle sera
plus ou moins évoluée mais devrait ressembler à ceci) :

Il est important de se placer dans le répertoire de travail désiré : on pourra y retrouver les fichiers
nécessaires au projet (visibles dans la fenêtre Current folder).

On peut entrer des commandes directement sur la fenêtre principale (Command Window, avec
le prompt >>). Matlab sera prêt à prendre votre commande dès que le mot Ready s’affiche tout
en bas à gauche.

On retrouvera dans le Workspace l’ensemble des variables définies/utilisées dans la fenêtre

principale.

Dans le menu Help (?), on trouvera une multitude d’exemples, démonstrations, des
présentations détaillées associées à chaque fonction, etc.
C’est le premier endroit où vous devez aller voir si vous êtes coincés dans votre projet.

1
 2- Premiers pas

On peut se servir de Matlab comme d’une calculatrice (améliorée). Par exemple, dans la fenêtre
principale de Matlab, après le prompt >>, tentez d’écrire les lignes suivantes les unes après les
autres dans cet ordre (en validant sur la touche Entrée à la fin de chaque ligne) :
a=1
b=5
c=a+b
d=cos(b)
e=pi
format long
e=pi
f=2^4
g=exp(1)
h=log(f)
‘Hello’
help atan
sign (-3)
abs (-3)
round (e)
floor (e)
ceil (e)

Notez qu’on retrouve chaque variable créée dans le Workspace. Attention : Matlab comprend
différemment majuscule et minuscule (a et A renverrons à deux variables différentes).

3- Matrices

Dans Matlab, toutes les variables représentent des matrices. Par exemple, on multiplie deux
matrices a et b avec a*b, et le produit de deux scalaires s’écrit de la même façon : ils sont
interprétés comme des matrices 1x1.
On peut définir une matrice dans Matlab de plusieurs façons :
– par la liste de ses éléments,
– en la générant par une suite d’instructions et de fonctions,
– en la lisant dans un fichier extérieur.
Si l’on représente la touche Entrée de votre clavier par le symbole ←, les instructions suivantes
:

A=[3 2 -2 ;-1 0 1 ;1 1 0] ←
et
A=[ ←

2
 3 2 -2 ←
-1 0 1 ←
1 1 0 ] ←

créent la même matrice 3x3.

Dans la suite, le symbole ← ne sera plus indiqué.

Cette énumération des éléments d’une matrice ou d’un vecteur peut être implicite. Essayez par
exemple :
m=[-3 :3]
x=[1 :-0.25 :-1]

Pour entrer une grande matrice, le plus simple est de l’écrire sur un fichier ; nous utiliserons
cette possibilité ultérieurement.
Certaines fonctions de Matlab créent des matrices particulières. Par exemple rand crée une
matrice aléatoire. Essayez :
b=rand(3,4)
On peut recommencer en faisant suivre la commande d’un point-virgule :
b=rand(3,4);
On constate que cette fois, la variable b n’est pas affichée. Dans la suite, vous essayerez de
penser à faire suivre vos lignes de commandes d’un point-virgule lorsque vous ne souhaiterez
pas voir s’afficher le résultat de ces commandes.
La commande help permet de recevoir des informations (en anglais !) sur une fonction ;
essayez :
help rand
Un coefficient quelconque d’une matrice est référencé par ses indices de ligne et de colonne,
dans cet ordre. Par exemple, l’instruction :
A(1,2)
renvoie la réponse :
ans =
2
ans est le nom d’une variable qui reçoit le dernier résultat d’une instruction ou d’une suite
d’instructions lorsqu’il n’a été affecté à aucune variable.
Les quelques matrices suivantes sont parmi les plus couramment utilisées :
– eye(n) renvoie la matrice identité ; essayez eye(4),
– ones(n,m) renvoie une matrice à n lignes et m colonnes dont tous les coefficients sont des 1,
– zeros(n,m) matrice à n lignes et m colonnes dont tous les coefficients sont des 0 ; elle sert
beaucoup pour les initialisations.
Pour les matrices carrées, il suffit de donner un seul argument à ces fonctions.

4- Opérations usuelles

Matlab propose les opérations usuelles de base pour les matrices comme pour les scalaires :
3
+,*,^ pour addition, multiplication et élévation à une puissance entière. On doit y ajouter la
transposition, désignée par ’(pour les matrices complexes, a’ sera la transposée-conjuguée de
a). Ces opérations sont soumises à la règle de concordance des dimensions. Essayez par
exemple :
rand(3,4)*ones(4,3)
rand(3,4)*ones(3,4)
hilb(3)*eye(4)
hilb(3)*eye(3)
ones (1,4)’*ones(1,4)-ones(4,4)
ones(1,4)*ones(1,4)’-4
Pour les matrices, il existe une version composante par composante de * (resp. ^) notée .*
(resp. .^) ; essayez :
ones(4,4).*ones(4,4)
(2*ones(4,4)).^3
Matlab propose aussi une autre opération : c’est la division, qui est généralisée à la résolution
de systèmes linéaires : les symboles / ou \ définissent cette opération. Essayez :
3/4
3\4
m=rand(5) ;
x= m\ones(5,1);
m*x
y=ones(5,1)’/m;
y*m
Vous constatez que ces opérations doivent se comprendre comme le produit à gauche (resp. à
droite) de la variable à droite du signe \(resp. à gauche de /) par l’inverse de la variable à gauche
du signe \ (resp. à droite de /) : x=m\b fournit la solution du système linéaire m*x=b , c’est-à-
dire x = m−1 b si et seulement si les variables m et b contiennent respectivement une matrice
carrée inversible et un vecteur (matrice uni-colonne) de taille correspondante.

Exercice 1 : Résoudre le système linéaire suivant

5𝑥 + 2𝑦 − 𝑧 = 6
{ 2𝑥 + 7𝑦 = 2
𝑥−𝑦+𝑧 =1

Fonctions vectorielles
Ces fonctions sont plutôt destinées à agir sur des vecteurs, lignes ou colonnes. Citons par
exemple :
max
sum
sort
min

4
 prod
dont vous trouverez l’objet par la commande help.
Elles agissent aussi sur les matrices, mais colonne par colonne. Essayez par exemple :
b=rand(3,3);
c=max(b) ;
d=max(max(b));
b,c,d

Fonctions matricielles
Citons en quelques-unes :
det : déterminant d’une matrice,
eig : valeurs et vecteurs propres d’une matrice,
inv : inverse,
size : dimensions de la matrice,
norm : norme (2 par défaut),
et bien d’autres encore (voir l’aide de Matlab si nécessaire).

Manipulations de matrices
- tril renvoie la partie triangulaire inférieure d’une matrice, éléments diagonaux compris.
- triu renvoie la partie triangulaire supérieure d’une matrice.
- reshape reformate une matrice, c’est-à-dire change le nombre de lignes et de colonnes, en
prennant les éléments colonne par colonne ; essayez par exemple :
A=(rand(3,4))
B=reshape(A,2,6)
- diag extrait la diagonale d’une matrice, sous forme d’un vecteur, ou crée une matrice
diagonale,
à partir d’un vecteur ; essayez par exemple les deux instructions suivantes :
diag(rand(4,1))
diag(rand(4,4))
Essayez de préciser, suivant la forme de a ce que vaudra diag(diag(a)).

L’argument général de diag est double ; entrez help diag . Vous constatez que l’on peut
ainsi extraire d’une matrice ses éléments d’une ”parallèle” à la diagonale. Essayez :
diag(rand(4,4),2) puis diag(ans,2)
On peut donc aussi créer facilement des matrices tridiagonales ; en particulier, les instructions
suivantes vont créer une matrice M que vous retrouverez souvent :
b=ones(4,1); M=2*eye(5)-(diag(b,1)+diag(b,-1))
Elle correspond à la matrice M de discrétisation par la méthode des différences finies du
problème :
−u′′(x) = f(x) avec 0 ≤ 𝑥 ≤ 1
u(0) = α , u(1) = β

5
Matlab permet aussi de manipuler les matrices par blocs. Essayez par exemple :
A = [ones(3,3), rand(3,2)]
ou alternativement
A=[ones(3,3) rand(3,2)]
C = [A ; rand(2,3), eye(2)]

Pour extraire une partie d’une matrice :

D = C( : ,2:4)
sélectionne pour toutes les lignes, les colonnes 2 à 4, et :
E = C(1:1, : )
sélectionne la première ligne uniquement. On peut enlever des lignes ou colonne à l’aide de la
matrice « vide » [], essayez :
C( : ,2:3) = []
C(1:2, : ) = []

5- Fichiers

Matlab peut exécuter une suite d’instructions stockées dans un fichier. On appellera ces fichiers
des m-fichiers, et leur nom doit être suivi du suffixe .m ; vous vous habituerez vite à travailler
sous Matlab essentiellement par l’intermédiaire de tels fichiers. Nous vous demandons de le
faire systématiquement.

Fichiers « scripts »
Un fichier script est un fichier contenant une suite d’instructions Matlab.
Pour créer un tel fichier, cliquez New puis Script.
Une fois que vous aurez écrit les instructions que vous voulez voir exécutées, vous allez
sauvegarder le fichier sous un nom de votre choix, avec le suffixe .m (bouton Save). Attention
à bien placer votre nouveau fichier dans le répertoire de travail sur lequel pointe la fenêtre
principale (voir au début).
Par exemple on peut créer un fichier model.m dans lequel on enregistrera les commandes :
b=ones(5,1); M=2*eye(6)-(diag(b,1)+diag(b,-1));

Apres avoir sauvegardé votre fichier, vous pouvez vérifier que vous obtenez bien cette matrice
en entrant dans la fenêtre principale (>>) les commandes :
model ;
M
On peut aussi exécuter directement un fichier script avec le bouton Run.
On peut enrichir le fichier model.m avec les commandes suivantes (à tester) :
n=input(‘taille de la matrice ?’)
disp(b)
pause(3)

6
Fichiers « functions »
Transformons notre fichier model.m en un fichier de fonction.
Pour cela, on l’édite à nouveau pour le réecrire de la façon suivante :
function M=model(n)
M=2*eye(n)-(diag(ones(n-1,1),1)+diag(ones(n-1,1),-1));
Apres l’avoir sauvegardé, vous pourrez créer une matrice modèle de la taille que vous souhaitez,
par exemple 7, par la simple commande :
M=model(7);

Nous pouvons y joindre des commentaires, avec des lignes qui commencent par le symbole %.
Ce symbole transforme en commentaires tous les caractères qui le suivent dans la ligne
courante. On peut par exemple transformer le fichier comme ceci :
function M = model(n)
% Cette fonction renvoie une matrice carrée
% de dimension n x n.
M=2*eye(n)-(diag(ones(n-1,1),1)+diag(ones(n-1,1),-1));
Ces commentaires sont placés immédiatement après la première ligne (de déclaration). De cette
façon, il constitueront la réponse fournie par Matlab à la commande :
help model

Mat-fichiers
Il est possible de sauvegarder des variables de l’espace de travail en vue d’une utilisation
ultérieure. Cela se fait à l’aide de l’instruction save. Le format le plus simple est le suivant :
save nomfichier X Y Z
Les variables X, Y et Z seront sauvegardées dans un fichier nomfichier.mat. On peut les
retrouver par l’appel :
load nomfichier

Dans la fenêtre principale, essayez par exemple :

save matrices C M
clc
clear C
clear
M
load matrices
M

La flèche vers le haut du clavier permet de revoir l’historique des commandes.

7
 6- Boucles et tests : for, while, if, switch

Condition « switch »

Notons que la suite d’instructions :

x=[] ;n=5 ;
for i= 1 :n
x=[x,i/n]
end ;
x
fournit le même résultat que
x=[1/5 :1/5 :1]
Dans la première expression, on utilise la matrice vide pour initialiser, et une écriture par blocs
pour mettre à jour la matrice uniligne x. Cette première expression est à éviter : l’initialisation

8
par la matrice vide n’alloue pas préalablement de place mémoire pour x, et Matlab va rechercher
la place dont il a besoin à chaque itération. Il faut, chaque fois que vous devez utiliser une telle
boucle, réserver cette place en initialisant vos variables au moyen de matrices zeros(m,n).

L’instruction for permet d’utiliser une matrice quelconque à la place de 1:n. La variable
compteur prendra successivement les valeurs de chacune des colonnes de la matrice utilisée ;
essayez par exemple :
s=0 ; for i=x, s=s+i ; end ; s
b=ones(2,4); v=zeros(2,1); for i=b, v=v+i ; end ; v

Pour tester la rapidité d’une boucle (ou d’un programme) on peut placer les
commandes tic au début et toc à la fin. Matlab affichera le temps écoulé entre ces deux
instructions.

Si une exécution prend trop de temps (Busy est toujours affiché en bas à gauche), on peut
toujours l’interrompre par Ctrl + C.

Exercice 2 : Créer un fichier script qui affiche à l’écran les chiffres de 1 à 100, avec une
temporisation de 1 seconde entre chaque itération, et qui efface de l’écran toutes les 5 itérations.

Exercice 3 : Créer un programme (comportant éventuellement plusieurs fichiers – scripts,

fonctions) qui cherche la valeur de la racine carrée d’un nombre x par dichotomie. On donne
un intervalle initial [0, x], et on cherche successivement les itérations [ai, bi] telles qu’au final
la solution s vérifie x=s². On estimera le temps de calcul en fonction de la précision voulue.

7- Visualisations

Visualisation des fonctions scalaires

Matlab permet de tracer facilement le graphe de fonctions scalaires. Cela se fait à l’aide de la
fonction plot. Elle prend en argument des paires de vecteurs de même dimension. Voici par
exemple le moyen d’obtenir le graphe de la fonction cos 3x sur l’intervalle [0, 2π] :
x=[0 :0.01 :2*pi] ;
y=cos(3*x);
plot(x,y);

Le format de base de la fonction plot est en fait le suivant :

plot(x,y,s);
où x contient les absisses, y les ordonnées, et s est une chaine de 1 à 3 caractères : s=’ct’,
respectivement couleur et tracé, qui peuvent être choisis dans le tableau suivant :

9
Les types de tracé associés à la lettre (c) sont des tracés continus, avec une interpolation entre
les points fournis, alors que pour les autres, ne sont représentés que les points (xi, yi).
On peut tracer les graphes de plusieurs fonctions simultanément. Essayez maintenant :
z=sin(2*x) ;plot(x,y,x,z);
On peut alors légender notre graphique de la façon suivante :
legend(‘cos(3x)’,’sin(2x)’);
Les axes sont définis automatiquement ; on peut choisir les bornes des coordonnées du graphe
à l’aide de la fonction axis . Essayez par exemple :
axis([-1 5 -1.5 1.5])
On peut utiliser hold on pour continuer à tracer des courbes sur le même graphe.
Alternativement, on utilise figure pour changer de fenêtre graphique.

Le format de la fonction plot permet bien sûr de représenter facilement des courbes
paramétriques :
plot(y,z) ;
fournit une courbe connue sous le nom de courbe de Lissajoux. Les instructions suivantes vont
réduire légèrement l’échelle, donner un titre et un nom aux axes, et faire apparaitre un grille sur
le fond :
axis([-1.1 1.1 -1.1 1.1])
title(’Courbe de Lissajoux’);
xlabel(’y : axe des absisses’);
ylabel(’z : axe des ordonnees’);
grid
Vous aurez remarqué que l’argument de la fonction title est une chaine de caractères qui
doit être fournie entre côtes.
On remarque que cette courbe possède des points doubles, et par exemple, on peut en trouver
un dans le rectangle [0.6, 0.8] × [0.4, 0.6]. La fonction gtext va nous permettre d’aller inscrire
un commentaire près de ce point, en le positionnant avec la souris ; essayez la avec :
gtext(’point double’) ;
Si l’on veut rechercher graphiquement les coordonnées de ce point, on va d’abord agrandir
l’échelle autour de ce point :
zoom ;

10
puis utiliser la fonction ginput et se servir de la souris :
[xd,yd]=ginput;
Un couple de valeurs est enregistré à chaque pression sur la souris ; la sélection se termine
lorsque l’on frappe la touche Entrée, puis les valeurs de xd et yd s’affichent dans la fenêtre
principale.

Visualisation des courbes en 3D

La fonction qui permet de représenter une courbe dans l’espace ℝ3 est plot3. Sa syntaxe est
plot3(x,y,z,s);
et cette fois x, y et z sont des vecteurs de même dimension contenant les trois coordonnées.
Essayez :
theta=pi*[-4 :0.04 :4] ;r=linspace(1,6,201);
x=r.*(1+cos(theta)); y=r.*sin(theta); z=r ;
plot3(x,y,z,’k*’); grid ;

Visualisation des surfaces

Matlab permet de représenter des surfaces données en coordonnées cartésiennes ou sous forme
paramétrique. La forme paramétrique peut s’écrire :

où les paramètres s et t parcourent un certain domaine. Deux fonctions permettent cette

représentation :
- mesh qui représente un treillis,
- surf qui représente une surface pleine. Elles ont le même format d’appel :
surf(X,Y,Z,C);
X,Y et Z sont des matrices de mêmes dimensions contenant les coordonnées de points de la
surface.
C permet de définir les couleurs et peut être omis. Nous allons représenter le cône d’équation
x2+y2−2xz = 0 en utilisant la représentation paramétrique donné pour (θ, ρ) ∈ ]−π, π[×] 0, 12[
par :

On peut procéder de la façon suivante :

n=31 ;theta=pi*[-n :2 :n]/n ;r=linspace(0,12,n);
X=r’*(1+cos(theta)); Y=r’*sin(theta); Z=r’*ones(size(theta));
surf(X,Y,Z);
Il est important de remarquer que X, Y et Z sont des matrices de même taille !
La surface représentée laisse apparaitre les traces d’une grille qui la recouvre. L’aspect de la
surface est contrôlé par la variable shading, dont les valeurs possibles sont faceted (valeur
par défaut), flat (supprime le treillis), et interp (adoucit les transitions). Essayez :

11
 shading interp ;
Les couleurs sont définies par une matrice C de même taille que celles des coordonnées, et par
défaut, cette matrice est C=Z, de sorte que d’une certaine façon, la couleur est “proportionnelle”
l’altitude du point de la surface. Tout cela dépend du choix d’une palette graphique. Essayez :
C=rand(size(Z));
surf(X,Y,Z,C);
La palette de couleurs de la fenêtre de visualisation est définie par la variable colormap. Sa
valeur par défault est jet . Essayez :
colormap(’cool’);
La liste des palettes disponibles est fournie avec celle de toutes les fonctions ou variables de
contrôle d’un graphique 3D par la commande :
help graph3d
Notez que les fonctions fill (en 2D) et fill3 (en 3D) vous permettront de tracer des formes
géométriques de couleur.

Examinons à présent le tracé d’une surface donnée par son équation cartésienne z = f(x, y).
En général, on dispose d’une famille de valeurs de x et d’une famille de valeur de y stockées
dans 2 vecteurs, respectivement x et y. On va devoir construire deux matrices X et Y telles que
les colonnes de X et les lignes de Y soient constantes : ces matrices seront utilisées pour le
calcul des valeurs de f. On peut utiliser la fonction meshgrid .
Ainsi, pour représenter la surface d’équation z = exp(−x2 − y2) , −2 < x, y < 2, on pourra procéder
comme suit :
[X, Y] = meshgrid(−2 : .2 : 2,−2 : .2 : 2) ;
Z = X.* exp(−X.^2 − Y.^2) ; surf(Z) ;
Si on ne souhaite que le treillis, on remplace la fonction surf par mesh. Si l’on souhaite des
isolignes, on utilise la fonction contour3 ; par exemple :
v=linspace(0,max(max(Z)),20);
contour3 (Z,v);
Autres fonctions 3D : waterfall, slice, cylinder, sphere…

Il est possible de créer des interfaces graphiques avec guide pour faciliter l’utilisation des
programmes Matlab.

Exercice 4 : Résoudre l’équation différentielle suivante puis tracer l’évolution dans le temps
(de 0 à 10 secondes) de y(t) :
𝑦̇ = 3𝑦 − 𝑦² avec la condition initiale y(0)=1.
Pour cela estimera y(t) sur des pas de temps Δt successifs : y(0), y(Δt), y(2Δt), …, y(10-Δt),
y(10), de la manière suivante : y(t + Δt) = y(t) + Δt. 𝑦̇ (t).
On pourra créer une fonction Matlab f(y) telle que 𝑦̇ = 𝑓.
Comparer avec la solution exacte : 𝑦(𝑥) = 3/(1 + 2𝑒 −3𝑥 ).
Si le temps le permet, on pourra tenter de créer une interface graphique permettant une
résolution généralisée de ce type d’équation.

12
 Table des fonctions Matlab utilisées dans ce tutoriel
avec numéros des pages où elles apparaissent

%, 7 max, 4, 5
abs, 2 mesh, 11
atan, 2 meshgrid, 12
axis, 10 min, 4
ceil, 2 norm, 5
clc, 7 ones, 3, 4
clear, 7 pause, 6
colormap, 12 pi, 2
contour3, 12 plot, 9
cos, 2 plot3, 11
cylinder, 12 prod, 5
det, 5 rand, 3, 4
diag, 5 reshape, 5
disp, 6 round, 2
eig, 5 save, 7
exp, 2, 12 shading, 11
eye, 3 sign, 2
figure, 10 size, 5, 11
fill, 12 slice, 12
fill3, 12 sort, 4
floor, 2 sphere, 12
for, 8 sum, 4
function, 7 surf, 11, 12
ginput, 11 switch, 8
grid, 10, 11 tic, 9
gtext, 10 title, 10
guide, 12 toc, 9
help, 2, 3, 5, 7 tril, 5
hilb, 4 triu, 5
hold on, 10 waterfall, 12
if, 8 while, 8
input, 6 xlabel, 10
inv, 5 ylabel, 10
legend, 10 zeros, 3, 9
linspace, 11, 12 zoom, 10
load, 7

13