CoinSnapshot.hpp

Go to the documentation of this file.

/* $Id: CoinSnapshot.hpp 2083 2019-01-06 19:38:09Z unxusr $ */
// 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
*/