espace de travail : le Workspace (1)

INTRODUCTION
Introduction (2)
• MATrix LABoratory
• Logiciel qui
interactive :
permet,
de
manière
– 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
interactive de MATLAB
graphique
Fonctionnement
• Mode interactif :
Les instructions sont exécutées au
fur et à mesure qu ’elles sont
entrées par l ’utilisateur
L ’espace de travail :
le Workspace (1)
Données
Espace de travail
• 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 :
>> x =12.5 ; y = [1 -5 0 2] ;
– définies et dimensionnées automatiquement
au fur et à mesure de leur déclaration
– stockées dans l ’espace de travail
• S ’informer sur les variables :
>> who
Your variables are:
x
y
>> whos
Name
Size
Bytes
Class
x
1x1
8 double
array
y
1x4
32 double array
Grand total is 5 elements using 40 bytes
L ’espace de travail (4)
>> clear x
>> clear all
• Entrer une valeur au clavier :
>> x = input(‘Valeur de x =’)
Valeur de x =12
x=
12
• Afficher un texte à l ’écran :
>> disp(‘ Ceci est un test ’)
Ceci est un test
>> disp([‘ x vaut ’, num2str(x)])
x vaut 12
L ’aide sous MATLAB
>> helpdesk
• Gérer les accès aux répertoires / fichiers
>> pathtool
• Editer les commandes :
ou lettre +
(ou double clic dans l’historique)
>> help nom de commande fournit de
l ’aide sur l ’utilisation de la commande (et
les rubriques connexes).
>> 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
Les scalaires (1)
VECTEURS ET MATRICES
• Scalaires et opérations scalaires
• Vecteurs et opérations vectorielles
• Matrices et opérations matricielles
• Tableaux multidimensionnels
• Structures
• Le scalaire : une matrice 1x1
>> s =2.5 ;
>> size(s)
ans =
1
1
ou
>> [i,j] = size(s)
i=
1
j=
1
• Les format d ’affichage
format short
format long
format short e
format long e
format rat
format bank
Les scalaires (2)
• Les complexes :
>> x=1+j
x=
1.0000 + 1.0000i
• Les constantes prédéfinies :
>> pi
ans =
0.0333
0.033333333333
3.3333E-002
3.333333333334E-002
1/30
0.03
Les scalaires (3)
• Les opérations arithmétiques
>> 3 +7 - 2 * 9
ans =
-8
divisions droite (/) et gauche (\)
élévation à une puissance (^)
3.1416
>> eps
ans =
2.2204e-016
>> 1/0
Warning : Divide by zero
Inf
>> 0/0
Warning : Divide by zero
NaN
• Quelques fonctions
–
–
–
–
–
–
–
–
fonctions trigo :
exponentielle :
log népérien :
log décimal :
racine :
|x|ou ||x||:
Re & Im :
arrondis :
cos acos cosh
exp
log
log10
sqrt
abs
real imag
round ceil floor fix
•4
Créer un vecteur (1)
• Vecteur ligne
>> v1= [1 2 -5] ;
ou
>> v1(1) =1; v1(2) =2;v1(3)=-5;
ou
>> v1(1) = [1, 2 ,-5] ;
• Vecteur colonne
>> v2=[-7;3];
• Transposition :
>> v3=v2 ’
v3 =
-7
3
Créer un vecteur (2)
• Le vecteur : une matrice 1xn
>> size(v1)
ans =
1
3
longueur d ’un vecteur
>> long_v1 = length(v1)
long_v1 =
3
• Concaténation
>> v4 =[v1 v3]
v4 =
1
2
-5
-7
3
• Vecteur vide
>> v =[ ] ;
Créer un vecteur (3)
Opérations vectorielles (1)
• Extraction
• Génération automatique
composantes espacées d ’un pas constant
syntaxe : v =debut : pas : fin
>> v5=1:0.5:3
v5=
1.000 1.500 2.000 2.500 3.000
⇔ v =linspace(1, 3, 5)
par défaut (pas = 1) v =debut : fin
espacement logarithmique de 10debut à 10fin
>> v4(3)
ans =
-5
>> v4(2:4)
ans =
2
-5
-7
• Extraction selon un critère
>> i =find(v4 <0)
i=
3
4
>> v4(i)
ans =
-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
>> s = [2 1 -1]+ [1 -3 5]
s=
3
-2
4
– ajout d ’un scalaire
>> s + 2
ans =
5
0
6
– produit de vecteurs de même dimensions
>> p = [2 1 -1] * [1 -3 5] ’
p=
-6
– produit élément par élément
>> [2 1 -1] .* [1 -3 5]
ans =
2
-3
-5
Créer une matrice (1)
• Saisie d ’une matrice
– lignes séparées par un point virgule
>> M1=[1 0 3;2 5 1]
M1 =
1 0 3
2 5 1
– lignes séparées par un retour chariot
>> M1=[1 0 3
2 5 1]
M1 =
1 0 3
2 5 1
• Dimensions
>> size(M1)
ans =
2
3
>> v = [1 2 -5 -7 3]
– somme des éléments d ’un vecteur
>> sum(v)
ans =
-6
– produit des éléments d ’un vecteur
>> prod(v)
ans =
210
–
–
–
–
–
moyenne :
médiane :
écart-type :
minimum :
maximum :
mean(v)
median(v)
std(v)
min(v)
max(v)
Créer une matrice (2)
• par concaténation
>> M2= [0 7 12];
>> M3 = [M1 ; M2]
M3 =
1 0 3
2 5 1
0 7 12
• par transformation
>> reshape(M3, 1,9)
ans =
1 2 0 0 5 7
• par extraction : triu
3
1
12
tril
Îmatrices triangulaires supérieures et inférieures
•6
Les matrices spéciales (1)
• Matrices identité, nulle et unité
>> IDENTITE = eye( 2,3)
IDENTITE =
1
0 0
0
1 0
– ones (m,n) : matrice m x n dont tous les
éléments valent 1
Les matrices spéciales (2)
• Matrices aléatoires
– Distribution normale (m = 0 , σ = 1) :
>> y = randn(10000,1) ;
– Distribution uniforme (m = 1/2 , σ = 1/12) :
>> y = rand(10000,1) ;
800
– zeros(m,n) : matrice m x n dont tous les
éléments valent 0
600
400
200
Si m=n, spécifier une seule dimension
>> UNITE = ones( 2)
-3
-2
-1
0
1
2
3
4
250
200
UNITE =
1
1
0
-4
150
100
1
1
50
0
0
Opérations matricielles (1)
– d ’une ligne :
>> M3(2, : )
ans =
2
5
– d ’une colonne :
>> M3( : ,2)
ans =
0
5
– d ’une sous-matrice : ??
0.4
0.6
0.8
1
Opérations matricielles (2)
• Comparaison
• Extraction
– d ’un élément :
>> M3(3,2)
ans =
7
0.2
>> M3(6)
ans =
7
1
>> M3 = [1 0 3 ; 2 5 1 ; 0 7 12] ;
>> M4 = ones(3) ;
>> M3 >
ans =
0
1
0
M4
0
1
1
%find(M3 > 1)
1
0
1
• Extension des instruction min, max ...
>> max(M3)
ans =
2
7
%maximum par colonnes
12
>> max(M3(:)) %max(max(M3))
ans =
12
•7
Opérations matricielles (3)
• Produit classique
Opérations matricielles (4)
• Transformations
Rappel : le produit de A(mxn) par B(pxq)
n ’est possible que si n = p et le résultat est
de dimension mxq
7
10
1
4
15
22
9
16
>> M = [1 2 ; 3 4]
>> fliplr(M) %retournement gauche/droite
ans =
2
1
4
3
>> flipud(M) %retournement haut/bas
ans =
3
4
1
2
>> rot90(M) %transposition + flipud
ans =
2
4
1
3
Opérations matricielles (5)
Vecteurs et valeurs propres
• Produit de Hadamard
ou produit élément par élément de deux
matrices de mêmes dimensions
>> A = [1 2 ; 3 4]
>> A * A
>> A .* A
ans =
ans =
• Fonctions diverses
– déterminant :
>> det(M)
– norme
>> norm(M)
– rang
>> rank(M)
– inverse (et pseudo-inverse)
>> inv(M)
>> pinv(M)
– conditionnement
>> cond(M)
– exponentielle
expm : vecteurs et valeurs propres
expm1 : approximation de Padé
expm2 : série de Taylor
>> M = [2 1 ; 1 2] ;
• Polynôme caractéristique : |λI - M| = 0
>> poly(M)
ans =
1
-4
3
• Vecteurs et valeurs propres
>> [vec val] = eig(M)
vec =
0.7071
- 0.7071
val =
1
0
0
3
0.7071
0.7071
•8
Les tableaux
multidimensionnels
• Extension à n dimensions :
– vecteur (1D) : 1 indice
– matrice (2D) : 2 indices, ligne et colonne
– tableau tridimensionnel : 3 indices, ligne,
colonne et page
– ...
exemple :
>> M1 =ones(3) ;
>> M2 =zeros(3) ;
>> M3 =cat(3,M1,M2) ;
M3( : , : , 1) =
1
1
1
1
1
1
1
1
1
M3( : , : , 2) =
0
0
0
0
0
0
0
0
0
Les structures (1)
Structure = regroupement de variables
(champs) de type différents (chaînes,
entiers ...) dans une même variable.
exemple : fichier des élèves d’un établissement
scolaire :
Î nom
Î notes
Î adresse ...
nom=struct(‘ch1’,{v1,v2...}, ’ch2 ’,{v1,v2
...})
>>eleve=struct(‘nom’,{‘paul’,’eve’,’jean’}, ’note1’,
{12,8,11}, ’note2’,{14,15,3})
eleve =
1x3 struct array with fields :
nom
note1
note2
Les structures (2)
• Liste des champs
>> fieldnames(eleve)
ans =
‘nom’
‘note1’
‘note2’
• Extraction : on utilise l ’opérateur ‘.‘
>> eleve(2).nom
Les structures (3)
Manipulation indirecte
Înécessite de créer des vecteurs de données
tampons
>> liste1 = cat(1,eleve.note1)
liste1 =
12
5
ans =
eve
• Affectation directe
>> eleve(4).nom = ‘toto’;
eleve =
1x4 struct array. with fields :
17
>> liste2 = cat(1,eleve.note2) ;
>> moy=mean(mean([ liste1 liste2 ])
moy =
13.1250
.
.
•9
LA PROGRAMMATION
MATLAB
• Les opérateurs logiques
• Les chaînes de caractères
• Les commandes structurées
• Les scripts et les fonctions
• La programmation
Opérateurs logiques
•
•
•
•
•
•
•
•
==
~=
<( <=)
>( >=)
&
~
|
xor
égalité
différence
inférieur (ou égal)
supérieur (ou égal)
ET logique (AND)
NON logique (NOT)
OU logique (OR)
OU exclusif (XOR)
Exemple :
>> a = [1 0 0 1] ;
>> b = [1 1 0 1] ;
>> a | b
ans =
1
1
0
Chaînes de caractères (1)
• Généralités
– chaîne = vecteur ligne
– nombre de composantes = longueur de
la chaîne
>> ch = ‘ bonjour monsieur ’
>> size(ch)
16
• Conversions
num2str : nombre
mat2str
: matrice
str2num : chaîne
Chaînes de caractères (2)
• Ecriture de chaînes formatées
syntaxe :
text=sprintf(‘ format1 format2... ’, data1,
data2 ...)
exemple :
• Affectation
ans =
1
1
chaîne
chaîne
nombre
>> pi2 = pi^2
pi2 =
9.8696
>> text = sprintf(‘ le carré de pi vaut %3.2f ’,
pi2)
text =
le carré de pi vaut 9.87
• Exécution d’une chaîne :
exemple :
>> name = ‘c:/bin/data’
>> eval([‘load’, name]); %load(name)
•10
L ’instruction FOR (1)
• parcours d'un intervalle
syntaxe :
for variable =debut : fin
instructions
..........
instructions
end
exemple : créer le vecteur [1 2 22 24 .... 210]
>> x=[ ]
x=
[]
>> for n=0:10 ; x =[x 2^n] ; end
L ’instruction FOR (2)
• On peut utiliser un incrément (pas) autre
que 1 (valeur par défaut).
syntaxe :
for variable =debut:pas:fin
• Les bornes ne sont pas nécessairement
des entiers.
• Le pas peut être négatif.
• Il est possible d ’imbriquer les boucles
ou directement
Penser à l ’indentation !!
>> for n=0:10; x(n +1) =2^n; end
!
bouton droit Æ smart indent
programmation matricielle ??
La boucle WHILE
• tant que . . . faire
Les ruptures de boucle
• Il est possible de provoquer une sortie
prématurée d'une boucle de contrôle.
syntaxe :
while expression
instructions
..........
instructions
end
exemple: calculer le plus petit entier n tel que
2n soit supérieur à un réel a donné.
>> max =2002 ; n=1;
>> while (2^n <max);n=n+1;end;
>> n
n=
11
break termine l ’exécution d ’une boucle.
for variable1 = debut1 : fin1
instructions
..........
for variable2 = debut2 : fin2
instructions
..........
break
instructions
end
instructions
end
return provoque un retour au programme
appelant (ou au workspace).
•11
L ’instruction IF (1)
L ’instruction IF (2)
• La séquence d ’instructions intérieure
est exécutée si expression est vrai (=1
logique).
syntaxe
if expression
instruction
........
instruction
end
• expression
peut
• Permet de choisir entre deux options.
syntaxe
if expression
instructions 1
else
instructions 2
end
être
simple
ou
• si expression n ’est pas vérifier alors
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)
• Permet une sélection multiple.
syntaxe
if expression1
instructions 1
elseif expression2
instructions 2
elseif expression3
instructions 3
...........
else expressionN
instructions N
L ’instruction SWITCH
• Permet une sélection multiple.
syntaxe
switch variable
case valeur1
instructions 1
case valeur2
instructions 2
..........
Otherwise
instructions (erreur)
end
end
•12
Script
• Fichier (trouvenom.m par exemple)
contenant une suite d ’instructions
matlab.
• Exécuté
séquentiellement
dans
l ’espace de travail, il accède aux
variables (locales) qui s ’y trouvent.
• Pour écrire un script, utiliser l’éditeur :
>> edit
%trouvenom.m
%trouve les noms commençant par
%lettre
liste(find(liste(:,1) == lettre),:)
>> lettre = ‘d’ ;
>> trouvenom
‘didier’
Fonctions (1)
• Fichier (trouve.m par exemple)
contenant une suite d ’instructions
matlab.
• Commence
function.
>> clear all
>> help trouve
retourne la liste des noms …
>> nom = trouve(liste,‘c’) ;
>> nom
nom =
‘catherine’
le
mot
réservé
• Reçoit un (ou plusieurs) paramètre(s)
d ’entrée.
• Peut renvoyer un (ou plusieurs)
paramètre(s) en sortie ou n ’en
renvoyer aucun.
!
Nom du fichier = nom de la fonction
Fonctions (2)
function noms = trouve (liste,lettre)
%retourne l’ensemble des noms
%commençant par lettre
%IN Æ liste, lettre
%OUT Æ noms
noms=liste(find(liste(:,1) == lettre),:);
par
Fonctions (3)
• Evaluation d ’une fonction définie
dans un fichier (f1.m)
function y = f1(x)
y = 2*x.^2 - 5*x +1
>> x = -10:0.1:10;
>> y =feval(‘ f1 ’, x) ;
>> plot(x,y)
300
250
200
150
100
syntaxes : s = f(e1, e2, …)
50
0
[s1, s2, …] = f(e1, e2, …)
-50
-10
-5
0
5
10
•13
Fonctions (4)
• Fonctions privées
– placées dans un répertoire private
– seuls les fichiers .M du répertoire parent
peuvent y accéder
REP1
M-files11
M-files12
Fonctions (5)
• Sous fonctions
– un fichier .M peut contenir plusieurs
fonctions
– la première est la fonction primaire
– les suivantes sont des sous fonctions
– accessible à la fonction primaire et aux
autres sous fonctions du fichier .M
– l ’aide ne peut accéder qu’aux lignes de
commentaires de la fonction primaire
function foncprim( ... )
%help fonc
instructions
x = sous_fonc( ... )
instructions
M-files13
REP2
M-files21
M-files22
%%%%%%%%%%%%%%%%%%%%
private
Fonction privée
Les variables :
locales ou globales ?
• Les variables des scripts sont locales à
l ’espace de travail
• Les variables des fonctions sont
locales à la fonction
• 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
function y = f2(x)
global A B C
y = A*x.^2 + B*x + C
>> global A B C
>> A = 1 ; B = 3 ; C = -1 ;
>> x = -10:0.1:10;
>> y = f2(x) ;
function x =sousfonc( ... )
%help sous_fonc
instructions
Programmation (1)
Forme générale d ’une
application MATLAB
SCRIPT
Fonction 1
Fonctions privées
et/ou
sous fonctions
Fonction 2 Fonction 3
Fonction 21
Fonction 22
•14
Programmation (2)
Programmation (3)
• Mesure de complexité algorithmique
• Quelques recommandations
– Choisir des noms significatifs pour les
variables et les fonctions
– temps d ’exécution (en secondes) :
>> A = rand(200);
>> tic ; inv(A ’*A) ; toc
elapsed_time =
12.4100
– Documenter les fonctions (help)
• Le profiler ( >> help profile )
– Vérifier le nombre d ’arguments d ’entrée
(nargin) et de sortie (nargout) des
fonctions
>> profile report
– Eviter (autant que possible !) les boucles
for et while
N lignes demandant le plus
d ’exécution (en % du temps total)
– Dimensionner les variables
temps d ’exécution total (en secondes)
>> profile report N
de
temps
• Les messages d’erreur :
??? Index exceeds matrix dimensions.
Error in ==> C:\MATLAB\bin\test.m
On line 2 ==> x(4)
Programmation (4)
• Boucles et programmation matricielle
>> A = rand(200) ;
>> x = 0 ;
>> tic
>> for i = 1 : 200
for j = 1 : 200
x = x + A(i,j) ;
end
end
>> toc
elapsed_time =
4.5000
>> tic ; sum(A(:)) ; toc
elapsed_time =
0.0600
Programmation (5)
• Le débogage permet de corriger :
– les erreurs de programmation (nombre
d’arguments d’entrée et de sortie, syntaxe
des commandes ...)
– les erreurs logiques (bugs)
• Utiliser :
– le point virgule ;
– le mode clavier : keyboard
K>>
– le debugger
>> help debug
Debugging command ...
•15
LES GRAPHIQUES
Tracer une courbes 2D (1)
• La commande plot(x,y,s) affiche le
vecteur y en fonction du vecteur x
avec les attributs (facultatifs) s.
• Les graphes en 2D
• Les graphes en 3D
• 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
Tracer une courbes 2D (2)
• 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’)
-5
0
5
10
Légender une courbe (1)
• 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’)
100
• Insérer du texte
90
>> gtext(‘x^2’)
>> gtext(‘0.5x^2 - x + 1’)
80
70
60
50
• Ajouter un quadrillage
40
>> grid
30
20
10
0
-10
-5
0
5
10
•16
Légender une courbe (2)
2
Manipuler un graphique (1)
• La commande zoom (2D seulement)
permet de ‘ zoomer ‘ sur une partie de
courbe avec le bouton gauche de la
souris (le bouton droit annule le zoom)
2
Tracé de x et 0.5x -x+1
100
90
80
70
2
y : axe des ordonnées
x
• La commande axis permet de changer
les bornes de visualisation
60
50
syntaxe:
axis([xmin xmax ymin ymax])
40
30
20
• Dans les deux cas :
2
0.5x - x + 1
10
0
-10
-5
0
x : axe des absisses
5
10
Manipuler un graphique (2)
– focalisation sur une partie ‘ intéressante ’
de la courbe
– Lecture précise du point d ’intersection
entre deux courbes
Tracer plusieurs courbes
• Sur un même graphique
ÎManipulation interactive du graphique
>> plot(x, y1, ’r’)
>> hold on
>> 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
-5
0
5
10
80
60
40
20
0
-10
•17
Tracer le graphe d ’une
fonction
• La commande fplot(‘ f ’,x) permet
d ’afficher les variations de la fonction
f1 (enregistrée dans le fichier f1.m) sur
l ’intervalle x.
>> x =0:0.1:4*pi;
>> fplot (‘sin’, x)
Histogrammes
• Tracés à l ’aide de la commande hist
>> y = randn(1000,1) ;
>> hist (y, 50)
>> title(‘ distribution normale : répartition
en 50 classes ’)
distribution normale : répatition en 50 classes
50
45
40
35
1
30
0.8
0.6
25
0.4
20
0.2
15
0
10
-0.2
5
-0.4
0
-3
-0.6
-2
-1
0
1
2
3
-0.8
-1
0
2
4
6
8
10
(par défaut N_classe = 10)
12
Courbes paramétrées
Syntaxe : plot3(x, y, z, s)
• Exprimer x et y en fonction de t
exemple : courbe de Lissajous
>> t =0:0.1:2*pi;
>> x = cos(3*t) ;
>> y = sin(t) ;
>> plot(x, y)
x(t) = cos(3t)
Tracer une courbe 3D
>>
>>
>>
>>
>>
t =0:0.1:25;
x = exp(-0.05*t).*cos(t) ;
y = exp(-0.05*t).*sin(t) ;
z=t;
plot3(x, y,z)
y(t) = sin(t)
1
0.8
0.6
25
0.4
20
0.2
15
0
10
-0.2
5
-0.4
0
1
-0.6
0.5
-0.8
1
0.5
0
-1
-1
-0.5
0
0.5
1
0
-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)
Tracer une surface (2)
>> colormap(‘ cool ’)
>> surf (X, Y, Z)
• surfc : avec contours
• 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)
• 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
L ’ANALYSE NUMERIQUE
Les polynômes
• Vecteur ligne
ensemble de données
• Polynômes
• Vecteur ligne
polynôme de degré n
p(x) = anxn + an-1xn-1 + ... + a1x + a0
• Opérations polynomiales
• Interpolation et régression
>> p =[an an-1 ... a1 a0] ;
• Résolution d’équations non linéaires
>> length(p)
ans =
• Recherche de minima
n+1
>> p1 =[1 0 2] ;
%p1(x) = x2 + 2
>> p2 =[2 4 0] ;
%p2(x) = 2x2 +4x
!
Opérations polynomiales
• Multiplication de 2 polynômes
>> p3 =conv(p1, p2)
p3 =
2
4
4
8
0
p3(x) = 2x4 + 4x3 + 4x2 + 8x
• Extension à n polynômes
coefficients disposés suivant les
puissances décroissantes de x
Fonctions polynomiales
• L ’instruction polyval permet d ’évaluer les variations d ’une fonction
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)
p4(x) = x(x + 2)(2x - 3)
3
2
graphe de f(x) = -x - 5x + x
500
>> p4 =conv([1 0],conv([1 2],[2 -3]))
p4 =
2
1
-6
0
y
0
-500
• Division de polynômes
>> p1 = deconv(p3, p2)
p1 =
1
0
2
-1000
-1500
-10
-5
0
x
5
10
•20
Interpolation (1)
• Interpolation polynomiale au sens des
moindres carrés :
Interpolation (2)
• Ordre 1 : erreur σ = 0.0113
1.5
>> p=polyfit(x, y, ordre) ;
1
• Importance de l ’ordre du polynôme
d ’interpolation :
%fonction sigmoïde bruitée
x = -5:0.1:5 ;
mes=1./(1+exp(-x))+0.05*randn(1,length(x)) ;
%interpolation d'ordre 1
p = polyfit(x, mes, 1) ;
res = polyval(p,x) ;
plot(x,mes,'b+',x, res,'r',x,mes - res, 'g')
0.5
0
-0.5
-5
-4
-3
-2
-1
0
1
2
3
4
5
4
5
• Ordre 5 : erreur σ = 0.0023
1.5
1
0.5
%interpolation d'ordre 5
p = polyfit(x, mes, 5)
res = polyval(p,x) ;
plot(x,mes,'b+',x, res,'r',x,mes -_res, 'g')
0
-0.5
-5
-4
Interpolation (3)
• Relier des points (ensemble de données)
expérimentaux par une courbe formée
de segments de droite ou de courbes
polynomiales
-3
-2
-1
0
1
2
3
Interpolation (4)
1
0.8
0.6
0.4
0.2
0
syntaxe : interp1(x,y,z, ’type’)
-0.2
-0.4
type : ‘ linear ’ interpolation linéaire
‘ spline ’ interpolation par splines
‘ cubic ’ interpolation cubique
>> x =0:10 ;
>> y = cos(x) ;
>> z = 0:0.1:10 ; %pas de z < pas de x
>> f =interp1(x,y,z) ; %par défaut : linear
>> plot(x,y, ’bo ’,z,f, ’r+ ’)
-0.6
-0.8
-1
0
2
4
6
8
10
• De même :
interp2 interpolation dans l ’espace 3D
.
interp3
.
.
interpn
•21
Régression linéaire
• Détermination du modèle linéaire
y=f(x) reliant deux séries de mesure x
et y.
⎡ y1 ⎤ ⎡ x1 1⎤
⎢ y ⎥ ⎢ x 1⎥ a
⎢ . 2 ⎥ = ⎢ . 2 ⎥⎡ ⎤
⎢ . ⎥ ⎢ . ⎥ ⎢⎣ b⎥⎦
⎢. ⎥ ⎢ . ⎥
⎣ yn ⎦ ⎣ x n 1⎦
y = Φθ
yi = axi + b
vecteur optimal θ = ( ΦTΦ)−1 ΦT y
(au sens des moindres carrés)
construction de la matrice Φ :
>> phi =[x’ ones(length(x),1)] ;
Résolution d ’équations
non linéaires
• Détermination des racines d’une
fonction non linéaire par la méthode de
Newton-Raphson
Îenregistrer l’expression littérale de la
fonction dans un fichier (foncnl.m)
Îutiliser la fonction fzero pour déterminer
une racine de l’équation au voisinage de x0
fzero(‘ fonc_nl ’, x0)
Îutiliser la fonction fsolve pour déter-miner
l’ensemble des racines de l’équation dans
l ’intervalle (xd, xf)
fsolve(‘ fonc_nl ’, xd : xf)
détermination de θ :
>> teta =nnls(phi,y’) ;
function f_nl = foncnl =(x)
%fonction non linéaire
f_nl = cos(x).*exp(-0.1*x).*sin(-2*x).+5 ;
>> x =-3:3 ;
>> plot(x,foncnl(x)), grid
Recherche de minima (1)
• Fonctions à une variable :
la valeur qui minimise localement une
fonction (enregistrée dans fonc.m) dans
l’intervalle (xd, xf) s ’obtient par :
1.6
1.4
1.2
fminbnd(‘ fonc ’, xd, xf)
1
0.8
0.6
0.4
0.2
0
-0.2
-0.4
-3
-2
-1
0
1
>> fzero(‘foncnl ’,0.5)
ans =
0.2826
>> fsolve(‘foncnl ’,0 : 2)
ans =
0.2826
0.9505
2
3
exemple :
>> xmin= fminbnd(‘foncnl ’,0,2)
xmin =
0.5989
• Fonctions à plusieurs variables :
même principe mais l ’argument d’appel est
un vecteur :
fminsearch(‘ fonc ’, [x0 y0])
•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
DE DONNEES
• Fichiers .mat
• Fichiers externes
• Formats spécifiques
Fichiers .mat (1)
• Sauvegarde et restitution des données
de l’espace de travail
syntaxe : save nom var1 var2 ... varN
>> x1 =ones(2) ; x2 =[4.5; 2.1; -6.2] ;
>> save nom
Î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)
• Si le nom du fichier de sauvegarde est
généré par programme
>> nomfich = ‘ nom1 ’
>> save(nomfich, ‘ x1 ’)
>> clear x1
>> load(nomfich)
>> who
Your variables are :
nomfich
x1
• Sauvegarde dans un fichier texte
>> save nom2 x1 - ascii
>> type nom2
1.0000000e+000
1.0000000e+000
1.0000000e+000
1.0000000e+000
Fichiers externes (1)
1. Ouverture de fichiers
FID =fopen(nomfich, attribut)
nomfich : chaîne de caractères
attribut : chaîne de caractères précisant le
mode d ’ouverture du fichier :
–r
ouverture en lecture seule
–w
création en écriture seule
–a
ouverture et placement en fin de
fichier en écriture seule
– r+
ouverture pour mise à jour ou w+
création (lecture et écriture)
– a+
ouverture pour mise à jour et
placement en fin de fichier
(lecture et écriture)
•24
Fichiers externes (2)
• Par défaut : ouverture des fichiers en
binaire.
ÎPour ouvrir un fichier texte ajouter la lettre
t (‘rt’, ‘wt’ ...)
2. Lecture/ecriture : fread fwrite fscanf
...
3. Fermeture
fclose(FID)
Îferme le fichier ayant pour identificateur
FID
fclose(‘ all ’)
Îferme tous les fichiers
Fichiers binaires (1)
• Lecture
Fichiers textes
• Lecture et écriture formatées
[data, compt]
=fscanf(FID, format, taille)
data :
vecteur colonne
valeurs lues
compt :
format :
nombre d’éléments lus (facultatif)
représentant
les
format (‘%d’, ‘%c’, ‘%3.2f ’ ...) et
séparateurs (‘\n’ ‘\t’ ...)
compt=fprintf(FID, format, data)
ligne=fgetl(FID)
ligne :
chaîne de caractères contenant la
ligne courante du fichier FID
Fichiers binaires (2)
• Ecriture
[data, compt]
=fread(FID,taille,type,saut)
compt
=fwrite(FID,data,type,saut)
data :
matrice de stockage des données lues
(réels double)
nombre d ’éléments lus avec succès
compt :
FID :
taille :
type :
nombre d ’éléments lus avec succès
compt :
FID :
data :
type :
saut :
nombre d ’octets à ignorer avant
chaque écriture (facultatif)
saut :
nombre d ’octets à ignorer après
chaque lecture (facultatif)
identificateur du fichier
nombre d ’éléments à lire (facultatif)
type (nombre d ’octets) de l ’élément
à lire (‘char’, ‘int’, ‘long’ ...)
identificateur du fichier
matrice des données à écrire
type (nombre d ’octets) de l ’élément
à écrire
Î intéressant pour l ’extraction de champs
non contigus mais de longueur fixe
•25
Fichiers binaires (3)
• Positionnement
statut =fseek(FID,offset,origine)
statut :
offset :
0 en cas de succès,-1 encas d’échec
origine :
position
‘ bof ’ début de fichier
‘ cof ’ position courante du pointeur
‘ eof ’ fin de fichier
nombre d’octets au-delà de origine
(positif ou négatif)
statut =feof(FID)
statut :
1 si la fin du fichier est atteinte, 0
autrement
frewind(FID)
Îpositionne le pointeur sur le premier octet
Formats spécifiques
• ASCII : fichiers textes manipulables par
un éditeur de textes et contenant des
données présentées sous formes de
matrice
Î load nom
• ASCII délimité (DLM = ‘ ‘, ‘,’, ’;’ ...)
Î data =dlmread(nom, DLM)
Î dlmwrite(nom, data,)
• CSV : ASCII délimité per une virgule
Î csvread(nom)
Î csvwrite(nom, data)
• WK1 : fichiers Lotus 123
Î wk1read(nom)
Î wk1write(nom, data)
•26