计算2的幂次长度的实数序列、复数序列的正向/逆向快速傅里叶变换。

正向变换： $\text{[math]}$

逆向变换： $\text{[math]}$

$\text{[math]}$

FFT函数调用流程如下：

调用Init初始化HmppsFFTPolicy结构体。
调用CToC、RToC、CToR等主函数。
最后调用Release释放HmppsFFTPolicy函数所包含内存。

函数接口声明如下：

初始化操作：
HmppResult HMPPS_FFTCToCInit_32f(int32_t power, int32_t direction, int32_t flag, HmppsFFTPolicy_32f **policy);

HmppResult HMPPS_FFTCToCInit_64f(int32_t power, int32_t direction, int32_t flag, HmppsFFTPolicy_64f **policy);

HmppResult HMPPS_FFTCToCInit_32fc(int32_t power, int32_t direction, int32_t flag, HmppsFFTPolicy_32fc **policy);

HmppResult HMPPS_FFTCToCInit_64fc(int32_t power, int32_t direction, int32_t flag, HmppsFFTPolicy_64fc **policy);

HmppResult HMPPS_FFTRToCInit_32f(int32_t power, int32_t flag, HmppsFFTPolicy_32f **policy);

HmppResult HMPPS_FFTRToCInit_64f(int32_t power, int32_t flag, HmppsFFTPolicy_64f **policy);

HmppResult HMPPS_FFTCToRInit_32f(int32_t power, int32_t flag, HmppsFFTPolicy_32f **policy);

HmppResult HMPPS_FFTCToRInit_64f(int32_t power, int32_t flag, HmppsFFTPolicy_64f **policy);
主函数操作：
HmppResult HMPPS_FFTCToC_32f(float *srcRe, float *srcIm, float *dstRe, float *dstIm, HmppsFFTPolicy_32f *policy);

HmppResult HMPPS_FFTCToC_64f(double *srcRe, double *srcIm, double *dstRe, double *dstIm, HmppsFFTPolicy_64f *policy)

HmppResult HMPPS_FFTCToC_32fc(Hmpp32fc *src, Hmpp32fc *dst, HmppsFFTPolicy_32fc *policy);

HmppResult HMPPS_FFTCToC_64fc(Hmpp64fc *src, Hmpp64fc *dst, HmppsFFTPolicy_64fc *policy)

HmppResult HMPPS_FFTCToC_32fc_I(Hmpp32fc *srcDst, HmppsFFTPolicy_32fc *policy);

HmppResult HMPPS_FFTCToC_64fc_I(Hmpp64fc *srcDst, HmppsFFTPolicy_64fc *policy);

HmppResult HMPPS_FFTRToC_32f(float *src, Hmpp32fc *dst, HmppsFFTPolicy_32f *policy)

HmppResult HMPPS_FFTRToC_64f(double *src, Hmpp64fc *dst, HmppsFFTPolicy_64f *policy);

HmppResult HMPPS_FFTCToR_32f(Hmpp32fc *src, float *dst, HmppsFFTPolicy_32f *policy);

HmppResult HMPPS_FFTCToR_64f(Hmpp64fc *src, double *dst, HmppsFFTPolicy_64f *policy);
释放内存操作：
HmppResult HMPPS_FFTCToCRelease_32f(HmppsFFTPolicy_32f *policy);

HmppResult HMPPS_FFTCToCRelease_64f(HmppsFFTPolicy_64f *policy);

HmppResult HMPPS_FFTCToCRelease_32fc(HmppsFFTPolicy_32fc *policy);

HmppResult HMPPS_FFTCToCRelease_64fc(HmppsFFTPolicy_64fc *policy);

HmppResult HMPPS_FFTRToCRelease_32f(HmppsFFTPolicy_32f *policy);

HmppResult HMPPS_FFTRToCRelease_64f(HmppsFFTPolicy_64f *policy);

HmppResult HMPPS_FFTCToRRelease_32f(HmppsFFTPolicy_32f *policy);

HmppResult HMPPS_FFTCToRRelease_64f(HmppsFFTPolicy_64f *policy);

参数

参数名	描述	取值范围	输入/输出
power	FFT序列输入信号长度为 $\text{[math]}$ 。	[0, 27]	输入
direction	direction=1表示FFT正变换。 direction=-1表示FFT逆变换。用于CToC模式。	±1	输入
flag	结果正规化模式。	HMPP_FFT_DIV_FWD_BY_N、HMPP_FFT_DIV_BWD_BY_N、HMPP_FFT_DIV_BY_SQRTN、HMPP_FFT_NODIV_BY_ANY	输入
policy（init函数中）	双重指针，指向HmppsFFTPolicy结构体，结构体内包含FFT计算需要的一些信息和缓存块的首地址。	非空	输出
policy（主函数和release函数）	指针，指向HmppsFFTPolicy结构体。	非空	输入
src	指向源序列的指针。	非空	输入
dst	指向输出序列的指针。	非空	输出
srcDst	指向原址操作序列的指针。	非空	输入/输出

表1 参数flag取值的说明
取值	描述
HMPP_FFT_DIV_FWD_BY_N	正向变换，1/N正规化模式。
HMPP_FFT_DIV_BWD_BY_N	反向变换，1/N正规化模式。
HMPP_FFT_DIV_BY_SQRTN	正向或反向变换，1/N^1/2正规化模式。
HMPP_FFT_NODIV_BY_ANY	正向或反向变换，不做特殊处理。

返回值

成功：返回HMPP_STS_NO_ERR。
失败：返回错误码。

错误码

错误码	描述
HMPP_STS_NULL_PTR_ERR	指针参数为空。
HMPP_STS_FFT_POWER_ERR	power小于0或大于27。
HMPP_STS_MALLOC_FAILED	所需的额外内存申请失败。
HMPP_STS_FFT_FLAG_ERR	flag的值不在[1,4]范围内。

注意

调用该接口计算FFT之前，必须调用HMPPS_FFTCToCInit接口初始化HmppsFFTPolicy规范结构。
HmppsFFTPolicy结构体初始化需在Init函数中进行申请的，用户无法自己进行该结构体申请定义。

示例

FFTCToC调用示例：

#define PI 3.14159265358979323846

void FFTCToC_Example()
{
    Hmpp32fc src[8], dst[8];
    for (int32_t i = 0; i < 8; i++) {
        src[i].re = cos(2 * PI * i * 16 / 64);
        src[i].im = 1;
    }
    HmppResult result;
    HmppsFFTPolicy_32fc *policy = NULL;
    
    result = HMPPS_FFTCToCInit_32fc(3, 1, HMPP_FFT_NODIV_BY_ANY, &policy);// 正向FFT
    if (result != HMPP_STS_NO_ERR) {
        printf("Create Policy Error!\n");
        return;
    }
    result = HMPPS_FFTCToC_32fc(src, dst, policy);
    if (result != HMPP_STS_NO_ERR) {
        printf("FFT Error!\n");
        return;
    }
    HMPPS_FFTCToCRelease_32fc(policy);
    printf("dstRe =");
    for (int32_t i = 0; i < 8; i++) {
        printf("    %.2f", dst[i].re);
    }
    printf("\ndstIm =");
    for (int32_t i = 0; i < 8; i++) {
        printf("    %.2f", dst[i].im);
    }
    printf("\n");
}

运行结果：

dstRe =    -0.00    -0.00    4.00    0.00    0.00    0.00    4.00    -0.00
dstIm =    8.00    -0.00    -0.00    -0.00    0.00    0.00    0.00    0.00

FFTRToC/CToR调用示例：

void FFT_R_Example()
{
    float src[8];
    Hmpp32fc rtoc_dst[5];
    float ctor_dst[8] = {0};
    for (int32_t i = 0; i < 8; i++) {
        src[i] = i + 1;
    }
    HmppResult result;
    HmppsFFTPolicy_32f *policy = NULL;

    result = HMPPS_FFTRToCInit_32f(3, HMPP_FFT_NODIV_BY_ANY, &policy);
    if (result != HMPP_STS_NO_ERR) {
        printf("RToC Create Policy Error!\n");
        return;
    }
    result = HMPPS_FFTRToC_32f(src, rtoc_dst, policy);
    if (result != HMPP_STS_NO_ERR) {
        printf("FFTRToC Error!\n");
        return;
    }
    HMPPS_FFTRToCRelease_32f(policy);
    printf("rtoc_dstRe =");
    for (int32_t i = 0; i < 8; i++) {
        printf("    %.2f", rtoc_dst[i].re);
    }
    printf("\nrtoc_dstIm =");
    for (int32_t i = 0; i < 8; i++) {
        printf("    %.2f", rtoc_dst[i].im);
    }
    printf("\n");

    result = HMPPS_FFTCToRInit_32f(3, HMPP_FFT_NODIV_BY_ANY, &policy);
    if (result != HMPP_STS_NO_ERR) {
        printf("CToR Create Policy Error!\n");
        return;
    }
    result = HMPPS_FFTCToR_32f(rtoc_dst, ctor_dst, policy);
    if (result != HMPP_STS_NO_ERR) {
        printf("FFTCToR Error!\n");
        return;
    }
    HMPPS_FFTCToRRelease_32f(policy);
    printf("ctor_dst =");
    for (int32_t i = 0; i < 8; i++) {
        printf("    %.2f", ctor_dst[i]);
    }
    printf("\n");
}

运行结果：

rtoc_dstRe =    36.00    -4.00    -4.00    -4.00    -4.00    1.00    3.00    5.00
rtoc_dstIm =    0.00    9.66    4.00    1.66    0.00    2.00    4.00    6.00
ctor_dst =    8.00    16.00    24.00    32.00    40.00    48.00    56.00    64.00