Vous êtes sur la page 1sur 15

< M A T L A B >

Copyright 1984-2004 The MathWorks, Inc.


Version 7.0.0.19901 (R14)
May 06, 2004
puis un double >> signifie que MATLAB est dans l’attente d’une commande ou instruction.
Chapitre 1
Chaque commande entrée par l’utilisateur est immédiatement interprétée à la suite d’un retour chariot
Exemple : tapez les instructions suivantes :
MATLAB - Partie 1 % ceci est un commentaire
3 * 6
cos(pi)
MATLAB (MATrix LABoratory) est un logiciel de calcul numérique développé par la société Mathworks z1 = 3 - i % variable de type complexe
(site WEB : www.mathworks.com). z1 * z1 % carré de z1
Ce logiciel a été développé autour d’un noyau de calcul matriciel composé de librairies écrites en Vous pouvez aussi écrire ces commandes dans un fichier MATLAB afin de les conserver :
FORTRAN : LINPACK et EISPACK – créer un nouveau fichier script (M-file),
Dans cette introduction à MATLAB, les points suivants seront passés en revue : – copier/coller les commandes ci-dessus (de préférence les copier à partir du document HTML),
– démarrage de MATLAB – sauvegarder le fichier en le nomnant par exemple partie1.m,
– types de données et variables – pour exécuter l’ensemble du fichier, taper la touche F5 (Run),
– opérations de base – pour n’exécuter que certaines commandes du fichier, les sélectionner à la souris, puis cliquer avec le
– programmation bouton de droite, et choisir l’item Evaluate Selection (raccourci - touche F9).
– scripts et fonctions
– graphique Par la suite, copiez les différents exemples
– interaction avec l’utilisateur
Pour certains points, une description plus détaillée peut être trouvée dans l’aide en ligne (help). (apparaissant en police de largeur fixe)
dans un script ou dans la fenêtre de commandes pour les exécuter.
1.1 Démarrage de MATLAB MATLAB fait la différence entre minuscules et majuscules.
Les noms des variables, routines et commandes prédéfinies dans MATLAB sont en lettres minuscules.
A l’UFR-IMA, MATLABest installé sur les postes Windows et sur le serveur jpp (accessible à partir des
Les noms des variables et routines définies par l’utilisateur doivent commencer par une lettre suivie de
terminaux SunRay), et est disponible dans toutes les salles de TP.
lettres, chiffres et/ou caractère souligné
– sous Windows : double-cliquer sur l’icône MATLAB.
MATLAB dispose d’un certain nombre de routines prédéfinies (par ex. cos). On retrouve notamment les
– sous UNIX, se loguer sur jpp, puis taper la commande matlab
fonctions mathématiques du langage C.
Un environnement de développement intégré (IDE) s’ouvre avec une fenêtre principale avec menus et
boutons d’action et différentes sous-fenêtres :
L’item MATLAB Help du menu Help (touche F1) permet d’ouvrir l’aide générale. N’hésitez pas à l’utiliser
– la fenêtre de commandes (Command Window),
par la suite.
– la fenetre de l’historique des commandes (Command History),
– la fenetre du répertoire courant (celui de travail) (Current Directory),
– la fenetre des variables définies (Workspace). 1.2 Types et variables
Commencez par créer dans votre répertoire personnel un répertoire nommé MATLAB, puis placez-vous 1.2.1 Les types
dans ce répertoire à l’aide du bouton ... de la fenêtre principale, ou bien en tapant la commande
Type numérique
cd Z:\MATLAB % sous Windows
MATLAB utilise le type réel et complexe pour les valeurs numériques, les fonctions prédéfinies s’appliquant
cd ~/MATLAB % sous UNIX
en général aussi bien aux réels qu’aux complexes :
Ce répertoire servira à stocker l’ensemble des scripts que vous écrirez. Exemple : calcul de e, ei 4 et i2 :
π

Afin que ce répertoire soit connu ensuite, il faut l’ajouter à la liste des répertoires de travail définis exp(1)
sous MATLAB : aller à l’item Set Path ... du menu File, dans le dialogue Set Path, cliquer sur les exp(i*pi/4)
boutons Add Path puis choisir le répertoire, et enfin valider en cliquant sur le bouton Save. j*j

Dans la fenêtre de commandes, un message similaire à celui ci-dessous apparait : Note : certaines constantes sont prédéfinies (pi=π, i=j= −1).

1 2
Type booléen 1.2.3 Vecteurs
Les valeurs booléennes sont codées en utilisant les deux valeurs numériques : 0 pour FAUX et 1 pour Pour définir un vecteur, il faut mettre les différents élements entre crochets et séparés
VRAI. – soit par un espace pour un vecteur-ligne,
– soit par un point-virgule ( ;) pour un vecteur-colonne,
Exemple : deux expressions booléennes
Exemple : création du vecteur-ligne t de dimension 7 et du vecteur-colonne v de dimension 5 :
3 < 8
3 > 8 t = [0 3 6 9 12 15 18], v = [1;3;7;9;5]
1 & 1 // opérateur ET : &
1 | 1 // opérateur OU : | Note : à l’affichage à l’écran, la différence est faite entre vecteur-ligne et vecteur-colonne.
~ 0 // opérateur NON : ~ MATLAB étant basé sur des routines en FORTRAN, les tableaux commencent tous à l’indice 1. Pour
accéder aux éléments d’un vecteur, il suffit d’indiquer l’indice entre parenthèses à la suite du nom du
Type caractère vecteur.

MATLAB permet de manipuler les caractères et chaı̂nes de caractère (cf. Chaı̂nes de caractères plus loin) Exemple : affichage de différents éléments des vecteurs t et v :

t(1),t(2),t(6),v(1),v(4)
1.2.2 Variables scalaires
On peut alors définir des variables numériques de type réel ou complexe et leur affectant une valeur : On peut aussi modifier un seul élément du tableau en utilisant cette notation :

Exemple : définitions de deux variables x et z t(2) = 7


v(3) = 5
x = 3
z = exp(1-i) Plus intéressant est la possibilité d’accèder à une partie du tableau correspondant à une suite d’indices :
Note : si on ne souhaite pas que le résultat soit écrit à l’écrit, il suffit de terminer l’instruction par un Exemple : on extrait le vecteur t1 de dimension 4 correspondant aux indices 2 à 5 du vecteur t :
point-virgule ( ;)
t1 = t(2:5)
Exemple :
ou bien tous les éléments d’un indice donnés à la fin du vecteur :
x = 7.3e-2;
z = 3+2*i; t2 = t(4:end) \\ end signifie dans ce cas le dernier indice du tableau

puis pour connaitre la valeur d’une variable, il suffit de tapez son nom.
Exemple : on modifie les éléments d’indices 1 à 3 du vecteur v :
Exemple :
v(1:3) = [4;8;0]
x
z puis les élements d’indices 2 et 4 :
y
v([2 4]) = [5;7]
Note : y n’ayant pas été définie, cela est indiqué.
On peut écrire plusieurs instructions sur une même ligne en séparant chaque instruction par une virgule On peut aussi former des vecteurs à partir d’autres vecteurs en les concatènant, c’est à dire en les
(,) ou un point-virgule ( ;) mettant les uns à la suite des autres et en utilisant les crochets ([ ]).
Exemple : création d’un vecteur-ligne de taille 10 en concatènant un vecteur-ligne de taille 4 puis
x = 8; y = 5; deux vecteurs-ligne de taille 3 :
x , y
v1 = [1 2 3 4], v2 = [7 6 0], v3 = [v1 v2 v2]
Note : Notez la différence entre la virgule (,) et le point-virgule ( ;)
Note : si les vecteurs à concatèner sont des vecteurs-colonnes, il faut alors les séparer par des points-
MATLAB étant au départ un logiciel pour manipuler des matrices, on peut aussi définir des vecteurs virgules.
(tableaux à une dim.) et des matrices (tableau à deux dimensions)
Exemple : création d’un vecteur-colonne u3 à partir de deux vecteurs-colonnes u1 et u2 :

u1 = [3;5;6], u2 = [9;6], u3 = [u1;u2]

3 4
La concaténation permet par exemple d’insérer un élément dans un vecteur. Note : une instruction peut être ”coupée” pour tenir sur plusieurs lignes en utilisant trois points (...)
en fin de ligne
Exemple :

v = [3 6 1 8 4] % un vecteur de 5 éléments On accède alors à chaque élément de la matrice en indiquant entre crochets la ligne et la colonne séparée
v = [2 v] % insertion de la valeur 2 en début de tableau par une virgule (,) .
v = [v 7] % insertion de la valeur 7 en fin de tableau Comme pour les vecteurs les indices de lignes et colonne commencent à 1.
n=3; Exemple :
v = [v(1:n-1) 9 v(n:end)] % insertion de la valeur 9 à l’indice n=3
A(3,1)
ou bien supprimer un élément B(2,3) = 8
Exemple : On peut aussi accéder à une partie de la matrice en utilisant la même notation que pour les vecteurs.
n = 5; Exemple :
v = [v(1:n-1) v(n+1:end)] % suppression de l’élément d’indice n
B(1,2:3), B(1:2,2:4), B(:,2:4), B(1,:)
Note : 1:0 représente un intervalle vide et correspond au tableau vide [] Note : l’utilisation du double-point ( :) seul signifie ”toutes les lignes” ou ”toutes les colonnes”.

La notation avec le double-point ( :) peut aussi être utilisée pour construire des vecteurs-lignes dont Exemple : remplir la deuxième ligne de la matrice B avec des valeurs nulles :
les éléments forme une suite arithmétique (linéaire) :
B(2,:)=zeros(1,4)
– soit une suite avec un pas de 1 : vmin :vmax
On peut comme pour les vecteurs, créer des matrices par blocs (à partir de tableaux).
Exemple : un vecteur contenant les 10 premiers entiers :
t = 0:9 Exemple :
– soit une suite avec un pas quelconque (non nul) : vmin:pas:vmax (le pas est indiqué entre les deux
bornes) A = [1 2;4 5], u = [3;6], v = [7 8], B = [A u;v 9]
kπ Comme pour les vecteurs, une fonction f appliquée à une matrice M donne une matrice de mêmes
Exemple : le vecteur-ligne t avec les valeurs de 0 à 2π et le vecteur-ligne u défini avec un pas
4 dimensions dont les éléments sont les images des éléments de la matrice M par la fonction f .
négatif :
Exemple : application de la racine carrée aux éléments de B :
t = 0:pi/4:2*pi
sqrt(B)
u = 10:-1:1
Il est possible aussi de créer des hyper-matrices, tableau de dimension supérieurs à 2.
Si on applique une fonction mathématique f à un vecteur v, on obtient un vecteur de même dimension
dont les éléments sont les images des éléments de v par la fonction f : Exemple : création d’une hyper-matrice nulle de dimensions 2 × 3 × 5 :

Exemple : fonction sinus appliquée aux éléments du vecteur t et fonction racine carrée appliquée aux H = zeros(2,3,5)
éléments du vecteur u.

sin(t) 1.2.5 Chaı̂nes de caractères


sqrt(u) Une chaine de caractères est un vecteur-ligne donc chaque élément est un caractère, une chaine est
délimitée par des quotes simples (’) et peut contenir des espaces et autres caractères spéciaux.
1.2.4 Matrices Exemple :
On définit de manière analogue des matrices (tableaux à deux dimensions) en décrivant une matrice
ligne par ligne (dans une même ligne les éléments sont séparés par un espace) ; les lignes étant elles-mêmes s = ’Bonjour a tous’
séparées par un point-virgule ( ;) . s(1), s(2), s(4:10)
s(4:7) = ’soir’, s2 = ’ et bienvenue’
Exemple : A matrice de dimensions 3 × 2 et B matrice de dimensions 2 × 4 : s3 = [s s2]

A = [ 2 5 ; 4 8 ; 7 9] Note : la manière de concatèner deux chaines l’une à la suite de l’autre en utilisant les crochets est la
B = [ 0 1 2 3 ; ... même que pour les vecteurs-ligne.
-1 0 1 -3] Il est possible d’évaluer une chaine de caractères contenant une instruction MATLAB à l’aide de la routine
eval
Exemple :

5 6
t = linspace(0,2*pi,13); 1
f = ’cos’; 1 1
s = [’x =’ f ’(t)’] 1 2 1
eval(s) 1 3 3 1
% on change de fonction 1 4 6 4 1
f = ’sin’; ....
s = [’x =’ f ’(t)’]
avec :
C(1,1) = 1
1.2.6 Structures
C(k,1) = C(k,k) = 1
Une structure est un type de donnée qui est un regroupement de données de types quelconques, chaque C(k,l) = C(k-1,l-1)+C(k-1,l) pour l compris entre 2 et k-1
donnée de la structure ou champ ayant un identificateur propre.
Une structure est créée en indiquant la liste des champs avec pour chacun l’identificateur (sous forme On peut par exemple construire le triangle de Pascal avec n lignes à l’aide d’un cell array avec n
d’une chaı̂ne de caractères) suivie de sa valeur. éléments, l’élément k du cell array représentant la ligne k du triangle de Pascal, et est un tableau de k
valeurs :
Exemple : une structure représentant une date sous la forme du jour, du numéro de jour, du mois et
de l’année : n = 10;
C = cell(n,1);
date1 = struct(’jour’, ’Lundi’, ... C{1} = [1]; % la première ligne
’numj’, 27, ... C{2} = [1 1]; % la deuxième ligne
’mois’, ’Septembre’, ...
’annee’, 2004) % les lignes suivantes en utilisant la récurrence
for k=3:n
% accès aux différents champs de la structure C{k} = [1 C{k-1}(1:k-2)+C{k-1}(2:k-1) 1];
date1.jour % \____________ ___________/ %
date1.numj % \/ %
date1.mois % = C{k}(2:k-1) %
date1.annee end
% copie d’une structure % affichage de C
date2 = date1 for k=1:n
fprintf(1, ’%5d ’,C{k}); fprintf(1, ’\n’); % affichage de la ligne k
% modification d’un champ end
date2.jour = ’Mardi’
date2.annee = 2005 Un cell array peut servir pour stocker un tableau de chaı̂ne de caractères.
Exemple :
1.2.7 Tableaux de cellules
Les tableaux vus jusqu’à présents sont des tableaux ”simples”, chaque élément du tableaux étant une Nom = cell(4,1);
valeur scalaire (réel ou complexe). Nom{1} = ’Dupond’;
Nom{2} = ’Durand’;
Il est possible de créer des tableaux tels que chaque élément (ou cellule) peut contenir n’importe quel Nom{3} = ’Martin’;
type de données (scalaire, tableau, structure, ...) : le tableau de cellules (cell array). Nom{4} = ’Chevalier’;
L’accès à chaque élément d’un cell array se fait en indiquant les indices entre accolades {} et non pas
entre parenthèses () . Prenom = cell(4,1);
Prenom{1} = ’Pierre’;
Prenom{2} = ’Catherine’;
Exemple : Triangle de Pascal - il s’agit d’un tableau C(n,p) des coefficients du binôme Prenom{3} = ’Jean-Louis’;
Prenom{4} = ’Anne’;
n!
C(n, p) = Cnp = pour 0 ≤ p ≤ n
p! (n − p)!
% affichage des différentes identités
où la première ligne contient un élément (tableau à 1 élément), la deuxième ligne contient deux éléments for i=1:length(Nom)
(tableau à 2 élément), ... , la n-ième ligne contient n éléments. fprintf(1, ’%s %s\n’, Prenom{i}, Nom{i});
end

7 8
1.2.8 Définition et suppression des variables puis testez les opérations suivantes :
Pour connaitre les variables définies par l’utilisateur (par affectation), on utilise la commande who pour A + B1
avoir la liste simple des variables ou la commande whos pour avoir la liste avec le type et les dimensions B1 + C
de chaque variable. B1 - B2
u + v
Exemple :
u + u + u
who Note : seules les opérations sont faites lorsque les dimensions concordent, dans le cas contraire, notez le
whos message d’erreur Matrix dimensions must agree.
Note : la variable ans correspond au résultat de la dernière expression évaluée.
Note : il y a une exception dans le cas où l’un des deux opérandes est un scalaire : dans ce cas, le
résultat est le tableau obtenu en faisant l’opération entre chaque élément du tableau et le scalaire.
Pour supprimer une, plusieurs ou toutes les variables, on utilise la commande clear.
Exemple :
Exemple : suppression de la variable s, puis suppression des variables A, B, u et v, et enfin suppression
de toutes les variables. 2 + A
A - 2
who 1 - u
clear s
who Multiplication entre vecteurs/matrices (*)
clear A B u v
who si les deux opérandes sont des tableaux alors le produit matriciel est effectué (si les dimensions
clear concordent).
who
Exemple : exécutez les instructions suivantes et notez les opérations faisables et celles qui ne le sont
pas :
1.3 Opérations de base sur les scalaires, vecteurs et matrices
A * B1
1.3.1 Scalaires B1 * A
B1 * C
Les opérations de base sur les scalaires sont :
addition (+) , soustraction (-) , multiplication (*) , division (/) , puissance (^) B1 * B2
et sont les opérations habituelles sur les réels/complexes avec les priorités habituelles. C * C
A * u
32 1
Exemple : calcul de 2 + 5 × 6 − et (1 − 2 i)−2 = v * B
9 (1 − 2 i)2
u * u
2 + 5*6 - 3^2/9 u * v
(1-2*i)^(-2) v * u

Note : l’ensemble des variables couramment définies est visible dans la fenêtre ’Workspace’ Transposée (’)
le symbole ”quote” (’) à la suite d’une matrice donne sa transposée.
1.3.2 Vecteurs/Matrices
Exemple :
Dès qu’un opérande est un vecteur/matrice, le calcul matriciel est utilisé.
A’
Addition (+) ou soustraction (-) B1’
C’
somme/différence élément par élément, les deux opérandes devant être de mêmes dimensions.
u’
Exemple : on définit quatre matrices A, B1, B2, C, un vecteur-ligne (=matrice à une ligne) v et un u’ * u
vecteur-colonne (=matrice à une colonne) u.

A = [1 2 3;4 5 6], B1= [0 1;1 0;1 1], B2= [1 2;2 3;5 9]


C = [1 2;1 3], v = [2 4 5], u = [1;2;1]

9 10
Puissance d’une matrice carrée (^) 1.3.4 Quelques fonctions usuelles sur les matrices
le symbole ”puissance” (^) s’applique à une matrice carrée. Cette partie présente les principales fonctions élémentaires (pour l’ensemble des fonctions, se référer à
2 3 −1 −1
la partie Elementary matrices and matrix manipulation - help elmat ).
Exemple : calcul de C , C , C (l’inverse de C) et C C :
• sum(v) ou sum(M) : calcule la somme des éléments d’un vecteur v ou la somme des éléments pour
C^2
chaque colonne d’une matrice M
C^3
C^(-1) Exemple :
C * C^(-1)
u = [1 2 4], v = [2;4;-6], A = [1 2 3;4 5 6]
Note : une puissance négative peut être utilisée seulement pour une matrice inversible. sum(u), sum(v), sum(A), sum(sum(A))

Multiplication/division élément par élément (.*) Note : sum(A) donne un vecteur de dimension égale au nombre de colonnes de A, chaque élément du
résultat étant la somme des éléments de la colonne correspondante, sum(sum(A)) donnant alors la somme
en utilisant le point devant * ou /, on peut pour deux matrices de mêmes dimensions, obtenir une des éléments de A .
matrice de mêmes dimensions obtenue en faisant l’opération élément par élément :
Exemple : • zeros(n1,n2) : crée une matrice nulle (la matrice est carrée si une seule dimension est indiquée)
Exemple :
B1 .* B2, C .* C, u .* u
3 .* A, 3 ./ A, u ./ 2 zeros(3,6), zeros(4)
Note : la puissance élément par élément peut être faite en utilisant point-circonflexe (.^). • ones(n1,n2) : crée une matrice dont tous les éléments sont égaux à 1 (la matrice est carrée si une
Exemple : seule dimension est indiquée)
Exemple :
C .^ 2, u .^ 3
ones(3,6), ones(4)
1.3.3 Lecture/sauvegarde de tableaux sur fichier
• eye(n) : crée une matrice identité de dimension n
Il est possible de lire un tableau à partir d’un fichier texte ou bien d’écrire un tableau dans un fichier
texte. Exemple :

Ecriture I4 = eye(4)

La commande save nom fichier T -ASCII permet de sauvegarder le tableau T dans le fichier nom fichier • diag : crée des matrices carrées diagonales à partir de vecteurs
au format texte (ASCII).
diag([2 4 7 3]) %valeurs sur la diagonale principale
Exemple : sauvegarde de la matrice B1 dans le fichier data.txt : diag([2 4 7 3],-1) % valeurs sur la diagonale à gauche de la diag. principale
diag([2 4 7 3],2) % valeurs sur la diagonale à distance 2 de la diag. principale
save ’data.txt’ B -ASCII
• rand(n1,n2) : crée une matrice dont tous les éléments sont des valeurs aléatoires entre 0 et 1 (la
Lecture matrice est carrée si une seule dimension est indiquée)
La fonction T = load(nom fichier) lit les valeurs du fichier nom fichier et les stocke dans la variable Exemple :
T.
Le fichier lu doit contenir le même nombre de valeurs sur chaque ligne. rand(3,6), rand(4), rand(1)
Exemple : lecture de la matrice B2 à partir du fichier data.txt : • size(M ,1) et size(M ,2) permettent de connaitre respectivement le nombre de lignes et le nombre
de colonne d’une matrice M , length(v) donne la dimension d’un vecteur.
B2 = load(’data.txt’)
Exemple :
Remarque
size(A,1), size(A,2), length(v)
Il est possible d’utiliser les routines fopen, fscanf, fprintf et fclose similaires au langage C afin de
faire des entrées-sorties sur fichier.

11 12
• linspace(xmin,xmax,n) : crée un vecteur-ligne de dimension n dont les valeurs sont répartis Note : tout calcul dans MATLABse faisant de manière numérique, une erreur (faible) apparait à l’issue
linéairement (unifomrmément) entre xmin et xmax. Par défaut n est égal à 100. des différents calculs.
linspace(xmin,xmax,n) est équivalent à xmin :(xmax-xmin)/(n-1) :xmax
• Résolution de système linéaire : les opérateurs / et \ permet la résolution de système(s) linéaire
Exemple :
X = B/A // donne la solution de l’équation X A = B
linspace(0,9), linspace(0,2,5), linspace(3,8,11) X = A\B // donne la solution de l’équation A X = B

Cette fonction est très utile lorsqu’on souhaite créer un certain nombre de valeurs de x équiréparties
Exemple :
dans un intervalle puis évaluer une fonction y = f (x).
Exemple : calcul de 20 valeurs de y = cos(x) pour x ∈ [0, 2 π] A = [1 2;3 4]
b1 = [2 3], b2 = [2;3]
x = linspace(0,2*pi,20), y = cos(x) x1 = b1/A, x2 = A\b2
% vérification
meshgrid(u,v) : crée une grille de points rectangulaire à l’aide de valeurs de paramètres (u i , vj ) : x1*A, A*x2 % on obtient b1 et b2
(xi,j , yi,j ) = (ui , vj ). b1*inv(A), inv(A)*b2, % on obtient x1 et x2
Cela permet de générer des ensembles de points (x, y) définis suivant une grille rectangulaire, qui
peuvent être utilisés pour évaluer des fonctions à deux variables. Les différentes routines d’algèbre linéaire sont consultables dans la partie Matrix functions - numerical
linear algebra - help matfun.
Exemple : évaluation de la fonction z = f (x, y) = x + y 2 sur [0, 2] × [1, 4] :
1.3.5 Exercices
[x,y] = meshgrid(0:0.5:2,0:1:4), z = x + y .^ 2
Exercice 1
• sparse : cette fonction permet de créer des matrices creuses (avec beaucoup de valeurs nulles).
Ecrire les instructions pour construire les vecteurs suivants :
Exemple : créer une matrice tridiagonale de dimension n=8 avec la valeur 2 sur la diagonale et la
valeur 1 sur la sur-diagonale. u1 = (3 6 9 . . . 27 30) u2 = (−π/2 −π/4 0 π/4 π/2 . . . 11π/4 3π) u3 = (0 1 4 9 . . . 81 100)

n = 8; Exercice 2
M = sparse(n,n);
Ecrire les instructions afin de construire la matrice carrée suivante de dimension n :
for i=1:n, M(i,i) = 2; end
2 1 0 ... ... ... 0
 
for i=2:n, M(i-1,i)= 1; end
M % affichage de M sous forme ’sparse’  1 2 ..
 1 . 

full(M) % affichage de M sous forme normale  0 1 ... ...
 .. 
M*M % calcul du carré de M . 
 .. . . . . . . 0 ...
 
A= . . . . 
full(M*M) 
 .. .. ..
 
 . . . 1 0 
• matrix(A,n,p) : redimensionnement d’une matrice. Cette routine prend les valeurs de la matrice A

 .
 ..

colonne par colonne, pour reformer une matrice avec n lignes et p colonnes. 1 2 1 
0 ... ... ... 0 1 2
A = [1 4 7 10;2 5 8 11;3 6 9 12]
reshape(A,2,6) Exercice 3
reshape(A,4,3)
Ecrire les instructions afin de construire la matrice de Vandermonde de degré n (dimension n + 1) :
reshape(A,1,12)
 
reshape(A,4,5) % ERREUR 1 0 0 0 ... 0
 1 1 1 1 ... 1 
Note : A( :) transforme une matrice en vecteur-colonne.
 
n 
   1 2 4 8 ... 2 
A = (Ai,j )1≥i,j≥n+1 = (i − 1)j−1 =  1 3 9 27 . . . 3n 
• inv : inverse d’une matrice
 
 .. .. .. .. .. 
 . . . . . 
Exemple : 1 n n 2 n3 . . . n n

inv(A), inv(A)*A, A*inv(A) Exercice 4


n!
Calculer n! (n factoriel) et Cnk =
k!(n − k)!

13 14
1.4 Programmation avec MATLAB else
...
MATLAB dispose d’instructions similaires aux langages de programmation classique afin de réaliser des end
programmes sous forme de scripts (fichiers .m).
Note : l’instruction switch permet d’écrire un test multiple où la condition dépendant de la valeur
1.4.1 Entrée-sortie d’une expression.
Les opérateurs de comparaison sont ceux utilisés en langage C (==, <=, >=, <, >) sauf pour ”différent
La routine disp(donnee) permet d’écrire à l’écran la valeur d’une expression. de” qui se note ∼= (au lieu de != en C).
Exemple :
Les opérateurs booléens sont &, |, ∼, respectivement pour l’opérateur ET, l’opérateur OU et l’opérateur
x = 1:8; NON.
disp(x) Exemple : quelques expressions booléennes
disp(5*9)
disp(’Ceci est du texte’) x = 9
x < 8
On peut aussi utiliser la routine fprintf similaire à celle du langage C. (x >= 0) & (x < 10)
Exemple : ~(x == 7)

x=[1 2 3;4 5 6] Exemple :


fprintf(1, ’%f %f\n’, x);
fprintf(1, ’%3d %3d %3d\n’, x’); x=input(’Entrer un reel : ’);
fprintf(1, ’%10.3e\n’, x’); if x<0
y = -1;
Note : fprintf écrit les valeurs d’une matrice colonne par colonne. elseif x>0
y = 1;
La routine x=input(info) permet de lire à l’écran une valeur scalaire ou un tableau et de le stocker else
dans la variable x. y = 0;
info représente une chaine de caractère qui est écrite avant que l’utilisateur entre la valeur de x. end
Exemple : fprintf(1, ’Signe de x = %d\n’ ,y);

x = input(’Entrez un vecteur-ligne : ’); Ce script lit une valeur x, calcule puis affiche son signe y.
normex = sqrt(x * x’);
fprintf(1, ’Norme de x = %f\n’, normex) 1.4.3 Boucle conditionnelle
La boucle conditionnelle est celle où le test est fait en premier (tant que ... faire ...)
1.4.2 Test while test
MATLAB dispose d’une instruction effectuant un test puis un branchement conditionnel. liste instructions
– test à une alternative (si ... alors ...) : end
if condition Exemple : créer le fichier suivant exemple while.m :
liste instructions
end x=input(’Entrer un reel : ’);
– test à deux alternatives (si ... alors ... sinon ...) : while x >= 0
if condition disp(’Racine de x = ’), disp(sqrt(x));
liste instructions x=input(’Entrer un reel : ’);
else end
liste instructions
end Ce script formé d’une boucle lit des valeurs réelles positives et affiche leurs racine carrée ; la boucle
– tests en cascade (si ... alors ... sinon si ... alors ...) s’arrète dès qu’une valeur lue est strictement négative.
if condition1
liste instructions
elseif condition2
liste instructions

15 16
1.4.4 Boucle incrémentale 1.4.5 Scripts avec paramètres : fonctions MATLAB
La boucle incrémentale correspond à la boucle où on utilise un compteur de boucle (pour ... variant de Il est possible d’écrire des scripts avec des paramètres d’entrées et/ou des paramètres de sorties afin de
... à ...) créer de nouvelles routines.
for variable = valeur initiale :valeur finale Un tel script s’écrit en indiquant en début de script un en-tête de la forme
liste instructions function [liste sorties]=nom (liste entrees)
end avec :
Dans ce cas, la variable varie de la valeur initiale à la valeur finale avec un pas de 1. – nom : le nom de la routine,
– liste entrees : la suite des paramètres d’entrée (séparés par des virgules). Si n’y a pas de paramètres
for variable = valeur initiale :pas :valeur finale d’entrée, on ne met pas les parenthèses.
liste instructions – liste sorties : la suite des paramètres des sorties (séparés par des virgules). Si n’y a pas de paramètres
end de sortie ou un seul paramètre de sortie, on ne met pas les crochets.
Dans ce cas, la variable varie de la valeur initiale à la valeur finale avec le pas spécifié (non nul).
Exemple : script resol trinome.m avec deux paramètres d’entrée et deux en sortie :
Exemple : création d’une matrice M de dimension 5 × 10 avec M(k,l)=k-l .

for k=1:5, for l=1:10, M(k,l)=k-l; end; end; % resol_trinome : résolution de l’équation x*x+b*x+c = 0
% syntaxe [r1,r2] = resol_trinome(b,c)
disp(M)
% Entrées : b,c = coefficients du binome
Note : l’instruction continue permet d’aller à la fin de la liste d’instructions d’une boucle for ou % Sorties : r1,r2 = les deux racines
while, function [r1,r2] = resol_trinome(b,c)
et l’instruction break permet de sortir d’une boucle for ou while.
delta = b*b-4*c;
Exemple : r1 = (-b-sqrt(delta))/2;
r2 = (-b+sqrt(delta))/2;
m = input(’Entrer un entier > 1’);
Créez ce fichier avec l’éditeur, puis exécutez les instructions suivantes :
% test tous les nombres entre 2 et m
% et écrit ceux qui sont premiers [r1,r2] = resol_trinome(-6,5) // deux racines distinctes
for n=2:m [r1,r2] = resol_trinome(-6,9) // racine double
%%% test si n est un nombre premier %%% [r1,r2] = resol_trinome(0,4) // racines complexes

% cas n pair Note : IMPORTANT : le nom de la routine corespond au nom du fichier (sans l’extension .m) et non
if (n==2) pas au nom dans l’en-tête de la fonction. Pour éviter toute confusion, utiliser le même nom pour le fichier
fprintf(1, ’%d est premier\n’, n); .m et dans l’en-tête de la routine.
continue % aller à la fin de la boucle for
elseif rem(n,2)==0 Note : Un fichier .m peut contenir la définition de plusieurs routines, mais seule la première est ”visible”
% n est pair et >= 4 donc n’est pas premier dans MATLAB, les autres étant locales au fichier.
continue % aller à la fin de la boucle for
end; Note : Par défaut, chaque variable est locale à la fonction où est elle définie.
Si on souhaite utiliser une même variable dans plusieurs routines, il faut la déclarer en début de
p=2; script/fonction à l’aide du mot-clé global .
while (p*p <= n)
Exemple : créer le fichier suivant en le nommant exemple global.m.
if (rem(n,p)==0)
break; % sortir de la boucle while car n n’est pas premier % routine principale
end function main()
p = p+1;
end; global a
if (p*p > n)
fprintf(1, ’%d est premier\n’, n); a = 2;
end fprintf(1, ’main : a = %d\n’, a);
end R2();
R1();
R2();

17 18
fprintf(1, ’main : a = %d\n’, a); eval_fonction(@cos, linspace(0,pi,12))
eval_fonction(@sin, linspace(0,pi,12))
% routines locales eval_fonction(@exp, 0:0.1:1)
function R1() h = @F1; % h : handle de la fonction 1/(1+x^2)
eval_fonction(h, -5:5)
global a
fprintf(1, ’R1 : a = %d\n’, a); 1.4.8 Test des arguments d’une fonction
function R2() Dans certains cas, il est nécessaire de tester les arguments d’une fonction, leur nombre, les types des
arguments en entrée, éventuellement dimensions et valeurs ; on peut aussi initialiser des arguments par
global a défaut s’ils ne sont pas fournis.
a=a+1;
Exemple : la fonction resol trinome définie ci-dessus nécessite deux paramètres en entrée de type
fprintf(1, ’R2 : a = %d\n’, a);
scalaire numérique, et deux paramètres en sortie.
puis taper la commande :
[r1,r2] = resol_trinome(1) // erreur car le deuxième parametre est manquant
exemple_global r1 = resol_trinome(1,-2) // ne donne que la première racine
[r1,r2,r3] = resol_trinome(1,-2) // erreur car trop d’argument en sortie
1.4.6 Récursivité On peut alors complèter la fonction resol trinome afin de tester les arguments :
Il est possible d’écrire des fonctions récursives.
% resol_trinome : résolution de l’équation x*x+b*x+c = 0
Exemple : la fonction ”factorielle” (fichier fact.m) % syntaxe [r1,r2] = resol_trinome(b,c)
% Entrées : b,c = coefficients du binome
function p=fact(n) % Sorties : r1,r2 = les deux racines
if n<1 then function [r1,r2] = resol_trinome(b,c)
p=1;
else % test des arguments
p=n*fact(n-1); % nargin : nombre d’arguments en entrée lors de l’appel
end % nargout : nombre d’arguments en sortie lors de l’appel

1.4.7 Paramètre de type fonction if nargout~=2


error(’il faut deux arguments en sortie’)
Une routine peut être passée en entrée comme paramètre d’une autre routine. end
Exemple : créez le fichier suivant eval fonction.m
% affecter des valeurs par défaut en entrée
% si les arguments n’ont pas été fournis
% eval_fonction : evaluation d’un fonction sur une variable x
if nargin<1
% Entrée : f = handle sur une fonction du type y=f(x)
b=0;
% x = scalaire ou matrice
end
% Sortie : y = résultat
if nargin<2
function y=eval_fonction(f,x)
c=0;
end
y = f(x)

Le handle d’une fonction t définie est obtenue à l’aide du symbole @. % tester le type des arguments en entrée
if ~(...
Exemple : isnumeric(b) & ... % test si b est de type numérique
Créez le fichier suivant en le nommant F1.m isnumeric(c) & ... % test si c est de type numérique
length(b)==1 & ... % test si b est un scalaire
function y = F1(x) length(b)==1 ... % test si c est un scalaire
y = 1./(1+x.^2); )
error(’les arguments en entrée doivent etre scalaires (réels ou complexes)’)
puis éxecutez les instructions suivantes : end

19 20
% les instructions de la fonction x = linspace(0,2*pi);
delta = b*b-4*c; y = cos(x);
r1 = (-b-sqrt(delta))/2; plot(x,y)
r2 = (-b+sqrt(delta))/2;
puis tester les différents instructions : Exemple : tracé de la fonction y = 1/(1 + x2 ) pour x compris entre −3 et 3 avec 11 valeurs seulement.

resol_trinome(1,2) % ERREUR x = linspace(-3,3,11);


[r1,r2,r3] = resol_trinome(1,2) % ERREUR y = 1./(1+x.*x);
[r1,r2] = resol_trinome([1,2],’3’) % ERREUR plot(x,y)
[r1,r2] = resol_trinome() % OK : b=c=0
[r1,r2] = resol_trinome(3) % OK : c=0 Note : on utilise ./ et .* afin de faire les opérations élément par élément pour calculer y .

1.4.9 Exercices On peut obtenir différents types de tracé en ajoutant un troisième paramètre qui est une chaı̂ne de un,
deux ou trois caractères (un caractère pour la couleur, un ou deux caractères pour le style)
Exercice 1
Exemple :
Ecrire une routine qui calcule numériquement l’integrale d’une fonction f sur un intervalle [a, b] par la
méthode de Simpson : plot(x,y,’k’) % une courbe en noir
plot(x,y,’:’) % une en pointillé fin
h
I= [f (a) + 4f (a + h/2) + 2f (a + h) + 4f (a + 3h/2) + · · · + 4f (b − 3h/2) + 2f (b − h) + 4f (b − h/2) + f (b)] plot(x,y,’g--’) % une en pointillé grossier
6
Note : couleur et style peuvent être combinés ensemble.
" n n−1
# Z
b
h X X
= f (a) + 4 f (a + (2i − 1)h/2) + 2 f (a + ih) + f (b) ' f (x)dx
3 a
i=1 i=1 Il est possible de tracer plusieurs courbes sur le même graphique en indiquant les différentes courbes
avec n un entier > 0, et h = (b − a)/n. dans la même instruction plot.
La routine doit avoir 4 paramètres en entrée : a et b (réels) les bornes de l’intervalle, f une variable
Exemple : tracé des fonctions sinus (bleu), cosinus (rouge) et tangente (vert) pour x ∈ [−π/3, π/3] :
fonction (de la forme y = f (x)) et n entier pair,
et un paramètre en sortie : la valeur I.
x = linspace(-pi/3,pi/3,200);
plot(x,sin(x),’b’,x,cos(x),’r’,x,tan(x),’g’)

Exercice 2
Lors d’un tracé si le vecteur des abscisses x est omis, alors les points tracés sont (k,y(k)).
Ecrire une routine qui évalue la valeur d’un polynôme de degré n
Exemple : tracé des 21 valeurs y(k) = (−2 + 0.2 k)2 pour 1 ≤ k ≤ 21
p(t) = cn tn + cn−1 tn−1 + · · · + c1 t + c0
x = -2:0.2:2;
par le schéma de Horner :
y = x .* x;
plot(y, ’*’)
  
p(t) = . . . (cn × t + cn−1 ) × t + cn−1 × t + · · · + c1 × t + c0
Note : les abscisses correspondent à k et non pas à x.
La routine doit avoir 2 paramètres en entrée : C le vecteur des coefficients (de longueur n+1 : C(i+1) = c i )
et t un réel, vecteur ou matrice (dans le cas d’un vecteur ou matrice, le polynôme doit être évalué en chaque
On peut utiliser la fonction plot pour tracer des courbes paramètrées.
valeur de t)
et un paramètre en sortie : la valeur pt (de même dimension que t), évaluation du polynome en t. Exemple : tracé du cercle unité en rouge. Le cercle est paramètré ainsi :

x(t) = cos(t) y(t) = sin(t) t ∈ [0, 2π]


1.5 Graphique t = linspace(0,2*pi,500);
x = cos(t);
1.5.1 Courbes y = sin(t);
MATLAB permet de tracer des ensembles de points et des courbes à l’aide de la fonction plot . plot(x,y,’r’)
Si x et y sont deux vecteurs-lignes de même dimension, alors l’instruction plot(x,y) trace une courbe
 Note : il a de fortes chances pour que le cercle apparaisse sous forme d’une ellipse car le repère n’est
en reliant les points x(k),y(k) entre eux.
pas normalisé.
Exemple : tracé de la fonction y = cos(x) pour x compris entre 0 et 2π L’instruction axis(’equal’) permet alors d’avoir un tracé normalisé :

21 22
axis equal Surfaces triangulées

L’instruction plot3 permet le tracé de courbes dans l’espace. Représentation d’une liste de n triangles T (i) dans le plan ou l’espace avec :
– chaque triangle T (i) = [T (i, 1), T (i, 2), T (i, 3)] avec T (i, j) indice du j-ième sommet ;
Exemple : tracé d’une hélice – les différents sommets étant décrits sous forme d’un tableau de coordonnées, chaque ligne du tableau
contenant 2 ou 3 coordonnées (resp. pour un sommet du plan ou de l’espace)
t = 0:0.01:4; Le tracé se fait à l’aide de la routine patch.
x = cos(2*pi*t);
y = sin(2*pi*t); Exemple : tracé d’une pyramide (4 faces) construit à partir des 5 sommets
z = t/2; S1 = (0, 0, 0), S2 = (2, 0, 0), S3 = (2, 2, 0), S4 = (0, 2, 0) et S5 = (1, 1, 1),
plot3(x,y,z,’b’) les 4 faces triangulaires étant
axis equal T1 = [S1 , S2 , S5 ], T2 = [S2 , S3 , S5 ], T3 = [S3 , S4 , S5 ] et T4 = [S4 , S1 , S5 ].
On définit :
L’icone Rotate permet de changer le point de vue à la souris.
% le tableau des coordonnées des sommets
S = [0 0 0; ...
1.5.2 Surfaces
2 0 0; ...
Surfaces définies suivant une grille rectangulaire 2,2,0; ...
0,2,0; ...
Représentation d’une surface image d’une fonction
1,1,1];
z = f (x, y) ou (x, y, z) = (f 1(u, v), f 2(u, v), f 3(u, v)).
% le tableau des triangles
Exemple : la gaussienne T = [1 2 5; ...
2 3 5; ...
[XG,YG] = meshgrid(-2:0.1:2,-2:0.1:2); 3 4 5;
ZG = exp(-XG.^2-YG.^2); 4 1 5];
figure % pour créer une nouvelle fenetre graphique
mesh(XG,YG,ZG) et la représentation graphique avec les arêtes en noir et triangles en vert :
axis equal figure
patch(’Vertices’, S, ’Faces’, T, ’EdgeColor’, ’k’, ’FaceColor’, ’g’)
Exemple : la sphere unité paramétrée en longitude (u) et latitude (v) axis equal % repere orthonormé

[u,v] = meshgrid(linspace(0,2*pi,50),linspace(-pi/2,pi/2,25)); Note : patch permet de représenter des polygones avec un nombre de sommets quelconques.
XS = cos(u) .* cos(v);
YS = sin(u) .* cos(v); 1.5.3 Objets d’une figure
ZS = sin(v);
Chaque instruction figure crée un nouvel objet MATLAB de type figure qui apparait sous forme
figure d’une fenêtre graphique.
surf(XS,YS,ZS) Une figure peut contenir différents objets MATLAB.
axis equal Chaque objet MATLAB possède un certain nombre de propriétés qui peuvent être initialisé ou modifié.

ou bien un tore Exemple :

[u,v] = meshgrid(linspace(0,2*pi,50),linspace(0,2*pi,25)); f1 = figure(’Position’,[100 100 500 400], ... % position et dimension


r1 = 1; % petit rayon ’Color’, [0.8 0.8 1], ... % couleur RGB du fond
r2 = 2; % grand rayon ’Name’, ’Fonctions hyperboliques’); % titre de la fenetre
XT = cos(u) .* (r2+r1*cos(v)); YT = sin(u) .* (r2+r1*cos(v)); % position/dimension relative à la fen^
etre
ZT = r1 * sin(v); a1 = axes(’Position’,[0.05 0.1 0.4 0.8]);
t = linspace(0,2,1000);
figure plot(t,cosh(t),’k’)
surf(XT,YT,ZT) % position/dimension relative à la fen^
etre
axis equal a2 = axes(’Position’,[0.55 0.1 0.4 0.8]);
plot(t,sinh(t),’b’)
Il existe d’autres routines afin de faire varier l’aspect de la surface (mesh, surf), la routine de base
étant la routine surface permettant de paramètrer le rendu. % tracé de la fonction exp(t) en pointillé sur les deux figures
axes(a1); % le tracé se fera dans l’axe a1

23 24
hold on Exemple : le script suivant permet d’entrer les points avec le bouton de gauche en les traçant au fur
plot(t,exp(t)/2,’r:’) et à mesure, le dernier point est saisi avec le bouton de droite.
set(a1, ’YLim’, [0 4]); % modifier les bornes en y de l’axe
% placer des objets textes dans l’axe figure
text(0.2, 3.5, ’cosh(t)’, ’Color’, [0 0 0]); axis([0 1 0 1]) % création d’un axe avec les bornes [0,1] x [0,1]
text(0.2, 3, ’exp(t)/2’, ’Color’, [1 0 0]); hold on
bouton = 1;
axes(a2); % le tracé se fera dans l’axe a2 x = []; y = [];
hold on while bouton==1
plot(t,exp(t)/2,’r:’) [xp,yp,bouton] = ginput(1); % saisir un point
set(a2, ’YLim’, [0 4]); % modifier les bornes en y de l’axe plot(xp,yp,’ko’);
% placer des objets textes dans l’axe axis([0 1 0 1]) % forcer les bornes de l’axe
text(0.2, 3.5, ’sinh(t)’, ’Color’, [0 0 1]); x = [x xp]; % ajouter les cooordonnées du point saisi
text(0.2, 3, ’exp(t)/2’, ’Color’, [1 0 0]); y = [y yp]; % aux tableaux x et y
end
1.5.4 Impression/Sauvegarde d’un graphique
% affichage des coordonnées des points saisis et leur nombre
Une figure peut être imprimée directement ou bien sauvegardée sous forme d’un fichier image. [x’ y’]
length(x)
L’impression directe d’une figure se fait en choisissant l’item Print du menu File de la figure concernée,
puis choisir A4 dans le champ PaperType puis cliquer sur le bouton OK. 1.6.2 Dialogues
La sauvegarde d’une figure dans un fichier image au format JPEG se fait en choisissant l’item Save MATLABfournit un certain nombre de dialogues standard permettant de créer facilement une interface
as ... du menu File de la figure concernée, puis choisir le format d’image (le format JPEG ou EPS est utilisateur simple. Les principaux sont présentés ci-dessous. Pour plus d’information, se référer à l’aide en
conseillé afin d’être inclus ensuite dans un document de traitement de texte). ligne (Predefined Dialog Boxes).

• msgdlg est un dialogue standard afin d’afficher une information (aide, warning, erreur, ...)
1.5.5 Exercices
Exemple :
Exercice 1
Tracer sur un même graphe les différentes fonctions (fk ) avec k entier entre 0 et 11 tel que : msgbox(’Un simple message’)
msgbox(’Le résultat est 0’,’Information’,’help’)
t2k msgbox(’Le système est mal conditionné’,’Attention’,’warn’)
f0 (t) = 1 fk (t) = fk−1 (t) + (−1)k msgbox(’La valeur entrée est invalide’,’Erreur’,’error’)
(2k)!

on prendra t ∈ [−2π, 2π], et on fixera les bornes de l’axe à [−2, 2] pour les ordonnées • questdlg permet de répondre à une question de 3 manières différentes (par défaut Oui, Non ou
Annuler). La valeur renvoyée est le nom (chaine de caractère) du bouton choisi.
Exemple :
1.6 Interaction avec l’utilisateur r = questdlg(’Continuer ?’);
if strcmp(r,’Yes’)
1.6.1 Entrée de points à la souris disp(’On continue’)
La routine ginput permet d’entrer à la souris des points dans l’axe d’une figure. else
disp(’On arrete’)
end
Exemple : le script suivant permet de récupérer 10 points dans le carré unité [0, 1] × [0, 1] puis de les
tracer. • inputdlg permet de saisir un certain nombre de champs sous forme de chaine de caractères.
Exemple : dialogue pour choisir les bornes min. et max. d’un intervalle (par défaut 0 et 1)
figure
axis([0 1 0 1]) % création d’un axe avec les bornes [0,1] x [0,1] r = inputdlg( ...
[x,y] = ginput(10) % cliquer 10 points dans l’axe {’xmin’,’xmax’}, ... % les labels de chaque entrée
% les coordonnées des 10 points sont renvoyés dans les vecteurs x et y ’Bornes de l’’intervalle’, ... % le titre
plot(x,y,’k+’) % tracé des points 1, ... % nb de lignes pour chaque valeur
axis([0 1 0 1]) % forcer les bornes de l’axe {’0’,’1’} ... % les valeurs par défaut sous forme chaine de caracteres

25 26
); % utilisation de la routine patch
% conversion du résultat en valeur numérique % une seule face dont les sommets sont (X,Y)
xmin = str2num(r{1}); % ne dessiner que le contour (aretes) en noir
xmax = str2num(r{2}); % et marquer les sommets (’o’)
if xmin>=xmax p = patch(’faces’,1:length(X), ’vertices’, [X’ Y’], ...
msgbox(’Borne min. supérieure à la borne max’,’Attention’,’warn’) ’facecolor’, ’none’, ’edgecolor’, ’k’, ...
end ’marker’, ’o’);

• listdlg permet de choisir un ou plusieurs items parmi une liste prédéfinie. %% activer les callbacks pour les évenements souris et clavier
Exemple : %% dans la fenetre
etat=0;
seuils = {’0.0001’,’0.001’,’0.01’,’0.1’}; set(f_id, ’WindowButtonDownFcn’, ’modifie_polygone(1)’);
[selection, ok] = listdlg( ... set(f_id, ’WindowButtonMotionFcn’, ’modifie_polygone(2)’);
’ListString’, seuils, ... % la liste d’items set(f_id, ’WindowButtonUpFcn’, ’modifie_polygone(3)’);
’SelectionMode’, ’single’, ... % le mode de sélection set(f_id, ’KeyPressFcn’, ’modifie_polygone(4)’);
’InitialValue’, 2, ... % l’indice de la valeur par défaut
’Name’, ’Choix du seuil’ ... % le titre – fichier modifie polygone.m
) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
if ok %% le gestionnaire d’évenement pour modifier le polygone
seuil_choisi = str2num(seuils{selection)}; %% code = 1 : bouton enfoncé - début du déplacement
else %% code = 2 : bouton déplacé - déplacement en cours
seuil_choisi = str2num(seuils{2)}; %% code = 3 : bouton relaché - fin du déplacement
else %% code = 4 : touche clavier - fin du mode déplacement
function modifie_polygone(code)
1.6.3 Gestion d’évènement
global etat indice_pt_deplace p v f_id a
Les évenements souris et clavier dans une fenêtre peuvent être gérés à l’aide des callbacks. Un callback
est une routine qui est déclenchée lorsqu’un évènement (click souris, touche clavier, ...) se produit dans if code==1 & etat==0
une fenêtre. %%%%% début du déplacement
Exemple : l’exemple suivant ouvre une fenêtre, crée un polygone p. Les sommets du polygone peuvent % récupérer les coordonnées du pointeur souris
ensuite être déplacés à la souris. cp=get(a,’currentpoint’);
Créer les deux fichiers suivants : x_pointer = cp(1,1);
– fichier ex gestion evenement.m y_pointer = cp(2,2);

%% utilisation d’un event handler % determiner le point du polygone le plus proche


%% modification d’un polygone à la souris % du pointeur souris
function ex_gestion_evenement() v=get(p, ’vertices’);
y=abs(v(:,2)-y_pointer);
global etat p f_id a x=abs(v(:,1)-x_pointer);
d=sqrt(y.^2+x.^2);
%% création d’une fenetre et tracé d’un polygone fermé indice_pt_deplace=find(d==min(d));
f_id = figure; etat=1;
axis([-0.2 1.2 -0.2 1.2]) end
axis equal if code==2 & etat==1
a=gca(); %%%%% déplacement en cours
cp=get(a,’currentpoint’); % récupérer les coordonnées du pointeur souris
set(a, ’DataAspectRatioMode’, ’manual’) x_pointer = cp(1,1);
set(a, ’XLimMode’, ’manual’) y_pointer = cp(2,2);
set(a, ’YLimMode’, ’manual’)
%% déplacer le point
X = [0 0 1 1]; v(indice_pt_deplace,:) = [x_pointer y_pointer];
Y = [0 1 1 0]; set(p, ’vertices’, v);
end

27 28
if code==3 & etat==1 pour obtenir un tracé de ce type
%%%%% fin du mode déplacement
etat=0;
end
if code==4 & etat==0
%%%%% fin de la gestion des évènements
etat=-1;
%% supprimer les callbacks
set(f_id, ’WindowButtonDownFcn’, ’’);
set(f_id, ’WindowButtonMotionFcn’, ’’);
set(f_id, ’WindowButtonUpFcn’, ’’);
set(f_id, ’KeyPressFcn’, ’’);
fprintf(1, ’TERMINE\n’);
end

La routine modifie polygone permet de gérer les différents évènements utilisés dans cet exemple.

1.6.4 Exercices
Exercice 1 Exercice 2
Ecrire un script permettant d’entrer via un dialogue les expressions de fonctions de la forme y = f (x) Ecrire un script permettant :
(entre une et cinq fonctions), d’entrer un intervalle pour x, puis de tracer sur une même fenêtre les graphes a) d’acquérir à la souris un ensemble de n + 1 points Pi = (xi , yi ) avec 1 ≤ i ≤ n + 1,
des fonctions sur l’intervalle. b) de tracer le polygone ouvert [P1 , P2 , . . . , Pn , Pn+1 ],
Par exemple, en utilisant les routines listdlg c) et la courbe de Bézier correspondante :
n
X (n) (n) n!
B = {M (t) = Pi+1 Bi (t), t ∈ [0, 1]} avec Bi (t) = ti (1 − t)n−i
i=0
i!(n − i)!

et inputdlg

29 30