Introduction A Matlab PAGE 41

U.E.R.
Automatique
Laboratoire Robotique et Productique
Module : Introduction à Matlab
1° Année Ing. Génie Electrique
Par : Col Djeddou Mustapha

Cdt Nemra Abdelkrim
2014/2015
Laboratoire Robotique et Productique Cours Initiation Matlab
Tables des Matières
0. INTRODUCTION ............................................................................................................................................................ 3

1. INFORMATIONS PRELIMINAIRES ........................................................................................................................... 3
2. LES VARIABLES SOUS MATLAB............................................................................................................................... 4
2.1 VARIABLES SPECIALES ......................................................................................................................................................... 5
2.2 NOMBRES COMPLEXES ......................................................................................................................................................... 5
3. VECTEURS ET MATRICES .......................................................................................................................................... 7
3.1 LES VECTEURS...................................................................................................................................................................... 7
3.2 LES MATRICES ..................................................................................................................................................................... 9
3.3 CHAINES DE CARACTERES .................................................................................................................................................. 19
3.4 POLYNOMES ....................................................................................................................................................................... 19
4. PROGRAMMER EN MATLAB ................................................................................................................................... 26
4.1 OPERATEURS LOGIQUES ET RELATIONNELS ........................................................................................................................ 26
4.2 CONTROLE DE L’EXECUTION .............................................................................................................................................. 27
5. SCRIPTS ET FONCTIONS .......................................................................................................................................... 32
5.1 LES SCRIPTS ....................................................................................................................................................................... 32
5.2 LES FONCTIONS .................................................................................................................................................................. 33
5.3 LES SOUS FONCTIONS ......................................................................................................................................................... 36
6. LECTURE ET ECRITURE DE FICHIER .................................................................................................................. 39
7. GRAPHISME ................................................................................................................................................................. 41
7.1 GRAPHIQUES A 2D ............................................................................................................................................................. 41
7.2 GRAPHIQUES A 3D ............................................................................................................................................................. 43
7.3 ANIMATIONS ...................................................................................................................................................................... 48
8. INTRODUCTION A SIMULINK ................................................................................................................................. 49
9. APPLICATIONS ............................................................................................................................................................ 52
9.1 TRAITEMENT D’IMAGE SUR MATLAB ................................................................................................................................. 52
9.2 FONCTIONS DE FILTRAGE ET DE CONVOLUTION .................................................................................................................. 53
9.3 TRANSFORMATION DE FOURIER ......................................................................................................................................... 54
9.4 GENERATION DE NOMBRES PSEUDO-ALEATOIRES ............................................................................................................... 54
9.5 RESOUDRE UNE EQUATION DIFFERENTIELLE ORDINAIRE .................................................................................................... 53
10. LES STRUCTURES ....................................................................................................................................................... 55
11. FONCTIONS ELEMENTAIRES MATLAB ............................................................................................................... 56
2
0. Introduction
Cette introduction au logiciel Matlab est proposée aux étudiants du département Génie électrique de
l’EMP avant le début de leur première année de formation. Ce cours permet aux étudiants de travailler
individuellement sur les exemples et exercices présentés ci-après.
Par ce recueil d’exemples, on souhaite montrer que l’usage de l’outil Matlab dans le domaine de
l’ingénierie est simple et efficace et ainsi inciter nos étudiants à l’appliquer dans les cours et les travaux
de laboratoires qu’ils auront à faire durant leur cursus.
Les commandes Matlab sont présentées dans des situations réelles et suffisamment explicites pour que
leurs utilisations soient claires par elles-mêmes. Les détails syntaxiques doivent être recherchés par les
étudiants en recourant de manière intensive à l’aide en ligne Matlab.
1. Informations préliminaires
Matlab est un système interactif et convivial de calcul numérique et de visualisation graphique destiné
aux ingénieurs et scientifiques. La facilité de développement des applications dans son langage fait qu’il
est pratiquement devenu le standard dans son domaine. Il possède un langage de programmation puissant
et simple à utiliser avec lequel l’utilisateur peut effectuer des calculs en ligne ou par l’intermédiaire d’un
fichier de commandes.
Figure 1 : Architecture de Matlab.
3
Le logiciel Matlab (Matrix Laboratory) est basé sur le calcul matriciel numérique. Tous les objets utilisés
dans Matlab sont donc définis au travers de matrices ou vecteurs dont les valeurs sont, par définition, des
grandeurs complexes. Il existe un très grand nombre d’opérateurs et fonctions distribuées dans le logiciel
de base et dans des boîtes à outils spécialisées. A ceci peut s’ajouter un outil de programmation
graphique : Simulink, essentiel pour la simulation de systèmes dynamiques non linéaires.
L’environnement Matlab se présente sous la forme de plusieurs fenêtres, essentiellement la fenêtre de

commande ou espace de travail dans lequel un interpréteur de commandes exécute les opérations
demandées, la fenêtre contenant l’historique des commandes, la fenêtre des variables utilisées dans
l’espace de travail, etc...
Figure 2: Fenêtre principale de Matlab
2. Les variables sous Matlab

Matlab gère de façon automatique : les nombres entiers, réels, complexes de façon indifférente, les
chaînes de caractères ainsi que les tableaux de nombre. En aucun cas, il n'est utile de déclarer le type de la
variable que l'on manipule, y compris les tableaux (mais il n’empêche qu’il est préférable pour la rapidité
d’exécution de déclarer les variables). Ainsi les instructions suivantes, déclarent les variables lors de leur
affectation :
4
2.1 Variables spéciales
N.B. : Eviter l’utilisation de mots clés ou des noms de valeurs spéciales pour un nom de variable.
MATLAB peut produire des messages d’erreurs ou des résultats étranges si l’un de ces mots
réservés ou noms de fonctions est redéfini. Les mots réservés sont listés par la commande
iskeyword.
2.2 Nombres complexes
La constante i ou j est le nombre imaginaire pré déclaré, de même que certaines constantes
5
Autres fonctions : conj, isreal
Exercice 1
Exercice 2
Utiliser Matlab pour évaluer
Exercice 3
Calculer :
1.
2.
3.
Exercice 4
Définir une variable x = 13.5 et évaluer :
1.
2.
3.
Exercice 5
Définir les variables x et z avec x = 9.6 et z = 8.1 et évaluer
1.
2.
Exercice 6
Calculer (par une seule commande) le rayon r d’une sphère qui a un volume de 350 cm3 . Une fois r est
calculé, l’utiliser pour calculer la surface de la sphère.
Exercice 7
6
Dans un triangle, a = 18 cm, b = 35 cm et c = 50 cm. Définir a, b et c comme variables et calculer alors

l’angle (en degrés) par substitution des variables dans la loi des cosinus. (La loi des cosinus
est : ).
3. Vecteurs et Matrices
3.1 Les vecteurs
Création de vecteurs
Par défaut, le vecteur est une ligne à plusieurs colonnes
 vecteur ligne par énumération des composantes :
>> v = [1 3.4 5 -6]

v =
1.0000 3.4000 5.0000 -6.0000
 vecteur ligne par description :
>> x = [0 : pi/10 : pi]

x =
Columns 1 through 7
0 0.3142 0.6283 0.9425 1.2566 1.5708 1.8850
Columns 8 through 11
2.1991 2.5133 2.8274 3.1416
 vecteur colonne :
>> xcol = x'
xcol =
0
0.3142
0.6283
0.9425
1.2566
1.5708
1.8850
2.1991
2.5133
2.8274
3.1416
 génération de vecteurs métriques
>> x = linspace(0, pi, 11)

x =
7
Columns 1 through 7
0 0.3142 0.6283 0.9425 1.2566 1.5708 1.8850
Columns 8 through 11
2.1991 2.5133 2.8274 3.1416
>> % x = linspace(0, 1, 11)*pi donne le même résultat
Adressages et indexages
>> x(3) % 3eme élément du vecteur x

ans =
0.6283
>> x(2 : 4) % un bloc de composantes
ans =
0.3142 0.6283 0.9425
>> x([8 3 9 1]) % une sélection de composantes ( on les désigne avec un

autre vecteur)
ans =
2.1991 0.6283 2.5133 0
L'utilisation d'indice hors limite provoque une erreur, comme le montre cet exemple:
>> x(12)
??? Index exceeds matrix dimensions.
Combinaison de vecteurs
 Accolage de deux vecteurs :
>> a = [1 : 3]
a =
1 2 3
>> b = [10 : 10 : 30]
b =
10 20 30
>> c = [a b]
c =
1 2 3 10 20 30
On peut faire plus compliqué :
>> c = [a b]
c =
8
1 2 3 10 20 30
>> d = [a(2 : -1 : 1) b] % on accole b avec une portion de a dans l'ordre renversé

d =
2 1 10 20 30
Notez la différence entre ( ) et [ ].
Exercice 8
3.2 Les Matrices

Création de matrices
Une matrice est un ensemble de lignes comportant toutes le même nombre de colonnes Matlab, depuis la
version 5, supporte les matrices à n dimensions (n > 2)
 Par énumération des éléments
>> m1 = [1 2 3 ; 4 5 6 ; 7 8 9] % on sépare les lignes par des points-virgules
9
m1 =
1 2 3
4 5 6
7 8 9
On peut étendre aux matrices les autres manières de définir des vecteurs.
Par exemple:
>> m2 = [1 : 3 ; 11 : 1 : 13]
m2 =
1 2 3
11 12 13
>> m2 = [1 : 1 : 3 ; logspace(0, 1, 3)]

m2 =
1.0000 2.0000 3.0000

1.0000 3.1623 10.0000
 sum, transpose, et diag
Utilisant les propriétés spéciales des matrices carrées ‘ magique’ par la sommation de différentes façons
ces éléments. Si on prend la somme le long des lignes et colonnes. Ou le long des deux diagonales
principales, on trouve toujours le même nombre. Vérifiant ces propriétés en utilisant MATLAB.
>> A = magic(4)
A =
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1
La première affirmation à essayer est
sum(A)
ans =
34 34 34 34
10
Quand on ne spécifie pas une variable de sortie, MATLAB utilise la variable ans, abréviation de answer
pour mémoriser le résultat du calcul. On a calculé un vecteur rangé contenant les sommes des colonnes de
A. chaque colonne a la même somme, la somme magic 34.
Qu’on t il de la somme des rangées ? MATLAB préfère travailler avec des colonnes d’une matrice, alors,
la façon la plus facile pour la somme des rangées est de transposer la matrice, et calculer la somme des
colonnes de la matrice transposée puis re-transposé le résultat Le transpose est noté par l’apostrophe '.
Alors
A'
produit
ans =
16 5 9 4
2 11 7 14
3 10 6 15
13 8 12 1
et sum(A')'
Produit un vecteur colonne contenant la somme des rangées
ans =
34
34
34
34
La somme des éléments de la diagonale principale est facile à obtenir avec l’aide de la fonction diag,
diag(A)
donne
ans =
16
11
6
1
et
sum(diag(A))
produit
ans =
34
11
L’autre diagonale, qu’on appelle antidiagonal, on utilise la fonction fliplr, qui tourne la matrice de la
gauche vers la droite.
>> sum(diag(fliplr(A)))
ans =
34
 Expansion de la taille d’une matrice
Si on accède à un élément externe à une matrice, c’est une erreur
B = A(4,5)
??? Index exceeds matrix dimensions
Cependant, si on ajoute un élément externe à la matrice, la taille de la matrice augmente pour

s’accommoder avec le nouvel élément.
B = A;
B(4,5) = 17
B=
16 2 3 13 0
5 11 10 8 0
9 7 6 12 0
4 14 15 1 17
On peut aussi étendre une matrice en assignant une série d’éléments
B(2 : 5 , 5 : 6) = 5
B=
16 2 3 13 0 0
5 11 10 8 5 5
9 7 6 12 5 5
4 14 15 1 5 5
0 0 0 0 5 5
 Suppression de Rangées et de Colonnes
On peut supprimer des rangées et des colonnes d’une matrice en utilisant une paire de crochet carré.
Soit
X = A;
Supprimant la seconde colonne de X,
X(:,2) = [ ]
12
X devient
X=
16 3 13
5 10 8
9 6 12
4 15 1
Si on supprime un élément d’une matrice, le résultat n’est plus une matrice. Alors, une expression
comme
X(1 , 2) = [ ]
donne une erreur.
 Concaténation des matrices
La concaténation est l’opération de joindre de ’petites matrices’ ensemble pour former une matrice plus
grande. La paire de crochet carrée, [], est l’opérateur de concaténation. Par exemple, commençons par
une matrice ‘magique’ carrée, A, et formant
B = [A A + 32 ; A + 48 A + 16]
Le résultat est une matrice 8-par-8, obtenue en joignant quatre sous matrices.
B=
16 2 3 13 48 34 35 45
5 11 10 8 37 43 42 40
9 7 6 12 41 39 38 44
4 14 15 1 36 46 47 33
64 50 51 61 32 18 19 29
53 59 58 56 21 27 26 24
57 55 54 60 25 23 22 28
52 62 63 49 20 30 31 17
Cette nouvelle matrice est une demi-matrice ‘magique’. La somme des colonnes est la valeur correcte
pour une matrice carrée ‘magique’ 8-par-8.
>> sum(B)
ans =
260 260 260 260 260 260 260 260
Mais, les sommes des rangées, sum(B')', ne sont pas toutes les mêmes.
13
Opérations scalaires-matrices
Une telle opération agit sur chaque élément de la matrice :
>> m2'*10 % de même : 4*m2 m2 – 10 m2 / 4

ans =
10.0000 10.0000
20.0000 31.6228
30.0000 100.0000
Une exception:
>> m2^2
??? Error using ==> mpower
Matrix must be square.
Dans ce cas, Matlab veut calculer le produit matriciel m2 * m2
La solution est l’usage du point qui force l’opération sur chaque élément:
>> m2.^2
ans =
1.0000 4.0000 9.0000

1.0000 10.0000 100.0000
Opérations entre matrices

 Multiplications
>> m1 % rappelons la définition de m1

m1 =
1 2 3
4 5 6
7 8 9
>> m2 % rappelons la définition de m2
m2 =
1.0000 2.0000 3.0000
1.0000 3.1623 10.0000
>> m1*m2' % le produit matriciel n’est possible que si les dimensions des matrices sont cohérents
ans =
14.0000 37.3246
14
32.0000 79.8114
50.0000 122.2982
>> m1*m2
??? Error using ==> mtimes
Inner matrix dimensions must agree.
 Multiplication élément par élément:
Soit :
m3 = [1 : 3 ; 11 : 1 : 13]
m3 =
1 2 3
11 12 13
>> m2.*m3 % (m2 et m3 ont les mêmes dimensions)

ans =
1.0000 4.0000 9.0000
11.0000 37.9473 130.0000
 Divisions
>> m2 / m3 % division matricielle à droite

ans =
1.0000 0
4.9279 -0.4279
>> m2 \ m3 % division matricielle à gauche (voir algèbre linéaire)

ans =
0 0 0
-2.1877 -1.5219 -0.8561
1.7918 1.6813 1.5707
 Division élément par élément:
>> m2 ./ m3 % chaque élément de m2 est divisé par l'élément équivalent de m3
ans =
1.0000 1.0000 1.0000
0.0909 0.2635 0.7692
>> m2 .\ m3 % chaque élément de m3 est divisé par l'élément équivalent de m2
ans =
1.0000 1.0000 1.0000
11.0000 3.7947 1.3000
15
Matrices particulières
Caractéristiques des matrices
De même, il existe des syntaxes particulières permettant d'extraire des lignes, des colonnes de matrices :
Une des difficultés que rencontre le débutant est le mauvais maniement des matrices du à une mauvaise
connaissance des tailles des matrices. Pour vérifier ces tailles, on pourra utiliser la commande size:
16
 L’opérateur ‘colon’ (:)
Cet opérateur est l’un des plus importants des opérateurs de MATLAB. Il apparaît sous plusieurs formes.
L’expression
1:10
est un vecteur rangé contenant des entiers de 1 à 10
1 2 3 4 5 6 7 8 9 10
Pour obtenir un pas non unitaire, on spécifie un pas d’incrémentation. Par exemple,
100:-7:50
donne
100 93 86 79 72 65 58 51
et
0:pi/4:pi
donne
0 0.7854 1.5708 2.3562 3.1416
Les expressions d’indexages des deux points délimitent une partie de la matrice.
A(1:k,j)
est les k premiers éléments de la j-ème colonne de A. Alors
17
sum(A(1:4,4))
Calcule la somme des quatre premiers éléments de la 4eme colonne. Mais il y a mieux. L’opérateur colon
par lui-même représente tous les éléments au sens des colonnes ou rangées d’une matrice et le mot clé fait
référence à la dernière rangée ou la dernière colonne. Alors
sum(A(:,end))
calcule la somme des éléments de la dernière colonne de A.
ans =
34
Décomposition de matrices
Certaines décompositions de matrices sont déjà implémentées :

 La décomposition en valeurs singulières est réalisée par la fonction svd (singular value
decomposition). Sa syntaxe est :
>> [U, S, V] = svd(X);
Elle produit une matrice diagonale S de même dimension que X, avec les éléments diagonaux non nuls
rangés en ordre décroissant, et des matrices unitaires U et V telles que X = U*S*V'.
 La factorisation de Cholesky est réalisée par la fonction chol :
>> R = chol(X);
Elle utilise uniquement la partie triangulaire supérieure de X (et considère que la partie triangulaire
inférieure de X est la transposée conjuguée de la précédente). Elle produit un message d'erreur si X n'est
pas définie positive, sinon elle produit la matrice triangulaire supérieure R telle que R'*R=X.
 La factorisation QR est réalisée par la fonction qr :
>> [Q,R] = qr(X);
produit une matrice triangulaire supérieure Q de même dimension que X et une matrice unitaire R telle
que X = Q*R.
 Une factorisation LU (Lower, Upper) est réalisée par la fonction lu :
>> [L, U] = lu(X);
exprime une matrice carrée X sous forme d'une matrice triangulaire supérieure U et d'une permutation
d'une matrice triangulaire inférieure L, telle que X = L*U.
18
3.3 Chaînes de caractères
Comme on l'a vu précédemment, toute variable de Matlab est une matrice. Cependant, il est peut-être
utile de conserver des chaînes de caractères dans des variables, et cela se fait d’une façon toute à fait
naturelle :
>> message = 'bienvenue sur Matlab';
On peut alors réaliser des manipulations de même type que pour les vecteurs
>> message = [message, ' version 7.1'];

message = bienvenue sur Matlab version 7.1
On peut convertir des nombres en chaîne de caractères à l'aide des fonctions num2str, int2str, sprintf.
Par exemple :
>> message = ['pi vaut ', num2str(pi)]

message = pi vaut 3.142
Deux fonctions peuvent être très utiles lors de manipulations de chaînes de caractères : eval et feval. Si
l'on possède une instruction Matlab dans une chaîne de caractères, la commande eval évaluera cette
chaîne de caractères comme si elle avait été tapée à la ligne de commande de Matlab; voici un exemple
:
» expr='1/x+x^2-2';
» x=1;
» eval(expr) %evaluation de l’expression expr avec la valeur x=1
ans =
Cette utilisation des séries des caractères est présente dans l’implantation de la boîte à outils Maple
Symbolic Toolbox, qui utilise la technologie achetée de chez Maple Software, les leaders dans le
domaine de la mathématique symbolique. Même sans cette boîte à outils, on peut toujours utiliser cette
technique pour des fonctions rudimentaires de mathématique symbolique.
De même, la commande feval est comme la fonction eval, sauf qu’elle est utilisée pour évaluer la fonction
citée.
str = ’sin’;
t = linspace(0,2*pi);
q = feval(str,t);
plot(t,q)
3.4 Polynômes
19
Les polynômes sont représentés comme des vectrices lignes qui contiennent les
coefficients dans l’ordre descendant de puissances. Par exemple, le polynôme
x 4  35
. x 3  3.9 x 2  8 x  20 s’écrit :
» p=[1 3.5 -3.9 8 -20]
p =
1.0000 3.5000 -3.9000 8.0000 -20.0000
Les racines de ce polynôme sont :
» r=roots(p)
r =
-4.8285
-0.0843 + 1.6613i
-0.0843 - 1.6613i
1.4970
On peut reconstruire le polynôme en partant de ses racines
» poly(r)
ans =
Columns 1 through 4
1.0000 3.5000 -3.9000 8.0000 -

0.0000i
Column 5
-20.0000 + 0.0000i
On utilise sans aucun problème les opérateurs et les fonctions pour la manipulation
de matrices sur ces vecteurs qui représentent des polynômes.
Exercice 9
Sans utiliser de boucles d’itération, ajouter aux éléments d’une matrice l’indice de leur colonne.
Exercice 10
20
Exercice 11
- Définissez A une matrice 3x3

- Mettez à zéro l’élément (3,3)
- Changez la valeur de l’élément dans la 2ème ligne, 6ème colonne, que se passe-t-il?
- Mettez tous les éléments de la 4ème colonne à 4
- Créez B en prenant les lignes de A en sens inverse
- Créer C en accolant toutes les lignes de la première et troisième colonne de B à la droite de A
- Créer D sous matrice de A faite des deux premières lignes et les deux dernières colonnes de
A. Trouvez aussi une manière de faire qui ne dépende pas de la taille de A.
Note: chacun de ces exercices se fait en une seule instruction, sans boucles itératives.
Exercice 12
21
Exercice 13
Exercice 14
22
Exercice 15
Exercice 16
En utilisant les commandes ones et zeros, créer une matrice 4x5 dans laquelle les deux premières lignes
sont des 0 et le reste des 1.
Exercice 17
Créer une matrice 6x6 dont les 2 lignes du milieu sont des 1 et le reste des 0.
Exercice 18
Etant donné, une matrice A 5x6, une matrice B 3x6 et un vecteur v.
23
v=
Créer ces trois matrices dans la fenêtre des commandes, et puis en utilisant une seule commande,
remplacer les 4 dernières colonnes de la première et troisième lignes de A avec les 4 premières colonnes
des 2 premières lignes de B, les 4 dernières colonnes de la quatrième lignes de A avec les éléments 5 à 8
de v, et les 4 dernières colonnes de la cinquième ligne de A avec les colonnes 3 à 5 de la troisième ligne
de B.
Exercice 19
Créer la matrice suivante en utilisant la notation vectorielle pour la création des vecteurs avec un
espacement constant et/ou la commande linespace pour les lignes.
Exercice 20
En utilisant la commande eye créer une matrice A ci-dessous. En utilisant les deux points d’adressage ‘’ :
’’ des éléments de la matrice, changer la matrice A en matrice B.
Exercice 21
Créer une matrice A 3x3 dont tous les éléments sont des 1 et créer une matrice B dont tous les éléments
sont des 5. Ajouter des éléments à A par concaténation de la matrice B de façon à avoir
24
Exercice 22
Deux vecteurs sont donnés par : U = 4i + 9j -5k, et V = -3i + 6j - 7k
Utiliser Matlab pour calculer le produit intérieur U.V des deux vecteurs de deux manières :
1. Définir U comme un vecteur ligne et V comme vecteur colonne et utiliser alors le produit
matriciel.
2. Utiliser directement la fonction dot.
Exercice 23
Utiliser Matlab pour montrer que la somme d’une série infinie converge vers /6.
Faire le calcule de la somme pour n = 100, n = 1000 et n = 10000.
Exercice 24
Créer les matrices suivantes :
1. Calculer A + B et B + A pour voir la commutativité des matrices ;
2. Calculer A + (B + C) et (A + B) + C pour voir l’associativité des matrices ;
3. Calculer 5(A + C) et 5A + 5C et calculer A*(B + C) et A*B + A*C ;
Exercice 25
Résoudre le système d’équations linéaires :
5x + 4y - 2z + 6w = 4
3x + 6y + 6z + 4.5w = 13.5
6x + 12y - 2z + 16w = 20
4x - 2y + 2z - 4w = 6
Exercice 26
Le graphe d’une fonction passe par les points (-2,-3.4), (-0.5, 5.525),
(1,16.7) et (2.5, 70.625). Déterminer les constantes a, b, c et d.
25
4. Programmer en Matlab
4.1 Opérateurs logiques et relationnels
Avant de décrire la syntaxe du test sous Matlab, indiquons les principaux opérateurs de relation ainsi que
les opérateurs booléens qu'utilisent Matlab.
Le résultat d'un test est un booléen, qui sous Matlab, prend la valeur 1 pour vrai et 0 pour faux. Par
exemple, on a les résultats suivants :
>> r = ~ ((1>2 ))
r=
>> r = ~ ((1 > 2 ) | ( 0 ~ = 0 )) (traduction Matlab de l’expression logique : non(1>2 ou 0 différent de 0))
r=
Il existe d'autres fonctions booléennes, par exemple xor, isfinite, isnan, isinf, dont on trouvera la
description en faisant help ops.
26
4.2 Contrôle de l’exécution
Exemples
a)For
 Boucles de vectorisation
27
On peut augmenter la vitesse d’exécution du code du fichier (.m) par la vectorisation des opérations.
Vectorisation veut dire convertir les boucles for et while en opérations équivalentes vectorielles ou
matricielles.
Exemple simple
Les fonctions zeros et ones, permettent parfois d'éviter de mettre en œuvre une boucle.
Par exemple, au lieu de faire la boucle :
r = 1:10000;
A = []; % initialisation de A à vide
for i = 1:5,
A = [A ; r];
end
On peut écrire
r = 1: 10000;
A = ones(5,1)*r;
Le deuxième exemple s’exécute plus rapidement que le premier et de cette façon que MATLAB doit être
utilisé. Tester cette exemple dans votre PC en créant un fichier script contenant le programme ci-dessus,
puis, utiliser les commandes tic et toc pour chronométrer les deux versions du programme.
Une façon plus rusée encore de réaliser ceci est :

tic,r = 1:10000;
A = r(ones(5,1),:);toc, % Etudiez bien cette instruction
On remarque qu'ainsi on évite la multiplication de l'instruction précédente.
b) While
La boucle while répète un groupe d’instructions indéfiniment sous le contrôle d’une condition logique.
La commande end arrête l’exécution des instructions quand la condition logique est remplie.
Voici un programme complet, pour illustrer les commandes while, if, else, et end, qui utilise
la bissection par intervalle pour trouver le zéro d’un polynôme.
a = 0; fa = -Inf; b = 3; fb = Inf;
while b-a > eps*b
x = (a+b)/2;
fx = x^3-2*x-5;
if sign(fx) == sign(fa)
a = x; fa = fx;
else
b = x; fb = fx;
end
end
28
Le résultat est la racine du polynôme x3 - 2x - 5, c'est-à-dire
x = 2.09455148154233
Interruption d'une boucle de contrôle
Il est possible de provoquer une sortie prématurée d'une boucle de contrôle.
 L'instruction break permet de sortir d'une boucle FOR ou d'une boucle WHILE. L'exécution se
poursuit alors séquentiellement à partir de l'instruction suivant le "end" fermant la boucle.
Attention: en cas de boucles imbriquées, on interrompt seulement l'exécution de la boucle
intérieure contenant l'instruction break.
 L'instruction return provoque un retour au programme appelant (ou au clavier).
Voir l’instruction continue
c) If-then-else
La commande if évalue une expression logique et exécute un groupe d’instruction, quand l’expression
est vraie. Les mots clés optionnels elseif et else donnent une exécution alternative d’un groupe
d’instructions. Le mot clé end, qui suit le if, termine le dernier groupe d’instructions. Les groupes
d’instruction sont entourés par les quatre mots clés – pas de parenthèse ni de crochets, sont nécessaires.
%Calcul du factorielle
%entrée = u numéro n quelconque
%sortie = -1 si n non-entier
%sortie = n! si n entier
ent=6 ;
if ~(ent==round(ent))
resultat=-1;
elseif (ent==0)
resultat = 1;
else resultat=ent*fact(ent-1);
end
Il est important de comprendre comment les opérateurs relationnels et les instructions if marchent avec
les matrices. Quand vous voulez tester l’égalité entre deux variables, on utilise
if A == B, ...
Ceci est un code juste dans MATLAB, et donne ce que vous espérer quand A et B sont des scalaires. Mais
quand A et B sont des matrices, A == B ne teste pas si (if) elles sont égales, elle teste là ou les éléments
des deux matrices sont égaux ; le résultat est une autre matrice de 0 et de 1 montrant l’égalité élément par
29
élément. En plus si A et B sont de tailles différentes, alors

A == B est une erreur.
La façon adéquate de tester l’égalité entre deux variables est d’utiliser la fonction isequal,
if isequal(A,B), ...
Dans cet exemple, on développera ce point. Si A et B sont des scalaires, le programme suivant n’atteindra
jamais la situation imprévisible. Mais pour la majorité des paires de matrices, aucune des conditions
matricielles A > B, A < B or A == B est vraie pour tous les éléments et alors la clause else est exécuter.
if A > B
'greater'
elseif A < B
'less'
elseif A == B
'equal'
else
error('Unexpected situation')
end
Plusieurs fonctions existent pour réduire les résultats de comparaisons de matrice aux conditions scalaires
avec l’utilisation de if, on peut citer
isequal
isempty
all
any
Expression de conditions
Il faut éviter d’exprimer des conditions trop complexes, introduisez des variables logiques
temporaires à la place.
L’expression :
if (value>=lowerLimit)&(value<=upperLimit)&~ismember(value,…valueArray)
:
end
Doit être remplacer par :

isValid = (value >= lowerLimit) & (value <= upperLimit);
isNew = ~ismember(value, valueArray);
if (isValid & isNew)
:
end
Le cas le plus fréquent doit être mis dans la partie if, le cas exceptions dans la partie else.
30
Cette pratique permet d’augmenter la lecture et empêche que les exceptions cachent le chemin normal
de l’exécution
fid = fopen(fileName);
if (fid~=-1)
:
else
:
end
d) switch et case
La commande switch exécute un groupe d’instructions en se basant sur la valeur d’une variable ou
d’une expression. Les mots clés case et otherwise délimitent les groupes d’instructions. Seul le
premier cas adéquat est exécuté. Il doit avoir toujours un end relatif à switch.
L’exemple de l’algorithme de matrice carrée magique peut être décrit aussi par
switch x
case 1
disp(’x est 1’)
case {2,3,4}
disp(’x est 2, 3 or 4’)
case 5
disp(’x est 5’)
otherwise
disp(’x n est pas 1, 2, 3, 4 ou 5’)
end
La commande switch doit toujours inclure la condition otherwise, ne pas l’incorporer peut conduire à
résultats inattendus.
La variable switch doit toujours être une chaine de caractères de type string.
Exercice 27
Écrire le script Matlab pour générer la matrice M de Vandermonde à partir d’un vecteur A.
Avec deux méthodes :
a) Sans utiliser de boucles d’itération
b) En utilisant de boucles d’itération
Exercice 28
31
Utiliser une boucle for-end dans un programme script pour calculer la somme des n premiers éléments de
la série : .
Exécuter le programme pour n = 4 et n = 20.
Exercice 29
Un vecteur est donné par V = [ 5 17 -3 8 0 -1 12 15 20 -6 6 4 -7 16]. Écrire un programme script qui
double les éléments qui sont positifs et sont divisibles par 3 et/ou 5, et élever à la puissance 3 les éléments
qui sont négatifs, mais plus grand que -5.
Exercice 30
Un vecteur est défini par x = [15 -6 0 8 -2 5 4 -10 0.5 3], en utilisant les expressions conditionnelles et les
boucles, écrire un programme qui détermine la somme des éléments positifs du vecteur.
5. Scripts et fonctions
5.1 Les scripts
L’extension classique d’un fichier MATLAB est .m. On peut trouver 2 types de fichiers m : les fichiers de
fonctions (abordés plus loin dans cet exercice) et les fichiers de script qui sont un ensemble de
commandes pouvant s’enchaîner. L’utilisation de fichiers script permet de sauvegarder vos commandes
d’une session Matlab à une autre. Pour ouvrir un fichier script :
- soit vous tapez la commande edit,
- soit vous cliquez : file→ new → M-file,
- soit vous cliquez directement sur l’icône représentant une page blanche.
Un script (ou M-file) est un fichier (message.m par exemple) contenant des instructions Matlab.
Voici un exemple de script :
32
Matlab vous offre un éditeur pour écrire et mettre au point vos M-files :
>> edit % cette commande lance l’éditeur de Matlab.
Les M-files sont exécutés séquentiellement dans le “workspace”, c'est-à-dire qu’ils peuvent accéder aux
variables qui s’y trouvent déjà, les modifier, en créer d'autres, etc.
On exécute un M-file en utilisant le nom du script comme commande :
Pour exécuter un script :

- soit vous lancez dans la fenêtre de commande la commande nom_du_fichier (sans l’extension .m), en
vous assurant que la liste des chemins est cohérente ;
- soit vous sélectionnez des lignes du fichier .m dans la fenêtre d’édition et vous tapez la touche F9
(pratique pour exécuter une partie isolée du script).
5.2 Les fonctions

Un grand nombre de fonctions mathématiques élémentaires (fonctions trigonométriques, exponentielle,
logarithmique) sont déjà définies dans l’environnement Matlab. En plus par rapport à ces fonctions,
l’utilisateur peut définir lui-même des fonctions pour automatiser certaines opérations.
La notion de fonction donc, existe sous Matlab. Sa syntaxe est la suivante :
function [args1,args2,...] = nomfonction(arge1,arge2,...)

instructions
args1,args2,... sont les arguments de sortie de la fonction et peuvent être de n'importe quel type
arge1,arge2,... sont les arguments d'entrée de la fonction et peuvent être de n'importe que type
instructions est un bloc d'instructions quelconque devant affecter les arguments de sortie args1,args2,...
L'appel à la fonction s'opère de la façon suivante :
[vars1,vars2,...] = nomfonction(vare1,vare2,...)
Lorsqu'il n'y a qu'un seul argument de sortie, on peut utiliser la syntaxe plus simple :
function args = nomfonction(arge1,arge2,...)
33
Avec compatibilité des variables d'entrées vare1,vare2,... avec les arguments d'entrée arge1,arge2,... et
compatibilité des variables de sorties vars1,vars2,..., si celles-ci ont déjà été utilisées, avec les arguments
de sortie args1,args2,....
Remarque : il n'est pas obligatoire de fournir tous les arguments d'entrées et de sortie lors de l'appel
d'une fonction, mais ceux que l'on omet doivent être les derniers des listes d'entrée ou de sortie. Ainsi,
supposons nomfonction soit une fonction à 2 arguments d'entrée et 2 arguments de sortie, on peut alors
utiliser l'appel suivant :
[vars1]= nomfonction(vare1) mais pas l'appel : [vars2]= nomfonction(vare2).
La limitation du nombre d'arguments de sortie est gérée de façon automatique dans Matlab. Par contre, les
variations du nombre d'arguments d'entrée doivent être gérées par le concepteur de la fonction à l'aide du
paramètre nargin qui indique le nombre d'arguments en entrée lors de l'appel de la fonction.
Par exemple, si sur le disque dur se trouve un fichier qui s’appelle fact.m et son contenu est :
%Fonction factorielle
%un exemple pour le cours d'initiation Matlab
%entrée = u numéro n quelconque
%sortie = -1 si n non-entier
%sortie = n! si n entier
function [resultat] = fact(ent)
if ~(ent==round(ent))
resultat=-1;
elseif (ent==0)
resultat = 1;
else resultat=ent*fact(ent-1);
end
Nous pouvons maintenant utiliser cette fonction pour calculer le factoriel d’un nombre entier n.
» fact(10)
ans =
3628800
La convention de définition de la fonction ressemble tout à fait aux autres langages de programmation
structurée. Cet exemple en apparence trivial contient plusieurs informations importantes. On observe que
Matlab accepte aussi des fonctions récursives, ce qui est quand même remarquable pour un langage
interprété. Cela ne veut pas dire que l’utilisation de ce genre de fonctions est souhaitable, mais juste pour
montrer que, de point de vue de flexibilité, Matlab n’a rien à envier aux langages compilés.
34
Comme vous avez déjà deviné, le symbole % précède une ligne de commentaires qui seront
ignorés. Mais si ces lignes sont en début de fonction, on va voir que la commande :
» help fact
Fonction factorielle
un exemple pour le cours d'initiation Matlab
entrée = un numéro n quelconque
sortie = -1 si n non-entier
sortie = n! si n entier
Voici une fonction” temps” définie dans le fichier temps.m:
Utilisation de cette fonction:
 Portée d'une fonction
On peut déclarer des fonctions dans un script principal à la suite des instructions du script principal. Mais
il est souvent plus recommandé, pour des raisons d'organisation, de les placer dans un autre script, voire
plusieurs. Dans ce cas, le nom du script externe devra porter le nom de la fonction avec l'extension .m. Si
dans ce script externe, on y place plusieurs fonctions, seule la fonction dont le script porte le nom sera
accessible depuis le script d'appel. Les autres fonctions ne seront accessibles que dans le script où elles
ont été déclarées; on parle, dans ce cas, de sous fonctions.
Egalement liée aux fonctions, la notion de variable globale permet de rendre visible des variables d'un
script à l'autre. Par défaut, aucune variable n'est globale. Supposons que l'on ait un script principal et un
script secondaire contenant la déclaration de la fonction nomfonction. Pour déclarer de façon globale, la
35
variable de nom varg, on introduira l'instruction suivante dans le script principal et la fonction
nomfonction :
global varg
Matlab offre plusieurs moyens de vérifier les arguments d’entrées et de sorties d’une fonction:
En résumé :
5.3 Les sous fonctions
Les fichiers fonction (.m) peuvent contenir des codes pour plus d’une fonction. La première fonction dans
le fichier est la fonction primaire, la fonction est appelée avec le nom du fichier. Des fonctions
additionnelles dans le fichier sont les sous fonctions qui sont seulement visibles pour la fonction primaire
ou pour les autres sous fonctions dans le même fichier.
Chaque sous fonction commence par sa propre ligne de définition de fonction. Les fonctions se suivent
immédiatement l’une après l’autre. Les différentes sous fonctions peuvent être dans ordre quelconque, de
moment que la fonction primaire apparaît en premier.
function [avg,med] = newstats(u) % Primary function

% NEWSTATS Find mean and median with internal functions.
n = length(u);
avg = mean(u,n);
med = median(u,n);
function a = mean(v,n) % Subfunction
36
% Calculate average.
a = sum(v)/n;
function m = median(v,n) % Subfunction

% Calculate median.
w = sort(v);
if rem(n,2) == 1
m = w((n+1)/2);
else
m = (w(n/2)+w(n/2+1))/2;
end
Les sous fonctions mean et median calcule la moyenne et la médiane de la liste d’entrée. La fonction
primaire newstats détermine la longueur de la liste et appelle les sous fonctions, en passant la longueur
n de la liste. Les fonctions contenues dans un même fichier .m ne peuvent accéder les mêmes variables
sous réserve de les déclarées variables globales dans les sous fonctions pertinentes, ou les faire passées
comme arguments.
Quand on appelle une fonction à partir d’un fichier .m, MATLAB teste en premier si la fonction est une
sous fonction. Puis il contrôle si elle est une fonction privée ayant le même nom, et puis cherche la
fonction .m standard dans le répertoire de travail.
Exercice 31
Écrire un fichier fonction n qui prend un vecteur comme entré et retourne 1 si tous les éléments sont
positives et -1 si tous les éléments sont tous négatifs et 0 si autrement N.B.: Tapez help all.
Exercice 32
Ecrivez une fonction “index_of_max” qui retourne l’index de l’élément le plus grand d’un vecteur A
donné comme argument d’entrée.
Exercice 33
Quand plusieurs résistances sont connectées dans un circuit électrique en série, la tension à la borne de
chaque résistance est donnée par la règle du diviseur de tension :
Où Vn et Rn sont la tension aux bornes de la résistance n et sa résistance correspondante, Req = ∑Rn est
la résistance équivalente. La puissance dissipée dans chaque résistance est :
Comme exemple, soit le circuit suivant :
37
Écrire un programme script qui calcule la tension à la borne de chaque résistance, et la puissance dissipée
dans chaque résistance. Quand le programme script est exécuté, il demande à l’utilisateur de faire entrer
la tension de la tension puis les valeurs des résistances dans un vecteur. Le programme affiche une table
avec les résistances listées dans la première colonne, les tensions dans la seconde colonne et la puissance
dans la troisième colonne. Ensuite, le programme affiche le courant dans le circuit et la puissance totale.
Exercice 34
Écrire une fonction Matlab pour la fonction suivante :
L’entrée pour la fonction est (en radians) et la sortie est r. écrire la fonction de façon que peut être un
vecteur.
1. Utiliser la fonction pour calculer r(π/3) et r(3π/2).
2. Utiliser la fonction pour tracer (en coordonnées polaire) r( ) pour
Exercice 35
La fonction sin(x) peut-être écrite en série de Taylor par :
Écrire une fonction qui calcule sin(x) en utilisant la série de Taylor. Le nom de la fonction et les
arguments utilisés : y = Tsin(x,n). Les arguments d’entrées sont l’angle x en degrés et n le nombre de
termes dans la série. Utiliser la fonction pour calculer sin(150°) en utilisant 3 puis 7 termes.
Exercice 36
Utiliser Matlab de deux différentes façons pour tracer la fonction :
1. Écrire un programme script en utilisant les boucles et commandes conditionnelles

2. Créer une fonction f(x), puis utiliser cette fonction dans un fichier script pour faire le tracé.
38
6. Lecture et écriture de fichier

Comme on l'a déjà mentionné, par défaut toute commande exécutée produit un résultat qui apparaît dans
la fenêtre d'exécution à la suite de la commande. On peut empêcher l'affichage du résultat en terminant la
commande par ';'. Ainsi, on a :
Dans les scripts d'exécution, l'affichage d'un résultat est exceptionnel. Il sert, essentiellement, à détecter
les erreurs et à afficher des résultats finaux. On prendra donc garde à ne pas oublier le ';' à la fin de
chaque ligne de commande.
Deux commandes utiles pour gérer le workspace, dont la taille dépend de votre espace de swap:
>> save % écrit toutes les variables du workspace dans le fichier matlab.mat
>> load % charge dans le workspace toutes les variables du fichier matlab.mat
 Impressions à l'écran
La commande standard d'écriture dans la fenêtre d'exécution est fprintf qui a la structure générale
suivante :
fprintf(format,var1,var2,...)
Où format est une chaîne de caractères décrivant le format d'écriture des variables var1,var2,... que l'on
souhaite afficher. Les principaux types de formats d'écriture sont :
Par souci de simplicité, on peut se contenter d'utiliser les formats %d, %f, %e sans spécifier de longueur
précise.
Par ailleurs, on dispose de certains opérateurs de mise en forme, par exemple \n pour passer à la ligne.
Ainsi, on écrira, par exemple :
fprintf('\n Convergence en %d itérations ',it)
39
Où it désigne une variable contenant un entier.

Pour plus de détails, faire help fprintf.
 Impression dans un fichier
Il est également possible d'écrire les résultats dans un fichier (et souhaitable lorsqu'il y en a beaucoup).
Pour ce faire, on utilise encore la commande fprintf, mais en spécifiant un numéro fid associé à un nom
de fichier de résultats, nommé ici monfichier. On effectue, les opérations suivantes :
fid = fopen(monfichier,’rw’) ; % ouvre le fichier monfichier en mode lecture et écriture

fprintf(fid,\n Convergence en %d itérations’,it) ; % écrit dans le fichier monfichier
status = fclose(fid) ; % ferme le fichier monfichier
L'opération d'ouverture de fichier par la commande fopen a échoué si fid vaut -1 et status renvoie 0 si
l’opération de fermeture par la commande fclose est réussie et -1 sinon.
 Lecture de données
Afin de lire des données utiles à l'exécution, on peut procéder de deux façons : soit en interrompant
l'exécution du programme et en demandant à l'utilisateur d'indiquer les données, soit en lisant un fichier
de données. Cette deuxième solution étant bien souvent préférable.
Pour interrompre l'exécution et demander une valeur, on utilise la commande input, dont voici un
exemple d'utilisation :
data = input('Donnez votre valeur (par defaut 0)');
A l'issue de la réponse, la variable data contiendra la réponse envoyée, qui peut prendre n'importe quel
type et même prendre la valeur vide [] si on a tapé sur enter. C'est d'ailleurs par ce moyen que l'on gère
les valeurs par défaut :
Pour afficher la valeur d’une variable N dans l’écran
disp(N) % affiche la valeur de N
Pour lire des fichiers de donnée, on utilise la commande fscanf dont le principe de fonctionnement est
proche de la commande fprint. Pour lire la donnée data dans le fichier ficdon, on utilisera la suite de
commande suivante :
fid = fopen(ficdon,’rw’) ; % ouvre le fichier ficdon en mode lecture et écriture

fprintf(fid,\n Convergence en %d itérations’,it) ; % écrit dans le fichier ficdon
status = fclose(fid) ; % ferme le fichier ficdon
40
Pour plus d'informations, faire help fscanf, help fopen et help fclose. Il existe d'autres méthodes de
lecture et d'écriture sur fichier, faire help iofun pour plus d’informations.
7. Graphisme
Nous donnons ici les indications minimales. Utilisez help et les autres commandes d’aide pour affiner vos
connaissances et vos graphiques.
7.1 Graphiques à 2D
 Courbes: plot
Exemple:
>> t=0:0.01e-3:0.06;
>> y=10*exp(-60*t).*cos(120*pi*t);
>> z=10*exp(-60*t).*sin(120*pi*t);
>> plot(t,y,'r',t,z,'g'),grid
>> a=10*exp(-60*t);
>> hold on %Current plot held
>> plot(t,a,'b--')
>> plot(t,-a,'b--')
>> title('Fonctions sinusoidales amorties')
>> xlabel('Temps , s'),ylabel('Tension , V')
>> hold off
>> plot(y,z),grid
>> axis equal
>> xlabel('y'),ylabel('z')
41
Affichage de plusieurs courbes
On peut bien évidemment vouloir afficher plusieurs courbes à l'écran. Pour cela deux solutions s'offrent
à nous :
On peut effectuer plusieurs affichages sur une même figure en utilisant la commande subplot qui
subdivise la fenêtre graphique. Sa syntaxe est :
subplot(nombre_lignes,nombre_colonnes,numéro_subdivision)
Les subdivisions sont numérotés de 1 à nombre_lignes*nombre_colonnes, de la gauche vers la droite puis
de haut en bas.
Exemple :
>> subplot(3,2,1)
>> plot(x,y)
>> subplot(3,2,2)
>> plot(x,y.^2)
1 2
3 4
5 6
On peut aussi ouvrir une deuxième fenêtre graphique à l'aide de la commande figure.
Le passage d'une fenêtre graphique à une autre pourra alors se faire à la souris ou en précisant le numéro
correspondant dans la commande figure(n).
Exemple :
>> w = logspace(0,3,1000);
>> s=j*w;
42
>> H=225./(s.*s+3*s+225);
>> AdB=20*log10(abs(H));
>> phase=angle(H)*(180/pi);
>> subplot(2,1,1),semilogx(w,AdB),grid
>> xlabel('w , rad/s'),ylabel('Amplitude , dB')
>> subplot(2,1,2),semilogx(w,phase),grid
>> xlabel('w , rad/s'),ylabel('Phase , degre')
Exercice 37
7.2 Graphiques à 3D
 ligne dans l’espace: plot3
43
 grillage en perspective: mesh
44
 Surface avec illumination: surfl
45
 courbes de niveau: contour
46
Exercice 38
Faire deux courbes séparées de la fonction ; une courbe pour

et une pour
Exercice 39
Tracer la fonction pour , Noter que cette fonction a deux asymptotes

verticales. Tracer la fonction en divisant le domaine de x en trois parties, une de -10 autour de
l’asymptote gauche, une entre les deux asymptotes et une autour de l’asymptote droite. Mettre l’axes des
y de -20 à 20.
Exercice 40
Un circuit électrique qui comprend une source de tension Vs avec une résistance
interne rs et une résistance de charge Rl. La puissance dissipée dans la résistance de
charge est donnée par :
Tracer la puissance P en fonction de Rl pour Etant donné Vs =

12V et rs = 2.5 Ohm.
Exercice 41
L’amplitude M, dans l’échelle de Richter d’un tremblement de terre est donnée par :
Où E est l’énergie en joules dégagée par la terre à travers le tremblement de terre.

Tracer la courbe de E en fonction de M (en abscisse) pour . Utiliser l’échelle logarithmique
pour E et une échelle linéaire pour M.
Exercice 42
Une résistance R = 4 Ohm et une inductance L = 1.3 H, sont connectées comme montré dans la figure ci-
dessous. Quand la source de tension applique une tension impulsion rectangulaire d’amplitude 12V et de
durée 0.5 s. Le courant i(t) dans le circuit est fonction du temps et donné par :
47
Tracer le courant en fonction du temps
Exercice 43
Un projectile est tiré avec une vitesse initiale de 250m/s avec un angle θ = 65° relative à la terre. Le
projectile est dirigé directement vers le nord mais un vent l’a dévié vers l’ouest. Le projectile aussi a une
vitesse constante de 30 m/s. Déterminer et tracer la trajectoire du projectile jusqu’à ce qu’il touche la
terre. Par comparaison, tracer sur la même figure, la trajectoire en absence de vent.
La position d’une particule en mouvement en fonction du temps est donnée par :
Tracer la position de la particule pour
7.3 Animations
moviein: initialisation d’un buffer pour les images
getframe: capture une figure dans une image de l’animation
movie: affiche l’animation
Exemple – Visualisation de la FFT comme une animation
Cet exemple illustre l’utilisation des animations pour visualiser la quantité fft(eye(n)), qu’est une
matrice complexe n-par-n dont les éléments sont les différentes puissances de la n-ieme racine unité,
exp(i*2*pi/n).
 Création de l’animation
48
Créer l’animation dans une boucle for en appelant getframe pour capturer le graphe. Vu que la
commande plot reset les propriétés des axes, appeler axis equal dans la boucle avant getframe.
for k = 1:16
plot(fft(eye(k+16)))
axis equal
M(k) = getframe;
end
 Exécution de l’animation
Apres la génération de l’animation, on peut la faire jouer plusieurs fois. Pour l’exécuter 30 fois tapé
movie(M,30)
8. Introduction à SIMULINK
Simulink est l'extension graphique de MATLAB permettant de représenter les fonctions mathématiques et
les systèmes sous forme de diagramme en blocs, et de simuler le fonctionnement de ces systèmes.
Pour démarrer Simulink, Dans la fenêtre Commande de MATLAB, taper simulink. La fenêtre Simulink
va s'ouvrir.
Cette fenêtre contient des collections de blocs que l'on peut ouvrir en cliquant (double) dessus:
Sources Sources de signaux
Sinks Systèmes d’affichage
49
Discrete Blocs discrets

Continuous Blocs linéaires continus
Discontinuities Blocs non linéaires
Math Operations Opérations mathématique
Signal Routing Entrée/sortie, multiplexeur/démultiplexeur, etc.
User-Defined Functions Fonction définies par l’utilisateur
Par exemple en cliquant (double) sur Sources on trouve :
CONSTRUCTION D'UN DIAGRAMME SIMULINK

Pour commencer, dans le menu File, on choisit New - Model. Une fenêtre de travail Untitled s'ouvrira.
Ouvrir les collections de blocs en cliquant dessus (double). Faire glisser dans la fenêtre de travail les
blocs dont on a besoin pour construire le diagramme. Faire des liaisons entre les blocs à l'aide de la
souris.
Lorsqu'on clique (double) sur un bloc, une fenêtre de dialogue s'ouvrira. On peut alors changer les
paramètres de ce bloc. Une fois terminé, on ferme la fenêtre de dialogue.
Une fois le diagramme terminé, on peut l'enregistrer dans un fichier: dans le menu File, choisir Save As
et donner un nom (*.mdl) au fichier.
Exemple de diagrammes Simulink:
50
Simulation avec Simulink

CHOISIR LES PARAMÈTRES DE SIMULATION
Avant de lancer une simulation, on doit choisir les paramètres appropriés au modèle du système. Dans le
menu Simulation, lorsqu'on choisit « Simulation Parameters » ou « Model Configuration
parameters V.2012b », une fenêtre (Simulation Parameters) s'ouvrira. On doit alors choisir les
paramètres pour Solver, Workspace I/O et Diagnostics.
Pour démarrer la simulation, dans le menu Simulation, on choisit Run. On peut aussi cliquer sure le
triangle vert pour démarrer la simulation.
Accès aux Structures

L’accès aux champs de données est obtenu par la spécification du nom de la structure et le champ. Par
exemple, avec
>> ttlString = Graphic.title

D’une façon similaire, une valeur peut assigner aux champs de donnée:
>> Graphic.title = 'Another example'

La même chose peut être obtenue en utilisant la fonction Matlab setfield.
Modification d’une Structure
Une structure peut être modifiée simplement par suppression de champs ou par attachements de champs.
Alors, par exemple,
>> Graphic = rmfield(Graphic, 'color')
51
9. Applications
9.1 Traitement d’image sur Matlab

Image :
Une image est une forme discrète d'un phénomène continu obtenue après discrétisation. Le plus
souvent, cette forme est bidimensionnelle. L'information dont elle est le support est caractéristique de
l'intensité lumineuse (couleur ou niveaux de gris).
I : 0, L  1 0, C  1  0, M 
p
définit une image de L lignes et C colonnes dont l'information portée est définit dans un espace à p
dimensions. Si I est une image binaire, alors  p, M   1,1 Si I est une image en niveaux de gris, alors
p  1 et le plus souvent M  255 Si I est une image couleur, alors p  3 et le plus souvent M  255 .
L’image digitale est représentée sous la forme d’un tableau de pixels. Traditionnellement, on numérote les
lignes de haut en bas et de gauche à droite, et on numérote (0, 0) le coin gauche supérieur de l’image.
Dans les problèmes de vision tridimensionnelle, il est plus commun de placer le pixel (0, 0) au centre de
l’image, là ou l’axe optique perce le plan de l’image (la location précise de ce point est définie par
étalonnage (calibrage) du système optique).
Matlab dispose un « Image Processing Toolbox » pour la lecture, le traitement et l’affichage de plusieurs
types d’images.
>> I = imread(‘cameraman.tif’); % pour lire l’image ‘cameraman’

I c’est une matrice de taille (256x256) qui contient les niveaux de gris de l’image. Les niveaux de gris de
l’image sont des nombres entiers codés sur 08 bit allant de 0 (couleur noire) à 255 (couleur blanche).
>> [nlin,ncol]=size(I); % déterminer la taille de l’image en pixel

>> imshow(I); % Afficher l’image I
>> x=I(30,40); % Accéder au niveau de gris du pixel de la ligne 30 et
% la colonne 40.
Exemple :
1. Ecrire un scripte Matlab qui fait la binairisation (noire et blanc) de l’image I avec un
seuil .
52
2. L’histogramme « H(x) » d’une image «I» traduit le nombre d'apparitions du niveau de gris « x »
dans l'image I. Ecrire un programme Matlab qui calcule l’histogramme de l’image I pour x allant
de 0 jusqu’à 255.
9.2 Résoudre une équation différentielle ordinaire

Matlab possède des fonctions pour résoudre les équations différentielles ordinaires (Ordinary differential
equations, ODE23, ODE45, …).
Pour une équation différentielle:
y' = f(t,y), tϵ[T0, Tfinal]
[Tout,Yout] = ode23(ODEFUN,TSPAN,Y0)
avec
TSPAN = [T0 Tfinal],
Y0 est la condition initiale,
ODEFUN est la fonction f, pour un scalaire T et un vecteur Y
ODEFUN(T,Y)donne en sortie un vecteur colonne qui correspond à f(t,
y).
Exemple :
Résoudre l’équation différentielle suivante :
y’’= (1-y2)y’-y. pour tϵ[0 20], et les conditions initiales: y(0)=2,
y’(0)=2;
9.3 Fonctions de filtrage et de convolution
Une fonction très utile en signal est la fonction filter :
>> Y = filter(B,A,X);
Elle construit le vecteur Y tel que :
y(n) = b(1)*x(n) + b(2)*x(n-1) + ... + b(nb+1)*x(n-nb) - a(2)*y(n-1) - ... - a(na+1)*y(n-na)
Cela correspond donc à un filtrage par un filtre ARMA.
La fonction roots qui calcule les zeros d'un polynôme, peut lui être associée afin de trouver les zéros et les
pôles d'un ARMA ; Par exemple le polynôme P(z)=z3-6z2-72z-27 est représenté par le vecteur :
>> p=[1 -6 -72 -27];
dont les racines sont données par :
>> r=roots(p)
r = 12.1229 -5.7345 -0.3884
53
Pour calculer la valeur du polynôme en certain points on pourra utiliser la fonction polyval :
>> polyval(p,[ 1, exp(j*pi/4), exp(j*pi/2)])

ans = 1.0e+002 *
-1.0400 -0.7862 - 0.5620i -0.2100 - 0.7300i
La fonction poly effectue l'opération inverse de roots : étant donné un polynôme unitaire défini par ses
racines, poly le développe en donnant les coefficients de ses monômes en puissance décroissante.
>> p=poly(r)
p = 1.000 -6.000 -72.000 -27.000
D'autre part, si l'argument de poly est une matrice, la fonction renvoie les coefficients du polynôme
caractéristique de cette matrice.
La fonction conv effectue elle la convolution de deux vecteurs :
>> Z = conv(X,Y);
Cette convolution est complète dans le sens où la longueur de Z est la somme des longueurs de X et Y
moins 1. Elle peut aussi être interprétée comme le développement du produit de deux polynômes.
En dimension 2 les fonctions correspondant à filter et conv sont filter2 et conv2.
Une fonction fournie mais dont l'utilisation doit vous sembler délicate est la fonction deconv. Elle est
sensée effectuer une déconvolution, ce qui peut sembler ambitieux (pour ceux qui ont suivi un cours sur
les problèmes inverses). Néanmoins cette fonction est utile pour la division de polynômes.
9.4 Transformation de Fourier
La transformation de Fourier rapide (Fast Fourier Transform) est implémentée sous Matlab et s'appelle fft,
de même on a la transformation inverse ifft; en dimension 2 on a fft2 et ifft2. Matlab nous donne la FFT
pour les fréquences normalisées sur [0, 1], pour les représenter sur [-0.5, 0.5] on utilisera la fonction
fftshift.
9.5 Génération de nombres pseudo-aléatoires
Matlab possède deux instructions pour générer des nombres pseudo-aléatoires : rand et randn.
>> Y=rand(p,q);
Génère une matrice de taille p×q contenant des nombres uniformément répartis sur l'intervalle [0,1]. De
même randn génère une matrice de taille p×q contenant des nombres répartis selon une loi gaussienne de
moyenne nulle et de variance unité. Ces générateurs de nombres pseudo-aléatoires sont toujours activés
avec la même graine au démarrage de Matlab. On veillera à utiliser l'option seed si l'on veut, pour
commencer, une autre séquence que celle offerte par défaut.
Matlab possède des fonctions permettant d'analyser des nombres pseudo-aléatoires. Ainsi les fonctions
mean, std, et cov, fournissent des estimations de la moyenne, de l'écart-type et de la matrice de covariance
de vecteurs et matrices correspondants à des réalisations de variables aléatoires.
54
10. Les structures

Les structures sont des champs par lesquelles différents types de données peuvent être combinés dans une
entité logique. L’accès à ces données est obtenu par noms au lieu des indices numériques comme le cas
pour les matrices
Définition des Structures
On illustre par un exemple. Supposant qu’on veut combiner certaines propriétés graphiques MATLAB
comme :
 Le titre d’une courbe (graphique)

 Le label sur l’axe x
 Le label sur l’axe y
 Le nombre de courbes
 La couleur des courbes
 Quadrillage activé (oui=1/non=0),
 L’échelle des x à afficher, et
 L’échelle des y à afficher.
Ce listing inclus des nombres, des vecteurs numériques et des chaines de caractères. On définit la
structure Graphic de la façon suivante:
>> Graphic.title = 'Example';

>> Graphic.xlabel = 'time / s';
>> Graphic.ylabel = 'voltage / V';
>> Graphic.num = 2;
>> Graphic.color = ['r', 'b'];
>> Graphic.grid = 1;
>> Graphic.xVals = [0,5];
>> Graphic.yVals = [-1,1];
>> whos
Name Size Bytes Class
Graphic 1x1 1096 struct array
Grand total is 42 elements using 1096 bytes
Bien sûr, ces instructions ont été utilisées pour créer un seul élément (1 × 1 array) Graphic, qui contient
toute les informations, comme montré par l’appel de Graphic:
>> Graphic
Graphic =
title: 'Example'
xlabel: 'time / s'
ylabel: 'voltage / V'
num: 2
color: 'rb'
grid: 1
55
xVals: [0 5]
yVals: [-1 1]
Une structure peut être aussi définit en utilisant la fonction Matlab struct. Par exemple :
>> Graphicempty = struct('title', [], 'xlabel', [],'ylabel', [],

'num', [],'color', [], 'grid', [],'xVals', [], 'yVals', [])
11. Fonctions élémentaires Matlab
56
57
58
59
60
61
62
63
64
65
66
67

Introduction A Matlab PAGE 41

Transféré par

Informations du document

Titre original

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

Introduction A Matlab PAGE 41

Transféré par

Droits d'auteur :

Formats disponibles

U.E.R.

Module : Introduction à Matlab

1° Année Ing. Génie Electrique

Par : Col Djeddou Mustapha

Tables des Matières

0. INTRODUCTION ............................................................................................................................................................ 3

Figure 1 : Architecture de Matlab.

L’environnement Matlab se présente sous la forme de plusieurs fenêtres, essentiellement la fenêtre de

Figure 2: Fenêtre principale de Matlab

2. Les variables sous Matlab

2.1 Variables spéciales

2.2 Nombres complexes

Autres fonctions : conj, isreal

Dans un triangle, a = 18 cm, b = 35 cm et c = 50 cm. Définir a, b et c comme variables et calculer alors

Par défaut, le vecteur est une ligne à plusieurs colonnes

 vecteur ligne par énumération des composantes :

>> v = [1 3.4 5 -6]

>> x = [0 : pi/10 : pi]

2.1991 2.5133 2.8274 3.1416

 génération de vecteurs métriques

>> x = linspace(0, pi, 11)

>> % x = linspace(0, 1, 11)*pi donne le même résultat

>> x(3) % 3eme élément du vecteur x

>> x(2 : 4) % un bloc de composantes

>> x([8 3 9 1]) % une sélection de composantes ( on les désigne avec un

??? Index exceeds matrix dimensions.

 Accolage de deux vecteurs :

On peut faire plus compliqué :

>> d = [a(2 : -1 : 1) b] % on accole b avec une portion de a dans l'ordre renversé

Notez la différence entre ( ) et [ ].

3.2 Les Matrices

 Par énumération des éléments

>> m1 = [1 2 3 ; 4 5 6 ; 7 8 9] % on sépare les lignes par des points-virgules

>> m2 = [1 : 1 : 3 ; logspace(0, 1, 3)]

1.0000 2.0000 3.0000

 sum, transpose, et diag

La première affirmation à essayer est

Produit un vecteur colonne contenant la somme des rangées

 Expansion de la taille d’une matrice

Si on accède à un élément externe à une matrice, c’est une erreur

??? Index exceeds matrix dimensions

Cependant, si on ajoute un élément externe à la matrice, la taille de la matrice augmente pour

On peut aussi étendre une matrice en assignant une série d’éléments

 Suppression de Rangées et de Colonnes

Supprimant la seconde colonne de X,

donne une erreur.

 Concaténation des matrices

260 260 260 260 260 260 260 260

Une telle opération agit sur chaque élément de la matrice :

>> m2'*10 % de même : 4*m2 m2 – 10 m2 / 4

??? Error using ==> mpower

Matrix must be square.

Dans ce cas, Matlab veut calculer le produit matriciel m2 * m2

1.0000 4.0000 9.0000

Opérations entre matrices

>> m1 % rappelons la définition de m1

>> m2 % rappelons la définition de m2

 Multiplication élément par élément:

>> m2.*m3 % (m2 et m3 ont les mêmes dimensions)

>> m2 / m3 % division matricielle à droite

>> m2 \ m3 % division matricielle à gauche (voir algèbre linéaire)

 Division élément par élément:

>> m2 ./ m3 % chaque élément de m2 est divisé par l'élément équivalent de m3

>> m2'10 % de même : 4m2 m2 – 10 m2 / 4