INTRODUCTION Introduction (2)

• MATrix LABoratory
• Logiciel qui permet, de manière
interactive :
– de faire des calculs matriciels ;
– d ’analyser les données ;
– de visualiser les résultats en 2D et 3D ...

• Langage de programmation
• Toolboxes : ensemble de fonctions
(fichiers .M) développées pour des
domaines d ’applications spécifiques
• SIMULINK : interface graphique
interactive de MATLAB

L ’espace de travail :
Fonctionnement
le Workspace (1)
• Mode interactif :
Données Espace de travail
Les instructions sont exécutées au
fur et à mesure qu ’elles sont
entrées par l ’utilisateur

• Mode programme :
MATLAB exécute, ligne par ligne,
les instructions d ’un fichier .M

• Type de variables :
unique : la matrice

Historique

•1
 L ’espace de travail (2) L ’espace de travail (3)
• Supprimer une (ou toutes les) variable(s) :
• Déclarer des variables : >> clear x
>> x =12.5 ; y = [1 -5 0 2] ; >> clear all
– définies et dimensionnées automatiquement
au fur et à mesure de leur déclaration • Entrer une valeur au clavier :
– stockées dans l ’espace de travail >> x = input(‘Valeur de x =’)
Valeur de x =12
• S ’informer sur les variables : x=
>> who 12
Your variables are:
x y • Afficher un texte à l ’écran :
>> whos >> disp(‘ Ceci est un test ’)
Name Size Bytes Class Ceci est un test
x 1x1 8 double array
y 1x4 32 double array >> disp([‘ x vaut ’, num2str(x)])
Grand total is 5 elements using 40 bytes x vaut 12

L ’espace de travail (4) L ’aide sous MATLAB

>> helpdesk

• Gérer les accès aux répertoires / fichiers

>> pathtool

>> help nom de commande fournit de

l ’aide sur l ’utilisation de la commande (et
• Editer les commandes : ou lettre + les rubriques connexes).

(ou double clic dans l’historique) >> lookfor mot-clé fournit la liste des
fonctions contenant le mot-clé.

•2
 Plan

1. Vecteurs et matrices

2. La programmation MATLAB

3. Les graphiques

4. Les polynômes et l ’analyse numérique

5. L’import/export de données

•3
 VECTEURS ET MATRICES Les scalaires (1)

• Scalaires et opérations scalaires • Le scalaire : une matrice 1x1

>> s =2.5 ;
>> size(s)
• Vecteurs et opérations vectorielles ans =
1 1
• Matrices et opérations matricielles ou
>> [i,j] = size(s)
• Tableaux multidimensionnels i=
1
j=
• Structures 1
• Les format d ’affichage
format short 0.0333
format long 0.033333333333
format short e 3.3333E-002
format long e 3.333333333334E-002
format rat 1/30
format bank 0.03

Les scalaires (2) Les scalaires (3)

• Les complexes : • Les opérations arithmétiques
>> x=1+j >> 3 +7 - 2 * 9
x=
1.0000 + 1.0000i ans =
-8
• Les constantes prédéfinies :
>> pi divisions droite (/) et gauche (\)
ans = élévation à une puissance (^)
3.1416
>> eps
• Quelques fonctions
ans = – fonctions trigo : cos acos cosh
2.2204e-016 – exponentielle : exp
>> 1/0 – log népérien : log
Warning : Divide by zero – log décimal : log10
Inf – racine : sqrt
>> 0/0 – |x|ou ||x||: abs
Warning : Divide by zero – Re & Im : real imag
NaN – arrondis : round ceil floor fix

•4
 Créer un vecteur (1) Créer un vecteur (2)

• Vecteur ligne • Le vecteur : une matrice 1xn

>> v1= [1 2 -5] ; >> size(v1)
ou ans =
>> v1(1) =1; v1(2) =2;v1(3)=-5; 1 3
ou
longueur d ’un vecteur
>> v1(1) = [1, 2 ,-5] ;
>> long_v1 = length(v1)
• Vecteur colonne long_v1 =
>> v2=[-7;3]; 3

• Transposition : • Concaténation
>> v4 =[v1 v3]
>> v3=v2 ’
v4 =
v3 =
1 2 -5 -7 3
-7 3
• Vecteur vide
>> v =[ ] ;

Créer un vecteur (3) Opérations vectorielles (1)

• Extraction
• Génération automatique >> v4(3)
composantes espacées d ’un pas constant ans =
-5
syntaxe : v =debut : pas : fin >> v4(2:4)
>> v5=1:0.5:3 ans =
v5= 2 -5 -7
1.000 1.500 2.000 2.500 3.000 • Extraction selon un critère
⇔ v =linspace(1, 3, 5) >> i =find(v4 <0)
i=
3 4
par défaut (pas = 1) v =debut : fin
>> v4(i)
ans =
espacement logarithmique de 10debut à 10fin -5 -7
syntaxe : v =logspace(debut, fin, N)
Sous MATLAB, le premier indice
! d ’un tableau est 1

•5
 Opérations vectorielles (2) Opérations vectorielles (3)
• opérations élémentaires
– somme de vecteurs de même dimensions >> v = [1 2 -5 -7 3]
>> s = [2 1 -1]+ [1 -3 5] – somme des éléments d ’un vecteur
s= >> sum(v)
3 -2 4 ans =
– ajout d ’un scalaire -6
>> s + 2
ans = – produit des éléments d ’un vecteur
5 0 6 >> prod(v)
– produit de vecteurs de même dimensions ans =
>> p = [2 1 -1] * [1 -3 5] ’ 210
p=
– moyenne : mean(v)
-6
– médiane : median(v)
– produit élément par élément
>> [2 1 -1] .* [1 -3 5] – écart-type : std(v)
ans = – minimum : min(v)
2 -3 -5 – maximum : max(v)

Créer une matrice (1) Créer une matrice (2)

• par concaténation
• Saisie d ’une matrice >> M2= [0 7 12];
– lignes séparées par un point virgule >> M3 = [M1 ; M2]
>> M1=[1 0 3;2 5 1] M3 =
M1 = 1 0 3
1 0 3 2 5 1
2 5 1 0 7 12

– lignes séparées par un retour chariot • par transformation

>> M1=[1 0 3 >> reshape(M3, 1,9)
2 5 1] ans =
M1 =
1 0 3 1 2 0 0 5 7 3 1 12
2 5 1

• Dimensions • par extraction : triu tril

>> size(M1)
Îmatrices triangulaires supérieures et infé-
ans = rieures
2 3

•6
 Les matrices spéciales (1) Les matrices spéciales (2)

• Matrices identité, nulle et unité • Matrices aléatoires

>> IDENTITE = eye( 2,3) – Distribution normale (m = 0 , σ = 1) :
IDENTITE = >> y = randn(10000,1) ;
1 0 0
0 1 0 – Distribution uniforme (m = 1/2 , σ = 1/12) :
>> y = rand(10000,1) ;
– ones (m,n) : matrice m x n dont tous les
éléments valent 1
800

– zeros(m,n) : matrice m x n dont tous les 600

éléments valent 0 400

200

Si m=n, spécifier une seule dimension 0

-4 -3 -2 -1 0 1 2 3 4

>> UNITE = ones( 2) 250

200

UNITE = 150

100

1 1 50

0
1 1 0 0.2 0.4 0.6 0.8 1

Opérations matricielles (1) Opérations matricielles (2)

• Extraction • Comparaison
>> M3 = [1 0 3 ; 2 5 1 ; 0 7 12] ;
– d ’un élément :
>> M4 = ones(3) ;
>> M3(3,2) >> M3(6)
ans = ans = >> M3 > M4 %find(M3 > 1)
7 7 ans =
0 0 1
– d ’une ligne : 1 1 0
>> M3(2, : ) 0 1 1
ans =
2 5 1 • Extension des instruction min, max ...
– d ’une colonne : >> max(M3) %maximum par colonnes
ans =
>> M3( : ,2)
2 7 12
ans =
0 >> max(M3(:)) %max(max(M3))
5 ans =
– d ’une sous-matrice : ?? 12

•7
 Opérations matricielles (3) Opérations matricielles (4)

• Produit classique • Transformations

Rappel : le produit de A(mxn) par B(pxq) >> M = [1 2 ; 3 4]
n ’est possible que si n = p et le résultat est >> fliplr(M) %retournement gauche/droite
de dimension mxq ans =
• Produit de Hadamard 2 1
4 3
ou produit élément par élément de deux
>> flipud(M) %retournement haut/bas
matrices de mêmes dimensions
ans =
>> A = [1 2 ; 3 4] 3 4
>> A * A >> A .* A 1 2
>> rot90(M) %transposition + flipud
ans = ans =
ans =
7 10 1 4 2 4
15 22 9 16 1 3

Opérations matricielles (5) Vecteurs et valeurs propres

• Fonctions diverses >> M = [2 1 ; 1 2] ;

– déterminant : • Polynôme caractéristique : |λI - M| = 0
>> det(M)
>> poly(M)
– norme
ans =
>> norm(M)
1 -4 3
– rang
>> rank(M)
• Vecteurs et valeurs propres
– inverse (et pseudo-inverse)
>> [vec val] = eig(M)
>> inv(M) >> pinv(M)
vec =
– conditionnement
>> cond(M) 0.7071 0.7071
– exponentielle - 0.7071 0.7071
expm : vecteurs et valeurs propres val =
expm1 : approximation de Padé 1 0
expm2 : série de Taylor 0 3

•8
 Les tableaux Les structures (1)
multidimensionnels Structure = regroupement de variables
• Extension à n dimensions : (champs) de type différents (chaînes,
– vecteur (1D) : 1 indice entiers ...) dans une même variable.
– matrice (2D) : 2 indices, ligne et colonne exemple : fichier des élèves d’un établissement
– tableau tridimensionnel : 3 indices, ligne, scolaire :
colonne et page Î nom
– ... Î notes
exemple : Î adresse ...
>> M1 =ones(3) ;
nom=struct(‘ch1’,{v1,v2...}, ’ch2 ’,{v1,v2
>> M2 =zeros(3) ; ...})
>> M3 =cat(3,M1,M2) ;
M3( : , : , 1) = >>eleve=struct(‘nom’,{‘paul’,’eve’,’jean’}, ’note1’,
1 1 1 {12,8,11}, ’note2’,{14,15,3})
1 1 1
1 1 1 eleve =
M3( : , : , 2) = 1x3 struct array with fields :
0 0 0 nom
0 0 0 note1
0 0 0
note2

Les structures (2) Les structures (3)

• Liste des champs Manipulation indirecte
>> fieldnames(eleve)
ans = Înécessite de créer des vecteurs de données
‘nom’ tampons
‘note1’
‘note2’ >> liste1 = cat(1,eleve.note1)

• Extraction : on utilise l ’opérateur ‘.‘ liste1 =

>> eleve(2).nom 12
ans = 5
eve 17
>> liste2 = cat(1,eleve.note2) ;
• Affectation directe
>> moy=mean(mean([ liste1 liste2 ])
>> eleve(4).nom = ‘toto’;
moy =
eleve =
1x4 struct array. with fields : 13.1250
.
.

•9
 LA PROGRAMMATION Opérateurs logiques
MATLAB • == égalité
• ~= différence
• Les opérateurs logiques • <( <=) inférieur (ou égal)
• Les chaînes de caractères • >( >=) supérieur (ou égal)
• & ET logique (AND)
• Les commandes structurées • ~ NON logique (NOT)
• | OU logique (OR)
• Les scripts et les fonctions • xor OU exclusif (XOR)
• La programmation Exemple :
>> a = [1 0 0 1] ;
>> b = [1 1 0 1] ;
>> a | b
ans =
1 1 0 1

Chaînes de caractères (1) Chaînes de caractères (2)

• Généralités
– chaîne = vecteur ligne • Ecriture de chaînes formatées
syntaxe :
– nombre de composantes = longueur de
text=sprintf(‘ format1 format2... ’, data1,
la chaîne data2 ...)
exemple :
• Affectation >> pi2 = pi^2
>> ch = ‘ bonjour monsieur ’ pi2 =
>> size(ch) 9.8696
>> text = sprintf(‘ le carré de pi vaut %3.2f ’,
ans = pi2)
1 16 text =
le carré de pi vaut 9.87
• Conversions
num2str : nombre chaîne • Exécution d’une chaîne :
mat2str : matrice chaîne exemple :
str2num : chaîne nombre >> name = ‘c:/bin/data’
>> eval([‘load’, name]); %load(name)

•10
 L ’instruction FOR (1) L ’instruction FOR (2)
• parcours d'un intervalle
syntaxe : • On peut utiliser un incrément (pas) autre
que 1 (valeur par défaut).
for variable =debut : fin
instructions syntaxe :
.......... for variable =debut:pas:fin
instructions
end • Les bornes ne sont pas nécessairement
exemple : créer le vecteur [1 2 22 24 .... 210] des entiers.
>> x=[ ]
x= • Le pas peut être négatif.
[]
>> for n=0:10 ; x =[x 2^n] ; end
• Il est possible d ’imbriquer les boucles
ou directement
>> for n=0:10; x(n +1) =2^n; end Penser à l ’indentation !!
! bouton droit Æ smart indent
programmation matricielle ??

La boucle WHILE Les ruptures de boucle

• Il est possible de provoquer une sortie
• tant que . . . faire prématurée d'une boucle de contrôle.
syntaxe :
break termine l ’exécution d ’une boucle.
while expression
instructions
for variable1 = debut1 : fin1
.......... instructions
instructions ..........
for variable2 = debut2 : fin2
end instructions
..........
exemple: calculer le plus petit entier n tel que break
2n soit supérieur à un réel a donné. instructions
>> max =2002 ; n=1; end
>> while (2^n <max);n=n+1;end; instructions
end
>> n
n= return provoque un retour au programme
11 appelant (ou au workspace).

•11
 L ’instruction IF (1) L ’instruction IF (2)
• La séquence d ’instructions intérieure • Permet de choisir entre deux options.
est exécutée si expression est vrai (=1 syntaxe
logique). if expression
syntaxe instructions 1
if expression else
instruction
........ instructions 2
instruction end
end • si expression n ’est pas vérifier alors
• expression peut être simple ou les instructions 2 sont exécutées
composée.
exemple
if (a<0 & b<0)
disp(‘ a et b négatifs ’)
end

L ’instruction IF (3) L ’instruction SWITCH

• Permet une sélection multiple. • Permet une sélection multiple.
syntaxe syntaxe
if expression1 switch variable
instructions 1 case valeur1
elseif expression2 instructions 1
instructions 2 case valeur2
elseif expression3 instructions 2
instructions 3 ..........
........... Otherwise
instructions (erreur)
else expressionN
instructions N end
end

•12
 Script Fonctions (1)
• Fichier (trouvenom.m par exemple)
• Fichier (trouve.m par exemple)
contenant une suite d ’instructions
matlab. contenant une suite d ’instructions
matlab.
• Exécuté séquentiellement dans
l ’espace de travail, il accède aux
• Commence par le mot réservé
variables (locales) qui s ’y trouvent.
function.
• Pour écrire un script, utiliser l’éditeur :
>> edit • Reçoit un (ou plusieurs) paramètre(s)
%trouvenom.m d ’entrée.
%trouve les noms commençant par
%lettre • Peut renvoyer un (ou plusieurs)
liste(find(liste(:,1) == lettre),:) paramètre(s) en sortie ou n ’en
renvoyer aucun.
>> lettre = ‘d’ ;
>> trouvenom
‘didier’ ! Nom du fichier = nom de la fonction

Fonctions (2) Fonctions (3)

function noms = trouve (liste,lettre)
%retourne l’ensemble des noms • Evaluation d ’une fonction définie
%commençant par lettre dans un fichier (f1.m)
%IN Æ liste, lettre
%OUT Æ noms function y = f1(x)
noms=liste(find(liste(:,1) == lettre),:);
y = 2*x.^2 - 5*x +1

>> clear all >> x = -10:0.1:10;

>> help trouve >> y =feval(‘ f1 ’, x) ;
retourne la liste des noms … >> plot(x,y)
>> nom = trouve(liste,‘c’) ; 300

>> nom 250

nom = 200

‘catherine’ 150

100

syntaxes : s = f(e1, e2, …) 50

[s1, s2, …] = f(e1, e2, …) -50

-10 -5 0 5 10

•13
 Fonctions (5)
Fonctions (4)
• Sous fonctions
– un fichier .M peut contenir plusieurs
• Fonctions privées fonctions
– placées dans un répertoire private – la première est la fonction primaire
– seuls les fichiers .M du répertoire parent – les suivantes sont des sous fonctions
peuvent y accéder – accessible à la fonction primaire et aux
autres sous fonctions du fichier .M
– l ’aide ne peut accéder qu’aux lignes de
REP1 commentaires de la fonction primaire
M-files11
function foncprim( ... )
M-files12 %help fonc
M-files13 instructions
REP2 x = sous_fonc( ... )
M-files21
instructions
M-files22 %%%%%%%%%%%%%%%%%%%%
private function x =sousfonc( ... )
%help sous_fonc
Fonction privée instructions

Les variables :
Programmation (1)
locales ou globales ?
• Les variables des scripts sont locales à Forme générale d ’une
l ’espace de travail application MATLAB
• Les variables des fonctions sont
locales à la fonction SCRIPT
• Une variable définie comme globale à
l ’espace de travail (ou à un script)
sera modifiable par toutes les
fonctions l ’ayant déclarée globale Fonction 1 Fonction 2 Fonction 3

function y = f2(x)
global A B C
y = A*x.^2 + B*x + C Fonctions privées
Fonction 21
et/ou
>> global A B C sous fonctions
>> A = 1 ; B = 3 ; C = -1 ; Fonction 22
>> x = -10:0.1:10;
>> y = f2(x) ;

•14
 Programmation (2) Programmation (3)
• Mesure de complexité algorithmique
• Quelques recommandations – temps d ’exécution (en secondes) :
>> A = rand(200);
– Choisir des noms significatifs pour les >> tic ; inv(A ’*A) ; toc
variables et les fonctions elapsed_time =
12.4100
– Documenter les fonctions (help)
• Le profiler ( >> help profile )
– Vérifier le nombre d ’arguments d ’entrée >> profile report
(nargin) et de sortie (nargout) des
temps d ’exécution total (en secondes)
fonctions
>> profile report N
– Eviter (autant que possible !) les boucles N lignes demandant le plus de temps
for et while d ’exécution (en % du temps total)

– Dimensionner les variables • Les messages d’erreur :

??? Index exceeds matrix dimensions.
Error in ==> C:\MATLAB\bin\test.m
On line 2 ==> x(4)

Programmation (4) Programmation (5)

• Boucles et programmation matricielle • Le débogage permet de corriger :
>> A = rand(200) ; – les erreurs de programmation (nombre
>> x = 0 ; d’arguments d’entrée et de sortie, syntaxe
>> tic des commandes ...)
>> for i = 1 : 200 – les erreurs logiques (bugs)
for j = 1 : 200
x = x + A(i,j) ; • Utiliser :
end
end – le point virgule ;
>> toc – le mode clavier : keyboard
elapsed_time = K>>
4.5000 – le debugger
>> tic ; sum(A(:)) ; toc >> help debug
elapsed_time = Debugging command ...
0.0600

•15
 LES GRAPHIQUES Tracer une courbes 2D (1)

• Les graphes en 2D • La commande plot(x,y,s) affiche le

vecteur y en fonction du vecteur x
• Les graphes en 3D avec les attributs (facultatifs) s.

• L ’exportation de graphes >> x =[-10:0.1:10];

>> y1 =x.^2;
>> plot(x, y1, ’r’)

100

90

80

70

60

50

40

30

20

10

0
-10 -5 0 5 10

Tracer une courbes 2D (2) Légender une courbe (1)

• plot(y) permet de tracer directement le
vecteur y en fonction de ses indices.
• plot(x,y1,s1,x,y2,s2,...) trace y1, y2 ...
en fonction de x sur le même graphe
avec les attributs s1, s2 ...
>> y2 =0.5*x.^2 - x + 1 ;
>> plot(x, y1, ’r’, x, y2, ’b’)
100
• Insérer un titre
>> title(‘Tracé de x^2 et 0.5x^2-x+1’)
• Légender l ’axe des abscisses
>> xlabel(‘x : axe des abscisses)
• Légender l ’axe des ordonnées
>> ylabel(‘y : axe des ordonnées’)

90 • Insérer du texte
80 >> gtext(‘x^2’)
70
>> gtext(‘0.5x^2 - x + 1’)
60

50

40 • Ajouter un quadrillage
30
>> grid
20

10

0
-10 -5 0 5 10

•16
 Légender une courbe (2) Manipuler un graphique (1)
2 2
Tracé de x et 0.5x -x+1 • La commande zoom (2D seulement)
100
permet de ‘ zoomer ‘ sur une partie de
90
courbe avec le bouton gauche de la
80
souris (le bouton droit annule le zoom)
70
2
x
• La commande axis permet de changer
y : axe des ordonnées

60

50
les bornes de visualisation
40 syntaxe:
30 axis([xmin xmax ymin ymax])
20
2
0.5x - x + 1 • Dans les deux cas :
10
– focalisation sur une partie ‘ intéressante ’
0
-10 -5 0 5 10 de la courbe
x : axe des absisses
– Lecture précise du point d ’intersection
entre deux courbes

Manipuler un graphique (2) Tracer plusieurs courbes

• Sur un même graphique
>> plot(x, y1, ’r’)
>> hold on
ÎManipulation interactive du graphique >> plot(x, y2, ’b’)

• Sur plusieurs graphiques différents

>> subplot(211), plot(x, y1, ’r’)
>> subplot(212), plot(x, y2, ’r’)
(Nb écrans vertical, Nb écrans horizontal, N° écran)

100

50

0
-10 -5 0 5 10

80

60

40

20

0
-10 -5 0 5 10

•17
 Tracer le graphe d ’une
Histogrammes
fonction
• La commande fplot(‘ f ’,x) permet • Tracés à l ’aide de la commande hist
d ’afficher les variations de la fonction >> y = randn(1000,1) ;
f1 (enregistrée dans le fichier f1.m) sur >> hist (y, 50)
l ’intervalle x. >> title(‘ distribution normale : répartition
en 50 classes ’)
>> x =0:0.1:4*pi;
distribution normale : répatition en 50 classes

>> fplot (‘sin’, x) 50

45

40

35
1

0.8
30

0.6 25

0.4 20

0.2 15

0 10

-0.2 5
-0.4
0
-3 -2 -1 0 1 2 3
-0.6

-0.8

-1
0 2 4 6 8 10 12
(par défaut N_classe = 10)

Courbes paramétrées Tracer une courbe 3D

• Exprimer x et y en fonction de t Syntaxe : plot3(x, y, z, s)

exemple : courbe de Lissajous >> t =0:0.1:25;

>> t =0:0.1:2*pi;
>> x = exp(-0.05*t).*cos(t) ;
>> x = cos(3*t) ;
>> y = exp(-0.05*t).*sin(t) ;
>> y = sin(t) ;
>> z=t;
>> plot(x, y)
>> plot3(x, y,z)
x(t) = cos(3t) y(t) = sin(t)
1

0.8

0.6
25
0.4
20
0.2
15
0
10
-0.2

5
-0.4

-0.6 0
1

-0.8 0.5 1
0 0.5
-1 0
-1 -0.5 0 0.5 1 -0.5
-0.5
-1 -1

•18
 Tracer une surface (1)
>> x = -pi/2 : pi/30 : pi/2 ;
>> y=x;
>> [X,Y] = meshgrid(x,y) ;
>> Z =sinc(X.^2 + Y.^2) ;
>> mesh(X, Y, Z)
• meshc meshz : idem avec contours
Orienter un graphe 3D
rotate3D + bouton gauche
ou view(azimut, élévation)
exemple :
>>subplot(121), surf(X,Y,Z), view(0,0)
>>subplot(122), surf(X,Y,Z), view(0,90)
Tracer une surface (2)
>> colormap(‘ cool ’)
>> surf (X, Y, Z)
• surfc : avec contours
• surfl : avec jeu d ’ombres
Gérer un graphique
• Gestion des fenêtres
– ouvrir une nouvelle fenêtre : figure
– fermer une fenêtre : close
– fermer toutes les fenêtres : close all
• Exportation
– créer un fichier postcript (qu’il est
possible d’importer dans un traitement de
texte). Son nom est alors fig.ps :
print -deps fig
– sous Windows, utiliser
edit Æ copy figure
puis coller (sous Word, Powerpoint ...)
•19
 LES POLYNOMES ET Les polynômes
L ’ANALYSE NUMERIQUE
• Vecteur ligne ensemble de données
• Polynômes
• Vecteur ligne polynôme de degré n
• Opérations polynomiales
p(x) = anxn + an-1xn-1 + ... + a1x + a0
• Interpolation et régression >> p =[an an-1 ... a1 a0] ;
>> length(p)
• Résolution d’équations non linéaires
ans =
• Recherche de minima n+1

>> p1 =[1 0 2] ; %p1(x) = x2 + 2

>> p2 =[2 4 0] ; %p2(x) = 2x2 +4x

coefficients disposés suivant les

! puissances décroissantes de x

Opérations polynomiales Fonctions polynomiales

• Multiplication de 2 polynômes
>> p3 =conv(p1, p2)
p3 =
2 4 4 8
p3(x) = 2x4 + 4x3 + 4x2 + 8x
• Extension à n polynômes
p4(x) = x(x + 2)(2x - 3)
• L ’instruction polyval permet d ’éva-
luer les variations d ’une fonction
0 polynomiale sur un intervalle x.
>> f =[-1 -5 1 0] ; %f(x)=- x3 - 5x2 +x
>> x =-10 :10 ;
>> y =polyval(f, x) ;
>> plot(x,y)
500
3 2
graphe de f(x) = -x - 5x + x

>> p4 =conv([1 0],conv([1 2],[2 -3]))

p4 = 0

2 1 -6 0
-500
y

• Division de polynômes
>> p1 = deconv(p3, p2)
-1000

p1 =
1 0 2 -1500
-10 -5 0
x
5 10

•20
 Interpolation (1) Interpolation (2)
• Interpolation polynomiale au sens des • Ordre 1 : erreur σ = 0.0113
moindres carrés :
1.5

>> p=polyfit(x, y, ordre) ;

1

• Importance de l ’ordre du polynôme 0.5

d ’interpolation : 0

-0.5
%fonction sigmoïde bruitée -5 -4 -3 -2 -1 0 1 2 3 4 5

x = -5:0.1:5 ;
mes=1./(1+exp(-x))+0.05*randn(1,length(x)) ; • Ordre 5 : erreur σ = 0.0023
%interpolation d'ordre 1 1.5

p = polyfit(x, mes, 1) ;
1
res = polyval(p,x) ;
plot(x,mes,'b+',x, res,'r',x,mes - res, 'g')
0.5

%interpolation d'ordre 5
p = polyfit(x, mes, 5) 0

res = polyval(p,x) ;
plot(x,mes,'b+',x, res,'r',x,mes -_res, 'g') -0.5
-5 -4 -3 -2 -1 0 1 2 3 4 5

Interpolation (3) Interpolation (4)

• Relier des points (ensemble de données) 1

0.8
expérimentaux par une courbe formée 0.6

de segments de droite ou de courbes 0.4

polynomiales 0.2

syntaxe : interp1(x,y,z, ’type’) -0.2

-0.4

type : ‘ linear ’ interpolation linéaire -0.6

-0.8

‘ spline ’ interpolation par splines -1

0 2 4 6 8 10

‘ cubic ’ interpolation cubique

>> x =0:10 ; • De même :
>> y = cos(x) ;
>> z = 0:0.1:10 ; %pas de z < pas de x interp2 interpolation dans l ’espace 3D
>> f =interp1(x,y,z) ; %par défaut : linear interp3 .
.
>> plot(x,y, ’bo ’,z,f, ’r+ ’) interpn .

•21
 Régression linéaire Résolution d ’équations
• Détermination du modèle linéaire non linéaires
y=f(x) reliant deux séries de mesure x
et y. • Détermination des racines d’une
fonction non linéaire par la méthode de
⎡ y1 ⎤ ⎡ x1 1⎤ Newton-Raphson
⎢ y ⎥ ⎢ x 1⎥ a
yi = axi + b ⎢ . 2 ⎥ = ⎢ . 2 ⎥⎡ ⎤ Îenregistrer l’expression littérale de la
⎢ . ⎥ ⎢ . ⎥ ⎢⎣ b⎥⎦ fonction dans un fichier (foncnl.m)
⎢. ⎥ ⎢ . ⎥
⎣ yn ⎦ ⎣ x n 1⎦ Îutiliser la fonction fzero pour déterminer
y = Φθ une racine de l’équation au voisinage de x0
vecteur optimal θ = ( ΦTΦ)−1 ΦT y fzero(‘ fonc_nl ’, x0)
(au sens des moindres carrés)
Îutiliser la fonction fsolve pour déter-miner
l’ensemble des racines de l’équation dans
construction de la matrice Φ : l ’intervalle (xd, xf)
>> phi =[x’ ones(length(x),1)] ;
fsolve(‘ fonc_nl ’, xd : xf)
détermination de θ :
>> teta =nnls(phi,y’) ;

function f_nl = foncnl =(x)

%fonction non linéaire
Recherche de minima (1)
f_nl = cos(x).*exp(-0.1*x).*sin(-2*x).+5 ;
>> x =-3:3 ; • Fonctions à une variable :
>> plot(x,foncnl(x)), grid
la valeur qui minimise localement une
1.6
fonction (enregistrée dans fonc.m) dans
1.4 l’intervalle (xd, xf) s ’obtient par :
1.2

0.8
fminbnd(‘ fonc ’, xd, xf)
0.6

0.4
exemple :
0.2 >> xmin= fminbnd(‘foncnl ’,0,2)
0

-0.2
xmin =
-0.4
-3 -2 -1 0 1 2 3
0.5989

>> fzero(‘foncnl ’,0.5) • Fonctions à plusieurs variables :

ans = même principe mais l ’argument d’appel est
0.2826 un vecteur :
>> fsolve(‘foncnl ’,0 : 2)
ans = fminsearch(‘ fonc ’, [x0 y0])
0.2826 0.9505

•22
 Recherche de minima (2)
exemple :

function f2 =fonc2(X)

f2 = 2*X(1)^2 +X(2)^2 - X(1) +X(2) +1

>> minxy =fminsearch(‘fonc2 ’,[0 0])

minxy =
0.2500 -0.5000

>> minf =fonc2(minxy)

minf =
7.5053
Î valeur minimale de la fonction

•23
 IMPORT/EXPORT Fichiers .mat (1)
DE DONNEES
• Sauvegarde et restitution des données
de l’espace de travail
• Fichiers .mat syntaxe : save nom var1 var2 ... varN
• Fichiers externes >> x1 =ones(2) ; x2 =[4.5; 2.1; -6.2] ;
>> save nom
• Formats spécifiques ÎSauvegarde de toutes les variables de
l’espace de travail dans le fichier nom.mat
>> save nom x1
ÎSauvegarde de la variable x1 dans le
fichier nom.mat
>> clear all
>> load nom
>> who
Your variables are :
x1

Fichiers .mat (2) Fichiers externes (1)

• Si le nom du fichier de sauvegarde est
généré par programme
>> nomfich = ‘ nom1 ’
>> save(nomfich, ‘ x1 ’)
1. Ouverture de fichiers
FID =fopen(nomfich, attribut)
nomfich : chaîne de caractères

>> clear x1 attribut : chaîne de caractères précisant le

>> load(nomfich) mode d ’ouverture du fichier :
>> who –r ouverture en lecture seule
Your variables are : –w création en écriture seule
nomfich x1 –a ouverture et placement en fin de
fichier en écriture seule
• Sauvegarde dans un fichier texte – r+ ouverture pour mise à jour ou w+
>> save nom2 x1 - ascii création (lecture et écriture)
>> type nom2 – a+ ouverture pour mise à jour et
1.0000000e+000 1.0000000e+000 placement en fin de fichier
1.0000000e+000 1.0000000e+000 (lecture et écriture)

•24
 Fichiers externes (2) Fichiers textes
• Par défaut : ouverture des fichiers en • Lecture et écriture formatées
binaire.
ÎPour ouvrir un fichier texte ajouter la lettre [data, compt]
t (‘rt’, ‘wt’ ...) =fscanf(FID, format, taille)
data : vecteur colonne représentant les
2. Lecture/ecriture : fread fwrite fscanf valeurs lues
... compt : nombre d’éléments lus (facultatif)
format : format (‘%d’, ‘%c’, ‘%3.2f ’ ...) et
3. Fermeture séparateurs (‘\n’ ‘\t’ ...)
fclose(FID)
compt=fprintf(FID, format, data)
Îferme le fichier ayant pour identificateur
FID ligne=fgetl(FID)
fclose(‘ all ’) ligne : chaîne de caractères contenant la
Îferme tous les fichiers ligne courante du fichier FID

Fichiers binaires (1) Fichiers binaires (2)

• Lecture • Ecriture
[data, compt] compt
=fread(FID,taille,type,saut) =fwrite(FID,data,type,saut)
data : matrice de stockage des données lues compt : nombre d ’éléments lus avec succès
(réels double) FID : identificateur du fichier
compt : nombre d ’éléments lus avec succès data : matrice des données à écrire
FID : identificateur du fichier type : type (nombre d ’octets) de l ’élément
taille : nombre d ’éléments à lire (facultatif) à écrire
type : type (nombre d ’octets) de l ’élément saut : nombre d ’octets à ignorer avant
à lire (‘char’, ‘int’, ‘long’ ...) chaque écriture (facultatif)
saut : nombre d ’octets à ignorer après
chaque lecture (facultatif)

Î intéressant pour l ’extraction de champs

non contigus mais de longueur fixe

•25
 Fichiers binaires (3) Formats spécifiques
• Positionnement • ASCII : fichiers textes manipulables par
un éditeur de textes et contenant des
statut =fseek(FID,offset,origine) données présentées sous formes de
statut : 0 en cas de succès,-1 encas d’échec matrice
offset : nombre d’octets au-delà de origine Î load nom
(positif ou négatif)
origine : position
• ASCII délimité (DLM = ‘ ‘, ‘,’, ’;’ ...)
Î data =dlmread(nom, DLM)
‘ bof ’ début de fichier
Î dlmwrite(nom, data,)
‘ cof ’ position courante du pointeur
‘ eof ’ fin de fichier • CSV : ASCII délimité per une virgule
statut =feof(FID) Î csvread(nom)
Î csvwrite(nom, data)
statut : 1 si la fin du fichier est atteinte, 0
autrement • WK1 : fichiers Lotus 123
Î wk1read(nom)
frewind(FID)
Î wk1write(nom, data)
Îpositionne le pointeur sur le premier octet

•26