```python
from sympy import *
init_printing(use_latex='mathjax')
x, y, z = symbols('x,y,z')
n, m = symbols('n,m', integer=True)
```


```python
import matplotlib.pyplot as plt
```

# Evaluación numérica

En esta sección aprenderemos como usar nuestras ecuaciones simbólicas para conducir cálculos numéricos

## `.subs` y `.evalf`

La forma más simple (y más lenta) de evaluar una expresión numéricamente es con los métodos `.subs` y` .evalf`


```python
sin(x)
```


```python
sin(x).subs({x: 0})
```


```python
acos(x).subs({x: -1})
```


```python
acos(x).subs({x: -1}).evalf()
```


```python
acos(x).subs({x: -1}).evalf(n=100)
```

### Ejercicio

En una sección anterior calculamos la siguiente integral simbólica

$$ \int_y^z x^n dx $$


```python
result = integrate(x**n, (x, y, z))
result
```

Usa `.subs` y un diccionario con claves (*keys*) `n, y, z` para evaluar el resultado

    n == 2
    y == 0
    z == 3


```python
# Evalua la integral resultante en los valores anteriores


```

### Ejercicio

Esta integral toma una forma especial cuando $n = -1$. Usa `subs` para encontrar la expresión cuando

    n == -1
    y == 5
    z == 100
    
Luego usa `.evalf` para evaluar esta expresión resultante como un flotante.


```python
# Evalua la intergral resultante para los valores {n: -1, y: 5, z: 100}
# Luego usa evalf para obtener un resultado numerico


```

## `lambdify`

Los métodos `.subs` y` .evalf` son geniales cuando quieres evaluar una expresión en un solo punto. Cuando quieres evaluar tu expresión en muchos puntos, se vuelven lentos rápidamente.

Para resolver este problema, *SymPy* puede reescribir sus expresiones como funciones normales de Python usando la biblioteca *math*, cálculos vectorizados usando la biblioteca *NumPy*, código *C* o *Fortran* usando impresoras de códigos, o incluso sistemas más sofisticados.

Hablaremos sobre algunos de los temas más avanzados más adelante. Por ahora, `lambdify`...


```python
# function = lambdify(input, output)

f = lambdify(x, x**2)
f(3)
```


```python
import numpy as np
f = lambdify(x, x**2)  # Use numpy backend
data = np.array([1, 2, 3, 4, 5], float)
f(data)
```

### Ejercicio

Aquí se muestra hay una función de onda radial para el átomo de carbono para $n=3$, $l=1$


```python
from sympy.physics.hydrogen import R_nl
n = 3
l = 1
r = 6 # Carbon
expr = R_nl(n, l, x, r)
expr
```

Crea una función, `f`, que evalúa esta expresión usando el motor (*backend*) *numpy*


```python
# Create Numpy function mapping x to expr with the numpy backend
f = lambdify(x,expr)
```


```python
f
```

Podemos graficar la función de $x \in [0, 5]$ con el siguiente código *numpy*/*matplotlib*


```python
nx = np.linspace(0, 5, 1000)
plt.plot(nx, f(nx))
```

### Ejercicio

Crea una función *numpy* que calcula la derivada de nuestra expresión. Grafica el resultado junto con el original.


```python
# Calcula la derivada de expr con respecto a x


```


```python
# Crea una funcion fprime usando lambdify


```


```python
# Grafica los resultados junto con f(nx)


```

9ac0307564edd2a1c4432047400934ee714d1add
ipynb
Jupyter Notebook
tutorial_exercises/05-Numeric-Evaluation.ipynb
t3rodrig/sympy-tutorial-es
5cd5497f799e889d758a26539781cdc72b1e6a74
BSD-3-Clause
tutorial_exercises/05-Numeric-Evaluation.ipynb
t3rodrig/sympy-tutorial-es
5cd5497f799e889d758a26539781cdc72b1e6a74
BSD-3-Clause
tutorial_exercises/05-Numeric-Evaluation.ipynb
t3rodrig/sympy-tutorial-es
5cd5497f799e889d758a26539781cdc72b1e6a74
BSD-3-Clause
Qwen/Qwen-72B
1. YES
2. YES