CUDA官方库函数：傅里叶变换（CUFFT）函数的介绍及使用方法

于 2024-05-14 22:15:00 发布
阅读量1.9k 收藏 40
点赞数 44
文章标签： c++ matlab gpu算力
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zy4213/article/details/136017680
版权

本文主要在前文的基础上进一步分析CUFFT函数库的使用方法，并利用matlab对运算结果做了对比。

CUFFT函数的使用流程

下面对cuFFT库的使用流程做以下阐述并且不失一般性：

  1. 变量内存分配及初始化
  2. 创建并配置cuFFT句柄：首先使用cufftHandle创建cuFFT句柄，然后调用函数cufftPlan1D()、cufftPlan2D()配置参数，其中cufftPlan1D()表示对一维向量执行FFT/IFFT操作，cufftPlan2D()表示先对矩阵的行执行FFT/IFFT操作，再对矩阵的列执行FFT/IFFT操作。指定待执行FFT操作的信号输入与输出类型，其中CUFFT_C2C表示输入输出均为复数，CUFFT_C2R表示输入复数输出实数等四类。
  3. 执行FFT策略：使用cufftExecC2C()函数执行FFT运算，此函数可以通过参数指定执行傅里叶变换(CUFFT_FORWARD)或逆傅里叶变换(CUFFT_INVERSE)。
  4. 销毁句柄：调用cufftDestroy()函数实现句柄销毁功能。

CUFFT函数的使用示例及对比


CUDA官方函数库：傅里叶变换（CUFFT）相关库函数介绍icon-default.png?t=N7T8https://blog.csdn.net/zy4213/article/details/136220080?spm=1001.2014.3001.5502和CUDA官方函数库：傅里叶变换（CUFFT）相关库函数使用示例icon-default.png?t=N7T8https://blog.csdn.net/zy4213/article/details/136288489?spm=1001.2014.3001.5502        两篇文章对CUFFT的库函数的使用方法做了介绍并给出了示例，但是并没有做更一步的分析，下面根据自己的了解，以代码及实际运行结果的形式对CUFFT函数做进一步分析。

1、数据生成

首先利用matlab生成1024个随机数据并以单精度形式存入数据文件“inData_cufftComplex1”，方便后续数据对比使用。

clc
clear all
close all;

iLen=1024;

%%
if(1)
    j=1;
    for i=1:1:iLen
        ccInData(j)=rand();
        ccInData(j+1)=rand();
        j=j+2;
    end
    filename=fopen('data/inData_cufftComplex1.dat','w');
    fwrite(filename,ccInData,'float32');
    fclose(filename);
    ccInData_complex=complex(ccInData(1:2:end),ccInData(2:2:end));
%     ccInDataFFT=fft(ccInData_complex);
end

2、一维行矩阵傅里叶变换

首先利用cufftExecC2C()函数执行一维行矩阵的傅里叶变换。并将计算结果写入"savaData_cufftComple.dat"文件保存，方便matlab读取并做对比。

#include"stdio.h"
#include"cuda.h"
#include <cufft.h>
void readFileComplex(cufftComplex* matrix,int iReadLen);
void writeFileComplex(cufftComplex *matrix,int iWriteLen);
int main(int argc, char **argv) {

	int col = 1;
	int row = 1024;
	int length = row * col;
	//主机端(CPU)变量定义及初始化
	cufftComplex *inputH = (cufftComplex*) malloc(sizeof(cufftComplex) * length);
	cufftComplex *outputH = (cufftComplex*) malloc(sizeof(cufftComplex) * length);
	memset(inputH, 0, sizeof(cufftComplex) * length);
	memset(outputH, 0, sizeof(cufftComplex) * length);
	//设备端(GPU)变量定义及初始化
	cufftComplex *inputD;
	cudaMalloc((void**) &inputD, length * sizeof(cufftComplex));
	cufftComplex *outputD;
	cudaMalloc((void**) &outputD, length * sizeof(cufftComplex));
	cudaMemset(inputD, 0, length * sizeof(cufftComplex));
	cudaMemset(outputD, 0, length * sizeof(cufftComplex));
	//读取二进制文件中的数据
	readFileComplex(inputH,length);
	//将数据从主机端复制至设备端
	cudaMemcpy(inputD, inputH, sizeof(cufftComplex) * length, cudaMemcpyHostToDevice);

	//1：创建用于FFT变换的句柄
	cufftHandle plan1d;
	//2：配置信号长度及输入输出数据类型信息
	cufftPlan1d(&plan1d, row, CUFFT_C2C, col);
	//3：调用函数执行或正或逆傅里叶变换
	cufftExecC2C(plan1d, inputD, outputD, CUFFT_FORWARD);
	//将数据从设备端复制至主机端
	cudaMemcpy(outputH, outputD, sizeof(cufftComplex) * length, cudaMemcpyDeviceToHost);
	//将数据写入二进制文件
	writeFileComplex(outputH,length);

}
void readFileComplex(cufftComplex* matrix,int iReadLen){
	FILE* fp;
	if ((fp = fopen("inData_cufftComplex.dat", "rb")) == NULL) {
		printf("file open failed\n");
	} else {
		fread(matrix , sizeof(cufftComplex), iReadLen, fp);
	}
}
void writeFileComplex(cufftComplex *matrix,int iWriteLen){
	FILE* fp;
	if((fp=fopen("saveData_cufftComplex.dat","wb"))==NULL){
		printf("file open failed\n");
	}else{
		fwrite(matrix, sizeof(cufftComplex) , iWriteLen, fp);
	}
}

 编译方法：

//test.cu代表文件名，test代表可执行文件名
nvcc test.cu -o test -lcufft

编译通过之后执行可执行文件即可得到运行结果：

./test

利用matlab读取生成的结果文件并对比

clc
clear all
close all;

row=1;
col=1024;
len=row*col;
input=zeros(1,len);
for i=1:1:len
    input(i)=complex(i-1,i);
end
output=fft(input);

filename='data/inData_cufftComplex.dat';
fileID=fopen(filename,'rb');
ccInData=fread(fileID,'float32');
ccInData_complex=complex(ccInData(1:2:end),ccInData(2:2:end));
%对输入信号做FFT运算
ccInDataFFT=fft(ccInData_complex);             %求fft


filename='data/saveData_cufftComplex.dat';
fileID=fopen(filename,'rb');
ccInData_GPU=fread(fileID,'float32');
ccInData_GPU_Complex=complex(ccInData_GPU(1:2:end),ccInData_GPU(2:2:end));

变量ccInDataFFT即为matlab对本段数据做fft之后的结果，ccInData_GPU_Complex为GPU卡通过cufft函数做fft之后的结果，在matlab运行可以对比看出两者运算结果一致，仅存在精度上的差异（可忽略不计）。本次对比未能提供对比结果图，请读者自行测试。

3、二维矩阵对列数据傅里叶变换

由于GPU的数据存储是按照读入数据顺序存储，因此即使是二维矩阵的数据在GPU内也是以一维的形式存储，因此，需要示例说明在对二维矩阵做傅里叶变换时，参数的设定对傅里叶变换的影响。主要与cufftPlan1d(&plan1d,  row,CUFFT_C2C,col)的第二个和第四个参数有关;具体见以下程序。

#include"stdio.h"
#include"cuda.h"
#include <cufft.h>
void readFileComplex(cufftComplex* matrix,int iReadLen);
void writeFileComplex(cufftComplex *matrix,int iWriteLen);
int main(int argc, char **argv) {

	int col = 8;
	int row = 128;
	int length = row * col;
	//主机端(CPU)变量定义及初始化
	cufftComplex *inputH = (cufftComplex*) malloc(sizeof(cufftComplex) * length);
	cufftComplex *outputH = (cufftComplex*) malloc(sizeof(cufftComplex) * length);
	memset(inputH, 0, sizeof(cufftComplex) * length);
	memset(outputH, 0, sizeof(cufftComplex) * length);
	//设备端(GPU)变量定义及初始化
	cufftComplex *inputD;
	cudaMalloc((void**) &inputD, length * sizeof(cufftComplex));
	cufftComplex *outputD;
	cudaMalloc((void**) &outputD, length * sizeof(cufftComplex));
	cudaMemset(inputD, 0, length * sizeof(cufftComplex));
	cudaMemset(outputD, 0, length * sizeof(cufftComplex));
	//读取二进制文件中的数据
	readFileComplex(inputH,length);
	//将数据从主机端复制至设备端
	cudaMemcpy(inputD, inputH, sizeof(cufftComplex) * length, cudaMemcpyHostToDevice);

	//1：创建用于FFT变换的句柄
	cufftHandle plan1d;
	//2：配置信号长度及输入输出数据类型信息
	cufftPlan1d(&plan1d,  row,CUFFT_C2C,col);
	//3：调用函数执行或正或逆傅里叶变换
	cufftExecC2C(plan1d, inputD, outputD, CUFFT_FORWARD);
	//将数据从设备端复制至主机端
	cudaMemcpy(outputH, outputD, sizeof(cufftComplex) * length, cudaMemcpyDeviceToHost);
	//将数据写入二进制文件
	writeFileComplex(outputH,length);
	for(int i=0;i<5;i++){
		printf("output.x=%f\n",outputH[i].x);
		printf("output.y=%f\n",outputH[i].y);
	}
void readFileComplex(cufftComplex* matrix,int iReadLen){
	FILE* fp;
	if ((fp = fopen("inData_cufftComplex.dat", "rb")) == NULL) {
		printf("file open failed\n");
	} else {
		fread(matrix , sizeof(cufftComplex), iReadLen, fp);
	}
}
void writeFileComplex(cufftComplex *matrix,int iWriteLen){
	FILE* fp;
	if((fp=fopen("saveData_cufftComplex.dat","wb"))==NULL){
		printf("file open failed\n");
	}else{
		fwrite(matrix, sizeof(cufftComplex) , iWriteLen, fp);
	}
}

 编译方法：

//test.cu代表文件名，test代表可执行文件名
nvcc test.cu -o test -lcufft

编译通过之后执行可执行文件即可得到运行结果：

./test

利用matlab读取生成的结果文件并对比

clc
clear all
close all;

row=1;
col=1024;
len=row*col;
input=zeros(1,len);
for i=1:1:len
    input(i)=complex(i-1,i);
end
output=fft(input);

filename='data/inData_cufftComplex.dat';
fileID=fopen(filename,'rb');
ccInData=fread(fileID,'float32');
ccInData_complex1=complex(ccInData(1:2:end),ccInData(2:2:end));
ccInData_complex=reshape(ccInData_complex1,128,8);  %变为128行8列
%对输入信号做FFT运算
ccInDataFFT=fft(ccInData_complex,[],1);              %对每一列数据做fft


filename='data/saveData_cufftComplex.dat';
fileID=fopen(filename,'rb');
ccInData_GPU=fread(fileID,'float32');
ccInData_GPU_Complex=complex(ccInData_GPU(1:2:end),ccInData_GPU(2:2:end));
ccInData_GPU_Complex=reshape(ccInData_GPU_Complex,128,8);

对比运行结果如下：

其中左边红框数据为GPU卡通过cufft函数对二维矩阵做fft之后的结果，右边红框为matlab矩阵灭一列做fft的结果，两个变量数据一致，以此来说明二维矩阵中cufftPlan1d()函数的使用方法。

4、二维矩阵行列傅里叶变换

前面介绍了cufftPlan1d()函数对行或者列做傅里叶变换的方法，下面介绍cufftPlan2d()函数：同时对行和列做傅里叶变换。首先给出GPU实现方案。

#include"stdio.h"
#include"cuda.h"
#include <cufft.h>
void readFileComplex(cufftComplex* matrix,int iReadLen);
void writeFileComplex(cufftComplex *matrix,int iWriteLen);
int main(int argc, char **argv) {

	int col = 8;
	int row = 128;
	int length = row * col;
	//主机端(CPU)变量定义及初始化
	cufftComplex *inputH = (cufftComplex*) malloc(sizeof(cufftComplex) * length);
	cufftComplex *outputH = (cufftComplex*) malloc(sizeof(cufftComplex) * length);
	memset(inputH, 0, sizeof(cufftComplex) * length);
	memset(outputH, 0, sizeof(cufftComplex) * length);
	//设备端(GPU)变量定义及初始化
	cufftComplex *inputD;
	cudaMalloc((void**) &inputD, length * sizeof(cufftComplex));
	cufftComplex *outputD;
	cudaMalloc((void**) &outputD, length * sizeof(cufftComplex));
	cudaMemset(inputD, 0, length * sizeof(cufftComplex));
	cudaMemset(outputD, 0, length * sizeof(cufftComplex));
	//读取二进制文件中的数据
	readFileComplex(inputH,length);
	//将数据从主机端复制至设备端
	cudaMemcpy(inputD, inputH, sizeof(cufftComplex) * length, cudaMemcpyHostToDevice);

	//1：创建用于FFT变换的句柄
	cufftHandle plan2d;
	//2：配置信号长度及输入输出数据类型信息
	cufftPlan2d(&plan2d,  col, row,CUFFT_C2C);
//	cufftPlan1d(&plan1d,  row,CUFFT_C2C,col);
	//3：调用函数执行或正或逆傅里叶变换
	cufftExecC2C(plan2d, inputD, outputD, CUFFT_FORWARD);
	//将数据从设备端复制至主机端
	cudaMemcpy(outputH, outputD, sizeof(cufftComplex) * length, cudaMemcpyDeviceToHost);
	//将数据写入二进制文件
	writeFileComplex(outputH,length);
	for(int i=0;i<5;i++){
		printf("output.x=%f\n",outputH[i].x);
		printf("output.y=%f\n",outputH[i].y);
	}


}
void readFileComplex(cufftComplex* matrix,int iReadLen){
	FILE* fp;
	if ((fp = fopen("inData_cufftComplex.dat", "rb")) == NULL) {
		printf("file open failed\n");
	} else {
		fread(matrix , sizeof(cufftComplex), iReadLen, fp);
	}
}
void writeFileComplex(cufftComplex *matrix,int iWriteLen){
	FILE* fp;
	if((fp=fopen("saveData_cufftComplex.dat","wb"))==NULL){
		printf("file open failed\n");
	}else{
		fwrite(matrix, sizeof(cufftComplex) , iWriteLen, fp);
	}
}

 编译方法：

//test.cu代表文件名，test代表可执行文件名
nvcc test.cu -o test -lcufft

编译通过之后执行可执行文件即可得到运行结果：

./test

然后给出matlab实现方案。

clc
clear all
close all;

row=1;
col=1024;
len=row*col;
input=zeros(1,len);
for i=1:1:len
    input(i)=complex(i-1,i);
end
output=fft(input);

filename='data/inData_cufftComplex.dat';
fileID=fopen(filename,'rb');
ccInData=fread(fileID,'float32');
ccInData_complex1=complex(ccInData(1:2:end),ccInData(2:2:end));
ccInData_complex=reshape(ccInData_complex1,128,8);  %变为128行8列
%对输入信号做FFT运算
% ccInDataFFT=fft(ccInData_complex,[],1);              %对每一列数据做fft

ccInDataFFT=fft(fft(ccInData_complex,[],1),[],2);              %对每一行和列数据做fft


filename='data/saveData_cufftComplex.dat';
fileID=fopen(filename,'rb');
ccInData_GPU=fread(fileID,'float32');
ccInData_GPU_Complex=complex(ccInData_GPU(1:2:end),ccInData_GPU(2:2:end));
ccInData_GPU_Complex=reshape(ccInData_GPU_Complex,128,8);

经过对比，两者运行结果一致。请读者自行运行代码测试。

5、矩阵的逆傅里叶变换

前面文章说明了cufft库函数在做逆傅里叶变换时并没有处理信号长度，下面给出实测证明。

首先给出GPU实现方法

#include"stdio.h"
#include"cuda.h"
#include <cufft.h>
void readFileComplex(cufftComplex* matrix,int iReadLen);
void writeFileComplex(cufftComplex *matrix,int iWriteLen);
int main(int argc, char **argv) {

	int col = 1;
	int row = 1024;
	int length = row * col;
	//主机端(CPU)变量定义及初始化
	cufftComplex *inputH = (cufftComplex*) malloc(sizeof(cufftComplex) * length);
	cufftComplex *outputH = (cufftComplex*) malloc(sizeof(cufftComplex) * length);
	memset(inputH, 0, sizeof(cufftComplex) * length);
	memset(outputH, 0, sizeof(cufftComplex) * length);
	//设备端(GPU)变量定义及初始化
	cufftComplex *inputD;
	cudaMalloc((void**) &inputD, length * sizeof(cufftComplex));
	cufftComplex *outputD;
	cudaMalloc((void**) &outputD, length * sizeof(cufftComplex));
	cudaMemset(inputD, 0, length * sizeof(cufftComplex));
	cudaMemset(outputD, 0, length * sizeof(cufftComplex));
	//读取二进制文件中的数据
	readFileComplex(inputH,length);
	//将数据从主机端复制至设备端
	cudaMemcpy(inputD, inputH, sizeof(cufftComplex) * length, cudaMemcpyHostToDevice);

	//1：创建用于FFT变换的句柄
	cufftHandle plan1d;
	//2：配置信号长度及输入输出数据类型信息
	cufftPlan1d(&plan1d, row, CUFFT_C2C, col);
	//3：调用函数执行或正或逆傅里叶变换
	cufftExecC2C(plan1d, inputD, outputD, CUFFT_INVERSE);
	//将数据从设备端复制至主机端
	cudaMemcpy(outputH, outputD, sizeof(cufftComplex) * length, cudaMemcpyDeviceToHost);
	//将数据写入二进制文件
	writeFileComplex(outputH,length);

}
void readFileComplex(cufftComplex* matrix,int iReadLen){
	FILE* fp;
	if ((fp = fopen("inData_cufftComplex.dat", "rb")) == NULL) {
		printf("file open failed\n");
	} else {
		fread(matrix , sizeof(cufftComplex), iReadLen, fp);
	}
}
void writeFileComplex(cufftComplex *matrix,int iWriteLen){
	FILE* fp;
	if((fp=fopen("saveData_cufftComplex.dat","wb"))==NULL){
		printf("file open failed\n");
	}else{
		fwrite(matrix, sizeof(cufftComplex) , iWriteLen, fp);
	}
}

然后给出matlab运行结果

clc
clear all
close all;

row=1;
col=1024;
len=row*col;
input=zeros(1,len);
for i=1:1:len
    input(i)=complex(i-1,i);
end
output=fft(input);

filename='data/inData_cufftComplex.dat';
fileID=fopen(filename,'rb');
ccInData=fread(fileID,'float32');
ccInData_complex=complex(ccInData(1:2:end),ccInData(2:2:end));
%对输入信号做FFT运算
ccInDataIFFT=ifft(ccInData_complex);             %求ifft


filename='data/saveData_cufftComplex.dat';
fileID=fopen(filename,'rb');
ccInData_GPU=fread(fileID,'float32');
ccInData_GPU_Complex=complex(ccInData_GPU(1:2:end),ccInData_GPU(2:2:end));
%通过画图的方式将通过matlab做FFT运算后的数据与GPU做FFT运算后的数据通过画图的方式做对比

ccInData_GPU_Complex_inv=ccInData_GPU_Complex./1024;

下面是对比结果：

其中第一列是matlab计算的逆傅里叶变换结果，第二列是GPU计算的逆傅里叶变换结果，第三列是初一信号长度之后的计算结果。可以看出，GPU在计算逆傅里叶变换过程中并没有除以信号长度，在手动除以信号长度之后，两平台的计算结果一致。

杨咩咩ing
关注
  • 44
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
CUDA快速傅里叶变换（cuFFT）阅读笔记（一）
余音绕梁九日的专属空间站
08-29 1万+
CUDA为开发人员提供了多种库，每一类库针对某一特定领域的应用，CUFFT库则是CUDA中专门用于进行傅里叶变换的函数库，这一系列的文章是博主近一段时间对cuFFT库的学习总结，主要内容是文档的译文，其间夹杂一些博主自己的理解。初学CUDA，理解有误之处在所难免，阅读本篇文章的读者如若发现请不吝指正。 1. 简介        cuFFT是的全称是CUDA Fast Fourier Trans
CUDA实现短时傅里叶变换
05-24
在tesla c1060上实现短时傅里叶变换。 做完stft后，取绝对值，取对数转化为db值； 并作灰度形态学闭运算，包含膨胀和腐蚀运算各一次，结构元素为n*n方阵，n为奇数； 根据需要选择后续处理。
使用CUFFT的实例，对CUDA程序参数如C2C、cufftPlan1d、cufftExecC2等进行了详细的中文注释。
03-13
在本例中，CUFFT被用来计算一维信号在给定滤波器下的滤波实现：首先进行时间域到频率域的变换，即将信号与滤波器都变换到频率域，然后二者相乘，最后逆变换回频率域。cuFFT plans被创建出来，且分别使用简单和高级的API。 使用方法： 1.make clean 2.make 3. ./simpleCUFFT //----------------------------------------------------------------------------------------------- // 程序执行，需放到 // Your_directory/NVIDIA_CUDA-10.1_Samples/7_CUDALibraries/simpleCUFFT //----------------------------------------------------------------------------------------------- 有问题欢迎交流：yuehankelisiduofu@126.com 微信：xiaofengfudong
cuFFT
人工智能
06-11 3310
cuFFT 1. Introduction This document describes cuFFT, the NVIDIA® CUDA™ Fast Fourier Transform (FFT) product. It consists of two separate libraries: cuFFT and cuFFTW. The cuFFT library is d
关于CUFFT
hdanbang的专栏
07-23 3183
我们知道，程序在首次执行调用GPU函数时，会有一个初始化的过程。该初始化过程有很大的开销，不应被计入实际执行时间。然而我们发现，在调用CUFFT库的时候，第一次生成plan handle 也会有很大的开销： void main() { int n = 100; float2 *data_h = new float2[n]; for (int i=0; i<n; ++i) { dat
cuFFT使用教程
把你挖出来的博客
01-11 4519
cuFFT使用教程
CUFFT库(cufft_C2C,cufft_R2C,cufft_C2R，cufft_Z2C,cufft_D2Z,cufft_Z2D)
武泗海的博客
01-18 7074
CUDA的cufft库可以实现（复数C-复数C），（实数R-复数C）和（复数C-实数R）的单精度，双精度福利变换。其变换前后的输入，输出数据的长度如图所示。在C2R和R2C模式中，根据埃尔米特对称性（Hermitian symmetry），变换后，*代表共轭复数。CUFFT的傅里叶变换类型则利用了这些冗余，将计算量降到最低。注意：下表都是单精度（C-表示float复数，R表示float实数）。而双
介绍STM32标准库函数说明及函数的使用方法 专栏 1 STM32固件库函数之通用输入/输出（GPIO）函数的介绍及使用
01-19
介绍STM32标准库函数说明及函数的使用方法 专栏 1 STM32固件库函数之通用输入/输出（GPIO）函数的介绍及使用。 序号 函数名 描述 1 GPIO_DeInit 将外设 GPIOx 寄存器重设为默认值 2 GPIO_Init 根据 GPIO_Init...
标准I/O库函数：fgets与gets比较分析
01-19
函数名：fgets 　功能：从流中读取一个字符串 　用法：char *fgets（char *string,int n,FILE *stream）; 　形参注释： 　*string：结果数据的首地址；n-1:读入数据块的长度,其默认值为1k，即1024;stream文件...
C语言数据结构算法之实现快速傅立叶变换
08-30
FFT算法的基本思想是将傅立叶变换分解成多个小的傅立叶变换，然后使用 butterfly操作对这些小的傅立叶变换进行合并。 三、C语言实现快速傅立叶变换 在C语言中，快速傅立叶变换可以使用递归函数或迭代函数来实现。...
cuda傅里叶变换库说明文档
06-11
英伟达提供的小册子，详细介绍了cufft变换的使用
基于CUDA 的矩阵乘法和FFT 性能测试
05-04
基于CUDA 的矩阵乘法和FFT 性能测试
zhengjiaobianhuan.rar_傅立叶变换_图像 傅立叶变换_正交变换_沃尔什变换_离散余弦变换
09-23
本程序集中了三种主要的正交变换方法：傅立叶变换、离散余弦变换（DCT）以及沃尔什变换。这些变换在信号处理和图像分析中有各自的优点和应用领域。 傅立叶变换是一种数学工具，能够将一个函数或信号分解为一系列...
正交变换 傅立叶变换 离散余弦变换 沃尔什变换.rar
09-05
例如，对于傅立叶变换，可以使用库函数如`std::complex`和`std::vector`来处理复数数组，然后调用快速傅立叶变换（FFT）算法，如Cooley-Tukey算法。对于DCT，可以使用库如OpenCV或自己实现算法。沃尔什变换则可以...
FFT.rar_CLK_init 5509_ti 傅立叶变换
09-23
3. **傅立叶变换**：傅立叶变换是一种数学工具，将信号从时域转换到频域，揭示了信号的频率成分。在数字信号处理中，DFT是离散版本的傅立叶变换，用于处理离散信号。FFT是DFT的一种快速算法，其计算复杂度为O(N log ...
CUDA官方函数库：傅里叶变换（CUFFT）相关库函数介绍
最新发布
zy4213的博客
02-21 1688
CUFFT函数库的主要作用是实现高性能的计算， 提供了多种类型的傅里叶变换函数，包括一维、二维和三维的实数和复数傅里叶变换。它支持多种数据布局和数据类型，例如当精度实数和复数，双精度实数和复数等。本文主要对常用的库函数做了简要介绍，以备后续使用。
cpu and cuda fft
weixin_39057744的博客
12-14 1105
#include<stdlib.h> #include<string.h> #include<time.h> #include<stdio.h> #include "cuda_runtime.h" #include "device_launch_parameters.h" #include<Windows.h> #include<math.h> #define PI acos(-1) #define CHECK(call) \ { \
CUDA C编程（二十六）cuFFT库
AAAA202012的博客
03-01 2726
   使 用 cuFFT API    cuFFT 功 能 示 范   
matlab不用库函数实现傅里叶变换
11-30
以下是使用Matlab实现傅里叶变换的代码，不需要使用库函数： ```matlab function [realPart, imagPart] = myFFT(signal) N = length(signal); if N == 1 realPart = signal; imagPart = 0; else signal_even = myFFT(signal(1:2:N)); signal_odd = myFFT(signal(2:2:N)); Wn = exp(-2*pi*1i/N).^(0:N/2-1); temp = Wn .* signal_odd; realPart = [signal_even + temp, signal_even - temp]; imagPart = []; end end ``` 这个函数使用递归的方式实现了傅里叶变换。它将信号分成偶数和奇数两部分，对它们分别进行傅里叶变换，然后将它们合并起来。在合并的过程中，使用了旋转因子 Wn，它是一个长度为 N/2 的向量，其中每个元素都是 exp(-2*pi*1i/N) 的幂。最后，函数返回实部和虚部。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值