Esperimenti in Matlab relativi alla teoria degli errori

(1)

Esperimenti in Matlab relativi alla teoria degli errori

Emma Perracchione

Corso di Calcolo Numerico per Ingegneria Meccanica (Univ. PD) Queste slides sono principalmente fornite dal Prof. Alvise Sommariva; vedasi https://www.math.unipd.it/~alvise/DIDATTICA/didattica_CNIE1819.html

A.A. 2018/2019

(2)

Materiale

TUTTO IL MATERIALE SI TROVA AL SEGUENTE LINK E VERRA' AGGIORNATO AD OGNI LEZIONE.

https://www.math.unipd.it/~emma/CN1819.html OPUURE VEDASI

https://elearning.unipd.it/dii/course/view.php?id=1720

(3)

Errori

Stabilità radici di secondo grado

Problema

Dato x ² + 2 px − q, con pp ² + q ≥ 0 implementare alcuni algoritmi in Matlab che valutino la radice positiva mediante la formula

y = −p + p

p ² + q.

p p ² + q ≥ 0 implica che l'equazione ha radici reali.

Algoritmo 1: Calcolo y = −p + pp ² + q .

(4)

Errori

Stabilità radici di secondo grado

La valutazione diretta è potenzialmente instabile per p q a causa della sottrazione tra p e pp ² + q (fenomeno della cancellazione).

Valutiamo la radice con un Algoritmo 2 stabile via razionalizzazione:

y = −p + p

p ² + q = (−p + p

p ² + q)(p + p

p ² + q) (p + p

p ² + q)

= q

(p + p

p ² + q) .

Abbiamo eliminato l'operazione di sottrazione.

(5)

Errori

Implementazione Matlab Algoritmo 1

Nella vostra cartella di lavoro trovate uno script denominato radicesecgrado.m.

p=1000; q=0.018000000081; sol=0.9*10^(-5);

% ALGORITMO 1 s=p^2;

t=s+q;

if t >=0 u=sqrt(t);

else fprintf('\n \t [RADICI COMPLESSE]');

end s1=-p+u; % valutazione radice richiesta col primo algoritmo

(6)

Errori

Implementazione Matlab Algoritmo 2

Di seguito, sullo stesso le trovate il secondo algoritmo

% ALGORITMO 2 s=p^2;

t=s+q;

if t >=0 u=sqrt(t);

else fprintf('\n \t [RADICI COMPLESSE]');

end v=p+u;

t1=q/v; % valutazione radice richiesta col secondo algoritmo

(7)

Errori

Valutiamo gli errori

Di seguito, sullo stesso le trovate l'implementazione del calcolo degli errori. Digitare sulla command window radicesecgrado.

% Soluzione fornita dal primo algoritmo.

fprintf('\n \t [ALG.1]: %10.19f',s1);

% Soluzione fornita dal secondo algoritmo.

fprintf('\n \t [ALG.2]: %10.19f',t1);

if length(sol) > 0 & (sol ~= 0)

% Errore relativo del primo algoritmo.

rerr1 =abs(s1-sol)/abs(sol);

% Errore relativo del secondo algoritmo.

rerr2=abs(t1-sol)/abs(sol);

% Stampa risultati.

fprintf('\n \t [REL.ERR.ALG.1]: %2.2e',rerr1);

fprintf('\n \t [REL.ERR.ALG.2]: %2.2e',rerr2);

end

(8)

Errori

Risultati e commenti

Come previsto, il secondo algoritmo si comporta notevolmente meglio del primo, che compie un errore relativo dell'ordine di circa 10 ⁻ ⁹ . Infatti:

>> radicesecgrado

[ALG.1]: 0.0000089999999772772 [ALG.2]: 0.0000090000000000000 [REL.ERR.ALG.1]: 2.52e-09 [REL.ERR.ALG.2]: 0.00e+00

>>

Su calcolatori diversi potete ottenere risultati leggermente diversi.

Seppure l'errore relativo sembri piccolo, è signicativo e non è dovuto

al problema ma esclusivamente all'algoritmo utilizzato.

(9)

Errori

Calcolo di π

Per celebrare la festa del π studiamo successioni convergenti (?) a π.

(10)

Errori

Calcolo di π

Eseguiamo un codice Matlab che valuti le successioni {u n } , {z n } , che teoricamente convergono a π, e sono denite rispettivamente come



 



 



s ₁ = 1, s 2 = 1 + ¹ ₄ , u ₁ = 1, u ₂ = 1 + ¹ ₄ , s _n+ ₁ = s _n + _(n+ ¹ ₁₎

₂

, u n+ 1 = √

6 s n+ 1 ,

e (

z ₁ = 1, z 2 = 2, z _n+ ₁ = 2 ⁿ⁻

¹²

q

1 − p1 − 4 ¹⁻ⁿ · z _n ² ,

Sul le pigreco.m dovete imlementare questi du metodi. Inoltre, ne

trovate un terzo (vedasi prossima slide).

(11)

Errori

Algoritmo 3

Implementiamo poi una terza successione, diciamo {y n } , che si ottiene razionalizzando, cioè moltiplicando numeratore e denominatore di

z _n+ ₁ = 2 ⁿ⁻

¹²

r

1 − q

1 − 4 ¹⁻ⁿ · z _n ² per r

1 + q

1 − 4 ¹⁻ⁿ · z _n ² e calcoliamo u m , z m e y m per m = 2, 3, . . . , 40.

% METODO 3.

y(1)=1; y(2)=2;

for n=2:40

num=(2^(1/2)) * abs(y(n));

c=(4^(1-n)) * (y(n))^2;

inner_sqrt=sqrt(1-c);

den=sqrt( 1+inner_sqrt );

y(n+1)=num/den;

end rel_err_y=abs(y-pi)/pi;

(12)

Errori

Algoritmi 12 (scriveteli voi!)

% METODO 1.

s(1)=1; u(1)=1; s(2)=1.25; u(2)=s(2);

for n=2:40

s(n+1)=s(n)+(n+1)^(-2);

u(n+1)=sqrt(6*s(n+1));

end rel_err_u=abs(u-pi)/pi;

fprintf('\n');

% METODO 2.

z(1)=1; z(2)=2;

for n=2:40

c=(4^(1-n)) * (z(n))^2; inner_sqrt=sqrt(1-c);

z(n+1)=(2^(n-0.5))*sqrt( 1-inner_sqrt );

end

rel_err_z=abs(z-pi)/pi;

(13)

Errori

Plot degli errori

Notare che alla ne del programa si stampano i graci degli errori.

Eseguire il programma (script) scrivendo sulla command window pigreco.

% SEMILOGY PLOT.

semilogy(1:length(u),rel_err_u,'k.',...

1:length(z),rel_err_z,'m+',...

1:length(y),rel_err_y,'ro');

legend('Alg. 1', 'Alg. 2', 'Alg. 3')

(14)

Errori

Risulati

0 5 10 15 20 25 30 35 40 45

10^-15 10^-10 10^-5 10⁰

Alg. 1 Alg. 2 Alg. 3

(15)

Complessità di calcolo

L'algoritmo di Horner

Ci poniamo il problema di valutare il polinomio con due algoritmi (presenti nella cartella di lavoro).

p(x ) = a ₀ + a ₁ · x + . . . + a _n · x ⁿ (1) in un punto x.

Osserviamo che

p(x ) = a ₀ + x · (a ₁ + x · (a ₂ + . . . + x · (a n− 1 + x · a n ))). (2) Supponiamo sia a = (a ₀ , . . . , a _n ) il vettore di dimensione n + 1 delle componenti del polinomio.

Il primo metodo valuta direttamente il polinomio secondo quanto descritto in (1),

Il secondo che eettua la stessa operazione come descritto in (2)

calcolando dapprima s ₁ = a n− 1 + x · a n , poi s ₂ = a n− 2 + x · s ₁ e così

via.

(16)

L'algoritmi di valutazione polinomio in matlab

Al ne di implementare gli algoritmi introduciamo delle function matlab. Sempre le di testo, ma con la parola chiave function. Vedasi lezione precedente.

Esperimenti in Matlab relativi alla teoria degli errori

Esperimenti in Matlab relativi alla teoria degli errori

Emma Perracchione

Corso di Calcolo Numerico per Ingegneria Meccanica (Univ. PD) Queste slides sono principalmente fornite dal Prof. Alvise Sommariva; vedasi https://www.math.unipd.it/~alvise/DIDATTICA/didattica_CNIE1819.html

A.A. 2018/2019

Materiale

TUTTO IL MATERIALE SI TROVA AL SEGUENTE LINK E VERRA' AGGIORNATO AD OGNI LEZIONE.

https://www.math.unipd.it/~emma/CN1819.html OPUURE VEDASI

https://elearning.unipd.it/dii/course/view.php?id=1720

Stabilità radici di secondo grado

Problema

Dato x 2 + 2 px − q, con pp 2 + q ≥ 0 implementare alcuni algoritmi in Matlab che valutino la radice positiva mediante la formula

y = −p + p

p 2 + q.

p p 2 + q ≥ 0 implica che l'equazione ha radici reali.

Algoritmo 1: Calcolo y = −p + pp 2 + q .

Stabilità radici di secondo grado

La valutazione diretta è potenzialmente instabile per p  q a causa della sottrazione tra p e pp 2 + q (fenomeno della cancellazione).

Valutiamo la radice con un Algoritmo 2 stabile via razionalizzazione:

y = −p + p

p 2 + q = (−p + p

p 2 + q)(p + p

p 2 + q) (p + p

p 2 + q)

= q

(p + p

p 2 + q) .

Abbiamo eliminato l'operazione di sottrazione.

Implementazione Matlab Algoritmo 1

Nella vostra cartella di lavoro trovate uno script denominato radicesecgrado.m.

p=1000; q=0.018000000081; sol=0.9*10^(-5);

% ALGORITMO 1 s=p^2;

t=s+q;

if t >=0 u=sqrt(t);

else fprintf('\n \t [RADICI COMPLESSE]');

end s1=-p+u; % valutazione radice richiesta col primo algoritmo

Implementazione Matlab Algoritmo 2

Di seguito, sullo stesso le trovate il secondo algoritmo

% ALGORITMO 2 s=p^2;

t=s+q;

if t >=0 u=sqrt(t);

else fprintf('\n \t [RADICI COMPLESSE]');

end v=p+u;

t1=q/v; % valutazione radice richiesta col secondo algoritmo

Valutiamo gli errori

Di seguito, sullo stesso le trovate l'implementazione del calcolo degli errori. Digitare sulla command window radicesecgrado.

% Soluzione fornita dal primo algoritmo.

fprintf('\n \t [ALG.1]: %10.19f',s1);

% Soluzione fornita dal secondo algoritmo.

fprintf('\n \t [ALG.2]: %10.19f',t1);

if length(sol) > 0 & (sol ~= 0)

% Errore relativo del primo algoritmo.

rerr1 =abs(s1-sol)/abs(sol);

% Errore relativo del secondo algoritmo.

rerr2=abs(t1-sol)/abs(sol);

% Stampa risultati.

fprintf('\n \t [REL.ERR.ALG.1]: %2.2e',rerr1);

fprintf('\n \t [REL.ERR.ALG.2]: %2.2e',rerr2);

end

Risultati e commenti

Come previsto, il secondo algoritmo si comporta notevolmente meglio del primo, che compie un errore relativo dell'ordine di circa 10 − 9 . Infatti:

>> radicesecgrado

[ALG.1]: 0.0000089999999772772 [ALG.2]: 0.0000090000000000000 [REL.ERR.ALG.1]: 2.52e-09 [REL.ERR.ALG.2]: 0.00e+00

>>

Su calcolatori diversi potete ottenere risultati leggermente diversi.

Seppure l'errore relativo sembri piccolo, è signicativo e non è dovuto

al problema ma esclusivamente all'algoritmo utilizzato.

Calcolo di π

Per celebrare la festa del π studiamo successioni convergenti (?) a π.

Calcolo di π

Eseguiamo un codice Matlab che valuti le successioni {u n } , {z n } , che teoricamente convergono a π, e sono denite rispettivamente come



 



 



s 1 = 1, s 2 = 1 + 1 4 , u 1 = 1, u 2 = 1 + 1 4 , s n+ 1 = s n + (n+ 1 1)

, u n+ 1 = √

6 s n+ 1 ,

e (

Dato x ² + 2 px − q, con pp ² + q ≥ 0 implementare alcuni algoritmi in Matlab che valutino la radice positiva mediante la formula

p ² + q.

p p ² + q ≥ 0 implica che l'equazione ha radici reali.

Algoritmo 1: Calcolo y = −p + pp ² + q .

La valutazione diretta è potenzialmente instabile per p q a causa della sottrazione tra p e pp ² + q (fenomeno della cancellazione).

p ² + q = (−p + p

p ² + q)(p + p

p ² + q) (p + p

p ² + q)

p ² + q) .

Di seguito, sullo stesso le trovate il secondo algoritmo

Di seguito, sullo stesso le trovate l'implementazione del calcolo degli errori. Digitare sulla command window radicesecgrado.

Come previsto, il secondo algoritmo si comporta notevolmente meglio del primo, che compie un errore relativo dell'ordine di circa 10 ⁻ ⁹ . Infatti:

Seppure l'errore relativo sembri piccolo, è signicativo e non è dovuto

Eseguiamo un codice Matlab che valuti le successioni {u n } , {z n } , che teoricamente convergono a π, e sono denite rispettivamente come

s ₁ = 1, s 2 = 1 + ¹ ₄ , u ₁ = 1, u ₂ = 1 + ¹ ₄ , s _n+ ₁ = s _n + _(n+ ¹ ₁₎

z ₁ = 1, z 2 = 2, z _n+ ₁ = 2 ⁿ⁻

1 − p1 − 4 ¹⁻ⁿ · z _n ² ,

Sul le pigreco.m dovete imlementare questi du metodi. Inoltre, ne

z _n+ ₁ = 2 ⁿ⁻

1 − 4 ¹⁻ⁿ · z _n ² per r

1 − 4 ¹⁻ⁿ · z _n ² e calcoliamo u m , z m e y m per m = 2, 3, . . . , 40.

Algoritmi 12 (scriveteli voi!)

Notare che alla ne del programa si stampano i graci degli errori.

p(x ) = a ₀ + a ₁ · x + . . . + a _n · x ⁿ (1) in un punto x.

p(x ) = a ₀ + x · (a ₁ + x · (a ₂ + . . . + x · (a n− 1 + x · a n ))). (2) Supponiamo sia a = (a ₀ , . . . , a _n ) il vettore di dimensione n + 1 delle componenti del polinomio.

Il secondo che eettua la stessa operazione come descritto in (2)

calcolando dapprima s ₁ = a n− 1 + x · a n , poi s ₂ = a n− 2 + x · s ₁ e così

Al ne di implementare gli algoritmi introduciamo delle function matlab. Sempre le di testo, ma con la parola chiave function. Vedasi lezione precedente.