Beruflich Dokumente
Kultur Dokumente
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
2
A.TIMESLI MATLAB
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
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);
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).
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
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
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
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 :
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
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.
10
A.TIMESLI MATLAB
11
A.TIMESLI MATLAB
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.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
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.
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.
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
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
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
>> 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.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.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 :
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
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))
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
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
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 :
>> 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]