傅里叶级数

最新推荐文章于 2025-04-18 03:55:19 发布
最新推荐文章于 2025-04-18 03:55:19 发布
阅读量8.8w 收藏 363
点赞数 83
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37855507/article/details/89415218
版权

一、理论基础

  任何周期函数都可以看成是不同振幅，不同相位的正弦波的叠加。

1. 三角函数系的正交性：

   三角函数系：
在这里插入图片描述

         三角函数系中任意两个不同的函数之积在[-π,π]上的积分为0。

在这里插入图片描述
在这里插入图片描述

2. 将周期函数展开为三角级数

   假设有周期函数 f(x)=f(x+2π)，周期为2*PI；则函数可以展开为下面的三角级数：

      在这里插入图片描述

书中展示的公式为： 在这里插入图片描述
以上两个公式本质上是形同的,下面给给出求解上式参数的过程：在这里插入图片描述

在这里插入图片描述

2 求取参数an,bn

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3. 离散傅里叶变换：

在这里插入图片描述

     已知，连续的傅里叶变换公式为：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4. 快速傅里叶变化（FFT）：

   离散傅里叶变换的计算量是巨大的。对一幅 MxN 的图像，他需要M^2 N^2 次的复数乘法和加法。因此，一般使用离散傅里叶变换的快速算法——快速傅里叶变换。

4.1 算法思想：

复数域中将一般形式转化为指数形式的公式推导：

在这里插入图片描述

2. n次单位根：

         在这里插入图片描述

n次单位根在复数域相当于是一个：

         幅角为： 2π/n

         长度为： 1

                         的虚数。

在这里插入图片描述

3. n次单位根的性质：

在这里插入图片描述
在这里插入图片描述

4.2.多项式系数表示法：

     在这里插入图片描述

4.3.多项式点值表示法：

  因为n次函数可由n+1个点确定下来（可以将每一个点列一个n次方程）。
在这里插入图片描述
由上面的式子可以唯一的确定一组多项式系数，a0,a1,a2,…an,因此多项式可以使用下面的点值表示法：
       在这里插入图片描述



点值表示法的乘法运算：

  两个多项式P,Q分别取点(x，y1)和(x，y2) ，P*Q就会去点（x，y1*y2）；

在这里插入图片描述

DFT(离散傅里叶变换):

  求多项式的点值表示法：

     想要求出一个多项式的点值表示法，需要选出n+1个数分别带入到多项式里面。带入一个数的复杂度是Θ(n) Θ(n)的，那么总复杂度就是Θ(n2) 。因为单位根有下面的性质，所以可以尝试去n次单位根来作为n+1个数。
在这里插入图片描述
在这里插入图片描述
                    在这里插入图片描述
在这里插入图片描述

FFT算法：

在这里插入图片描述
在这里插入图片描述

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DFT与FFT算法
{
    /// <summary>
    /// 实现复数运算的类
    /// </summary>
    class complex
    {
        //复数为a+bi
        //其中real为实部字段
        private double real;
        /// <summary>
        /// 复数的实部（属性）
        /// </summary>
        public double Real
        {
            get { return real; }
            set { real = value; }
        }
        //image为虚部字段。
        private double image;
        /// <summary>
        /// 复数的虚部（属性）
        /// </summary>
        public double Image
        {
            get { return image; }
            set { image = value; }
        }

        /// <summary>
        /// 默认构造函数
        /// </summary>
        public complex ()
            :this(0,0)
        {
        }
        /// <summary>
        /// 只有实部的构造函数
        /// </summary>
        /// <param name="real"></param>
        public complex(double real)
            : this(real, 0)
        {

        }
        /// <summary>
        /// 由实部和虚部创建的构造函数
        /// </summary>
        /// <param name="real"></param>
        /// <param name="image"></param>
        public complex(double real,double image)
        {
            this.real = real;
            this.image = image;
        }

        /// <summary>
        /// 重载加法符号
        /// </summary>
        /// <param name="c1"></param>
        /// <param name="c2"></param>
        /// <returns></returns>
        public static complex operator +(complex c1,complex c2)
        {
            return new complex(c1.real + c2.real, c1.image + c2.image);
        }
        /// <summary>
        /// 重载减法
        /// </summary>
        /// <param name="c1"></param>
        /// <param name="c2"></param>
        /// <returns></returns>
        public static complex operator -(complex c1, complex c2)
        {
            return new complex(c1.real - c2.real, c1.image - c2.image);
        }
        
        /// <summary>
        /// 重载乘法
        /// </summary>
        /// <param name="c1"></param>
        /// <param name="c2"></param>
        /// <returns></returns>
        public static complex operator *(complex c1, complex c2)
        {
            return new complex(c1.real * c2.real - c1.image * c2.image, c1.image * c2.real + c1.real * c2.image);
        }

        /// <summary>
        /// 复数的模
        /// </summary>
        /// <returns></returns>
        public double ToModul()
        {
            return Math.Sqrt(real * real + image * image);
        }

        /// <summary>
        /// 重载ToString 方法
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
           if(Real==0 && Image ==0)
           {
               return string.Format("{0}", 0);
           }
           if(Real==0 && (Image !=1 && Image !=-1))
           {
               return string.Format("{0} i", Image);
           }

           if(Image==0)
           {
                return string.Format("{0}", Real);
           }
           if(Image==1)
           {
               return string.Format("i");
           }
           if (Image == -1)
           {
               return string.Format("- i");
           }
           if (Image < 0)
           {
               return string.Format("{0} - {1} i", Real, -Image);
           }
           return string.Format("{0} + {1} i", Real, Image);
        }

    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DFT与FFT算法
{
    /// <summary>
    /// 实现运算
    /// </summary>
    class DFT
    {
        /// <summary>
        /// 求复数数组的模数组
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static double[] Cmp2Mdl(complex[] input)
        {
            //确定模数组的长度
            double[] output = new double[input.Length];
            //对复数求模
            for(int i=0;i<input.Length;i++)
            {
                if(input[i].Real>0)
                {
                    output[i] = -input[i].ToModul();
                }
                else
                {
                    output[i] = input[i].ToModul();
                }
            }
            return output;
        }

        /// <summary>
        /// 傅里叶变换以及傅里叶反变换
        /// </summary>
        /// <param name="input"></param>
        /// <param name="invert，false FFT变换，true  IFFT变换"></param>
        /// <returns></returns>
        public static complex[] FFT(double[] input,bool invert)
        {
            //由输入序列确定输出序列的长度
            complex[] output = new complex[input.Length];

            ///将输入的实数数组转换为复数数组
            for(int i=0;i<input.Length;i++)
            {
                output[i]=new complex(input[i]);
            }

            //返回FFT或者IFFT序列
            return output = FFT(output, invert);
        }
        /// <summary>
        /// 傅里叶变换以及傅里叶反变换,递归蝶形运算
        /// </summary>
        /// <param name="input"></param>
        /// <param name="invert，false FFT变换，true  IFFT变换"></param>
        /// <returns></returns>
        public static complex[] FFT(complex[] input,bool invert)
        {
            ///如果输入序列只有一个元素，输出这个元素并返回
            if(input.Length==1)
            {
                return new complex[] { input[0]};
            }

            //输入序列的长度
            int length = input.Length;
            //输入序列长度的一半
            int half = length / 2;

            //由输入序列的长度确定输出序列的长度
            complex[] output = new complex[length];

            //正变换旋转因子的基数
            double fac = -2.0 * Math.PI / length;
            //反变换旋转因子的基数是正变换的相反数
            if(invert)
            {
                fac = -fac;
            }

            //序列中下标中为偶数的点
            complex[] evens = new complex[half];

            for(int i=0;i<half;i++)
            {
                evens[i] = input[2 * i];
            }
            //求偶数点FFT或IFFT的结果，递归实现多级蝶形运算
            complex[] evenResult = FFT(evens,invert);

            //序列中下标为奇数的点
            complex[] odds=new complex[half];
            for(int i=0;i<half;i++)
            {
                odds[i] = input[2 * i + 1];
            }
            //求奇数点FFT或IFFT的结果，递归实现多级蝶形运算
            complex[] oddResult = FFT(odds, invert);

            for(int k=0;k<half;k++)
            {
                ///旋转因子
                double fack = fac * k;

                //进行蝶形运算
                complex oddpart = oddResult[k] * new complex(Math.Cos(fack), Math.Sin(fack));
                output[k] = evenResult[k] + oddpart;
                output[k + half] = evenResult[k] - oddpart;
            }

            //返回FFT或IFFT的结果
            return output;
        }

    }

}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DFT与FFT算法
{
    class Program
    {
        static void Main(string[] args)
        {
            double[] input = {
                2,3,4,5,6,7,8,9
                //0.0928,0.0353,0.6124,0.6085,0.0158,0.0164,0.1901,0.5869
                             };
            complex[] output_complex = new complex[input.Length];
            output_complex = DFT.FFT(input, false);//正变换
            Console.WriteLine();
            Console.WriteLine("i\treal\timage");
            Console.WriteLine();
            for (int i = 0; i < input.Length; i++)
            {
                Console.WriteLine("{0}\t{1}\t{2}", i, output_complex[i].Real, output_complex[i].Image);
            }

            Console.WriteLine("------------------------------------------");
            output_complex = DFT.FFT(output_complex, true);//反变换
            Console.WriteLine();
            Console.WriteLine("i\treal\timage");
            Console.WriteLine();
            for (int i = 0; i < input.Length; i++)
            {
                Console.WriteLine("{0}\t{1}\t{2}", i, output_complex[i].Real, output_complex[i].Image);
            }
            input = DFT.Cmp2Mdl(output_complex);

            Console.WriteLine("------------------------------------------");

            //反变换完了除以数据长度
            for (int i = 0; i < input.Length; i++)
            {
                input[i] = -input[i] / input.Length;
            }
            foreach (double a in input)
            {
                Console.WriteLine("{0}", a);
            }
            Console.ReadKey();
        }
    }
}
溪午X
关注
三角波傅立叶级数展开式matlab,常见波形的傅里叶级数展开式
weixin_39866874的博客
03-24 8533
引言近来，在开展课题时遇到了需要将梯形波进行傅里叶级数展开的问题，查询了一些资料(惭愧，一开始就没想着自己动手积分)，然后没有找到自己想要的结果(其实有相近的，只不过不是任意周期的，当时没有转变过来)，最后还是动手算出来了，在这里做一个小小的记录，算是回顾以前的知识吧，捂脸。由于像三角波，矩形波，梯形波这种波形不连续，因此在仿真软件中很容易出现计算不收敛的情况。所以，在这种情况下，利用一系列谐波叠...
傅里叶变换与傅里叶级数理解
.
02-18 2710
作 者：韩 昊 知 乎：Heinrich 微 博：@花生油工人 知乎专栏：与时间无关的故事 谨以此文献给大连海事大学的吴楠老师，柳晓鸣老师，王新年老师以及张晶泊老师。 转载的同学请保留上面这句话，谢谢。如果还能保留文章来源就更感激不尽了。 https://zhuanlan.zhihu.com/p/19763358 p.s.本文无论是cos还是sin，都统一用“正弦波”（Sine Wave）一词...
由浅入深系列——傅里叶变换
m0_37755875的博客
02-26 1182
频率（Frequency）是单位时间内周期性事件重复的次数，单位为赫兹（Hz）。​心跳：1 Hz ≈ 60次/分钟，频域中对应一个尖峰（图2）。​钢琴中央C：261.63 Hz，代表每秒振动次数，与琴弦长度/张力相关。哲学延伸：频率是物质的“振动指纹”。从DNA双螺旋到银河系旋转，宇宙本质是不同频率振动的叠加。
傅里叶变换学习记录
最新发布
Starsad的博客
04-18 718
傅里叶变换是信号处理中的一个非常重要的数学工具，它的核心思想是将复杂的信号分解成不同频率的正弦波的叠加。虽然看起来可能有点抽象，但可以通过一些通俗的例子和应用来帮助理解它在电子信息中的实际作用。提示：首先粗略了解一下傅里叶变换......拓展——计算K维向量在某个基向量上的投影方法：现在的需求是计算 k 维向量 u 在基向量 v_i 上的投影。首先，回忆向量投影的公式。向量 u 在向量 v_i 上的投影公式是：投影值 = (u・v_i) / ||v_i||² * v_i。
傅立叶级数计算器：启动一个 GUI，根据其傅立叶级数的第 n 个部分和绘制函数-matlab开发
06-01
傅立叶级数计算器是一种数学工具，用于将复杂的周期性函数分解为一组简单的正弦和余弦函数的无限级数。在 MATLAB 开发环境中，我们可以创建一个图形用户界面（GUI）来实现这一功能，帮助用户直观地理解傅立叶级数的...
方波：傅立叶级数-matlab开发
05-30
标题中的“方波：傅立叶级数-matlab开发”揭示了本次讨论的核心主题，即使用MATLAB软件来分析和生成方波的傅立叶级数表示。傅立叶级数是一种数学工具，用于将周期性信号分解为一系列简单的正弦和余弦函数的线性组合...
周期锯齿波傅立叶级数（离散频谱）的MATLAB实现
06-18
周期锯齿波傅立叶级数（离散频谱）的MATLAB实现，绘制并观察周期锯齿脉冲信号频谱特性，可自改成其他周期函数
傅里叶级数在电路中的应用： 半波整流器：傅里叶级数-matlab开发
05-30
傅里叶级数是数学分析中的一个重要工具，它在电路理论和信号处理中扮演着核心角色。本主题探讨了傅里叶级数如何应用于半波整流器的电路分析，结合MATLAB软件进行仿真和计算。 半波整流器是一种基本的电力电子设备，...
傅里叶级数（Fourier）
2302_78846666的博客
01-21 6651
一、傅里叶展开的意义1、泰勒(Tarlor展开的基本形式2、傅里叶(fourier)展开的基本形式二、三角函数系1、三角函数系2、性质3、积化和差公式4、例题讲解三、如何求解傅里叶级数中的a0、an、bn四、傅里叶级数1的展开方法和狄利克雷(Dirichlet)收敛定理1、展开方法傅里叶图像要求有周期性，进行周期延拓2、狄利克雷收敛证明图像五、正弦级数和余弦级数1、正弦级数和余弦级数的介绍2、奇延拓和偶延拓。
傅立叶变换与傅立叶级数解析
"傅立叶变换与傅立叶级数是数学物理方法中的核心概念，它们在处理周期性信号和复杂函数表示上有着重要应用。傅立叶级数是将周期为2π的函数表示为无限个正弦和余弦函数的线性组合，其基本函数包括1、cos(nx)和sin(nx...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值