OsiDylpSolverInterface.hpp

Go to the documentation of this file.

#ifndef OsiDylpSolverInterface_H
#define OsiDylpSolverInterface_H

/*
  Copyright (C) 2002, 2003, 2004.
  Lou Hafer, Stephen Tse, International Business Machines Corporation and
  others. All Rights Reserved.
  Copyright (C) 2005 -- 2010 Lou Hafer

  This file is a portion of the COIN/OSI interface for dylp and is licensed
  under the terms of the Eclipse Public License (EPL)
*/

/*
  sccs: @(#)OsiDylpSolverInterface.hpp  1.12    09/16/04
  cvs: $Id: OsiDylpSolverInterface.hpp 1312 2008-10-10 00:26:32Z lou $
*/

#include "OsiConfig.h"
#include <CoinPackedMatrix.hpp>
#include <OsiSolverInterface.hpp>
#include <CoinWarmStart.hpp>
#include <CoinMessageHandler.hpp>
#include <CoinMpsIO.hpp>
#include <CoinPresolveMatrix.hpp>

#define DYLP_INTERNAL
extern "C" {
#include "dylp.h"
}

class OsiDylpWarmStartBasis ;

typedef enum { startInvalid = 0,
               startCold = 1, startWarm, startHot } ODSI_start_enum ;


class OsiDylpSolverInterface: virtual public OsiSolverInterface

{ friend void OsiDylpSolverInterfaceUnitTest(const std::string &mpsDir,
                                             const std::string &netLibDir) ;

/*
  Consult the COIN OSI documentation or relevant source code for details
  not covered here. Supported functions are listed first, followed by
  unsupported functions.
*/

public:


  OsiDylpSolverInterface() ;

  OsiDylpSolverInterface(const OsiDylpSolverInterface &src) ;

  OsiSolverInterface* clone(bool copyData = true) const ;

  OsiDylpSolverInterface &operator=(const OsiDylpSolverInterface &rhs) ;

  ~OsiDylpSolverInterface() ;

  void reset() ;



  int readMps(const char *filename, const char *extension = "mps") ;

  int readMps(const char *filename, const char *extension,
              int &numberSets, CoinSet **&sets) ;

  void writeMps(const char *basename,
                const char *extension = "mps",
                double objsense = 0.0) const ;

  void loadProblem(const CoinPackedMatrix &matrix,
                   const double *collb, const double *colub, const double *obj,
                   const char *rowsen, const double *rowrhs,
                   const double *rowrng) ;

  void loadProblem(const CoinPackedMatrix &matrix,
                   const double *collb, const double *colub, const double *obj,
                   const double *rowlb, const double *rowub) ;
  
  void loadProblem(const int colcnt, const int rowcnt,
               const int *start, const int *index, const double *value,
               const double *collb, const double *colub, const double *obj,
               const char *sense, const double *rhsin, const double *range) ;

  void loadProblem(const int colcnt, const int rowcnt,
                   const int *start, const int *index, const double *value,
                   const double *collb, const double *colub, const double *obj,
                   const double *row_lower, const double *row_upper) ;

  void assignProblem(CoinPackedMatrix *&matrix,
                     double *&collb, double *&colub, double *&obj, 
                     char *&rowsen, double *&rowrhs, double *&rowrng) ;

  void assignProblem(CoinPackedMatrix *&matrix,
                     double *&collb, double *&colub, double *&obj,
                     double *&rowlb, double *&rowub) ;



  int getNumCols() const ;

  int getNumRows() const ;

  int getNumElements() const ;

  int getNumIntegers() const ;

  const double* getColLower() const ;

  const double* getColUpper() const ;

  bool isContinuous(int colIndex) const ;

  bool isBinary(int colIndex) const ;

  bool isIntegerNonBinary (int colIndex) const ;

  bool isInteger (int colIndex) const ;

  const char* getRowSense() const ;

  const double* getRightHandSide() const ;

  const double* getRowRange() const ;

  const double* getRowLower() const ;

  const double* getRowUpper() const ;

  const double* getObjCoefficients() const ;

  double getObjSense() const ;

  const CoinPackedMatrix *getMatrixByRow() const ;

  const CoinPackedMatrix *getMatrixByCol() const ;


  void setObjName (std::string name) ;

  void setRowName(int ndx, std::string name) ;

  void setColName(int ndx, std::string name) ;



  void setContinuous(int index) ;
  using OsiSolverInterface::setContinuous ;

  void setInteger(int index) ;
  using OsiSolverInterface::setInteger ;

  void setColLower(int index, double value) ;
  using OsiSolverInterface::setColLower ;

  void setColUpper(int index, double value) ;
  using OsiSolverInterface::setColUpper ;

  void setRowLower(int index, double value) ;

  void setRowUpper(int index, double value) ;

  void setRowType(int index, char rowsen, double rowrhs, double rowrng) ;

  void setObjCoeff (int index, double value) ;

  void setObjective(const double * array);

  void setObjSense(double sense) ;

  void setColSolution(const double *colsol) ;

  void setRowPrice(const double*) ;

  /* For overload resolution with OSI::addCol functions. */

  using OsiSolverInterface::addCol ;

  void addCol(const CoinPackedVectorBase &vec,
              const double collb, const double colub, const double obj) ;

  void deleteCols(const int num, const int *colIndices) ;

  /* For overload resolution with OSI::addRow functions. */

  using OsiSolverInterface::addRow ;

  void addRow(const CoinPackedVectorBase &row,
              const double rowlb, const double rowub) ;

  void addRow(const CoinPackedVectorBase &row,
              const char rowsen, const double rowrhs, const double rowrng) ;

  void deleteRows(const int num, const int *rowIndices) ;

  void applyRowCut(const OsiRowCut &cut) ;

  void applyColCut(const OsiColCut &cut) ;


  void initialSolve() ;

  CoinWarmStart *getEmptyWarmStart () const ;

  CoinWarmStart *getWarmStart() const ;

  bool setWarmStart(const CoinWarmStart *warmStart) ;

  void resolve() ;

  void markHotStart() ;

  void solveFromHotStart() ;

  void unmarkHotStart() ;



  bool isAbandoned() const ;

  bool isProvenOptimal() const ;

  bool isProvenPrimalInfeasible() const ;

  bool isProvenDualInfeasible() const ;

  bool isIterationLimitReached() const ;

  int getIterationCount() const ;

  bool isPrimalObjectiveLimitReached() const ;

  bool isDualObjectiveLimitReached() const ;



  double getInfinity() const ;

  bool setIntParam(OsiIntParam key, int value) ;

  bool setDblParam(OsiDblParam key, double value) ;

  bool setStrParam(OsiStrParam key, const std::string& value) ;

  bool setHintParam(OsiHintParam key, bool sense = true,
                    OsiHintStrength strength = OsiHintTry, void *info = 0) ;

  bool getIntParam(OsiIntParam key, int &value) const ;

  bool getDblParam(OsiDblParam key, double &value) const ;

  bool getStrParam(OsiStrParam key, std::string &value) const ;

  /* For overload resolution with OSI::getHintParam functions. */

  using OsiSolverInterface::getHintParam ;

  bool getHintParam(OsiHintParam key, bool &sense,
                    OsiHintStrength &strength, void *&info) const ;

  inline void newLanguage(CoinMessages::Language language)
  { setOsiDylpMessages(language) ; }

  inline void setLanguage(CoinMessages::Language language)
  { setOsiDylpMessages(language) ; }



  double getObjValue() const ;

  const double* getColSolution() const ; 

  const double* getRowPrice() const ;

  const double* getReducedCost() const ;

  const double* getRowActivity() const ;

  std::vector<double *> getDualRays(int maxNumRays, bool fullRay) const ;

  std::vector<double *> getPrimalRays(int maxNumRays) const ;



  int canDoSimplexInterface() const ;

  void enableFactorization() const ;

  void disableFactorization() const ;

  bool basisIsAvailable () const ;

  void getBasisStatus (int *archStatus, int *logStatus) const ;

  int setBasisStatus (const int *archStatus, const int *logStatus) ;

  virtual void getReducedGradient(double *columnReducedCosts, 
                                  double *duals, const double *c) const ;

  virtual void getBasics(int *index) const ;

  virtual void getBInvCol(int col, double *betak) const ;

  virtual void getBInvACol(int col, double *abarj) const ;

  virtual void getBInvRow(int row, double *betai) const ;

  virtual void getBInvARow(int row, double *abari, double *betai = 0) const ;




  void activateRowCutDebugger (const char * modelName) ;

  void activateRowCutDebugger (const double *solution,
                               bool keepContinuous = false) ;

# if ODSI_PARANOIA >= 1

  void indexCheck (int k, bool isCol, std::string rtnnme) ;
# endif



  void dylp_controlfile(const char* name, const bool silent,
                        const bool mustexist = true) ;

  void dylp_logfile(const char* name, bool echo = false) ;

  void dylp_outfile(const char* name) ;

  void dylp_printsoln(bool wantSoln, bool wantStats) ;

  void setOsiDylpMessages(CoinMessages::Language local_language) ;




  void branchAndBound() ;



  lpopts_struct *initialSolveOptions ;

  lpopts_struct *resolveOptions ;

  lptols_struct *tolerances ;


private:

/*
  Private implementation state and helper functions. If you're contemplating
  using any of these, you should have a look at the code.
  See OsiDylpSolverInterface.cpp for descriptions.
*/ 

  consys_struct *consys ;
  lpprob_struct *lpprob ;
  lpstats_struct *statistics ;



  static int reference_count ;
  static bool basis_ready ;




  ioid local_outchn ;

  ioid local_logchn ;

  bool initial_gtxecho ;

  bool resolve_gtxecho ;

  lpret_enum lp_retval ;

  double obj_sense ;

  double odsiInfinity ;

  const std::string solvername ;

  mutable void *info_[OsiLastHintParam] ;

  bool mps_debug ;

  CoinWarmStart *hotstart_fallback ;

  enum basisCondition
  { basisNone = 0, basisFresh, basisModified, basisDamaged } ;

  struct
  { CoinWarmStart *basis ;
    basisCondition condition ;
    int balance ; } activeBasis ;

  bool solnIsFresh ;

  mutable struct
  { int simplex ;
    bool saved_fullsys ; } simplex_state ;





  mutable double _objval ;
  mutable double* _col_obj ;
  mutable double* _col_x ;
  mutable double* _col_cbar ;

  mutable double* _row_rhs ;
  mutable double* _row_lower ;
  mutable double* _row_upper ;
  mutable char* _row_sense ;
  mutable double* _row_range ;
  mutable double* _row_lhs ;
  mutable double* _row_price ;

  mutable CoinPackedMatrix* _matrix_by_col ;
  mutable CoinPackedMatrix* _matrix_by_row ;



  CoinPresolveMatrix *preObj_ ;

  const CoinPresolveAction *postActions_ ;

  CoinPostsolveMatrix *postObj_ ;

  int passLimit_ ;

  bool keepIntegers_ ;

  consys_struct *savedConsys_ ;

  mutable double* saved_col_obj ;
  mutable double* saved_row_rhs ;
  mutable double* saved_row_lower ;
  mutable double* saved_row_upper ;
  mutable char* saved_row_sense ;
  mutable double* saved_row_range ;
  mutable CoinPackedMatrix* saved_matrix_by_col ;
  mutable CoinPackedMatrix* saved_matrix_by_row ;


  CoinPresolveMatrix *initialisePresolve(bool keepIntegers) ;

  void doPresolve() ;

  bool evalPresolve() ;

  void saveOriginalSys() ;

  void installPresolve() ;

  CoinPostsolveMatrix *initialisePostsolve(CoinPresolveMatrix *&preObj) ;

  void doPostsolve() ;

  void installPostsolve() ;

  void destruct_presolve() ;



  bool ensureOwnership () const ;

//}@

  void construct_lpprob() ;
  void construct_options() ;
  void construct_consys(int cols, int rows) ;
  void dylp_ioinit() ;
  void gen_rowparms(int rowcnt,
                    double *rhs, double *rhslow, contyp_enum *ctyp,
                    const double *rowlb, const double *rowub) ;
  void gen_rowparms(int rowcnt,
               double *rhs, double *rhslow, contyp_enum *ctyp,
               const char *sense, const double *rhsin, const double *range) ;
  void load_problem(const CoinMpsIO &mps) ;
  void load_problem(const CoinPackedMatrix &matrix,
         const double* col_lower, const double* col_upper, const double* obj,
         const contyp_enum *ctyp, const double* rhs, const double* rhslow) ;
  void load_problem (const int colcnt, const int rowcnt,
         const int *start, const int *lens,
         const int *index, const double *value,
         const double* col_lower, const double* col_upper, const double* obj,
         const contyp_enum *ctyp, const double* rhs, const double* rhslow) ;

  lpret_enum do_lp (ODSI_start_enum start, bool echo) ;

  void setBasisInLpprob (const OsiDylpWarmStartBasis *wsb,
                         lpprob_struct *lpprob) const ;

  void destruct_primal_cache() ;
  void destruct_dual_cache() ;
  void destruct_col_cache(bool structure) ;
  void destruct_row_cache(bool structure) ;
  void destruct_cache(bool rowStructure, bool colStructure) ;
  void destruct_problem(bool preserve_interface) ;
  void detach_dylp() const ;


/*
  There are separate groups for member and static methods so that doxygen
  won't promote the group to the top level.
*/
  
  void add_col(const CoinPackedVectorBase& coin_coli,
               vartyp_enum vtypi, double vlbi,
               double vubi, double obji, const std::string *nme) ;
  void add_row(const CoinPackedVectorBase& coin_rowi, 
               char clazzi, contyp_enum ctypi,
               double rhsi, double rhslowi, const std::string *nme) ;
  void calc_objval() ;
  contyp_enum bound_to_type(double lower, double upper) ;
  void gen_rowiparms(contyp_enum* ctypi, double* rhsi, double* rhslowi, 
                            char sensei, double rhsini, double rangei) ;
  void gen_rowiparms(contyp_enum* ctypi, double* rhsi, double* rhslowi, 
                            double rowlbi, double rowubi) ;
  void unimp_hint(bool dylpSense, bool hintSense,
                 OsiHintStrength hintStrength, const char *msgString) ;
  void pessimal_primal() ;
  void reduceActiveBasis() ;


  static contyp_enum sense_to_type(char type) ;
  static char type_to_sense(contyp_enum type) ;

  template<class T> static void copy(const T* src, T* dst, int n) ;
  template<class T> static T* copy(const T* src, int n) ;
  template<class T> static T* copy(const T* src) ;
/*
  Specializations for more complicated structures.
*/
  static basis_struct* copy_basis(const basis_struct* src, int dstsze) ;
  static void copy_basis(const basis_struct* src, basis_struct* dst) ;
  static lpprob_struct* copy_lpprob(const lpprob_struct* src) ;

#ifndef _MSC_VER

  template<class T> static void assert_same(const T& t1, const T& t2,
                                            bool exact) ;
  template<class T> static void assert_same(const T* t1, const T* t2,
                                            int n, bool exact) ;

  static void assert_same(double d1, double d2, bool exact) ;

  static void assert_same(const basis_struct& b1, 
                          const basis_struct& b2, bool exact) ;
  static void assert_same(const consys_struct& c1, const 
                          consys_struct& c2, bool exact) ;
  static void assert_same(const conbnd_struct& c1, const 
                          conbnd_struct& c2, bool exact) ;
  static void assert_same(const lpprob_struct& l1, 
                          const lpprob_struct& l2, bool exact) ;
  static void assert_same(const OsiDylpSolverInterface& o1, 
                          const OsiDylpSolverInterface& o2, bool exact) ;
#endif  /* ! _MSC_VER */


  template<class T> inline static T* idx_vec (T* vec) { return (vec-1) ; }

  inline static int idx (int i) { return (i+1) ; }

  template<class T> inline static T* inv_vec (T* vec) { return (vec+1) ; }

  inline static int inv (int i) { return (i-1) ; }

  static pkvec_struct* packed_vector(
    const CoinShallowPackedVector vector, int dimension) ;
  static void packed_vector(
    const CoinShallowPackedVector vector, int dimension, pkvec_struct *dst) ;

  static std::string make_filename(const char *filename, 
                                   const char *ext1, const char *ext2) ;

} ;


/*
  OsiDylpSolverInterfaceTest.cpp
*/

void OsiDylpSolverInterfaceUnitTest(const std::string & mpsDir,
                                    const std::string &netLibDir) ;

#endif // OsiDylpSolverInterface_H