Sei sulla pagina 1di 34

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.  
 
 
Utilizzando  gli  scarti  è  possibile  stimare  la  costante  asintotica  come:  
 
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.  
 
 
Utilizzando  gli  scarti  è  possibile  stimare  la  costante  asintotica  come:  
 
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.  
 
 
Utilizzando  gli  scarti  è  possibile  stimare  la  costante  asintotica  come:  
 
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  
di  cui  l’ultimo  è  in  ottimo  accordo  con  la  stima:  
  €

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).  

Di  conseguenza  la  velocità  di  convergenza  R  risulta:   €
 
€ R = − log M = 0.913707  
 
 
  €
 
 
 
 
 

11  
Posso  ora  facilmente  approssimare  il  numero  di  iterazioni  necessarie  per  avere  
|en|/|e0|    <  TOLL  secondo  la  formula:  
 
logTOLL
n≥ = 6.567  
log M
 
che  combacia  perfettamente  con  la  quantità  di  iterazioni  eseguite  per  ottenere  la  migliore  
approssimazione  della  radice x 7 .  
  €
 
 
 
  €
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

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.  
 
 
Utilizzando  gli  scarti  è  possibile  stimare  la  costante  asintotica  come:  
 
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  
 
Posso  ora  facilmente  approssimare  il  numero  di  iterazioni  necessarie  per  avere  
|en|/|e0|    <  TOLL  secondo  l€
a  formula:  
 
logTOLL
n≥ = 19.932  
log M
 
che  combacia  perfettamente  con  la  quantità  di  iterazioni  eseguite  per  ottenere  la  migliore  
approssimazione  della  radice x 20 .  

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  
Utilizzando  gli  scarti  è  possibile  stimare  la  costante  asintotica  come:  
 
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  
di  cui  l’ultimo  è  in  ottimo  accordo  con  la  stima:  
  €
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).  
Di  conseguenza  la  velocità  di  convergenza  R  risulta:   €
 
€ R = − log M = 0.442815  
 
Posso  ora  facilmente  approssimare  il  numero  di  iterazioni  necessarie  per  avere  
|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)

% imposto i parametri d'ingresso del metodo


parconv = [toll nmaxiter];

% chiamo la function tanfis.m


[tfx, tfconv, tfconvstory] = tanfis(x0, fname, dfname, parconv);

% stampo i risultati
if (graficofunz == 1 || metodo(1))
disp(['\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'...
'\\\\\\\\\\\\\\\'])
disp(['///////////////////////////////////////////////////////'...
'///////////////']), disp(' ')
end
disp(' ')
disp('--------------- METODO DELLA TANGENTE FISSA ---------------')
disp(' ')
disp(['funzione usata : ', fname])
disp(['numero massimo di iterazioni : ', int2str(nmaxiter)])
disp(['criterio d''arresto : ', '|s_n| < ', ...
num2str(toll)])

18  
if tfconv == -1 % ovvero non c'Ë stata convergenza
messaggio = 'convergenza : no';
else
messaggio = ['convergenza : sÏ (', ...
int2str(tfconv), ' iterazioni (n))'];
end
disp(messaggio), disp(' '), disp(' ')
if tfconv > 0 % se il metodo converge stampo la convstory
disp('sintesi del processo di convergenza:'), disp(' ')
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));
% ora posso creare la mia tabella
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('stima costante di errore M usando il rapporto degli scarti:')
disp(' ')
% calcolo la costante M (tfM) per ogni iterazione
tfM = abs(tfscar(2:length(tfscar)))./ ...
abs(tfscar(1:length(tfscar)-1));
% creo la tabella per la costante M
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)

% imposto i parametri d'ingresso del metodo


parconv = [toll nmaxiter];

% chiamo la function secvar.m


[svx, svconv, svconvstory] = secvar(x0, fname, dfname, parconv);

% stampo i risultati
if (graficofunz == 1 || metodo(1) || metodo(2))
disp(['\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'...
'\\\\\\\\\\\\\\\'])
disp(['///////////////////////////////////////////////////////'...
'///////////////']), disp(' ')
end
disp(' ')
disp('--------------- METODO DELLA SECANTE VARIABILE ---------------')
disp(' ')
disp(['funzione usata : ', fname])
disp(['numero massimo di iterazioni : ', int2str(nmaxiter)])
disp(['criterio d''arresto : ', '|s_n| < ', ...
num2str(toll)])
if svconv == -1 % ovvero non c'Ë stata convergenza
messaggio = 'convergenza : no';
else
messaggio = ['convergenza : sÏ (', ...
int2str(svconv), ' iterazioni (n))'];
end
disp(messaggio), disp(' '), disp(' ')
if svconv > 0 % se il metodo converge stampo la convstory
disp('sintesi del processo di convergenza:'), disp(' ')
disp([' n x_n f(x_n) h_n'...
' s_n']), disp(' ')
% calcolo gli scarti
svscar = abs(svconvstory(2:length(svconvstory), 2) - ...
svconvstory(1:length(svconvstory)-1, 2));
% ora posso creare la mia tabella
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('stima costante di errore M usando il rapporto degli scarti:')
disp(' ')
% calcolo la costante M (svM) per ogni iterazione
svM = abs(svscar(2:length(svscar)))./ ...
((abs(svscar(1:length(svscar)-1))).^1.6181);
% creo la tabella per la costante M
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)

% imposto i parametri d'ingresso del metodo


parconv = [toll nmaxiter];

% chiamo la function secfis.m


[sfx, sfconv, sfconvstory] = secfis(x0, fname, dfname, parconv);

% stampo i risultati
if (graficofunz == 1 || metodo(1) || metodo(2) || metodo(3))
disp(['\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'...
'\\\\\\\\\\\\\\\'])
disp(['///////////////////////////////////////////////////////'...
'///////////////']), disp(' ')
end
disp(' ')
disp('--------------- METODO DELLA SECANTE FISSA ---------------')
disp(' ')
disp(['funzione usata : ', fname])
disp(['numero massimo di iterazioni : ', int2str(nmaxiter)])
disp(['criterio d''arresto : ', '|s_n| < ', ...
num2str(toll)])
if sfconv == -1 % ovvero non c'Ë stata convergenza
messaggio = 'convergenza : no';
else
messaggio = ['convergenza : sÏ (', ...
int2str(sfconv), ' iterazioni (n))'];
end
disp(messaggio), disp(' '), disp(' ')
if sfconv > 0 % se il metodo converge stampo la convstory
disp('sintesi del processo di convergenza:'), disp(' ')
disp([' n x_n f(x_n) '...
' s_n']), disp(' ')
% calcolo gli scarti
sfscar = abs(sfconvstory(2:length(sfconvstory), 2) - ...
sfconvstory(1:length(sfconvstory)-1, 2));
% ora posso creare la mia tabella
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('stima costante di errore M usando il rapporto degli scarti:')
disp(' ')
% calcolo la costante M (sfM) per ogni iterazione
sfM = abs(sfscar(2:length(sfscar)))./ ...
abs(sfscar(1:length(sfscar)-1));
% creo la tabella per la costante M
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)

% imposto i parametri d'ingresso del metodo


parconv = [toll nmaxiter];

% chiamo la function bisez.m


[bx, bconv, bconvstory] = bisez(I, fname, parconv);

% stampo i risultati
if (graficofunz == 1 || metodo(1) || metodo(2) || metodo(3) ||...
metodo(4))
disp(['\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'...
'\\\\\\\\\\\\\\\'])
disp(['///////////////////////////////////////////////////////'...
'///////////////']), disp(' ')
end
disp(' ')
disp('--------------- METODO DI BISEZIONE ---------------')
disp(' ')
disp(['funzione usata : ', fname])
disp(['numero massimo di iterazioni : ', int2str(nmaxiter)])
disp(['criterio d''arresto : ', '|s_n| < ', ...
num2str(toll)])
if bconv == -1 % ovvero non c'Ë stata convergenza
messaggio = 'convergenza : no';
else
messaggio = ['convergenza : sÏ (', ...
int2str(bconv), ' iterazioni (n))'];
end

20  
disp(messaggio), disp(' '), disp(' ')
if bconv > 0 % se il metodo converge stampo la convstory
disp('sintesi del processo di convergenza:'), disp(' ')
disp([' n x_n low_x'...
' up_x f(x_n)'...
' s_n']), disp(' ')
% calcolo gli scarti
bscar = abs(bconvstory(2:length(bconvstory), 2) - ...
bconvstory(1:length(bconvstory)-1, 2));
% ora posso creare la mia tabella
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('stima costante di errore M usando il rapporto degli scarti:')
disp(' ')
% calcolo la costante M (svM) per ogni iterazione
bM = abs(bscar(2:length(bscar)))./ ...
(abs(bscar(1:length(bscar)-1)));
% creo la tabella per la costante M
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)

% imposto i parametri d'ingresso del metodo


parconv = [toll nmaxiter];

% chiamo la function puntfis.m


[pfx, pfconv, pfconvstory] = puntfis(x0, gname, parconv);

% stampo i risultati
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 usata : ', fname])
disp(['funzione di punto fisso usata: ', gname])
disp(['numero massimo di iterazioni : ', int2str(nmaxiter)])
disp(['criterio d''arresto : ', '|s_n| < ', ...
num2str(toll)])
if pfconv == -1 % ovvero non c'Ë stata convergenza
messaggio = 'convergenza : no';
else
messaggio = ['convergenza : sÏ (', ...
int2str(pfconv), ' iterazioni (n))'];
end
disp(messaggio), disp(' '), disp(' ')
if pfconv > 0 % se il metodo converge stampo la convstory
disp('sintesi del processo di convergenza:'), disp(' ')
disp([' n x_n g(x_n) '...
' s_n']), disp(' ')
pfscar = abs(pfconvstory(2:length(pfconvstory), 2) - ...
pfconvstory(1:length(pfconvstory)-1, 2));
% ora posso creare la mia tabella
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('stima costante di errore M usando il rapporto degli scarti:')
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)));
% creo la tabella per la costante M
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
% 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 (1x2) che contiene i parametri per la convergenza
% parconv(1): toll
% parconv(2): nmaxiter
% toll : tollerenza desiderata per lo scarto
% nmaxiter : numero massimo di iterazioni da effettuare

%%%%%%%%%%% 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)x3] 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

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

% stabilisco i parametri d'entrata


toll = parconv(1);
nmaxiter = parconv(2);

% creo la matrice nulla che conterr‡ convstory


convstory = zeros(nmaxiter+1, 3);

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
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 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


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

% assegno i parametri d'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: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
% 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 (1x2) che contiene i parametri per la convergenza
% parconv(1): toll
% parconv(2): nmaxiter
% toll : tollerenza desiderata per lo scarto
% nmaxiter : numero massimo di iterazioni da effettuare

%%%%%%%%%%% 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 h_n: (f(x_n) - f(x_n-1))/(x_n - x_n-1)

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

% imposto i parametri d'entrata


toll = parconv(1);
nmaxiter = parconv(2);

% creo la matrice nulla che conterr‡ convstory


convstory = zeros(nmaxiter+1, 4);

% 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

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


while (ntoll > toll && n <= nmaxiter)
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


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

% assegno i parametri d'uscita


x = xnew; % il valore finale della mia radice
conv = n; % il numero di iterazioni eseguite
if (n > nmaxiter && ntoll > toll) % non c'Ë stata convergenza
conv = -1;
end

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

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
% 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 (1x2) che contiene i parametri per la convergenza
% parconv(1): toll
% parconv(2): nmaxiter
% toll : tollerenza desiderata per lo scarto
% nmaxiter : numero massimo di iterazioni da effettuare

%%%%%%%%%%% 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)x3] 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

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

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

% creo la matrice nulla che conterr‡ convstory


convstory = zeros(nmaxiter+1, 3);

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


fx0 = feval(fname, x0);
dfx0 = feval (dfname, x0);
ntoll = 2*toll; % la tolleranza iniziale deve essere maggiore
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;

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


while (ntoll > toll && n <= nmaxiter)
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


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

% assegno i parametri d'uscita


x = xnew; % il valore 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:3); % elimino le righe che mi avanzano

 
 
 
 
 
 
 
 
 
 
 

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

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


% x0 : intervallo che contiene i valori a e b.
% fname : nome del file Matlab che contiene la funzione f(x)
% parconv : vettore (1x2) che contiene i parametri per la convergenza
% parconv(1): toll
% parconv(2): nmaxiter
% toll : tollerenza desiderata per lo scarto
% nmaxiter : numero massimo di iterazioni da effettuare

%%%%%%%%%%% 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)x5] 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: estremo inferiore dell'intervallo
% 4∞ colonna: estremo superiore dell'intervallo
% 5∞ 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);

% creo la matrice nulla che conterr‡ la convstory


convstory = zeros(nmaxiter+1, 5);

% 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
while (ntoll > toll && n <= nmaxiter)
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 = 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: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
% 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.
% gname : nome del file Matlab che contiene la funzione g(x)
% (funzione di punto fisso)
% parconv : vettore (1x2) che contiene i parametri per la convergenza
% parconv(1): toll
% parconv(2): nmaxiter
% toll : tollerenza desiderata per lo scarto
% nmaxiter : numero massimo di iterazioni da effettuare

%%%%%%%%%%% 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)x3] 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 g(x) per l'iterazione attuale

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

% stabilisco i parametri d'entrata


toll = parconv(1);
nmaxiter = parconv(2);

% creo la matrice nulla che conterr‡ convstory


convstory = zeros(nmaxiter+1, 3);

% stabilisco i valori iniziali di x, toll e n


xold = x0; % stima iniziale della radice
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)
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];

% assegno i parametri d'uscita


x = xnew; % il valore finale della mia radice
conv = n; % il numero di iterazioni effettuate
if (n > nmaxiter && ntoll > toll) % non c'Ë stata convergenza
conv = -1;
end

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

28  
4.8     Altre  funzioni  
function y = fEs1(x)
% f(x) per l'esercitazione assegnata il 24-Mar-2010

% Emanuele De Villa Bais $ 28-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

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

y = 6*x+(1/x);

function y = d2fEs1(x)
% d2f(x) (derivata seconda) per l'esercitazione assegnata il 24-Mar-2010

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

y = 6-(1/(x.^2));

function y = g1Es1(x)
% prima g(x) consigliata per l'esercitazione assegnata il 24-Mar-2010

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

y = sqrt((1-log(x))/3);

function y = dg1Es1(x)
% derivata della funzione g1Es1

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

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

% Emanuele De Villa Bais $ 28-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    -­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐  
   
funzione  usata                                :  fEs1  
numero  massimo  di  iterazioni  :  50  
criterio  d'arresto                              :  |s_n|  <  1e-­‐06  
convergenza                                                                      :  sì  (9  iterazioni  (n))  
   
   
sintesi  del  processo  di  convergenza:  
   
   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    
 
   
stima  costante  di  errore  M  usando  il  rapporto  degli  scarti:  
   
         0.097            0.196            0.205            0.207            0.207            0.207    
         0.207            0.207    
   

30  
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\  
//////////////////////////////////////////////////////////////////////  
   
   
-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐    METODO  DELLA  SECANTE  VARIABILE    -­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐  
   
funzione  usata                                :  fEs1  
numero  massimo  di  iterazioni  :  50  
criterio  d'arresto                              :  |s_n|  <  1e-­‐06  
convergenza                                              :  sì  (5  iterazioni  (n))  
   
   
sintesi  del  processo  di  convergenza:  
   
   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    
 
   
stima  costante  di  errore  M  usando  il  rapporto  degli  scarti:  
   
         0.233            1.065            0.381            0.637    
   
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\  
//////////////////////////////////////////////////////////////////////  
   
   
-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐    METODO  DELLA  SECANTE  FISSA    -­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐  
   
funzione  usata                                            :  fEs1  
numero  massimo  di  iterazioni  :  50  
criterio  d'arresto                          :  |s_n|  <  1e-­‐06  
convergenza                                              :  sì  (7  iterazioni  (n))  
   
   
sintesi  del  processo  di  convergenza:  
   
   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    
 
   
stima  costante  di  errore  M  usando  il  rapporto  degli  scarti:  
   
         0.108            0.110            0.121            0.122            0.122            0.122    
 
 
 
 
   

31  
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\  
//////////////////////////////////////////////////////////////////////  
   
   
-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐    METODO  DI  BISEZIONE    -­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐  
   
funzione  usata                                              :  fEs1  
numero  massimo  di  iterazioni  :  50  
criterio  d'arresto                              :  |s_n|  <  1e-­‐06  
convergenza                                              :  sì  (20  iterazioni  (n))  
   
   
sintesi  del  processo  di  convergenza:  
   
   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    
 
   
stima  costante  di  errore  M  usando  il  rapporto  degli  scarti:  
   
         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  usata                                                :  fEs1  
funzione  di  punto  fisso  usata      :  g1Es1  
numero  massimo  di  iterazioni  :  50  
criterio  d'arresto                                        :  |s_n|  <  1e-­‐06  
convergenza                                                  :  sì  (14  iterazioni  (n))  
   
   
sintesi  del  processo  di  convergenza:  
   
   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    
 
   
stima  costante  di  errore  M  usando  il  rapporto  degli  scarti:  
   
         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