MATSGN_FFT.h

Go to the documentation of this file.

#ifndef MATSGN_FFT_H
#define MATSGN_FFT_H

#include "CORE_Object.h"
#include "CORE_Array.h"
#include "MATSGN_ComplexArray.h"

DEFINE_SPTR(MATSGN_FFT);
class MATSGN_FFT : public virtual CORE_Object {
    SP_OBJECT(MATSGN_FFT);
    // ATTRIBUTES

public:
    static const tFlag FXT;
    static const tFlag SL;
    static const tFlag LIB_ROW;
    static const tFlag FFTW;

    static const tBoolean FORWARD;
    static const tBoolean BACKWARD;
    static const tBoolean DIRECT;
    static const tBoolean INVERSE;


private:
    tFlag  mMethod;
    
    // ASSOCIATIONS
    
    
protected: 
    // METHODS
    
    // CONSTRUCTORS 
    
    MATSGN_FFT(void);
    
    
    
    // DESTRUCTORS 
    
    
    virtual ~MATSGN_FFT(void);


public:

    inline static SP::MATSGN_FFT New() {
        SP::MATSGN_FFT p(new MATSGN_FFT(),MATSGN_FFT::Delete());
        p->setThis(p);
        return p;
    }
   
    
public:
    
    // SET methods
    inline void setMethod(const tFlag& method) {
        mMethod=method;
    };
    
    // GET methods
    static tString getFFTMethodName(const tFlag& m);
    
    // OTHERS methods
   
public:
    void slowFourierTransform(const MATSGN_ComplexArray& input, 
                              MATSGN_ComplexArray& output,
                              const tBoolean& isForward) const;
    
    inline void slowFourierTransform(const MATSGN_ComplexArray& input,  
                                     MATSGN_ComplexArray& output) const {
        slowFourierTransform(input,output,true);
    }
    
    inline static void fastFourierTransform(const CORE_DoubleArray& input,
                                            MATSGN_ComplexArray& output,
                                            const tFlag& method)  {
        //copy the input into output
        output=input;
        MATSGN_FFT::fastFourierTransform(output,output,true,false,method);
    };
    inline static void fastFourierTransform(const CORE_DoubleArray& x,
                                            MATSGN_ComplexArray& res,
                                            const tBoolean& isForward,
                                            const tFlag& method) {
        res=x;
        fastFourierTransform(res,res,isForward,false,method);
    };
    
    static void fastFourierTransform(const MATSGN_ComplexArray& x,
                                     MATSGN_ComplexArray& res,
                                     const tBoolean& isForward,
                                     const tBoolean& inverse,
                                     const tFlag& method);
    
    static void fastFourierTransform(MATSGN_ComplexArray& x,
                                     const tBoolean& isForward,
                                     const tBoolean& inverse,
                                     const tFlag& method);
    
    inline void fastFourierTransform(const MATSGN_ComplexArray& x,
                                     MATSGN_ComplexArray& res) {
        fastFourierTransform(x,res,true,false,mMethod);
    };

    inline void fastFourierInverseTransform(const MATSGN_ComplexArray& x,
                                            MATSGN_ComplexArray& res,
                                            const tFlag& method) {
        fastFourierTransform(x,res,true,true,method);
    };
    inline void fastFourierInverseTransform(const MATSGN_ComplexArray& x,
                                            MATSGN_ComplexArray& res,
                                            const tBoolean& isForward,
                                            const tFlag& method) {
        fastFourierTransform(x,res,isForward,true,method);
    };

    
    virtual tBoolean fastFourierTransform3D(const tUInteger& Nx,
                                            const tUInteger& Ny,
                                            const tUInteger& Nz,
                                            MATSGN_ComplexArray& x,
                                            const tBoolean& isForward,
                                            const tBoolean& inverse,
                                            const tFlag& method) const;
    
protected:
    virtual  tBoolean fastFourierTransform3D_GENERIC(const tUInteger& Nx,
                                                     const tUInteger& Ny,
                                                     const tUInteger& Nz,
                                                     MATSGN_ComplexArray& x,
                                                     const tBoolean& isForward,
                                                     const tBoolean& inverse,
                                                     const tFlag& method) const;
    
    virtual  tBoolean fastFourierTransform3D_SL(const tUInteger& Nx,
                                                const tUInteger& Ny,
                                                const tUInteger& Nz,
                                                MATSGN_ComplexArray& x,
                                                const tBoolean& isForward,
                                                const tBoolean& inverse) const;
    
    virtual tBoolean fastFourierTransform3D_FFTW(const tUInteger& Nx,
                                                 const tUInteger& Ny,
                                                 const tUInteger& Nz,
                                                 MATSGN_ComplexArray& x,
                                                 const tBoolean& isForward,
                                                 const tBoolean& inverse) const;
public:
    
    virtual tBoolean fastFourierTransform3DMatrix(MATSGN_ComplexArray& A,
                                                  const tUIndex& fromAIndex,
                                                  MATSGN_ComplexArray& Wrk,
                                                  const tUInteger& lx,
                                                  const tUInteger& ly,
                                                  const tUInteger& lz,
                                                  const tUInteger& lda,
                                                  const tBoolean& isForward,
                                                  const tBoolean& inverse,
                                                  const tFlag& method) const;
    virtual tBoolean fastFourierTransform3DMatrix(MATSGN_ComplexArray& A,
                                                  const tUInteger& lx,
                                                  const tUInteger& ly,
                                                  const tUInteger& lz,
                                                  const tUInteger& lda,
                                                  const tBoolean& isForward,
                                                  const tBoolean& inverse,
                                                  const tFlag& method) const {
        MATSGN_ComplexArray wrk;
        wrk.setSize(lx*ly*lz);
        return fastFourierTransform3DMatrix(A,0,wrk,lx,ly,lz,lda,isForward,inverse,method);
    }
    virtual tBoolean fastFourierTransform3DMatrix(MATSGN_ComplexArray& A,
                                                  MATSGN_ComplexArray& wrk,
                                                  const tUInteger& lx,
                                                  const tUInteger& ly,
                                                  const tUInteger& lz,
                                                  const tUInteger& lda,
                                                  const tBoolean& isForward,
                                                  const tBoolean& inverse,
                                                  const tFlag& method) const {
       
        return fastFourierTransform3DMatrix(A,0,wrk,lx,ly,lz,lda,isForward,inverse,method);
    }

     
public:

    // FXT Method
    // ===========
    static void fastFourierTransform_FXT(const MATSGN_ComplexArray& input,
                                         const tBoolean& isForward,
                                         const tBoolean& isInverse,
                                         complex<tDouble>* output);
    static void fastFourierTransform_FXT(complex<tDouble>* x,const tUIndex& n,
                                         const tBoolean& isForward,
                                         const tBoolean& isInverse);
    
    // FFTW Method
    // ===========
    static void Transpose(const tChar& storage,fftw_complex* A, const tUIndex& nRows, const tUIndex& nCols);
    
    static void fastFourierTransform_FFTW(const MATSGN_ComplexArray& x,
                                          MATSGN_ComplexArray& y,
                                          const tBoolean& isForward,
                                          const tBoolean& isInverse);
    inline static void fastFourierTransform_FFTW(MATSGN_ComplexArray& x,
                                                 const tBoolean& isForward,
                                                 const tBoolean& isInverse) {
        fastFourierTransform_FFTW(x.getSize(),&x[0],isForward,isInverse);
    }
    static void fastFourierTransform_FFTW(const tUIndex& length,
                                          fftw_complex* x,
                                          const tBoolean& isForward,
                                          const tBoolean& isInverse) ;

    static void fastFourierTransformND_FFTW(const CORE_IntArray& dims,
                                            MATSGN_ComplexArray& x,
                                            const tBoolean& isForward,
                                            const tBoolean& isInverse) ;
    

    // Labbe method
    // =============
public:
    static void tabfft( const tBoolean& isForward,
                        MATSGN_ComplexArray& w,
                        const tUIndex& nx);

public:
    static void fastFourierTransform_SL(const MATSGN_ComplexArray& w,
                                        MATSGN_ComplexArray& x,
                                        const tBoolean& isForward,
                                        const tBoolean& inverse);
private:
    static tBoolean Rearrange(const MATSGN_ComplexArray& input,
                              MATSGN_ComplexArray& output);
    static tBoolean Rearrange(MATSGN_ComplexArray& inoutput);
    static tBoolean Perform(MATSGN_ComplexArray& data,
                            const tBoolean& isForward,
                            const tBoolean& inverse);
    static tBoolean Scale(MATSGN_ComplexArray& data);
    
    
    
public:
    // LIBROW method
    // ===============
    //  @see http://www.librow.com/articles/article-10
    //
    
    static tBoolean fastFourierTransform_LR(const MATSGN_ComplexArray& input,
                                            MATSGN_ComplexArray& output,
                                            const tBoolean& isForward,  
                                            const tBoolean& inverse) ;
    
   
 
    static tBoolean fastFourierTransform_LR(MATSGN_ComplexArray& input,
                                            const tBoolean& isForward,
                                            const tBoolean& inverse);
    
    
    
    
};

#endif