/home/coin/SVN-release/CoinAll-1.1.0/Clp/src/ClpMatrixBase.hpp

Go to the documentation of this file.

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

#include "CoinPragma.hpp"

#include "CoinPackedMatrix.hpp"
class CoinIndexedVector;
class ClpSimplex;
class ClpModel;

class ClpMatrixBase  {
  
public:

  virtual CoinPackedMatrix * getPackedMatrix() const = 0;
  virtual bool isColOrdered() const = 0;
  virtual CoinBigIndex getNumElements() const = 0;
  virtual int getNumCols() const = 0;
  virtual int getNumRows() const = 0;
  
  virtual const double * getElements() const = 0;
  virtual const int * getIndices() const = 0;
  
  virtual const CoinBigIndex * getVectorStarts() const = 0;
  virtual const int * getVectorLengths() const = 0 ;
  virtual int getVectorLength(int index) const ;
  virtual void deleteCols(const int numDel, const int * indDel) = 0;
  virtual void deleteRows(const int numDel, const int * indDel) = 0;
#ifndef CLP_NO_VECTOR
  virtual void appendCols(int number, const CoinPackedVectorBase * const * columns);
  virtual void appendRows(int number, const CoinPackedVectorBase * const * rows);
#endif

  virtual void modifyCoefficient(int row, int column, double newElement,
                                 bool keepZero=false);
  virtual int appendMatrix(int number, int type,
                           const CoinBigIndex * starts, const int * index,
                           const double * element, int numberOther=-1);
  
  virtual ClpMatrixBase * reverseOrderedCopy() const {return NULL;}
  
  virtual CoinBigIndex countBasis(ClpSimplex * model,
                                 const int * whichColumn, 
                                 int numberRowBasic,
                                  int & numberColumnBasic)=0;
  virtual void fillBasis(ClpSimplex * model,
                                 const int * whichColumn, 
                                 int & numberColumnBasic,
                                 int * row, int * start,
                                 int * rowCount, int * columnCount,
                                 double * element)=0;
  virtual int scale(ClpModel * model, const ClpSimplex * baseModel=NULL) const 
  { return 1;}
  virtual void scaleRowCopy(ClpModel * model) const 
  { }
  virtual bool canGetRowCopy() const
  { return true;}
  inline virtual ClpMatrixBase * scaledColumnCopy(ClpModel * model) const 
  { return this->clone();}
  
  virtual bool allElementsInRange(ClpModel * model,
                                  double smallest, double largest,
                                  int check=15)
  { return true;}
  virtual void setDimensions(int numrows, int numcols);
  virtual void rangeOfElements(double & smallestNegative, double & largestNegative,
                               double & smallestPositive, double & largestPositive);
  
  virtual void unpack(const ClpSimplex * model,CoinIndexedVector * rowArray,
                      int column) const =0;
  virtual void unpackPacked(ClpSimplex * model,
                            CoinIndexedVector * rowArray,
                            int column) const =0;
  virtual int refresh(ClpSimplex * model)
  { return 0;}
  
  // Really scale matrix
  virtual void reallyScale(const double * rowScale, const double * columnScale);
  virtual CoinBigIndex * dubiousWeights(const ClpSimplex * model,int * inputWeights) const;
  virtual void add(const ClpSimplex * model,CoinIndexedVector * rowArray,
                   int column, double multiplier) const =0;
  virtual void add(const ClpSimplex * model,double * array,
                   int column, double multiplier) const =0;
  virtual void releasePackedMatrix() const =0;
  virtual bool canDoPartialPricing() const;
  virtual int hiddenRows() const;
  virtual void partialPricing(ClpSimplex * model, double start, double end,
                              int & bestSequence, int & numberWanted);
  virtual int extendUpdated(ClpSimplex * model,CoinIndexedVector * update,int mode);
  virtual void primalExpanded(ClpSimplex * model,int mode);
  virtual void dualExpanded(ClpSimplex * model,CoinIndexedVector * array,
                            double * other,int mode);
  virtual int generalExpanded(ClpSimplex * model,int mode,int & number);
  virtual int updatePivot(ClpSimplex * model,double oldInValue, double oldOutValue);
  virtual void createVariable(ClpSimplex * model, int & bestSequence);
  virtual int checkFeasible(ClpSimplex * model,double & sum) const ;
  double reducedCost(ClpSimplex * model,int sequence) const;
  virtual void correctSequence(const ClpSimplex * model,int & sequenceIn, int & sequenceOut) ;
  
  //---------------------------------------------------------------------------
  virtual void times(double scalar,
                     const double * x, double * y) const=0;
  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 = 0;
  virtual void transposeTimes(double scalar,
                              const double * x, double * y,
                              const double * rowScale, 
                              const double * columnScale,
                              double * spare=NULL) const;
  virtual void transposeTimes(const ClpSimplex * model, double scalar,
                              const CoinIndexedVector * x,
                              CoinIndexedVector * y,
                              CoinIndexedVector * z) const = 0;
  virtual void subsetTransposeTimes(const ClpSimplex * model,
                                    const CoinIndexedVector * x,
                                    const CoinIndexedVector * y,
                                    CoinIndexedVector * z) const = 0;
  virtual bool canCombine(const ClpSimplex * model,
                          const CoinIndexedVector * pi) const {return false;}
  virtual void transposeTimes2(const ClpSimplex * model,
                               const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
                               const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
                               CoinIndexedVector * spare,
                               double referenceIn, double devex,
                               // Array for exact devex to say what is in reference framework
                               unsigned int * reference,
                               double * weights, double scaleFactor);
  virtual void subsetTimes2(const ClpSimplex * model,
                            CoinIndexedVector * dj1,
                               const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
                               double referenceIn, double devex,
                               // Array for exact devex to say what is in reference framework
                               unsigned int * reference,
                               double * weights, double scaleFactor);
  virtual void listTransposeTimes(const ClpSimplex * model,
                                  double * x,
                                  int * y,
                                  int number,
                                  double * z) const;



  virtual ClpMatrixBase * clone() const = 0;
  virtual ClpMatrixBase * subsetClone (
                                       int numberRows, const int * whichRows,
                                       int numberColumns, const int * whichColumns) const;
  virtual void backToBasics() {}
  inline int type() const
  { return type_;}
  void setType(int type) {type_=type;}
  void useEffectiveRhs(ClpSimplex * model);
  virtual double * rhsOffset(ClpSimplex * model,bool forceRefresh=false,
                                bool check=false);
  inline int lastRefresh() const
  { return lastRefresh_;}
  inline int refreshFrequency() const
  { return refreshFrequency_;}
  inline void setRefreshFrequency(int value)
  { refreshFrequency_=value;}
  inline bool skipDualCheck() const
  { return skipDualCheck_;}
  inline void setSkipDualCheck(bool yes)
  { skipDualCheck_=yes;}
  inline int minimumObjectsScan() const
  { return minimumObjectsScan_;}
  inline void setMinimumObjectsScan(int value)
  { minimumObjectsScan_=value;}
  inline int minimumGoodReducedCosts() const
  { return minimumGoodReducedCosts_;}
  inline void setMinimumGoodReducedCosts(int value)
  { minimumGoodReducedCosts_=value;}
  inline double startFraction() const
  { return startFraction_;}
  inline void setStartFraction(double value) 
  { startFraction_ = value;}
  inline double endFraction() const
  { return endFraction_;}
  inline void setEndFraction(double value) 
  { endFraction_ = value;}
  inline double savedBestDj() const
  { return savedBestDj_;}
  inline void setSavedBestDj(double value) 
  { savedBestDj_ = value;}
  inline int originalWanted() const
  { return originalWanted_;}
  inline void setOriginalWanted(int value) 
  { originalWanted_ = value;}
  inline int currentWanted() const
  { return currentWanted_;}
  inline void setCurrentWanted(int value) 
  { currentWanted_ = value;}
  inline int savedBestSequence() const
  { return savedBestSequence_;}
  inline void setSavedBestSequence(int value) 
  { savedBestSequence_ = value;}
  
  
protected:
  
  ClpMatrixBase();
public:
  virtual ~ClpMatrixBase();
protected:
  // Copy
  ClpMatrixBase(const ClpMatrixBase&);
  // Assignment
  ClpMatrixBase& operator=(const ClpMatrixBase&);
  
  
protected:
  double * rhsOffset_;
  double startFraction_;
  double endFraction_;
  double savedBestDj_;
  int originalWanted_;
  int currentWanted_;
  int savedBestSequence_;
  int type_;
  int lastRefresh_;
  int refreshFrequency_;
  int minimumObjectsScan_;
  int minimumGoodReducedCosts_;
  int trueSequenceIn_;
  int trueSequenceOut_;
  bool skipDualCheck_;
};
// bias for free variables
#define FREE_BIAS 1.0e1
// Acceptance criteria for free variables
#define FREE_ACCEPT 1.0e2

#endif

---