Tutorial de graficación - Curso

Ecuaciones Diferenciales

William Gómez Ortega

Estudiante de Ingeniería Electrónica
Universidad de Antioquia.
 Contenido
• Programación básica en IPython
• Módulos importantes para el curso
• Graficación en IPython
• Solución de O.D.E.
• Comandos de Maxima
• Interfaz de Maxima
• Matlab
Programación básica en IPython

Comentarios:

# Esto es un comentario de linea

""" Para varias líneas colocamos 3 comillas al

inicio y al final """
Programación básica en IPython

Control de flujo:
• Requieren identación

Flujos condicionales If Bucle while Bucle for

If condición: for variable in lista (o

while condición:
Instrucciones cadena):
Instrucciones
elif condición: Instrucciones

Instrucciones
else
Programación básica en IPython

Módulos y paquetes:

Módulo: Todo archivo que contenga código, con la extensión .py

Paquete: Carpetas con archivos .py pero que contiene un archivo llamado __init__.py

¿Cómo importar módulos a nuestro código?

import moduloejemplo
import paquetico.moduloejemplo

¿Y si sólo me interesa una variable del modulo?

from moduloejemplo import variableprincipal
Programación básica en IPython

Módulos y paquetes:
Puedo importar un módulo y nombrarlo diferente para trabajar con este nuevo nombre.
import moduloejemplo as ptr

¿Cómo utilizo los elementos contenidos en el módulo?

A= ptr.variableprincipal

print(ptr.variableprincipal)
Programación básica en IPython

Funciones:
Porción de código que se ejecuta cuando es llamado. (Recordar la identación)

def mi_funcion():
Instrucciones

Formas de definir funciones con parametros

def mi_funcion(par1,par2) Llamado funcion(a , b)

def mi_funcion(par1, par2 = b) Llamado funcion(a)

def mi_funcion(par1,par2) Llamado funcion(par1=a , par2=b)

Módulos importantes para el curso

• NumPy: Módulo que agrega mayor soporte

para vectores y matrices.
• Matplotlib: Para la generación de gráficos.
 Pylab: Generación de gráficos similar a matlab
• SciPy: Herramientas y algoritmos matemáticos.
• SymPy: Cálculo simbólico.
 Graficación en IPython

Creación de vectores y matrices:

El lenguaje python como tal permite crear vectores y matrices, llamados listas.

A=[3,4,5]
A=[[3,5,6],[8,9,0]]

Pero desde paquete NumPy podemos crear objetos llamados array que nos permiten realizar
operaciones matemáticas y algebra lineal.
Primero que todo debemos importarla:

import numpy from numpy import *

import numpy as np
 Graficación en IPython

Creación de vectores y matrices:

La creación del array puede ser desde una lista:

A= np.array( [ [3,4,5] , [3,5,7] ] )

Para el curso principalmente nos importará crear vectores para graficar, que son los posibles
valores que nuestra variable en una función puede tomar, para esto hay dos formas.

x = np.linspace Pu to i icial , Pu to fi al , Nu ero de pu tos del vector

x = np.arange ( Pu to i icial , Pu to fi al-1 , Ta año de pasos
Se crearán dos vectores iguales con lso dos métodos.

A= np.linspace(2, 9, 8) x = np.arange(2, 10, 1)

[ 2. 3. 4. 5. 6. 7. 8. 9.]
 Graficación en IPython

Graficación 2D:
Para la gráficación debemos utilizar el módulo PyLab de matplotlib

import pylab

import pylab as ptr Import matplotlib.pylab as ptr

Debemos utilizar la función plot del paquete pylab, que recibe dos vectores que deben tener el
mismo tamaño. Finalmente para mostrar la gráfica en Ipython notebook se debe utilizar la función
show

A= [3,4,5,6,7]
B= [4,5,6,7,9]

ptr.plot(A,B)
ptr.show()
 Graficación en IPython

Graficación 2D:
Podemos darle estilo a nuestra grafica con las siguientes funciones:

A= np.linspace(-10,10,1000)
B= np.exp(-A**2)

ptr.plot(A,B,label="La campana")
ptr.title('Grafica de dos vectores')
ptr.xlim(-10,10)
ptr.ylim(0,2)
ptr.xlabel('Vector A')
ptr.ylabel('Vector B')
ptr.legend(loc="best")
ptr.show()
 Graficación en IPython

Graficación 2D:
Se puede graficar más de una función si se utilizar la función hold():

ptr.plot(A,B,label="La campana")
ptr.hold()
ptr.plot(B,A,label="La campana
inversa")
ptr.hold()

La función subplots nos permite crear varios ejes cartesianos para graficar, esta función nos
devuelve objetos correspondientes a cada eje, en este ejemplo son ax1,ax2:

fig, (ax1,ax2) = ptr.subplots(2,1)

 Graficación en IPython

Graficación 2D:
Cada uno de estos ejes es un objeto PyLab por lo que se pueden utilizar cada una de las funciones
previamente vistas, algunas con modificaciones en el nombre: set_xlabel, set_title.

fig, (ax1,ax2) = pt.subplots(2,1)

y=np.exp(-x**2)
ax1.plot(x,y,label="Primer cuadro")
ax1.legend()

y=x**5
ax2.plot(x,y,label="Segundo Cuadro")
ax2.legend()
 Graficación en IPython
Graficación 2D: Funciones implícitas
Hay funciones que no se pueden expresar como =
−
= +

Que se expresan como , = � en este caso

−
, = − − =

Para graficar esta función primero se debe crear un arreglo donde se pueda evaluar en la ecuación
, = � cada par coordenado deseado, este procedimiento se realiza con la función meshgrid.
Luego se grafica con la función contour de PyLab.
 Graficación en IPython
Graficación 2D: Funciones implícitas
y
¿Qué es un meshgrid?
5
(2,5) (3,5) (4,5) (5,5) (6,5) (7,5) (8,5) (9,5) Código:
x = np.arange(2, 10, 1)
4
(2,4) (3,4) (4,4) (5,4) (6,4) (7,4) (8,4) (9,4) y = np.arange(1, 6, 1)
X, Y = np.meshgrid(x,y)
3
(2,3) (3,3) (4,3) (5,3) (6,3) (7,3) (8,3) (9,3)

2
(2,2) (3,2) (4,2) (5,2) (6,2) (7,2) (8,2) (9,2)

1 x
(2,1) (3,1) (4,1) (5,1) (6,1) (7,1) (8,1) (9,1)
2 3 4 5 6 7 8 9
 Graficación en IPython
Graficación 2D: Funciones implícitas
A continuación el uso de la función contour:

pt.contour Arreglo de X’s proveniente del meshgrid , Arreglo de X’s proveniente del
meshgrid , Fu ció e terminos de X y Y , Arreglo de valores de C , Opcio es

Código:

x=np.linspace(-10,10,500)
y=np.linspace(-10,10,500)
X, Y = np.meshgrid(x, y)
ptr.contour(X, Y, X**2/2-Y**2-np.exp(-X*Y),[3,12,24])
 Graficación en IPython
Graficación 2D: Campo de pendientes
Básicamente es igual a graficar una función implícita, sólo que se hacen unas pequeñas
modificaciones para que sea más ilustrativo.
Para cualquier función que cumpla una ecuación diferencial de la forma

= ,
Para un punto �, � se puede graficar la pendiente como un vector que se origina en ese punto

Δ , , Se puede descomponer entonces

= en una componente en y otra
Δ en .
�, �

� =

� = ,
 Graficación en IPython
Graficación 2D: Campo de pendientes
=

Código:
Primero se crea � y � , a partir de ,

def f1(x,y):
return y/(2*x)

x = np.linspace(-10,10,10);
Y=x
X, Y = np.meshgrid(x, y)

U = 1;
V = f1(X,Y);
ptr.quiver(X,Y,U, V)
 Solución de E.D.
Solución simbólica:
Para esto se debe importa el paquete SymPy de cálculo simbólico:

from sympy import *

Las variables " " y " " dejan de ser vectores y se declaran como objetos symbols.
y = symbols('y', cls=Function)
x = symbols('x')

Se crea un objeto ecuación donde se escribe la E.D. luego se utiliza la función dsolve.

diffeq = Eq(y(x).diff(x,2)+2*y(x).diff(x)+2*y(x), exp(-x)+x**2+sin(x))

dsolve(diffeq, y(x))
 Solución de E.D.
Solución numérica de E.D.O de primer orden:
Se hace uso del paquete SciPy y su subpaquete integrate.

import scipy.integrate as sp

Para resolver la siguiente ecuación diferencial primero se debe crear un vector x, con el cual se
aplicará el método numérico. Luego se debe tener en cuenta que el primer valor de vector es el
punto de la condición inicial, en este caso � = , luego se debe declarar � = .

x = np.linspace(1,10,500) �
�
= cos − sin =
y0 =2

Se debe escribir la ecuación diferencial como una función de python:

def df(y,x):
return x*np.cos(x)**2-np.sin(y)
 Solución de E.D.
Solución numérica:
Finalmente se utiliza el método odeint, que nos retorna el vector de y, lo siguiente es graficarlo.

y=sp.odeint( df , y0 , x )
ptr.plot(x,y)
ptr.show()
 Solución de E.D.
Solución numérica de E.D.O de orden superior:
El procedimiento es muy similar, sólo se debe organizar la E.D.:
� �
+ + sin = = ′ =
� �
El P.V.I que vayamos a resolver debe tener la misma abscisa inicial, � = en este caso.
Se debe organizar de la siguiente manera, comenzando con al derivada de primer orden hasta el
orden de la E.D. menos 1.
=
�
= El objetivo es obtener una E.D. de primer orden para alguna variable nueva que
�
creemos.
+ + sin =
 Solución de E.D.
Solución numérica de E.D.O de orden superior:
�
=− − sin
�

En la función que llama el método odeint, la cual es la

ecuación diferencial que hemos organizado debemos def df(y,x):
asignar a y a a valores de y, debido a que así lo
y1, y2= y[0], y[1]
pide el método.
dy1=y2
Luego creamos un arreglo y0 donde están las dy2=-x*y2-20*sin(y1)
condiciones iniciales a utilizar y creamos el vector x.
return [dy1,dy2]

Ahora ya podemos ingresar esta ecuación en odeint.

y0 =[1,4]
x = linspace(0,6,500)
 Solución de E.D.
Solución numérica:
Finalmente se utiliza el método odeint, que nos retorna el vector de y el vector ′, lo siguiente es
graficarlo.

sol = odeint(df, y0, x)

y=sol[:,0]
yprima=sol[:,1]
ptr.plot(x,y)

print yprima[0] = 4.0

 Contenido
• Programación básica en IPython
• Módulos importantes para el curso
• Graficación en IPython
• Solución de O.D.E.
• Comandos de Maxima
• Interfaz de Maxima
• Matlab
 Introducción a maxima
Expresiones numéricas y simbólicas.
• Interfaz
 Graficación
Graficación en 2D
Se usa el comando plot2d

plot2d (plot, x_range, …, options, …

Plot puede ser nombre de una función o una lista de valores.

= sin

plot2d (sin(x), [x, -%pi, %pi])

 Graficación
Graficación de funciones implicitas
Se carga el comando implicit_plot

load(implicit_plot);

= +

implicit_plot (x^2 = y^2 +1, [x, -4, 4], [y, -4, 4]);
 Solucion E.D. Simbólica
Solucion E.D. Simbólica
Creamos una variables simbólica que va contener nuestra E.D.

ed: 'diff(y,x,2) + 2*'diff(y,x) + 2*y = x^2

Utilizamos el comando ode2 para hallar la solución:

ysol: ode2(ed,y,x);

Luego utilizamos las condiciones iniciales, para un valor de x,

ic2(ysol,x=0,y=0, 'diff(ysol,x)=0);
 Solucion E.D. Simbólica
Solucion E.D. Simbólica
Creamos una variables simbólica que va contener nuestra E.D.

ed: 'diff(f(x),x,2) + 2*'diff(f(x),x) + 2*f(x) = x^2

Si es un P.V.I debemos asignar las C.I. antes de aplicar desolve

atvalue(f(x),x=0,0)

atvalue('diff(f(x),x),x=0,0)

Utilizamos el comando desolve para hallar la solución:

ysol: desolve(ed,f(x));
 Solucion E.D. Numérica
Solucion E.D. numérica de primer orden
Se usa el comando rk(ode,var,initial, domain).
�
• En donde ode, es la ecuación despejada =�
�
• var es la variable a resolver.
• initial es la condición inicial.
• domain el vector del dominio de solución, [x, inicio, final, incremento].

Sol: rk(((y+x)/(y-x)),y,1,[x,3,10,0.1]);
• En Sol quedan los pares ordenados, es decir los valores de y agrupados, así que solo queda
graficar con plot2d, agregando el parámetro discrete.
The discrete form is used to plot a set of points with given coordinates.

plot2d([discrete,Sol]);
 Solucion E.D. Numérica
Solucion E.D. numérica de orden superior
Se debe organizar la ecuación diferencial de manera que cada derivada quede en términos de su
derivada superior.

� �
�
+ �
+ sin = = ′ =

=
�
= El objetivo es obtener una E.D. de primer orden para alguna variable nueva que
�
creemos.

+ + sin =
 Solucion E.D. Numérica
Solucion E.D. numérica de orden superior
Se usa el comando

rk ([ODE1,...,ODEm], [v1,...,vm], [init1,...,initm], dominio)

Similar al anterior, sólo es la descomposición de la ecuación diferencial de orden superior.

sol:rk([-x*y2-20*sin(y1),y2],[y2,y1],[1,0],[x,0,6,0.1])$

La solución entrega grupos de 3 valores: [x,y2,y1], nos interesa y1 y x por lo que lo organizamos
con el comando makelist. Luego podemos graficar y con el discrete y plot2d.

y:makelist([sol[k][1],sol[k][3]],k,1,length(sol))

plot2d([discrete,y]);
 Campo de pendientes
Graficación del campo de pendientes
�
Se debe despejar de la ecuación :
�

load(drawdf) drawdf(y^2/2)

10

-5

-10
-10 -5 0 5 10
 Campo de pendientes
Graficación del campo de pendientes
Es posible dibujar una trayectoria del campo de pendientes perteneciente a una solución
particular:
=

drawdf(2*y/x,[trajectory_at,1,1])

10

-5

-10
-10 -5 0 5 10
 Contenido
• Programación básica en IPython
• Módulos importantes para el curso
• Graficación en IPython
• Solución de O.D.E.
• Comandos de Maxima
• Interfaz de Maxima
• Matlab
 Matlab
Graficación
Una forma de graficar en matlab es mediante vectores y el comando plot.
Creamos un vector de cualquiera de las dos formas:
x = 0:pi/100:2*pi;

x = linspace(0,2*pi,200)

Creamos otro vector y en base a x

y = sin(x)

Finalmente graficamos con plot(x,y)

 Matlab
Graficación con variables simbólicas
Esta graficación es más sencilla y se usa por lo general cuando tenemos una expresión que no está
en formato de vectores:

ezplot('cos(x)'); ezplot('cos(x)‘,[-1,1]);
cos(x) cos(x)

1 1

0.95

0.9
0.5
0.85

0.8
0
0.75

0.7
-0.5
0.65

0.6
-1
0.55

-6 -4 -2 0 2 4 6 0.5
x -1 -0.8 -0.6 -0.4 -0.2 0 0.2 0.4 0.6 0.8 1
x
 Matlab
Solución de E.D.
La solución simbolica de una E.D. se hace mediante el uso del comando dsolve y la derivada de
orden N se expresa como DNy.

dsolve('D2y+Dy+y=0','x')

Para tener en cuenta las condiciones iniciales:

dsolve('D2y+Dy+y=0','y(1)=1','Dy(1)=0','x')
 Matlab
Solución de E.D. numérica
� �
10 + . + = = ′ = en x= (0,5)
� �

Organizando la ecuación para obtener una de primer orden:

� �� �� − − . 5�
�= 10 + . �+ = =
� � �
= � =

ode45(@odeFunction,tspan,x0)

Ahora definimos una función en matlab:

function dx = odeFunction(t,x)
y=x(1)
v=x(2)
dx=[v, (-0.05*v-12*y)/10]

= � =
[t,ysol]=ode45(@odeFunction,[0,5],[1,5])