LAP_DoublePackedStorage.h

Go to the documentation of this file.

#ifndef LAP_DoublePackedStorage_H
#define LAP_DoublePackedStorage_H


#include "LAP_DoubleMatrixStorage.h"


class LAP_DoubleFullStorage;

DEFINE_SPTR(LAP_DoublePackedStorage);

DEFINE_SPTR(LAP_DoublePackedStorage);

class LAP_DoublePackedStorage: public  LAP_DoubleMatrixStorage {
    
    SP_OBJECT(LAP_DoublePackedStorage);
    
private:
    // ATTRIBUTES
    
   
  
    // ASSOCIATIONS
  
    // METHOD
  
  
public:
    // CONSTRUCTORS
    LAP_DoublePackedStorage() {
    }
    
   
  
    // DESTRUCTORS
    virtual ~LAP_DoublePackedStorage() {
    }
    
 


     
    // -------------
    // NEW METHODS
    // -------------
public:
    inline static SP::LAP_DoublePackedStorage New() {
        SP::LAP_DoublePackedStorage p(new LAP_DoublePackedStorage(),
                                      LAP_DoublePackedStorage::Delete());
        p->setThis(p);
        return p;
    };
    
    //-----------
    // OPERATORS
    // ----------
    
    
public:
    //accessor operators
    //===================
    
    virtual double& operator()(const tLVectorIndex& i,const tLVectorIndex& j) {
        return (*this)[i+(j*(j+1)/2)];
    };
    
    virtual const double& operator()(const tLVectorIndex& i,const tLVectorIndex& j) const {
        return (*this)[i+(j*(j+1)/2)];
    };
    
    
    //scalar operators
    //================
    
    LAP_DoublePackedStorage& operator^=(const lapack_real&  s);
    
    LAP_DoublePackedStorage& operator*=(const lapack_real&  s);
    LAP_DoublePackedStorage& operator/=(const lapack_real&  s);
 
    LAP_DoublePackedStorage& operator+=(const lapack_real&  s);
  
  
    LAP_DoublePackedStorage& operator-=(const lapack_real&  s);
    
    //pack matrix operator
    //=====================
   
    LAP_DoublePackedStorage& operator*=(const LAP_DoublePackedStorage& s);
    LAP_DoublePackedStorage& operator/=(const LAP_DoublePackedStorage& s);
   
    LAP_DoublePackedStorage& operator-=(const LAP_DoublePackedStorage& s);
    LAP_DoublePackedStorage& operator+=(const LAP_DoublePackedStorage& s);

    LAP_DoublePackedStorage& operator*=(const LAP_DoubleFullStorage& s);
    LAP_DoublePackedStorage& operator/=(const LAP_DoubleFullStorage& s);
   
    LAP_DoublePackedStorage& operator-=(const LAP_DoubleFullStorage& s);
    LAP_DoublePackedStorage& operator+=(const LAP_DoubleFullStorage& s);


    // copy methods from different storage arrays
    // ===========================================

    
    virtual tBoolean copy(const tBoolean& isSymmetric,
                          const tBoolean& isUpper,
                          const tBoolean& isTransposed,
                          const LAP_DoubleMatrixStorage& x);
    
    tBoolean copyFullStorage(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 &nUpperBands,
                              const tLVectorIndex &nLowerBands,
                              const double * x);


    //allocation methods
    //==================

    
    
   
   
    // Values setting
    // ===============
    
   
    
   
    
    //values getting
    // =============

public:
   
    inline tLVectorIndex getDimension() const {
        return (tLVectorIndex) ((sqrt(1+8*getValuesNumber())-1)/2+0.5);
    }
    // ------------------------
    // operations on matrix
    // ------------------------
public:
   
    virtual double trace() const;
    
    virtual void addDiagonal(const double& alpha);
    
    
    void add(const double& alpha, const LAP_DoublePackedStorage& B);
    
   
    /* \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 std::pair<tLVectorIndex,tLVectorIndex> computeBandsNumber() const {
        return computeBandsNumber(getValuesNumber(),&(*this)(0,0),ZERO_EPSILON);
    }
    /* \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 std::pair<tLVectorIndex,tLVectorIndex> computeBandsNumber(const tLVectorIndex& nX,const double* x,const tReal& eps) ;
    

    tReal max(const tFlag& d,const tLVectorIndex& index) const;
  
    void indexMin(tLVectorIndex& i,tLVectorIndex& j) const;


    
    
};
#endif