Esercitazione 1 - Studio Di Funzione

Esercitazione
per il corso di

Calcolo Numerico

Prof. G. Zilli

Metodi per la risoluzione di
equazioni non lineari

Emanuele De Villa Bais
615803

Laurea in ingegneria aerospaziale

a.a. 2009 – 2010

1
Indice

1. Testo della esercitazione 4
2. Introduzione 5
3. Approssimazione della radice 7
3.1 Metodo di Newton-Raphson 7
3.2 Metodo della tangente fissa 8
3.3 Metodo della secante variabile 10
3.4 Metodo della secante fissa 11
3.5 Metodo della bisezione 13
3.6 Metodo del punto fisso 14
3.7 Confronto dei metodi 16
4. Codice Matlab 17
4.1 Programma principale (stimaRadice) 17
4.2 Metodo di Newton-Raphson (newton) 22
4.3 Metodo della tangente fissa (tanfis) 23
4.4 Metodo della secante variabile (secvar) 24
4.5 Metodo della secante fissa (secfis) 25
4.6 Metodo della bisezione (bisez) 27
4.7 Metodo del punto fisso (puntfis) 28
4.8 Altre funzioni 29
5. Uscita del programma 30

2

3
1. Testo della esercitazione

Dopo aver dimostrato esistenza ed unicità della soluzione ξ in I, si risolva, utilizzando il linguaggio
MatLab, l'equazione f(x) = 0 con:
f (x) = 3x 2 −1+ log(x), I = [0.2,1].
Si applichino, a scelta, almeno 3 tra i suguenti i metodi:

1.Newton-‐Raphson (e della tangente fissa);
2.secante variabile (e €della secante fissa);
3.bisezione;
4.punto fisso.
Si prenda x0 = 1 come punto iniziale. Per i 2 metodi delle secanti si prenda x1 ottenuto con il metodo
di Newton-‐Raphson. Con tutti i metodi, calcolare l'approssimazione xk della radice ξ usando il test di
arresto sullo scarto: sn = |xn+1-xn| < TOLL; (ad esempio con una tolleranza TOLL = 10-6). Porre a 50 il
numero massimo di iterazioni consentite. Tutti i metodi vengano implementati nel seguente modo:
• per il metodo di Newton-‐Raphson, per ogni iterata n-‐esima si riporti: n, xn, f(xn), f ’(xn), lo scarto sn, e si
verifichi se l'ordine di convergenza è quadratico considerando il rapporto |sn+1|/|sn|2 (stima della
costante asintotica M).
• per il metodo della secante variabile, per ogni iterata n-‐esima si riporti: n, xn, f(xn),
f ( xn ) − f ( x )
n−1 ,
xn − x
n−1
lo scarto sn, e si verifichi se l’ordine di convergenza è p = 1.6181, considerando il

rapporto|sn+1|/|sn|1.6181 (stima della costante asintotica M).
€
• Si proceda analogamente per i 2 metodi della tangente fissa e della secante fissa (e della bisezione).
Considerando il rapporto fra gli scarti |sn+1|/|sn si verifichi se l'ordine di convergenza è p = 1 stimando
la costante asintotica M e quindi la velocità di convergenza R. Di conseguenza, si stimi il numero n di
iterazioni necessarie per avere |en|/|e0| < TOLL confrontandolo con il risultato sperimentale.
• Per il metodo di punto fisso occorre considerare un’opportuna funzione di punto fisso g(x). Si
suggeriscono le seguenti due funzioni:
⎧ 1 − log( x)
⎪ g( x) =
⎨ 3
⎪ 2
⎩ g( x) = exp(−3x +1)
Prendendo come punto iniziale x0 = 1, per ogni iterata n-‐esima, si riporti n, xn, g(xn), lo scarto sn =
|xn+1-xn|. Considerando il rapporto |sn+1|/|sn| si verifichi se l’ordine di convergenza è p = 1 stimando la
costante asintotica M e quindi la velocità di convergenza R. Di conseguenza, stimare il numero
€ n di
iterazioni necessarie per avere |en|/|e0|<TOLL, confrontandolo con il risultato sperimentale.
Commentare la convergenza o la divergenza di ciascuno dei due schemi alla luce della teoria.
Si riporti in grafico semilogaritmico lo scarto sn in funzione del numero delle iterate (un unico grafico
in cui vi sono le curve di convergenza per i vari metodi impiegati), commentando brevemente i
risultati. Si costruisca anche il grafico della funzione f in I per esempio discretizzando l'intervallo
con punti equidistanti (si scelga un numero di punti compreso tra 20 e 30) e riportando su due
colonne i valori dei punti e della funzione nei punti stessi.
Si scriva una breve relazione in un documento di testo, in cui si descrive il problema, i risultati
ottenuti con i metodi utilizzati e il loro confronto, il numero delle iterazioni richieste per soddisfare il
test di arresto, e l'ordine di convergenza (includendo e descrivendo i grafici). Si alleghino inoltre: i
programmi Matlab che implementano i metodi sopra elencati, i file di input e i file di output generati.
4
2. Introduzione

Consideriamo la funzione:

f (x) = 3x 2 −1+ log(x), I = [0.2,1].

Osservo che la funzione è continua nell’intervallo I poiché composta di funzioni continue, inoltre
poiché negli estremi dell’intervallo la funzione vale:
€
f (0.2) = -2.49
f (1) = 2

per il teorema di tutti i valori ho a€
lmeno uno zero in I. Questo zero è unico perché la funzione è
strettamente crescente in I dato che: €

1
f ' (x) = 6x + > 0, ∀x ∈ I .
x

Il grafico della funzione nell’intervallo I, riportato in Figura 2.1, conferma visivamente quanto
appena trovate ed, inoltre, mostra che la radice è compresa tra 0.6 e 0.8.
€

In seguito sono riportati i valori di x e y in 24 punti dell’intervallo I

5
x f(x)

0.200000 -‐2.489438
0.234783 -‐2.283727
0.269565 -‐2.092949
0.304348 -‐1.911701
0.339130 -‐1.736342
0.373913 -‐1.564299
0.408696 -‐1.393688
0.443478 -‐1.223088
0.478261 -‐1.051399
0.513043 -‐0.877754
0.547826 -‐0.701457
0.582609 -‐0.521941
0.617391 -‐0.338736
0.652174 -‐0.151452
0.686957 0.040244
0.721739 0.236631
0.756522 0.437951
0.791304 0.644415
0.826087 0.856204
0.860870 1.073477
0.895652 1.296375
0.930435 1.525023
0.965217 1.759532
1.000000 2.000000

6
3. Approssimazione della radice

3.1 Metodo di Newton-Raphson

Il metodo di Newton crea la successione:

f ( xn )
x = xn − , n = 0, 1, 2...
n+1 f '( x n )

a partire dalla stima iniziale x0 della radice. L’interpretazione geometrica del metodo di
Newton suggerisce che la successione € xk è monotona decrescente. L’applicazione del
metodo di Newton € fornisce i risultati della Tabella 3.1.

n x_n f(x_n) f '(x_n) s_n

0 1.000000000000000 2.000e+00 7.000e+00 2.857e-‐01
1 0.714285714285714 1.941e-‐01 5.686e+00 3.415e-‐02
2 0.680140486699352 2.317e-‐03 5.551e+00 4.175e-‐04
3 0.679723032601509 3.344e-‐07 5.550e+00 6.025e-‐08
4 0.679722972350233 6.883e-‐15 5.550e+00 NaN

Tabella 3.1: processo di convergenza del metodo di Newton-‐Raphson.

La colonna degli scarti mostra il comportamento quadratico del procedimento di
convergenza dato che:

2
s ≈ s
n +1 n
Utilizzando gli scarti è possibile stimare la costante asintotica come:
€
s
n+1
M= 2 , n = 0,1, 2, ...
sn
Applicando la relazione per n = 0, 1, 2 si ottengono i tre valori 0.418, 0.358, 0.346 di cui
l’ultimo è in ottimo accordo con la stima:
€
1 f ''(ξ ) 1 f ''( x 4 )
M= ⋅ = ⋅ = 0.346
2 f '(ξ ) 2 f '( x 4 )
dove si è utilizzata x4 come migliore approssimazione nota della radice ξ per valutare le
derivate prima e seconda della funzione.
€

7
3.2 Metodo della tangente fissa

Il metodo della tangente fissa crea la successione:

f ( xn )
x = xn − , n = 0, 1, 2...
n+1 f '( x 0 )

a partire dalla stima iniziale x 0 della radice. L’interpretazione geometrica del metodo della
€
tangente fissa suggerisce che la successione x n è monotona decrescente. L’applicazione del
€ fissa fornisce i risultati della Tabella 3.2.
metodo della tangente

€
n x_n f(x_n) s_n
€
0 1.000000000000000 2.000e+00 2.857e-‐01
1 0.714285714285714 1.941e-‐01 2.773e-‐02
2 0.686551427389036 3.798e-‐02 5.426e-‐03
3 0.681125078359269 7.785e-‐03 1.112e-‐03
4 0.680012964634302 1.609e-‐03 2.299e-‐04
5 0.679783038797567 3.333e-‐04 4.762e-‐05
6 0.679735417769552 6.907e-‐05 9.867e-‐06
7 0.679725551131274 1.431e-‐05 2.044e-‐06
8 0.679723506699316 2.965e-‐06 4.236e-‐07
9 0.679723083072977 6.145e-‐07 NaN

Tabella 3.2.: processo di convergenza del metodo della tangente fissa.


s
n+1
M= , n = 0,1, 2, ...
sn

Applicando la relazione per n = 0, 1,…., 8 si ottengono i valori: 0.097, 0.196, 0.205, 0.207,…, 0.207
di cui l’ultimo è in ottimo accordo con la stima:
€
f '(ξ ) f '( x 9 )
M = 1− = 1− = 0.207
f '( x 0 ) f '( x 0 )

dove si è utilizzata 9 come migliore approssimazione nota della radice ξ per valutare la
x
derivata prima della funzione. Posso quindi affermare che l’ordine di convergenza del metodo è
€
lineare (p = 1).
Di conseguenza la velocità di convergenza R risulta: €

€ R = − log M = 0.683588

€

8
Posso ora facilmente approssimare il numero di iterazioni necessarie per avere
|en|/|e0| < TOLL secondo la formula:

logTOLL
n≥ = 8.777
log M

che combacia perfettamente con la quantità di iterazioni eseguite per ottenere la migliore
approssimazione della radice x 9 .
€

€

9
3.3 Metodo della secante variabile

Il metodo della secante variabile crea la successione:

f (x ) f ( xn ) − f ( x )
x = xn − n con h = n−1 , n = 0, 1, 2...
n+1 h n xn − x
n n−1

a partire dalla stima iniziale x 0 della radice. La prima iterazione
€ per trovare x1 , necessario per il
calcolo di hn , è effettuata tramite il metodo di Newton-‐Raphson. L’applicazione del metodo
€ €
della secante variabile fornisce i risultati della Tabella 3.3.

€ €
€ n x_n f(x_n) h_n s_n

0 1.000000000000000 2.000e+00 7.000e+00 2.857e-‐01
1 0.714285714285714 1.941e-‐01 6.321e+00 3.072e-‐02
2 0.683569837059582 2.138e-‐02 5.625e+00 3.801e-‐03
3 0.679769235048111 2.567e-‐04 5.557e+00 4.620e-‐05
4 0.679723033900763 3.416e-‐07 5.550e+00 6.155e-‐08
5 0.679722972351216 5.461e-‐12 4.166e+03 NaN

Tabella 3.3.: processo di convergenza del metodo della secante variabile.


s
n+1
M= 1.6181 , n = 0,1, 2, ...
sn

Applicando la relazione per n = 0, 1,…., 5 si ottengono i valori: 0.233, 1.065, 0.318, 0.637;
considerando che posso scartare i primi due valori (poiché ho utilizzato il metodo di Newton –
€
Raphson per la prima iterazione) e calcolando una stima più precisa di M:

0.618 0.618
⎛ 1 f ''(ξ ) ⎞ ⎛ 1 f ''( x ) ⎞
M = ⎜ ⎟ = ⎜ 5
⎟ = 0.519
⎝ 2 f '(ξ ) ⎠ ⎝ 2 f '( x 5 ) ⎠

dove si è utilizzata x 5 come migliore approssimazione nota della radice ξ per valutare la
derivata prima e seconda della funzione. Osservo come il valore esatto di M stia nell’intervallo
€
[0.318,0.637]. Effettuando inoltre un’ulteriore iterazione utilizzando gli scarti ottengo un valore
di M pari a 0.458. €
Posso quindi affermare che, per n → ∞ , M vale 0.519 e che quindi il metodo ha ordine di
convergenza € superlineare (p = 1.6181).

€

10
3.4 Metodo della secante fissa

Il metodo della secante fissa crea la successione:

f (x ) f ( x1 ) − f ( x 0 )
x = xn − n con h = , n = 0, 1, 2...
n+1 h n x1 − x 0
n

a partire dalla stima iniziale x 0 della radice. La prima €iterazione per trovare x1 , necessario per il
calcolo di hn , è effettuata tramite il metodo di Newton-‐Raphson. L’applicazione del metodo
€ €
della secante fissa fornisce i risultati della Tabella 3.4.

€ €
€ n x_n f(x_n) s_n

0 1.000000000000000 2.000e+00 2.857e-‐01
1 0.714285714285714 1.941e-‐01 3.072e-‐02
2 0.683569837059582 2.138e-‐02 3.382e-‐03
3 0.680187718507857 2.580e-‐03 4.081e-‐04
4 0.679779597176004 3.142e-‐04 4.972e-‐05
5 0.679729878551882 3.833e-‐05 6.064e-‐06
6 0.679723814763790 4.675e-‐06 7.397e-‐07
7 0.679723075108788 5.703e-‐07 NaN

Tabella 3.4.: processo di convergenza del metodo della secante fissa.


s
n+1
M= , n = 0,1, 2, ...
sn

Applicando la relazione per n = 0, 1,…., 7 si ottengono i valori: 0.108, 0.110, 0.121, 0.122,…, 0.122
€
f '(ξ ) f '( x 7 )
M = 1− = 1− = 0.122
h h
n n

dove si è utilizzata x 7 come migliore approssimazione nota della radice ξ per valutare la
derivata prima della funzione. Posso quindi affermare che l’ordine di convergenza del metodo è
lineare (p = 1).
€

€ R = − log M = 0.913707

€

11
|en|/|e0| < TOLL secondo la formula:

logTOLL
n≥ = 6.567
log M

€

€

12
3.5 Metodo di bisezione

Il metodo di bisezione ad ogni iterazione suppone come radice il punto medio dell’intervallo
dato, per poi valutare in quale dei due intervalli così ottenuti si trova la vera radice, e quindi
ripete l’operazione per il nuovo intervallo. L’applicazione del metodo della tangente fissa
fornisce i risultati della Tabella 3.5.

n x_n low_x up_x f(x_n) s_n

0 0.600000000000000 0.200000000000000 1.000000000000000 -‐4.308e-‐01 2.000e-‐01
1 0.800000000000000 0.600000000000000 1.000000000000000 6.969e-‐01 1.000e-‐01
2 0.700000000000000 0.600000000000000 0.800000000000000 1.133e-‐01 5.000e-‐02
3 0.650000000000000 0.600000000000000 0.700000000000000 -‐1.633e-‐01 2.500e-‐02
4 0.675000000000000 0.650000000000000 0.700000000000000 -‐2.617e-‐02 1.250e-‐02
5 0.687500000000000 0.675000000000000 0.700000000000000 4.328e-‐02 6.250e-‐03
6 0.681250000000000 0.675000000000000 0.687500000000000 8.479e-‐03 3.125e-‐03
7 0.678125000000000 0.675000000000000 0.681250000000000 -‐8.863e-‐03 1.563e-‐03
8 0.679687500000000 0.678125000000000 0.681250000000000 -‐1.969e-‐04 7.813e-‐04
9 0.680468750000000 0.679687500000000 0.681250000000000 4.140e-‐03 3.906e-‐04
10 0.680078125000000 0.679687500000000 0.680468750000000 1.971e-‐03 1.953e-‐04
11 0.679882812500000 0.679687500000000 0.680078125000000 8.871e-‐04 9.766e-‐05
12 0.679785156250000 0.679687500000000 0.679882812500000 3.451e-‐04 4.883e-‐05
13 0.679736328125000 0.679687500000000 0.679785156250000 7.412e-‐05 2.441e-‐05
14 0.679711914062500 0.679687500000000 0.679736328125000 -‐6.137e-‐05 1.221e-‐05
15 0.679724121093750 0.679711914062500 0.679736328125000 6.375e-‐06 6.104e-‐06
16 0.679718017578125 0.679711914062500 0.679724121093750 -‐2.750e-‐05 3.052e-‐06
17 0.679721069335937 0.679718017578125 0.679724121093750 -‐1.056e-‐05 1.526e-‐06
18 0.679722595214844 0.679721069335937 0.679724121093750 -‐2.093e-‐06 7.629e-‐07
19 0.679723358154297 0.679722595214844 0.679724121093750 2.141e-‐06 3.815e-‐07
20 0.679722976684570 0.679722595214844 0.679723358154297 2.405e-‐08 NaN

Tabella 3.5.: processo di convergenza del metodo di bisezione.


s
n+1
M= , n = 0,1, 2, ...
sn

Applicando la relazione per n = 0, 1,…., 20 si ottengono i valori: 0.500, 0.500,…, 0.500; risultato
perfettamente in accordo col metodo di bisezione, che dimezza l’intervallo ad ogni iterazione.
Posso quindi affermare che € l’ordine di convergenza del metodo è lineare (p = 1).
La velocità di convergenza R risulta quindi:

R = − log M = 0.301030

|en|/|e0| < TOLL secondo l€
a formula:

logTOLL
n≥ = 19.932
log M

€
13
€
3.6 Metodo di punto fisso

Il metodo di punto fisso crea la successione:

x = g( x n ), n = 0, 1, 2...
n+1

a partire dalla stima iniziale x 0 della radice. ξ è detta funzione di punto fisso.
€ €

€
3.6.1 Metodo
€ di punto fisso con g(x) = exp(−3x 2 + 1)

Utilizzando la funzione di punto fisso consigliata:

€g( x) = exp(−3x 2 +1)

non si ottiene convergenza, poiché il valore di ξ oscilla tra:
€
x1 = 0.000000000641528 e x2 = 2.718281828459046
€

€ € 1− log(x)
3.6.2 Metodo di punto fisso con g(x) =
3

Utilizzando la funzione di punto fisso consigliata:

€ 1 − log( x)
g( x) =
3

si ottengono i risultati della Tabella 3.6.

€
n x_n g(x_n) s_n

0 1.000000000000000 5.774e-‐01 4.226e-‐01
1 0.577350269189626 7.186e-‐01 1.413e-‐01
2 0.718634386489183 6.659e-‐01 5.270e-‐02
3 0.665933568606050 6.847e-‐01 1.880e-‐02
4 0.684729961433595 6.779e-‐01 6.809e-‐03
5 0.677921021783776 6.804e-‐01 2.453e-‐03
6 0.680373545652549 6.795e-‐01 8.852e-‐04
7 0.679488361391006 6.798e-‐01 3.193e-‐04
8 0.679807613405771 6.797e-‐01 1.152e-‐04
9 0.679692440815186 6.797e-‐01 4.155e-‐05
10 0.679733986214736 6.797e-‐01 1.499e-‐05
11 0.679718999315753 6.797e-‐01 5.406e-‐06
12 0.679724405554191 6.797e-‐01 1.950e-‐06
13 0.679722455347831 6.797e-‐01 7.035e-‐07
14 0.679723158849667 6.797e-‐01 NaN

Tabella 3.6.: processo di convergenza del metodo di punto fisso.
14

s
n+1
M= , n = 0,1, 2, ...
sn

Applicando la relazione per n = 0, 1,…., 14 si ottengono i valori: 0.334, 0.373,…, 0.361
€
M = g'(ξ ) = g'( x14 ) = 0.361

dove si è utilizzata x14 come migliore approssimazione nota della radice ξ per valutare
la derivata prima della funzione di punto fisso. Posso quindi affermare che l’ordine di
€
convergenza del metodo è lineare (p = 1).

€ R = − log M = 0.442815

|en|/|e0| < TOLL secondo
€ la formula:

logTOLL
n≥ = 13.550
log M

che combacia perfettamente con la quantità di iterazioni eseguite per ottenere la
migliore approssimazione della radice x14 .
€

€

15
3.7 Confronto dei metodi

La Figura 3.7 riporta in un grafico semilogaritmico il processo di convergenza dei vari metodi.

16
4. Codice Matlab

4.1 Programma principale (stimaRadice)

% programma per l'approssimazione della radice f(x)=0
%
% metodi disponibili:
% (1) metodo di Newton-Raphson
% (2) metodo della tangente fissa
% (3) metodo della secante variabile
% (4) metodo della secante fissa
% (5) metodo di bisezione
% (6) metodo del punto fisso
%
% Emanuele De Villa Bais $ 29-Mar-2010 / 08-Apr-2010 $
% PARAMETRI D'INGRESSO
% la mia funzione (nome del file Matlab che la contiene)

fname = 'fEs1';
% nome della derivata della funzione

dfname = strcat('d', fname);
% nome della funzione di punto fisso g

gname = 'g1Es1'; % oppure g2Es1 (ne ho due da utilizzare)
% intervallo che contiene la radice

I = [0.2 1.0];
% stima iniziale della radice

x0 = 1.0;
% imposto i parametri per il test d'arresto

toll = 1e-6; % tolleranza sugli scarti
nmaxiter = 50; % numero massimo di iterazioni da eseguire
% scelgo i metodi da utilizzare nella stima della radice

metodo = [1 1 1 1 1 1]; % dove 1 indica che il metodo viene utilizzato
% scelgo se creare il grafico della funzione

graficofunz = 0; % dove 1 indica che il grafico viene realizzato
% scelgo se creare il grafico degli scarti

graficoscar = 1; % dove 1 indica che il grafico viene realizzato
%%%%%%%%%%%% CODICE %%%%%%%%%%%
% imposto la eventuale creazione del grafico di f con tabella

if graficofunz == 1 % allore creo il grafico
npunti = 24; % il numero di punti nell'intervallo I
a = I(1); % estremo inferiore dell'intervallo
b = I(2); % estremo superiore dell'intervallo
x = linspace(a, b, npunti); % creo il vettore delle x
y = feval(fname, x); % creo il vettore delle y
figure(1);
plot(x, y, 'k', 'lineWidth', 2); % creo il grafico
% k indica il colore della linea (nero in questo caso)
% mentre con (lineWidth, n) indico lo spessore della linea
title('Grafico della funzione', 'fontSize', 14)
xlabel('x', 'fontSize', 18) % assegno il nome dell'asse x
ylabel('y', 'fontSize', 18) % assegno il nome dell'asse x
grid on % inserisco la griglia
% creo la tabella tabgrafico coi valori di x e f(x)

tabgraficfunz = zeros(24, 2); % creo la matrice vuota
tabgraficfunz(:, 1) = x; % imposto la colonna di x
tabgraficfunz(:, 2) = y; % imposto la colonna di y
% stampo la tabella
disp(' ')
disp('valori di x e y nell''intervallo I'), disp(' ')
disp(' x f(x)'), disp(' ')
tabgraficfunz = sprintf('%10.6f %15.6f \n', tabgraficfunz');
disp(tabgraficfunz), disp(' ')
end
17
%%%%%%%%%%%% METODO DI NEWTON-RAPHSON %%%%%%%%%%%
if metodo(1)
% imposto i parametri d'ingresso del metodo

moltradice = 1; % la molteplicit‡ della radice
parconv = [toll nmaxiter moltradice];
% chiamo la function newton.m

[nwx, nwconv, nwconvstory] = newton(x0, fname, dfname, parconv);
% stampo i risultati
if graficofunz == 1 % metto uno spazio tra le due tabelle
disp(['\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'...
'\\\\\\\\\\\\\\\'])
disp(['///////////////////////////////////////////////////////'...
'///////////////']), disp(' ')
end
disp(' ')
disp('--------------- METODO DI NEWTON-RAPHSON ---------------')
disp(' ')
disp(['funzione usata : ', fname])
disp(['numero massimo di iterazioni : ', int2str(nmaxiter)])
disp(['criterio d''arresto : ', '|s_n| < ', ...
num2str(toll)])
disp(['molteplicit‡ della radice : r = ', int2str(moltradice)])
if nwconv == -1 % ovvero non c'Ë stata convergenza
messaggio = 'convergenza : no';
else
messaggio = ['convergenza : sÏ (', ...
int2str(nwconv), ' iterazioni (n))'];
end
disp(messaggio), disp(' '), disp(' ')
if nwconv > 0 % se il metodo converge stampo la convstory
disp('sintesi del processo di convergenza:'), disp(' ')
disp([' n x_n f(x_n) f''(x_n)'...
' s_n']), disp(' ')
% calcolo gli scarti (ovvero prendo la colonna della matrice
% nwconvstory che contiene x_n escluso il primo valore e le
% sottraggo la stessa colonna con incluso il primo valore ed
% escluso l'ultimo); cosÏ facendo faccio |x_(n+1) - x_n|
nwscar = abs(nwconvstory(2:length(nwconvstory), 2) - ...
nwconvstory(1:length(nwconvstory)-1, 2));
% ora posso creare la mia tabella
nwtabp = [nwconvstory [nwscar; NaN]]; % p di provvisoria (n.d.t)
nwtab = sprintf('%3i %20.15f %13.3e %13.3e %13.3e \n', nwtabp');
disp(nwtab), disp(' ')
disp('stima costante di errore M usando il rapporto degli scarti:')
disp(' ')
% calcolo la costante M (nwM) per ogni iterazione (vale come per
% nwscar la stringa che segue...)
nwM = abs(nwscar(2:length(nwscar)))./ ...
((abs(nwscar(1:length(nwscar)-1))).^2);
% creo la tabella per la costante M
tabnwM = sprintf('%10.3f %10.3f %10.3f %10.3f %10.3f %10.3f \n', nwM);
disp(tabnwM), disp(' ')
end
end
%%%%%%%%%%%% METODO DELLA TANGENTE FISSA %%%%%%%%%%%

if metodo(2)

parconv = [toll nmaxiter];
% chiamo la function tanfis.m

[tfx, tfconv, tfconvstory] = tanfis(x0, fname, dfname, parconv);
if (graficofunz == 1 || metodo(1))
disp(['\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'...
'\\\\\\\\\\\\\\\'])
disp(['///////////////////////////////////////////////////////'...
'///////////////']), disp(' ')
end
disp(' ')
disp('--------------- METODO DELLA TANGENTE FISSA ---------------')
disp(' ')
num2str(toll)])
18
if tfconv == -1 % ovvero non c'Ë stata convergenza
else
int2str(tfconv), ' iterazioni (n))'];
end
if tfconv > 0 % se il metodo converge stampo la convstory
disp([' n x_n f(x_n) '...
' s_n']), disp(' ')
% calcolo gli scarti
tfscar = abs(tfconvstory(2:length(tfconvstory), 2) - ...
tfconvstory(1:length(tfconvstory)-1, 2));
tftabp = [tfconvstory [tfscar; NaN]]; % p di provvisoria (n.d.t)
tftab = sprintf('%3i %20.15f %13.3e %13.3e \n', tftabp');
disp(tftab), disp(' ')
disp(' ')
% calcolo la costante M (tfM) per ogni iterazione
tfM = abs(tfscar(2:length(tfscar)))./ ...
abs(tfscar(1:length(tfscar)-1));
tabtfM = sprintf('%10.3f %10.3f %10.3f %10.3f %10.3f %10.3f \n', tfM);
disp(tabtfM), disp(' ')
end
end
%%%%%%%%%%%% METODO DELLA SECANTE VARIABILE %%%%%%%%%%%

if metodo(3)

% chiamo la function secvar.m

[svx, svconv, svconvstory] = secvar(x0, fname, dfname, parconv);
if (graficofunz == 1 || metodo(1) || metodo(2))
disp(['\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'...
'\\\\\\\\\\\\\\\'])
disp(['///////////////////////////////////////////////////////'...
'///////////////']), disp(' ')
end
disp(' ')
disp('--------------- METODO DELLA SECANTE VARIABILE ---------------')
disp(' ')
num2str(toll)])
if svconv == -1 % ovvero non c'Ë stata convergenza
else
int2str(svconv), ' iterazioni (n))'];
end
if svconv > 0 % se il metodo converge stampo la convstory
disp([' n x_n f(x_n) h_n'...
' s_n']), disp(' ')
svscar = abs(svconvstory(2:length(svconvstory), 2) - ...
svconvstory(1:length(svconvstory)-1, 2));
svtabp = [svconvstory [svscar; NaN]]; % p di provvisoria (n.d.t)
svtab = sprintf('%3i %20.15f %13.3e %13.3e %13.3e \n', svtabp');
disp(svtab), disp(' ')
disp(' ')
% calcolo la costante M (svM) per ogni iterazione
svM = abs(svscar(2:length(svscar)))./ ...
((abs(svscar(1:length(svscar)-1))).^1.6181);
tabsvM = sprintf('%10.3f %10.3f %10.3f %10.3f %10.3f %10.3f \n', svM);
disp(tabsvM), disp(' ')
end
end
19
%%%%%%%%%%%% METODO DELLA SECANTE FISSA %%%%%%%%%%%
if metodo(4)

% chiamo la function secfis.m

[sfx, sfconv, sfconvstory] = secfis(x0, fname, dfname, parconv);
if (graficofunz == 1 || metodo(1) || metodo(2) || metodo(3))
disp(['\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'...
'\\\\\\\\\\\\\\\'])
disp(['///////////////////////////////////////////////////////'...
'///////////////']), disp(' ')
end
disp(' ')
disp('--------------- METODO DELLA SECANTE FISSA ---------------')
disp(' ')
num2str(toll)])
if sfconv == -1 % ovvero non c'Ë stata convergenza
else
int2str(sfconv), ' iterazioni (n))'];
end
if sfconv > 0 % se il metodo converge stampo la convstory
disp([' n x_n f(x_n) '...
' s_n']), disp(' ')
sfscar = abs(sfconvstory(2:length(sfconvstory), 2) - ...
sfconvstory(1:length(sfconvstory)-1, 2));
sftabp = [sfconvstory [sfscar; NaN]]; % p di provvisoria (n.d.t)
sftab = sprintf('%3i %20.15f %13.3e %13.3e \n', sftabp');
disp(sftab), disp(' ')
disp(' ')
% calcolo la costante M (sfM) per ogni iterazione
sfM = abs(sfscar(2:length(sfscar)))./ ...
abs(sfscar(1:length(sfscar)-1));
tabsfM = sprintf('%10.3f %10.3f %10.3f %10.3f %10.3f %10.3f \n', sfM);
disp(tabsfM), disp(' ')
end
end
%%%%%%%%%%%% METODO DI BISEZIONE %%%%%%%%%%%

if metodo(5)

% chiamo la function bisez.m

[bx, bconv, bconvstory] = bisez(I, fname, parconv);
if (graficofunz == 1 || metodo(1) || metodo(2) || metodo(3) ||...
metodo(4))
disp(['\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'...
'\\\\\\\\\\\\\\\'])
disp(['///////////////////////////////////////////////////////'...
'///////////////']), disp(' ')
end
disp(' ')
disp('--------------- METODO DI BISEZIONE ---------------')
disp(' ')
num2str(toll)])
if bconv == -1 % ovvero non c'Ë stata convergenza
else
int2str(bconv), ' iterazioni (n))'];
end
20
if bconv > 0 % se il metodo converge stampo la convstory
disp([' n x_n low_x'...
' up_x f(x_n)'...
' s_n']), disp(' ')
bscar = abs(bconvstory(2:length(bconvstory), 2) - ...
bconvstory(1:length(bconvstory)-1, 2));
btabp = [bconvstory [bscar; NaN]]; % p di provvisoria (n.d.t)
btab = sprintf('%3i %20.15f %20.15f %20.15f %13.3e %13.3e \n', btabp');
disp(btab), disp(' ')
disp(' ')
% calcolo la costante M (svM) per ogni iterazione
bM = abs(bscar(2:length(bscar)))./ ...
(abs(bscar(1:length(bscar)-1)));
tabbM = sprintf('%10.3f %10.3f %10.3f %10.3f %10.3f %10.3f \n', bM);
disp(tabbM), disp(' ')
end
end
%%%%%%%%%%%% METODO DEL PUNTO FISSO %%%%%%%%%%%

if metodo(6)

% chiamo la function puntfis.m

[pfx, pfconv, pfconvstory] = puntfis(x0, gname, parconv);
if (graficofunz == 1 || metodo(1) || metodo(2) || metodo(3) ||...
metodo(4) || metodo(5))
disp(['\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'...
'\\\\\\\\\\\\\\\'])
disp(['///////////////////////////////////////////////////////'...
'///////////////']), disp(' ')
end
disp(' ')
disp('--------------- METODO DI PUNTO FISSO ---------------')
disp(' ')
disp(['funzione di punto fisso usata: ', gname])
num2str(toll)])
if pfconv == -1 % ovvero non c'Ë stata convergenza
else
int2str(pfconv), ' iterazioni (n))'];
end
if pfconv > 0 % se il metodo converge stampo la convstory
disp([' n x_n g(x_n) '...
' s_n']), disp(' ')
pfscar = abs(pfconvstory(2:length(pfconvstory), 2) - ...
pfconvstory(1:length(pfconvstory)-1, 2));
pftabp = [pfconvstory [pfscar; NaN]]; % p di provvisoria (n.d.t)
pftab = sprintf('%3i %20.15f %13.3e %13.3e \n', pftabp');
disp(pftab), disp(' ')
disp(' ')
% calcolo la costante M (pfM) per ogni iterazione (vale come per
% nwscar la stringa che segue...)
pfM = abs(pfscar(2:length(pfscar)))./ ...
(abs(pfscar(1:length(pfscar)-1)));
tabpfM = sprintf('%10.3f %10.3f %10.3f %10.3f %10.3f %10.3f \n', pfM);
disp(tabpfM), disp(' ')
end
end
% imposto l'eventuale creazione del grafico degli scarti

if (sum(metodo) > 0 && graficoscar == 1) % ho utilizzato almeno un metodo
figure(2)
21
if metodo(1)
semilogy(abs(nwscar), '-o', 'lineWidth', 2)
hold on
end
if metodo(2)
semilogy(abs(tfscar), '-ok', 'lineWidth', 2)
hold on
end
if metodo(3)
semilogy(abs(svscar), '-og', 'lineWidth', 2)
hold on
end
if metodo(4)
semilogy(abs(sfscar), '-p', 'lineWidth', 2)
hold on
end
if metodo(5)
semilogy(abs(bscar), '-pk', 'lineWidth', 2)
hold on
end
if metodo(6)
semilogy(abs(pfscar), '-pg', 'lineWidth', 2)
end
if sum(metodo) == 6 % ovvero se ho utilizzato tutti i metodi
% inserisco la legenda
legend('Newton', 'Tangente fissa', 'Secante variabile',...
'Secante fissa', 'Bisezione', 'Punto fisso')
end
title('Grafico degli scarti', 'fontSize', 14)
xlabel('Numero di iterazione', 'fontSize', 18)
ylabel('Valore assoluto degli scarti', 'fontSize', 18)
end
4.2 Metodo di Newton-Raphson (newton)

function [x, conv, convstory] = newton(x0, fname, dfname, parconv)
% [X, CONV, CONVSTORY] = NEWTON(X0, FNAME, DFNAME, PARCONV)
% risolve f(x)=0 utilizzando il metodo iterativo di Newton-Raphson con
% punto iniziale x0.
% Il test di arresto utilizzato Ë quello sullo scarto:
% |x_(n+1) - x_n| < toll.
%%%%%%%%%%% PARAMETRI DI INGRESSO %%%%%%%%%%

% x0 : valore iniziale della stima della radice.
% fname : nome del file Matlab che contiene la funzione f(x)
% dfname : nome del file Matlab che contiene la derivata di f(x)
% parconv : vettore (1x3) che contiene i parametri per la convergenza
% parconv(1): toll
% parconv(2): nmaxiter
% parconv(3): r
% toll : tollerenza desiderata per lo scarto
% nmaxiter : numero massimo di iterazioni da effettuare
% r : molteplicit‡ della radice
%%%%%%%%%%% PARAMETRI DI USCITA %%%%%%%%%%

% x : valore della radice
% conv : indica il numero di iterazioni effettuate (niter) se il
% metodo converge, -1 se il metodo non converge (Ë stato
% raggiunto il numero massimo di iterazioni desiderato)
% convstory : matrici [(niter+1)x4] che tiene traccia del processo
% iterativo eseguito:
% 1∞ colonna: valore del numero di iterazione (niter) attuale
% 2∞ colonna: valore della radice x per l'iterazione attuale
% 3∞ colonna: valore di f(x) per l'iterazione attuale
% 4∞ colonna: valore di f'(x) per l'iterazione attuale
% Emanuele De Villa Bais $ 28-Mar-2010 $
% stabilisco i parametri d'entrata

toll = parconv(1);
nmaxiter = parconv(2);
r = parconv(3);
% creo la matrice nulla che conterr‡ la convstory

convstory = zeros(nmaxiter+1, 4);
22
% stabilisco i valori iniziali di x, toll e n
xold = x0; % la mia x_n
ntoll = 2*toll; % la tolleranza iniziale deve essere maggiore
n = 0;
% creo il ciclo che calcoler‡ l'approssimazione della radice

while (ntoll > toll && n <= nmaxiter)
fxold = feval(fname, xold); % valuto la funzione col valore x_n
dfxold = feval(dfname, xold); % valuto la derivata col valore x_n
if abs(dfxold) < toll*abs(fxold)
% ovvero se la derivata di f(x_n) Ë troppo piccola
dfxold = toll; % le assegno il valore di toll
end
convstory(n+1, 1:4) = [n xold fxold dfxold]; % aggiorno la matrice
xnew = xold - r*fxold/dfxold; % calcolo x_n+1
ntoll = abs(xnew - xold); % calcolo lo scarto dell'iterazione
xold = xnew; % assegno ad xold il nuovo valore trovato per proseguire
n = n+1; % indico il numero dell'iterazione
end
% termino la matrice convstory coi valori dell'ultima iterazione

fxlast = feval(fname, xnew);
dfxlast = feval(dfname, xnew);
convstory(n+1, 1:4) = [n xnew fxlast dfxlast];
% definisco i parametri di uscita

x = xnew; % il valore finale della mia radice
conv = n; % il numero di iterazioni eseguite
if (n > nmaxiter && ntoll > toll) % ovvero non c'Ë stata convergenza
conv = -1;
end
convstory = convstory(1:n+1, 1:4); % tolgo le righe che mi avanzano
4.3 Metodo della tangente fissa (tanfis)

function [x, conv, convstory] = tanfis(x0, fname, dfname, parconv)
% [X, CONV, CONVSTORY] = TANFIS(X0, FNAME, DFNAME, PARCONV)
% risolve f(x)=0 utilizzando il metodo iterativo della tangente fissa con
% |x_(n+1) - x_n| < toll

% parconv(1): toll


toll = parconv(1);
% creo la matrice nulla che conterr‡ convstory

23
% stabilisco i valori iniziali di x, toll, n e h_n
% nel metodo della tangente fissa h_n Ë costante e vale f'(x0)
dfx = feval(dfname, x0); % ecco qui il mio valore h_n
xold = x0; % stima iniziale della radice
n = 0;

fxold = feval(fname, xold); % valuto la funzione in x_n
convstory(n+1, 1:3) = [n xold fxold]; % aggiorno convstory
xnew = xold - fxold/dfx; % calcolo la nuova stima della radice (x_n+1)
ntoll = abs(xnew - xold); % controllo lo scarto dell'iterazione
xold = xnew; % assegno a x il nuovo valore trovato
n = n+1;
end
% termino la matrice convstory coi valore dell'ultima iterazione

convstory(n+1, 1:3) = [n xnew fxlast];
% assegno i parametri d'uscita

conv = -1;
end
convstory = convstory(1:n+1, 1:3); % elimino le righe che mi avanzano
4.4 Metodo della secante variabile (secvar)

function [x, conv, convstory] = secvar(x0, fname, dfname, parconv)
% [X, CONV, CONVSTORY] = SECVAR(X0, FNAME, DFNAME, PARCONV)
% risolve f(x)=0 utilizzando il metodo iterativo della secante variabile
% con punto iniziale x0 e x1 calcolato col metodo di Newton-Raphson
% |x_(n+1) - x_n| < toll

% parconv(1): toll

% 4∞ colonna: valore di h_n: (f(x_n) - f(x_n-1))/(x_n - x_n-1)
% imposto i parametri d'entrata

toll = parconv(1);

% assegno i valori iniziali di x, toll, n, fx0 e dfx0

fx0 = feval(fname, x0);
dfx0 = feval (dfname, x0);
ntoll = 2*toll; % la tollerenza iniziale deve essere maggiore
n = 0;
24
% calcolo tramite il metodo di Newton-Raphson il valore di x1
if (ntoll > toll && n <= nmaxiter)
if abs(dfx0) < toll*abs(fx0)
% ovvero se la derivata di f(x0) Ë troppo piccola
dfx0 = toll; % le assegno il valore di toll
end
convstory(n+1, 1:4) = [n x0 fx0 dfx0]; % aggiorno la matrice
x1 = x0 - fx0/dfx0; % trovo il valore di x1
ntoll = abs(x1 - x0); % calcolo il valore della tolleranza
n = n+1;
end
% imposto i valori iniziali per il ciclo della secante variabile

xatt = x1; % dove xatt sta per x_n ed Ë l'ultima stima della radice
xold = x0; % x_n-1, necessaria per il metodo della secante variabile

fxatt = feval(fname, xatt);
fxold = feval(fname, xold);
h = (fxatt - fxold) / (xatt - xold);
convstory(n+1, 1:4) = [n xatt fxatt h]; % aggiorno la convstory
xnew = xatt - fxatt/h;
% cosÏ calcolo la nuova stima della radice (x_n+1)
ntoll = abs(xnew - xatt); % calcolo lo scarto dell'iterazione
xold = xatt; % assegno a xold il valore di x_n-1
xatt = xnew; % assegno a xatt l'ultimo valore della stima
n = n+1;
end
% termino la matrice convstory col valore dell'ultima iterazione

hlast = (fxatt - fxold) / (xatt - xold);
convstory(n+1, 1:4) = [n xnew fxlast hlast];

if (n > nmaxiter && ntoll > toll) % non c'Ë stata convergenza
conv = -1;
end
4.5 Metodo della secante fissa (secfis)

function [x, conv, convstory] = secfis(x0, fname, dfname, parconv)
% [X, CONV, CONVSTORY] = SECFIS(X0, FNAME, DFNAME, PARCONV)
% risolve f(x)=0 utilizzando il metodo iterativo della secante fissa
% con punto iniziale x0 e x1 calcolato col metodo di Newton-Raphson
% |x_(n+1) - x_n| < toll

% parconv(1): toll

25
% imposto i parametri d'entrata
toll = parconv(1);

% assegno i valori iniziali di x, toll, n, fx0 e dfx0

fx0 = feval(fname, x0);
dfx0 = feval (dfname, x0);
n = 0;
% calcolo tramite il metodo di Newton-Raphson il valore di x1

if (ntoll > toll && n <= nmaxiter)
if abs(dfx0) < toll*abs(fx0)
% ovvero se la derivata di f(x0) Ë troppo piccola
dfx0 = toll; % le assegno il valore di toll
end
convstory(n+1, 1:3) = [n x0 fx0]; % aggiorno la matrice
x1 = x0 - fx0/dfx0; % trovo il valore di x1
ntoll = abs(x1 - x0); % calcolo il valore della tolleranza
n = n+1;
end
% calcolo il valore di h_n (per il metodo della secante fissa Ë costante)

fx1 = feval(fname, x1); % valuto la funzione per x1
h = (fx1 - fx0)/(x1 - x0); % ora ho il valore di h_n
xold = x1;

fxold = feval(fname, xold);
convstory (n+1, 1:3) = [n xold fxold]; % aggiorno la matrice
xnew = xold - (fxold/h); % calcolo la nuova stima della radice (x_n+1)
ntoll = abs(xnew-xold); % calcolo il valore dello scarto
xold = xnew; % assegno a x_n il nuovo valore della stima
n = n+1;
end
% termino la matrice convstory col valore dell'ultima iterazione

convstory(n+1, 1:3) = [n xnew fxlast];

x = xnew; % il valore della mia radice
conv = -1;
end

26
4.6 Metodo di bisezione (bisez)
function [x, conv, convstory] = bisez(x0, fname, parconv)
% [X, CONV, CONVSTORY] = BISEZ(X0, FNAME, PARCONV)
% risolve f(x)=0 utilizzando il metodo iterativo della bisezione con
% punti iniziali appartenenti all'intervallo I.
% Il criterio d'uscita prevede che l'ampiezza dell'intervallo che contiene
% la radice sia inferiore a toll

% x0 : intervallo che contiene i valori a e b.
% parconv(1): toll

% 3∞ colonna: estremo inferiore dell'intervallo
% 4∞ colonna: estremo superiore dell'intervallo

toll = parconv(1);
% creo la matrice nulla che conterr‡ la convstory

% stabilisco l'intervallo iniziale, i valori di toll ed n

a = x0(1);
b = x0(2);
ntoll = b-a;
n = 0;
% creo il ciclo per il calcolo della radice

fa = feval(fname, a);
fb = feval(fname, b);
if fa*fb > 0 % la radice non Ë nell'intervallo I = [a,b]
disp('L''intervallo iniziale non Ë accettabile')
else
c = (b + a)/2; % calcolo il punto medio c (la mia radice)
fa = feval(fname, a); % valuto la funzione in a
fc = feval(fname, c); % valuto la funzione in c
convstory(n+1, 1:5) = [n, c, a, b, fc]; % aggiorno la matrice
if sign(fa * fc) > 0 % ovvero se f(a)*f(c) > 0 (hanno segno uguale)
a = c; % la radice si trova tra a e c, quindi pongo b = c
else % ovvero f(a)*f(c) < 0 (hanno segno opposto)
b = c;
end
ntoll = b - a; % controllo l'ampiezza dell'intervallo
n = n+1;
end
end
% completo la matrice convstory coi valori dell'ultima iterazione

c = 0.5*(b+a);
fxlast = feval(fname, c);
convstory(n+1, 1:5) = [n, c, a, b, fxlast];
% definisco i parametri d'uscita

x = c; % il valore finale della mia radice
conv = -1;
end
convstory = convstory(1:n+1, 1:5); % tolgo le righe che mi avanzano
27
4.7 Metodo di punto fisso (puntfis)
function [x, conv, convstory] = puntfis(x0, gname, parconv)
% [X, CONV, CONVSTORY] = PUNTFIS(X0, GNAME, PARCONV)
% risolve f(x)=0 utilizzando il metodo iterativo del punto fisso con
% |x_(n+1) - x_n| < toll

% gname : nome del file Matlab che contiene la funzione g(x)
% (funzione di punto fisso)
% parconv(1): toll

% 3∞ colonna: valore di g(x) per l'iterazione attuale

toll = parconv(1);

% stabilisco i valori iniziali di x, toll e n

xold = x0; % stima iniziale della radice
n = 0;

xnew = feval(gname, xold); % valuto la funzione g in x_n
% osservo che xnew Ë anche il valore della nuova stima della radice
convstory(n+1, 1:3) = [n xold xnew]; % aggiorno convstory
ntoll = abs(xnew - xold); % controllo lo scarto dell'iterazione
xold = xnew; % assegno a x il nuovo valore trovato
n = n+1;
end
% termino la matrice convstory coi valori dell'ultima iterazione

gxlast = feval(gname, xnew);
convstory(n+1, 1:3) = [n xold gxlast];

conv = n; % il numero di iterazioni effettuate
if (n > nmaxiter && ntoll > toll) % non c'Ë stata convergenza
conv = -1;
end
28
4.8 Altre funzioni
function y = fEs1(x)
% f(x) per l'esercitazione assegnata il 24-Mar-2010
y = 3*x.^2-1+log(x);
function y = dfEs1(x)
% derivata di f(x) per l'esercitazione assegnata il 24-Mar-2010
y = 6*x+(1/x);
function y = d2fEs1(x)
% d2f(x) (derivata seconda) per l'esercitazione assegnata il 24-Mar-2010
y = 6-(1/(x.^2));
function y = g1Es1(x)
% prima g(x) consigliata per l'esercitazione assegnata il 24-Mar-2010
y = sqrt((1-log(x))/3);
function y = dg1Es1(x)
% derivata della funzione g1Es1
y = (1/(2*sqrt((1-log(x))/3)))*(-1/(3*x));
function y = g2Es1(x)
% seconda g(x) consigliata per l'esercitazione assegnata il 24-Mar-2010
y = exp(-3*x.^2+1);
29
5. Uscita del programma

>> stimaRadice

-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ METODO DI NEWTON-‐RAPHSON -‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐

funzione usata : fEs1
numero massimo di iterazioni : 50
criterio d'arresto : |s_n| < 1e-‐06
molteplicità della radice : r = 1
convergenza : sì (4 iterazioni (n))

sintesi del processo di convergenza:

n x_n f(x_n) f'(x_n) s_n

0 1.000000000000000 2.000e+00 7.000e+00 2.857e-‐01
1 0.714285714285714 1.941e-‐01 5.686e+00 3.415e-‐02
2 0.680140486699352 2.317e-‐03 5.551e+00 4.175e-‐04
3 0.679723032601509 3.344e-‐07 5.550e+00 6.025e-‐08
4 0.679722972350233 6.883e-‐15 5.550e+00 NaN

stima costante di errore M usando il rapporto degli scarti:

0.418 0.358 0.346

\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
//////////////////////////////////////////////////////////////////////

-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ METODO DELLA TANGENTE FISSA -‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐



n x_n f(x_n) s_n

0 1.000000000000000 2.000e+00 2.857e-‐01
1 0.714285714285714 1.941e-‐01 2.773e-‐02
2 0.686551427389036 3.798e-‐02 5.426e-‐03
3 0.681125078359269 7.785e-‐03 1.112e-‐03
4 0.680012964634302 1.609e-‐03 2.299e-‐04
5 0.679783038797567 3.333e-‐04 4.762e-‐05
6 0.679735417769552 6.907e-‐05 9.867e-‐06
7 0.679725551131274 1.431e-‐05 2.044e-‐06
8 0.679723506699316 2.965e-‐06 4.236e-‐07
9 0.679723083072977 6.145e-‐07 NaN


0.097 0.196 0.205 0.207 0.207 0.207
0.207 0.207

30
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
//////////////////////////////////////////////////////////////////////

-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ METODO DELLA SECANTE VARIABILE -‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐



n x_n f(x_n) h_n s_n

0 1.000000000000000 2.000e+00 7.000e+00 2.857e-‐01
1 0.714285714285714 1.941e-‐01 6.321e+00 3.072e-‐02
2 0.683569837059582 2.138e-‐02 5.625e+00 3.801e-‐03
3 0.679769235048111 2.567e-‐04 5.557e+00 4.620e-‐05
4 0.679723033900763 3.416e-‐07 5.550e+00 6.155e-‐08
5 0.679722972351216 5.461e-‐12 4.166e+03 NaN


0.233 1.065 0.381 0.637

\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
//////////////////////////////////////////////////////////////////////

-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ METODO DELLA SECANTE FISSA -‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐



n x_n f(x_n) s_n

0 1.000000000000000 2.000e+00 2.857e-‐01
1 0.714285714285714 1.941e-‐01 3.072e-‐02
2 0.683569837059582 2.138e-‐02 3.382e-‐03
3 0.680187718507857 2.580e-‐03 4.081e-‐04
4 0.679779597176004 3.142e-‐04 4.972e-‐05
5 0.679729878551882 3.833e-‐05 6.064e-‐06
6 0.679723814763790 4.675e-‐06 7.397e-‐07
7 0.679723075108788 5.703e-‐07 NaN


0.108 0.110 0.121 0.122 0.122 0.122

31
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
//////////////////////////////////////////////////////////////////////

-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ METODO DI BISEZIONE -‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐



n x_n low_x up_x f(x_n) s_n

0 0.600000000000000 0.200000000000000 1.000000000000000 -‐4.308e-‐01 2.000e-‐01
1 0.800000000000000 0.600000000000000 1.000000000000000 6.969e-‐01 1.000e-‐01
2 0.700000000000000 0.600000000000000 0.800000000000000 1.133e-‐01 5.000e-‐02
3 0.650000000000000 0.600000000000000 0.700000000000000 -‐1.633e-‐01 2.500e-‐02
4 0.675000000000000 0.650000000000000 0.700000000000000 -‐2.617e-‐02 1.250e-‐02
5 0.687500000000000 0.675000000000000 0.700000000000000 4.328e-‐02 6.250e-‐03
6 0.681250000000000 0.675000000000000 0.687500000000000 8.479e-‐03 3.125e-‐03
7 0.678125000000000 0.675000000000000 0.681250000000000 -‐8.863e-‐03 1.563e-‐03
8 0.679687500000000 0.678125000000000 0.681250000000000 -‐1.969e-‐04 7.813e-‐04
9 0.680468750000000 0.679687500000000 0.681250000000000 4.140e-‐03 3.906e-‐04
10 0.680078125000000 0.679687500000000 0.680468750000000 1.971e-‐03 1.953e-‐04
11 0.679882812500000 0.679687500000000 0.680078125000000 8.871e-‐04 9.766e-‐05
12 0.679785156250000 0.679687500000000 0.679882812500000 3.451e-‐04 4.883e-‐05
13 0.679736328125000 0.679687500000000 0.679785156250000 7.412e-‐05 2.441e-‐05
14 0.679711914062500 0.679687500000000 0.679736328125000 -‐6.137e-‐05 1.221e-‐05
15 0.679724121093750 0.679711914062500 0.679736328125000 6.375e-‐06 6.104e-‐06
16 0.679718017578125 0.679711914062500 0.679724121093750 -‐2.750e-‐05 3.052e-‐06
17 0.679721069335937 0.679718017578125 0.679724121093750 -‐1.056e-‐05 1.526e-‐06
18 0.679722595214844 0.679721069335937 0.679724121093750 -‐2.093e-‐06 7.629e-‐07
19 0.679723358154297 0.679722595214844 0.679724121093750 2.141e-‐06 3.815e-‐07
20 0.679722976684570 0.679722595214844 0.679723358154297 2.405e-‐08 NaN


0.500 0.500 0.500 0.500 0.500 0.500
0.500 0.500 0.500 0.500 0.500 0.500
0.500 0.500 0.500 0.500 0.500 0.500
0.500

32
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
//////////////////////////////////////////////////////////////////////

-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ METODO DI PUNTO FISSO -‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐

funzione di punto fisso usata : g1Es1


n x_n g(x_n) s_n

0 1.000000000000000 5.774e-‐01 4.226e-‐01
1 0.577350269189626 7.186e-‐01 1.413e-‐01
2 0.718634386489183 6.659e-‐01 5.270e-‐02
3 0.665933568606050 6.847e-‐01 1.880e-‐02
4 0.684729961433595 6.779e-‐01 6.809e-‐03
5 0.677921021783776 6.804e-‐01 2.453e-‐03
6 0.680373545652549 6.795e-‐01 8.852e-‐04
7 0.679488361391006 6.798e-‐01 3.193e-‐04
8 0.679807613405771 6.797e-‐01 1.152e-‐04
9 0.679692440815186 6.797e-‐01 4.155e-‐05
10 0.679733986214736 6.797e-‐01 1.499e-‐05
11 0.679718999315753 6.797e-‐01 5.406e-‐06
12 0.679724405554191 6.797e-‐01 1.950e-‐06
13 0.679722455347831 6.797e-‐01 7.035e-‐07
14 0.679723158849667 6.797e-‐01 NaN


0.334 0.373 0.357 0.362 0.360 0.361
0.361 0.361 0.361 0.361 0.361 0.361
0.361
33

Esercitazione 1 - Studio Di Funzione

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Esercitazione 1 - Studio Di Funzione

Uploaded by

Copyright:

Available Formats

Esercitazione

per il corso di

f (x) = 3x 2 −1+ log(x), I = [0.2,1].

Si applichino, a scelta, almeno 3 tra i suguenti i metodi:

lo scarto sn, e si verifichi se l’ordine di convergenza è p = 1.6181, considerando il

Utilizzando gli scarti è possibile stimare la costante asintotica come:

% Emanuele De Villa Bais $ 29-Mar-2010 / 08-Apr-2010 $

% la mia funzione (nome del file Matlab che la contiene)

% nome della derivata della funzione

% nome della funzione di punto fisso g

% intervallo che contiene la radice

% stima iniziale della radice

% imposto i parametri per il test d'arresto

% scelgo i metodi da utilizzare nella stima della radice

% scelgo se creare il grafico della funzione

% scelgo se creare il grafico degli scarti

%%%%%%%%%%%% CODICE %%%%%%%%%%%

% imposto la eventuale creazione del grafico di f con tabella

% creo la tabella tabgrafico coi valori di x e f(x)

% imposto i parametri d'ingresso del metodo

% chiamo la function newton.m

%%%%%%%%%%%% METODO DELLA TANGENTE FISSA %%%%%%%%%%%

% imposto i parametri d'ingresso del metodo

% chiamo la function tanfis.m

%%%%%%%%%%%% METODO DELLA SECANTE VARIABILE %%%%%%%%%%%

% imposto i parametri d'ingresso del metodo

% chiamo la function secvar.m

% imposto i parametri d'ingresso del metodo

% chiamo la function secfis.m

%%%%%%%%%%%% METODO DI BISEZIONE %%%%%%%%%%%

% imposto i parametri d'ingresso del metodo

% chiamo la function bisez.m

%%%%%%%%%%%% METODO DEL PUNTO FISSO %%%%%%%%%%%

% imposto i parametri d'ingresso del metodo

% chiamo la function puntfis.m

% imposto l'eventuale creazione del grafico degli scarti

4.2 Metodo di Newton-­Raphson (newton)

%%%%%%%%%%% PARAMETRI DI INGRESSO %%%%%%%%%%

%%%%%%%%%%% PARAMETRI DI USCITA %%%%%%%%%%

% Emanuele De Villa Bais $ 28-Mar-2010 $

% stabilisco i parametri d'entrata

% creo la matrice nulla che conterr‡ la convstory

% creo il ciclo che calcoler‡ l'approssimazione della radice

% termino la matrice convstory coi valori dell'ultima iterazione

% definisco i parametri di uscita

convstory = convstory(1:n+1, 1:4); % tolgo le righe che mi avanzano

4.3 Metodo della tangente fissa (tanfis)

%%%%%%%%%%% PARAMETRI DI INGRESSO %%%%%%%%%%

%%%%%%%%%%% PARAMETRI DI USCITA %%%%%%%%%%

% Emanuele De Villa Bais $ 28-Mar-2010 $

% stabilisco i parametri d'entrata

% creo la matrice nulla che conterr‡ convstory

% creo il ciclo che calcoler‡ l'approssimazione della radice

% termino la matrice convstory coi valore dell'ultima iterazione

% assegno i parametri d'uscita

convstory = convstory(1:n+1, 1:3); % elimino le righe che mi avanzano

4.4 Metodo della secante variabile (secvar)

%%%%%%%%%%% PARAMETRI DI INGRESSO %%%%%%%%%%

%%%%%%%%%%% PARAMETRI DI USCITA %%%%%%%%%%

% Emanuele De Villa Bais $ 28-Mar-2010 $

% imposto i parametri d'entrata

% creo la matrice nulla che conterr‡ convstory

% assegno i valori iniziali di x, toll, n, fx0 e dfx0

4.2 Metodo di Newton-Raphson (newton)