gfftgen.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2012-2014 by Vladimir Mirnyy                            *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 ***************************************************************************/


#ifndef __gfftgen_h
#define __gfftgen_h

#include "sint.h"
#include "typelistgen.h"
#include "gfftparamgroups.h"


namespace GFFT {


template<class N,
class VType,
class Type,                    // DFT, IDFT, RDFT, IRDFT
class Dim,
class Parall,
class Place,              // IN_PLACE, OUT_OF_PLACE
class FactoryPolicy = Empty,
id_t IDN = N::ID>
class Transform;


template<class N,
class VType,
class Type,                    // DFT, IDFT, RDFT, IRDFT
class Dim,
class Parall,
class FactoryPolicy,
id_t IDN>
class Transform<N,VType,Type,Dim,Parall,IN_PLACE,FactoryPolicy,IDN> : public FactoryPolicy 
{
   typedef typename VType::ValueType T;
   typedef typename Factorization<N, SInt>::Result NFact;
   typedef typename Parall::template Swap<NFact::Head::first::value,NFact::Head::second::value,T>::Result Swap;
   typedef typename Type::template Direction<N::value,T> Dir;
   typedef Separate<N::value,T,Dir::Sign> Sep;

   typedef typename GetFirstRoot<N::value,Dir::Sign,VType::Accuracy>::Result W1;
   
   typedef typename IN_PLACE::template List<N::value,NFact,T,Swap,Dir,Parall::NParProc,W1>::Result TList;
   typedef typename Type::template Algorithm<TList,Sep>::Result Alg;
   
   Caller<Loki::Typelist<Parall,Alg> > run;
   
public:
   typedef VType ValueType;
   typedef Type TransformType;
   typedef Parall ParallType;
   typedef IN_PLACE PlaceType;

   enum { ID = IDN };
   static const int_t Len = N::value;

   static FactoryPolicy* Create() {
      return new Transform<N,VType,Type,Dim,Parall,IN_PLACE,FactoryPolicy,ID>();
   }

   Transform() { }
    ~Transform() { }

//   in-place transform
   void fft(T* data) { run.apply(data); }
};


template<class N,
class VType,
class Type,                    // DFT, IDFT, RDFT, IRDFT
class Dim,
class Parall,
class FactoryPolicy,
id_t IDN>
class Transform<N,VType,Type,Dim,Parall,OUT_OF_PLACE,FactoryPolicy,IDN> : public FactoryPolicy 
{
   typedef typename VType::ValueType T;
   typedef typename Type::template Direction<N::value,T> Dir;
   typedef Separate<N::value,T,Dir::Sign> Sep;
   typedef Caller<Loki::NullType> EmptySwap;
   typedef typename Factorization<N, SInt>::Result NFact;

   //typedef typename GenerateRootList<N::value,Dir::Sign,2>::Result RootList;
   typedef typename GetFirstRoot<N::value,Dir::Sign,VType::Accuracy>::Result W1;
   
   typedef typename OUT_OF_PLACE::template List<N::value,NFact,T,EmptySwap,Dir,Parall::NParProc,W1>::Result TList;
   typedef typename Type::template Algorithm<TList,Sep>::Result Alg;
   
   Caller<Loki::Typelist<Parall,Alg> > run;
   
public:
   typedef VType ValueType;
   typedef Type TransformType;
   typedef Parall ParallType;
   typedef OUT_OF_PLACE PlaceType;

   enum { ID = IDN, Len = N::value };

   static FactoryPolicy* Create() {
      return new Transform<N,VType,Type,Dim,Parall,OUT_OF_PLACE,FactoryPolicy>();
   }

   Transform() 
   {
   }
 
   ~Transform() 
   {
   }

   // out-of-place transform
   void fft(const T* src, T* dst) { run.apply(src, dst); }
};



template<class TList, id_t ID>
struct DefineTransform {
   typedef typename TList::Tail::Head VType;
   typedef typename TList::Tail::Tail::Head TransformType;
   typedef typename TList::Tail::Tail::Tail::Tail::Tail::Head Place;
   typedef typename Place::template Interface<typename VType::ValueType>::Result Abstract;
   
   typedef Transform<typename TList::Head, VType, TransformType,
                typename TList::Tail::Tail::Tail::Head,
                typename TList::Tail::Tail::Tail::Tail::Head,
                Place,Abstract,ID> Result;
};



template<class NList>
struct TranslateID;

template<id_t N, class T>
struct TranslateID<Loki::Typelist<s_uint<N>,T> > {
   static unsigned int apply(const int_t* n) {
      return TranslateID<T>::apply(n+1)*N + *n;
   }
};

template<id_t N>
struct TranslateID<Loki::Typelist<s_uint<N>,Loki::NullType> > {
   static unsigned int apply(const int_t* n) {
      return *n;
   }
};



template <typename IdentifierType, class AbstractProduct>
struct TransformFactoryError
{
   struct Exception : public std::exception 
   {
      const char* what() const throw() { 
        return "Requested transform is not compiled! Check your instantiation of GenerateTransform class!"; 
      }
   };
   static AbstractProduct* OnUnknownType(IdentifierType) {
      throw Exception();
   }
};



template<class NList,
class T         /* = ValueTypeList*/,        // has to be set explicitely because of AbstractFFT<T>
class TransType  = TransformTypeGroup::Default,     // DFT, IDFT, RDFT, IRDFT
class Dim        = SIntID<1>,
class Parall     = ParallelizationGroup::Default,
class Place      = PlaceGroup::Default>             // IN_PLACE, OUT_OF_PLACE
class GenerateTransform {
   //typedef typename GenNumList<Begin,End>::Result NList;
   enum { L1 = Loki::TL::Length<NList>::value };
   enum { L2 = Loki::TL::Length<ValueTypeGroup::FullList>::value };
   enum { L3 = Loki::TL::Length<TransformTypeGroup::FullList>::value };
   enum { L4 = 1 };
   enum { L5 = Loki::TL::Length<ParallelizationGroup::FullList>::value };
   enum { L6 = Loki::TL::Length<DecimationGroup::FullList>::value };
   typedef TYPELIST_6(s_uint<L1>,s_uint<L2>,s_uint<L3>,s_uint<L4>,s_uint<L5>,s_uint<L6>) LenList;

   typedef typename Loki::TL::Reverse<LenList>::Result RevLenList;

   typedef TYPELIST_6(Place,Parall,Dim,TransType,T,NList) RevList;

   typedef TranslateID<LenList> Translate;

public:
   typedef typename ListGenerator<RevList,RevLenList,DefineTransform>::Result Result;
   typedef typename Place::template Interface<typename T::ValueType>::Result ObjectType;

   Loki::Factory<ObjectType,int_t,ObjectType*(*)(),TransformFactoryError> factory;

   GenerateTransform() {
      FactoryInit<Result>::apply(factory);
   }

   ObjectType* CreateTransformObject(int_t n, int_t vtype_id, 
                                   int_t trans_id = TransformTypeGroup::Default::ID, 
                                   int_t dim = 1, 
                                   int_t parall_id = ParallelizationGroup::Default::ID, 
                                   int_t decim_id = DecimationGroup::Default::ID) 
   {
      int_t narr[] = {n-1, vtype_id, trans_id, dim-1, parall_id, decim_id};
      int_t obj_id = Translate::apply(narr);
      return factory.CreateObject(obj_id);
   }

};

  
}  //namespace

#endif