CoinSnapshot.hpp

Go to the documentation of this file.

/* $Id: CoinSnapshot.hpp 1416 2011-04-17 09:57:29Z stefan $ */
// 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