METODI ITERATIVI  P*x(k+1)=N*x(k)+b
----------------
A=P-N, P non singolare.  matr di iterazione:B=inv(P)*N, il metodo converge se rho(B)<1
la velocità di asintotica convergenza di un metodo è definita R(B)=-log(rhoB)
-stima del numero minimo di iterazioni in norma 2: 
 k(min)=-log(1e-6)/R , R=-log(rhoB)
-stima del num di iter su err assoluto:
 k(min)=log((1-norm(B))*1e-6/norm(err))log(norm(B))-1

JACOBI
P=D=diag(diag(A); N=-(E+F) con E=-tril(A,-1),F=-triu(A,1)
Bj=I-inv(D)*A    rhoJ=max(abs(eig(Bj)))
-converge sicuramente se la matr è a dominanza diagonale

GAUSS-SEIDEL
P=D-E  N=F; Bgs=inv(P)*N
-converge sicuramente se la matr è simm e definita positiva
-se A è tridiagonale, rhoGS=rhoJ^2 : converge più velocemente

SOR
è una ottimizzazione di GS (con w=1 si ottiene GS)
B(w)=inv(d-w*e)*((1-w)*d+w*f)
-c.n. per la convergenza:  0=<w=<2
-se A simm, definita positiva, tridiag, allora w ottimo=2/(1+sqrt(1-rho(Bgs)))
-modo per trovare sperimentalmente w ottimo:
 w=0; i=1;
 for w=.001:.01:1.99 
     wvet(i)=w; bsor=B(w)
     rhosor(i)=max(abs(eig(bsor))); i=i+1;
 end
 plot(wvet,rhosor)
 [y,j]=min(rhosor); wopt=wvet(j);

GRADIENTE
converge se la matr è simm e definita positiva
-verifica del test d'arresto del comando graddyn basato sul controllo incremento:
 la matrice deve essere ben condizionata

RICHARDSON
la matr di iteraz è br=I-alp*inv(P)*A
-se la matr è simm e definita positiva il metodo converge se alp<2/(max(eig(inv(p)*a)))
 inoltre alp ott=2/(eig min +eig max)

ZERI DI UNA FUNZIONE
--------------------
BISEZIONE
-per trovare il minimo num di iterazioni : k min=(log((b-a)/toll))/log(2)

PTO FISSO  x(k+1)=F(x(k))
Newton e Corde possono essere considerati metodi a punto fisso, infatti
Corde: F(x)=x-(b-a)/(f(b)-f(a))*f(x)   converg se:abs (1-(b-a)/(f(b)-f(a))*f'(x))<1
Newton:F(x)=x-f(x)/f'(x)
-consistenza: trovata sperimentalmente una sol. si controlla che sol=F(sol)
-ordine di convergenza: è pari al grado p+1 della prima derivata non nulla di F(sol)
 cioè se la dF/dx=0 ma d^2F/dx^2 ~= 0 allora l'ordine è 2  (usa stimap)
-convergenza: abs(F'(sol))<1
-vel di convergenza: R=log(1/F'(sol))

INTERPOLAZIONE
--------------
f(x)=Pn(x(i)) per 0=<i=<n  Pn(x)=somma per i=0->n di f(x(i))*Li(x)
con Li(x)=prod (x-x(k))/(x(i)-x(k)) per k=0,...,n ma k~=i
altro modo di scrivere Li(x)=w/((x-x(i))w')  con w=(x-x0)(x-x1)...(x-xn)
-err(x)=f(x)-Pn(x)=d/dx^(n+1) f(x) * w/(n+1)!
-nodi Gauss-Chebyshev: xj=-cos(pi/2*(2j+1)/(n+1) per j=0,...,n

INTEGRAZIONE
------------
-per calcolo il numero "m" di intervalli necessari per un err max di 1e-4:
pto med  E0,m(f)=-(b-a)/24 *H^2 * max(abs(d^2/dx^2 f(x)))
trap     E1,m(f)=-(b-a)/12 *H^2 * max(abs(d^2/dx^2 f(x)))
simps    E2,m(f)=-(b-a)/180*(H/2)^2 * max(abs(d^4/dx^4 f(x)))
con H=(b-a)/m, poi si pone E=toll e si ricava m

EDO
---
eulero avanti  : u(j+1)-u(j)=h*f(x(j),u(j)) ass stab se 0<h<2/abs(lambda)  ord1
eulero indietro: u(j+1)-u(j)=h*f(x(j+1),u(j+1))
punto medio    : u(j+1)-u(j-1)=2h*f(x(j),u(j))  ass inst... guarda 0-stab  ord2 
trapezi(Cr-Nic): u(j+1)-u(j)=h/2*[f(x(j),u(j))+f(x(j+1),u(j+1))]           ord2
heun           : u(j+1)-u(j)=h/2*[f(x(j),u(j))+f(x(j+1),u(j)+h*f(x(j),u(j)))]
eulero modifica: u(j+1)-u(j)=h*f(x(j+1/2),u(j)+h/2*f(x(j),u(j))) ord2

-un metodo si dice a un passo se u(j+1) dipende solo da u(j)
-un met è esplicito se u(j+1) si ricava direttamente da u(j),(eul av,pto med)
-un met è implicito se compare f(...,u(j+1),...)    sono incondizionatamente stabili
-un met è 0-stab se esiste H>0, esiste C>0 tali che per ogni h<H sia abs(z-u)<C*err
 con u sol di u(j+1)=u(j)+h*F(t,u,f(t,u)), z sol di z(j+1)=z(j)+h*F(t,z,f(t,z)+err)
 C è preso a cazzo(dipende dall'intervallo di integrazione temporale)
-err troncamento locale: T(x,y(x);h)=(y(x+h)-y(x))/h-F(del metodo)
 lim (h->0) T= O(h^p)  p=ordine del metodo
-err glob per eulero avanti: err=<h*max(abs(y"(x))*(exp(L(x-x0)-1)/(2L) L lipschitz
 metodi di ord maggiore saranno più accurati
-verifica consistenza: lim(h->0) di (y(x+h)-y(x))/h=F(x,y;h) e si confronta
-verifica ass stab (esempio del metodo di heun):considera il prob modello y'=lam*y
 y(0)=1  -> u(n+1)-u(n)=h/2*[lam*u(n)+lam(u(n)+h*lam*u(n)] poichè y(0)=1,
 u(n)=u(0)*[1+H*lam+((h*lam)^2)/2]^n; ass stab=>lim abs(u(n))=0 -> 
 abs[1+H*lam+((h*lam)^2)/2]<1

MULTISTEP a p+1 passi:  
u(n+1)=for j=0:p(sum(a(j)*u(n-j))+ for j=-1:p(sum(b(j)*f(x(n-j),u(n-j)) con x(n)=x0+nh
-eul esp: a(0)=1 b(0)=1 b(-1)=0  (p=0)
-eul imp: a(0)=1 b(0)=0 b(-1)=1  (p=0)
-pto med: a(0)=0 a(1)=1 b(-1)=0 b(0)=2 b(1)=0  (p=1)

-consistenza: 1) for j=0:p(sum(a(j)))=1   
              2) for j=0:p(-sum(j*a(j))) + for j=-1:p(sum(b(j))=1
-ordine q: for j=0:p(sum((-j)^i*a(j))) + for j=-1:p(i*sum((-j)^(i-1)*b(j)=1
           con i=2,3,...,q
-stabilità: pol car P(r)=r^(p+1) - for j=0:p(sum(a(j)*r^(p-j)))
            stabile se le radici r(j) soddisfano abs(r(j))=<1
            se abs(r(j))=1 allora P'(r(j))~=0
            NB il comando stabreg dà un'indicazione sul abs(h*lam)