ClpPackedMatrix.hpp

// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef ClpPackedMatrix_H
#define ClpPackedMatrix_H


#include "CoinPragma.hpp"

#include "ClpMatrixBase.hpp"

class ClpPackedMatrix : public ClpMatrixBase {
  
public:

  virtual CoinPackedMatrix * getPackedMatrix() const { return matrix_;};
    virtual bool isColOrdered() const { return matrix_->isColOrdered(); }
  virtual  CoinBigIndex getNumElements() const 
  { return matrix_->getNumElements(); }
   virtual int getNumCols() const { return matrix_->getNumCols(); }
  virtual int getNumRows() const { return matrix_->getNumRows(); };

   virtual const double * getElements() const 
  { return matrix_->getElements();};
   virtual const int * getIndices() const 
  { return matrix_->getIndices();};

   virtual const CoinBigIndex * getVectorStarts() const 
  { return matrix_->getVectorStarts();};
   virtual const int * getVectorLengths() const 
  { return matrix_->getVectorLengths();} ;

    virtual void deleteCols(const int numDel, const int * indDel)
  { matrix_->deleteCols(numDel,indDel);};
    virtual void deleteRows(const int numDel, const int * indDel)
  { matrix_->deleteRows(numDel,indDel);};
  virtual void appendCols(int number, const CoinPackedVectorBase * const * columns)
  { matrix_->appendCols(number,columns);};
  virtual void appendRows(int number, const CoinPackedVectorBase * const * rows)
  { matrix_->appendRows(number,rows);};
  void replaceVector(const int index,
                       const int numReplace, const double * newElements)
      {matrix_->replaceVector(index,numReplace,newElements);};
  virtual ClpMatrixBase * reverseOrderedCopy() const;
  virtual CoinBigIndex numberInBasis(const int * columnIsBasic) const ;
  virtual CoinBigIndex fillBasis(const ClpSimplex * model,
                                const int * columnIsBasic, int & numberBasic,
                                int * row, int * column,
                                double * element) const ;
  virtual CoinBigIndex fillBasis(const ClpSimplex * model,
                                 const int * whichColumn, 
                                 int numberRowBasic,
                                 int numberColumnBasic,
                                 int * row, int * column,
                                 double * element) const ;
  virtual int scale(ClpSimplex * model) const ;
  virtual bool allElementsInRange(ClpModel * model,
                                  double smallest, double largest);
  virtual void rangeOfElements(double & smallestNegative, double & largestNegative,
                       double & smallestPositive, double & largestPositive);

  virtual void unpack(const ClpSimplex * model,CoinIndexedVector * rowArray,
                   int column) const ;
  virtual void unpackPacked(ClpSimplex * model,
                            CoinIndexedVector * rowArray,
                            int column) const;
  virtual void add(const ClpSimplex * model,CoinIndexedVector * rowArray,
                   int column, double multiplier) const ;
   virtual void releasePackedMatrix() const { };
  virtual CoinBigIndex * dubiousWeights(const ClpSimplex * model,int * inputWeights) const;
  virtual bool canDoPartialPricing() const;
  virtual void partialPricing(ClpSimplex * model, int start, int end,
                      int & bestSequence, int & numberWanted);

  virtual void times(double scalar,
                       const double * x, double * y) const;
  virtual void times(double scalar,
                     const double * x, double * y,
                     const double * rowScale, 
                     const double * columnScale) const;
    virtual void transposeTimes(double scalar,
                                const double * x, double * y) const;
    virtual void transposeTimes(double scalar,
                                const double * x, double * y,
                                const double * rowScale, 
                                const double * columnScale) const;
  virtual void transposeTimes(const ClpSimplex * model, double scalar,
                              const CoinIndexedVector * x,
                              CoinIndexedVector * y,
                              CoinIndexedVector * z) const;
  virtual void transposeTimesByRow(const ClpSimplex * model, double scalar,
                              const CoinIndexedVector * x,
                              CoinIndexedVector * y,
                              CoinIndexedVector * z) const;
  virtual void subsetTransposeTimes(const ClpSimplex * model,
                                    const CoinIndexedVector * x,
                                    const CoinIndexedVector * y,
                                    CoinIndexedVector * z) const;


  inline CoinPackedMatrix * matrix() const { return matrix_;};


   ClpPackedMatrix();
   virtual ~ClpPackedMatrix();

   ClpPackedMatrix(const ClpPackedMatrix&);
   ClpPackedMatrix(const CoinPackedMatrix&);
  ClpPackedMatrix (const ClpPackedMatrix & wholeModel,
                    int numberRows, const int * whichRows,
                    int numberColumns, const int * whichColumns);
  ClpPackedMatrix (const CoinPackedMatrix & wholeModel,
                    int numberRows, const int * whichRows,
                    int numberColumns, const int * whichColumns);

   ClpPackedMatrix(CoinPackedMatrix * matrix);

   ClpPackedMatrix& operator=(const ClpPackedMatrix&);
  virtual ClpMatrixBase * clone() const ;
  virtual ClpMatrixBase * subsetClone (
                    int numberRows, const int * whichRows,
                    int numberColumns, const int * whichColumns) const ;
   
    
protected:

  CoinPackedMatrix * matrix_;
  bool zeroElements_;
};

#endif

---