标签: dft

我差不多一个月一直在和一个非常奇怪的虫子打架.问你们这是我最后的希望.我在C中编写了一个程序,它使用傅里叶(或倒数)空间中的隐式欧拉(IE)方案集成了2d Cahn-Hilliard方程:

"帽子"意味着我们处于傅里叶空间:h_q(t_n + 1)和h_q(t_n)是时间t_n和t_(n + 1)的h(x,y)的FT,N [h_q]是非线性算子应用于傅立叶空间中的h_q,而L_q是线性的,同样在傅立叶空间中.我不想过多介绍我使用的数值方法的细节,因为我确信问题不是来自那里(我尝试使用其他方案).

我的代码实际上非常简单.这是开始,基本上我声明变量,分配内存并为FFTW例程创建计划.

# include <stdlib.h>
# include <stdio.h>
# include <time.h>
# include <math.h>
# include <fftw3.h>
# define pi M_PI

int main(){

// define lattice size and spacing
int Nx = 150;         // n of points on x
int Ny = 150;         // n of points on y
double dx = 0.5;      // bin size on x and y

// define simulation time and time step
long int Nt = 1000; …

我正在实施fft作为我作业的一部分.我的问题在于使用位反转来实现数据元素的混乱.我收到以下警告:

DeprecationWarning:使用非整数而不是整数将导致将来出错.

data [x],data [y] = data [y],data [x]

自动评分系统(由大学提供)返回以下内容:

错误:只有整数,slices(:),省略号(...),numpy.newaxis(None)和整数或布尔数组才是有效索引.

我的代码是:

def shuffle_bit_reversed_order(data: np.ndarray) -> np.ndarray:
    """
    Shuffle elements of data using bit reversal of list index.

    Arguments:
    data: data to be transformed (shape=(n,), dtype='float64')

    Return:
    data: shuffled data array
    """

    # implement shuffling by reversing index bits

    size = data.size

    half = size/2;

    for x in range(size):
        xx = np.int(x)
        n = np.int(half)

        y = 0

        while n > 0:
            y += …

我目前正在尝试编写一些傅里叶变换算法.我从一个简单的DFT算法开始,如数学定义中所述:

public class DFT {
    public static Complex[] Transform(Complex[] input) {
        int N = input.Length;

        Complex[] output = new Complex[N];

        double arg = -2.0 * Math.PI / (double)N;
        for (int n = 0; n < N; n++) {
            output[n] = new Complex();
            for (int k = 0; k < N; k++)
                output[n] += input[k] * Complex.Polar(1, arg * (double)n * (double)k);
        }
        return output;
    }
}

所以我用以下代码测试了这个算法:

    private int samplingFrequency = 120;
    private int numberValues = 240;

    private void doCalc(object …

我一直在使用FFT的Exocortex实现,但我遇到了一些问题.

每当我在调用iFFT之前修改频率区间的幅度时,结果信号包含一些咔嗒声和砰砰声,特别是当信号中存在低频时(如鼓或低音).但是,如果我用相同的因子衰减所有的箱子,就不会发生这种情况.

让我举一个4样本FFT输出缓冲区的例子:

// Bin 0 (DC)
FFTOut[0] = 0.0000610351563
FFTOut[1] = 0.0

// Bin 1
FFTOut[2] = 0.000331878662
FFTOut[3] = 0.000629425049

// Bin 2
FFTOut[4] = -0.0000381469727
FFTOut[5] =  0.0

// Bin 3, this is the first and only negative frequency bin.
FFTOut[6] =  0.000331878662
FFTOut[7] = -0.000629425049

输出由成对的浮点组成,每个浮点数代表单个bin的实部和虚部.因此,bin 0(数组索引0,1)将代表DC频率的实部和虚部.正如你所看到的,第1和第3个箱子都有相同的值(除了Im部分的符号),所以我猜bin 3是第一个负频率,最后索引(4,5)将是最后的正值频率仓.

然后,为了衰减频率仓1,这就是我所做的:

// Attenuate the 'positive' bin
FFTOut[2] *= 0.5;
FFTOut[3] *= 0.5;

// Attenuate its corresponding negative bin.
FFTOut[6] *= 0.5;
FFTOut[7] *= 0.5;

对于实际测试,我使用1024长度的FFT,我总是提供所有样本,因此不需要0填充.

// Attenuate
var …

在python中获取二维DFT的DFT矩阵的最简单方法是什么？我在numpy.fft找不到这样的功能.谢谢!

我正在尝试理解有关神经网络的一些事情.首先,在浏览网页后,似乎没有办法通过神经网络计算(离散)傅里叶变换.你可以通过对事物进行硬编码来包含变换的傅里叶常数,然后获得一个不错的结果.为什么机器本身不能解决这些问题？

所以我试图在C中编写离散傅立叶变换以使用真正的32位浮点wav文件.它一次读取2帧(每个通道一个,但为了我的目的,我假设它们都是相同的,因此我使用frame [0]).该代码应该通过用频率20,40,60,...,10000探测输入文件的幅度谱来写出.我在输入框架上使用汉宁窗口.如果可以,我想避免使用复数.当我运行它时,它给了我一些非常奇怪的振幅(其中大部分非常小,并且与正确的频率无关),这让我相信我在计算中犯了一个根本性的错误.有人可以提供一些有关这里发生的事情的见解吗？这是我的代码:

int windowSize = 2205;
int probe[500];
float hann[2205];
int j, n;
// initialize probes to 20,40,60,...,10000
for (j=0; j< len(probe); j++) {
    probe[j] = j*20 + 20;
    fprintf(f, "%d\n", probe[j]);
}
fprintf(f, "-1\n");
// setup the Hann window
for (n=0; n< len(hann); n++) {
    hann[n] = 0.5*(cos((2*M_PI*n/(float)windowSize) + M_PI))+0.5;
}

float angle = 0.0;
float w = 0.0; // windowed sample
float realSum[len(probe)]; // stores the real part of the probe[j] within a window
float imagSum[len(probe)]; // stores …

我目前正在学习离散傅里叶变换,我正在玩numpy来更好地理解它.

我试图绘制一个"sin x sin x sin"信号并获得一个带有4个非零点的干净FFT.我天真地告诉自己:"好吧,如果我用这些幅度和频率绘制一个"罪恶+罪恶+罪恶+罪恶"信号,我应该获得相同的"罪x x sin x sin"信号,对吧？

嗯...不完全是

(首先是"x"信号,第二个是"+"信号)

两者共享相同的幅度/频率,但不是相同的信号,即使我可以看到它们有一些相似之处.

好的,因为我只绘制了FFT的绝对值,我想我丢失了一些信息.

然后我绘制了两个信号的实部,虚部和绝对值:

现在,我很困惑.我该怎么办？我从数学的角度阅读有关DFT的内容.我知道复杂的价值来自单位圈.我甚至不得不了解希尔伯特的空间,以了解它是如何工作的(这很痛苦!......而且我只是划伤了表面).我只想了解这些真实/想象的情节是否在数学世界之外具有任何具体含义:

• abs(fft):频率+幅度
• 真实的(fft):?
• 虚构(fft):?

代码:

import numpy as np
import matplotlib.pyplot as plt
N = 512 # Sample count
fs = 128 # Sampling rate
st = 1.0 / fs # Sample time
t = np.arange(N) * st # Time vector

signal1 = \
1   *np.cos(2*np.pi * t) *\
2   *np.cos(2*np.pi * 4*t) *\
0.5 *np.cos(2*np.pi * 0.5*t)

signal2 = \
0.25*np.sin(2*np.pi * …

我需要将两个多项式相乘,每个多项式具有小的积分系数.我需要一个C/C++中的快速FFT例程,它可以对它们进行卷积.我见过几个库,但它们似乎分布在多个文件中.重要的是我需要的代码不会太长,并且可以很容易地在单个.c/.cpp文件中使用和编译.

1. FFT应针对实际输入进行优化,至少即使不是小整数也是如此.
2. Radix 4实现(如果可用)也可以.
3. 编译它应该不需要特殊的编译标志,因为程序的编译必须在我无法控制的外部环境中完成.

一个非常符合我需求的是这里.但我需要两倍的速度.

我需要执行FFT和逆FFT变换.输入将是double的向量和矩阵.理想情况下,输出应该是std :: complex的数组,但我可以使用double _Complex.

我没有找到任何简单的例子,所有英特尔示例都在没有足够评论的情况下同时做了很多事情.

我只想在C++中使用一个简单的例子,将double的向量(或矩阵)作为输入并输出FFT转换结果(理想情况下使用std :: complex).