Tutorial de solución simbólica de EDO de primer orden mediante software

En este breve tutorial de ilustrarán a través de ejemplos, los comandos más usados en Máxima, Matlab y Python para resolver simbólicamente ecuaciones diferenciales ordinarias (EDO) de primer orden.

Máxima:Maxima

Máxima cuenta con los comandos ode2(), desolve(), contrib_ode() y dsolve()  que nos ayudarán a resolver ecuaciones diferenciales ordinarias de primer orden y de orden superior.  En esta caso, solo vamos a mencionar el comando ode2() para solucionar EDO de primer orden.

Lo primero que podemos aclarar es que Máxima denota las entradas de comando como (%in) y sus salidas como (%on), donde n será un número entero que corresponde al número de entrada/salida.  Esta notación también implica que dicha salida es guarda en una variable con su mismo nombre, es decir, la variable %o1 contiene la salida o resultado del comando que se ejecutó en la entrada %i1.  Si queremos hacer alguna operación con el resultado de un comando inmediatemente anterior, se usa simplemente la variable “%”.

Varios comandos en secuencia se separan mediante punto coma “;”, en cuyo caso Máxima desplegará el resultado de todos ellos. Si se separan por el símbolo “$” entonces no se desplegarán los resultados del comando que lo precede.

Ahora, la notación usada para escribir la EDO, es la siguiente:

La la 1era derivada se escribe como:‘diff(y,x)  y la derivada n-ésima como: ‘diff(y,x,n).  Observe que la derivada se escribe usando la función diff() (operación de derivación) de Máxima pero precedida por una comilla simple , esto indica que la operación de derivación diff() no se calcula en la expresión, es decir, se deja indicada.

Para ejecutar un comando es necesario presionar la combinación de teclas SHIFT+ENTER.

Para que usted vea la diferencia de preceder un comando por la comilla simple , ejecute los dos comandos:

diff(x^2,x); 'diff(x^2,x);Maxima

Y observe la salida obtenida.

 

Ejemplo 1:

Resolver la EDO de primer orden: y'=y x \sin(x)

Solución: la secuencia de comandos usada para solucionar la EDO dada es:

eq:'diff(y,x)=y*x*sin(x);Maxima
ode2(eq,y,x);

Cuyo resultado es:

y=\%c\,{e}^{\mathrm{sin}\left( x\right) -x\,\mathrm{cos}\left( x\right) } Maxima

Usted también puede escribir la EDO directamente en el argumento de la función ode2(), pero se recomienda por claridad que se escriba en una variable (llamada en este caso eq) y luego pasársela como argumento al comando.  De esta manera el código es más legible y fácil de detectar algún posible error.

Ejemplo 2:

Resuelva la EDO del ejemplo 1, con las condiciones iniciales y(\frac{\pi}{4})=e

Solución: para introducir la condición inicial de un PVI (Problema de Valor Inicial) de primer orden, se usa el comando ic1().  La secuencia de comandos para resolver el problema es:

eq:'diff(y,x)=y*x*sin(x);
Maximaode2(eq,y,x); ic1(%,x=%pi/4,y=%e);

Cuyo resultado es:

y=%e^(sin(x)-x*cos(x)-sin(%pi/4)+(%pi*cos(pi/4))/4+1)Maxima

Observe que en el comando ic1() se ha tomado el resultado del comando anterior (%).  En otro caso, usted deberá llevar el resultado de ode2() a una variable (por ejemplo sol) que será el primer argumento de ic1(), es decir:

sol=ode2(eq,y,x);
Maxima.... mas comandos... 
ic1(sol,x=%pi/4,y=%e);

Observe que Maxima cuenta con la definición del número pi y el número e (denotados como %pi y %e).

Si desea graficar la solución obtenida, usted deberá escribir la expresión obtenida al otro lado del igual en la función plot2d() o definir una nueva variable con dicha expresión, esto es:

y1:%e^(sin(x)-x*cos(x)-sin(%pi/4)+(%pi*cos(%pi/4))/4+1)Maxima
plot2d(y1,[x,0,5])

Sin embargo, existe una manera de no tener que escribir la expresión en una nueva variable para obtener la gráfica.  Esto se consigue usando las función rhs() de Maxima que toma la expresión al lado derecho del igual. Para el ejemplo anterior, nos quedaría así:

eq:'diff(y,x)=y*x*sin(x);
Maximaode2(eq,y,x); ic1(%,x=%pi/4,y=%e);
sol:rhs(%);
plot2d(sol,[x,-1,1]);

 

Si al usar el comando ode2() sale el mensaje “false” , esto nos indica que no se puede solucionar la E.D.  En cuyo caso se deberá intentar otro método, como por ejemplo contrib_ode() que mencionaremos en ejemplos posteriores.

Para más información consulte el manual (SolEDconMaxima.pdf) en la sección de Recurso de la web.

 

MatlabSolución con Matlab:

En este caso se usa el comando dsolve().  La notación usada es: la 1era derivada se escribe como Dy , la 2da como D2y y así sucesivamente.  Observe que en esta notación no se especifica la variable independiente.  Matlab asumirá por defecto que la variable independiente es “t“.

La secuencia de comandos que soluciona el ejemplo 1 es:

>> eq='Dy=y*x*sin(x)'; dsolve(eq,'x')Matlab
ans = 
C2*exp(sin(x) - x*cos(x))

Los argumentos del comando deben escribirse entre comillas simples ‘  ‘.  Observe que si usted no escribe el último argumento ‘x‘ (variable independiente), Matlab asumirá que es “t“.

Si se desea introducir las condiciones iniciales, se puede hacer como segundo argumento del comando.  Entonces, para solucionar el ejemplo 2, digitamos:

>> dsolve(eq,'y(pi/4)=exp(1)','x')Matlab
ans = 
exp(sin(x) - x*cos(x))*exp(1)*exp((pi*2^(1/2))/8 - 2^(1/2)/2)

Si usted desea graficar el resultado, deberá definir un vector con la expresión obtenida (solución de dsolve), sin embargo, el comando ezplot() permite graficar directamente el resultado de dsolve, evitando la definición de dicho vector.  La secuencia de comandos es:

>> eq='Dy=y*x*sin(x)';y=dsolve(eq,'y(pi/4)=exp(1)','x')Matlab;
>> ezplot(y,[-1,1])

Observe que adicionalmente es posible introducir el rango(eje y) de la gráfica como [-1,1].

 

pythonSolución con iPython:

Aunque Python no está enfocado al cálculo simbólico, cuenta con la librería sympy que permite solucionar simbólica y numéricamente EDO de primer orden y superior.  En este caso nos concentraremos en el comando dsolve() .

Una notación que usa Python para la primera derivada es: y(x).diff(x).  Para la segunda: y(x).diff(x,x) y así sucesivamente para las de orden mayor.

Así las cosas, el código que nos resuelve el ejemplo 1 es:

# Solucion de Ecuaciones diferenciales simbolicas de primer ordenpython
from sympy import *
x, y = symbols("x y")

# Definicion de E.D a resolver: y' = y*x*sin(x)
eq = y(x).diff(x)-y(x)*x*sin(x)
sol=dsolve(eq, y(x)) 
print sol # imprime en pantalla

Observe que es necesario definir las variables “x,y” como símbolos y que para el primer argumento del comando dsolve(), la EDO y’=f(x,y) se debe escribir de la forma y’-f(x,y).

Otra notación que usa Python para la primera derivada es: Derivative(f(x),x).  Para la 2da: Derivative(f(x),x,x) y así sucesivamente.  En este caso, además de la definición de los símbolos “x, y” se debe definir funciones “f, g,.. etc”. Aquí la EDO se debe escribir dentro del argumento del comando Eq().  El siguiente código ilustra el caso:

# Otra manera y desplegando mas informacion de la EDOpython
from sympy import *
from sympy import init_printing # para mejor despliege de la EDO
x, y = symbols("x y")
f, g = map(Function, 'fg')
# Definicion de E.D a resolver: y' = y*x*sin(x)
eq = Eq(Derivative(f(x),x), f(x)*x*sin(x)) # otra manera de definir la EDO
sol=dsolve(eq, f(x)) 
print sol

Observe que adicionalmente se ha usado el paquete “init_printing” para un mejor despliegue de las salidas.

Aquí les dejo el link de la secuencia de comandos que se usaron en iPython con más ejemplos:

Sagemath: Tutorial de solución simbólica de EDO de primer orden

 

 

Para finalizar, les dejo un tutorial en pdf con más ejemplos usando MATLAB