LAP_DoubleVector.h

Go to the documentation of this file.

#ifndef LAP_DoubleVector_H
#define LAP_DoubleVector_H

#include "LAP_Vector.h"
#include "CORE_ListPointers.h"

#include "dvector_functions.h"

#include "LAP_ConstDoubleVector.h"

DEFINE_SPTR(LAP_DoubleVector);
DEFINE_SVPTR(LAP_DoubleVector);
class LAP_DoubleVector: public LAP_Vector<lapack_real> {
    
    SP_OBJECT(LAP_DoubleVector);
    
private:
    // ATTRIBUTES
   
    
    // ASSOCIATIONS
  
    // METHODS
  
  
public:
    // CONSTRUCTORS
    LAP_DoubleVector();
    LAP_DoubleVector(const tLVectorIndex& s);
    LAP_DoubleVector(const LAP_DoubleVector& s); 
  
  
    // DESTRUCTORS
    virtual ~LAP_DoubleVector();

public:
    
    
    // -------------
    // NEW METHODS
    // -------------
public:
    inline static SP::LAP_DoubleVector New() {
        SP::LAP_DoubleVector p(new LAP_DoubleVector(),
                               LAP_DoubleVector::Delete());
        p->setThis(p);
        return p;
    };
    inline static SP::LAP_DoubleVector New(const tLVectorIndex& s) {
        SP::LAP_DoubleVector p(new LAP_DoubleVector(s),
                               LAP_DoubleVector::Delete());
        p->setThis(p);
        return p;
    };
   
    inline static SP::LAP_DoubleVector New(const LAP_DoubleVector& s) {
        SP::LAP_DoubleVector p(new LAP_DoubleVector(s),
                               LAP_DoubleVector::Delete());
        p->setThis(p);
        return p;
    };
    inline static SP::LAP_DoubleVector New(SPC::LAP_DoubleVector s) {
        if (s.get()!=null) {
            SP::LAP_DoubleVector p(new LAP_DoubleVector(*s.get()),
                                   LAP_DoubleVector::Delete());
            p->setThis(p);
            return p;
        } else
            return New();
    };

  
    inline static SP::LAP_DoubleVector New(const vector<lapack_real>& vs) {
        SP::LAP_DoubleVector p=New();
        p.get()->copy(vs);
        return p;
    };
    
    
    //copy operators 
    // ============
    inline LAP_DoubleVector& operator=(const lapack_real& s)  {
      init(s);
      return (*this);
    };
    
    inline LAP_DoubleVector& operator=(const vector<lapack_real>& s)  {
      LAP_Vector<lapack_real>::copy(s);
      return (*this);
    };

    inline LAP_DoubleVector& operator=(const LAP_DoubleVector& s)  {
        copy(s);
        return (*this);
    };
    inline LAP_DoubleVector& operator=(const LAP_ConstDoubleVector& s)  {
        copy(s);
        return (*this);
    };


    //accessor methods
    //==================
    virtual tLVectorIndex getNullValuesNumber(const tReal& eps) const {
        tLVectorIndex n=0;
        tLVectorIndex i,nvs=getCapacity();
        const double *vs=&(*this)[0];
        for (i=nvs-1;i>0;i--) n+=(fabs(vs[i])<eps);
        if (nvs>0) n+=(fabs(vs[i])<eps);
        return n;
    }
    
    //computation operators
    //=====================
    inline LAP_DoubleVector& operator+=(const double&  s)  {
      LAP_Vector<double>::add(s);
      return(*this);
    }
    
    inline LAP_DoubleVector& operator-=(const double&  s)  {
      sub(s);
      return (*this);
    };
    
    inline LAP_DoubleVector& operator^=(const double&  s)  {
      power(s);
      return (*this);
    };
    inline LAP_DoubleVector& operator/=(const LAP_DoubleVector&  s)  {
      divideBy(s);
      return (*this);
    };
    inline LAP_DoubleVector& operator*=(const LAP_DoubleVector&  s)  {
      multiplyBy(s);
      return (*this);
    };
    
    
    //BLAS operators
    //==============
    
    inline LAP_DoubleVector& operator*=(const lapack_real&  s)  {
        scale(s);
        return (*this);
    };
    inline LAP_DoubleVector& operator/=(const lapack_real&  s)  {
        scale(1./s);
        return (*this);
    };
    
    inline LAP_DoubleVector& operator+=(const LAP_Vector<lapack_real>&  s)  {
        add(1,s);
        return (*this);
    };
    inline LAP_DoubleVector& operator-=(const LAP_Vector<lapack_real>&  s)  {
        add(-1,s);
        return (*this);
    };

    // copy methods
    // ============
    
    void copy(const LAP_Vector<lapack_real>& v) {
        setSize(v.getSize());
        DoubleVectorCopy(v.getSize(),v.getIncrement(),&v(0),getIncrement(),&(*this)(0));
    }

    void copy(const LAP_ConstVector<lapack_real>& v) {
        setSize(v.getSize());
        DoubleVectorCopy(v.getSize(),v.getIncrement(),&v(0),getIncrement(),&(*this)(0));
    }

    virtual void copy(const vector<lapack_real>& vs) {
      LAP_Vector<lapack_real>::copy(vs);
    }

   
    // ----------------
    // scalar product
    // ----------------
  
    
    inline double product(const LAP_DoubleVector& v)  const {
      
      if (getSize() != v.getSize())
        throw LAP_Exception("math/linalg/core","LAD_DoubleVector::product","incompatible dimension of vectors");
      
      //call lapack function
      return DoubleVectorDot(v.getSize(),
                             v.getIncrement(),&v(0),
                             getIncrement(),&(*this)(0)); 
    }
    
    inline static double product(const LAP_DoubleVector& v,
                                 const LAP_DoubleVector& w) {
      return v.product(w);
    }


    // --------------
    // add operators
    // ---------------
    
    inline void add(const lapack_real& alpha,
                    const LAP_Vector<lapack_real>& x) {
      
      if (getSize() != x.getSize())
        throw LAP_Exception("math/linalg/core","LAP_DoubleVector::add","incompatible dimension of vector");
      
      DoubleVectorAdd(x.getSize(),
                      x.getIncrement(),&x(0),
                      alpha,
                      getIncrement(),&(*this)(0));
    }
    
    inline void add(const lapack_real& alpha,
                    const tLVectorIndex n,
                    const lapack_real* x) {
      
      
        DoubleVectorAdd(n,1,x,
                        alpha,
                        getIncrement(),&(*this)(0));
    }
    
    virtual void add(const tLVectorIndex& i,const lapack_real& v) {
        LAP_Vector<lapack_real>::add(i,v);
    }

    // ------------------
    // multiply operators
    // -------------------
    
    inline void scale(const lapack_real& alpha) {
      DoubleVectorScale(getSize(),getIncrement(),&(*this)(0),alpha);
    }
    
   
   
    // ---------------------
    // geometric operators
    // --------------------
    
    static void rotate(LAP_DoubleVector& dx,LAP_DoubleVector& dy,const lapack_real& c,const lapack_real& s);
    static inline void buildRotation(lapack_real& dx,lapack_real& dy,lapack_real& c,lapack_real& s) {
      DoubleVectorRotationPlane(dx,dy,c,s);
    }

    // ----------------
    // swap operators
    // ----------------
    
    inline static void swap(LAP_DoubleVector& x,LAP_DoubleVector& y) {
        lapack_int n=x.getSize();
        ASSERT_IN((tLVectorIndex) n == y.getSize());
        if ((tLVectorIndex) n != y.getSize()) throw LAP_Exception("math/linalg/core","LAP_DoubleVector::swap","incompatible size of vectors");

        lapack_int incx =x.getIncrement();
        lapack_int incy =y.getIncrement();
        DoubleVectorSwap(n,incx,&x(0),incy,&y(0));
    }
   


    // -----------------
    //  scalar operators
    // -----------------
    inline tLVectorIndex indexMax() const {
      return DoubleVectorIndexMax(getSize(),getIncrement(),&(*this)(0));
    }
    

    double maxValue(tLVectorIndex& i) const {
        return LAP_Vector<lapack_real>::maxValue(i);
    }
    double minValue(tLVectorIndex& i) const {
        return LAP_Vector<lapack_real>::minValue(i);
    }
    
    inline double norm1() const{
      return DoubleVectorNorm1(getSize(),getIncrement(),&(*this)(0));
    }
    
    inline double norm2() const{
      return DoubleVectorNorm2(getSize(),getIncrement(),&(*this)(0));
    };
    
    double sum() const {
        return LAP_Vector<lapack_real>::sum();
    }
    
    inline double normInf() const {
      return fabs((*this)(indexMax()));
    };

    double distance2(const LAP_DoubleVector& b) const {
        return  LAP_Vector<lapack_real>::distance2(*this,b);
    }
    inline double distance2(SPC::LAP_DoubleVector b) const {
        if (b.get()!=null) return distance2(*b.get());
        return 0;
    };

public:

    virtual tString toString() const;
    
};
#endif