CALCOLONUMERICO1

Programma del Corso di
CALCOLO NUMERICO
a.a. 2010/2011
Prof. Giulio Giunta
Il corso è una introduzione alle metodologie generali, alle tecniche e alle competenze operative legate allo
sviluppo e all’analisi di algoritmi e software nel campo del calcolo scientifico. Il corso contiene una
introduzione al linguaggio MATLAB, che viene utilizzato per lo sviluppo del software nelle attività di
Laboratorio.
Prerequisiti: Matematica I, Programmazione I.
Programma dettagliato
Introduzione al calcolo scientifico. Ore di lezione: 2

Modelli matematici, modelli numerici, algoritmi e software scientifico - importanza delle simulazioni
numeriche - la computational science - il contesto tecnologico - web e calcolo scientifico.
Approfondimenti sulla rappresentazione floating-point: massima accuratezza dell’unità aritmetica, errore
assoluto e relativo, epsilon macchina.
Programmazione in MATLAB. Ore di laboratorio:3.

MATLAB come linguaggio di programmazione - programmazione a parallelismo sui dati - visualizzazione
scientifica in MATLAB. Confronto tra la programmazione in MATLAB e in C. Approfondimenti in C e Matlab
sulla rappresentazione floating-point: epsilon macchina, spaziatura tra numeri f-p, cifre significative,
accuratezza del rapporto incrementale in precisione finita, massimi e minimi dei numeri f-p.
Risoluzione di una equazione. Ore di lezione: 5. Ore di laboratorio: 2.

Equazioni non lineari e metodi iterativi, metodi di bisezione, di Newton, delle secanti e ibridi - convergenza,
velocità di convergenza e criteri di arresto - risoluzione del problema del punto fisso e metodo del punto
fisso – convergenza del metodo del punto fisso – punto fisso e analisi di convergenza dei metodi iterativi -
la function MATLAB fzero.
Calcolo di massimi e minimi di funzioni. Ore di lezione: 3. Ore di laboratorio: 2.

Metodo di minimizzazione di Newton e sue varianti – cenno al metodo del gradiente discendente – metodi
di minimizzazione di funzioni unimodali: Fibonacci search e Golden search - convergenza, velocità di
convergenza e criteri di arresto - la function MATLAB fminbnd.
Algebra lineare numerica. Ore di lezione: 6. Ore di laboratorio: 3.

operazioni e computazioni base con vettori e matrici: prodotto scalare e angolo tra vettori, algoritmi per
prodotto matrice-vettore – trasformazioni lineari di vettori: rotazioni, riflessioni, scalatura, shearing –
applicazione alla generazione di frattali - algoritmi per prodotto matrice-matrice - norme di vettori e di
matrici - aspetti strutturali delle matrici - matrici sparse - sistemi di equazioni lineari - algoritmi per la
risoluzione di sistemi triangolari - algoritmo di Gauss - complessità di tempo dell’algoritmo di Gauss -
fattorizzazione LU - stabilità e pivoting – algoritmo di Gauss-Jordan - applicazioni della fattorizzazione LU:
calcolo del determinante, risoluzione di sistemi multipli, calcolo della matrice inversa - i principali operatori
e function MATLAB per l’algebra lineare numerica.
Fitting di dati. Ore di lezione: 8. Ore di laboratorio: 4.
iInterpolazione di dati e approssimazione di dati - interpolazione lagrangiana e di Hermite - interpolazione
con polinomi - interpolazione con modelli lineari - limiti dell’interpolazione polinomiale su nodi equispaziati
– nodi di Chebychev - interpolazione con polinomi a tratti, con spline e con cubiche di Hermite -
interpolazione con curve parametriche - applicazioni alla grafica computazionale - interpolazione
quadratica inversa e applicazione al problema di risoluzione di una equazione – il problema
dell’approssimazione – residuo - approssimazione nel senso dei minimi quadrati - minimi quadrati lineari:
interpretazione analitica e geometrica – il sistema delle equazioni normali – sistemi lineari sovradeterminati
- applicazioni alla statistica (regressione lineare) - i principali operatori e function MATLAB per
l’interpolazione e l’approssimazione di dati.
Integrazione numerica. Ore di lezione: 4. Ore di laboratorio: 2.

formule di base e formule composite: rettangolare, punto medio, trapezoidale, di Simpson - quadratura
composita con spline e cubiche di Hermite interpolanti - analisi dell’errore delle formule di quadratura
composita - algoritmi adattativi di quadratura – metodi Monte Carlo per la quadratura - la function MATLAB
quad.
Statistica descrittiva. Ore di lezione: 2. Ore di laboratorio: 2.

campioni – istogrammi - indici di posizione: media, moda, mediana, quartili - indici di variabilità: deviazione
standard e varianza campionaria, deviazione media – standardizzazione di un campione di dati - indici di
asimmetria e di forma: skewness, curtosi - dati di tipo qualitativo e indici di mutabilità: indice di Gini,
entropia di Shannon - cenni al caso multivariato: diagramma di dispersione, matrice di covarianza e di
correlazione – le principali function MATLAB per la statistica descrittiva con cenni al toolbox statistico.
Materiale didattico fornito

Le presentazioni multimediali in audio-video e copia delle slide (formato .pdf, .pps e ) di tutte le lezioni sono
disponibili sulla piattaforma di e-learning (http://e-scienzeetecnologie.uniparthenope.it/moodle/).
Testi consigliati
A.QUARTERONI, C. SALERI: “Introduzione al Calcolo Scientifico”, II Ed., Springer, 2004.
A.MURLI: “Matematica Numerica: metodi, algoritmi e software". Liguori, 2007.
W.J. PALM - “MATLAB per l’ingegneria” - McGraw Hill Italia, 2001.
Corso di Calcolo Numerico
CdL Informatica,
Calcolo Numerico e Matematica Applicata
CdL SNeA - 6 CFU
Prof. Giulio GIUNTA

giulio.giunta@uniparthenope.it
modalità esame:
orale con prova Matlab (40%)+ 2 Prove
intercorso (40%) + 2 HomeWork (20%)
Prof. Giulio GIUNTA
giulio.giunta@uniparthenope.it
Orario ricevimento:
lunedì, ore 14:00 – 16:00, stanza 420,
quarto piano Nord
Tutor: dott. Mario RUGGIERI

mario.ruggieri@studenti.uniparthenope.it
Orario ricevimento:
martedì, ore 16:00 – 18:00, LabMNCP,
quarto piano Nord
Materiale didattico
presentazioni multimediali con registrazione audio, slide
delle lezioni e delle esercitazioni di Laboratorio (.pps, .pdf),
sintesi delle lezioni (.pdf, e-book), programmi Matlab (.m),
quiz di autovalutazione, esercizi, tutte le vecchie prove di
esame:
sulla piattaforma di e-learning
testi utili:
A. Murli
Matematica numerica: metodi, algoritmi e software
Liguori Editore, 2007
A. Quarteroni, F. Saleri
Introduzione al Calcolo Scientifico
Springer Italia, 2000
Attività di Laboratorio
Suddivisione in gruppi di Lab di 35 - 40 studenti

Uso del sistema MATLAB
Sviluppo guidato di progetti (in Lab)
Esercitazioni in aula con il Tutor
scaricare MATLAB dal sito

sd.uniparthenope.it
e installarlo sul proprio pc
Corso di Calcolo Numerico
fondamenti di calcolo scientifico

(scientific computing)
progetto, analisi e sviluppo

di algoritmi, software e sistemi software
per la risoluzione di problemi di
matematica applicata nelle applicazioni
scientifiche e tecnologiche
discipline applicative (ingegneria, economia,..)
calcolo scientifico
informatica
schema del processo di risoluzione di un problema
nel calcolo scientifico
problema applicativo
modello matematico
modello numerico
algoritmo
software
strumenti di sviluppo (nel corso)
il WEB
calcolo scientifico
altri linguaggi di MATLAB

programmazione
Servizi di distribuzione di software scientifico
http://www.netlib.org
http://www.nhse.org/
http://math.nist.gov/
http://math.nist.gov/MatrixMarket/
http://gams.nist.gov/
MATLAB
http://www.mathworks.com
MATLAB @ Informatica Uniparthenope
L’Università Parthenope offre agli studenti la

possibilità di installare gratuitamente MATLAB,
Simulink e altri prodotti software aggiuntivi sul
proprio personal computer.
Per installare Matlab, seguire la procedura sul sito
https://sd.uniparthenope.it
MATLAB
http://www.mathworks.com
il servizio MATLAB Central File Exchange contiene

migliaia di programmi sviluppati dagli utenti MATLAB:
http://www.mathworks.com/matlabcentral/fileexchange/
https://www.gnu.org/software/octave/
OCTAVE
versione 3.8.x
GNU General Public License

struttura del corso (CN, CNeMA)
 sistema aritmetico di un computer
 risoluzione di una equazione
 calcolo di massimi e minimi di funzioni
 risoluzione di sistemi di equazioni lineari
 fitting di dati: interpolazione
 fitting di dati: approssimazione (min. quadrati)
 integrazione numerica
 statistica descrittiva
 il sistema (“linguaggio”) MATLAB
quattro ore di lezione in aula
2 lezioni (nel semestre, per gruppo) di
laboratorio di approfondimento
quattro ore di lezione in aula
portare un pc laptop (con Matlab) per le
lezioni in aula
una esercitazione settimanale in aula con
il Tutor (sviluppo guidato di progetti)
portare un pc laptop (con Matlab)
Prerequisiti
Esempio: dati 10 numeri, memorizzati in un vettore vet,
calcolare la loro somma
>> vet = [31 14 28 5 -12 32 -25 19 0 66];

>> somma = 0;
>> for i = 1:10
somma = somma + vet(i);
end
>> somma
somma =
158
Prerequisiti
Esempio: dati 10 numeri, memorizzati in un vettore vet,
calcolare il massimo e la sua posizione
>> vet = [31 14 28 5 -12 32 -25 19 0 66];

>> mas = vet(1); indmas = 1;
>> for i = 2:10
if vet(i) > mas
mas = vet(i); indmas = i;
end
end
>> [mas indmas]
ans =
66 10
Esempio: risolvere gli esempi precedenti usando le
function Matlab
>> vet = [31 14 28 5 -12 32 -25 19 0 66];
>> somma = sum(vet);
somma =
158
>> mas = max(vet);
mas =
66
>> [mas indmas] = max(vet);
mas =
66
indmas =
10
Esempio: costruzione e uso di function utente
function risultato = piugrande(x,y)
if x > y
risultato = x;
else
risultato = y;
end
>> a = piugrande(7,8)
a =
8
>> p = -73*8; q = exp(2.1);
>> b = piugrande(p,q)
b =
8.1662
sistema aritmetico di un computer
(ma anche di un tablet, di uno smartphone, etc.)
 organizzazione della Unità logico -

aritmetica (ALU) del Processore (CPU)
 rappresentazione dei numeri in

memoria
l’unità logico aritmetica (ALU) è la parte del
processore che effettua le operazioni
aritmetiche e logiche (confronto) su dati in
memoria
la ALU ha accesso diretto alla memoria

principale (RAM), che può essere organizzata
su più livelli
una ALU deve rispettare precisi

standard industriali
l’input per la ALU consiste in una istruzione (in
linguaggio macchina) che contiene un codice
operativo e uno o più operandi
il codice operativo denota l’operazione da

effettuare e gli operandi sono le quantità da
coinvolgere nell’operazione (per esempio,
somma o confronto)
l’output per la ALU è il risultato

dell’operazione, che viene memorizzato in voci
di memoria interne alla ALU, dette registri
una ALU ha
 registri per gli operandi in input

 registri per i dati parziali (per es. un dato
incolonnato per una addizione)
 registri per i risultati (detti anche
accumulatori)
rappresentazione dei numeri in memoria
 rappresentazione posizionale
 notazione scientifica
 rappresentazione a precisione finita
 base 2
rappresentazione posizionale
425.76
1 2
4 10  2 10  5 10  7 10  6 10
2 1 0
notazione scientifica
4.2576 10 2
in posizione fissa
notazione scientifica
esponente
4.2576 10 2
mantissa
m  b e base
(fissa)
mantissa  base esponente
ordine di grandezza
0.0000076
notazione scientifica:
6
7.6 10
evita di visualizzare/memorizzare
gli zeri non significativi
(ovvero gli zeri “in testa”)
il massimo numero di cifre per rappresentare
la mantissa e l’esponente è fissato
rappresentazione finita
rappresentazione normalizzata,
a precisione finita (base 2)
limitazioni su m e su e:
 m è compreso tra 1 e 2, (1<=m <2)
(normalizzazione)
 e è un intero con al più E cifre binarie,
ovvero e è compreso tra 0 e 2E-1,
(range finito)
 m ha al più t cifre binarie (precisione finita)
i numeri rappresentati in memoria sono detti
numeri floating point (fp)
 l’insieme dei numeri fp è finito

 esiste il minimo numero fp
 esiste il massimo numero fp
 fissato un qualunque numero fp, minore
del massimo numero fp, esiste il
numero fp successivo
Aritmetica standard IEEE
Nel 1985 lo
IEEE Standards Board and the American
National Standards Institute
ha adottato lo ANSI/IEEE Standard 754-1985
per l’aritmetica floating-point
oggi tutti i computer

usano l’aritmetica IEEE
rappresentazione fp ±m× b in singola
e
precisione e in doppia precisione

mantissa
e + bias
±1. frazione × 2
vengono memorizzate solo le quantità
 segno
 frazione
 esponente (e + bias)
rappresentazione fp ±m× b in singola
e
precisione e in doppia precisione

mantissa
e + bias
±1. frazione × 2
segno esponente frazione bias
singola precisione 1 [32] 8 [31-24] 23 [23-01] 127
doppia precisione 1 [64] 11 [63-53] 52 [52-01] 1023
range singola precisione  10 38
(intervallo rappresentabile)
- (2-2 )  2 ,- 2
-23 127 -126
 2 -126
,(2-2 )  2 
-23 127
range doppia precisione  10 308
(intervallo rappresentabile)
- (2-2 )  2 ,- 2
-52 1023 -1022
 2
-1022
, (2-2 )  2
-52 1023

 il segno è rappresentato con un bit,
che vale 0 per positivo e 1 per negativo
 la base dell’esponente è 2
 l’esponente (memorizzato) è 127+e in
singola precisione, 1023+e in doppia
precisione
 il primo bit della mantissa, che è sempre 1,
non viene memorizzato esplicitamente;
ovvero, il campo mantissa contiene solo
la frazione (la parte frazionaria della
mantissa)
singola precisione
00100001 00000000
11000000 00001000
segno esponente frazione

00100001 00000000
11000000 00001000
frazione
00000000 10000000
00000000 00000000
1.0000000 00000000 00000000x2-126
(è il più piccolo numero rappresentabile;
l’esponente = 0 è riservato per situazioni eccezionali)
(il suo successivo)

1.0000000 00000000 00000001x2-126
00000000 10000000
23
00000000 00000001 2
rappresentazione del numero 0 (zero)
00000000 00000000
00000000 00000000

00000000 00000000
00000000 00000000
frazione
doppia precisione
00000000 00010000
00000000 00000000
00000000 00000000
52
00000000 00000001 2
frazione
overflow: numeri troppo grandi, in valore assoluto
underflow: numeri troppo piccoli, in valore assoluto
o o
v intervallo rappresentabile v
e 0 e
r r
f f
l l
o o
underflow
w w
intervallo rappresentabile (range): unione degli intervalli dei
numeri che possono essere rappresentati, eventualmente in
modo approssimato, attraverso arrotondamento della mantissa
alla precisione del sistema
intervallo rappresentabile
0
numeri fp
numeri rappresentabili esattamente

(la loro mantissa ha un numero di cifre minore o uguale alla
precisione del sistema)
le operazioni aritmetiche eseguite

dall’unita aritmetica
(su numeri fp)
sono dette operazioni fp
il risultato di una operazione fp

è il risultato dell’operazione usuale
rappresentato come numero fp
(massima accuratezza)
massima accuratezza
numeri fp
x  y = arrotondamento( x  y)
rappresentazione del risultato
“vero” con mantissa arrotondata
operazione fp alla precisione del sistema (t bit)
massima accuratezza
registri interni di almeno 80 bit

con mantissa di almeno 58 bit
registri interni ALU
00000000 00000000
00000000 00000000
00000000 00000000
00000000 00000000
00000000 00000000
#include <stdio.h>
void main()
{
int cont; float uno,sum,numero;
numero = 1.0F;
uno = 1.0F;
cont = 0;
sum = uno+numero;
while(sum>uno)
{
numero = numero/2; cont++;
sum = uno+numero;
}
numero = numero*2;
printf(“numero= %16.8e \n numero
divisioni= %d\n",numero,cont);
}
numero = 1.19209290e-7
numero divisioni= 24
output
numero è una stima di epsMacchina
epsMacchina è il più piccolo numero fp che

sommato a 1.0, mediante addizione fp,
fornisce un risultato
strettamente maggiore di 1.0

sommato a 1.0, mediante addizione fp, fornisce
un risultato strettamente maggiore di 1.0
la somma fp tra 1.0 e un qualunque numero fp

minore di epsMacchina
fornisce come risultato 1.0,
ovvero l’operazione di addizione fp, a differenza
della operazione di addizione usuale, ammette
elementi neutri diversi da zero
sommato a 1.0, mediante addizione fp, fornisce
un risultato strettamente maggiore di 1.0
0 1
numero fp
successivo di
1
#include <stdio.h>
void main()
{
int cont; double numero,uno,sum;
numero = 1.0;
uno = 1.0;
cont = 0;
sum = uno+numero;
while(sum>uno)
{
numero = numero/2; cont++;
sum = uno+numero;
}
numero = numero*2;
printf(“numero= %24.16e \n numero
}
% Script Epsilon – Esperimento esistenza
% epsilon macchina
format long
numero = 1.0;
uno = 1.0;
cont = 0;
sum = uno + numero;
while sum > uno
numero = numero/2; cont = cont + 1;
sum = uno + numero;
end
numero = numero*2;
sprintf(‘numero = %24.16e \n numero
format
numero= 2.2204460492503131e-016
numero divisioni= 53
output
stima di epsMacchina in doppia precisione

Esempio di esecuzione di somma fp (nei registri)
2.0 + 1./4.
mantissa e
1.0 21
1 . 0 0 0 0 + 0 0 0 0 1
1.0 2-2 1 . 0 0 0 0 - 0 0 0 1 0
incolonnamento
1.0 21 1 . 0 0 0 0 + 0 0 0 0 1
1.0 2-2 0 . 0 0 1 0 + 0 0 0 0 1
somma 1 . 0 0 1 0 + 0 0 0 0 1
errore assoluto ed errore relativo
sia dato un numero x e una sua approssimazione a
se x e a hanno la stessa
errore assoluto di a parte intera e le stesse
prime m cifre della parte
Eass  x  a frazionaria, allora
m
Eass  x  a  10
se x e a hanno le stesse
errore relativo di a
prime m cifre significative,
xa allora xa
Erel  Erel   10  m
x x
le cifre significative di un numero sono le cifre della sua
mantissa esclusi gli eventuali “zeri in testa”
non è strettamente
sia dato un numero x e una sua
VERO
approssimazione a
se Eass  x  a  10  m
errore assoluto di a
allora x e a hanno la
Eass  x  a stessa parte intera e le
stesse prime m cifre della
parte frazionaria
x  21 .1281 a  21 .1243 x  21 .1281 a  21 .1276

Eass  0.38 10  2  10  2 Eass  0.5 10 3  10  2
x  1234 .5649 a  1234 .5611 x  1.9999 a  2.0001

Eass  0.38 10 2
 10 2 Eass  0.2 10 3  10  2
sia dato un numero x e una non è strettamente
sua approssimazione a VERO
errore relativo di a xa

se Erel   10  m
xa x
Erel  allora x e a hanno le stesse
x prime m cifre significative
x  21 .1281 a  21 .1243 x  21 .1281 a  21 .1276

Erel  1.79 10  4  10  4 Erel  2.36 10 5  10 5
x  1234 .5649 a  1234 .5611 x  1.9999 a  2.0001

Erel  3.07 10 6
 10 6 Erel  10  4
MATLAB
» format long
» eps
ans =
2.220446049250313e-016
» 2^(-52)
ans =
2.220446049250313e-016
» 1+eps
ans =
1.00000000000000
» 1+eps/4
ans =
1
» format hex
» 0
ans =
0000000000000000 rappresentazione f-p di 0
» 1
ans =
3ff0000000000000 rappresentazione f-p di 1
»
0011 1111 1111 0000 0000 .. 0000
+1.000… 0× 2 0
0011 1111 1111 0000 ..0000
00111111 11110000
00000000 00000000
00000000 00000000
00000000 00000000
e = esponente memorizzato - 1023=1023-1023= 0
in Matlab eps è la distanza tra il numero 1 e
il numero fp successivo a 1
eps
0 1
epsMacchina  eps/2
» format hex
0 0000 9 1001
» 1+eps
ans = 1 0001 10 (a) 1010
2 0010 1
3ff0000000000001 11 (b) 1011
» 1+eps/2 3 0011
4 0100 12 (c) 1100
ans =
5 0101 13 (d) 1101
3ff0000000000000
>> 1+eps/2+eps/2 6 0110 14 (e) 1110
ans = 7 0111 15 (f) 1111
3ff0000000000000 8 1000
» 1+2^(-52)
ans =
3ff0000000000001 1
» 1+2^(-53)
ans =
3ff0000000000000
» format hex
» 1+(eps/2+eps/2)
ans =
3ff0000000000001
» 1+(eps/2+eps/4)
ans =
3ff0000000000001
» 1+(eps/2+eps/10)
ans =
3ff0000000000001
epsMacchina
=
numero fp successivo a eps/2
» max=(2-2^(-52))*2^1023
max =
1.797693134862316e+308
» realmax il più grande numero rappresentabile
realmax =
1.797693134862316e+308
» 2*max
ans =
Inf
» max+1
1 è minore di eps*max
ans =
1.797693134862316e+308
» max+eps*max
ans =
Inf
la somma fp tra 1.0 e un qualunque numero fp
minore di epsMacchina
fornisce come risultato 1.0,
ovvero l’operazione di addizione fp, a differenza
della operazione di addizione usuale, ammette
elementi neutri diversi da zero
questa proprietà vale solo
nella somma con 1 ?
fissato un numero x, esistono numeri fp y che
sommati a x, mediante addizione fp, forniscono
un risultato uguale a x ?
y : x  y  x  y
x  y  x 1  
 x
y y
1Å = 1 solo se < epsMacchina
x x
y Î éë0, x × epsMacchina ) Þ x Å y = x
la somma fp tra x e un qualunque numero fp

minore di ( epsMacchina * x )
fornisce come risultato x,
ovvero l’operazione di addizione fp ammette
sempre elementi neutri diversi da zero
y : x  y  x  y
x  y  x 1  
 x
y y
1Å = 1 solo se < epsMacchina
x x
y Î éë0, x × epsMacchina ) Þ x Å y = x
» 3.234e12+(0.1*eps*3.234e12)
ans =
3.234000000000000e+012
» 7.734e-34+(0.1*eps*7.734e-34)
ans =
7.734000000000000e-034
Risoluzione di una equazione
risolvere: f  x  0
significa: trovare un numero r tale che
r : f r   0
r è detto:
 soluzione dell’equazione
 radice dell’equazione
 zero della funzione f
il problema della risoluzione dell’equazione:
wx   vx 
è equivalente al problema :
f  x  0
se si pone:
f x   wx   vx 
wx 
oppure
f x   1 , v x   0
v x 
f x   0 la funzione può avere più zeri
f x   0 la funzione può avere zeri multipli
x. 2-2*x+1
1.5
0.5
-0.5
-0.5 0 0.5 1 1.5 2 2.5
f x   0 la funzione può avere zeri multipli
x. 3-3*x. 2+3*x-1
1.5
0.5
-0.5
-1
-1.5
-0.5 0 0.5 1 1.5 2 2.5
f x   0 problema poco sensibile a errori sulla funzione
(problema ben condizionato)
1.5
0.5
-0.5
-0.5 0 0.5 1 1.5 2 2.5
f x   0 problema molto sensibile a errori sulla funzione
(problema mal condizionato)
1.5
0.5
-0.5
-0.5 0 0.5 1 1.5 2 2.5
TEOREMA: non sempre è possibile esprimere
la soluzione r di una equazione mediante una
formula chiusa
Paolo Ruffini Niels Abel

(1765-1822): (1802-1829):
Evariste Galois
(1811-1832):
Non esiste una formula per calcolare gli zeri di un

qualunque polinomio di grado maggiore o uguale di 5
non sempre è possibile esprimere la soluzione r
di una equazione mediante una formula chiusa
approssimazione di r:
generare, mediante una formula ricorrente,
una successione di approssimazioni
x0 , x1 , , xk ,
che converge alla soluzione r
xk  r errk  xk  r  0
formula ricorrente algoritmo iterativo
approssimazione iniziale (dato di input)

criterio di arresto del processo iterativo
(accuratezza richiesta = dato di input)
convergenza e rapidità di convergenza:
l’errore tende a zero ?
come tende a zero l’errore in funzione k ?
approssimazione (localizzazione) della soluzione di interesse
intervallo che contiene la soluzione di interesse
generare una successione di intervalli
che contengono la soluzione
gli intervalli hanno ampiezza decrescente
la successione delle ampiezze degli intervalli tende a zero
l’ampiezza di un intervallo è una stima dell’incertezza

(errore assoluto) dell’approssimazione
metodo di bisezione
condizioni:
 f(x) è una funzione continua in [a,b]
 f(x) cambia segno in [a,b] f  a  f b   0
requisiti per l’applicabilità:

 f(x) deve essere nota
 [a,b] deve essere noto
idea del divide et impera
metodo di bisezione input: • f(x)
•aeb
a0  a b0  b m0 
 a0  b0 
2
f  a0  f  m0   0
vero falso
 a1 , b1    a0 , m0   a1 , b1    m0 , b0 
al passo k:  ak , bk  contiene la radice
metodo di bisezione input: • f(x)
•aeb
a0  a b0  b m0 
 a0  b0 
2
segno  f  a0    segno  f  m0  
vero falso
 a1 , b1    a0 , m0   a1 , b1    m0 , b0 
l’approssimazione al passo k è:
mk 
 ak  bk 
2
l’ampiezza dell’intervallo [ak,bk]

è la metà dell’ampiezza
dell’intervallo precedente [ak-1,bk-1]
l’errore di approssimazione al passo k è:
errk  r  mk
1 1
errk  r  mk  bk  ak  ek ek  ek 1
2 2
k
1
ek    e0
2
k 1
1
ek    b  a 
2
andamento dell’errore di approssimazione
1
r  m0  e0  ba
2
2
1
r  m1  e1    b  a
2
3
1
r  m2  e2    b  a
2

l’errore si dimezza a ogni passo

metodo di bisezione
converge 1 convergenza
ek  ek 1 lineare
sempre 2
metodo globale
si “guadagna” un bit corretto a ogni passo

(l’errore al passo precedente viene moltiplicato per 2-1)
101  23.3
“3 o 4” passi per “guadagnare” una cifra in base 10 corretta
(l’errore viene moltiplicato per 10-1)
richiami
il contenuto informativo (in bit) di un numero n
è
log 2 n
il numero di cifre in base b necessarie per

rappresentare un numero n in base b è
il più piccolo intero maggiore di
log b n
ovvero
logb  n  1 
  log 2 10  3.3219
l’errore si dimezza a ogni passo
è possibile determinare il minimo k tale che

l’errore di approssimazione sia minore di una
accuratezza prefissata
k : ek 
 r  mk  
k 1
1
k:  b  a   
2
1
k 1
 k 1 
b  a    2 
  b  a 
2
    b  a  
k  1  log 2   k  1  log 2  
 b  a     
 b  a  
k  log 2   1
  
il minimo k intero che verifica la disuguaglianza è
 ba 
k  log 2    1
    
il minimo k tale che l’errore di approssimazione sia
minore di una accuratezza prefissata è
 ba 
k  log 2    1
    
notare l’analogia con la complessità di tempo

dell’algoritmo di ricerca binaria
(al size dell’input n della r.b. corrisponde il rapporto
tra l’incertezza iniziale e l’accuratezza richiesta)
b-a
a  b
dimensione computazionale del problema: rapporto tra
l’incertezza iniziale e l’accuratezza richiesta ba

nell’analisi della complessità di tempo di

un algoritmo per f(x)=0
l’operazione dominante è
la valutazione della funzione f
ba
T = numero di passi per numero di
  
valutazioni di f a ogni passo
function radice=bisezione(funzione,a,b,delta_ass)
% risoluzione dell'equazione f(x)=0 mediante % %
il metodo di bisezione.
% input:
% funzione puntatore (handle) alla
% function che definisce f(x)
% a,b estremi di un intervallo tale
% che f(a)*f(b)<=0
% delta_ass reale non negativo; il massimo
% errore assoluto richiesto sul
% risultato
% output:
% radice il punto medio dell'intervallo
% [ak,bk] tale che
% f(ak)*f(bk)<=0
% |bk-ak|<=delta+eps*max(|ak|,|bk|)
%
ak = a; bk = b;
fak = funzione(ak);
fbk = funzione(bk);
while abs(bk-ak)>delta_ass+eps*max(abs(ak),abs(bk))
pmediok = (ak+bk)/2; criterio
fpmediok = funzione(pmediok);
di
if sign(fak)~ = sign(fpmediok)
%la radice e' nell'intervallo [ak,pmediok] arresto
bk = pmediok;
fbk = fpmediok;
else
%la radice e' nell'intervallo [pmediok,bk]
ak = pmediok;
fak = fpmediok;
end
disp([ak,bk,abs(ak-bk)])
end
radice = (ak+bk)/2;
criterio di arresto
abs(bk-ak) > delta_ass+eps*max(abs(ak),abs(bk))
abs(bk-ak) > delta_ass criterio di arresto basato

sull’errore assoluto
stima dell’ampiezza del
eps*max(abs(ak),abs(bk))
più piccolo intervallo fp
con estremo ak o bk
se delta_ass = 0, allora l’iterazione si arresta quando ak

e bk sono (all’incirca) due numeri fp consecutivi
criterio di arresto altri criteri di arresto
abs(bk-ak)/max(abs(ak),abs(bk)) > delta_rel +eps
abs(bk-ak)/max(abs(ak),abs(bk)) > delta_rel

criterio di arresto basato
sull’errore relativo
eps massima spaziatura relativa tra due numeri fp

consecutivi
se delta_rel = 0, allora l’iterazione si arresta quando ak

e bk sono (all’incirca) due numeri fp consecutivi
criterio di arresto altri criteri di arresto
abs(funzione(pmediok)) > delta_ass

criterio di arresto basato
sul residuo (assoluto)
il residuo è la misura di quanto una soluzione

approssimata soddisfa il problema
f xk   0
?
resxk   f xk   0  f xk 

quattro diverse modalità di definizione e passaggio di
function che implementano la funzione di interesse
>> f=@(x) x.^2-1; definizione diretta di una
>> bisezione(f,0,2,0.001) function tramite handle
ans = (puntatore)
0.99951171875000
>> f1=inline('x.^2-1'); definizione diretta di
>> bisezione(f1,0,2,0.001) una inline function
ans = (f1 è un hanlde)
0.99951171875000
>> bisezione(@f2,0,12,0.001)
ans = function y=f2(x)
1.35095214843750 % f(x)=0.15*x.^4-0.5
>> puntf = @f2; y=0.15*x.^4-0.5;
>> bisezione(puntf,0,12,0.001)
ans =
1.35095214843750
>> bisezione(f,0,2,0.001)
estremo sinistro estremo destro ampiezza interv.
0 1 1
0.50000000000000 1.00000000000000 0.50000000000000
0.75000000000000 1.00000000000000 0.25000000000000
0.87500000000000 1.00000000000000 0.12500000000000
0.93750000000000 1.00000000000000 0.06250000000000
0.96875000000000 1.00000000000000 0.03125000000000
0.98437500000000 1.00000000000000 0.01562500000000
0.99218750000000 1.00000000000000 0.00781250000000
0.99609375000000 1.00000000000000 0.00390625000000
0.99804687500000 1.00000000000000 0.00195312500000
0.99902343750000 1.00000000000000 0.00097656250000
ans =
0.99951171875000
>> bisezione(@f2,0,12,0.001)
0 6 6
0 3 3
0 1.50000000000000 1.50000000000000
0.75000000000000 1.50000000000000 0.75000000000000
1.12500000000000 1.50000000000000 0.37500000000000
1.31250000000000 1.50000000000000 0.18750000000000
1.31250000000000 1.40625000000000 0.09375000000000
1.31250000000000 1.35937500000000 0.04687500000000
1.33593750000000 1.35937500000000 0.02343750000000
1.34765625000000 1.35937500000000 0.01171875000000
1.34765625000000 1.35351562500000 0.00585937500000
1.35058593750000 1.35351562500000 0.00292968750000
1.35058593750000 1.35205078125000 0.00146484375000
1.35058593750000 1.35131835937500 0.00073242187500
ans =
1.35095214843750
function radice=bisez_ric(funzione,a,b,delta_ass)
% risoluzione dell'equazione f(x)=0 mediante
% bisezione con approccio ricorsivo.
% input:
% a,b estremi di un intervallo tale che
% f(a)*f(b)<=0
% errore assoluto richiesto
% sul risultato
% output:
% radice il punto medio dell'intervallo
% [ak,bk] tale che
% f(ak)*f(bk)<=0
% bk-ak|<=delta+eps*max(|ak|,|bk|)
%
disp([a,b,abs(a-b)])
if abs(b-a)<=delta_ass+eps*max(abs(a),abs(b))
% istanza banale
radice = (a+b)/2;
else
% autoattivazioni
fa = funzione(a);
pmedio = (a+b)/2;
fpmedio = funzione(pmedio);
if sign(fa) ~= sign(fpmedio)
%la radice e' nell'intervallo [a,pmedio]
radice=bisez_ric(funzione,a,pmedio,delta_ass);
else
%la radice e' nell'intervallo [pmedio,b]
radice=bisez_ric(funzione,pmedio,b,delta_ass);
end
end
>> bisez_ric(@f2,0,12,0.001)
0 12 12
0 6 6
0 3 3
0 1.50000000000000 1.50000000000000
0.75000000000000 1.50000000000000 0.75000000000000
1.12500000000000 1.50000000000000 0.37500000000000
1.31250000000000 1.50000000000000 0.18750000000000
1.31250000000000 1.40625000000000 0.09375000000000
1.31250000000000 1.35937500000000 0.04687500000000
1.33593750000000 1.35937500000000 0.02343750000000
1.34765625000000 1.35937500000000 0.01171875000000
1.34765625000000 1.35351562500000 0.00585937500000
1.35058593750000 1.35351562500000 0.00292968750000
1.35058593750000 1.35205078125000 0.00146484375000
1.35058593750000 1.35131835937500 0.00073242187500
ans =
1.35095214843750
il metodo di bisezione usa solo l’informazione
sul segno della f(x)
 convergenza lineare (lenta)

 convergenza sempre garantita
DOMANDA:
esistono metodi con maggiore rapidità di
convergenza?
metodo di Newton
usa i valori di f(x) e i valori di f’(x)

pendenza della retta =
tangente dell’angolo
f   xk 
f  xk 
xk 1 xk
f  xk 
f   xk 
metodo di Newton
f  xk 
xk 1  xk 
f   xk 
requisiti per l’applicabilità:
 f(x) e f’(x) devono essere note
 x0 deve essere noto
f xk 
xk 1  xk  ck ck  
f xk 
function radice =
Newton(funzione,derivata,xiniz,delta_ass,kmax)
% risoluzione dell'equazione f(x)=0
% mediante metodo di Newton
% input:
% derivata puntatore (handle) alla
% function che definisce f'(x)
% xiniz approssimazione iniziale della
% soluzione
% sul risultato
% kmax intero, massimo numero di
% iterazioni
% output:
% radice approssimazione della radice
xk = xiniz;
k = 1;
fxk = funzione(xk);
fprimoxk = derivata(xk);
correzionek = -fxk/fprimoxk;
disp([xk,abs(correzionek)])
while
abs(correzionek)>delta_ass+eps*abs(xk)&k<=kmax
xk = xk+correzionek; criterio
fxk = funzione(xk);
di
correzionek = -fxk/fprimoxk; arresto
k = k+1;
end
radice = xk;
>> Newton(@f2,@f2primo,2,0.001,20)
approssimazione correzione
2.00000000000000 0.39583333333333
1.60416666666667 0.19917236039527
1.40499430627140 0.05078276632164
1.35421153994975 0.00300135531660
1.35121018463315 0.00001002971444
ans =
1.35121018463315
f2 e f2primo sono function, implementate attraverso un

m-file, per la funzione di cui calcolare lo zero e per la
funzione che rappresenta la sua derivata, rispettivamente
è possibile implementare una function mediante inline o

definendola implicitamente mediante un handle
>> Newton(@f2,@f2primo,12,0.001,20)
approssimazione correzione
12.00000000000000 2.99951774691358
9.00048225308642 2.24897762858231
6.75150462450411 1.68516835324770
5.06633627125641 1.26017585807613
3.80616041318028 0.93642686639234
2.86973354678794 0.68217243496896
2.18756111181898 0.46728567676147
1.72027543505751 0.26637786302962
1.45389757202789 0.09231957843697
1.36157799359091 0.01025979193355
1.35131820165736 0.00011803138294
ans =
1.35131820165736
zoom
zoom
interpretazione del metodo di Newton come
risoluzione di una successione di problemi lineari
(zero di una funzione lineare)
il metodo di Newton a ogni iterazione:

 approssima localmente la funzione f(x)
con una retta t(x)
 risolve il problema (facile) t(x)=0
 considera la soluzione di t(x)=0 come
approssimazione (a quel passo) della
soluzione di f(x)=0
interpretazione del metodo di Newton come
risoluzione di una successione di problemi lineari
(zero di una funzione lineare)
al passo k : t(x) è la retta che passa per il punto di
ascissa xk e ordinata f(xk ) e ha pendenza f’(xk ),
la cui equazione è
y  f  xk   f   xk  x  xk 
la soluzione di t(x)=0 è:
0  f  xk   f   xk  x  xk 
f  xk  f  xk 
xk  x xk 1  xk 
f   xk  f   xk 
il metodo di Newton non converge sempre
(metodo locale)
condizione sufficiente per la convergenza
se f x   0 , f x  non cambia segno in a, b

se f a  f b  0
e se f a  f b 
ba , ba
f a  f b 
allora il metodo di Newton converge per qualsiasi

scelta di x0  a, b
(metodo locale)
f a  f b 
ba , ba
f a  f b 
f b 
f b 
a b
f a 
f a 
(metodo locale)
il metodo di Newton ha rapidità di

convergenza quadratica
(più efficiente del metodo di bisezione)
xk 1  r  c  xk  r
2
errk 1  c  errk 2
nel caso di zeri
non multipli
errk  xk  r xk 1  xk  ck
sviluppo di Taylor, arrestato al primo ordine:
0  f r   f xk   f xk r  xk   f  r  xk  ,   xk , r 

1 2
2
f xk  f xk  1 f  
0  r  xk   r  xk 2
f xk  f xk  2 f xk 
f xk  1 f  
 xk  r   r  xk 2
f xk  2 f xk 
1 f   1 f   
r  xk 1   r  xk 2
errk 1  errk 2
2 f xk  2 f   xk 
errk 1 1 f   xk   errk 1 1 f   r  
xk  r    lim   c
errk 2
2 f   xk   k  err
k
2
2 f   r  
(metodo locale)
PERICOLO! PERICOLO!
la derivata f’(xk) è piccola rispetto al valore

della funzione f(xk)
PERICOLO! PERICOLO!
la correzione al passo k è grande

rispetto al valore xk
criterio di arresto per il metodo di Newton
xk 1  xk  
stime
dell’errore assoluto
f  xk 

f   xk 
Complessità di tempo del metodo di Newton
ba = numero di passi per numero di

T 
  
valutazioni di funzione a ogni passo
 b  a  = numero di passi
T 
   moltiplicato per
due valutazioni di function ( f e f’ )
metodo delle secanti
usa solo valori di f(x) (approssimare f ’(x))
pendenza della retta (secante)

f xk   f xk 1 
pk 
xk  xk 1
xk 1
xk xk 1
xk 1xk
pendenza della retta (secante)

f xk   f xk 1 
pk 
xk  xk 1
xk 1
xk xk 1
f xk 
xk 1  xk  ck ck  
pk
f xk   f xk 1 
pendenza della retta (secante) pk 
xk  xk 1
xk 1  xk  ck f xk 
ck  
pk
f xk 
xk 1  xk 
f xk   f xk 1 
xk  xk 1
xk 1 xk
xk 1
xk xk 1 xk 1
function radice =
Secanti(funzione,xiniz,xiniz1,delta_ass,kmax)
% risoluzione dell'equazione f(x)=0
% mediante metodo delle Secanti
% input:
% xiniz prima approssimazione iniziale
% della soluzione
% xiniz1 seconda approssimazione iniziale
% della soluzione
% sul risultato
% iterazioni
% output:
% radice approssimazione della radice
xk = xiniz; xk1 = xiniz1;
k = 1;
fxk = funzione(xk); fxk1 = funzione(xk1);
pxk = (fxk-fxk1)/(xk-xk1);
correzionek = -fxk/pxk;
while
abs(correzionek)>delta_ass+eps*abs(xk)&k<=kmax
xk1 = xk; fxk1 = fxk; criterio
xk = xk + correzionek;
fxk = funzione(xk);
di
pxk = (fxk-fxk1)/(xk-xk1); arresto
k = k+1;
end
radice = xk;
il metodo delle secanti non converge sempre
(metodo locale)
il metodo delle secanti ha rapidità di
convergenza superlineare
xk 1  r  C  xk  r
1.618
errk 1  C  errk 1.618
il metodo delle secanti è più efficiente del metodo di

bisezione e meno efficiente del metodo di Newton
errk  xk  r
giustificazione della velocità di convergenza superlineare:
si può dimostrare che per il metodo delle secanti si ha
errk 1  C  errk  errk 1

supponiamo che la velocità di convergenza sia di ordine q
errk 1    err k
q
errk    err q
k 1
1 1

  errkq  C  errk   q
 err k
q
1
1
1
err  c  errk
k
q q
 q  1
q
sezione aurea (golden section) q    1.618
metodi ibridi
obiettivo: metodo globale con velocità di

la function Matlab fzero calcola uno zero di

una funzione, utilizzando un metodo ibrido
r = fzero(funzione,xiniz)
r = fzero(funzione,[estremo_sin,estremo_des])
metodi ibridi
obiettivo: metodo globale con velocità di

strategia: combinare un metodo globale

(bisezione) con un metodo locale
superlineare (Newton, secanti)
 metodo ibrido Newton-Bisezione

 metodo ibrido Secanti-Bisezione
intervallo successivo
xk
a xk 1 b
intervallo successivo
xk
a xk 1 b
function radice = NewtonGlobale(funzione,derivata,
a,b,delta_ass,res_ass,kmax)
% risoluzione dell'equazione f(x)=0 mediante metodo
% ibrido Newton-bisezione
% input:
% funzione puntatore (handle) alla function
% che definisce f(x)
% derivata puntatore (handle) alla function
% che definisce f'(x)
% a estremo sinistro di un intervallo
% che contiene la soluzione
% b estremo destro di un intervallo
% errore assoluto sul risultato
% res_ass reale non negativo; il massimo
% residuo assoluto sul risultato
% kmax intero, massimo numero di iterazioni
% output:
% radice approssimazione della soluzione
fa = funzione(a); fb = funzione(b);
if fa*fb>0
disp(' Intervallo non contenente la soluzione')
return
end
x = (a+b)/2;
fx = funzione(x);
fpx = derivata(x);
disp(sprintf('%20.15f %20.15f %20.15f',a,x,b))
k = 1;
while abs(a-b) > delta_ass+eps*max(abs(a),abs(b))
& (abs(fx) > res_ass) & k <= kmax
%[a,b] contiene una radice e x = a o x = b.
if appross_in_ab(x,fx,fpx,a,b)
% si effettua un passo di Newton
disp('Newton'); x = x-fx/fpx;
else
%si effettua un passo di Bisezione
disp('Bisezione'); x = (a+b)/2;
end %end if
fx = funzione(x);
fpx = derivata(x);
k = k+1;
if fa*fx<=0
% radice in [a,x]
b = x;
fb = fx;
else
% radice in [x,b]
a = x;
fa = fx;
end
end %end while
radice = x;
function ok = appross_in_ab(x,fx,fpx,a,b)
% determina l'appartenenza dell'approssimazione di un
% passo di Newton o selle Secanti all'intervallo [a,b].
% E’ usata da NewtonGlobale, SecantiGlobale
% input
% x approssimazione corrente della radice
% fx valore di f in x.
% fpx valore di f'(o di una sua approssimazione) in x
% a,b [a,b] intervallo che contiene la radice
% output
% ok 1 se la approssimazione di Newton/Secanti
% x - fx/fpx appartiene a [a,b]
% 0 ALTRIMENTI
mi = min([a b]); ma = max([a b]); a=mi; b=ma;
ok = (a <= x-fx/fpx) && (x-x/fpx <= b);
end
function radice =
SecantiGlobale(funzione,a,b,delta_ass,res_ass,kmax)
% risoluzione dell'equazione f(x)=0 mediante metodo
% ibrido Secanti-bisezione
% input:
% funzione puntatore (handle) alla function
% che definisce f(x)
% a estremo sinistro di un intervallo
% b estremo destro di un intervallo
% errore assoluto sul risultato
% res_ass reale non negativo; il massimo
% residuo assoluto sul risultato
% kmax intero, massimo numero di iterazioni
% output:
% radice approssimazione della soluzione
fa = funzione(a); fb = funzione(b);
if fa*fb>0
disp(' Intervallo non contenente la soluzione')
return
end
x = (a+b)/2; fx = funzione(x);
px = (fx-fa)/(x-a);
k = 1;
while(abs(a-b) > delta_ass+eps*max(abs(a),abs(b))
& (abs(fx) > res_ass) & k <= kmax)
%[a,b] contiene una radice e x = a o x = b.
if appross_in_ab(x,fx,px,a,b)
% si effettua un passo di Secanti
disp('Secanti'); xprec = x; x = x-fx/px;
else
%si effettua un passo di Bisezione
disp('Bisezione'); xprec = x; x = (a+b)/2;
end %end if
fxprec = fx;
fx = funzione(x);
px = (fx-fxprec)/(x-xprec);
k = k+1;
if fa*fx<=0
% radice in [a,x]
b = x;
fb = fx;
else
% radice in [x,b]
a = x;
fa = fx;
end
end % end while
radice = x;
Problema del punto fisso
data una funzione g(x) , trovare, se

esiste, una ascissa p tale che:
p: p  g  p
p è un punto fisso di g
x  g  x
problema del punto fisso
x  g  x p: p  g  p
una soluzione approssimata del problema del punto fisso è

ottenibile mediante il metodo del punto fisso
noto metodo del punto fisso
(dato di input)
x1  g  x0  x2  g  x1 
x3  g  x2  x4  g  x3 
x5  g x4  
metodo del punto fisso
xk 1  g  xk 
g
funzione di
iterazione
convergenza: dipende dalla funzione g

e dalla scelta di x0
il metodo del punto fisso converge a p se la
funzione g è una contrazione
contrazione in I: g v   g q   c v  q , c  1, v, q  I
xk 1  g  xk 
se g è derivabile e ha derivata minore di 1 (in
valore assoluto) in p, allora il metodo del punto
fisso converge a p , scegliendo x0 vicino a p
errk 1  xk 1  p errk 1  xk 1  p  g  xk   g  p 
g  xk   g  p   g  k  xk  p 
teorema del Valor Medio k tra xk e p
xk 1  g  xk 
errk 1  g  xk   g  p  g  xk   g  p   g  k  xk  p 
errk 1  g  k  errk

se g   p   1 e se x0 è vicino a p, allora esiste una costante c:
g   k   c  1 ,k 1
e allora
errk 1  c  errk   c  err0
k
cioè errk  0, k  
xk 1  g  xk 
errk 1  c  errk , c 1
la velocità di convergenza è (generalmente) lineare
con costante di proporzionalità c
c  g  p 
al diminuire di c
aumenta la velocità di convergenza
se g’(p)=0 allora la velocità di convergenza è quadratica

function p=PFisso(funz_iter,xiniz,delta_ass,kmax)
% risoluzione dell'equazione x=g(x)
% mediante metodo di Punto Fisso
% input:
% funz_iter puntatore (handle) alla
% function che definisce g(x)
% (la funzione di iterazione)
% xiniz approssimazione iniziale della
% soluzione
% sul risultato
% iterazioni
% output:
% p approssimazione del punto fisso,
% ovvero la soluzione di x = g(x)
xsucc = xiniz;
xprec = 10*delta_ass+xsucc;
k = 1;
disp(xsucc)
while abs(xprec-xsucc)>delta_ass+eps*xprec & k<=kmax
xprec = xsucc; criterio
xsucc = funz_iter(xprec);
di
k = k+1;
disp([xsucc abs(xsucc-xprec)])
arresto
end
p = xsucc;
>> pp=PFisso(@g,xiniz,0.0001,20)
1
3.26424111765712 2.26424111765712
3.92354813387019 0.65930701621308
3.96045835874241 0.03691022487222
3.96189124290255 0.00143288416014
3.96194580923401 0.00005456633146
pp =
3.96194580923401
>> pp-g(pp)
ans =
-2.076420934749024e-006
function y=g(x)
% g(x)= 2*(1-exp(-x)+1);
y=2*(1-exp(-x)+1);
problema del punto fisso e
risoluzione di una equazione
f  x  0 il problema di risoluzione
di una equazione può
essere trasformato in un
problema di punto fisso
x  f  x  x
equivalente
(ovvero, che hanno la
stessa soluzione)
funzione di
iterazione g
esempio f  x   x  3sin  x   0
4
problema di punto fisso equivalente:
x  3sin  x   x  x
4
funzione di
iterazione g
function y=g(x)
y=x.^4-3*sin(x)+x;
>> pp=PFisso(@g,xiniz,0.0001,20)
pp è soluzione di x  3sin  x   x  x
4
pp è soluzione di x  3sin  x   0
4
esempio
f  x  x  x  2  0 r  2
2
problemi di punto fisso equivalenti:
x 2  x
2 g  x   x 2
 2 diverge g   2  4
2 2
1  x g  x  1 converge
x x
x2  2 x2  2 g  2  0
x g  x  converge
2x 1 2x 1
p2
punto fisso e analisi dei metodi iterativi
xk 1  g  xk 
un metodo iterativo
può essere visto come metodo di punto fisso
f  xk 
es.: metodo di Newton xk 1  xk 
f   xk 
è un metodo di punto fisso con funzione di iterazione

f  x
g  x  x 
f  x
f  f   f f  f f  f  r  f   r 

g  1  g  r   0
f f 2  f   r 
2 2
convergenza quadratica
Lezioni 2 e 2bis - “ f(x) = 0, risoluzione di una equazione ” in sintesi: punti fondamentali da ricordare.
Il problema f(x)=0
Il problema è detto “risoluzione di una equazione” oppure ”determinazione di uno zero di una
funzione”. Ci siamo occupati solo di soluzioni che sono numeri reali, e non del caso più generale in cui le
soluzioni possono essere numeri complessi.
Un numero r è una soluzione del problema f(x) = 0 se si ha che f(r) = 0.
Il problema può ammettere nessuna soluzione, una o più soluzioni, o anche infinite soluzioni, a seconda
della natura della f e del dominio a cui si è interessati.
Gli algoritmi (metodi) che abbiamo trattato permettono di determinare una sola soluzione alla volta.
Quindi, se il problema ammette più soluzioni, l’algoritmo deve essere eseguito tante volte quante sono
le soluzioni che si vogliono calcolare.
I dati che devono essere noti sono: la funzione f e poi una informazione che consente di localizzare una
soluzione. Tale informazione può essere un intervallo (incluso nel dominio di f) che contiene la
soluzione o un numero che rappresenta una approssimazione iniziale della soluzione. In genere, la
localizzazione avviene esaminando il grafico della f o usando altre informazioni sul problema. Si ricorda
che la f si ritiene nota se si conosce la sua espressione esplicita (per es. f(x)=sin(3x)/(1+(log(x2))2) ),
oppure se si ha un programma che consente di calcolare il valore di f(x) per qualunque valore fissato x.
Un importante aspetto teorico del problema f(x) = 0 è che, anche se esiste una soluzione, può non
esistere una formula (chiusa) per calcolarla. Si ricorda che per formula chiusa si intende una formula
che contiene un numero finito di operazioni aritmetiche e di valutazioni di funzioni elementari. Un
esempio in tal senso è dato dal teorema di Ruffini-Abel-Galois che afferma l’impossibilità di esprimere
mediante formula chiusa (che coinvolga i coefficienti del polinomio) gli zeri di un qualunque polinomio
di grado maggiore o uguale di 5: per esempio, non esiste una formula per risolvere 3x5-8x4-x+1=0.
Ne consegue che un algoritmo per risolvere il problema f(x) = 0 deve necessariamente essere di tipo
iterativo. Un algoritmo iterativo è in grado di generare una successione che, sotto opportune ipotesi,
converge alla soluzione del problema. E’ chiaro che un algoritmo iterativo deve contenere un criterio di
arresto che stabilisce le condizioni che si devono verificare per terminare, a un certo passo p, il
processo iterativo, in modo che il p-simo elemento della successione (detto approssimazione al passo p)
sia una approssimazione soddisfacente della soluzione (ovvero del limite della successione).
Le due caratteristiche principali di un algoritmo iterativo sono la convergenza, e la velocità di
convergenza. Analizzare la convergenza significa stabilire le condizioni affinché l’algoritmo generi una
successione che converge alla soluzione. Determinare la velocità di convergenza di un algoritmo
iterativo significa determinare la legge che indica di quanto si riduce l’errore (tra l’approssimazione e la
soluzione) dopo aver eseguito un passo di iterazione.
Metodo di bisezione
Il metodo di bisezione è un algoritmo iterativo globale e a velocità di convergenza lineare che risolve il
problema f(x) = 0; è utilizzabile se f è una funzione continua e se si conosce un intervallo che contiene la
soluzione e ai cui estremi la f assume valori di segno opposto. Con globale si intende che l’algoritmo è
sempre convergente (quando è applicabile!). Con velocità di convergenza lineare si intende che l’errore
si riduce di un fattore costante a ogni passo di iterazione.
L’algoritmo è basato sull’approccio detto divide et impera, che riduce progressivamente (dimezzandolo
a ogni passo) l’intervallo che contiene la soluzione.
A ogni passo p, si ha un intervallo che contiene la soluzione: il punto medio dell’intervallo è
l’approssimazione della soluzione e la semi-ampiezza dell’intervallo è la stima dell’errore tra tale
approssimazione e la soluzione. Il fatto che l’errore si dimezza a ogni passo di iterazione implica che se
al passo p l’errore 2-s (cioè l’approssimazione ha s cifre della parte frazionaria corrette) allora al passo
successivo p+1 l’errore sarà 2-1 2-s = 2-s-1, ovvero la nuova approssimazione avrà un bit corretto in più
rispetto all’approssimazione precedente. Poiché sono necessari al più 4 bit per rappresentare i numeri
della base 10 (0,1,2,…8,9), dopo quattro passi di iterazione la nuova approssimazione avrà una cifra (in
base 10) corretta in più.
L’intestazione di una function Matlab per l’algoritmo di bisezione ha la seguente forma:
function radice = bisezione(funzione,a,b,delta_ass)
si noti che il primo argomento di input deve essere l’handle alla function Matlab che implementa la
funzione f, il secondo e il terzo sono gli estremi dell’intervallo iniziale, l’ultimo argomento è
l’accuratezza che si vuole sul risultato da calcolare (restituito in radice), ovvero |r - radice|<
delta_ass.
Il nucleo della function è costituito dalla struttura ripetitiva che realizza il processo iterativo:
while abs(bk-ak)>delta_ass + eps*max(abs(ak),abs(bk))
pmediok = (ak+bk)/2;
fpmediok = funzione(pmediok);
if sign(fak) ~ = sign(fpmediok)
% la radice è nell'intervallo [ak, pmediok]
bk = pmediok;
fbk = fpmediok;
else
% la radice è nell'intervallo [pmediok, bk]
ak = pmediok;
fak = fpmediok;
end
end
Si noti l’uso di eps nel criterio di arresto.

Per esempio, se si vuole risolvere sin(3x)/(1+(log(x2))2) = 0 in [0.5, 1.5], che contiene una soluzione e ai
cui estremi la funzione ha segno opposto, si procede così:
>> f = @(x) sin(3*x)./(1+(log(x.^2)).^2);
>> g = linspace(0.5, 1.5, 200);
>> plot(g, f(g)), grid
>> title(‘grafico di sin(3*x)/(1+(log(x^2))^2)’)
2 2
grafico di sin(3*x)./(1+(log(x.)).
0.6
0.4
0.2
-0.2
-0.4
-0.6
-0.8
0.5 1 1.5
>> ris = bisezione(f,0.5,1.5,1e-6)

ris =
1.047197818756104 % in format long
ris è una approssimazione (1.047197818756104) della soluzione (1.047197551196598) con 6 cifre della
parte frazionaria corrette. L’algoritmo ha effettuato 20 passi di iterazione.

Il residuo dell’approssimazione ris è immediatamente calcolabile valutando la f in ris:
>> residuo = f(ris)
residuo =
-7.959073945683713e-007
Si noti che il residuo è un numero dello stesso ordine dell’accuratezza richiesta (1e-6) , ed è una
approssimazione di 0 con 6 cifre corrette.
Metodo di Newton
Il metodo di Newton è un algoritmo iterativo locale e a velocità di convergenza quadratica che risolve il
problema f(x) = 0; è utilizzabile se f è una funzione continua e derivabile (con derivata nota) e se si
conosce una buona (ricordare il corrispondente teorema) approssimazione iniziale della soluzione.
Con locale si intende che l’algoritmo non è sempre convergente e che la convergenza dipende da come
si sceglie la condizione iniziale. Con velocità di convergenza quadratica si intende che, a ogni passo di
iterazione, l’errore relativo si riduce diventando il (proporzionale al) quadrato dell’errore precedente
(si ricorda che gli errori sono del tipo 10-s e che (10-s)2 = 10-2s ).
L’algoritmo è basato sull’idea di approssimare linearmente la f, a ogni passo p di iterazione, con la retta
tangente alla f nel punto (xp, f(xp)), il cui coefficiente angolare1 è f’(xp), e di considerare lo zero di tale
retta come approssimazione dello zero di f.
1
Il coefficiente angolare, o pendenza, di una retta è la tangente dell’angolo tra la retta e la direzione positiva
dell’asse x.
Se chiamiamo xp l’approssimazione al passo p, allora effettuando un altro passo di iterazione si ottiene
la nuova approssimazione xp+1 data da xp+1 = xp - cp , dove cp è la lunghezza del cateto sull’asse delle x del
triangolo rettangolo che ha per vertici (xp ,0), (xp , f( xp ) ) e il punto di intersezione della retta tangente
con l’asse delle x. La lunghezza di tale cateto, in virtù del noto teorema sui cateti del triangolo
rettangolo e della interpretazione geometrica della derivata di una funzione in un punto, è f(xp) /f’(xp).
Il fatto che l’errore diventi a ogni passo di iterazione il quadrato dell’errore al passo precedente implica
che se al passo p l’errore 10-s (cioè l’approssimazione ha s cifre della parte frazionaria corrette) allora al
passo successivo p+1 l’errore sarà (10-t )2 = 10-2t, ovvero la nuova approssimazione avrà il doppio delle
cifre corrette rispetto all’approssimazione precedente. Si noti che se l’approssimazione iniziale x0 ha
una cifra corretta (errore dell’ordine di 10-1), allora dopo 4 passi di iterazione si avrà una nuova
approssimazione con 16 cifre (in base 10) corrette, ovvero tutte le cifre memorizzabile nella
rappresentazione f-p.
L’intestazione di una function Matlab per l’algoritmo di Newton ha la seguente forma:
function radice = Newton(funzione,derivata,xiniz,delta_ass,kmax)
si noti che i primi due argomenti di input devono essere l’handle alla function Matlab che implementa
la funzione f e l’handle alla function Matlab che implementa la funzione f’, cioè la derivata di f, il terzo
argomento è l’approssimazione iniziale, il quarto argomento è l’accuratezza che si vuole sul risultato da
calcolare (restituito in radice), ovvero |r - radice|< delta_ass, e l’ultimo è il massimo numero di
iterazioni consentito (serve per evitare che l’algoritmo vada in loop nel caso di non convergenza).
while abs(correzionek) > delta_ass + eps*abs(xk) & k <= kmax
fxk = funzione(xk);
correzionek = -fxk/fprimoxk;
k = k+1;
end

Per esempio, se si vuole risolvere sin(3x)/(1+(log(x2))2) = 0 in [0.5, 1.5], si procede così:
>> f = @(x) sin(3*x)./(1+(log(x.^2)).^2);
>> fprimo = @(x) (3*cos(3*x))./(log(x.^2).^2 + 1) - (4*log(x.^2) *sin(3*x))./
(x.*(log(x.^2).^2 + 1).^2); %derivata calcolata con funtool2
>> g = linspace(0.5, 1.5, 200);
>> figure(1), plot(g, f(g)), grid
>> title(‘grafico di sin(3*x)/(1+(log(x^2))^2’)
>> figure(2), plot(g, fprimo(g)), grid
>> title(‘grafico della derivata di sin(3*x)/(1+(log(x^2))^2’)
2
L’espressione della derivata della funzione f può essere determinata a mano, con un po’ di attenzione e di
tempo, ma può essere ottenuta ricorrendo al servizio funtool di Matlab. Basta digitare funtool nella
finestra comandi, poi scrivere l’espressione di f nel primo campo della finestra centrale e cliccare sul tasto df/dx,
ottenendo l’espressione della derivata di f nella stessa finestra (con il suo grafico visualizzato nella finestra di
sinistra). Bisogna fare attenzione al fatto che funtool opera in notazione matematica pura e non in notazione
Matlab: non bisogna usare le operazioni .*, ./, .^ ma sempre *,/,^.
2 2
grafico di sin(3*x)./(1+(log(x.)). grafico della derivata di sin(3*x)./(1+(log(x.2)).2
0.6 1.5
1
0.4
0.5
0.2
0
0 -0.5
-0.2 -1
-1.5
-0.4
-2
-0.6
-2.5
-0.8 -3
0.5 1 1.5 0.5 1 1.5
>> ris = Newton(f,fprimo,0.9,1e-6,30) % appross. iniziale 0.9

ris =
1.047197258345557 % in format long
parte frazionaria corrette. L’algoritmo ha effettuato 4 passi di iterazione. Si noti la maggiore velocità di
convergenza rispetto all’algoritmo di bisezione (4 vs. 20 iterazioni, per ottenere approssimazioni con 6
cifre frazionarie corrette).
>> residuo = f(ris)
residuo =
8.711421187216681e-007
Si noti che il residuo è un numero dello stesso ordine dell’accuratezza richiesta (1e-6) , ed è una
E’ importante osservare che se si prende un’approssimazione iniziale più lontana dalla soluzione, per
esempio 0.7, l’algoritmo di Newton non converge alla soluzione desiderata. Provare a giustificare
qualitativamente questo fatto analizzando il grafico della f.
Infine, ricordare che l’algoritmo di Newton ha una velocità di convergenza minore se la soluzione del
problema è uno zero multiplo della f (ovvero uno zero anche per la funzione f’, derivata di f).
Metodo delle secanti

Il metodo delle secanti è un algoritmo iterativo locale e a velocità di convergenza superlineare che
risolve il problema f(x) = 0; è utilizzabile se f è una funzione continua e se si conosce una buona
approssimazione iniziale della soluzione.
si sceglie la condizione iniziale. Con velocità di convergenza superlineare si intende che, a ogni passo di
iterazione, l’errore relativo si riduce diventando una (proporzionale alla) potenza dell’errore
precedente. Nella convergenza superlineare la potenza è compresa tra 1 e 2. In particolare, nel metodo
delle secanti si ha che la potenza è il numero 1.618…., noto come sezione aurea. Si ricorda che nel caso
di convergenza quadratica la potenza è 2.
L’algoritmo è basato sull’idea di approssimare linearmente la f, a ogni passo p di iterazione, con la retta
che passa per i due punti (xp, f(xp)) e (xp-1, f(xp-1)), il cui coefficiente angolare è (f(xp) - f(xp-1)) /(xp - xp-1), e
di considerare lo zero di tale retta come approssimazione dello zero di f.
Il metodo delle secanti è una variante del metodo di Newton, in quanto usa una retta secante al posto
della retta tangente. Il vantaggio sta nel non dover usare la funzione derivata; lo svantaggio è una
minore velocità di convergenza.
Se chiamiamo xp l’approssimazione al passo p, allora effettuando un altro passo di iterazione si ottiene
la nuova approssimazione xp+1 data da xp+1 = xp - cp , dove cp è la lunghezza del cateto sull’asse delle x del
triangolo rettangolo che ha per vertici (xp ,0), (xp , f(xp ) ) e il punto di intersezione della retta secante (al
passo p) con l’asse delle x. La lunghezza di tale cateto, in virtù del noto teorema sui cateti del triangolo
rettangolo e della definizione di pendenza di una retta, è f(xp) /(pendenza al passo p).
Il fatto che l’errore diventi a ogni passo di iterazione la potenza 1.618… dell’errore al passo precedente
implica che se al passo p l’errore 10-s (cioè l’approssimazione ha s cifre della parte frazionaria corrette)
allora al passo successivo p+1 l’errore sarà (10-t )1.618 = 10-1.618*t, ovvero la nuova approssimazione avrà
circa gli 8/5 delle cifre corrette rispetto all’approssimazione precedente.
Si noti che se l’approssimazione iniziale x0 ha una cifra corretta (errore dell’ordine di 10-1), allora dopo 6
passi di iterazione (più piccolo intero maggiore o uguale di log1.6 16) si avrà una nuova approssimazione
con 16 cifre (in base 10) corrette, ovvero tutte le cifre memorizzabile nella rappresentazione f-p.
L’intestazione di una function Matlab per l’algoritmo delle secanti ha la seguente forma:
function radice = Secanti(funzione,xiniz,xiniz1,delta_ass,kmax)
si noti che il primo argomento di input è l’handle alla function Matlab che implementa la funzione f, il
secondo e il terzo argomento sono le prime due approssimazioni iniziali, il quarto argomento è
l’accuratezza che si vuole sul risultato da calcolare (restituito in radice), ovvero |r - radice|<
delta_ass, e l’ultimo è il massimo numero di iterazioni consentito (serve per evitare che l’algoritmo
vada in loop nel caso di non convergenza).

while abs(correzionek) > delta_ass + eps*abs(xk) & k <= kmax
xk1 = xk; fxk1 = fxk;
fxk = funzione(xk);
pxk = (fxk-fxk1)/(xk-xk1);
k = k+1;
end

>> f = @(x) sin(3*x)./(1+(log(x.^2)).^2);
>> ris = Secanti(f,0.9,0.95,1e-6,30) % appross. iniziali 0.9, 0.95
ris =
1.047197553370035 % in format long
parte frazionaria corrette. L’algoritmo ha effettuato 5 passi di iterazione. Si noti che la velocità di
convergenza è maggiore di quella dell’algoritmo di bisezione e minore dell’algoritmo di Newton (5 vs.
20, e 5 vs. 4 iterazioni, rispettivamente, per ottenere approssimazioni con 6 cifre frazionarie corrette).
>> residuo = f(ris)
residuo =
-6.465308752413356e-009
Si noti che il residuo è un numero di un paio di ordini minore dell’accuratezza richiesta (1e-6) , ed è una
E’ importante osservare che se si prendono due approssimazioni iniziali più lontane dalla soluzione, per
esempio 0.7 e 0.8, l’algoritmo delle secanti non converge alla soluzione desiderata. Provare a
giustificare qualitativamente questo fatto analizzando il grafico della f.
Metodi ibridi
I metodi ibridi combinano in un unico algoritmo un metodo globale e uno (o più) metodi locali.
L’obiettivo è di ottenere un algoritmo globale con velocità di convergenza superlineare.
Considerando per esempio un metodo ibrido basato su bisezione e Newton, l’algoritmo a ogni passo
determina sia l’approssimazione della bisezione sia l’approssimazione di Newton. Se l’approssimazione
di Newton appartiene al nuovo intervallo di bisezione, allora l’approssimazione di Newton diventa la
nuova approssimazione dell’algoritmo. Si noti che l’appartenenza all’intervallo di bisezione è una
ragionevole garanzia della convergenza del metodo di Newton. Altrimenti, la nuova approssimazione
dell’algoritmo è quella della bisezione.
L’algoritmo implementato nella function Matlab fzero è un algoritmo ibrido.
L’algoritmo combina il metodo di bisezione, il metodo delle secanti e un terzo metodo detto
interpolazione quadratica inversa, che sarà discusso più avanti nel Corso.
La function fzero ha due parametri di input: il primo è l’handle alla function Matlab che implementa
la funzione f; il secondo argomento può essere uno scalare o un vettore; se è uno scalare, allora è una
approssimazione iniziale della soluzione; se è un vettore, allora deve avere due componenti che sono
l’estremo sinistro e l’estremo destro di un intervallo che contiene la soluzione.
>> f = @(x) sin(3*x)./(1+(log(x.^2)).^2);
>> ris = fzero(f,0.7) % appross. iniziale 0.7
ris =
1.047197551196598 % in format long
ris è una approssimazione della soluzione (1.047197551196598) con tutte le cifre corrette. Si noti la
convergenza anche nel caso di approssimazione iniziale lontana dalla soluzione.

Anche la chiamata
>> ris = fzero(f,[0.7 1.3]) % intervallo che contiene la soluzione
ris =
1.047197551196598
produce un’approssimazione di massima accuratezza.
L’accuratezza richiesta è posta per default uguale a 1e-16. Il comando Matlab optimset consente di
visualizzare le opzioni di chiamata a fzero:
>> options = optimset('fzero')
mentre
>> options = optimset(options,'TolX',1e-6)
modifica il valore dell’accuratezza richiesta per fzero, riducendola a 1e-6.
Il problema del punto fisso g(x)=x

Il problema del punto fisso è un problema di grande rilevanza nelle applicazioni della matematica.
Attenzione al fatto che si tratta di un problema diverso da f(x)=0, cioè dalla risoluzione di una
equazione.
La soluzione p del problema del punto fisso è il cosiddetto punto fisso della funzione g, cioè il numero p
tale che g(p)=p. Si noti che il punto del piano di coordinate (p,g(p)) ha la proprietà di avere l’ascissa
uguale all’ordinata; pertanto, tale punto deve necessariamente appartenere alla retta bisettrice del
primo (e del terzo) quadrante, cioè alla retta di equazione y = x.
Il metodo del punto fisso è un algoritmo iterativo che consente di risolvere il problema del punto fisso
g(x)=x. A partire da un’approssimazione iniziale x0 della soluzione, da localizzare per via grafica, il
metodo genera una successione di approssimazioni xk+1=g(xk) che converge alla soluzione (punto fisso)
nel caso in cui (condizione sufficiente) g(x) sia una funzione che gode della proprietà di contrazione in
un intorno della soluzione p.
Si dice che g è una contrazione in un intervallo L che contiene p se, per ogni coppia di numeri v e w
appartenenti a L si ha che la differenza |v-w| è minore della differenza |g(v)-g(w)|. Se la funzione è
derivabile in L, allora tale condizione equivale alla condizione |g’(p)|<1.
Il legame tra il problema del punto fisso g(x)=x e il problema della risoluzione di una equazione f(x)=0
consiste nel fatto che f(x)=0 può essere trasformato in un problema di punto fisso: per es., sommando
x a entrambi i membri, f(x)=0 diventa f(x)+x=x, che è un problema di punto fisso per la funzione
g(x)=f(x)+x.
Minimi di una funzione
(Ottimizzazione non vincolata)
determinazione di punti di
minimo locale di una funzione
min ( f ( x )) arg min( f ( x ))

x x
f :ℜ → ℜ f è detta funzione obiettivo

120
110
100
90
80
70
60
50
40
30
20
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
120
110
100
90
80
70
60
50
40
30
20
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
Massimi di una funzione
determinazione di punti di
massimo locale di una funzione
max( f (x )) arg max( f ( x ))

x x
min (− f ( x )) arg min (− f ( x ))

x x
20
f (x )
18
16
14
12
10
0
0 0.2 0.4 0.6 0.8 1 1.2 1.4
0
-2 − f (x )
-4
-6
-8
-10
-12
-14
-16
-18
-20
0 0.2 0.4 0.6 0.8 1 1.2 1.4
f(x) derivabile
il punto di minimo di f(x) è un punto in cui si annulla f ’(x),

la derivata prima di f
risolvere il problema (radice di una equazione)

f ’(x) = 0
se f ’(x) è nota, usare un qualunque metodo di risoluzione:

bisezione, Newton (se è nota la derivata seconda di f ),
secanti, metodi ibridi, metodo del punto fisso.
risolvere il problema (radice di una equazione)
f ’(x) = 0
il metodo di Newton (deve essere nota la derivata seconda

di f ) assume la forma
f ′ ( xk )
x k +1 = xk −
f ′′ ( xk )
metodo di minimizzazione di Newton

di una funzione f
(derivabile due volte)
metodo locale, convergenza quadratica
metodo di Newton per la minimizzazione: f ′ ( xk )
xk +1 = xk −
risoluzione di f ’(x) = 0 f ′′ ( xk )
se d1(x) e d2(x) sono le function (.m) per la

derivata prima e seconda di f allora
x_minimo = Newton(@d1,@d2,xiniz,delta,kmax)
restituisce una approssimazione del punto di minimo

di f con accuratezza delta
interpretazione geometrica del metodo di Newton per
la minimizzazione
f ′ ( xk )
xk +1 = xk −
f ′′ ( xk )
equivale ad approssimare localmente, a ogni passo,
la funzione f con il polinomio di secondo grado q
tale che: q (x ) = f (x )
k k
q ′( x k ) = f ′( xk )
q ′′( x k ) = f ′′( x k )
considerando come approssimazione successiva
del minimo di f il minimo del polinomio q
18
16
x.^2+0.45*(sin(2*x)).^2;
14
12
10
0
-4 -3 -2 -1 0 1 2 3 4
20
15
10
polinomio q xk = 2.2
-5
-4 -3 -2 -1 0 1 2 3 4
xk +1 = −1.128
x k +1 = xk −
risoluzione di f ’(x) = 0 f ′′ ( x k )
q (x k )= f (x k )
sviluppo di Taylor di f
q ′ (x k )= f ′ (x k )
attorno a xk arrestato al
q ′′ ( x k ) = f ′′ ( x k )
secondo ordine:
c2
f ( xk + c ) = f ( xk ) + c ⋅ f ′ ( xk ) + ⋅ f ′′ ( xk ) + O c
2
3
( )
min f (x ) = min f (xk + c )  c2 
≈ min  f ( xk ) + c ⋅ f ′ ( xk ) + ⋅ f ′′ ( xk ) 
x c c
 2 
è una funzione
della variabile c
d  c2 
 f ( xk ) + c ⋅ f ′( xk ) + ⋅ f ′′( xk ) = 0
dc  2 
x k +1 = xk −
risoluzione di f ’(x) = 0 f ′′ ( x k )
q (x k )= f (x k )
sviluppo di Taylor di f
q ′ (x k )= f ′ (x k )
attorno a xk arrestato al
q ′′ ( x k ) = f ′′ ( x k )
secondo ordine:
min f (x ) = min f (xk + c )  c2 

≈ min  f ( xk ) + c ⋅ f ′ ( xk ) + ⋅ f ′′ ( xk ) 
x c c
 2 
d 
f ′(xk ) + c ⋅ f ′′(xk ) = 0
c2 
 f ( xk ) + c ⋅ f ′( xk ) + ⋅ f ′′( xk ) = 0
dc  2 
f ′( x k )
c=−
f ′′( x k )
xk +1 = xk + c xk +1 = xk + ck
metodo di minimizzazione di Newton f ′ ( xk )
x k +1 = xk −
f ′′ ( x k )
il problema (non lineare) viene approssimato

risolvendo (in modo esatto) una successione
di problemi quadratici (minimizzazione di un
polinomio di secondo grado)
il metodo è locale (può non convergere)

il metodo ha velocità di convergenza
quadratica
il metodo può convergere solo linearmente
(se nel punto di minimo si annulla anche
la derivata seconda)
metodo di minimizzazione di Newton varianti
approssimazione della derivata prima e seconda

(con differenze finite)
determinazione (a ogni passo k) del minimo del
polinomio di secondo grado interpolante
su xk , xk-1, xk-2
metodi damped (il parametro αk è scelto a ogni

passo in modo tale da evitare che la nuova
approssimazione sia troppo lontana dalla
precedente)
~
xk +1 = xk + ck
f ( x k ) − f ( x k −1 )
f ′( x k ) ≈ p k =
f ′( x k ) x k − x k −1
ck = −
f ′′( x k ) f ′ ( x k ) − f ′ ( x k −1 )
f ′′( x k ) ≈
x k − x k −1
f ( x k ) − f ( x k −1 ) f ( x k −1 ) − f ( x k − 2 )
−
x k − x k −1 x k −1 − x k − 2
f (x k ) ≈ p 2 k =
′′
x k − x k −1
~
xk +1 = xk + ck
f ( x k ) − f ( x k −1 )
f ′( x k ) ≈ p k =
f ′( x k ) x k − x k −1
ck = −
f ′′( x k ) f ′′( x k ) ≈ p 2 k =
f ( x k ) − f ( x k −1 )
−
f ( x k −1 ) − f ( x k − 2 )
(x k − x k −1 )2 (x k − x k −1 )(x k −1 − x k − 2 )
p k − p k −1
f ′′( x k ) ≈ p 2 k =
( x k − x k −1 )
~ pk
ck = −
p2k
determinazione (a ogni passo k) del minimo del
polinomio di secondo grado interpolante
su xk , xk-1, xk-2
20
15
10
-5
-4
xk-3− 2 -2 x-1k +1 0 1
x k2 3 xk −1 4
metodi damped (il parametro αk è scelto a ogni
passo in modo tale da evitare che la nuova
approssimazione sia troppo lontana dalla
precedente)
xk +1 = xk + α k ck
αk è scelta in modo che sia
f ( xk +1 ) < f ( xk )
calcolo di minimi di una funzione di una variabile in Matlab
(ottimizzazione non vincolata)
x = fminbnd(@mia_fun,estremo_sin,estremo_des)
f = @(x) 2+(x-pi).^2;
x = fminbnd(f,1.2,5.1)
miaf = @(x) –humps(x);

x = fminbnd(miaf,0.1,0.6)
calcolo del massimo della funzione implementata dalla
function Matlab humps nell’intervallo [0.1,0.6]
richiamo: derivata
richiamo: derivata
indichiamo con una

freccia verso l’alto la
derivata positiva
metodo del gradiente discendente (steepest descent)
approssimazione
iniziale
passo
approssimazione
successivo
iniziale
approssimazione
nuova
iniziale
derivata
passo
successivo
approssimazione
iniziale
passo
successivo
approssimazione
iniziale
xk +1 = xk − α ⋅ f ′( xk )
per esempio: α = 0.1
xk +1 = xk + ck
a ogni passo l’approssimazione della soluzione
viene corretta con una quantità proporzionale
all’opposto del valore della derivata
(valutata in quel punto di approssimazione)
difficoltà: criterio di arresto
criterio per
arrestare il metodo
iterativo
difficoltà: funzione non convessa
approssimazione
iniziale buona
difficoltà: funzione non convessa
approssimazione
iniziale cattiva
approssimazione
iniziale buona
funzione convessa
x
funzione convessa
funzione non convessa
funzione concava
f convessa concavità verso l’alto
f concava concavità verso il basso
se f è convessa, allora –f è concava

se f è concava, allora –f è convessa
insiemi convessi
Definizione
presi due qualunque punti
A e B dell’insieme, allora
ogni punto sulla retta che
passa per A e B
appartiene all’insieme. insieme convesso
λ A + (1 − λ ) B, 0 ≤ λ ≤1
appartiene all’insieme
insiemi convessi
Definizione
presi due qualunque punti
A e B dell’insieme, allora
ogni punto sulla retta che
passa per A e B
insieme non
appartiene all’insieme.
convesso
λ A + (1 − λ ) B, 0 ≤ λ ≤1
appartiene all’insieme
funzioni e insiemi convessi
l’epigrafo di una funzione convessa è un insieme

convesso
funzione convessa funzione non convessa

funzione non convessa funzione convessa
un mimino locale può un mimino locale è un

non essere un minimo minimo globale
globale
funzione convessa
il minimo globale può un mimino locale è un

non essere unico minimo globale
calcolo del minimo globale di una funzione convessa
min f ( x )
funzione convessa
x
f è una funzione convessa,
definita su insiemi convessi
il calcolo del minimo globale

di funzioni convesse è un
un mimino locale è un
problema più facile, rispetto
minimo globale
al caso generale
calcolo del minimo di una
funzione unimodale
le funzioni con un unico punto di

minimo sono dette funzioni unimodali
definizione:
definizione:
una funzione f(x)
una funzione f(x) èè unimodale
unimodale in in [[a,b
a,b],], se
se esiste
esiste
un
un unico numero pp in
unico numero in [a,b]
[a,b] tale
tale che
che
f(x)
f(x) èè strettamente
strettamente decrescente in [[a,p
decrescente in a,p]] ed
ed èè
strettamente
strettamente crescente in [[p,b
crescente in p,b]]
funzione unimodale
è possibile applicare metodi che

“racchiudono” la soluzione
(come il metodo della bisezione per il problema
del calcolo degli zeri di una funzione)

metodo
metodo della
della ricerca
ricerca di
di Fibonacci
Fibonacci
(Fibonacci
(Fibonacci search)
search)

metodo
metodo della
della ricerca
ricerca Aurea
Aurea
(Golden
(Golden search)
search)
funzione unimodale
riduzione di un intervallo che racchiude uno zero
di una funzione continua
basta una valutazione di funzione
riduzione di un intervallo che racchiude un

minimo di una funzione unimodale
sono necessarie due valutazioni di funzione

18
16
x.^2+0.45*(sin(2*x)).^2;
14
c <12d and f(c)<f(d) a < minimo < d

10
0
-4 -3 -2 -1 0 1 2 3 4
a c d b
18
16
x.^2+0.45*(sin(2*x)).^2;
14
c <12d and f(c)>f(d) c < minimo < b

10
0
-4 -3 -2 -1 0 1 2 3 4
a c d b
function
function risris == fminrand(f,a,b,delta_ass)
fminrand(f,a,b,delta_ass)
%% minimizzazione
minimizzazione di di f,
f, unimodale
unimodale in
in a,b;
a,b;
%% l'approssimazione
l'approssimazione ha ha accuratezza
accuratezza delta_ass
delta_ass
if
if abs(b-a)
abs(b-a) << delta_ass
delta_ass
ris
ris =(a+b)/2;
=(a+b)/2;
else
else
r1
r1 == aa +(b-a)*rand(1,1);
+(b-a)*rand(1,1);
r2
r2 == aa +(b-a)*rand(1,1);
+(b-a)*rand(1,1);
cc == min([r1,r2]);
min([r1,r2]);
dd == max([r1,r2]);
max([r1,r2]);
fc
fc == f(c);
f(c); fdfd == f(d);
f(d);
if
if fc
fc <=<= fd
fd
bb == d;
d;
else
else
aa == c;
c;
end
end
ris
ris == fminrand(f,a,b,delta_ass);
fminrand(f,a,b,delta_ass);
end
end
function
function risris == fminrand1(f,a,b,delta_ass)
fminrand1(f,a,b,delta_ass)
%% minimizzazione
f, unimodale
unimodale in
in a,b;
a,b;
delta_ass
if
if abs(b-a)
delta_ass
ris
ris =(a+b)/2;
=(a+b)/2;
else
else
rr == 0.5*rand;
0.5*rand;
cc == aa +(b-a)*r;
+(b-a)*r;
dd == aa +(b-a)*(1-r);
+(b-a)*(1-r);
fc
fc == f(c);
f(c); fdfd == f(d);
f(d);
if
if fc
fc <=<= fd
fd
bb == d;
d;
else
else
aa == c;
c;
end
end
ris
ris == fminrand1(f,a,b,delta_ass);
fminrand1(f,a,b,delta_ass);
end
end
18
criterio per la scelta di c e d
16
14 rendere il più piccolo possibile il nuovo

12 intervallo che racchiude il minimo
( [a,d] o [c,b] )
10
8 a ogni passo valutare una sola volta la

funzione
6
4
il punto c o il punto d deve essere un
punto già considerato al passo precedente
2
0
-4 -3 -2 -1 0 1 2 3 4
a c d b
Metodo della ricerca di Fibonacci (Fibonacci search)
si sceglie un intero N
si considerano i numeri di Fibonacci
fibonacci(N), fibonacci(N-1), fibonacci (N-2), …,
fibonacci(2), fibonacci(1)
primo passo (l’intervallo che contiene la soluzione è [a,b])
c = a + fibonacci (N-2)/fibonacci (N) *(b-a)
d = a + fibonacci (N-1)/fibonacci (N) *(b-a)
se f(c) < f(d) il nuovo intervallo è [a,d]
se f(c) ≥ f(d) il nuovo intervallo è [c,b]
secondo passo (l’intervallo è chiamato ancora [a,b])
c = a + fibonacci (N-3)/fibonacci (N-1) *(b-a)
d = a + fibonacci (N-2)/fibonacci (N-1) *(b-a)
si sceglie il nuovo intervallo
e così via, fino al passo N-simo
primo passo : l’intervallo che conteneva la soluzione è [a,b];

diventa un intervallo di ampiezza
fibonacci (N-1)/fibonacci(N) *(b-a)
secondo passo : l’intervallo che contiene la soluzione è un
intervallo di ampiezza
fibonacci (N-2)/fibonacci(N-1) del precedente
e così via, fino all’ultimo intervallo (passo N)
i due nuovi intervalli [a,d] e [c,b] hanno uguale ampiezza
ampiezza intervallo [a,d] : (d-a)
(b − a ) FN −1
numeri di Fibonacci
FN

ampiezza intervallo [c,b] : (b-c)
 FN − 2 
(b − a ) − (b − a ) FN − 2
= (b − a )1 − 
FN  FN 

(b − a ) FN −1  FN − 2 
(b − a )1 −  = (b − a )
FN − FN − 2
FN  FN  FN

FN − FN − 2
(b − a ) FN −1
(b − a ) = (b − a )
FN −1
FN FN FN

l’intervallo finale ha ampiezza:
[b − a] FN −1 FN − 2 FN −3 F2 F1
⋯ [b − a] 1
FN FN −1 FN − 2 F3 F2 FN
[b − a] 1
FN
fissato δ allora N deve

[b − a ] < δ
1 essere tale che
FN
[b − a ] 1
< FN ≈ ϕ N
δ
sezione aurea (golden section)
c = a + [b − a ] , d = a + [b − a ]
FN − 2 FN −1
FN FN
supponiamo che il nuovo intervallo sia [a,d]
= a + [d − a ] = a + [b − a ]
FN − 2 FN −1 FN − 2
d nuovo =c
FN −1 FN FN −1
un analogo risultato vale per cnuovo

(cnuovo=d) nel caso che il nuovo intervallo sia [c,b]
function
function risris == fminfibo(f,a,b,delta_ass)
fminfibo(f,a,b,delta_ass)
h=b-a;
h=b-a;
n=ceil(((log(h)-log(delta_ass))/log(1.61803398874989)));
n=ceil(((log(h)-log(delta_ass))/log(1.61803398874989)));
den
den == fibonacci(n);
fibonacci(n);
cc =(fibonacci(n-2)/den)*h+a; [ b − a ]1
< F ≈ ϕ N
=(fibonacci(n-2)/den)*h+a;
δ
N
dd =(fibonacci(n-1)/den)*h+a;
=(fibonacci(n-1)/den)*h+a;
1
([ ]) ( )
ak
ak == a;
a; bk
bk == b;
b; hk
hk == h;
h;
fc
fc == f(c);
f(c); fdfd == f(d); log b − a + log  ≈ N log ϕ
δ 
f(d);
for
for k=n-1:-1:2
k=n-1:-1:2
den
den == fibonacci(k);
fibonacci(k);
N≈
([ ]) ( )
log b − a − log δ
if
if fc
fc << fd
bk
fd
bk == d;
d; dd == c;
c; fd
fd == fc;
fc;
( )
log ϕ
hk
hk == bk-ak;
bk-ak;
cc =(fibonacci(k-2)/den)*hk+ak;
=(fibonacci(k-2)/den)*hk+ak; fc fc == f(c);
f(c);
else
else
ak
ak == c;
c; cc == d;
d; fc
fc == fd;
fd;
hk
hk == bk-ak;
bk-ak;
dd =(fibonacci(k-1)/den)*hk+ak;
=(fibonacci(k-1)/den)*hk+ak; fd fd == f(d);
f(d);
end
end
end
end
ris
ris == (ak+bk)/2;
(ak+bk)/2;
Metodo di ricerca basato sulla sezione aurea (Golden search)
Fn
lim =ϕ 1.6180….
sezione aurea
(golden section)
n →∞ F
n −1
Fn −1 1
lim = ≡ ϕ −1 0.6180….
n →∞ F
n ϕ
Fibonacci search
ϕ -1
Golden search
Fn
lim =ϕ 1.6180….
sezione aurea
(golden section)
n →∞ F
n −1
Fn −1 1
lim = ≡ ϕ −1 0.6180….
n →∞ F
n ϕ
Fibonacci search
Golden search Fn −1 1
lim = ≡ ϕ −1
n →∞ F
n ϕ
Fn − 2 Fn − Fn −1 Fn −1
= = 1−
Fn Fn Fn
= 1 − (ϕ − 1) = 2 − ϕ
Fn − 2
lim 0.3819...
n →∞ F
n
Fibonacci search
2-ϕ
Golden search Fn −1 1
lim = ≡ ϕ −1
n →∞ F
n ϕ
Fn − 2 Fn − Fn −1 Fn −1
= = 1−
Fn Fn Fn
= 1 − (ϕ − 1) = 2 − ϕ
Fn − 2
lim 0.3819...
n →∞ F
n
Golden search
c = a + (2-phi) *(b-a)
d = a + (phi-1) *(b-a)
Golden search
c = a + (b − a )(2 − ϕ ) , d = a + (b − a )(ϕ − 1)
supponiamo che il nuovo intervallo sia [a,d]
d nuovo = a + (d − a )(ϕ − 1) = a + (b − a )(ϕ − 1) = a + (b − a )(2 − ϕ ) = c

2
(ϕ − 1)2 = (ϕ − 1) = 1 − 1 = 1 − (ϕ − 1) = 2 − ϕ
ϕ ϕ
un analogo risultato vale per cnuovo

(cnuovo=d) nel caso che il nuovo intervallo sia [c,b]
function
function risris == fmingolden(f,a,b,delta_ass)
fmingolden(f,a,b,delta_ass)
%% minimizzazione
f, unimodale
unimodale in
in (a,b);
(a,b);
delta_ass
if
if abs(b-a)
delta_ass
ris
ris =(a+b)/2;
=(a+b)/2;
else
else
phi
phi == 1.61803398874989;
1.61803398874989;
duemphi
duemphi == 22 -- phi;
phi; phim1
phim1 == phi
phi -- 1;
1;
cc == a+(b-a)*duemphi;
a+(b-a)*duemphi;
dd == a+(b-a)*phim1;
a+(b-a)*phim1;
fc
fc == f(c);
f(c); fdfd == f(d)
f(d)
if
if fc
fc <=<= fd
fd
bb == d;
d;
else
else
aa == c;
c;
end
end
ris
ris == fmingolden(f,a,b,delta_ass);
fmingolden(f,a,b,delta_ass);
end
end
Gli esercizi proposti devono essere sviluppati in Matlab.
La risoluzione di un esercizio consiste nello sviluppare uno
script Matlab, eventualmente corredato da function Matlab, e
nel redigere una breve relazione (in word) contenente il
codice Matlab, i grafici richiesti (copia/incolla dalla figure
Matlab), i risultati ottenuti, con un sintetico commento degli
stessi.
I commenti dovrebbero fare riferimento alle eventuali
difficoltà intrinseche del problema (condizionamento, scelta
dei valori iniziali,….), all’accuratezza dei risultati (errore
assoluto/relativo, rediduo assoluto/relativo), alla complessità
di tempo degli algoritmi e a quant’altro l’allievo giudichi
significativo per il processo di risoluzione computazionale del
problema.
Esercizio:
determinare una approssimazione del punto di minimo
della funzione f, nell’intervallo [-2,2] applicando:
metodo di minimizzazione di Newton

3 passi del metodo del gradiente discendente (function
da sviluppare)
function fminrand
metodo di ricerca di Fibonacci
Golden search
function Matlab fminbnd
f ( x ) = 3 + ( x + 1) + 0.45 sin (2( x + 1))

2 2
Esercizio:
determinare una approssimazione del punto di minimo
della funzione f, nell’intervallo [1.8,2.2] applicando:
function fminrand
metodo di ricerca di Fibonacci
Golden search
  
( ( ))
f (x ) = exp sin x 2 4 


+ x + 3 sin exp −
1 

  1+ x 
utilizzare 2.15 come approssimazione iniziale

4
  
3.9 ( ( ))
f ( x ) = exp sin x 2  
+ x + 3 sin exp −
4

1 

  1+ x 
3.8
3.7
3.6
3.5
3.4
3.3
3.2
1.8 1.85 1.9 1.95 2 2.05 2.1 2.15 2.2 2.25
Ripetere l’esercizio osservando, dal grafico della funzione
f, che questa ammette vari minimi locali.
Trovare il minimo:
• nell’intervallo [-1,1]
• nell’intervallo [-2.85,3.75]
Usare:
variante di Newton con differenze finite
3 passi del metodo del gradiente discendente
20
  
18 ( ( ))
f ( x ) = exp sin x 2 
+ x + 3 sin exp −
4

1 

16
  1+ x 
14
12
10
0
-5 -4 -3 -2 -1 0 1 2 3 4 5
Lezioni 3 - “ min f(x), determinazione del minimo di una funzione” in sintesi: punti fondamentali da
ricordare.
Il problema min f(x)

Il problema è detto “minimizzazione di una funzione” oppure ”ottimizzazione di una funzione obiettivo”
oppure “determinazione di un punto di minimo di una funzione”. Il problema potrebbe essere (più
correttamente) denotato con argmin f(x), a sottolineare il fatto che si è interessati a conoscere l’ascissa
in cui la funzione assume il valore minimo.
Ci siamo occupati di funzioni di una variabile. Non abbiamo preso in considerazione i cosiddetti vincoli,
ovvero condizioni che restringono l’insieme dei punti del dominio in cui si deve effettuare la ricerca del
minimo.
Un numero r è una soluzione del problema min f(x) se si ha che f(r) <= f(x) , qualunque sia x
appartenente a un intorno di r, ovvero r è un minimo locale di f.
Il problema può ammettere una o più soluzioni, nessuna soluzione o anche infinite soluzioni, a seconda
della natura della f e della porzione del dominio a cui si è interessati.
Gli algoritmi (metodi) che abbiamo trattato permettono di determinare una sola soluzione alla volta.
Quindi, se il problema ammette più soluzioni, l’algoritmo deve essere eseguito tante volte quante sono
le soluzioni che si vogliono calcolare.
Inoltre, i metodi presentati non sono in grado di stabilire se un minimo (locale) è un minimo globale
della funzione.
I dati che devono essere noti sono: la funzione f e poi una informazione che consente di localizzare una
soluzione. Tale informazione può essere un intervallo (incluso nel dominio di f) che contiene la
soluzione, o un numero che rappresenta un’approssimazione iniziale della soluzione. In genere, la
localizzazione avviene esaminando il grafico della f o usando altre informazioni sul problema. Si ricorda
che la f si ritiene nota se si conosce la sua espressione esplicita (per es. f(x)=sin(3x)/(1+(log(x2))2) ),
oppure se si ha un programma che consente di calcolare il valore di f(x) per qualunque valore fissato x.
Il problema max f(x) è immediatamente riconducile a un problema di minimo, in quanto si ha che se r è
soluzione di max f(x), allora r è anche soluzione di min –f(x).
Come abbiamo già visto nel caso del problema f(x)=0, un importante aspetto teorico del problema min
f(x) è che, anche se esiste una soluzione, può non esistere una formula (chiusa) per calcolarla. Si
ricorda che per formula chiusa si intende una formula che contiene un numero finito di operazioni
aritmetiche e di valutazioni di funzioni elementari. Ne consegue che un algoritmo per risolvere il
problema min f(x) deve necessariamente essere di tipo iterativo.
Metodo di Newton per la minimizzazione
Se la funzione f è derivabile, allora il problema min f(x) è riconducibile al problema f’(x)=0, ovvero al
calcolo dello zero della derivata prima di f. Se la funzione f è derivabile due volte, il problema f’(x)=0
può essere risolto mediante il metodo di Newton classico. E’ opportuno notare che, in tal caso, il
metodo di Newton agisce sulla derivata prima e sulla derivata seconda di f, ma non opera direttamente
sulla f. Il metodo di Newton per la minimizzazione è un algoritmo iterativo locale e a velocità di
convergenza quadratica; è utilizzabile se f è una funzione continua e derivabile due volte (con derivata
prima e seconda note) e se si conosce una buona approssimazione iniziale della soluzione.
si sceglie la condizione iniziale. Con velocità di convergenza quadratica si intende che, a ogni passo di
iterazione, l’errore relativo si riduce diventando il (proporzionale al) quadrato dell’errore precedente
(si ricorda che gli errori sono del tipo 10-s e che (10-s)2 = 10-2s ).
Abbiamo dimostrato che l’algoritmo può essere visto come la risoluzione esatta di una successione di
problemi di minimo di opportuni polinomi di secondo grado. Infatti, abbiamo visto che, a ogni passo p
di iterazione:
1) l’algoritmo approssima (localmente, attorno a xp) la f con il polinomio di secondo grado (parabola)
che gode delle seguenti proprietà: il polinomio passa per il punto (xp, f(xp)), il polinomio ha derivata
prima in xp uguale a f’(xp), il polinomio ha derivata seconda in xp uguale a f’’(xp);
2) che l’algoritmo considera il punto di minimo di tale polinomio come successiva approssimazione del
punto di minimo di f.
Si noti che non è necessario implementare il metodo di Newton mediante una nuova function Matlab,
ma basta richiamare la function Newton nel seguente modo:
>> xminimo = Newton(d1,d2,xiniz,delta_ass,kmax)
dove i primi due argomenti di input devono essere l’handle alla function Matlab che implementa la
derivata prima della funzione f e l’handle alla function Matlab che implementa la derivata seconda della
funzione f, il terzo argomento è l’approssimazione iniziale, il quarto argomento è l’accuratezza che si
vuole sul risultato da calcolare (restituito in xminimo), ovvero |r - xminimo|< delta_ass, e l’ultimo è
il massimo numero di iterazioni consentito (serve per evitare che l’algoritmo vada in loop nel caso di
non convergenza).
Per esempio, se si vuole risolvere min -exp(-x)*sin(2*x-pi/2) in [-3,0], si procede così:
>> f = @(x) -exp(-x).*sin(2*x-pi/2);
>> fprimo = @(x) -(cos(2*x) + 2*sin(2*x))./exp(x); %derivata prima calcolata
con funtool1
1
L’espressione della derivata della funzione f può essere determinata a mano, con un po’ di attenzione e di
tempo, ma può essere ottenuta ricorrendo al servizio funtool di Matlab. Basta digitare funtool nella
finestra comandi, poi scrivere l’espressione di f nel primo campo della finestra centrale e cliccare sul tasto df/dx,
ottenendo l’espressione della derivata di f nella stessa finestra (con il suo grafico visualizzato nella finestra di
>> fsecondo = @(x) -(3*cos(2*x) - 4*sin(2*x))./exp(x); %derivata seconda
calcolata con funtool
>> g = linspace(-3, 0, 200);
>> figure(1), plot(g, f(g)), grid
>> title(‘grafico di -exp(-x)*sin(2*x-pi/2)’)
>> figure(2), plot(g, fprimo(g)), grid
>> title(‘grafico della derivata di -exp(-x)*sin(2*x-pi/2)’)
grafico di -exp(-x)*sin(2*x-pi/2) grafico della derivata di -exp(-x)*sin(2*x-pi/2)

20 10
5
15
0
10 -5
-10
5
-15
0 -20
-25
-5
-30
-10 -35
-3 -2.5 -2 -1.5 -1 -0.5 0 -3 -2.5 -2 -1.5 -1 -0.5 0
>> xminimo = Newton(fprimo,fsecondo,-2.5,1e-6,30) % appross. iniziale 0.9

xminimo =
-1.802620131305244 % in format long
xminimo è una approssimazione (-1.802620131305244) della soluzione (-1.802620131175508) con 9
cifre della parte frazionaria corrette. L’algoritmo ha effettuato 4 passi di iterazione.

E’ importante osservare che se si prende un’approssimazione iniziale più lontana dalla soluzione, per
esempio -1, l’algoritmo di Newton non converge alla soluzione desiderata. Provare a giustificare
qualitativamente questo fatto analizzando il grafico della f e, soprattutto, della f’.
Infine, ricordare che l’algoritmo di Newton ha una velocità di convergenza solo lineare se la soluzione
del problema è uno zero multiplo della f’ (ovvero uno zero anche per la funzione f’’, derivata seconda di
f).
fminbnd
La function Matlab fminbnd calcola il punto di minimo di una funzione.
La function fminbnd ha tre parametri di input: il primo è l’handle alla function Matlab che implementa
la funzione f; il secondo e il terzo argomento sono, rispettivamente, l’estremo sinistro e l’estremo
destro di un intervallo che contiene la soluzione.
Per esempio, se si vuole risolvere min -exp(-x)*sin(2*x-pi/2), in [-2.5,1], con 14 cifre della parte
frazionaria corrette, si procede così:
>> f = @(x) -exp(-x).*sin(2*x-pi/2);
>> xminimo = fminbnd(f,-2.5,-1,optimset(‘TolX’,1e-14)) % delta è 1e-4
xminimo =
-1.802620131175508 % in format long
sinistra). Bisogna fare attenzione al fatto che funtool opera in notazione matematica pura e non in notazione
Matlab: non bisogna usare le operazioni .*, ./, .^ ma sempre *,/,^.
L’accuratezza richiesta è posta per default uguale a 1e-4. Il comando Matlab optimset consente di
visualizzare le opzioni di chiamata a fminbnd:
>> options = optimset('fminbnd')
mentre
>> options = optimset(options,'TolX',1e-14)
modifica il valore di default dell’accuratezza richiesta, portandola a 1e-14.
Si noti che è possibile modificare il valore di Tolx solo per una chiamata, usando la optimset come
quarto argomento di chiamata della function fminbnd (fminbnd(f,-2.5,-
1,optimset(‘TolX’,1e-14))).
Minimo di funzioni unimodali

Se la f è unimodale in un intervallo [a,b] , allora esistono algoritmi per il calcolo del minimo che godono
della proprietà di racchiudere la soluzione a ogni passo in un intervallo, la cui ampiezza decresce
all’aumentare dei passi. Si tratta di algoritmi di tipo divide et impera, basati su un’idea simile a quella
dell’algoritmo di bisezione per f(x)=0.
Una funzione f è unimodale in [a,b] se esiste un unico numero r in [a,b] tale che f è decrescente in [a,r]
ed è crescente in [r,b].
E’ facile rendersi conto che se f è unimodale in [a,b], considerando due qualunque numeri c, d
appartenenti a [a,b] e tali che c<d, allora è sicuramente possibile considerare un nuovo intervallo,
incluso in [a,b], che contiene la soluzione: infatti se f(c)>f(d), allora la soluzione si trova certamente in
[c,b]; mentre se f(c)<f(d), allora la soluzione si trova certamente in [a,d].
Abbiamo visto che il modo più semplice per determinare c,d a ogni passo consiste nel generarli a caso,
come nella nostra function fminrand:
function ris = fminrand(f,a,b,delta)
% minimizzazione di f, unimodale in [a,b].
% l'approssimazione ha accuratezza delta
while abs(b-a) < delta
r1 = a +(b-a)*rand(1,1); r2 = a +(b-a)*rand(1,1);
c = min([r1,r2]); d = max([r1,r2]);
fc = f(c); fd = f(d);
if fc <= fd
b = d;
else
a = c;
end
end
ris =(a+b)/2;
end
Per esempio, se si vuole risolvere min -exp(-x)*sin(2*x-pi/2) in [-2.5,-1], in cui f è unimodale, si
procede così:
>> f = @(x) -exp(-x).*sin(2*x-pi/2);
>> xminimo = fminrand(f,-2.5,-1,1e-6)
xminimo =
-1.802620005186674
xminimo è una approssimazione (-1.802620005186674) della soluzione (-1.802620131175508) con 6
cifre della parte frazionaria corrette.
Fibonacci search e Golden search

Sempre nel caso di f unimodale in [a,b], la scelta di c,d può essere effettuata in modo tale da garantire
una riduzione ottimale dell’ampiezza degli intervalli che racchiudono a ogni passo la soluzione.
L’algoritmo di Fibonacci search sceglie c, d nel seguente modo: se [a,b] contiene la soluzione, allora c =
a + p1*(b-a) e d = a+p2*(b-a) , dove p1= fibonacci(n-2)/fibonacci(n) e p1= fibonacci (n-1)/fibonacci(n)
con n scelto in base all’accuratezza richiesta delta.
Si ricorda che fibonacci(n) indica l’n-simo numero della successione di Fibonacci: 1,1,2,3,5,8,13,21,….. La
successione di Fibonacci è caratterizzata dal fatto che
fibonacci(1) = fibonacci(2) = 1
e che
fibonacci(n) = fibonacci(n-1) + fibonacci(n-2), qualunque sia n>2.
Abbiamo visto che l’algoritmo di Fibonacci search garantisce che il nuovo intervallo, che può essere
[a,d] oppure [c,b] entrambi della stessa ampiezza, abbia ampiezza (fibonacci(n-1)/fibonacci(n)) * (b-a),
che è minore di (b-a); inoltre, al passo successivo, il nuovo c o il nuovo d coincidono certamente o con il
vecchio d o con il vecchio c, consentendo di risparmiare una valutazione della funzione f a ogni passo (è
necessario cioè effettuare 1 valutazione, invece di 2). Al passo successivo il valore di n viene ridotto di 1,
e si procede nello stesso modo, fino ad arrivare a n = 1.
Infine, abbiamo visto che l’algoritmo, dopo n passi, determina un intervallo che contiene la soluzione e
che ha ampiezza uguale a (1/fibonacci(n)) *(b-a), ovvero l’algoritmo riduce l’errore iniziale sulla
soluzione (ovvero (b-a)) di un fattore 1/fibonacci (n).
L’algoritmo di Fibonacci search è globale e con velocità di convergenza lineare.
Una sua variante consiste nel ridurre, a ogni passo, di un fattore costante l’ampiezza dell’intervallo che
contiene la soluzione. Tale fattore è il numero -1 = 0.618, dove  è il numero noto come sezione
aurea (golden section). Per tale motivo, l’algoritmo prende il nome di Golden search. Anche l’algoritmo
Golden search garantisce che al passo successivo, il nuovo c o il nuovo d coincidono certamente o con il
vecchio d o con il vecchio c, consentendo di risparmiare una valutazione della funzione f a ogni passo (è
necessario cioè effettuare 1 valutazione, invece di 2).
L’algoritmo di Golden search è globale e con velocità di convergenza lineare.
Per esempio, se si vuole risolvere min -exp(-x)*sin(2*x-pi/2) in [-2.5,-1], in cui f è unimodale, si
procede così:
>> f = @(x) -exp(-x).*sin(2*x-pi/2);
>> xminimo = fmingolden(f,-2.5,-1,1e-6)
xminimo =
-1.802619924394157
xminimo è una approssimazione (-1.802619924394157) della soluzione (-1.802620131175508)
assumibile con 6 cifre della parte frazionaria corrette.

CALCOLONUMERICO1

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

CALCOLONUMERICO1

Diunggah oleh

Hak Cipta:

Format Tersedia

Programma del Corso di

Prerequisiti: Matematica I, Programmazione I.

Introduzione al calcolo scientifico. Ore di lezione: 2

Programmazione in MATLAB. Ore di laboratorio:3.

Risoluzione di una equazione. Ore di lezione: 5. Ore di laboratorio: 2.

Calcolo di massimi e minimi di funzioni. Ore di lezione: 3. Ore di laboratorio: 2.

Algebra lineare numerica. Ore di lezione: 6. Ore di laboratorio: 3.

Integrazione numerica. Ore di lezione: 4. Ore di laboratorio: 2.

Statistica descrittiva. Ore di lezione: 2. Ore di laboratorio: 2.

Materiale didattico fornito

Prof. Giulio GIUNTA

Tutor: dott. Mario RUGGIERI

Suddivisione in gruppi di Lab di 35 - 40 studenti

scaricare MATLAB dal sito

fondamenti di calcolo scientifico

progetto, analisi e sviluppo

altri linguaggi di MATLAB

MATLAB @ Informatica Uniparthenope

L’Università Parthenope offre agli studenti la

il servizio MATLAB Central File Exchange contiene

GNU General Public License

>> vet = [31 14 28 5 -12 32 -25 19 0 66];

>> vet = [31 14 28 5 -12 32 -25 19 0 66];

 organizzazione della Unità logico -

 rappresentazione dei numeri in

la ALU ha accesso diretto alla memoria

una ALU deve rispettare precisi

il codice operativo denota l’operazione da

l’output per la ALU è il risultato

 registri per gli operandi in input

mantissa  base esponente

 l’insieme dei numeri fp è finito

oggi tutti i computer

precisione e in doppia precisione

precisione e in doppia precisione

range singola precisione  10 38

range doppia precisione  10 308

segno esponente frazione

(il suo successivo)

segno esponente frazione

numeri rappresentabili esattamente

le operazioni aritmetiche eseguite

il risultato di una operazione fp

registri interni di almeno 80 bit

numero è una stima di epsMacchina

epsMacchina è il più piccolo numero fp che

strettamente maggiore di 1.0

la somma fp tra 1.0 e un qualunque numero fp

stima di epsMacchina in doppia precisione

x  21 .1281 a  21 .1243 x  21 .1281 a  21 .1276

x  1234 .5649 a  1234 .5611 x  1.9999 a  2.0001

errore relativo di a xa

x  21 .1281 a  21 .1243 x  21 .1281 a  21 .1276

x  1234 .5649 a  1234 .5611 x  1.9999 a  2.0001

0011 1111 1111 0000 0000 .. 0000

la somma fp tra x e un qualunque numero fp

significa: trovare un numero r tale che

Paolo Ruffini Niels Abel

Non esiste una formula per calcolare gli zeri di un

approssimazione iniziale (dato di input)

l’ampiezza di un intervallo è una stima dell’incertezza

requisiti per l’applicabilità:

l’ampiezza dell’intervallo [ak,bk]

l’errore si dimezza a ogni passo