Aproximaciones de Taylor y análisis de error en Python

¿Cómo implementar la aproximación de Taylor en Python?

La aproximación de Taylor es una poderosa herramienta matemática que nos permite representar funciones no lineales mediante funciones afines en torno a un punto. Esto es especialmente útil en análisis numérico y matemáticas aplicadas, donde simplificar funciones puede facilitar cálculos complejos. Vamos a profundizar en el uso de la aproximación de Taylor a través de un ejemplo práctico y su implementación en Python.

¿Qué es NumPy y cómo nos ayuda en esto?

NumPy es una biblioteca fundamental para la computación científica en Python. Nos proporciona soporte para grandes arreglos multidimensionales y matrices, junto con una amplia colección de funciones matemáticas para operar con estos arreglos. En el contexto de aproximaciones de Taylor, usaremos NumPy para manejar los cálculos de vectores y funciones de manera eficiente.

¿Cómo calculamos el gradiente de la función?

Para calcular el gradiente de una función dada ( f: \mathbb{R}^2 \to \mathbb{R} ), primero necesitamos definir la función del gradiente, que nos devuelve un vector:

import numpy as np

def gradiente_f(z):
    return np.array([1 - np.exp(z[1] - z[0]), z[1] - z[0]])

z = np.array([1, 2])
grad = gradiente_f(z)
print(grad)

Este código representa cómo calculamos el vector gradiente de nuestra función en el punto ((1, 2)).

¿Cómo se define la función original ( f ) en Python?

A partir de la función original ( f(x) = x_0 + \exp(x_1 - x_0) ), la podemos programar en Python así:

def f(x):
    return x[0] + np.exp(x[1] - x[0])

f_evaluado = f(z)
print(f_evaluado)

Al evaluar ( f ) en el punto ((1,2)), obtenemos un valor que será usado en la construcción de la aproximación de Taylor.

¿Cómo construimos la aproximación de Taylor?

Para crear la aproximación de Taylor, sumamos la función evaluada en ( z ) y el producto del gradiente evaluado por la diferencia entre ( x ) y ( z ):

def aproximacion_taylor(x):
    f_z = f(z)
    grad_z = gradiente_f(z)
    return f_z + np.dot(grad_z, x - z)

aprox = aproximacion_taylor(z)
print(aprox)

Asegurándonos de que la aproximación se valide mediante su evaluación en el punto de interés, debe coincidir con el valor de ( f(z) ).

¿Cómo visualizamos la aproximación para entender mejor?

La visualización es crucial. Utilizamos bibliotecas de visualización como matplotlib para graficar tanto la función original como su aproximación:

import matplotlib.pyplot as plt

# Definir un rango de valores
x_values = np.linspace(0, 1, 1000)
original_function = [f([x, x]) for x in x_values]
approximated_function = [aproximacion_taylor([x, x]) for x in x_values]

plt.plot(x_values, original_function, label='Función original')
plt.plot(x_values, approximated_function, label='Aproximación de Taylor')
plt.scatter([1], [f_evaluado], color='red', zorder=5)  # Punto de aproximación
plt.legend()
plt.show()

Mediante esta comparación gráfica, podemos observar cómo en la vecindad del punto de aproximación, las funciones se asemejan. Sin embargo, al alejarnos del punto, el error entre la función original y su aproximación aumenta.

¿Cómo calcular y entender el error de la aproximación?

El error entre ( f ) y su aproximación de Taylor en un punto ( x ) se mide mediante el valor absoluto de la diferencia entre ambas evaluaciones:

def error(x):
    return abs(f(x) - aproximacion_taylor(x))

error_0_3 = error([0.3, 0.3])
error_0_4 = error([0.4, 0.4])  # Punto donde empieza la aproximación
print(error_0_3, error_0_4)

Podemos notar que cuando evaluamos la función en valores cercanos a ( z ), el error es mínimo. Esto se debe a que nuestras aproximaciones de Taylor son más precisas en estos puntos. A medida que te alejas del punto de aproximación, el error se incrementa, demostrando la limitación de nuestra aproximación en un dominio más amplio.

En conclusión, ánimo con esta aventura de aprender a aproximar funciones no lineales mediante el uso de herramientas matemáticas modernas. Si encuentras dificultades, profundiza en los cursos básicos de cálculo y programación en Python para reforzar las bases necesarias. ¡Vamos a seguir aprendiendo y explorando!