Cours Matlab 

1 Introduction

MAT (rix) LAB (oratory) est un logiciel puissant doté à la fois d'un langage de programmation haut niveau et d'outiils dédiés au calcul numérique et à la visualisation numérique. Développé en C par la société Mathworks (http://www.mathworks.com/), Matlab était initialement destiné à faire du calcul matriciel simplement.  Actuellement, Matlab recouvre d'autres domaines d'applications de l'informatique scientifique :

• visualisation graphique 2D et 3D
• résolution d'équations aux dérivées partielles
• optimisation
• contrôle de procédés
• traitement du signal
• traitement de l'image
• logique floue
• réseaux de neurones

Les système Matlab se divise en deux parties :

• le noyau Matlab, qui comprend :
1. l'environnement de travail offrant pluiseurs facilités pour la manipulation des données. Son interpréteur permet de tester rapidement ses propres programmes Matlab.
2. le système graphique Matlab (interfaces homme-machine, graphiques, images, animations).
3. le langage de programmation Matlab.
4. une librairie de fonctions mathématiques Matlab.
5. un système d'interfaçage faciltant l'exécution de programmes C ou Fortran sous Matlab.
• une collection de toolboxes (boîtes à outils) regroupant un ensemble de fonctions spécifiques à un thème.

---

---

2 Quelques fonctions pour bien débuter

Matlab dispose de plusieurs commandes d'aide à la manipulation des fonctions et des fichiers :

• help : fournit la liste des catégories de fonctions installées.
• help fonction/commande : indique comment utiliser une fonction.
• helpwin : ouvre une fenêtre permet d'accéder facilement aux aides des différentes commandes.
• doc fonc : affiche la documentation HTML de la fonction fonc (cette fonction doit appartenir au noyau Matlab).
• lookfor mot-clé : recherche dans toutes les aides le mot-clé donné en argument et retourne la ligne contenant ce mot en précisant la fonction correspondante.
• which fonc : retourne le chemin du fichier de déclaration de la fonction fonc (lorsque celle-ci est décrite sous la forme d'un fichier avec l'extension .m)
• dir('rep') : liste tous les fichiers présents dans le répertoire passé en argument .
• what('rep') : liste tous les fichiers Matlab présents dans le répertoire rep en précisant le type de fichier.
• type fonc : affiche le code de la fonction fonc (à condition que la fonction soit décrite dans un fichier m).
• dbtype fonc : identique à la fonction type en indiquant des numéros de ligne.
• exist('A') : permet de savoir si une fonction Matlab, une variable Matlab ou un répertoire existe.

Pour contrôler le défilement des pages d'aide, il est souvent pratique d'utiliser la commande more on/off.

Matlab fournit également la possibilité d'exécuter des commandes unix directement sous l'interpréteur :

• les commandes cd, ls, pwd et mkdir sont analogues à celles connues sous UNIX.
• unix('unix_com') : exécute une commande UNIX et affiche une valeur de retour (0 si la commande unix est licite).
• !unix_com : exécute juste la commande UNIX unix_com.

---

---

3 Les variables Matlab

Un seul type de données existe sous Matlab : le type matrice (Matrix). Tout doit être pensé avec des matrices : un nombre est une matrice 1*1, une chaîne de caractères est une matrice 1*n, une courbe 2D sera tracée à l'aide de deux vecteurs de même dimension.
Par conséquent, aucune variable n'a besoin d'être déclarée. Les calculs en virgule flottante sont alors effectués avec la précision maximale disponible sur la machine (32 bits pour nos machines). De même, aucune allocation mémoire n'est à gérer et les opérations de redimensionnement des matrices sont relativement aisées.

Les noms de variables sont composés de lettres et de chiffres ; seuls les 19 premiers caractères sont pris en compte et Matlab fait la distinction entre minuscules et majuscules.

Matlab fournit deux fonctions permettant de lister les variables de l'environnement de travail :

• who : liste le nom des variables courantes.
• whos : précise pour chaque variable courante : son nom, sa dimension, sa classe.

La commande clear var permet d'effacer la variable var de l'environnement de travail.
La commande clear all permet d'effacer toutes les variables de l'environnement de travail.

Plusieurs commandes permettent de sauvegarder / restaurer des variables dans l'environnement de travail :

• save nomf : sauve toutes les variables de l'environnement de travail dans le fichier nomf.mat (.mat est l'extension de fichier par défaut).
• save nomf X₁ X₂ ... X_n : sauve les variables X₁ X₂ ... X_n dans le fichier nomf.mat.
• load nomf : restaure dans l'environnement de travail toutes les variables stockées dans nomf.mat.
• diary nomf : à partir du moment où cette commande est tapée, l'ensemble des instructions effectuées dans la session Matlab sont enregistrées dans le fichier nomf.mat et ce jusqu'à ce que les commandes exit (de sortie de session) ou diary off soit exécutée.

---

---

4 Les constantes Matlab

Quatre constantes Matlab sont prédéfinies :

• pi : 3.14159...
• eps : 2.2204e-16 par défaut. C'est la distance entre deux réels informatiques consécutifs. Cette valeur est modifiable. Cette valeur est utilisée au niveau des tests d'arrêt des algorithmes.
• Inf (Infinite) : nombre infini. C'est par exemple le résultat de l'opération 1/0.
• NaN (Not a Number) : n'est pas un nombre. C'est par exemple le résultat de l'opération 0/0.
• realmin / realmax : plus petit /plus grand nombre flottant.
• i, j : nombre complexe égal à sqrt(-1).

---

---

5 Format de représentation des nombres

La commande format permet d'afficher un nombre à un format donné. Les différents formats possibles sont :

• short (valeur par défaut) : représentation d'un nombre réel sous forme fixe avec 4 chiffres de précision après la virgule (x....x.y₁y₂y₃y₄).
• long : représentation d'un nombre réel sous forme fixe avec 14 chiffres de précision après la virgule.
• short e :  représentation d'un nombre réel en notation scientifique scientifique avec 4 chiffres de précision après la virgule (x...x.y₁y₂y₃y₄e+z₁z₂z₃).
• long e : représentation d'un nombre réel en notation scientifique avec 14 chiffres de précision après la virgule.
• short g : choisit la meilleure représentation entre short et short e.
• long g : choisit la meilleure représentation entre long et long e.
• format hex : représentation d'un nombre sous forme hexadécimale.
• format rat : représentation d'un nombre au format rationnel (x/y).

---

---

6 Les vecteurs et matrices

6.1 Saisie

La saisie d'une matrice s'effectue ligne par ligne. Le ; est un séparateur de ligne et le caractère blanc (ou la virgule) est un séparateur de deux éléments consécutifs d'une même ligne.

>>  A=[1 1 3; 4 0 6; 2,5,-1]

A =

     1     1     3
     4     0     6
     2     5    -1

On peut également taper enter à la place d'un ;

>>  B=[1 0 -1
0 1 1
-1 1 0]

B =

     1     0    -1
     0     1      1
   -1     1      0

6.2 Opérations élémentaires

Les opérations d'addition, de soustraction, de multiplications, de tranposition de matrices, d'addition/soustraction/multiplication d'un scalaire à une matrice se font de manière très intuitive :

>>  x=[3 6 -2]; y=[7 2 4];
>>  x+y

ans =

    10     8     2

>>  x'

ans =

     3
     6
    -2

>>  A*x'

ans =

     3
     0
    38

>>  3+y

ans =

    10     5     7

Lorsqu'un opérateur est précédé du caractère ., l'opération s'effectue élément par élément.

>>  A*B

ans =

    -2     4     0
    -2     6    -4
     3     4     3

>>  A.*B

ans =

     1     0    -3
     0     0     6
    -2     5     0

6.3 Opérateur de mise en colonne

L'opérateur : permet de transformer toute matrice en un vecteur colonne

>>  A

A =

     1     1     3
     4     0     6
     2     5    -1

>> A(:)'

ans =

     1     4     2     1     0     5     3     6    -1

6.4 Extraction /extension d'une partie de matrice

L'opérateur : appliqué à une dimension d'une matrice permet d'extraire des parties de matrice

>>  A(:,2:3) %extraction des colonnes 2 à 3

ans =

     1     3
     0     6
     5    -1

La suppresssion d'une colonne  (resp. ligne) se fait par substitution avec une colonne (resp. ligne) vide.

>>  A(2,:)=[] %suppression de la 2ieme ligne

A =

     1     1     3
     2     5    -1

>>  A(:,3)=[] %suppression de la 3ieme colonne

A =

     1     1
     2     5

Les instructions suivantes permettent d'ajouter une ligne et une colonne

>>  A=[A;3 4] %ajout d'une 3eme ligne

A =

     1     1
     2     5
     3     4

>>  A(:,3)=[7 9 12]' %ajout d'une 3eme colonne

A =

     1     1     7
     2     5     9
     3     4    12
 

6.5 Taille et dimensions d'une matrice

>>  size(A) %précise les dimensions de A sous la forme d'un vecteur colonne

ans =

     3     3

>> length(A) %plus grande dimension de A

ans =

     3

>> ndims(A) % nombre de dimensions de A

ans =

     2
 

6.5 Affichage d'une matrice

Les commandes disp, printmat et pltmat permettent d'afficher une matrice :

• disp(A) affiche la matrice A sans son nom dans l'interpréteur de commandes Matlab.
• printmat (A) affiche la matrice A en indiquant les numéros de ligne.
• pltmat(A) affiche la matrice A dans une fenêtre séparée. Il est possible de préciser un titre, la couleur du quadrillage et la taille des caractères.

>>  disp(A)
     1     1     7
     2     5     9
     3     4    12

>> printmat(A)
  --1-->      1      1      7
  --2-->      2      5      9
  --3-->      3      4     12

>> pltmat(A,'Matrice A','b',12)
 

6.6 Transformation et manipulation des matrices

Les commandes fliplr (respectivement flipud) réalisent un retournement des colonnes (respectivement des lignes). La commande flipdim effectue un retournement de la matrice suivant une dimension précisée. Ainsi, pour une matrice 2D appelée A, flipdim(A,1) est équivalent à flipud(A) et flipdin(A,2) est équivalent à fliplr(A,2).

>> fliplr(A)

ans =

     7     1     1
     9     5     2
    12     4     3

>> flipud(A)

ans =

     3     4    12
     2     5     9
     1     1     7

>> all(all(flipdim(A,2)==fliplr(A)))% on verifie que flipdim(A,2)==fliplr(A)

ans =

     1

La commande rot90 effectue une rotation de 90° d'une matrice :

>> A

A =

     1     1     7
     2     5     9
     3     4    12

>> rot90(A)

ans =

     7     9    12
     1     5     4
     1     2     3

La commande permute réordonne les dimensions d'une matrice suivant l'ordre spécifié par un vecteur :

>> permute(A,[2 1])

ans =

     1     2     3
     1     5     4
     7     9    12

La commande reshape(x, m, n) forme une matrice m*n à partir des éléments de x. x doit avoir m*n éléments :

>> x=[1 2 3 4 5 6]; reshape(x,2,3)

ans =

     1     3     5
     2     4     6

La commande sub2ind(size, i1, ..., in) retourne l'indice de l'élément (i1, ..., in) d'une matrice dont les dimensions sont précisées par le tableau size. Sa fonction réciproque est ind2sub(size, index).

>> sub2ind([3 3], 1, 2)

ans =

     4

>> [i,j]=ind2sub([3 3], 4)

i =

     1
 

j =

     2

Enfin, end fait référence au dernier indice d'une matrice suivant la dimension indiquée :

>> A(end,end)

ans =

    12

>> A(end,:) % fait référence à la dernière ligne de A

ans =

     3     4    12

6.7 Fonctions élémentaires sur les matrices

Matlab possède plusieurs fonctions (présentes dans datafun) agissant directement sur les vecteurs ou les colonnes de matrices :

• min, max : valeurs minimale et maximale des éléments
• sum : somme des éléments
• prod : produit des éléments
• cumsum : somme cumulée des éléments
• cumprod : produit cumulé des éléments
• mean : valeur moyenne des éléments
• median : valeur médiane des éléments
• std, var : écart-type et variance des éléments
• sort : tri des éléments par ordre croissant

>> sum(A)

ans =

     6    10    28

>> cumsum(A)

ans =

     1     1     7
     3     6    16
     6    10    28

>> cumprod(A)

ans =

     1     1     7
     2     5    63
     6    20   756

Pour obtenir la somme de tous les éléments de la matrice A, on peut soit appliquer deux fois la fonction sum, soit appliquer une fois la fonction sum à la matrice A mise en colonne.

>> sum(sum(A))

ans =

    44

>> sum(A(:))

ans =

    44

6.8 Génération de matrices particulières

Le répertoire elmat propose plusieurs fonctions de génération de matrices élémentaires ou spécifiques.
Voici tout d'abord les fonctions de génération de matrices élémentaires :

• zeros : crée une matrice nulle
• ones : crée une matrice dont tous les éléments valent 1
• eye : crée une matrice identité
• rand : crée une matrice dont les éléments sont tirés aléatoirement entre 0 et 1
• randn : crée une matrice dont tous les éléments sont distribués suivant la loi normale N(0,1)
• repmat : permet de créer des matrices blocs dont chaque bloc est identique à celui spécifié en argument

>> eye(3,3)

ans =

     1     0     0
     0     1     0
     0     0     1

>> eye(2,3)

ans =

     1     0     0
     0     1     0

>> rand(2,3)

ans =

    0.4565    0.8214    0.6154
    0.0185    0.4447    0.7919

>> C=[1 2;3 4]

C =

     1     2
     3     4

>> repmat(C,2,3)

ans =

     1     2     1     2     1     2
     3     4     3     4     3     4
     1     2     1     2     1     2
     3     4     3     4     3     4

Plus de 60 fonctions sont prévues pour la création de matrices plus spécifiques. Ces fonctions sont détaillées à la fin de l'aide en ligne obtenue par la commande "help elmat". Les fonctions listées par la commande "help gallery" peuvent être détaillées à l'aide de la commande "help private/function" (par exemple "help private/cauchy" pour les matrices de Cauchy).

>> compan([1 2 3]) % Calcule la matrice dont le polynome caractéristique est X^2+2X+3

ans =

    -2    -3
     1     0

>> gallery('invol',4) % Calcule une matrice involutive d'ordre 4 (ie tq ans*ans=eye(4))

ans =

   -4.0000    0.5000    0.3333    0.2500
 -120.0000   20.0000   15.0000   12.0000
  240.0000  -45.0000  -36.0000  -30.0000
 -140.0000   28.0000   23.3333   20.0000
 

6.9 Opérations propres au calcul matriciel

L'ensemble des opérations élémentaires sur les matrices peuvent être effectuées par Matlab :

• rank(A) : rang de A
• det(A) : déterminant de A
• trace(A) : trace de A
• expm(A), logm(A), sqrt(A) : calcul de l'exponentielle, du logarithme ou de la racine carrée de A. De manière générale, on peut appliquer une fonction fun à une matrice via la fonction funm : funm(A,'fun') (exemple : funm(A, 'sin') calcul le sinus de la matrice A).

Matlab permet d'effectuer la plupart des décompositions et factorisations de matrices grâce, entre autre, aux fonctions suivantes :

• chol(A) : factorisation de Cholesky. Pour A définie positive, cette fonction calcule une matrice R triangulaire supérieure vérifiant R'*R=A.
• [R, P] = cholp(A) : factorisation de Cholesky avec pivotage. Pour A définie positive, cette fonction calcule deux matrices R et P tel que R'*R=P'*A*P.
• [L, U] = LU(A) : décomposition LU. Cette fonction calcule une matrice L triangulaire supérieure et une matrice U triangulaire inférieure tel que A=L*U.
• [Q, R] = QR(A) : décomposition QR. Calcule une matrice Q unitaire (Q'*Q=Id) et une matrice R triangulaire supérieure vériafiant A=Q*R.
• [U, T] = schur(A) : décomposition de Schur. Calcule 2 matrices T et U telles que A=U*T*U' où T est une matrice de Schur (matrice triangulaire supérieure dont la diagonale est composée des valeurs propres de A) et U est une matrice unitaire (U*U'=Id)
• [P, H] = hess(A) : forme Hessenberg de A. Calcule 2 matrices H et P vérifiant X=P*H*P'. H est nulle en-dessous de la première sous-diagonale, possède les mêmes valeurs propres que A et est tridiagonale si A est symétrique. P est unitaire : P'*P=Id.
• [U, R, V] = cod(A) : décomposition orthogonale de A. Fournit 3 matrices U, R et V vérifiant A=U*T*V où U et V sont unitaires et T=[R 0;0 0], R étant triangulaire supérieure inversible avec dim(R)=rang(A).
• [U, S, V] = svd(A) : décomposition en valeurs singulières. Décompose A sous la forme A=U*S*V' où S est une matrice diagonale contenant les valeurs singulières de A et U, V sont toutes deux des matrices unitaires.

Matlab fournit également de nombreuses fonctions permettant de résoudre des problèmes d'inversion matricielle :

• cond(A,N) : calcule le conditionnement de la matrice A pour la norme N (à savoir N(A)*N(A^-1)). N peut valoir 1, 2 ou inf. Plus le conditionnement est grand, plus le système linéaire sera instable. La fonction norm(A, N) calcule la norme N de A pour les mêmes valeurs de N.
• condest(A) : calcule un conditionnement de A toujours compris entre 0 et 1.
• inv(A) : calcule l'inverse de la matrice carrée A si elle existe. Ainsi, la solution X du système linéaire A*X=B se calcule en faisant inv(A)*B, ce qui est aussi équivalent à A\B.
• X=lsqnonneg(A,B,X₀) : résout, par la méthode des moindres carrés, le problème d'optimisation min|AX-B|² soumis à la contrainte X>=0 en choisissant comme vecteur initial X₀.
• X=cgs(A,B) : résout, par la méthode des gradients conjugués, le problème d'optimisation min|AX-B|².
• Les fonctions bicg (méthode des gradients biconjugués), gmres (méthode du résidu minimal généralisé), qmr (méthode du résidu quasi-minimal), pcg (méthode des gradients conjugués préconditionnés).
• X=pinv(A) : calcule la pseudo-inverse X de A. X possède les mêmes dimensions que A' et vérifie A*X*A = A, X*A*X = X avec A*X et X*A hermitiennes.

Les problèmes de recherche de valeurs et vecteurs propres sont effectués à l'aide de la fonction eig :

• [V, D] = eig(A) : fournit la matrice diagonale D des valeurs propres et la matrice V des vecteurs propres de A.
• poly(A) : renvoit un vecteur de dimension length(A)+1 dont les éléments sont les coefficients du polynôme caractéristique de A (le 1er coefficient est celui de la plus grande puissance).

6.10 Les matrices creuses

La boîte à outils sparfun comporte un ensemble de fonctions sur les matrices creuses à 1 ou 2 dimensions.
En effet, lorsqu'une matrice possède beaucoup d'éléments nuls (la matrice est dite creuse), il est intéressant d'utiliser une représentation condensée de ce type de matrice afin de diminuer la place mémoire occupée, le nombre d'opérations et le temps de calcul.

La fonction de conversion d'une matrice pleine m*n en matrice creuse est sparse(i, j, s, m, n) avec i, j indices lignes et colonnes des éléments non nuls et s valeurs des éléments non nuls. La fonction réciproque (passage de la représentation creuse à la représentation pleine d'une matrice) se fait grâce à la fonction full.

>> i=[1 3 2 2]

i =

     1     3     2     2

>> j=[1 1 2 3]

j =

     1     1     2     3

>> s=[1 2 3 4]

s =

     1     2     3     4

>> A=sparse(i,j,s,3,3)

A =

   (1,1)        1
   (3,1)        2
   (2,2)        3
   (2,3)        4

>> fullA=full(A)

fullA =

     1     0     0
     0     3     4
     2     0     0

La commande issparse permet de savoir si une matrice admet une représentation pleine ou creuse :

>> issparse(A)

ans =

     1

>> issparse(fullA)

ans =

     0

Des fonctions permettent d'extraîre les informations propres aux éléments nuls et non nuls d'une matrice creuse :

• [i, j, s] = find(A) : retourne les vecteurs d'indices i et j des éléments non nuls ainsi que la valeur de ces éléments dans le vecteur s. find(A) retournera juste un vecteur d'indices des éléments non nuls de A.
• nnz(A) : donne le nombre d'éléments non nuls de A.
• nonzeros(A) : donne le vecteur des éléments non nuls de A.
• spy(A) : affiche sur un graphique 2D la répartition des éléments non nuls.

>>  [i,j,s]=find(A)

i =

     1
     3
     2
     2
 

j =

     1
     1
     2
     3
 

s =

     1
     2
     3
     4

>> find(A)

ans =

     1
     3
     5
     8

>> nnz(A)

ans =

     4

>> nonzeros(A)

ans =

     1
     2
     3
     4

>> spy(A)
 

De la même manière que pour les matrices pleines, plusieurs fonctions de génération de matrices sont préprogrammées :

• speye(m, n) : génère une matrice identité de taille m*n.
• sprand(m, n, d) : génère une matrice creuse avec approximativement m*n*d éléments non nuls suivant la loi uniforme sur [0;1] qui sont répartis aléatoirement.
• sprandn(m, n, d) : génère une matrice creuse avec approximativement m*n*d éléments non nuls suivant la loi normale N(0,1) qui sont répartis aléatoirement.
• sprandsym(n, d) : génère une matrice creuse symétirque avec approximativement n*n*d éléments non nuls, suivant la somme d'une ou plusieurs variables aléatoires.  Les éléments non nuls sont répartis aléatoirement.

>> full(sprand(3,4,0.2))

ans =

         0         0    0.8928     0
         0    0.2731     0         0
         0         0         0         0

>> full(sprandn(3,4,0.3))

ans =

   -0.0956    0         0   -0.8323
         0         0         0         0
    0.2944     0         0         0

>> full(sprandsym(3,0.4))

ans =

    0.8580     0    1.2540
         0         0         0
    1.2540     0         0
 

La fonction spfun permet d'appliquer une fonction à tous les éléments non nuls d'une matrice creuse : spfun('fun', A).

>>  full(A)

ans =

     1     0     0
     0     3     4
     2     0     0

>> full(spfun('exp',A))

ans =

    2.7183         0         0
         0   20.0855   54.5982
    7.3891         0         0

Les algorithmes classiques rencontrés en algèbre linéaire ont également été programmés : résolution de systèmes linéaires, recherche de valeurs et vecteurs propres, calcul de normes, du conditionnement d'une matrice.
 

---

---

7 Les nombres complexes

Matlab permet une manipulation aisée des complexes soit sous la forme algébrique (a+i*b) soit sous la forme exponentielle (rho*exp(i*theta)).
NB : Les imaginaires purs i et j vérifient tous deux i² = j² = -1.
Les opérations et fonctions usuelles +, -, *, /, ^, sqrt, exp, log sont directement applicables sur les nombres complexes.

>> z1=1+3i % Notez que le * entre 3 et i est inutile

z1 =

   1.0000 + 3.0000i

>> z2=2-4i

z2 =

   2.0000 - 4.0000i

>> z1+z2

ans =

   3.0000 - 1.0000i

>> z1*z2

ans =

  14.0000 + 2.0000i

>> z1/z2

ans =

  -0.5000 + 0.5000i

>> z1^2

ans =

  -8.0000 + 6.0000i

>> 2^z1

ans =

  -0.9740 + 1.7468i

>> z1^z2

ans =

 -7.5542e+02 - 1.2709e+03i

>> log(z1)

ans =

   1.1513 + 1.2490i

>> sqrt(z1)

ans =

   1.4426 + 1.0398i
 

Quelques fonctions de manipulation des complexes :

• abs(z) : renvoit le module du complexe z.
• angle(z) : renvoit la phase (en radians) du complexe z.
• real(z), imag(z) : renvoit respectivement les parties réelles et imaginaires du complexe z.
• conj(z) : renvoit le conjugué de z.
• complex(a,b) : renvoit le complexe a+ib.

Fonction de représentation graphique de complexes :

• compass(vz) : représentation graphique des complexes du vecteur vz en choisissant pour origine de chacun de ces complexes l'origine du répère.

Plusieurs fonctions d'aide au tracé de fonctions complexes :

• cplxgrid(n) : renvoit une matrice (n+1)*(2n+1) de complexes permettant de subdiviser le pavé [-1,+1]*[-1,+1] de manière quasi-uniforme.
• cplxmap(z,f(z)) : fonction de tracé d'une fonction complexe

>> s=cplxgrid(4);
>> plot(s)
>> plot(s(1,:))
>> plot(s(2,:))
>> plot(s(3,:))
>> plot(s(4,:))
>> plot(s(5,:))
 

>> z=cplxgrid(20);
>> cplxmap(z,sqrt(z)) % tracé de la fonction sqrt(z) sur le pavé [-1,+1]*[-1,+1]
 

• cplxroot(n) : tracé de la fonction f(z) = z^(1/n) avec n>0 sur le pavé [-1,+1]*[-1,+1]

---

---

8 Les chaînes de caractères

La boîte à outils strfun est consacré au traitement des chaînes de caractères.
Pour Matlab, une chaîne de caractères est un vecteur ligne composé de chaque caractère de la chaîne.
Une chaîne de caractères ne peut être délimitée qu'avec des apostrophes.

Les fonctions de base :

• length(ch) : retourne la longueur de la chaîne ch.
• disp(ch) : affiche une variable de type chaîne de caractères.
• abs(ch) ou double(ch) : renvoit, sous forme de vecteur ligne,  les codes ASCII de chaque caractère de la chaîne.
• setstr(vc) ou char(vc) : fonction réciproque de abs ; retourne la chaîne de caractères pour lesquels les codes ASCII sont ceux du vecteur ligne vc.
• [ch1, ch2, ..., chn] : concaténation de n chaînes de caractères (similaire à strcat sauf que strcat ignore les caractères blancs en fin de chacune des chaines chi).
• deblank(ch) : supprime les éventuels blancs figurant en fin de chaîne de caractères.

>> ch1='presentation'

ch1 =

presentation

>> length(ch1)

ans =

    12

>> vc=abs(ch1)

vc =

   112   114   101   115   101   110   116    97   116   105   111   110

>> setstr(vc)

ans =

presentation

>> disp([ch1,' de ','Matlab'])
presentation de Matlab

>> ch2='3 blancs a la fin   ';
>> disp(['Taille avec les blancs a la fin=',num2str(length(ch2))]);
Taille avec les blancs a la fin=20
>> disp(['Taille sans les blancs a la fin=',num2str(length(deblank(ch2)))]);
Taille sans les blancs a la fin=17
 

Fonctions de test sur les caractères et chaînes de caractères :

• isstr(ch) / ischar(ch) : renvoit 1 si ch est une chaîne de caractères et 0 sinon.
• isletter(l) : renvoit 1 si l est une lettre de l'alphabet et 0 sinon.
• isspace(ch) : renvoit 1 si ch est le caractère blanc et 0 sinon.
• strcmp(ch1, ch2) : renvoît 1 si les deux chaînes ch1 et ch2 sont identiques et 0 sinon.

Ecriture d'une chaîne de caractères en minuscules / majuscules :

• lower(ch) : écrit tout le contenu de la chaîne ch en minuscules
• upper(ch) : écrit tout le contenu de la chaîne ch en majuscules

>> lower('logiciel MATLAB')

ans =

logiciel matlab

>> upper('logiciel MATLAB')

ans =

LOGICIEL MATLAB

Evaluation d'une chaîne de caractères :

• eval(ch) : évalue les commandes, opérations de la chaîne de la chaîne. Une erreur est retournée si la chaîne ne peut être interprétée.

>> eval('sqrt(2)+1')

ans =

    2.4142

Quelques fonctions utiles :

• strrep(ch1, ch2, ch3) : substitue toutes les occurences de la chaîne ch2 dans la chaîne ch1 par la chaîne ch3.
• [mot1, reste_chaine] = strtok(ch) : renvoie le premier mot (mot1) et le reste de la chaîne ch.
• l = findstr(ch1, ch2) : l est le tableau des indices auxquels commencent les occurences de ch1 dans ch2.

>> strrep('logiciel MATLAB', 'logiciel', 'super logiciel')

ans =

super logiciel MATLAB

>> [mot1, reste] = strtok('super logiciel MATLAB')

mot1 =

super
 

reste =

 logiciel MATLAB

>> l = findstr('informatique scientifique', 'ti')

l =

     8    19
 

• strcat(ch1, ch2, ..., chn) : concatène les n chaînes de caractères chi en supprimant les blancs de fin de chaîne.

>> strcat('logiciel    ', ' scientifique', ' MATLAB')

ans =

logiciel scientifique MATLAB

Cette boîte à outils inclut également les conversions nombre<->chaîne de caractères et conversions de nombre d'une base à une autre (bases admises : binaire, décimale et hexadécimale ou base quelconque entre 2 et 36) :

• num2str(nb) : convertit un  nombre en chaîne de caractères. Sa fonction réciproque est str2num.

>> dec2hex(12)

ans =

C

>> dec2bin(12)

ans =

1100

>> dec2base(12,4)

ans =

30
 

---

---

9 Les polynômes

L'essentiel des fonctions sur les polynômes figure dans la boîte à outils polyfun.

Génération d'un polynôme à partir de ses coefficients rangés par ordre de décroissance de leur puissance :

>> p=[2 0 3] % p(x)=2x²+3

p =

     2     0     3

Génération d'un polynôme à partir de ses racines :

>> poly([2 1]) % polynome x²-3x+2

ans =

     1    -3     2

Recherche des racines d'un polynôme :

>> roots([1 -3 2])

ans =

     2
     1

Evaluation d'un polynôme en un point :

>>  polyval([1 -3 2], 3)

ans =

     2

Multiplication de polynômes :

>>  conv(poly([1 2]), poly([3 4])) % generation du polynome (x-1)(x-2)(x-3)(x-4)

ans =

     1   -10    35   -50    24
 

Division de polynômes :

>> P=[1 2 3];
>> S=[4 5 6];
>> [Q,R]=deconv(P,S) % Calcul du quotient Q et du reste R : P=QS+R

Q =

    0.2500
 

R =

         0    0.7500    1.5000

Dérivation d'un polynôme :

>> polyder([3 4 5]) % Derivation du polynome 3x²+4x+5

ans =

     6     4

Décomposition d'une fraction en éléments simples :

>> [R,P,K]=residue(P,S) % B(s)/A(s) = K(s) + R(1)/(s-P(1)) + ... + R(n)/(s-P(n))

R =

   0.0938 - 0.1224i
   0.0938 + 0.1224i
 

P =

  -0.6250 + 1.0533i
  -0.6250 - 1.0533i
 

K =

    0.2500
 

Interpolation polynomiale :

• polyfit(x, y, n) : Retourne le polynôme p d'ordre n respectant au mieux les conditions yi=p(xi) au sens des moindres carrés.

D'autres fonctions d'interpolation :

• interp1(x, y, z, 'methode') : interpolation aux points d'une courbe donnée par les données (xi, yi). Plusieurs méthodes sont disponibles : plus proche voisin, linéaire, spline cubique, cubique.
• interp2, interp3, interpn : même fonction que interp1 mais pour une interpolation 2D, 3D ou n dimensions.

---

---

10 Résolution d'autres problèmes numériques

Recherche de zéro d'une fonction :

• fzero(func, x0) : renvoit la valeur d'annulation de la fonction func la plus proche de x0. func est soit une fonction mise sous la forme d'un fichier en extension .m, soit une fonction en ligne.

>> fzero('sin(x)+0.5', 2)
Zero found in the interval: [0.18981, 3.8102].

ans =

    3.6652

Minimisation d'une fonction :

• x=fminsearch(func, x0) : minimisation de fonction non linéaire multidimensionnelle et sans contraintes. Retourne la valeur de x la plus proche de x0 minimisant la fonction func. Si x0 est un vecteur colonne, x sera également un vecteur colonne contenant les valeurs de minimisation pour les différentes valeurs de x0.
• x=fminbnd(func, x1, x2) : minimisation de fonction non linéaire multidimensionnelle sous les contraintes x1<x<x2. Une seule solution est renvoyée.

Ajustement des paramètres de l'algorithme de minimisation / recherche de zeros :

• options = optimset('param1',value1,'param2',value2,...)

Intégration numérique :

• q = quad('func', a, b) / q= quad8('func', a, b) : integration numérique de la fonction monodimensionnelle 'func' entre a et b avec une méthode d'ordre plus ou moins élevée.
• q = dblquad('func', a1, a2, b1, b2, 'methode') : intégration numérique de la fonction bidimensionnelle 'func' dans le pavé [a1, b1]*[a2, b2] par une méthode d'ordre plus ou moins élevée (méthode peut valoir quad ou quad8).

Résolution de systèmes différentiels :

• ode45, ode23, ode113, ode23t, ode15s, ode23s, ode23tb : méthodes de résoltuion de systèmes différentiels. Ces fonctions prennent en argument la fonction décrivant le système (fonction qui dépend du temps t et de y) qui est définie dans un fichier .m.

Exemple :

Extrait du fichier sys.m décrivant le système (x'=-2y, y'=x) :

function yp=sys(t,y)
yp=[-2*y(2),y(1)]';

>> t0=1;
>> tfinal=20;
>> y0 = [10 3]';
>> [t,y]=ode23('sys',[t0 tfinal],y0);
>> plot(t,y)
 

De la même manière que pour les fonctions d'optimisation, il est possible de régler les paramètres de résoltuion d'un système à l'aide de la fonction odeset.
Si par exemple, on tape les commandes options = odeset('OutputFcn','odeplot') puis ode23('sys',[t0, tfinal], y0, options), on verra le système évoluer graphiquement à chaque pas de temps. Les options odephas2 et odephas3 passées à la fonction odeset permettent de visualiser le portrait de phase des 2 ou 3 premières composantes à chaque pas de temps. L'option odeprint passée à la fonction odeset affiche à l'écran les valeurs de la solution à chaque pas de temps.

---

---

11 Programmer en MATLAB

1. Les fichiers Matlab : il en existe principalement 5 sortes :
• Les fichiers de description d'une fonction (ils possèdent l'extension .m). La première ligne commence par :
• function y=nom_de_la_fonction(liste_des_parametres) si la fonction renvoit une seule valeur.
• function [y1, ..., yn]=nom_de_la_fonction(liste_des_parametres) si la fonction renvoit  n valeurs y1, ..., yn.
• Les fichiers script (ils possèdent également l'extension .m) : ils sont composés d'une succession de commandes Matlab.
• Les fichiers de données au format texte (avec l'extension .dat) : la commande load var.dat provoque la création de la variable var dont le contenu est celui du fichier var.dat.
• Les fichiers binaires au format .mat : ce sont des fichiers de stockage des variables de l'espace de travail (remplissage du fichier avec la fonction save, chargement des variables avec la fonction load).
• Les fichiers MEX : fichiers générés à partir d'un code C ou Fortran 77 afin que ce code soit directement interprété par Matlab.

1. Quelques précisions sur les variables Matlab :

• Pas de distinction minuscules / majuscules.
• Les 19 premiers caractères sont significatifs.
• Toutes les variables d'un fichier en extension .m sont par défaut locales à l'espace de travail.
• On précise que la portée d'une variable est globale et est accessible dans un fichier .m ou dans l'espace de travail en indiquant localement l'instruction global VAR (par convention, les variables globales sont en majuscules).
• Les variables nargin et nargout peuvent être utilisées dans toute fonction. Elles précisent respectivement le nombre d'arguments d'appel et le nombre d'arguments de retour de la fonction. De même, les variables varargin et varargout sont les tableaux contenant la valeur des arguments d'appel et de retour.

1. Les commentaires :

Tout commentaire Matlab est précédé du symbole %.
 
2. Les instructions Matlab :
• L'instruction for
 
FOR var=val_ini:pas:val_fin
instructions
END
• L'instruction while
 
WHILE expression_logique
instructions
END
• L'instruction if
 
IF expression_logique_1
instructions_1
ELSEIF expression_logique_2
instructions_2
...
ELSE
instructions_n
END
• L'instruction switch
 
SWITCH switch_expr
CASE case_expr
statement, ..., statement
CASE {case_expr1, case_expr2, case_expr3,...}
statement, ..., statement
...
OTHERWISE
statement, ..., statement
END


switch_expr et les case_expr peuvent être des scalaires ou des chaînes de caractères. Un seul CASE peut être exécuté, auquel cas les instructions suivantes sont celles qui suivent le END du switch.

• L'instruction try / catch
 
TRY
statement, ..., statement
CATCH
statement, ..., statement
END


Normalement, seules les instructions entre le TRY et le CATCH sont exécutées. Cependant, si une erreur survient lors de l'exécution d'une de ces instructions, ce sont les instructions entre le CATCH et le END qui seront exécutées.

• break : permet de sortir de la boucle la plus proche.
• return : permet soit de revenir au fichier M appelant, soit de revenir dans l'interpréteur de commandes.
• error('MSG') : affiche le texte MSG, émet un "bip" et interrompt l'exécution du programme.
• eval(chaine) : Exécute les instructions d'une chaîne de caractères.
• eval(chaine1, chaine2) : Exécute les instructions de chaine1. Si aucune erreur ne se produit, retourne au programme appelant. Sinon, exécute les instructions de chaine2.
• T=evalc(chaine) : identique à la fonction eval sauf que les sorties sur la fenetre de commandes sont renvoyées dans le tableau T.
3. Les instructions de saisie et d'affichage au clavier :
• disp(X) : affiche le contenu du vecteur X. X peut être une chaîne de caractères.
• S=printf(formats, variables) : renvoit le contenu d'une liste de variables formattées sous la forme d'une chaîne de caractères.
• R=input(message) : affiche message et atteint la saisie d'une donnée, qui sera affectée dans R.
• A=sscanf(string, format) : lit des variables a partir d'une chaîne de caractères, les convertit en utilisant les formats spécifiés et affecte le résultat dans le vecteur A.
4. Les entrées / sorties : Les fonctions d'entrées / sorties sous Matlab sont analogues à celles du C.
• FID=fopen(nom_fichier, mode_d_ouverture) : ouverture d'un fichier.
• fclose(FID) : fermeture du fichier ayant FID pour descripteur.
• fprintf(FID, 'formats', liste_variables) :  ecriture de données formattées dans un fichier.
• [A, compteur]=fscanf(FID, format, nb_lus) : lecture dans un fichier d'une série de données. Les valeurs lues sont affectées dans le vecteur colonne A. nb_lus est un argument facultatif qui représente le nombre d'éléments que l'on veut lire dans le fichier. Si nb_lus est affecté à inf, tous les éléments du fichier seront avec le format décrit. compteur est également optionnel et représente le nombre d'arguments effectivement lus dans le fichier.
• fseek(FID, offset, origine) : déplace le pointeur de fichier de "offset" octets à partir d'origine (qui vaut -1 / 0 / 1 suivant que l'origine est le début de fichier / la position courante du fichier / la fin du fichier).
• position=ftell(FID) : retourne la position courante du fichier (en nombre d'octets) à partir du début de fichier.
• frewind(FID) : positionne le pointeur de fichier sur le premier octet.
5. Lecture de données dans un fichier texte :
Supposons qu'un fichier texte "donnees3d.dat" contienne 3 colonnes de n valeurs, la commande "load donnes3d.dat" créera une matrice donnees3d de taille n*3 contenant les valeurs du fichier.

---

---

12 Les graphiques 2D

• La commande plot(x, y, s) trace des courbes ou nuages de points à partir de 2 vecteurs de dimension identique (y en fonction de x). s est une chaîne de 1 à 3 caractères précisant la couleur de la courbe, le symbole de représentation d'un point, le type de trait utilisé pour le tracé.
• Les fonctions semilogx / semilogy / loglog sont analogues à la fonction plot sauf qu'une échelle logarithmique (en base 10) est ulilisée pour l'axe des x / l'axe des y / l'axe des x et des y.
• polar(rho, theta, s) dessine la courbe en coordonnées polaires rho=f(theta).
• fplot(string, [Xmin Xmax]) dessine une fonction décrite dans une chaîne de caractères entre Xmin et Xmax. (exemple : fplot('sin(1./x)',[1 2])).

Remarque :  Pour dessiner un nuage de points, il suffit de spécifier juste un marqueur au niveau de s
Exemple :  plot(x,y,'+')

Commandes d' "habillage" de graphiques (communes aux graphiques 2D et 3D) :

• axis([Xmin Xmax Ymin Ymax]) fixe les bornes des axes.
• grid on / off ajoute ou enlève des grilles dans les plans des axes.
• box on / off permet d'encadrer ou non un cadre dans chaque plan combinant plusieurs axes.
• hold on / off permet d'autoriser ou de supprimer la superposition de graphiques.
• xlabel('texte') / ylabel('texte') / zlabel('texte') ajoute une légende à un axe. Ces commandes combinées à la commande texlabel permettent d'obtenir une légende écrite au format TeX. Essayer xlabel(texlabel('x^2+y^2')) pour tester.
• title('texte') ajoute un texte en haut du graphique.
• text(x,y,'texte') ou text(x,y,z,'texte) positionne un texte de documentation d'une courbe au point de coordonnées (x,y) ou (x,y,z).
• gtext('texte') : analogue à la fonction text sauf que le point est choisi à la souris.
• legend('leg1', 'leg2', ...) : crée une boîte de légende pour les courbes tracées.
• plotedit on / off : active ou désactive un mode de modification du graphique. Si plotedit est mis à on, il est possible de visualiser les propriétés des objets, d'ajouter des objets. Pour cela, utiliser le bouton "Tools" de la fenêtre.

Il est possible de dessiner plusieurs graphiques dans une même fenêtre à l'aide de la fonction subplot :

• subplot(m, n, num) : se positionne sur le graphique de numéro num sachant que la fenêtre est subdivisée en une matrice m*n de graphiques.

Enregistrement / Impression d'un graphique :

• print -format nom.fmt : sauvegarde la fenêtre courante sous la forme d'une image au format indiqué.

Gestion des fenêtres :

• Chaque fenêtre possède un numéro dont la valeur est accessible en cliquant sur la fenêtre puis en tapant la commande gcf (get current figure).
• Pour créer une figure ayant h comme numéro de handle, il suffit de taper figure(h). Si la fenêtre existe déjà, cette fonction met en avant la fenêtre ayant num comme numéro de handle.
• Pour effacer le graphe de la figure courante, taper clf.
• La commande close(h) supprime la figure ayant h comme numéro de handle.
• get(h) permet d'obtenir la liste des propriétés de la fenêtre ayant h pour numéro de handle.

Les autres fonctions de tracé de graphiques 2D :

• ezplot('f(x,y)') : fonction de tracé d'une courbe implicite f(x,y)=0.
• comet(x,y) : fonction identique à plot sauf que les segments de droite sont affichés au fur et à mesure de manière à créer une animation.
• bar(x, y) où nb_lignes(y)=nb_colonnes(x) affiche les m colonnes de y en fonction de x avec des barres verticales centrées sur les valeurs du vecteur x. La fonction bar3(x, y) donne le même résultat mais en 3 dimension.
• hist(x) : trace un histogramme de fréquence des valeurs de x.
• pie(x) : trace un camembert des valeurs de x. pie3(x) donne le même résultat avec un camembert 3D.
• stem(x, y) : trace y en fonction de x sous la forme de fonctions de Dirac.
• stairs(x, y) : trace y en fonction de x sous la forme de fonctions en escalier.
• fill(x,y) : fonction de tracé d'un polygone en fonction des points spécifiés par les vecteurs x et y.

---

---

13 Les graphiques 3D

Principales fonctions de tracé 3D :

• plot3(x, y, z, s) permet d'afficher des nuages de points ou de relier une série de points (dont les coordonnées sont stockées dans les vecteurs x, y et z) avec des lignes. Au niveau du contenu de s, les mêmes conventions que la fonction plot sont adoptées.
• [X, Y]=meshgrid(x, y) génère deux matrices X et Y à partir des vecteurs x et y. X et Y sont ensuite utilisés dans les fonctions de tracé de surfaces. Si x et y sont de taille respective m et n, X et Y sont des matrices n*m. Chaque ligne de X vaut x et chaque colonne de Y vaut y.
• surf(X, Y, Z, C) dessine la surface définie par quatre matrices. Les coordonnées des points sont stockées dans X, Y et Z et C est une matrice d'échelle de couleurs utilisée pour colorer une facette de la surface. Si C n'est pas spécifié, C=Z.
• mesh(X, Y, Z, C) : identique à surf sauf que l'intérieur des facettes n'est pas colorée.

Contrôle des couleurs d'un graphique :

• hidden on / off : montre / cache les parties cachées d'une surface.
• shading flat / interp /faceted : supprime le quadrillage / supprime le quadrillage et effectue un dégradé de couleurs uniforme / affecte une seule couleur sur une facette (à utiliser avec surf).
• brighten nb (-1 <= nb <= 1) : eclaircit le graphique si nb >=0 et l'assombrit sinon.
• colordef white / black : axes noirs sur fond blanc / axes blancs sur fond noir.
• colormap(map) : affecte une table des couleurs (map), matrice à n lignes et 3 colonnes. Chaque ligne est composée de 3 valeurs comprises entre 0 et 1 et formant une couleur RGB. Une correspondance est établie entre les cotes extremes du graphique et les première et dernière couleur de la table des couleurs. Pour avoir la liste des cartes disponibles, taper help graph3d.

Obtention des coordonnées de la normale d'une surface : [Nx,Ny,Nz]=surfnorm(x,y,z)

Quelques autres fonctions de tracé de graphiques 3D :

• contour(x, y, z) : trace sur un plan les lignes de niveau de la surface (x, y, z).
• surfc(x, y, z) / meshc(x, y, z) sont équivalents à surf(x, y, z) + contour(x, y, z) / mesh(x, y, z) + contour(x, y,z).
• clabel permet d'étiqueter des courbes de niveau.

Vecteurs et de volumes : les fonctions figurent dans la partie "Volume and vector visualization" du help specgraph3d.

---

---

14 Images et animations

La toolbox specgraph contient les fonctions élémentaires de manipulation des images :

• image(C) ou imagesc(C) : crée une image à partir de la matrice C. C peut être une matrice m*n, auquel cas la colormap courante est utilisée ou une matrice m*n*3 de réels compris entre 0 et 1 qui sera alors utilisée comme colormap.
• a=imread('nom_image.fmt') : crée une matrice m*n*3 à partir d'une image au format JPEG, TIFF, BMP (pour ne citer que les formats les plus connus).
• imwrite(a, 'nom_image.fmt') : crée une image appelée nom_image.fmt à partir de la matrice a (qui peut être m*n ou m*n*3).
• imfinfo('nom_image.fmt') : fournit quelques informations sur une image.

Des fonctions plus avancées, propres au traitement de l'image, se trouvent dans la toolbox imagetb : attention, quelques bugs ont été constatés. Pour plus d'infos, faire un help imagetb ou taper imdemo.

Les fonctions permettant de gérer des animations se trouvent également dans la toolbox specgraph :

• a=getframe(h) : stocke dans la matrice a la figure de handle h
• movie(M) : crée une animation à partir du vecteur de matrices M

---

---

15 Création d'interfaces Homme-Machine

La réalisation d'interfaces graphiques se fait à l'aide d'un outil appelé graphique. Grâce à cet outil, il est possible de créer, de personnaliser les interfaces graphiques de ses applications de manière visuelle.

Pour lancer l'éditeur, taper guide. La fenêtre suivante apparaît alors :

Les quatre boutons du haut permettent d'ouvrir les fenêtres suivantes :

1. Une fenêtre "Property Editor" permettant d'éditer et de modifier la liste des propriétés graphiques d'un objet sélectionné.
2. Une fenêtre "Callback Editor" permettant d'associer une ou plusieurs instructions au clic souris d'un objet.
3. Une fenêtre "Alignment Tool" permettant de gérer les espaces et alignement des objets de la fenêtre sélectionnée.
4. Une fenêtre "Menu Editor" permettant la construction de barres de menus.

Le même guide permet l'insertion des objets suivants :

• axes : insertion de graphiques
• pushbutton : bouton poussoir
• text : texte statique (le contenu du texte n'est pas modifiable par l'utilisateur)
• edit : texte éditable (modifiable par l'utilisateur)
• listbox : liste simple pour le choix d'une option parmi plusieurs possibilités
• popupmenu : menus déroulants
• checkbox : case à cocher (choix non exclusifs)
• radiobutton : bouton radio ou bouton d'option (choix exclusifs)
• slider : barre de défilement (pour contrôler une valeur sur un intervalle)
• frame : cadre (pour encadrer plusieurs objets)