Documentazione esterna al software matematico sviluppato con MatLab

Transcript

1 Documentazione esterna al software matematico sviluppato con MatLab Algoritmi Metodo di Gauss-Seidel con sovrarilassamento Metodo delle Secanti Metodo di Newton Studente Amelio Francesco 556/00699 Anno Accademico: 2003/04

2 Metodo di Gauss-Seidel (con sovrarilassamento) per la soluzione di sistemi lineari con matrici sparse. Scopo Descrizione Risolvere un sistema di equazioni lineari di una matrice sparsa utilizzando il metodo di sovrarilassamento (Gauss-Seidel con accelerazione di convergenza). L algoritmo calcola le soluzioni in modo iterativo usando la formula: x ( k+ ) i = b i i n ( k+ ) aij x j aij j= j= i+ a ii x ( k ) j Il miglioramento fatto ad ogni iterazione dall algoritmo è: r = x x ( k ) ( k+ ) ( k ) i i i Per ottenere un accelerazione della convergenza viene usata la seguente formula: x = x + wr ( k+ ) ( k ) ( k ) i i i w (omega) è il fattore di accelerazione che viene passato alla funzione per migliorare la convergenza (per maggiori informazioni vedi i parametri) Prototipo e parametri SOR (ele, col, rig, b, x, w, toll, maxiter) Parametri in input: ele col rig b x w toll vettore contenente gli elementi non nulli della matrice sparsa in ordine di lettura. vettore contenente gli indici di colonna degli elementi non nulli presenti nella matrice vettore contenente gli indici del vettore col corrispondente al primo elemento non nullo di ogni riga della matrice il vettore dei termini noti. il vettore approssimazione iniziale. Valore di omega che accelera la convergenza. Occorre adoperare un valore tra e 2. Se w = il metodo equivale al metodo di Gauss-Seidel senza sovrarilassamento.

3 precisione richiesta all'algoritmo. maxiter il numero massimo di iterazioni richieste all'algoritmo. Valore restituito: x le soluzioni approssimate del sistema lineare Routine ausiliarie Indicatori di errore Accuratezza Per testate la convergenza viene usata la routine testconvergenza che calcola si massimo del valore assoluto degli autovalori della matrice di iterazione B = D - C. Per prendere l elemento A ij dai tre vettori rappresentanti la matrice sparsa viene utilizzata la funzione getsparseelement. Se il sistema non è convergente viene stampato un messaggio di errore e l algoritmo esce. Durante le iterazioni viene costruito un vettore che memorizza la stima dell errore ad ogni passo. Alla fine il vettore viene stampato. Se non viene raggiunta la precisione richiesta nel numero di iterazioni indicate in maxiter l algoritmo mostra un warning e l approssimazione viene restituita. L indice di accuratezza viene scelto dall utente che utilizza la routine specificando il valore nel parametro toll. Per verificare se è stata raggiunta l accuratezza richiesta l algoritmo effettua questo controllo: norm( abs(x)-abs(prev) ) <= toll*norm(x) Non appena non viene più soddisfatta l algoritmo considera buona l accuratezza. Ad esempio se vogliamo un accuratezza di 0-4 invocheremo la funzione con i seguenti parametri: SOR ( ele, col, rig, b, x, w, 0^-4, maxiter) Per testate il software sono stati effettuate alcune verifiche sulle seguenti tipologie di matrici: ) Matrice fornita dal docente 2) Matrice non a diagonale dominante 3) Matrice singolare 4) Matrice a diagonale dominante 5) Matrice mal condizionata E sono stata fatti vari test quali: test di convergenza, calcolo indice di condizionamento, modifiche al parametro omega. L indice di condizionamento viene calcolato dalla formula norm(a)*norm(a^-)). Il raggio spettrale della matrice di iterazione viene calcolato usando la funziona ausiliaria 2

4 testconvergenzasor. Un teorema dimostra che se il raggio spettrale della matrice di iterazione è maggiore uguale di il metodo non converge. Test () Matrice fornita dal docente I vettori che memorizzano la matrice sono: elem = [2,4,23,-7,4,5,6, -,2,-9,,-8,2,-,8,4,5,-6,-6,9,,20,2, -9,22,-7,5,-8,2,7,2,3,5,6,,9]; col = [,8,2,2,3,5,4,7,5,,6,3,4,4,7,,8,9,8,9, 6,0,3,5,,2,2,6,0,3,6,4,3,5,9,6]; rig = [,3,5,7,9,,4,6,9,22,24,26,28,3,33,35,37]; b = [ ]; L indice di condizionamento della matrice è: e+00 La soluzione data dai comandi in linea di MatLab (A\b) è:

5 Effettuiamo il primo test su questa matrice con i seguenti parametri: w = ; toll = eps; maxiter = 200 Il raggio spettrale è e-00 che è minore di. Invocando l algoritmo con i parametri indicati otteniamo il seguente output: L'algoritmo ha raggiunto la precisione desiderata in 33 iterazioni. e le soluzioni trovate sono: Potremmo provare ad incrementare il fattore di accelerazione omega per ridurre il numero di iterazioni. Utilizziamo l algoritmo con i seguenti parametri: w =.367; toll = eps; maxiter = 200 Il raggio spettrale è e-00 che è minore di ed è migliore del precedente. Invocando l algoritmo con i parametri indicati otteniamo il seguente output: L'algoritmo ha raggiunto la precisione desiderata in 38 iterazioni. e le soluzioni trovate sono:

6 Vediamo ora che succede se al vettore dell approssimazione iniziale impostiamo un valore molto vicino alla soluzione reale. Assegniamo ad x il vettore delle soluzione a meno di un 0.2. Chiamiamo l algoritmo con gli stessi parametri del precedente test e vediamo l output mostrato: L'algoritmo ha raggiunto la precisione desiderata in 35 iterazioni. Abbiamo recuperato solo 3 iterazioni, evidentemente il maggior numero di passi vengono fatti quando ci si avvicina di più alla soluzione reale. Test (2) Matrice non a diagonale dominante A = ; b = 4 ; I vettori che memorizzano la matrice sono: elem = [8,.2, 2, -4, 4, 4, 0.008, 24, -8, 7.92]; col = [, 5,, 2, 2, 3, 5, 4, 3, 5]; rig = [, 3, 5, 8, 9, ]; b = [8, 0, -4, 0.76, ]; L indice di condizionamento della matrice è: e+00 La soluzione data dai comandi in linea di MatLab (A\b) è: Effettuiamo il primo test su questa matrice con i seguenti parametri: w = ; toll = eps; maxiter = 00 5

7 Il raggio spettrale è e-00 che è minore di. Invocando l algoritmo con i parametri indicati otteniamo il seguente output: L'algoritmo ha raggiunto la precisione desiderata in 46 iterazioni Il vettore delle soluzioni date è Proviamo ora a cambiare il valore di omega e impostiamolo a.06 lasciando invariati gli altri parametri. Il raggio spettrale, in questo caso è e-00 e l'algoritmo raggiunge la precisione desiderata in 25 iterazioni ottenendo le stesse soluzioni di prima. Se provassimo ad incrementare omega portandolo a.5 il controllo sulla convergenza dell algoritmo ci informerà che l algoritmo non converge (nel caso il controllo sulla convergenza nel codice fosse commentato, l algoritmo potrebbe iterare fino a raggiungere il massimo numero di iterazioni). Supponiamo ora di voler ottenere una precisione minore di eps, ad esempio proviamo ad impostare toll a 0^-2. Con questi valori otteniamo le soluzioni che come si vede sono molto meno vicine a quelle corrette. Test (3) Matrice singolare A = ; b = ; I vettori che memorizzano la matrice sono: elem = [ ]; col = [, 2, 2,4,,3,2,4]; rig = [,3,5,7,9]; b = [, -2, 4, 3]; 6

8 L indice di condizionamento della matrice è: e+032 (calcolato con cond(a)) Un valore alto dell indice di condizionamento indica che la matrice singolare o quasi. L algoritmo in linea di MatLab da come soluzioni un vettore di Inf. Il nostro algoritmo cicla sempre fino al massimo numero di iterazioni. Test (4) Matrice a diagonale dominante A =. ; b = ; I vettori che memorizzano la matrice sono: elem = [.7, -2.6, -.3, 5.2, 7.8, 9., 6.5, -.3, 2.6, -2.6, 5.2, -3.9, 9.] col = [ ] rig = [ ] b = [2, 0.5, 0.6,, 0, 3] L indice di condizionamento della matrice è: e+000 La soluzione data dai comandi in linea di MatLab (A\b) è: Effettuiamo il primo test su questa matrice con i seguenti parametri: w = ; toll = eps; maxiter = 00 Il raggio spettrale è e-00 che è minore di. Invocando l algoritmo con i parametri indicati otteniamo il seguente output: 7

9 L'algoritmo ha raggiunto la precisione desiderata in 24 iterazioni E il risultato ottenuto è: Che è molto molto simile a quello ottenuto dal comando in linea. Per verificarlo assegnamo il risultato del comando in linea alla variabile cpu e il risultato del SOR alla variabile mia ed eseguiamo la seguente istruzione: otteniamo abs(mia)-abs(cpu)<eps che sta a significare che la condizione è vera per tutti gli elementi della soluzione. Effettuando un ultimo test aumentando il valore di w: w =.2; toll = eps; maxiter = 00 notiamo che l algoritmo non termina nel massimo numero di iterazioni perchè non è convergemte. Infatti si vede dal vettore che contiene le stime dell errore che i suoi valori aumentano ad ogni iterazione, ovvero l algoritmo non è convergente. Test (5) Matrice mal condizionata 2^ A = ; b = ; 0 2*0^ ^35 5 I vettori che memorizzano la matrice sono: elem = [2^00, 0.3, 3, 40000, 2*0^-9, ^35]; col = [ ]; 8

10 rig = [ ]; L indice di condizionamento della matrice è:.43969e+047 La soluzione data dai comandi in linea di MatLab (A\b) è: e-03-5e e-048 Effettuiamo il primo test su questa matrice con i seguenti parametri: w = ; toll = eps; maxiter = 00 Il raggio spettrale è e-045 che è molto minore di. Invocando l algoritmo con i parametri indicati otteniamo il seguente output: L'algoritmo ha raggiunto la precisione desiderata in 2 iterazioni Le soluzioni trovate sono: e-03-5e e-048 Lo stesso comando in linea di MatLab ci informa del fatto che la matrice è mal condizionata e che quindi la soluzione non è accurata. 9

11 Metodo delle secanti per il calcolo degli zeri di un equazione non lineare Scopo Descrizione Calcolo degli zeri di un equazione non lineare. A partire da un approssimazione iniziale (gli estremi di un intervallo di partenza) l algoritmo cerca il punto in cui la funzione si annulla. L algoritmo itera su intervalli i cui estremi cambiano ad ogni passo. Gli estremi X k X k+ dell intervallo vengono ricalcolati ad ogni passo usando la formula: x k+ = x k f ( xk )( xk x f ( x ) f ( x k k k ) ) Dove X k+ è l intersezione della secante ai punti X k X k+ con l asse ascisse. Prototipo e parametri secanti ( funzione, x0, x, toll, maxiter) Parametri in input: funzione la funzione su cui deve lavorare. x0 primo estremo dell'intervallo di partenza x secondo estremo dell intervallo di partenza toll è la tolleranza minima ammessa della differenza tra una iterazione e quella successiva. maxiter è il numero massimo di iterazioni dopo le quali l'algoritmo si arresta. Valore restituito: zero lo zero della funzione Routine ausiliarie Indicatori di errore Solo funzioni incluse nelle librerie standard di MatLab quali feval, disp, warning ecc. Se il prodotto della funzione valutata negli estremi dell intervallo dato non è minore di 0 ( f(a)*f(b) >= 0), viene mostrato un warning in cui si comunica all utente che la funzione potrebbe non avere uno zero nell intervallo ma l algoritmo continua. Se non viene raggiunta la precisione richiesta nel numero di iterazioni indicate in maxiter l algoritmo mostra un warning e l ultima approssimazione ottenuta viene restituita. 0

12 Accuratezza L indice di accuratezza viene scelto dall utente che utilizza la routine specificando il valore nel parametro toll. Per verificare se è stata raggiunta l accuratezza richiesta l algoritmo effettua i due controlli sottostanti: abs(x(2)-x()) > toll (accuratezza orizzontale) abs(y(2)) > toll (accuratezza verticale) Non appena non viene più soddisfatta una delle seguenti condizioni l algoritmo considera buona l approssimazione. Ad esempio se vogliamo un accuratezza di 0-4 invocheremo la funzione con i seguenti parametri: secanti( funzione, x0, x, 0^-4, maxiter ) Complessità computazionale La complessità computazionale è data dal numero di valutazioni della funzione nei punti. In realtà per ogni iterazione viene fatta una valutazione della funzione più le due valutazioni iniziale fatta sugli estremi in input. Quindi in totale avremo: Θ ( [numero iterazioni] + 2 ) A seguire vengono mostrati alcuni test effettuati su delle funzioni di esempio.

13 . y = cos x log x Passando l intervallo [/8,2] otteniamo lo zero contrassegnato da [*] nella figura: Per ottenere l altro zero della funzione basta passare l intervallo [-,-/8] Facciamo ora un ulteriore verifica sul comportamento dell algoritmo. Passando alla routine l intervallo[,6] il prossimo punto dell intervallo sostituirà l estremo e porterà ad una situazione di non convergenza che darà una radice immaginaria. Infatti l output sarà: con risultato: Warning: L'algoritmo non ha raggiunto la precisione desiderata nel massimo numero di iterazioni specificate e e+00i Proviamo ora ad utilizzare lo stesso intervallo con gli estremi invertiti [6,] otteniamo: Raggiunta la precisione richiesta in 8 iterazioni. Complessità computazionale (in numero di valutazioni della funzione): 9 2

14 Lo zero trovato è: che è il risultato che volevamo ottenere. 3

15 2x 2. y = e + x 8 x Per trovare lo zero contrassegnato passiamo alla funzione l intervallo [-,-/8]. L output del programma è: Raggiunta la precisione richiesta in 2 iterazioni. Complessità computazionale (in numero di valutazioni della funzione): 3 Lo zero trovato è: e-00 Proviamo ora ad utilizzare lo stesso intervallo con gli estremi invertiti [-9,-8] otteniamo: Warning: Attenzione: la funzione potrebbe non avere degli zeri nell'intervallo fornito. Raggiunta la precisione richiesta in 30 iterazioni. Complessità computazionale (in numero di valutazioni della funzione): 3 Lo zero trovato è: 4

16 Il numero di iterazioni richieste, partendo da questo intervallo sono maggiori, ma la soluzione è la stessa. 5

17 y = 5 2cos x 4sin x 2cos x Passando l intervallo [-/20,0], l algoritmo mostra il messaggio Warning: Attenzione: la funzione potrebbe non avere degli zeri nell'intervallo fornito. Raggiunta la precisione richiesta in 38 iterazioni. Complessità computazionale (in numero di valutazioni della funzione): 39 In effetti la funzione valutata nei due estremi ha valori di uguale segno. Quindi potrebbe non esserci uno zero nell intervallo (per il teorema degli zeri). L algoritmo mostra un semplice avviso ma procede comunque alla ricerca dello zero che verrà trovato e sarà uguale a: e-00 Possiamo fare un ulteriore test cambiando il valore della tolleranza. Passiamo alla funzione toll = 0e-5 L output del programma sarà: Warning: Attenzione: la funzione potrebbe non avere degli zeri nell'intervallo fornito. 6

18 Raggiunta la precisione richiesta in 0 iterazioni. Complessità computazionale (in numero di valutazioni della funzione): Lo zero trovato è: e-00 Come si vede dall output la precisione richiesta è stata raggiunta in 0 iterazioni invece di 38 ma la radice è molto più imprecisa. 7

19 Metodo di Newton (o delle tangenti) per il calcolo degli zeri di un equazione non lineare Scopo Descrizione Calcolo degli zeri di un equazione non lineare. A partire da un approssimazione iniziale l algoritmo cerca il punto in cui la funzione si annulla. L algoritmo trova il punto X k+ in cui la tangente in Xk si interseca con le ascisse. Il nuovo punto viene calcolato con la formula: x k+ = x k f ( xk ) f '( x ) k Prototipo e parametri Come si nota è necessario conoscere la derivata della funzione per ottenere l approssimazione k+ esima dello zero. newton ( funzione, derivata, x0, toll, maxiter) Parametri in input: funzione la funzione su cui deve lavorare. derivata la derivata della funzione fornita dall utente x0 approssimazione iniziale dello zero toll è la tolleranza minima ammessa della differenza tra una iterazione e quella successiva. maxiter è il numero massimo di iterazioni dopo le quali l'algoritmo si arresta. Valore restituito: zero lo zero della funzione Routine ausiliarie Indicatori di errore Solo funzioni incluse nelle librerie standard di MatLab quali feval, disp, warning ecc. Se alla iterata k la derivata nel punto approssimato x0 assume valore molto vicino a 0 rischiamo di fare una divisione per un numero molto piccolo e in ogni caso il prossimo valore dell approssimazione sarebbe un numero troppo grande. Per questo motivo newton probabilmente non converge. In questo caso viene stampato un messaggio di errore e si esce. Se non viene raggiunta la precisione richiesta nel numero di iterazioni i di i I l l i i l i i 8

20 indicate in maxiter l algoritmo mostra un warning e l approssimazione viene restituita. Accuratezza L indice di accuratezza viene scelto dall utente che utilizza la routine specificando il valore nel parametro toll. Ad ogni iterazione viene verificata la condizione: abs( feval(funzione,x0) ) > toll Se non viene soddisfatta vuol dire che è stata raggiunta l accuratezza richiesta. Se vogliamo un accuratezza di 0-4 invocheremo la funzione con i seguenti parametri: newton( funzione, derivata, x0, 0^-4, maxiter ) La complessità computazionale è data dal numero di valutazioni della funzione nei punti. In realtà per ogni iterazione viene fatta una valutazione della funzione e una della sua derivata. Quindi in totale avremo: Complessità computazionale Θ ( [numero iterazioni] * 2 ) A seguire vengono mostrati alcuni test effettuati su delle funzioni di esempio. 9

21 d. y = 2sin 2 x 3cos x (2sin 2 x 3cos x) = 4sin xcos x + 3sin x dx La routine è stata invocata con un approssimazione iniziale di.4 e una toll di 0e-2 e ha raggiunto l accuratezza richiesta in 2 iterazioni. Lo zero trovato è: Provando ad aumentare la tolleranza alla precisione di macchina eps e passando maxiter = 6 l algoritmo ottiene il seguente output. Warning: L'algoritmo non ha raggiunto lo zero nel numero di iterazioni specificate. E l ultima approssimazione calcolata è:

22 d 2. y = cos 2x 3 cos x + = 0 (cos 2x 3 cos x + ) = 2sin 2x + 3sin x in [0,2π] dx Lo zero contrassegnato è stato trovato invocando la routine con un x iniziale uguale a.9, una tolleranza uguale alla precisione di macchina e un numero massimo di iterazioni = 6. L output dell algoritmo è: L'algoritmo ha raggiunto l'accuratezza in 5 iterazioni. E lo zero trovato è: Cambiando il valore di toll a 0e-2 otteniamo L'algoritmo ha raggiunto l'accuratezza in 2 iterazioni. Lo zero trovato è:

23 4 3 2 d y = x + 30x + 263x + 644x 490 ( x + 30x + 263x + 644x 490) = 4x + 90x + 526x dx 8 x Lo zero contrassegnato è stato trovato invocando la routine con un valore di x iniziale uguale a 4 e una tolleranza uguale alla precisione di macchina, e un numero massimo di iterazioni = 0. L output dell algoritmo è: L'algoritmo ha raggiunto l'accuratezza in 7 iterazioni. Lo zero trovato è: e-00 Proviamo ora a cambiare la tolleranza e la impostiamo a 0e-2. Otteniamo il seguente output: Lo zero è: L'algoritmo ha raggiunto l'accuratezza in 5 iterazioni e-00 22