标签: fft

我只是不明白如何对两个多项式执行FFT,例如X ^ 2 + 1和X + 1 ......任何人都可以一步一步地与我一起完成这个过程吗？

非常感谢

我已在440Hz音频文件上运行此FFT算法.但我得到一个意想不到的声音频率:510Hz.

1. 在byteArray含有的.wav正确地转化为2-双阵列(重新&林份)？虚数组只包含0.
2. 我假设最高声音频率是xRe阵列的最大值:请看run()功能的最后一部分？也许这是我的错误:是平均还是类似的？

那有什么问题呢？

更新:最大和Re + Im在索引= 0,所以我得到频率= 0;

整个项目:包含.wav - >只需打开并运行.

using System;
using System.Net;
using System.IO;


namespace FFT {
    /**
     * Performs an in-place complex FFT.
     *
     * Released under the MIT License
     *
     * Copyright (c) 2010 Gerald T. Beauregard
     *
     * Permission is hereby granted, free of charge, to any person obtaining a copy
     * of this software and associated documentation files (the "Software"), …

我有一个大小矩阵mXn和一个[-1 0 1]我需要执行卷积的滤波器.我能够在O(n ^ 2)步骤中做到这一点,但是进一步谷歌搜索快速傅里叶变换继续弹出到处.我想知道FFT是否适合这个问题.矩阵只有随机整数.但如果我有浮动值,它会有所作为吗？FFT是否适合这样的问题？

我创建了一个与matlab帮助页面完全相同的对数啁啾.

t = 0:0.001:10;      % 10 seconds @ 1kHz sample rate
fo = 10; f1 = 400;   % Start at 10Hz, go up to 400Hz
X = chirp(t,fo,10,f1,'logarithmic');
figure(2);
spectrogram(X,256,200,256,1000,'yaxis');

然后我使用以下代码将其带到频域,该代码适用于我的其他应用程序.

fft_prep = fftshift(fft(X));
fft_mag = abs(fft_prep);
pos_fft = fft_mag(1:ceil(length(fft_mag)/2));
db_fft = 20*log10(pos_fft);
figure(1);
plot(db_fft);

我很惊讶地发现以下图表看起来令人兴奋1kHz-5kHz:

我对matlab中的啁啾功能并不熟悉,并且想知道是否有人看到了我遗漏的明显东西.欢迎任何其他指针.

所以,我正在尝试编写一个算法croot(k,n),它返回n的第k个根,n == n.我得到了大多数正确的答案,但它给了我一些奇怪的陈述,这些陈述似乎对某些数字是错误的.这是一个例子.

import cmath

def croot(k, n):
    if n<=0:
        return None
    return cmath.exp((2 * cmath.pi * 1j * k) / n)


for k in range(8):
    print croot(k, 8)

输出是:

(1+0j)
(0.70710...+0.70710...j)
(6.12323399574e-17+1j)

哇哇哇哇 所以k = 2和n = 8时的根是错误的,因为它应该是i,它将表示为1j,或j,或1.00000j等.有人可以帮助我吗？我这样做是因为我正在尝试编写FFT算法.我对复杂的数字和Python不是很有经验,所以我很可能犯了一个简单的错误.

谢谢,

如果你们需要任何其他信息,请询问.

我Matlab在C++使用Apple's 获得等效的Hilbert变换时遇到了问题Accelerate Framework.我已经能够使vDSP的FFT算法工作,并且在Paul R的帖子的帮助下,已经设法获得与Matlab相同的结果.

我已经读过两个:Jordan的这个stackoverflow问题并且已经阅读了Matlab算法(在'Algorithms'子标题下).将算法分为3个阶段:

1. 前进输入的FFT.
2. DC和Nyquist之间的零反射频率和双频率.
3. 对修改后的正向FFT输出进行逆FFT.

以下是每个阶段的Matlab和C++的输出.这些示例使用以下数组:

• Matlab的: m = [1 2 3 4 5 6 7 8];
• C++: float m[] = {1,2,3,4,5,6,7,8};

Matlab示例

阶段1:

  36.0000 + 0.0000i
  -4.0000 + 9.6569i
  -4.0000 + 4.0000i
  -4.0000 + 1.6569i
  -4.0000 + 0.0000i
  -4.0000 - 1.6569i
  -4.0000 - 4.0000i
  -4.0000 - 9.6569i

第二阶段:

  36.0000 + 0.0000i
  -8.0000 + 19.3137i
  -8.0000 + 8.0000i
  -8.0000 + 3.3137i
  -4.0000 + …

我有一个python代码,它导入4列txt文件,数字前三列是x,y,z坐标,第四列是该坐标的密度.

下面是读取的代码,转换为ndarray,傅里叶变换该字段,计算距离原点的距离(k =(0,0,0))和变换后的坐标,并取平均值并绘制它们.感谢pandas(用于数据分析的python库)和python FFT,加载256 ^ 3行和傅里叶变换非常快,并在几秒钟内完成.

但是,将加载的txt转换为numpy ndarray,计算平均密度(每个坐标的平均值),以及计算距离原点的距离(k =(0,0,0))需要很长时间.

我认为问题是最后的部分,但我无法弄清楚优化它的方法.

我有一个32核心机器的资源.

有人可以教我如何加速,使它成为一个多进程代码,或类似的东西,以便这些可以很快完成？谢谢.

(如果您是宇宙学家并且需要此代码,您可以使用它,但如果可以,请与我联系.谢谢)

from __future__ import division
import numpy as np

ngridx = 128
ngridy = 128    
ngridz = 128

maxK = max(ngridx,ngridy,ngridz)

#making input file
f = np.zeros((ngridx*ngridy*ngridz,4))

i = 0
for i in np.arange(len(f)):
    f[i][0] = int(i/(ngridy*ngridz))
    f[i][1] = int((i/ngridz))%ngridy
    f[i][2] = int(i%ngridz)
    f[i][3] = np.random.rand(1)
    if i%1000000 ==0:
        print i
#This takes forever
#end making input file

#Thanks to Mike,
a = f[:,3].reshape(ngridx,ngridy,ngridz)

avg =np.sum(f[:,3])/len(f)
a /= …

我了解了通过相关性进行DFT的工作原理，并将其用作理解FFT结果的基础。如果我有一个以44.1kHz采样的离散信号，则意味着如果我要采集1s的数据，那么我将有44,100个采样。为了对此进行FFT，我必须有一个44,100的数组和一个N = 44,100的DFT，以便获得检测高达22kHz频率所需的分辨率，对吗？（因为FFT只能将输入与正弦分量相关联，直到N / 2的频率）

显然，这是很多数据点和计算时间，而且我已经读到这是短时FT（STFT）出现的地方。如果我随后进行前1024个采样（〜23ms）并对其进行FFT，则取一个重叠的1024个样本，我可以每23ms获得信号的连续频域。那我该如何解释输出呢？如果对静态数据的FFT输出是具有fs /（N / 2）带宽的N / 2个数据点，那么STFT的频率输出的带宽是多少？

这是我在Mathematica中运行的示例：

100Hz正弦波，采样率为44.1kHz：

然后，我仅在前1024个点上运行FFT：

然后，感兴趣的频率在数据点3处，该点应以某种方式对应于100Hz。我认为44100/1024 = 43类似于比例因子，这意味着在此小窗口中具有1Hz的信号将对应于整个数据阵列中的43Hz的信号。但是，这将给我输出43Hz * 3 = 129Hz。我的逻辑正确但我的实现不正确吗？

最近，我一直在尝试在STM32F4-Discovery评估板上进行FFT计算，然后将其发送到PC。我已经研究了我的问题-我认为制造商提供的FFT函数有问题。

我正在使用CMSIS-DSP库。目前，我一直在用代码生成样本（如果可以正常工作，我将通过麦克风进行采样）。

我正在使用，arm_rfft_fast_f32因为将来我的数据将是浮动的，但是我在输出数组中得到的结果是疯狂的（我认为）-我的频率低于0。

number_of_samples = 512; (l_probek in code)
dt = 1/freq/number_of_samples

这是我的代码

float32_t buffer_input[l_probek];
uint16_t i;
uint8_t mode;
float32_t dt;
float32_t freq;
bool DoFlag = false;
bool UBFlag = false;
uint32_t rozmiar = 4*l_probek;

union
{
    float32_t f[l_probek];
    uint8_t b[4*l_probek];
}data_out;


union
{
    float32_t f[l_probek];
    uint8_t b[4*l_probek];
}data_mag;

union
{
    float32_t f;
    uint8_t b[4];
}czest_rozdz;


/* Pointers ------------------------------------------------------------------*/
arm_rfft_fast_instance_f32 S;
arm_cfft_radix4_instance_f32 S_CFFT;
uint16_t output;
/* ---------------------------------------------------------------------------*/
int main(void)
{
    freq = 5000;
    dt = 0.000000390625;


    _GPIO();
    _LED(); …

我有两个时间序列A和B。A的长度为mB，B的长度为n。m << n。两者都有尺寸d。

我通过在B上滑动A来计算A与B中所有子序列之间的距离。在python中，代码如下所示。

def sliding_dist(A,B)
    n = len(B)
    dist = np.zeros(n)
    for i in range(n-m):
        subrange = B[i:i+m,:]
        distance = np.linalg.norm(A-subrange)
        dist[i] = distance
    return dist

现在，这段代码需要花费很多时间来执行，并且我有很多计算要做。我需要加快计算速度。我的猜测是，我可以使用卷积和频域乘法（FFT）来做到这一点。但是，我无法实现它。

有任何想法吗？：） 谢谢