MateWiki - Contribuciones del usuario [es]

Ecuación del Calor LÁJ

2026-04-08T06:43:13Z

Álvaro Moreno:

{{ 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 LÁJ.png||800px]]
[[Medio:Ecuación del calor LÁJ.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
from scipy.integrate import trapezoid
from matplotlib import cm

# Ecuación del calor acotada-----------------------------------------------------------------------
def Eca_Acotada(L,alpha,n_terms,f):

"""
Aproxima la solución de la ecuación del calor u_t -alpha * u_xx = 0, con
condición inicial f(x) y condiciones frontera dirichlet homogéneas

Inputs:
L: longitud de la barra
alpha: constante
n_terms: número de términos para la serie de Fourier
f: condición inicial
"""

# 1. Preparar la malla con T en el eje "X" y X en el eje "Y"
t_plot = np.linspace(0, 0.1, 100)
x_plot = np.linspace(0, L, 100)
T, X = np.meshgrid(t_plot, x_plot)

# 2. Cálculo de coeficientes a_n con la fórmula del trapecio
x_fine = np.linspace(0, L, 1000)
y_init = f(x_fine)
a = np.zeros(n_terms + 1)
for n in range(1, n_terms + 1):
integrando = y_init * np.sin(n * np.pi * x_fine / L)
a[n] = (2/L) * trapezoid(integrando, x=x_fine)

# 3. Calcular la solución U(T, X)
U = np.zeros_like(T)
for n in range(1, n_terms + 1):
term_exp = np.exp(-alpha * (n * np.pi / L)**2 * T)
term_sin = np.sin(n * np.pi * X / L)
U += a[n] * term_exp * term_sin

# 4. Graficar
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')

# Ahora graficamos T en el primer eje y X en el segundo
surf = ax.plot_surface(T, X, U, cmap=cm.inferno, linewidth=0, antialiased=True)

ax.set_xlabel('Tiempo (t)')
ax.set_ylabel('Posición (x)')
ax.set_zlabel('Temperatura (u)')
ax.set_title('Visualización: Tiempo vs Posición')
fig.colorbar(surf, shrink=0.5, aspect=5)

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

plt.show()

# Parámetros
L = 1.0
alpha = 1.0
n_terms = 50

# Dato inicial
def f(x):
return np.where((x >= 0.3) & (x <= 0.7), 10.0, 0.0)
# def f(x):
# return 1.0 - 2.0 * np.abs(0.5 - x)

# LLamamos a la función
Eca_Acotada(L,alpha,n_terms,f)

# Ecuación del calor no acotada-----------------------------------------------------------------------
# Visualizar como la solución fundamental tiende a la delta de Dirac------------------------
# Parámetros
alpha = 1.0 # Difusividad térmica

# Definición de la solución fundamental
def solucion_fundamental(x, t, alpha):
"""
Calcula el valor de la solución fundamental en (x, t).
Representa la distribución de calor partiendo de una masa puntual en x=0.
"""
# Evitamos división por cero si t=0
if t <= 0:
return np.zeros_like(x)

coeficiente = 1.0 / np.sqrt(4 * np.pi * alpha * t)
exponente = - (x**2) / (4 * alpha * t)
return coeficiente * np.exp(exponente)

# Configuración de la visualización
x = np.linspace(-2, 2, 1000)
# Tiempos que se acercan a cero para ver la Delta de Dirac
tiempos = [0.1, 0.05, 0.01, 0.005, 0.001]

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

for t in tiempos:
u = solucion_fundamental(x, t, alpha)
plt.plot(x, u, label=f't = {t}')

plt.title('Convergencia de la Solución Fundamental a la Delta de Dirac')
plt.xlabel('Posición (x)')
plt.ylabel('Temperatura (u)')
plt.legend()
plt.grid(True, linestyle=':')
plt.show()

#Visualizar la solución fundamental en 3D----------------
# Parámetros
alpha = 1.0

# 1. Crear malla de puntos (T en el primer eje, X en el segundo)
t_plot = np.linspace(0.005, 0.1, 100)
x_plot = np.linspace(-2, 2, 100)
T, X = np.meshgrid(t_plot, x_plot) # Invertimos el orden para el intercambio

# 2. Calcular la solución fundamental
U = (1.0 / np.sqrt(4 * np.pi * alpha * T)) * np.exp(-(X**2) / (4 * alpha * T))

# 3. Graficar
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')

# Graficamos T en el eje X del gráfico, X en el eje Y
surf = ax.plot_surface(T, X, U, cmap=cm.viridis, linewidth=0, antialiased=True)

# Etiquetas corregidas
ax.set_xlabel('Tiempo (t)')
ax.set_ylabel('Posición (x)')
ax.set_zlabel('Temperatura (u)')
ax.set_title('Núcleo de Calor: Evolución del Pico (t -> 0)')

fig.colorbar(surf, shrink=0.5, aspect=5)

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

plt.show()

#Visualizar solución de la ecuación del calor no acotada----------------

# 1. Definición del núcleo y dato inicial
def kernel(x, t, alpha=1.0):
return (1.0 / np.sqrt(4 * np.pi * alpha * t)) * np.exp(-(x**2) / (4 * alpha * t))

def u0(y):
# Dato inicial
return np.where((y >= 0) & (y <= 1), 1.0, 0.0)

# 2. Configuración de la malla
t_range = np.linspace(0.001, 1, 50) # Eje T
x_range = np.linspace(-2, 3, 60) # Eje X
T, X = np.meshgrid(t_range, x_range)

# Espacio de integración para la convolución (eje y)
y_int = np.linspace(-4, 5, 500)
u_initial_values = u0(y_int)

# 3. Cálculo de la superficie U(T, X)
U = np.zeros_like(X)

for i in range(len(x_range)):
for j in range(len(t_range)):
curr_x = X[i, j]
curr_t = T[i, j]
# Realizamos la convolución numérica para cada punto (x, t)
integrando = kernel(curr_x - y_int, curr_t) * u_initial_values
U[i, j] = trapezoid(integrando, x=y_int)

# 4. Graficar en 3D
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')

# Graficamos con Tiempo en el primer eje y Posición en el segundo
surf = ax.plot_surface(T, X, U, cmap=cm.plasma, linewidth=0, antialiased=True)

ax.set_xlabel('Tiempo (t)')
ax.set_ylabel('Posición (x)')
ax.set_zlabel('Temperatura (u)')
ax.set_title('Solución por Convolución: Disipación de un bloque de calor')

fig.colorbar(surf, shrink=0.5, aspect=5)
ax.view_init(elev=30, azim=-130)

plt.show()

#Ver como el máximo va disminuyendo a lo largo del tiempo
maximos = [np.max(U[:, j]) for j in range(len(t_range))]

plt.figure(figsize=(8, 4))
plt.plot(t_range, maximos, color='red', linewidth=2)
plt.axhline(y=1.0, color='black', linestyle='--', label='Máximo Inicial (t=0)')
plt.title('Validación del Principio del Máximo')
plt.xlabel('Tiempo (t)')
plt.ylabel('Temperatura Máxima alcanzada')
plt.legend()
plt.grid(True)
plt.show()

</source>

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

Ecuación del Calor LÁJ

2026-04-08T06:41:05Z

Álvaro Moreno:

{{ 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 LÁJ.jpeg||800px]]
[[Medio:Ecuación del calor LÁJ.png | 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
from scipy.integrate import trapezoid
from matplotlib import cm

# Ecuación del calor acotada-----------------------------------------------------------------------
def Eca_Acotada(L,alpha,n_terms,f):

"""
Aproxima la solución de la ecuación del calor u_t -alpha * u_xx = 0, con
condición inicial f(x) y condiciones frontera dirichlet homogéneas

Inputs:
L: longitud de la barra
alpha: constante
n_terms: número de términos para la serie de Fourier
f: condición inicial
"""

# 1. Preparar la malla con T en el eje "X" y X en el eje "Y"
t_plot = np.linspace(0, 0.1, 100)
x_plot = np.linspace(0, L, 100)
T, X = np.meshgrid(t_plot, x_plot)

# 2. Cálculo de coeficientes a_n con la fórmula del trapecio
x_fine = np.linspace(0, L, 1000)
y_init = f(x_fine)
a = np.zeros(n_terms + 1)
for n in range(1, n_terms + 1):
integrando = y_init * np.sin(n * np.pi * x_fine / L)
a[n] = (2/L) * trapezoid(integrando, x=x_fine)

# 3. Calcular la solución U(T, X)
U = np.zeros_like(T)
for n in range(1, n_terms + 1):
term_exp = np.exp(-alpha * (n * np.pi / L)**2 * T)
term_sin = np.sin(n * np.pi * X / L)
U += a[n] * term_exp * term_sin

# 4. Graficar
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')

# Ahora graficamos T en el primer eje y X en el segundo
surf = ax.plot_surface(T, X, U, cmap=cm.inferno, linewidth=0, antialiased=True)

ax.set_xlabel('Tiempo (t)')
ax.set_ylabel('Posición (x)')
ax.set_zlabel('Temperatura (u)')
ax.set_title('Visualización: Tiempo vs Posición')
fig.colorbar(surf, shrink=0.5, aspect=5)

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

plt.show()

# Parámetros
L = 1.0
alpha = 1.0
n_terms = 50

# Dato inicial
def f(x):
return np.where((x >= 0.3) & (x <= 0.7), 10.0, 0.0)
# def f(x):
# return 1.0 - 2.0 * np.abs(0.5 - x)

# LLamamos a la función
Eca_Acotada(L,alpha,n_terms,f)

# Ecuación del calor no acotada-----------------------------------------------------------------------
# Visualizar como la solución fundamental tiende a la delta de Dirac------------------------
# Parámetros
alpha = 1.0 # Difusividad térmica

# Definición de la solución fundamental
def solucion_fundamental(x, t, alpha):
"""
Calcula el valor de la solución fundamental en (x, t).
Representa la distribución de calor partiendo de una masa puntual en x=0.
"""
# Evitamos división por cero si t=0
if t <= 0:
return np.zeros_like(x)

coeficiente = 1.0 / np.sqrt(4 * np.pi * alpha * t)
exponente = - (x**2) / (4 * alpha * t)
return coeficiente * np.exp(exponente)

# Configuración de la visualización
x = np.linspace(-2, 2, 1000)
# Tiempos que se acercan a cero para ver la Delta de Dirac
tiempos = [0.1, 0.05, 0.01, 0.005, 0.001]

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

for t in tiempos:
u = solucion_fundamental(x, t, alpha)
plt.plot(x, u, label=f't = {t}')

plt.title('Convergencia de la Solución Fundamental a la Delta de Dirac')
plt.xlabel('Posición (x)')
plt.ylabel('Temperatura (u)')
plt.legend()
plt.grid(True, linestyle=':')
plt.show()

#Visualizar la solución fundamental en 3D----------------
# Parámetros
alpha = 1.0

# 1. Crear malla de puntos (T en el primer eje, X en el segundo)
t_plot = np.linspace(0.005, 0.1, 100)
x_plot = np.linspace(-2, 2, 100)
T, X = np.meshgrid(t_plot, x_plot) # Invertimos el orden para el intercambio

# 2. Calcular la solución fundamental
U = (1.0 / np.sqrt(4 * np.pi * alpha * T)) * np.exp(-(X**2) / (4 * alpha * T))

# 3. Graficar
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')

# Graficamos T en el eje X del gráfico, X en el eje Y
surf = ax.plot_surface(T, X, U, cmap=cm.viridis, linewidth=0, antialiased=True)

# Etiquetas corregidas
ax.set_xlabel('Tiempo (t)')
ax.set_ylabel('Posición (x)')
ax.set_zlabel('Temperatura (u)')
ax.set_title('Núcleo de Calor: Evolución del Pico (t -> 0)')

fig.colorbar(surf, shrink=0.5, aspect=5)

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

plt.show()

#Visualizar solución de la ecuación del calor no acotada----------------

# 1. Definición del núcleo y dato inicial
def kernel(x, t, alpha=1.0):
return (1.0 / np.sqrt(4 * np.pi * alpha * t)) * np.exp(-(x**2) / (4 * alpha * t))

def u0(y):
# Dato inicial
return np.where((y >= 0) & (y <= 1), 1.0, 0.0)

# 2. Configuración de la malla
t_range = np.linspace(0.001, 1, 50) # Eje T
x_range = np.linspace(-2, 3, 60) # Eje X
T, X = np.meshgrid(t_range, x_range)

# Espacio de integración para la convolución (eje y)
y_int = np.linspace(-4, 5, 500)
u_initial_values = u0(y_int)

# 3. Cálculo de la superficie U(T, X)
U = np.zeros_like(X)

for i in range(len(x_range)):
for j in range(len(t_range)):
curr_x = X[i, j]
curr_t = T[i, j]
# Realizamos la convolución numérica para cada punto (x, t)
integrando = kernel(curr_x - y_int, curr_t) * u_initial_values
U[i, j] = trapezoid(integrando, x=y_int)

# 4. Graficar en 3D
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')

# Graficamos con Tiempo en el primer eje y Posición en el segundo
surf = ax.plot_surface(T, X, U, cmap=cm.plasma, linewidth=0, antialiased=True)

ax.set_xlabel('Tiempo (t)')
ax.set_ylabel('Posición (x)')
ax.set_zlabel('Temperatura (u)')
ax.set_title('Solución por Convolución: Disipación de un bloque de calor')

fig.colorbar(surf, shrink=0.5, aspect=5)
ax.view_init(elev=30, azim=-130)

plt.show()

#Ver como el máximo va disminuyendo a lo largo del tiempo
maximos = [np.max(U[:, j]) for j in range(len(t_range))]

plt.figure(figsize=(8, 4))
plt.plot(t_range, maximos, color='red', linewidth=2)
plt.axhline(y=1.0, color='black', linestyle='--', label='Máximo Inicial (t=0)')
plt.title('Validación del Principio del Máximo')
plt.xlabel('Tiempo (t)')
plt.ylabel('Temperatura Máxima alcanzada')
plt.legend()
plt.grid(True)
plt.show()

</source>

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

Archivo:Ecuación del calor LÁJ.png

2026-04-08T06:40:39Z

Álvaro Moreno:

Archivo:Ecuación del calor LÁJ.pdf

2026-04-08T06:37:10Z

Álvaro Moreno: Trabajo ecuación del calor

Trabajo ecuación del calor

Ecuación del Calor LÁJ

2026-04-08T06:35:43Z

Álvaro Moreno: 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 LÁJ.jpeg||800px]]
[[Medio:Ecuación del calor LÁJ.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
from scipy.integrate import trapezoid
from matplotlib import cm

# Ecuación del calor acotada-----------------------------------------------------------------------
def Eca_Acotada(L,alpha,n_terms,f):

"""
Aproxima la solución de la ecuación del calor u_t -alpha * u_xx = 0, con
condición inicial f(x) y condiciones frontera dirichlet homogéneas

Inputs:
L: longitud de la barra
alpha: constante
n_terms: número de términos para la serie de Fourier
f: condición inicial
"""

# 1. Preparar la malla con T en el eje "X" y X en el eje "Y"
t_plot = np.linspace(0, 0.1, 100)
x_plot = np.linspace(0, L, 100)
T, X = np.meshgrid(t_plot, x_plot)

# 2. Cálculo de coeficientes a_n con la fórmula del trapecio
x_fine = np.linspace(0, L, 1000)
y_init = f(x_fine)
a = np.zeros(n_terms + 1)
for n in range(1, n_terms + 1):
integrando = y_init * np.sin(n * np.pi * x_fine / L)
a[n] = (2/L) * trapezoid(integrando, x=x_fine)

# 3. Calcular la solución U(T, X)
U = np.zeros_like(T)
for n in range(1, n_terms + 1):
term_exp = np.exp(-alpha * (n * np.pi / L)**2 * T)
term_sin = np.sin(n * np.pi * X / L)
U += a[n] * term_exp * term_sin

# 4. Graficar
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')

# Ahora graficamos T en el primer eje y X en el segundo
surf = ax.plot_surface(T, X, U, cmap=cm.inferno, linewidth=0, antialiased=True)

ax.set_xlabel('Tiempo (t)')
ax.set_ylabel('Posición (x)')
ax.set_zlabel('Temperatura (u)')
ax.set_title('Visualización: Tiempo vs Posición')
fig.colorbar(surf, shrink=0.5, aspect=5)

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

plt.show()

# Parámetros
L = 1.0
alpha = 1.0
n_terms = 50

# Dato inicial
def f(x):
return np.where((x >= 0.3) & (x <= 0.7), 10.0, 0.0)
# def f(x):
# return 1.0 - 2.0 * np.abs(0.5 - x)

# LLamamos a la función
Eca_Acotada(L,alpha,n_terms,f)

# Ecuación del calor no acotada-----------------------------------------------------------------------
# Visualizar como la solución fundamental tiende a la delta de Dirac------------------------
# Parámetros
alpha = 1.0 # Difusividad térmica

# Definición de la solución fundamental
def solucion_fundamental(x, t, alpha):
"""
Calcula el valor de la solución fundamental en (x, t).
Representa la distribución de calor partiendo de una masa puntual en x=0.
"""
# Evitamos división por cero si t=0
if t <= 0:
return np.zeros_like(x)

coeficiente = 1.0 / np.sqrt(4 * np.pi * alpha * t)
exponente = - (x**2) / (4 * alpha * t)
return coeficiente * np.exp(exponente)

# Configuración de la visualización
x = np.linspace(-2, 2, 1000)
# Tiempos que se acercan a cero para ver la Delta de Dirac
tiempos = [0.1, 0.05, 0.01, 0.005, 0.001]

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

for t in tiempos:
u = solucion_fundamental(x, t, alpha)
plt.plot(x, u, label=f't = {t}')

plt.title('Convergencia de la Solución Fundamental a la Delta de Dirac')
plt.xlabel('Posición (x)')
plt.ylabel('Temperatura (u)')
plt.legend()
plt.grid(True, linestyle=':')
plt.show()

#Visualizar la solución fundamental en 3D----------------
# Parámetros
alpha = 1.0

# 1. Crear malla de puntos (T en el primer eje, X en el segundo)
t_plot = np.linspace(0.005, 0.1, 100)
x_plot = np.linspace(-2, 2, 100)
T, X = np.meshgrid(t_plot, x_plot) # Invertimos el orden para el intercambio

# 2. Calcular la solución fundamental
U = (1.0 / np.sqrt(4 * np.pi * alpha * T)) * np.exp(-(X**2) / (4 * alpha * T))

# 3. Graficar
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')

# Graficamos T en el eje X del gráfico, X en el eje Y
surf = ax.plot_surface(T, X, U, cmap=cm.viridis, linewidth=0, antialiased=True)

# Etiquetas corregidas
ax.set_xlabel('Tiempo (t)')
ax.set_ylabel('Posición (x)')
ax.set_zlabel('Temperatura (u)')
ax.set_title('Núcleo de Calor: Evolución del Pico (t -> 0)')

fig.colorbar(surf, shrink=0.5, aspect=5)

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

plt.show()

#Visualizar solución de la ecuación del calor no acotada----------------

# 1. Definición del núcleo y dato inicial
def kernel(x, t, alpha=1.0):
return (1.0 / np.sqrt(4 * np.pi * alpha * t)) * np.exp(-(x**2) / (4 * alpha * t))

def u0(y):
# Dato inicial
return np.where((y >= 0) & (y <= 1), 1.0, 0.0)

# 2. Configuración de la malla
t_range = np.linspace(0.001, 1, 50) # Eje T
x_range = np.linspace(-2, 3, 60) # Eje X
T, X = np.meshgrid(t_range, x_range)

# Espacio de integración para la convolución (eje y)
y_int = np.linspace(-4, 5, 500)
u_initial_values = u0(y_int)

# 3. Cálculo de la superficie U(T, X)
U = np.zeros_like(X)

for i in range(len(x_range)):
for j in range(len(t_range)):
curr_x = X[i, j]
curr_t = T[i, j]
# Realizamos la convolución numérica para cada punto (x, t)
integrando = kernel(curr_x - y_int, curr_t) * u_initial_values
U[i, j] = trapezoid(integrando, x=y_int)

# 4. Graficar en 3D
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')

# Graficamos con Tiempo en el primer eje y Posición en el segundo
surf = ax.plot_surface(T, X, U, cmap=cm.plasma, linewidth=0, antialiased=True)

ax.set_xlabel('Tiempo (t)')
ax.set_ylabel('Posición (x)')
ax.set_zlabel('Temperatura (u)')
ax.set_title('Solución por Convolución: Disipación de un bloque de calor')

fig.colorbar(surf, shrink=0.5, aspect=5)
ax.view_init(elev=30, azim=-130)

plt.show()

#Ver como el máximo va disminuyendo a lo largo del tiempo
maximos = [np.max(U[:, j]) for j in range(len(t_range))]

plt.figure(figsize=(8, 4))
plt.plot(t_range, maximos, color='red', linewidth=2)
plt.axhline(y=1.0, color='black', linestyle='--', label='Máximo Inicial (t=0)')
plt.title('Validación del Principio del Máximo')
plt.xlabel('Tiempo (t)')
plt.ylabel('Temperatura Máxima alcanzada')
plt.legend()
plt.grid(True)
plt.show()

</source>

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

Series de Fourier LÁJ

2026-02-19T08:41:39Z

Álvaro Moreno:

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

[[Archivo:Series de fourier LÁJ.jpeg||800px]]
[[Medio:Series de fourier LÁJ corregido.pdf | PDF del póster]]

Abajo se puede ver el código que se ha utilizado para conseguir las gráficas. La función serie_de_fourier_definitiva aproxima una función dada en un intervalo mediante una serie de Fourier, la función comparar_fourier_cesaro es la que da las gráficas de la última parte y la función base_trigonométrica aunque no se ha incluído en el póster ilustra como funciona la base trigonométrica.

<source lang="python" line>
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import trapezoid

def base_trigonometrica(n):
#Puntos donde se grafica
x = np.linspace(-1,1,1000)
plt.figure(figsize = (10,6))

#Primer término de la serie
plt.plot(x, np.full_like(x, 0.5), label='1/2 (n=0)', linewidth=2, color='black')

#Términos trigonométricos
for n in range(1,n):
plt.plot(x, np.cos(n*np.pi*x), color = 'r', linestyle='-')
plt.plot(x, np.sin(n*np.pi*x), color = 'b', linestyle='-')

plt.title('Primeros términos de la base trigonométrica {1/2, cos(nπx), sin(nπx)}')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.axhline(0, color='black', linewidth=0.5)
plt.axvline(0, color='black', linewidth=0.5)
plt.grid(True, linestyle=':', alpha=0.6)
plt.legend(['1/2','cos','sin'], loc = 'upper right', bbox_to_anchor = (1,1))
plt.tight_layout()

# Mostrar resultado
plt.show()

def serie_fourier_definitiva(f,L,n):

#Puntos donde se grafica y sus valores exactos
x = np.linspace(-L/2,L/2,1000)
f_ev = f(x)

def serie_fourier(funcion,x_val,n_terms):
fn = np.zeros_like(x_val)
f_eval = funcion(x_val)

c0 = trapezoid(2/L * f_eval,x_val)
fn = c0/2
for k in range(1,n_terms+1):
#Coeficientes
cn = trapezoid(2/L * f_eval * np.cos(2*k*np.pi*x_val/L),x_val)
dn = trapezoid(2/L * f_eval * np.sin(2*k*np.pi*x_val/L),x_val)

#Sumar términos
fn += cn* np.cos(2*k*np.pi*x_val/L) + dn * np.sin(2*k*np.pi*x_val/L)

return fn

#Gráfica
plt.figure(figsize = (10,6))
plt.plot(x,f_ev,'k--', label='f(x) original', linewidth=2)

for i in n:
fn_ev = serie_fourier(f,x,i)
plt.plot(x,fn_ev, label=f'n = {i}')

plt.title('Aproximación de f(x) mediante serie de Fourier')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

#Cálculo de errores
n_error = []
for i in range(1,100):
n_error.append(i)

error_l2 = []
error_inf = []

for i in n_error:
f_n = serie_fourier(f,x,i)
dif = f_ev - f_n

error_l2.append(np.sqrt(trapezoid(dif**2,x)))
error_inf.append(round(float(np.max(np.abs(dif))),6))

#Gráfica
plt.figure(figsize = (10,6))
plt.plot(n_error,error_l2, linewidth=2)
plt.title('Error $L^2$')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

def comparar_fourier_cesaro(func, L, n_terms, nombre_funcion="Función"):
"""
Calcula y grafica la aproximación de Fourier estándar vs Sumas de Cesàro.

func: Función original a aproximar.
L: Longitud del intervalo [-L/2, L/2].
n_terms: Número máximo de coeficientes (n).

"""

def get_coefficients(n):
# Integración por método del trapecio como se indica en el documento
x_int = np.linspace(-L/2, L/2, 2000)
y_int = func(x_int)

# Coeficiente c0
c0 = (2/L) * trapezoid(y_int, x_int)

an = []
bn = []
for i in range(1, n + 1):
cos_term = np.cos(2 * np.pi * i * x_int / L)
sin_term = np.sin(2 * np.pi * i * x_int / L)
an.append((2/L) * trapezoid(y_int * cos_term, x_int))
bn.append((2/L) * trapezoid(y_int * sin_term, x_int))
return c0, an, bn

# Obtener coeficientes
c0, an, bn = get_coefficients(n_terms)

# Construir sumas parciales S_k para Cesàro
x_range = np.linspace(-L/2,L/2,1000)
sumas_parciales = []
current_sum = np.full_like(x_range, c0 / 2)
sumas_parciales.append(current_sum.copy())

for i in range(n_terms):
term = an[i] * np.cos(2 * np.pi * (i+1) * x_range / L) + \
bn[i] * np.sin(2 * np.pi * (i+1) * x_range / L)
current_sum += term
sumas_parciales.append(current_sum.copy())

# Calcular Suma de Cesàro (Promedio de las sumas parciales)
sigma_n = np.mean(sumas_parciales, axis=0)

# Gráfica
plt.figure(figsize=(12, 6))
plt.plot(x_range, func(x_range), 'k--', label=f"Original: {nombre_funcion}", alpha=0.6)
plt.plot(x_range, current_sum, label=f"Fourier Estándar (n={n_terms})", color='red', alpha=0.5)
plt.plot(x_range, sigma_n, label=f"Suma de Cesàro (n={n_terms})", color='blue', linewidth=2)

plt.title(f"Aproximación de {nombre_funcion}: Fourier vs Cesàro")
plt.xlabel("x")
plt.ylabel("f(x)")
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()

#Lo que se ejecuta---------------------------------------------------------
base_trigonometrica(6)

def f(x):
lista = []
for i in x:
if i < 0:
lista.append(0)
else:
lista.append(1)
return np.array(lista)

def MW(x):
n = 200
a = 1/2
b = 13

suma = 0
for i in range(n):
suma += a**i * np.cos(b**i * np.pi*x)

return suma

def g(x):
return x**2

serie_fourier_definitiva(f,10,[1,5,10,100])
comparar_fourier_cesaro(f, 10, 50, "Función Discontinua (Escalón)")
comparar_fourier_cesaro(MW, 10, 100, "Monstruo de Weierstrass")

</source>

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

Archivo:Series de fourier LÁJ corregido.pdf

2026-02-19T08:37:38Z

Álvaro Moreno:

Series de Fourier LÁJ

2026-02-16T16:34:59Z

Álvaro Moreno:

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

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

Abajo se puede ver el código que se ha utilizado para conseguir las gráficas. La función serie_de_fourier_definitiva aproxima una función dada en un intervalo mediante una serie de Fourier, la función comparar_fourier_cesaro es la que da las gráficas de la última parte y la función base_trigonométrica aunque no se ha incluído en el póster ilustra como funciona la base trigonométrica.

<source lang="python" line>
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import trapezoid

def base_trigonometrica(n):
#Puntos donde se grafica
x = np.linspace(-1,1,1000)
plt.figure(figsize = (10,6))

#Primer término de la serie
plt.plot(x, np.full_like(x, 0.5), label='1/2 (n=0)', linewidth=2, color='black')

#Términos trigonométricos
for n in range(1,n):
plt.plot(x, np.cos(n*np.pi*x), color = 'r', linestyle='-')
plt.plot(x, np.sin(n*np.pi*x), color = 'b', linestyle='-')

plt.title('Primeros términos de la base trigonométrica {1/2, cos(nπx), sin(nπx)}')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.axhline(0, color='black', linewidth=0.5)
plt.axvline(0, color='black', linewidth=0.5)
plt.grid(True, linestyle=':', alpha=0.6)
plt.legend(['1/2','cos','sin'], loc = 'upper right', bbox_to_anchor = (1,1))
plt.tight_layout()

# Mostrar resultado
plt.show()

def serie_fourier_definitiva(f,L,n):

#Puntos donde se grafica y sus valores exactos
x = np.linspace(-L/2,L/2,1000)
f_ev = f(x)

def serie_fourier(funcion,x_val,n_terms):
fn = np.zeros_like(x_val)
f_eval = funcion(x_val)

c0 = trapezoid(2/L * f_eval,x_val)
fn = c0/2
for k in range(1,n_terms+1):
#Coeficientes
cn = trapezoid(2/L * f_eval * np.cos(2*k*np.pi*x_val/L),x_val)
dn = trapezoid(2/L * f_eval * np.sin(2*k*np.pi*x_val/L),x_val)

#Sumar términos
fn += cn* np.cos(2*k*np.pi*x_val/L) + dn * np.sin(2*k*np.pi*x_val/L)

return fn

#Gráfica
plt.figure(figsize = (10,6))
plt.plot(x,f_ev,'k--', label='f(x) original', linewidth=2)

for i in n:
fn_ev = serie_fourier(f,x,i)
plt.plot(x,fn_ev, label=f'n = {i}')

plt.title('Aproximación de f(x) mediante serie de Fourier')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

#Cálculo de errores
n_error = []
for i in range(1,100):
n_error.append(i)

error_l2 = []
error_inf = []

for i in n_error:
f_n = serie_fourier(f,x,i)
dif = f_ev - f_n

error_l2.append(np.sqrt(trapezoid(dif**2,x)))
error_inf.append(round(float(np.max(np.abs(dif))),6))

#Gráfica
plt.figure(figsize = (10,6))
plt.plot(n_error,error_l2, linewidth=2)
plt.title('Error $L^2$')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

def comparar_fourier_cesaro(func, L, n_terms, nombre_funcion="Función"):
"""
Calcula y grafica la aproximación de Fourier estándar vs Sumas de Cesàro.

func: Función original a aproximar.
L: Longitud del intervalo [-L/2, L/2].
n_terms: Número máximo de coeficientes (n).

"""

def get_coefficients(n):
# Integración por método del trapecio como se indica en el documento
x_int = np.linspace(-L/2, L/2, 2000)
y_int = func(x_int)

# Coeficiente c0
c0 = (2/L) * trapezoid(y_int, x_int)

an = []
bn = []
for i in range(1, n + 1):
cos_term = np.cos(2 * np.pi * i * x_int / L)
sin_term = np.sin(2 * np.pi * i * x_int / L)
an.append((2/L) * trapezoid(y_int * cos_term, x_int))
bn.append((2/L) * trapezoid(y_int * sin_term, x_int))
return c0, an, bn

# Obtener coeficientes
c0, an, bn = get_coefficients(n_terms)

# Construir sumas parciales S_k para Cesàro
x_range = np.linspace(-L/2,L/2,1000)
sumas_parciales = []
current_sum = np.full_like(x_range, c0 / 2)
sumas_parciales.append(current_sum.copy())

for i in range(n_terms):
term = an[i] * np.cos(2 * np.pi * (i+1) * x_range / L) + \
bn[i] * np.sin(2 * np.pi * (i+1) * x_range / L)
current_sum += term
sumas_parciales.append(current_sum.copy())

# Calcular Suma de Cesàro (Promedio de las sumas parciales)
sigma_n = np.mean(sumas_parciales, axis=0)

# Gráfica
plt.figure(figsize=(12, 6))
plt.plot(x_range, func(x_range), 'k--', label=f"Original: {nombre_funcion}", alpha=0.6)
plt.plot(x_range, current_sum, label=f"Fourier Estándar (n={n_terms})", color='red', alpha=0.5)
plt.plot(x_range, sigma_n, label=f"Suma de Cesàro (n={n_terms})", color='blue', linewidth=2)

plt.title(f"Aproximación de {nombre_funcion}: Fourier vs Cesàro")
plt.xlabel("x")
plt.ylabel("f(x)")
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()

#Lo que se ejecuta---------------------------------------------------------
base_trigonometrica(6)

def f(x):
lista = []
for i in x:
if i < 0:
lista.append(0)
else:
lista.append(1)
return np.array(lista)

def MW(x):
n = 200
a = 1/2
b = 13

suma = 0
for i in range(n):
suma += a**i * np.cos(b**i * np.pi*x)

return suma

def g(x):
return x**2

serie_fourier_definitiva(f,10,[1,5,10,100])
comparar_fourier_cesaro(f, 10, 50, "Función Discontinua (Escalón)")
comparar_fourier_cesaro(MW, 10, 100, "Monstruo de Weierstrass")

</source>

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

Serie de Fourier LÁJ

2026-02-16T16:33:30Z

Álvaro Moreno: Álvaro Moreno trasladó la página Serie de Fourier LÁJ a Series de Fourier LÁJ: Errata en el título

#REDIRECCIÓN [[Series de Fourier LÁJ]]

Series de Fourier LÁJ

2026-02-16T16:33:30Z

Álvaro Moreno: Álvaro Moreno trasladó la página Serie de Fourier LÁJ a Series de Fourier LÁJ: Errata en el título

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

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

Abajo se puede ver el código que se ha utilizado para conseguir las gráficas. La función serie_de_fourier_definitiva aproxima una función dada en un intervalo mediante una serie de Fourier, la función comparar_fourier_cesaro es la que da las gráficas de la última parte y la función base_trigonométrica aunque no se ha incluído en el póster ilustra como funciona la base trigonométrica.

<source lang="python" line>
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import trapezoid

def base_trigonometrica(n):
#Puntos donde se grafica
x = np.linspace(-1,1,1000)
plt.figure(figsize = (10,6))

#Primer término de la serie
plt.plot(x, np.full_like(x, 0.5), label='1/2 (n=0)', linewidth=2, color='black')

#Términos trigonométricos
for n in range(1,n):
plt.plot(x, np.cos(n*np.pi*x), color = 'r', linestyle='-')
plt.plot(x, np.sin(n*np.pi*x), color = 'b', linestyle='-')

plt.title('Primeros términos de la base trigonométrica {1/2, cos(nπx), sin(nπx)}')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.axhline(0, color='black', linewidth=0.5)
plt.axvline(0, color='black', linewidth=0.5)
plt.grid(True, linestyle=':', alpha=0.6)
plt.legend(['1/2','cos','sin'], loc = 'upper right', bbox_to_anchor = (1,1))
plt.tight_layout()

# Mostrar resultado
plt.show()

def serie_fourier_definitiva(f,L,n):

#Puntos donde se grafica y sus valores exactos
x = np.linspace(-L/2,L/2,1000)
f_ev = f(x)

def serie_fourier(funcion,x_val,n_terms):
fn = np.zeros_like(x_val)
f_eval = funcion(x_val)

c0 = trapezoid(2/L * f_eval,x_val)
fn = c0/2
for k in range(1,n_terms+1):
#Coeficientes
cn = trapezoid(2/L * f_eval * np.cos(2*k*np.pi*x_val/L),x_val)
dn = trapezoid(2/L * f_eval * np.sin(2*k*np.pi*x_val/L),x_val)

#Sumar términos
fn += cn* np.cos(2*k*np.pi*x_val/L) + dn * np.sin(2*k*np.pi*x_val/L)

return fn

#Gráfica
plt.figure(figsize = (10,6))
plt.plot(x,f_ev,'k--', label='f(x) original', linewidth=2)

for i in n:
fn_ev = serie_fourier(f,x,i)
plt.plot(x,fn_ev, label=f'n = {i}')

plt.title('Aproximación de f(x) mediante serie de Fourier')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

#Cálculo de errores
n_error = []
for i in range(1,100):
n_error.append(i)

error_l2 = []
error_inf = []

for i in n_error:
f_n = serie_fourier(f,x,i)
dif = f_ev - f_n

error_l2.append(np.sqrt(trapezoid(dif**2,x)))
error_inf.append(round(float(np.max(np.abs(dif))),6))

#Gráfica
plt.figure(figsize = (10,6))
plt.plot(n_error,error_l2, linewidth=2)
plt.title('Error $L^2$')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

def comparar_fourier_cesaro(func, L, n_terms, nombre_funcion="Función"):
"""
Calcula y grafica la aproximación de Fourier estándar vs Sumas de Cesàro.

func: Función original a aproximar.
L: Longitud del intervalo [-L/2, L/2].
n_terms: Número máximo de coeficientes (n).

"""

def get_coefficients(n):
# Integración por método del trapecio como se indica en el documento
x_int = np.linspace(-L/2, L/2, 2000)
y_int = func(x_int)

# Coeficiente c0
c0 = (2/L) * trapezoid(y_int, x_int)

an = []
bn = []
for i in range(1, n + 1):
cos_term = np.cos(2 * np.pi * i * x_int / L)
sin_term = np.sin(2 * np.pi * i * x_int / L)
an.append((2/L) * trapezoid(y_int * cos_term, x_int))
bn.append((2/L) * trapezoid(y_int * sin_term, x_int))
return c0, an, bn

# Obtener coeficientes
c0, an, bn = get_coefficients(n_terms)

# Construir sumas parciales S_k para Cesàro
x_range = np.linspace(-L/2,L/2,1000)
sumas_parciales = []
current_sum = np.full_like(x_range, c0 / 2)
sumas_parciales.append(current_sum.copy())

for i in range(n_terms):
term = an[i] * np.cos(2 * np.pi * (i+1) * x_range / L) + \
bn[i] * np.sin(2 * np.pi * (i+1) * x_range / L)
current_sum += term
sumas_parciales.append(current_sum.copy())

# Calcular Suma de Cesàro (Promedio de las sumas parciales)
sigma_n = np.mean(sumas_parciales, axis=0)

# Gráfica
plt.figure(figsize=(12, 6))
plt.plot(x_range, func(x_range), 'k--', label=f"Original: {nombre_funcion}", alpha=0.6)
plt.plot(x_range, current_sum, label=f"Fourier Estándar (n={n_terms})", color='red', alpha=0.5)
plt.plot(x_range, sigma_n, label=f"Suma de Cesàro (n={n_terms})", color='blue', linewidth=2)

plt.title(f"Aproximación de {nombre_funcion}: Fourier vs Cesàro")
plt.xlabel("x")
plt.ylabel("f(x)")
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()

#Lo que se ejecuta---------------------------------------------------------
base_trigonometrica(6)

def f(x):
lista = []
for i in x:
if i < 0:
lista.append(0)
else:
lista.append(1)
return np.array(lista)

def MW(x):
n = 200
a = 1/2
b = 13

suma = 0
for i in range(n):
suma += a**i * np.cos(b**i * np.pi*x)

return suma

def g(x):
return x**2

serie_fourier_definitiva(f,10,[1,5,10,100])
comparar_fourier_cesaro(f, 10, 50, "Función Discontinua (Escalón)")
comparar_fourier_cesaro(MW, 10, 100, "Monstruo de Weierstrass")

</source>

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

Series de Fourier LÁJ

2026-02-16T16:31:59Z

Álvaro Moreno:

Series de Fourier LÁJ

2026-02-16T16:30:17Z

Álvaro Moreno:

{{ TrabajoED | Series de Fourier. Grupo 6-A | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP25/26|2025-26]] | Luis García Suárez, Álvaro Moreno Cisneros, Juan Pérez Guerra }}

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

Abajo se puede ver el código que se ha utilizado para conseguir las gráficas. La función serie_de_fourier_definitiva aproxima una función dada en un intervalo mediante una serie de Fourier, la función comparar_fourier_cesaro es la que da las gráficas de la última parte y la función base_trigonométrica aunque no se ha incluído en el póster ilustra como funciona la base trigonométrica.

<source lang="python" line>
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import trapezoid

def base_trigonometrica(n):
#Puntos donde se grafica
x = np.linspace(-1,1,1000)
plt.figure(figsize = (10,6))

#Primer término de la serie
plt.plot(x, np.full_like(x, 0.5), label='1/2 (n=0)', linewidth=2, color='black')

#Términos trigonométricos
for n in range(1,n):
plt.plot(x, np.cos(n*np.pi*x), color = 'r', linestyle='-')
plt.plot(x, np.sin(n*np.pi*x), color = 'b', linestyle='-')

plt.title('Primeros términos de la base trigonométrica {1/2, cos(nπx), sin(nπx)}')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.axhline(0, color='black', linewidth=0.5)
plt.axvline(0, color='black', linewidth=0.5)
plt.grid(True, linestyle=':', alpha=0.6)
plt.legend(['1/2','cos','sin'], loc = 'upper right', bbox_to_anchor = (1,1))
plt.tight_layout()

# Mostrar resultado
plt.show()

def serie_fourier_definitiva(f,L,n):

#Puntos donde se grafica y sus valores exactos
x = np.linspace(-L/2,L/2,1000)
f_ev = f(x)

def serie_fourier(funcion,x_val,n_terms):
fn = np.zeros_like(x_val)
f_eval = funcion(x_val)

c0 = trapezoid(2/L * f_eval,x_val)
fn = c0/2
for k in range(1,n_terms+1):
#Coeficientes
cn = trapezoid(2/L * f_eval * np.cos(2*k*np.pi*x_val/L),x_val)
dn = trapezoid(2/L * f_eval * np.sin(2*k*np.pi*x_val/L),x_val)

#Sumar términos
fn += cn* np.cos(2*k*np.pi*x_val/L) + dn * np.sin(2*k*np.pi*x_val/L)

return fn

#Gráfica
plt.figure(figsize = (10,6))
plt.plot(x,f_ev,'k--', label='f(x) original', linewidth=2)

for i in n:
fn_ev = serie_fourier(f,x,i)
plt.plot(x,fn_ev, label=f'n = {i}')

plt.title('Aproximación de f(x) mediante serie de Fourier')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

#Cálculo de errores
n_error = []
for i in range(1,100):
n_error.append(i)

error_l2 = []
error_inf = []

for i in n_error:
f_n = serie_fourier(f,x,i)
dif = f_ev - f_n

error_l2.append(np.sqrt(trapezoid(dif**2,x)))
error_inf.append(round(float(np.max(np.abs(dif))),6))

#Gráfica
plt.figure(figsize = (10,6))
plt.plot(n_error,error_l2, linewidth=2)
plt.title('Error $L^2$')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

def comparar_fourier_cesaro(func, L, n_terms, nombre_funcion="Función"):
"""
Calcula y grafica la aproximación de Fourier estándar vs Sumas de Cesàro.

func: Función original a aproximar.
L: Longitud del intervalo [-L/2, L/2].
n_terms: Número máximo de coeficientes (n).

"""

def get_coefficients(n):
# Integración por método del trapecio como se indica en el documento
x_int = np.linspace(-L/2, L/2, 2000)
y_int = func(x_int)

# Coeficiente c0
c0 = (2/L) * trapezoid(y_int, x_int)

an = []
bn = []
for i in range(1, n + 1):
cos_term = np.cos(2 * np.pi * i * x_int / L)
sin_term = np.sin(2 * np.pi * i * x_int / L)
an.append((2/L) * trapezoid(y_int * cos_term, x_int))
bn.append((2/L) * trapezoid(y_int * sin_term, x_int))
return c0, an, bn

# Obtener coeficientes
c0, an, bn = get_coefficients(n_terms)

# Construir sumas parciales S_k para Cesàro
x_range = np.linspace(-L/2,L/2,1000)
sumas_parciales = []
current_sum = np.full_like(x_range, c0 / 2)
sumas_parciales.append(current_sum.copy())

for i in range(n_terms):
term = an[i] * np.cos(2 * np.pi * (i+1) * x_range / L) + \
bn[i] * np.sin(2 * np.pi * (i+1) * x_range / L)
current_sum += term
sumas_parciales.append(current_sum.copy())

# Calcular Suma de Cesàro (Promedio de las sumas parciales)
sigma_n = np.mean(sumas_parciales, axis=0)

# Gráfica
plt.figure(figsize=(12, 6))
plt.plot(x_range, func(x_range), 'k--', label=f"Original: {nombre_funcion}", alpha=0.6)
plt.plot(x_range, current_sum, label=f"Fourier Estándar (n={n_terms})", color='red', alpha=0.5)
plt.plot(x_range, sigma_n, label=f"Suma de Cesàro (n={n_terms})", color='blue', linewidth=2)

plt.title(f"Aproximación de {nombre_funcion}: Fourier vs Cesàro")
plt.xlabel("x")
plt.ylabel("f(x)")
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()

#Lo que se ejecuta---------------------------------------------------------
base_trigonometrica(6)

def f(x):
lista = []
for i in x:
if i < 0:
lista.append(0)
else:
lista.append(1)
return np.array(lista)

def MW(x):
n = 200
a = 1/2
b = 13

suma = 0
for i in range(n):
suma += a**i * np.cos(b**i * np.pi*x)

return suma

def g(x):
return x**2

serie_fourier_definitiva(f,10,[1,5,10,100])
comparar_fourier_cesaro(f, 10, 50, "Función Discontinua (Escalón)")
comparar_fourier_cesaro(MW, 10, 100, "Monstruo de Weierstrass")

</source>

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

Series de Fourier LÁJ

2026-02-16T16:26:17Z

Álvaro Moreno:

{{ TrabajoED | Series de Fourier. Grupo 6-A | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP25/26|2025-26]] | Luis García Suárez, Álvaro Moreno Cisneros, Juan Pérez Guerra }}

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

<source lang="python" line>
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import trapezoid

def base_trigonometrica(n):
#Puntos donde se grafica
x = np.linspace(-1,1,1000)
plt.figure(figsize = (10,6))

#Primer término de la serie
plt.plot(x, np.full_like(x, 0.5), label='1/2 (n=0)', linewidth=2, color='black')

#Términos trigonométricos
for n in range(1,n):
plt.plot(x, np.cos(n*np.pi*x), color = 'r', linestyle='-')
plt.plot(x, np.sin(n*np.pi*x), color = 'b', linestyle='-')

plt.title('Primeros términos de la base trigonométrica {1/2, cos(nπx), sin(nπx)}')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.axhline(0, color='black', linewidth=0.5)
plt.axvline(0, color='black', linewidth=0.5)
plt.grid(True, linestyle=':', alpha=0.6)
plt.legend(['1/2','cos','sin'], loc = 'upper right', bbox_to_anchor = (1,1))
plt.tight_layout()

# Mostrar resultado
plt.show()

def serie_fourier_definitiva(f,L,n):

#Puntos donde se grafica y sus valores exactos
x = np.linspace(-L/2,L/2,1000)
f_ev = f(x)

def serie_fourier(funcion,x_val,n_terms):
fn = np.zeros_like(x_val)
f_eval = funcion(x_val)

c0 = trapezoid(2/L * f_eval,x_val)
fn = c0/2
for k in range(1,n_terms+1):
#Coeficientes
cn = trapezoid(2/L * f_eval * np.cos(2*k*np.pi*x_val/L),x_val)
dn = trapezoid(2/L * f_eval * np.sin(2*k*np.pi*x_val/L),x_val)

#Sumar términos
fn += cn* np.cos(2*k*np.pi*x_val/L) + dn * np.sin(2*k*np.pi*x_val/L)

return fn

#Gráfica
plt.figure(figsize = (10,6))
plt.plot(x,f_ev,'k--', label='f(x) original', linewidth=2)

for i in n:
fn_ev = serie_fourier(f,x,i)
plt.plot(x,fn_ev, label=f'n = {i}')

plt.title('Aproximación de f(x) mediante serie de Fourier')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

#Cálculo de errores
n_error = []
for i in range(1,100):
n_error.append(i)

error_l2 = []
error_inf = []

for i in n_error:
f_n = serie_fourier(f,x,i)
dif = f_ev - f_n

error_l2.append(np.sqrt(trapezoid(dif**2,x)))
error_inf.append(round(float(np.max(np.abs(dif))),6))

#Gráfica
plt.figure(figsize = (10,6))
plt.plot(n_error,error_l2, linewidth=2)
plt.title('Error $L^2$')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

def comparar_fourier_cesaro(func, L, n_terms, nombre_funcion="Función"):
"""
Calcula y grafica la aproximación de Fourier estándar vs Sumas de Cesàro.

func: Función original a aproximar.
L: Longitud del intervalo [-L/2, L/2].
n_terms: Número máximo de coeficientes (n).

"""

def get_coefficients(n):
# Integración por método del trapecio como se indica en el documento
x_int = np.linspace(-L/2, L/2, 2000)
y_int = func(x_int)

# Coeficiente c0
c0 = (2/L) * trapezoid(y_int, x_int)

an = []
bn = []
for i in range(1, n + 1):
cos_term = np.cos(2 * np.pi * i * x_int / L)
sin_term = np.sin(2 * np.pi * i * x_int / L)
an.append((2/L) * trapezoid(y_int * cos_term, x_int))
bn.append((2/L) * trapezoid(y_int * sin_term, x_int))
return c0, an, bn

# Obtener coeficientes
c0, an, bn = get_coefficients(n_terms)

# Construir sumas parciales S_k para Cesàro
x_range = np.linspace(-L/2,L/2,1000)
sumas_parciales = []
current_sum = np.full_like(x_range, c0 / 2)
sumas_parciales.append(current_sum.copy())

for i in range(n_terms):
term = an[i] * np.cos(2 * np.pi * (i+1) * x_range / L) + \
bn[i] * np.sin(2 * np.pi * (i+1) * x_range / L)
current_sum += term
sumas_parciales.append(current_sum.copy())

# Calcular Suma de Cesàro (Promedio de las sumas parciales)
sigma_n = np.mean(sumas_parciales, axis=0)

# Gráfica
plt.figure(figsize=(12, 6))
plt.plot(x_range, func(x_range), 'k--', label=f"Original: {nombre_funcion}", alpha=0.6)
plt.plot(x_range, current_sum, label=f"Fourier Estándar (n={n_terms})", color='red', alpha=0.5)
plt.plot(x_range, sigma_n, label=f"Suma de Cesàro (n={n_terms})", color='blue', linewidth=2)

plt.title(f"Aproximación de {nombre_funcion}: Fourier vs Cesàro")
plt.xlabel("x")
plt.ylabel("f(x)")
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()

#Lo que se ejecuta---------------------------------------------------------
base_trigonometrica(6)

def f(x):
lista = []
for i in x:
if i < 0:
lista.append(0)
else:
lista.append(1)
return np.array(lista)

def MW(x):
n = 200
a = 1/2
b = 13

suma = 0
for i in range(n):
suma += a**i * np.cos(b**i * np.pi*x)

return suma

def g(x):
return x**2

serie_fourier_definitiva(f,10,[1,5,10,100])
comparar_fourier_cesaro(f, 10, 50, "Función Discontinua (Escalón)")
comparar_fourier_cesaro(MW, 10, 100, "Monstruo de Weierstrass")

</source>

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

Series de Fourier LÁJ

2026-02-16T16:21:46Z

Álvaro Moreno:

{{ TrabajoED | Series de Fourier. Grupo 6-A | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP25/26|2025-26]] | Luis García Suárez, Álvaro Moreno Cisneros, Juan Pérez Guerra }}

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

<source lang="python" line>

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

def base_trigonometrica(n):
#Puntos donde se grafica
x = np.linspace(-1,1,1000)
plt.figure(figsize = (10,6))

#Primer término de la serie
plt.plot(x, np.full_like(x, 0.5), label='1/2 (n=0)', linewidth=2, color='black')

#Términos trigonométricos
for n in range(1,n):
plt.plot(x, np.cos(n*np.pi*x), color = 'r', linestyle='-')
plt.plot(x, np.sin(n*np.pi*x), color = 'b', linestyle='-')

plt.title('Primeros términos de la base trigonométrica {1/2, cos(nπx), sin(nπx)}')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.axhline(0, color='black', linewidth=0.5)
plt.axvline(0, color='black', linewidth=0.5)
plt.grid(True, linestyle=':', alpha=0.6)
plt.legend(['1/2','cos','sin'], loc = 'upper right', bbox_to_anchor = (1,1))
plt.tight_layout()

# Mostrar resultado
plt.show()

def aproximar_funcion_cont(n_array):
def f(x):
return 1 - 2*np.abs(1/2 - x)

#Puntos donde se grafica y sus valores exactos
x = np.linspace(0,1,1000)
f_ev = f(x)

def serie_fourier(funcion,x_val,n_terms):
fn = np.zeros_like(x_val)
f_eval = funcion(x_val)

for k in range(1,n_terms+1):
#Integración númerica con método del trapecio
integrando = 2*f_eval*np.sin(k*np.pi*x_val)
ak = trapezoid(integrando,x_val)

#Sumar término
fn += ak * np.sin(k*np.pi*x_val)

return fn

#Gráfica
plt.figure(figsize = (10,6))
plt.plot(x,f_ev,'k--', label='f(x) original', linewidth=2)

for i in n_array:
fn_ev = serie_fourier(f,x,i)
plt.plot(x,fn_ev, label=f'n = {i}')

plt.title('Aproximación de f(x) mediante Serie de Fourier (Senos)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

#Cálculo de errores
n_error = []
for i in range(1,100):
n_error.append(i)

error_l2 = []
error_inf = []

for i in n_error:
f_n = serie_fourier(f,x,i)
dif = f_ev - f_n

error_l2.append(np.sqrt(trapezoid(dif**2,x)))
error_inf.append(round(float(np.max(np.abs(dif))),6))

fig, ax = plt.subplots(1,2,figsize = (10,4))

#Error L2
ax[0].plot(n_error, error_l2, label='Error $L^2$')
ax[0].set_title('Error $L^2$')

#Error Linf
ax[1].plot(n_error, error_inf, label='Error Uniforme ($L^{infty}$)')
ax[1].set_title('Error $L^{inf}$')

plt.show()

def serie_fourier_definitiva(f,L,n):

#Puntos donde se grafica y sus valores exactos
x = np.linspace(-L/2,L/2,1000)
f_ev = f(x)

def serie_fourier(funcion,x_val,n_terms):
fn = np.zeros_like(x_val)
f_eval = funcion(x_val)

c0 = trapezoid(2/L * f_eval,x_val)
fn = c0/2
for k in range(1,n_terms+1):
#Coeficientes
cn = trapezoid(2/L * f_eval * np.cos(2*k*np.pi*x_val/L),x_val)
dn = trapezoid(2/L * f_eval * np.sin(2*k*np.pi*x_val/L),x_val)

#Sumar términos
fn += cn* np.cos(2*k*np.pi*x_val/L) + dn * np.sin(2*k*np.pi*x_val/L)

return fn

#Gráfica
plt.figure(figsize = (10,6))
plt.plot(x,f_ev,'k--', label='f(x) original', linewidth=2)

for i in n:
fn_ev = serie_fourier(f,x,i)
plt.plot(x,fn_ev, label=f'n = {i}')

plt.title('Aproximación de f(x) mediante serie de Fourier')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

#Cálculo de errores
n_error = []
for i in range(1,100):
n_error.append(i)

error_l2 = []
error_inf = []

for i in n_error:
f_n = serie_fourier(f,x,i)
dif = f_ev - f_n

error_l2.append(np.sqrt(trapezoid(dif**2,x)))
error_inf.append(round(float(np.max(np.abs(dif))),6))

fig, ax = plt.subplots(1,2,figsize = (10,4))

#Error L2
ax[0].plot(n_error, error_l2, label='Error $L^2$')
ax[0].set_title('Error $L^2$')

#Error Linf
ax[1].plot(n_error, error_inf, label='Error Uniforme ($L^{infty}$)')
ax[1].set_title('Error $L^{inf}$')

plt.show()

#Lo que se ejecuta
# base_trigonometrica(6)
#aproximar_funcion_cont([1,5,10])

def f(x):
lista = []
for i in x:
if i < 0:
lista.append(0)
else:
lista.append(1)
return np.array(lista)

def MW(x):
n = 200
a = 1/2
b = 13

suma = 0
for i in range(n):
suma += a**i * np.cos(b**i * np.pi*x)

return suma

serie_fourier_definitiva(MW,20,[1,5,10,200])
</source>

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

Series de Fourier LÁJ

2026-02-16T16:10:14Z

Álvaro Moreno: Página creada con «{{ TrabajoED | Series de Fourier. Grupo 6-A | EDP|2025-26 | Luis García Suárez, Álvaro Moreno Cisneros, Juan Pérez Guerra }...»

Archivo:Series de fourier LÁJ.jpeg

2026-02-16T16:03:41Z

Álvaro Moreno:

Archivo:Series de fourier LÁJ.pdf

2026-02-16T16:02:05Z

Álvaro Moreno:

Archivo:Serie de Fourier LÁJ.pdf

2026-02-16T15:58:28Z

Álvaro Moreno: