19 FEBBRAIO SECONDA PARTE

Transcript

1 19 FEBBRAIO SECONDA PARTE 1. FILE SCRIPT: Nella prima parte della lezione abbiamo visto come sia particolarmente facile gestire e lavorare con matrici utilizzando Matlab. In particolare abbiamo lavorato restando nell'ambiente interattivo costituito dal Command Window. Se vogliamo salvarci le istruzioni digitate nel CW per richiamarle in seguito o abbiamo una sequenza abbastanza lunga di comandi è più conveniente trascrivere tali comandi in un M-file di tipo SCRIPT. I file Matlab vengono detti M-file in quanto hanno estensione.m. In questi file possiamo scrivere in sequenza i comandi che scriveremmo accanto al prompt del Command Window (CW) e Matlab esegue i comandi in sequenza come se fossero stati impressi sul CW stesso. Come creare un file script: File Nuovo M-file Salva con Nome: es. matrice.m Scrivi sequenza di comandi: A = [1 0-1; 3 0 2; 1 4-1]; AI = inv(a); AQ = A^2; AI AQ Richiama dal CW con il nome dello script-file: >> matrice AI = AQ = Caratterizzazione script: opera sui dati presenti nello script non accetta variabili in input non ha variabili in output utile per automatizzare una serie di istruzioni che si devono eseguire più volte

2 i dati che vengono generati da un file script restano nell ambiente lavoro (WorkSpace) e possono essere riutilizzati per altri calcoli. Passare valori variabili ad uno script: comando input 2. CONTROLLI DI FLUSSO for if while CICLO FOR: Il ciclo for esegue un gruppo di istruzioni un numero fissato di volte. for indice = inizio: incremento: fine Esempio: Definire un vettore b in IR^n tale che b(i)=2i+1, per i=1,...,n. n = input ( ' Dai n ---> '); b = zeros(1, n) % inizializzo il vettore for i = 1: 10 b(i)=2*i+1 Esempio: Algoritmo per calcolare il valore assunto in x = x* da un polinomio di grado n nella forma P(x)=a_0 + a_1 x + a_2 x^2 + + a_n x^n. (1.1) L algoritmo segue immediatamente dalla forma del polinomio: Algoritmo 1. Dati: n, a_0, a_1,, a_n, x* Risultato: y = P(x*) 1. p = 1 2. s = a_0 3. per i = 1, 2,, n 1. p = x* p 2. s = s + a_i p fine ciclo su i

3 4. y = s 5. Fine In Matlab: (polinomio.m) n=input('\n dare grado polinomio, n ----> '); a=input('\n dare il vettore dei coefficienti, a --- > '); y=input('\n dare valore in cui calcoloil polinomio, y ----> '); % y = x* p=1; s=a(1); for i=2:n+1 p = p*y; s = s + a(i)*p; s Questo algoritmo utilizza due variabili di appoggio, p e s. I valori assunti da p sono le potenze di x*: infatti p viene inizialmente posto uguale a 1 e successivamente moltiplicato per x* ad ogni passo del ciclo così che p vale x*^i al variare di i. Nella variabile s viene accumulata la sommatoria. L algoritmo richiede in tutto 3n operazioni aritmetiche, 2n moltiplicazioni e n addizioni, e non viene quasi mai usato nella pratica perché è possibile ottenere lo stesso risultato faco meno operazioni. L algoritmo utilizzato comunemente per calcolare i valori assunti da un polinomio è noto come algoritmo di Horner, o delle moltiplicazioni annidate. Esso parte dalla riscrittura del polinomio in una forma diversa da (1.1), apparentemente più complicata ma più conveniente dal punto di vista dei calcoli; la forma in questione è la seguente: P(x) = a_0 + a_1 x + a_2 x^2 + + a_n x^n = = a_0 + x(a_1 + a_2 x + + a_n x^(n-1)) = = a_0 +x (a_1 +x (a_2 + + a_n x^(n-2))) = =.= = a_0 +x (a_1 +x (a_2 + x(a_(n-2) +x(a_(n-1)+ a_n x)) )). (1.2) Sulla base della (1.2) si può scrivere il seguente algoritmo: Algoritmo 2. (Horner) Dati: n, a_0, a_1,, a_n, x* Risultato: y = P(x*) 1. s = a_n 2. per i = n-1, n-2,, 0 s = s x* + a_i fine ciclo su i 3. y = s 4. Fine ATTENZIONE: Il ciclo for è all indietro!!!!

4 In Matlab: (horner.m) n=input('\n dare grado polinomio, n ----> '); a=input('\n dare il vettore dei coefficienti, a --- > '); y=input('\n dare valore in cui calcolo il polinomio, y ----> '); % y = x* s=a(n+1); for i=n:-1:1 s=s*y+a(i); s L algoritmo calcola per x = x* e memorizza in s i contenuti delle parentesi tonde in (1.2), parto dalla più interna e procedo verso l esterno. I coefficienti del polinomio intervengono in ordine decrescente, da a_n ad a_0; per questo motivo il ciclo è impostato in modo che i valori di i vadano a diminuire, da i = n-1 a i = 0 (ciclo all indietro). Si può facilmente vedere che questo algoritmo richiede soltanto 2n operazioni. Confronto tra gli algoritmi: In base a quali considerazioni si può o si deve preferire un algoritmo rispetto ad un altro? I termini di confronto sono fondamentalmente tre: 1) un algoritmo è da preferirsi ad un altro se è più stabile, ovvero se si può dimostrare (teoricamente e/o sperimentalmente) che fornisce risultati più accurati. 2) un algoritmo è da preferirsi ad un altro se è più robusto, ovvero se è dimostrato sperimentalmente che riesce a risolvere un maggior numero di problemi. 3) infine, un algoritmo è da preferirsi ad un altro se è più efficiente, ovvero se richiede l utilizzo di meno risorse. In generale il costo di un algoritmo si può misurare in termini di memoria occupata e/o in termini di tempo di esecuzione. D altra parte il tempo è ritenuto spesso una risorsa più preziosa perché non riutilizzabile e quindi in generale l efficienza di un algoritmo numerico viene misurata tramite il suo costo in termini di tempo di esecuzione. CONTROLLO IF, ELSE, ELSEIF: If valuta una espressione logica ed esegue un gruppo di istruzioni quando il valore dell espressione logica è vero ed un altro gruppo quando il valore dell espressione logica è falso. if espressione logica else if espressione logica elseif espressione logica else Se le istruzioni sono da farsi solo nel caso in cui sia soddisfatta l espressione logica allora la forma migliore per il controllo if è la seguente:

5 if espressione logica Nelle espressioni logiche si utilizzano i seguenti operatori di relazione: Operatori di relazione: < minore di <= minore o uguale di > maggiore di >= maggiore o uguale di == uguale a ~= diverso da Esempio facile: File script che dice se un numero è positivo, negativo o zero (posneg.m). n = input('\n dai n :'); if n>0 disp(sprintf('\n n e'' positivo \n')) elseif n<0 disp(sprintf('\n n e'' negativo \n')) else disp(sprintf('\n n e'' zero \n')) Esempio: File script per calcolare il massimo tra n numeri (massimo.m) x = input('\n dare il vettore x: '); n = length (x); M = x(1); for i = 2 : n if M < x(i) M = x(i); M Esempio: File script che calcola il massimo in valore assoluto tra n componenti di un vettore e che restituisce l indice della componente corrispondente (massimo_comp.m). x = input('\n dare il vettore x: '); n = length (x); M=abs(x(1)); comp=1; for i=2:n if M < abs(x(i)) M=abs(x(i)); comp=i; M comp

6 CICLO WHILE: Il ciclo while esegue un gruppo di istruzioni fino a che l espressione logica di controllo rimane vera. while espressione logica Esempio: Trova la più grande potenza p di un numero n, tale che p < 100. (potenza.m) n = input (' \n dai il numero n ---> '); s = n; while s <= 100 s=s*n; disp(sprintf (' \n potenza : %d \n', s/n)) Esempio: Come prima ma stampa anche l esponente corrispondente (potenza_esp.m) n = input(' \n dai il numero n ---> '); s = n; i=1; while s <= 100 s=s*n; i=i+1; disp(sprintf( ' \n potenza : %d', s/n)) disp(sprintf(' \n esponente : %d \n', i-1))

7 Esempio: CALCOLO DELLA PRECISIONE DI MACCHINA. Sfruttando il ciclo while si può calcolare anche la precisione di macchina. Una definizione per la precisione di macchina può essere la seguente: La precisione di macchina è il più piccolo numero floating point che possiamo sommare a 1 otteno un risultato maggiore di 1. Cioè, detto x un qualunque numero di macchina, e prec la precisione di macchina: fl(1+x) > 1, per ogni x >= prec fl(1+x) = 1, per ogni x < prec L importanza di questa nuova definizione consiste nel fatto che essa porta in modo naturale ad un algoritmo per il calcolo della precisione di macchina: Algoritmo. Calcolo precisione di macchina Dati: nessuno Risultato: prec 1. prec = 1 2. prec = prec * y = prec Se y > 1 allora vai a prec = 2 * prec 6. Fine In Matlab: (prec.m) prec = 1; while 1 + prec >1 prec = prec * 0.5; prec = 2*prec; disp(prec)

8 OPERATORI LOGICI: && e o Un espressione con l operatore & è vera se sono veri entrambi gli operandi Un espressione con l operatore è vera se è vero uno dei due operandi ~ non Un espressione con l operatore ~ è vera se è falso l operando. Esempio: Dati due numeri n e m, stabilire se sono concordi o discordi (conc_disc1.m) n = input('\n dai n : '); m = input('\n dai m : '); if (n>0 & m>0) elseif (n<0 & m<0) else disp(sprintf('\n n e m sono discordi \n')) Esempio: Considera anche il caso in cui uno dei due è ZERO!!! (conc_disc2.m) n = input('\n dai n : '); m = input('\n dai m : '); if (n>0 & m>0) elseif (n<0 & m<0) elseif (n= =0 m= =0) disp(sprintf('\n n o m vale zero \n')) else disp(sprintf('\n n e m sono discordi \n')) Esempio: Metto insieme i due casi dei concordi (conc_disc3.m) n = input('\n dai n : '); m = input('\n dai m : '); if ((n>0 && m>0) (n<0 && m<0)) elseif (n==0 m==0) disp(sprintf('\n n o m vale zero \n')) else disp(sprintf('\n n e m sono discordi \n'))