FFTW_ComplexArray.h

Go to the documentation of this file.

#ifndef FFTW_ComplexArray_H
#define FFTW_ComplexArray_H


#include "FFTW_Object.h"
#include "CORE_Array.h"

#include "FFTW_Complex.h"

DEFINE_SPTR(FFTW_ComplexArray);
class FFTW_ComplexArray : public virtual FFTW_Object {
    SP_OBJECT(FFTW_ComplexArray);
    // ATTRIBUTES
    
    
private:
    
    //values of the warray  
    tFFTWComplex *mValues;
    
    //size of the array
    tUIndex mSize;

    //memory size of the array
    tUIndex  mCapacity;

    //inidate if the values has been allocated within this class
    tBoolean mIsPrivateAllocated;

    
    // ASSOCIATIONS
    
    
public:
    // METHODS
    
    // CONSTRUCTORS 
    
    FFTW_ComplexArray(void);

    FFTW_ComplexArray(const tUIndex& n);
    
    
    
    // DESTRUCTORS 
    
    
    virtual ~FFTW_ComplexArray(void);   
    
public:
    static inline SP::FFTW_ComplexArray New() {
        SP::FFTW_ComplexArray p(new FFTW_ComplexArray(),
                                CORE_Object::Delete());
        p->setThis(p);
        return p;
    };
    

    //operators
    //=========
    
    inline tFFTWComplex& operator[](const tUIndex & i)  {
        if (i>=mCapacity)
            throw CORE_Exception("math/fftw",
                                 "FFTW_ComplexArray["+CORE_Integer::toString(i)+"]",
                                 "index out of bounds [0,"+CORE_Integer::toString(mCapacity)+"[");
        return mValues[i];
    };
    
    inline const tFFTWComplex& operator[](const tUIndex & i)  const {
        if (i>=mCapacity)
            throw CORE_Exception("math/fftw",
                                 "FFTW_ComplexArray["+CORE_Integer::toString(i)+"]",
                                 "index out of bounds [0,"+CORE_Integer::toString(mCapacity)+"[");
        return mValues[i];
    };
    
    inline tFFTWReal& operator()(const tUIndex & i,const tUSInt& j)  {
        if (j>=2)
            throw CORE_Exception("math/fftw",
                                 "FFTW_Complex("+CORE_Integer::toString(i)+","+CORE_Integer::toString(j)+")",
                                 "index out of bounds [0,1]");
        return (*this)[i][j];
    };
    
    inline const tFFTWReal& operator()(const tUIndex & i,const tUSInt& j)  const {
        if (j>=2)
            throw CORE_Exception("math/fftw",
                                 "FFTW_Complex("+CORE_Integer::toString(i)+","+CORE_Integer::toString(j)+")",
                                 "index out of bounds [0,1]");
        return (*this)[i][j];
    };
    inline FFTW_ComplexArray& operator=(const FFTW_ComplexArray&  s)  {
        //cout << " complex array = operator \n";
        copy(s);
        return (*this);
    };
    inline FFTW_ComplexArray& operator=(const CORE_ComplexArray&  s)  {
        //cout << " complex array = operator \n";
        copy(s);
        return (*this);
    };
    
    inline FFTW_ComplexArray& operator=(const CORE_RealArray&  s)  {
        copy(s);
        return (*this);
    };
    inline FFTW_ComplexArray& operator=(const CORE_DoubleArray&  s)  {
        copy(s);
        return (*this);
    };
    inline FFTW_ComplexArray& operator=(const CORE_FloatArray&  s)  {
        copy(s);
        return (*this);
    };
    
    inline FFTW_ComplexArray& operator=(const tFFTWReal&  s)  {
        initArray(s);
        return (*this);
    };
    inline FFTW_ComplexArray& operator=(const tFFTWComplex&  s)  {
        initArray(s);
        return (*this);
    };
    
    inline FFTW_ComplexArray& operator*=(const tFFTWReal&  s)  {
        multiply(s);
        return (*this);
    };
    inline FFTW_ComplexArray& operator*=(const tFFTWComplex&  s)  {
        multiply(s);
        return (*this);
    }
    
    
    inline FFTW_ComplexArray& operator*=(const FFTW_ComplexArray&  s)  {
        multiply(s);
        return (*this);
    };
   
    inline FFTW_ComplexArray& operator/=(const tFFTWReal&  s)  {
        if (s==0) throw CORE_Exception("math/fftw","FFTW_ComplexArray/=","division by 0");
        multiply(1/s);
        return (*this);
    };

    inline FFTW_ComplexArray& operator+=(const tFFTWReal&  s)  {
        add(s);
        return (*this);
    };
    inline FFTW_ComplexArray& operator+=(const tFFTWComplex&  s)  {
        add(s);
        return (*this);
    };
    inline FFTW_ComplexArray& operator+=(const FFTW_ComplexArray&  s)  {
        add(s);
        return (*this);
    };
    
    inline FFTW_ComplexArray& operator-=(const tFFTWReal&  s)  {
        add(-s);
        return (*this);
    };
    
    //Builder of array
    //================
private:
    
    void desallocate();
    
    void allocate(const tUIndex& cap);
    
public:
    inline void clear() {
        
        desallocate();
        mSize=0;
        mCapacity=0;
        mValues=null;
        mIsPrivateAllocated=false;
    }
    
    inline void setSize(const tUIndex& n) {
        if (n>mCapacity) allocate(n); 
        mSize=n;
    }

    void fitToSize();

public:
    //copy method
    //===========

    void copy(const FFTW_ComplexArray& f);
    
    void copy(const CORE_ComplexArray& f);
    
    template<class T>
    void copy(const complex<T>* f,const tUIndex& n);
    
    
    void copy(const CORE_RealArray& f);
    
    void copy(const CORE_DoubleArray& f);

    void copy(const CORE_FloatArray& f);

    
    // init methods

    void initArray(const tReal& f);
    
    void initArray(const tFFTWComplex& f);
    
   
    //set methods
    //===========
    
    inline void setValue(const tUIndex& index,const tFFTWReal& x,const tFFTWReal& y) {
        tFFTWComplex &c=mValues[index];
        c[0]=x;
        c[1]=y;
    }

    inline tBoolean setValuesByReference(const tUIndex& n,tFFTWComplex * array) {
        desallocate();
        mValues=array;
        mSize=n;
        mCapacity=n;
        mIsPrivateAllocated=false;
        return true;
    }
    
    
    // GET methods

    virtual tULLInt getMemorySize() const {
        return  sizeof(tFFTWComplex)*mSize;
    }
    inline const tFFTWComplex* getValues() const {
        return mValues;
    }
    inline tFFTWComplex* getValues()  {
        return mValues;
    }
    inline const tUIndex& getSize() const {
        return mSize;
    }
    inline const tUIndex& getCapacity() const {
        return mCapacity;
    }
    

    inline void swap(const tUIndex& i,const tUIndex& j) {
        std::swap(mValues[i][0],mValues[j][0]);
        std::swap(mValues[i][1],mValues[j][1]);
    }

    //arithmetic methods
    //===================
    void multiply(const tFFTWReal&  s);
    void multiply(const tFFTWComplex&  s);
    
    void multiply(const FFTW_ComplexArray&  s);

    void add(const tFFTWReal&  s);
    
    void add(const tFFTWComplex&  s);
    
    void add(const FFTW_ComplexArray&  s);
    

    static void MatrixVectorProduct(const tFFTWReal& alpha,
                                    const tUIndex& N,const tFFTWComplex* A,
                                    const tFFTWComplex* X,
                                    tFFTWComplex* Y);
    
    
    
    //euclidian methods
    //=================
    
    tFFTWReal norm2() const;
    
    inline tFFTWReal norm() const {
        return sqrt(norm2());
    }

    
    tFFTWReal distance2(const FFTW_ComplexArray& x) const;
    
    
    inline tFFTWReal distance(const FFTW_ComplexArray& x) const {
        return sqrt(distance2(x));
    }
    
    
    tFFTWReal fabs(tUIndex& i) const;
    
    tFFTWReal fabs(const FFTW_ComplexArray& x,tUIndex& i) const;
    
 
    
    virtual tString toString() const;

};

#include "FFTW_ComplexArray.hpp" 

#endif