Sei sulla pagina 1di 19

1 function x=bksub(A,b)

2 %
3 % x=bksub(A,b)
4 %
5 % Algoritmo di sostituzione all'indietro
6 %
7 % INPUT:
8 % A: matrice quadrata triangolare superiore
9 % b: termine noto
10 %
11 % OUTPUT:
12 % x: soluzione del sistema Ax=b
13
14 n=length(b);
15
16 if((size(A,1)~=n)||(size(A,2)~=n))
17 error('ERRORE: dimensioni incompatibili')
18 end
19
20 if(~isequal(A,triu(A)))
21 error('ERRORE: matrice non triangolare superiore')
22 end
23
24 if(prod(diag(A))==0)
25 % almeno un elemento diagonale nullo
26 error('ERRORE: matrice singolare')
27 end
28
29 x = zeros(n,1);
30
31 x(n) = b(n)/A(n,n);
32
33 for i=n−1:−1:1
34 x(i) = (b(i)−A(i,i+1:n)*x(i+1:n))/A(i,i);
35 end
36
37 end
1 function x=fwsub(A,b)
2 %
3 % x=fwsub(A,b)
4 %
5 % Algoritmo di sostituzione in avanti
6 %
7 % INPUT:
8 % A: matrice quadrata triangolare inferiore
9 % b: termine noto
10 %
11 % OUTPUT:
12 % x: soluzione del sistema Ax=b
13
14 n=length(b);
15
16 if ((size(A,1)~=n)||(size(A,2)~=n))
17 error('ERRORE: dimensioni incompatibili')
18 end
19
20 if ~isequal(A,tril(A))
21 error('ERRORE: matrice non triangolare inferiore')
22 end
23
24 if (prod(diag(A))==0)
25 % almeno un elemento diagonale nullo
26 error('ERRORE: matrice singolare')
27 end
28
29 x = zeros(n,1);
30
31 x(1) = b(1)/A(1,1);
32
33 for i=2:n
34 x(i) = (b(i)−A(i,1:i−1)*x(1:i−1))/A(i,i);
35 end
36
37 end
1 function [xk, k] = gradiente(A, b, P, x0, tol, nmax)
2 %
3 % [xk, k] = gradiente(A, b, P, x0, tol, nmax)
4 %
5 % Metodo di Richardson dinamico precondizionato
6 % con parametro ottimale (metodo del gradiente).
7 %
8 % INPUT:
9 % A: matrice di sistema
10 % b: vettore termine noto
11 % P: precondizionatore
12 % x0: guess iniziale
13 % tol: tolleranza criterio d'arresto
14 % nmax: numero massimo di iterazioni ammesse
15 % alpha: parametro di accelerazione
16 %
17 % OUTPUT
18 % x: soluzione
19 % k: numero di iterazioni
20
21 n = length(b);
22 if ((size(A,1) ~= n) || (size(A,2) ~= n) || (length(x0) ~= n))
23 error('Dimensioni incompatibili')
24 end
25
26 % E' possibile utilizzare una sola variabile x al
27 % posto di xn e xv viste nel laboratorio precedente.
28
29 x = x0;
30 k = 0;
31 r = b − A * x;
32 res_normalizzato = norm(r) / norm(b);
33 while ((res_normalizzato > tol) && (k < nmax))
34 z = P \ r;
35 alpha = (z' * r) / (z' * A * z); % alpha dinamico
36 x = x + alpha * z;
37 r = b − A * x; % equivalente a: r = r − alpha * A * z;
38 res_normalizzato = norm(r) / norm(b);
39 k = k + 1;
40 end
41
42 if (res_normalizzato < tol)
43 fprintf('Richardson converge in %d iterazioni \n', k);
44 else
45 fprintf('Richardson non converge in %d iterazioni. \n', k)
46 end
47
48 end
1 function [xn,iter]=myjacobi(A,b,x0,nmax,toll)
2 %
3 % [xn,iter]=myjacobi(A,b,x0,nmax,toll)
4 %
5 % Metodo di Jacobi per sistemi lineari.
6 %
7 % INPUT:
8 % A: Matrice del sistema
9 % b: Termine noto (vettore colonna)
10 % x0: Vettore iniziale (vettore colonna)
11 % nmax: Numero massimo di iterazioni
12 % toll: Tolleranza sul test d'arresto (residuo normalizzato)
13 %
14 % OUTPUT:
15 % xn: Vettore soluzione
16 % iter: Iterazioni effettuate
17 %
18 % Viene usata la norma 2
19
20 [n,m] = size(A);
21 if n ~= m
22 error (' >> La matrice non e'' quadrata !!! ')
23 end
24
25 xv = x0;
26 xn = x0;
27 iter = 0;
28 err = toll + 1;
29 normb = norm(b);
30
31 while iter < nmax && err > toll
32 for i=1:n
33 xn(i) = ( b(i) − A(i,[1:i−1,i+1:n])*xv([1:i−1,i+1:n]) )/A(i,i);
34 end
35 iter = iter + 1;
36 err = norm(b − A*xn)/normb;
37 xv = xn;
38 end
39
40 end
1 function [xn,iter]=mysor(A,b,x0,nmax,toll,omega)
2 %
3 % [xn,iter]=mysor(A,b,xin,nmax,toll,omega)
4 %
5 % Metodo SOR per sistemi lineari.
6 % Per omega uguale a 1 si ottiene il metodo di Gauss Seidel
7 %
8 % INPUT:
9 % A: Matrice del sistema
10 % b: Termine noto (vettore colonna)
11 % x0: Vettore iniziale (vettore colonna)
12 % nmax: Numero massimo di iterazioni
13 % toll: Tolleranza sul test d'arresto (fra iterate)
14 % omega: Parametro di rilassamento
15 %
16 % OUTPUT:
17 % xn: Vettore soluzione
18 % iter: Iterazioni effettuate
19
20 [n,m] = size(A);
21 if n ~= m
22 error (' >> La matrice non e'' quadrata !!! ')
23 end
24
25 xv = x0;
26 xn = x0;
27 iter = 0;
28 err = toll +1;
29 normb = norm(b);
30
31 while iter < nmax && err > toll
32 for i=1:n
33 xn(i) = (1−omega)*xv(i) + (omega/A(i,i))*(b(i) − A(i,1:i−1)*xn(1:i−1) − A(i,i+1:n) *
34 end
35 iter = iter + 1;
36 err = norm(b − A*xn)/normb;
37 xv = xn;
38 end
39
40 if iter==nmax
41 disp('**SOR non converge nel numero di iterazioni fissato**')
42 end
43
44 end
1 function [x, k] = richardson(A, b, P, x0, tol, nmax, alpha)
2 %
3 % [x, k] = richardson(A, b, P, x0, tol, nmax, alpha)
4 %
5 % Metodo di Richardson stazionario precondizionato
6 %
7 % INPUT:
8 % A: matrice di sistema
9 % b: vettore termine noto
10 % P: precondizionatore
11 % x0: guess iniziale
12 % tol: tolleranza criterio d'arresto
13 % nmax: numero massimo di iterazioni ammesse
14 % alpha: parametro di accelerazione
15 %
16 % OUTPUT
17 % x: soluzione
18 % k: numero di iterazioni
19
20 n = length(b);
21 if ((size(A,1) ~= n) || (size(A,2) ~= n) || (length(x0) ~= n))
22 error('Dimensioni incompatibili')
23 end
24
25 % E' possibile utilizzare una sola variabile x al posto
26 % di xn e xv viste nel laboratorio precedente.
27
28 x = x0;
29 k = 0;
30 r = b − A*x;
31 res_normalizzato = norm(r) / norm(b);
32
33 while ((res_normalizzato > tol) && (k < nmax))
34 z = P \ r;
35 x = x + alpha * z;
36 r = b − A * x; % equivalente a: r = r − alpha * A * z;
37 res_normalizzato = norm(r) / norm(b);
38 k = k + 1;
39 end
40
41 if (res_normalizzato < tol)
42 fprintf('Richardson converge in %d iterazioni \n', k);
43 else
44 fprintf('Richardson non converge in %d iterazioni. \n', k)
45 end
46
47 end
1 function I = pmedcomp(a,b,N,f)
2 %
3 % I = pmedcomp(a,b,N,f)
4 %
5 % Formula del punto medio composita:
6 %
7 % INPUT:
8 % a,b: estremi di integrazione
9 % N: numero di sottointervalli
10 % (N=1 formula di integrazione semplice)
11 % f: funzione da integrare definita come inline o anonimous
12 %
13 % OUTPUT:
14 % I: integrale calcolato
15
16 h = (b−a)/N;
17
18 % costruzione dei punti medi
19 xM = [a+h/2:h:b−h/2];
20
21 % valuto funzione nei punti medi
22 fxM = f(xM);
23
24 I = h*sum(fxM);
25
26 end
1 function I = simpcomp(a,b,N,f)
2 %
3 % I = simpcomp(a,b,N,f)
4 %
5 % Formula di Simpson composita:
6 %
7 % INPUT:
8 % a,b: estremi di integrazione
9 % N: numero di sottointervalli
10 % (N=1 formula di integrazione semplice)
11 % f: funzione da integrare definita come inline o anonimous
12 %
13 % OUTPUT:
14 % I: integrale calcolato
15
16 h = (b−a)/N;
17
18 xL = [a:h:b−h];
19 xM = [a+h/2:h:b−h/2]; % costruzione dei punti medi
20 xR = [a+h:h:b];
21
22 I = h/6 * sum( f(xL) + 4*f(xM) + f(xR) );
23
24 end
1 function I = trapcomp(a,b,N,f)
2 %
3 % I = trapcomp(a,b,N,f)
4 %
5 % Formula del trapezio composita:
6 %
7 % INPUT:
8 % a,b: estremi di integrazione
9 % N: numero di sottointervalli
10 % (N=1 formula di integrazione semplice)
11 % f: funzione da integrare definita come inline o anonimous
12 %
13 % OUTPUT:
14 % I: integrale calcolato
15
16 h = (b−a)/N;
17
18 % vettore dei nodi di integrazione
19 x = linspace(a, b, N+1);
20
21 y = f(x);
22 I = h * ( 0.5 * y(1) + sum( y(2:N ) ) + 0.5 * y(N+1) );
23
24 end
1 function [th,uh,iter_pf] = CN(f,t_0,t_max,y0,h)
2 %
3 % [th,uh,iter_pf] = CN(f,t_0,t_max,y0,h)
4 %
5 % Risolve il problema di Cauchy
6 %
7 % y'=f(y,t)
8 % y(0)=y_0
9 %
10 % utilizzando il metodo di Crank−Nicolson
11 % (CN) : u^(n+1) = u^n + h/2*( f^{n} + f^{n+1} )
12 %
13 % INPUT:
14 % f: function che descrive il problema di Cauchy
15 % (dichiarata ad esempio tramite inline o @).
16 % Deve ricevere in ingresso due argomenti: f=f(t,y)
17 % t_max: istante finale dell'intervallo temporale di soluzione
18 % (l'istante iniziale e' t_0=0)
19 % y0: dato iniziale del problema di Cauchy
20 % h: ampiezza del passo di discretizzazione temporale.
21 %
22 % OUTPUT:
23 % th: vettore degli istanti in cui si
24 % calcola la soluzione discreta
25 % uh: soluzione discreta calcolata nei nodi temporali t_h
26
27 th = t_0:h:t_max;
28 N = length(th);
29 uh = zeros(1,N);
30 uh(1) = y0;
31
32 % parametri per le iterazioni di punto fisso
33 Nmax = 1000;
34 toll = 1e−9;
35 iter_pf = zeros(1,N);
36
37 for it = 2:N
38 phi = @(u) uh(it−1) + h/2 * ( f( th(it−1), uh(it−1) ) + f( th(it), u ) );
39 j = 0; err = toll+1;
40 w0 = uh(it−1);
41 while err > toll && j < Nmax
42 w1 = phi(w0);
43 err = abs(w1−w0);
44 j = j+1;
45 w0 = w1;
46 end
47 iter_pf(it) = j;
48 uh(it) = w1;
49 end
50
51 end
1 function [th,uh]=eulero_avanti(f,t_0,t_max,y0,h)
2 %
3 % [th,uh]=eulero_avanti(f,t_max,y0,h)
4 %
5 % Risolve il problema di Cauchy
6 %
7 % y'=f(t,y)
8 % y(t_0)=y_0
9 %
10 % utilizzando il metodo di Eulero in Avanti
11 % (Eulero Esplicito) : u^(n+1) = u^n + h*f^n
12 %
13 % INPUT:
14 % f: function che descrive il problema di Cauchy
15 % (dichiarata ad esempio tramite inline o @).
16 % Deve ricevere in ingresso due argomenti: f=f(t,y)
17 % t_0: l'istante iniziale dell' intervallo temporale di soluzione
18 % t_max: l'istante finale dell' intervallo temporale di soluzione
19 % y0: il dato iniziale del problema di Cauchy
20 % h: l'ampiezza del passo di discretizzazione temporale.
21 %
22 % OUTPUT:
23 % th: vettore degli istanti in cui si calcola la soluzione discreta
24 % uh: la soluzione discreta calcolata nei nodi temporali t_h
25
26
27 % allocazione del tempo discreto
28 th = t_0:h:t_max;
29 N = length(th);
30
31 % vettore riga con spazio vuoto pronti per partire
32 uh = zeros(1,N);
33
34 % uso la notazione con i : in caso uh fosse un vettore, ma qui
35 % bastava scrivere u(1,1) o addirittura u(1)
36 uh(:,1) = y0;
37
38 for i=2:N % parto da 2 cosi' posso considerare il passo precedente
39 uh(:,i) = uh(:,i−1) + h * f( th(i−1) , uh(:,i−1) );
40 end
41
42 end
43
44 % Note
45 % E' un metodo ESPLICITO a UN PASSO
46 % NON era possibile farlo SENZA un ciclo for
1 function [th,uh]=eulero_indietro(a,b,t_0,t_max,y0,h)
2 %
3 % [th,uh]=eulero_indietro(a,b,t_0,t_max,y0,h)
4 %
5 % Risolve il problema di Cauchy
6 %
7 % y'=f(y,t)=a(t)y+b(t)
8 % y(t_0)=y_0
9 %
10 % utilizzando il metodo di Eulero Indietro
11 % (Eulero Implicito) : u^{n+1} = u^n + h*f^{n+1}.
12 %
13 % INPUT:
14 % a,b: function che descrivono il problema di Cauchy
15 % (dichiarata ad esempio tramite inline o @)
16 % devono ricevere in ingresso un argomento: a=a(t), b=b(t)
17 % t_max: l'istante finale dell' intervallo temporale di soluzione
18 % (l'istante iniziale e' t_0=0)
19 % y0: il dato iniziale del problema di Cauchy
20 % h: l'ampiezza del passo di discretizzazione temporale.
21 %
22 % OUTPUT:
23 % th: vettore degli istanti in cui si calcola la soluzione discreta
24 % uh: la soluzione discreta calcolata nei nodi temporali t_h
25 %
26 % NB: funzione solo per equazioni lineari
27
28 % allocazione del tempo discreto
29 th = t_0:h:t_max;
30 N = length(th);
31
32 % vettore riga con spazio vuoto pronti per partire
33 uh = zeros(1,N);
34
35 % uso la notazione con i : in caso uh fosse un vettore, ma qui
36 % bastava scrivere u(1,1) o addirittura u(1)
37 uh(:,1) = y0;
38
39 % u_n+1 = u_n + hf(t_n+1,u_n+1)
40 % u_n+1 = u_n + h[a(t_n+1)u_n+1 + b(t_n+1)]
41 % u_n+1 = u_n + h*a(t_n+1)u_n+1 + h*b(t_n+1)
42 % u_n+1 − h*a(t_n+1)u_n+1 = u_n + h*b(t_n+1)
43 % u_n+1*[1 − h*a(t_n+1)] = u_n + h*b(t_n+1)
44 % u_n+1 = [u_n + h*b(t_n+1)]/[1 − h*a(t_n+1)]
45
46 for i=2:N
47 uh(:,i) = ( uh(:,i−1) + h * b(th(i)) ) ./ (1 − h*a(th(i)) );
48 end
49
50 end
1 function [th, uh] = heun(f, t_0, t_max, y0, h)
2 %
3 % [th, uh] = heun(f, t_0, t_max, y0, h)
4 %
5 % Risolve il problema di Cauchy
6 %
7 % y'=f(t,y)
8 % y(0)=y_0
9 %
10 % utilizzando il metodo di Heun
11 % (Heun) : u^(n+1) = u^n + h/2 *( f^{n+1} + f(t,u^n+hf^n) )
12 %
13 % INPUT:
14 % f: function che descrive il problema di Cauchy
15 % (dichiarata ad esempio tramite inline o @).
16 % Deve ricevere in ingresso due argomenti: f=f(t,y)
17 % t_0: l'istante iniziale dell' intervallo temporale di soluzione
18 % t_max: l'istante finale dell' intervallo temporale di soluzione
19 % y0: il dato iniziale del problema di Cauchy
20 % h: l'ampiezza del passo di discretizzazione temporale.
21 %
22 % OUTPUT:
23 % th: vettore degli istanti in cui si calcola la soluzione discreta
24 % uh: la soluzione discreta calcolata nei nodi temporali t_h
25
26 it=1;
27 th(it) = t_0;
28 uh(it) = y0;
29 for it = 2:(t_max−t_0)/h+1
30 th(it) = th(it−1) + h;
31 uh(it) = uh(it−1) + h/2 * ( f( th(it−1), uh(it−1) ) +
32 + f( th(it), uh(it−1 ) + h * f( th(it−1), uh(it−1) ) ) );
33 end
34
35 end
1 function [t_h,u_h]=RK2(f,t0,t_max,y_0,h)
2 %
3 % [t_h,u_h]=RK2(f,t_max,y_0,h)
4 %
5 % Risolve il problema di Cauchy
6 %
7 % y'=f(y,t)
8 % y(0)=y_0
9 %
10 % utilizzando il metodo Runge−Kutta 2
11 % u^*_(n+1) = u_n + h * f_n
12 % u_(n+1) = u_n + h/2 * (f_n + f(t_(n+1), u^*_(n+1)))
13 %
14 % INPUT:
15 % f: function che descrive il problema di Cauchy
16 % Deve ricevere in ingresso due argomenti: f=f(t,y)
17 % t0: l'istante iniziale dell' intervallo temporale di soluzione
18 % t_max: l'istante finale dell' intervallo temporale di soluzione
19 % y_0: il dato iniziale del problema di Cauchy
20 % h: l'ampiezza del passo di discretizzazione temporale.
21 %
22 % OUTPUT:
23 % t_h: vettore degli istanti in cui si calcola la soluzione discreta
24 % u_h: la soluzione discreta calcolata nei nodi temporali t_h
25
26 % [OUT] vettore degli istanti in cui risolvo la edo
27 t_h = t0:h:t_max;
28
29 % inizializzo il vettore che conterra' la soluzione discreta
30 N_istanti = length(t_h);
31 u_h = zeros(1,N_istanti);
32
33 % ciclo iterativo
34 u_h(1)=y_0;
35
36 % it = istante temporale che stiamo considerando
37 for it = 2:N_istanti
38
39 u_old = u_h(it−1);
40
41 % step intermedio
42 u_s = u_old + h * f(t_h(it−1), u_old);
43
44 % [OUT] step finale
45 u_h(it) = u_old + 0.5 * h * ( f(t_h(it−1),u_old) + f(t_h(it), u_s) );
46 end
47
48 end
1 function [xvect, niter] = corde(a, b, x0, kmax, tol, fun)
2 %
3 % [xvect, it] = corde(a, b, x0, kmax, tol, fun)
4 %
5 % Metodo delle corde per la risoluzione
6 % dell'equazione non lineare f(x)=0
7 %
8 % INPUT:
9 % a,b: estremi dell'intervallo
10 % x0: punto iniziale
11 % kmax: numero massimo di iterazioni
12 % tol: tolleranza sull'errore
13 % fun: function da analizzare
14 %
15 % OUTPUT:
16 % xvect: vettore delle iterazioni della soluzione
17 % niter: numero di iterazioni fatte
18
19 fa = fun(a);
20 fb = fun(b);
21 rappinc = (fb−fa)/(b−a);
22 err = tol +1;
23 niter = 0;
24 xvect = x0;
25 xold = x0;
26 while (err > tol && niter < kmax)
27 niter = niter + 1;
28 xnew = xold − fun(xold)/rappinc;
29 %err = abs(xnew−xold);
30 err = abs(fun(xnew));
31 xvect = [xvect; xnew];
32 xold = xnew;
33 end
34
35 end
1 function [xvect, niter] = punto_fisso( phi, x0, tol, kmax )
2 %
3 % [xvect, niter] = punto_fisso( phi, x0, tol, kmax )
4 %
5 % Trova un punto fisso della funzione PHI
6 % usando il metodo delle iterazioni di punto fisso
7 % e restituisce un vettore xvect contenente le iterate del metodo.
8 %
9 % INPUT:
10 % phi: funzione scalare che accetta una variabile scalare in input
11 % x0: approssimazione iniziale
12 % tol: tolleranza per il criterio d'arresto (basato sull'incremento)
13 % conviene questo criterio perche' in input c'e' phi
14 % kmax: numero massimo di iterazioni concesso
15 %
16 % OUTPUT:
17 % xvect: vettore delle iterazioni della soluzione
18 % niter: numero di iterazioni fatte
19
20
21 err = tol + 1;
22 niter = 0;
23 xvect = x0;
24 xold = x0;
25 while(err > tol && niter<kmax)
26 niter = niter +1;
27 xnew = phi(xold);
28 err = norm(xnew−xold);
29 xvect = [xvect, xnew];
30 xold = xnew;
31 end
1 function [xvect, niter] = newton(x0, kmax, tol, fun, dfun, mol)
2 %
3 % [xvect, niter] = newton(x0, kmax, tol, fun, dfun, mol)
4 %
5 % Metodo di Newton per la ricerca degli zeri della funzione
6 % fun. Test d'arresto basato sull'incremento tra due
7 % iterazioni successive.
8 %
9 % INPUT:
10 % x0: punto iniziale
11 % kmax: numero massimo di iterazioni
12 % tol: tolleranza sull'errore
13 % fun: anonymous function con la funzione
14 % dfun: anonymous function con la derivata
15 % mol: molteplicita' dello zero che si vuole trovare
16 %
17 % OUTPUT:
18 % xvect: vettore delle iterazioni della soluzione
19 % niter: numero di iterazioni fatte
20
21 err = tol + 1;
22 niter = 0;
23 xvect = x0;
24 xold = x0;
25
26 while (err > tol && niter < kmax)
27 niter = niter + 1;
28
29 dfx = dfun(xold);
30 if dfx == 0
31 disp('derivata nulla!');
32 return
33 end
34
35 xnew = xold − mol*fun(xold)/dfx;
36 %err = abs(xnew−xold);
37 err = abs(fun(xnew));
38 xvect = [xvect; xnew];
39 xold = xnew;
40 end
41
42 end
1 function [xvect, niter] = newtonsys(x0, kmax, tol, fun, J)
2 %
3 % [xvect, niter] = newtonsys(x0, kmax, tol, fun, J)
4 %
5 % Metodo di Newton per la ricerca degli zeri del sistema
6 % descritto dalla funzione fun.
7 % Test d'arresto basato sulla norma infinito dell'incremento
8 % tra due iterate successive.
9 %
10 % INPUT:
11 % x0: punto iniziale
12 % kmax: numero massimo di iterazioni
13 % tol: tolleranza sull'errore
14 % fun: anonymous function con la funzione (vettore colonna)
15 % J: anonymous function con la jacobiana (vettore colonna)
16 %
17 % OUTPUT:
18 % xvect: vettore delle iterazioni della soluzione
19 % niter: numero di iterazioni fatte
20
21 err = tol + 1;
22 niter = 0;
23 xvect = x0;
24 xold = x0;
25
26 while (err > tol && niter < kmax)
27 niter = niter + 1;
28 xnew = xold − J(xold)\fun(xold);
29 %err = abs(xnew−xold);
30 err = abs(max(fun(xnew)));
31 xvect = [xvect, xnew];
32 xold = xnew;
33 end
34
35 end

Potrebbero piacerti anche