Beispiel #1
0
void FFT(const ColumnVector& U, const ColumnVector& V,
   ColumnVector& X, ColumnVector& Y)
{
   // from Carl de Boor (1980), Siam J Sci Stat Comput, 1 173-8
   // but first try Sande and Gentleman
   Tracer trace("FFT");
   REPORT
   const int n = U.Nrows();                     // length of arrays
   if (n != V.Nrows() || n == 0)
      Throw(ProgramException("Vector lengths unequal or zero", U, V));
   if (n == 1) { REPORT X = U; Y = V; return; }

   // see if we can use the newfft routine
   if (!FFT_Controller::OnlyOldFFT && FFT_Controller::CanFactor(n))
   {
      REPORT
      X = U; Y = V;
      if ( FFT_Controller::ar_1d_ft(n,X.Store(),Y.Store()) ) return;
   }

   ColumnVector B = V;
   ColumnVector A = U;
   X.ReSize(n); Y.ReSize(n);
   const int nextmx = 8;
#ifndef ATandT
   int prime[8] = { 2,3,5,7,11,13,17,19 };
#else
   int prime[8];
   prime[0]=2; prime[1]=3; prime[2]=5; prime[3]=7;
   prime[4]=11; prime[5]=13; prime[6]=17; prime[7]=19;
#endif
   int after = 1; int before = n; int next = 0; bool inzee = true;
   int now = 0; int b1;             // initialised to keep gnu happy

   do
   {
      for (;;)
      {
	 if (next < nextmx) { REPORT now = prime[next]; }
	 b1 = before / now;  if (b1 * now == before) { REPORT break; }
	 next++; now += 2;
      }
      before = b1;

      if (inzee) { REPORT fftstep(A, B, X, Y, after, now, before); }
      else { REPORT fftstep(X, Y, A, B, after, now, before); }

      inzee = !inzee; after *= now;
   }
Beispiel #2
0
static void fftstep(ColumnVector& A, ColumnVector& B, ColumnVector& X,
                    ColumnVector& Y, int after, int now, int before)
{
    REPORT
    Tracer trace("FFT(step)");
    // const Real twopi = 6.2831853071795864769;
    const int gamma = after * before;
    const int delta = now * after;
    // const Real angle = twopi / delta;  Real temp;
    // Real r_omega = cos(angle);  Real i_omega = -sin(angle);
    Real r_arg = 1.0;
    Real i_arg = 0.0;
    Real* x = X.Store();
    Real* y = Y.Store();   // pointers to array storage
    const int m = A.Nrows() - gamma;

    for (int j = 0; j < now; j++)
    {
        Real* a = A.Store();
        Real* b = B.Store(); // pointers to array storage
        Real* x1 = x;
        Real* y1 = y;
        x += after;
        y += after;
        for (int ia = 0; ia < after; ia++)
        {
            // generate sins & cosines explicitly rather than iteratively
            // for more accuracy; but slower
            cossin(-(j*after+ia), delta, r_arg, i_arg);

            Real* a1 = a++;
            Real* b1 = b++;
            Real* x2 = x1++;
            Real* y2 = y1++;
            if (now==2)
            {
                REPORT int ib = before;
                if (ib) for (;;)
                    {
                        REPORT
                        Real* a2 = m + a1;
                        Real* b2 = m + b1;
                        a1 += after;
                        b1 += after;
                        Real r_value = *a2;
                        Real i_value = *b2;
                        *x2 = r_value * r_arg - i_value * i_arg + *(a2-gamma);
                        *y2 = r_value * i_arg + i_value * r_arg + *(b2-gamma);
                        if (!(--ib)) break;
                        x2 += delta;
                        y2 += delta;
                    }
            }
            else
            {
                REPORT int ib = before;
                if (ib) for (;;)
                    {
                        REPORT
                        Real* a2 = m + a1;
                        Real* b2 = m + b1;
                        a1 += after;
                        b1 += after;
                        Real r_value = *a2;
                        Real i_value = *b2;
                        int in = now-1;
                        while (in--)
                        {
                            // it should be possible to make this faster
                            // hand code for now = 2,3,4,5,8
                            // use symmetry to halve number of operations
                            a2 -= gamma;
                            b2 -= gamma;
                            Real temp = r_value;
                            r_value = r_value * r_arg - i_value * i_arg + *a2;
                            i_value = temp    * i_arg + i_value * r_arg + *b2;
                        }
                        *x2 = r_value;
                        *y2 = i_value;
                        if (!(--ib)) break;
                        x2 += delta;
                        y2 += delta;
                    }
            }

            // temp = r_arg;
            // r_arg = r_arg * r_omega - i_arg * i_omega;
            // i_arg = temp  * i_omega + i_arg * r_omega;

        }
    }
}