LAP_DoubleFullStorage.h

Go to the documentation of this file.

#ifndef LAP_DoubleFullStorage_H
#define LAP_DoubleFullStorage_H

#include "LAP_DoubleMatrixStorage.h"

#include "LAP_Matrix.h"
#include "LAP_DoubleVector.h"
#include "LAP_ConstDoubleVector.h"


#include "LAP_2DView.h"

class LAP_DoublePackedStorage;

DEFINE_SPTR(LAP_DoubleFullStorage);

class LAP_DoubleFullStorage: public LAP_DoubleMatrixStorage  {
    
    SP_OBJECT(LAP_DoubleFullStorage);

    
    
    // ATTRIBUTES
public:
    
private:
    
    //the size of rows
    tLVectorIndex mRowSize;
    
    // ASSOCIATIONS
    LAP_2DView mView;


    
    // METHOD
  
  
public:
    // CONSTRUCTORS
    LAP_DoubleFullStorage() {
        mRowSize=0;
    }
   
    // DESTRUCTORS
    virtual ~LAP_DoubleFullStorage() {
    }

    
    
    // -------------
    // NEW METHODS
    // -------------
public:

    inline static SP::LAP_DoubleFullStorage New() {
        SP::LAP_DoubleFullStorage p(new LAP_DoubleFullStorage(),
                                    LAP_DoubleFullStorage::Delete());
        p->setThis(p);
        return p;
    };
    
    //-----------
    // OPERATORS
    // ----------
    virtual double& operator()(const tLVectorIndex& i,const tLVectorIndex& j) {
        return (*this)[mRowSize*getViewIndex(LAP_Matrix::COL,j)+getViewIndex(LAP_Matrix::ROW,i)];
    };
    
    virtual const double& operator()(const tLVectorIndex& i,const tLVectorIndex& j) const {
        return (*this)[mRowSize*getViewIndex(LAP_Matrix::COL,j)+getViewIndex(LAP_Matrix::ROW,i)];
    };
 
    //scalar operators
    //================
    LAP_DoubleFullStorage& operator*=(const double& s);
    LAP_DoubleFullStorage& operator/=(const double& s);
    LAP_DoubleFullStorage& operator+=(const double& s);
    LAP_DoubleFullStorage& operator-=(const double& s);
    LAP_DoubleFullStorage& operator^=(const double& s);

    //full matrix operator
    //====================
    
    LAP_DoubleFullStorage& operator*=(const LAP_DoubleFullStorage& s);

    LAP_DoubleFullStorage& operator/=(const LAP_DoubleFullStorage& s);
    LAP_DoubleFullStorage& operator+=(const LAP_DoubleFullStorage& s);
    LAP_DoubleFullStorage& operator-=(const LAP_DoubleFullStorage& s);
    
     
 
    
    // ----------------
    // 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 tLVectorIndex &nViewedRows,
                             const tLVectorIndex &nViewedCols,
                             const tLVectorIncrement& incx,
                             const tLVectorIndex &ldx,
                             const double * x);
    tBoolean copyPackStorage(const tBoolean& isSymmetric,
                             const tBoolean& isUpper,
                             const tLVectorIndex &nX,
                             const double * x);
    
    tBoolean copyBandStorage(const tBoolean& isSymmetric,
                             const tBoolean& isUpper,
                             const tLVectorIndex &nX,
                             const tLVectorIndex &nUpperBands,
                             const tLVectorIndex &nLowerBands,
                             const double * x);
    

    //set the values from vectors
    //===========================
    
public:
    virtual void setValuesPointer(SP::LAP_DoubleVector v) {
        mRowSize=(tLVectorIndex) (sqrt(v->getSize())+0.5);
        LAP_DoubleMatrixStorage::setValuesPointer(v);
        resetView();
    }
   
    virtual void setValuesPointer(const tLVectorIndex& rowSize,SP::LAP_DoubleVector v) {
        mRowSize=rowSize;
        LAP_DoubleMatrixStorage::setValuesPointer(v);
        resetView();
    }
    virtual void setValues(const tLVectorIndex& n,
                           const double* values) {
        mRowSize=(tLVectorIndex) (sqrt(n)+0.5);
        LAP_DoubleMatrixStorage::setValues(n,values);
        resetView();
    }
    virtual void setValues(const tLVectorIndex& rowSize,
                           const tLVectorIndex& n,
                           const double* values) {
        mRowSize=rowSize;
        LAP_DoubleMatrixStorage::setValues(n,values);
        resetView();
    }
    
    virtual void setValuesNumber(const tLVectorIndex& nRows,const tLVectorIndex& n) {
        mRowSize=nRows;
        LAP_DoubleMatrixStorage::setValuesNumber(n);
        resetView();
    };
     
    virtual void setValuesNumber(const tLVectorIndex& n) {
        mRowSize=(tLVectorIndex) (sqrt(n)+0.5);
        LAP_DoubleMatrixStorage::setValuesNumber(n);
        resetView();
    };
    
   

    // view setting
    // =============
    inline tBoolean setView(const tFlag& k,
                            const tLVectorIndex& start,
                            const tLVectorIndex& end,
                            const tLVectorIndex& increment) {
        tLVectorIndex s=mRowSize;
        if (k!=0) s=getValuesNumber()/mRowSize;
        
        if (increment==0) return false;
        if (end<start) return false;
        if (end-increment>s) return false; 
        mView[k].setView(start,end,increment);
        return true;
    };
    
    inline void resetView() {
        mView.setView(LAP_Matrix::ROW,0,mRowSize,1);
        mView.setView(LAP_Matrix::COL,0,getValuesNumber()/mRowSize,1);
    };
    // view getting
    // =============
    inline  tLVectorIndex getViewSize(const tFlag& d) const {
        return mView.getSize(d);
    };
    inline  const tLVectorIncrement& getIncrement(const tFlag& d) const {
        return mView.getIncrement(d);
    };
    inline const tLVectorIndex& getStart(const tFlag& d) const {
        return mView.getStart(d);
    };
    inline tLVectorIndex getViewIndex(const tLVectorIndex& k,const tLVectorIndex& i) const {
        return (mView[k].getStart()+i*mView[k].getIncrement());
    }
    
    virtual tLVectorIndex getViewedRowsNumber() const {
        return getViewSize(LAP_Matrix::ROW);
    };
    virtual tLVectorIndex getViewedColumnsNumber() const {
        return getViewSize(LAP_Matrix::COL);
    };

    tLVectorIndex getLeadingDimension() const {
        return mRowSize*getIncrement(LAP_Matrix::COL);
    }
    const tLVectorIncrement& getRowIncrement() const {
        return getIncrement(LAP_Matrix::ROW);
    }
    
    inline tBoolean isSubmatrixView() const {
        return 
            (mView[LAP_Matrix::ROW].getStart()!=0) ||
            (mView[LAP_Matrix::ROW].getEnd()!=mRowSize) ||
            (mView[LAP_Matrix::COL].getStart()!=0) ||
            (mView[LAP_Matrix::COL].getEnd()!=getValuesNumber()/mRowSize);
        
    };
    
    
    //values getting
    // =============

    
    inline tLVectorIndex getRowSize() const {
        return mRowSize;
    }


    virtual void addDiagonal(const double& alpha);

    virtual double trace() const;
    
    virtual void getRowByReference(const tLVectorIndex& i,LAP_DoubleVector& v);
    virtual void getRowByReference(const tLVectorIndex& i,LAP_ConstDoubleVector& v) const;
   
    virtual void getColumnByReference(const tLVectorIndex& j,LAP_DoubleVector& v);
    virtual void getColumnByReference(const tLVectorIndex& j,LAP_ConstDoubleVector& v) const;
    void removeColumn(const tLVectorIndex& j);

    void reverseColumns();
    void swapColumns(const tLVectorIndex& i,const tLVectorIndex& j);
    
    // Merging methods
    // ===============

    inline void concat(const double& alpha,const LAP_DoubleFullStorage& X,
                       const double& beta, const LAP_DoubleFullStorage& Y) {
        
        getValues().merge(alpha,X.getValues(),beta,Y.getValues());   
    }
    
    
    // ------------------------
    // operation on matrix
    // ------------------------
public:
  
    /* \brief compute the bands number
     * @param eps:absolute module to detect null value
     * @return a pair whose firest element is the number of upper bands and the second the lower bands number
     */
    virtual pair<tLVectorIndex,tLVectorIndex> computeBandsNumber() const;
    /* \brief compute the bands number
     * @param eps:absolute module to detect null value
     * @return a pair whose firest element is the number of upper bands and the second the lower bands number
     */
    static  pair<tLVectorIndex,tLVectorIndex> computeBandsNumber(const tBoolean& isUpper,
                                                               const tLVectorIndex& nRows,
                                                               const tLVectorIndex& nCols,
                                                               const tLVectorIncrement& inc,
                                                               const tLVectorIndex& ldx,
                                                               const double* x,
                                                               const tReal& eps);
   

    //operator with packed storage
    //============================
    LAP_DoubleFullStorage& multiplyBy(const tBoolean& isPackedSymmetric,const LAP_DoublePackedStorage& s);

    LAP_DoubleFullStorage& divideBy(const tBoolean& isPackedSymmetric,const LAP_DoublePackedStorage& s);
    LAP_DoubleFullStorage& add(const tBoolean& isPackedSymmetric,const LAP_DoublePackedStorage& s);
    LAP_DoubleFullStorage& sub(const tBoolean& isPackedSymmetric,const LAP_DoublePackedStorage& s);
    
   
   
};
#endif