SciPy - 振荡函数

什么是振荡函数？

振荡函数是在一定值之间反复波动的函数，通常以周期性方式出现。这些函数在信号处理、物理学和工程领域很常见。

In SciPy中，振荡函数如 sine、cosine 和其他三角函数可以使用各种用于数值积分、优化和信号处理的工具有效处理。

在数值计算中，振荡函数可能会带来挑战，尤其是在大区间积分时，因为频繁的符号变化可能导致抵消误差或收敛困难。

SciPy 提供了专门的方法来高效处理此类函数，特别是在积分和求解微分方程的上下文中。振荡函数的一些常见示例包括 sine 和 cosine 函数、Bessel 函数和其他周期信号。

振荡函数的特性

以下振荡函数的特性在信号处理、物理学和电气工程等领域至关重要，这些领域中振荡函数用于建模波、振动和交流电 −

• 周期性：振荡函数通常以固定间隔重复其值，这种间隔称为周期。例如，像 sine 和 cosine 这样的函数以固定间隔 2π 表现出周期性行为。
• 符号交替：振荡函数在正值和负值之间波动。随着振荡，它们在峰值（即最大值）和谷值（即最小值）之间交替。
• 幅度：这指的是函数所能达到的最大绝对值。振荡函数的峰值和谷值由该幅度决定。
• 频率：这定义了单位区间内发生的振荡或周期数。较高的频率表示在相同区间内有更多振荡。
• 阻尼（可选）：一些振荡函数如阻尼振荡会由于阻尼因子而随时间减少幅度，这可以用指数项建模。
• 对称性：许多振荡函数表现出对称性，例如偶函数（即围绕 y 轴对称）或奇函数（即围绕原点对称），尤其是像 sine 和 cosine 这样的三角函数。
• 相移：振荡函数的相移指的是函数图形的水平位移，通过移动其峰值和谷值的位置。

SciPy 中处理振荡函数

振荡函数在各种科学计算中很常见，特别是在物理和工程领域。由于其重复特性，精确积分或分析这些函数可能具有挑战性。SciPy 提供了工具和策略来高效处理振荡行为。

通过调整积分方法或应用适当的技术，SciPy 可以有效管理振荡函数带来的挑战。以下详细介绍关键方法 −

• 用于积分的 Quad 函数： SciPy 的 quad 函数可以处理振荡积分。虽然 quad 会自动适应振荡，但对于高度振荡的函数有时会遇到困难，因此可能需要额外注意或特定方法。以下是使用 quad 函数处理振荡函数的示例 −

  import numpy as np
  from scipy.integrate import quad
  
  # 定义一个振荡函数
  def oscillatory_func(x):
      return np.sin(100 * x)
  
  # 执行积分
  result, error = quad(oscillatory_func, 0, np.pi)
  print("Integral result:", result)
  

  以下是 quad 函数用于积分的输出 −

  Integral result: 2.3480880169895062e-15
  

• 振荡权重函数： quad() 函数允许指定积分权重，这可以通过补偿快速变化来更高效地处理振荡函数。
• 避免精度损失： 对于频率非常高的函数，由于快速振荡可能会发生精度损失。在这种情况下，将积分范围分解成更小的子范围可能获得更好的精度。
• 专用方法： 对于某些高度振荡函数，推荐使用 Levin 积分或其他专用算法。虽然 SciPy 未直接提供这些方法，但可以使用其他包或自定义实现来处理高频振荡函数。

简单振荡函数

在这个示例中，我们定义了一个简单的正弦波函数，这是振荡函数的经典示例。我们将使用 Matplotlib 绘制正弦波，然后使用 SciPy 在特定区间上对其进行积分 −

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

# 定义振荡函数（正弦波）
def oscillatory_func(x):
    return np.sin(10 * x)  # 频率为 10 的正弦波

# 生成用于绘图的 x 值
x_values = np.linspace(0, 2 * np.pi, 100)
y_values = oscillatory_func(x_values)

# 绘制振荡函数
plt.plot(x_values, y_values, label="Sine wave", color='blue')
plt.title('Oscillatory Function (Sine Wave)')
plt.xlabel('x')
plt.ylabel('sin(10x)')
plt.grid(True)
plt.legend()
plt.show()

# 在区间 [0, 2π] 上执行积分
result, error = quad(oscillatory_func, 0, 2 * np.pi)
print("Integral of sin(10x) over [0, 2p]:", result)

以下是使用 SciPy 处理简单振荡函数的输出 −

SciPy 中的振荡函数类型

以下是 SciPy 中可用的不同类型的振荡函数 −

正弦波振荡函数

在 SciPy 中，振荡正弦波 函数指的是在指定区间内周期性地在最大值和最小值之间波动的周期函数。正弦函数的数学表示如下 −

f(x) = A . sin(Bx + C) + D

其中，A 是振幅，决定了波峰的高度；B 影响振荡频率，即单位区间内的周期数；C 是相移，决定了波沿 x 轴的起始位置；D 是垂直移位，将整个函数向上或向下移动。

以下是一个使用 SciPy 和 Matplotlib 生成并绘制振荡正弦波函数的简单示例 −

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

# 定义正弦波函数
def sine_wave(x, A=1, B=1, C=0, D=0):
    return A * np.sin(B * x + C) + D

# 设置参数
A = 1   # 振幅
B = 2   # 频率
C = 0   # 相移
D = 0   # 垂直移位

# 定义积分限
lower_limit = 0
upper_limit = 2 * np.pi

# 使用 scipy.integrate.quad 在一个周期内对正弦波进行积分
integral, error = integrate.quad(sine_wave, lower_limit, upper_limit, args=(A, B, C, D))

# 输出积分结果
print(f"正弦波从 {lower_limit} 到 {upper_limit} 的积分值为: {integral:.5f}")
print(f"估计误差: {error:.5f}")

# 生成绘图点
x = np.linspace(0, 2 * np.pi, 1000)
y = sine_wave(x, A, B, C, D)

# 绘制正弦波
plt.plot(x, y, label=f'正弦波 (A={A}, B={B})', color='blue')
plt.title('振荡正弦波函数')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.axhline(0, color='black', lw=0.5, ls='--')
plt.axvline(0, color='black', lw=0.5, ls='--')
plt.grid(True)
plt.legend()
plt.show()

以下是使用 SciPy 的振荡正弦函数的输出 −

Integral of sine wave from 0 to 6.283185307179586 is: -0.00000
Estimated error: 0.00000

余弦波振荡函数

SciPy 中的 振荡余弦 函数是指表现出振荡行为的函数，其特征是值呈现规律且重复的波动。具体来说，余弦函数是一个周期函数，其数学定义如下 −

f(x) = A . cos(Bx + C) + D

其中，A 是幅度，决定了波的峰值高度；B 影响振荡频率，即单位区间内的周期数；C 是相移，决定了函数水平方向的偏移量；D 是垂直移位，决定了函数垂直方向的偏移量。

振荡余弦波的关键特性

以下是 SciPy 中振荡余弦波的关键特性 −

• 周期性： 余弦函数以固定间隔重复其值，周期为 2/。
• 幅度： 幅度决定了函数振荡的高低程度。较大的幅度会导致更大的峰值和谷值。
• 频率： 频率表示函数振荡的速度。较高的频率会在给定区间内产生更多周期。
• 应用： 余弦函数等振荡函数常用于信号处理、物理学和工程学等领域，用于建模波形、振动和周期现象。

以下是使用 SciPy 生成并绘制振荡余弦波函数的简单示例 −

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

# 定义余弦波函数
def cosine_wave(x, A=1, B=1, C=0, D=0):
    return A * np.cos(B * x + C) + D

# 设置参数
A = 1   # 幅度
B = 2   # 频率
C = 0   # 相移
D = 0   # 垂直移位

# 定义积分限
lower_limit = 0
upper_limit = 2 * np.pi

# 使用 scipy.integrate.quad 在一个周期内对余弦波进行积分
integral, error = integrate.quad(cosine_wave, lower_limit, upper_limit, args=(A, B, C, D))

# 输出积分结果
print(f"Integral of cosine wave from {lower_limit} to {upper_limit} is: {integral:.5f}")
print(f"Estimated error: {error:.5f}")

# 生成绘图点
x = np.linspace(0, 2 * np.pi, 1000)
y = cosine_wave(x, A, B, C, D)

# 绘制余弦波
plt.plot(x, y, label=f'Cosine Wave (A={A}, B={B})', color='red')
plt.title('Oscillatory Cosine Wave Function')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.axhline(0, color='black', lw=0.5, ls='--')
plt.axvline(0, color='black', lw=0.5, ls='--')
plt.grid(True)
plt.legend()
plt.show()

以下是使用 SciPy 的振荡余弦函数的输出 −

Integral of cosine wave from 0 to 6.283185307179586 is: -0.00000
Estimated error: 0.00000

傅里叶级数 振荡函数

傅里叶级数是一种将周期函数表示为正弦和余弦函数之和的方法。在 SciPy 中，我们可以通过利用 快速傅里叶变换 (FFT) 来使用傅里叶级数分析振荡函数。

以下是一个使用 SciPy 为振荡函数创建傅里叶级数的示例 −

import numpy as np
import matplotlib.pyplot as plt

# 定义时间变量和振荡函数
t = np.linspace(0, 2 * np.pi, 1000)  # 时间变量
A = 1  # 振幅
frequency = 1  # 振荡函数的频率

# 创建复合函数（例如，方波）
square_wave = A * np.sign(np.sin(frequency * t))

# 计算傅里叶级数系数
n_terms = 10  # 傅里叶级数中的项数
fourier_coefficients = np.zeros((n_terms, 2))

for n in range(1, n_terms + 1):
    # 计算正弦和余弦项的系数
    a_n = (1 / np.pi) * np.trapz(square_wave * np.cos(n * t), t)  # 余弦系数
    b_n = (1 / np.pi) * np.trapz(square_wave * np.sin(n * t), t)  # 正弦系数
    fourier_coefficients[n - 1] = [a_n, b_n]

# 使用傅里叶级数重构函数
fourier_series = np.zeros_like(t)

for n in range(1, n_terms + 1):
    a_n, b_n = fourier_coefficients[n - 1]
    fourier_series += a_n * np.cos(n * t) + b_n * np.sin(n * t)

# 绘制原始函数及其傅里叶级数逼近
plt.figure(figsize=(10, 6))
plt.plot(t, square_wave, label='Square Wave', color='blue', linewidth=2)
plt.plot(t, fourier_series, label='Fourier Series Approximation', color='red', linestyle='--')
plt.title('Oscillatory Fourier Series Representation')
plt.xlabel('Time (t)')
plt.ylabel('Amplitude')
plt.axhline(0, color='black', lw=0.5, ls='--')
plt.axvline(0, color='black', lw=0.5, ls='--')
plt.grid(True)
plt.legend()
plt.show()

以下是使用 SciPy 的振荡 FFT 级数函数的输出 −

贝塞尔函数

贝塞尔函数是一组贝塞尔微分方程的解，通常出现在具有圆柱或球对称性的问题中。在 SciPy 中，我们可以使用 scipy.special 模块来计算贝塞尔函数。

这些函数本质上是振荡的，在波传播、静态势和信号处理等多个领域有应用。

此示例展示了如何计算和绘制第一类贝塞尔函数 _n(x)，这是最常见的贝塞尔函数类型之一 −

import numpy as np
import matplotlib.pyplot as plt
from scipy.special import jn  # Bessel function of the first kind

# 定义贝塞尔函数的阶数 (n) 和 x 值范围
n = 0  # 贝塞尔函数的阶数
x = np.linspace(0, 20, 1000)  # x 值范围

# 计算第一类贝塞尔函数
bessel_function = jn(n, x)

# 绘制贝塞尔函数
plt.figure(figsize=(10, 6))
plt.plot(x, bessel_function, label=f'Bessel Function J_{n}(x)', color='blue')
plt.title(f'Oscillatory Bessel Function of the First Kind (J_{n}(x))')
plt.xlabel('x')
plt.ylabel(f'J_{n}(x)')
plt.axhline(0, color='black', lw=0.5, ls='--')
plt.axvline(0, color='black', lw=0.5, ls='--')
plt.grid(True)
plt.legend()
plt.show()

以下是使用 SciPy 的振荡贝塞尔函数的输出 −

Airy 函数

Airy 函数 是一种特殊函数，用于求解微分方程，其特征是在自变量的负值时表现出振荡行为。在 SciPy 中，我们可以使用 scipy.special.airy() 函数来计算 Airy 函数。

它会返回 Airy 函数的值及其导数以及其他相关函数的值。

Airy 函数的特性

以下是 SciPy 中 Airy 函数的特性 −

• 振荡行为： 对于 x 的负值，Airy 函数表现为阻尼振荡波。
• 衰减： 对于 x 的负值，Airy 函数表现为阻尼振荡波。
• 振荡行为： 对于 x 的正值，Airy 函数快速衰减。
• 应用： Airy 函数常用于量子力学、光学和信号处理中，特别是在求解具有转折点的微分方程时。

以下是使用 SciPy 处理振荡 Airy 函数的示例 −

import numpy as np
import matplotlib.pyplot as plt
from scipy.special import airy

# 定义 x 值范围
x = np.linspace(-10, 10, 1000)

# 计算 Airy 函数 Ai(x) 及其导数
Ai, Aip, Bi, Bip = airy(x)

# 绘制 Airy Ai 函数（负 x 时振荡）
plt.figure(figsize=(10, 6))
plt.plot(x, Ai, label='Ai(x) - Airy 函数', color='blue')
plt.plot(x, Aip, label="Ai'(x) - Airy 函数的导数", color='red', linestyle='--')

# 标题和标签
plt.title('振荡 Airy 函数及其导数')
plt.xlabel('x')
plt.ylabel('值')
plt.axhline(0, color='black', lw=0.5, ls='--')
plt.axvline(0, color='black', lw=0.5, ls='--')
plt.grid(True)
plt.legend()

# 显示图形
plt.show()

以下是使用 SciPy 的振荡 Airy 函数的输出 −

修正贝塞尔函数

修正贝塞尔函数 是第一类函数，常用于物理和工程领域，特别是在处理圆柱坐标中的振荡问题时。在 SciPy 中，我们可以使用 scipy.special 模块来计算这些函数。

以下是使用 SciPy 处理振荡修正贝塞尔函数的示例 −

import numpy as np
import matplotlib.pyplot as plt
from scipy.special import iv  # 导入第一类修正贝塞尔函数

# 定义 x 值范围
x = np.linspace(0, 20, 1000)

# 定义贝塞尔函数的阶数
order = 0  # 可以更改为 1、2 等以获得更高阶

# 计算第一类修正贝塞尔函数
bessel_values = iv(order, x)

# 绘制结果
plt.figure(figsize=(10, 6))
plt.plot(x, bessel_values, label=f'第一类修正贝塞尔函数 (order={order})', color='blue')
plt.title('第一类振荡修正贝塞尔函数')
plt.xlabel('x')
plt.ylabel(f'I_{order}(x)')
plt.axhline(0, color='black', lw=0.5, ls='--')
plt.axvline(0, color='black', lw=0.5, ls='--')
plt.grid(True)
plt.legend()
plt.show()

以下是使用 SciPy 的振荡贝塞尔函数的输出 −