ClpMatrixBase.hpp

Go to the documentation of this file.

/* $Id$ */
// 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 int 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 *, 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 int transposeTimes2(const ClpSimplex *model,
    const CoinIndexedVector *pi1, CoinIndexedVector *dj1,
    const CoinIndexedVector *pi2,
    CoinIndexedVector *spare,
    double *infeas, double *reducedCost,
    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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/