Chapitre I: Initiation à Matlab

Prof. BAKKALI Abderrahmane

Département : Physique

Filière : SMP-parcours mécanique S6 Module: Calcul scientifique

Faculté des Sciences Tétouan

2019 -2020
Université Abdelmalek Essaadi
 Initiation à MATLAB
I. Logiciel Matlab :
Matlab est un logiciel de calcul scientifique, dont la base est le calcul matriciel (MATrix LABoratory = MATLAB). C'est
un logiciel interactif, où les instructions peuvent être directement tapées en ligne de commande, ou bien sauvées
dans un fichier (un script).
On peut également utiliser des fonctions (comme en langage C). Le langage est interprété (pas de compilation des
programmes avant exécution), et utilise des bibliothèques de fonctions très nombreuses, ce qui fait de Matlab un
outil puissant permettant d'écrire des programmes scientifiques beaucoup plus rapidement
qu'avec n'importe quel autre langage traditionnel comme le langage C, C++.

I.1. Répertoire de travail

Le répertoire par défaut est en général c:\matlab\work. Pour conserver vos données,
il faut donc changer de répertoire de travail, pour mettre ses fichiers dans un
répertoire personnel. On suppose qu’il existe un disque dur D. Créons un
répertoire de travail TP Matlab sur le disque D :

I.2. Interpréter une ligne de commande

Les instructions sont interprétées dès qu’on a tapé sur « Entrée ».
On peut aussi faire afficher l’aide en ligne générale, via la commande help, qui liste les fonctions
disponibles, par thème.
2
» help
HELP topics:
matlab\general - General purpose commands.
matlab\ops - Operators and special characters.
matlab\lang - Programming language constructs.
matlab\elmat - Elementary matrices and matrix manipulation.
matlab\elfun - Elementary math functions.
matlab\specfun - Specialized math functions.
matlab\matfun - Matrix functions - numerical linear algebra.
matlab\datafun - Data analysis and Fourier transforms.
matlab\polyfun - Interpolation and polynomials.
matlab\funfun - Function functions and ODE solvers.
……………………

I.3. Variables
Dans Matlab, toute variable est une matrice de dimensions m x n, avec m correspond
au nombre de lignes, n correspond au nombre de colonnes,
 scalaire : 1 x 1;
 vecteur ligne : 1 x n;
 vecteur colonne m x 1;
 matrice m x n

3
Un nom de variable doit respecter les règles suivantes :
 commencer par une lettre (a-z ou A-Z)
 avoir au plus 63 caractères
 ne contenir ni blancs, ni caractères de ponctuation, ni caractères accentués,
ni opérateurs arithmétiques (-, +, ...), ...
Matlab fait la différence entre les majuscules et les minuscules.

Exemple :
» a=15  Affichage: a = 15
» SMP1=2*a  Affichage : SMP1 = 30
» SMP2=3*a  Affichage : SMP2 = 45

Matlab traite également les variables complexes ; le nombre complexe i (ou j)

existe par défaut dans l'espace de travail.

% =i1: » sqrt(-1)  Affichage : ans = 0 + 1.0000i

>> z1=5+2i  Affichage z1 = 5.0000 + 2.0000i
>> z2=6+3i  Affichage: z2 = 6.0000 + 3.0000i
>> z3=z1*z2  Affichage : z3 = 24.0000 +27.0000i
>> z4=z3'  Affichage : z4 = 24.0000 -27.0000i (z3’ c’est le transposé de z3)
>> Z5=z3'*z3  Affichage : z5 = 1305
>> z6=abs(z3)^2  Affichage : z6 =1.3050e+003
4
I.4. Format d’affichage dans la fenêtre de commande, double précision
Lorsque l’on met un point-virgule à la fin d’une ligne, le résultat de l’opération n’est pas affiché, mais la commande a
bien été exécutée.
»r=2 ;
% circonférence
» circonf=2*pi*r;  Affichage : circonf= 12.5664
% surface
» surf=pi*r^2;  Affichage : surface =12.5664
% volume d’une sphérique
»volsph=4/3*pi*r^3;  Affichage : volsph = 33.5103

L’affichage par défaut est de 4 chiffres après la virgule, bien que les valeurs numériques soient en double précision.
En double précision, les valeurs sont stockées sur 8 octets et ont au moins 15 chiffres significatifs, soit une précision
de 10-16.
On peut choisir le format d’affichage à l’écran :
» help format
FORMAT Set output format.
All computations in MATLAB are done in double precision.
FORMAT may be used to switch between different output
display formats as follows:
FORMAT Default. Same as SHORT.
FORMAT SHORT Scaled fixed point format with 5 digits.

5
FORMAT LONG Scaled fixed point format with 15 digits.
FORMAT SHORT E Floating point format with 5 digits.
FORMAT LONG E Floating point format with 15 digits.
FORMAT SHORT G Best of fixed or floating point format with 5 digits.
FORMAT LONG G Best of fixed or floating point format with 15 digits.
FORMAT HEX Hexadecimal format.

Exemple:
>> f= cos(pi/3)-sqrt(3)/5  Affichage : f= 0.1536

>> format long

>> f= cos(pi/3)-sqrt(3)/5  Affichage : f = 0.15358983848622
>> format long e
>> f= cos(pi/3)-sqrt(3)/5  Affichage : f = 1.535898384862247e-01

>> format short

>> f= cos(pi/3)-sqrt(3)/5  Affichage : f= 0.1536
>> format short e
>> f= cos(pi/3)-sqrt(3)/5  Affichage : 1.5359e-01

6
II. Opérations sur les vecteurs et matrices
[Link] des vecteurs : Opérations de base
» v=[1 3 5 7 11 13 17 19 23 29] il s’agit d’un vecteur ligne
l’écran affiche: v = 1 3 5 7 11 13 17 19 23 29

Calculer les dimensions d’un vecteur : » s=size(v)  Affichage : s = 1 10

Calculer la longueur d’un vecteur : » l=length(v)  Affichage: l = 10

» v=[1; 3; 5; 7; 11; 13] il s’agit d’un vecteur colonne . L’écran va afficher

v=
1
3
5
7
11
13
Le même résultat peut être obtenu faisant la transposé du vecteur ligne » v=[1 3 5 7 11 13]’
II.2 Opérations sur les matrices
• Opérateurs arithmétiques
+ Addition ; - Soustraction ; * multiplication ; / Division ; \ division à gauche
^ puissance ; ' transposition ou complexe conjugué ; .* multiplication de matrice "point par point"
./ division de matrice "point par point" ; .^ puissance de matrice "point par point"

7
Une matrice est souvent le résultat d’un calcul. Elle peut être définie par une
commande d’affectation simple :
A = [9 1 4 5; 5 6 18 4; 7 2 3 15; 3 7 11 4]
Si on ne termine pas la ligne de commande par le caractère de ponctuation ";"
MATLAB affiche le résultat de l'affectation dans la fenêtre de commande :
A= 9 1 4 5
5 6 18 4
7 2 3 15
3 7 11 4
Cette matrice est maintenant mémorisée dans l'espace de travail MATLAB et
pourra être utilisée durant toute la séance de travail courante. L'instruction who
Donne la liste des variables mémorisées dans l'espace de travail MATLAB.
L'instruction whos donne la liste des variables avec leur taille et leur classe (type)

• Ajouter retrancher une constante:

>> X=A+100  Affichage X=
109 101 104 105
105 106 118 104
107 102 103 115
103 107 111 104
>> Y=A-A  Affichage Y=
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0 8
>> B=[5 3 8 6;10 7 8 10;2 0 4 6;11 3 4 9]  Affichage B =
5 3 8 6
10 7 8 10
2 0 4 6
11 3 4 9
>> y=A+B  Affichage y = 14 4 12 11
15 13 26 14
9 2 7 21
14 10 15 13
• Multiplication et diviser par une constante.
>> X =A*2  X = 18 2 8 10
10 12 36 8
14 4 6 30
6 14 22 8
•Multiplication de matrice.
>> A * B  ans = 118 49 116 133
165 69 176 234
226 80 144 215  Il s’agit d’une vraie multiplication de matrice.
151 70 140 190

•Matrice puissance une constante

>> A^2  ans = 129 58 121 129
213 105 226 335
139 130 238 148  La matrice A à la puissance 2 ( A*A)
151 95 215 224
9
>> A^3  ans = 2685 1622 3342 3208
5029 3640 7105 6215  La matrice A à la puissance 3 ( A*A*A)
4011 2431 5238 5377
4011 2719 5423 5256
•Matrice puissance une matrice
>> A ^ B
??? Error using ==> mpower
At least one operand must be scalar.
Matrix dimensions must agree.
On ne sait pas calculer une matrice carrée puissance une matrice carré

•Mutiplication élément par élément (mode tableau)

Chaque élément de A est multiplié par l'élément correspondant dans B.
On utilise l'opérateur .*
>> X1 = A.*B  X1 = 45 3 32 30
50 42 144 40
14 0 12 90
33 21 44 36
•Division élément par élément (mode tableau)
Chaque élément de A est divisé par l'élément correspondant dans B.
On utilise l'opérateur ./
>> X =A./B  Warning: Divide by zero. X = 1.8000 0.3333 0.5000 0.8333
0.5000 0.8571 2.2500 0.4000
 On remarque que la division par zéro a généré un simple warning. Le 3.5000 Inf 0.7500 2.5000
calcul global est terminé. Les divisions par zéro produisent inf 0.2727 2.3333 2.7500 0.4444
10
•Puissance de n élément par élément (mode tableau)
Chaque élément de A est élevé a la puissance n.
On utilise l'opérateur .^
>> A.^2  ans = 81 1 16 25
25 36 324 16
49 4 9 225
9 49 121 16
• Puissance élément par élément (mode tableau)
Chaque élément de A est élevé à la puissance de l'élément correspondant dans B.
On utilise l'opérateur .^
>> X = A.^B  X = 1.0e+010 *
0.0000 0.0000 0.0000 0.0000
0.0010 0.0000 1.1020 0.0001
0.0000 0.0000 0.0000 0.0011
0.0000 0.0000 0.0000 0.0000

•Fonction de Matlab: zeros & ones

la fonction zeros produit une matice de zeros, ones produit une matrice de 1.
Il faut préciser les dimensions lors de l’appel de la fonction. Par exemple zeros(n) produit une matrice carré de
dimension n et zeros(m,n) produit une matice de m linges et n colonnes.
» zeros(3,3)  Affichage : ans = 0 0 0
0 0 0
0 0 0
» ones(3,8)  Affichage : ans = 11111111
11111111
11111111 11
III. Opération & Instructions de contrôle
III.1 Operateurs de comparaison
Ces opérateurs sont essentiellement utilisés avec les instructions if else, while
== est égal à ; ~= est différent de ; > supérieur à ;
< inférieur à ; >= supérieur ou égal à <= inférieur ou égal à
Exemple: (if, else, end)
if a == b
faire quelque chose
else
faire autre chose
end Calcul de la factorielle d’un nombre
III.2. Instructions de contrôle entier
>> n = 4;
• Boucles « for » : Affichage M = 2 3 4 nfac = 1;
>> for i = 1:4 5 6 7 for k = 1:n
for j = 1:3 10 11 12 nfac = nfac*k;
M (i,j) = i^2 + j; 17 18 19 end
end >> nfac
end Choix en cascade lors d'initialisation
• Instructions conditionnée « if » d’une matrice
La structure générale de “if” et “else” est la suivante: if numex == 1
if expression logique 1 A = ones(n);
instructions A elseif numex == 2
elseif expression logique 2 A = magic(n);
elseif numex == 3 | numex == 4
instructions B
A = rand(n);
else else
instructions C error('numero d''exemple non prevu ...');
12
end end
 Calcul de la factorielle d’un
• Boucles « while » nombre entier
>> while (expression) >> n = 4;
{Instructions} k = 1; nfac = 1;
end while k <= n
nfac = nfac*k;
 Pour stopper une boucle en cours d’exécution k = k+1;
end
en utilise l’instruction: « Ctrl C »
>> nfac

•switch: pour effectuer un choix

en cascade Initialiser la matrice A en fonction de la
switch var
variable prise par numex:
casecst1,
switch numex
séquence d'instructions 1
case 1,
casecst2,
A = ones(n)
séquence d'instructions 2
case 2,
...
A = magic(n);
casecstN,
case {3,4},
séquence d'instructions N
A = rand(n);
otherwise
otherwise
séquence d'instructions par défaut
error('numero d''exemple non prevu ...');
end
end

13
III.3. Interruption d’une boucle de contrôle

beak : Une sortie prématuré d’une boucle for ou while est possible en utilisant l’instruction beak. L'exécution se poursuit alors
séquentiellement à partir de l'instruction suivant le mot clé end fermant la boucle.

return : Permet de quitter une fonction ou le programme principale avant sa fin normale.

error : L'instruction error permet d'arrêter un programme et d'afficher un message d'erreur. La syntaxe est error(' message
d''erre’).

warning : L'instruction warning permet d'afficher un message de mise en garde sans suspendre l'exécution du programme. La
syntaxe est warning(' message de mise en garde ').

14
IV. Scripts & fonctions
IV.1. Scripts
Un script (ou M-file) est un fichier (question.m par ex) contenant des instructions matlab
% ce programme affiche un message
clear all;
reponse = input ('fait-il beau? (y/n)', 's');
if (reponse=='y')
fprintf ('vous êtes de bonne humeur \n');
else
fprintf ('vous êtes de mauvaise humeur \n');
end
IV. 2. Fonctions
On peut écrire des fonctions Matlab que l’on peut ensuite appeler dans un script
ou directement dans l’espace de travail
Exemple
function imax = index_max(vecA)
% fonction qui calcule l’indice de la valeur maximale d’un vecteur
% utilisation : i = index_max (vecteur)
[a,ia] = max (vecA);
imax = ia;
>> help index_max
fonction qui calcule l’indice de la valeur maximale d’un vecteur
utilisation : i = index_max (vecteur)
>> vec = [1 5 6 3 5 2];
>> i = index_max (vec)  i=3
15
•Fonction anonyme
Une fonction anonyme est une fonction MATLAB qui est définie directement, sans la création préalable d'un fichier
spécifique. La fonction est dite anonyme, parce qu’elle n’a pas de nom explicite
Le symbole @ permet la matérialisation de cette création de fonction anonyme.
le symbole @, est un handle, c'est-à-dire un pointeur vers une fonction.

La syntaxe générale pour définir une fonction anonyme est :

Variable_stockant_la_fonction = @(argument1, argument2, ....) expression_de_la_fonction

Exemple:
Fonction calculant le carré d’une valeur ou d’un tableau
carre = @(x) x.^2;

V. Les indices et l’opérateur ‘: (deux points)’

A(i,j) est l'élément situé à la ligne i et à la colonne j
>> A(2,3)  l’écran affiche 18
>> A(2,2)  l’écran affiche 6
>> A(3,3)  l’écran affiche 3
L'opérateur ":" est fondamental sous MATLAB, il permet de définir une suite d'éléments.
En l'utilisant dans les indices, on peut accéder à une partie d'une matrice.
>> 3:10  l’écran affiche: ans = 3 4 5 6 7 8 9 10
>> 0:0.5:4  l’écran affiche: ans =
0 0.5000 1.0000 1.5000 2.0000 2.5000 3.0000 3.5000 4.0000
>> 12:-2:2  l’écran affiche : ans = 12 10 8 6 4 2
16
>> A(1,2:4) (dans la première ligne, on affiche les valeurs du deuxième, troisième
et quatrième colonnes. : 1, 4 et 5
>> A(2,2:4)  6 18 4
>> A(3,2:4)  2 3 15
>> A(4,2:4)  7 11 4
>> A(1,:) : affiche toutes les valeurs de la première ligne  Résultat : 9 1 4 5
>> A(2,:)  5 6 18 4
>> A(3,:)  7 2 3 15
>> A(4,:)  3 7 11 4
>> A(:,1) : affiche toutes les valeurs de la première colonne: 9
5
7
3

A(:,2)  1 A(:,3)  4 A(:,4)  5

6 18 4
2 3 15
7 11 4

Si on essaye d'utiliser un élément en dehors de la matrice, il se produit une erreur :

>> A(7,2)  ??? Index exceeds matrix dimensions.

D'un autre coté, si on définit un nouvel élément de la matrice en de hors de la taille initiale, la matrice est redimensionnée pour
inclure le nouvel élément, les éléments non définis sont complétés par des zéros :

17
 >> A(3,7) = 10 >> A(3,8) = 15
A= 9 1 4 5 0 0 0 A= 9 1 4 5 0 0 0 0
5 6 18 4 0 0 0 5 6 18 4 0 0 0 0
7 2 3 15 0 0 10 7 2 3 15 0 0 0 15
3 7 11 4 0 0 0 3 7 11 4 0 0 0 0
On peux retrouver facilement notre matrice originale en utilisant l’instruction : A(:,1:4)
>> A=A(:,1:4)
A= 9 1 4 5
5 6 18 4
7 2 3 15
3 7 11 4
On peut aussi accéder à plusieurs éléments non adjacents
>> A([1 3],[2 4]) Ligne 1 et 3 puis colonnes 2 et 4 : Résultats ans = 1 5
2 15
VI. Concaténation, transposée et fonctions pour les matrice et vecteur
>> X=[A A] >> X=[A A A]
X = X=
9 1 4 5 9 1 4 5 9 1 4 5 9 1 4 5 9 1 4 5
5 6 18 4 5 6 18 4 5 6 18 4 5 6 18 4 5 6 18 4
7 2 3 15 7 2 3 15 7 2 3 15 7 2 3 15 7 2 3 15
3 7 11 4 3 7 11 4 3 7 11 4 3 7 11 4 3 7 11 4

18
>> X = [A; A] >> X = [A; A;A]  X=
X= 9 1 4 5
9 1 4 5 5 6 18 4
5 6 18 4 7 2 3 15
7 2 3 15 3 7 11 4
3 7 11 4 9 1 4 5
9 1 4 5 5 6 18 4
5 6 18 4 7 2 3 15
7 2 3 15 3 7 11 4
3 7 11 4 9 1 4 5
5 6 18 4
7 2 3 15
3 7 11 4
VI.1. Transposition : les lignes devienent des colonnes
La transposition d’une matrice est obtenue à l'aide du caractère de ponctuation '
>> C=A'  C=
9 5 7 3
1 6 2 7
4 18 3 11
5 4 15 4
VI.2. Fonction de sommation ‘sum’ et transposé
La fonction sum calcule la somme colonne par colonne, mais dans le cas où la matrice se réduit
à un vecteur ligne, elle calcule la somme de tous les éléments du vecteur :
>> X=sum(A)  X = 24 16 36 28 ; >> Y = sum(X)  Y =104
Pour transformer un vecteur ligne en vecteur colonne et vice versa, il suffit de transposer :
>> Z=X'  Z = 24; 16; 36; 28
19
Pour calculer la somme lignes par lignes, il suffit de transposer avant d'utiliser la fonction sum :
>> C=A'  C =
9 5 7 3
1 6 2 7
4 18 3 11
5 4 15 4
>> XX=sum(A’)  XX = 19 33 27 25
VI.3 Fonctions Diag, triu & tril
Cette fonction retourne une colonne contenant la diagonale d'une matrice
A=
9 1 4 5
5 6 18 4
7 2 3 15
3 7 11 4
>> Vp=diag(A)  Vp = 9
6
3
4
>> H=diag(A)'  H=9 6 3 4
La fonction MATLAB triu avec comme argument la matrice originale seule, génère une nouvelle matrice qui a la même diagonale
principale que A et les même valeurs situées au dessus de cette diagonale, avec des 0 partout ailleurs. La fonction triu(A,k) est une
matrice qui a la même taille et les mêmes éléments que A qui sont situés sur et au dessus de la kième diagonale;
on complète la nouvelle matrice obtenue avec des 0.

20
 >> A4=triu(A) A4 = >> A5=triu(A,-1)  A5 =
9 1 4 5 9 1 4 5
0 6 18 4 5 6 18 4
0 0 3 15 0 2 3 15
0 0 0 4 0 0 11 4
>> A6=triu(A,-2)  A6 =
9 1 4 5 >> B1=tril(A)  B1 =
5 6 18 4 9 0 0 0
7 2 3 15 5 6 0 0
0 7 11 4 7 2 3 0
>> A7=triu(A,-3)  A7 = 3 7 11 4
9 1 4 5 >> B2=tril(A,+1)  B2 =
5 6 18 4 9 1 0 0
7 2 3 15 5 6 18 0
3 7 11 4 7 2 3 15
3 7 11 4
>> B3=tril(A,+2)  B3 = >> B4=tril(A,-1)  B4=
9 1 4 0 0 0 0 0
5 6 18 4 5 0 0 0
7 2 3 15 7 2 0 0
3 7 11 4 3 7 11 0

VI.4. Les fonctions fliplr et flipud

Ces deux fonctions permettent de retourner une matrice de gauche à droite
ou de droite à gauche :
Fliplr : intervertit de la gauche vers la droite ; flipud : intervertit de haut en bas. 21
 >> A1=fliplr(A) A1= >> A2=flipud(A)  A2 =
5 4 1 9 3 7 11 4
4 18 6 5 7 2 3 15
15 3 2 7 5 6 18 4
4 11 7 3 9 1 4 5

VI.5 Fonctions ones et zeros

Les fonctions zeros et ones permettent de générer des matrices remplies avec des zéros ou des uns.
>> X = zeros(4)  X= >> X = ones(4)  X=
0 0 0 0 1 1 1 1
0 0 0 0 1 1 1 1
0 0 0 0 1 1 1 1
0 0 0 0 1 1 1 1
>> X=zeros(4,6)  X =
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
VI.6 Fonctions length & size
La fonction length retourne la longueur d'un vecteur (ligne ou colonne) et la fonction size retourne la dimension d'une
matrice: A= 9 1 4 5 V=[ 1 2 3 4]
5 6 18 4
7 2 3 15
3 7 11 4
>> L=length(V)  L = 4,
>> size(A)  ans = 4 4 22
 VI.7 Fonctions min, max & fix
Les fonctions min et max retournent le plus petit et le plus grand élément d'un vecteur.
>> min(A)  ans = 3 1 3 4
>> max(A)  ans = 9 7 18 15
Fonction fix
La fonction fix retourne la partie entière d'un nombre
>> A3=A+0.00125
 A3= >> fix(A3)  ans = 9 1 4 5
9.0013 1.0013 4.0012 5.0012 5 6 18 4
5.0012 6.0012 18.0012 4.0012 7 2 3 15
7.0012 2.0013 3.0013 15.0013 3 7 11 4
3.0013 7.0012 11.0013 4.0012

VI.8 Fonction reshape

Pour redimensionner une matrice, On utilise la fonction reshape() :
A= 9 1 4 5 >> B2=reshape(A,8,2) 
5 6 18 4 B2 =
7 2 3 15 9 4
3 7 11 4 5 18
>> B1=reshape(A,2,8) 7 3
B1= 3 11
9 7 1 2 4 3 5 15 1 5
5 3 6 7 18 11 4 4 6 4
2 15
7 4
23
 VII. Opérateur logiques
Ces opérateurs sont utilisés avec des grandeurs logiques. Une grandeur logique peut avoir
deux valeurs: true ou false. Les grandeurs numériques peuvent aussi être manipulé comme
logique: tout ce qui est différent de 0 est true, 0 = false
& ET logique --> (a & b) est varie si a est vraie ET b est vraie
| OU logique ; ~ NON logique ; xor OU exclusif
Exemple: if, elseif else, else, end
if a == b & b > c
faire les devoirs d’analyse
elseif
faire les devoirs d’électronique
else
faire les devoirs de mécanique
end
• Opérateurs logique de court-circuit
&& similaire à & sauf que le 2ème opérande n'est évalué que si le premier est vrai
|| similaire à | sauf que le 2ème opérande n'est évalué que si le premier n’est pas vrai
Dans beaucoup de cas, ceci va éviter des messages d'erreur. Par exemple, si la variable
x n'existe pas et le programme rencontre:
if x > 0
y = log(2x);
end
Le programme va générer le message d'erreur ??? Undefined function or variable 'x'
On peut éviter le message d'erreur comme suit:
if exist('x') && x > 0
y = log(2x);  La variable x ne sera comparée à 0 que si elle existe
end 24
VIII. Graphismes
VIII.1 Plot
La fonction plot est utilisée pour tracée des courbes en 2 dimensions. plot est utilisable avec des vecteurs
et des matrices.
Vecteurs de même taille: Annotation d’une figure:
>> x=0:0.1:1;
>> f=x.^2;
>> plot(x,f)
>> grid
>> title("dessiner une figure")
>> xlabel("axe des abscices")
>> ylabel("axes des ordonnées")

Tracer la fonction f(x):

>> x=0:0.1:1;
>> f=x.^2;
>> plot(x,f)
>> grid

25
 Affichage de plusieurs graphiques sur une même fenêtre

On peut afficher plusieurs courbes sur un même graphique en utilisant hold on

hold off: est pour arriter l’affichage sur le meme graphique.

VIII. 2 subplot
L’idée générale est de diviser la fenêtre graphique en pavés de même taille, et d’afficher un graphe dans chaque pavé. On utilise
l’instruction subplot en lui spécifiant le nombre de pavés sur la hauteur, le nombre de pavés sur la largeur, et le numéro du pavé
dans lequel on va tracer : subplot (Nbre pavés sur hauteur, Nbre pavés sur largeur, Numero pavé). La virgule peut être omise. Les
pavés sont numérotés dans le sens de la lecture d’un texte :
de gauche `a droite et de haut en bas :

Exemple:

subplot(2,2,1)  1 2  subplot(2,2,2)
subplot(2,2,3)  3 4  subplot(2,2,4)

Pour revenir à la 1ère fenêtre, effacer la fenêtre, puis fermer toutes les fenêtres :
» figure(1)
» clf
» close all

26
%Exemple1:
%définir l'intervalle et le pas
t=-1.5:0.01:1.5;
% calcul de la fréquence
w1=1/3; 1
% calcul de la fonction f1, f2 et f3 f1
0.5
f1=sin(2*pi*w1*t); f2
f2=cos(2*pi*w1*t);

f1,f2
0
f3= tan(2*pi*w1*t);
subplot(2,1,1) -0.5
plot(t,f1,'k')
xlabel('t') -1
-1.5 -1 -0.5 0 0.5 1 1.5
ylabel('f1,f2')
t
grid; 16
x 10
hold on 2
plot(t,f2,'m')
subplot(2,1,2) 1
plot(t,f3,'r')
xlabel('t')
f3
0
ylabel('f3')
grid; -1

-2
-1.5 -1 -0.5 0 0.5 1 1.5
t

 Avec la commande hold, on maintient le stylo graphique sur la fenêtre, alors que hold off
le relève. La commande hold seule fait passer d'un état à l'autre. Pour afficher plusieurs
graphiques dans une même fenêtre, on utilise subplot de la façon suivante :
27
Exemple
t=-10:0.1:10; w1=3/2; x=(1+cos(2*pi*w1*t))/2; y=exp(t/3) ;
subplot(2,2,1) ; plot(t,x,’r’) ; grid ; xlabel('t en secondes') ; ylabel('x') ;
title(['x(t)=(1+cos(2\pi w1 t))/2, w1 = ',num2str(w1),' rad/s'])
subplot(2,2,2) ; plot(t,y,’b’) ; grid ; xlabel('t en secondes'); ylabel('y'); title('y(t) = exp(t/3)');
subplot(2,2,3) ; plot(t,x.*y,’k’) ; grid ; title('p(t)=x(t)y(t)') ; xlabel('t en secondes'); ylabel('p(t)')
subplot(2,2,4) ; plot(t,x./y,’g’) ; grid ; title('d(t)=x(t)/y(t)') ; xlabel('t en secondes'); ylabel('d(t)')
x(t)=(1+cos(2 w1 t))/2, w1 = 0.5 rad/s y(t) = exp(t/3)
1 1

0.5 0.5
x

y
0 0
-10 -5 0 5 10 -10 -5 0 5 10
t en secondes t en secondes
p(t)=x(t)y(t) d(t)=x(t)/y(t)
1 30

20
p(t)

d(t)
0.5
10

0 0
-10 -5 0 5 10 -10 -5 0 5 10
t en secondes t en secondes 28
 x(t)=(1+cos(2 w1 t))/2, w1 = 1.5 rad/s y(t) = exp(t/3)
1 1

0.5 0.5
x

y
0 0
-10 -5 0 5 10 -10 -5 0 5 10
t en secondes t en secondes
p(t)=x(t)y(t) d(t)=x(t)/y(t)
1 30

20
p(t)

d(t)
0.5
10

0 0
-10 -5 0 5 10 -10 -5 0 5 10
t en secondes t en secondes

Les 4 figures de la fenêtre peuvent être vues comme les 4 éléments d'une matrice 2x2,
numérotés de 1 à 4 en suivant les lignes de gauche à droite.

29
VIII.3. Affichage graphique en 3D (surfaces)
Pour afficher des surfaces dans une fenêtre graphique, voir les fonctions de help graph3d.
On ne présente ici que les fonctions les plus courantes.
On veut représenter sous forme d'une surface les valeurs prises par une fonction de deux
variables x et y. Par exemple, on veut évaluer la fonction z(x,y), en fonction des deux variables
x et y, cette fonction étant définie par z(x,y)= xy.
En choisissant une grille de points espacés de 1, on devra évaluer z pour tous les couples de
coordonnées possibles .
La fonction meshgrid permet d'obtenir ces points :
x=-10:20 800 800

y=-10:20 600 600

[X,Y]=meshgrid(x,y) 400 400

Z=X.^2+Y.^2 200 200

subplot(2,2,1) 0
20
0
20

mesh(X,Y,Z) 10 20 10 20
10 10
0 0 0 0
subplot(2,2,2) -10 -10 -10 -10

surf(X,Y,Z)
subplot(2,2,3) 20

contour(X,Y,Z)
15

10

0
0 5 10 15 20

30
Exemple : Evaluer cette fonction sur une grille de points espacés de 0.1 avec x  [-1,2]
et y  [-1,2] .

x=-1:0.1:2;
y=-1:0.1:2;
1
%fréquence en Hz
f=1.0
%pulsation 0
w=2*pi*f
[X,Y] = meshgrid(x,y); -1
Z=cos(w*X/2).*sin(w*Y/2); 2
2
1
subplot(2,1,1) 0 1
0
mesh(X,Y,Z); -1 -1
subplot(2,1,2)
surf(X,Y,Z);
 Pour avoir une surface pleine, en utilise la fonction surf(X,Y,Z)
subplot(3,1,3)
contour(X,Y,Z); 1

-1
2
1 2
0 1
0
-1 -1

31
La fonction contour permet d'afficher les lignes de niveau : contour(X,Y,Z)

1
0
-1
2 2
1 1
0 0
-1 -1

1
0
-1
2 2
1 1
0 0
-1 -1
2

-1
-1 -0.5 0 0.5 1 1.5 2

32
IX. Interpolation
Une interpolation consiste à relier des points expérimentaux par une courbe formée de segment
de droites ou de courbes polynomiales. Ceci est réalisé par la fonction interp1. la commande
interp1(x,y,z) retourne un vecteur de mêmes dimensions que z dont les valeurs correspondent
aux images des éléments de z déterminés par interpolation sur x et y.
f=interp1(x,y,z,’type’)
La chaine ‘type’ spécifie un type d’interpolation parmi les suivants :
‘linear’ : interpolation linaire.
‘spline’ : interpolation par splines cubiques
‘cubic’ : interpolation cubique

SMP_TP7.m %interpolation par splines cubiques

%y=cos(x);On peux tester par la fonction cos(x) figure(2)
%y=tan(x);On peux tester par la fonction tan(x) f=interp1(x,y,z,'spline');
y=x.^2;% On peux tester par une fonction polynôme plot(x,y,'-',z,f);
xlabel('x')
%pas du vecteur z inférieur à celui de x. ylabel('x^2')
z=-pi:pi/10:pi grid;
%interpolation linéaire title('interpolation pas splines cubiques');
figure(1)
f=interp1(x,y,z); %interpolation cubiques
%tracé des valeurs réelles et de la courbe d'interpolation figure(3)
plot(x,y,'o',z,f); f=interp1(x,y,z,'cubic');
xlabel('x') plot(x,y,'--',z,f);
ylabel('x^2') xlabel('x')
grid; ylabel('x^2')
title('interpolation linéaire'); grid;
title('interpolation cubiques');
33
 interpolation lineaire interpolation pas splines cubiques
10 10

9 9

8 8

7 7

6 6

x2
5
x2

4 4

3 3

2 2

1 1

0 0
-4 -3 -2 -1 0 1 2 3 4 -4 -3 -2 -1 0 1 2 3 4
x interpolation pas cubiques x
10

6
x2

0
-4 -3 -2 -1 0 1 2 3 4
x 34
X. Exercices d’application: Systèmes linéaires
Exercice 1
Tout système linéaire peut être représenté sous forme matricielle. La résolution d'un tel système
fait appel à la notion d'inverse d'une matrice. 4 x  5 y  8 z  12


Considérons le système d'équations suivant  x  2 y  3 z  8
2 x  y  z  2

Ce système peut être écrit sous une forme matricielle: AX = B, avec:

4 5  8  12   x
A 3  B 
X  
 1 2  8  y
  
  1 
  2 
2 1   z 
Résoudre ce système d'équations, il faut trouver X tel que AX = B.
MATLAB permet de résoudre ce problème en écrivant les instructions suivantes:
A = [4 5 -8;-1 2 3;2 1 -1]; B = [12 ;8 ;-2];
X = inv(A)*B
On obtient comme résultat:
X=
-3.2444
3.6444
-0.8444
Remarque :
On peut aussi utiliser la commande MATLAB X = A\B pour retrouver les mêmes
valeurs propres de X.
35
Exercice 2:
Résoudre les systèmes d'équations ci-dessous en utilisant la commande X=inv(A)*B Et X=A\B
4 x  5 y  8 z  w  2t  12
 x  2 y  3 z  3w  5t  8
4 x  5 y  8 z  w  12 
4 x  5 y  12  
  x  5 y  2 z  w  8  2 x  y  z  6 w  t  2
 x  2 y  8 2 x  y  z  2 w  0  x  2 y  z  w  t  3
 

3 x  y  2 z  w  2t  1

36
 Graphisme
Ex4:
Ex3: créations de boucles
t = 0:pi/50:10*pi;
t=0:0.01:3.5; c='rgbmck:';
plot3(sin(t),cos(t),t,'linewidth',2)
close all;hold on;
grid on
for i = 1 : length(c)
axis square
plot(t,i*sin(i*t),c(i));
xlabel('sin(t)');
end;
ylabel('cos(t)');
grid;
zlabel('t')
8

6
40
4
30
i*sin(i*t),c(i)

0 20

t
-2 10

-4
0
1
-6 0.5 1
0
-8 0
0 0.5 1 1.5 2 2.5 3 3.5 -0.5
t cos(t) -1 -1
sin(t)

37
 mesh(x, y, z)

Ex5: Fonction meshgrid

[x,y] = meshgrid(-5:0.2:5); 4
r = sqrt(x.^2 + y.^2) + eps;
3
z = sin(pi*r) ./ r;
close all; 2

z
mesh(x, y, z); 1
figure; 0
meshc(x, y, z);
-1
figure; 5
meshz(x, y, z); 5
0
0
-5 -5
y x
meshc(x, y, z)
meshz(x, y, z)

4
4
3
3
2
2
z

z
1
0
0
-1
5 -1
5 5
0 5
0
0
-5 0
-5
y x -5 -5
y x 38
Ex5: Fonction meshgrid (suite) 4

[x,y] = meshgrid(-5 : 0.2 : 5); 3

r = sqrt(x.^2 + y.^2) + eps;
2
z = sin(pi*r) ./ r;

z
close all; 1
surf(x, y, z); 0
xlabel('x');
ylabel('y'); -1
5
zlabel('z'); 5
figure; 0
0
surf(x, y, z,'FaceColor','interp','FaceLighting','phong','EdgeColor','none');
-5 -5
daspect([5 5 5]) y x
axis tight
view(-50,30)
camlight left
xlabel('x');
ylabel('y');
zlabel('z');
3
2

z
1
0
5
5

0
0

y -5 -5 x
39
Ex5: fonctions avec subplot
% affichage des quatre figures dans une seule fenêtres
%définir la base du temps avec un pas de 0.1 par exemple
t=-5:0.1:5;
% définir la fréquence
w1=0.5;
% fonction x(t)=(1+cos(2*pi*w1*t))/2
x=(1+cos(2*pi*w1*t))/2; x(t)=(1+cos(2 w1 t))/2, w1 = 0.5 rad/s y(t) = exp(t/3)
% fonction y(t)=exp(-abs(t/3)) 1 1
y=exp(t/3) ; %figure(2)
subplot(2,2,1)
plot(t,x) ; grid ; xlabel('t en secondes'); 0.5 0.5

y
ylabel('x')
title(['x(t)=(1+cos(2\pi w1 t))/2, …
w1 = ',num2str(w1),' rad/s'])
subplot(2,2,2) 0 0
-5 0 5 -5 0 5
plot(t,y) ; grid ;
t en secondes t en secondes
xlabel('t en secondes')
ylabel('y') p(t)=x(t)y(t) d(t)=x(t)/y(t)
1 4
title('y(t) = exp(t/3)')
subplot(2,2,3) 3
% tracé de la fonction p(t)=x(t)*y(t)
p(t)

d(t)
plot(t,x.*y) 0.5 2
grid
title('p(t)=x(t)y(t)') ; xlabel('t en secondes') ; 1
ylabel('p(t)') ;
0 0
subplot(2,2,4) -5 0 5 -5 0 5
% tracé de la fonction d(t)=x(t)./y(t) t en secondes t en secondes
plot(t,x./y) ; grid ; title('d(t)=x(t)/y(t)')
xlabel('t en secondes') ; ylabel('d(t)')
40
Ex7: allure d'un polynôme tracé polynôme de K(x)
6
x=0:0.001:4;
r=[1 2 3];
4
K=poly(r);
y=polyval(K,x); 2
plot(x,y)
xlabel('x')

K(x)
0
ylabel('K(x)')
title('tracé polynôme de K(x)') -2
Grid
-4

-6
0 0.5 1 1.5 2 2.5 3 3.5 4
x

41
Problème à résoudre:

42
43
44
 Un aperçu de quelques fonctions de MATLAB

[] Énumération d’éléments
: Descripteur d’éléments de vecteur/matrice
() Ensemble d’arguments
, Séparateur d’arguments
; Séparateur des lignes dans les matrices , supression du résultat de l’évaluation d’une instruction

’ Transposition de matrice
. Force l’opérateur à s’appliquer sur chaque élément du vecteur/matrice
% Délimitateur de commentaire
... Continuation de l’instruction sur la ligne suivante

45
Fonctions signification
plot Représentation graphique plane
loglog Représentation plane logarithmique
semilogx somilogy Représentation plane en semilog

polar Représentation en coordonnées polaires

mesh Représentation graphique en trois dimensions
contour Contour plot
title Titre de la figure
xlabel Titre de l’axe des abscisses
ylabel Titre de l’axe des ordonnées
gtext Positionne la souris sur du texte
ginput Donne les coordonnées d’un point
axis Changement d’axe
hold Maintient la figure à l’écran
shg Montre la figure à l’écran
clg Efface la figure
subplot Subdivise la fenêtre de graphe
text Ecrit du texte sur la figure
grid Cadrille la figure
46