sympy_cas

Vista previa del material en texto

El entorno sympy como CAS (del
inglés computer algebra system)
Los sistemas de álgebra computacional aparecieron al principio de 
la década de los 70, y evolucionaron a partir de la investigación en 
inteligencia artificial, aunque hoy en día constituyen campos 
ampliamente separados. Los primeros trabajos fueron dirigidos por 
el Premio Nobel Martin Veltman, quien diseñó en 1963 un programa 
para matemática simbólica, llamado Schoonship, especializado en 
Física de Altas Energías. Los primeros sistemas populares fueron 
Reduce y Macsyma. Hoy en día, una versión copyleft de Macsyma 
llamada Maxima es mantenida activamente. Posteriormente, en los 
años 1980 adquirió popularidad Derive (actualmente 
discontinuado). Los actuales líderes del mercado propietario son 
Maple y Mathematica; ambos son usados frecuentemente en 
ingeniería e investigaciones matemáticas.
SymPy es una biblioteca escrita en Python cuyo objetivo es reunir 
todas las características de un sistema de álgebra computacional 
(CAS), ser fácilmente extensible y mantener el código todo lo 
simple que sea posible. SymPy no requiere ninguna biblioteca 
externa, salvo para soporte gráfico.
Aspectos básicos
El alma del Cálculo Simbólico son, naturalmente, las variables 
simbólicas, que en SymPy son instancias de la clase Symbol. Una 
explicación intuitiva sería que, mientras que las variables ordinarias
tienen un valor que puede ser un número, una cadena, un valor 
verdadero / falso, una secuencia, etc. las variables simbólicas 
juegan el papel de contenedores: no sabemos a priori lo que 
pueden ser. En SymPy existe un entorno integrado para efectuar 
cálculos de manera interactiva que se conoce como isympy. 
hcaste@azul2:~$ isympy
IPython console for SymPy 0.7.6.1 (Python 2.7.12­64­bit) (ground types: gmpy)
These commands were executed:
>>> from __future__ import division
>>> from sympy import *
>>> x, y, z, t = symbols('x y z t')
>>> k, m, n = symbols('k m n', integer=True)
>>> f, g, h = symbols('f g h', cls=Function)
>>> init_printing()
Documentation can be found at http://www.sympy.org
In [1]: 
Veamos algunos aspectos claves:
En SymPy, todas las variables simbólicas que vayamos a utilizar se 
tienen que definir antes. Esto se realiza con el método constructor 
symbol(), este permite definir constantes, variables y funciones 
contenedoras.
Al definir una variable, podemos añadir una serie de suposiciones 
sobre ella (assumptions): por ejemplo, hemos dicho que "x, y, z, t" 
será de tipo complejo y que "k, m, n" serán tipo entero. Esto es 
muy importante a la hora de trabajar.
Como desconozco el valor numérico de los contenedores entonces 
su evaluación produce otro contenedor. 
Por ejemplo:
In [1]: cos(n * pi)
Out[1]: (­1) n
In [2]:  _ ** 2
Out[2]: 1
con la sobrecarga type se puede saber que tipo de contenedor se 
refiere:
In [4]: type(x)
Out[4]: sympy.core.symbol.Symbol
n [5]: type(n)
Out[5]: sympy.core.symbol.Symbol
In [6]: n=2
In [7]: type(n)
Out[7]: int
Nota: el objeto al cual le asigna symbol puede no coincidir con el 
nombre del contenedor, por ejemplo:
In [11]: d=symbols("c_v")
In [12]: d
Out[12]: cᵥ
Pero para evitar confusiones de inexperto, no conviene hacer esto.
Manipulación de expresiones numéricas
En el caso de números se pude definir un racional con el método 
Rational(,)
In [1]: a = Rational(1,3)
In [2]: print a
1/3
In [3]: print 3*a
1
In [4]: Rational(2)**50/Rational(10)**50
Out[4]: 1/88817841970012523233890533447265625
Nota: sympy por defecto toma la división entera a menos que se 
coloque la clausula from __future__ import division
Por defecto sympy no evalúa las constantes irracionales, esto se 
hace por medio del método evalf()
In [6]: pi**2
Out[6]: π2 
In [8]: pi.evalf()
Out[8]: 3.14159265358979
Existe el objeto numérico llamado infinito, y se lo representa como
oo
In [9]: oo > 99999
Out[9]: True
In [10]: oo + 1
Out[10]: ∞
Manipulación de expresiones
Para manipular expresiones algebraicas que involucren variables 
simbólicas en SymPy hay tres herramientas básicas: la sustitución,
las funciones de simplificación, expansión y las suposiciones. 
Sustitución
El método subs(old, new) permite modificar un contenedor por otro 
o por un tipo numérico
In [11]: ((x+y)**2).subs(x, 1)
Out[11]: (y + 1) 2
In [12]: ((x+y)**2).subs(x, y)
Out[12]: 4 y⋅ 2
Expansiones
Por defecto sympy no expande una expresión a menos que se use 
el método expand()
In [13]: (x+y)**2
Out[13]: (x + y) 2
In [14]: ((x+y)**2).expand()
Out[14]: x2 + 2 x y + y⋅ ⋅ 2 
Simplificación 
Sympy cuando puede simplifica
In [26]: x+y+x-y
Out[26]: 2 x⋅
SymPy pone a nuestra disposición multitud de métodos para 
reescribir las expresiones en una forma que nos sea más cómoda o 
que nos aporte algún tipo de beneficio. Estos pertenecen a la clase 
class sympy.core.expr.Expr, por ejemplo apart(expr, x) permite 
descomponer en fracciones simples
In [27]: apart(1/( (x+2)*(x+1) ), x)
Out[27]: −
1
x+2
+
1
x+1
together(expr, x) permite unir en mínimo común múltiplo 
fracciones racionales
In [28]: together(1/x + 1/y + 1/z)
Out[28]: 
x y+x z+ y x
x y z
cancel() simplifica una función racional
In [29]: cancel((1 - x ** 2) / (1 + x))
Out[29]: -x + 1
expand_trig() expande una expresión trigonométrica
In [30]: expand_trig(cos(3*x))
Out[30]: 4 cos⋅ 3 (x) - 3 cos(x)⋅
In [31]: expand(cos(3 * x), trig=True) #equivalente
Out[31]: 4 cos⋅ 3 (x) - 3 cos(x)⋅
En resumen un conjunto de métodos útiles
In [32]: (1 + I) * (1 + sin(x))
Out[32]: (1 + ) (sin(x) + 1)ⅈ ⋅
In [33]: expand(_) # Hace los productos y expande la expresión
Out[33]: sin(x) + sin(x) + 1 + ⅈ⋅ ⅈ
In [34]: collect(_, sin(x)) # Saca factor común
Out[34]: (1 + ) sin(x) + 1 + ⅈ ⋅ ⅈ
In [35]: _.subs(1 + I, t) # Voy a hacer un cambio de variable para que sea más 
sencillo
Out[35]: t sin(x) + t⋅
Suposiciones
Las suposiciones(assumptions en inglés) afectan directamente a 
cómo trata SymPy a los contenedores en cuestión (que llamaremos 
para no entrar en confusión variales simbólicas).
• Para imponer que la variable cumple ciertas propiedades en el 
momento de la creación se utilizan los argumentos positive, 
real, etc. en el constructor, indicando su valor de verdadero o 
falso. 
• Por otro lado, para simplificar una expresión a posteriori con 
nuevas suposiciones hemos de utilizar la clase Q del módulo 
assumptions. 
• Para comprobar si una variable o expresión cumple 
determinadas propiedades, tendremos que utilizar las 
funciones is_real, is_integer, etc. 
In [15]: n.is_integer # indica que el contenedor se supone entero
Out[15]: True
In [17]: sqrt(x ** 2)
Out[17]: √( x) # si no se asume nada no se hace nada
In [18]: (sqrt(x ** 2)).refine(Q.real(x)) #se reasume real
Out[18]: x│ │
In [20]: (sqrt(x ** 2)).refine(Q.positive(x)) #se reasume real y positivo
Out[20]: x
Cálculos
Como buen paquete de cálculo simbólico que es, Sympy ofrece 
numerosas posibilidades para realizar tareas comunes del cálculo 
infinitesimal, como son calcular límites, derivadas, series e 
integrales simbólicas.
Límites
Para calcular límites simbólicos con SymPy se utiliza la función 
limit. Podemos calcular el límite de casi cualquier expresión, con 
una o varias variables y por las dos direcciones
In [37]: limit(1 / x, x, oo)
Out[37]: 0
In [38]: limit(sin(x) / x, x, 0)
Out[38]: 1
In [39]: limit(tan(x), x, pi / 2) # como es indeterminado toma una dirección
Out[39]: -∞
In [40]: limit(tan(x), x, pi / 2, dir='+')
Out[40]: -∞
In [41]: limit(tan(x), x, pi / 2, dir='-')
Out[41]: ∞
Derivadas
Para calcular la derivada simbólica en SymPy (esto es: la función 
derivada) se usa la función diff o el método .diff de una expresión. 
Esta admite varias sintaxis para indicar las variables y el orden de 
las derivadas
In [43]: diff(_42, x) # Derivada primera con respecto a x
Out[43]: -(x + 1) sin(x) + cos(x)⋅
In [44]: diff(_42, x, 2) # Derivada segunda con respecto a x
Out[44]: -((x + 1) cos(x) + 2 sin(x))⋅ ⋅
In [45]: diff(x * y * log(x * y), x, y) # Derivada parcial con respectoa x e 
yOut[45]: log(x y) + 2⋅
In [46]: diff(f(x) * sin(x), x) #derivada de funciones implicitas
Out[46]: f (x)cos (x)+sin (x) d
d x
f (x)
Esto último fue posible gracias a que previamente se definió f, g, h =
symbols('f g h', cls=Function). 
Series
Para calcular desarrollos en series de potencias en SymPy 
utilizamos la función series o el método .series de una expresión
In [47]: cos(x).series(x) # Por defecto, desarrollo en torno al 0 con 
n = 6 términos
Out[47]: 1−
x2
2
+
x4
24
+o(x6)
In [48]: log(z).series(z, 1, n=5) # Desarrollo en torno a z = 1 
Out[48]: −1−
(z−1)2
2
+
(z−1)3
3
−
(z−1)4
4
+o((z−1)5 ; z→1)
Integrales
Para calcular integrales definidas e indefinidas con SymPy 
emplearemos la función integrate. Esta utiliza el algoritmo de 
Risch-Norman extendido más algunas reglas heurísticas y búsqueda
de patrones. En matemática el algoritmo de Risch, nombrado en 
honor a Robert H. Risch, es un algoritmo utilizado para el cálculo de 
integrales indefinidas (es decir, encontrar la función primitiva de 
una función dada).Risch desarrolló el algoritmo en 1968, 
denominándolo un procedimiento de decisión, porque es un método
para decidir si una función posee como integral indefinida una 
función elemental; y en el caso que la tuviera permite calcularla. En
1976 se desarrolló el algoritmo de Risch-Norman, que aunque es 
más rápido es una técnica menos poderosa.
In [49]: integrate(6 * x ** 5, x)
Out[49]: x6 
In [50]: integrate(x * log(x), x)
Out[50]: 
x2 log(x)
2
−
x2
4
In [51]: integrate(exp(-x ** 2), x)
Out[51]: 
√π erf (x)
2
También podemos efectuar integrales definidas, tanto propias como
impropias
In [52]: integrate(log(x), (x, 0, 1))
Out[52]: -1
Resolución de ecuaciones
SymPy es capaz de resolver ecuaciones algebraicas de una o varias 
variables
In [53]: solve(x**4 - 1, x)
Out[53]: [-1, 1, - , ]ⅈ ⅈ
Es capaz de resolver múltiples ecuaciones respecto a múltiples 
variables (sistemas de ecuaciones) proporcionando una tupla como 
segundo argumento
In [54]: solve([x + 5*y - 2, -3*x + 6*y - 15], [x, y])
Out[54]: {x: -3, y: 1}
También tiene capacidad (limitada) de resolver ecuaciones 
transcendentales
In [55]: solve(exp(x) + 1, x)
Out[55]: [ π]ⅈ⋅
Ecuaciones diferenciales
SymPy es capaz de resolver (algunas) ecuaciones diferenciales 
ordinarias, dsolve() funciona de la siguiente forma
In [56]: dsolve(f(x).diff(x, x) + f(x), f(x))
Out[56]: f(x) = C sin(x) + C cos(x)₁⋅ ₂⋅
Álgebra lineal
Las Matrices se crean como instancias de la clase Matrix
 Matrix([[1,0], [0,1]])
Out[58]: [1 00 1]
In [59]: A = Matrix([[1,x], [y,1]])
In [60]: A**2
Out[60]: [x y+1 2 x2 y x y+1]
	Aspectos básicos
	Manipulación de expresiones numéricas
	Manipulación de expresiones
	Sustitución
	Expansiones
	Simplificación
	Suposiciones
	Cálculos
	Límites
	Derivadas
	Series
	Integrales
	Resolución de ecuaciones
	Ecuaciones diferenciales
	Álgebra lineal