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., A.MURLI: “Matematica Numerica: metodi, algoritmi e software". W.J. PALM - “MATLAB per l’ingegneria” - McGraw Hill Italia, 2001.

Springer, Liguori,

2004. 2007.

Corso di Calcolo Numerico CdL Informatica, Calcolo Numerico e Matematica Applicata CdL SNeA - 6 CFU Prof. Giulio GIUNTA [email protected]

modalità esame: orale con prova Matlab (40%)+ 2 Prove intercorso (40%) + 2 HomeWork (20%)

Prof. Giulio GIUNTA [email protected]

Orario ricevimento: lunedì, ore 14:00 – 16:00, stanza 420, quarto piano Nord

Tutor: dott. Mario RUGGIERI [email protected]

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 programmazione

MATLAB

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

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 portare un pc laptop (con Matlab) per le lezioni in aula

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

4 10  2 10  5 10  7 10  6 10 2

1

0

notazione scientifica

4.2576 10 in posizione fissa

2

2

notazione scientifica

4.2576 10

2

esponente

mantissa

m  b

e

base (fissa)

mantissa  base

esponente

ordine di grandezza

0.0000076 notazione scientifica:

7.6 10

6

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

Aritmetica standard IEEE rappresentazione fp ±m× b in singola precisione e in doppia precisione e

mantissa

e + bias

±1. frazione × 2

vengono memorizzate solo le quantità

 segno  frazione  esponente (e + bias)

Aritmetica standard IEEE rappresentazione fp ±m× b in singola precisione e in doppia precisione e

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

Aritmetica standard IEEE  10

range singola precisione (intervallo rappresentabile)

- (2-2 )  2 ,- 2 -23

127

-126

 2

-126

range doppia precisione (intervallo rappresentabile)

- (2-2 )  2 ,- 2 -52

1023

-1022

 2

-1022

38

,(2-2 )  2  -23

127

 10

308

, (2-2 )  2 -52

1023



Aritmetica standard IEEE  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 00000000 00000001

23

2

rappresentazione del numero 0 (zero)

00000000 00000000 00000000 00000000 segno esponente

frazione

00000000 00000000 00000000 00000000 frazione

doppia precisione segno

esponente

frazione

00000000 00010000

00000000 00000000 00000000 00000000 00000000 00000001 frazione

52

2

overflow: numeri troppo grandi, in valore assoluto underflow: numeri troppo piccoli, in valore assoluto

o v e r f l o w

intervallo rappresentabile 0

underflow

o v e r f l o 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)

Aritmetica standard IEEE 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)

Aritmetica standard IEEE massima accuratezza

numeri fp

x  y = arrotondamento( x  y) operazione fp

rappresentazione del risultato “vero” con mantissa arrotondata alla precisione del sistema (t bit)

Aritmetica standard IEEE 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 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

epsMacchina è il più piccolo numero fp che 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

epsMacchina è il più piccolo numero fp che sommato a 1.0, mediante addizione fp, fornisce un risultato strettamente maggiore di 1.0

0

1 numero fp successivo di 1

#include 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 divisioni= %d\n",numero,cont); }

% 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 divisioni= %d\n",numero,cont); 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.0

21

+

1./4.

mantissa

e

1 . 0 0 0 0 1 . 0 0 0 0

+ 0 0 0 0 1 - 0 0 0 1 0

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

1.0 2-2 incolonnamento

errore assoluto ed errore relativo sia dato un numero x e una sua approssimazione a errore assoluto di a

Eass  x  a

se x e a hanno la stessa parte intera e le stesse prime m cifre della parte frazionaria, allora

Eass  x  a  10

xa

se x e a hanno le stesse prime m cifre significative, allora xa

x

x

errore relativo di a

Erel 

m

Erel 

 10  m

le cifre significative di un numero sono le cifre della sua mantissa esclusi gli eventuali “zeri in testa”

errore assoluto ed errore relativo non è strettamente VERO

sia dato un numero x e una sua approssimazione a

errore assoluto di a

Eass  x  a

x  21 .1281

a  21 .1243

se

Eass  x  a  10  m

allora x e a hanno la stessa parte intera e le stesse prime m cifre della parte frazionaria

x  21 .1281

a  21 .1276

Eass  0.38 10  2  10  2

Eass  0.5 10 3  10  2

x  1234 .5649

x  1.9999

Eass  0.38 10

a  1234 .5611 2

 10

2

a  2.0001

Eass  0.2 10 3  10  2

errore assoluto ed errore relativo sia dato un numero x e una sua approssimazione a

errore relativo di a

Erel  x  21 .1281

xa

se

non è strettamente VERO

Erel 

xa x

 10  m

allora x e a hanno le stesse prime m cifre significative

x

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

x  1.9999

Erel  3.07 10

a  1234 .5611 6

 10

6

Erel  10  4

a  2.0001

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 » 1 ans = 3ff0000000000000 »

rappresentazione f-p di 0

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 » 1+eps ans = 3ff0000000000001 » 1+eps/2 ans = 3ff0000000000000 >> 1+eps/2+eps/2 ans = 3ff0000000000000 » 1+2^(-52) ans = 3ff0000000000001 » 1+2^(-53) ans = 3ff0000000000000

0 1 2 3 4 5 6 7 8

0000 9 0001 10 (a) 0010 1 11 (b) 0011 12 (c) 0100 13 (d) 0101 14 (e) 0110 0111 15 (f) 1000

1

1001 1010 1011 1100 1101 1110 1111

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

oppure

wx  f x   1 v x 

, v x   0

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

1

0.5

0

-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

1

0.5

0

-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

1

0.5

0

-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

1

0.5

0

-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 (1765-1822):

Niels Abel (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

gli intervalli hanno ampiezza decrescente

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

a0  a

b0  b

input:

m0

• f(x) •aeb

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

a0  a

b0  b

input:

m0

• f(x) •aeb

a0  b0    2

segno  f  a0    segno  f  m0   vero

falso

 a1 , b1    a0 , m0   a1 , b1    m0 , b0  al passo k:

 ak , bk 

contiene la radice

al passo k:

 ak , bk 

contiene la radice

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 errk  r  mk  bk  ak  ek 2

1 ek  ek 1 2

k

1 ek    e0 2 1 ek    2

k 1

b  a 

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 sempre

1 ek  ek 1 2

convergenza lineare

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

1 k:  2

k 1

b  a   

1   2

k 1

b  a   

2

 k 1

  b  a 

    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 ba l’incertezza iniziale e l’accuratezza richiesta 

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 eps*max(abs(ak),abs(bk))

criterio di arresto basato sull’errore assoluto stima dell’ampiezza del 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 (massima accuratezza)

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 (massima accuratezza)

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; >> bisezione(f,0,2,0.001) ans = 0.99951171875000 >> f1=inline('x.^2-1'); >> bisezione(f1,0,2,0.001) ans = 0.99951171875000

definizione diretta di una function tramite handle (puntatore) definizione diretta di una inline function (f1 è un hanlde)

>> 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 0 1 0.50000000000000 1.00000000000000 0.75000000000000 1.00000000000000 0.87500000000000 1.00000000000000 0.93750000000000 1.00000000000000 0.96875000000000 1.00000000000000 0.98437500000000 1.00000000000000 0.99218750000000 1.00000000000000 0.99609375000000 1.00000000000000 0.99804687500000 1.00000000000000 0.99902343750000 1.00000000000000 ans = 0.99951171875000

ampiezza interv. 1 0.50000000000000 0.25000000000000 0.12500000000000 0.06250000000000 0.03125000000000 0.01562500000000 0.00781250000000 0.00390625000000 0.00195312500000 0.00097656250000

>> bisezione(@f2,0,12,0.001) estremo sinistro estremo destro 0 6 0 3 0 1.50000000000000 0.75000000000000 1.50000000000000 1.12500000000000 1.50000000000000 1.31250000000000 1.50000000000000 1.31250000000000 1.40625000000000 1.31250000000000 1.35937500000000 1.33593750000000 1.35937500000000 1.34765625000000 1.35937500000000 1.34765625000000 1.35351562500000 1.35058593750000 1.35351562500000 1.35058593750000 1.35205078125000 1.35058593750000 1.35131835937500 ans = 1.35095214843750

ampiezza interv. 6 3 1.50000000000000 0.75000000000000 0.37500000000000 0.18750000000000 0.09375000000000 0.04687500000000 0.02343750000000 0.01171875000000 0.00585937500000 0.00292968750000 0.00146484375000 0.00073242187500

function radice=bisez_ric(funzione,a,b,delta_ass) % risoluzione dell'equazione f(x)=0 mediante % bisezione con approccio ricorsivo. % 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|) %

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) estremo sinistro estremo destro 0 12 0 6 0 3 0 1.50000000000000 0.75000000000000 1.50000000000000 1.12500000000000 1.50000000000000 1.31250000000000 1.50000000000000 1.31250000000000 1.40625000000000 1.31250000000000 1.35937500000000 1.33593750000000 1.35937500000000 1.34765625000000 1.35937500000000 1.34765625000000 1.35351562500000 1.35058593750000 1.35351562500000 1.35058593750000 1.35205078125000 1.35058593750000 1.35131835937500 ans = 1.35095214843750

ampiezza interv. 12 6 3 1.50000000000000 0.75000000000000 0.37500000000000 0.18750000000000 0.09375000000000 0.04687500000000 0.02343750000000 0.01171875000000 0.00585937500000 0.00292968750000 0.00146484375000 0.00073242187500

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 1 xk

 xk 

f  xk  f   xk 

metodo di Newton

xk 1

f  xk   xk  f   xk 

requisiti per l’applicabilità:  f(x) e f’(x) devono essere note  x0 deve essere noto

xk 1  xk  ck

f xk  ck   f xk 

function radice = Newton(funzione,derivata,xiniz,delta_ass,kmax) % risoluzione dell'equazione f(x)=0 % mediante metodo di Newton % input: % funzione puntatore (handle) alla % function che definisce f(x) % derivata puntatore (handle) alla % function che definisce f'(x) % xiniz approssimazione iniziale della % soluzione % delta_ass reale non negativo; il massimo % errore assoluto richiesto % 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 fprimoxk = derivata(xk); arresto correzionek = -fxk/fprimoxk; k = k+1; disp([xk,abs(correzionek)]) 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  xk  x f   xk 

f  xk  xk 1  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  ba f a 

,

f b  ba f b 

allora il metodo di Newton converge per qualsiasi scelta di x0  a, b

il metodo di Newton non converge sempre (metodo locale) f a  ba f a 

,

f b  ba f b  f b  f b 

a

b f a  f a 

il metodo di Newton non converge sempre (metodo locale) il metodo di Newton ha rapidità di convergenza quadratica (più efficiente del metodo di bisezione)

xk 1  r  c  xk  r errk 1  c  errk

2

2 nel caso di zeri non multipli

xk 1  xk  ck

errk  xk  r sviluppo di Taylor, arrestato al primo ordine:

1 2 0  f r   f xk   f xk r  xk   f  r  xk  2 f xk  f xk  1 f   r  xk   r  xk 2 0  f xk  f xk  2 f xk 

,   xk , r 

f xk  1 f   r  xk 2  xk  r   f xk  2 f xk 

1 f   2 r  xk  r  xk 1   2 f xk  xk  r 

errk 1 1 f   xk   2 errk 2 f   xk 

1 f    errk 1  errk 2 2 f   xk   errk 1 1 f   r     lim  2 k  err 2 f   r   k 

c

il metodo di Newton non converge sempre (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 T    

= numero di passi per numero di

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

metodo delle secanti usa solo valori di f(x) (approssimare f ’(x))

xk 1xk

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

xk 1

f xk  ck   pk

metodo delle secanti 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

metodo delle secanti usa solo valori di f(x) (approssimare f ’(x))

xk 1 xk xk 1

metodo delle secanti usa solo valori di f(x) (approssimare f ’(x))

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: % funzione puntatore (handle) alla % function che definisce f(x) % xiniz prima approssimazione iniziale % della soluzione % xiniz1 seconda approssimazione iniziale % della soluzione % delta_ass reale non negativo; il massimo % errore assoluto richiesto % sul risultato % kmax intero, massimo numero di % 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; disp([xk,abs(correzionek)]) while abs(correzionek)>delta_ass+eps*abs(xk)&k<=kmax xk1 = xk; fxk1 = fxk; criterio xk = xk + correzionek; di fxk = funzione(xk); arresto pxk = (fxk-fxk1)/(xk-xk1); correzionek = -fxk/pxk; k = k+1; disp([xk,abs(correzionek)]) 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

errk 1  C  errk

1.618

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

errk 1    err

errk    err

q k

  errkq  C  errk  



1 q

q

q k 1

1 q k

 err

1

err  c  errk q k

sezione aurea (golden section)

1 q

1  q  1 q

q    1.618

metodi ibridi obiettivo: metodo globale con velocità di convergenza superlineare 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 convergenza superlineare

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 % che contiene la soluzione % delta_ass reale non negativo; il massimo % 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 disp(sprintf('%20.15f %20.15f %20.15f',a,x,b)) 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 % che contiene la soluzione % b estremo destro di un intervallo % che contiene la soluzione % delta_ass reale non negativo; il massimo % 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); 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,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 disp(sprintf('%20.15f %20.15f %20.15f',a,x,b)) 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

metodo del punto fisso noto (dato di input)

x1  g  x0 

x2  g  x1 

x3  g  x2 

x4  g  x3 

x5  g x4 



metodo del punto fisso g funzione di iterazione

xk 1  g  xk



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

metodo del punto fisso

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

metodo del punto fisso

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

metodo del punto fisso

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 % delta_ass reale non negativo; il massimo % errore assoluto richiesto % sul risultato % kmax intero, massimo numero di % 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; arresto disp([xsucc abs(xsucc-xprec)]) 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

x  f  x  x

il problema di risoluzione di una equazione può essere trasformato in un problema di punto fisso equivalente (ovvero, che hanno la stessa soluzione)

funzione di iterazione g

problema del punto fisso e risoluzione di una equazione

f  x   x  3sin  x   0 4

esempio

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 pp è soluzione di

x  3sin  x   x  x 4

x  3sin  x   0 4

problema del punto fisso e risoluzione di una equazione

f  x  x  x  2  0 r  2 2

esempio

problemi di punto fisso equivalenti: 2 g x  x  2 diverge   x 2  x

2

2 1  x x

2 g  x  1 x

converge

x2  2 x 2x 1

x2  2 g  x  2x 1

converge

p2

g   2  4

g  2  0

punto fisso e analisi dei metodi iterativi xk 1  g  xk



un metodo iterativo può essere visto come metodo di punto fisso

f  xk  xk 1  xk  f   xk 

es.: metodo di Newton

è un metodo di punto fisso con funzione di iterazione

f  x g  x  x  f  x f  f   f f  f f   g  1  2 f f 2

g  r  

f  r  f   r 

 f   r 

2

0

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

-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). Il nucleo della function è costituito dalla struttura ripetitiva che realizza il processo iterativo: while

abs(correzionek) > delta_ass + eps*abs(xk) & k <= kmax xk = xk + correzionek; fxk = funzione(xk); fprimoxk = derivata(xk); correzionek = -fxk/fprimoxk; k = k+1;

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], 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 -1

-0.2

-1.5 -0.4 -2 -0.6

-0.8 0.5

-2.5

1

1.5

-3 0.5

1

1.5

>> ris = Newton(f,fprimo,0.9,1e-6,30) % appross. iniziale 0.9 ris = 1.047197258345557 % in format long ris è una approssimazione (1.047197258345557) della soluzione (1.047197551196598) con 6 cifre della

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). Il residuo dell’approssimazione ris è immediatamente calcolabile valutando la f in ris: >> residuo = f(ris) residuo = 8.711421187216681e-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. 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. 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 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). Il nucleo della function è costituito dalla struttura ripetitiva che realizza il processo iterativo: while

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

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], si procede così: >> 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 ris è una approssimazione (1.047197553370035) della soluzione (1.047197551196598) con 6 cifre della

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). Il residuo dell’approssimazione ris è immediatamente calcolabile valutando la f in ris: >> 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 approssimazione di 0 con 6 cifre corrette. 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. 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); >> 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]) ris = 1.047197551196598

% intervallo che contiene la soluzione

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

f :ℜ → ℜ

arg min( f ( x )) x

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

min (− f ( x ))

arg min (− f ( x ))

x

x

x

x

20

f (x )

18 16 14 12 10 8 6 4 2 0

0

0.2

0.4

0.6

0.8

1

1.2

1.4

0

− f (x )

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

x k +1

f ′ ( xk ) = 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: risoluzione di f ’(x) = 0

f ′ ( xk ) xk +1 = xk − 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 8 6 4 2 0 -4

-3

-2

-1

0

1

2

3

4

20

15

10

5

0

polinomio q -5 -4

-3

xk = 2.2 -2

-1

xk +1 = −1.128

0

1

2

3

4

metodo di Newton per la minimizzazione: risoluzione di f ’(x) = 0

x k +1

f ′ ( xk ) = xk − f ′′ ( x k )

q (x k q ′ (x k

)= )= q ′′ ( x k ) =

sviluppo di Taylor di f attorno a xk arrestato al secondo ordine:

f (x k ) f ′ (x k )

f ′′ ( x k

)

( )

c2 3 f ( xk + c ) = f ( xk ) + c ⋅ f ′ ( xk ) + ⋅ f ′′ ( xk ) + O c 2

min f (x ) = min f (xk + c ) x

c

  c2 ≈ min  f ( xk ) + c ⋅ f ′ ( xk ) + ⋅ f ′′ ( xk )  c 2  

 d  c2  f ( xk ) + c ⋅ f ′( xk ) + ⋅ f ′′( xk ) = 0 dc  2 

è una funzione della variabile c

metodo di Newton per la minimizzazione: risoluzione di f ’(x) = 0

q (x k q ′ (x k

)= )= q ′′ ( x k ) =

sviluppo di Taylor di f attorno a xk arrestato al secondo ordine:

min f (x ) = min f (xk + c ) x

c

f (x k ) f ′ (x k )

f ′′ ( x k

)

  c2 ≈ min  f ( xk ) + c ⋅ f ′ ( xk ) + ⋅ f ′′ ( xk )  c 2  

 d  c2  f ( xk ) + c ⋅ f ′( xk ) + ⋅ f ′′( xk ) = 0 dc  2 

f ′( x k ) c=− f ′′( x k )

x k +1

f ′ ( xk ) = xk − f ′′ ( x k )

f ′(xk ) + c ⋅ f ′′(xk ) = 0

xk +1 = xk + c xk +1 = xk + ck

metodo di minimizzazione di Newton

x k +1

f ′ ( xk ) = 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)

metodo di minimizzazione di Newton

varianti


approssimazione della derivata prima e seconda (con differenze finite)

~ xk +1 = xk + ck

f ′( x k ) ck = − f ′′( x k )

f ( x k ) − f ( x k −1 ) f ′( x k ) ≈ p k = x k − x k −1

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

metodo di minimizzazione di Newton

varianti


approssimazione della derivata prima e seconda (con differenze finite)

~ xk +1 = xk + ck f ′( x k ) ck = − f ′′( x k )

f ′( x k ) ≈ p k =

f ( x k ) − f ( x k −1 ) x k − x k −1

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 )(x k −1 − x k − 2 ) (x k − x k −1 )2

f ′′( x k ) ≈ p 2 k =

p k − p k −1 ( x k − x k −1 )

pk ~ ck = − p2k

varianti

metodo di minimizzazione di Newton


determinazione (a ogni passo k) del minimo del polinomio di secondo grado interpolante su xk , xk-1, xk-2 20

15

10

5

0

-5 -4

xk-3− 2

-2

x-1k +1

0

1

x k2

3

xk −1 4

metodo di minimizzazione di Newton

varianti


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

metodo del gradiente discendente

passo successivo

(steepest descent)

approssimazione iniziale

metodo del gradiente discendente

approssimazione iniziale passo successivo

(steepest descent)

nuova derivata

metodo del gradiente discendente

approssimazione iniziale passo successivo

(steepest descent)

metodo del gradiente discendente

approssimazione iniziale

(steepest descent)

metodo del gradiente discendente

(steepest descent)

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.

λ A + (1 − λ ) B,

0 ≤ λ ≤1

appartiene all’insieme

insieme convesso

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.

λ A + (1 − λ ) B,

0 ≤ λ ≤1

appartiene all’insieme

insieme non convesso

funzioni e insiemi convessi l’epigrafo di una funzione convessa è un insieme convesso

funzione convessa

funzione non convessa

funzioni e insiemi convessi funzione non convessa

un mimino locale può non essere un minimo globale

funzione convessa

un mimino locale è un minimo globale

funzioni e insiemi convessi funzione convessa

il minimo globale può non essere unico

un mimino locale è un 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 problema più facile, rispetto al caso generale

un mimino locale è un minimo globale

calcolo del minimo di una funzione unimodale le funzioni con un unico punto di minimo sono dette funzioni unimodali definizione: definizione: una una funzione funzione f(x) f(x) èè unimodale unimodale in in [[a,b a,b],], se se esiste esiste un un unico unico numero numero pp in in [a,b] [a,b] tale tale che che

f(x) f(x) èè strettamente strettamente decrescente decrescente in in [[a,p a,p]] ed ed èè strettamente strettamente crescente crescente in in [[p,b p,b]]

calcolo del minimo di una 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)

calcolo del minimo di una 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)
a < minimo < d

10 8 6 4 2 0 -4

a

-3

-2

c

-1

0

1

2

3

d

4

b

18 16

x.^2+0.45*(sin(2*x)).^2;

14

c <12d and f(c)>f(d)

c < minimo < b

10 8 6 4 2 0 -4

a

-3

-2

c

-1

0

1

2

d

3

4

b

function function ris ris == 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); fd fd == 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 ris ris == fminrand1(f,a,b,delta_ass) fminrand1(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 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); fd fd == 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

rendere il più piccolo possibile il nuovo intervallo che racchiude il minimo 12 ( [a,d] o [c,b] ) 14

10 8 6

a ogni passo valutare una sola volta la funzione

il punto c o il punto d deve essere un punto già considerato al passo precedente 4 2 0 -4

a

-3

-2

c

-1

0

1

2

3

d

4

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

Metodo della ricerca di Fibonacci (Fibonacci search) 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) d = a + fibonacci (N-1)/fibonacci (N) *(b-a)

FN −1 (b − a ) FN

numeri di Fibonacci

Metodo della ricerca di Fibonacci (Fibonacci search) 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 [c,b] : (b-c) c = a + fibonacci (N-2)/fibonacci (N) *(b-a)  FN − 2  FN − 2  (b − a ) − (b − a ) = (b − a )1 − FN FN  

Metodo della ricerca di Fibonacci (Fibonacci search) 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

FN −1 (b − a ) FN

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

Metodo della ricerca di Fibonacci (Fibonacci search) 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

FN −1 (b − a ) FN

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

Metodo della ricerca di Fibonacci (Fibonacci search) 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) l’intervallo finale ha ampiezza:

FN −1 FN − 2 FN −3 F2 F1 [b − a] ⋯ FN FN −1 FN − 2 F3 F2

1 [b − a] FN

Metodo della ricerca di Fibonacci (Fibonacci search)

1 [b − a] FN

1 [b − a ] < δ FN

fissato δ allora N deve essere tale che

[b − a ]

1

δ

< FN ≈ ϕ

N

sezione aurea (golden section)

Metodo della ricerca di Fibonacci (Fibonacci search)

FN − 2 FN −1 c = a + [b − a ] , d = a + [b − a ] FN FN supponiamo che il nuovo intervallo sia [a,d]

d nuovo

FN − 2 FN −1 FN − 2 = a + [d − a ] = a + [b − a ] =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 ris ris == 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); 1 N b − a < F ≈ ϕ cc =(fibonacci(n-2)/den)*h+a; N =(fibonacci(n-2)/den)*h+a; δ dd =(fibonacci(n-1)/den)*h+a; =(fibonacci(n-1)/den)*h+a; ak ak == a; a; bk bk == b; b; hk hk == h; h; 1 log b − a + log  ≈ N log ϕ fc fc == f(c); f(c); fd fd == f(d); f(d); δ  for for k=n-1:-1:2 k=n-1:-1:2 den log b − a − log δ den == fibonacci(k); fibonacci(k); N≈ if if fc fc << fd fd log ϕ bk bk == d; d; dd == c; c; fd fd == fc; fc; 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 =ϕ n →∞ F n −1

1.6180….

Fn −1 1 lim = ≡ ϕ −1 n →∞ F ϕ n

sezione aurea (golden section)

0.6180….

Fibonacci search 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)

ϕ -1

Golden search

Fn lim =ϕ n →∞ F n −1

1.6180….

Fn −1 1 lim = ≡ ϕ −1 n →∞ F ϕ n

sezione aurea (golden section)

0.6180….

Fibonacci search 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)

Fn −1 1 lim = ≡ ϕ −1 n →∞ F ϕ n

Golden search

Fn − 2 Fn − Fn −1 Fn −1 = = 1− Fn Fn Fn Fn − 2 lim = 1 − (ϕ − 1) = 2 − ϕ n →∞ F n

0.3819...

Fibonacci search 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)

2-ϕ

Golden search

Fn −1 1 lim = ≡ ϕ −1 n →∞ F ϕ n

Fn − 2 Fn − Fn −1 Fn −1 = = 1− Fn Fn Fn Fn − 2 lim = 1 − (ϕ − 1) = 2 − ϕ n →∞ F n

0.3819...

Golden search primo passo (l’intervallo che contiene la soluzione è [a,b]) 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 ris ris == fmingolden(f,a,b,delta_ass) fmingolden(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 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); fd fd == 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
function Matlab fminbnd

( ( ))

f (x ) = exp sin x

2

  1   + x + 3 sin exp −   1+ x  4

utilizzare 2.15 come approssimazione iniziale

   

4 3.9

( ( ))

f ( x ) = exp sin x

2

  1   + x + 3 sin exp −   1+ x  4

   

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
function Matlab fminbnd

20

( ( ))

f ( x ) = exp sin x

18

2

16

  1  + x + 3 sin exp −   1+ x  4

   

14 12 10 8 6 4 2 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. 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 ). 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 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)

seconda

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

-2.5

-2

-1.5

-1

-0.5

0

-35 -3

-2.5

-2

>> xminimo = Newton(fprimo,fsecondo,-2.5,1e-6,30) xminimo = -1.802620131305244 % in format long

-1.5

-1

-0.5

0

% appross. iniziale 0.9

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)) xminimo = -1.802620131175508 % in format long

% delta è 1e-4

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 cf(d), allora la soluzione si trova certamente in [c,b]; mentre se f(c)
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.