快速傅立叶变换(FFT)的C#代码

这个代码是从《快速傅立叶变换(FFT)的C++实现与Matlab实验》这篇文章里的源代码转换而来,请注意查看原文。

在这里自己转换成了C#代码,并作了一些改动,主要是对N值的确定,原文的N值为常量1024,自己通过对输入的数组的长度来确定N值,N值的确定符合2的n次方,函数返回N值。通过作者提供的测试变量进行测试,能得到相应的结果。代码如下:

FFT代码:

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication1
{
    /// <summary>
    /// 快速傅立叶变换(Fast Fourier Transform)。 
    /// </summary>
    public class TWFFT
    {
        private TWFFT()
        {
        }

        private static void bitrp(float[] xreal, float[] ximag, int n)
        {
            // 位反转置换 Bit-reversal Permutation
            int i, j, a, b, p;

            for (i = 1, p = 0; i < n; i *= 2)
            {
                p++;
            }
            for (i = 0; i < n; i++)
            {
                a = i;
                b = 0;
                for (j = 0; j < p; j++)
                {
                    b = b * 2 + a % 2;
                    a = a / 2;
                }
                if (b > i)
                {
                    float t = xreal[i];
                    xreal[i] = xreal[b];
                    xreal[b] = t;

                    t = ximag[i];
                    ximag[i] = ximag[b];
                    ximag[b] = t;
                }
            }
        }

        public static int FFT(float[] xreal, float[] ximag)
        {
            //n值为2的N次方
            int n = 2;
            while (n <= xreal.Length)
            {
                n *= 2;
            }
            n /= 2;

            // 快速傅立叶变换,将复数 x 变换后仍保存在 x 中,xreal, ximag 分别是 x 的实部和虚部
            float[] wreal = new float[n / 2];
            float[] wimag = new float[n / 2];
            float treal, timag, ureal, uimag, arg;
            int m, k, j, t, index1, index2;

            bitrp(xreal, ximag, n);

            // 计算 1 的前 n / 2 个 n 次方根的共轭复数 W'j = wreal [j] + i * wimag [j] , j = 0, 1, ... , n / 2 - 1
            arg = (float)(-2 * Math.PI / n);
            treal = (float)Math.Cos(arg);
            timag = (float)Math.Sin(arg);
            wreal[0] = 1.0f;
            wimag[0] = 0.0f;
            for (j = 1; j < n / 2; j++)
            {
                wreal[j] = wreal[j - 1] * treal - wimag[j - 1] * timag;
                wimag[j] = wreal[j - 1] * timag + wimag[j - 1] * treal;
            }

            for (m = 2; m <= n; m *= 2)
            {
                for (k = 0; k < n; k += m)
                {
                    for (j = 0; j < m / 2; j++)
                    {
                        index1 = k + j;
                        index2 = index1 + m / 2;
                        t = n * j / m;    // 旋转因子 w 的实部在 wreal [] 中的下标为 t
                        treal = wreal[t] * xreal[index2] - wimag[t] * ximag[index2];
                        timag = wreal[t] * ximag[index2] + wimag[t] * xreal[index2];
                        ureal = xreal[index1];
                        uimag = ximag[index1];
                        xreal[index1] = ureal + treal;
                        ximag[index1] = uimag + timag;
                        xreal[index2] = ureal - treal;
                        ximag[index2] = uimag - timag;
                    }
                }
            }

            return n;
        }

        public static int IFFT(float[] xreal, float[] ximag)
        {
            //n值为2的N次方
            int n = 2;
            while (n <= xreal.Length)
            {
                n *= 2;
            }
            n /= 2;

            // 快速傅立叶逆变换
            float[] wreal = new float[n / 2];
            float[] wimag = new float[n / 2];
            float treal, timag, ureal, uimag, arg;
            int m, k, j, t, index1, index2;

            bitrp(xreal, ximag, n);

            // 计算 1 的前 n / 2 个 n 次方根 Wj = wreal [j] + i * wimag [j] , j = 0, 1, ... , n / 2 - 1
            arg = (float)(2 * Math.PI / n);
            treal = (float)(Math.Cos(arg));
            timag = (float)(Math.Sin(arg));
            wreal[0] = 1.0f;
            wimag[0] = 0.0f;
            for (j = 1; j < n / 2; j++)
            {
                wreal[j] = wreal[j - 1] * treal - wimag[j - 1] * timag;
                wimag[j] = wreal[j - 1] * timag + wimag[j - 1] * treal;
            }

            for (m = 2; m <= n; m *= 2)
            {
                for (k = 0; k < n; k += m)
                {
                    for (j = 0; j < m / 2; j++)
                    {
                        index1 = k + j;
                        index2 = index1 + m / 2;
                        t = n * j / m;    // 旋转因子 w 的实部在 wreal [] 中的下标为 t
                        treal = wreal[t] * xreal[index2] - wimag[t] * ximag[index2];
                        timag = wreal[t] * ximag[index2] + wimag[t] * xreal[index2];
                        ureal = xreal[index1];
                        uimag = ximag[index1];
                        xreal[index1] = ureal + treal;
                        ximag[index1] = uimag + timag;
                        xreal[index2] = ureal - treal;
                        ximag[index2] = uimag - timag;
                    }
                }
            }

            for (j = 0; j < n; j++)
            {
                xreal[j] /= n;
                ximag[j] /= n;
            }

            return n;
        }
    }
}

这里只给出了函数FFT()的,函数IFFT()可以进行相应测试。测试代码:

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            float[] a = {
                0.5751f,0.4514f,0.0439f,0.0272f,0.3127f,0.0129f,0.3840f,0.6831f,
                0.0928f,0.0353f,0.6124f ,0.6085f,0.0158f,0.0164f,0.1901f,0.5869f};

            float[] b = {
                0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,
                0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f};

            int n = TWFFT.FFT(a,b);

            Console.WriteLine("FFT:");

            Console.WriteLine("FFT的返回值N = {0}",n);
            Console.WriteLine();

            Console.WriteLine("i\ta\tb");

            Console.WriteLine();
            for (int i = 0; i < n; i++)
            {
                Console.WriteLine("{0}\t{1}\t{2}",i,a[i],b[i]);
            }

            Console.ReadLine();
        }
    }
}

时间: 2024-09-28 04:51:08

快速傅立叶变换(FFT)的C#代码的相关文章

fft快速傅立叶变换问题!!急

问题描述 我是用java进行fft变换.参考了一些资料,实现了二维的fft.比如说输入二维矩阵输出的结果和和参考的结果一样..但是我有个问题不明白,假如是一一幅图像作为二维矩阵进行fft变换,变换前的矩阵是每个像素的灰度值么?变换以后的复数矩阵怎么把它显示成该图像的频谱呢?贴出核心代码大家给个说明吧谢谢就是resPixArray返回的复数数组怎么把它显示成输入图像的频谱???//一维FFT变换publicvoidFFT(){//doublea=Math.log10(complex.length-

《精通Matlab数字图像处理与识别》一6.3 快速傅立叶变换及实现

6.3 快速傅立叶变换及实现 精通Matlab数字图像处理与识别 6.2节介绍了离散傅立叶变换(DFT)的原理,但并没有涉及其实现问题,这主要是因为DFT的直接实现效率较低.在工程实践中,我们迫切地需要一种能够快速计算离散傅立叶变换的高效算法,快速傅立叶变换(FFT)便应运而生.本节将给出快速傅立叶变换算法的原理及其实现细节. 6.3.1 FFT变换的必要性 之所以提出快速傅立叶变换(FFT)方法,是因为在计算离散域上的傅立叶变换时,对于N点序列,它的DFT变换与反变换对定义为 于是不难发现,计

《精通Matlab数字图像处理与识别》一6.2 傅立叶变换基础知识

6.2 傅立叶变换基础知识 精通Matlab数字图像处理与识别 要理解傅立叶变换,掌握频率域滤波的思想,必要的数学知识是不能跳过的.为便于理解,我们将尽可能定性地去描述.其实傅立叶变换所必需的数学知识对于一个理工科大学二年级以上的学生来说是很有限的,高等数学中傅立叶级数的知识加上线性代数中基和向量空间的概念就足够了.下面就从一维情况下的傅立叶级数开始进行介绍. 6.2.1 傅立叶级数 法国数学家傅立叶发现任何周期函数只要满足一定条件(狄利赫里条件)都可以用正弦函数和余弦函数构成的无穷级数,即以不

利用xml+xsl快速生成大量JSP的常用代码的方法.

js|xml 利用xml+xsl快速生成大量JSP的常用代码的方法. 参考Jbuilder的Servlet向导来使用xml+xsl产生JSP的常用代码.xml样本: <?xml version="1.0" encoding="GB2312"?><?xml-stylesheet type="text/xsl" href="jspram.xsl"?><jsp xmlns:xsi="http:

程序-小波帧变换的图像融合代码

问题描述 小波帧变换的图像融合代码 最近在做图像融合方面的论文需要小波帧变换方面的程序,是两幅灰度图像 解决方案 这个问题貌似遇到过,你可以到知网里,下载一些相关的论文看看,最近的论文这种问题已经解决了吧,,祝你好运 解决方案二: 这个问题貌似遇到过,你可以到知网里,下载一些相关的论文看看,最近的论文这种问题已经解决了吧,,祝你好运 解决方案三: 这个问题貌似遇到过,你可以到知网里,下载一些相关的论文看看,最近的论文这种问题已经解决了吧,,祝你好运

JS实现自动变换的菜单效果代码_javascript技巧

本文实例讲述了JS实现自动变换的菜单效果代码.分享给大家供大家参考.具体如下: 这是一款自动变换的JS菜单,由原来的一款自动TAB修改而成的,有需要的就拿去,代码内有几个JS函数,分别用来控制TAB的自动切换. 运行效果截图如下: 在线演示地址如下: http://demo.jb51.net/js/2015/js-auto-cha-menu-codes/ 具体代码如下: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//E

Emmet——快速的编写HTML和CSS代码

这学期被自愿的选择了<Web应用程序设计>这门课,还是自学课.好吧,反正基础的HTML和CSS迟早也是要学习的,就提前学吧. 按照我的性子,当学习新的语言以及语法规则的时候,我就又开始折腾编辑器的语法高亮和配置自动补全功能了.其实接触到新的语言时,我个人建议还是不要急着去寻找相关的IDE去使用,还是先用基本的文本编辑器写,尝试自己手工去构建.等到理解了之后再使用IDE提高编码效率也不晚.IDE的方便是建立在对很多细节的屏蔽之上的,这样对学习新的知识没有益处.没有手写HTML的经验,全靠IDE点

在Windows xp/7下快速设置IP地址的批处理代码

  @把下面bat保存,就可以用了. @echo off echo 正在配置ip,请稍等- set name="本地连接" set ipaddress=1.2.3.4 set mask=255.255.255.0 set gateway=1.2.3.4 set dns=1.2.3.4 set wins=1.2.3.4 echo 正在配置%name%,请稍等- echo 正在配置首选DNS:%dns%- netsh interface ip set dns name="本地连接

傅立叶变换-是否有支持定点化,支持NEON, 支持任意长度的的傅里叶变换的库

问题描述 是否有支持定点化,支持NEON, 支持任意长度的的傅里叶变换的库 现在正在做实时信号处理,在ARM上对性能要求比较高,所以需要比较快的FFT库 需要能同时支持定点化,NEON指令优化,并且支持非2的N次方的傅里叶变换库.希望有谁有用过的,了解过的,介绍一下给点指导. PS:现在找到大部分库都都不能满足上面三个特性,例如FFTWKISSFFTNET10 等都是只能满足两个特性.