Ускорение функции расчета автокорреляционной функции

    float *ACF = NULL; ACF = (float*)malloc(sizeof(float)*Win);
    for (long j = 0; j < Win; j++)
    {
        ACF[j] = 0.0;
        for (long k = 0; k < Win; k++)
        {
            ACF[j] += In[2*Win-1-k]*In[2*Win-1-k-j];
        }
      }

Vector.clear();

void fastACF(short *In,int Win,float *&Out)
{
 FastFourier Kernel(2*Win,-1);
 Kernel.ShortToRedat(In,2*Win); //заполняю вещественную часть значениями
 FFT_for_conv(Kernel); //прямое БПФ
 for (long i = 0; i < 2*Win; i++)
  {
   Kernel.Redat[i] *= Kernel.Redat[i];
   Kernel.Redat[i] += Kernel.Imdat[i]*Kernel.Imdat[i];
  } //получил мощность спектра
// memset(Kernel.Redat+Win,0,sizeof(float)*Win);
 memset(Kernel.Imdat,0,sizeof(float)*(2*Win));
 Kernel.SetFlag(1);
 FFT_for_conv(Kernel); //обратное БПФ
 if (Out != NULL) { free(Out); Out = 0; }
 Out = (float*)malloc(sizeof(float)*Win);
 memcpy(Out,Kernel.Redat,sizeof(float)*Win); //заполнил выходной массив
}

bool  FFT_for_conv(FastFourier &Params) //FFT преобразование
{
#define  NUMBER_IS_2_POW_K(x)   ((!((x)&((x)-1)))&&((x)>1))  // x is pow(2, k), k=1,2, ...
#define  FT_DIRECT        -1    // Direct transform.
#define  FT_INVERSE        1    // Inverse transform.
    // #define NULL 0
 
    // parameters error check:
    if((Params.Redat == NULL) || (Params.Imdat == NULL))                  return false;
    if((Params.N > 16384) || (Params.N < 1))                            return false;
    if(!NUMBER_IS_2_POW_K(Params.N))                             return false;
    if((Params.LogN < 2) || (Params.LogN > 14))                         return false;
    if((Params.Ft_Flag != FT_DIRECT) && (Params.Ft_Flag != FT_INVERSE)) return false;
    register long  i, j, n, k, io, ie, in, nn;
    float         ru, iu, rtp, itp, rtq, itq, rw, iw, sr;
    static const float Rcoef[14] =
    {  -1.0000000000000000F,  0.0000000000000000F,  0.7071067811865475F,
       0.9238795325112867F,  0.9807852804032304F,  0.9951847266721969F,
       0.9987954562051724F,  0.9996988186962042F,  0.9999247018391445F,
       0.9999811752826011F,  0.9999952938095761F,  0.9999988234517018F,
       0.9999997058628822F,  0.9999999264657178F
    };
    static const float Icoef[14] =
    {   0.0000000000000000F, -1.0000000000000000F, -0.7071067811865474F,
        -0.3826834323650897F, -0.1950903220161282F, -0.0980171403295606F,
        -0.0490676743274180F, -0.0245412285229122F, -0.0122715382857199F,
        -0.0061358846491544F, -0.0030679567629659F, -0.0015339801862847F,
        -0.0007669903187427F, -0.0003834951875714F
    };
    nn = Params.N >> 1;
    ie = Params.N;
    for(n=1; n<=Params.LogN; n++)
    {
        rw = Rcoef[Params.LogN - n];
        iw = Icoef[Params.LogN - n];
        if(Params.Ft_Flag == FT_INVERSE) iw = -iw;
        in = ie >> 1;
        ru = 1.0F;
        iu = 0.0F;
        for(j=0; j<in; j++)
        {
            for(i=j; i< Params.N; i+=ie)
            {
                io       = i + in;
                rtp      = Params.Redat[i]  + Params.Redat[io];
                itp      = Params.Imdat[i]  + Params.Imdat[io];
                rtq      = Params.Redat[i]  - Params.Redat[io];
                itq      = Params.Imdat[i]  - Params.Imdat[io];
                Params.Redat[io] = rtq * ru - itq * iu;
                Params.Imdat[io] = itq * ru + rtq * iu;
                Params.Redat[i]  = rtp;
                Params.Imdat[i]  = itp;
            }
            sr = ru;
            ru = ru * rw - iu * iw;
            iu = iu * rw + sr * iw;
        }
        ie >>= 1;
    }
    for(j=i=1; i< Params.N; i++)
    {
        if(i < j)
        {
            io       = i - 1;
            in       = j - 1;
            rtp      = Params.Redat[in];
            itp      = Params.Imdat[in];
            Params.Redat[in] = Params.Redat[io];
            Params.Imdat[in] = Params.Imdat[io];
            Params.Redat[io] = rtp;
            Params.Imdat[io] = itp;
        }
        k = nn;
        while(k < j)
        {
            j   = j - k;
            k >>= 1;
        }
        j = j + k;
    }
    if(Params.Ft_Flag == FT_DIRECT) return true;
    rw = 1.0F / Params.N;
    for(i=0; i< Params.N; i++)
    {
        Params.Redat[i] *= rw;
        Params.Imdat[i] *= rw;
    }
    return true;
}

void fastACF(short *In,int Win,float *&Out)
{
 FastFourier Kernel(2*Win,-1);
 Kernel.ShortToRedat(In,2*Win);
 FFT_for_conv(Kernel);
 FastFourier X(2*Win,-1);
 X.Zeros();
 for (long i = 0; i < 2*Win; i++)
  {
   X.Redat[i] = Kernel.Redat[i];
   X.Imdat[i] *=-1;
  }
 float a_re,b_im;
 for (long i = 0; i < Kernel.N; i++)
 {
     a_re = Kernel.Redat[i]*X.Redat[i]-Kernel.Imdat[i]*X.Imdat[i];
     b_im = Kernel.Imdat[i]*X.Redat[i]+Kernel.Redat[i]*X.Imdat[i];
     Kernel.Redat[i] = a_re;
     Kernel.Imdat[i] = b_im;
 }
 Kernel.SetFlag(1);
 FFT_for_conv(Kernel);
 Out = (float*)malloc(sizeof(float)*Win);
 memcpy(Out,Kernel.Redat,sizeof(float)*Win);
}

X.Imdat[i] *=-1;

X.Imdat[i] *=-1*Kernel.Imdat[i];

     for (int i = 0; i < Win; i++)
       {
        for (int j = 0; j < Win-i; j++)
          {
           ACF[i]+=In[j]*In[j+i];
          }
        }

    for (int i = 0; i < Win; i++)
    {
        for (int j = 0; j < Win; j++)
        {
            ACF[i] += In[j]*In[j+i];
        }
    }

void fastACF(short *In,int Win,float *&Out)
{
 if (Out != NULL) { free(Out); Out = 0; }
 Out = (float*)malloc(sizeof(float)*Win);
 FastFourier Kernel(2*Win,-1);
 Kernel.ShortToRedat(In,2*Win);
 FFT_for_conv(Kernel);
 FastFourier S(2*Win,-1);
 S.ShortToRedat(In,Win);
 FFT_for_conv(S);
 float a_re,b_im;
 for (long i = 0; i < Kernel.N; i++)
 {
     S.Imdat[i] *= -1;
     a_re = Kernel.Redat[i]*S.Redat[i]-Kernel.Imdat[i]*S.Imdat[i];
     b_im = Kernel.Imdat[i]*S.Redat[i]+Kernel.Redat[i]*S.Imdat[i];
     S.Redat[i] = a_re;
     S.Imdat[i] = b_im;
 }
 S.SetFlag(1);
 FFT_for_conv(S);
 memcpy(Out,S.Redat,sizeof(float)*Win);
}