MATH_ElementaryMultiLevelsToeplitzMatrix.h

Go to the documentation of this file.

#ifndef MATH_ElementaryMultiLevelsToeplitzMatrix_H
#define MATH_ElementaryMultiLevelsToeplitzMatrix_H

#include "MATH_MultiLevelsFFTToeplitzMatrix.h"

#include "MATH_LeafBlockMatrixPackedStorage.h"
#include "MATH_LeafBlockMatrixFullStorage.h"

DEFINE_SPTR(MATH_ElementaryMultiLevelsToeplitzMatrix);

class MATH_ElementaryMultiLevelsToeplitzMatrix : public MATH_MultiLevelsFFTToeplitzMatrix  {
    SP_OBJECT(MATH_ElementaryMultiLevelsToeplitzMatrix);
    
public:
    
    
    
private:

    mutable SP::FFTW_FFT mWork;
    
protected: 
    
    // METHOD
    
    // CONSTRUCTORS 
  
    MATH_ElementaryMultiLevelsToeplitzMatrix(void);
    
    
    
    // DESTRUCTORS 
    
  
    virtual ~MATH_ElementaryMultiLevelsToeplitzMatrix(void);   
    
    
public:
  

    //copy
    virtual void copy(const MATH_MultiLevelsToeplitzMatrix& mat) {
        MATH_MultiLevelsToeplitzMatrix::copy(mat);
    }
    

    // SET methods
  
    inline void setStorage(const tString& storage) {
        if (storage.compare("packed")==0) {
            MATH_MultiLevelsFFTToeplitzMatrix::setStorage(MATH_LeafBlockMatrixPackedStorage::New());
        } else {
            MATH_MultiLevelsFFTToeplitzMatrix::setStorage(MATH_LeafBlockMatrixFullStorage::New());
        }
    }
    
public:
 
  
    
    // GET methods 
    virtual tULLInt getMemorySize() const {
        return MATH_MultiLevelsFFTToeplitzMatrix::getMemorySize()+
            ((mWork.get()==null)?0:mWork->getMemorySize());
            
    }

  
    // diagonalization methods
    //=========================
 
protected:
    virtual tUIndex computeSpectralSpaceSizePerDimension(const tUIndex& s,
                                                         const tUSInt& d,
                                                         CORE_UIndexArray& Ms) const=0;
    
    virtual void buildSpectralVectorProjector(FFTW_FFT& proj) const;
    
    virtual void buildSpectralSpace();
    
    virtual void recoverCanonicalSpace();
    
    virtual void buildColumnLeadingDimensions();
    
    virtual void buildRowLeadingDimensions();

private:
    virtual tUIndex getElementIndex(const tUIndex& i,
                                    const tUIndex& j) const;
private:
    tUIndex getElementIndex(const tUIndex& i,
                            const tUIndex& j,
                            const tUSInt& level,
                            const tUIndex& nRows,
                            tUIndex& nValues) const;
    
    
    
    
   
    //product in spectral space methods
    //==================================
protected:
    virtual void vectorProductInSpectralSpace(const FFTW_FFT& A,FFTW_FFT& Z) const;
  
    virtual void projectIntoSpectralSpace(const tUIndex& N,const tReal* X) const;
  
    virtual void recoverFromSpectralSpace(const tUIndex& N,tReal* X) const;
    

  
    
        
    
};
#endif