Vous êtes sur la page 1sur 29

A.

TIMESLI MATLAB

Initiation à MatLab

1
A.TIMESLI MATLAB

1. Généralités
MAT (matrix) LAB (laboratory) est un logiciel puissant doté à la fois d'un langage de
programmation haut niveau et d'outils dédiés au calcul numérique et à la visualisation numérique.
Développé en C par la société Mathworks, Matlab était initialement destiné à faire simplement du
calcul matriciel.
Matlab est un outil puissant qui permet la résolution de nombreux problèmes en beaucoup moins
de temps qu'il n'en faudrait pour les formuler en C ou en Pascal. Il est aussi un outil de référence pour
la simulation numérique, notamment en ce qui concerne l‟Automatique, Mécanique, Electronique
…etc .
Il offre des possibilités avancées que ce soit en matière d‟identification ou de commande.
Il permet, de manière plus générale, de résoudre une grande diversité de problèmes de simulation,
dans des domaines aussi variés que le traitement du signal, les statistiques ou la vision, pour ne citer
que quelques exemples.
Avec MatLab les calculs sont numériques (une variable doit avoir une valeur) et basés sur la
manipulation de scalaires, de vecteurs et de matrices.
Le logiciel MatLab est en même temps un langage de programmation et un environnement
permettant d'utiliser ce langage.
Ce langage fut développé dans les années 70 pour des applications impliquant des matrices,
l'algèbre linéaire et l'analyse numérique. Le mot "MatLab" est en fait la forme courte de "Matrix
Laboratory".
Comme ce langage existe et est utilisé depuis longtemps, de nombreuses bibliothèques d'outils et
de fonctions en rapport avec des applications bien spécifiques ont été développées et testées. Ainsi,
Simulink est la boîte d'outil pour le traitement du signal.
Matlab se divise en deux parties :
le noyau Matlab, qui comprend :
 l'environnement de travail offrant plusieurs facilités pour la manipulation des données. Son
interpréteur permet de tester rapidement ses propres programmes Matlab.
 le système graphique Matlab (interfaces homme-machine, graphiques, images, animations).
 le langage de programmation Matlab.
 une librairie de fonctions mathématiques Matlab.
un système d'interfaçage facilitant 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.
C'est un langage interprété, c'est-à-dire que les instructions sont exécutées immédiatement après avoir
été introduites. Il n'est pas nécessaire de compiler un programme avant de l'exécuter et toute
commande introduite dans la fenêtre de commande est immédiatement exécutée. C'est dans cette
fenêtre que l'on peut écrire les instructions Matlab (à la suite des chevrons >>).
La réponse est affichée et stockée dans la variable ans (answer en anglais est la réponse).
La plupart des fonctions mathématiques usuelles sont définies dans Matlab, et ceci sous une forme
naturelle (sin, cos, exp, ...). de même que certaines constantes (pi ...).
>> 2*sin(pi/4)  ans = 1.4142

1.1. Comment lancer MatLab?


MATLAB est beaucoup plus qu'un langage de programmation. Il s'agit d'une console d'exécution
(shell ) au même titre que les consoles DOS ou UNIX.
Comme toutes les consoles, MATLAB permet d'exécuter des fonctions, d'attribuer des valeurs à des
variables, etc. Plus spécifiquement, la console MATLAB permet d'effectuer des opérations
mathématiques, de manipuler des matrices, de tracer facilement des graphiques.
Interface graphique du MatLab

2
A.TIMESLI MATLAB

1.2. Opérations directement faites sur l’invite MatLab


L‟utilisateur peut affecter des valeurs à des variables et effectuer des opérations sur ces variables. Par
exemple :
>> x = 2
x= 2
>> y = 3
y= 3
>> x + y
ans = 5
>> x * y
ans = 6
Ici, il faut noter que lorsque l'utilisateur ne fixe pas de variable de sortie, MATLAB place le résultat
d'une opération dans ans. Il est toujours possible de connaître les variables utilisées et leur type à
l'aide de la fonction whos. Par exemple, pour les manipulations précédentes :
>> whos
Name Size Bytes Class
ans 1x1 8 double array
x 1x1 8 double array
y 1x1 8 double array

1.3. Variables
On peut indiquer le nom de la variable dans laquelle le résultat doit être stocké (commence par
une lettre, moins de 19 caractères).
>> x = pi/4  x = 0.7854
Le nom de cette variable ainsi que le résultat sont affichés. Un point virgule à la fin de la ligne permet
de ne pas afficher ce résultat. On peut taper plusieurs commandes par ligne, séparées par un point
virgule.
>> x = pi/2; y = sin(x);
Il existe un certain nombre de variables prédéfinies : pi inf i realmin realmax eps ans
>> eps  ans = 2.2204e-16
>> realmax  ans = 1.7977e+308
>> realmin  ans = 2.2251e-308

1.4. Variables complexes


Matlab travaille indifféremment avec des nombres réels et complexes. Par défaut les variables i et
j sont initialisées à la valeur complexe.

3
A.TIMESLI MATLAB

Naturellement si vous redéfinissez la variable i ou j avec une autre valeur elle n'aura plus la même
signification.
>> z = 3 + 2*i  z = 3.0000 + 2.0000i
Les fonctions usuelles de manipulation des nombres complexes sont prédéfinies dans Matlab : real,
imag, abs, angle (en radian), conj.
>> r = abs(z);
>> theta = angle(z);
>> y = r*exp(i*theta);

1.5. Scalaires, Vecteurs, matrices et leur manipulation


L‟élément de base de MATLAB est la matrice. C'est-à-dire qu'un scalaire est une matrice de
dimension 1x1, un vecteur colonne de dimension n est une matrice nx1, un vecteur ligne de dimension
n, une matrice 1xn. Contrairement aux langages de programmation usuels (i.e. C++), il n'est pas
obligatoire de déclarer les variables avant de les utiliser et, de ce fait, il faut prendre toutes les
précautions dans la manipulation de ces objets.
Les scalaires se déclarent directement, par exemple :
>> x = 0;
>> a = x;
Les vectrices lignes se déclarent de la manière suivante :
>> V_ligne = [0 1 2]
V_ligne = 0 1 2

Pour les vecteurs colonne, on sépare les éléments par des points-virgules :
>> V_colonne = [0;1;2]
V_colonne = 0
1
2
Il est possible de transposer un vecteur à l'aide de la fonction transpose ou avec l'apostrophe ('). Ainsi,
>> V_colonne = transpose(V_ligne)
V_colonne = 0
1
2
>> V_colonne = V_ligne'
V_colonne = 0
1
2
On peut spécifier directement une matrice sous la forme d'un tableau, l'espace ou la virgule sépare
deux éléments d'une même ligne, les points virgules séparent les éléments de lignes distinctes.
123
>> A = [1, 2, 3 ; 4, 5, 6 ; 7, 8, 9]  A = 4 5 6
789
Les éléments d'une matrice peuvent être n'importe quelle expression de Matlab :
>> x = [ -1.3, sqrt(3), (1+2+3)*4/5 ]  x = -1.3000 1.7321 4.8000
Les éléments d'une matrice peuvent être référencés par leurs indices :
>>x(2)  ans = 1.7321
>>x(5) = abs(x(1))  x = -1.3000 1.7321 4.8000 0.0000 1.3000
On peut remarquer que la taille du vecteur x a été ajustée en remplissant les éléments non précisés par
0.
On peut aussi créer des matrices avec les fonctions zeros, ones et eye, ces fonctions créent des
matrices de la taille précisée, respectivement remplies de zéros , de un, et de un sur la diagonale et des
zéros ailleurs (eye = prononciation anglaise de I comme identité).
>> eye(2,3)  ans = 1 0 0
4
A.TIMESLI MATLAB

010
>> ones(1,5)  ans = 1 1 1 1 1
On peut avoir des informations sur la taille d'une matrice :
>> size(x)  ans = 1 5 Il s‟agit d‟une matrice 1x5 (1 ligne et 5 colonnes)
>> length(x)  ans = 5 C‟est en faite sup(nb de lignes,nb de colonnes)
Concaténation
On peut ajouter des lignes et des colonnes à des matrices déjà existantes.
>> r1 = [10, 11, 12];
1 2 3
>> A = [A ; r1]  A = 4 5 6
7 8 9
10 11 12
>> r2 = zeros(4,1);
1 2 3 0
>> A = [A, r2]  A = 4 5 6 0
7 8 9 0
10 11 12 0
Transformations de Matrice
On peut avoir le transposé ou le transposé conjugué d'une matrice :
>> A' % Transposée conjuguée de A
>> A.' % Transposée de A
mais aussi des retournements horizontaux (flipud : Up/Down), verticaux (fliplr : Left/Right), ou des
rotations de matrices :
7 8 9
>> A = [1, 2, 3 ; 4, 5, 6 ; 7, 8, 9] ; flipud(A) % Retournement vertical de A  4 5 6
1 2 3
3 2 1
>> fliplr(A) % Retournement horizontal de A  6 5 4
9 8 7
3 6 9
>> rot90(A) % Rotation de A de 90 degrés 2 5 8
1 4 7
On peut également remettre en forme des matrices et vecteurs sur un nombre de lignes et de colonnes
donnés (à condition que le nombre total d'éléments corresponde) :
>> B = [ 1 2 3 4 5 6 ];
>> B = reshape(B,2,3) % Remise en forme avec 2 lignes et 3 colonnes  B = 1 3 5
2 4 6
L'opérateur " : "
L'opérateur " : ", sous Matlab, peut être considéré comme l'opérateur d'incrémentation. Sa syntaxe
usuelle est : deb:pas:fin. Il construit un vecteur dont le premier élément est deb puis deb+pas,
deb+2*pas... jusqu'à deb+n*pas tel que deb+n*pas < fin < deb+(n+1)*pas.
>> x = 0.5:0.1:0.85  x = 0.5000 0.6000 0.7000 0.8000
Le pas d'incrémentation peut être omis, 1 est alors pris par défaut :
>> x =1:5  x = 1 2 3 4 5
On peut aussi utiliser le " : " pour sélectionner des éléments d'une matrice :
>> A(1,3) % Troisième élément de la première ligne de A
>> A(1,1:3) % Premier, deuxième et troisième éléments de % la première ligne de A
>> A(:,3) % Tous les éléments de la troisième colonne
>> A(:) % Vecteur colonne contenant tous les éléments lus colonne par colonne.
>> A = [ 1, 2, 3 ; 4, 5, 6 ; 7, 8, 9 ];
>> A( [3, 2, 1],[1, 3])  ans = 7 9
4 6
5
A.TIMESLI MATLAB

1 3
nous donnera les premiers et troisièmes éléments des lignes 3, 2 et 1 de A.
Mais il faut cependant remarquer que:
>> A([ 1, 0, 3 ],:)  ans = 1 2 3
789
nous donne les lignes de A dont l‟indice est non nul (c'est-à-dire ici la 1ère et la 3ième ligne).

1.6. Chaînes de caractères


Comme on l'a vu précédemment, toute variable de Matlab est une matrice. Cependant, il peut être
utile de conserver des chaînes de caractères dans des variables, et cela se fait de façon tout à fait
naturelle. On peut alors réaliser des manipulations de même type que pour les vecteurs
Affectation
>> ch = ‘ bonjour monsieur ’;
>> size(ch)  ans = 1 16
Cancatenation
>> ch1 = ‘ Flane ’;
>> ch2 = [ch ch1]  ch2 = bonjour monsieur flane
>> n=size(ch,2)-size(ch1,2);
>> ch3 = [ch1 blanks(n)];
>> ch4 = [ch ; ch3] ou ch4 = strvcat(ch,ch1)  bonjour monsieur
flane
>> size(ch4)  ans =2 17
Conversions
On peut convertir des nombres en chaîne de caractères à l'aide des fonctions
num2str : nombre chaîne
str2num : chaîne nombre
double ou abs : chaîne codes ascii
char ou setstr : codes ascii chaîne
Ecriture de chaînes formatées
syntaxe : text=sprintf(„ chaine1 format1 chaine2 format2... ‟, data1, data2 ...)
exemple :
>> pi2 = pi^2  pi2 =9.8696
>> text = sprintf(‘ le carré de pi vaut %3.2f ’, pi2)  text = le carré de pi vaut 9.87
On peut même écrire des caractères spéciaux comme retour à la ligne : \n et tabulation : \t
Comparaison de chaînes
Strcmp(s1,s2) : comparaison des chaînes s1 et s2
>> s1=‘Bonjour Monsieur’
>>s2=lower(s1);
>>strcmp(s1,s2)  ans = 0
Strcmpi(s1,s2) : comparaison sans tenir compte des majuscule
>>strcmpi(s1,s2)  ans = 1
Strncmp(s1,s2,n) : comparaison des n premiers caractères
>> s1(1)=‘b’  s1=‘bonjour Monsieur’
>>strncmp(s1,s2,8)  ans = 1
Strmatch(str,T) : renvoie les numéros de lignes qui commence par str
>>i=strmatch(‘min’,strvcat(‘min’, ‘max’, ‘minim’))  i= 1
3
findstr(s1,s2) : renvoie les indices de début de la chaîne la plus courte dans l‟autre
>> findstr (s1,’on’)  ans 2 10
Strrep(s1,s2,s3) : remplace les occurrences de s2 dans s1 par s3
>> s=Strrep(s1,’on’,’ON’)  s = bONjour MONsieur

6
A.TIMESLI MATLAB

Deux fonctions peuvent être très utiles lors de manipulations de chaînes de caractères : eval et
feval. Si l'on possède une instruction Matlab dans une chaîne de caractères, la commande eval
évaluera cette chaîne de caractères comme si elle avait été introduite à la ligne de commande de
Matlab :
>> eval([ nom-var, '1 = sqrt(-1)'])  x1 = 0.0000 + 1.0000i

1.7. Affichage alphanumérique


On peut afficher des chaînes de caractères dans la fenêtre de commande :
>> message=['pi vaut ' num2str(pi)] ;disp(message)  pi vaut 3.142
Les fonctions fprintf existe également et a la même syntaxe qu'en C.
>> fprintf('pi vaut %f\n',pi)  pi vaut 3.141593
On peut aussi demander des valeurs à l'utilisateur :
>>rep = input('Nombre d''itération de l''algorithme : ');
Matlab affichera la chaîne de caractère entrée en paramètre et attendra une réponse de l'utilisateur.

2. Opérations matricielles
Les opérations usuelles sont définies de façon naturelle pour les matrices :
>> 2*A % Produit par un scalaire
>> A*B % Produit de deux matrices (de dimensions % cohérentes)
>> A^p % Elève la matrice carrée A à la puissance p
>> inv(A) % Inversion d'une matrice carrée inversible (message % d'alerte éventuel)
>> A.*B % Produit élément par élément de deux matrices
Attention : A*A est différent de A.*A.
>> X = A\B % Donne la solution de A*X = B
>> X = B/A % Donne la solution de X*A = B
>> X = A./B % Division éléments par éléments
La plupart des fonctions mathématiques n'ayant pas de signification particulière pour des matrices les
considèrent comme un simple tableau de valeur, par exemple :
>> exp(A)  renverra une matrice dans laquelle tous les éléments seront l'exponentielle des éléments
de A, de même pour log, sqrt, round, rem (correspond au modulo), sign. Pour calculer l'exponentielle
matricielle, le logarithme matriciel ou la racine carrée d'une matrice on utilisera respectivement expm,
logm et sqrtm.
Certaines fonctions de Matlab agissent indépendamment sur chaque colonnes de la matrice. C'est le
cas de la fonction max (et min) :
>> max(A)  renverra un vecteur ligne dont chaque élément sera le maximum (minimum) de la
colonne correspondante. C'est aussi le cas des fonctions sum, prod et median qui donnent
respectivement les sommes, produit, et la valeur médiane des colonnes de la matrice. Les fonctions
cumsum, cumprod et sort renvoient une matrice dont chaque colonne contient les sommes et produits
cumulés et un tri des colonnes de la matrice initiale.
D'autres fonctions sont très utiles sur les matrices :
>> det(A) % Déterminant de A
>> trace(A) % Trace de A
>> [V, D] = eig(A) % Renvoie les vecteurs propres et les valeurs propres de A
Remarques sur les matrices creuses : Un grand nombre de fonctions Matlab s'appliquent
directement à des matrices creuses (c'est-à-dire dont la majeure partie des éléments sont nuls). On
peut créer des matrices creuses grâce à la fonction sparse. On ne conservera ainsi en mémoire que les
éléments non nuls de la matrice, d'où le gain de place mémoire. De même lorsqu'on utilisera ces
matrices lors de calculs, Matlab tiendra compte du fait qu'elles soient creuses pour réduire le coût de
calcul. Par exemple :
>> A = eye(2);
>> B = sparse(A)  B = (1,1) 1
(2,2) 1
7
A.TIMESLI MATLAB

On voit bien ici que Matlab ne conserve dans la matrice B que les éléments non nuls (ici les éléments
diagonaux) de la matrice A. Ainsi, les deux instructions suivantes donneront le même résultat mais la
première calculera quatre multiplications alors que la deuxième n'en calculera que deux car la matrice
B est creuse.
>> A*[ 1; 1];
>>C= B*[ 1; 1];
C est une matrice sparse, pour avoir la matrice entière on utilise la fonction full
>> D=full(C) ;
Le tableau suivant résume les différents opérateurs applicables aux matrices.
Syntaxe MATLAB Ecriture mathématique Terme général
A A Aij
B B Bij
A+B A+B Aij + Bij
A-B A-B Aij - Bij
A.*B Aij Bij
A./B Aij / Bij
A.^B AijBij
A.^s Aijs
A*B AB ∑kAikBkj
-1
A/B AB
A\B A-1B
A^n An
A‟ AT Aji

3. Affichages graphiques

3.1. Courbes à deux dimensions


Pour tout logiciel de tracée de courbes, une courbe 2D est représenté par une série d'abscisses et une
série d'ordonnées. Ensuite, le logiciel trace généralement des segments entre ces points. MATLAB
n'échappe pas à la règle. La fonction s'appelle plot. L'utilisation la plus simple de l'instruction plot est
la suivante :
plot ( vecteur d'abscisses, vecteur d'ordonnées )
[ x1 x2 … xn ] [ y1 y2 … yn ]
Les vecteurs peuvent être ligne ou colonne, pourvu qu'ils soient tous deux de même type.
Par exemple, si on veut tracer sin(x) sur l'intervalle [0; 2], on commence par définir une série
(raisonnable, disons 100) de valeurs équidistantes sur cet intervalle :
>> x = 0: 2*pi/100 : 2*pi;
puis, comme la fonction sin peut s'appliquer
terme à terme à un tableau :
>> plot(x, sin(x))
qui fournit le graphe suivant dans la fenêtre
graphique

On voit que les axes s'adaptent automatiquement aux valeurs extrémales des abscisses et ordonnées.
On remarquera que tout ce que demande plot,
c'est un vecteur d'abscisses et un vecteur
d'ordonnées. Les abscisses peuvent donc être une
fonction de x plutôt que x lui même. En d'autres
termes, il est donc possible de tracer des courbes
paramétrées :>> plot(cos(x), sin(x))

8
A.TIMESLI MATLAB

Superposer plusieurs courbes


Il suffit de spécifier autant de couples (abscisses,
ordonnées) qu'il y a de courbes à tracer. Par
exemple pour superposer sin et cos :
>> plot(x,cos(x),x,sin(x))

Les deux courbes étant en réalité dans des couleurs différentes. Cette méthode fonctionne même si
les abscisses des deux courbes ne sont pas les mêmes. Dans le cas plus fréquent où les abscisses
sont les mêmes, il existe un autre moyen de superposer les courbes. On a toujours le vecteur des
abscisses, commun aux deux courbes, et on a autant de vecteurs d'ordonnées qu'il y a de courbes.
Tous ces vecteurs d'ordonnées sont regroupés
dans un même tableau, chaque ligne du tableau
représentant un vecteur d'ordonnées :
plot ( vecteur d'abscisses, tableau d'ordonnées )
Par exemple, pour superposer sin et cos, on devra fournir à plot les arguments suivants :

Le deuxième tableau se construit très facilement avec le point-virgule


>> plot(x, [cos(x);sin(x)])
Lorsque l'on écrit une expression arithmétique dans les arguments de plot, il faut utiliser
systématiquement les opérateurs terme à terme .* ./ et .^ au lieu de * / et ^
Attributs de courbes
Vous aurez remarqué que MATLAB attribue des couleurs par défaut aux courbes. Il est possible de
modifier la couleur, le style du trait et celui des points, en spécifiant après chaque couple (abscisse,
ordonnée) une chaîne de caractères pouvant contenir les codes suivants (obtenus par help plot) :
Couleurs Styles de point Style de lignes
b blue g green . point o circle - solid
r red c cyan x x-mark + plus : dotted
m magenta y yellow s square * star -. dashdot
k black d diamond p pentagram -- dashed
h hexagram <,>,v triangle (none) no line
Lorsque l'on utilise seulement un style de points, MATLAB ne trace plus de droites entre les points
successifs, mais seulement les points eux même. Ceci peut être pratique par exemple pour présenter
des résultats expérimentaux. Les codes peuvent être combinés entre eux. Par exemple >>
plot(x,sin(x),':',x,cos(x),'r-.')
Décoration des graphiques
Titre : C'est l'instruction title à laquelle il faut
fournir une chaîne de caractéres2. Le titre
apparaît en haut de la fenêtre graphique :
>> plot(x,cos(x),x,sin(x)),
>>title('Fonctions sin et cos')

Labels : Il s'agit d'afficher le nom des axes des


abscisses et des ordonnées :
>> plot(x,cos(x)),
>>xlabel('Abscisse'), ylabel('Ordonnée')

Légendes :
C'est l'instruction legend. Il faut lui communiquer
autant de chaînes de caractères que de courbes

9
A.TIMESLI MATLAB

tracées à l'écran. Un cadre est alors tracé au


milieu du graphique, qui affiche en face du style
de chaque courbe, le texte correspondant.
Par exemple :
>> plot(x,cos(x),':',x,sin(x),'-.',x,sqrt(x),'--') ,
legend(‘cosinus’,’sinus’,’racine’)

Tracer un quadrillage : C'est l'instruction grid, qui utilisé après une instruction plot affiche un
quadrillage sur la courbe.
Afficher plusieurs graphiques (subplot)
Il s‟agit de découper la fenêtre graphique en
pavés de même taille, et d'afficher un graphe
dans chaque pavé. On utilise l'instruction
subplot en lui spécifiant le nombre de pavés
sur la hauteur, le nombre de pavés sur la
largeur, et le numéro du pavé dans lequel on
va tracer :
subplot (Nbre pavés sur hauteur, Nbre pavés
sur largeur, Numéro pavé)
Les pavés sont numérotés dans le sens de la
lecture d'un texte de gauche à droite et de haut
en bas. Une fois que l'on a tapé une commande
subplot,
toutes les commandes graphiques suivantes
seront exécutées dans le pavé spécifié.
Exemple :
>> subplot(2,2,1), plot(x,sin(x))
>> subplot(2,2,2),plot(x,cos(x),x,sin(x),'-.')
>> subplot(2,2,3),plot(cos(x),sin(x))
>> subplot(2,2,4),plot(sin(2*x),sin(3*x))
Axes et zoom
Il y a deux manières de modifier les valeurs extrêmes sur les axes, autrement dit de faire du
zooming sur les courbes. La plus simple est de la fenêtre graphique. Vous pouvez alors :
 encadrer une zone à zoomer avec le bouton de gauche de la souris
 cliquer sur un point avec le bouton de gauche. Le point cliqué sera le centre du zoom, ce dernier
étant effectué avec un facteur arbitraire
 cliquer sur un point avec le bouton de droite pour dézoomer
Pour faire des zooms plus précis, utiliser la commande axis.
Instructions graphiques diverses
Par défaut une instruction plot efface systématiquement le graphique précédent. Il est parfois utile
de le conserver et de venir le surcharger avec la nouvelle courbe. Pour cela on utilise la commande
hold. Pour démarrer le mode surcharge, taper hold on, pour revenir en mode normal, hold off.
Pour effacer la fenêtre graphique, tapez simplement clf. Cette commande annule également toutes
les commandes subplot et hold passées.
Saisie d'un point à la souris : la commande ginput(N) permet de cliquer N points dans la fenêtre
graphique, et la commande renvoie deux vecteurs, l'un contenant les abscisses, l'autre les ordonnées.
Utilisée sans le paramètre N, la commande tourne en boucle jusqu„à ce que la touche <Entrée> soit
tapée.

3.1. Graphique à trois dimensions

10
A.TIMESLI MATLAB

3.1.1. Courbes à trois dimensions


Une courbe en 3D est définie par une liste de
triplets (x; y; z). L'instruction correspondant plot3
attend donc trois arguments. Voici un exemple de
courbe 3d : >> plot3(exp(-t/10).*sin(t), exp(-
t/10).*cos(t), exp(-t)), grid
3.1.2. Surfaces
Génération des points (meshgrid)
Pour définir une surface, il faut un ensemble de triplets (x; y; z). Le nombre de points nécessaires
pour tracer la surface est le produit de deux entiers m x n. Cela signifie que l'on a m x n valeurs de
x, m x n valeurs de y et m x n valeurs de z. Il apparaît donc qu‟abscisses, ordonnées et cotes des
points de la surface peuvent être stockés dans des tableaux de taille m x n.
Toutes les instructions du tracé de la surface, par exemple surf auront donc la syntaxe suivante :
>>surf(tableau d’abscisses, tableau d’ordonnées, tableau de cotes)
Il reste maintenant à construire ces tableaux. Prenons tout d'abord le cas de la surface définie par z =
x2 + y2 dont on veut tracer la surface représentative sur [-1,1] x [-2,2]. Pour définir un quadrillage
de ce rectangle, il faut définir une suite de valeurs x1,…,xm pour x et une suite de valeurs y1,…,yn
pour y. En combinant toutes ces valeurs de x et y, on obtient m x n points dans le plan (x; y). Il faut
maintenant construire deux tableaux, l'un contenant les n x m abscisses de ces points l'autre les n x
m ordonnées, soit :
x1 x2 . . . xm   y1 y1 . . . y1 
x y . . . y 2 
 1 x2 . . . x m   2 y2
. . . . . .   . . . . . . 
X  Y 
. . . . . .   . . . . . . 
. . . . . .   . . . . . . 
   
 x 1 x2 . . . x m   y n yn . . . y n 

La création de ces matrices est assurée par la fonction meshgrid :


>> [X,Y] = meshgrid(x,y);
Il reste maintenant à calculer les z
correspondants. On applique directement la
formule aux tableaux X et Y, sans oublier de
mettre un point devant les opérateurs *, / et ^
>> Z = X .^2 + Y.^2;
Ensuite on peut utiliser toutes les fonctions de
tracé de surface, par exemple mesh :
>> mesh(X,Y,Z)
Les instructions les plus courantes sont :
 mesh qui trace une série de lignes entre les points de
la surface en mode <lignes cachées>
 meshc qui est comme mesh mais ajoute les
courbes de niveau dans le plan (x; y)
 surf qui <peint> la surface avec une couleur
fonction de la cote
 surfl qui <peint> la surface comme si elle était
éclairée.
 surfc qui est comme mesh mais ajoute les
courbes de niveau dans le plan (x; y)
Notons enfin qu'il existe des fonctions de conversion entre les coordonnées cartésiennes,
cylindriques et sphériques, permettant de tracer facilement des courbes définies dans l'un de ces
systèmes de coordonnées. On regardera par exemple la documentation de cart2pol.
Contrôle de l'angle de vue

11
A.TIMESLI MATLAB

Il existe la commande view, mais le plus simple


est de fenêtre graphique. Cliquez avec le bouton
gauche de la souris pour faire tourner la figure.
ATTENTION : tout clic de la souris provoque un
réaffichage, et si votre surface contient beaucoup
de points, elle met beaucoup de temps se
réafficher.

3.1.2. Courbes de contour


C'est la fonction contour. Elle s'utilise comme les instructions précédentes, mais fournit un graphe
2D dans le plan (x; y).
Plusieurs paramètres optionnels peuvent être
spécifiés, notamment le nombre de courbes de
contours à afficher :
>> contour(X,Y,Z, 10)

>> [c,h] = contour(peaks,-4:2:4);


clabel(c,h),

4. Environnement de travail, scripts et fonctions

4.1. Répertoire de travail


Il est indispensable de travailler dans votre propre répertoire et non dans le répertoire de Matlab.
Ainsi dans votre répertoire, vous pouvez organiser vos fichiers dans des sous répertoires.
Pour que vos fonctions et scripts soient accessibles à partir de la ligne de commande Matlab il
faut s‟assurer que vos répertoires de travail soient déclarés. Ceci se fait à l'aide de la commande
editpath qui permet de rajouter aux chemins déjà existants le chemin des répertoires contenant vos
programmes. Sinon, il faut aussi se placer dans votre répertoire de travail.
En fait lorsqu'on travaille souvent sous matlab avec des fichiers de fonctions et des scripts organisés
dans une arborescence sur le disque de travail, il est possible et préférable de réaliser un fichier
startup.m qui sera exécuté immédiatement en lançant Matlab. Dans ce fichier on peut définir le path
(addpath), charger d'éventuelles variables, se placer dans le répertoire désiré

4.2. Sauvegarde et chargement de variables


Il peut être utile, lors d'une session de travail, de sauvegarder des variables dans des fichiers du
répertoire de travail. Cela peut être réalisé à l'aide de la fonction save dont la syntaxe est :
save nom_fichier nom_variables
exemple :
>> save test.mat A, x, y
Si le nom des variables est omis, tous l'espace de travail est sauvé; si l'extension du fichier est omise
elle sera automatiquement .mat, si de plus, le nom du fichier est omis, la sauvegarde se fera dans le
fichier matlab.mat.
Pour recharger des variables sauvées dans un fichier, il suffit de taper :
>> load nom-fichier

12
A.TIMESLI MATLAB

Il est parfois utile de sauvegarder les commandes tapées et les résultats obtenus lors d‟une séance de
travail dans un fichier. Pour cela on utilise la commande diary :
>> diary nomfichier
Pour désactiver, taper diary off.
Importer des tableaux
MATLAB est souvent utilisé comme logiciel d'exploitation de résultats. Exemple classique : on
a un programme FORTRAN qui calcule des séries de valeurs, et on souhaite tracer une série en
fonction de l'autre.
Le moyen le plus simple est que votre programme écrive un fichier texte organisé sous forme de
m colonnes, séparées par des blancs, contenant chacune n lignes :
x1 y1 z1 ...
x2 y2 z2 ...
...
xn yn zn ...
Cette structure est obligatoire pour que la méthode simple exposée ici fonctionne correctement. Ce
fichier doit porter une extension, qui peut être quelconque, mais différente de .m ou .mat.
Admettons qu'il s'appelle toto.txt, tapez dans MATLAB :
>> load data.txt
Ce faisant, vous créez un nouveau tableau MATLAB, qui porte le nom du fichier sans extension,
soit data. Vous pouvez maintenant extraire les colonnes de ce tableau, et les mettre dans des
vecteurs, par exemple :
>> x = data(:,1); y = data(:,2); z = data(:,3)
et vous n'avez plus qu'à tracer l'un de ces vecteurs en fonction d'un autre.

4.3. Fichiers SCRIPT et FUNCTION


Jusqu„à présent, l'utilisation que nous avons faite de MATLAB s'apparente beaucoup à celle d'une
calculatrice.
Pour des tâches répétitives, il s'avère beaucoup plus pratique et judicieux d„écrire de courts
programmes pour effectuer les calculs désirés.
Il existe deux types de fichiers qui peuvent être programmés avec MATLAB : les fichiers SCRIPT
et FUNCTION.
Dans les deux cas, il faut lancer l‟éditeur de fichier et sauvegarder le fichier avec l'extension .m.

4.3.1. Scripts
Il est parfois (souvent) souhaitable, pour ne pas avoir à taper plusieurs fois une même séquence
d'instructions, de la stocker dans un fichier. Ainsi on pourra réutiliser cette séquence dans une autre
session de travail. Un tel fichier est dénommé script.
Il suffit d'ouvrir un fichier avec le menu file, new, de taper la séquence de commande et de
sauver le fichier avec une extension " .m " (nom-fich.m). En tapant le nom du fichier sous Matlab, la
suite d'instructions s'exécute.
Les variables définies dans l'espace de travail sont accessibles pour le script. De même les
variables définies (ou modifiées) dans le script sont accessibles dans l'espace de travail.
On peut (doit) mettre des commentaires à l'aide du caractère pour-cent " % ". Toute commande
située après " % " n'est pas prise en compte par Matlab, jusqu'à la ligne suivante. De plus Matlab ne
voit pas les espaces blancs (lorsqu'il n'y a pas d'ambiguïté), ce qui permet de bien indenter ses
fichiers.
Par exemple, le fichier test.m qui reprend l'exemple précédent de la section 1.2.:
clear all
x = 2;
y = 3;
a=x+y
b=x*y
whos
A.TIMESLI MATLAB

produit la sortie suivante lorsque qu'appelle :


>> test
a=5
b=6
Name Size Bytes Class
a 1x1 8 double array
b 1x1 8 double array
x 1x1 8 double array
y 1x1 8 double array
Habituellement, on utilise les fichiers SCRIPT afin de :
{ Initialiser le système (fonction clear)
{ Déclarer les variables
{ Effectuer les opérations algébriques
{ Appeler les fonctions
{ Tracer les figures
Il est utile ici de noter que le langage MATLAB n'est pas un langage compilé (contrairement au
langage C++, par exemple). A chaque appel d'un SCRIPT (ou d'une FUNCTION), le logiciel lit et
exécute les programmes ligne par ligne.
Lorsque MATLAB détecte une erreur, le logiciel arrête et un message d'erreur ainsi que la ligne où
l'erreur est détectée s'affichent à l‟écran. Apprendre à lire les messages d'erreur est donc important
pour "déboguer" vos programmes rapidement et efficacement.

4.3.2 Fonctions
L'idée de base d'une fonction est d'effectuer des opérations sur une ou plusieurs entrées ou
arguments pour obtenir un résultat qui sera appelé sortie.

4.3.2.1 Fonctions définies dans un fichier


On a parfois besoin de fonctions qui ne sont pas fournies par Matlab. On peut alors créer de
telles fonctions dans un fichier séparé et les appeler de la même façon que les fonctions
préexistantes.
La première ligne (hormis les lignes de commentaires) d'une fonction doit impérativement avoir
la syntaxe suivante :
function [ var de sorties, ...] = nom_fonction( var d'entrée, ...)
Exemple de fonction :
function y = sinuscardinal(x)
z = sin(x); % Variable de stockage
y = z./x; % Résultat de la fonction % Il faudra se méfier de la division pour x=0
Cette fonction pourra être appelée par :
>> sincpi = sinuscardinal(pi);
Exemple de fonction à plusieurs variables de sortie :
function [mini, maxi] = minetmax(x)
mini = min(x); % Première variable de sortie
maxi = max(x); % Deuxième variable de sortie
Cette fonction pourra être appelée par :
>> [miny, maxy] = minetmax(y);
Il est important de noter que les variables internes ne sont pas disponibles à l'invite MATLAB.
Par exemple, la fonction suivante (avec une seule sortie, le résultat de l'addition) :
function a = ma_fonction(x,y)
a = x + y;
b = x * y;
produit la sortie suivante :
>> a = ma_fonction(2,3)
a=
A.TIMESLI MATLAB

5
>> whos
Name Size Bytes Class
a 1x1 8 double array
Le résultat de la multiplication n'est plus disponible. On peut cependant modifier les sorties de
la manière suivante :
function [a,b] = ma_fonction(x,y)
a = x + y;
b = x * y;
pour obtenir :
>> [a,b] = ma_fonction(4,2)
a=5
b=6
>> whos
Name Size Bytes Class
a 1x1 8 double array
b 1x1 8 double array
Habituellement, on utilise les fichiers FUNCTION afin de :
{ Programmer des opérations répétitives
{ Limiter le nombre de variables dans l'invite MATLAB
{ Diviser le programme (problème) de manière claire
Le nom de la fonction doit impérativement être le même que le nom du fichier dans lequel elle
est stockée (sinon Matlab ne prendra pas en compte ce nom mais uniquement celui du fichier).
Les nombres d'arguments en entrée et en sortie ne sont pas fixes et peuvent être récupérés par
nargin et nargout. Cela nous permet donc de faire des fonctions Matlab pouvant dépendre d'un
nombre variable de paramètres.
Les variables de l'espace de travail ne sont pas accessibles à la fonction sauf si elles sont entrées
comme variable d'entrée. De même les variables définies dans une fonction ne sont pas accessibles
dans l'espace de travail.

4.3.2.2 Fonctions inline


On peut aussi définir une fonction dans la fenêtre de commande, cette fonction est dite inline,
exemple :
>> sincos = inline('sin(x)-x*cos(x)')  Inline function: sincos(x) = sin(x)-x*cos(x)
On peut maintenant utiliser cette nouvelle fonction :
>> sincos(pi/12)  ans =0.0059
On aura remarqué que la commande inline reconnaît automatiquement que la variable est x. On peut
de même définir des fonctions de plusieurs variables :
>> prodscal=inline(„sqrt((a(1))^2+(a(2))^2+(a(3))^2)‟,‟a‟)

4.4. Help / Aide en ligne


Matlab est pourvu d'une fonction d'aide très utile : help. Ainsi si vous tapez help suivi du nom
d'un répertoire, Matlab affiche une explication brève sur toutes les fonctions et scripts de ce
répertoire. Enfin si vous tapez help suivi du nom d'un fichier (script ou fonction), apparaît une
explication détaillée sur l'utilisation de la fonction ou du script.
De plus vous pouvez créer une aide sur les fonctions et scripts que vous créez et sur vos
répertoires. Pour une fonction et un script, Matlab prendra comme help toutes les lignes de
commentaires placés en début de fichier. Pour un répertoire, il faut créer un fichier Contents.m dans
lequel on place (en commentaires) en première ligne l'aide général sur le répertoire, ensuite les
aides sur les différentes fonctions et scripts contenus dans le répertoire. Ces aides que vous créez
pour vos fonctions et scripts, peuvent évidement être intéressantes pour un utilisateur éventuel, mais
peuvent aussi vous être utiles, pour vous rappeler le but de telle fonction ou pour vous souvenir de
sa syntaxe. Exemple simple :
A.TIMESLI MATLAB

function [mini, maxi] = minetmax(x)


% [mini, maxi] = minetmax(x)
% Cette fonction renvoie les éléments minimum et maximum d'un % vecteur
% Réalisée le 21 octobre 2006 : M. Afifi

5. Structures de contrôle
On va parler ici de tests et de boucles. Commençons par les opérateurs de comparaison et les
opérateurs logiques

5.1. Opérateurs de comparaison et logiques


Notons tout d'abord le point important suivant MATLAB représente la constante logique FAUX par
0 et la constante VRAI par 1. Ceci est particulièrement utile par exemple pour définir des fonctions
par morceaux.
Le tableau suivant comporte l'essentiel de ce qu'il faut savoir sur les opérateurs logiques:
Opérateur Syntaxe Opérateur Syntaxe
égal à == inférieur ou égal à <=
différent de ~= Négation ~
supérieur à > Ou |
supérieur ou égal à >= Et &
inférieur à <
Il existe d‟autres opérateurs logiques tels que : exist, isnan, isreal, ischar , islogical …
On peut se demander ce qui se passe quand on applique un opérateur de comparaison entre deux
tableaux, ou entre un tableau et un scalaire. L'opérateur est appliqué terme à terme. Ainsi :
>> A=[1 4 ; 3 2]  A =1 4
32
>> A> 2  ans = 0 1
10
Les termes de A supérieur à 2 donnent 1 (vrai), les autres 0 (faux). C‟est très utile pour construire
des fonctions par morceaux. Imaginons que l'on veuille définir la fonction suivante :
f(x) = sin x si x > 0
sin 2x sinon
>> f = inline('sin(x).*(x>0) + sin(2*x).*(~(x>0))')
On ajoute les deux expressions sin x et sin 2x en les pondérant par la condition logique définissant
leurs domaines de validité.

5.2. La commande find


La commande find est utile pour extraire simplement des éléments d'un tableau selon un critère
logique donné.
k = find (tableau logique) renvoie dans la variable k la liste des indices du tableau dont les éléments
sont non nuls. Cela permet de trouver tous les indices d'un tableau respectant un critère logique
donné exemple:
>> x = [ -1.2 0 3.1 6.2 -3.3 -2.1]  x = -1.2000 0 3.1000 6.2000 -3.3000 -2.1000
>> inds = find (x < 0)  inds = 1 5 6
On peut ensuite facilement extraire le sous tableau ne contenant que les éléments négatifs de x en
écrivant simplement :
>> y = x(inds)  y = -1.2000 -3.3000 -2.1000
Retenez bien cet exemple. Ce type de séquence s'avère très utile dans la pratique.

5.3. Instructions conditionnelles if


La syntaxe est la suivante :
if condition logique
instructions
elseif condition logique
A.TIMESLI MATLAB

instructions
...
else
instructions
end
Notons qu'il est souvent possible d'éviter les blocs de ce type en exploitant directement les
opérateurs de comparaison sur les tableaux ainsi que find.
Il existe aussi une structure des conditions multiples : switch…case dont la syntaxe est :
switch variable
case expression1
instructions 1
case expression2
instructions 2
..........
Otherwise
instructions (erreur)
end

5.4. Boucles for et while


Boucles for
for variable = valeur début: pas: valeur fin
instructions
end
L'originalité, par rapport à d‟autres langages, réside dans le fait que la variable de boucle peut être
réelle. Exemple : créer le vecteur [1 2 22 24 .... 210]
>> x=[ ]; for n=0:10 x =[x, 2^n] ; end
ou directement
>> for n=0:10; x(n +1) =2^n; end
On peut éviter la boucle en utilisant la notion de vecteur
>> n = 0:10;x=2.^n
Cette méthode est dite vectorisation du problème.
Boucles while
while condition logique
instructions
end
Le fonctionnement est classique.
Exemple: calculer le plus petit entier n tel que 2n soit supérieur à un réel a donné.
>> max =1998; n=1;
>> while (2^n <max);n=n+1;end; n  n = 11
Par vecorisation :
>>n=1:20; max(find(2.^n)<1998) +1

6. Les polynômes
Matlab est un outil très puissant également pour faire des opérations sur des fonctions
polynomiales. Par défaut, Matlab utilise un vecteur pour représenter un polynôme. Ainsi le vecteur
suivant
>> p = [2 4 8];%représente le polynôme suivant: p = 2x2 + 4x + 8
Comment différencier alors un vecteur normal d'un polynôme ? En fait c'est simplement par le
genre d'opérations qu'on effectuer sur la variable p. Ainsi si on fait l'opération suivante:
4 8 16
>> p'*p  ans = 8 16 32
16 32 64
A.TIMESLI MATLAB

Matlab interprète p, comme un vecteur et effectue le produit de la transposée de p fois le vecteur p.


Si par contre on utilise la fonction suivante:
>> y =polyint(p)  y = 0.6667 2.0000 8.0000 0
on effectue l'intégrale du polynôme p, car la fonction polyfun interprète p comme un polynôme. La
fonction roots est très utilie également pour trouver les racines d'un polynôme :
>> roots(p)  ans = -1.0000 + 1.7321i
-1.0000 - 1.7321i
Pour plus de détails sur les fonctions appliquées aux polynômes tapez :
>> help polyfun
roots - Find polynomial roots. polyfit - Fit polynomial to data.
poly - Convert roots to polynomial. polyder - Differentiate polynomial.
polyval - Evaluate polynomial. polyint - Integrate polynomial analytically.
polyvalm - Evaluate polynomial with matrix argument. conv - Multiply polynomials.
residue - Partial-fraction expansion (residues). deconv - Divide polynomials.

7. Calcul numérique avec MATLAB


L'objectif de ce chapitre est de présenter brièvement des routines de calcul numérique fournies dans
la version de base de MATLAB.

7.1. Recherche des zéros d'une fonction


Problème : On cherche x0 tel que f(x0) = 0.
La fonction fzero permet de résoudre ce problème. Il faut fournir d'une part la fonction f elle même,
et d'autre part une estimation de x0. L'efficacité de l'algorithme est comme toujours dépendante de
la valeur estimée choisie. La fonction f peut être définie par une directive inline ou bien écrite dans
un fichier.
Par exemple on cherche le zero de f(x) = cos
x – x. Une approche graphique permet
souvent de trouver une estimation de x0. La
figure suivante montre ainsi que les fonctions
x  x et x  cos x se coupent en un point sur
[-,]. Une valeur raisonnable pour
l'estimation de x0 est par exemple 0.
On peut donc écrire, en utilisant inline :
>> f = inline('x-cos(x)')
>> fzero(f,0) % Zero found in the interval: [-0.9051, 0.9051].  ans = 0.7391
On remarquera que la variable f envoyée à la fonction fzero est elle même une fonction. On peut
également écrire la fonction dans un fichier f.m :
function y = f(x)
y = x-cos(x);
et ensuite on écrira :
>> fzero('f',0)
Un dernier point important : comment faire lorsque la définition de la fonction dépend en plus d'un
paramètre ? Par exemple, on veut chercher le zéro de la fonction f(x) = cos(mx) – x où m est un
paramètre susceptible de varier entre deux exécutions. On ne peut pas rajouter un argument à la
définition de notre fonction f car fzero impose que f ne dépende que d'une variable. Une solution
serait d'affecter m dans le corps de la fonction mais elle est mauvaise car :
 lorsque l'on veut changer la valeur de m il faut modifier la fonction,
 cette fonction sera peut être appelée des dizaines voire des centaines de fois par fzero, et on
répétera à chaque fois la même instruction d'affectation de m.
La bonne solution est d'utiliser la directive globale. La fonction f s'écrira donc :
function y = f(x)
global m
y = x-cos(m*x);
et on cherchera son zéro en écrivant :
A.TIMESLI MATLAB

>> global m
>> m = 1;
>> fzero(‘f’,0)
Notons que l'on aura tout intérêt à mettre les trois lignes ci-dessus dans un fichier de commandes, et
à lancer ce fichier de commandes en bloc.
Si on a la toolbox optimisation, on peut déterminer plusieurs racines à l‟aide de fsolve au voisinage
des éléments d‟un vecteur que l‟on donne en argument d‟entrée. La syntaxe est : fsolve(„ fonc_nl ‟,
[x1 x2 … xn]). Exemple :
>> fun = inline('sin(3*x)');
>> x = fsolve(fun,[1 4 9])  x = 1.0472 4.1888 10.4720

7.2. Recherche de minima


Fonctions à une variable :
La valeur qui minimise localement une fonction dans l‟intervalle [xd, xf] s‟obtient par :
fminbnd(„ fonc ‟, xd, xf). Exemple :
>> f = inline('x.^3-2*x-5');
>> xmin = fminbnd(f, 0, 2)  xmin = 0.8175
Fonctions à plusieurs variables :
C‟est fminsearch qui permet de déterminer le vecteur minimisant localement une fonction autour
d‟un vecteur [x0 y0]. Exemple :
>> fs= inline('(a(1)-1)^2+(a(2)-1)^2','a')
>> a=fminsearch(fs,[0 0])  a = 1.00002111816406 1.00003894042969

7.3. Interpolation
Le problème : connaissant des points tabulés (xi; yi), construire une fonction polynomiale par
morceaux passant par ces points. En termes plus simples, c'est ce que fait la fonction plot quand elle
relie les points que vous lui donnez : elle fait passer un polynôme de degré 1 entre deux points
consécutifs. La fonction interp1 résout le problème. Il suffit de lui donner les valeurs tabulées ainsi
qu'une série d'abscisses où l'on souhaite connaître les ordonnées interpolées. Sur chaque intervalle
on peut interpoler par un polynôme de degré 1qui est le comportement par défaut (option 'linear') ou
de degré 3 (option 'cubic').
Les lignes suivantes fournissent un exemple générique : à partir de cinq points (xi; yi) et on cherche
une interpolation f(x) entre ces cinq points.
>> xi = [1 1/2 0 1/2 1];
>> yi = [1.5 1 0 1 1/2];
>> x = 1:0.1:1;
>> ylinear = interp1 (xi, yi, x);
>> ycubic = interp1 (xi, yi, x, 'cubic');
>> plot(xi,yi,'*', x,ylinear,'-', x,ycubic,'--')
La figure suivante illustre les interpolations linéaires (en traits pleins) et cubiques (en traits
pointillés) obtenues par interp1 sur ces 5 points (illustrés par des cercles).
A.TIMESLI MATLAB

7.4. Approximation (estimation de paramètres ou <fitting>)


Problème : faire passer une courbe d'équation connue au milieu d'un nuage de points de telle
sorte que la courbe soit la plus proche possible de l'ensemble des points. Comme on cherche à
minimiser une distance entre deux fonctions, on parle en général d'approximation aux moindres
carrés ou encore de régression.

7.4.1 Linéaire
Supposons que l'on dispose de n données expérimentales (xi; yi) et que l'on cherche à déduire
une loi y = f(x) dépendant linéairement de m coefficients :

Idéalement, les (xi; yi) vérifieraient cette relation, auquel cas on aurait le système de n équations
linéaires à m inconnues (a1; ... am) :

soit sous forme matricielle Y = F A auquel cas on trouverait simplement les coefficients ai par
inversion :
A = F-1 Y
En MATLAB, ce genre d'instruction peut se programmer simplement à l'aide de l'opérateur \ , et on
écrirait alors A = F \Y;
Cela dit le nombre d'équations n'est pas égal au nombre d'inconnues dans le système linéaire ci-
dessus, il est (normalement) supérieur, et le système est surcontraint. Ça ne fait rien, l'opérateur \ le
résout alors au mieux c'est-à-dire qu'il trouve les ai qui minimise la somme des carrés des résidus :

Voici un exemple : on cherche à fitter des points expérimentaux (xi; yi) par une fonction de la
forme :

La séquence d'instructions est la suivante :


>> xi = [1/4 1/2 1 2 3]; xi = xi';
>> yi = [18 7 4 2 1.1]; yi = yi'; % en colonnes
>> F = [ones(size(xi)) 1./xi 1./(xi.^2)];
>> A = F \ yi
>> x = 1/4:1/16:3; >> plot(xi,yi,'o', x, A(1) + …
A(2)./x + A(3)./(x.^2))
Ce programme trace la courbe fittée ainsi que les
points expérimentaux :
Cette méthode marche dés que la fonction cherchée dépend linéairement des coefficients inconnus.
Ça marche en particulier pour faire de l'approximation polynomiale (les fj sont des monômes xj),
mais dans ce cas on peut utiliser directement la fonction polyfit, qui en plus des coefficients du
polynôme renvoie des informations sur la qualité de l'approximation réalisée. Polyfit attend en
entrée simplement les xi, les yi et l'ordre du polynôme recherché. La fonction polyval peut être
utilisée pour recalculer le polynôme d'approximation en tout point.
L'exemple suivant calcule deux polynômes d'approximation, un d'ordre 3, l'autre d'ordre 4 et trace
le résultat.
>> xi = [-2 -1.5 -1 0 1 1.5 2]; >> yi = [3.5 2 1.5 0 1.3 2.5 3.9];
A.TIMESLI MATLAB

>> A4 = polyfit (xi, yi, 4)


>> A3 = polyfit (xi, yi, 3)
>> x = -2:0.1:2;
>> plot(xi, yi, 'o', x, polyval(A4,x), x,
polyval(A3,x), '--' )

7.4.2. Non linéaire


On cherche maintenant à fitter des points expérimentaux (xi; yi) par une fonction y = f(x) dépendant
non linéairement de m coefficients : y = f(a1; a2; ... am; x). Il s'agit ensuite de minimiser la distance
entre cette fonction et les points expérimentaux,

avec

La fonction F dépend non linéairement des paramètres a1; a2; ... am et un algorithme
d'optimisation doit être utilisé. MATLAB possède des routines d'optimisation utiles pour ce genre
de problème notamment si on dispose de la toolbox « Optimisation ».
Si on n‟a pas cette toolbox, il faut utiliser la routine de minimisation fournie dans la version
MATLAB de base qui s'appelle fminsearch. Pour cela il faut simplement programmer la fonction F
à minimiser et d'écrire la fonction de fitting f dans une sous fonction séparée. Voici comment
procéder dans l'exemple suivant : des analyses spectrométriques fournissent des pics que l'on
cherche à fitter (par exemple) par des gaussiennes. Par exemple dans le cas de deux pics :

Il y a 6 paramètres B1, B2, x1, x2, 1 et 2 que nous regroupons dans un tableau a avec a(1) = B1,
a(2) = B2, a(3) = 1, a(4) = 2, a(5) = x1, a(6) = x2.
Ecrivons tout d'abord la fonction de fitting :
Function y = f (a, x)
y = a(1)*exp(- ( (x-a(5))/a(3) ).^2) + a(2)*exp(- ( (x-a(6))/a(4) ).^2)
Il est important que cette fonction puisse accepter un tableau en entrée, d'où l'usage des points
devant les opérateurs puissance. Ensuite on écrit la fonction F représentant le résidu à optimiser :
function out = F (a)
global xi yi
out = sum ( (yi - f(a,xi)).^2 );
L'usage de global pour passer les points expérimentaux xi yi est nécessaire car l'entête de la
fonction F à optimiser est imposée par fminsearch. Il reste à appeler l'optimiseur dans un
programme principal :
% Pour passer les points expérimentaux à F
global xi yi
% Définition des points expérimentaux (en général chargés depuis un fichier)
xi=[20 40 60 80 100 120 140 145 155 156 176 196 216 236 256 276 296 ...
316 336 346 356 360 380 400 420 440]
yi=[0.0025 0.0162 0.0846 0.3073 0.7528 1.4288 1.9315 1.9962 2.1083 2.0104 ...
1.6617 0.8970 0.4343 0.3466 0.5393 1.0182 1.7069 2.4561 2.9957 3.1671 3.0137 ...
2.9506 2.6111 1.9578 1.2067 0.5896]
% Estimation de la solution. Le succès de l'opération dépend de cette
A.TIMESLI MATLAB

a0=[2,3,50,70,150,350]; % correspond à B1, B2 ,sigma1, sigma2, x1, x2


% Appel de l'optimiseur.
asol = fminsearch ( 'F', a0);
% Superposition points expérimentaux et fittés.
plot (xi, yi, '*', xi, f(asol, xi))

L'algorithme utilisé par fminsearch est parfois insuffisant. La toolbox optimisation fourni un grand
nombre de routines d'optimisation. Pour le problème d'estimation de paramètres proposé ci-dessus,
la routine dédiée est lsqcurvefit (least squares curve fit>). Elle permet de ne programmer que la
fonction f et forme elle-même la somme des carrés. Voici ce qu'il faut écrire pour résoudre le
problème précédent :
function y = f (a, x)
y = a(1)*exp(- ( (x-a(5))/a(3) ).^2) + a(2)*exp(- ( (x-a(6))/a(4) ).^2)
C'est en fait la même que précédemment. Maintenant on peut appeler directement lsqcurvefit :
% Definition des points expérimentaux
xi = ...
yi = ...
% Estimation de la solution.
a0=[2,3,50,70,150,350]; % correspond à B1, B2 ,sigma1, sigma2, x1, x2
% Appel de l'optimiseur. On remarque que la fonction à passer est maintenant f et % plus F et
qu'on passe les points expérimentaux directement au solveur.
asol = lsqcurvefit ( 'f', a0, xi, yi);
% Superposition points expérimentaux et fittés.
plot (xi, yi, '*', xi, f(asol, xi))

7.5 Equations différentielles


Problème : on cherche à résoudre un système d'équations différentielles ordinaires (EDO, en anglais
ODE) du premier ordre :

avec les conditions initiales y1(0) = y10 … yn(0) = yn0


Rappelons au lecteur non averti que tout système ou équation différentielle d'ordre supérieur peut se
ramener simplement à cette forme canonique, utilisée dans tous les solveurs d'EDO. On voit donc
que la définition d'un tel système repose sur la définition de n fonctions de n+1 variables. Ces
fonctions devront être programmées dans une fonction MATLAB sous la forme canonique suivante :
function ypoint = f (y, t)
ypoint(1) = une expression de y(1), y(2) ... y(n) et t
...
ypoint(n) = une expression de y(1), y(2) ... y(n) et t
ypoint = ypoint';
On remarquera que les yi et les y i sont regroupés dans des vecteurs, ce qui fait que la forme de
cette fonction est exploitable quel que soit le nombre d'équations du système différentiel. La
dernière ligne est nécessaire car la fonction doit ressortir un vecteur colonne et non un vecteur ligne.
Ensuite, pour résoudre cette équation différentielle, il faut appeler un solveur et lui transmettre
au minimum :
 le nom de la fonction.
 les bornes d'intégration (tmin et tmax).
A.TIMESLI MATLAB

 les conditions initiales.


Le solveur fournit en sortie un vecteur colonne représentant les instants d'intégration t, et une
matrice dont la première colonne représente les y1 calculés à ces instants, la deuxième les y2, et la
nième les yn.
L'appel du solveur prend donc en général la forme suivante :
[t, y] = ode45 ('f', [tmin tmax], [y10 y20 ... yn0] );
y1 = y(:,1);
y2 = y(:,2);
...
yn = y(:,n);
plot(t, y1, t, y2) % par exemple on trace y1(t) et y2(t)
plot(y1,y2) % ou bien y2(y1) (plan de phase pour les oscillateurs)
Les lignes y1 = ... servent à extraire les différentes fonctions yi dans des colonnes simples. Nous
avons utilisé ici ode45 qui est un Runge-Kutta-Merson imbriqué d'ordre 4 et 5. C'est le plus courant
et celui par lequel il faut commencer, mais il en existe d'autres.
Exemple : On considère l'équation de Matthieu amortie :

où a, b et  sont des paramètres. On prend comme conditions initiales y(0) = 10-3 et y  (0) = 0. En
posant y1 = y et y2 = y  on se ramène à la forme canonique :
y 1 = y2
y 2 = -by2 - a(1 + cos t)y1
Ecrivons la fonction matthieu définissant cette équation dans un fichier matthieu.m. Comme pour le
problème de recherche de zéro, on passera généralement les paramètres de l'équation dans une
directive global :
function ypoint = matthieu (y, t)
global a b epsilon
ypoint(1) = y(2);
ypoint(2) = -b*y(1) -a*(1+epsilon*cos(t))*y(2);
ypoint = ypoint';
La séquence d'instructions (à mettre dans un autre fichier .m) qui appelle le solveur sera par
exemple :
global a b epsilon
% Parametres
a = 1;
b = 0.1;
epsilon = 1;
tfinal = 10*pi; % Temps final
y01 = 1e-3; % Conditions initiales
y02 = 0;
[t,y] = ode45('matthieu', [0 tfinal], [y01 y02]);
y1 = y(:,1); % Extraction de y1 et y2
y2 = y(:,2);
subplot(221)
plot(t,y1) % y1 fonction du temps %
subplot(222),plot(t,y2) (représente dy(t)/dt))
subplot(212)
plot(y1,y2) % Plan de phase
A.TIMESLI MATLAB

 (t) de l'équation
Ce programme trace la figure suivante qui représente les grandeurs y(t) et y
originale en fonction du temps, plus le plan de phase.

8. Représentation symbolique
Il est possible de travailler avec une représentation symbolique des polynômes ainsi que d'autres
sortes de fonctions si on possède le toolbox symbolique. Voici une brève introduction des
possibilités de manipulation symbolique de matlab

8.1 Création d’un objet symbolique


La commande sym nous permet de créer des variables et des expressions symboliques. Par exemple
>> x=sym(„x‟)
crée la variable symbolique x qui représente x. La commande f = sym('a*x+b') affecte l‟expression
symbolique ax+b à la variable f. Mais pour effectuer des opérations mathématiques sur f, on a
besoin de créer explicitement les trois variables :
>> a=sym(„a‟)
>> b=sym(„b‟)
>> x=sym(„x‟)
ou simplement :
>> syms a b x
La commande sym permet de spécifier les propriétés mathématiques des variables symboliques en
utilisant une option comme 'real' :
>> x = sym('x','real'); y = sym('y','real');
ou simplement
>> syms x y real
x et y sont ainsi variables symboliques réelles et donc f = x^2 + y^2 est positive ou nulle et
z=x+i*y est forcement une variable complexe ou abs(z) donne x^2+y^2 et conj(z) est x-i*y.
Pour enlever la propriété “real”, on écrit la commande suivante :
>> x = sym('x','unreal')
ou >> syms x unreal
La commande clear x ne rend pas la variable irréelle si on la crée à nouveau. Nous pouvons aussi
avoir comme option „positive‟ qui permet d‟obtenir des variables symboliques réelles positives.
On peut convertir une variable symbolique en chaîne de caractères à l‟aide de la fonction char.
C‟est en faite l‟opération inverse de sym qui convertit une chaîne en variable symbolique
Exemple: Création d’une Matrice Symbolique
Pour créer une matrice Symbolique, il faut créer les variables symboliques contenues dans ses
éléments. Ainsi si nous voulons créer une matrice 3x3 dont lignes s‟obtiennent par permutation
circulaire, nous procédonts comme suit :
>> syms a b c
>> A = [a b c; b c a; c a b]  A = [ a, b, c ]
[ b, c, a ]
[ c, a, b ]
Nous pouvons traiter A comme dans le cas d‟une variable numérique, nous avons :
>> sum(A(1,:)) ans =a+b+c
>> sum(A(1,:)) = = sum(A(:,2)) % This is a logical test.  ans = 1
>> syms alpha beta;
>> A(2,3) = beta;
>> A = subs(A,b,alpha)  A = [ a, alpha, c]
[ alpha, c, beta]
[ c, a, alpha]
A.TIMESLI MATLAB

8.2. Symbolique et conversion numérique


La commande sym permet aussi de faire des représentations symboliques des valeurs numériques.
Exemple :
>> rho=(1+sqrt(5))/2  rho = 1.6180
>> sym(rho,'r')  ans = 7286977268806824*2^(-52) %Format rational (par défaut)
>> sym(0.25,'r')  ans = 1/4
>> sym(rho,'d')  ans = 1.618033988749894902525739 % Format décimal
On peut contrôler le nombre de chiffres après la virgule à l‟aide de la fonction digits
>> digits(12)
>> sym(rho,'d')  ans =1.61803398875
L‟utilisation de sym peut s‟étendre à une matrice :
>> A=hilb(3)  A = 1.0000 0.5000 0.3333
0.5000 0.3333 0.2500
0.3333 0.2500 0.2000
>> A=sym(A)  A = [ 1, 1/2, 1/3]
[ 1/2, 1/3, 1/4]
[ 1/3, 1/4, 1/5]

8.3 Création des fonctions symboliques


Il y a deux manière pour créer les fonctions symbolique :
•Utilisation expressions symboliques
•Creation de M-file
Utilisation des expressions symboliques
La séquence des commandes,
>> syms x y z
>> r = sqrt(x^2 + y^2 + z^2)
>> t = atan(y/x)
>> f = sin(x*y)/(x*y)
génèrent des expressions symboliques r, t, et f.
Remarque : r, t, et f étant issues d‟une opération symbolique est automatiquement une variable
symbolique sans qu‟on ait eu à la définir avec la commande sym, (ou syms).
Nous pouvons récrire les expressions symboliques en utilisant les commandes suivantes :
simplify(expression) - Simplifier l‟expression.
simple(expression) - Recherche d‟une forme plus compacte.
pretty(expression) - met une expression symbolique plus lisible
Exemple
>> syms x,f= (sin(x))^2+(cos(x))^2 ;
>> simplify(f)  ans =1
>> f = x^3-6*x^2+11*x-6
>> pretty(f)  3 2
x - 6 x + 11 x - 6
Si on veut appliquer la fonction à une valeur numérique on utilise :
subs(expression,symbole,valeur numérique)
Exemple :
>> syms x,f= x^2+x-1 ;
>> subs(f,x,0)ans=-1
Creation de M-File
Les M-files permet aussi de définir des fonctions symboliques. Si on veut, par exemple, créer la
fonction sinc = sin(x)/x, On crée le M-file ci-dessous dans le répertoire
c:\matlab61\toolbox\symbolic\ @sym
A.TIMESLI MATLAB

function z = sinc(x)
%SINC The symbolic sinc function
% sin(x)/x. This function
% accepts a sym as the input argument.
if isequal(x,sym(0))
z = 1;
else
z = sin(x)/x;
end

8.4. Fonctions d’analyse


La Toolboxe Symbolic contient des fonctions qui permet d‟effectuer des opérations de base comme
le dérivation, limite, intégration, sommation et développement en séries de Taylor.
Dérivation
La fonction correspondant à la dérivation est diff. Exemple :
>> syms a x
>> f = sin(a*x)
>> diff(f) % dérivation par rapport à x  ans =cos(a*x)*a
Pour dériver par rapport à a, on utilise un deuxième argument :
>> diff(f,a)  ans =cos(a*x)*x
Les dérivées seconde par rapport à x et a, respectivement, s‟écrivent :
>> diff(f,2)  ans = -sin(a*x)*a^2
>> diff(f,a,2)  ans = -sin(a*x)*x^2
En général, la syntaxe de la dérivation est diff(fonction,ordre,variable)
La fonction diff peut être appliquée à une matrice symbolique. Dans ce cas, la dérivation s‟applique
à chaque élément, exemple :
syms a x
>> A = [cos(a*x),sin(a*x);-sin(a*x),cos(a*x)]  A = [ cos(a*x), sin(a*x)]
[ -sin(a*x), cos(a*x)]
>> diff(A)  ans = [ -sin(a*x)*a, cos(a*x)*a]
[ -cos(a*x)*a, -sin(a*x)*a]
Integration
int(fonction,variable) - Intégrale indéfinie c'est-à-dire primitive.
int(fonction,variable,borne inf,borne sup) - Intégrale définie.
Exemple :
>> syms x f
>> f = cos(x) ;
>>int(f)  f= -- sin(x);
>> int(sin(2*x),0,pi/2) ans =1
Nous pouvons aussi integrer des fonctions paramétrées :
>> syms x k real
>> int(f,x,-inf,inf)  ans = signum(k)/k*pi^(1/2)
Limites
Syntaxes :
limit(f)  lim f ( x)
x0

limit(f,x,a) or limit(f,a)  lim f ( x)


xa
A.TIMESLI MATLAB

limit(f,x,a,'left')  lim f ( x)
x a

limit(f,x,a,'right')  lim f ( x)
x a
Exemples :
>> limit(1/x)  ans =NaN
>> limit(1/x,x,0,'left')  ans =-inf
>> limit(1/x,x,0,'right')  ans = inf
Sommation Symbolique
On peut calculer des sommations symboliques quand elles existent, en utilisant la commande
symsum. Par exemple, la somme des termes des series :
>> syms x k
>> s1 = symsum(1/k^2,1,inf)  s1 = 1/6*pi^2
>> s2 = symsum(x^k,k,0,inf)  s2 =-1/(x-1)
Dévelopement deTaylor
Syntaxe : taylor( fonction,ordre de développement)
taylor( fonction,ordre de développement,au voisinage de)
Exemple s:
>> syms x
>> f = 1/(5+4*cos(x));
>> T = taylor(f,8)  T =1/9+2/81*x^2+5/1458*x^4+49/131220*x^6
>> pretty
2 4 49 6
1/9 + 2/81 x~ + 5/1458 x~ + ------ x~
131220
>> syms x
>> g = exp(x*sin(x))
>> t = taylor(g,12,2); % développement d’ordre 12 au voisinage de 2
Représentons la fonction g et son développement dans un même graphique pour les comparer :

>> xd = 1:0.05:3; yd = subs(g,x,xd);


>> ezplot(t, [1,3]); hold on;
>> plot(xd, yd, 'r-.')
>> title('Taylor approximation vs. actual
function');
>> legend('Function','Taylor')

8.5. Résolution d’équations

8.5.1. Equations algébriques


Si S est une expression symbolique, solve(S) permet de résoudre l‟équation S=0 Par exemple,
>> syms a b c x
>> S = a*x^2 + b*x + c;
>> solve(S) % l’inconnu est x par défautans = [1/2/a*(-b+(b^2-4*a*c)^(1/2))]
[1/2/a*(-b-(b^2-4*a*c)^(1/2))]
>> b = solve(S,b) % l’inconnu est b  b = -(a*x^2+c)/x
Nous pouvons aussi écrire l‟équation sous forme d‟une chaîne de caractères
A.TIMESLI MATLAB

>> s = solve('cos(2*x)+sin(x)=1')  s= [ 0]
[ pi]
[ 1/6*pi]
[ 5/6*pi]
Système d’équations
>> syms x y alpha
>> [x,y] = solve(x^2*y^2-1, x-y/2-alpha)
x = [ 1/2*alpha+1/2*(alpha^2+2)^(1/2)] y = [ -alpha+(alpha^2+2)^(1/2)]
[ 1/2*alpha-1/2*(alpha^2+2)^(1/2)] [ -alpha-(alpha^2+2)^(1/2)]
[ 1/2*alpha+1/2*(alpha^2-2)^(1/2)] [ -alpha+(alpha^2-2)^(1/2)]
[ 1/2*alpha-1/2*(alpha^2-2)^(1/2)] [ -alpha-(alpha^2-2)^(1/2)]
Les commandes suivantes donnent le même résultat
>> eqs1 = 'x^2*y^2=1, x-y/2-alpha'
>> [x,y] = solve(eqs1)
Un autre exemple où nous écrivons la solution avec une seul sortie
>> syms u v x y
>> S = solve(x+2*y-u, 4*x+5*y-v);
>> sol = [S.x;S.y]  sol = [ -5/3*u+2/3*v]
[ 4/3*u-1/3*v]

8.5.2 Equation Differentielle


La résolution d‟une équation différentielle se fait à l‟aide de la commande dsolve. La variable
indépendante est par défaut t. La syntaxe est dsolve(équation,conditions limites,variable)
Exemple 1
>> dsolve('Dy=1+y^2')  ans = tan(t+C1)
Pour déterminer la constante, on doit préciser les conditions initiales :
>> y = dsolve('Dy=1+y^2','y(0)=1')  y = tan(t+1/4*pi)
Notons que seul y est dans le workspace. Pour utiliser la variable indépendante t, il faut la créer en
utilisant syms t.
Exemple 2 : il s‟agit d‟équations non linéaires ayant des solutions multiples :
>> x = dsolve('(Dx)^2+x^2=1','x(0)=0')  x = [-sin(t)]
[ sin(t)]
Exemple 3 : équation différentielle de second ordre
>> y = dsolve('D2y=cos(2*x)-y','y(0)=1','Dy(0)=0', 'x')
 y=(1/2*sin(x)+1/6*sin(3*x))*sin(x)+(1/6*cos(3*x)-1/2*cos(x))*cos(x)+4/3*cos(x)
>> simplify(y)  y = -2/3*cos(x)^2+1/3+4/3*cos(x)
Système d’équations différentielles
>> S = dsolve('Df = 3*f+4*g', 'Dg = -4*f+3*g');
>> f = S.f  f =exp(3*t)*(cos(4*t)*C1+sin(4*t)*C2)
>> g = S.g  g =exp(3*t)*(-sin(4*t)*C1+cos(4*t)*C2)
Avec les conditions initiales :
>> [f,g] = dsolve('Df=3*f+4*g, Dg =-4*f+3*g', 'f(0) = 0, g(0) = 1')
 f = exp(3*t)*sin(4*t)
g = exp(3*t)*cos(4*t)
Dans le tableau suivant, nous représentons quelques exemples
A.TIMESLI MATLAB