28.5: Temas avanzados

Esta sección introduce algunos temas más avanzados que permiten utilizar la programación informática para simplificar muchas tareas. En esta sección, te mostraremos cómo puedes escribir tu propio programa para estimar numéricamente el valor de una integral de cualquier función.

Definir sus propias funciones

Aunque Python proporciona muchos módulos y funciones, a menudo es útil poder definir tus propias funciones. Por ejemplo, supongamos que le gustaría definir una función que calcule\(\frac{1}{2}x^{2} +\frac{1}{4}x^{3} + \cos(2x)\), para un valor dado de\(x\). Esto se hace fácilmente usando la palabra clave def en Python:

código python\(\PageIndex{1}\)

Definición de una función

#import the math module in order to use cos
import math as m

#define our function and call it myfunction:
def myfunction(x):
    return x**2 / 3 + x**3 / 4 + m.cos(2*x)
    
#Test our function by printing out the result of evaluating it as x = 3
print ( myfunction(3) )

Salida

10.710170286650365

Algunas cosas a tener en cuenta sobre el código anterior:

• Las funciones se definen usando la palabra clave def seguida del nombre que elegimos para la función (en nuestro caso, myfunction)
• Si las funciones toman argumentos, esos se especifican entre paréntesis después del nombre de la función (en nuestro caso, tenemos un argumento que elegimos llamar x)
• Después del nombre de la función y los argumentos, colocamos dos puntos
• El código que pertenece a la función, después de los dos puntos, debe ser sangría (esto permite a Python saber dónde termina el código de la función)
• La función puede “devolver” un valor; esto se hace usando la palabra clave return.
• Utilizamos el “operador” ** para tomar la potencia de un número (x**2), y el operador *, para multiplicar números. Python no entendería algo como 2x; necesitas usar el operador de multiplicación, es decir, 2*x.

En el ejemplo anterior, escribimos una función Python para representar una función matemática. Sin embargo, se puede escribir una función para ejecutar cualquier conjunto de tareas, no solo para aplicar una función matemática. Las funciones Python son muy útiles para evitar tener que escribir repetidamente el mismo código.

Recordemos que el módulo numpy nos permite aplicar funciones a matrices de números, en lugar de un solo número. Podemos modificar ligeramente el código de arriba para que, si el argumento de la función, x, es una matriz, la función devolverá con gracia una matriz de números a la que se ha aplicado la función. Esto se hace simplemente reemplazando la llamada a la versión matemática de la función cos usando la versión numpy:

código python\(\PageIndex{2}\)

Definir una función que funcione en una matriz

#import the numpy module in order to use cos to an array
import numpy as np

#define our function and call it myfunction:
def myfunction(x):
    return x**2 / 3 +x**3 / 4 + np.cos(2*x)
    
 #Test our function by printing out the result and evaluating it at x = 3 (same as before)
 print( myfunction(3) )
 
 #Test it with an array
 xvals = np.array([1, 2, 3])
 print ( myfunction(xvals) )

Salida

10.710170286650365

[ 0.1671865   2.67968971   10.71017029]

donde creamos la matriz xvals usando el módulo numpy.

Usar un bucle para calcular una integral

La capacidad de definir nuestras propias funciones en Python nos permite simplificar fácilmente tareas complejas. El uso de “loops” es otra forma en que la programación informática puede simplificar enormemente los cálculos que de otra manera serían muy tediosos. En un bucle, uno es capaz de repetir la misma tarea muchas veces. El siguiente ejemplo simplemente imprime una declaración cinco veces:

Código Python\(\PageIndex{3}\)

Un bucle simple

#A loop to print out a statement 5 times:

for i in range(5):
    print("The value of i is ", i)

Salida

The value of i is 0
The value of i is 1
The value of i is 2
The value of i is 3
The value of i is 4

Algunas notas sobre el código anterior:

• El bucle se define mediante el uso de las palabras clave para... en
• El valor después de la palabra clave for es la variable “iterador” y tendrá un valor diferente cada vez que se ejecute el código dentro del bucle (en nuestro caso, llamamos a la variable i)
• El valor después de la palabra clave in es una matriz de valores que tomará el iterador
• La función range (N) devuelve una matriz de N valores enteros entre 0 y N-1 (en nuestro caso, esto devuelve los cinco valores\(0,1,2,3,4\))
• El código a ejecutar en cada “iteración” del bucle va precedido de dos puntos y sangría (de la misma manera que el código de una función también sigue dos puntos y se sangra)

Ahora contamos con todas las herramientas para evaluar una integral numéricamente. Recordemos que la integral de la función\(f(x)\) entre\(x_{a}\) y\(x_{b}\) es simplemente una suma:

\[\begin{aligned} \int_{x_{a}}^{x_{b}}f(x)dx &= \lim_{\Delta x \to 0}\sum _{i=0}^{i=N-1}f(x_{i})\Delta x \\ \Delta x&=\frac{x_{b}-x_{a}}{N} \\ x_{i}&=x_{a}+i\Delta x \end{aligned}\]

El límite de\(∆x → 0\) es equivalente al límite\(N → ∞\). Nuestra estrategia para evaluar la integral es:

1. Definir una función Python para\(f(x)\).
2. Crear una matriz, xvals, de\(N\) valores de\(x\) entre\(x_{a}\) y\(x_{b}\).
3. Evaluar la función para todos esos valores y almacenarlos en una matriz, fvals.
4. Bucle sobre todos los valores en la matriz fvals, multiplicarlos por\(∆x\), y sumarlos juntos.

Usemos Python para evaluar la integral de la función\(f(x) = 4x^{3}+3x^{2}+5\) entre\(x = 1\) y\(x = 5\):

Código Python\(\PageIndex{4}\)

Integración numérica de una función

#import numpy to work with arrays:
import numpy as np

#define our function
def f(x):
    return 4*x**3 + 3*x**2 + 5
    
#Make N and the range of integration variables:
N - 1000
xmin = 1
xmax = 5

#create the array of values of x between xmin and xmax
xvals = np.linspace(xmin, xmax, N)

#evaluate the function at all those values of x
fvals = f(xvals)

#calculate delta x
deltax = (xmax - xmin) / N

#initialize the sum to be zero:
sum = 0

#loop over the values fvals and add them to the sum
for fi in fvals:
    sum = sum + fi*deltax
    
#print the result:
print("The integral between {} and {} using {} steps is {:.2f}".format(xmin, xmax, N, sum))

Salida

The integral between 1 and 5 using 1000 steps is 768.42

Uno puede integrar fácilmente la función anterior analíticamente y obtener el resultado exacto de\(768\). La respuesta numérica se acercará a la respuesta exacta a medida que hagamos\(N\) más grandes. Por supuesto, el poder de la integración numérica es utilizarla cuando la función no se puede integrar analíticamente.

Ejercicio\(\PageIndex{1}\)

¿Qué valor de\(N\) debes usar arriba para meterte dentro\(0.01\) de la respuesta analítica exacta?

Contestar