j) Utilice un código de programación de Python para realizar los ejercicios b, c, d, e.

Como
resultado coloque el código, si no se ve bien, se puede colocar como imagen. Además, mostrar
una gráfica en donde se pueda ver la original y la interpolación que obtuvieron. Agregar el cálculo
del error relativo en el código.

Algoritmo interpolación Lagrange

import sympy as sp
import numpy as np

def lagrange_interpolation(x_values, y_values):

"""
Devuelve el polinomio de Lagrange simplificado como una cadena.

:param x_values: Lista de valores x (nodos)

:param y_values: Lista de valores y correspondientes a x_values
:return: Representación en cadena del polinomio simplificado
"""
n = len(x_values)
x = sp.symbols('x')
polynomial = 0

for i in range(n):
term = y_values[i]
for j in range(n):
if i != j:
term *= (x - x_values[j]) / (x_values[i] - x_values[j])
polynomial += term

# Simplificar el polinomio
polynomial = sp.simplify(polynomial).evalf(3)

return polynomial
Algoritmo Interpolación Newton
import sympy as sp
import numpy as np
def divided_differences(x_values, y_values):
"""
Calcula las diferencias divididas.

:param x_values: Lista de valores x (nodos)

:param y_values: Lista de valores y correspondientes a x_values
:return: Lista de diferencias divididas
"""
n = len(x_values)
diff = [[0 for _ in range(n)] for _ in range(n)]
for i in range(n): diff[i]
[0] = y_values[i]

for j in range(1, n):

for i in range(n - j):
diff[i][j] = (diff[i + 1][j - 1] - diff[i][j - 1]) /
(x_values[i + j] - x_values[i])

return [diff[0][i] for i in range(n)]

def newton_interpolation(x_values, y_values):

"""
Devuelve el polinomio de interpolación de Newton simplificado como
una cadena.

:param x_values: Lista de valores x (nodos)

:param y_values: Lista de valores y correspondientes a x_values
:return: Representación en cadena del polinomio simplificado
"""
n = len(x_values)
x = sp.symbols('x')
polynomial = 0
coeffs = divided_differences(x_values, y_values)
term = 1

for i in range(n):
polynomial += coeffs[i] * term
if i < n - 1:
term *= (x - x_values[i])

# Simplificar el polinomio
polynomial = sp.simplify(polynomial).evalf(3)

return polynomial
Ejercicio B

Ajuste el polinomio de interpolación de Newton de segundo grado para estimar 𝑥 = 3.5.

# Datos de ejemplo
y_values = [1.20, 1.91, 2.41]
x_values = [2, 3, 4]

# Mostrar el polinomio resultante simplificado

polynomial = newton_interpolation(x_values, y_values)
print(f"Polinomio de Newton simplificado: {polynomial}")

# Evaluar el polinomio en un punto

x_point = 3.5
y_interp = polynomial.subs('x', x_point)

# Valor real (para calcular el error, en este caso es un valor ficticio)

y_real = np.power(np.exp(x_point),0.25)

# Cálculo de errores
error_absoluto = abs(y_real - y_interp)
error_relativo = (error_absoluto / abs(y_real))*100

print(f"\nValor interpolado: {y_interp}")

print(f"Error absoluto: {error_absoluto}")
print(f"Error relativo: {error_relativo}")

import matplotlib.pyplot as plt

# Crear una serie de puntos x para la gráfica
x_plot = np.linspace(min(x_values), max(x_values), 400)
y_plot_newton = [polynomial.subs('x', x_val) for x_val in x_plot]
y_plot_real = [2*np.log(x_val**2) for x_val in x_plot]

plt.figure(figsize=(10,6))
plt.plot(x_plot, y_plot_newton, label='Interpolación de Newton')
plt.plot(x_plot, y_plot_real, label='Función real: $2\log(x^2)$')
plt.scatter(x_values, y_values, color='red') # puntos de interpolación
for i in range(len(x_values)):
plt.text(x_values[i], y_values[i], f'({x_values[i]}, {y_values[i]})')
plt.title('Interpolación de Newton vs Función Real')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid(True)
plt.show()
Ejercicio C

Ajuste el polinomio de interpolación de Lagrange de segundo grado para estimar 𝑥 = 3.5.

# Ejercicio
# Datos de ejemplo
y_values = [1.20, 1.91, 2.41]
x_values = [2, 3, 4]

# Mostrar el polinomio resultante simplificado

polynomial = lagrange_interpolation(x_values, y_values)
print(f"Polinomio de Lagrange simplificado: {polynomial}")

# Evaluar el polinomio en un punto

x_point = 3.5
y_interp = polynomial.subs('x', x_point)

# Valor real (para calcular el error, en este caso es un valor ficticio)

y_real = np.power(np.exp(x_point),0.25)

# Cálculo de errores
error_absoluto = abs(y_real - y_interp)
error_relativo = (error_absoluto / abs(y_real))*100

print(f"\nValor interpolado: {y_interp}")

print(f"Error absoluto: {error_absoluto}")
print(f"Error relativo: {error_relativo}")
import matplotlib.pyplot as plt
# Crear una serie de puntos x para la gráfica
x_plot = np.linspace(min(x_values), max(x_values), 400)
y_plot_lagrange = [polynomial.subs('x', x_val) for x_val in x_plot]
y_plot_real = [2*np.log(x_val**2) for x_val in x_plot]

plt.figure(figsize=(10,6))
plt.plot(x_plot, y_plot_lagrange, label='Interpolación de Lagrange')
plt.plot(x_plot, y_plot_real, label='Función real: $2\log(x^2)$')
plt.scatter(x_values, y_values, color='red') # puntos de interpolación
for i in range(len(x_values)):
plt.text(x_values[i], y_values[i], f'({x_values[i]}, {y_values[i]})')
plt.title('Interpolación de Lagrange vs Función Real')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid(True)
plt.show()
Ejercicio D

Ajuste el polinomio de interpolación de Newton de tercer grado para estimar 𝑥 = 3.5.

# Datos de ejemplo
y_values = [1.20, 1.91, 2.41, 2.80]
x_values = [2, 3, 4, 5]

# Mostrar el polinomio resultante simplificado

polynomial = newton_interpolation(x_values, y_values)
print(f"Polinomio de Newton simplificado: {polynomial}")

# Evaluar el polinomio en un punto

x_point = 3.5
y_interp = polynomial.subs('x', x_point)

# Valor real (para calcular el error, en este caso es un valor ficticio)

y_real = np.power(np.exp(x_point),0.25)

# Cálculo de errores
error_absoluto = abs(y_real - y_interp)
error_relativo = (error_absoluto / abs(y_real))*100

print(f"\nValor interpolado: {y_interp}")

print(f"Error absoluto: {error_absoluto}")
print(f"Error relativo: {error_relativo}")

import matplotlib.pyplot as plt

# Crear una serie de puntos x para la gráfica
x_plot = np.linspace(min(x_values), max(x_values), 400)
y_plot_newton = [polynomial.subs('x', x_val) for x_val in x_plot]
y_plot_real = [2*np.log(x_val**2) for x_val in x_plot]

plt.figure(figsize=(10,6))
plt.plot(x_plot, y_plot_newton, label='Interpolación de Newton')
plt.plot(x_plot, y_plot_real, label='Función real: $2\log(x^2)$')
plt.scatter(x_values, y_values, color='red') # puntos de interpolación
for i in range(len(x_values)):
plt.text(x_values[i], y_values[i], f'({x_values[i]}, {y_values[i]})')
plt.title('Interpolación de Newton vs Función Real')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid(True)
plt.show()
Ejercicio E

Ajuste el polinomio de interpolación de Lagrange de tercer grado para estimar 𝑥 = 3.5.

# Ejercicio
# Datos de ejemplo
y_values = [1.20, 1.91, 2.41, 2.80]
x_values = [2, 3, 4, 5]

# Mostrar el polinomio resultante simplificado

polynomial = lagrange_interpolation(x_values, y_values)
print(f"Polinomio de Lagrange simplificado: {polynomial}")

# Evaluar el polinomio en un punto

x_point = 3.5
y_interp = polynomial.subs('x', x_point)

# Valor real (para calcular el error, en este caso es un valor ficticio)

y_real = np.power(np.exp(x_point),0.25)

# Cálculo de errores
error_absoluto = abs(y_real - y_interp)
error_relativo = (error_absoluto / abs(y_real))*100

print(f"\nValor interpolado: {y_interp}")

print(f"Error absoluto: {error_absoluto}")
print(f"Error relativo: {error_relativo}")
import matplotlib.pyplot as plt
# Crear una serie de puntos x para la gráfica
x_plot = np.linspace(min(x_values), max(x_values), 400)
y_plot_lagrange = [polynomial.subs('x', x_val) for x_val in x_plot]
y_plot_real = [2*np.log(x_val**2) for x_val in x_plot]

plt.figure(figsize=(10,6))
plt.plot(x_plot, y_plot_lagrange, label='Interpolación de Lagrange')
plt.plot(x_plot, y_plot_real, label='Función real: $2\log(x^2)$')
plt.scatter(x_values, y_values, color='red') # puntos de interpolación
for i in range(len(x_values)):
plt.text(x_values[i], y_values[i], f'({x_values[i]}, {y_values[i]})')
plt.title('Interpolación de Lagrange vs Función Real')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid(True)
plt.show()
k) Utilice un código de programación de Python para realizar los ejercicios g, h. Como

resultado coloque el código, si no se ve bien, se puede colocar como imagen. Además,

mostrar una gráfica en donde se pueda ver la original y la interpolación que

obtuvieron. Agregar el cálculo del error relativo en el código.

Ejercicio G

Para la función dada, queremos encontrar el valor de 𝑥, cuando 𝑓(𝑥) = 1.5. Realizar la interpolación
inversa por el método de Newton de tercer grado.
# Datos de ejemplo
x_values = [1.20, 1.91, 2.41, 2.80]
y_values = [2, 3, 4, 5]

# Mostrar el polinomio resultante simplificado

polynomial = newton_interpolation(x_values, y_values)
print(f"Polinomio de Newton simplificado: {polynomial}")

# Evaluar el polinomio en un punto

x_point = 1.5
y_interp = polynomial.subs('x', x_point)

# Valor real (para calcular el error, en este caso es un valor ficticio)

y_real = np.power(np.exp(1.5),0.25)

# Cálculo de errores
error_absoluto = abs(y_real - y_interp)
error_relativo = (error_absoluto / abs(y_real))*100

print(f"\nValor interpolado: {y_interp}")

print(f"Error absoluto: {error_absoluto}")
print(f"Error relativo: {error_relativo}")

import matplotlib.pyplot as plt

# Crear una serie de puntos x para la gráfica
x_plot = np.linspace(min(x_values), max(x_values), 400)
y_plot_newton = [polynomial.subs('x', x_val) for x_val in x_plot]
y_plot_real = [2*np.log(x_val**2) for x_val in x_plot]

plt.figure(figsize=(10,6))
plt.plot(x_plot, y_plot_newton, label='Interpolación de Newton')
plt.plot(x_plot, y_plot_real, label='Función real: $2\log(x^2)$')
plt.scatter(x_values, y_values, color='red') # puntos de interpolación
for i in range(len(x_values)):
plt.text(x_values[i], y_values[i], f'({x_values[i]}, {y_values[i]})')
plt.title('Interpolación de Newton vs Función Real')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid(True)
plt.show()

Ejercicio H

Para la función dada, queremos encontrar el valor de 𝑥, cuando 𝑓(𝑥) = 1.5. Realizar la interpolación
inversa por el método de Lagrange de tercer grado.
# Datos de ejemplo
x_values = [1.20, 1.91, 2.41, 2.80]
y_values = [2, 3, 4, 5]

# Mostrar el polinomio resultante simplificado

polynomial = lagrange_interpolation(x_values, y_values)
print(f"Polinomio de Lagrange simplificado: {polynomial}")

# Evaluar el polinomio en un punto

x_point = 1.5
y_interp = polynomial.subs('x', x_point)

# Valor real (para calcular el error, en este caso es un valor ficticio)

y_real = np.power(np.exp(1.5),0.25)

# Cálculo de errores
error_absoluto = abs(y_real - y_interp)
error_relativo = error_absoluto / abs(y_real)

print(f"\nValor interpolado: {y_interp}")

print(f"Error absoluto: {error_absoluto}")
print(f"Error relativo: {error_relativo}")

import matplotlib.pyplot as plt

# Crear una serie de puntos x para la gráfica
x_plot = np.linspace(min(x_values), max(x_values), 400)
y_plot_lagrange = [polynomial.subs('x', x_val) for x_val in x_plot]
y_plot_real = [2*np.log(x_val**2) for x_val in x_plot]

plt.figure(figsize=(10,6))
plt.plot(x_plot, y_plot_lagrange, label='Interpolación de Lagrange')
plt.plot(x_plot, y_plot_real, label='Función real: $2\log(x^2)$')
plt.scatter(x_values, y_values, color='red') # puntos de interpolación
for i in range(len(x_values)):
plt.text(x_values[i], y_values[i], f'({x_values[i]}, {y_values[i]})')
plt.title('Interpolación de Lagrange vs Función Real')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid(True)
plt.show()

Link de drive:
https://drive.google.com/file/d/16JI_eUkS4BO87jFa_5ggSZFmb214oV91/
view?usp=drive_link