test_fft.c

几个FFT算法

#include "stdlib.h"
#include "stdio.h"
#include "malloc.h"
#include "memory.h"
#include "math.h"

#include "..\lbcfft\cmpl.h"
#include "..\lbcfft\currTime.h"

#include "config.h"

#ifdef OUT_INTER_RESULT
	#include "test_FFT.h"
#endif 


#define TEST_DATA_LEN (65536*16)
#define TRANS_LEN  4096

FILE    *g_fp1;
FILE    *g_fp2;


CMPL  g_data[TEST_DATA_LEN];

CMPL  g_inData1[TEST_DATA_LEN];
CMPL  g_inData2[TEST_DATA_LEN];

CMPL  g_outData1[TEST_DATA_LEN];
CMPL  g_outData2[TEST_DATA_LEN];

double g_dou_data[TEST_DATA_LEN*2];

double g_ReData1[TEST_DATA_LEN];
double g_ImData1[TEST_DATA_LEN];

double g_ReData2[TEST_DATA_LEN];
double g_ImData2[TEST_DATA_LEN];


BOOL FFT1(  CMPL data[], size_t n);
BOOL FFT2(  CMPL data[], size_t n);

BOOL  rawFFT(CMPL data[],size_t n);

void initTestData(CMPL data[],int len);
void dumpData(CMPL data[],int n, char *fileName);
void readData(CMPL data[],int n,char *fileName);
void CompResult(CMPL data1[],CMPL data2[],int n);
void combineToCMPL(double ReArr[],double ImArr[],CMPL cmplArr[],int n);
void combineToCMPL2(double Arr[],CMPL cmplArr[],int n);
void ReArrageToDoubleArray(CMPL cmplArr[],double Arr[],int n);
void SplitToReImArray(CMPL cmplArr[],double ReArr[],double ImArr[],int n);
void DirectCFT(int n,CMPL x[],CMPL y[]);

void test_fft()
{
	
#ifdef OUT_INTER_RESULT
	char file1[32];
	char file2[32];
	int i;

	initTestData(g_data, TRANS_LEN);
	memcpy(g_inData1,g_data,sizeof(CMPL)*TRANS_LEN);
	memcpy(g_inData2,g_data,sizeof(CMPL)*TRANS_LEN);
	
	rawFFT(g_inData1,TRANS_LEN);
	FFT1(g_inData2,TRANS_LEN);

	for (i=2;i<=TRANS_LEN;i*=2)
	{
		sprintf(file1,"data0_%08d.bin",i);
		sprintf(file2,"data1_%08d.bin",i);
		readData(g_inData1,TRANS_LEN,file1);
		readData(g_inData2,TRANS_LEN,file2);
		printf("LEN=%d\n",i);
		CompResult(g_inData1,g_inData2,TRANS_LEN);
		printf("\n\n");
	}
#endif
}

void Init_OMAGE_ARRAY(int n);
void Free_OMAGE_ARRAY();
DWORD Log2(DWORD n);
void fft(int n, double xRe[], double xIm[], double yRe[], double yIm[]);

void testSpeed_lbcFFT1(int maxLen)
{
	int  len,c;
	double k,t,tmp;
	CMPL *data=NULL;
	FILE *fp=fopen("benchmark1.txt","wt");
	
	if (fp==NULL)
		return;

	data=(CMPL *)malloc( sizeof(CMPL) * maxLen);
	if (data==NULL)
		return ;
	
	Init_OMAGE_ARRAY(maxLen);	
	
	fprintf(fp,"    len  \tfft time \ttime/(n*log2(n)\n");
	for (len=64;len<=maxLen;len*=2)
	{
		t=0.0;
		c=0;

		initTestData(data, len);

		while (1)
		{
			tmp=currTime();
			FFT1(data,len);
			t+=currTime()-tmp;
			
			c++;
			if (t>0.001)
				break;
		}
		t/=c;
		k=t/(len*log10(len)/log10(2));
		fprintf(fp,"%8d \t%.8f \t%.12f\n",len,t,k);
		
	}

    Free_OMAGE_ARRAY();
	fclose(fp);

	if (data!=NULL)
		free(data);
}


void testSpeed_lbcFFT2(int maxLen)
{
	int  len,c;
	double k,t,tmp;
	CMPL *data=NULL;
	FILE *fp=fopen("benchmark2.txt","wt");
	
	if (fp==NULL)
		return;

	data=(CMPL *)malloc( sizeof(CMPL) * maxLen);
	if (data==NULL)
		return ;
	
	Init_OMAGE_ARRAY(maxLen);	
	
	fprintf(fp,"    len  \tfft time \ttime/(n*log2(n)\n");
	for (len=64;len<=maxLen;len*=2)
	{
		t=0.0;
		c=0;

		initTestData(data, len);

		while (1)
		{
			tmp=currTime();
			FFT2(data,len);
			t+=currTime()-tmp;
			
			c++;
			if (t>0.001)
				break;
		}
		t/=c;
		k=t/(len*log10(len)/log10(2));
		fprintf(fp,"%8d \t%.8f \t%.12f\n",len,t,k);
		
	}

    Free_OMAGE_ARRAY();
	fclose(fp);

	if (data!=NULL)
		free(data);
}

void cdft(int n, int isgn, double *a);

void testSpeed_oouraFFT()
{
	int i,j;
	double t1,t2;
	t1=currTime();

	initTestData(g_data, TEST_DATA_LEN);
	for (i=64;i<=TEST_DATA_LEN;i*=2)
	{
		for (j=0;j<i;j++)
		{
			g_dou_data[j*2]   =g_data[j].Re;
			g_dou_data[j*2+1] =g_data[j].Im;
		}
		t1=currTime();
		cdft(i*2,-1,g_dou_data);		
		t2=currTime()-t1;
		printf("FFT(%d)=\t%.12f,\tk=%.12f\n",i,t2,t2/(i*Log2(i)));
	}
}


void testSpeed_mixFFT()
{
	int i,j;
	double t1,t2;
	t1=currTime();

	initTestData(g_data, TEST_DATA_LEN);
	for (i=64;i<=TEST_DATA_LEN;i*=2)
	{
		for (j=0;j<i;j++)
		{
			g_ReData1[j]   =g_data[j].Re;
			g_ImData1[j] =  g_data[j].Im;
		}
		t1=currTime();
		
		fft(i,g_ReData1,g_ImData1,g_ReData2,g_ImData2);
				
		t2=currTime()-t1;
		printf("FFT(%d)=\t%.12f,\tk=%.12f\n",i,t2,t2/(i*Log2(i)));
	}
}


void test_resultBetweenEveryFFT()
{
	char file1[32];
	char file2[32];
	FILE *fp1,*fp2;
	int i;
	int  transLen=4;
		
	//initTestData(g_data, transLen);
	memset(g_data,0,sizeof(g_data));
	
	g_data[0].Re=-2;
	g_data[1].Re=4;
	g_data[2].Re=3;
	g_data[3].Re=4;

	//-------------------------------------------------	
	memcpy(g_inData1,g_data,sizeof(CMPL)*transLen);
	DirectCFT(transLen,g_inData1,g_outData1);
	
	memcpy(g_inData2,g_data,sizeof(CMPL)*transLen);
	rawFFT(g_inData2, transLen);
	memcpy(g_outData2,g_inData2,sizeof(CMPL)*transLen);
	
	printf("\nresult between DirectCFT and rawFFT\n");
	CompResult(g_outData1,g_outData2,transLen);
	
	/*
	//--------------------------------------------------	
	memcpy(g_inData2,g_data,sizeof(CMPL)*transLen);
	ReArrageToDoubleArray(g_inData2,g_dou_data,transLen);
	cdft(2*transLen,-1,g_dou_data);
	combineToCMPL2(g_dou_data,g_outData2,transLen);

	printf("\nresult between rawFFT and cdft\n");
	CompResult(g_outData1,g_outData2,transLen);
	
	//--------------------------------------------------
	memcpy(g_inData2,g_data,sizeof(CMPL)*transLen);

	SplitToReImArray(g_inData2,g_ReData1,g_ImData1,transLen);
	fft(transLen,g_ReData1,g_ImData1,g_ReData2,g_ImData2);
	combineToCMPL(g_ReData2,g_ImData2,g_outData2,transLen);

	printf("\nresult between rawFFT and mixfft\n");
	CompResult(g_outData1,g_outData2,transLen);
	*/
	sprintf(file1,"data.dat");
	fp1=fopen(file1,"wt");
	print_FFTArray( g_outData2, transLen, fp1);
	fclose(fp1);

}

int main(int argc, char* argv[])
{
	/*
	printf("test speed for occura_fft\n");
	testSpeed_oouraFFT();

	printf("\ntest speed for mix_fft\n");
	testSpeed_mixFFT();

	printf("\ntest speed for lbc_fft\n");
	testSpeed_lbcFFT();

	printf("\ntest speed for lbc_fft2\n");
	testSpeed_lbcFFT2();
	*/
	//test_resultBetweenEveryFFT();
	testSpeed_lbcFFT1(2*1048576);
	testSpeed_lbcFFT2(2*1048576);
	return 0;
}