Sympy¶
Introducción¶
Hay dos sistemas de álgebra computarizada (CAS) notables para Python:
SymPy: un módulo de Python que se puede utilizar en cualquier programa de Python, o en una sesión de IPython, que proporciona potentes funciones de CAS.
Sage - Sage es un entorno CAS muy potente y con todas las funciones que tiene como objetivo proporcionar un sistema de código abierto que compita con Mathematica y Maple. Sage no es un módulo Python normal, sino un entorno CAS que utiliza Python como lenguaje de programación.
Sage es en algunos aspectos más poderoso que SymPy, pero ambos ofrecen una funcionalidad CAS muy completa. La ventaja de SymPy es que es un módulo Python normal y se integra bien con el portátil IPython.
Para comenzar a usar SymPy en un programa o cuaderno de Python, importe el módulo sympy:
from sympy import *
---------------------------------------------------------------------------
ModuleNotFoundError Traceback (most recent call last)
<ipython-input-1-a03f9816da30> in <module>
----> 1 from sympy import *
ModuleNotFoundError: No module named 'sympy'
Para obtener una salida con formato LATEX atractiva, ejecute:
init_printing()
# or with older versions of sympy/ipython, load the IPython extension
#%load_ext sympy.interactive.ipythonprinting
# or
#%load_ext sympyprinting
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-2-b0fddb2e1ad1> in <module>
----> 1 init_printing()
2
3 # or with older versions of sympy/ipython, load the IPython extension
4 #%load_ext sympy.interactive.ipythonprinting
5 # or
NameError: name 'init_printing' is not defined
Variables simbólicas¶
En SymPy necesitamos crear símbolos para las variables con las que queremos trabajar. Podemos crear un nuevo símbolo usando la clase Symbol:
x = Symbol('x')
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-3-7558e6db5e90> in <module>
----> 1 x = Symbol('x')
NameError: name 'Symbol' is not defined
(pi + x)**2
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-4-7bb65e1bf95d> in <module>
----> 1 (pi + x)**2
NameError: name 'pi' is not defined
# alternative way of defining symbols
a, b, c = symbols("a, b, c")
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-5-364548348ad5> in <module>
1 # alternative way of defining symbols
----> 2 a, b, c = symbols("a, b, c")
NameError: name 'symbols' is not defined
type(a)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-6-b152ec05ccbc> in <module>
----> 1 type(a)
NameError: name 'a' is not defined
Podemos agregar suposiciones a los símbolos cuando los creamos:
x = Symbol('x', real=True)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-7-c1dc293cb047> in <module>
----> 1 x = Symbol('x', real=True)
NameError: name 'Symbol' is not defined
x.is_imaginary
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-8-d874b18bf116> in <module>
----> 1 x.is_imaginary
NameError: name 'x' is not defined
x = Symbol('x', positive=True)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-9-e1006826df4b> in <module>
----> 1 x = Symbol('x', positive=True)
NameError: name 'Symbol' is not defined
x > 0
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-10-11039dfd6b87> in <module>
----> 1 x > 0
NameError: name 'x' is not defined
Números complejos¶
La unidad imaginaria se denota “I” en Sympy.
1+1*I
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-11-ecaecbc988c3> in <module>
----> 1 1+1*I
NameError: name 'I' is not defined
I**2
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-12-2917383a4f4e> in <module>
----> 1 I**2
NameError: name 'I' is not defined
(x * I + 1)**2
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-13-5afdd492776d> in <module>
----> 1 (x * I + 1)**2
NameError: name 'x' is not defined
Numeros racionales¶
Hay tres tipos numéricos diferentes en SymPy: Real, Rational, ʻInteger`:
r1 = Rational(4,5)
r2 = Rational(5,4)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-14-f1c511921ff4> in <module>
----> 1 r1 = Rational(4,5)
2 r2 = Rational(5,4)
NameError: name 'Rational' is not defined
r1
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-15-d502f2d87627> in <module>
----> 1 r1
NameError: name 'r1' is not defined
r1+r2
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-16-a3226ca875b9> in <module>
----> 1 r1+r2
NameError: name 'r1' is not defined
r1/r2
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-17-0f227dc3e89a> in <module>
----> 1 r1/r2
NameError: name 'r1' is not defined
Evaluación numérica¶
SymPy usa una biblioteca para precisión artística como backend numérico, y tiene expresiones SymPy predefinidas para una serie de constantes matemáticas, como: pi, ʻe, ʻoo para infinito.
Para evaluar una expresión numéricamente podemos usar la función evalf (o N). Toma un argumento “n” que especifica el número de dígitos significativos.
pi.evalf(n=50)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-18-40346f710e81> in <module>
----> 1 pi.evalf(n=50)
NameError: name 'pi' is not defined
y = (x + pi)**2
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-19-05ddcb3351e1> in <module>
----> 1 y = (x + pi)**2
NameError: name 'x' is not defined
N(y, 5) # same as evalf
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-20-eeb27bc0a2d2> in <module>
----> 1 N(y, 5) # same as evalf
NameError: name 'N' is not defined
Cuando evaluamos numéricamente expresiones algebraicas, a menudo queremos sustituir un símbolo por un valor numérico. En SymPy lo hacemos usando la función subs:
y.subs(x, 1.5)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-21-34a2c4873a25> in <module>
----> 1 y.subs(x, 1.5)
NameError: name 'y' is not defined
N(y.subs(x, 1.5))
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-22-0902ad8773b3> in <module>
----> 1 N(y.subs(x, 1.5))
NameError: name 'N' is not defined
Por supuesto, la función subs también se puede utilizar para sustituir símbolos y expresiones:
y.subs(x, a+pi)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-23-1aa365e1c30c> in <module>
----> 1 y.subs(x, a+pi)
NameError: name 'y' is not defined
También podemos combinar la evolución numérica de expresiones con matrices Numpy:
import numpy
import matplotlib.pyplot as plt
x_vec = numpy.arange(0, 10, 0.1)
y_vec = numpy.array([N(((x + pi)**2).subs(x, xx)) for xx in x_vec])
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-26-55617d5250d0> in <module>
----> 1 y_vec = numpy.array([N(((x + pi)**2).subs(x, xx)) for xx in x_vec])
<ipython-input-26-55617d5250d0> in <listcomp>(.0)
----> 1 y_vec = numpy.array([N(((x + pi)**2).subs(x, xx)) for xx in x_vec])
NameError: name 'N' is not defined
fig, ax = plt.subplots()
ax.plot(x_vec, y_vec);
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-27-18c01a3ab0f9> in <module>
1 fig, ax = plt.subplots()
----> 2 ax.plot(x_vec, y_vec);
NameError: name 'y_vec' is not defined
Sin embargo, este tipo de evolución numérica puede ser muy lenta, y hay una manera mucho más eficiente de hacerlo: use la función lambdify para” compilar “una expresión Sympy en una función que sea mucho más eficiente para evaluar numéricamente:
f = lambdify([x], (x + pi)**2, 'numpy') # the first argument is a list of variables that
# f will be a function of: in this case only x -> f(x)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-28-6d4989e762f0> in <module>
----> 1 f = lambdify([x], (x + pi)**2, 'numpy') # the first argument is a list of variables that
2 # f will be a function of: in this case only x -> f(x)
NameError: name 'lambdify' is not defined
y_vec = f(x_vec) # now we can directly pass a numpy array and f(x) is efficiently evaluated
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-29-02e3c48fbd2e> in <module>
----> 1 y_vec = f(x_vec) # now we can directly pass a numpy array and f(x) is efficiently evaluated
NameError: name 'f' is not defined
La aceleración cuando se utilizan funciones lambdify en lugar de una evaluación numérica directa puede ser significativa, a menudo de varios órdenes de magnitud. Incluso en este ejemplo simple obtenemos una velocidad significativa:
%%timeit
y_vec = numpy.array([N(((x + pi)**2).subs(x, xx)) for xx in x_vec])
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-30-1c1dd8f88b09> in <module>
----> 1 get_ipython().run_cell_magic('timeit', '', '\ny_vec = numpy.array([N(((x + pi)**2).subs(x, xx)) for xx in x_vec])\n')
~/.cache/pypoetry/virtualenvs/mat281-2021-V7B8LTfe-py3.8/lib/python3.8/site-packages/IPython/core/interactiveshell.py in run_cell_magic(self, magic_name, line, cell)
2401 with self.builtin_trap:
2402 args = (magic_arg_s, cell)
-> 2403 result = fn(*args, **kwargs)
2404 return result
2405
~/.cache/pypoetry/virtualenvs/mat281-2021-V7B8LTfe-py3.8/lib/python3.8/site-packages/decorator.py in fun(*args, **kw)
230 if not kwsyntax:
231 args, kw = fix(args, kw, sig)
--> 232 return caller(func, *(extras + args), **kw)
233 fun.__name__ = func.__name__
234 fun.__doc__ = func.__doc__
~/.cache/pypoetry/virtualenvs/mat281-2021-V7B8LTfe-py3.8/lib/python3.8/site-packages/IPython/core/magic.py in <lambda>(f, *a, **k)
185 # but it's overkill for just that one bit of state.
186 def magic_deco(arg):
--> 187 call = lambda f, *a, **k: f(*a, **k)
188
189 if callable(arg):
~/.cache/pypoetry/virtualenvs/mat281-2021-V7B8LTfe-py3.8/lib/python3.8/site-packages/IPython/core/magics/execution.py in timeit(self, line, cell, local_ns)
1167 for index in range(0, 10):
1168 number = 10 ** index
-> 1169 time_number = timer.timeit(number)
1170 if time_number >= 0.2:
1171 break
~/.cache/pypoetry/virtualenvs/mat281-2021-V7B8LTfe-py3.8/lib/python3.8/site-packages/IPython/core/magics/execution.py in timeit(self, number)
167 gc.disable()
168 try:
--> 169 timing = self.inner(it, self.timer)
170 finally:
171 if gcold:
<magic-timeit> in inner(_it, _timer)
<magic-timeit> in <listcomp>(.0)
NameError: name 'N' is not defined
%%timeit
y_vec = f(x_vec)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-31-395cef115f11> in <module>
----> 1 get_ipython().run_cell_magic('timeit', '', '\ny_vec = f(x_vec)\n')
~/.cache/pypoetry/virtualenvs/mat281-2021-V7B8LTfe-py3.8/lib/python3.8/site-packages/IPython/core/interactiveshell.py in run_cell_magic(self, magic_name, line, cell)
2401 with self.builtin_trap:
2402 args = (magic_arg_s, cell)
-> 2403 result = fn(*args, **kwargs)
2404 return result
2405
~/.cache/pypoetry/virtualenvs/mat281-2021-V7B8LTfe-py3.8/lib/python3.8/site-packages/decorator.py in fun(*args, **kw)
230 if not kwsyntax:
231 args, kw = fix(args, kw, sig)
--> 232 return caller(func, *(extras + args), **kw)
233 fun.__name__ = func.__name__
234 fun.__doc__ = func.__doc__
~/.cache/pypoetry/virtualenvs/mat281-2021-V7B8LTfe-py3.8/lib/python3.8/site-packages/IPython/core/magic.py in <lambda>(f, *a, **k)
185 # but it's overkill for just that one bit of state.
186 def magic_deco(arg):
--> 187 call = lambda f, *a, **k: f(*a, **k)
188
189 if callable(arg):
~/.cache/pypoetry/virtualenvs/mat281-2021-V7B8LTfe-py3.8/lib/python3.8/site-packages/IPython/core/magics/execution.py in timeit(self, line, cell, local_ns)
1167 for index in range(0, 10):
1168 number = 10 ** index
-> 1169 time_number = timer.timeit(number)
1170 if time_number >= 0.2:
1171 break
~/.cache/pypoetry/virtualenvs/mat281-2021-V7B8LTfe-py3.8/lib/python3.8/site-packages/IPython/core/magics/execution.py in timeit(self, number)
167 gc.disable()
168 try:
--> 169 timing = self.inner(it, self.timer)
170 finally:
171 if gcold:
<magic-timeit> in inner(_it, _timer)
NameError: name 'f' is not defined
Manipulaciones algebraicas¶
Uno de los usos principales de un CAS es realizar manipulaciones algebraicas de expresiones. Por ejemplo, podríamos querer expandir un producto, factorizar una expresión o simplemente una expresión. Las funciones para realizar estas operaciones básicas en SymPy se muestran en esta sección.
Expandir y factorizar¶
Los primeros pasos en una manipulación algebraica
(x+1)*(x+2)*(x+3)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-32-b23b02f5c4bd> in <module>
----> 1 (x+1)*(x+2)*(x+3)
NameError: name 'x' is not defined
expand((x+1)*(x+2)*(x+3))
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-33-59f5088160c1> in <module>
----> 1 expand((x+1)*(x+2)*(x+3))
NameError: name 'expand' is not defined
La función expand toma un número de argumentos de palabras clave que podemos decirle a las funciones qué tipo de expansiones queremos que se realicen. Por ejemplo, para expandir expresiones trigonométricas, use el argumento de palabra clave trig = True:
sin(a+b)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-34-0f89e4790ea2> in <module>
----> 1 sin(a+b)
NameError: name 'sin' is not defined
expand(sin(a+b), trig=True)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-35-62fd14a1559c> in <module>
----> 1 expand(sin(a+b), trig=True)
NameError: name 'expand' is not defined
Consulte help (expand) para obtener una explicación detallada de los distintos tipos de expansiones que pueden realizar las funciones de ʻexpand`.
Lo contrario, una expansión de producto es, por supuesto, factorización. El factor de una expresión en SymPy usa la función factor:
factor(x**3 + 6 * x**2 + 11*x + 6)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-36-c086203fdb24> in <module>
----> 1 factor(x**3 + 6 * x**2 + 11*x + 6)
NameError: name 'factor' is not defined
Simplificar¶
El “simplificar” intenta simplificar una expresión en una expresión agradable, utilizando varias técnicas. También existen alternativas más específicas a las funciones simplify: trigsimp, powsimp, logcombine, etc.
Los usos básicos de estas funciones son los siguientes:
# simplify expands a product
simplify((x+1)*(x+2)*(x+3))
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-37-28c28fae36bf> in <module>
1 # simplify expands a product
----> 2 simplify((x+1)*(x+2)*(x+3))
NameError: name 'simplify' is not defined
# simplify uses trigonometric identities
simplify(sin(a)**2 + cos(a)**2)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-38-9df6d0e02e1d> in <module>
1 # simplify uses trigonometric identities
----> 2 simplify(sin(a)**2 + cos(a)**2)
NameError: name 'simplify' is not defined
simplify(cos(x)/sin(x))
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-39-383a75e64d2a> in <module>
----> 1 simplify(cos(x)/sin(x))
NameError: name 'simplify' is not defined
Separados y juntos¶
Para manipular expresiones simbólicas de fracciones, podemos usar las funciones apart y together:
apart
f1 = 1/((a+1)*(a+2))
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-40-cf0d0ee48cb3> in <module>
----> 1 f1 = 1/((a+1)*(a+2))
NameError: name 'a' is not defined
f1
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-41-aece6dfba588> in <module>
----> 1 f1
NameError: name 'f1' is not defined
apart(f1)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-42-91fa4737e079> in <module>
----> 1 apart(f1)
NameError: name 'apart' is not defined
together
f2 = 1/(a+2) + 1/(a+3)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-43-5ee87f638ebe> in <module>
----> 1 f2 = 1/(a+2) + 1/(a+3)
NameError: name 'a' is not defined
f2
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-44-1c49a440c352> in <module>
----> 1 f2
NameError: name 'f2' is not defined
together(f2)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-45-446be11658c7> in <module>
----> 1 together(f2)
NameError: name 'together' is not defined
Simplificar generalmente combina fracciones pero no factoriza:
simplify(f2)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-46-5394828ce0d4> in <module>
----> 1 simplify(f2)
NameError: name 'simplify' is not defined
Cálculo¶
Además de las manipulaciones algebraicas, el otro uso principal de CAS es hacer cálculo, como derivadas e integrales de expresiones algebraicas.
Diferenciación¶
La diferenciación suele ser sencilla. Utilice la función diff. El primer argumento es la expresión para tomar la derivada y el segundo argumento es el símbolo por el cual tomar la derivada:
y
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-47-9063a9f0e032> in <module>
----> 1 y
NameError: name 'y' is not defined
diff(y**2, x)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-48-0d3f8ce09e5d> in <module>
----> 1 diff(y**2, x)
NameError: name 'diff' is not defined
Para derivados de orden superior podemos hacer:
diff(y**2, x, x)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-49-fac872697a7b> in <module>
----> 1 diff(y**2, x, x)
NameError: name 'diff' is not defined
diff(y**2, x, 2) # same as above
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-50-bad3ff488e03> in <module>
----> 1 diff(y**2, x, 2) # same as above
NameError: name 'diff' is not defined
Para calcular la derivada de una expresión multivariante, podemos hacer:
x, y, z = symbols("x,y,z")
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-51-3c3883d07bb3> in <module>
----> 1 x, y, z = symbols("x,y,z")
NameError: name 'symbols' is not defined
f = sin(x*y) + cos(y*z)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-52-26b73e49a569> in <module>
----> 1 f = sin(x*y) + cos(y*z)
NameError: name 'sin' is not defined
d3fdxdy2
diff(f, x, 1, y, 2)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-53-6dfe75c5ec01> in <module>
----> 1 diff(f, x, 1, y, 2)
NameError: name 'diff' is not defined
Integración¶
La integración se realiza de manera similar:
f
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-54-a9fcd54b25e7> in <module>
----> 1 f
NameError: name 'f' is not defined
integrate(f, x)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-55-f992ad274d12> in <module>
----> 1 integrate(f, x)
NameError: name 'integrate' is not defined
Al proporcionar límites para la variable de integración, podemos evaluar integrales definidas:
integrate(f, (x, -1, 1))
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-56-6ea08d365097> in <module>
----> 1 integrate(f, (x, -1, 1))
NameError: name 'integrate' is not defined
y también integrales impropias:
integrate(exp(-x**2), (x, -oo, oo))
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-57-144b4fae98e2> in <module>
----> 1 integrate(exp(-x**2), (x, -oo, oo))
NameError: name 'integrate' is not defined
Recuerde, oo es la notación SymPy para infinito.
Sumas y productos¶
Podemos evaluar sumas y productos usando las funciones: ‘Suma’
n = Symbol("n")
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-58-50e31fb0a310> in <module>
----> 1 n = Symbol("n")
NameError: name 'Symbol' is not defined
Sum(1/n**2, (n, 1, 10))
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-59-7be98b8443e5> in <module>
----> 1 Sum(1/n**2, (n, 1, 10))
NameError: name 'Sum' is not defined
Sum(1/n**2, (n,1, 10)).evalf()
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-60-5747c8ee32b2> in <module>
----> 1 Sum(1/n**2, (n,1, 10)).evalf()
NameError: name 'Sum' is not defined
Sum(1/n**2, (n, 1, oo)).evalf()
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-61-64cbfba1354c> in <module>
----> 1 Sum(1/n**2, (n, 1, oo)).evalf()
NameError: name 'Sum' is not defined
Los productos funcionan de la misma manera:
Product(n, (n, 1, 10)) # 10!
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-62-601e839b0974> in <module>
----> 1 Product(n, (n, 1, 10)) # 10!
NameError: name 'Product' is not defined
Límites¶
Los límites se pueden evaluar utilizando la función limit. Por ejemplo,
limit(sin(x)/x, x, 0)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-63-4637b3b92d37> in <module>
----> 1 limit(sin(x)/x, x, 0)
NameError: name 'limit' is not defined
Podemos usar limit para verificar el resultado de la derivación usando la función diff:
f
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-64-a9fcd54b25e7> in <module>
----> 1 f
NameError: name 'f' is not defined
diff(f, x)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-65-f8814b809af0> in <module>
----> 1 diff(f, x)
NameError: name 'diff' is not defined
df(x,y)dx=f(x+h,y)−f(x,y)h
h = Symbol("h")
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-66-5f630b77c30b> in <module>
----> 1 h = Symbol("h")
NameError: name 'Symbol' is not defined
limit((f.subs(x, x+h) - f)/h, h, 0)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-67-55bbdfde9a95> in <module>
----> 1 limit((f.subs(x, x+h) - f)/h, h, 0)
NameError: name 'limit' is not defined
Podemos cambiar la dirección desde la que nos acercamos al punto límite usando el argumento dir:
limit(1/x, x, 0, dir="+")
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-68-b61b99296774> in <module>
----> 1 limit(1/x, x, 0, dir="+")
NameError: name 'limit' is not defined
limit(1/x, x, 0, dir="-")
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-69-8a3ff87fd855> in <module>
----> 1 limit(1/x, x, 0, dir="-")
NameError: name 'limit' is not defined
Serie¶
La expansión de la serie también es una de las características más útiles de un CAS. En SymPy podemos realizar una expansión en serie de una expresión usando la función series:
series(exp(x), x)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-70-cdec683aefe9> in <module>
----> 1 series(exp(x), x)
NameError: name 'series' is not defined
De forma predeterminada, expande la expresión alrededor de x=0, pero podemos expandir alrededor de cualquier valor de x al incluir explícitamente un valor en la llamada a la función:
series(exp(x), x, 1)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-71-c611dba7e677> in <module>
----> 1 series(exp(x), x, 1)
NameError: name 'series' is not defined
Y podemos definir explícitamente en qué orden se debe realizar la expansión de la serie:
series(exp(x), x, 1, 10)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-72-73baa3383a5a> in <module>
----> 1 series(exp(x), x, 1, 10)
NameError: name 'series' is not defined
La expansión de la serie incluye el orden de la aproximación, lo cual es muy útil para realizar un seguimiento del orden de validez cuando hacemos cálculos con expansiones de la serie de diferente orden:
s1 = cos(x).series(x, 0, 5)
s1
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-73-91a327d4807b> in <module>
----> 1 s1 = cos(x).series(x, 0, 5)
2 s1
NameError: name 'cos' is not defined
s2 = sin(x).series(x, 0, 2)
s2
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-74-509962eeb7a6> in <module>
----> 1 s2 = sin(x).series(x, 0, 2)
2 s2
NameError: name 'sin' is not defined
expand(s1 * s2)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-75-9ccc5e2b7fbb> in <module>
----> 1 expand(s1 * s2)
NameError: name 'expand' is not defined
Si queremos deshacernos de la información del error, podemos usar el método removeO:
expand(s1.removeO() * s2.removeO())
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-76-d0bbff31ca65> in <module>
----> 1 expand(s1.removeO() * s2.removeO())
NameError: name 'expand' is not defined
Pero tenga en cuenta que esta no es la expansión correcta de cos(x)sin(x) a 5 ésimo orden:
(cos(x)*sin(x)).series(x, 0, 6)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-77-e077ff5b8246> in <module>
----> 1 (cos(x)*sin(x)).series(x, 0, 6)
NameError: name 'cos' is not defined
Álgebra lineal¶
Matrices¶
Las matrices se definen usando la clase Matrix:
m11, m12, m21, m22 = symbols("m11, m12, m21, m22")
b1, b2 = symbols("b1, b2")
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-78-35530c07e998> in <module>
----> 1 m11, m12, m21, m22 = symbols("m11, m12, m21, m22")
2 b1, b2 = symbols("b1, b2")
NameError: name 'symbols' is not defined
A = Matrix([[m11, m12],[m21, m22]])
A
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-79-4c64c4078ea5> in <module>
----> 1 A = Matrix([[m11, m12],[m21, m22]])
2 A
NameError: name 'Matrix' is not defined
b = Matrix([[b1], [b2]])
b
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-80-921d1cd49262> in <module>
----> 1 b = Matrix([[b1], [b2]])
2 b
NameError: name 'Matrix' is not defined
Con las instancias de la clase Matrix podemos hacer las operaciones habituales de álgebra matricial:
A**2
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-81-c6cd36636038> in <module>
----> 1 A**2
NameError: name 'A' is not defined
A * b
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-82-a6703e1b14a4> in <module>
----> 1 A * b
NameError: name 'A' is not defined
Y calcular determinantes e inversas, y similares:
A.det()
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-83-0c79b70f8c8e> in <module>
----> 1 A.det()
NameError: name 'A' is not defined
A.inv()
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-84-60cc4e20accc> in <module>
----> 1 A.inv()
NameError: name 'A' is not defined
Resolver ecuaciones¶
Para resolver ecuaciones y sistemas de ecuaciones podemos usar la función resolver:
solve(x**2 - 1, x)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-85-16c513ac6ef2> in <module>
----> 1 solve(x**2 - 1, x)
NameError: name 'solve' is not defined
solve(x**4 - x**2 - 1, x)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-86-2137753deac2> in <module>
----> 1 solve(x**4 - x**2 - 1, x)
NameError: name 'solve' is not defined
Sistema de ecuaciones:
solve([x + y - 1, x - y - 1], [x,y])
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-87-4199fc5cbc06> in <module>
----> 1 solve([x + y - 1, x - y - 1], [x,y])
NameError: name 'solve' is not defined
En cuanto a otras expresiones simbólicas:
solve([x + y - a, x - y - c], [x,y])
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-88-2286ebab1a84> in <module>
----> 1 solve([x + y - a, x - y - c], [x,y])
NameError: name 'solve' is not defined