# SymPy
    
    

[SymPy](https://es.wikipedia.org/wiki/SymPy) es una biblioteca de Python que permite realizar cálculos simbólicos.
Nos ofrece las capacidades de álgebra computacional, y se puede usar en línea a través de [SymPy Live](http://live.sympy.org/) o [SymPy Gamma](http://www.sympygamma.com/), este último es similar a
[Wolfram Alpha](https://www.wolframalpha.com/).

Si usas Anaconda este paquete ya viene instalado por defecto pero si se usa miniconda o pip debe instalarse.

````python
conda install sympy # Usando el gestor conda de Anaconda/Miniconda
pip install sympy # Usando el gestor pip (puede requerir instalar más paquetes)
````


Lo primero que debemos hacer, antes de usarlo, es importar el módulo, como con cualquier
otra biblioteca de Python.

Si deseamos usar SymPy de forma interactiva usamos

```python
from sympy import *
init_printing()
```

Para scripting es mejor importar la biblioteca de la siguiente manera

```python
import sympy as sym
```

Y llamar las funciones de la siguiente manera

```python
x = sym.Symbols("x")
expr = sym.cos(x)**2 + 3*x
deriv = expr.diff(x)
```

en donde calculamos la derivada de  $\cos^2(x) + 3x$,
que debe ser $-2\sin(x)\cos(x) + 3$.


```python
%matplotlib notebook
import numpy as np
import matplotlib.pyplot as plt
from sympy import *
```


```python
init_printing()
```

Definamos la variable $x$ como un símbolo matemático. Esto nos permite hacer uso de
esta variable en SymPy.


```python
x = symbols("x")
```

Empecemos con cálculos simples. Abajo, tenemos una _celda de código_ con una suma.
Ubica el cursor en ella y presiona SHIFT + ENTER para evaluarla.



```python
1 + 3
```

Realicemos algunos cálculos.


```python
factorial(5)
```


```python
1 // 3
```


```python
1 / 3
```


```python
S(1) / 3
```

Podemos evaluar esta expresión a su versión en punto flotante


```python
sqrt(2*pi)
```


```python
float(sqrt(2*pi))
```

También podemos almacenar expresiones como variables, como cualquier variable de Python.



```python
radius = 10
height = 100
area = pi * radius**2
volume = area * height
```


```python
volume
```


```python
float(volume)
```

Hasta ahora, hemos usado SymPy como una calculadora. Intentemos
algunos cálculos más avanzados. Por ejemplo, algunas integrales.



```python
integrate(sin(x), x)
```


```python
integrate(sin(x), (x, 0, pi))
```

Podemos definir una función, e integrarla


```python
f = lambda x: x**2 + 5
```


```python
f(5)
```


```python
integrate(f(x), x)
```


```python
y = symbols("y")
integrate(1/(x**2 + y), x)
```

Si asumimos que el denominador es positivo, esta expresión se puede simplificar aún más


```python
a = symbols("a", positive=True)
integrate(1/(x**2 + a), x)
```

Hasta ahora, aprendimos lo más básico. Intentemos algunos ejemplos
más complicados ahora.

**Nota:** Si quieres saber más sobre una función específica se puede usar
la función ``help()`` o el comándo _mágico_ de IPython ``??``


```python
help(integrate)
```


```python
integrate??
```

## Ejemplos

### Solución de ecuaciones algebraicas

Para resolver sistemas de ecuaciones algebraicos podemos usar: 
[``solveset`` and ``solve``](http://docs.sympy.org/latest/tutorial/solvers.html).
El método preferido es ``solveset``, sin embargo, hay sistemas que
se pueden resolver usando ``solve`` y no ``solveset``.

Para resolver sistemas usando ``solveset``:


```python
a, b, c = symbols("a b c")
solveset(a*x**2 + b*x + c, x)
```

Debemos ingresar la expresión igualada a 0, o como una ecuación


```python
solveset(Eq(a*x**2 + b*x, -c), x)
```

``solveset`` no permite resolver sistemas de ecuaciones no lineales, por ejemplo



```python
solve([x*y - 1, x - 2], x, y)
```

### Álgebra lineal

Usamos ``Matrix`` para crear matrices. Las matrices pueden contener variables y expresiones matemáticas.

Usamos el método ``.inv()`` para calcular la inversa, y ``*`` para multiplicar matrices.


```python
A = Matrix([
        [1, -1],
        [1, sin(c)]
    ])
display(A)
```


```python
B = A.inv()
display(B)
```


```python
A * B
```

Esta expresión debería ser la matriz identidad, simplifiquemos la expresión.
Existen varias formas de simplificar expresiones, y ``simplify`` es la más general.


```python
simplify(A * B)
```

### Graficación

SymPy permite realizar gráficos 2D y 3D


```python
from sympy.plotting import plot3d
```


```python
plot(sin(x), (x, -pi, pi));
```


```python
monkey_saddle = x**3 - 3*x*y**2
p = plot3d(monkey_saddle, (x, -2, 2), (y, -2, 2))
```

### Derivadas y ecuaciones diferenciales

Podemos usar la función ``diff`` o el método ``.diff()`` para calcular derivadas.


```python
f = lambda x: x**2
```


```python
diff(f(x), x)
```


```python
f(x).diff(x)
```


```python
g = lambda x: sin(x)
```


```python
diff(g(f(x)), x)
```

Y sí, ¡SymPy sabe sobre la regla de la cadena!

Para terminar, resolvamos una ecuación diferencial de segundo orden

$$ u''(t) + \omega^2 u(t) = 0$$


```python
t = symbols("t")
u = symbols("u", cls=Function)
omega = symbols("omega", positive=True)
```


```python
ode = u(t).diff(t, 2) + omega**2 * u(t)
dsolve(ode, u(t))
```

## Convertir expresiones de SymPy en funciones de NumPy

``lambdify`` permite convertir expresiones de sympy en funciones para hacer cálculos usando NumPy.

Veamos cómo.


```python
f = lambdify(x, x**2, "numpy")
f(3)
```


```python
f(np.array([1, 2, 3]))
```

Intentemos un ejemplo más complejo


```python
fun = diff(sin(x)*cos(x**3) - sin(x)/x, x)
fun
```


```python
fun_numpy = lambdify(x, fun, "numpy")
```

y evalúemoslo en algún intervalo, por ejemplo, $[0, 5]$.


```python
pts = np.linspace(0, 5, 1000)
fun_pts = fun_numpy(pts + 1e-6) # Para evitar división por 0
```


```python
plt.figure()
plt.plot(pts, fun_pts)
```

## Ejercicios

1. Calcule el límite

  $$ \lim_{x \rightarrow 0} \frac{\sin(x)}{x}\, .$$

2. Resuelva la ecuación diferencial de Bernoulli

  $$x \frac{\mathrm{d} u(x)}{\mathrm{d}x}  + u(x) - u(x)^2 = 0\, .$$


## Recursos adicionales

- Equipo de desarrollo de SymPy. [SymPy Tutorial](http://docs.sympy.org/latest/tutorial/index.html), (2018). Consultado: Julio 23, 2018
- Ivan Savov. [Taming math and physics using SymPy](https://minireference.com/static/tutorials/sympy_tutorial.pdf), (2017). Consultado: Julio 23, 2018


```python

```

c40fe67272cce528f04b4e72247a83235798976e
ipynb
Jupyter Notebook
sympy_basico.ipynb
carlosalvarezh/FEM
e38f4fe5cfba208243687453af207ae9c0e4c55b
CC0-1.0
sympy_basico.ipynb
carlosalvarezh/FEM
e38f4fe5cfba208243687453af207ae9c0e4c55b
CC0-1.0
2022-01-25T15:10:49.000Z
2022-01-25T15:10:49.000Z
sympy_basico.ipynb
carlosalvarezh/FEM
e38f4fe5cfba208243687453af207ae9c0e4c55b
CC0-1.0
2021-10-13T02:08:02.000Z
2021-11-11T04:20:33.000Z
Qwen/Qwen-72B
1. YES
2. YES