Movimiento cohetes

Movimiento de cohetes
Por Vicente Herrera García
Un breve estudio del movimiento de sistemas de masa variable frente a la ley de la
gravedad, expresada en forma genérica en función de la distancia; y la resolución del
problema empleando algoritmos numéricos codificados en Matlab.
Realizado para la asignatura de Análisis Numérico, curso 2001/2002, de la Ingeniería
Técnica de Informática de Sistemas en la universidad de Huelva.

Movimiento de cohetes
Ley de Newton para el movimiento, en su expresión más general ,es:
vmp
dt
pd
Fi
rr
rr
=
=∑
Para el caso de movimiento lineal de un cuerpo de masa variable, esta ecuación queda
como:
)()()()( tvtmtvtmF
vmp
dt
dp
F
⋅+⋅=⇒




⋅=
=
&&
Si consideramos que el cuerpo es un cohete que “expulsa” combustible a una velocidad
constante, podemos expresar su masa como:
tmMtm
mtm
e
e
⋅−=
−=
0)(
)(constante)(&
Tenemos además que considerar la ley de acción y reacción, según la cual podemos
averiguar la fuerza que la masa expulsada ejerce sobre el cohete, propulsándolo, a partir
de la que el cohete ejerce sobre esta.
En todo momento, el cohete expulsará el propelente con una velocidad ve constante,
relativa a la propia velocidad del cohete. Luego el propelente ha ganado una cantidad de
movimiento
∆pe = me ve
Es decir, se ha aplicado sobre el una fuerza
|Fe | = ∆pe = me ve
Luego este ejerce la misma fuerza sobre el cohete, en sentido contrario.
Representamos el sistema de 2 ecuaciones diferenciales:
vx
vmvtmMFF eee
=
⋅−⋅−=+
&
&)( 0
Siendo F el resto de fuerzas aplicables en el problema

Utilizando la ley de la gravitación universal:
2
)(
r
Mtm
GF t
g
⋅
=
El caso más general, el cohete se encuentra a una distancia arbitraria r medida
desde el centro de la tierra, y es atraído por esta.
Se supone r lo suficientemente grande como para que la aproximación P = -mg no sea
adecuada, aunque para valores cercanos a la superficie se obtendrán los mismos
resultados.
Por otra parte, para valores muy grandes de r, la solución será la misma que considerar
que F=0.
Si incluimos en la ecuación anterior:
r = Rt + x
m(t) = M0 – met
nos queda:
2
0
)(
)(
xR
MtmM
GF
t
te
g
+
⋅−
−=
Donde hemos representado la fuerza - Fg al tratarse de una fuerza atractiva
Simplificando:
vmvtmM
xR
MtmM
Gvm ee
t
te
ee ⋅−⋅−=
+
⋅−
− &)(
)(
)(
02
0
vx
v
tmM
vvm
xR
M
Gv
e
ee
t
t
=
⋅
−
+
+
+
−=
&
&
0
2
)(
)(
Constante gravitatoria universal: G = 6’6726·10-11
Masa de la tierra: Mt = 5’98·1024
kg
Radio de la tierra: Rt = 6’370 ·106
m
Masa del cohete + combustible inicial: M0 (kg)
Ratio de consumo de combustible: me (kg/s)
Velocidad de expulsión del combustible: ve (m/s)
Posición del cohete, desde la superficie de la tierra: x (m)

Codificamos en Matlab este sistema de ecuaciones diferenciales:
function Y=fc(X)
t=X(1);
v=X(2); %corresponde a Y(1)=v'
x=X(3); %corresponde a Y(2)=x'
G=6.6726e-11;
Mt=5.98e24;
Rt=6.370e6;
Mo=208000; %Cohete Ariane I
me=10000;
ve=2000;
Y(1)=-G*Mt/(Rt+x)^2+me*v/(Mo-me*t);
Y(2)=v;
Algunos cálculos adicionales que pueden resultar útiles:
Tiempo de duración del combustible
Si tenemos un cohete de masa total
M0 = Mv + Mc
donde Mv es la masa del cohete vacío de combustible
Mc es la masa total de combustible inicial
el tiempo que durará el combustible cuando se consuma con velocidad constante me
será:
Mc - met = 0 t = Mc/me
Nótese que la mayoria de los cohetes poseen distintas etapas con diferentes sistemas de
propulsion, consumo y empuje.
Fuerza de empuje
Es usual dar el empuje del cohete en kgf (kilogramo fuerza).
Esta unidad corresponde a la fuerza que ejerce un kg en la superficie de la tierra, es
decir
1 kgf = 9’8 N
Si recordamos la formula anterior:
|Fe | = ∆pe = me ve
Al conocer el empuje y el consumo de combustible o la velocidad de expulsión,
podremos calcular el otro parámetro desconocido.

Ejemplos
El cohete europeo Ariane I creado en 1979 pesaba 208.000 Kg
Si suponemos que en la etapa de lanzamiento, en los primeros 60 segundos de
despegue, este se comporta como si estuviera quemando 2000 kg de combustible
por segundo, expulsándolos a una velocidad de 2000 m/s, ¿a qué altura se
encontrará transcurridos esos 60 segundos? ¿con qué velocidad viajará?
Considerar el peso del combustible incluido en el peso del cohete dado.
Utilizaremos
me=1500;
ve=2000;
Mo=208000;
En el intervalo de tiempo [0,60] para valores iniciales x=0, v=0
Mediante Runge Kutta con tamaño de paso 1:
[R,s,h]=rk4sist('fc',0,60,[0 0],60);
Evolución del sistema:
Obtenemos los valores finales:
t = 60 s
v = 711 m/s
x = 1.5686·104
m

La lanzadera espacial (Space Shuttle) creada por Estados Unidos en 1981 pesa
2.040.815 Kg
Si suponemos que cuando se encuentra a una altitud de 1000 Km y con una
velocidad de 1000 m/s se desprende de sus cohetes de aceleración inicial, quedando
con el peso especificado y quemando 100 Kg de combustible por segundo,
expulsándolo a 1000 m/s, ¿tendrá en estas condiciones empuje suficiente para
continuar el ascenso?
Utilizaremos
me=100;
ve=1000;
Mo=2040815;
Representamos la evolución del sistema entre [0,60] con tamaño de paso h=1 mediante
el metodo de Gragg de paso fijo para sistemas de ecuaciones, con las condiciones
iniciales v=1000 (m/s), x=500000 (m)
R=graggsist('fc',0,60,[1000 50000],60)
Vemos que, aunque la posición continua aumentando durante el primer minuto de
funcionamiento de la segunda etapa del cohete, la velocidad cae rápidamente, luego
llegará un momento en que la posición deje de aumentar, y el cohete caerá.

Si buscamos cuando llegará el cohete a chocar contra el suelo, entre los valores t=0 y
t=300 s, con 50 muestras (tamaño de paso h=6 ).
R=graggsist('fc',0,300,[1000 50000],50);
Vemos como algo después de los 250 segundos, el cohete ha perdido por completo toda
la altitud que había conseguido, y ha impactado contra el suelo.
Será entonces necesario aumentar la masa de combustible quemado por segundo, o
aumentar la velocidad de expulsión de este.

Código de los algoritmos para
Matlab
Método de Euler
function [E,sol,h]=euler(f,a,b,ya,M)
%Datos
% -function E=euler(f,a,b,ya,M)
% -f es la funcion
% -a y b son los extremos del intervalo
% -ya es la condicion inicial y(a)
% -M es el numero de pasos
%Resultado
% -E=[T' W'] siendo T el vector de abcisas e Y el de ordenadas
h=(b-a)/M;
T=zeros(1,M+1);
W=zeros(1,M+1);
T=a:h:b;
W(1)=ya;
for i=1:M
pto=[T(i),W(i)];
W(i+1)=W(i)+h*feval(f,pto);
end
sol=W(M+1);
E=[T' W'];
Método de Euler para sistemas de dos ecuaciones
function [E,sol,h]=eulersist(f,a,b,ya,M)
%Datos
% -function E=eulersist(f,a,b,ya,M)
% -f es el sistema de ecuaciones
% -ya es la condicion inicial
%Resultado
% -E=[T' W'] siendo T el vector de abcisas e Y el de ordenadas
h=(b-a)/M;
T=zeros(1,M+1);
W=zeros(M+1,2);
T=a:h:b;
W(1,1)=ya(1);
W(1,2)=ya(2);
for i=1:M
pto=[T(i),W(i,1),W(i,2)];
y=feval(f,pto);
W(i+1,1)=W(i,1)+h*y(1);
W(i+1,2)=W(i,2)+h*y(2);
end
sol(1)=W(M+1,1);
sol(2)=W(M+1,2);
E=[T' W];

Método de Euler con paso variable
function E=eulervar(f,a,b,ya,M,tol,tolh)
%Datos
% -function E=eulervar(f,a,b,ya,M,tol,tolh)
% -f es la funcion
% -tol es la tolerancia para cada paso
% -tolh es la tolerancia para h
%Resultado
% -E=[TP' T' W'] siendo T el vector de abcisas e Y el de ordenadas
h=(b-a)/M;
W=zeros(1,M+1);
W(1)=ya;
TP(1)=h;
i=1;
p=1;
T(i)=a;
while (T(i)<b)
q=0;
pto=[T(i),W(i)];
[X,W(i+1),hf]=euler(f,T(i),T(i)+h,W(i),1);
[X,A(i),hf]=euler(f,T(i),T(i)+h,W(i),2);
%W(i+1)=W(i)+h*feval(f,pto);
%A(i)=W(i)+h/2*feval(f,pto);
err=abs((W(i+1)-A(i))/((2^p)-1));
n=1;
while(err>tol)
[X,W(i+1),hf]=euler(f,T(i),T(i)+h,W(i),2^n);
[X,A(i),hf]=euler(f,T(i),T(i)+h,W(i),2^(n+1));
%W(i+1)=W(i)+h*feval(f,pto);
%A(i)=W(i)+h/2*feval(f,pto);
err=abs((W(i+1)-A(i))/((2^p)-1));
n=n+1;
q=1;
TP(i+1)=2*hf;
end
if (q==1)
%h=2*hf;
TP(i+1)=2*hf;
end
if (h<tolh)
disp('h es menor que tolh');
h=2*hf;
end
i=i+1;
T(i)=T(i-1)+h;
if (T(i)>b)
T(i)=b;
end
if (q==0)
TP(i)=h;
end
end
E=[TP' T' W'];

Método de Euler para sistemas con dos ecuaciones, paso variable.
function [E,sol]=eulersistvar2(f,a,b,ya,M,tol,tolh)
%Datos
% -function [E,sol]=eulersistvar2('f',a,b,ya,M,tol,tolh)
% -f es la funcion
% -tol es la tolerancia para cada paso
% -tolh es la tolerancia para h
%Resultado
% -E=[TP' T' W'] siendo T el vector de abcisas e Y el de ordenadas
% -sol es f(b)
h=(b-a)/M;
W(1,1)=ya(1);
W(1,2)=ya(2);
TP(1)=h;
i=1;
p=1;
T(i)=a;
while (T(i)<(b-h))
q=0;
pto=[T(i),W(i,1)];
[X,P,hf]=eulersist(f,T(i),T(i)+h,W(i,:),1);
W(i+1,1)=P(1);
W(i+1,2)=P(2);
[X,AA,hf]=eulersist(f,T(i),T(i)+h,W(i,:),2);
A(i,1)=AA(1);
A(i,2)=AA(2);
err=abs((W(i+1,1)-A(i,1))/((2^p)-1));
err2=abs((W(i+1,2)-A(i,2))/((2^p)-1));
n=1;
while((err>tol)&(err2>tol))
[X,P,hf]=eulersist(f,T(i),T(i)+h,W(i,:),2^n);
W(i+1,1)=P(1);
W(i+1,2)=P(2);
[X,AA,hf]=eulersist(f,T(i),T(i)+h,W(i,:),2^(n+1));
A(i,1)=AA(1);
A(i,2)=AA(2);
err=abs((W(i+1,1)-A(i,1))/((2^p)-1));
err2=abs((W(i+1,2)-A(i,2))/((2^p)-1));
n=n+1;
q=1;
TP(i+1)=2*hf;
end
if (q==1)
%h=2*hf;
TP(i+1)=2*hf;
end
if (h<tolh)
h=2*hf;
end
i=i+1;
T(i)=T(i-1)+h;
if (T(i)>b)
T(i)=b;
end
if (q==0)
TP(i)=h;
end
end
E=[TP' T' W];
sol(1)=W(i,1);
sol(2)=W(i,2);

Método de Gragg
function [W,FT,err]=gragg3(f,a,b,ya,n,tol,M)
%Datos
% -function [W,FT,err,h]=gragg3(f,a,b,ya,n,tol,M)
% -f es la funcion
% -n es el numero maximo de filas de la tabla
% -tol es la tolerancia
%Resultados
% -W es el esquema de Gragg
% -FT es la aproximacion a la f(b)
% -err es una estimacion del error
G=gragg(f,a,b,ya,M);
err=1;
J=0;
W=zeros(4,4);
W(1,1)=G(M+1,2);
while ((err>tol)&(J<n))%&(J<n))|(J<4)
J=J+1;
M=2*M;
G=gragg(f,a,b,ya,M);
W(J+1,1)=G(M+1,2);
for K=1:J
W(J+1,K+1)=W(J+1,K)+(W(J+1,K)-W(J,K))/(4^K-1);
end
err=abs(W(J,J)-W(J+1,K+1));
end
FT=W(J+1,J+1);
function G=gragg(f,a,b,ya,M)
%Datos
% -function G=gragg(f,a,b,ya,M)
% -f es la funcion
%Resultado
% -G=[T' W'] siendo T el vector de abcisas e Y el de ordenadas
h=(b-a)/M;
T=zeros(1,M+2);
W=zeros(1,M);
T=a:h:b;
W(1)=ya;
for i=1:M-1
pto=[T(i),W(i)];
W(i+1)=W(i)+h*feval(f,pto);
pto2=[T(i+1),W(i+1)];
W(i+2)=W(i+1)+(2*h*feval(f,pto2));
end
G=[T' W'];

Método de Gragg para sistemas de dos ecuaciones
function [X,Y,FT,errx,erry,h]=gragg3sist(f,a,b,ya,n,tolx,toly,M)
%Datos
% -function [X,Y,FT,errx,erry,h]=gragg3sist(f,a,b,ya,n,tolx,toly,M)
% -f es el sistema
% -n es el numero maximo de filas de la tabla
%Resultados
% -X e Y son el esquema de Gragg
% -FT es la aproximacion a la f1(b) y f2(b)
% -err es una estimacion del error
% -h es el menor de los incrementos usados
G=graggsist(f,a,b,ya,M);
errx=1;
erry=1;
J=0;
X=zeros(4,4);
X(1,1)=G(M+1,2);
Y=zeros(4,4);
Y(1,1)=G(M+1,3);
while ((errx>tolx)&(J<n)&(erry>toly))%&(J<n))|(J<4)
J=J+1;
M=2*M;
G=graggsist(f,a,b,ya,M);
X(J+1,1)=G(M+1,2);
Y(J+1,1)=G(M+1,3);
for K=1:J
X(J+1,K+1)=X(J+1,K)+(X(J+1,K)-X(J,K))/(4^K-1);
Y(J+1,K+1)=Y(J+1,K)+(Y(J+1,K)-Y(J,K))/(4^K-1);
end
errx=abs(X(J,J)-X(J+1,K+1));
erry=abs(Y(J,J)-Y(J+1,K+1));
end
FT=[X(J+1,J+1) Y(J+1,J+1)];
function G=graggsist(f,a,b,ya,M)
%Datos
% -function G=graggsist(f,a,b,ya,M)
% -f es el sistema
%Resultado
% -G=[T' W'] siendo T el vector de abcisas e Y el de ordenadas
h=(b-a)/M;
T=zeros(1,M+2);
W=zeros(M+1,2);
T=a:h:b;
W(1,1)=ya(1);
W(1,2)=ya(2);
for i=1:M-1
pto=[T(i),W(i,1),W(1,2)];
F=feval(f,pto);
W(i+1,1)=W(i,1)+h*F(1);
W(i+1,2)=W(i,2)+h*F(2);
pto2=[T(i+1),W(i+1,1),W(i+1,2)];
F=feval(f,pto2);
W(i+2,1)=W(i+1,1)+(2*h*F(1));
W(i+2,2)=W(i+1,2)+(2*h*F(2));
end
G=[T' W];

Método de Runge-Kutta
function [R,sol,h]=rk4(f,a,b,ya,M)
%Datos
% -function [R,sol]=rk4(f,a,b,ya,M)
% -f es la funcion
% -a y b son los extremos derecho e izquierdo del intervalo
%Resultado
% -R=[T'Y'] T abcisas e Y ordenadas
% -sol es f(b)
% -h es el incremento usado
h=(b-a)/M;
T=zeros(1,M+1);
Y=zeros(1,M+1);
T=a:h:b;
Y(1)=ya;
for j=1:M
pto=[T(j),Y(j)];
k1=h*feval(f,pto);
pto=[T(j)+h/2,Y(j)+k1/2];
k2=h*feval(f,pto);
pto=[T(j)+h/2,Y(j)+k2/2];
k3=h*feval(f,pto);
pto=[T(j)+h,Y(j)+k3];
k4=h*feval(f,pto);
Y(j+1)=Y(j)+(k1+2*k2+2*k3+k4)/6;
end
sol=Y(M+1);
R=[T' Y'];
Método Runge-Kutta para sistemas de dos ecuaciones
function [R,sol,h]=rk4sist(f,a,b,ya,M)
%Datos
% -function [R,sol,h]=rk4sist('f',a,b,ya,M)
% -f es el sistema
%Resultado
% -sol es f(b)
% -h es el incremento usado
h=(b-a)/M;
T=zeros(1,M+1);
Y=zeros(M+1,2);
T=a:h:b;
Y(1,1)=ya(1);
Y(1,2)=ya(2);
for j=1:M
y1=Y(j,1);
y2=Y(j,2);
pto=[T(j),y1,y2];
F=feval(f,pto);
k1(1,1)=F(1);
k1(1,2)=F(2);
pto=[T(j)+h/2,y1+h*k1(1,1)/2,y2+h*k1(1,2)/2];
F=feval(f,pto);
k2(1,1)=F(1);
k2(1,2)=F(2);
pto=[T(j)+h/2,y1+h*k2(1,1)/2,y2+h*k2(1,2)/2];
F=feval(f,pto);
k3(1,1)=F(1);
k3(1,2)=F(2);
pto=[T(j)+h,y1+h*k3(1,1),y2+h*k3(1,2)];
F=feval(f,pto);

k4(1,1)=F(1);
k4(1,2)=F(2);
Y(j+1,1)=Y(j,1)+h*(k1(1,1)+2*k2(1,1)+2*k3(1,1)+k4(1,1))/6;
Y(j+1,2)=Y(j,2)+h*(k1(1,2)+2*k2(1,2)+2*k3(1,2)+k4(1,2))/6;
end
sol(1,1)=Y(M+1,1);
sol(1,2)=Y(M+1,2);
R=[T' Y];
Método Runge-Kutta con paso variable
function [R,sol]=rk4var(f,a,b,ya,M,tol,tolh)
%Datos
% -function [R,sol]=rk4var('f',a,b,ya,M,tol,tolh)
% -f es la funcion
% -tol es la tolerancia entre un paso y otro
% -tolh es el minimo valor de h
%Resultado
% -R=[TP' T' W'] T abcisas e Y ordenadas
% -sol es f(b)
h=(b-a)/M;
TP(1)=h;
W(1)=ya;
j=1;
T(j)=a;
p=4;
%q=0;
while (T(j)<b)
q=0;
[R,W(j+1),hf]=rk4(f,T(j),T(j)+h,W(j),1);
[R,A(j),hf]=rk4(f,T(j),T(j)+h,W(j),2);
err=abs((W(j+1)-A(j))/(2^p-1));
n=1;
while (err>tol)
[R,W(j+1),hf]=rk4(f,T(j),T(j)+h,W(j),2^n);
[R,A(j),hf]=rk4(f,T(j),T(j)+h,W(j),2^(n+1));
err=abs((W(j+1)-A(j))/(2^p-1));
q=1;
n=n+1;
TP(j+1)=2*hf;
end
if (q==1)
%h=2*hf;
TP(j+1)=2*hf;
end
if (h<tolh)
h=2*hf;
end
j=j+1;
T(j)=T(j-1)+h;
if (T(j)>b)
T(j)=b;
end
if (q==0)
TP(j)=h;
end
end
R=[TP' T' W'];
sol=W(j);

Método Runge-Kutta para sistemas de dos ecuaciones, paso variable.
function [R,sol]=rk4sist(f,a,b,ya,M,tol,tolh)
%Datos
% -function [R,sol]=rk4sist('f',a,b,ya,M,tol,tolh)
% -f es el sistema
% -tolh es el valor minimo de h
%Resultado
% -sol es f(b)
h=(b-a)/M;
TP(1)=h;
Y=zeros(M+1,2);
T(1)=a;
W(1,1)=ya(1);
W(2,1)=ya(2);
j=1;
p=4;
while (T(j)<(b-h))
q=0;
[R,pto,hf]=rk4sist(f,T(j),T(j)+h,W(:,j),1);
W(1,j+1)=pto(1);
W(2,j+1)=pto(2);
[R,pto,hf]=rk4sist(f,T(j),T(j)+h,W(:,j),2);
A(j,1)=pto(1);
A(j,2)=pto(2);
err=abs((W(1,j+1)-A(j,1))/(2^p-1));
err2=abs((W(2,j+1)-A(j,2))/(2^p-1));
n=1;
while ((err>tol)&(err2>tol))
[R,pto,hf]=rk4sist(f,T(j),T(j)+h,W(:,j),2^n);
W(1,j+1)=pto(1);
W(2,j+1)=pto(2);
[R,pto,hf]=rk4sist(f,T(j),T(j)+h,W(:,j),2^(n+1));
A(j,1)=pto(1);
A(j,2)=pto(2);
err=abs((W(1,j+1)-A(j,1))/(2^p-1));
err2=abs((W(2,j+1)-A(j,2))/(2^p-1));
q=1;
n=n+1;
TP(j+1)=2*hf;
end
if (q==1)
%h=2*hf;
TP(j+1)=2*hf;
end
if (h<tolh)
h=2*hf;
end
j=j+1;
T(j)=T(j-1)+h;
if (T(j)>b)
T(j)=b;
end
if (q==0)
TP(j)=h;
end
end
R=[TP' T' W'];
sol(1)=W(1,M+1);
sol(2)=W(2,M+1);

Método Adams-Basfort-Multon
function [ABM,s]=abm4(f,a,b,ya,M,n,k)
%Datos
% -function [ABM,s]=abm4('f',a,b,ya,M,n,k)
% -f es la funcion
% -a y b son los extremos
% -M es el numero de pasos para ab
% -n es el numero de pasos para rk4
% -k es el numero se pasos para Adams-Moulton
%Resultados
% -ABM es la secuencia
% -s es el valor de la funcion en b
h=(b-a)/M;
t=a:h:b;
A(1,1)=ya; %w0
w0=rk4(f,a,a+h,ya,n);
A(2,1)=w0(n+1,2); %w1
w1=rk4(f,a+h,a+2*h,w0(n+1,2),n);
A(3,1)=w1(n+1,2); %w2
w2=rk4(f,a+2*h,a+3*h,w1(n+1,2),n);
A(4,1)=w2(n+1,2); %w3
if (M<5)
disp('M menor que 5');
break
end
for i=4:M
% A-B
pto3=[t(i-3),A(i-3,1)]; %Wi-3 Ti-3
pto2=[t(i-2),A(i-2,1)]; %Wi-2 Ti-2
pto1=[t(i-1),A(i-1,1)]; %Wi-1 Ti-1
pto=[t(i),A(i,1)]; %Wi Ti
F=[feval(f,pto3) feval(f,pto2) feval(f,pto1) feval(f,pto)];
A(i+1,1)=A(i,1)+((h/24)*(F*[-9 37 -59 55]'));
%A-M
err=abs(A(i,1)-A(i+1,1));
j=1;
while (j<k)
pto4=[t(i+1),A(i+1,1)]; %Wi+1 Ti+1
F=[feval(f,pto2) feval(f,pto1) feval(f,pto) feval(f,pto4)];
A(i+1,1)=A(i,1)+((h/24)*(F*[1 -5 19 9]'));
err=abs(A(i,1)-A(i+1,1));
j=j+1;
end
end
ABM=[t' A];
s=A(M+1,1);

Método Adams-Basfort-Multon para sistemas de dos ecuaciones
function [A,sol]=abm4sist(f,a,b,ya,M,n,k)
%Datos
% -function [A,sol]=abm4sist('f',a,b,ya,M,n,k)
% -f es el sistema
%Resultados
% -A es la secuencia
% -sol es el valor de la funcion en b
h=(b-a)/M;
t=a:h:b;
A(1,1)=ya(2); %w0
A(1,2)=ya(2); %w0
w0=rk4sist(f,a,a+h,ya,n);
A(2,1)=w0(n+1,2); %w1
A(2,2)=w0(n+1,3); %w1
w1=rk4sist(f,a+h,a+2*h,A(2,:),n);
A(3,1)=w1(n+1,2); %w2
A(3,2)=w1(n+1,3); %w2
w2=rk4sist(f,a+2*h,a+3*h,A(3,:),n);
A(4,1)=w2(n+1,2); %w3
A(4,2)=w2(n+1,3); %w3
if (M<5)
break
end
for i=4:M
% A-B
pto3=[t(i-3),A(i-3,1),A(i-3,2)]; %Wi-3 Ti-3
pto2=[t(i-2),A(i-2,1),A(i-2,2)]; %Wi-2 Ti-2
pto1=[t(i-1),A(i-1,1),A(i-1,2)]; %Wi-1 Ti-1
pto=[t(i),A(i,1),A(i,2)]; %Wi Ti
F=[feval(f,pto3) ;feval(f,pto2); feval(f,pto1); feval(f,pto)];
A(i+1,1)=A(i,1)+((h/24)*(F(:,1)'*[-9 37 -59 55]'));
A(i+1,2)=A(i,2)+((h/24)*(F(:,2)'*[-9 37 -59 55]'));
%A-M
j=1;
while (j<k)
pto4=[t(i+1),A(i+1,1),A(i+1,2)]; %Wi+1 Ti+1
F=[feval(f,pto2) ;feval(f,pto1); feval(f,pto); feval(f,pto4)];
A(i+1,1)=A(i,1)+((h/24)*(F(:,1)'*[1 -5 19 9]'));
A(i+1,2)=A(i,2)+((h/24)*(F(:,2)'*[1 -5 19 9]'));
j=j+1;
end
end
A=[t' A];
sol(1)=A(M+1,1);
sol(2)=A(M+1,2);

Método Adams-Basfort-Multon con paso variable.
function ABM=abm4var(f,a,b,ya,M,n,k,tol,tolh)
%Datos
% -function ABM=abm4var(f,a,b,ya,M,n,k,tol,tolh)
% -f es la funcion
%Resultados
% -A es el valor de la funcion en b
h=(b-a)/M;
t(1)=h;
TP(1)=h;
A(1,1)=ya; %w0
w0=rk4(f,a,a+h,ya,n);
A(2,1)=w0(n+1,2); %w1
w1=rk4(f,a+h,a+2*h,w0(n+1,2),n);
A(3,1)=w1(n+1,2); %w2
w2=rk4(f,a+2*h,a+3*h,w1(n+1,2),n);
A(4,1)=w2(n+1,2); %w3
if (M<5)
break
end
p=4;
i=1;
while (t(i)<b)
% A-B
pto3=[t(i-3),A(i-3,1)]; %Wi-3 Ti-3
pto2=[t(i-2),A(i-2,1)]; %Wi-2 Ti-2
pto1=[t(i-1),A(i-1,1)]; %Wi-1 Ti-1
A(i+1,1)=A(i,1)+((h/24)*(F*[-9 37 -59 55]'));
%A-M
for j=1:k
pto4=[t(i+1),A(i+1,1)]; %Wi+1 Ti+1
A(i+1,1)=A(i,1)+((h/24)*(F*[1 -5 19 9]'));
end
B(i,1)=A(i,1)+((h/48)*(F*[-9 37 -59 55]'));
err=abs((A(i+1,1)-B(i,1))/((2^p)-1));
while (err>tol)
w1=rk4(f,a+h,a+2*h,w0(n+1,2),n);
A(3,1)=w1(n+1,2); %w2
w2=rk4(f,a+2*h,a+3*h,w1(n+1,2),n);
A(4,1)=w2(n+1,2); %w3
pto3=[t(i-3),A(i-3,1)]; %Wi-3 Ti-3
pto2=[t(i-2),A(i-2,1)]; %Wi-2 Ti-2
pto1=[t(i-1),A(i-1,1)]; %Wi-1 Ti-1
A(i+1,1)=A(i,1)+((h/24)*(F*[-9 37 -59 55]'));
%A-M
for j=1:k
pto4=[t(i+1),A(i+1,1)]; %Wi+1 Ti+1
A(i+1,1)=A(i,1)+((h/24)*(F*[1 -5 19 9]'));
end
B(i,1)=A(i,1)+((h/48)*(F*[-9 37 -59 55]'));
err=abs((A(i+1,1)-B(i,1))/((2^p)-1));
end

if (h<tolh)
h=(b-a)/M;
end
t(i+1)=t(i)+h;
TP(i+1)=h;
i=i+1;
end
ABM=[TP' t' A];

Movimiento cohetes

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Movimiento cohetes

Similar a Movimiento cohetes (20)

Último

Último (20)

Movimiento cohetes