Département de Mathématiques

Licence Mathématiques Appliquées

Prise en main de Matlab

Année Universitaire 2016-2017

M. Er-Riani

1
 Préface

Cette initiation à Matlab a pour objectif de familiariser les étudiants avec un outil puissant et
fréquemment utilisé dans le secteur de l’industrie et de la recherche.

Le succès actuel de Matlab vient de sa simplicité de prise en main et d’utilisation. De plus, il

existe des boîtes à outils (toolbox) optionnelles mais très utiles dans certains domaines comme le
traitement d’images, la statistique, l’automatique (Simulink), etc.

L’objectif principal de ce cours est de :

- Prendre en main l’environnement logiciel : visualisation (présentation détaillée des fonctions de
tracé, graphe D, graphe 3D), environnement de programmation (scripts, fonctions,
éditeur/débogueur etc.)
- Passer en revue les principales fonctionnalités (toolbox) de ce logiciel.

La première partie permet d’assimiler les éléments de base de syntaxe Matlab pour la
manipulation de variables, de fichiers et de graphiques. La dernière partie sera dédiée à la
résolution de quelques problèmes courants d’analyse numérique.

2
 Sommaire
I. Introduction
I.1. Préliminaires
I.2. Utilisation des menus
II. Nombres complexes
II.1. Variables spéciales et constantes
II.2. Format de nombres
II.3. Ecriture de nombres complexes
II.4. Opérations arithmétiques
III. Vecteurs et tableaux à une dimension
III.1. Ecriture d’un vecteur
III.2. Opérations sur les tableaux
IV. Chaînes de caractères
V. Matrices ou tableaux à deux dimensions
V.1. Ecriture d’une matrice
V.2. Opérations sur les matrices
V.3. Construction de matrices particulières
VI. Polynômes
VII. Programmation avec Matlab
VII.1.Opérateurs booléens
VII.2. Instructions de contrôle
VII.3. Fichiers Matlab
VII.4. Recommandations générales
VIII. Graphiques
VIII. 1. Graphiques (2D)
VIII. 2. Graphiques (3D)
IX. Applications
IX.1. Analyse numérique
IX.2. Probabilités et statistiques
X. Pages web et bibliographie

3
I. Introduction
I.1. Préliminaires
Matlab est une abréviation en anglais de « MATrix LABoratory ». Matlab est un logiciel
interactif et convivial de calcul numérique, calcul matriciel et de visualisation (graphiques 2D,
3D). Tous les objets en jeu sont des matrices, y compris les scalaires (matrice 1x1) :
Matlab est maintenant une référence au niveau mondial, non seulement dans les universités et
instituts de recherche, mais aussi dans le milieu industriel.
Il est utilisé en deux modes :
i) Mode interactif
Possibilité de réaliser rapidement des calculs et de présenter les résultats sous forme numérique
ou graphique.
ii) Mode programmation
Possibilité d’écrire des scripts (programmes, fonctions). Ceci permet l’extensibilité de Matlab.

Matlab s’enrichit au fur et à mesure, grâce aux toolbox (boites à outils) spécialisées. Ces boîtes à
outils sont constituées d’un ensemble de fonctions programmées à partir des fonctions de base de
Matlab. On peut citer les toolbox suivantes :
1. Optimization toolbox
2. Spline toolbox
3. Partial Differential Equations toolbox (2D + temps)
4. Statistics toolbox
5. Symbolic mathematics toolbox (Calcul formel avec Maple) et bien d’autres encore.
Description de quelques toolbox :
Toolbox statistics
- Probability distributions
- Descriptive statistics
- Linear models
- Hypothesis tests
- Nonlinear regression models
- Multivariate statistics
- Statistical plots

4
Toolbox system identification
- AR models
- ARMA models
Toolbox opimization
- Minimisation
- Moindres carrées
- Programmation linéaire
Signal Processing Toolbox
- Génération et prétraitement d’un signal
- Filtrage numérique et analogique
- Analyse spectrale
En plus des différentes toolbox, Matlab possède l’outil Simulink, permettant la simulation des
systèmes dynamiques au moyen d’une interface graphique évoluée.
Un autre atout de Matlab est sa portabilité, c’est à dire qu’un programme Matlab peut être utilisé
sur différents systèmes d’exploitation (Unix, Ms Windows, etc.) sans aucune modification.
En plus on n’a pas besoin de déclarer le type de variable que l’on manipule.
I.2. Utilisation des menus
a) Menu help
On a trois façons d’appeler l’aide en ligne :
i) Dans la fenêtre des commandes à la suite de l’invite >>, taper : help nom de commande
Par exemple : >> help log
LOG Natural logarithm.
LOG(X) is the natural logarithm of the elements of X. Complex results are produced if X is not
positive.
See also LOG2, LOG10, EXP, LOGM.
ii) Si à la suite de l’invite >>, on tape help, on obtient :
help topics (help par catégories):
matlab\general - General purpose commands.
matlab\ops - Operators and special characters.
matlab\lang - Programming language constructs.
matlab\elmat - Elementary matrices and matrix manipulation.

5
matlab\elfun - Elementary math functions.
matlab\specfun - Specialized math functions, etc.
iii) Dans le menu Help de la fenêtre des commandes, il y a un help navigator avec un sommaire
sur les fonctions de Matlab (classées par ordre alphabétique) ainsi qu’un outil de recherche par
mots clés.
b) Commande lookfor
Lookfor item : permet de chercher toutes les fonctions Matlab contenant le mot ‘item’.
Exemple : >> lookfor identity
EYE Identity matrix.
SPEYE Sparse identity matrix.
c) Menu edit
Edition des commandes : Les flèches  ,  , → ,  , permettent de restaurer les commandes
précédentes et de rectifier d’éventuelles erreurs :
 : instructio n précédente

 : instructio n suivante
 : aller vers la gauche de la commande
→ : aller vers la droite de la commande
Dans le menu edit, il y a les fonctions :
Clear command history : efface l’historique des flèches
Clear command window : (clc )efface l’affichage à l’écran
De même si on tape :
clear all : efface toutes les données
clear x : efface la variable x
close all : ferme toutes les figures
clf : efface la figure courante
d) Menu des M-files
Dans les fichiers.m, on a plusieurs menus, en particulier le menu Debug et Breakpoints qu’on
utilise pour le débogage d’une partie d’un programme, en faisant un breakpoint (point d’arrêt).
Par exemple les commandes :
Step F10 : débogage ligne par ligne
Step in F11 : débogage fin ligne par ligne (en entrant dans les sous programmes)

6
e) Commandes who, whos
who : donne la liste des variables
whos : donne la liste des variables avec leurs attributs (taille, occupation mémoire, etc..)
f) Affichage des résultats
On évite l’affichage du résultat en tapant un point-virgule à la fin d’une commande. Pour
certaines commandes (help, plot, ls, etc.) cela ne change rien.
g) Ecriture de commentaires
Il est important de pouvoir écrire des commentaires lors de l’élaboration d’un programme. Ainsi,
sur une ligne tout ce qui est écrit après le symbole % sera non lu.
h) Affichage d’une phrase
La commande disp('phrase à afficher') affiche à l’écran la phrase « phrase à afficher ».
II. Nombres complexes
II.1. Variables spéciales et constantes
Dans Matlab, on trouve des constantes prédéfinies :
pi : 3.1416
eps : 2.2204 e-16 (distance entre 1 et le flottant le plus proche). Ainsi par exemple : 1+eps = 1.
Notation : L’écriture aeb, a et b réels, signifie a*10b
inf : nombre infini
nan (not a number) : exprime une indétermination
ans (answer) : variable contenant la dernière réponse.
realmax : le plus grand nombre à virgule flottante (1.7977e+308)
realmin : le plus petit nombre positif à virgule flottante (2.2251e-308).
II.2. Format de nombres
Il y a plusieurs façons d’écrire un nombre réel.
format short (4 chiffres après la virgule) : pi = 3.1416
format long (14 chiffres après la virgule) : pi = 3.141592653589793
format short e : écriture sous la forme a eb , a avec format short : 151/3 =5.0333e+001
format long e : a avec format long : 151/3 = 5.033333333333334e+001
format bank : unité avec deux décimales : 151/3 = 50.33
format rat : donne le rationnel le plus proche par défaut : 11.3251 = 5991/529

7
II.3. Ecriture des nombres complexes
Le nombre complexe i est noté indifféremment i ou j. Ainsi le nombre complexe z = a + bi, ou a
+ bj (sans *) donne comme réponse a + bi. Des fonctions sont prévues pour le calcul de la partie
réelle real(z), de la partie imaginaire imag(z), du module abs(z), de l’argument angle(x) et du
conjugué complexe conj(x).
II.4. Opérations arithmétiques
Outre l’addition (+), la soustraction (-), la multiplication (*), il y a la division à droite (\) et la
division à gauche (/). Ainsi : a / b signifie a est divisé par b, et a \ b signifie b est divisé par a.
III. Vecteurs ou tableaux à une dimension
III.1. Ecriture d’un vecteur
Un vecteur ligne est introduit de deux façons :
>> v = [1,2.01, 3.5, pi]
ou bien :
>> v = [1 2.01 3.5 pi]
Un vecteur colonne est introduit en remplaçant les virgules ou les espaces par des points virgules
ou des retours de chariot.
>> w = [1 ; 2.01 ; 3.5 ; pi]
L’accès aux composantes d’un vecteur s’effectue directement par des commandes du genre :
>> v(3)
ans = 3.5000
On peut augmenter la taille d’un vecteur en tapant par exemple ;
>> v(7) = -1
v = 1.0000 2.0100 3.5000 3.1416 0 0 -1.0000
Ainsi les composantes intermédiaires sont considérées nulles.
Remarque : Dans Matlab les indices de vecteurs et de matrices sont des entiers > 0. L’indice 0
n’est pas permis.
Les dimensions d’un tableau sont calculées par la commande size (v).
>> size (v)
ans = 1 7
La longueur d’un tableau est égale à sa plus grande dimension.
>> length (v)

8
ans = 7
On peut définir d’autres tableaux en rajoutant des composantes à droite ou à gauche. Par
exemple.
>> u1 = [2, v]
>> u2 = [v, –6.1]
On peut définir un vecteur ligne par une subdivision d’un intervalle d’un pas constant :
>> v = début : pas : fin ;
Si le pas n’est pas déclaré, Matlab prend par défaut un pas de 1. De même on peut construire un
vecteur par la commande linspace (début, fin, N) respectivement logspace (début, fin, N) qui
donne N points espacés linéairement respectivement logarithmiquement entre deux extrémités.
Si N n’est déclaré, Matlab prend par défaut N = 100 dans le cas linéaire, et 50 dans l’autre cas.
fin − début
Remarque : Les écritures = début : pas : fin et linspace (début, fin, N + 1), ( N = )
pas

sont similaires.
III.2. opérations sur les vecteurs
L’addition et la soustraction se font élément par élément. Les dimensions doivent être les mêmes.
Sinon on reçoit le message d’erreur : matrix dimensions must agree.
De même on peut ajouter, soustraire, multiplier ou diviser un vecteur par un nombre.
Exemple : >> x = [1, 2, 4, 5] ;
>> y = [0, 1, -1, 5.1] ;
>> x + y
ans = 1.0000 3.0000 3.0000 10.1000
>> 1+ y
ans = 1.0000 2.0000 0 6.1000

La transposé d’un vecteur x (ligne ou colonne) s’écrit x’ ;

Les opérations .* , . / , . \ , et .  sont des opérations de Hadamard (élément par élément). Ainsi :

>> x. *y

ans = 0 2.0000 -4.0000 25.5000

9
Plusieurs opérations sur les vecteurs sont disponibles dans Matlab. Par exemple :
sum(x) : somme des composantes de x
prod(x) : produit des composantes de x
sqrt(x) : vecteur dont les composantes sont les racines carrées des composantes de x
min(x) : plus petite composante de x
max(x) : plus grande composante de x
>> sqrt(y)
ans = 0 1.0000 0 + 1.0000i 2.2583
IV. Chaînes de caractères
Toute chaîne de caractère alphanumérique est représentée par un tableau à une ligne et un nombre
de colonnes égal à sa longueur.
Exemple : >> ch1 = ‘père’ ;
>> size(ch1) ;
ans = 1 4
On peut concaténer plusieurs chaînes en utilisant les commandes strcat (concaténation
horizontale) strvcat (concaténation verticale). Exemple:
>> ch2 =’mon’;
>> ch3 = strcat(ch2 , ch1)
ans = monpère
>> ch4 = strvcat(ch2,ch1)
ans = mon
père
Remarques :
i) La commande strcat(ch2 , ch1) s’écrit simplement [ch2 , ch1].
ii) Quand il y a une apostrophe dans une chaîne de caractères, il faut la dédoubler. Exemple
>> t = ‘ graphe d’’une fonction’
ans : t = graphe d'une fonction
>> length(t)
ans = 21
L’espace est considéré comme un caractère.

10
V. Matrices ou tableaux à deux dimensions
V.1. Ecriture d’une matrice
Une matrice est construite de différentes manières :
a) Par des nombres séparés de virgules (ou espaces) et point virgules :
A = [ 5 , 2 , 1, 3 ; 6 , 8 , 3 , 1; 0 , 1 , 2 0 ]
et l’affichage donne :
5 2 1 3
6 8 3 1
0 1 2 0
>> size(A)
ans = 3 4
b) Si on définit préalablement les vectrices lignes v1, v2 et v3 :
>> v1 = [5, 2, 1, 3] ;
>> v2 = [6, 8, 3, 1] ;
>> v3 = [0, 1, 2, 0] ;
A = [v1 ; v2 ; v3] ;
c) Par des vecteurs colonnes :
>> v1 = [5 6 0]’ ; v2 = [2 8 1]’ ; v3 = [1 3 2]’ ; v4 = [3 1 0]’ ;
>> A = [v1, v2, v3, v4]
On accède directement aux éléments de la matrice en utilisant la commande:
>> A(2 , 3)
ans = 3
Les commandes :
A( : , 3) : affiche la 3e colonne de A
A(2 , : ) : affiche la 2e ligne de A
A( : , [2 , 3]) permet l’accès aux colonnes 2 et 3
A([1 , 2] , : ) permet l’accès aux lignes 1 et 2
De même l’affichage d’une sous matrice s’obtient par la commande : A( [1 , 2 ] , [2 , 3])
La taille (resp. la longueur) d’une matrice est donnée par la commande size(A) (resp. length(A)).
Remarque : on définit un tableau vide en écrivant : >> A = [ ] ;

11
V.2. Opérations sur les matrices
i) Transposition : La transposée d’une matrice A s’écrit A’.
ii) Addition et soustraction de deux matrices
L’addition et soustraction de deux matrices de mêmes tailles se fait élément par élément.
iii) Produit de deux matrices
Soit A une matrice (n, p) et B une matrice (p, q), alors le produit matriciel s’écrit A*B. Si le
produit ne peut pas avoir lieu, alors on a le message d’erreur : ?? Error using ==> *
Inner matrix dimensions must agree.
On peut donc définir les puissances successives d’une matrice carrée par l’opération 
iv) Opérations de Hadamard
Les opérations produit respectivement puissance, divisions à gauche et à droite, des matrices de
mêmes tailles se fait élément par élément et sont notées .* , .^ , . / et .\
v) Inversion d’une matrice carrée
L’inverse d’une matrice carrée A est donnée par la commande inv(A).
Le déterminant de A est défini par la commande det(A).
vi) Valeurs propres et vecteurs propres
La commande [V, D] = eig (A) donne : V= liste des vecteurs propres (eigenvalues)
D = liste des valeurs propres (eigenvectors)
vii) Autres commandes
size(A) : donne les dimensions de la matrice A
trace(A) : donne la trace de la matrice A
spy(A) : permet de représenter les matrices de grandes tailles.
rank(A) : donne le rang de la matrice.

expm(A) : renvoie l'exponentielle matricielle de A.

norm(A) : renvoie la norme 2 de la matrice A.
norm(A,inf) : renvoie la norme infinie de la matrice A.
V.3. Construction de matrices particulières
Les routines :
i) ones (m, n) donne une matrice dont les éléments sont tous égaux à 1.
ii) zeros (m, n) donne une matrice dont les éléments sont nuls. Cette commande est souvent
utilisée pour initialiser une matrice à m lignes et n colonnes.
iii) eye (n) donne la matrice identité n x n.

12
iv) Soit V un vecteur, n  Z, alors diag(V , n) définit une matrice dont la ne diagonale est V.
Ainsi diag(V , 0) est la matrice diagonale dont les éléments sont donnés par V.
v) Les commandes :
- rand(m,n) est une matrice n x m dont les éléments sont distribués de manière aléatoire uniforme.
- randn(m , n) est une matrice n x m dont les éléments sont distribués normalement.
VI. Polynômes
Un polynôme est représenté dans Matlab par un tableau de dimension 1 formé par les coefficients
classés dans l’ordre des puissances décroissantes.
i) Ainsi le polynôme P = x3 - 5x2 + 4, est défini par :
>> P = [1 , 0 , -3 , 2] ;
ii) les racines de P sont calculées par la commande roots :
>> roots(P)
ans = -2.0000 1.0000 1.0000
iii) L’évaluation d’un polynôme en un point est donnée par la commande polyval.
>> polyval(P , 2)
ans = 4
iv) On peut déterminer un polynôme à partir de ses racines en utilisant la commande poly.
>> racines = [0, 1 , 3] ;
>> P1 = poly(racines)
P1 = 1 -4 3 0
Ainsi roots(P) = racines.
v) Multiplication et division de polynômes
La multiplication est donnée par la commande conv.
>> P2 = conv (P, P1)
P2 = 1 -4 0 14 -17 6 0
La division euclidienne est déterminée par la fonction deconv
>> [Quotient, Reste] = deconv (P, P1)
Quotient = 1
Reste = 0 4 -6 2
vi) La commande polyfit(x, y, n) calcule le polynôme de degré n qui interpole les données, p(x(i))
= y(i), au sens des moindres carrés.

13
VII. Programmation avec Matlab
VII.1. Opérateurs booléens.
Les opérateurs booléens sont de deux sortes (relationnels ou logiques).
Le résultat d’un test prend la valeur 1 pour Vrai et 0 pour Faux.
VII.1.1. Opérateurs relationnels
Il s’git des opérateurs de comparaison. Ils sont au nombre de six.
inférieur à : <, inférieur ou égal : < =, supérieur à : >, supérieur ou égal : > =
egal à : = =, différent de :  =
VII.1.2. Opérateurs logiques
Il s’agit des opérateurs et, ou et non :
et (and) : & , ou (or)  , non (not) : 
Exemples :
>> t = (0 < 1)
ans : t = 1
>> t =  ((0 < 1) & (0 == 0))
ans : t = 0
Il existe d’autres opérateurs booléens, par exemple xor (ou exclusif), isfinite,isinf, isnan, any, all.
Ainsi, si X est une matrice, all(X) retourne un tableau de même longueur que X formé de 1 et 0. 1
si toutes les composantes de chaque colonne sont non nulles, 0 si au moins une est nulle.
De même isfinite(X) retourne une matrice de même taille que X formé de 1 et 0. 1 si la
composante est un nombre fini, 0 si elle vaut inf, -inf, nan.
xor(A , B) (A et B de même taille) retourne 1 si une des composantes de A ou B, est nulle mais
pas les deux , 0 dans le cas contraire.
Exemple :
>> X = [1, 2, 3, 4; 4, 5, 6, -inf; inf, 8, 0, nan];
>> all(X)
ans = 1 1 0 1
>> isfinite(X)
1 1 1 1
1 1 1 0
0 1 1 0

14
VII.2. Instructions de contrôle
VII.2.1. Syntaxe du test (if)
On a les cas suivants :
i) if expression booléenne ii) if expression booléenne
instructions instructions (si les conditions sont vérifiées)
end else
instructions (conditions non vérifiées)
end
De manière plus générale :
iii) if expression booléenne
instructions
elseif
instructions
…….
else
instructions
end
Exemples :
1) if rem(n , 2) == 0
disp(‘nombre pair’)
else
disp(‘nombre impair’)
end
rem : retourne le reste de la division de deux nombres
disp : affiche le message sous forme d’une chaîne de caractères
2) if moyenne >=16
disp('mention trés bien')
elseif moyenne >=14
disp('mention bien')
elseif moyenne >=12

15
 disp('mention assez bien')
elseif moyenne >=10
disp('mention passable')
else
disp('mention ajourne(e)')
end
VII.2.2. Syntaxe de branchement (switch)
L’instruction switch permet une sélection multiple dans un programme. Sa syntaxe est :
switch expression (expression est un scalaire ou une chaîne de caractères)
case valeur1
instructions (instructions effectuées si expression = valeur1)
case valeur2
instructions
…..
otherwise
instructions
end
VII.2.3. Syntaxe de boucle (while et for)
Les instructions de boucle ont la syntaxe suivante :
i) while expression ii) for indice = début:pas:fin
instructions instructions
end end
Remarque: si le pas n’est pas précisé, par défaut il vaut 1.
Exemples :
i) n = 5 ; x = [ ] ; for i = 1:n , x = [x , i^2 ]; end
ans : x = 1 4 9 16 25
ii) nmax = 5 ; x = 2 ; n = 0;
while n <= nmax , disp(x^n ); n = n+1; end
ans : 1 2 4 8 16 32
Il y a d’autres commandes liées aux boucles (voir break, return, continue).

16
VII.3. Fichiers Matlab
Dans Matlab, il y a deux types de fichiers : fichiers de données et les fichiers M-file (scripts ou
fonctions). Tous ces fichiers doivent se terminer par le suffixe .m.
VII.3.1. Fichiers de données
Les fichiers de données d’extension .mat permettent de restituer et de sauvegarder les données.
Ces opérations sont réalisées par les commandes save et load.
Exemple :
>> t = [1, 2, 3] ;
On peut sauvegarder la variable t dans le fichier tfich en tapant la commande :
>> save tfich t
Le fichier sera sauvegardé sous le nom de tfich.mat
>> clear all
>> t;
??? Undefined function or variable 't'.
>> load tfich
>> t
ans : t = 1 2 3
VII.3.2. Fichiers script
Un fichier de commande (script file) est un fichier ASCII d’extension .m (M-file) contenant une
suite de commandes Matlab. Il est exécuté directement en tapant son nom dans l’espace de travail
(workspace), ou en l’éditant et en sélectionnant run.
VII.3.3. Fichiers fonctions
Les fonctions dans Matlab sont des fichiers M-file.
La syntaxe est la suivante :
function [arguments de sortie] = nomfonction (arguments d’entrée)
instructions
où les arguments de sortie respectivement d’entrée peuvent être de n’importe quel type.
instructions : est un bloc d’instructions quelconques affectant les arguments de sortie.
Lorsqu’il y a un seul argument de sortie, on écrit simplement :
function args = nomfonction (arguments d’entrée)
instructions

17
L’appel à la fonction s’opère de la façon suivante :
[vars1, vars2, vars3,…] = nomfonction (vare1, vare2, vare3,….)
avec compatibilité des variables vare1, vare2, vare3,…. avec les arguments d’entrée.
Remarques :
i) Les fonctions de base prédéfinies dans Matlab ont la même syntaxe.
ii) Il n’est pas obligatoire de fournir tous les arguments d’entrée et de sortie lors de l’appel d’une
fonction. Ceux que l’on omet doivent être les derniers des listes d’entrée ou de sortie.
On peut écrire : vars1 = nomfonction (vare1)
Alors que l’écriture : vars2 = nomfonction (vare2), n’est pas admise.
iii) On peut fabriquer une fonction en ligne en utilisant la commande inline. La syntaxe est :
inline (expression, arg1, arg2 ,…)
Ceci fournit une fonction dont les arguments d’entrée sont arg1, arg2,…
Exemple :>> f = inline('1./(x.^2-2*x-4)');
>> a = [1 2 3];
>> f(a)
ans : -0.2000 -0.2500 -1.0000
iv) Les variations du nombre d’arguments d’entrée peuvent être gérées par le concepteur de la
fonction en utilisant la commande nargin.
Exemple : function c = test( a , b)
if (nargin ==1)
c = a^2
elseif (nargin ==2)
c=a+b
end
VII.3.4. Fonctions mathématiques

Matlab connaît les fonctions mathématiques standards, qui peuvent s'appliquer à des vecteurs ou
matrices (dans ce cas on applique la fonction aux éléments).

1. les fonctions trigonométriques: sin, cos, tan, asin, acos, atan

2. les fonctions exponentielles: exp, log, log2, log10, sinh, cosh

18
 3. D’autres fonctions mathématiques sont incorporées dans Matlab comme : abs(x) valeur
absolue de x, sign(x) signe de x, angle(z) argument de z
4. Les fonctions d'arrondis sont:
round(x) : entier le plus proche de x
floor(x) : arrondi par défaut (partie entière de x)
ceil(x) : arrondi par excès
fix(x) : arrondi par défaut un réel positif et par excès un réel négatif.
Autres fonctions : factor isprime primes, gcd (pgcd) lcm (ppcm)

VII.4. Variables globales

La notion de variable globale permet de rendre visible des variables d’un script à l’autre.
Par défaut toutes les variables sont locales. Pour déclarer de façon globale la variable varg, on
introduit l’instruction : global varg dans les deux scripts.
VII.5. Recommandations générales
Il est recommandé :
- de sauvegarder les fonctions sous le même nom que le fichier.
- d’insérer des commentaires dans les fichiers script et fonctions (un commentaire est un
texte précédé de %). Ces commentaires seront accessibles à l’aide en ligne.
- de n’écrire qu’une seule fonction par fichier, car seule la fonction qui porte le nom sera
accessible lors d’une procédure d’appel.
- de valider par des tests toutes les procédures pouvant être intégrées dans un programme
principal.
- de n’utiliser des variables globales que dans le strict minimum.
- de ne pas passer en paramètres les tailles des tableaux.
VII.6. Exemples :
i) Fichier fonction
function [moyenne, ecarttype] = stat(x)
% La fonction stat calcule la moyenne et l’écart type d’un échantillon
n = length(x) ;
moyenne = sum(x)/n ;
ecarttype = sqrt(sum((x-moyenne).^2)/n);

19
ii) Fichier script
Dans un M-file en tant que programme, on veut construire un programme qui calcule la moyenne
pondérée.
% Programme de calcul de la moyenne pondérée d’un échantillon
clear all
format long
global lambda
% lambda est le vecteur de pondération
lambda = [lambda1, lambda2, ….lambdan] ;
x = [x1, x2, ….xn] ;
% x est l’échantillon
moyp = sum(x.*lambda)/sum(x)
VIII. Graphiques
VIII.1. Graphiques 2D
VIII.1.1. Coordonnés cartésiennes
La commande plot(x, y, ‘options’) permet de tracer des courbes ou nuages de points du vecteurs
y en fonction de x. x et y doivent être de même longueur.
Les options sont de trois sortes (couleur, tracé discontinu, tracé continu).
couleur tracé discontinu tracé continu
b bleu . point - trait continu
g vert o cercle : pointillés
r rouge x croix -. trait-point
y jaune * étoile -- trait-trait

Pour voir les autres options, taper help plot.

Remarques
- Si aucune option n’est déclarée, le type de tracé est par défaut de couleur noire, de trait
continu.
- Un nuage de points est obtenu par la commande plot(x, y, ‘s’) à condition de prendre
s = +, x, etc.
D’autres instructions sont disponibles dans Matlab. On peut citer par exemple :

20
 - La commande grid réalise un quadrillage du tracé. grid off supprime le quadrillage du
graphique courant.
- La commande title ajoute un titre au graphique. La syntaxe est : title (‘texte du titre’).
- Les commandes xlabel, ylabel permettent de définir des titres pour les axes des
coordonnées. Elles s’écrivent : xlabel (‘texte axe x’).
- On peut rajouter un texte explicatif à plusieurs endroits d’un graphique. La commande est
donnée par : text(1,-3,’courbe de f(x)’). Cette commande place la chaîne de caractères
’courbe de f(x)’ aux points de coordonnées (1, -3)
- Il est possible de placer un texte à un endroit d’un graphique choisi par l’utilisateur à
l’aide de la souris grâce à la commande gtext : gtext(‘graphe de f’).
- On peut tracer plusieurs courbes dans un même graphique grâce à l’instruction :
plot(x1 , y1 , s1 , x2 , y2 , s2 ,.....)
- La commande hold on ou hold off offre ou supprime la possibilité de tracer plusieurs
courbes dans le même graphique.
- La commande subplot(m , n , p) subdivise la fenêtre graphique en m x n zones de petits
axes, et sélectionne la pe zone pour le graphique courant.
- Il est de plus recommandé de consulter la documentation MATLAB (ou l’aide en ligne)
pour les commandes axis, figure, legend, semilogx, colormap, etc. ainsi que figure. Cette
dernière instruction permet de spécifier le numéro de la fenêtre graphique dans laquelle le
tracé doit être effectué.
Exemple :>> x =-2*pi : pi/100 : 2*pi; >> y = sin(x);
>>x =-pi : pi/100 : pi;
>> y1= sin(x1).*exp(x1) + 5;
>> plot(x , y ,’r’)
>> hold on
>> plot(x1 , y1 ,’b’)
>> title('courbes de deux fonctions')
>> xlabel('abscisse')
>> ylabel('ordonnée')
>> grid
>> gtext('courbe de la fonction sinus')

21
 >> gtext('courbe d’’une sinusoïde amortie décalée’)

Figure I

Figure II
VIII.1.2. Courbes paramétriques
La procédure est la même que pour le cas cartésien.
Exemple : Voir Figure II

22
>> t=-100:0.1:100;
>> x = t./ (1+ t.^4); y = t.^2./(1+ t.^4);
>> plot(x,y)
>> grid
>> title('courbe paramétrique')
VIII.1.3. Graphiques en coordonnée polaires
La syntaxe polar(theta, r , ‘options’) définit un graphique en coordonnées polaires
Exemple : Voir Figure III
>> theta=-pi:0.1:pi; >> r = 1+cos(2*theta);
>> polar(theta , r , 'b')
>> title('Rosace à trois lobes')

Figure III
VIII.1.4. Diagrammes statistiques
i) Le tracé d’un histogramme se fait par la commande :
hist(x , N) = trace les valeurs de x en N classes.
Exemple : Voir Figure IV
>> x = rand(100,1) ; >> hist(x , 20)
>> grid
>> title('histogramme d''une répartition de nombres aléatoires')

23
ii) La commande bar(x, y) dessine un diagramme sous forme des barres de y en fonction de x
Exemple : Voir Figure V
>>x = 3:0.2:3;>> y = exp(-x.*x),
>> bar(x, y);
>> grid
>> title('diagramme des valeurs d''une fonction')
iii) La commandes stairs(x, y) trace les valeurs discrètes de y en fonction de x sous forme de
marche en escaliers. (Voir Figure VI)
iv) Le diagramme en bâtons est donné par la commande stem(x, y). (Voir Figure VII)

Figure IV

24
Figure V

Figure VI

25
 Figure VII
VIII.2. Graphiques 3D
VIII.2.1. Courbes 3D
Le tracé dans l’espace se fait à l’aide de l’instruction plot3 (x, y, z,’options’).
Les options sont les mêmes qu’en 2D et elles sont facultatives. plot3 comme plot permet de tracer
plusieurs graphiques dans la même fenêtre avec la commande :
plot3(x1, y1, ‘options1’, x2, y2, ‘options2’,.....)
ou avec les commandes hold on, hold off. On défint de la même façon les commandes xlabel,
ylabel , zlabel , gtext , etc.
VIII.2.2. Surfaces
Pour tracer une surface, on introduit la commande meshgrid qui génère un maillage, ensuite on
utilise mesh pour tracer la surface.
Exemple : On veut tracer la surface d’équation : z = x2 - y2.
>> x = -10:0.1:10; y = -1:0.1:1;
>> [X, Y] = meshgrid(x, y);
>> Z = X.^2 - Y.^2;
>> mesh(X, Y, Z)
Matlab propose d’autres commandes pour tracer des surfaces voir meshc, surf, surfc, surfl,

26
 Figure VIII
VIII.2.3. Contours
Pour les isovaleurs d’une fonction, on utilise la commande : contour3 (x, y, z, N).
N = nombre de lignes de niveaux.
La commande contour(x, y, z, N) donne la projection de la surface sur le plan (ox , oy)
VIII.2.4. Volumes et surface de révolutions
VIII.2.4. 1. La commande cylinder
La génération d’une surface de révolution d’axe oz se fait à l’aide de la commande :
Cylinder (r, N), où r est la courbe génératrice qui représente les variations du rayon. Le cylindre a
possède N points équidistants autour de sa circonférence.
>>theta = -2*pi:0.1:2*pi; r = sin(2*theta).*exp(-0.1*theta) + 1;
>> [x, y, z] = cylinder(r, N);
>> surf(x, y, z)

27
 Figure IX

Figure X

28
VIII.2.4. 2. Sphères
La commande [x, y, z] = sphere(N) génère 3 matrices carrées (N+1) x (N+1), x, y, z qui
représente la sphère unité.
La commande surf(x, y, z) produit le graphique de la sphère.
VIII.2.4. 3. Volumes
La commande slice offre la possibilité de tracer des plans de coupe d’un volume. La syntaxe est :
slice (X, Y, Z, X1, Y1, Z1, N)
X, Y, Z : coordonnées de points générés par un maillage à l’aide de la commande meshgid
X1, Y1, Z1 : plan de coupe suivant les différents axes.
N = longueur de x
Exemple : >>x = -1 :0.1 :1 ; >> y = -2 :0.1 :2 ; z = y ;
% génération du volume
[X ,Y , Z] = meshgrid(x , y , z);
% Plan de coupe
>> X1, Y1, Z1
>> slice (X, Y, Z, X1 , Y1 , Z1 , length(x))
IX. Applications
IX.1. Analyse numérique
IX.1.1. Intégration numérique
La commande quad évalue numériquement les intégrales selon la méthode de Simpson
b
q = quad (‘f’, a , b) donne une valeur approché de  f ( x) dx .
a

Dans le cas des fonctions définies par la commande inline, on peut procéder, comme dans
l’exemple suivant :
>> f = inline('1./(x.^2-2*x-4)');
>> q = quad(f,0,1)
ans : q = -0.2152
Pour les intégrales doubles et triples voir les commandes dblquad, triplequad.
IX.1.2. Résolution des équations non linéaires
La commande fzero permet de calculer les solutions d’une équation non linéaire de la forme :

29
f(x) = 0. L’instruction s’écrit : X = fzero (nomfonction, X0), où X0 est un scalaire. Ceci calcule
une solution de l’équation proche de X0.
Exemple :
>> fzero (f ,1)
ans : -1.2361
Remarque : L’instruction fzero(f,-1) donnerai le même résultat.
IX.1.2. Résolution des équations différentielles
La commande ode23 résout les équations différentielles du 1er ordre de la forme : y' = F(t, y).
Avec la condition initiale y(t0) = y0.
Ainsi l’écriture :
[t, y] = ode 23(‘fonction F’, int_temps , y0) avec int_temps = [ t0 , tf], tf = temps final.
y peut être un vecteur.
Exemple : On veut résoudre le système :
 y1 = −2 y1 y2 + y3  y1 (0) = 0
 
 y 2 = − y2 y3 avec les conditions :  y2 (0) = 1
 y = y y + y  y (0) = 2
 3 3 2 1  3
On défint la fonction F(t , y) sauvegardé dans le fichier F.m, comme suit :
function dy = F(t, y)
dy = zeros(3 , 1); % un vecteur colonne
dy(1) = -2*y(1) * y(2) + y(3);
dy(2) = -y(2) * y(3);
dy(3) = y(3) * y(2) + y(1);
Dans l’espace de travail, en tapant les instructions suivantes, on obtient une liste des temps :
ti  int_temps à laquelle correspond 3 vecteurs yj (ti), j = 1, 2, 3.
>> int_temps = [0, 2];
>> y0 = [0, 1, 2];
>> [t, y] = ode23 (f, int_temps , y0)
Pour visualiser les résultats :
>> plot(t , y(1),’r’, t, y(2) ,’b’, t , y(3) ,’y’)
Pour les autres solveurs voir les commandes ode45, ode 113, ode 15S, ode 23S, etc.

30
IX.1.3. Optimisation
IX.1.3.1. La commande fsolve
La commande fsolve calcule par la méthode des moindres carrés les solutions d’un système
d’équations non linéaires de la forme : F(X) = 0 où F et X peuvent être des vecteurs ou matrices.
Exemple : Il s’agit de trouver la solution du système :
 3 x1 − x2 = e x2

 x1 + 2 x2 = −e x1

avec comme valeurs de départ : x0 = [x1, x2] = [1,-1].

Tout d’abord, on définit une fonction F, qu’on sauvegarde dans le fichier fonction1.m.
function F = fonction2(x)
F = [3*x(1) - x(2) - exp(x(1));
x(1) + 2*x(2) + exp(x(2))];
et après on appelle la procédure d’optimisation fsolve :
>> fsolve('fonction1',x0)
>> ans : 0.2929
-0.4616
Remarque : voir les options, en tapant help fsolve
IX.1.3.2. La commande fmin
fmin cherche le minimum d’une fonction d'un variable. La syntaxe est :
X = fmin (' F', x1, x2) retourne une valeur de x qui est un minimum local de F(x) dans l'intervalle
x1 <x < x2. ' F' est le nom de la fonction objective qui doit être minimisée.
Exemple : Il s’agit de trouver le minimum de la fonction f(x) = x5 - 3x – 1, dans [0 , 2].
On définit la fonction f(x) dans un fichier fonction2.
>> x1 = 0 ; x2 =2 ;
>> X = fmin (' fonction2 ', x1,x2)
ans : X = 0.8801
Dans le cas où l’on veut chercher le minimum d’une fonction à plusieurs variables, on utilise la
commande fmins qui possède la même syntaxe que fmin.
IX.2. Probabilités et statistiques
IX.2.1. Lois de probabilités
IX.2.1.1. Distribution binomiale

31
On appelle distribution binomiale de paramètres n  IN et p  [0 , 1] la distribution d’une
variable aléatoire qui prend les valeurs entières entre 0 et n telle que :

P( X = k ) = bn, p (k ) = Cnk p k (1 − p) n−k

L’instruction y = binornd(n , p) génère des nombres aléatoires à partir de la loi binomiale de

paramètres n et p . n et p peuvent être des matrices et doivent être de même taille.
Exemple :
>> n = 1:1:20;
>> r1 = binornd(n,1./n)
IX.2.1.2. Distribution normale

On appelle distribution normale (ou de Gauss) de paramètres   IR et   IR *+ , la distribution

−
(t − )2
1 2 2
continue de densité: , ( x) = e
 2
La commande normrnd génère une matrice de nombres aléatoires à partir de la loi normale et
peuvent être des matrices de même taille.
La syntaxe est : R = normrnd ( , )
Exemple : >> N1 = normrnd(1:5 ,1./(1:5))
ans : N1 = 2.1892 1.9812 3.1091 4.0437 4.9627
De même la commande : R = normrnd (,m,n) où m et n sont des scalaires, engendre une
matrice m x n de nombres aléatoires.
IX.2.1.3. Loi de Student
L’expression de la loi de Student à n degrés de libertés est la suivante :
 n +1
 
f (t ) =  2  où  est la fonction gamma
n +1
 n 
2 2
t
n 1 + 
 2  n

t désigne la valeur que prend la variable aléatoire qui suit la loi de Student.
Dans Matlab l’instruction : R = trnd(n) génère des nombres aléatoires suivant la loi Student à n
degrés de libertés.
IX.2.1.4. Autres lois
Les instructions suivantes définissent quelques distributions :

32
 - Distribution de Poisson de paramètre  est donné par la commande poissrnd(LAMBDA)
- Distribution  (khi - deux) à n degrés de libertés est donné par la commande : chi2rnd(n)
- Distribution bêta de paramètres A et B est définie par betarnd(A , B).
- R = exprnd(mu) génère des nombres aléatoires selon la distribution exponentielle de
moyenne mu.
IX.2.1.5. Intervalle de confiance
On veut construire un intervalle aléatoire qui contient la valeur d’un paramètre inconnu  d’un
échantillon avec une probabilité proche de 1, donc noté 1-  appelée niveau de confiance de
l’intervalle.  est appelé le risque d'erreur. De façon globale, on doit résoudre une équation de la
forme : P( LI    LS ) = 1 −  où  = paramètre à estimer, LI (resp. LS) = limite inférieure
(resp. supérieure) de l’intervalle de confiance.
Dans Matlab, il y a plusieurs procédures pour déterminer l’intervalle de confiance. On peut citer
par exemple les commandes normfit , binofit, poissfit expfit, etc. La syntaxe de normfit est :

[mu,sigma,muic,sigmaic] = normfit(X, alpha) retourne les estimations  et  des paramètres de la

distribution normale, étant donné la matrice de données X. muic et sigmaic sont les estimations
des paramètres  et  au niveau 100 (1- alpha)% de l’intervalle de la confiance et ont deux lignes
et autant de colonnes que la matrice X.
La ligne d’en haut est la limite inférieure de l'intervalle de la confiance tandis que la ligne
inférieure est la limite supérieure. Par exemple, alpha = 0.05 correspond à de l’intervalle de la
confiance 95%.
Exemple:
>> mu = 10; sigma = 2.
>> r = normrnd(10,2,100,2);
>>[mu,sigma,muci,sigmaci] = normfit(r)
mu =
10.1455 10.0527
sigma =
1.9072 2.1256
muci =
9.7652 9.6288

33
 10.5258 10.4766
sigmaci =
1.6745 1.8663
2.2155 2.4693
X. Pages web et bibliographie

X.1. Pages web

Services Internet : http://www.mathworks.com
Autres liens :
http://www.lkb.upmc.fr/quantumoptics/wp-content/uploads/sites/23/2015/12/Matlab2013.pdf
http://enacit1.epfl.ch/cours_matlab/

X.1. 2. Bibliographie
1) Mokhtari M., Mesbah A: Apprendre et maîtriser Matlab, Springer Verlag, 1999
2) Biran A, Breiner M: Matlab for engineers. Springer Verlag, 1995
3) Kwon Y, Bang H: The finite element methods using Matlab. Springer Verlag 1998
4) Wilson H, Turcote L.H, Halpern D: Advanced mathematical and mechanics applications using
Matlab. Springer Verlag, 1999
5) Les manuels de Mathworks :
i) Matlab users’s guide
ii) Using Matlab graphics
Et d’autres manuels pour les toolbox.

34