Pseudocódigos de programación para SciLab para Métodos Computacionales en Ingeniería II

MÉTODOS DE UN PASO

EULER GENÉRICO

function [w]=euler(a, b, N, alfa) // a<x<b, N numero de subintervalos.

deff('[q]=f(t,w)','q=forma de f') //definimos la forma de f segun corresp

h=(b-a)/N

t(1)=a

w(1)=alfa

for i=1:N

w(i+1)=w(i)+h*f(t(i),w(i))

t(i+1)=t(i)+h;

end

plot (t,w)

endfunction

HEUN GENÉRICO

function [w] = heun(a,b,N,alfa)

deff('[p]=f(t,w)','p=forma de f')//defino f

h=(b-a)/N;

w(1)=alfa

t(1)=a

for i=1:N

t(i+1)=t(i)+h; //paso temporal

p(i)=f(t(i),w(i)) //defino p(i) como la pendiente en f(t(i),w(i))

w0(i+1)=w(i)+h*f(t(i),w(i));

wp(i+1)=f(t(i+1),w0(i+1)); //defino wp como "omega prima"

w(i+1)=w(i)+(h/2)*(p(i)+wp(i+1))

end

plot(t,w)

endfunction

Ernesto E. Merlo, ING-237

Pseudocódigos de programación para SciLab para Métodos Computacionales en Ingeniería II

PUNTO MEDIO GENÉRICO

function [w] = pmedio(a,b,N,alfa)

deff('[f]=f(t,w)','f=formadef')//defino la funcion f interna en el programa

h=(b-a)/N;

w(1)=alfa

t(1)=a

for i=1:N

t(i+1)=t(i)+h

w(i+1)=w(i)+h*f(t(i)+h/2,w(i)+(h/2)*f(t(i),w(i)))

end

plot(t,w)

endfunction

RUNGE-KUTTA ORDEN 4 GENÉRICO

function [w]=rk4(a,b,N,alfa)

deff('[f]=f(t,w)','f=formadef') //defino f para cada problema

w(1)=alfa

t(1)=a

h=(b-a)/N

//se debe abrir f como funcion adjunta

for i=1:N

k1=h*f(t(i),w(i))

k2=h*f(t(i)+h/2,w(i)+k1/2)

k3=h*f(t(i)+h/2,w(i)+k2/2)

k4=h*f(t(i)+h,w(i)+k3)

w(i+1)=w(i)+(1/6)*(k1+2*k2+2*k3+k4)

t(i+1)=t(i)+h

end

plot(t,w)

endfunction

Ernesto E. Merlo, ING-237

Pseudocódigos de programación para SciLab para Métodos Computacionales en Ingeniería II

EULER GENÉRICO GENERALIZADO PARA SISTEMAS (de 2 ecuaciones diferenciales lineales)

function [w1,w2] = eulersistema(a,b,N,alfa1,alfa2)

deff('[p]=f1(t,w1,w2)','p=formadef1')//definir f1 y f2 como corresponda segun el problema

deff('[q]=f2(t,w1,w2)','q=formadef2')

h=(b-a)/N

t(1)=a //t varia en j

w1(1)=alfa1 //w1 se corresponde con la aprox. a u1 variando en tiempo t(j)

w2(1)=alfa2 //w2 se corresponde con la aprox. a u2 variando en tiempo t(j)

for j=1:N

w1(j+1)=w1(j)+h*f1(t(j),w1(j),w2(j))

w2(j+1)=w2(j)+h*f2(t(j),w1(j),w2(j))

t(j+1)=t(j)+h

end

plot(t,w1)

disp("se grafica w1 vs t por defecto.")

endfunction

Ernesto E. Merlo, ING-237

Pseudocódigos de programación para SciLab para Métodos Computacionales en Ingeniería II

RUNGE-KUTTA ORDEN 4 GENÉRICO GENERALIZADO PARA SISTEMAS (lineal de 2 ED)

function [w1,w2]=rksistema(a,b,N,alfa1,alfa2)

deff('[p]=f1(t,w1,w2)','p=formadef1') //será necesario definir cada f1

deff('[q]=f2(t,w1,w2)','q=formadef2') //será necesario definir cada f2

h=(b-a)/N

t(1)=a //t varia en j

w1(1)=alfa1

w2(1)=alfa2 //cada wi varia en j

disp("se graficará w1 por defecto ya que es el resultado")

disp("mas util para ciertos problemas de orden superior")

for j=1:N

t(j+1)=t(j)+h

k11=h*f1(t(j),w1(j),w2(j))

k12=h*f2(t(j),w1(j),w2(j))// Kli, seria k sub ele corresp a Wi

k21=h*f1(t(j)+(h/2),w1(j)+k11/2,w2(j)+k12/2)

k22=h*f2(t(j)+(h/2),w1(j)+k11/2,w2(j)+k12/2)

k31=h*f1(t(j)+(h/2),w1(j)+k21/2,w2(j)+k22/2)

k32=h*f2(t(j)+(h/2),w1(j)+k21/2,w2(j)+k22/2)

k41=h*f1(t(j+1),w1(j)+k31,w2(j)+k32)

k42=h*f2(t(j+1),w1(j)+k31,w2(j)+k32)

w1(j+1)=w1(j)+(1/6)*(k11+2*k21+2*k31+k41); //calculo los sucesivos a

w2(j+1)=w2(j)+(1/6)*(k12+2*k22+2*k32+k42); //partir de los valores recien obtenidos

end

plot(t,w1)

endfunction

Ernesto E. Merlo, ING-237

Pseudocódigos de programación para SciLab para Métodos Computacionales en Ingeniería II

MÉTODOS DE DIFERENCIAS FINITAS

PARABOLICO EXPLICITO GENÉRICO

function [wt]=mpe(alfacuad, k, m, ti, tf, l, a, b)

//alfacuad es alfacuadrado,k paso en t, h paso en x

//tf tiempo final, ti tiempo inicial, l longitud del intervalo x

//a valor de frontera inicial, b valor de frontera final

deff('[f]=f(x)','f=formadef) //defino la funcion de condicion inicial

h=l/m, landa=alfacuad*k/h^2, n=round((tf-ti)/k)

if landa<=0.5 then //Si se asegura la estabilidad,

v1=(1-2*landa)*ones(m-1,1)

v2=landa*ones(m-2,1)

A=diag(v1,0)+diag(v2,1)+diag(v2,-1)

for i=1:m+1 //esta pensado así para incluir a los valores de frontera

x(i)=(i-1)*h//forma de los x incluyendo los valores de frontera

for j=1:n

t=j*k

w(i,1)=f(x(i))//asigno a cada valor lo que corresponde

w(1,j)=a

w(m+1,j)=b //con estos le digo que reemplacen las cond de front.

w(2:m,j+1)=A*w(2:m,j)//la notacion 2:m me indica "desde el elemento 2 hasta

//el elemento m" /Resuelve AWj=Wj+1

end

end

wt=w

else

disp("El método será inestable, por la elección de k (paso temporal)")

wt=["no puede hallarse wij"]

end

endfunction

Ernesto E. Merlo, ING-237

Pseudocódigos de programación para SciLab para Métodos Computacionales en Ingeniería II

PARABOLICO IMPLICITO GENÉRICO

function [wt]=mpi(alfacuad, k, m, ti, tf, l, a, b)

deff('[f]=f(x)','f=formadef') //f es condicion inicial

h=l/m, landa=alfacuad*k/h^2, n=round(tf-ti)/k //defino variables

v1=(1+2*landa)*ones(m-1,1)

v2=-landa*ones(m-2,1)

A=diag(v1,0)+diag(v2,-1)+diag(v2,1) //formo la matriz A como suma de 3 diagonales

//definimos la matriz w que tendra en sus columnas los sucesivos wj

for i=1:m+1 //esto esta pensado para incluir los valores de frontera

x(i)=(i-1)*h //valores de x

for j=1:n

w(i,j)=f(x(i))

w(1,j)=a //aplica condicion de frontera inicial (fila 1 corresponde a x1)

w(m+1,j)=b //aplica condicion de frontera final (fila 2 corresponde a xm+1)

w(2:m,j+1)=inv(A)*w(2:m,j)

//la notacion 2:m me indica "desde la componente

//2 hasta la componente m". /resuelvo el sist AWj=Wj-1

end

end

wt=w

endfunction

Ernesto E. Merlo, ING-237

Pseudocódigos de programación para SciLab para Métodos Computacionales en Ingeniería II

METODO DE CRACK-NICOLSON GENÉRICO

function [wt]=mcn(alfacuad, k, m, ti, tf, l, a, b)

deff('[f]=f(x)',['f=formadef]) //definir la forma de f cada ejercicio

h=l/m

landa=k*alfacuad/h^2

n=(tf-ti)/k

v1=(1+landa)*ones(m-1,1)

v3=(1-landa)*ones(m-1,1)

v2=(landa/2)*ones(m-2,1)

v4=(-landa/2)*ones(m-2,1)

A=diag(v4,-1)+diag(v1,0)+diag(v4,1) //formo A

B=diag(v2,-1)+diag(v3,0)+diag(v2,1) //formo B

R=inv(A)

for i=1:m+1

x(i)=(i-1)*h//esto esta pensado para definir las x incluyendo las fronteras

for j=1:n

w(i,1)=f(x(i))

w(1,j)=a

w(m+1,j)=b//defino para todos los j

w(m+1,1)=b//defino para el j=1

w(2:m,j+1)=R*B*w(2:m,j) //resuelve Wj+1=inv(A)*B*Wj

end

end

wt=w

endfunction

Ernesto E. Merlo, ING-237

Pseudocódigos de programación para SciLab para Métodos Computacionales en Ingeniería II

METODO HIPERBOLICO GENÉRICO

function [wt]=mh(alfacuad, m, k, l, ti, tf, a, b)

deff('[f]=f(x)','f=forma de f')

deff('[g]=g(x)','g=forma de g')

h=l/m, alfa=sqrt(alfacuad), landa=alfa*k/h, n=round((tf-ti)/k)

//tener cuidado con los valores para probar, n>1

//formamos la matriz A de (m-1)x(m-1) elementos

p=(1-landa^2)

q=landa^2

v1=(2*(1-landa^2))*ones(m-1,1)

v2=(landa^2)*ones(m-2,1)

A=diag(v1,0)+diag(v2,1)+diag(v2,-1)

//ahora quiero formar las primeras dos columnas de Wij

//que será una matriz de (m+1,n) donde cada columna Wi en el tiempo j

for i=2:m //este conteo define solo los internos, los de frontera se agregan despues

x(i)=(i-1)*h

w(i)=f(x(i)), w(1)=a, w(m+1)=b//con esto defino la primer columna de W (Wi1)

end //con este end me aseguro de haber formado todos los w11

//ahora defino los wi2

for i=2:m //los externos valdran cero por defecto

w(i,2)=(0.5*q*w(i-1))+(p*w(i))+(0.5*q*w(i+1))-(k*g(x(i))) //calcula wi2 ahora que tengo wi1

end

for j=1:n

w(2:m,j+2)=A*w(2:m,j+1)-w(2:m,j)//calculo los sucesivos variando j desde 1

end

wt=w

endfunction

Ernesto E. Merlo, ING-237