Il sistema MATLAB

Transcript

Il sistema MATLAB

Calcolo Numerico II- CdL Specialistica in Ingegneria Informatica - A.d’Alessio
Il Sistema Interattivo MATLAB
Il sistema interattivo MATLAB
L’ambiente Matlab
Matlab (Matrix Laboratory) (www.mathworks.com) è un sistema interattivo di facile utilizzo
per il calcolo scientifico e la visualizzazione grafica di dati. Attualmente è uno dei sistemi
numerici più usati sia in ambito didattico che applicativo. Fu progettato inizialmente (da C.
Moler negli anni ’70) per la risoluzione di problemi di algebra lineare, semplificando
l’utilizzo dei moduli software dei packages LINPACK, LAPACK ed EISPACK. In seguito le
sue capacità si sono estese alla risoluzione di svariati problemi di analisi numerica
(algebra lineare, interpolazione, calcolo di integrali, risoluzione numerica di equazioni
differenziali,…) e di visualizzazione grafica. Può essere corredato da vari toolbooks
applicativi specifici : signal processing toolbox, control system toolbox, etc.
Attualmente è uno standard de facto nella didattica, ricerca ed industria .
Il Matlab è scritto prevalentemente in C, mentre molte routines interne sono scritte in
linguaggio Matlab. Fornisce un linguaggio di programmazione facile da usare, grazie
anche ai numerosi programmi dimostrativi (DEMO) e ad una potente e naturale
documentazione on line. Il Matlab può essere usato
In modalità immediata
Come linguaggio di programmazione (è dotato di un proprio editor)
Mette a disposizione:
Linguaggio di programmazione di alto livello
Algoritmi di calcolo numerico “higt performance”
Grafica 2D e 3D, animazione,suono
Ambiente di calcolo vettoriale
Allocazione dinamica della memoria
Numerose funzioni predefinite e possibilità di crearne altre
Numerosi toolbox in svariate aree applicative
Capacità di interfacciarsi con altri linguaggi (C,C++,Fortran,Java,…) e di
importare ed esportare dati
Un potente HELP on line (help,doc)
Sviluppo di applicazioni dotate di interfaccia utente grafica :GUI – Graphical
User Interface
Per avviare il Matlab in ambiente Windows basta selezionare con il mouse l’icona
corrispondente. Sullo schermo compare il desktop di Matlab. Nella configurazione
standard (v.7) compaiono tre finestre: Command Window (finestra comandi), Command
History (mostra i comandi immessi precedentemente, Current Directory (cartella corrente,
si usa per accedere ai files). Si può attivare anche la finestra Workspace, che visualizza le
variabili in memoria e consente di operare su di esse. La finestra comandi è quella tramite
la quale l’utente comunica con il programma Matlab. Avviato il Matlab compare il prompt
(>>) nella finestra comandi e si potranno eseguire i comandi in modo interattivo. Per
terminare una sessione di lavoro si digita quit. Per conoscere la versione Matlab che si
sta usando si digita version.
La directory principale di Matlab è C: \matlab. Per visualizzare il percorso di ricerca di un
file si usa il comando path. Se il file non è nella directory corrente il Matlab segnala errore;
1
per conoscere la directory corrente vi è il comando pwd, per avere un elenco dei file
presenti dir.
Matlab possiede un potente help in linea: il comando help visualizza i toolbox disponibili
(pacchetti dedicati ad una specifica applicazione). Per un’informazione più dettagliata
basta far seguire ad help il nome del comando (toolbox) desiderato:
>> help
HELP topics:
matlab\general
- General purpose commands.
matlab\ops
- Operators and special characters.
matlab\lang
- Programming language constructs.
matlab\elmat
- Elementary matrices and matrix manipulation
…………..
>> help elfun
Elementary math functions.
Trigonometric.
sin
- Sine.
sinh
- Hyperbolic sine.
asin
- Inverse sine.
asinh
- Inverse hyperbolic sine.
cos
- Cosine
……..
>> help sin
SIN Sine.
SIN(X) is the sine of the elements of X.
Il comando lookfor consente invece di identificare tutte le funzioni relative ad un
argomento particolare.
E’consigliabile usare l’help quando si usa per la prima volta un comando o una funzione
Matlab così da verificarne la sintassi.
Il sistema aritmetico usato è lo standard IEEE a doppia precisione.
Le variabili MATLAB
In Matlab non esistono dichiarazioni di tipo: il tipo di una variabile è stabilito al momento
della sua definizione.
La variabile elementare in Matlab è una matrice rettangolare di numeri reali o
complessi, che non richiede un dimensionamento esplicito, ma è dichiarata e definita
attraverso l’assegnazione dei suoi elementi.
Operazioni e funzioni operano per default su matrici. Come casi particolari si ritrovano:
I vettori riga (matrici 1×n) o colonna(matrici n×1)
Gli scalari (matrici 1×1)
Un array può essere di diversi tipi (class):
2
Inizializzazione di variabili
Il Matlab opera per espressioni, ossia converte espressioni in variabili. Le dichiarazioni
hanno frequentemente la forma:
variabile = espressione
espressione
E’ possibile comporre espressioni con operatori, caratteri speciali, funzioni e nomi di
variabili. La valutazione
lutazione di un’espressione produce una matrice che viene visualizzata
sullo schermo ed assegnata a:
variabile
ans , una variabile creata automaticamente ed aggiornata dopo la valutazione di
espressione.
>> 8/10
ans =
0.8000
>> r=8/10
r=
0.8000
Il comando who dà una lista delle variabili, whos della quantità di memoria allocata:
>> who
Your variables are:
ans f r
>> whos
Name
Size
Bytes Class
ans
1x1
8 double array
f
1x1
8 double array
r
1x1
8 double array
Grand total is 3 elements using 24 bytes
Le variabili dichiarate sono conservate nello spazio di memoria detto workspace, e restano
in quest’area per tutta la
a durata della sessione.
Il comando clear cancella le variabili definite dall’utente. Per cancellarne solo alcune va
seguito dai nomi delle variabili.
Alcune variabili sono predefinite, come ad esempio:
realmin = minimo numero reale positivo, realmax = massimo numero reale positivo, eps
= epsilon macchina , pi = π , i,j = unità immaginaria, NaN = “not a number”, inf =
“infinito”, clock = tempo corrente.
Per la visualizzazione dei numeri sono previsti i seguenti formati, tra cui:
format short (default): 5 cifre significative
format short e : notazione esponenziale con 5 cifre significative
format long : 16 cifre significative
format long e : notazione esponenziale con 16 cifre significative
format hex : esadecimale, visualizza il contenuto della memoria.
Ad esempio per visualizzare 2/7 si ha:
format short (default): 0.2857
format short e : 2.8571e-001
format long : 0.28571428571429
format long e : 2.857142857142857e-001
format hex : 3fd2492492492492
Il format long e è il più fedele al formato interno del calcolatore.
Visualizziamo il valore di 1+eps, che come è noto è diverso da 1. Si ha:
>> 1+eps
ans =
1.000000000000000e+000
Tale risultato apparentemente errato dipende solo dal formato di output, infatti se
visualizziamo l’effettivo contenuto delle locazioni di memoria di 1 e 1+eps si vede che
sono diversi nell’ultima cifra:
>> format hex
>> 1
ans =
3ff0000000000000
>> 1+eps
ans =
3ff0000000000001
Infine, un numero complesso si può definire in maniera diretta : z=a+bi o tramite il
comando complex(a,b).
Generazione di array
L’input di una matrice può avvenire in vari modi:
attraverso la lista esplicita dei suoi elementi
attraverso funzioni intrinseche
attraverso M-file
caricata da un data file esterno
L’input mediante la lista esplicita degli elementi avviene racchiudendo la lista tra parentesi
quadre e separando le righe con il punto e virgola:
A=[1 2 3; 4 5 6; 7 8 9; 10 11 12]
Per accedere alla componente di un array : A(2,3).
4
La generazione di un vettore riga è :
x = [1 2 3];
di un vettore colonna :
c= [1;2;3] ;
Per accedere all’ultima componente di un vettore x si può usare x(end).
Per generare un vettore di componenti equispaziate si usa il carattere “:”. Il comando
x=1:5
genera il vettore x= (1, 2, 3, 4, 5).
Se l’incremento è diverso da uno il comando è ad esempio:
x=5:-1:1
che genera x = (5, 4, 3, 2, 1).
Se invece si vuole generare un vettore di n elementi in [a,b] il comando è:
linspace(a,b,n)
Ad esempio si vuole un vettore di 5 elementi in [0,π] :
y=linspace(0, pi,5)
La gestione degli array è dinamica cioè essi possono variare le dimensioni durante il
calcolo. Ad esempio, considerata la precedente matrice A, i comandi seguenti aggiungono
ad A la riga r (concatenazione di array: attenzione alla correttezza delle dimensioni!):
>> r= [13 14 15];
>> A= [A; r];
Il punto e virgola inibisce la visualizzazione del valore della variabile, che altrimenti è
sempre visualizzato.
Le dimensioni di A (date dalla funzione size(A)) sono automaticamente aggiornate:
size(A) produce:
ans =
5 3
Il comando:
A=A(1:3, : )
estrae dalla matrice A la sottomatrice costituita dalle prime 3 righe di A.
A(m:n,l:k) è la sottomatrice di A formata dalle righe tra m ed n e le colonne tra l e k.
Il comando: A=[ ] crea una matrice vuota, che si può utilizzare per eliminare righe o
colonne da una matrice:
>>a =
[1 2 3
4 5 6
7 4 9]
>> a(:,[2 3])=[]
a=
1
4
7
>>a(:,[1 3])=b(:,[4 2])
sostituisce la I e III colonna di a con la IV e II di b.
>> a(:) = -1
sostituisce tutti gli elementi di a con -1.
Vi sono molte funzioni predefinite che generano automaticamente molti tipi di matrici:
matrice identica, matrice nulla,etc.
5
Alcune funzioni generatrici di matrici e vettori
linspace(a,b,n)
a:h:b
logspace(a,b,n)
meshgrid(x,y)
eye(n)
zeros(m,n)
ones(m,n)
rand(m,n)
hilb(n)
sparse
repmat
Genera il vettore di n componenti tra a e b
Genera il vettore di n componenti con passo h
Genera il vettore di n componenti a spaziatura logaritmica
Genera reticolo 2D
Matrice identica
Matrice nulla
Matrice di elementi uguali ad 1
Matrice random
Matrice di Hilbert di ordine n
Genera una matrice sparsa
Genera una matrice con righe o colonne uguali
Si può anche costruire una matrice a blocchi:
A= [zeros(2,3),eye(2)]
Variabili di tipo stringa
Le variabili di tipo stringa sono riconosciute se delimitate da apici:
c=’tabella’
La stringa è memorizzata come un vettore di caratteri, ogni componente del vettore
contiene il numero intero corrispondente al codice ASCII del carattere. Sfruttando le
potenzialità nella gestione di matrici, sulle stringhe si possono effettuare operazioni di
concatenazione, estrazione di una sottostringa, e confronto tra stringhe.
Anche sulle stringhe vi sono funzioni predefinite, tra cui ad esempio:
Alcune funzioni relative a stringhe
num2str
int2str
str2num
eval(stringa)
feval(f,x)
Converte da numero a stringa
Converte da intero a stringa
Converte da stringa a numero
Valuta una stringa come comando matlab
Valuta una funzione f data come stringa nel punto x
In alcuni casi ad esempio è utile convertire un risultato numerico in una stringa di caratteri
e viceversa. Il programma:
r=2.5; area=pi*r^2;
t=[‘il cerchio di raggio’,num2str(r),’ha area’,num2str(area)];
disp(t)
produce:
il cerchio di raggio 2.5 ha area 19.36
Input-output
Per definire il valore di una variabile oltre all’assegnazione si può usare il comando input
che visualizza un testo sullo schermo, aspetta che l’utente digiti un valore che registra
nella variabile specificata:
x=input(‘valore di x’)
6
>> n=input('digita il valore di n')
digita il valore di n 6
n=
6
>> b=input('digita array b')
digita array b [1 2 3 5]
b=
1 2 3 5
Il comando disp visualizza il valore di una variabile.
>> disp(n)
6
>> disp(b)
1 2 3 5
>> disp('testo')
testo
E’ spesso utile salvare e leggere da disco dati e variabili sotto forma di file sia in ambiente
Matlab che leggibili dall’esterno con programmi scritti in altri linguaggi.
In ambiente Matlab vi sono i comandi save e load:
w=0:0.1:10;
save dati.mat w
clear all
In tal modo si sono cancellate tutte le variabili tranne w, che è memorizzata in formato
matlab nel file binario dati.mat. Per ricaricare w in memoria basta il comando load dati.
Il comando delete nomefile cancella un file, mentre il comando type nomefile visualizza un
file. Il comando save ha delle opzioni che consentono di salvare dati in formato diverso da
quello binario, utili per dati condivisi con programmi scritti in altri linguaggi:
save dati.dat -ascii
salva dati in formato ASCII con 8 cifre
save dati.dat -ascii -double
salva dati in formato ASCII con 16 cifre
Si possono leggere file scritti con programmi diversi dal matlab, ad esempio excel. I
comandi per leggere diversi tipi di file sono nella tabella seguente:
Tipo di dato Lettura
scrittura
Excel .XLSX xlsread
xlswrite
Testo .TXT
dlmread
dlmwrite
Immagine
imread
imwrite
audio
.AU .WAV
auread
wavread
auwrite
wavwrite
Film .AVI
aviread
Funzioni matematiche
Il Matlab possiede molte funzioni matematiche predefinite. Molte di esse possono essere
applicate anche a variabili matriciali. Tra le più usate vi sono:
abs(x) = valore assoluto, sqrt(x) = x , sign(x) = segno di x , sin(x) = sen(x), cos(x) =
cos(x) , tan(x) = tang(x) , exp(x) = ex , log(x) = log(x) .
7
Il Matlab inoltre consente una semplice gestione dei polinomi. Un polinomio è identificato
dai suoi coefficienti memorizzati in un vettore. Ad esempio il polinomio p(x)=x2+2x+3 è
identificato da:
p=[1 2 3]
vettore dei coefficienti di p(x)
Il valore y del polinomio in uno o più punti x è dato dalla funzione:
y=polyval(p,x)
che memorizza in y i valori del polinomio di coefficienti p nei punti x:
>>p=[1 2 3];x= 0 :5 ;
>>y=polyval(p,x)
y=
3 6 11 18 27 38
Per definire una funzione non predefinita si può usare il comando inline:
>> f=inline(‘1/(1+x)’)
f=
inline function:
f(x)=1/(1+x)
>> y=f(1)
y=
0.5
Un altro modo per definire una funzione non predefinita è l’ anonymous function , che è
una function che si definisce direttamente in uno script:
>>f=@(x)(1./(1+x))
f=
@(x) )(1./(1+x))
>>y=f(1)
y=
0.5000
Operazioni su array
Il Matlab prevede le operazioni di tipo vettoriale, nel senso che sono definite su operandi
che non sono scalari, ma vettori.
Operazioni elementari
Le operazioni elementari in Matlab sono operazioni vettoriali, ossia gli operandi sono
matrici e vettori.
Le operazioni elementari previste sugli array sono:
+
*
^
’
\
/
Addizione
Sottrazione
Moltiplicazione righe-colonne
Elevamento a potenza
Trasposta di una matrice AT
Divisione a sinistra
Divisione a destra
Ad esempio :
>>x=[1:4];
>>y=[1:2];
8
>>z=[1 2 3 4];
>>x+z
somma vettori riga
ans =
2468
>> x+y
produce il messaggio di errore
??? error using = = > +Matrix dimension must agree
>>x*y
produce il messaggio di errore
??? error using = = > *Inner matrix dimension must agree
Si può infatti effettuare il prodotto scalare * solo tra un vettore riga ed uno colonna della
stessa dimensione:
>> x*z’
ans =
z’ vettore colonna trasposto di z
30
>> a=[1 2;3 4];b=[5 6;7 8];
>> c=a*b
prodotto righe per colonne
c=
19 22
43 50
I simboli precedenti rappresentano anche le usuali operazioni su scalari.
Date due matrici A e B con lo stesso numero di righe, la notazione X= A\B, con A
quadrata, denota la matrice X contenente i vettori soluzioni del sistema a più colonne
AX=B (algoritmo di Gauss con pivoting). Se A e B (quadrata) hanno lo stesso numero di
colonne si ha che X=A/B=A*inv(B), dove inv è la funzione che calcola l’inversa di B.
E’ anche possibile eseguire operazioni aritmetiche su matrici componente per
componente, facendo precedere l’operatore da un punto, ad esempio:
C=A .* B ⇒ ci,j = ai,jbi,j , i,j=1,…,n.
Inoltre è ammesso l’utilizzo di operazioni su variabili complesse :
>> a=3+2i;
>> b=3.2+2.3i;
>>a+b
ans=
6.2000 + 4.2000i
Operatori relazionali
Su ogni tipo di dato dotato di ordinamento naturale sono definiti i seguenti operatori:
<
>
<=
>=
==
∼=
minore
maggiore
minore o uguale
maggiore o uguale
uguale
non uguale
Il risultato delle operazioni precedenti è 0 (falso) ,1 (vero).
9
Applicati ad array (di uguale dimensione) confrontano gli elementi uno ad uno, se si
confronta un array con uno scalare sono confrontati tutti gli elementi con lo scalare. Il
risultato è un array di elementi uguali a 0 o ad 1.
>> x=[5 4 9];
>> y=[14 3 9];
>> z=x>y
z=
0 1 0
>> z=x= =y
z=
0 0 1
>> eps+1= =1
ans =
0
>> 1+eps/2= =1
ans =
1
>> z=x(x>y) elementi di x maggiori dei corrispondenti elementi di y
z=
4
Ad esempio si vuole generare una tabella di valori di f(x) in [0,3π] con f(x)=cos(x), se
cos(x)>0, altrimenti f(x)=0:
>>x=0:pi/20 :3*pi;
>>y=cos(x);
>>y=y.*(y>0);
>>[x’ y’]
L’espressione y>0 genera un vettore con 1 dove cos(x)>0 e 0 altrimenti.
Operatori logici
Il Matlab, associando al valore 0 FALSO ed al valore 1 VERO, consente di usare variabili
di tipo logico, anche non definite esplicitamente, mediante i seguenti operatori:
∼a not array di 1 se gli elementi di a sono 1,altrimenti di 0
a&b and array di 1 se gli elementi di a e b sono≠ 0,altrimenti di 0
a|b or array di 1 se almeno uno dei corrispondenti elementi di a e b
è ≠ 0,di 0 se entrambi sono nulli
>> z=5>3|4==7
z
1
>> x=[5 -2 0 0]&[5 7 0 3]
x=
1 1 0 0
Per le variabili di tipo logico sono definite delle funzioni, tra cui:
funzioni di tipo booleano
10
any(A)
all(A)
find(A)
isempty(A)
Vero se almeno un elemento di A è #0
Vero se tutti gli elementi di A sono #0
Indici degli elementi #0
Vero se A è vuoto, falso altrimenti
Ad esempio, se A è una matrice [i,j]=find(A) dà le righe e le colonne degli elementi #0; si
può usare anche con una condizione logica, dà gli indici degli elementi che la soddisfano.
>> x=[3 0 5 7];
>> z=find(x)
z=
1 3 4
>> z=find(x>3)
z=
3 4
>> y=[1 2 4 7];
>> z=find(x>y)
z=
1 3
Cell array, structure array, Map object
In Matlab esistono tipi di dati strutturati : cell array, structure array, Map object.
Un cell array è un array in cui ogni elemento è una cella che a sua volta può contenere
un array. In questo modo si possono raggruppare tipi diversi di array. Un cell array si
può creare direttamente con un’assegnazione tramite indicizzazione delle celle :
>> C(1,1)={'esame'};
>> C(1,2)={'18/2/08'};
>> C(2,1)={30};
>> C(2,2)={'calcolo numerico'};
>> C
C=
'esame' '18/2/08'
[ 30] 'calcolo numerico'
>> C(2,2)={'calcolo numerico,algebra'};
>> C(2,1)={[30 23]};
>> C
C=
'esame'
'18/2/08'
[1x2 double] [1x24 char]
Per visualizzare il contenuto dell’array:
>> celldisp(C)
C{1,1} =
esame
C{2,1} =
30 23
C{1,2} =
18/2/08
C{2,2} =
calcolo numerico,algebra
11
Per visualizzare il contenuto di una cella:
>> C{2,2}
ans =
calcolo numerico,algebra
Per individuare una cella:
>> C(2,2)
ans =
'calcolo numerico,algebra'
Un array di strutture è formato da strutture e consente di memorizzare dati di tipo
diverso. Una struttura è una serie di dati di natura diversa. Un array di strutture è un
insieme di strutture sotto lo stesso nome. Per accedere agli elementi si usano i nomi dei
campi. Per inizializzare e dare i valori si assegnano semplicemente i valori ai campi:
>> studente.nome='Mario Rossi';
>> studente.matricola='34001234';
>> studente.voti=[18 21 25];
Ho creato una struttura di nome studente con tre campi. Per espanderlo ad array:
>> studente(2).nome='Carlo Esposito';
>> studente(2).matricola='34001235';
>> studente(2).voti=[23 27 24];
Digitando il nome dell’array ottengo:
studente =
1x2 struct array with fields:
nome
matricola
voti
Per accedere agli elementi di un campo:
>> studente(1).voti(2)
ans =
21
Per aggiungere un campo all’array:
>> studente(1).telefono='081233456';
>> studente
studente =
nome
matricola
voti
telefono
Per cancellare un campo:
>> studente=rmfield(studente,'telefono')
studente =
nome
matricola
12
voti
E’ possibile applicare gli operatori e le funzioni di Matlab in modo tradizionale :
>> max(studente(1).voti)
ans =
25
>> mean(studente(2).voti)
ans =
24.6667
MAP Objet
Struttura contenitore di altri dati. Simile ad un array tranne che per il modo di indirizzare i
dati. L’indice, invece di essere un intero, può essere di vario tipo, come una stringa di
caratteri. Un oggetto Map consiste di una chiave(indice) e di un dato corrispondente. Ad
esempio per creare un oggetto Map che associa agli Stati Europei le Capitali:
>> Europa=containers.Map({'Italia','Francia', ‘Inghilterra’},{'Roma','Parigi',’Londra’})
Europa =
containers.Map handle
Package: containers
Properties:
Count: 3
KeyType: 'char'
ValueType: 'char'
Methods, Events, Superclasses
>> values(Europa,{'Italia'})
ans =
'Roma'
Vi sono molte funzioni che si possono usare sugli oggetti Map.
Funzioni elementari di array
Il Matlab possiede molte funzioni elementari che consentono di manipolare matrici e
vettori e di risolvere alcuni tra i principali problemi di algebra lineare, come ad esempio il
calcolo del determinante, dell’inversa di una matrice, del rango di una matrice, e così via.
Alcune funzioni di vettori e matrici
det(A)
rank(A)
inv(A)
eig(A)
lu(A)
diag(A)
Determinante di A
Rango di A
Inversa di A
Autovalori ed autovettori di A
Fattorizzazione PA=LU
Crea una matrice diagonale da un vettore o
13
estrae diagonali da una matrice
triu(A),tril(A)
Estrae il triangolo superiore o inferiore da A
sum(A)
Somma degli elementi di un vettore; applicato ad
una matrice dà un vettore con la somma delle colonne
max(A),
Max(min) degli elementi di un vettore; applicato ad
min(A)
una matrice dà un vettore con il max(min) delle colonne
norm(A)
Calcola la norma2 di A
cond(A)
Calcola l’indice di condizionamento di A
diff(x)
Vettore delle differenze tra elementi successivi di x
length(A),size(A) Dimensione di un vettore o di una matrice
spy(A)
Visualizza una matrice sparsa
>> A=[1 2 3;4 5 6;7 8 9];
>> [m,n] = size(A)
m=
3
n=
3
>>d=diag(A)
d=
1
5
9
>>c=diag(d)
c=
100
050
009
>> A=eye(4)+diag(3*ones(3,1),1)+diag(2*ones(3,1),-1)
A=
1 3 0 0
2 1 3 0
0 2 1 3
0 0 2 1
>> a=[1 2 3;4 5 6;7 8 9];
>> m=max(max(a))
m=
9
>> A=[1 2;3 4]; det(A)
ans=
-2.0000
>> B=inv(A)
B=
-2.0000 1.0000
-0.5000
Se A è singolare si ha un messaggio di errore e l’output contiene la variabile inf:
>> A=[0 0;0 1];inv(A)
warning: matrix is singular to working precision
14
ans=
inf inf
inf inf
Matlab come linguaggio di programmazione
Il Matlab, oltre ad essere usato in modalità immediata, può essere usato per scrivere
programmi, in cui possono essere usate tutte le funzioni interne. E’ quindi dotato di un
linguaggio di programmazione molto flessibile e semplice da usare.
Costrutti di controllo
I costrutti di controllo ( che regolano il flusso di istruzioni) previsti dal Matlab sono i
seguenti:
for ind=iniz:passo:fin si ripetono le istruzioni per ogni valore assunto
istruzioni
da ind a partire da iniz fino a fin con incremento
end
passo (se omesso vale 1)
for k =1:n
for m = 1:n
A(k,m)=0;
end
end
Si può usare un vettore per indicizzare il ciclo. Ad ogni passo del ciclo, l’indice del for
conterrà il valore successivo del vettore.
>> w=[3 1 9 2 6 2 3];v=[1 3 4];
>> for k=v
x(k)=w(k);
end
>> x
x=
3
0
9
2
Attenzione all’utilizzo di i e j come variabili di ciclo, in quanto rappresentano in Matlab
l’unità immaginaria.
while espressione logica
istruzioni
le istruzioni sono ripetute fino a che
espressione
logica è vera,altrimenti sono saltate
end
if
n=0;
while n < = k
n=n+1;
end
espressione logica
istruzioni 1
se espressione logica è vera si eseguono
istruzioni1,se è
falsa si saltano
end
if x<0
15
disp(‘x negativo’)
end
if espressione logica
se espressione logica è vera si eseguono
istruzioni1,se è falsa istruzioni2;
istruzioni 1
alla fine di ogni blocco istruzioni si va
else
ad end.
istruzioni2
end
if n = = k
x(n)=a;
else
x(n)=b;
end
if
espressione logica 1
se espressione logica1 è vera si eseguono
istruzioni1,se è falsa si testa espressione
istruzioni 1
logica2: se è vera si eseguono
elseif espressione logica2 istruzioni2 se è falsa istruzioni3; alla fine di
istruzioni2
ogni blocco istruzioni si va ad end.
else
istruzioni3
end
switch expr
case valore 1
istruzioni
case valore2
istruzioni
...
otherwise
istruzioni
end
switch a
case 2
y=2*a;
case 3
y=3*a;
case 5
y=5*a;
otherwise
y=a;
end
Il comando break consente l’uscita da un ciclo for o while:
for k= 1:10
x=50-x^2
if x<0 , break, end
16
end
Il comando error(‘testo’) scrive un messaggio ed arresta i calcoli.
Si possono digitare più comandi sulla stessa linea separati da
indicano la continuazione di un comando sulla linea successiva.
; mentre tre punti …
Script files e function files
Appare evidente l’esigenza di salvare su file un programma, con un’eventuale passaggio
di parametri di input-output, così da poterlo eseguire più volte per dati diversi, o modificare
senza doverlo riscrivere. Si chiamano M-files i files contenenti programmi scritti in
linguaggio Matlab. Gli M-files devono avere un’estensione .m. Un M-file può richiamare se
stesso .
Per creare un M-files si usa l’Editor/Debugger. Si seleziona New> M-file dal menù File
della finestra comandi; a questo punto si apre la finestra dell’editor, nella quale si digita, ad
esempio, il seguente programma, che calcola il fattoriale di n:
>> n=input(‘valore di n’)
>>k=n;fatto=k;
>>while k>2
k=k-1,
fatto=fatto*k;
>> end
>>disp(‘fattoriale’)
>>disp(n)
Dopodichè lo si salva in un m-file, ad esempio fattoriale.m. Per eseguire il programma
basta semplicemente digitare il suo nome nella finestra comandi:
>>fattoriale
>>valore di n 4
n=
4
fattoriale
24
Gli M-files si dividono in:
script files
function files
non hanno parametri di input/output
hanno parametri di input/output
Gli script files sono files scritti in linguaggio Matlab e memorizzati su memoria di massa.
Contengono una sequenza di comandi che sono interpretati ed eseguiti sequenzialmente
quando si digita il nome del file (senza l’estensione .m). Operano sulle variabili nel
Workspace.
Il seguente programma scrive una tabella di valori di 2exsinx in (0.5,3) ed è memorizzato
nello script file tabella.m:
x=linspace(0.5,3,10);
y=2*exp(-x).*sin(x);
z=[x;y];
17
fprintf('ascisse\tvalori funzione\n\n'),
fprintf('%6.2f\t%10.5e\n',z);
digitando il nome del file si ottiene:
>> tabella
Ascissa valori funzione
0.50
0.78
1.06
1.33
1.61
1.89
2.17
2.44
2.72
3.00
5.81573e-001
6.44756e-001
6.05640e-001
5.12400e-001
3.99007e-001
2.87305e-001
1.89632e-001
1.11424e-001
5.35274e-002
1.40519e-002
contengono anch’essi una sequenza di comandi Matlab, ma
I function files
rappresentano delle “procedure” e, come tali, prevedono parametri di input e di output. Il
nome della function deve essere uguale al nome dell’ M-file che la contiene. La prima linea
del file deve contenere la dichiarazione:
function [ ou1,…,outn] = nome(in1,..,inn)
dove:
function = nome chiave che identifica il file come function
nome = nome della function(uguale al nome del file che la contiene)
out1,..,outn = parametri di output
in1,..,inn = parametri di input
Se vi è un solo parametro di output si omettono le parentesi quadre.
La function verrà richiamata tramite:
[ ou1,…,outn] = nome(in1,..,inn)
Il ritorno al programma chiamante avviene dopo l’esecuzione dell’ultimo comando
contenuto nel function file o quando si incontra l’istruzione di return.
All’atto della prima chiamata la function è compilata ed opera su variabili locali , che
esistono solo al suo interno. Le variabili nel workspace non sono in genere accessibili alla
function, a meno che non siano dichiarate globali con il comando global che va inserito
prima di chiamare la function e all’interno di essa prima di ogni istruzione eseguibile.
Gli argomenti di input che sono modificati all’interno della function sono passati per valore,
ossia la modifica non si riflette quando si torna al workspace, a meno che non siano anche
di output, mentre se non sono modificati vengono passati per indirizzo.
Un’altra differenza sostanziale tra uno script file ed un function file è che, mentre uno script
file è reinterpretato ad ogni chiamata, un function file è compilato alla prima chiamata e
memorizzato per tutta la durata della sessione, consentendo una esecuzione più rapida.
Esempio di function file per il calcolo di n!, memorizzato nel file fatto.m:
function nfat=fatto(n)
18
%funzione che calcola il fattoriale di n
%parametri di ingresso:
%n= valore di cui si vuole il fattoriale
%parametri di uscita
%nfat= fattoriale di n
k=n; nfat=k;
while k>2
k=k-1;
nfat=nfat*k;
end
Il carattere % identifica una linea di commento. I commenti inseriti all’inizio sono mostrati
digitando help fatto.
Un programma per il calcolo del coefficiente binomiale n!/[k!(n-k)!] è:
>> n=input('valore di n');
valore di n 4
>> k=input('valore di k');
valore di k 3
>> a=fatto(n);b=fatto(k);c=fatto(n-k);
>> binom=a/(b*c)
binom =
4
Due variabili interne interessanti sono nargin e nargout che contano rispettivamente il
numero di parametri di ingresso e uscita di una funzione, consentendo di scrivere funzioni
con numero variabile di parametri, caratteristica questa di molte funzioni interne Matlab.
Ad esempio una funzione che calcola la successione:
n>1
xn+1 = 3xn +1
con x1 intero ed il numero di termini che può essere fissato nel programma chiamante o di
default dalla funzione è:
function x = succ(x1,N)
% il parametro N è opzionale,se omesso N=100
if nargin= =1
N=100;
end
x=zeros(N,1);
x(1)=x1;
for k=1:N-1
x(k+1)=3*x(k)+1;
end
Un file .m può contenere i codici di più function. La funzione primaria è la prima
funzione in un file .m , che ha il nome del file. All’interno dello stesso file si possono
scrivere più sottofunzioni, sono richiamabili solo dalla funzione primaria e dalle altre
sottofunzioni dello stesso file. Il vantaggio è nella riduzione di file .m e quindi dei tempi di
esecuzione della funzione primaria, e anche nella più semplice “lettura” del codice
completo.
19
Il Matlab è un linguaggio ricorsivo, ossia una function può richiamare se stessa. Ad
esempio una function ricorsiva per calcolare n! è:
function y=fact(n)
if n>1
y=n*fact(n-1);
else
y=1;
end
Cell Mode
Il Cell Mode è un’utility che consente di dividere un M-file in sezioni, dette celle, che
possono essere eseguite singolarmente. Ciò è utile nello sviluppo di un programma sia in
fase di debug che di test. Per attivare il cell mode si seleziona sulla barra menù dell’editor:
cell→Enable Cell Mode. Per dividere il programma in celle si usa il divisore di celle che è il
simbolo %% seguito da blank. Si ottiene ad esempio:
Esegue la cella corrente.
Esegue la cella corrente e avanza alla successiva.
Il Matlab dalla v.7 consente di convertire un file.m in un documento formato HTML,Word,
pdf, PowerPoint,…. Se il file è strutturato in cell mode si può da esso ottenere un
documento strutturato in modo che è stampata ogni cella con il relativo output grafico
tramite il comando :
publish(‘nomefile’,’formato’).
Di seguito vi è un esempio di documento ottenuto in formato HTML e pdf.
Function Handle
Un tipo di dato standard presente dalla v.6.5 è il function handle(@), simile ad un
puntatore del C++ ma più generale. Si genera un handle alla funzione che contiene il path
della funzione, permette di richiamarla indirettamente, memorizza tutte le informazioni per
eseguire la funzione e si può utilizzare come gli altri tipi di dati. Il vantaggio è nella
velocità di esecuzione e nell’aumento delle prestazioni per le operazioni ripetute o i cicli.
La sintassi per generare un handle alla funzione è:
handle=@nome-function
handle=@(arg)anonymous function
>>h=@sin; %h=nome dell’handle alla function sin
>>h(34.5)
ans=
0.0575
Il function handle è inoltre la tecnica ottimale per passare una function come parametro di
input di un’altra function:
function m=somf(fun,x)
y=fun(x)
%calcola la media dei valori di una funzione fun nei punti x
m=sum(y)/length(y);
x=0:0.1:1;
M=somf(@exp,x)
M=
1.7465
%media della funzione esponenziale
Media della funzione f = 1./(1+x), definita nel function file f.m e con una anonymous
function:
m=somf(@f,x)
21
m=
0.7047
media=somf(@(x)(1./(1+x)),x)
media=
0.7047
Programmare in Matlab
Il Matlab è stato ideato per svolgere rapidamente calcoli vettoriali. Il suo uso ottimale infatti
non consiste nello scrivere programmi come con un qualsiasi linguaggio di
programmazione, ma nello sfruttare le sue potenzialità nel gestire le matrici e nell’usare le
numerose funzioni interne, così da svolgere molti calcoli con pochi comandi ed in tempo
minore.
Consente una scrittura codice 50 volte più veloce che in C o C++ ,e un codice 10 volte
più veloce che in C o C++ (NASA ).
Per massimizzare la performance dei codici :
vettorizzare il codice
preallocare gli array di lunghezza fissa
evitare variabili non necessarie
gestire gli array per colonne
usare function e non script
Il prodotto scalare della riga i di una matrice per un vettore colonna x scritto in maniera
poco efficiente è:
>> som=0;
>> for j=1 :n
som=som+a(i,j)*x(j);
>>end
Scritto eliminando l’inutile ciclo che opera a livello scalare diventa:
>> som=a(i,:)*x
Di seguito vi sono alcuni esempi con la valutazione dei tempi di codici ottimali e non.
Vettorizzazione del codice:
>> tic
k=0;
for t=0:0.1:10
k=k+1;
y(k)=exp(t)*cos(3*t);
end
>>toc
Elapsed time is 1.532000 seconds.
>> tic
x=[0:0.1:10];
y=exp(x).*cos(3*x);
>>toc
Elapsed time is 0.210000 seconds.
function [somma,som]=testsomma(a)
profile on
%fa partire profile
n=length(a);
somma=som1(a,n);
22
som=som2(a);
profile viewer
%genera profile report e lo visualizza
%sottofunzione som1
function somm=som1(a,n)
somm=0;
for k=1:n
somm=somm+a(k);
end
%sottofunzione som2
function som=som2(a)
som = sum(a);
>>a=rand(1000000,1);
>> [somma,somma1]=testsomma(a);
Si ottiene il profile summary, che dà informazioni sui tempi delle varie function richiamate:
Preallocazione di array:
% script file mem.m
n=10e3; x(1)=1000; %test senza allocazione memoria
for k=2:n
x(k)=1.05*x(k-1);
end
%script file mem1.m
n=10^3;x=zeros(n,1); %test con allocazione memoria
x(1)=1000;
for k=2:n
x(k)=1.05*x(k-1);
end
>> t=cputime;
>> mem
>> cputime-t
ans =
0.6309
>> t=cputime;
>> mem1
>> cputime-t
ans =
0.2804
23
Evitare variabili non necessarie:
%script file testtempi1.m , variabile non necessaria
n=3000;
x=randn(n);
y=x*1.2;
%script file testtempi2.m , in place
n=3000;
x=randn(n);
x=x*1.2;
>> t=cputime;
>> testtempi1;
>> cputime-t
ans =
2.2532
>> t=cputime;
>> testtempi2;
>> cputime-t
ans =
2.0129
Gestire gli array per colonne:
% script file test righe.m , non è un programma ottimale !
n=3000;x=rand(n);y=zeros(n);
for r=1:n %per righe
for c=1:n
if x(r,c)>0
y(r,c)=x(r,c);
end
end
end
% script file test colonne.m , non è un programma ottimale !
n=3000;x=rand(n);y=zeros(n);
for c=1:n %per colonne
for r=1:n
if x(r,c)>0
y(r,c)=x(r,c);
end
end
end
>> t=cputime;
>> testrighe;
>> cputime-t
ans =
7.3205
>> t=cputime;
>> testcolonne;
>> cputime-t
24
ans =
2.4435
Grafica in MATLAB
Il Matlab consente di tracciare in maniera molto semplice grafici bidimensionali e
tridimensionali. Inoltre, una volta creato un grafico, si può modificarlo, aggiungere testi,
frecce, linee, ruotarlo o effettuarne uno zoom mediante Plot editor , che è una interfaccia
grafica molto semplice da usare e si può avviare direttamente dalla finestra grafica.
Grafica a due dimensioni
Il grafico di una funzione f(x) è l’insieme dei punti del piano (x,y) con x∈[a,b] e y=f(x). Su
di un computer tale insieme infinito e continuo non si può rappresentare e va sostituito con
insiemi finiti e discreti. In un grafico bidimensionale in Matlab si rappresentano i punti:
(xi,yi) i=1,..,n
discretizzazione della curva, con a=x1<x2<…xn =b e yi=f(xi) .
Il comando per tracciare un grafico bidimensionale è : plot(x,y)
1
0.8
0.6
>>x=linspace(-pi,pi,100);
>>y=sin(x);
>>plot(x,y)
Produce il grafico della funzione sin(x).
0.4
0.2
0
-0.2
-0.4
-0.6
-0.8
-1
-4
-3
-2
-1
0
1
2
3
4
Vi sono molte funzioni che consentono di gestire grafici sulla stessa finestra, di modificare
colore e tratto, di inserire un titolo,una griglia, di assegnare gli assi (axis), etc:
>> x=1:0.1:5;
>> p=[1 2 3];
>>y=polyval(p,x);
>> plot(x,y)
>>title(‘grafico del polinomio’);
>>xlabel(‘assex’);
>>ylabel(‘polinomio’);
>>grid
Su una stessa finestra si possono rappresentare più curve con colori e tratti diversi. Il
seguente programma traccia il grafico di sen(x) con linea rossa e simbolo o, e di cos(x)
con linea verde e simbolo * .
>> x=linspace(-pi,pi,100);
>>y=sin(x);z=cos(x) ;
>>plot(x,y,’ro‘,x,z,’g *’)
25
Il comando subplot divide la finestra grafica in più finestre ed in ognuna traccia un grafico:
subplot(m,n,p) divide la finestra in un array m×n di sottofinestre,p è la finestra corrente:
>> x=linspace(-pi,pi,100); y=sin(x);z=cos(x) ;
>> subplot (2,1,1),plot(x,y) ;title(‘senx’);
>> subplot (2,1,2),plot(x,z) ;title(‘cosx’);
Nella figura seguente vi sono tutti i possibili tipi di grafici in due dimensioni:
Curve parametriche
Una curva parametrica è espressa in funzione di un determinato parametro.
La maniera più semplice ed intuitiva per descrivere una curva nel piano è quella di
considerarla come traiettoria di un punto che si muove in un intervallo di tempo(punta della
matita del disegnatore). All’istante t in un intervallo [a,b] di tempo il punto si trova nella
posizione P(t)=(x(t),y(t)); per descrivere il moto di P basta definire x(t),y(t), e la curva sarà
costituita da tutti i punti P(t), tε[a,b], parametro. Le equazioni parametriche della curva :
x=x(t)
y=y(t)
tε[a,b]
Nelle applicazioni sono spesso utilizzate curve e superfici rappresentate in forma
parametrica. Ciò consente semplici ed eleganti procedure di calcolo al computer, e
presenta notevoli vantaggi, tra cui la possibilità di rappresentare curve chiuse o intrecciate,
la possibilità di preservare proprietà di invarianza geometrica utili nella computer graphic(
ad esempio le routines di base per il linguaggio PostScript, in cui semplici trasformazioni
geometriche corrispondono a stili e dimensioni diverse). Alcune forme geometriche sono
esprimibili solo in forma parametrica, ed è la relazione tra i punti dell’oggetto a determinare
la forma.
26
%cerchio di centro(2,2)e raggio 3.5
>> t=linspace(0,2*pi,200);
>> x=2+3.5*cos(t);
>> y=2+3.5*sin(t);
>> plot(x,y)
>> axis square
6
5
4
3
2
1
0
-1
-2
-2
-1
0
1
2
3
4
5
6
Grafica a tre dimensioni
Si può fare il grafico di:
Traiettorie
Superfici
Solidi
Nella figura seguente vi sono i possibili tipi di grafici in tre dimensioni.
Le linee nello spazio a 3 dimensioni si possono rappresentare con:
plot3(x,y,z)
>> t=0:pi/50:10*pi;
>> plot3(sin(t),cos(t),t)
40
30
20
10
0
1
0 .5
1
0.5
0
0
-0.5
-0.5
-1
-1
Il grafico di una superficie z = f(x,y) è definito come l’insieme dei punti del piano (x,y,z) con
x∈[a,b], y∈[c,d] e z=f(x,y). Bisogna discretizzare il grafico:
27
(xi,yi,zi,j) i=1,..,m;j=1,..,n
discretizzazione
a=x1<x2<…xm =b; c=y1<y2<…ym =d (reticolo o griglia) e zi,j=f(xi,yj). Per generare il reticolo
si usa il comando meshgrid:
>> x=linspace(0,1,50);y=linspace(0,1,50);
>> [X,Y]=meshgrid(x,y) ;
La funzione f sarà valutata in corrispondenza delle matrici X,Y: per tracciarne il grafico si
può usare il comando mesh :
0.5
>> x=-2:0.25:2;
>> y=-1:0.2:1;
>> [X,Y]=meshgrid(x,y);
>> z=X.*exp(-X.^2-Y.^2);
>> mesh(X,Y,z)
0
-0.5
1
0.5
2
1
0
0
-0.5
-1
-1
-2
Vi sono molti altri comandi, ad esempio:
0.5
>> x=-2:0.25:2;
>> y=-1:0.2:1;
>> z=X.*exp(-X.^2-Y.^2);
>>surf(X,Y,z)
0
-0.5
1
0.5
2
1
0
0
-0.5
-1
-1
>> x=-2:0.25:2;
>> y=-1:0.2:1;
>> z=X.*exp(-X.^2-Y.^2);
>> ribbon(z)
-2
0.5
0
-0.5
15
20
10
15
10
5
5
0
0
Si possono ottenere grafici più raffinati con i comandi:
colormap cambia la colorazione
shading cambia l’ombreggiatura
view
cambia l’orientamento
lighting cambia l’illuminazione
10
material cambia il materiale
colorbar inserisce barra colori
5
>> p=peaks;
>> surfl(p);shading interp
0
-5
-10
60
50
40
40
30
20
20
0
10
0
28
0.9
10
>> surfl(p);shading interp
>> colormap(cool);colorbar
0.8
0.7
5
0.6
0
0.5
-5
0.4
0.3
-10
60
0.2
50
40
40
0.1
30
20
20
10
0
0
Si possono poi ottenere grafici a barra, istogrammi e grafici a torta:
grafico a barre
3
x=randn(100,1);subplot(2,1,1);bar(x)
axis([0 100 –3 3]);
title(‘grafico a barre’);
n=hist(x);subplot(2,2,3);bar(n)
title(‘istogramma’);
subplot(2,2,4);pie3
2
1
0
-1
-2
-3
0
10
20
30
40
50
60
70
80
90
100
istogram m a
25
grafic o a torta
20
4% 10%
1%
2%
6%
15
21%
9%
10%
10
18%
19%
5
0
1 2 3 4 5 6 7 8 9 10
Il comando imagesc genera un grafico a densità di colore variabile, cioè una
rappresentazione nel piano di funzioni di 2 variabili dove lo stesso valore corrisponde allo
stesso colore. Molte funzioni producono immagini interessanti e decorative, come si vede
dagli esempi seguenti.
x=-0.5:0.005:.5;y=x;
[X,Y]=meshgrid(x,y);
Z=X.^2+Y.^2;
imagesc(Z);
shading interp
axis('equal','square','off')
Si può applicare ad una matrice:
>> imagesc(hadamard(20))
>> colormap(winter) ;axis('equal','off')
29
Se i nodi non sono distribuiti su una griglia cartesiana, non sono equispaziati o sono
casuali(misurazioni), ad esempio bisogna disegnare
disegnare la superficie di un monte partendo
da misure sperimentali delle altitudini in punti che non corrispondono a una griglia
cartesiana, non si può usare mesh ma bisogna generare una griglia non strutturata. Il
Matlab ha delle funzioni che costruiscono una
una mesh di triangoli e disegnano una
superficie partendo da essi : delaunay,trimesh.
delaunay,trimesh
Esempio : (x,y,z) = misure sperimentali.
load seamount
figure(1);plot3(x,y,z,'.','markersize',5);
xlabel('longitudine');ylabel('latitudine');
tri=delaunay(x,y);
figure(2);trimesh(tri,x,y,z);
0
0
-1000
-1000
-2000
-2000
-3000
-3000
-4000
-4000
-5000
-47.8
-5000
-47.8
-48
-48
211.8
211.4
-48.6
-48.6
211
210.8
211.2
-48.4
211.4
211.2
-48.4
latitudine
211.8
211.6
-48.2
211.6
-48.2
211
210.8
longitudine
Si possono poi generare solidi:
>>t=0:pi/10:2*pi;
>>cylinder(2+cos(t)
1
0.8
0.6
0.4
0.2
0
4
2
4
2
0
0
-2
-2
-4
>> cylinder(2+cos(t));
>> shading interp
%modifica il tipo di materiale
-4
>> material dull
>> colormap(winter)
>> axis off
Menù a pulsanti
Per creare un semplice menù a pulsanti si può usare la funzione menu:
scelta=menu('intestazione','pulsante1','pulsante2', …)
%Script file sceltamenu
scelta=menu('scegliunafunzione','sin','cos', 'exp','fine');
if scelta==1
x=0:0.1:2*pi;y=sin(x);
plot(x,y);
elseif scelta==2
x=0:0.1:2*pi;y=cos(x);
plot(x,y);
elseif scelta==3
x=0:0.1:2;y=exp(x);
plot(x,y);
elseif scelta==4
close all;
cancella tutte le figure
return;
ritorna alla command window
end
clear scelta;
sceltamenu
nome dello script che contiene il programma
Ho cliccato
su exp
Modifica di un oggetto grafico da programma
Si possono modificare le proprietà degli oggetti creati da plot:
plot(...,'PropertyName',PropertyValue,...)
dove 'PropertyName' è
LineWidth
ampiezza linea
MarkerEdgeColor colore marker o bordo marker
MarkerFaceColor colore di riempimento marker
MarkerSize
ampiezza marker
x = -pi:pi/10:pi;
y = sin(x);
plot(x,y,'--rs','LineWidth',2,'MarkerEdgeColor','k','MarkerFaceColor','g', 'MarkerSize',10)
1
0.8
0.6
0.4
0.2
0
-0.2
-0.4
-0.6
-0.8
-1
-4
-3
-2
-1
0
1
2
3
4
Per creare più figure basta anteporre al comando di disegno figure(k),per chiudere tutte
le figure:close all.
Si può modificare in modo più sofisticato l’aspetto di una finestra grafica (colore
sfondo,spessore linee,grandezza e tipo caratteri,assi,titolo, …)e dei grafici in essa
presenti da programma, così da non perdere le modifiche al grafico di base, cosa che
avviene se si modifica in modo interattivo dalla finestra grafica.
Il Matlab ha una gestione dei grafici object-oriented, cioè lo schermo è un albero in cui
ogni nodo è un oggetto, proveniente da un nodo padre e che ha nodi figli(children),a cui
si accede tramite puntatore (handle) ed a cui sono associate delle proprietà modificabili.
La finestra grafica(Figure) attiva è individuata dal puntatore gcf (graphic current
figure).Le proprietà di un oggetto Figure sono ad esempio la posizione, il colore di
sfondo,le dimensioni… Per vederle tutte:
get(gcf)
I figli di un oggetto Figure sono i grafici, menù a tendine, immagini,.. (Axes) nella
finestra.In una Figure vi possono essere più Axes, quello attivo è individuato dal
puntatore gca (grafhic current Axes).I figli di un oggetto axes sono i grafici ed i testi.
Le proprietà di un oggetto Axes sono ad esempio title,color,xlabel,…Per vederle tutte:
get(gca)
>> x=-pi:0.1:pi;
>> y=cos(x);
>> plot(x,y)
il comando set modifica le proprietà.
Modifichiamo il colore di fondo della figura corrente da grigio a giallo e portiamo a 15 la
dimensione dei caratteri negli assi:
>> set(gcf,'color','y')
>> set(gca,'fontsize',15)
32
1
0.5
0
-0.5
-1
-4
-2
0
2
4
Una funzione come plot può generare un handle all’oggetto grafico che produce.
L’ handle memorizza la figura e la rende disponibile per un uso futuro.(Un handle di
figura è un tipo speciale di “handle di oggetto”,che può essere assegnato ad altri tipi di
oggetti). Con il comando
>> hsin=plot(x,y);
si crea un handle alla curva e se ne possono modificare le caratteristiche:
>> set(hsin,'linewidth',4)
1
0.8
0.6
0.4
0.2
0
-0.2
-0.4
-0.6
-0.8
-1
-4
-3
-2
-1
0
1
2
3
4
Con il comando axes si può specificare la posizione dell’oggetto nella figura corrente:
axes(‘position’,[a b c d])
c,d = larghezza e altezza del rettangolo in cui inserire la figura
a,b= angolo sinistro in basso della figura rispetto alla finestra.
Funzioni relative al suono e all’animazione
soundsc(y,Fs) converte un vettore in suono
y= segnale discreto di frequenza Fs
Fs frequenza,se omessa Fs=8192Hz
>> y=sin(linspace(0,20000,20000));
>> soundsc(y,15000)
>> soundsc(y)
Matlab include alcuni file audio, ad esempio:
>>load chirp
>>soundsc(y,Fs)
Un modo per ottenere sequenze animate (senza memorizzarle), è quella di cambiarne
posizione e proprietà e ridisegnare l’oggetto:si può animare un oggetto cambiandone le
coordinate e cancellando nella figura corrente l’oggetto precedente. Per fare ciò si cambia
la proprietà EraseMode ponendola xor e si usa il comando drawnow per eseguire
immediatamente il comando grafico. Si può rallentare l’animazione con il comando
pause(n).
La function seguente anima la funzione e-x.
function muoviexp
33
%anima la funzione exp
clear;close all;
t=[0:0.1:5];
%crea un handle al plot
p=plot(t(1),exp(-t(1)),'o',...
'EraseMode','xor','MarkerEdgeColor','b','MarkerFaceColor','g','MarkerSize',10);
axis([0 5 0 1]);
hold on
for j=2:length(t)
%specifica I dati da rappresentare in p
set(p,'XData',t(j),'YData',exp(-t(j)))
drawnow
pause(0.05)
end
Si possono anche visualizzare e memorizzare animazioni (“movie”) memorizzando le
immagini come singoli fotogrammi di un film con i comandi,getframe, movie.
La funzione getframe cattura la figura corrente per creare un fotogramma(frame).
F=getframe cattura un frame dalla figura corrente e dà in output una struttura con due
campi:
cdata dati relativi all’immagine
colormap mappa dei colori
Per registrare un’animazione si usa in un ciclo del tipo:
for k=1:n
istruzioni per creare l’immagine
M(k) = getframe salva la figura corrente nell’array M
end
Per vedere quanto registrato tramite il comando getframe più volte, con una velocità
diversa o all’indietro si usa la funzione movie. Per una semplice ripetizione si usa
movie(M).
movie(M,n) visualizza n volte la sequenza di immagini memorizzate nella matrice M, se
n è negativo all’indietro.
movie(M,n,fps) visualizza n volte la sequenza di immagini fps frames per secondo (di
default fps=12).
Lo script seguente crea l’animazione e muove una superficie tridimensionale.
% script file muovifigura.m
clear;close all;
set(gcf,’DoubleBuffer’,’on’) elimina i flash
z=peaks;
funzione demo
surf(z);
axis tight;
setta gli assi nel range dei dati
thisax=axis;
fissa gli assi
for j=1:5
surf(sin(2*pi*j/20)*z);axis(thisax);
F(j)=getframe;
carica le immagini nella matrice F
end
movie(F,5)
visualizza 5 volte il film
34
Per visualizzare un fotogramma lo si estrae dalla struttura creata da getframe e si usa il
comando image:
%estrai il terzo fotogramma
>> colori=F(3).colormap;
>> foto=F(3).cdata;
>> colormap(colori);
>> image(foto) %visualizza l’immagine
50
100
150
200
250
300
50
100
150
200
250
300
350
400
Si può vedere il film anche su un computer che non ha a disposizione il Matlab, si può
includere in una pagina web o in una presentazione power point salvando il filmato in un
file di tipo AVI(Audio Video Interleave, il più comune formato per file multimediali). Si crea,
con il comando avifile un oggetto che può contenere un filmato tipo AVI, si creano i frames
con getframe e si aggiungono all’oggetto con la funzione addframe, infine si chiude il file
con la funzione close. Si può anche creare un file AVI con la funzione movie2avi,
partendo da una matrice movie di matlab. Infine la funzione aviread legge un file AVI.
Image processing toolbox
In Matlab vi sono funzioni per leggere,scrivere e visualizzare immagini di formato
diverso(JPEG,BMP,GIF,..).
Modalità Grayscale :l’immagine è rappresentata da un array i cui valori rappresentano
il livello di grigio del pixel corrispondente,Class array :double Є[0,1] , uint8 Є[0,255].
Modalità Indexed : l’immagine è rappresentata da un array X corrispondente ai pixel e
da una colormap matrix (MAP) mx3. I valori di X sono gli indici di riga dell’array MAP
che rappresenta la mappa di colori Є[0,1] : il livello di rosso,verde e blu del pixel
corrispondente .
Modalità Truecolor(RGB) : l’immagine è rappresentata da un array (m,n,3) di uint8 o
double∈[0,1] .La combinazione dell’intensità dei 3 colori base nella posizione(i,j,1:3)
fornisce il colore finale del pixel(i,j)
Per leggere e memorizzare un’immagine:
I=imread(‘filename.ftm’) : legge un’immagine contenuta nel file filename.ftm
[I,map]=imread(‘filename.ftm’) : legge un’immagine indexed
I=imread(‘URL) :Legge un’immagine da un indirizzo URL
imwrite(I,‘filename.ftm’) :Scrive un file contenente un’immagine .
Per visualizzare un’immagine:
imshow(I)
image(I)
imtool(I) :Interfaccia grafica per visualizzare e modificare un’immagine.
Si possono fare operazioni sui singoli pixel, l’immagine si può modificare, filtrare,..
Di seguito alcuni esempi di semplici operazioni:
>> [X,map]=imread('trees.tif');
>> imshow(X,map)
35
>> colormap(jet) % cambia i colori
>> [X,map]=imread('trees.tif');
>> j=imrotate(X,35);
>> imshow(j,map)
>>[I,map]=imread('trees.tif');
>> j=ind2gray(I,map);
>> imshow(j)
>> k=imcomplement(j);
>> figure(2)
>> imshow(k)
>> J=imread('cameraman.tif');
>> I=imread('rice.png');
>> K=imadd(I,J);
36
>> imshow(K)
>> A=imread('panorama.jpg');
>> B=imread('ischia.jpg');
>> C=cat(4,A,B);
>> montage(C)
Per creare un’animazione :
mov = immovie(X,map) : Crea un movie struct array
mov = immovie(RGB) :Crea un movie struct array
implay(mov) :Visualizza il film
37

Il sistema MATLAB

Transcript

Documenti analoghi

Sistemi Avanzati per il Riconoscimento A.A. 2014/2015

Algebra Lineare Numerica Esercitazione n 7

IL PROGRAMMA MATLAB (ver 5.2)

Introduzione a Matlab e Simulink

Mini Manuale Matlab

appunti della lezione

Ese_filtri_a_tempo_d..

Introduzione a MATLAB

Lez 2 - MATLAB

Laboratorio di MATLAB - Dipartimento di Ingegneria dell

Scienze e Tecnologie della Moda - Area Reclutamento

INVITO

Presentazione MatLab nuova versione

Convocazione PROVA ORALE esame di abilitazione all`esercizio

Introduzione a Matlab