Introducción

Los métodos más sencillos como el de Euler o las mejoras de este procedimiento, tienen dos defectos esenciales: la exactitud es pequeña y los errores crecen sistemáticamente.

El procedimiento de Runge-Kutta se puede programar fácilmente en los ordenadores, y además se emplea mucho en la práctica, debido a la su exactitud relativamente elevada de la solución aproximada de la ecuación diferencial. La justificación del procedimiento de Runge-Kutta no es sencilla, el lector interesado puede consultar algún libro de métodos numéricos de análisis que como el que se cita en la bibliografía.

 

Ecuaciones diferenciales de primer orden

Sea una ecuación diferencial de primer orden, con la condición inicial

Se elige una anchura de paso h, y se calculan cuatro números k1, k2, k3, k4 de acuerdo con el procedimiento esquematizado en la tabla adjunta. Según el procedimiento ordinario de Runge-Kutta, a partir del valor de x en el instante t se determina el valor de x en el instante t+h mediante la fórmula que figura en la última fila de dicha tabla.

 

La jerarquía de clases

Definimos una clase base abstracta denomina RungeKutta, cuya función miembro resolver nos calcule la solución aproximada de la ecuación diferencial x en el instante final tf, cuando le pasamos el estado inicial, es decir, el valor de x0 en el instante inicial t0. La función devuelve el estado del sistema que puede ser la posición del móvil, la intensidad de la corriente eléctrica en un circuito, etc., es decir, el valor de x, en el instante t.

public abstract class RungeKutta { public double resolver(double tf, double t0, double x, double h){ double k1, k2, k3, k4; for(double t=t0; t<tf; t+=h){ k1=h*f(x, t); k2=h*f(x+k1/2, t+h/2); k3=h*f(x+k2/2, t+h/2); k4=h*f(x+k3, t+h); x+=(k1+2*k2+2*k3+k4)/6; } return x; } abstract public double f(double x, double t);}

En la clase Funcion derivada de RungeKutta describimos el modelo físico particular, redefiniendo la función f(x, t). Consideremos la ecuación diferencial que describe la desintegración de una sustancia radioactiva en otra estable.

Donde a es la constante de desintegración radioactiva. A la izquierda tenemos la ecuación diferencial y a la drecha su solución analítica.

La definición de la clase Funcion define la función f(x), tomando el valor de la constante de desintegración a igual a 0.1

public class Funcion extends RungeKutta{ public double f(double x, double t){ return (-0.1*x); }}

La llamada a la función resolver se efectuará desde un objeto de la clase derivada Funcion. Se nos pedirá los siguientes datos: el estado inicial, es decir, el número de núcleos x0 en el instante inicial t0, el instante final t en el que queremos calcular el nuevo estado del sistema x, y el paso h para resolver numéricamente la ecuación diferencial. La función miembro resolver devuelve el número de núcleos quedan sin desintegrar en dicho instante t.

double h=0.5; //paso

double x0=5000; //número inicial de núcleos en el instante t=0 double t=20.0; //resolver la e. d. hasta este instante

double x=new Funcion().resolver(t, 0, x0, h); System.out.println("valor aprox. de x "+(int)x);

Comparamos el valor exacto y el valor aproximado, tomando como paso h el valor 0.5, el número inicial de núcleos, 5000, y el instante t, 20. Se obtiene para el resultado aproximado 676 y para el resultado exacto 676, lo que nos confirma la exactitud del procedimiento de Runge-Kutta.

// valor exacto x=(int)(x0*Math.exp(-0.1*t)); System.out.println("valor exacto de x "+(int)x);

Sistema de ecuaciones diferenciales de primer orden

El procedimiento de Runge-Kutta es igualmente efectivo en la resolución de ecuaciones diferenciales de primer orden. Sea el sistema

El procedimiento de aplicación del método de Runge-Kutta a cada una de las ecuaciones diferenciales, con las condiciones iniciales

se esquematiza en la tabla adjunta. Como vemos además de los cuatro números k1, k2, k3, k4

para la primera ecuación diferencial precisamos otros cuatro números l1, l2, l3, l4 para la segunda ecuación diferencial. A partir del valor de x en el instante t, se determina el valor de x en el instante t+h, y a partir del valor de y en el instante t se determina el valor de y en el instante t+h mediante las fórmulas de la última fila de la tabla.

 

La jerarquía de clases

De modo similar, definimos la clase base abstracta denominada RungeKutta cuya función miembro resolver nos calcule la solución aproximada del sistema de ecuaciones diferenciales de primer orden (x, y) en el instante final tf, cuando le pasamos el estado inicial, es decir, el valor x0 e y0 en el instante inicial t0

public abstract class RungeKutta { public void resolver(double tf, Estado e, double h){//variables auxiliares double k1, k2, k3, k4; double l1, l2, l3, l4;//estado inicial double x=e.x; double y=e.y; double t0=e.t;

for(double t=t0; t<tf; t+=h){ k1=h*f(x, y, t); l1=h*g(x, y, t); k2=h*f(x+k1/2, y+l1/2, t+h/2); l2=h*g(x+k1/2, y+l1/2, t+h/2); k3=h*f(x+k2/2, y+l2/2, t+h/2); l3=h*g(x+k2/2, y+l2/2, t+h/2); k4=h*f(x+k3, y+l3, t+h); l4=h*g(x+k3, y+l3, t+h); x+=(k1+2*k2+2*k3+k4)/6; y+=(l1+2*l2+2*l3+l4)/6; }//estado final e.t=tf; e.x=x; e.y=y; } abstract public double f(double x, double y, double t); abstract public double g(double x, double y, double t);}

Una función solamente, puede devolver un valor, sin embargo, el estado del sistema en cualquier instante t viene dado por dos números x e y. Para ello, definimos la clase denominada Estado con tres miembros públicos x e y y el tiempo t.

La función resolver recibe en su segundo parámetro el estado inicial del sistema. Ya que los objetos que se pasan a una función se pueden modificar en el curso de su llamada. La función resolver modifica dicho objeto, devolviendo el estado final cuando se le pasa el estado inicial.

public class Estado { public double t; public double x; public double y; public Estado(double t, double x, double y) { this.t=t; this.x=x; this.y=y; }}

Para obtener el estado e (objeto de la clase Estado) accedemos a sus miembros dato públicos t, x, y

System.out.println("t " +e.t);System.out.println("x " +e.x);System.out.println("y " +e.y);

Para crear el estado e a partir de los valores de t, x, e y, llamamos al constructor de la clase  Estado.

double t=0; double x=1000; double y=0;

Estado e=new Estado(t, x, y);

 

Ejemplo

Continuando con el ejemplo de la desintegración radioactiva consideremos ahora, una serie radioactiva de tres elementos en la que, una sustancia radiactiva A se desintegra y se transforma en otra sustancia radiactiva B, que a su vez se desintegra y se transforma en una sustancia C estable. Las ecuaciones diferenciales que gobiernan el proceso y sus soluciones analíticas son, respectivamente,

La solución analítica que aparece a la derecha, se ha obtenido con las condiciones iniciales t=0, x=x0 e y=0. La segunda solución se obtiene siempre que a sea distinto de b. En el caso de que a sea igual a b, la solución analítica para y es

La interpretación del sistema de ecuaciones diferenciales no es complicada. En la unidad de tiempo, desaparecen ax núcleos de la sustancia A al desintegrarse (primera ecuación). En la unidad de tiempo, se producen ax núcleos de la sustancia B, y a su vez desaparecen bx núcleos de la sustancia B que al desintegrarse se transforman en núcleos de la sustancia C estable (segunda ecuación).

Para codificar este ejemplo, primero se han de definir las funciones f, g en la clase derivada Funcion de la clase abstracta RungeKutta.

public class Funcion extends RungeKutta{ public double f(double x, double y, double t){ return (-0.1*x); } public double g(double x, double y, double t){ return (0.1*x-0.2*y); }}

Definimos el estado inicial en el instante t0=0, el número de núcleos de la sustancia radiactiva A, suponemos que no hay inicialmente núcleos de sustancia B. Establecemos el instante t en el que deseamos conocer el número de núcleos que hay de la sustancia A, y el número de núcleos de la sustancia B, llamando a la función resolver desde un objeto de la clase Funcion.

double h=0.5; //paso

double x0=5000; Estado es=new Estado(0, x0, 0);

double t=20.0; //resolver la e. d. hasta este instante new Funcion().resolver(t, es, h); System.out.println("valor aprox. de x "+(int)es.x); System.out.println("valor aprox. de y "+(int)es.y);

Como en el apartado anterior fijamos el número de núcleos de la sustancia A en 5000, y el de la B ningún núcleo. El valor del paso h lo tomamos como 0.5. Los resultados aproximados para el instante t=20 están en concordancia con los obtenidos a partir del resultado exacto, como queda reflejado en la tabla adjunta

 

 

 

 

t=20 Aproximado Exacto

A 676 676

B 585 585

Ecuación diferencial de segundo orden

Vamos a aplicar el procedimiento de Runge-Kutta a una ecuación diferencial de segundo orden.

con las condiciones iniciales

Una ecuación diferencial de segundo orden es equivalente a un sistema de dos ecuaciones diferenciales de primer orden, por lo que aplicaremos el mismo esquema.

Comparando esta tabla con la de un sistema de dos ecuaciones diferenciales de primer orden, vemos que la segunda columna es la misma, excepto por cambio de nombre de la función, f en vez de g, y de la variable, v en vez de y. En la primera columna, las variables k1, k2, k3, k4 pueden calcularse directamente sin efectuar llamadas a una función.

 

La jerarquía de clases

La definición de la clase abstracta RungeKutta con la función miembro resolver es, la siguiente.

public abstract class RungeKutta { public void resolver(double tf, Estado e, double h){//variables auxiliares double k1, k2, k3, k4; double l1, l2, l3, l4;//estado inicial double x=e.x; double v=e.v; double t0=e.t;

for(double t=t0; t<tf; t+=h){ k1=h*v; l1=h*f(x, v, t); k2=h*(v+l1/2); l2=h*f(x+k1/2, v+l1/2, t+h/2); k3=h*(v+l2/2); l3=h*f(x+k2/2, v+l2/2, t+h/2); k4=h*(v+l3); l4=h*f(x+k3, v+l3, t+h); x+=(k1+2*k2+2*k3+k4)/6; v+=(l1+2*l2+2*l3+l4)/6; } e.t=tf; e.x=x; e.v=v; } abstract public double f(double x, double y, double t);}

La definición de la clase cuyos miembros dato nos sirven para guardar el estado del sistema es similar a la clase definida en el apartado sistema de dos ecuaciones diferenciales de primer orden con el mismo propósito, cambiando el miembro y por la derivada de x, que hemos llamado v.

public class Estado { public double t; public double x; public double v; public Estado(double t, double x, double v) { this.t=t; this.x=x; this.v=v; }}

 

Ejemplos

Oscilaciones libres

La ecuación diferencial que describe un oscilador armónico y su solución para unas condiciones iniciales fijadas es

donde 0 es la frecuencia angular, y el periodo del movimiento es P=2/0.

La clase denominada Oscilador que describirá un oscilador armónico tendrá como miembro dato, la frecuencia angular, y derivará de la clase base RungeKutta, ya que el comportamiento de un oscilador armónico viene descrito por una ecuación diferencial de segundo orden. La clase Oscilador definirá la función f declarada abstracta en la clase base.

public class Oscilador extends RungeKutta{ protected double w0; //frecuencia angular public Oscilador(double w0){ this.w0=w0; } public double f(double x, double v, double t){ return (-w0*w0*x); }}

Examinemos el comportamiento de un oscilador que en el instante inicial t=0, se encuentra en la posición de máximo desplazamiento x=A, y se suelta con velocidad inicial cero v=0. La amplitud A y la fase inicial se calculan, a partir de las condiciones iniciales especificadas, que pueden ser distintas de las señaladas.

Podemos experimentar con un oscilador de frecuencia angularde 2 rad/s, lo que corresponde a un periodo P=2/de s, calculemos la posición y la velocidad del oscilador en el instante t= 2s, tomando como paso h el valor de 0.01.

double h=0.01; //paso double w0=2.0; //frecuencia propia oscilaciones libres double t=2.0; //resolver la e. d. hasta este instante//Situación inicial double x0=1.5; //posición inicial double v0=0.0; //velocidad inicial Estado es=new Estado(0.0, x0, v0);

//oscilaciones libres System.out.println("Oscilaciones libres"); Oscilador os=new Oscilador(w0); os.resolver(t, es, h); System.out.println("posición aprox. "+es.x); System.out.println("velocidad aprox. "+es.v);

// valor exacto double fi=Math.atan(w0*x0/v0); double A=x0/Math.sin(fi); double x=A*Math.sin(w0*t+fi); double v=A*w0*Math.cos(w0*t+fi); System.out.println("posición exacta "+x); System.out.println("velocidad exacta "+v);

Oscilaciones amortiguadas

Si además consideramos que existe un rozamiento que se describe en términos de una fuerza proporcional a la velocidad, la ecuación diferencial del oscilador amortiguado se escribe.

En vez de crear una nueva clase Amortiguado que sustituya a la clase Oscilador, podemos pensar que un oscilador amortiguado, es una clase especial de oscilador, y por tanto la clase que lo describe, derivará de Oscilador, le añadirá el miembro dato g (por ), que da cuenta de la intensidad de las fuerzas de rozamiento, y además, redefine la función f.

public class Amortiguado extends Oscilador{ protected double g; public Amortiguado(double g, double w0){ super(w0); this.g=g; } public double f(double x, double v, double t){ return (-2*g*v-w0*w0*x); }}

En la figura, se muestra la jerarquía de clases.

Sea por ejemplo, un oscilador armónico amortiguado que tiene los datos 0=2, =0.5, y las condiciones iniciales en el instante son t=0, x=1.5, y v=0. Tomando un paso h de anchura

0.1, se puede comparar la posición del móvil en el instante t, con la deducida a partir de la solución analítica de la ecuación diferencial

La amplitud A y la fase inicial se calculan a partir de las condiciones iniciales especificadas.

double h=0.01; //paso double w0=2.0; //frecuencia propia oscilaciones libres double g=0.5; //cte de amortiguamiento double t=2.0; //resolver la e. d. hasta este instante//Situación inicial double x0=1.5; //posición inicial double v0=0.0; //velocidad inicial Estado es=new Estado(0.0, x0, v0);//oscilaciones amortiguadas System.out.println("Oscilaciones amortiguadas"); es=new Estado(0.0, x0, v0); new Amortiguado(g, w0).resolver(t, es, h); System.out.println("posición aprox. "+es.x); System.out.println("velocidad aprox. "+es.v);// valor exacto double w=Math.sqrt(w0*w0-g*g); fi=Math.atan(w*x0/(v0+g*x0)); A=x0/Math.sin(fi); x=A*Math.exp(-g*t)*Math.sin(w*t+fi); System.out.println("posición exacta "+x); v=A*Math.exp(-g*t)*(-g*Math.sin(w*t+fi)+w*Math.cos(w*t+fi)); System.out.println("velocidad exacta "+v);

Sistema de dos ecuaciones diferenciales de segundo orden

Sea el sistema de dos ecuaciones diferenciales de segundo orden

con las condiciones iniciales

Este sistema, se puede transformar en un sistema equivalente formado por cuatro ecuaciones diferenciales de primer orden. Aplicando dos veces el esquema descrito para una ecuación diferencial de segundo orden, obtenemos el esquema descrito en las siguientes tablas

 

La codificación de la función que resuelve el sistema de dos ecuaciones diferenciales de segundo orden, repite dos veces, el código de la función resolver correspondiente a una  ecuación diferencial de segundo orden, ya que hay que calcular cuatro pares de parámetros más, los correspondientes a la segunda ecuación diferencial de segundo orden.

 

La jerarquía de clases

De modo análogo a los apartados anteriores, estableceremos una jerarquía de clases, la clase base abstracta define el procedimiento numérico y la clase derivada define el sistema físico particular.

public abstract class RungeKutta { public void resolver(double tf, Estado e, double h){//variables auxiliares

double k1, k2, k3, k4; double l1, l2, l3, l4; double q1, q2, q3, q4; double m1, m2, m3, m4;

//estado inicial double x=e.x; double y=e.y; double vx=e.vx; double vy=e.vy; double t0=e.t;

for(double t=t0; t<tf; t+=h){ k1=h*vx; l1=h*f(x, y, vx, vy, t); q1=h*vy; m1=h*g(x, y, vx, vy, t);

k2=h*(vx+l1/2); l2=h*f(x+k1/2, y+q1/2, vx+l1/2, vy+m1/2, t+h/2); q2=h*(vy+m1/2); m2=h*g(x+k1/2, y+q1/2, vx+l1/2, vy+m1/2, t+h/2);

k3=h*(vx+l2/2); l3=h*f(x+k2/2, y+q2/2, vx+l2/2, vy+m2/2, t+h/2); q3=h*(vy+m2/2); m3=h*g(x+k2/2, y+q2/2, vx+l2/2, vy+m2/2, t+h/2);

k4=h*(vx+l3); l4=h*f(x+k3, y+q3, vx+l3, vy+m3, t+h); q4=h*(vy+m3); m4=h*g(x+k3, y+q3, vx+l3, vy+m3, t+h); x+=(k1+2*k2+2*k3+k4)/6; vx+=(l1+2*l2+2*l3+l4)/6; y+=(q1+2*q2+2*q3+q4)/6; vy+=(m1+2*m2+2*m3+m4)/6;

}//estado final

e.x=x; e.y=y; e.vx=vx; e.vy=vy; e.t=tf;

} abstract public double f(double x, double y, double vx, double vy, double t); abstract public double g(double x, double y, double vx, double vy, double t);}

El estado del sistema vendrá dado por cuatro números x, y, vx, vy y t, miembros dato de la clase que hemos denominado Estado.

public class Estado { public double t; public double x; public double y; public double vx; public double vy; public Estado(double t, double x, double y, double vx, double vy) { this.t=t; this.x=x; this.y=y; this.vx=vx; this.vy=vy; }}

 

Ejemplo

Uno de los ejemplos más interesantes de resolución de un sistema de ecuaciones diferenciales de segundo orden es la descripción del movimiento de los planetas, el cual tiene una solución analítica sencilla en coordenadas polares. La trayectoria seguida por un planeta es una cónica, una elipse en particular, en uno de cuyos focos está el centro fijo de fuerzas, el Sol. En la figura, se muestra la fuerza que ejerce el Sol sobre un planeta, inversamente proporcional al cuadrado de las distancias que separan sus centros, y también se muestran sus componentes rectangulares

Teniendo en cuenta que la fuerza que ejerce el sol sobre un planeta viene descrita por la ley de la Gravitación Universal

donde M es la masa del Sol, m la masa del planeta y r la distancia entre el centro del Sol y del planeta. Las componentes de la aceleración del planeta serán

Uno de los problemas del tratamiento numérico con ordenador, es la de reducir el problema a números simples e inteligibles por el usuario de un vistazo. Las masa de los planetas y del Sol son números muy grandes: la masa de la Tierra es 5.98 1024 kg., y 1.98 1030 kg. la del Sol. La distancia media entre la Tierra y el Sol es también muy grande 1.49 1011 m. y la constante G es muy pequeña 6.67 10-11 en el Sistema Internacional de Unidades. Podemos simplificar el problema numérico, refiriéndonos a un hipotético Sol cuya masa sea tal que el producto GM=1 o bien, que se ha cambiado la escala de los tiempos de modo que se

cumpla esta condición. Teniendo en cuenta que la aceleración es la derivada segunda de la posición, el sistema de dos ecuaciones diferenciales de segundo orden quedará

En la clase derivada Planeta redefinimos las funciones f y g.

public class Planeta extends RungeKutta{ public double f(double x, double y, double vx, double vy, double t){ double r=Math.sqrt(x*x+y*y); return (-x/(r*r*r)); } public double g(double x, double y, double vx, double vy, double t){ double r=Math.sqrt(x*x+y*y); return (-y/(r*r*r)); }}

Los pasos para usar la clase Planeta son los siguientes

Establecer la magnitud del paso h Introducir el estado inicial de la partícula (su posición y su

velocidad inicial) Establecer el tiempo final t, en el que deseamos calcular el

nuevo estado del planeta. Crear un objeto de la clase Planeta y llamar a la función

miembro resolver. Mostrar la posición y velocidad final del planeta.

double h=0.1; //paso

//Situación inicial double x0=1.0; double vy0=1.2; Estado es=new Estado(0.0, x0, 0.0, 0.0, vy0);

double t=10.0; //resolver la e. d. hasta este instante new Planeta().resolver(t, es, h); System.out.println("posición aprox. x "+es.x); System.out.println("posición aprox. y "+es.y); System.out.println("velocidad aprox. vx "+es.vx); System.out.println("velocidad aprox. vy "+es.vy);