MATH_ArrayVector.h

Go to the documentation of this file.

#ifndef MATH_ArrayVector_H
#define MATH_ArrayVector_H

#include "MATH_Vector.h"

#include "CORE_Array.h"


DEFINE_SPTR(MATH_ArrayVector);

class MATH_ArrayVector : public MATH_Vector {
    SP_OBJECT(MATH_ArrayVector);

private:
    
    CORE_RealArray mArray;
    
public:
    MATH_ArrayVector(void) {
        
    }
    
    
    
    // DESTRUCTORS 
    
  
    virtual ~MATH_ArrayVector(void) {
    }

public:
    inline static SP::MATH_ArrayVector New() {
        SP::MATH_ArrayVector p(new MATH_ArrayVector(),MATH_ArrayVector::Delete());
        p->setThis(p);
        return p;
    }
    virtual SP::MATH_Vector NewInstance() const  {
        return New();
    }



    //operators
    //==========
    inline MATH_ArrayVector& operator=(const MATH_Vector& v) {
        copy(v);
        return *this;
    }
    inline MATH_ArrayVector& operator=(const tReal&  v) {
        init(v);
        return *this;
    }
   inline MATH_ArrayVector& operator+=(const MATH_Vector&  v) {
        add(v);
        return *this;
    }

    inline MATH_ArrayVector& operator*=(const tReal&  v) {
        dot(v);
        return *this;
    }
    
    virtual tReal& operator[](const tUIndex& i) {
        return mArray[i];
       
    }
    virtual const tReal& operator[](const tUIndex& i) const {
        return mArray[i];
    }
    
  
   
   
    //SET Methods
    //===========
    /* \brief copy method
     * @param c: vector to copy
     */
    virtual void copy(const MATH_Vector& v) {
        const MATH_ArrayVector* av=dynamic_cast<const MATH_ArrayVector* >(&v);
        if (av!=null) {
            mArray.copy(av->getArray());
            
        }
        MATH_Vector::copy(v);
    }
    
    virtual void setSize(const tUIndex& n) {
        mArray.setSize(n);
    }
    virtual void setCapacity(const tUIndex& n) {
        mArray.setSize(n);
    }

    virtual void setValuesByReference(const tUIndex& n,tReal *Vs ) {
        mArray.setValuesByReference(n,Vs);
    }
    virtual void setValues(const tUIndex& n,tReal *Vs ) {
        mArray.setValues(n,Vs);
    }

    //GET Methods
    //===========
    virtual tULLInt getMemorySize() const {
        return mArray.getMemorySize()+MATH_Vector::getMemorySize();
    }
    inline const CORE_RealArray& getArray() const {
        return mArray;
    }
    inline CORE_RealArray& getArray()  {
        return mArray;
    }
    
    virtual const tReal* getValues() const {
        return &mArray[0];
    } 
    virtual tReal* getValues() {
        return &mArray[0];
    }

    virtual tUIndex getSize() const {
        return mArray.getSize();
    }
    virtual tUIndex getCapacity() const {
        return mArray.getSize();
    }


    //to string
    virtual tString toString() const {
        return "size:"+CORE_Integer::toString(mArray.getSize())+":"+mArray.toString();
    }
  
    
    
  

    
};
#endif