Question

我有周期T的周期函数，想知道如何获得傅立叶系数列表。我尝试使用来自numpy的fft模块，但它似乎更专注于傅里叶变换而非系列。也许它缺乏数学知识，但我看不出如何从fft计算傅立叶系数。

帮助和/或示例赞赏。

Answer 1

最后，最简单的事情（用黎曼和计算系数）是解决我问题的最便携/有效/最有效的方法：

def cn(n):
   c = y*np.exp(-1j*2*n*np.pi*time/period)
   return c.sum()/c.size

def f(x, Nh):
   f = np.array([2*cn(i)*np.exp(1j*2*i*np.pi*x/period) for i in range(1,Nh+1)])
   return f.sum()

y2 = np.array([f(t,50).real for t in time])

plot(time, y)
plot(time, y2)

给了我： alt text

Answer 2

这是一个老问题，但由于我必须对此进行编码，因此我在此处发布使用numpy.fft模块的解决方案，这可能比其他手工制作的解决方案更快。

DFT是用于计算函数的傅里叶级数的系数的数值精度的正确工具，定义为参数的解析表达式或作为一些离散点上的数值插值函数

这是实现，它允许通过传递适当的return_complex来计算傅立叶级数的实值系数或复值系数：

def fourier_series_coeff_numpy(f, T, N, return_complex=False):
    """Calculates the first 2*N+1 Fourier series coeff. of a periodic function.

    Given a periodic, function f(t) with period T, this function returns the
    coefficients a0, {a1,a2,...},{b1,b2,...} such that:

    f(t) ~= a0/2+ sum_{k=1}^{N} ( a_k*cos(2*pi*k*t/T) + b_k*sin(2*pi*k*t/T) )

    If return_complex is set to True, it returns instead the coefficients
    {c0,c1,c2,...}
    such that:

    f(t) ~= sum_{k=-N}^{N} c_k * exp(i*2*pi*k*t/T)

    where we define c_{-n} = complex_conjugate(c_{n})

    Refer to wikipedia for the relation between the real-valued and complex
    valued coeffs at http://en.wikipedia.org/wiki/Fourier_series.

    Parameters
    ----------
    f : the periodic function, a callable like f(t)
    T : the period of the function f, so that f(0)==f(T)
    N_max : the function will return the first N_max + 1 Fourier coeff.

    Returns
    -------
    if return_complex == False, the function returns:

    a0 : float
    a,b : numpy float arrays describing respectively the cosine and sine coeff.

    if return_complex == True, the function returns:

    c : numpy 1-dimensional complex-valued array of size N+1

    """
    # From Shanon theoreom we must use a sampling freq. larger than the maximum
    # frequency you want to catch in the signal.
    f_sample = 2 * N
    # we also need to use an integer sampling frequency, or the
    # points will not be equispaced between 0 and 1. We then add +2 to f_sample
    t, dt = np.linspace(0, T, f_sample + 2, endpoint=False, retstep=True)

    y = np.fft.rfft(f(t)) / t.size

    if return_complex:
        return y
    else:
        y *= 2
        return y[0].real, y[1:-1].real, -y[1:-1].imag

这是一个使用示例：

from numpy import ones_like, cos, pi, sin, allclose
T = 1.5  # any real number

def f(t):
    """example of periodic function in [0,T]"""
    n1, n2, n3 = 1., 4., 7.  # in Hz, or nondimensional for the matter.
    a0, a1, b4, a7 = 4., 2., -1., -3
    return a0 / 2 * ones_like(t) + a1 * cos(2 * pi * n1 * t / T) + b4 * sin(
        2 * pi * n2 * t / T) + a7 * cos(2 * pi * n3 * t / T)


N_chosen = 10
a0, a, b = fourier_series_coeff_numpy(f, T, N_chosen)

# we have as expected that
assert allclose(a0, 4)
assert allclose(a, [2, 0, 0, 0, 0, 0, -3, 0, 0, 0])
assert allclose(b, [0, 0, 0, -1, 0, 0, 0, 0, 0, 0])

结果a0,a1,...,a10,b1,b2,...,b10系数的图表： enter image description here

对于两种操作模式，这是该功能的可选测试。您应该在示例之后运行此命令，或者在运行代码之前定义周期函数f和句点T。

# #### test that it works with real coefficients:
from numpy import linspace, allclose, cos, sin, ones_like, exp, pi, \
    complex64, zeros


def series_real_coeff(a0, a, b, t, T):
    """calculates the Fourier series with period T at times t,
       from the real coeff. a0,a,b"""
    tmp = ones_like(t) * a0 / 2.
    for k, (ak, bk) in enumerate(zip(a, b)):
        tmp += ak * cos(2 * pi * (k + 1) * t / T) + bk * sin(
            2 * pi * (k + 1) * t / T)
    return tmp


t = linspace(0, T, 100)
f_values = f(t)
a0, a, b = fourier_series_coeff_numpy(f, T, 52)
# construct the series:
f_series_values = series_real_coeff(a0, a, b, t, T)
# check that the series and the original function match to numerical precision:
assert allclose(f_series_values, f_values, atol=1e-6)

# #### test similarly that it works with complex coefficients:

def series_complex_coeff(c, t, T):
    """calculates the Fourier series with period T at times t,
       from the complex coeff. c"""
    tmp = zeros((t.size), dtype=complex64)
    for k, ck in enumerate(c):
        # sum from 0 to +N
        tmp += ck * exp(2j * pi * k * t / T)
        # sum from -N to -1
        if k != 0:
            tmp += ck.conjugate() * exp(-2j * pi * k * t / T)
    return tmp.real

f_values = f(t)
c = fourier_series_coeff_numpy(f, T, 7, return_complex=True)
f_series_values = series_complex_coeff(c, t, T)
assert allclose(f_series_values, f_values, atol=1e-6)

Answer 3

Numpy不是真正计算傅里叶级数组件的合适工具，因为您的数据必须进行离散采样。你真的想使用像Mathematica这样的东西，或者应该使用傅里叶变换。

粗略地说，让我们看一下简单的周期2pi的三角波，我们可以很容易地计算出傅里叶系数（c_n = -i（（-1）^（n + 1））/ n，n> 0;例如，对于n = 1,2,3,4,5,6，c_n = { - i，i / 2，-i / 3，i / 4，-i / 5，i / 6，...} （使用Sum（c_n exp（i 2 pi nx））作为傅立叶级数。）

import numpy
x = numpy.arange(0,2*numpy.pi, numpy.pi/1000)
y = (x+numpy.pi/2) % numpy.pi - numpy.pi/2
fourier_trans = numpy.fft.rfft(y)/1000

如果你看看前几个傅立叶组件：

array([ -3.14159265e-03 +0.00000000e+00j,
         2.54994550e-16 -1.49956612e-16j,
         3.14159265e-03 -9.99996710e-01j,
         1.28143395e-16 +2.05163971e-16j,
        -3.14159265e-03 +4.99993420e-01j,
         5.28320925e-17 -2.74568926e-17j,
         3.14159265e-03 -3.33323464e-01j,
         7.73558750e-17 -3.41761974e-16j,
        -3.14159265e-03 +2.49986840e-01j,
         1.73758496e-16 +1.55882418e-17j,
         3.14159265e-03 -1.99983550e-01j,
        -1.74044469e-16 -1.22437710e-17j,
        -3.14159265e-03 +1.66646927e-01j,
        -1.02291982e-16 -2.05092972e-16j,
         3.14159265e-03 -1.42834113e-01j,
         1.96729377e-17 +5.35550532e-17j,
        -3.14159265e-03 +1.24973680e-01j,
        -7.50516717e-17 +3.33475329e-17j,
         3.14159265e-03 -1.11081501e-01j,
        -1.27900121e-16 -3.32193126e-17j,
        -3.14159265e-03 +9.99670992e-02j,

由于浮点精度（~1e-16为零），首先忽略接近0的分量。更难的部分是看到3.14159数字（在我们除以1000之前出现的数字）也应该被识别为零，因为函数是周期性的）。因此，如果我们忽略了这两个因素：

fourier_trans = [0,0,-i,0,i/2,0,-i/3,0,i/4,0,-i/5,0,-i/6, ...

你可以看到傅立叶级数与其他数字一样出现（我没有调查过;但我相信组件对应于[c0，c-1，c1，c-2，c2，...] ）。我根据维基使用约定：http://en.wikipedia.org/wiki/Fourier_series。

同样，我建议使用mathematica或能够集成和处理连续函数的计算机代数系统。

Answer 4

正如其他答案所提到的，似乎你所寻找的是一个符号计算包，所以numpy不适合。如果您希望使用基于python的免费解决方案，则sympy或sage应满足您的需求。

Answer 5

您是否有功能的离散样本列表，或者您的功能本身是离散的？如果是这样，使用FFT算法计算的离散傅立叶变换直接提供傅里叶系数（see here）。

另一方面，如果你有一个函数的解析表达式，你可能需要某种符号数学解算器。

Answer 6

关于例程的background information是您应该参考的第一个资源。

如何计算Numpy的傅立叶级数？

6 个答案: