Series de Fourier RAJ

2026-02-18T19:20:58Z

Rodrigo.gallardo:

{{ TrabajoED | Series de Fourier. Grupo RAJ| [[:Categoría:EDP|EDP]]|[[:Categoría:EDP25/26|2025-26]] | Rodrigo Gallardo García

Alejandro Cogollor Torres

Javier Martín Pérez }}

Se adjunta a continuación el código utilizado para la visualización de las gráficas expuestas durante la presentación.

<source lang="python" line>

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()

</source>

[[Categoría:EDP]]
[[Categoría:EDP25/26]]

MateWiki - Contribuciones del usuario [es]

Series de Fourier RAJ