LAP_DoubleBandedStorage.h

Go to the documentation of this file.

#ifndef LAP_DoubleBandedStorage_H
#define LAP_DoubleBandedStorage_H

#include "LAP_DoubleMatrixStorage.h"

DEFINE_SPTR(LAP_DoubleBandMatrix);

DEFINE_SPTR(LAP_DoubleBandedStorage);
class LAP_DoubleBandedStorage: public LAP_DoubleMatrixStorage {
    
    SP_OBJECT(LAP_DoubleBandedStorage);
    
private:
    // ATTRIBUTES
    
  
  
    //number of bands on the upper matrix, diagonal is included
    tLVectorIndex mUBandsNumber;
    //number of bands on the lower matrix, diagonal is included
    tLVectorIndex mLBandsNumber;
    //number of bands = mUBandsNumber+mLBandsNumber-1
    tLVectorIndex mBandsNumber;
    
    // ASSOCIATIONS
    // METHOD
  
  
public:
    // CONSTRUCTORS
    LAP_DoubleBandedStorage() {
      
        mUBandsNumber=0;
        mLBandsNumber=1;
        mBandsNumber=mUBandsNumber+mLBandsNumber-1;
    }
   
    // DESTRUCTORS
    virtual ~LAP_DoubleBandedStorage() {
    }

    
    
    // -------------
    // NEW METHODS
    // -------------
public:
    inline static SP::LAP_DoubleBandedStorage New() {
        SP::LAP_DoubleBandedStorage p(new LAP_DoubleBandedStorage(),
                                      LAP_DoubleBandedStorage::Delete());
        p->setThis(p);
        return p;
    };
    
    //-----------
    // OPERATORS
    // ----------
  
    virtual double& operator()(const tLVectorIndex& i,const tLVectorIndex& j) {
        //AB(Ku+i-j,j) K=mUBandsNumber-1
        return ( (j>=i+mUBandsNumber) || (j+mLBandsNumber<=i)  )? getNullValue():(*this)[mUBandsNumber-1+(i-j)+mBandsNumber*j];
    };
    
    virtual const double& operator()(const tLVectorIndex& i,const tLVectorIndex& j) const {
        return ( (j>=i+mUBandsNumber) || (j+mLBandsNumber<=i)  )? getNullValue():(*this)[mUBandsNumber-1+(i-j)+mBandsNumber*j];
    };
    
   
  
     //scalar operators
    //================
    LAP_DoubleBandedStorage& operator^=(const lapack_real&  s);
    
    LAP_DoubleBandedStorage& operator*=(const lapack_real&  s);
    LAP_DoubleBandedStorage& operator/=(const lapack_real&  s);
 
    LAP_DoubleBandedStorage& operator+=(const lapack_real&  s);
  
  
    LAP_DoubleBandedStorage& operator-=(const lapack_real&  s);
   
    
    //full matrix operator
    //===============================
   
    LAP_DoubleBandedStorage& operator*=(const LAP_DoubleBandedStorage& s);
    LAP_DoubleBandedStorage& operator/=(const LAP_DoubleBandedStorage& s);
   
    LAP_DoubleBandedStorage& operator-=(const LAP_DoubleBandedStorage& s);
    LAP_DoubleBandedStorage& operator+=(const LAP_DoubleBandedStorage& s);
  
    inline void add(const double& alpha, const LAP_DoubleBandedStorage& B) {
        add(alpha,
            B.getValuesNumber(),
            B.getUpperBandsNumber(),
            B.getLowerBandsNumber(),
            &B[0]);
    }
private:
    void add(const double& alpha,
             const tLVectorIndex& nX,
             const tLVectorIndex& ux,
             const tLVectorIndex& lx,
             const double *x);
 
    
    // ----------------
    // MATRIX SETTINGS
    // ----------------

public:
    virtual tBoolean copy(const tBoolean& isSymmetric,
                          const tBoolean& isUpper,
                          const tBoolean& isTransposed,
                          const LAP_DoubleMatrixStorage& x);
    
   
    tBoolean copyFullStorage(const tBoolean& isSymmetric,
                             const tBoolean& isUpper,
                             const tBoolean& isTransposed,
                             const tLVectorIndex& nViewedRows,
                             const tLVectorIndex& nViewedCols,
                             const tLVectorIncrement& incx,
                             const tLVectorIndex& ldx,
                             const double* x);
    tBoolean copyPackStorage(const tLVectorIndex& nX,
                             const double* x);
    
    tBoolean  copyBandStorage(const tLVectorIndex& nX,
                              const tLVectorIndex& nUBands,
                              const tLVectorIndex& nLBands,
                              const double* x);
              
    
    //dimension setting
    //=================

    inline void setUpperBandsNumber(const tLVectorIndex& n) {
        mUBandsNumber=n;
        mBandsNumber= mUBandsNumber+mLBandsNumber-1;
    }
    inline void setLowerBandsNumber(const tLVectorIndex& n) {
        mLBandsNumber=n;
        mBandsNumber= mUBandsNumber+mLBandsNumber-1;
    }
    inline const tLVectorIndex& setBandsNumber(const tLVectorIndex& u,const tLVectorIndex& l) {
        mUBandsNumber=u;
        mLBandsNumber=l;
        mBandsNumber= mUBandsNumber+mLBandsNumber-1;
        return mBandsNumber;
    }
   
    tBoolean  updateBandsNumber(const std::pair<tLVectorIndex,tLVectorIndex>& nBands);

    inline tBoolean compile() {
        return updateBandsNumber(computeBandsNumber());
    }
        

    
    //====== 
    
    pair<tLVectorIndex,tLVectorIndex> computeBandsNumber() const;
    
    inline const tLVectorIndex& getBandsNumber() const {
        return mBandsNumber;
    } 
    inline const tLVectorIndex& getUpperBandsNumber() const {
        return mUBandsNumber;
    }
    inline const tLVectorIndex& getLowerBandsNumber() const {
        return mLBandsNumber;
    }
    
   

  
    // ------------------------
    // operation on matrix
    // ------------------------
public:
    
   
      
    double max(const tFlag& d,const tLVectorIndex& index) const;
  
    void indexMin(tLVectorIndex& i,tLVectorIndex& j) const;

    virtual double trace() const;
    


public:
    virtual void addDiagonal(const double& alpha);
    
    
   

  
};
#endif