MASTERS TI 

, PNT ,MEC
Initiation à Matlab
M. AFIFI

1
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.  Actuellement, Matlab recouvre d'autres domaines d'applications de l'informatique
scientifique :
 visualisation graphique 2D et 3D
 optimisation
 traitement du signal
 traitement de l'image
 etc …
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.
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. 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).

2
>> 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.2. 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.
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.3. Vecteurs, matrices et leur manipulation

En fait, toute variable de Matlab est une matrice (scalaire : matrice 1x1, vecteur : matrice 1xN
ou Nx1). 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

3
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, rand 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

  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 fait 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

4
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

246

L'opérateur " : "

L'opérateur " : ", sous Matlab, peut être considéré comme l'opérateur d'énumération. 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

5
>> 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
1  3

nous donnera les premiers et troisièmes éléments des lignes 3, 2 et 1 de A.

1.4. 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

6
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

7
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

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.5. 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

8
>> 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

Le tableau suivant résume les différents opérateurs applicables aux matrices.

9
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))

10
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 plot ( vecteur d'abscisses, tableau d'ordonnées
dans un même tableau, chaque ligne du tableau
représentant un vecteur 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

11
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 >> plot(x,cos(x),':',x,sin(x),'-.',x,sqrt(x),'--') ,
autant de chaînes de caractères que de courbes legend(‘cosinus’,’sinus’,’racine’)
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 :

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))

12
>> 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

3.1.1. Courbes à trois dimensions

13
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
x1 x2 . . . xm y2 y2 . . . y2
X= . . . . . . Y= . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
x1 x2 . . . xm yn yn . . . yn

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

>> [X,Y] = meshgrid(x,y);
Il reste maintenant à calculer les z >> mesh(X,Y,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 :
Les instructions les plus courantes sont :  meshc qui est comme mesh mais ajoute les
 mesh qui trace une série de lignes entre les pointscourbes
de de niveau dans le plan (x; y)
la surface en mode <lignes cachées>

14
 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
Il existe la commande view, mais le plus simple de points, elle met beaucoup de temps se
est de fenêtre graphique. Cliquez avec le bouton réafficher.
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

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),

15
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
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 :

16
 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. 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.

4.4. Fonctions

4.4.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, ...)

17
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);
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.4.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.5. 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.

18
 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 :
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

19
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
instructions
...
else
instructions
end

20
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

21
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
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

22
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 On peut donc écrire, en utilisant inline :
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.
>> 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 :
>> 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.

23
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).

24
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 a i 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
a2 a3
forme : f ( x )=a1 + +
x x2
La séquence d'instructions est la suivante :

25
>> x = [1/4 1/2 1 2 3]; x = x';
>> y = [18 7 4 2 1.1]; y = y'; % en colonnes
>> F = [ones(sze(x)) 1./x 1./(x.^2)];
>> A = F \ y
>> xx = 1/4:1/16:3; >> plot(x,y,'o', xx, A(1) +
… A(2)./xx + A(3)./(xx.^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 f j 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.
>> x = [-2 -1.5 -1 0 1 1.5 2];
>> y = [3.5 2 1.5 0 1.3 2.5 3.9];
>> A4 = polyfit (x, y, 4)
>> A3 = polyfit (x, y, 3)
>> xx = -2:0.1:2;
>> plot(x, y, 'o', xx, polyval(A4,xx), xx,
polyval(A3,xx), '--' )

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 ».

26
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
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))

27
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';

28
On remarquera que les yi et les
ẏ 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).
 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 ẏ (0) = 0. En
posant y1 = y et y2 = ẏ on se ramène à la forme canonique :
ẏ 1 = y2
ẏ 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

29
ypoint(1) = y(2);
ypoint(2) = -b*y(2) -a*(1+epsilon*cos(t))*y(1);
ypoint = ypoint';
La séquence d'instructions (à mettre dans un autre fichier .m) qui appelle le solveur sera par
exemple :
global a b epsilon subplot(212)
% Parametres plot(y1,y2) % Plan de phase
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))

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

30