Sympy¶
Módulo de Python de computación simbólica, permite mostrar resultados de forma exacta y no aproximada como estan definidas por defecto y permite realizar operaciones con variables que no tienen un valor definido.
In [1]:
# Importación de la librería sympy
import sympy
Operaciones básicas¶
Normalmente una operación en Python arroja un resultado aproximado, cuyas cifras dependen del tipo de dato. Se hace una comparación entre algunas operaciones matemáticas con sympy y con la librería math.
Raiz cuadrada
In [2]:
import math
math.sqrt(8)
Out[2]:
2.8284271247461903
In [3]:
sympy.sqrt(8)
Out[3]:
2*sqrt(2)
Logaritmo natural
In [4]:
sympy.log(2)
Out[4]:
log(2)
In [5]:
math.log(2)
Out[5]:
0.6931471805599453
Infinito
In [6]:
from sympy import oo
In [7]:
oo + 1
Out[7]:
oo
In [8]:
34534535453 < oo
Out[8]:
True
In [9]:
34534 / oo
Out[9]:
0
In [10]:
oo / oo
Out[10]:
nan
In [11]:
type(oo)
Out[11]:
sympy.core.numbers.Infinity
Números racionales¶
In [12]:
number = sympy.S('3/4')
number
Out[12]:
3/4
In [13]:
2 * number
Out[13]:
3/2
Evaluación de expresiones¶
Para mostrar el resultado como número real se usa la función evalf( )
In [14]:
number.evalf()
Out[14]:
0.750000000000000
Definición de variables¶
Normalmente para realizar un operación con una variable, esta debe estar definida antes. Sympy permite realizar operaciones con variables sin tener su valor exacto, pero para no causar errores en Python se debe indicar que es una variable de sympy.
In [15]:
# Python reconoce x como una variable de sympy y ahora permite realizar
# operaciones con esta sin tener asignado un valor numérico
x = sympy.symbols('x')
In [16]:
x**2 + 4*x + 1
Out[16]:
x**2 + 4*x + 1
In [17]:
x+4*x
Out[17]:
5*x
In [18]:
x**4/x**2
Out[18]:
x**2
Para definir varias variables
In [19]:
r, y = sympy.symbols('r y')
In [20]:
2*r + y + 5*r - 4*y
Out[20]:
7*r - 3*y
Sustituir variables¶
Luego de definida una variable se generan expresiones al hacer operaciones con estas. El valor de la variable de sympy puede ser sustituida en cualquier momento y obtener el valor de la expresión. Para esto se usa el método subs( )
In [21]:
x = sympy.symbols('x')
# Se define la expresión
expr = x**4 - 1
expr
Out[21]:
x**4 - 1
In [22]:
# Se reemplaza x por 2
expr.subs(x, 2)
Out[22]:
15
In [23]:
expr = sympy.sin(x) + sympy.tan(x)
In [24]:
expr.subs(x, 0.5)
Out[24]:
1.02572802844799
Para una sustitución en expresiones con mas de una variable se puede usar un diccionario especificando los valores algunas o todas las variables.
In [25]:
a, b = sympy.symbols('a, b')
x = a + b
In [26]:
x.subs({a:2})
Out[26]:
b + 2
In [27]:
x.subs({a:2, b:4})
Out[27]:
6
Simplificación¶
In [28]:
# Se definen las variables
x, y = sympy.symbols('x y')
In [29]:
sympy.simplify(sympy.sqrt(8*x*3))
Out[29]:
2*sqrt(6)*sqrt(x)
In [30]:
sympy.simplify(sympy.cos(x)**2 + sympy.sin(x)**2)
Out[30]:
1
In [31]:
sympy.simplify((x**4 + 5 * x**3 - 2 * x**2 + x)/(x**2 + x))
Out[31]:
(x**3 + 5*x**2 - 2*x + 1)/(x + 1)
In [32]:
sympy.S((x**4 + 5 * x**3 - 2 * x**2 + x)/(x**2 + x))
Out[32]:
(x**4 + 5*x**3 - 2*x**2 + x)/(x**2 + x)
Solución de ecuaciones con Sympy¶
La sintaxis para resolver una expresión algebraica con sympy consiste en usar la librería solve y en paréntesis usar la expresión y luego la incógnita:
solve(expresión a resolver, incógnita).
Algunos ejemplos de solución de ecuaciones con sympy:
solve(expresión a resolver, incógnita).
Algunos ejemplos de solución de ecuaciones con sympy:
$2x-1=0$
In [33]:
from sympy.solvers import solve
solve(2*x-1, x)
Out[33]:
[1/2]
$2x^{2}+4x-6=0$
In [34]:
solve(2*x**2 + 4*x - 6, x)
Out[34]:
[-3, 1]
$x+y=1$
$xy=-20$
$xy=-20$
In [35]:
eq1 = x + 2*y - 1
eq2 = x*y + 20
sol = solve((eq1, eq2), (x, y))
In [36]:
print sol
[(1/2 + sqrt(161)/2, -sqrt(161)/4 + 1/4), (-sqrt(161)/2 + 1/2, 1/4 + sqrt(161)/4)]
In [37]:
[[x.evalf(), y.evalf()] for x, y in sol]
Out[37]:
[[6.84428877022476, -2.92214438511238], [-5.84428877022476, 3.42214438511238]]
Polinomios¶
Expansión¶
Expandir el polinomio
$P = (m-1)(m-6)(m-5)$
$P = (m-1)(m-6)(m-5)$
In [38]:
p = sympy.simplify('(m-1)*(m-6)*(m-5)')
print p
(m - 6)*(m - 5)*(m - 1)
In [39]:
p_exp = p.expand()
p_exp
Out[39]:
m**3 - 12*m**2 + 41*m - 30
Factorización¶
Se toma el polinomio anterior expandido y se factoriza usando el método factor( )
In [40]:
p_exp.factor()
Out[40]:
(m - 6)*(m - 5)*(m - 1)
Solución de la ecuación igualada a cero
In [41]:
solve(p, 'm')
Out[41]:
[1, 5, 6]
Note que al no haber definido m como una variable de sympy, al momento de reemplazar debe indicarse 'm' (como un string), de otra forma resulta un error porque la variable m no ha sido definida para el intérprete de Python.
raices¶
Se obtienen las raices del polinomio p igualado a cero
In [42]:
sympy.roots(p, multiple=True)
Out[42]:
[1, 5, 6]
Igualdad de expresiones¶
Se toman dos expresiones iguales:
In [43]:
m = sympy.symbols('m')
p = (m-1)*(m-6)*(m-5)
r = m**3 - 12*m**2 + 41*m - 30
Se sabe entonces que p es la expresión r factorizada, pero si se compara con el igual de Python (==) no las identifica como dos expresiones iguales
In [44]:
p == r
Out[44]:
False
In [45]:
p - r == 0
Out[45]:
False
Para hacer esta comparación se usa la función simplify
In [46]:
sympy.simplify(p - r) == 0
Out[46]:
True
