MATH_MultiLevelsFFTToeplitzMatrix.h

Go to the documentation of this file.

#ifndef MATH_MultiLevelsFFTToeplitzMatrix_H
#define MATH_MultiLevelsFFTToeplitzMatrix_H

#include "MATH_MultiLevelsToeplitzMatrix.h"

DEFINE_SPTR(MATH_MultiLevelsFFTToeplitzMatrix);

class MATH_MultiLevelsFFTToeplitzMatrix : public MATH_MultiLevelsToeplitzMatrix {
    SP_OBJECT(MATH_MultiLevelsFFTToeplitzMatrix);
  
public:
    

private:

    mutable SP::FFTW_FFT mDFTProjector;
    tUIndex mSpectralSpaceSize;
    
    //column leading dimensions in the CANONICAL_SPACE values which are on first row
    CORE_UIndexArray mColumnLeadingDimensions;
    
    //row indices in the CANONICAL_SPACE values which are o the first column
    CORE_UIndexArray mRowLeadingDimensions;
    
    
    // ASSOCIATIONS

    
   
    
protected: 
    
    // METHOD
    
    // CONSTRUCTORS 
    
    MATH_MultiLevelsFFTToeplitzMatrix(void);
    
    
    
    // DESTRUCTORS 
    
  
    virtual ~MATH_MultiLevelsFFTToeplitzMatrix(void);   
    
    
public:
  
    
    
    
  
   
public:
   
   
  
    
    virtual void copy(const MATH_MultiLevelsToeplitzMatrix& mat);
    

    // SET methods

    virtual void clear();
    
protected:
    
    inline void setSpectralSpaceSize(const tUIndex& n) {
        mSpectralSpaceSize=n;
    }
  
public:


    // GET methods
    virtual tULLInt getMemorySize() const {
        return MATH_MultiLevelsToeplitzMatrix::getMemorySize()+
            ((mDFTProjector.get()==null)?0:mDFTProjector->getMemorySize())+
            mColumnLeadingDimensions.getMemorySize()+
            mRowLeadingDimensions.getMemorySize();
        
            
    }
    
    inline FFTW_FFT& getDFTProjector() const {
        return *mDFTProjector.get();
    }





    
 
   
    
    // GET methods

  
    
protected: 
    inline const CORE_UIndexArray& getColumnLeadingDimensions() const {
        return mColumnLeadingDimensions;
    }
    inline CORE_UIndexArray& getColumnLeadingDimensions()  {
        return mColumnLeadingDimensions;
    }
   

    inline const CORE_UIndexArray& getRowLeadingDimensions() const {
        return mRowLeadingDimensions;
    }

    inline CORE_UIndexArray& getRowLeadingDimensions()  {
        return mRowLeadingDimensions;
    }
  
    
    inline const tUIndex& getSpectralSpaceSize() const {
        return mSpectralSpaceSize;
    }

   
    // diagonalization methods
    //=========================
protected:
    virtual void buildSpectralVectorProjector(FFTW_FFT& proj) const {
        proj.copy(getDFT());
    }
    
    virtual void buildSpectralSpace()=0;
    
    virtual void recoverCanonicalSpace()=0;
    
    virtual void buildColumnLeadingDimensions()=0;
    
    virtual void buildRowLeadingDimensions()=0;

 
   
    
protected:
    virtual void diagonalize();
    
    
    virtual void recover();
     
    
    

  

    
    //product in spectral space methods
    //==================================

public:

 
    virtual void vectorProduct(const tUIndex& N,
                               const tReal* X,
                               tReal* Y) const;

    virtual void vectorProduct(const CORE_RealArray& X,
                               CORE_RealArray&  Y) const {
        MATH_MultiLevelsToeplitzMatrix::vectorProduct(X,Y);
    }
    
    
protected:

    virtual void vectorProductInSpectralSpace(const FFTW_FFT& A,FFTW_FFT& Z) const=0;
    
    virtual void projectIntoSpectralSpace(const tUIndex& N,const tReal* X) const=0;
  
    virtual void recoverFromSpectralSpace(const tUIndex& N,tReal*  X) const=0;
   
        
    
    

    
};
#endif