ClpMatrixBase.hpp

// 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 void deleteCols(const int numDel, const int * indDel) = 0;
    virtual void deleteRows(const int numDel, const int * indDel) = 0;
  virtual void appendCols(int number, const CoinPackedVectorBase * const * columns);
  virtual void appendRows(int number, const CoinPackedVectorBase * const * rows);

  virtual ClpMatrixBase * reverseOrderedCopy() const {return NULL;};

  // OLD - out soon
  virtual CoinBigIndex numberInBasis(const int * columnIsBasic) const = 0;
  virtual CoinBigIndex fillBasis(const ClpSimplex * model,
                                const int * columnIsBasic, int & numberBasic,
                                int * row, int * column,
                                double * element) const = 0;
  virtual CoinBigIndex fillBasis(const ClpSimplex * model,
                                 const int * whichColumn, 
                                 int numberRowBasic,
                                 int numberColumnBasic,
                                 int * row, int * column,
                                 double * element) const = 0;
  virtual int scale(ClpSimplex * model) const 
  { return 1;};

  virtual bool allElementsInRange(ClpModel * model,
                                  double smallest, double largest)
  { return true;};
  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;
  int refresh(ClpSimplex * model)
    { return 0;};
  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 releasePackedMatrix() 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=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) 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 ClpMatrixBase * clone() const = 0;
  virtual ClpMatrixBase * subsetClone (
                    int numberRows, const int * whichRows,
                    int numberColumns, const int * whichColumns) const;
 
  inline int type() const
  { return type_;};
  void setType(int type) {type_=type;};
  
  
protected:

   ClpMatrixBase();
public:
   virtual ~ClpMatrixBase();
protected:
  // Copy
   ClpMatrixBase(const ClpMatrixBase&);
  // Assignment
   ClpMatrixBase& operator=(const ClpMatrixBase&);
   
    
protected:

   int type_;
};
// bias for free variables
#define FREE_BIAS 1.0e1
// Acceptance criteria for free variables
#define FREE_ACCEPT 1.0e2

#endif

---