Chapitre 1
MATLAB est un logiciel de calcul et de visualisation, dont les entite´s de base sont des matrices : MATLAB est une abre´viation de Matrix Laboratory.
MATLAB est un langage interpre´te´ : il propose des facilite´s de programmation et de visualisation,ainsi qu’un grand nombre de fonctionsre´alisant diversesme´thodes nume´riques.
La meilleure fac¸on d’apprendre a` utiliser ce logiciel est de l’utiliser vous meˆme, en faisant des essais, en commettant des erreurs et en essayant de comprendre les messages d’erreur qui vous seront renvoye´s. Ces messages sont en anglais!
Ce document est destine´ a` vous aider pour quelques premiers pas avec MATLAB. Les sections et sous-sections signaleés par (*) donnent des comple´ments qui pourront vous eˆtre utiles a` l’avenir, mais peuvent eˆtre re´serveés pour une lecture ulte´rieure.
Nos salles de TP utilisent un environnemment Linux. Pour acce´der au logiciel MATLAB, vous avez plusieurs possibilite´s :
- Vous pouvez utiliser les icoˆnes du menu de´roulant de KDE, et suivre les arborescenses a` partir du menu CRI. Vous aurez acce`s a` plusieurs versions de MATLAB. Les sessions comple`tes mettent en œuvre une machine virtuelle java. Elles peuvent se re´ve´ler un peu trop lourdes lorsqu’il y a de nombreux utilisateurs. Elles ouvrent une feneˆtre du type de celle repre´senteé a` la figure 1.1.
- Vous pouvez acce´der aux meˆmes versions a` partir d’un terminal. C’est cette fac¸on de proceder que nous vous recommandons´ . Elle vous permet en effet de mieux organiser votre travail. Vous devez :
– ouvrir un terminal (icøne sur la barre de tcˆhes de votre e´cran),ˆ
– creer un r´ epertoire´ pour le TP en cours. Aujourd’hui, vous aller creér le re´pertoire InitMatlab en entrant la commande :
mkdir InitMatlab
– vous rendre dans ce re´pertoire :
cd InitMatlab
– lancer par exemple une session comple`te :
1
matlab -jvm
FIG. 1.1 – Exemple de session matlab avec le support java (matlab -jvm).
Vous reconnaˆ?trez votre feneˆtre de travail par le “prompt” :
>>
Vous pourrez quitter MATLAB en tapant dans cette feneˆtre :
>> quit
Dans la suite de cette se´ance, vous eˆtes invite´s a` tester les instructions pre´senteés en les tapant apre`s le “prompt”. Les instructions et variables MATLAB sont donneés dans une typographie de machine a` e´crire. Les ope´rations mathe´matiques et valeurs repre´senteés par ces variables sont e´crites en italiques.
Un certain nombre de fichiers vous sont fournis. Vous pourrez les re´cupe´rer en utilisant un navigateur et en vous rendant a` l’adresse :
http ?huard/InitMatlab/
La commande lookfor est une commande de recherche par mot clef. Elle permet de retrouver toutes les fonctions MATLAB dont les commentaires introductifs contient une chaine de caracte`res donne´s.
1.2. UTILISERLESAIDESENLIGNE
Si, par exemple, je cherche une fonction permettant de tracer un histogramme, je peux entrer l’instruction :
lookfor histogram
En re´ponse, j’obtiens la liste suivante :
HIST Histogram.
HISTC Histogram count.
ROSE Angle histogram plot.
On utilise ensuite la commande help pour plus de pre´cisions. Cette commande affiche les commentaires de la fonction indiqueé. Ces commentaires contiennent l’objet de la fonction ainsi que les diffe´rents formats d’appel. Ils contiennent e´galement une rubrique “See Also” qui donne les noms de fonctions dont l’objet est en rapport avec la fonction conside´reé. Ces commentaires sont affiche´s sur la feneˆtre de travail.
FIG. 1.2 – Page d’accueil de la feneˆtre ouverte par helpwin.
La fonction helpwin ouvre une feneˆtre qui donne acce`s a` ces commentaires sur une feneˆtre se´pareé. L’acce`s est arborescent, partant d’un classement par domaine d’application jusqu’a` l’aide de chaque fonction. Le lien est fait avec les aides des renvois sugge´re´s par la rubrique “See Also”.
La figure 1.2 nous montre sa page d’accueil. On peut cliquer sur une ligne pour continuer sa recherche...
La commande helpdesk donne acce`s a` une documentation hypertexte comple`te supporteé par le navigateur internet. Il suffit alors de se laisser guider dans sa recherche. Cette aide n’est pas accessible lorsque l’on utilise MATLAB sans le support java.
Dans MATLAB, toutes les variables repre´sentent des matrices. Par exemple, on multiplie deux matrices a et b par a*b, et le produit de deux scalaires s’e´crit de la meˆme fac¸on : ils sont interpre´te´s comme des matrices 1X1.
On peut de´finir une matrice dans MATLAB de plusieurs fac¸ons : – par la liste de ses e´le´ments,
– en la ge´ne´rant par une suite d’instructions et de fonctions, – en la lisant dans un fichier exte´rieur.
Si l’on repre´sente la touche enter de votre clavier par le symbole ?-, les instructions suivantes :
>> A = [3 2 -2;-1 0 1;1 1 0] ?et
>> A = [ ?3 2 -2 ?-
-1 0 1 ?-
1 1 0 ] ?-
creént la meˆme matrice 3X3.
Dans la suite, le symbole ?- ne sera plus indique´. Le symbole = de´signe l’ope´rateur d’affectation. Il permet de fixer ou de changer la valeur d’une variable.
En ayant e´xecute´ l’une ou l’autre de ces commandes, vous aurez remarque´ que MATLAB affiche la valeur de la variable A que vous venez de de´finir. Vous pouvez e´viter l’affichage en faisant suivre la commande d’un point-virgule. Ne la retapez pas pour le ve´rifier ; en utilisant la fle`che ascendante de votre clavier ?, vous pouvez rappeler la commande
>> A = [3 2 -2;-1 0 1;1 1 0]
et ajouter le point-virgule
>> A = [3 2 -2;-1 0 1;1 1 0] ;
MATLAB distingue les majuscules et les minuscules; si vous tapez :
>> a
vous recevrez le message :
??? Undefined function or variable ’a’.
L’ensemble des variables actives peut eˆtre consulte´ graˆce aux commandes whos et who :
>> t = 1;
>> whos
Name Size Bytes Class
A 3x3 72 double array
Grand total is 9 elements using 72 bytes
La commande clear permet de de´truire une variable.
>> who
Your variables are:
A t
>> clear t
>> who
Your variables are: A
La commande clear all re´initialise l’environnement (en de´truisant toutes les variables actives).
L’e´nume´ration des e´le´ments d’une matrice ou d’un vecteur peut eˆtre implicite. Essayez par exemple :
>> m = [-3:3]
>> x = [1:-0.25:-1]
Les matrices m et x sont des matrices a` une ligne (vecteurs-lignes). MATLAB vous fournit les dimensions d’une variable par la fonction size :
>> size(m)
ans =
1 7
Si l’on veut un vecteur, on peut taper
>> m = m’
ou
>> x = x(:)
L’apostrophe de´finit la transposition : A’ repre´sente la matrice AT . Les deux points imposent le format colonne :
>> format compact % pour éviter les sauts de ligne à l’affichage.
>> A’ ans =
3 -1 1
2 0 1
-2 1 0
>> A(:)’ ans =
3 -1 1 2 0 1 -2 1 0
On peut aussi creér directement un vecteur en se´parant les composantes par un pointvirgule :
>> b = [3 ; 0 ; 2 ] ; size(b)
Un coefficient quelconque d’une matrice est re´fe´rence´ par ses indices de ligne et de colonne, dans cet ordre. Par exemple, l’instruction :
>> A(1,2)
renvoie la re´ponse :
ans =
2
ans est le nom d’une variable qui rec¸oit le dernier re´sultat d’une instruction ou d’une suite d’instructions lorsqu’il n’a e´te´ affecte´ a` aucune variable. On peut faire s’afficher la valeur d’une variable sans affichage de son nom ni de ans
>> disp(A(1,2))
Certaines fonctions de MATLAB creént des matrices particulie`res. Les quelques matrices suivantes sont parmi les plus couramment utiliseés :
– eye(n) renvoie la matrice identite´, habituellement noteé In en mathe´matiques; essayez eye(4),
– ones(n,m) renvoie une matrice a` n lignes et m colonnes dont tous les coefficients sont des 1,
– zeros(n,m) matrice a` n lignes et m colonnes dont tous les coefficients sont des 0; elle sert beaucoup pour les initialisations.
– linspace(a,b,n) creé une matrice ligne de n points re´gulie`rement espace´s sur l’intervalle [a, b] (bornes comprises).
– rand creé une matrice ale´atoire. Essayez >> B = rand(3,4). Dans quel intervalle sont choisis les coefficients de cette matrice?
La commande help permet de recevoir des informations (en anglais!) sur une fonction; essayez :
>> help linspace, >> help rand
MATLAB permet d’effectuer les ope´rations usuelles en e´tendant leur de´finition aux matrices selon les re`gles de l’alge`bre line´aire.
L’addition et la soustraction ne me´ritent aucun commentaire particulier, sinon que les tailles des matrices doivent eˆtre e´gales, essayez :
>> 3+5
>> ans -2
>> A + ones(3)
>> m + x
La dernie`re commande aura entraine´ cette re´ponse cinglante :
??? Error using ==> +
Matrix dimensions must agree.
MATLAB autorise que les dimensions ne soient pas e´gales lorsqu’une des variables est un scalaire. A + 1 fournit la meˆme valeur que A + ones(3).
La multiplication de deux variables sera possible si les matrices qu’elles repre´sentent respectent les re`gles de concordance des dimensions :
>> 3*4
>> c = A*b
>> C = A*B
>> b’*c
>> b*c’
Comme les variables A et B repre´sentent respectivement des matrices 3 × 3 et 3×4, la variable C repre´sente une matrice 3×4, mais la commande B*A susciterait un message d’erreur de dimensions.
On peut aussi remarquer que le produit scalaire des vecteurs b et c s’obtient directement par b’*c , alors que b*c’ de´finira une matrice 3 × 3 (de rang 1!).
MATLAB autorise que les dimensions ne concordent pas lorsqu’une des variables repre´sente un scalaire.
MATLAB distingue la division a` gauche et la division a` droite :
>> 3/4 ans =
0.7500 >> 3\4 ans =
1.3333
Ainsi cette division doit elle s’interpreter comme le produit par l’inverse de la variable situeé du coˆte´ vers lequel penche la barre : 3/4 repre´sente 3× alors que 3\4 repre´sente × 4. Cette ideé se ge´ne´ralise aux variables repre´sentant des matrices :
>> x = A\b ;
>> A*x - b
Comment interpre´ter le dernier re´sultat renvoye´ par la machine? Vous aurez compris que la variable x contient la solution du syste`me line´aire Ax = b. Au passage, vous remarquerez que cette nouvelle affectation de la variable x e´crase la pre´ce´dente. Quelle reflexion vous sugge`re le re´sultat de :
>> b/A
On peut se demander ce que repre´sente la matrice M de´finie par
>> M = A\eye(3)
MATLAB autorise le produit et les divisions par un scalaire.
L’e´le´vation a` une puissance donneé est de´finie par le symbole b : essayez
>> 2ˆ3
>> Aˆ2
>> Aˆ0
>> Aˆ(-1)
Vous avez retrouve´ la matrice M.
Les re`gles de priorite´ des ope´rations sont conformes a` celles qui sont utiliseés dans la plupart des langages de programmation. Elles sont donneés par le tableau suivant :
| Niveau de priorite´ | Ope´ration |
| 1 | puissance |
| 2 | multiplication et division |
| 3 | addition et soustraction |
A niveau de priorite´ e´gale, les ope´rations sont effectuées de la gauche vers la droite. Les parenthe`ses vous permettent d’organiser les priorite´s dans vos calculs. Leur utilisation est recommandeé pour e´viter les ambiguite´s et risques d’erreurs.
>> 2 + 3ˆ2
>> 2 + 3*3ˆ2
>> 2 + (3*3)ˆ2
>> (2 + 3*3)ˆ2
>> Aˆ2\A
>> A*A\A
Une matrice peut eˆtre vue comme un tableau de valeurs, inde´pendament de l’alge`bre line´aire. MATLAB permet de travailler avec les valeurs contenues dans un tableau. Pour l’addition et la soustraction, il n’y a pas de diffe´rence entre matrice et tableau de valeurs.
Pour la multiplication, les divisions et l’e´le´vation a` une puissance, on fait pre´ce´der le symbole d’ope´ration d’un point. Les tableaux doivent avoir la meˆme taille :
>> A.ˆ2
>> M.*A
>> b./c
>> C.*B
>> A.*B
>> A.ˆ[2 1 2 ; 2 0 1 ; 1 1 1]
On remarquera que A.b 2 e´le`ve a` la puissance 2 chaque e´le´ment de A. C’est un raccourci pour A.b (2*ones(3)).
MATLAB permet de manipuler les matrices par blocs : Essayez par exemple :
C = [ones(3), rand(3,2) ; rand(2,3), eye(2)]
On peut ensuite en extraire la sous-matrice formeé des trois dernie`res colonnes :
C1 = C(:,3:5);
et on retrouve ones(3) en faisant afficher C(1 :3,1 :3).
MATLAB propose quelques fonctions qui facilitent certaines manipulations.
La fonction diag extrait la diagonale d’une matrice, sous forme d’un vecteur, ou creé une matrice diagonale, a` partir d’un vecteur; essayez par exemple les instructions suivantes :
>> R = rand(5);
>> diag(R)
>> diag(ans)
>> diag(diag(R))
L’argument ge´ne´ral de diag est double; entrez :
>> help diag
Vous constatez que l’on peut ainsi extraire d’une matrice ses e´le´ments d’une ”paralle`le” a` la diagonale. Essayez :
>> diag(R,1)
>> diag(R,-2)
>> d = ones(4,1);
>> M = 2*eye(5)-(diag(d,1)+diag(d,-1))
tril renvoie la partie triangulaire infe´rieure d’une matrice, e´le´ments diagonaux
compris. Elle admet aussi plusieurs arguments
>> tril(R)
>> tril(R,1)
triu renvoie la partie triangulaire supe´rieure d’une matrice.
reshape reformate une matrice, c’est-a`-dire change le nombre de lignes et de co-
lonnes, en prenant les e´le´ments colonne par colonne.
repmat creé une “grande” matrice en recopiant une matrice donneé selon le format fournit.
Les principales instructions de controˆle proposeés par MATLAB sont for, while et if; elles fonctionnent a` peu pre`s comme leurs e´quivalents dans les autres langages de programmation.
La boucle for doit respecter la syntaxe suivante :
for compteur = expression
instructions
end
Generalement, expression est un vecteur de la forme début :incrément :fin et compteur prend successivement toutes les valeurs de expression pour e´xecuter instructions.
Les instructions suivantes permettent de calculer une valeur approcheé de ex, pour x = 10, en utilisant la formule :
Xn xk
ex '(1.1) k ! k=0
>> x = 10;
>> n = 50;
>> s = 1;
>> terme = 1;
>> for k = 1:n, terme = x*terme/k ; s = s + terme ; end;
>> s
1.4. BOUCLESETTESTS
On pourra ve´rifier plus tard que la valeur obtenue, s ' 2.2026 × 104 est assez proche de e10.
Plusieurs boucles peuvent eˆtre emboˆ?teés. Comme MATLAB est un language interpre´te´, il faut essayer d’e´viter les boucles quand c’est possible. Pour cela on peut utiliser des
1
boucles implicites. Pour construire la matrice H = (hi,j) ? M3(R) avec hi,j = , i + j ? 1 on peut utiliser les instructions suivantes :
>> n = 3;
>> H = zeros(3);
>> for i = 1:n for j = 1:n
H(i,j) = 1/(i+j-1); end;
end;
>> H
Notez que l’on a initialise´ la variable H. C’est recommande´ lorsque c’est possible. Notez e´galement que l’on a indente´ les boucles : c’est recommande´ pour une meilleure lisibilite´ !
On peut aussi construire H de la fac¸on suivante :
>> J = 1:n;
>> J = repmat(J,n,1);
>> I = J’;
>> E = ones(n);
>> H = E./(I+J-E);
Remarque 1Dans le premier exemple d’utilisation de for, la boucle tenait dans une ligne. Dans ce cas, une virgule doit separer l’initialisation de la boucle de l’instruction´ suivante.
Dans la second exemple, puisque l’on va a la ligne, le promptde` MATLAB ne reapparait´ que lorsque la boucle est correctement terminee.´
L’instruction while respecte la syntaxe suivante :
while expression
instructions
end
expression de´signe le re´sultat d’une operation logique´ . Elle est construite en utilisant des ope´rateurs relationnels et logiques.
| Ope´rateurs relationnels | Ope´rateurs logiques | ||
| Ope´rateur | Symbole | Ope´rateur | Symbole |
| egal´ | == | et logique | & |
| diffe´rent | ?= | non logique | ? |
| supe´rieur | > | ou logique | | |
| infe´rieur ou e´gal | <= | ||
Les instructionsseront e´xe´cuteés tant que expression sera “vraie”. Toute valeur diffe´rente de 0 est assimileé au 1 logique, c’est-a`-dire au “vrai”. Essayez
>> x = [1 -1 1] ; y = [1 1 -1];
>> x>0, ˜(x>0),˜x>0
>> x>=y
>> x>0 & y>0
>> x>0 | y>0
Les instructionssuivantespermettent de trouver approximativementle plus petit nombre positif repre´sente´ dans l’arithme´tique utiliseé par MATLAB :
>> x = 1 ; while x>0 , xm = x; x = x/2; end; xm
L’instruction if respecte la syntaxe suivante :
if expression instructions
end
Les instructions ne seront e´xe´cuteés que si expression est vraie. Il est possible de proposer une alternative, en indiquant les instructions a` e´xecuter lorsque expression est fausse :
if expression instructions 1 else
instructions 2
end
Il est e´galement possible d’emboˆ?ter les choix propose´s :
if expression1 instructions 1
elseif expression2 instructions 2
1.4. BOUCLESETTESTS
else
instructions 3 end
Les exemples d’utilisation de la boucle for nous ont amene´s a` e´crire plusieurs lignes de commandes. Lorsque l’on veut recommencer l’exe´cution d’un de ces exemples en modifiant la valeur d’un parame`tre, il faudra rappeler toutes les lignes qui suivent sa de´finition : c’est le cas si l’on veut e´valuer (1.1) pour une autre valeurs de x ou de n. Cette ope´ration devient tre`s de´sagre´able lorsque l’on a emboite´ des boucles!
De meˆme que vous utilisez un brouillon avant de rendre un devoir, de fac¸on a` pouvoir faire des ratures, changer les expressions ou` vous avez de´tecte´ une erreur, vous pouvez e´diter un fichier de commandes MATLAB dont vous vous servirez comme d’un brouillon.
Un tel fichier s’appelle un M-fichier. Il devra eˆtre enregistre´ sous le nom de votre choix avec le suffixe .m.
Pour e´crire ce fichier, vous devez utiliser un editeur´ : MATLAB vous en propose un auquel vous pouvez acce´der en vous servant des icoˆnes de la feneˆtre.
Nous allons illustrer cette possibilite´ en traitant un exemple qui utilise la boucle while et le branchement if : il s’agit de tester la conjecture de Syracuse.
On part d’un nombre entier diffe´rent de 1. S’il est impair, on le multiplie par 3 et on ajoute 1; sinon, on le divise par 2. On recommence avec ce nouveau nombre tant qu’il n’est pas e´gal a` 1. Dans ce cas, en effet, on reproduira inde´finiment le cycle {··· , 1, 4, 2, 1,···}.
Quelque soit le nombre entier dont on part, on finit toujours par obtenir la valeur 1. C’est en tous cas ce que montre l’expe´rience, car personne n’a jamais trouve´ de contre exemple. Mais, on a jamais pu de´montrer qu’il devait en eˆtre ainsi!
On vous propose de tester cette conjecture. L’objectif de l’exercice est d’e´crire un programme MATLAB qui propose a` l’utlisateur de donner un nombre entier différent de 1, et a` partir de ce nombre, de compter le nombre d’ite´rations de la suite de Syracuse avant qu’elle n’atteigne la valeur 1. On prendra la pre´caution de limiter le nombre d’iterations´ a` 1000 pour e´viter que le programme ne tourne inde´finiment. Cela pourrait se produire en cas d’erreur de saisie.
Pour cela, vous allez commencer par e´diter le fichier dans lequel vous e´crirez ce programme. Vous pouvez utiliser le fichier qui vous est fournit sous le nom de Syracuse.m et qui contient le squelette de programme qui est donne´ au tableau 1.1.
Il vous faut remplacer les points de suspension par des instructions approprieés. Voici quelques indications :
- La fonction input permet de proposer a` l’utilisateur de rentrer un entier n initial.
- Le symbole % permet de placer des commentaires.
- Le nombre d’ite´rations sera donne´ par la variable compteur.
| % Syracuse : Tester la conjecture de Syracuse n = input(’Entrez un entier superieur a 1 : ’) ; compteur = 1 ; % Compteur des it´ while ... & ... if rem(n,2) ... n = ... ; else n = ... ; end compteur = compteur +1; end compteur |
erations
TAB. 1.1 – Programme Syracuse.m
- la boucle while sera cotroˆleé par deux expressions logiques, qui autoriseront son e´xe´cution tant que n restera diffe´rent de 1 et compteur infe´rieur ou e´gal a` 1000.
- Le test sur la parite´ de n utilise la fonction rem (abre´viation de remainder) qui donne le reste de la division entie`re par 2 : ce reste vaut 1 si n est impair et 0 sinon.
Remarque 2On ne s’est pas trop bride en limitant le nombre des it´ erations´ a` 1000. Pour des valeurs initiales inferieures ou´ egales´ a 10 000, la suite la plus longue est obtenue` pour une valeur initiale de 6171. Sa longueur est 262.
Ce sont les fonctions usuelles; par exemple :
| sin | exp | abs | round |
| cos | log | sqrt | tanh |
| tan | rem | sign | acosh |
Ces fonctions font partie des fonctions e´le´mentaires proposeés par MATLAB. Pour en avoir la liste, vous pouvez taper :
>> help elfun
Comme la liste est longue, vous pouvez controˆler son de´filement :
>> more on, help elfun, more off
1.5. FONCTIONSDEBASE
Le de´filement se fait ligne a` ligne (en tapant une touche quelconque) ou par pages de 20 lignes (en tapant la barre d’espacements). Vous pouvez maintenant comparer la variable s calculeé en utilisant la formule (1.1) avec e10 ;
>> s - exp(10)
Quelle commande devrez-vous entrer pour obtenir la valeur absolue de l’erreur relative?
Ces fonctions traitent les variables matricielles comme des tableaux de nombres; si la variable A repre´sente une matrice A, la variable S = sin(A) repre´sentera une matrice S dont les coefficients sont si,j = sin(ai,j). Pour l’exponentielle et la racine carreé, qui posse`dent une version “matricielle”, MATLAB propose les fonctions expm et sqrtm.
Le cas des polynoˆmes est un peu particulier : un polynoˆme peut eˆtre de´fini par ses coefficients : on utilise dans ce cas une matrice ligne : par exemple, le polynoˆme Q(x) = x3 + 2x2 ? 3 sera repre´sente´ par :
>> Q = [1 2 0 -3];
Sa valeur au point x = 1.2 sera fournie par :
>> polyval(Q,1.2)
Les racines du polynoˆme Q seront fournies par la fonction roots. A l’inverse, on peut aussi de´terminer les coefficients d’un polynoˆme a` partir de ses racines en utilisant la fonction poly :
>> r=[1 2 3]; K = poly(r)
>> polyval(K,r)
Ces instructions assignent a` K la valeur [1 -6 11 -6] qui de´finit le polynoˆme K(x) = x3 ? 6x2 + 11x ? 6. Le polynoˆme ainsi calcule´ a toujours le coefficient de son terme de plus fort degre´ e´gal a` 1.
Comme les fonctions usuelles polyval traite les matrices comme des tableaux, Il faudra utiliser la fonction polyvalm pour e´valuer un polynoˆme de matrice. Comparez polyval(K,A) et polyvalm(K,A).
Certaines fonctions spe´ciales sont e´galement proposeés par Matlab : par exemple, les fonctions de Bessel de premie`re espe`ce noteés J?(x) sont donneés par la fonction besselj dont le format d’appel le plus courant est, pour le parame`tre entier nu et la
variable x : y = besselj(nu,x);
Vous pouvez retrouver l’information sur le format d’utilisation par :
>> help besselj
La liste de ces fonctions spe´ciales vous sera renvoyeé par la commande :
>> more on, help specfun, more off
Ces fonctions sont plutot destineés a` agir sur des vecteurs, lignes ou colonnes. Elles sont tre`s utiles a` l’analyse des donneés. Citons par exemple :
max sum mean sort min prod std find
dont vous trouverez l’objet par la commande help lorsqu’il n’est pas e´vident.
Elles agissent aussi sur les matrices, mais colonne par colonne. Essayez par exemple :
>> b = rand(3,3) ; c = max(b) ; d = max(max(b));
>> b,c,d
>> sort(c)
>> sort(b)
Vous pouvez modifier le fichier Syracuse.m pour retrouver le re´sultat annonce´ a` la remarque 2 en utilisant une boucle for et la fonction max.
Citons en quelques-unes :
eig : valeurs et vecteurs propres d’une matrice, inv : inverse, expm : exponentielle de matrice, size : dimensions de la matrice, norm : norme (2 par de´faut, mais aussi 1 ou ?), rank : rang.
Une liste un peu plus comple`te, mais non exhaustive, de ces fonctions vous est fournie en annexe. Une liste comple`te est fournie en re´ponse a` la commande
>> more on, help matfun, more off 1.6 Graphiques
MATLAB permet de tracer facilement le graphe de fonctions scalaires. Cela se fait a` l’aide de la fonction plot . Elle prend en argument des paires de vecteurs de meˆme dimension. Voici par exemple le moyen d’obtenir le graphe de la fonction cos3x sur l’intervalle [0,2?] :
>> x = [0:0.01:2*pi] ; y =cos(3*x) ; plot(x,y);
Le format de base de la fonction plot est en fait le suivant :
plot(x,y,s);
ou` x contient les absisses, y les ordonneés, et s est une chaine de 1 a` 3 caracte`res : s=’ctm’, pour la couleur (c) et le style (tm), qui peuvent eˆtre choisis dans le tableau suivant :
| Couleur Style | |||
| y | jaune | - | trait continu (t) |
| m | magenta | : | pointille´s (t) |
| c | cyan | -. | trait-point (t) |
| r | rouge | -- | tirets (t) |
| g | vert | + | plus (m) |
| b | bleu | o | cercles (m) |
| k | noir | * | e´toiles (m) |
| w | blanc | x | croix (m) |
Les style de trace´ suivis de (t) sont des trace´s continus, avec une interpolation entre les points fournis, alors que pour les autres on utilise des marqueurs pour ne repre´senter que les points (xi,yi). On peut combiner ces deux styles.
On peut tracer les graphes de plusieurs fonctions simultane´ment. Essayez maintenant :
>> z = sin(2*x);plot(x,y,x,z);
On peut alors le´gender notre graphique de la fac¸on suivante :
>> legend(’cos(3x)’,’sin(2x)’);
On peut e´galement obtenir ces deux courbes par la succession de commandes :
>> plot(x,y);
>> hold on;
>> plot(x,z);
La seule diffe´rence est que cette fois, les deux graphes sont trace´s avec la meˆme couleur. hold on ge`re le graphique courant de fac¸on que les commandes graphiques a` suivre vont s’ajouter a` ce graphique. hold off est a valeur par de´faut : dans ce cas une nouvelle commande plot effacera le graphique existant.
Les axes sont de´finis automatiquement; on peut choisir les bornes des coordonneés du graphe a` l’aide de la fonction axis . Essayez par exemple :
>> axis([-1 5 -1.5 1.5]);
Pour la suite de notre travail, il est pre´fe´rable que vous entriez maintenant la commande :
>> hold off;
Le format de la fonction plot permet bien suˆr de repre´senter facilement des courbes parame´triques :
>> plot(y,z);
On obtient, pour les valeurs de´finies plus haut, une courbe connue sous le nom de courbe de Lissajoux. Les instructions suivantes vont re´duire le´ge`rement l’e´chelle, donner un titre et un nom aux axes, et faire apparaˆ?tre une grille sur le fond :
>> axis([-1.1 1.1 -1.1 1.1])
>> title(’Courbe de Lissajoux’);
>> xlabel(’x : axe des absisses’);
>> ylabel(’y : axe des ordonnees’);
>> grid
Vous obtiendrez l’impression sur papier d’un graphe en utilisant la commande print qui enverra l’impression sur l’imprimante a` laquelle est relie´ votre ordinateur. C’est la dernie`re de vos figures qui sera imprimeé.
On conside`re la fonction de´finie par
F(x) = 0.01 expx + 10 cosx ? 3x. (1.2)
On vous demande d’e´crire un M-fichier ExempleCourbe.m pour tracer la courbe repre´sentant cette fonction sur l’intervalle [?1,10], en utilisant ses valeurs aux points k
xk. Vous fixerez la taille de la feneˆtre de visualisation de fac¸on que les absisses soient comprises entre ?1 et 11 et les ordonneés entre ?50 et 200.
Vous pourrez comple´ter cette figure en y ajoutant les axes et un titre. Ces axes peuvent eˆtre trace´s “a` la main” en utilisant les fonctionnalite´s de la feneˆtre graphique (voir les icoˆnes). Vous les obtiendrez aussi en terminant votre programme par les instructions donneés dans l’encadre´ ci-dessous.
...
hold on ; plot([0,9],[0,0],9,0,’>’) plot([0,0],[-20,150],0,150,’ˆ’) hold off ;
Vous allons creér un fichier qui repre´sente la fonction de Bessel de parame`tre ? = 0 sur l’intervalle [0, 50], et ve´rifier graphiquement que ses racines sur cet intervalle sont bien approcheés par les expressions
rj ' . (1.3)
Vous appellerez ce fichier VisuRacBess.m. Il devra contenir des instructions pour :
- de´finir les absisses x (utiliser la fonction linspace),
- de´finir le parame`tre ? et calculer les y = J?(x), en utilisant la fonction fzero.
Cette fonction re´soud les e´quations non line´aires. L’algorithme utilise´ combine plusieurs me´thodes, dont celles de la se´cante et de bissection. On doit fournir une valeur pour initialiser les ite´rations, et il est bon de disposer d’une valeur assez voisine de la solution chercheé. On se servira donc des expressions (1.3).
- repre´senter sur la meˆme figure les y et l’axe des x,
- calculer les rj, (de´finir un tableau R en utilisant une variable J = [1 :15]; ), - repre´senter sur la figure pre´ce´dente les points (rj, 0) par le symbole ?.
On voudrait pouvoir donner un titre a` cette figure, et pour cela repre´senter les lettres grecques ? et : cela peut se faire de la fac¸on suivante :
title(’La fonction J_{\nu } pour \nu = 0’);
On peut souhaiter des caracte`res un peu plus grands pour ce titre :
title(’La fonction {\nu } pour \nu = 0’,’Fontsize’,12);
La taille de fonte est pre´ciseé par la proprie´te´ ’Fontsize’, suivie de la valeur choisie.
Cette instruction utilise les re`gles du langage LATEXqui est un langage de programmation de traitement de texte particulie`rement bien adapte´ a` la gestion des formules mathe´matiques. Elle appelle quelques commentaires :
– Le caracte`re permet de mettre en position d’indice les caracte`res entre accolades qui le suivent.
– Le caracte`re \ permet a` LATEX de reconnaˆ?tre ses commandes. Vous en trouverez quelques-unes dans le tableau 1.2.
La fonction qui permet de repre´senter une courbe dans l’espace R3 est plot3. Sa syntaxe est
plot3(x,y,z,s);
et cette fois x, y et z sont des vecteurs de meˆme dimension contenant les trois coordonneés. Essayez :
>> theta = pi*[-4:0.04:4]; r = linspace(1,6,201);
>> x = r.*(1+cos(theta)); y = r.*sin(theta); z = r;
>> plot3(x,y,z,’k*’); grid;
| minuscules grecques | majuscules grecques | symboles mathematiques´ | |||
| Commande | Symbole | Commande | Symbole | Commande | Symbole |
| \alpha | ? | \Delta | ? | \leq | ? |
| \beta \gamma | ? ? | \Theta \Gamma | ? ? | \geq \int | ? R |
| \omega | ? | \Omega | ? | \infty | |
| \lambda | ? | \Lambda | ? | \sim | |
| \pi | ? | \Phi | ? | \partial | |
| \rho | ? | \Psi | ? | \in | |
| \nu | ? | \Sigma | ? | \rightarrow | ? |
TAB. 1.2 – Principaux symboles mathe´matiques reconnus par MATLAB.
MATLAB permet de repre´senter des surfaces donneés en coordonneés carte´siennes ou sous forme parame´trique. La forme parame´trique peut s’e´crire :
x = x(s,t) y = y(s,t) z = z(s,t)
ou` les parame`tres s et t parcourent un certain domaine. Plusieurs fonctions permettent cette repre´sentation, parmi lesquelles mesh repre´sente un treillis, et surf une surface pleine. Elles ont le meˆme format d’appel :
surf(X,Y,Z,C);
X,Y et Z sont des matrices de meˆmes dimensions contenant les coordonneés de points de la surface. C permet de de´finir les couleurs et peut eˆtre omis. Nous allons repre´senter le coˆne d’equation x2 + y2 ? 2xz = 0 en utilisant la repre´sentation parame´trique donnee pour (?, ?) ?] ? ?, ?[×]0, 12[ par :
x = ?(1 + cos?), y = ? sin?, z = ?.
On peut proce´der de la fac¸on suivante :
>> n = 31 ; theta = pi*[-n:2:n]/n ; r = linspace(0,12,n);
>> X = r’*(1+cos(theta)) ;
>> Y = r’*sin(theta) ;
>> Z = r’*ones(size(theta));
>> surf(X,Y,Z);
Il est important de remarquer que X, Y et Z sont des matrices de meˆme taille!
La surface repre´senteé laisse apparaitre les traces d’une grille qui la recouvre. L’aspect de la surface est controˆle´ par la variable shading, dont les valeurs possibles sont faceted (valeur par de´faut), flat (supprime le treillis), et interp (adoucit les transitions). Essayez :
>> shading interp;
Les couleurs sont de´finies par une matrice C de meˆme taille que celles des coordonneés, et par de´faut, cette matrice est C=Z, de sorte que d’une certaine fac¸on, la couleur est “proportionnelle” a` l’altitude du point de la surface. Tout cela de´pend du choix d’une palette graphique. Essayez :
>> C = rand(size(Z)) ; surf(X,Y,Z,C);
La palette de couleurs de la feneˆtre de visualisationest définie par la variable colormap.
Sa valeur par de´fault est ’jet’ . Essayez :
>> colormap(’cool’);
La liste des palettes disponibles est fournie avec celle de toutes les fonctions ou variables de controˆle d’un graphique 3D par la commande :
>> more on, help graph3d, more off
Examinons a` pre´sent le trace´ d’une surface donneé par son e´quation carte´sienne z = f(x,y). En ge´ne´ral, on dispose d’une famille de valeurs de x et d’une famille de valeur de y stockeés dans 2 vecteurs, respectivement x et y. On va devoir construire deux matrices X et Y telles que les colonnes de X et les lignes de Y soient constantes : ces matrices seront utilisees pour le calcul des valeurs de f. On peut utiliser la fonction meshgrid .
Ainsi, pour repre´senter la surface d’e´quation z = exp(?x2 ?y2), ?2 < x,y < 2, on pourra proce´der comme suit :
>> [X,Y] = meshgrid(-2:.2:2, -2:.2:2);
>> Z = X .* exp(-X.ˆ2 -Y.ˆ2);
>> surf(Z);
Si on ne souhaite que le treillis, on remplace la fonction surf par mesh. Si l’on souhaite des isolignes, on utilise la fonction contour3; par exemple :
>> v = linspace(0,max(max(Z)),20); contour3(Z,v);
Lorsque que l’on trace une figure, par exemple la courbe repre´sentant la fonction y = sinx sur l’intervalle [?3.5,3.5], on utilise une fonction graphique de MATLAB. On peut le faire simplement de la fac¸on suivante :
>> x = linspace(-3.5,3.5) ;
>> y = sin(x);
>> plot(x,y);
Les commandes pre´ce´dentes auront creé´ la figure 1.3
FIG. 1.3 – Une figure obtenue par la commande de base plot.
La fonction plot que l’on a utilise´ a ge´ne´re´ un assez grand nombre de données. Ces donneés sont les caracte´ristiques de notre figure. Le syste`me de repre´sentation graphique de MATLAB est un syste`me oriente´ objet, et les donneés qui caracte´risent une figure sont relatives aux diffe´rents objets qui la constituent.
Certaines de ces donneés peuvent eˆtre pre´ciseés lors de l’appel de la fonction : on peut choisir le type de trace´, sa couleur ... D’autres pourraient l’eˆtre en utilisant des fonctions qui le permettent : legend, xlabel...
Si l’on avait voulu modifier la position la taille de la feneˆtre graphique, il aurait cependant fallu utiliser la fonction figure avant la fonction plot et fixer les valeurs de la proprie´te´ ’Position’.
Pour ge´rer une feneˆtre graphique, il convient de pouvoir identifier ces objets, avant de fixer ou de modifier leurs proprie´te´s. Cette identification se fait par les handles, litte´ralement les “poigneés” pour les attraper!
La premie`re e´tape consiste a` re´cupe´rer ces handles. La fonction findobj le permet.
Voici ce que peut fournir son appel :
>> h = findobj h =
0
1.0000 151.0015
152.0022
Il ne s’agit pas ensuite d’utiliser les valeurs afficheés, mais de se rappeler que h est un vecteur de 4 composantes dont chacune est un handle. Quels sont les objets ainsi identifie´s?
>> get(h,’type’) ans =
’root’
’figure’
’axes’
’line’
La premie`re composante dont la valeur est 0 est la racine, c’est-a`-dire l’e´cran. La seconde est le feneˆtre. Son handle est e´galement de´signé par la fonction gcf (“get current figure”).
Cette structure est arborescente : a` partir de la racine, on peut trouver une ou plusieurs feneˆtres; dans chaque feneˆtre, un ou plusieurs syste`mes d’axes, et dans chacun d’entre eux, un ou plusieurs courbes.
Chaque type d’objet ge`re certaines proprie´te´s. On va commencer par modifier la taille de la feneˆtre. Pour cela, il faut modifier la proprie´te´ ’Position’.
Pour voir comment elle est de´finie, nous re´cupe´rons sa valeur.
>> get(h(2),’Position’) ans =
181 457 560 420
Vous n’aurez pas les meˆmes valeurs. Ces valeurs repre´sentent respectivement la distance la feneˆtre au bord gauche de l’e´cran, sa distance au bord infe´rieur de l’e´cran, sa largeur et sa hauteur. Elles sont donneés en Pixels.
Pour modifier la taille de cette feneˆtre, il faut connaˆ?tre la taille de l’e´cran. C’est une proprie´te´ de la racine :
>> get(h(1),’ScreenSize’) ans =
1 1 1280 1024
On peut pre´fe´rer travailler en coordonneés relatives avant de fixer cette taille :
>> set(h(2),’Units’,’normalized’,’Position’,[0.1 0.3 0.6 0.4])
Pour connaˆ?tre l’ensemble des proprie´te´s relatives a` l’objet figure, il suffit de taper get(h(2)).
Pour obtenir la liste de ces proprie´te´s avec les valeurs autoriseés, lorsqu’elles sont pre´de´finies, on tape set(h(2)).
L’objet h(3) est de type axes. On peut lister le champ de ses proprie´te´s avec leur valeur actuelle :
>> get(h(3))
Nous allons supprimer l’encadrement, modifier les limites de l’axe des y, fixer les positions et valeurs des “ticks” de l’axe des x :
>>set(h(3),’Box’,’off’)
>>set(h(3),’Ylim’,[-1.1 1.1])
>>set(h(3),’Ytick’,[])
>>set(h(3),’Xtick’,[-pi -pi/2 0 pi/2 pi])
>>set(h(3),’XtickLabel’,’-pi|-pi/2|0|pi/2|pi’)
On remarquera que les symboles LATEX ne sont pas pris en compte pour e´tiqueter les ticks.
Une proprie´te´ du nom de Title figure dans la liste des proprie´te´s de l’objet axes et sa valeur est un nombre reél. Il s’agit la` encore d’un handle, car le titre est lui meˆme un objet graphique.
>>htit = get(h(3),’Title’)
>>set(htit)
>>set(htit,’string’,’Fonction sinus’,’FontSize’,12)
>>set(htit,’Color’,[1 0 0])
La couleur obtenue est le rouge. La de´finition des couleurs peut se faire par un tableau de 3 valeurs comprises entre 0 et 1 qui donnent respectivement les poids relatifs du rouge, du vert et du bleu. (syste`me rgb). Le blanc est [1 1 1] et le noir [0 0 0].
On peut aussi modifier certaines proprie´te´s de l’objet de type line On en obtient la liste par get(h(4)).
Pour connaˆ?tre les possibilite´s offertes au niveau des types de trace´,
>>set(h(4),’Linestyle’)
>>set(h(4),’Marker’)
Fonction sinus
FIG. 1.4 – Figure modifieé graˆce a` la manipulation des hanlde.
On peut alors proposer
>>set(h(4),’Linestyle’,’none’,’Marker’,’+’)
>>set(h(4),’Markersize’,4)
>>set(h(4),’Ydata’,cos(x))
La figure apre`s modification ressemblera, sauf pour les couleurs, a` la figure 1.4. Il faudrait quand meˆme modifier son titre ...
Bien que l’on puisse faire beaucoup de choses en travaillant directement dans la feneˆtre de commandes de MATLAB, nous avons de´ja constate´ que qu’il e´tait souvent plus pratique d’utiliser des M-fichiers. Ils permettent
- de corriger plus facilement ses erreurs,
- de garder un travail en cours pour le reprendre plus tard,
- d’exe´cuter plusiers fois un programme en modifiant certains parame`tres, - d’e´changer son travail avec des camarades.
Jusqu’a pre´sent, ces fichiers e´taient des fichiers d’instructions, ou fichiers “scripts”. Un fichier script est un fichier contenant une suite d’instructions MATLAB directement e´xe´cutables. Ces instructions sont e´xe´cuteés en utilisant les variables de l’espace de travail, ou en cre´ant des variables dans cet espace.
MATLAB utilise e´galement des M-fichiers. En fait, un grand nombres des fonctions que nous avons rencontreés sont e´crites dans des M-fichiers. Il s’agit de fichiers “fonction”. Vous pouvez e´galement creér vos propres fonctions.
Un fichier “fonction” a sa premie`re ligne d’instruction e´xe´cutable qui commence par le mot clef function. Il peut recevoir des variables en entreé, mais utilise ces variables en dehors de l’espace de travail. Aucune des variables cre´ées ou modifieés lors de son e´xe´cution n’est visible depuis l’espace de travail a` moins qu’elle ne soit une variable en sortie de la fonction!
Nous allons illustrer la diffe´rence entre ces deux types de fichiers sur un exemple. Si le fonction f est suffisament re´gulie`re, la formule de Taylor permet d’obtenir une valeur approcheé de sa de´riveé en un point x, pour un pas h, suivant
f(x + h) ? f(x) 0 h 00 2) ' f0(x). (1.4)
= f (x) +f (x) + O(h h 2
| % Fichier ScriptDn1 pour calcu % la derivee numerique de sinu % au point 1 pour le pas % h = 0.01. x = 1; h = 0.01; Dn = (sin(x+h) -sin(x))./h; | s | lerfunction Res = Fonc1Dn1(h); % Derivee numerique de sinus % au point 1 en fonction du % pas h. x = 1; Dn = (sin(x+h) -sin(x))./h; Res = Dn; |
TAB. 1.3 – Fichier “script” et fichier “fonction”.
Le tableau 1.3 montre le contenu du fichier “script” ScriptDn1.m et du fichier “fonction” FoncDn1.m Une fois ces deux fichiers sauvegarde´s dans votre espace de travail, vous pourrez tapez les commandes quivantes :
>> clear all >> ScriptDn1
>> who
>> Err = abs(Dn-cos(1))
>> clear all
>> FoncDn1
MATLAB n’est pas content et il vous le dit :
??? Input argument "h" is undefined.
Error in ==> FoncDn1 at 6
Dn = (sin(x+h) -sin(x))./h;
L’erreur est commenteé; MATLAB vous indique le nume´ro de la ligne ou` elle s’est produite. A pre´sent, nous fournissons le pas en appel de la fonction
>> pas = 0.01 ; FoncDn1(pas) ans =
0.5361
>> Err = abs(Dn-cos(1))
??? Undefined function or variable ’Dn’.
>> who
Your variables are: ans pas
>> Der = FoncDn1(pas);
>> Der-ans
On peut faire quelques remarques :
- Le fichier script s’e´xe´cute sans qu’on lui fournisse d’arguments. Le fichier fonction a besoin qu’on lui fournisse les arguments qu’il ne creé pas, ici le pas.
- Le nom de la variable affecteé de la valeur de ce pas dans l’espace de travail n’a pas d’importance; c’est sa valeur qui est passeé.
- Les variables creéés par l’e´xe´cution du script sont vues dans l’espace de travail. Celles qui sont creéés lors de l’e´xe´cution de la fonction ne le sont pas. Ce sont des variables locales. L’argument en sortie prend le nom qu’on lui donne dans la session MATLAB.
Nous avons de´ja` rencontre´ la fonction F(x) = 0.01ex + 10 cosx ? 3x.
Dans ce cas, on dispose de deux fac¸ons pour creér une fonction MATLAB qui calcule les valeurs de F :
- comme la fonction F peut se de´finir en une seule ligne, on peut le faire avec la fonction inline
>> F1 = inline(’0.01*exp(x)+10*cos(x)-3*x’)
- de fac¸on plus ge´ne´rale, on peut e´diter un fichier que l’on va appeler F2.m qui devra commencer par le mot-clef function : vous pouvez le de´finir de la fac¸on suivante function y = F2(x) ;
y = 0.01*exp(x)+10*cos(x)-3*x;
La premie`re de´finition est a` utiliser lorsque l’on n’envisage pas d’utilisation ulte´rieure de cette fonction. La de´finition au moyen d’un fichier permet de la conserver. Cependant, ainsi qu’elle est re´digeé, cette fonction a encore le de´faut que son objet n’est pas imme´diatement lisible; on risque de l’avoir oublie´ quand on aura besoin de la re´utiliser. Il faut donc la commenter.
Cela se fait sur des lignes qui commencent par le symbole % . Ce symbole transforme en commentaires tous les caracte`res qui le suivent dans la ligne courante. Entre autres commentaires, vous devrez toujours indiquer le format d’appel de la fonction. Voici comment je vous sugge`re d’e´crire ce fichier :
function y = F2(x) ;
% fichier fonction definissant la fonction F2(x) qui sert d’exemple % au polycopie d’initiation a Matlab.
% L’appel se fait selon :
% >> y = F2(x);
y = 0.01*exp(x)+10*cos(x)-3*x;
Ces commentaires sont place´s imme´diatementapre`s la premie`re ligne (de de´claration). De cette fac¸on, ils constitueront la re´ponse fournie par MATLAB a` la commande :
>> help F2
Les variables internes d’un fichier fonction sont locales; elles ne sont pas vues depuis l’espace de travail. Corollairement, les variables de l’espace de travail que vous souhaitez utiliser dans une fonction doivent eˆtre passeés en argument. La commande global permet de de´finir des variables globales. Elles doivent eˆtre de´clareés globales au de´but de la fonction et dans l’espace de travail.
La formule (1.4) est dite d’ordre 1 car l’erreur d’approximation de la de´riveé est de la forme O(h). On peut obtenir une formule d’ordre 2, c’est-a`-dire avec une erreur en O(h2) en utlisant la formule
f(x + h) ? f(x ? h) = f0(x) + h2 f000(x) + O(h3) ' f0(x). (1.5)
2h 6
On vous demande d’e´crire une fonction Fonc2Dn1.m qui calcule la de´riveé approcheé de la fonction sinus au point x = 1 pour le pas h en utilisant la formule (1.5) Vous e´crirez e´galement un script TestDn.m dans lequel : - vous de´finirez le vecteur des pas, pas = 10.ˆ(-[1 : 16]);
- vous calculerez les de´riveés approcheés pour ces pas en utilisant les deux fonctions; - vous calculerez les erreurs Err1 et Err2 commises dans chaque cas;
- vous repre´senterez ces erreurs en fonction du pas avec des coordonneés logarithmiques :
loglog(pas, Err1, ’b-+’, pas, Err2, ’r-*’) ;
- vous pourrez re´fle´chir et commenter cette figure!
On peut passer plusieurs arguments a` une fonction. Supposons que l’on souhaite creér une fonction MATLAB qui calcule la fonction F(a,b) pre´sentant un “pic” peu marque´ au point a et un pic plus marque´ au point b :
