LAP_IntegerVector.h

Go to the documentation of this file.

#ifndef LAP_IntegerVector_H
#define LAP_IntegerVector_H

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


DEFINE_SPTR(LAP_IntegerVector);
DEFINE_SVPTR(LAP_IntegerVector);

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

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

    //copy operators
    //===============
    inline LAP_IntegerVector& operator=(const lapack_int& s)  {
      init(s);
      return (*this);
    };
    
    inline LAP_IntegerVector& operator=(const vector<lapack_int>& s)  {
      LAP_Vector<lapack_int>::copy(s);
      return (*this);
    };

    inline LAP_IntegerVector& operator=(const LAP_IntegerVector& s)  {
        copy(s);
        return (*this);
    };
    //accessor methods
    //==================
    
    virtual tLVectorIndex getNullValuesNumber(const tReal& eps) const {
        tLVectorIndex n=0;
        tLVectorIndex i,nvs=getCapacity();
        const lapack_int *vs=&(*this)[0];
        for (i=nvs-1;i>0;i--) n+=(vs[i]==0);
        if (nvs>0) n+=(vs[i]==0);
        return n;
    }
     //computation operators
    //=====================
    inline LAP_IntegerVector& operator+=(const lapack_int&  s)  {
      LAP_Vector<lapack_int>::add(s);
      return(*this);
    }
    
    inline LAP_IntegerVector& operator-=(const lapack_int&  s)  {
      sub(s);
      return (*this);
    };
    
    inline LAP_IntegerVector& operator^=(const lapack_int&  s)  {
      power(s);
      return (*this);
    };
    inline LAP_IntegerVector& operator/=(const lapack_int&  s)  {
      tLVectorIndex n=getSize();
      for (tLVectorIndex i=0;i<n;i++) (*this)(i)/=s;
      return (*this);
    };
    inline LAP_IntegerVector& operator*=(const LAP_IntegerVector&  s)  {
      multiplyBy(s);
      return (*this);
    };
    inline LAP_IntegerVector& operator*=(const lapack_int&  s)  {
        tLVectorIndex n=getSize();
        for (tLVectorIndex i=0;i<n;i++) (*this)(i)*=s;
        return (*this);
    };
   
  
    
    //SET methods
    //============
    
    void copy(const LAP_IntegerVector& v);
    
  

    void add(const lapack_real& alpha,const LAP_IntegerVector& x);
    
    virtual void add(const tLVectorIndex& i,const lapack_int& v) {
      LAP_Vector<lapack_int>::add(i,v);
    };

   
    tLVectorIndex indexMax() const;
   
    
  
};
#endif