path: root/thirdparty/linux/include/coin1/CoinSnapshot.hpp

/* $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"

//#############################################################################

/** NON Abstract Base Class for interfacing with cut generators or branching code or ..
    It is designed to be snapshot of a problem at a node in tree
    
  The class may or may not own the arrays - see owned_


  Querying a problem that has no data associated with it will result in
  zeros for the number of rows and columns, and NULL pointers from
  the methods that return arrays.
*/

class CoinSnapshot  {
  
public:
  
  //---------------------------------------------------------------------------
  /**@name Problem query methods
     
     The Matrix pointers may be NULL
  */
  //@{
  /// Get number of columns
  inline int getNumCols() const
  { return numCols_;}
  
  /// Get number of rows
  inline int getNumRows() const
  { return numRows_;}
  
  /// Get number of nonzero elements
  inline int getNumElements() const
  { return numElements_;}
  
  /// Get number of integer variables
  inline int getNumIntegers() const
  { return numIntegers_;}
  
  /// Get pointer to array[getNumCols()] of column lower bounds
  inline const double * getColLower() const
  { return colLower_;}
  
  /// Get pointer to array[getNumCols()] of column upper bounds
  inline const double * getColUpper() const
  { return colUpper_;}
  
  /// Get pointer to array[getNumRows()] of row lower bounds
  inline const double * getRowLower() const
  { return rowLower_;}
  
  /// Get pointer to array[getNumRows()] of row upper bounds
  inline const double * getRowUpper() const
  { return rowUpper_;}
  
  /** Get pointer to array[getNumRows()] of row right-hand sides
      This gives same results as OsiSolverInterface for useful cases
      If getRowUpper()[i] != infinity then
        getRightHandSide()[i] == getRowUpper()[i]
      else
        getRightHandSide()[i] == getRowLower()[i]
  */
  inline const double * getRightHandSide() const
  { return rightHandSide_;}

  /// Get pointer to array[getNumCols()] of objective function coefficients
  inline const double * getObjCoefficients() const
  { return objCoefficients_;}
  
  /// Get objective function sense (1 for min (default), -1 for max)
  inline double getObjSense() const
  { return objSense_;}
  
  /// Return true if variable is continuous
  inline bool isContinuous(int colIndex) const
  { return colType_[colIndex]=='C';}
  
  /// Return true if variable is binary
  inline bool isBinary(int colIndex) const
  { return colType_[colIndex]=='B';}
  
  /// Return true if column is integer.
  inline bool isInteger(int colIndex) const
  { return colType_[colIndex]=='B'||colType_[colIndex]=='I';}
  
  /// Return true if variable is general integer
  inline bool isIntegerNonBinary(int colIndex) const
  { return colType_[colIndex]=='I';}
  
  /// Return true if variable is binary and not fixed at either bound
  inline bool isFreeBinary(int colIndex) const
  { return colType_[colIndex]=='B'&&colUpper_[colIndex]>colLower_[colIndex];}

  /// Get colType array ('B', 'I', or 'C' for Binary, Integer and Continuous) 
  inline const char * getColType() const
  { return colType_;}
  
  /// Get pointer to row-wise copy of current matrix
  inline const CoinPackedMatrix * getMatrixByRow() const
  { return matrixByRow_;}
  
  /// Get pointer to column-wise copy of current matrix
  inline const CoinPackedMatrix * getMatrixByCol() const
  { return matrixByCol_;}
  
  /// Get pointer to row-wise copy of "original" matrix
  inline const CoinPackedMatrix * getOriginalMatrixByRow() const
  { return originalMatrixByRow_;}
  
  /// Get pointer to column-wise copy of "original" matrix
  inline const CoinPackedMatrix * getOriginalMatrixByCol() const
  { return originalMatrixByCol_;}
  //@}
  
  /**@name Solution query methods */
  //@{
  /// Get pointer to array[getNumCols()] of primal variable values
  inline const double * getColSolution() const
  { return colSolution_;}
  
  /// Get pointer to array[getNumRows()] of dual variable values
  inline const double * getRowPrice() const
  { return rowPrice_;}
  
  /// Get a pointer to array[getNumCols()] of reduced costs
  inline const double * getReducedCost() const
  { return reducedCost_;}
  
  /// Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vector). 
  inline const double * getRowActivity() const
  { return rowActivity_;}
  
  /// Get pointer to array[getNumCols()] of primal variable values which should not be separated (for debug)
  inline const double * getDoNotSeparateThis() const
  { return doNotSeparateThis_;}
  //@}
  
  /**@name Other scalar get methods */
  //@{
  /// Get solver's value for infinity
  inline double getInfinity() const
  { return infinity_;}
  
  /** Get objective function value - includinbg any offset i.e.
      sum c sub j * x subj - objValue = objOffset */
  inline double getObjValue() const
  { return objValue_;}

  /// Get objective offset i.e. sum c sub j * x subj -objValue = objOffset 
  inline double getObjOffset() const
  { return objOffset_;}

  /// Get dual tolerance
  inline double getDualTolerance() const
  { return dualTolerance_;}

  /// Get primal tolerance
  inline double getPrimalTolerance() const
  { return primalTolerance_;}

  /// Get integer tolerance
  inline double getIntegerTolerance() const
  { return integerTolerance_;}

  /// Get integer upper bound i.e. best solution * getObjSense
  inline double getIntegerUpperBound() const
  { return integerUpperBound_;}

  /// Get integer lower bound i.e. best possible solution * getObjSense
  inline double getIntegerLowerBound() const
  { return integerLowerBound_;}
  //@}
  
  //---------------------------------------------------------------------------
  
  /**@name Method to input a problem */
  //@{
  /** Load in an problem by copying the arguments (the constraints on the
      rows are given by lower and upper bounds). If a pointer is NULL then the
      following values are the default:
      <ul>
      <li> <code>colub</code>: all columns have upper bound infinity
      <li> <code>collb</code>: all columns have lower bound 0 
      <li> <code>rowub</code>: all rows have upper bound infinity
      <li> <code>rowlb</code>: all rows have lower bound -infinity
      <li> <code>obj</code>: all variables have 0 objective coefficient
      </ul>
      All solution type arrays will be deleted
  */
  void loadProblem(const CoinPackedMatrix& matrix,
		   const double* collb, const double* colub,   
		   const double* obj,
		   const double* rowlb, const double* rowub,
		   bool makeRowCopy=false);
  
  //@}
  
  //---------------------------------------------------------------------------
  
  /**@name Methods to set data */
  //@{
  /// Set number of columns
  inline void setNumCols(int value)
  { numCols_ = value;}
  
  /// Set number of rows
  inline void setNumRows(int value)
  { numRows_ = value;}
  
  /// Set number of nonzero elements
  inline void setNumElements(int value)
  { numElements_ = value;}
  
  /// Set number of integer variables
  inline void setNumIntegers(int value)
  { numIntegers_ = value;}
  
  /// Set pointer to array[getNumCols()] of column lower bounds
  void setColLower(const double * array, bool copyIn=true);
  
  /// Set pointer to array[getNumCols()] of column upper bounds
  void setColUpper(const double * array, bool copyIn=true);
  
  /// Set pointer to array[getNumRows()] of row lower bounds
  void setRowLower(const double * array, bool copyIn=true);
  
  /// Set pointer to array[getNumRows()] of row upper bounds
  void setRowUpper(const double * array, bool copyIn=true);
  
  /** Set pointer to array[getNumRows()] of row right-hand sides
      This gives same results as OsiSolverInterface for useful cases
      If getRowUpper()[i] != infinity then
        getRightHandSide()[i] == getRowUpper()[i]
      else
        getRightHandSide()[i] == getRowLower()[i]
  */
  void setRightHandSide(const double * array, bool copyIn=true);

  /** Create array[getNumRows()] of row right-hand sides
      using existing information
      This gives same results as OsiSolverInterface for useful cases
      If getRowUpper()[i] != infinity then
        getRightHandSide()[i] == getRowUpper()[i]
      else
        getRightHandSide()[i] == getRowLower()[i]
  */
  void createRightHandSide();

  /// Set pointer to array[getNumCols()] of objective function coefficients
  void setObjCoefficients(const double * array, bool copyIn=true);
  
  /// Set objective function sense (1 for min (default), -1 for max)
  inline void setObjSense(double value)
  { objSense_ = value;}
  
  /// Set colType array ('B', 'I', or 'C' for Binary, Integer and Continuous) 
  void setColType(const char *array, bool copyIn=true);
  
  /// Set pointer to row-wise copy of current matrix
  void setMatrixByRow(const CoinPackedMatrix * matrix, bool copyIn=true);
  
  /// Create row-wise copy from MatrixByCol
  void createMatrixByRow();
  
  /// Set pointer to column-wise copy of current matrix
  void setMatrixByCol(const CoinPackedMatrix * matrix, bool copyIn=true);
  
  /// Set pointer to row-wise copy of "original" matrix
  void setOriginalMatrixByRow(const CoinPackedMatrix * matrix, bool copyIn=true);
  
  /// Set pointer to column-wise copy of "original" matrix
  void setOriginalMatrixByCol(const CoinPackedMatrix * matrix, bool copyIn=true);

  /// Set pointer to array[getNumCols()] of primal variable values
  void setColSolution(const double * array, bool copyIn=true);
  
  /// Set pointer to array[getNumRows()] of dual variable values
  void setRowPrice(const double * array, bool copyIn=true);
  
  /// Set a pointer to array[getNumCols()] of reduced costs
  void setReducedCost(const double * array, bool copyIn=true);
  
  /// Set pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vector). 
  void setRowActivity(const double * array, bool copyIn=true);
  
  /// Set pointer to array[getNumCols()] of primal variable values which should not be separated (for debug)
  void setDoNotSeparateThis(const double * array, bool copyIn=true);

  /// Set solver's value for infinity
  inline void setInfinity(double value)
  { infinity_ = value;}
  
  /// Set objective function value (including any rhs offset)
  inline void setObjValue(double value)
  { objValue_ = value;}

  /// Set objective offset i.e. sum c sub j * x subj -objValue = objOffset 
  inline void setObjOffset(double value)
  { objOffset_ = value;}

  /// Set dual tolerance
  inline void setDualTolerance(double value)
  { dualTolerance_ = value;}

  /// Set primal tolerance
  inline void setPrimalTolerance(double value)
  { primalTolerance_ = value;}

  /// Set integer tolerance
  inline void setIntegerTolerance(double value)
  { integerTolerance_ = value;}

  /// Set integer upper bound i.e. best solution * getObjSense
  inline void setIntegerUpperBound(double value)
  { integerUpperBound_ = value;}

  /// Set integer lower bound i.e. best possible solution * getObjSense
  inline void setIntegerLowerBound(double value)
  { integerLowerBound_ = value;}
  //@}
  
  //---------------------------------------------------------------------------
  
  ///@name Constructors and destructors
  //@{
  /// Default Constructor
  CoinSnapshot(); 
    
  /// Copy constructor 
  CoinSnapshot(const CoinSnapshot &);
  
  /// Assignment operator 
  CoinSnapshot & operator=(const CoinSnapshot& rhs);
  
  /// Destructor 
  virtual ~CoinSnapshot ();
  
  //@}

private:
  ///@name private functions
  //@{
  /** Does main work of destructor - type (or'ed)
      1 - NULLify pointers
      2 - delete pointers
      4 - initialize scalars (tolerances etc)
      8 - initialize scalars (objValue etc0
  */
  void gutsOfDestructor(int type);
  /// Does main work of copy
  void gutsOfCopy(const CoinSnapshot & rhs);
  //@}

  ///@name Private member data 

  /// objective function sense (1 for min (default), -1 for max)
  double objSense_;
  
  /// solver's value for infinity
  double infinity_;
  
  /// objective function value (including any rhs offset)
  double objValue_;

  /// objective offset i.e. sum c sub j * x subj -objValue = objOffset 
  double objOffset_;

  /// dual tolerance
  double dualTolerance_;

  /// primal tolerance
  double primalTolerance_;

  /// integer tolerance
  double integerTolerance_;

  /// integer upper bound i.e. best solution * getObjSense
  double integerUpperBound_;

  /// integer lower bound i.e. best possible solution * getObjSense
  double integerLowerBound_;

  /// pointer to array[getNumCols()] of column lower bounds
  const double * colLower_;
  
  /// pointer to array[getNumCols()] of column upper bounds
  const double * colUpper_;
  
  /// pointer to array[getNumRows()] of row lower bounds
  const double * rowLower_;
  
  /// pointer to array[getNumRows()] of row upper bounds
  const double * rowUpper_;
  
  /// pointer to array[getNumRows()] of rhs side values
  const double * rightHandSide_;
  
  /// pointer to array[getNumCols()] of objective function coefficients
  const double * objCoefficients_;
  
  /// colType array ('B', 'I', or 'C' for Binary, Integer and Continuous) 
  const char * colType_;
  
  /// pointer to row-wise copy of current matrix
  const CoinPackedMatrix * matrixByRow_;
  
  /// pointer to column-wise copy of current matrix
  const CoinPackedMatrix * matrixByCol_;
  
  /// pointer to row-wise copy of "original" matrix
  const CoinPackedMatrix * originalMatrixByRow_;
  
  /// pointer to column-wise copy of "original" matrix
  const CoinPackedMatrix * originalMatrixByCol_;

  /// pointer to array[getNumCols()] of primal variable values
  const double * colSolution_;
  
  /// pointer to array[getNumRows()] of dual variable values
  const double * rowPrice_;
  
  /// a pointer to array[getNumCols()] of reduced costs
  const double * reducedCost_;
  
  /// pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vector). 
  const double * rowActivity_;
  
  /// pointer to array[getNumCols()] of primal variable values which should not be separated (for debug)
  const double * doNotSeparateThis_;

  /// number of columns
  int numCols_;
  
  /// number of rows
  int numRows_;
  
  /// number of nonzero elements
  int numElements_;
  
  /// number of integer variables
  int numIntegers_;

  /// To say whether arrays etc are owned by CoinSnapshot
    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