NFFT的傅立叶系数 - 非均匀快速傅里叶变换？

Question

我试图在python 2.7中使用包pynfft来进行非均匀快速傅立叶变换（nfft）。我已经学习了两个月的python，所以我遇到了一些困难。

这是我的代码：

import numpy as np
from pynfft.nfft import NFFT

#loading data, 104 lines
t_diff, x_diff = np.loadtxt('data/analysis/amplitudes.dat', unpack = True)

N = [13,8]
M = 52

#fourier coefficients
f_hat = np.fft.fft(x_diff)/(2*M)

#instantiation
plan = NFFT(N,M)

#precomputation
x = t_diff
plan.x = x
plan.precompute()

# vector of non uniform samples
f = x_diff[0:M]

#execution
plan.f = f
plan.f_hat = f_hat
f = plan.trafo()

我基本上遵循我在pynfft教程（http://pythonhosted.org/pyNFFT/tutorial.html）中找到的说明。

我需要nfft，因为我的数据采集的时间间隔不是恒定的（我的意思是，第一个测量是在t，第二个是在dt之后，第三个是在dt + dt之后，dt'与dt不同，依此类推）。

pynfft包在执行之前需要傅立叶系数的向量（“f_hat”），所以我使用numpy.fft计算它，但我不确定这个过程是否正确。有没有其他方法可以做到（也许与nfft）？

我还要计算频率;我知道numpy.fft有一个命令：对于pfft来说还有类似的东西吗？我没有在教程中找到任何内容。

感谢您给我的任何建议。

Answer 1

这是一个工作示例，取自here：

首先，我们定义我们想要重建的函数，它是四个谐波的总和：

import numpy as np
import matplotlib.pyplot as plt

np.random.seed(12345)

%pylab inline --no-import-all

# function we want to reconstruct
k=[1,5,10,30] # modulating coefficients
def myf(x,k): 
    return sum(np.sin(x*k0*(2*np.pi)) for k0 in k)

x=np.linspace(-0.5,0.5,1000)   # 'continuous' time/spatial domain; -0.5<x<+0.5
y=myf(x,k)                     # 'true' underlying trigonometric function

fig=plt.figure(1,(20,5))
ax =fig.add_subplot(111)

ax.plot(x,y,'red')
ax.plot(x,y,'r.')

                        # we should sample at a rate of >2*~max(k)
M=256                   # number of nodes
N=128                   # number of Fourier coefficients

nodes =np.random.rand(M)-0.5 # non-uniform oversampling
values=myf(nodes,k)     # nodes&values will be used below to reconstruct 
                        # original function using the Solver

ax.plot(nodes,values,'bo')

ax.set_xlim(-0.5,+0.5)

我们初始化并运行Solver：

from pynfft import NFFT, Solver

f     = np.empty(M,     dtype=np.complex128)
f_hat = np.empty([N,N], dtype=np.complex128)

this_nfft = NFFT(N=[N,N], M=M)
this_nfft.x = np.array([[node_i,0.] for node_i in nodes])
this_nfft.precompute()

this_nfft.f = f
ret2=this_nfft.adjoint()

print this_nfft.M  # number of nodes, complex typed
print this_nfft.N  # number of Fourier coefficients, complex typed
#print this_nfft.x # nodes in [-0.5, 0.5), float typed


this_solver = Solver(this_nfft)
this_solver.y = values          # '''right hand side, samples.'''

#this_solver.f_hat_iter = f_hat # assign arbitrary initial solution guess, default is 0

this_solver.before_loop()       # initialize solver internals

while not np.all(this_solver.r_iter < 1e-2):
this_solver.loop_one_step()

最后，我们显示频率：

import matplotlib.pyplot as plt

fig=plt.figure(1,(20,5))
ax =fig.add_subplot(111)


foo=[ np.abs( this_solver.f_hat_iter[i][0])**2 for i in range(len(this_solver.f_hat_iter) ) ]

ax.plot(np.abs(np.arange(-N/2,+N/2,1)),foo)

干杯