CoinSnapshot.hpp

Go to the documentation of this file.

/* $Id$ */
// Copyright (C) 2006, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef CoinSnapshot_H
#define CoinSnapshot_H
 
class CoinPackedMatrix;
#include "CoinTypes.hpp"
 
//#############################################################################
 
class CoinSnapshot {
 
public:
  //---------------------------------------------------------------------------
  inline int getNumCols() const
  {
    return numCols_;
  }
 
  inline int getNumRows() const
  {
    return numRows_;
  }
 
  inline int getNumElements() const
  {
    return numElements_;
  }
 
  inline int getNumIntegers() const
  {
    return numIntegers_;
  }
 
  inline const double *getColLower() const
  {
    return colLower_;
  }
 
  inline const double *getColUpper() const
  {
    return colUpper_;
  }
 
  inline const double *getRowLower() const
  {
    return rowLower_;
  }
 
  inline const double *getRowUpper() const
  {
    return rowUpper_;
  }
 
  inline const double *getRightHandSide() const
  {
    return rightHandSide_;
  }
 
  inline const double *getObjCoefficients() const
  {
    return objCoefficients_;
  }
 
  inline double getObjSense() const
  {
    return objSense_;
  }
 
  inline bool isContinuous(int colIndex) const
  {
    return colType_[colIndex] == 'C';
  }
 
  inline bool isBinary(int colIndex) const
  {
    return colType_[colIndex] == 'B';
  }
 
  inline bool isInteger(int colIndex) const
  {
    return colType_[colIndex] == 'B' || colType_[colIndex] == 'I';
  }
 
  inline bool isIntegerNonBinary(int colIndex) const
  {
    return colType_[colIndex] == 'I';
  }
 
  inline bool isFreeBinary(int colIndex) const
  {
    return colType_[colIndex] == 'B' && colUpper_[colIndex] > colLower_[colIndex];
  }
 
  inline const char *getColType() const
  {
    return colType_;
  }
 
  inline const CoinPackedMatrix *getMatrixByRow() const
  {
    return matrixByRow_;
  }
 
  inline const CoinPackedMatrix *getMatrixByCol() const
  {
    return matrixByCol_;
  }
 
  inline const CoinPackedMatrix *getOriginalMatrixByRow() const
  {
    return originalMatrixByRow_;
  }
 
  inline const CoinPackedMatrix *getOriginalMatrixByCol() const
  {
    return originalMatrixByCol_;
  }
 
  inline const double *getColSolution() const
  {
    return colSolution_;
  }
 
  inline const double *getRowPrice() const
  {
    return rowPrice_;
  }
 
  inline const double *getReducedCost() const
  {
    return reducedCost_;
  }
 
  inline const double *getRowActivity() const
  {
    return rowActivity_;
  }
 
  inline const double *getDoNotSeparateThis() const
  {
    return doNotSeparateThis_;
  }
 
  inline double getInfinity() const
  {
    return infinity_;
  }
 
  inline double getObjValue() const
  {
    return objValue_;
  }
 
  inline double getObjOffset() const
  {
    return objOffset_;
  }
 
  inline double getDualTolerance() const
  {
    return dualTolerance_;
  }
 
  inline double getPrimalTolerance() const
  {
    return primalTolerance_;
  }
 
  inline double getIntegerTolerance() const
  {
    return integerTolerance_;
  }
 
  inline double getIntegerUpperBound() const
  {
    return integerUpperBound_;
  }
 
  inline double getIntegerLowerBound() const
  {
    return integerLowerBound_;
  }
 
  //---------------------------------------------------------------------------
 
  void loadProblem(const CoinPackedMatrix &matrix,
    const double *collb, const double *colub,
    const double *obj,
    const double *rowlb, const double *rowub,
    bool makeRowCopy = false);
 
 
  //---------------------------------------------------------------------------
 
  inline void setNumCols(int value)
  {
    numCols_ = value;
  }
 
  inline void setNumRows(int value)
  {
    numRows_ = value;
  }
 
  inline void setNumElements(int value)
  {
    numElements_ = value;
  }
 
  inline void setNumIntegers(int value)
  {
    numIntegers_ = value;
  }
 
  void setColLower(const double *array, bool copyIn = true);
 
  void setColUpper(const double *array, bool copyIn = true);
 
  void setRowLower(const double *array, bool copyIn = true);
 
  void setRowUpper(const double *array, bool copyIn = true);
 
  void setRightHandSide(const double *array, bool copyIn = true);
 
  void createRightHandSide();
 
  void setObjCoefficients(const double *array, bool copyIn = true);
 
  inline void setObjSense(double value)
  {
    objSense_ = value;
  }
 
  void setColType(const char *array, bool copyIn = true);
 
  void setMatrixByRow(const CoinPackedMatrix *matrix, bool copyIn = true);
 
  void createMatrixByRow();
 
  void setMatrixByCol(const CoinPackedMatrix *matrix, bool copyIn = true);
 
  void setOriginalMatrixByRow(const CoinPackedMatrix *matrix, bool copyIn = true);
 
  void setOriginalMatrixByCol(const CoinPackedMatrix *matrix, bool copyIn = true);
 
  void setColSolution(const double *array, bool copyIn = true);
 
  void setRowPrice(const double *array, bool copyIn = true);
 
  void setReducedCost(const double *array, bool copyIn = true);
 
  void setRowActivity(const double *array, bool copyIn = true);
 
  void setDoNotSeparateThis(const double *array, bool copyIn = true);
 
  inline void setInfinity(double value)
  {
    infinity_ = value;
  }
 
  inline void setObjValue(double value)
  {
    objValue_ = value;
  }
 
  inline void setObjOffset(double value)
  {
    objOffset_ = value;
  }
 
  inline void setDualTolerance(double value)
  {
    dualTolerance_ = value;
  }
 
  inline void setPrimalTolerance(double value)
  {
    primalTolerance_ = value;
  }
 
  inline void setIntegerTolerance(double value)
  {
    integerTolerance_ = value;
  }
 
  inline void setIntegerUpperBound(double value)
  {
    integerUpperBound_ = value;
  }
 
  inline void setIntegerLowerBound(double value)
  {
    integerLowerBound_ = value;
  }
 
  //---------------------------------------------------------------------------
 
 
  CoinSnapshot();
 
  CoinSnapshot(const CoinSnapshot &);
 
  CoinSnapshot &operator=(const CoinSnapshot &rhs);
 
  virtual ~CoinSnapshot();
 
 
private:
 
 
  void gutsOfDestructor(int type);
  void gutsOfCopy(const CoinSnapshot &rhs);
 
 
  double objSense_;
 
  double infinity_;
 
  double objValue_;
 
  double objOffset_;
 
  double dualTolerance_;
 
  double primalTolerance_;
 
  double integerTolerance_;
 
  double integerUpperBound_;
 
  double integerLowerBound_;
 
  const double *colLower_;
 
  const double *colUpper_;
 
  const double *rowLower_;
 
  const double *rowUpper_;
 
  const double *rightHandSide_;
 
  const double *objCoefficients_;
 
  const char *colType_;
 
  const CoinPackedMatrix *matrixByRow_;
 
  const CoinPackedMatrix *matrixByCol_;
 
  const CoinPackedMatrix *originalMatrixByRow_;
 
  const CoinPackedMatrix *originalMatrixByCol_;
 
  const double *colSolution_;
 
  const double *rowPrice_;
 
  const double *reducedCost_;
 
  const double *rowActivity_;
 
  const double *doNotSeparateThis_;
 
  int numCols_;
 
  int numRows_;
 
  int numElements_;
 
  int numIntegers_;
 
  typedef struct {
    unsigned int colLower : 1;
    unsigned int colUpper : 1;
    unsigned int rowLower : 1;
    unsigned int rowUpper : 1;
    unsigned int rightHandSide : 1;
    unsigned int objCoefficients : 1;
    unsigned int colType : 1;
    unsigned int matrixByRow : 1;
    unsigned int matrixByCol : 1;
    unsigned int originalMatrixByRow : 1;
    unsigned int originalMatrixByCol : 1;
    unsigned int colSolution : 1;
    unsigned int rowPrice : 1;
    unsigned int reducedCost : 1;
    unsigned int rowActivity : 1;
    unsigned int doNotSeparateThis : 1;
  } coinOwned;
  coinOwned owned_;
};
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/