<jupyter_start><jupyter_text>Introducción a SymPy ![](http://sympy.org/static/images/logo.png)__SymPy es una biblioteca de Python para matemática simbólica__. Apunta a convertirse en un sistema de algebra computacional (__CAS__) con todas sus prestaciones manteniendo el código tan simple como sea posible para manterlo comprensible y fácilmente extensible. SymPy está __escrito totalmente en Python y no requiere bibliotecas adicionales__. _Este proyecto comenzó en 2005, fue lanzado al público en 2007 y a él han contribuido durante estos años cientos de personas.__ Otros CAS conocidos son Mathematica y Maple, sin embargo ambos son software privativo y de pago. [Aquí](https://github.com/sympy/sympy/wiki/SymPy-vs.-Maple) puedes encontrar una comparativa de SymPy con Maple. _Hoy veremos cómo:* Crear símbolos y expresiones.* Manipular expresiones (simplificación, expansión...)* Calcular derivadas e integrales.* Límites y desarrollos en serie.* Resolución de ecuaciones.* Resolción de EDOs.* MatricesSin embargo, SymPy no acaba aquí ni mucho menos...  Documentación & SymPy Live Shell<jupyter_code>from IPython.display import HTML
HTML('<iframe src="http://docs.sympy.org/latest/index.html" width="700" height="400"></iframe>')<jupyter_output><empty_output><jupyter_text>SymPy Gamma<jupyter_code>HTML('<iframe src="http://www.sympygamma.com/input/?i=integrate%281+%2F+%281+%2B+x^2%29%29" width="700" height="400"></iframe>')<jupyter_output><empty_output><jupyter_text>Creación de símbolos Lo primero, como siempre, es importar aquello que vayamos a necesitar. La manera usual de hacerlo con SymPy es importar la función `init_session`:```from sympy import init_sessioninit_session(use_latex=True)``` Esta función ya se encarga de importar todas las funciones básicas y preparar las salidas gráficas. Sin embargo, en este momento, esta función se encuentra en mantenimiento para su uso dentro de los notebooks por lo que activaremos la salida gráfica e importaremos las funciones de la manera usual. Puedes consultar el estado de la corrección en: https://github.com/sympy/sympy/pull/13300 y https://github.com/sympy/sympy/issues/13319 . El comando `init_session` llevaría a cabo algunas acciones por nostros:* Gracias a `use_latex=True` obtenemos la salida en $\LaTeX$.* __Crea una serie de variables__ para que podamos ponernos a trabajar en el momento.Estas capacidades volverán a estar disponibles cuando el problema se corrija.<jupyter_code># aeropython: preserve
from sympy import (symbols, pi, I, E, cos, sin, exp, tan, simplify, expand, factor, collect,
                   apart, cancel, expand_trig, diff, Derivative, Function, integrate, limit,
                   series, Eq, solve, dsolve, Matrix, N)<jupyter_output><empty_output><jupyter_text>Nota: En Python, no se declaran las variables, sin embargo, no puedes usar una hasta que no le hayas asignado un valor. Si ahora intentamos crear una variable `a` que sea `a = 2 * b`, veamos qué ocurre:<jupyter_code># Intentamos usar un símbolo que no hemos creado<jupyter_output><empty_output><jupyter_text>Como en `b` no había sido creada, Python no sabe qué es `b`.Esto mismo nos ocurre con los símbolos de SymPy. __Antes de usar una variable, debo decir que es un símbolo y asignárselo:__<jupyter_code># Creamos el símbolo a
# Número pi
# Unidad imaginaria
# Número e
# Vemos qué tipo de variable es a<jupyter_output><empty_output><jupyter_text>Ahora ya podría crear `b = 2 * a`: ¿Qué está ocurriendo? Python detecta que a es una variable de tipo `Symbol` y al multiplicarla por `2` devuelve una variable de Sympy.Como Python permite que el tipo de una variable cambie, __si ahora le asigno a `a` un valor float deja de ser un símbolo.__ ---__Las conclusiones son:__* __Si quiero usar una variable como símbolo debo crearla previamente.__* Las operaciones con símbolos devuelven símbolos.* Si una varibale que almacenaba un símbolo recibe otra asignación, cambia de tipo.--- __Las variables de tipo `Symbol` actúan como contenedores en los que no sabemos qué hay (un real, un complejo, una lista...)__. Hay que tener en cuenta que: __una cosa es el nombre de la variable y otra el símbolo con el que se representa__.<jupyter_code>#creación de símbolos<jupyter_output><empty_output><jupyter_text>Incluso puedo hacer cosas raras como:<jupyter_code># Diferencia entre variable y símbolo<jupyter_output><empty_output><jupyter_text>Además, se pueden crear varos símbolos a la vez: y símbolos griegos: ![](../images/simplification_sympy.png)_Fuente: Documentación oficial de SymPy_ __Por defecto, SymPy entiende que los símbolos son números complejos__. Esto puede producir resultados inesperados ante determinadas operaciones como, por ejemplo, lo logaritmos. __Podemos indicar que la variable es real, entera... en el momento de la creación__:<jupyter_code># Creamos símbolos reales
# Podemos ver las asunciones de un símbolo<jupyter_output><empty_output><jupyter_text>Expresiones Comencemos por crear una expresión como: $\cos(x)^2+\sin(x)^2$  `simplify()` Podemos pedirle que simplifique la expresión anterior: En este caso parece estar claro lo que quiere decir más simple, pero como en cualquier _CAS_ el comando `simplify` puede no devolvernos la expresión que nosotros queremos. Cuando esto ocurra necesitaremos usar otras instrucciones.  `.subs()` En algunas ocasiones necesitaremos sustituir una variable por otra, por otra expresión o por un valor.<jupyter_code># Sustituimos x por y ** 2
# ¡Pero la expresión no cambia!
# Para que cambie<jupyter_output><empty_output><jupyter_text>Cambia el `sin(x)` por `exp(x)` Particulariza la expresión $sin(x) + 3 x $ en $x = \pi$ __Aunque si lo que queremos es obtener el valor numérico lo mejor es `.evalf()`__<jupyter_code>#ver pi con 25 decimales
#el mismo resultado se obtiene ocn la función N()<jupyter_output><empty_output><jupyter_text>Simplificación SymPy ofrece numerosas funciones para __simplificar y manipular expresiones__. Entre otras, destacan:* `expand()`* `factor()`* `collect()`* `apart()`* `cancel()`Puedes consultar en la documentación de SymPy lo que hace cada una y algunos ejemplos. __Existen también funciones específicas de simplificación para funciones trigonométricas, potencias y logaritmos.__ Abre [esta documentación](http://docs.sympy.org/latest/tutorial/simplification.html) si lo necesitas.  ¡Te toca! Pasaremos rápidamente por esta parte, para hacer cosas "más interesantes". Te proponemos algunos ejemplos para que te familiarices con el manejor de expresiones: __Crea las expresiones de la izquierda y averigua qué función te hace obtener la de la derecha:__expresión 1| expresión 2:------:|:------:$\left(x^{3} + 3 y + 2\right)^{2}$    |    $x^{6} + 6 x^{3} y + 4 x^{3} + 9 y^{2} + 12 y + 4$$\frac{\left(3 x^{2} - 2 x + 1\right)}{\left(x - 1\right)^{2}} $ | $3 + \frac{4}{x - 1} + \frac{2}{\left(x - 1\right)^{2}}$$x^{3} + 9 x^{2} + 27 x + 27$         |    $\left(x + 3\right)^{3}$$\sin(x+2y)$                          |    $\left(2 \cos^{2}{\left (y \right )} - 1\right) \sin{\left (x \right )} + 2 \sin{\left (y \right )} \cos{\left (x \right )} \cos{\left (y \right )}$<jupyter_code>#1
#2
#3
#4<jupyter_output><empty_output><jupyter_text>Derivadas e integrales Puedes derivar una expresion usando el método `.diff()` y la función `dif()`<jupyter_code>#creamos una expresión
#obtenemos la derivada primera con funcion
#utilizando método<jupyter_output><empty_output><jupyter_text>__¿derivada tercera?__ __¿varias variables?__ __Queremos que la deje indicada__, usamos `Derivative()` __¿Será capaz SymPy de aplicar la regla de la cadena?__<jupyter_code># Creamos una función F
# Creamos una función G<jupyter_output><empty_output><jupyter_text>$$\frac{d}{d x} F{\left (G(x) \right )} $$<jupyter_code># Derivamos la función compuesta F(G(x))<jupyter_output><empty_output><jupyter_text>En un caso en el que conocemos las funciones:<jupyter_code># definimos una f
# definimos una g(f)
#la derivamos<jupyter_output><empty_output><jupyter_text>Te toca integrar __Si te digo que se integra usando el método `.integrate()` o la función `integrate()`__. ¿Te atreves a integrar estas casi inmediatas...?:$$\int{\cos(x)^2}dx$$$$\int{\frac{dx}{\sin(x)}}$$$$\int{\frac{dx}{(x^2+a^2)^2}}$$  Límites Calculemos este límite sacado del libro _Cálculo: definiciones, teoremas y resultados_, de Juan de Burgos:$$\lim_{x \to 0} \left(\frac{x}{\tan{\left (x \right )}}\right)^{\frac{1}{x^{2}}}$$Primero creamos la expresión: Obtenemos el límite con la función `limit()` y si queremos dejarlo indicado, podemos usar `Limit()`:  Series Los desarrollos en serie se pueden llevar a cabo con el método `.series()` o la función `series()`<jupyter_code>#creamos la expresión
#la desarrollamos en serie<jupyter_output><empty_output><jupyter_text>Se puede especificar el número de términos pasándole un argumento `n=...`. El número que le pasemos será el primer término que desprecie.<jupyter_code># Indicando el número de términos<jupyter_output><empty_output><jupyter_text>Si nos molesta el $\mathcal{O}(x^{10})$ lo podemos quitar con `removeO()`: ---  Resolución de ecuaciones Como se ha mencionado anteriormente las ecuaciones no se pueden crear con el `=`<jupyter_code>#creamos la ecuación
# También la podemos crear como
#la resolvemos<jupyter_output><empty_output><jupyter_text>Pero la gracia es resolver con símbolos, ¿no?$$a e^{\frac{x}{t}} = C$$<jupyter_code># Creamos los símbolos y la ecuación
# La resolvemos<jupyter_output><empty_output><jupyter_text>Si consultamos la ayuda, vemos que las posibilidades y el número de parámetros son muchos, no vamos a entrar ahora en ellos, pero ¿se ve la potencia?  Ecuaciones diferenciales Tratemos de resolver, por ejemplo:$$y{\left (x \right )} + \frac{d}{d x} y{\left (x \right )} + \frac{d^{2}}{d x^{2}}  y{\left (x \right )} = \cos{\left (x \right )}$$<jupyter_code>#resolvemos<jupyter_output><empty_output><jupyter_text>Matrices<jupyter_code>#creamos una matriz llena de símbolos
#sacamos autovalores
#inversa
#elevamos al cuadrado la matriz<jupyter_output><empty_output><jupyter_text>---_ Esto ha sido un rápido recorrido por algunas de las posibilidades que ofrece SymPy . El cálculo simbólico es un terreno díficil y este joven paquete avanza a pasos agigantados gracias a un grupo de desarrolladores siempre dispuestos a mejorar y escuchar sugerencias. Sus posibilidades no acaban aquí. En la siguiente clase presentaremos el paquete `mechanics`, pero además cuenta con herramientas para geometría, mecánica cuántica, teoría de números, combinatoria... Puedes echar un ojo [aquí](http://docs.sympy.org/latest/modules/index.html). _ Si te ha gustado esta clase:Tweet!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');---  ¡Síguenos en Twitter!  Follow @Pybonacci !function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');  Follow @Alex__S12 !function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');  Follow @newlawrence !function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');  Curso AeroPython por <NAME> y <NAME> se distribuye bajo una Licencia Creative Commons Atribución 4.0 Internacional.      ---_Las siguientes celdas contienen configuración del Notebook__Para visualizar y utlizar los enlaces a Twitter el notebook debe ejecutarse como [seguro](http://ipython.org/ipython-doc/dev/notebook/security.html)_    File > Trusted Notebook<jupyter_code># Esta celda da el estilo al notebook
from IPython.core.display import HTML
css_file = '../styles/aeropython.css'
HTML(open(css_file, "r").read())<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.11696378156005485, 'fraction_numerical': 0.009437767201742357, 'mean_word_length': 5.7564032697547685, 'pattern_counts': {'":': 0, '<': 95, '<?xml version=': 0, '>': 96, 'https://': 3, 'lorem ipsum': 0, 'www.': 1, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '22', 'dir': 'jupyter-structured-clean-dedup', 'id': '225370', 'license': 'CC-BY-4.0', 'n_tokens_mistral': 4424, 'n_tokens_neox': 4299, 'n_words': 1335, 'path': 'notebooks_vacios/040-SymPy-Intro.ipynb', 'repo_name': 'caorodriguez/aprendealgo-', 'size': '12431'}