Metodo di Bisezione Applicabilità metodo di bisezione

Metodo di Bisezione
Applicabilità metodo di bisezione: Se è continua in
e
Proprietà di convergenza:
converge allo zero in quanto
, l’errore al passo
che
, basta fermarsi dopo
ammette almeno uno zero in
.
si dimezza ad ogni passo. Essendo
sarà t.c.:
. Per garantire
iterazioni:
Affidabilità criteri d’arresto:
. Stima accurata dell’errore se
zero cercato. Se
ho sovrastima dell’errore, se
ho sottostima dell’errore.
Bisez: function [xvect, it] = bisez(a, b, toll, f)
in un intorno dello
if f(a)*f(b)>= 0
error('Il metodo non è applicabile')
end
xvect = [];
nmax = ceil(log2((b - a)/toll)-1);
err = toll + 1;
it = -1;
while (err > toll && it < nmax)
it = it + 1;
x = (b + a)/2;
if f(x) == 0
err = 0;
elseif f(a)*f(x)<0
b = x;
err = abs(f(x));
else
a = x;
err = abs(f(x));
end
xvect = [xvect; x];
end
Metodo di Newton
Descrizione: Cerchiamo
t.c.
. Dall’eq. della retta tangente si trova:
,
purché
. Equivale a calcolare lo zero di sostituendo localmente a la sua retta tangente.
Convergenza e ordine di convergenza: Newton converge a zero in un solo passo quando è lineare. La convergenza di
Newton non è garantita
semplice (
ha molteplicità
)e
, ma solo per valori di
suff. vicini ad . Se
è scelto opportunamente, lo zero
, Newton converge almeno quadraticamente:
l’ordine 2 di convergenza può essere recuperato usando:
Criterio d’arresto: Diff fra due it succ:
. Buon criterio quando lo zero è semplice,
Newton:function [xvect, it] = newton(x0, nmax, toll, f, df)
xvect = [];
x = x0;
err = toll+1;
it = 0;
while (err > toll && it < nmax)
if df(x) == 0
error('Azzeramento della derivata prima')
end
err = abs((x - (f(x)/df(x))) - x);
x = x - (f(x)/df(x));
xvect = [xvect; x];
it = it + 1;
end
è
. Se lo zero
.
.
Punto fisso
viene detto punto fisso di se
.
Descrizione: Data
successione:
Teorema 1:
1) Se
e lo si può determinare come limite della
almeno un punto fisso
2) Se
Teorema 2 (Ostrowski): Se
è punto fisso di
,
converge ad
(
di .
è unico e
converge sempre
opportuno intorno di ) e
. Inoltre:
Teorema 3: Sotto le ipotesi del th. di Ostrowski, se inoltre
.
.
e
, ma
(converge con ordine p).
Criterio d’arresto: Sia
. Con il th. del valor medio troviamo:
, e dall’identità:
quando
è un buon stimatore.
Ptofis: function [succ , it] = ptofis (x0 , phi , nmax , toll)
x = x0;
succ = [ x0 ];
it = 0;
err = toll + 1;
while (it < nmax && err > toll)
err = abs(x - phi(x));
x = phi(x);
succ = [succ; x];
it = it + 1;
end
Polinomi
Polinomi Caratteri di Lagrange:
Polinomio di interpolazione nella forma di Lagrange:
Errore per un polinomio di Lagrange di grado n con partizione generica e stima nel caso di partizione uniforme:
dove
per
.
Nel caso di una distribuzione uniforme di nodi:
Matlab:% Polinomio di lagrange di grado n relativo a nodi equispaziati
h = (b-a)/n;
x_nodi = [a : h : b];
P = polyfit(x_nodi, f(x_nodi), n);
Pn = polyval(P, x);
err = abs(f(x) - Pn);
% Polinomio relativo a nodi di Chebyshev (evita fenomeno di runge (oscill spurie)
i = [0 : n];
x_cheb = -cos((pi.*i)./n);
x_nodi_cheb = ((a + b)/2) + ((b - a)/2).*x_cheb;
P_cheb = polyfit(x_nodi_cheb, f(x_nodi_cheb), n);
Pn_cheb = polyval(P_cheb, x);
err_cheb = abs(f(x) - Pn_cheb);
Interpolazione composita lineare: Data una distribuzione di nodi, non necessariamente equisp., indichiamo con
l’intervallo
. Approssimiamo con una funzione continua che, su ciascun intervallo, è data dal
.
segmento congiungente i punti
:
,
dove
. Se
è la max lunghezza degli .
% Interpolazione composita lineare
y_ICL = interp1(x_nodi, f(x_nodi), x);
err_ICL = abs(f(x)-y_ICL);
Minimi quadrati: Dati
, dove
e dato
. Se ,
, cerchiamo un polinomio
che soddisfi:
è l’appross nel senso dei minimi quadrati di grado
.
% Interpolazione ai minimi quadrati
PMQ = polyfit(x_nodi, f(x_nodi), 2);
y_IMQ = polyval(PMQ, x);
err_IMQ = abs(f(x)-y_IMQ);
Spline Cubica naturale: Costruiamo una funz

Su ogni
,
che abbia le seguenti caratteristiche:
deve essere un pol di grado 3 che interp le coppie

e
devono essere continue in ogni
Per la completa det è nec assegnare 4 condizioni su ciascun e 4n eq che possono essere così individuate:
 n+1 cond dovute alla richiesta che interpoli i dati nei nodi
 n-1 cond dovute alla richiesta che sia continua nei nodi interni
 imponendo la continuità anche a
e
negli stessi nodi otteniamo 2(n-1) eq addizionali
Restano da individuare 2 eq addizionali che possono essere date da
e
così caratterizzata
è detta spline cubica naturale. L’errore che si commette approssimando una
dove
solo , ma anche
è la max ampiezza dei sottoint,
vengono ben approssimate da
quando
è
un opportuna cost che dipende da r. Non
.
% Interpolazione con spline cubica naturale
y_ISCN = cubicspline(x_nodi, f(x_nodi), x);
err_ISCN = abs(f(x)-y_ISCN);
Punto Medio
Suddividiamo
in M sottointervalli
. Interpoliamo
equispaziati con passo
nel punto medio di
, dove
:
t.c.
. Otteniamo:
. L’errore è:
. O.D.A rispetto ad H = 2. G.D.E = 1.
Pmedcomp: function I = pmedcomp(a, b, N, f)
h = (b - a) / N;
x_medio = [a + h/2 : h : b - h/2];
I = h * sum(f(x_medio));
Trapezi
Suddividiamo
in M sottointervalli
equispaziati con passo
t.c.
. La formula del trapezio comp. è:
L’errore è:
.
, dove
. O.D.A rispetto ad
= 2. G.D.E. = 1.
Trapcomp.m: function I = trapcomp(a, b, N, f)
h = (b-a)/N;
x = [a + h : h : b - h];
I = ((h / 2)*(f(a) + f(b))) + (h * sum(f(x)));
Formula di Simpson
Suddividiamo
in M sottointervalli
equispaziati con passo
. Sostituiamo su ogni intervallo l’integrale di
nodi:
L’errore è:
con quello del polinomio interp di grado 2 di
. Otteniamo:
.
, dove
t.c.
. O.D.A rispetto ad
= 4. G.D.E = 3.
relativo ai
Simpcomp: function I = simpcomp(a, b, N, f)
h = (b - a) / N;
x = [a : h : b];
x_medio = [a + h/2 : h : b - h/2];
I = (h /6)*sum(f(x(1 : N)) + 4*f(x_medio) + f(x(2 : N+1)));
Numero N di sottointervalli in cui suddividere (a, b) per garantire un err < toll:
d2f_massima = max(abs(d2f(x)));
N_ptomedio = ceil(sqrt(((b-a)^3*d2f_massima)/(24*toll)));
N_trapezio = ceil(sqrt( ((b-a)^3*d2f_massima)/(12*toll)));
d4f_massima = max(abs(d4f(x)));
N_simpson = ceil((((b-a)^5*d4f_massima)/(2880*toll))^(1/4));
Fattorizzazione LU
Fattorizzazione LU:
, dove deve essere non singolare
.
Condizioni necessarie e sufficiente per
:
ammette una ed una sola fattorizzazione LU se e solo se le
sottomatrici principali di , per
, sono non singolari.
Classi di matrici che garantiscono la validità del teorema:
-
Simmetriche e definite positive:
-
A dominanza diagonale stretta per righe:
-
A dominanza diagonale stretta per colonne:
Metodo delle sostituzioni in avanti:
Fwsub: function [y] = fwsub(L, b)
n = length(b);
y = zeros(n,1);
y(1)= b(1)/L(1,1);
for i = 2 : n
y(i) = (b(i) - (L(i,1:i-1)*y(1:i-1)))/L(i,i);
end
Metodo delle sostituzioni all’indietro:
Bksub: function [x] = bksub(U, y)
n = length(y);
x = zeros(n, 1);
x(n)=y(n)/U(n,n);
for i = n-1 : -1 : 1
x(i)=(y(i)- (U(i,i+1:n)*x(i+1:n)))/U(i,i);
end
Algoritmo di Gauss:
function [L, U] = lugauss(A)
L = eye(n); % prima inserire controllo su quadraticità di A
for k = 1 : n-1
for i = k+1 : n
if (A(k,k) ~= 0)
L(i,k) = A(i,k)/A(k,k);
for j = k+1 : n
A(i,j) = A(i,j)-L(i,k)*A(k,j);
end
else
error('Elemento diagonale uguale a 0!')
end
end
end
U = triu(A);
Relazione tra errore relativo e residuo normalizzato:
dove
e
è il numero di cond
di A. Se
è “piccolo” l’errore sarà piccolo quando lo è il residuo, mentre ciò non è nec vero qndo
è “grande”.
Pivoting: Consente di portare a compimento il processo LU per qualunque A non singolare. Permutando opportunam. le
righe di A, è possibile portare a termine il processo di fatt. anche quando le ipotesi del th. di non sono soddisfatte. La
fatt. viene così modificata:
, dove
. Si dovranno risolvere i sistemi
.
Metodi iterativi
Espressione generica:
Condizione di consistenza:
. Essendo
, dovremo avere
.
Convergenza metodi iterativi: Condizione nec.&suff. affinché un metodo iterativo converga
è che
Inoltre, minore è
, minore è il numero di iterazioni nec. per ridurre l’errore iniziale di un dato fattore.
Richardson
Espressione metodo Richardson:
dove
Condizione nec.&suff. convergenza Richardson STAZ:
solo se
, dove
è l’autovalore max di
simm def pos.. Richardson staz. converge
se
dove
. Il metodo con questa scelta di
otterremo
è detto
.
.
Relazione tra errore relativo e residuo normalizzato:
con
.
simm def pos.. Richardson dinamico
metodo del gradiente precondizionato o semplicemente metodo del gradiente quando
Stima di convergenza:
se e
. La convergenza ottimale si ha per
Condizione necessaria e sufficiente per convergenza Richardson NON STAZ:
converge
.
dove, ponendo
. Il controllo del residuo è significativo solo
è ragionev. piccolo.
Richardson: function [x, k] = richardson(A, b, P, x0, tol, nmax, alpha)
r = b - A*x0;
err = norm(r)/norm(b);
k = 0;
x = x0;
while (k < nmax) && (err > tol)
z = P\r;
if nargin == 6
alpha = ((z'*r)/(z'*A*z));
end
x = x + alpha*z;
r = r - alpha*A*z;
err = norm(r)/norm(b)
k = k+1;
end
Jacobi come metodo di Rich.: Data
Otteniamo:
Metodo di Jacobi
, dove
, scegliamo
, che per componenti:
La matrice di Jacobi è allora:
Convergenza di Jacobi: Se
è a dominanza diagonale stretta per righe, allora Jacobi converge.
Metodo di Gauss-Seidel
e
.
.
Gauss-Seidel come metodo Rich.: Schema di GS:
Questo metodo corrisponde ad aver scelto
e
, dove è una matrice triangolare inferiore i cui soli
elementi non nulli sono
Otteniamo quindi che:
Convergenza GS: Se
è a dom diag stretta per righe o è una matrice reale simm e def pos, allora GS converge.
Velocità converg Jacobi-GS: Se
è tridiag, non singolare, con
, allora i metodi di Jacobi e GS convergono
o divergono entrambi. Se convergono, GS converge con velocità doppia rispetto a Jacobi:
Autovalori e Autovettori
Cerchi di Gershgorin:
Cerchi di raggio
.
e centro
Primo teorema di Gershgorin: Tutti gli autovalori di A
. Allora gli autovalori di A sono tutti contenuti
nell’intersezione tra l’unione dei cerchi riga e l’unione dei cerchi colonna.
Secondo teorema di Gerschgorin: Se m cerchi riga (o colonna) con
, sono sconnessi dall’unione dei restanti
n-m cerchi riga (o colonna), allora la loro unione contiene esattamente m autovalori.
Metodo delle potenze
Ricerca dell’autovalore di modulo massimo: Dato
. Si arresta alla prima iterazione
e posto
calcoliamo per
tale che:
:
.
function [lambda, x, it] = epower(A, x0, toll, nmax)
y = x0/norm(x0);
lambda = y'*A*y;
err = toll*abs(lambda) + 1;
it = 0;
while (it < nmax) && (err > toll*abs(lambda)) && (abs(lambda) ~= 0)
it = it + 1;
x = A*y;
y = x/norm(x);
err = abs((y'*A*y) - lambda);
lambda = y'*A*y;
end
if (it < nmax)
fprintf('\nIl metodo delle potenze converge in %d iterazioni\n', it)
else
fprintf('\nIl metodo delle potenze non converge in %d iterazioni\n', it)
end
Epower.m:
Metodo delle potenze inverse
Metodo per la ricerca dell’autovalore di modulo minimo: Dato
:
. Se
distinto dagli altri, il metodo converge:
Invpower:
e posto
calcoliamo per
sono linearmente indipendenti e se l’autovettore di modulo minimo
.
function [lambda, x, it] = invpower(A, tol, nmax, x0)
[L, U, P] = lu(A);
y = x0 /norm( x0 );
lambda = y'*A*y;
it = 0;
è
err = tol*abs(lambda ) + 1;
while(err > tol*abs(lambda)) && (it < nmax)
it = it + 1;
z = fwsub (L, P*y);
x = bksub(U, z);
y = x / norm(x);
err = abs(y'*A*y - lambda );
lambda = y'*A*y;
end
if (it < nmax)
fprintf('Il metodo converge in %d iterazioni', it)
else
fprintf('Il metodo non converge in %d iterazioni', it)
end
Metodo delle potenze inverse con shift
Shift:
viene modificato nel corso delle iterzioni comportando una diminuzione del numero di iterazioni
necessarie per soddisfare il test d’arresto, ma anche un aumento del sosto computazionale. Un’efficiente applicazione
richiede una conoscenza a priori sulla localizzazione degli autovalori della matrice nel piano complesso. Questi tipo di
informazione può essere ottenuta esaminando i cerchi di Gershgorin.
Invpowershift: function [lambda, x, it] = invpowershift(A, mu, tol, nmax, x0)
M = A - mu*eye ( n );
[L, U, P] = lu(M) ;
y = x0 /norm( x0 ) ;
lambda = y'*A*y ;
it = 0 ;
err = tol*abs(lambda ) + 1 ;
while(err > tol*abs(lambda)) && (abs(lambda)~=0 ) && (it < nmax)
it = it + 1;
z = fwsub (L, P*y) ;
x = bksub(U, z) ;
y = x / norm(x) ;
err = abs(y'*A*y - lambda ) ;
lambda = y'*A*y ;
end
if it < nmax
fprintf('Il metodo converge in %d iterazioni', it)
else
fprintf('Il metodo non converge in %d iterazioni', it)
end
Fattorizzazione QR:
Calcola tutti gli autovalori di . Se gli autovalori non sono ben separati sono necessarie più iterazioni per la convergenza,
Qrbasic: function D = qrbasic(A, tol, nmax)
[n, m] = size(A);
if n ~= m
error('La matrice deve essere quadrata')
end
T = A;
it = 0 ;
test = max(max(abs(tril(T, -1 ))));
while it <= nmax & test >= tol
[Q, R] = qr(T) ;
T = R*Q;
it = it + 1 ;
test = max(max(abs(tril(T, -1))));
end
if it > nmax
fprintf('Il metodo non converge nel massimo numero di iterazioni permesso')
else
fprintf('Il metodo converge in %d iterazioni\n', it)
end
D = diag(T);
Metodi one-step
Eu in avanti (EE):
, dove
passo di discretizzazione e, per ogni nodo
di troncamento locale:
è il numero di sottointervalli e
si cerca il valore incognito
dove
è il
che approssimi
. Errore
. Ordine di convergenza 1. Ordine di consistenza 1.
Condizionatamente assolutamente stabile.
EE:
function [t_h, u_h] = eulero_avanti(f, t_max, y_0, h)
t_0 = 0;
t_h = [t_0 : h : t_max];
N = (t_max - t_0)/h;
u_h = [];
u_h(1) = y_0;
for i = 1 : N
u_h(i+1) = u_h(i) + h*f(t_h(i), u_h(i));
end
Eu all’indietro(EI):
dove
EI:
. Errore di troncamento locale:
. Ordine di convergenza 1. Ordine di consistenza 1. Incond. assolut. stabile e A-stabile.
function [t_h, u_h, iter_pf] = eulero_indietro(f, t_max, y_0, h)
t_0 = 0;
t_h = t_0 : h : t_max;
N = length(t_h);
u_h = zeros(1, N);
u_h(1) = y_0;
% parametri per le iterazioni di punto fisso
N_max=100;
toll = 1e-5;
iter_pf = zeros(1, N);
for it = 2 : N
u_old = u_h(it-1);
t_pf = t_h(it);
phi = @(u) u_old + h*f(t_pf, u); % u è l'incognita u(n+1)
[u_pf, it_pf] = ptofis(u_old, phi, N_max, toll);
u_h(it) = u_pf(end);
iter_pf(it) = it_pf;
end
Crank-Nicolson(Impl):
. Errore di troncamento locale:
dove
CN:
. Ordine di conv. 2. Ordine di consistenza 2. Incond assolut stabile e A-stabile.
function [t_h, u_h, iter_pf] = Crank_Nicolson(f, t_max, y_0, h)
t_0 = 0;
t_h = t_0 : h : t_max;
N = length(t_h);
u_h = zeros(1, N);
u_h(1) = y_0;
% parametri per le iterazioni di punto fisso
N_max = 100;
toll = 1e-5;
iter_pf = zeros(1, N);
for it = 2 : N
phi = @(u) u_h(it-1) + 0.5*h*(f(t_h(it-1), u_h(it-1)) + f(t_h(it), u));
[u_pf, it_pf] = ptofis(u_h(it-1), phi, N_max, toll);
u_h(it) = u_pf(end);
iter_pf(it) = it_pf;
end
Convergenza: Un metodo si dice convergente se
ad per
. Se
per qualche
Errore di troncamento:
dove
è un infinitesimo rispetto
, diremo che il metodo converge con ordine .
è l’errore di troncamento locale dove
l’errore di troncamento globale è definito come
.
Consistenza: Se
, allora il metodo è consistente. Inoltre è consistente con ordine
, mentre
se
.
Zero stabilità: Un metodo per l’approssimazione del probl. di Cauchy, con
e
è detto
zero stabile se:
.
Th di Lax-Ritchmyer: Ogni metodo consistente è convergente se e solo se è zero stabile (EE, EI, CN sono zero stabili).
Assoluta stabilità: Se
il metodo è assolutamente stabile.
Regione di ass stabilità: Insieme dei valori del piano complesso in corrispondenza dei quali il metodo è assolut stabile.
Metodo di Rungkutta (ordine elevato ma one-step)
dove
stadi. Se
dove s è il n° di
allora il metodo è esplicito.
-
RK3 (ordine 3)
-
RK4 (ordine 4)
con
dove
dove
Metodi multi-step (ordine elevato)
Schema generico:
-
AB3:
-
AM4:
-
BDF2:
-
BDF3:
3 passi, 3°ordine, esplic, consistente, zero stab, condiz ass stabile
3 passi, 4°ordine, implic, consist, zero stab, condiz ass stabile
2 passi, 2° ordine, implicito, consistente, zero stabile, incond ass stabile
3 passi, 3° ordine, implicito, consistente, zero stabile
, incond ass stab sui reali
Consistenza:
, ma non sui complessi a parte reale
sono soddisfatte:
Ordine: Se inoltre
, ho consistenza di ordine q
Zero stabilità:
. Se
Reinterpr 1-step come multi-step: EE:
schema zero stabile
EI:
CN:
. Tutti zero stab
Errore di troncamento locale:
.
Teorema di Lax-Ritchmyer: uno schema multi-step consistente è convergente se e solo se è zero stabile.
Assoluta Stabilita:
per i passi
che soddisfano:
Il secondo pol caratteristico è
, dove
. Il metodo è ass stab
sono le radici di
.
Metodi numerici per problemi ai limiti
Condizioni al bordo di Dirichlet + schema centrato di ordine 2:
equisp:
con
, con passo
. Dati
, indichiamo con
nodi
la soluz num calcolata sul nodo
L’approssimaz centrata con diff finite di ordine 2 è:
. Il sistema
.
diventa:
dove:
Errore:
. Converge con ordine 2 rispetto ad .
Condizioni al bordo miste + schema decentrato di ordine 1:
decentrata all’indietro:
sistema
. Diff finita
, dividendo per
. L’ -esima riga è data da:
che è la
. Otteniamo:
Condizioni al bordo miste + schema di ordine 1 centrato nell’ultimo nodo:
Schema di ordine 2 centrato nel nodo
-esima riga del
:
.
, che fa intervenire
approssimante la soluzione
nel nodo
esterno al dominio(nodo fantasma). Abbiamo
incognite e
equazioni. Dobbiamo
quindi aggiungere un’ulteriore eq, che sarà l’appross del problema con uno schema centrato nel nodo
:
che è
la
-esima riga di
. L’ -esima riga è data da:
. Otteniamo:
Condizioni al bordo di Neumann:
. Con uno schema decentrato di ordine 1:
L’ -esima riga è data da:
. Otteniamo:
Approssimazione di un problema ai limiti non stazionario: consideriamo l’eq. del calore con termine di reazione:
La discretizzazione spaziale produce il sistema di eq diff:
matrice triadiag del problema
e
Per integrare il sistema usiamo il θ-metodo: Scelto
ponendo
e
, dove A è la stessa
.
(passo per la discretizzazione temporale), suddividiamo l’intervallo
e il generico istante temporale discreto
. Otteniamo:
La generica eq.del θ-metodo:
us = @(t) u_es(a, t);
ud = @(t) u_es(b, t);
u0 = @(x) u_es(x, 0);
theta = % =1 EI, =0 EE, =1/2 CN
[U,griglia_x,passi_t]=diff_fin(Q,f,aa,bb,us,ud,u0,T,n,deltat,theta,1)
u = U( :, end );
err = [err; max(abs(u - u_es(griglia_x,passi_t(end))))];
Appross alle diff finite del problema di Poisson in 2D:
e si consideri una griglia di
dove
nodi equisp lungo
con
. Sia
in entrambe le
direzioni. Calcolo le derivate seconde parziali con diff finite centrate 2°ordine:
. Otteniamo un sist lineare
. Il generico
Con condizioni di Dirichlet non omogenee si ha:
Dirichlet solo lungo i bordi in cui è diversa da 0 (bordo “superiore” ed “inferiore”).
.
. Si valutano le condizione di