FUNCIONES DEL MATLAB

RESOLUCIN DE ECUACIONES DIFERENCIALES NO LINEALES

BSQUEDA DE CEROS


- BISECCIN


function sol=biseccion(H,a,b,epsi)
if ((H(a)*H(b))>0)
error('H(a) y H(b) deben tener distinto signo!!');
end
sol=(a+b)/2;
while(sqrt(H(sol)^2 + (b-a)^2)>=epsi)
if H(sol)==0
return;
elseif sign(H(sol))==sign(H(a))
a=sol;
else
b=sol;
end
sol=(a+b)/2;
end

- NEWTON-RAPHSON

function sol=NR1(H,Hp,x0,n)
sol=x0;
for k=1:n
sol=sol-H(sol)/(Hp(sol));
end


- SECANTE

function sol=secante(H,x0,x1,n)
sol=x1;
for k=1:n
sol=sol-H(sol)*(x1-x0)/(H(x1)-H(x0));
x0=x1;
x1=sol;
end

- NEWTON RAPHSON CON DERIVADA APROXIMADA

function sol=NR1AP(H,x0,n,h)
if nargin==3
h=0.001;
end
sol=x0;
for k=1:n
sol=sol-H(sol)/derivaprox(H,sol,h);
end

con: function Hpx=derivaprox(H,x,h) Hpx=(H(x+h)-H(x-h))/(2*h);


- NEWTON RAPHSON MULTIVARIADO

function sol=NR_multi(H,x0,n,h)
if nargin==3
h=0.001;
end
sol=x0;
for k=1:n
sol=sol-inv(jacobaprox(H,sol,h))*H(sol);
end

con: function J=jacobaprox(H,X,h)

I=eye(max(size(X)));
for k=1:max(size(X))
J(:,k)=(H(X+h*I(:,k))-H(X-h*I(:,k)))/(2*h);
end



RESOLUCIN DE ECUACIONES DIFERENCIALES ORDINARIAS


EULER

function [t,x]=euler(f,t0,x0,tf,h)
pasos=floor(abs(tf-t0)/h)+1;
t=linspace(t0,tf,pasos);
x(:,1)=x0;
hutil=t(2)-t(1);
for k=2:pasos
x(:,k)=x(:,k-1)+f(t(k-1),x(:,k-1))*hutil;
end
El mtodo de Euler se basa de forma general en la pendiente estimada de la
funcin para extrapolar desde un valor anterior a un nuevo valor:

Nuevo valor = Valor anterior + Pendiente x Paso (ALGORITMO)

X
i+1
= X
i
+ f(t
i
, x
i
) . h
T
i+1
= t
i
+ h

f(t
i
, x
i
) es la ecuacin diferencial evaluada en (t
i
, x
i
) y es una estimacin directa de
la pendiente en t
i
. As, Euler utiliza la pendiente al inicio del intervalo como una
aproximacin de la pendiente promedio en todo el intervalo.
Esta frmula se aplica paso a paso (h) para encontrar un valor futuro y trazar la
trayectoria de la solucin.

Ejemplo

dx/dt : -2t
3
+ 12t
2
-20t + 8,5 con t=[0;4] ; h=0,5 ; en el punto (0;1)

x
1
= 1 + f(0;1) . 0,5 = 1+ 8,5 . 0,5 = 5,25


EULER IMPLCITO

function [t,x]=eulerimp(f,t0,x0,tf,h,tol)
if nargin==5
tol=0.001;
end
pasos=floor(abs(tf-t0)/h)+1;
t=linspace(t0,tf,pasos);
x(:,1)=x0;
hutil=t(2)-t(1);
for k=2:pasos
temp1=x(:,k-1)+f(t(k-1),x(:,k-1))*hutil;
temp2=x(:,k-1)+f(t(k),temp1)*hutil;
while(abs(temp2-temp1)>=tol)
temp1=temp2;
temp2=x(:,k-1)+f(t(k),temp1)*hutil;
end
x(:,k)=temp2;
end



La idea es la misma pero el algoritmo es el siguiente:

X
i+1
= X
i
+ f(t
i+1
, x
i+1
) . h


EULER COMBINADO O MEJORADO (el ms efectivo de los 3)

function [t,x]=eulercomb(f,t0,x0,tf,h,tol)
if nargin==5
tol=0.001;
end
[te,xe]=euler(f,t0,x0,tf,h);
[ti,xi]=eulerimp(f,t0,x0,tf,h,tol);
t=(te+ti)/2;
x=(xe+xi)/2;

Para la estimacin de la pendiente emplea la determinacin de dos derivadas en
el intervalo: una en el punto inicial y otra en el punto final. Estas se promedian con
la finalidad de obtener una mejor estimacin de la pendiente en todo el intervalo.

X
i+1
= X
i
+ { [ f(t
i
, x
i
) + f(t
i+1
, x
i+1
) ] / 2 }. h ALGORITMO



RUNGE-KUTTA DE ORDEN 2


function [t,x]=RK2(f,t0,x0,tf,h)
pasos=floor(abs(tf-t0)/h)+1;
t=linspace(t0,tf,pasos);
hutil=t(2)-t(1);
x(:,1)=x0;
for k=2:pasos
m1=f(t(k-1),x(:,k-1));
m2=f(t(k),x(:,k-1)+m1*hutil);
x(:,k)=x(:,k-1)+((m1+m2)/2)*hutil;
end



Este mtodo se deriva de la serie de Taylor:


2 3 1 1
1 1
( ) ( )
( ) ( ) ( ). . . ......
2 6
i i
i i i
x t x t
x t x t x t t t t


= + A + A + A +

Como se quiere tomar orden 2, se desprecian todos los trminos de mayor orden:

2 1
1 1
( )
( ) ( ) ( ). .
2
i
i i i
x t
x t x t x t t t

= + A + A donde se puede demostrar que:

1 1
( )
i
x t m

= y
2 1
1
( )
i
m m
x t
t

=
A
.
As, reemplazando, queda que
1 2
1
( ) ( )
2
i i
m m
x t x t t

+ | |
= + A
|
\ .
siendo este el
ALGORITMO principal del mtodo.

El mtodo de Runge-Kutta estima derivadas por pendientes usando un promedio
ponderado de pendientes para resolver los sistemas de ecuaciones.


RUNGE-KUTTA DE ORDEN 4

function [t,x]=RK4(f,t0,x0,tf,h)
pasos=floor(abs(tf-t0)/h)+1;
t=linspace(t0,tf,pasos);
hutil=t(2)-t(1);
x(:,1)=x0;
for k=2:pasos
m1=f(t(k-1),x(:,k-1));
m2=f(t(k-1)+hutil/2,x(:,k-1)+m1*hutil/2);
m3=f(t(k-1)+hutil/2,x(:,k-1)+m2*hutil/2);
m4=f(t(k-1)+hutil,x(:,k-1)+m3*hutil);
x(:,k)=x(:,k-1)+((m1+2*m2+2*m3+m4)/6)*hutil;
end

Runge-Kutta de orden 4 se deriva de la serie de Taylor pero su demostracin y
algoritmo son muy complicados. Utiliza un promedio de 4 pendientes: una del
principio, dos del medio, y una del final del intervalo.


RUNGE-KUTTA DE RDENES 2-4

function [t,x]=RK24(f,t0,x0,tf,h,tol)
if nargin==4
h=abs(tf-t0)/100;
tol=0.001;
end
if nargin==5
tol=0.001;
end
[tr2,xr2]=RK2(f,t0,x0,tf,h);
[tr4,xr4]=RK4(f,t0,x0,tf,h);
err=norm(xr2-xr4)/norm(xr4);
while(err>=tol)
h=h/2;
[tr2,xr2]=RK2(f,t0,x0,tf,h);
[tr4,xr4]=RK4(f,t0,x0,tf,h);
err=norm(xr2-xr4)/norm(xr4);
end
t=tr4;
x=xr4; Es una combinacin efectiva de ambos mtodos.