MATSGN_ComplexArray.h

Go to the documentation of this file.

#ifndef MATSGN_ComplexArray_H
#define MATSGN_ComplexArray_H

#include "CORE_Object.h"
#include "CORE_Array.h"
#include "CORE_Exception.h"
#include "fftw3.h"

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


private:

    //values of the warray  
    fftw_complex *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;


    mutable tDouble mReal,mImag;
    
    // ASSOCIATIONS
    
    
public:
    // METHODS
    
    // CONSTRUCTORS 
    
    MATSGN_ComplexArray(void);

    MATSGN_ComplexArray(const tUIndex& n);
    
    
    
    // DESTRUCTORS 
    
    
    virtual ~MATSGN_ComplexArray(void);   
    
public:

    //operators
    //=========
    
    inline fftw_complex& operator[](const tUIndex & i)  {
        ASSERT_IN(i<mSize);
        return mValues[i];
    };
    inline const fftw_complex& operator[](const tUIndex & i)  const {
        ASSERT_IN(i<mSize);
        return mValues[i];
    };
    
    inline tDouble& operator()(const tUIndex & i,const tUSInt& j)  {
        ASSERT_IN(i<mSize);
        ASSERT_IN(j<2);
        return mValues[i][j];
    };
    inline const tDouble& operator()(const tUIndex & i,const tUSInt& j)  const {
        ASSERT_IN(i<mSize);
        ASSERT_IN(j<2);
        return mValues[i][j];
    };
    inline MATSGN_ComplexArray& operator=(const MATSGN_ComplexArray&  s)  {
        //cout << " complex array = operator \n";
        copy(s);
        return (*this);
    };
    inline MATSGN_ComplexArray& operator=(const CORE_ComplexArray&  s)  {
        //cout << " complex array = operator \n";
        copy(s);
        return (*this);
    };
    
    inline MATSGN_ComplexArray& operator=(const CORE_RealArray&  s)  {
        copy(s);
        return (*this);
    };
    inline MATSGN_ComplexArray& operator=(const CORE_DoubleArray&  s)  {
        copy(s);
        return (*this);
    };
    inline MATSGN_ComplexArray& operator=(const tReal&  s)  {
        initArray(s);
        return (*this);
    };
    inline MATSGN_ComplexArray& operator=(const fftw_complex&  s)  {
        initArray(s);
        return (*this);
    };
    
    inline MATSGN_ComplexArray& operator*=(const tReal&  s)  {
        if (mSize==0) return (*this);
        tUIndex i;
        fftw_complex* Ts=&(*this)[0];
        for (i=0;i<mSize;i++) {
            (*Ts)[0]*=s;
            (*Ts)[1]*=s;
            Ts++;
            
        }
        return (*this);
    };
    inline MATSGN_ComplexArray& operator*=(const MATSGN_ComplexArray&  Y)  {
        if (mSize==0) return (*this);
        if (Y.getSize()<mSize) throw CORE_Exception("math/signal",
                                                    "MATSGN_ComplexArray*=Y",
                                                    "Y has too small size "+CORE_Integer::toString(Y.getSize())+" with respect to This size :"+CORE_Integer::toString(mSize));
        tUIndex i;
        fftw_complex* Ts=&(*this)[0];
        const fftw_complex *Ys=&Y[0];
        for (i=0;i<mSize;i++) {
            mReal=(*Ts)[0]*(*Ys)[0]-(*Ts)[1]*(*Ys)[1];
            (*Ts)[1]=(*Ts)[0]*(*Ys)[1]+(*Ts)[1]*(*Ys)[0];
            (*Ts)[0]=mReal;
            Ts++;
            Ys++;
        }
        return (*this);
    };
   
    inline MATSGN_ComplexArray& operator/=(const tReal&  s)  {
        if (s==0) throw CORE_Exception("math/signam","MATSGN_ComplexArray/=","division by 0");
        if (mSize==0) return (*this);
        tUIndex i;
        fftw_complex* Ts=&(*this)[0];
        for (i=0;i<mSize;i++) {
            (*Ts)[0]/=s;
            (*Ts)[1]/=s;
            Ts++;
            
        }
        return (*this);
    };

    inline MATSGN_ComplexArray& operator+=(const tReal&  s)  {
        if (mSize==0) return (*this);
        tUIndex i;
        fftw_complex* Ts=&(*this)[0];
        for (i=0;i<mSize;i++) {
            (*Ts)[0]+=s;
            Ts++;
            
        }
        return (*this);
    };
    inline MATSGN_ComplexArray& operator-=(const tReal&  s)  {
        if (mSize==0) return (*this);
        tUIndex i;
        fftw_complex* Ts=&(*this)[0];
        for (i=0;i<mSize;i++) {
            (*Ts)[0]-=s;
            Ts++;
            
        }
        return (*this);
    };
    
    //Builder of array
    //================
private:
    
    void desallocate();
    
    void allocate(const tUIndex& cap);

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

    void copy(const MATSGN_ComplexArray& f);
    
    void copy(const CORE_ComplexArray& f);
    
    template<class T>
    void copy(const complex<T>* f,const tUIndex& n) {
        tUIndex k;
        
        if (n==0) {
            desallocate();
            return;
        }
        
        //allocate the vector
        if (n>mCapacity) {
        mSize=n;
        allocate(n);
        }
        
        //copy the vector
        if (n==0) return;
        
        const complex<T>* pf=&f[0];
        fftw_complex* vs=mValues;
        for (k=0;k<n;k++) {
            (*vs)[0]=pf->real();
            (*vs)[1]=pf->imag();
            vs++;
            pf++;
            
        }
    }
    
    void copy(const CORE_RealArray& f);
    
    void copy(const CORE_DoubleArray& f);

    
    // SET methods

    void initArray(const tReal& f);
    
    void initArray(const fftw_complex& f);
    
    
    inline void setSize(const tUIndex& n) {
        if (n>mCapacity) allocate(n); 
        mSize=n;
    }

    void fitToSize();
    
    inline void setValue(const tUIndex& index,const tDouble& x,const tDouble& y) {
        fftw_complex &c=mValues[index];
        c[0]=x;
        c[1]=y;
    }

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

    inline const fftw_complex* getValues() const {
        return mValues;
    }
    inline fftw_complex* 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]);
    }

    tReal norm2() const;
    
    inline tReal norm() const {
        return sqrt(norm2());
    }

    
    tReal distance2(const MATSGN_ComplexArray& x) const;
    
    
    inline tReal distance(const MATSGN_ComplexArray& x) const {
        return sqrt(distance2(x));
    }
    
    
    tReal fabs(tUIndex& i) const;
    
    tReal fabs(const MATSGN_ComplexArray& x,tUIndex& i) const;

    static void InPlaceTransposeWithMarker(fftw_complex* A, const tUIndex& nRows, const tUIndex& nCols);
    
    static void InPlaceTranspose(fftw_complex* A, const tUIndex& nRows, const tUIndex& nCols);
    
    virtual tString toString() const;
    
   
   
    
    
};

#endif