MateWiki - Contribuciones del usuario [es]

Archivo:Ecuación del calor RAJ.pdf

2026-04-12T11:20:11Z

Alejandro.mates:

Archivo:Ecuación del calor RAJ.png

2026-04-12T11:19:22Z

Alejandro.mates:

Ecuación del calor RAJ

2026-04-12T11:17:59Z

Alejandro.mates: Página creada con «{{ TrabajoED | Ecuación del calor. Grupo LÁJ| EDP|2025-26 | Luis García Suárez Álvaro Moreno Cisneros Juan Pérez Guerra...»

{{ TrabajoED | Ecuación del calor. Grupo LÁJ| [[:Categoría:EDP|EDP]]|[[:Categoría:EDP25/26|2025-26]] | Luis García Suárez

Álvaro Moreno Cisneros

Juan Pérez Guerra }}

[[Archivo:Ecuación del calor RAJ.png||800px]]
[[Medio:Ecuación del calor RAJ.pdf| PDF del póster]]

Abajo se puede ver el código que se ha utilizado para conseguir las gráficas.

<source lang="python" line>

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from mpl_toolkits.mplot3d import Axes3D

#Visualización unidimensional

def nucleo_calor(x, t):
return (1.0 / np.sqrt(4 * np.pi * t)) * np.exp(-(x**2) / (4 * t))

def condicion_inicial_escalon(x):
return np.where((x >= 0) & (x <= 1), 1.0, 0.0)

def condicion_inicial_gaussiana(x):
return np.exp(-x**2)

def resolver_calor_integral(x_eval, t, u0_func, y_min=-10, y_max=10, dy=0.002):
y = np.arange(y_min, y_max, dy)
u0_y = u0_func(y)

u_vals = np.zeros_like(x_eval, dtype=float)

for i, x in enumerate(x_eval):
integrando = nucleo_calor(x - y, t) * u0_y
u_vals[i] = np.trapezoid(integrando, y)

return u_vals

x_dominio = np.linspace(-2, 3, 500)
tiempos = [0.001, 0.01, 0.1, 0.5, 1]

plt.figure(figsize=(10, 6))
plt.plot(x_dominio, condicion_inicial_escalon(x_dominio), 'k--', label='t = 0 (Dato Inicial)')

for t in tiempos:
u_t = resolver_calor_integral(x_dominio, t, condicion_inicial_escalon)
plt.plot(x_dominio, u_t, label=f't = {t}')

plt.title(r'Evolución de la Ecuación del Calor por Convolución en $\mathbb{R}$')
plt.xlabel('Posición x')
plt.ylabel('Temperatura u(x,t)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
plt.close()

x_vals = np.linspace(-2, 3, 100)
t_vals = np.linspace(0.001, 2, 100)

X_mesh, T_mesh = np.meshgrid(x_vals, t_vals)

y_int = np.linspace(0, 1, 300)

diffs = X_mesh[:, :, np.newaxis] - y_int[np.newaxis, np.newaxis, :]
kernel_vals = nucleo_calor(diffs, T_mesh[:, :, np.newaxis])
u0_y = condicion_inicial_escalon(y_int)[np.newaxis, np.newaxis, :]

U_solution = np.trapezoid(kernel_vals * u0_y, x=y_int, axis=2)

fig = plt.figure(figsize=(9, 7))
ax = fig.add_subplot(111, projection='3d')

surf = ax.plot_surface(X_mesh, T_mesh, U_solution, cmap='viridis',
edgecolor='none', alpha=0.9, antialiased=True)

ax.set_title(r'Evolución Espacio-Temporal de la Ecuación del Calor por Convolución en $\mathbb{R}$')
ax.set_xlabel('Posición x')
ax.set_ylabel('Tiempo t')
ax.set_zlabel('Temperatura u(x,t)')

fig.colorbar(surf, ax=ax, shrink=0.5, aspect=10, label='Temperatura')

ax.view_init(elev=30, azim=-120)

plt.tight_layout()

plt.show()

#Velocidad Infinita de Propagación

x_lejos = np.linspace(1.5, 10, 300)

plt.figure(figsize=(10, 6))
for t in tiempos:
u_t_lejos = resolver_calor_integral(x_lejos, t, condicion_inicial_escalon)
plt.plot(x_lejos, u_t_lejos + 1e-300, label=f't = {t}')

plt.yscale('log')
plt.title('Velocidad Infinita de Propagación')
plt.xlabel('Posición x')
plt.ylabel('Temperatura u(x,t) - Escala Logarítmica')
plt.legend()
plt.grid(True, which="both", ls="--", alpha=0.5)
plt.tight_layout()
plt.show()
plt.close()

puntos_obs = [-1.0, -0.1, 0.5, 1.1, 2.0]
tabla_datos = {'Posición (x)': puntos_obs, 'u(x, t=0)': [0.0, 0.0, 1.0, 0.0, 0.0]}

for t in tiempos:
valores = resolver_calor_integral(np.array(puntos_obs), t, condicion_inicial_escalon)
tabla_datos[f't={t}'] = valores

df = pd.DataFrame(tabla_datos)
print("\n--- Tabla de Propagación ---")
print(df.to_string(index=False))
df.to_csv('tabla_propagacion.csv', index=False)

#Comparación del decaimiento

def max_R_t(t):
y = np.linspace(-5, 6, 2000)
integrando = nucleo_calor(0.5 - y, t) * condicion_inicial_escalon(y)
return np.trapezoid(integrando, y)

def max_acotado_t(t, L=5.0, X_centro=0.5, terms=50):
val = 0
for n in range(1, terms + 1):
bn = (2.0 / (n * np.pi)) * (1 - np.cos(n * np.pi * 1.0 / L))
val += bn * np.exp(-((n * np.pi / L)**2) * t) * np.sin(n * np.pi * X_centro / L)
return val

def norm_L2_R_t(t):
x_vals = np.linspace(-15, 15, 1000)
y_vals = np.linspace(-1, 2, 400)

X, Y = np.meshgrid(x_vals, y_vals)
K = nucleo_calor(X - Y, t)
u0 = condicion_inicial_escalon(Y)

u_vals = np.trapezoid(K * u0, x=y_vals, axis=0)

integral_u2 = np.trapezoid(u_vals**2, x=x_vals)
return np.sqrt(integral_u2)

def norm_L2_acotado_t(t, L=5.0, terms=50):
norm_cuadrado = 0
for n in range(1, terms + 1):
bn = (2.0 / (n * np.pi)) * (1 - np.cos(n * np.pi * 1.0 / L))
lambda_n = (n * np.pi / L)**2
norm_cuadrado += (bn**2) * np.exp(-2 * lambda_n * t)
return np.sqrt((L / 2.0) * norm_cuadrado)

tiempos = np.linspace(0.1, 50, 100)
max_R = [max_R_t(t) for t in tiempos]
max_acotado = [max_acotado_t(t) for t in tiempos]

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

plt.plot(tiempos, max_R, label=r'Dominio $\mathbb{R}$ (Decaimiento $t^{-1/2}$)', color='blue', lw=2)
plt.plot(tiempos, max_acotado, label=r'Dominio Acotado (Decaimiento $e^{-\lambda_1 t}$)', color='red', lw=2)

plt.yscale('log')

plt.title('Comparativa de Decaimiento de la Temperatura Máxima')
plt.xlabel('Tiempo t')
plt.ylabel('Temperatura Máxima - Escala Logarítmica')
plt.grid(True, which="both", ls="--", alpha=0.5)
plt.legend()
plt.tight_layout()

plt.show()

tiempos = np.linspace(0.1, 50, 100)
norma_R = [norm_L2_R_t(t) for t in tiempos]
norma_acotado = [norm_L2_acotado_t(t) for t in tiempos]

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

plt.plot(tiempos, norma_R, label=r'Dominio $\mathbb{R}$ (Decaimiento $t^{-1/4}$)', color='blue', lw=2)
plt.plot(tiempos, norma_acotado, label=r'Dominio Acotado (Decaimiento $e^{-\lambda_1 t}$)', color='red', lw=2)

plt.yscale('log')
plt.title('Comparativa de Decaimiento en Norma $L^2$')
plt.xlabel('Tiempo t')
plt.ylabel('Norma $L^2$ - Escala Logarítmica')
plt.grid(True, which="both", ls="--", alpha=0.5)
plt.legend()
plt.tight_layout()

plt.show()

#Visualización del Caso bidimensional

def nucleo_calor_2d(x, y, t):
return (1.0 / (4 * np.pi * t)) * np.exp(-(x**2 + y**2) / (4 * t))

def u0_gaussiana_2d(x, y):
return np.exp(-(x**2 + y**2))

def u0_escalon_2d(x, y):
return np.where((np.abs(x) <= 0.5) & (np.abs(y) <= 0.5), 1.0, 0.0)

def resolver_calor_convolucion_2d_trapecio(X, Y, t, u0_func,
xi_min=-2, xi_max=2,
eta_min=-2, eta_max=2,
dxi=0.05, deta=0.05):

xi = np.arange(xi_min, xi_max, dxi)
eta = np.arange(eta_min, eta_max, deta)
XI, ETA = np.meshgrid(xi, eta)

u0_vals = u0_func(XI, ETA)

Z = np.zeros_like(X)

for i in range(X.shape[0]):
for j in range(X.shape[1]):

kernel = nucleo_calor_2d(X[i, j] - XI, Y[i, j] - ETA, t)
integrando = kernel * u0_vals

integral_eta = np.trapezoid(integrando, eta, axis=0)
integral_total = np.trapezoid(integral_eta, xi)

Z[i, j] = integral_total

return Z

x_vals = np.linspace(-1, 1, 100)
y_vals = np.linspace(-1, 1, 100)
X, Y = np.meshgrid(x_vals, y_vals)

tiempos = [0.01, 0.1, 1]

fig = plt.figure(figsize=(18, 8))

for i, t in enumerate(tiempos):

L = 5 * np.sqrt(t)

Z = resolver_calor_convolucion_2d_trapecio(
X, Y, t,
u0_gaussiana_2d,
xi_min=-L, xi_max=L,
eta_min=-L, eta_max=L,
dxi=0.05, deta=0.05
)

ax = fig.add_subplot(1, 3, i+1, projection='3d')

surf = ax.plot_surface(X, Y, Z, cmap='inferno', edgecolor='none', alpha=0.9)

ax.set_title(f'Tiempo t = {t}', fontsize=12)
ax.set_xlabel('$x_1$', fontsize=14)
ax.set_ylabel('$x_2$', fontsize=14)
ax.set_zlabel('$u(x,t)$', fontsize=14)

ax.tick_params(axis='x', labelsize=12)
ax.tick_params(axis='y', labelsize=12)
ax.tick_params(axis='z', labelsize=12)

ax.view_init(elev=25, azim=-45)

plt.suptitle(r'Solución por Convolución de la Ecuación del Calor en $\mathbb{R}^2$', fontsize=20, y=0.98)
plt.tight_layout(rect=[0, 0.03, 1, 0.95], w_pad=4.0)

plt.show()

</source>

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

Archivo:Series de fourier RAJ.jpeg

2026-02-18T21:16:26Z

Alejandro.mates:

Series de Fourier RAJ

2026-02-18T21:16:01Z

Alejandro.mates:

{{ 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 }}

[[Archivo:Series de fourier RAJ.jpeg||800px]]
[[Archivo:Poster_Gibbs_RAJ.pdf]]

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]]

Series de Fourier RAJ

2026-02-18T21:14:51Z

Alejandro.mates:

Archivo:Póster Fenómeno de Gibbs.png

2026-02-18T21:11:52Z

Alejandro.mates:

Series de Fourier RAJ

2026-02-18T21:07:47Z

Alejandro.mates:

{{ 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 }}

[[Archivo:Póster Fenómeno de Gibbs.png||800px]]
[[Archivo:Poster_Gibbs_RAJ.pdf]]

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]]

Series de Fourier RAJ

2026-02-18T21:07:25Z

Alejandro.mates:

Archivo:Fenómeno de Gibbs.png

2026-02-18T21:06:34Z

Alejandro.mates:

Archivo:Poster Gibbs RAJ.pdf

2026-02-18T21:06:04Z

Alejandro.mates:

Archivo:Poster Gibbs RAJ.png

2026-02-18T21:04:59Z

Alejandro.mates:

Series de Fourier RAJ

2026-02-18T21:03:56Z

Alejandro.mates:

{{ 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 }}

[[Archivo:Fenómeno de Gibbs.png||800px]]
[[Archivo:Poster_Gibbs_RAJ.pdf]]

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]]

Series de Fourier RAJ

2026-02-18T19:01:37Z

Alejandro.mates:

{{ 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 f_discontinua(x):
"""
Define la función característica del intervalo [0, 1/4].
Retorna 1 si 0 <= x <= 0.25, y 0 en otro caso.
"""
# Usamos np.where para vectorizar la operación sobre arrays de numpy
return np.where((x >= 0) & (x <= 0.25), 1.0, 0.0)

def construir_coeficientes_par(funcion, n_terminos, dx=1e-3):
"""
Construye los coeficientes de Fourier para una extensión PAR de la función dada.

Parámetros:
-----------
funcion : callable
Función f(x) definida en [0, 1].
n_terminos : int
Número de coeficientes a calcular (incluyendo a0).
dx : float
Tamaño de la malla para la integración numérica (Sugerencia: 10^-3).

Retorna:
--------
coeficientes : list
Lista [a0, a1, ..., a_n-1] calculada mediante la regla del trapecio.
"""

# 1. Definir la malla de integración [0, 1]
# Se usa arange hasta 1 + dx/2 para asegurar que incluye el punto final 1.0
x = np.arange(0, 1 + dx/2, dx)

# 2. Evaluar la función en la malla
y = funcion(x)

coeficientes = []

# 3. Calcular los coeficientes a_k
for k in range(n_terminos):
# Base trigonométrica par: cos(k * pi * x)
termino_base = np.cos(k * np.pi * x)

# Integrando: 2 * f(x) * cos(k*pi*x)
# El factor '2' proviene de la simetría par en [-1, 1]
integrando = 2 * y * termino_base

# Aproximación de la integral usando la regla del trapecio
# Tal como se sugiere en el punto 2 del texto
a_k = scipy.integrate.trapezoid(integrando, dx=dx)

coeficientes.append(a_k)

return coeficientes

# ---------------------------------------------------------
# 1. Función de Reconstrucción (Solicitada al inicio)
# ---------------------------------------------------------
def reconstruir_serie_par(coeficientes, x_eval):
"""
Reconstruye la serie de Fourier de cosenos.
S_N(x) = a0/2 + sum(a_k * cos(k*pi*x))

Parámetros:
-----------
coeficientes : list
Coeficientes [a0, a1, ..., aN] calculados.
x_eval : array
Puntos donde evaluar la serie (puede ser [-1, 1]).
"""
# 1. Término constante (siempre es a0 / 2)
a0 = coeficientes[0]
y_approx = (a0 / 2) * np.ones_like(x_eval)

# 2. Sumar términos cosenos
# La paridad (simetría) en [-1, 1] es automática con cos(k*pi*x)
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

# ---------------------------------------------------------
# 2. Funciones Auxiliares (Coeficientes y Error)
# ---------------------------------------------------------
def f_par_extendida(x):
"""
Define la función par en todo el eje real.
f(x) = 1 si |x| <= 0.25, 0 en otro caso.
"""
return np.where(np.abs(x) <= 0.25, 1.0, 0.0)

def construir_coeficientes(n_terminos, dx):
"""
Calcula a_k integrando solo en [0, 1] (suficiente por simetría).
Usa 'dx' para crear la malla con np.arange (sin linspace).
"""
# Malla positiva [0, 1] para la integral
x = np.arange(0, 1 + dx/10, dx)
y = f_par_extendida(x)

coefs = []
for k in range(n_terminos):
base = np.cos(k * np.pi * x)
integrando = 2 * y * base
# Integral numérica
a_k = scipy.integrate.trapezoid(integrando, dx=dx)
coefs.append(a_k)
return coefs

def calcular_errores_completo(y_real, y_aprox, dx):
"""Calcula errores L2 y Uniforme en el dominio dado."""
diff = np.abs(y_real - y_aprox)
# L2 = sqrt( integral(diff^2) )
err_l2 = np.sqrt(scipy.integrate.trapezoid(diff**2, dx=dx))
# Uniforme = max(diff)
err_unif = np.max(diff)
return err_l2, err_unif

def reconstruir_cesaro_par(coeficientes, x_eval):
"""
Reconstruye la Suma de Cesàro (promedio de sumas parciales).
Matemáticamente equivale a multiplicar los coeficientes a_k
por el peso triangular: (N - k + 1) / (N + 1).

Parámetros:
-----------
coeficientes : list
[a0, a1, ..., aN] calculados previamente.
x_eval : array
Puntos de evaluación.
"""
N = len(coeficientes) - 1 # El índice máximo es N
y_approx = np.zeros_like(x_eval)

# El denominador común del peso es N + 1
denominador = N + 1

# 1. Término constante a0/2
# El peso de Cesàro para k=0 es (N - 0 + 1)/(N+1) = 1.
# Pero recordamos que en la serie el término es a0/2.
a0 = coeficientes[0]
y_approx += (a0 / 2) * np.ones_like(x_eval)

# 2. Términos cosenos con pesos de Fejér
for k in range(1, len(coeficientes)):
a_k = coeficientes[k]

# Peso triangular que define la suma de Cesàro
peso = (N - k + 1) / denominador

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

return y_approx

# --- Función para Método de Lanczos (Factores Sigma) ---
def reconstruir_lanczos_par(coeficientes, x_eval):
"""
Reconstruye usando factores Sigma (sinc).
Suaviza Gibbs manteniendo buena pendiente.
"""
N = len(coeficientes) - 1
y_approx = np.zeros_like(x_eval)

# Término a0/2
y_approx += (coeficientes[0] / 2)

# Términos cosenos multiplicados por sigma = sinc(k/N)
for k in range(1, len(coeficientes)):
# np.sinc(x) calcula sin(pi*x)/(pi*x)
sigma = np.sinc(k / N)
y_approx += sigma * coeficientes[k] * np.cos(k * np.pi * x_eval)

return y_approx

# --- Función para Método de Abel (Poisson) ---
def reconstruir_abel_r_variable(coeficientes, x_eval, r):
"""
Reconstruye la serie usando Abel con un r fijo dado por el usuario.
"""
y_approx = np.zeros_like(x_eval)

# Término a0/2 (r^0 = 1)
y_approx += (coeficientes[0] / 2)

# Términos cosenos multiplicados por r^k
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

# ---------------------------------------------------------
# 3. Ejecución y Gráficas (Extensión Par Completa [-1, 1])
# ---------------------------------------------------------

# A. Parámetros Basados en Malla (Sin número fijo de puntos)
dx_malla = 1e-4 # Tamaño del paso (resolución)
N_max_calculo = 500 # Máximo N para el análisis de error
lista_N_dibujar = [1, 5, 20, 50, 100, 500]

# B. Construcción del Dominio Completo [-1, 1]
# Usamos arange: start=-1, stop=1 (con margen), step=dx
x_completo = np.arange(-1, 1 + dx_malla/10, dx_malla)
y_real = f_par_extendida(x_completo)

# C. Cálculo de Coeficientes (una sola vez hasta N_max)
coefs_totales = construir_coeficientes(N_max_calculo + 1, dx_malla)

# --- GRÁFICA 1: Función y Aproximaciones ---
plt.figure(figsize=(12, 6))

# Dibujar la función original (Exacta)
plt.plot(x_completo, y_real, 'k-', linewidth=2, label='Función Original (Par)', alpha=0.3)

# Dibujar las aproximaciones para distintos N
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'Extensión Par Completa en [-1, 1] (dx={dx_malla})')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# --- GRÁFICA 2: Evolución de Errores (L2 y Uniforme) ---
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)

# Calcular error sobre todo el intervalo [-1, 1]
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 [-1, 1]', markersize=4)
plt.loglog(rango_n, errores_inf, 'r-s', label='Error Uniforme (Max)', markersize=4)

plt.title('Evolución del Error vs Número de Términos')
plt.xlabel('N (log)')
plt.ylabel('Error (log)')
plt.legend()
plt.grid(True, which="both", alpha=0.3)
plt.show()

# Parámetros globales
dx_malla = 1e-4
N_max_calculo = 500
lista_N_dibujar = [1, 5, 20, 50, 100, 500]

# Dominio completo [-1, 1] usando arange y dx
x_completo = np.arange(-1, 1 + dx_malla/10, dx_malla)
y_real = f_par_extendida(x_completo)

# Calcular coeficientes "crudos" una sola vez
coefs_totales = construir_coeficientes_par(f_par_extendida, N_max_calculo + 1, dx_malla)

# --- GRÁFICA 1: Aproximación de Cesàro ---
plt.figure(figsize=(10, 6))

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

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

for i, n in enumerate(lista_N_dibujar):
# Para Cesàro de orden N, necesitamos coeficientes hasta N
coefs_n = coefs_totales[:n+1]

# Reconstrucción usando la función de Cesàro
y_cesaro = reconstruir_cesaro_par(coefs_n, x_completo)

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

plt.title(f'Sumas de Cesàro (Mitigación de Gibbs) en [-1, 1]')
plt.xlabel('x')
plt.ylabel('S_N(x) [Cesàro]')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# --- GRÁFICA 2: Evolución de Errores (Cesàro) ---
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 (Cesàro)', markersize=4)
plt.loglog(rango_n, errores_inf, 'r-s', label='Error Uniforme (Cesàro)', markersize=4)

plt.title('Evolución del Error en Sumas de Cesàro vs N')
plt.xlabel('N (log)')
plt.ylabel('Error (log)')
plt.legend()
plt.grid(True, which="both", alpha=0.3)
plt.show()

# --- Configuración (Tomamos los valores del caso anterior) ---
dx_malla = 1e-4
N_max_calculo = 500
lista_N_dibujar = [5, 20, 50, 100, 500]

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

# Calculamos coeficientes (si no existen ya en memoria)
# Nota: Aquí SÍ usamos dx_malla
coefs_totales = construir_coeficientes(N_max_calculo + 1, dx_malla)

# ---------------------------------------------------------
# GRÁFICAS LANCZOS
# ---------------------------------------------------------

# 1. Aproximación Visual
plt.figure(figsize=(10, 6))
plt.plot(x_completo, y_real, 'k-', linewidth=2, label='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]
# Aquí NO hace falta dx, solo coeficientes y x
y_lanczos = reconstruir_lanczos_par(coefs_n, x_completo)

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

plt.title('Método de Lanczos (Factores Sigma)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# 2. Evolución del Error
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)

# Aquí usamos dx SOLO para calcular la integral del error L2
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('Error en Lanczos vs N')
plt.xlabel('N (log)')
plt.ylabel('Error (log)')
plt.legend()
plt.grid(True, which="both", alpha=0.3)
plt.show()

dx_malla = 1e-4
N_FIJO = 300 # Fijamos un N alto para tener "espacio" de frecuencias
lista_r_dibujar = [0.6, 0.8, 0.9, 0.95, 0.99, 0.999] # Variamos r

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

# Calculamos coeficientes HASTA N_FIJO
coefs_fijos = construir_coeficientes(N_FIJO + 1, dx_malla)

# ---------------------------------------------------------
# GRÁFICA 1: Aproximación Visual (N fijo, r variable)
# ---------------------------------------------------------
plt.figure(figsize=(10, 6))
plt.plot(x_completo, y_real, 'k-', linewidth=2, label='Original', alpha=0.3)

# Usamos un mapa de colores secuencial (Blues) para ver la progresión de r
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'Método de Abel variando r (N fijo = {N_FIJO})')
plt.xlabel('x')
plt.ylabel('A_r(x)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# ---------------------------------------------------------
# GRÁFICA 2: Evolución del Error vs r
# ---------------------------------------------------------
# Generamos muchos valores de r entre 0.5 y 0.999
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'Evolución del Error al aumentar r (N={N_FIJO})')
plt.xlabel('Valor de r')
plt.ylabel('Error')
plt.legend()
plt.grid(True, which="both", alpha=0.3)
plt.show()

# Invertimos el eje X si quieres ver el efecto de acercarse a 1,
# o simplemente observamos que al acercarse a 1 el error L2 baja pero el Uniforme sube (Gibbs).
plt.show()

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]]

Series de Fourier RAJ

2026-02-18T18:58:00Z

Alejandro.mates:

{{ 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 }}

<source lang="python" line>

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

def f_discontinua(x):
"""
Define la función característica del intervalo [0, 1/4].
Retorna 1 si 0 <= x <= 0.25, y 0 en otro caso.
"""
# Usamos np.where para vectorizar la operación sobre arrays de numpy
return np.where((x >= 0) & (x <= 0.25), 1.0, 0.0)

def construir_coeficientes_par(funcion, n_terminos, dx=1e-3):
"""
Construye los coeficientes de Fourier para una extensión PAR de la función dada.

Parámetros:
-----------
funcion : callable
Función f(x) definida en [0, 1].
n_terminos : int
Número de coeficientes a calcular (incluyendo a0).
dx : float
Tamaño de la malla para la integración numérica (Sugerencia: 10^-3).

Retorna:
--------
coeficientes : list
Lista [a0, a1, ..., a_n-1] calculada mediante la regla del trapecio.
"""

# 1. Definir la malla de integración [0, 1]
# Se usa arange hasta 1 + dx/2 para asegurar que incluye el punto final 1.0
x = np.arange(0, 1 + dx/2, dx)

# 2. Evaluar la función en la malla
y = funcion(x)

coeficientes = []

# 3. Calcular los coeficientes a_k
for k in range(n_terminos):
# Base trigonométrica par: cos(k * pi * x)
termino_base = np.cos(k * np.pi * x)

# Integrando: 2 * f(x) * cos(k*pi*x)
# El factor '2' proviene de la simetría par en [-1, 1]
integrando = 2 * y * termino_base

# Aproximación de la integral usando la regla del trapecio
# Tal como se sugiere en el punto 2 del texto
a_k = scipy.integrate.trapezoid(integrando, dx=dx)

coeficientes.append(a_k)

return coeficientes

# ---------------------------------------------------------
# 1. Función de Reconstrucción (Solicitada al inicio)
# ---------------------------------------------------------
def reconstruir_serie_par(coeficientes, x_eval):
"""
Reconstruye la serie de Fourier de cosenos.
S_N(x) = a0/2 + sum(a_k * cos(k*pi*x))

Parámetros:
-----------
coeficientes : list
Coeficientes [a0, a1, ..., aN] calculados.
x_eval : array
Puntos donde evaluar la serie (puede ser [-1, 1]).
"""
# 1. Término constante (siempre es a0 / 2)
a0 = coeficientes[0]
y_approx = (a0 / 2) * np.ones_like(x_eval)

# 2. Sumar términos cosenos
# La paridad (simetría) en [-1, 1] es automática con cos(k*pi*x)
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

# ---------------------------------------------------------
# 2. Funciones Auxiliares (Coeficientes y Error)
# ---------------------------------------------------------
def f_par_extendida(x):
"""
Define la función par en todo el eje real.
f(x) = 1 si |x| <= 0.25, 0 en otro caso.
"""
return np.where(np.abs(x) <= 0.25, 1.0, 0.0)

def construir_coeficientes(n_terminos, dx):
"""
Calcula a_k integrando solo en [0, 1] (suficiente por simetría).
Usa 'dx' para crear la malla con np.arange (sin linspace).
"""
# Malla positiva [0, 1] para la integral
x = np.arange(0, 1 + dx/10, dx)
y = f_par_extendida(x)

coefs = []
for k in range(n_terminos):
base = np.cos(k * np.pi * x)
integrando = 2 * y * base
# Integral numérica
a_k = scipy.integrate.trapezoid(integrando, dx=dx)
coefs.append(a_k)
return coefs

def calcular_errores_completo(y_real, y_aprox, dx):
"""Calcula errores L2 y Uniforme en el dominio dado."""
diff = np.abs(y_real - y_aprox)
# L2 = sqrt( integral(diff^2) )
err_l2 = np.sqrt(scipy.integrate.trapezoid(diff**2, dx=dx))
# Uniforme = max(diff)
err_unif = np.max(diff)
return err_l2, err_unif

def reconstruir_cesaro_par(coeficientes, x_eval):
"""
Reconstruye la Suma de Cesàro (promedio de sumas parciales).
Matemáticamente equivale a multiplicar los coeficientes a_k
por el peso triangular: (N - k + 1) / (N + 1).

Parámetros:
-----------
coeficientes : list
[a0, a1, ..., aN] calculados previamente.
x_eval : array
Puntos de evaluación.
"""
N = len(coeficientes) - 1 # El índice máximo es N
y_approx = np.zeros_like(x_eval)

# El denominador común del peso es N + 1
denominador = N + 1

# 1. Término constante a0/2
# El peso de Cesàro para k=0 es (N - 0 + 1)/(N+1) = 1.
# Pero recordamos que en la serie el término es a0/2.
a0 = coeficientes[0]
y_approx += (a0 / 2) * np.ones_like(x_eval)

# 2. Términos cosenos con pesos de Fejér
for k in range(1, len(coeficientes)):
a_k = coeficientes[k]

# Peso triangular que define la suma de Cesàro
peso = (N - k + 1) / denominador

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

return y_approx

# --- Función para Método de Lanczos (Factores Sigma) ---
def reconstruir_lanczos_par(coeficientes, x_eval):
"""
Reconstruye usando factores Sigma (sinc).
Suaviza Gibbs manteniendo buena pendiente.
"""
N = len(coeficientes) - 1
y_approx = np.zeros_like(x_eval)

# Término a0/2
y_approx += (coeficientes[0] / 2)

# Términos cosenos multiplicados por sigma = sinc(k/N)
for k in range(1, len(coeficientes)):
# np.sinc(x) calcula sin(pi*x)/(pi*x)
sigma = np.sinc(k / N)
y_approx += sigma * coeficientes[k] * np.cos(k * np.pi * x_eval)

return y_approx

# --- Función para Método de Abel (Poisson) ---
def reconstruir_abel_r_variable(coeficientes, x_eval, r):
"""
Reconstruye la serie usando Abel con un r fijo dado por el usuario.
"""
y_approx = np.zeros_like(x_eval)

# Término a0/2 (r^0 = 1)
y_approx += (coeficientes[0] / 2)

# Términos cosenos multiplicados por r^k
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

# ---------------------------------------------------------
# 3. Ejecución y Gráficas (Extensión Par Completa [-1, 1])
# ---------------------------------------------------------

# A. Parámetros Basados en Malla (Sin número fijo de puntos)
dx_malla = 1e-4 # Tamaño del paso (resolución)
N_max_calculo = 500 # Máximo N para el análisis de error
lista_N_dibujar = [1, 5, 20, 50, 100, 500]

# B. Construcción del Dominio Completo [-1, 1]
# Usamos arange: start=-1, stop=1 (con margen), step=dx
x_completo = np.arange(-1, 1 + dx_malla/10, dx_malla)
y_real = f_par_extendida(x_completo)

# C. Cálculo de Coeficientes (una sola vez hasta N_max)
coefs_totales = construir_coeficientes(N_max_calculo + 1, dx_malla)

# --- GRÁFICA 1: Función y Aproximaciones ---
plt.figure(figsize=(12, 6))

# Dibujar la función original (Exacta)
plt.plot(x_completo, y_real, 'k-', linewidth=2, label='Función Original (Par)', alpha=0.3)

# Dibujar las aproximaciones para distintos N
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'Extensión Par Completa en [-1, 1] (dx={dx_malla})')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# --- GRÁFICA 2: Evolución de Errores (L2 y Uniforme) ---
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)

# Calcular error sobre todo el intervalo [-1, 1]
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 [-1, 1]', markersize=4)
plt.loglog(rango_n, errores_inf, 'r-s', label='Error Uniforme (Max)', markersize=4)

plt.title('Evolución del Error vs Número de Términos')
plt.xlabel('N (log)')
plt.ylabel('Error (log)')
plt.legend()
plt.grid(True, which="both", alpha=0.3)
plt.show()

# Parámetros globales
dx_malla = 1e-4
N_max_calculo = 500
lista_N_dibujar = [1, 5, 20, 50, 100, 500]

# Dominio completo [-1, 1] usando arange y dx
x_completo = np.arange(-1, 1 + dx_malla/10, dx_malla)
y_real = f_par_extendida(x_completo)

# Calcular coeficientes "crudos" una sola vez
coefs_totales = construir_coeficientes_par(f_par_extendida, N_max_calculo + 1, dx_malla)

# --- GRÁFICA 1: Aproximación de Cesàro ---
plt.figure(figsize=(10, 6))

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

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

for i, n in enumerate(lista_N_dibujar):
# Para Cesàro de orden N, necesitamos coeficientes hasta N
coefs_n = coefs_totales[:n+1]

# Reconstrucción usando la función de Cesàro
y_cesaro = reconstruir_cesaro_par(coefs_n, x_completo)

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

plt.title(f'Sumas de Cesàro (Mitigación de Gibbs) en [-1, 1]')
plt.xlabel('x')
plt.ylabel('S_N(x) [Cesàro]')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# --- GRÁFICA 2: Evolución de Errores (Cesàro) ---
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 (Cesàro)', markersize=4)
plt.loglog(rango_n, errores_inf, 'r-s', label='Error Uniforme (Cesàro)', markersize=4)

plt.title('Evolución del Error en Sumas de Cesàro vs N')
plt.xlabel('N (log)')
plt.ylabel('Error (log)')
plt.legend()
plt.grid(True, which="both", alpha=0.3)
plt.show()

# --- Configuración (Tomamos los valores del caso anterior) ---
dx_malla = 1e-4
N_max_calculo = 500
lista_N_dibujar = [5, 20, 50, 100, 500]

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

# Calculamos coeficientes (si no existen ya en memoria)
# Nota: Aquí SÍ usamos dx_malla
coefs_totales = construir_coeficientes(N_max_calculo + 1, dx_malla)

# ---------------------------------------------------------
# GRÁFICAS LANCZOS
# ---------------------------------------------------------

# 1. Aproximación Visual
plt.figure(figsize=(10, 6))
plt.plot(x_completo, y_real, 'k-', linewidth=2, label='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]
# Aquí NO hace falta dx, solo coeficientes y x
y_lanczos = reconstruir_lanczos_par(coefs_n, x_completo)

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

plt.title('Método de Lanczos (Factores Sigma)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# 2. Evolución del Error
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)

# Aquí usamos dx SOLO para calcular la integral del error L2
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('Error en Lanczos vs N')
plt.xlabel('N (log)')
plt.ylabel('Error (log)')
plt.legend()
plt.grid(True, which="both", alpha=0.3)
plt.show()

dx_malla = 1e-4
N_FIJO = 300 # Fijamos un N alto para tener "espacio" de frecuencias
lista_r_dibujar = [0.6, 0.8, 0.9, 0.95, 0.99, 0.999] # Variamos r

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

# Calculamos coeficientes HASTA N_FIJO
coefs_fijos = construir_coeficientes(N_FIJO + 1, dx_malla)

# ---------------------------------------------------------
# GRÁFICA 1: Aproximación Visual (N fijo, r variable)
# ---------------------------------------------------------
plt.figure(figsize=(10, 6))
plt.plot(x_completo, y_real, 'k-', linewidth=2, label='Original', alpha=0.3)

# Usamos un mapa de colores secuencial (Blues) para ver la progresión de r
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'Método de Abel variando r (N fijo = {N_FIJO})')
plt.xlabel('x')
plt.ylabel('A_r(x)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# ---------------------------------------------------------
# GRÁFICA 2: Evolución del Error vs r
# ---------------------------------------------------------
# Generamos muchos valores de r entre 0.5 y 0.999
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'Evolución del Error al aumentar r (N={N_FIJO})')
plt.xlabel('Valor de r')
plt.ylabel('Error')
plt.legend()
plt.grid(True, which="both", alpha=0.3)
plt.show()

# Invertimos el eje X si quieres ver el efecto de acercarse a 1,
# o simplemente observamos que al acercarse a 1 el error L2 baja pero el Uniforme sube (Gibbs).
plt.show()

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]]

Series de Fourier RAJ

2026-02-18T18:55:31Z

Alejandro.mates:

{{ TrabajoEDP | 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 }}

<source lang="python" line>

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

def f_discontinua(x):
"""
Define la función característica del intervalo [0, 1/4].
Retorna 1 si 0 <= x <= 0.25, y 0 en otro caso.
"""
# Usamos np.where para vectorizar la operación sobre arrays de numpy
return np.where((x >= 0) & (x <= 0.25), 1.0, 0.0)

def construir_coeficientes_par(funcion, n_terminos, dx=1e-3):
"""
Construye los coeficientes de Fourier para una extensión PAR de la función dada.

Parámetros:
-----------
funcion : callable
Función f(x) definida en [0, 1].
n_terminos : int
Número de coeficientes a calcular (incluyendo a0).
dx : float
Tamaño de la malla para la integración numérica (Sugerencia: 10^-3).

Retorna:
--------
coeficientes : list
Lista [a0, a1, ..., a_n-1] calculada mediante la regla del trapecio.
"""

# 1. Definir la malla de integración [0, 1]
# Se usa arange hasta 1 + dx/2 para asegurar que incluye el punto final 1.0
x = np.arange(0, 1 + dx/2, dx)

# 2. Evaluar la función en la malla
y = funcion(x)

coeficientes = []

# 3. Calcular los coeficientes a_k
for k in range(n_terminos):
# Base trigonométrica par: cos(k * pi * x)
termino_base = np.cos(k * np.pi * x)

# Integrando: 2 * f(x) * cos(k*pi*x)
# El factor '2' proviene de la simetría par en [-1, 1]
integrando = 2 * y * termino_base

# Aproximación de la integral usando la regla del trapecio
# Tal como se sugiere en el punto 2 del texto
a_k = scipy.integrate.trapezoid(integrando, dx=dx)

coeficientes.append(a_k)

return coeficientes

# ---------------------------------------------------------
# 1. Función de Reconstrucción (Solicitada al inicio)
# ---------------------------------------------------------
def reconstruir_serie_par(coeficientes, x_eval):
"""
Reconstruye la serie de Fourier de cosenos.
S_N(x) = a0/2 + sum(a_k * cos(k*pi*x))

Parámetros:
-----------
coeficientes : list
Coeficientes [a0, a1, ..., aN] calculados.
x_eval : array
Puntos donde evaluar la serie (puede ser [-1, 1]).
"""
# 1. Término constante (siempre es a0 / 2)
a0 = coeficientes[0]
y_approx = (a0 / 2) * np.ones_like(x_eval)

# 2. Sumar términos cosenos
# La paridad (simetría) en [-1, 1] es automática con cos(k*pi*x)
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

# ---------------------------------------------------------
# 2. Funciones Auxiliares (Coeficientes y Error)
# ---------------------------------------------------------
def f_par_extendida(x):
"""
Define la función par en todo el eje real.
f(x) = 1 si |x| <= 0.25, 0 en otro caso.
"""
return np.where(np.abs(x) <= 0.25, 1.0, 0.0)

def construir_coeficientes(n_terminos, dx):
"""
Calcula a_k integrando solo en [0, 1] (suficiente por simetría).
Usa 'dx' para crear la malla con np.arange (sin linspace).
"""
# Malla positiva [0, 1] para la integral
x = np.arange(0, 1 + dx/10, dx)
y = f_par_extendida(x)

coefs = []
for k in range(n_terminos):
base = np.cos(k * np.pi * x)
integrando = 2 * y * base
# Integral numérica
a_k = scipy.integrate.trapezoid(integrando, dx=dx)
coefs.append(a_k)
return coefs

def calcular_errores_completo(y_real, y_aprox, dx):
"""Calcula errores L2 y Uniforme en el dominio dado."""
diff = np.abs(y_real - y_aprox)
# L2 = sqrt( integral(diff^2) )
err_l2 = np.sqrt(scipy.integrate.trapezoid(diff**2, dx=dx))
# Uniforme = max(diff)
err_unif = np.max(diff)
return err_l2, err_unif

def reconstruir_cesaro_par(coeficientes, x_eval):
"""
Reconstruye la Suma de Cesàro (promedio de sumas parciales).
Matemáticamente equivale a multiplicar los coeficientes a_k
por el peso triangular: (N - k + 1) / (N + 1).

Parámetros:
-----------
coeficientes : list
[a0, a1, ..., aN] calculados previamente.
x_eval : array
Puntos de evaluación.
"""
N = len(coeficientes) - 1 # El índice máximo es N
y_approx = np.zeros_like(x_eval)

# El denominador común del peso es N + 1
denominador = N + 1

# 1. Término constante a0/2
# El peso de Cesàro para k=0 es (N - 0 + 1)/(N+1) = 1.
# Pero recordamos que en la serie el término es a0/2.
a0 = coeficientes[0]
y_approx += (a0 / 2) * np.ones_like(x_eval)

# 2. Términos cosenos con pesos de Fejér
for k in range(1, len(coeficientes)):
a_k = coeficientes[k]

# Peso triangular que define la suma de Cesàro
peso = (N - k + 1) / denominador

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

return y_approx

# --- Función para Método de Lanczos (Factores Sigma) ---
def reconstruir_lanczos_par(coeficientes, x_eval):
"""
Reconstruye usando factores Sigma (sinc).
Suaviza Gibbs manteniendo buena pendiente.
"""
N = len(coeficientes) - 1
y_approx = np.zeros_like(x_eval)

# Término a0/2
y_approx += (coeficientes[0] / 2)

# Términos cosenos multiplicados por sigma = sinc(k/N)
for k in range(1, len(coeficientes)):
# np.sinc(x) calcula sin(pi*x)/(pi*x)
sigma = np.sinc(k / N)
y_approx += sigma * coeficientes[k] * np.cos(k * np.pi * x_eval)

return y_approx

# --- Función para Método de Abel (Poisson) ---
def reconstruir_abel_r_variable(coeficientes, x_eval, r):
"""
Reconstruye la serie usando Abel con un r fijo dado por el usuario.
"""
y_approx = np.zeros_like(x_eval)

# Término a0/2 (r^0 = 1)
y_approx += (coeficientes[0] / 2)

# Términos cosenos multiplicados por r^k
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

# ---------------------------------------------------------
# 3. Ejecución y Gráficas (Extensión Par Completa [-1, 1])
# ---------------------------------------------------------

# A. Parámetros Basados en Malla (Sin número fijo de puntos)
dx_malla = 1e-4 # Tamaño del paso (resolución)
N_max_calculo = 500 # Máximo N para el análisis de error
lista_N_dibujar = [1, 5, 20, 50, 100, 500]

# B. Construcción del Dominio Completo [-1, 1]
# Usamos arange: start=-1, stop=1 (con margen), step=dx
x_completo = np.arange(-1, 1 + dx_malla/10, dx_malla)
y_real = f_par_extendida(x_completo)

# C. Cálculo de Coeficientes (una sola vez hasta N_max)
coefs_totales = construir_coeficientes(N_max_calculo + 1, dx_malla)

# --- GRÁFICA 1: Función y Aproximaciones ---
plt.figure(figsize=(12, 6))

# Dibujar la función original (Exacta)
plt.plot(x_completo, y_real, 'k-', linewidth=2, label='Función Original (Par)', alpha=0.3)

# Dibujar las aproximaciones para distintos N
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'Extensión Par Completa en [-1, 1] (dx={dx_malla})')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# --- GRÁFICA 2: Evolución de Errores (L2 y Uniforme) ---
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)

# Calcular error sobre todo el intervalo [-1, 1]
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 [-1, 1]', markersize=4)
plt.loglog(rango_n, errores_inf, 'r-s', label='Error Uniforme (Max)', markersize=4)

plt.title('Evolución del Error vs Número de Términos')
plt.xlabel('N (log)')
plt.ylabel('Error (log)')
plt.legend()
plt.grid(True, which="both", alpha=0.3)
plt.show()

# Parámetros globales
dx_malla = 1e-4
N_max_calculo = 500
lista_N_dibujar = [1, 5, 20, 50, 100, 500]

# Dominio completo [-1, 1] usando arange y dx
x_completo = np.arange(-1, 1 + dx_malla/10, dx_malla)
y_real = f_par_extendida(x_completo)

# Calcular coeficientes "crudos" una sola vez
coefs_totales = construir_coeficientes_par(f_par_extendida, N_max_calculo + 1, dx_malla)

# --- GRÁFICA 1: Aproximación de Cesàro ---
plt.figure(figsize=(10, 6))

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

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

for i, n in enumerate(lista_N_dibujar):
# Para Cesàro de orden N, necesitamos coeficientes hasta N
coefs_n = coefs_totales[:n+1]

# Reconstrucción usando la función de Cesàro
y_cesaro = reconstruir_cesaro_par(coefs_n, x_completo)

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

plt.title(f'Sumas de Cesàro (Mitigación de Gibbs) en [-1, 1]')
plt.xlabel('x')
plt.ylabel('S_N(x) [Cesàro]')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# --- GRÁFICA 2: Evolución de Errores (Cesàro) ---
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 (Cesàro)', markersize=4)
plt.loglog(rango_n, errores_inf, 'r-s', label='Error Uniforme (Cesàro)', markersize=4)

plt.title('Evolución del Error en Sumas de Cesàro vs N')
plt.xlabel('N (log)')
plt.ylabel('Error (log)')
plt.legend()
plt.grid(True, which="both", alpha=0.3)
plt.show()

# --- Configuración (Tomamos los valores del caso anterior) ---
dx_malla = 1e-4
N_max_calculo = 500
lista_N_dibujar = [5, 20, 50, 100, 500]

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

# Calculamos coeficientes (si no existen ya en memoria)
# Nota: Aquí SÍ usamos dx_malla
coefs_totales = construir_coeficientes(N_max_calculo + 1, dx_malla)

# ---------------------------------------------------------
# GRÁFICAS LANCZOS
# ---------------------------------------------------------

# 1. Aproximación Visual
plt.figure(figsize=(10, 6))
plt.plot(x_completo, y_real, 'k-', linewidth=2, label='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]
# Aquí NO hace falta dx, solo coeficientes y x
y_lanczos = reconstruir_lanczos_par(coefs_n, x_completo)

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

plt.title('Método de Lanczos (Factores Sigma)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# 2. Evolución del Error
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)

# Aquí usamos dx SOLO para calcular la integral del error L2
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('Error en Lanczos vs N')
plt.xlabel('N (log)')
plt.ylabel('Error (log)')
plt.legend()
plt.grid(True, which="both", alpha=0.3)
plt.show()

dx_malla = 1e-4
N_FIJO = 300 # Fijamos un N alto para tener "espacio" de frecuencias
lista_r_dibujar = [0.6, 0.8, 0.9, 0.95, 0.99, 0.999] # Variamos r

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

# Calculamos coeficientes HASTA N_FIJO
coefs_fijos = construir_coeficientes(N_FIJO + 1, dx_malla)

# ---------------------------------------------------------
# GRÁFICA 1: Aproximación Visual (N fijo, r variable)
# ---------------------------------------------------------
plt.figure(figsize=(10, 6))
plt.plot(x_completo, y_real, 'k-', linewidth=2, label='Original', alpha=0.3)

# Usamos un mapa de colores secuencial (Blues) para ver la progresión de r
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'Método de Abel variando r (N fijo = {N_FIJO})')
plt.xlabel('x')
plt.ylabel('A_r(x)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# ---------------------------------------------------------
# GRÁFICA 2: Evolución del Error vs r
# ---------------------------------------------------------
# Generamos muchos valores de r entre 0.5 y 0.999
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'Evolución del Error al aumentar r (N={N_FIJO})')
plt.xlabel('Valor de r')
plt.ylabel('Error')
plt.legend()
plt.grid(True, which="both", alpha=0.3)
plt.show()

# Invertimos el eje X si quieres ver el efecto de acercarse a 1,
# o simplemente observamos que al acercarse a 1 el error L2 baja pero el Uniforme sube (Gibbs).
plt.show()

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]]

Series de Fourier RAJ

2026-02-18T18:53:49Z

Alejandro.mates:

Series de Fourier RAJ

2026-02-18T18:53:39Z

Alejandro.mates: Página creada con «{{ TrabajoEDP | Series de Fourier. Grupo RAJ| EDP|2025-26 | Rodrigo Gallardo García Alejandro Cogollor Torres Javier Martín...»

{{ TrabajoEDP | 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 }}

[[Archivo:Series de fourier LÁJ.jpeg||800px]]
[[Archivo:Series de fourier LÁJ.pdf]]

</source>

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

EDP-Trabajo 1

2026-02-17T08:53:26Z

Alejandro.mates: Página reemplazada por «hola»

hola

EDP-Trabajo 1

2026-02-17T08:52:45Z

Alejandro.mates:

{{ TrabajoED | Series de Fourier. Grupo LÁJ| [[:Categoría:EDP|EDP]]|[[:Categoría:EDP25/26|2025-26]] | Luis García Suárez

Álvaro Moreno Cisneros

Juan Pérez Guerra }}

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

EDP-Trabajo 1

2026-02-16T17:23:40Z

Alejandro.mates: Página creada con «hola»

hola