ClpMatrixBase.hpp

Go to the documentation of this file.

/* $Id: ClpMatrixBase.hpp 2078 2015-01-05 12:39:49Z forrest $ */
// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef ClpMatrixBase_H
#define ClpMatrixBase_H

#include "CoinPragma.hpp"
#include "CoinTypes.hpp"

#include "CoinPackedMatrix.hpp"
class CoinIndexedVector;
class ClpSimplex;
class ClpModel;
// Compilers can produce better code if they know about __restrict
#ifndef COIN_RESTRICT
#ifdef COIN_USE_RESTRICT
#define COIN_RESTRICT __restrict
#else
#define COIN_RESTRICT
#endif
#endif

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(const int * whichColumn,
                                     int & numberColumnBasic) = 0;
     virtual void fillBasis(ClpSimplex * model,
                            const int * whichColumn,
                            int & numberColumnBasic,
                            int * row, int * start,
                            int * rowCount, int * columnCount,
                            CoinFactorizationDouble * element) = 0;
     virtual int scale(ClpModel * , const ClpSimplex * = NULL) const {
          return 1;
     }
     virtual void scaleRowCopy(ClpModel * ) const { }
     virtual bool canGetRowCopy() const {
          return true;
     }
     inline virtual ClpMatrixBase * scaledColumnCopy(ClpModel * ) const {
          return this->clone();
     }

     virtual bool allElementsInRange(ClpModel * ,
                                     double , double ,
                                     int = 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 * ) {
          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 * COIN_RESTRICT x, double * COIN_RESTRICT y) const = 0;
     virtual void times(double scalar,
                        const double * COIN_RESTRICT x, double * COIN_RESTRICT y,
                        const double * COIN_RESTRICT rowScale,
                        const double * COIN_RESTRICT columnScale) const;
     virtual void transposeTimes(double scalar,
                                 const double * COIN_RESTRICT x, double * COIN_RESTRICT y) const = 0;
     virtual void transposeTimes(double scalar,
                                 const double * COIN_RESTRICT x, double * COIN_RESTRICT y,
                                 const double * COIN_RESTRICT rowScale,
                                 const double * COIN_RESTRICT columnScale,
                                 double * COIN_RESTRICT spare = NULL) const;
#if COIN_LONG_WORK
     // For long double versions (aborts if not supported)
     virtual void times(CoinWorkDouble scalar,
                        const CoinWorkDouble * COIN_RESTRICT x, CoinWorkDouble * COIN_RESTRICT y) const ;
     virtual void transposeTimes(CoinWorkDouble scalar,
                                 const CoinWorkDouble * COIN_RESTRICT x, CoinWorkDouble * COIN_RESTRICT y) const ;
#endif

     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 * ,
                             const CoinIndexedVector * ) const {
          return false;
     }
     virtual void transposeTimes2(const ClpSimplex * model,
                                  const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
                                  const CoinIndexedVector * pi2,
                                  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 newtype) {
          type_ = newtype;
     }
     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