Diferencia entre revisiones de «Series de Fourier RAJ»

import numpy as np
import matplotlib.pyplot as plt
import scipy.integrate

def construir_coeficientes_par(funcion, n_terminos, dx=1e-3):

    x = np.arange(0, 1 + dx/2, dx)
    y = funcion(x)
    coeficientes = []

    for k in range(n_terminos):
        termino_base = np.cos(k * np.pi * x)
        integrando = 2 * y * termino_base
        a_k = scipy.integrate.trapezoid(integrando, dx=dx)
        coeficientes.append(a_k)

    return coeficientes


def reconstruir_serie_par(coeficientes, x_eval):

    a0 = coeficientes[0]
    y_approx = (a0 / 2) * np.ones_like(x_eval)

    for k in range(1, len(coeficientes)):
        a_k = coeficientes[k]
        y_approx += a_k * np.cos(k * np.pi * x_eval)

    return y_approx


def f_par_extendida(x):

    return np.where(np.abs(x) <= 0.25, 1.0, 0.0)

def calcular_errores_completo(y_real, y_aprox, dx):

    diff = np.abs(y_real - y_aprox)
    err_l2 = np.sqrt(scipy.integrate.trapezoid(diff**2, dx=dx))
    err_unif = np.max(diff)
    return err_l2, err_unif

def reconstruir_cesaro_par(coeficientes, x_eval):

    N = len(coeficientes) - 1
    y_approx = np.zeros_like(x_eval)

    denominador = N + 1

    a0 = coeficientes[0]
    y_approx += (a0 / 2) * np.ones_like(x_eval)

    for k in range(1, len(coeficientes)):
        a_k = coeficientes[k]

        peso = (N - k + 1) / denominador

        y_approx += peso * a_k * np.cos(k * np.pi * x_eval)

    return y_approx

def reconstruir_lanczos_par(coeficientes, x_eval):

    N = len(coeficientes) - 1
    y_approx = np.zeros_like(x_eval)

    y_approx += (coeficientes[0] / 2)

    for k in range(1, len(coeficientes)):
        sigma = np.sinc(k / N)
        y_approx += sigma * coeficientes[k] * np.cos(k * np.pi * x_eval)

    return y_approx

def reconstruir_abel_r_variable(coeficientes, x_eval, r):

    y_approx = np.zeros_like(x_eval)

    y_approx += (coeficientes[0] / 2)

    for k in range(1, len(coeficientes)):
        peso = r**k
        y_approx += peso * coeficientes[k] * np.cos(k * np.pi * x_eval)

    return y_approx


# Gráficas de Fourier

dx_malla = 1e-4
N_max_calculo = 500
lista_N_dibujar = [1, 5, 20, 50, 100, 300]

x_completo = np.arange(-1, 1 + dx_malla/10, dx_malla)
y_real = f_par_extendida(x_completo)

coefs_totales = construir_coeficientes_par(f_par_extendida, N_max_calculo + 1, dx_malla)

plt.figure(figsize=(12, 6))

plt.plot(x_completo, y_real, 'k-', linewidth=2, label='Función Original', alpha=0.3)

colores = plt.cm.magma(np.linspace(0, 0.85, len(lista_N_dibujar)))
for i, n in enumerate(lista_N_dibujar):
    coefs_n = coefs_totales[:n+1]
    y_aprox = reconstruir_serie_par(coefs_n, x_completo)

    plt.plot(x_completo, y_aprox, label=f'N={n}', color=colores[i], linewidth=1.5)

plt.title(f'Gráfica de Fourier en [-1, 1]')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()


errores_l2 = []
errores_inf = []
rango_n = np.arange(1, N_max_calculo + 1)

for n in rango_n:
    coefs_n = coefs_totales[:n+1]
    y_aprox = reconstruir_serie_par(coefs_n, x_completo)

    l2, unif = calcular_errores_completo(y_real, y_aprox, dx_malla)
    errores_l2.append(l2)
    errores_inf.append(unif)

plt.figure(figsize=(10, 6))
plt.loglog(rango_n, errores_l2, 'b-o', label='Error L2', markersize=4)
plt.loglog(rango_n, errores_inf, 'r-s', label='Error Uniforme', markersize=4)

plt.title(f'Errores de Fourier en [-1, 1]')
plt.xlabel('N (log)')
plt.ylabel('Error (log)')
plt.legend()
plt.grid(True, which="both", alpha=0.3)
plt.show()

# Gráficas de Cesaro

dx_malla = 1e-4
N_max_calculo = 500
lista_N_dibujar = [1, 5, 20, 50, 100, 300]

x_completo = np.arange(-1, 1 + dx_malla/10, dx_malla)
y_real = f_par_extendida(x_completo)

coefs_totales = construir_coeficientes_par(f_par_extendida, N_max_calculo + 1, dx_malla)


plt.figure(figsize=(10, 6))

plt.plot(x_completo, y_real, 'k-', linewidth=2, label='Función Original', alpha=0.6)

colores = plt.cm.magma(np.linspace(0, 0.85, len(lista_N_dibujar)))

for i, n in enumerate(lista_N_dibujar):
    coefs_n = coefs_totales[:n+1]

    y_cesaro = reconstruir_cesaro_par(coefs_n, x_completo)

    plt.plot(x_completo, y_cesaro, label=f'N={n}', color=colores[i], linewidth=2)

plt.title(f'Gráfica de Cesàro en [-1, 1]')
plt.xlabel('x')
plt.ylabel('S_N(x)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()


errores_l2 = []
errores_inf = []
rango_n = np.arange(1, N_max_calculo + 1)

for n in rango_n:
    coefs_n = coefs_totales[:n+1]
    y_cesaro = reconstruir_cesaro_par(coefs_n, x_completo)

    l2, unif = calcular_errores_completo(y_real, y_cesaro, dx_malla)
    errores_l2.append(l2)
    errores_inf.append(unif)

plt.figure(figsize=(10, 6))
plt.loglog(rango_n, errores_l2, 'b-o', label='Error L2', markersize=4)
plt.loglog(rango_n, errores_inf, 'r-s', label='Error Uniforme', markersize=4)

plt.title(f'Errores de Cesàro en [-1, 1]')
plt.xlabel('N (log)')
plt.ylabel('Error (log)')
plt.legend()
plt.grid(True, which="both", alpha=0.3)
plt.show()

# Gráficas de Lanczos

dx_malla = 1e-4
N_max_calculo = 500
lista_N_dibujar = [1, 5, 20, 50, 100, 300]

x_completo = np.arange(-1, 1 + dx_malla/10, dx_malla)
y_real = f_par_extendida(x_completo)

coefs_totales = construir_coeficientes_par(f_par_extendida, N_max_calculo + 1, dx_malla)


plt.figure(figsize=(10, 6))
plt.plot(x_completo, y_real, 'k-', linewidth=2, label='Función Original', alpha=0.5)

colores = plt.cm.viridis(np.linspace(0, 0.9, len(lista_N_dibujar)))

for i, n in enumerate(lista_N_dibujar):
    coefs_n = coefs_totales[:n+1]
    y_lanczos = reconstruir_lanczos_par(coefs_n, x_completo)

    plt.plot(x_completo, y_lanczos, label=f'N={n}', color=colores[i])

plt.title(f'Gráfica de Lanczos en [-1, 1]')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()


errores_l2 = []
errores_inf = []
rango_n = np.arange(1, N_max_calculo + 1)

for n in rango_n:
    coefs_n = coefs_totales[:n+1]
    y_lanczos = reconstruir_lanczos_par(coefs_n, x_completo)

    l2, unif = calcular_errores_completo(y_real, y_lanczos, dx_malla)
    errores_l2.append(l2)
    errores_inf.append(unif)

plt.figure(figsize=(10, 6))
plt.loglog(rango_n, errores_l2, 'b-o', label='Error L2', markersize=4)
plt.loglog(rango_n, errores_inf, 'r-s', label='Error Uniforme', markersize=4)
plt.title(f'Errores de Lanczos en [-1, 1]')
plt.xlabel('N (log)')
plt.ylabel('Error (log)')
plt.legend()
plt.grid(True, which="both", alpha=0.3)
plt.show()

#Gráficas de Abel

dx_malla = 1e-4
N_FIJO = 300
lista_r_dibujar = [0.6, 0.8, 0.9, 0.95, 0.99, 0.999]

x_completo = np.arange(-1, 1 + dx_malla/10, dx_malla)
y_real = f_par_extendida(x_completo)

coefs_fijos = construir_coeficientes_par(f_par_extendida, N_FIJO + 1, dx_malla)


plt.figure(figsize=(10, 6))
plt.plot(x_completo, y_real, 'k-', linewidth=2, label='Función Original', alpha=0.3)

colores = plt.cm.Blues(np.linspace(0.4, 1.0, len(lista_r_dibujar)))

for i, r_val in enumerate(lista_r_dibujar):
    y_abel = reconstruir_abel_r_variable(coefs_fijos, x_completo, r_val)

    plt.plot(x_completo, y_abel, label=f'r={r_val}', color=colores[i], linewidth=1.5)

plt.title(f'Gráfica de Abel en [-1, 1]')
plt.xlabel('x')
plt.ylabel('A_r(x)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()


r_range = np.linspace(0.5, 0.999, 100)

errores_l2 = []
errores_inf = []

for r_val in r_range:
    y_abel = reconstruir_abel_r_variable(coefs_fijos, x_completo, r_val)

    l2, unif = calcular_errores_completo(y_real, y_abel, dx_malla)
    errores_l2.append(l2)
    errores_inf.append(unif)

plt.figure(figsize=(10, 6))
plt.loglog(r_range, errores_l2, 'b-o', label='Error L2', markersize=4)
plt.loglog(r_range, errores_inf, 'r-s', label='Error Uniforme', markersize=4)
plt.title(f'Errores de Abel en [-1, 1]')
plt.xlabel('r (log)')
plt.ylabel('Error (log)')
plt.legend()
plt.grid(True, which="both", alpha=0.3)
plt.show()

plt.show()