OsiSpxSolverInterface.hpp

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// name:     OSI Interface for SoPlex >= 1.4.2c
// authors:  Tobias Pfender
//           Ambros Gleixner
//           Wei Huang
//           Konrad-Zuse-Zentrum Berlin (Germany)
//           email: pfender@zib.de
// date:     01/16/2002
// license:  this file may be freely distributed under the terms of the EPL
//-----------------------------------------------------------------------------
// Copyright (C) 2002, Tobias Pfender, International Business Machines
// Corporation and others.  All Rights Reserved.
// Last edit: $Id$
 
#ifndef OsiSpxSolverInterface_H
#define OsiSpxSolverInterface_H
 
#include <string>
#include "OsiSolverInterface.hpp"
#include "CoinWarmStartBasis.hpp"
 
#ifndef _SOPLEX_H_
/* forward declarations so the header can be compiled without having to include soplex.h
 * however, these declaration work only for SoPlex < 2.0, so we do them only if soplex.h hasn't been included already
 */
namespace soplex {
class DIdxSet;
class DVector;
class SPxOut;
class SoPlex;
}
#endif
 
class OsiSpxSolverInterface : virtual public OsiSolverInterface {
  friend void OsiSpxSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir);
 
public:
  //---------------------------------------------------------------------------
  virtual void initialSolve();
 
  virtual void resolve();
 
  virtual void branchAndBound();
 
  //---------------------------------------------------------------------------
  // Set an integer parameter
  bool setIntParam(OsiIntParam key, int value);
  // Set an double parameter
  bool setDblParam(OsiDblParam key, double value);
  // Get an integer parameter
  bool getIntParam(OsiIntParam key, int &value) const;
  // Get an double parameter
  bool getDblParam(OsiDblParam key, double &value) const;
  // Get a string parameter
  bool getStrParam(OsiStrParam key, std::string &value) const;
  // Set timelimit
  void setTimeLimit(double value);
  // Get timelimit
  double getTimeLimit() const;
 
  //---------------------------------------------------------------------------
 
  virtual bool isAbandoned() const;
  virtual bool isProvenOptimal() const;
  virtual bool isProvenPrimalInfeasible() const;
  virtual bool isProvenDualInfeasible() const;
  // Is the given primal objective limit reached? - use implementation from OsiSolverInterface
  virtual bool isDualObjectiveLimitReached() const;
  virtual bool isIterationLimitReached() const;
  virtual bool isTimeLimitReached() const;
 
  //---------------------------------------------------------------------------
  inline CoinWarmStart *getEmptyWarmStart() const
  {
    return (dynamic_cast< CoinWarmStart * >(new CoinWarmStartBasis()));
  }
  virtual CoinWarmStart *getWarmStart() const;
  virtual bool setWarmStart(const CoinWarmStart *warmstart);
 
  //---------------------------------------------------------------------------
  virtual void markHotStart();
  virtual void solveFromHotStart();
  virtual void unmarkHotStart();
 
  //---------------------------------------------------------------------------
  virtual int getNumCols() const;
 
  virtual int getNumRows() const;
 
  virtual int getNumElements() const;
 
  virtual const double *getColLower() const;
 
  virtual const double *getColUpper() const;
 
  virtual const char *getRowSense() const;
 
  virtual const double *getRightHandSide() const;
 
  virtual const double *getRowRange() const;
 
  virtual const double *getRowLower() const;
 
  virtual const double *getRowUpper() const;
 
  virtual const double *getObjCoefficients() const;
 
  virtual double getObjSense() const;
 
  virtual bool isContinuous(int colNumber) const;
 
#if 0
      virtual bool isBinary(int columnNumber) const;
  
      virtual bool isInteger(int columnNumber) const;
  
      virtual bool isIntegerNonBinary(int columnNumber) const;
  
      virtual bool isFreeBinary(int columnNumber) const;
#endif
 
  virtual const CoinPackedMatrix *getMatrixByRow() const;
 
  virtual const CoinPackedMatrix *getMatrixByCol() const;
 
  virtual double getInfinity() const;
 
  virtual const double *getColSolution() const;
 
  virtual const double *getRowPrice() const;
 
  virtual const double *getReducedCost() const;
 
  virtual const double *getRowActivity() const;
 
  virtual double getObjValue() const;
 
  virtual int getIterationCount() const;
 
  virtual std::vector< double * > getDualRays(int maxNumRays,
    bool fullRay = false) const;
  virtual std::vector< double * > getPrimalRays(int maxNumRays) const;
 
#if 0
 
      virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05)
        const;
#endif
 
 
 
  //---------------------------------------------------------------------------
 
  //-------------------------------------------------------------------------
  virtual void setObjCoeff(int elementIndex, double elementValue);
 
  virtual void setColLower(int elementIndex, double elementValue);
 
  virtual void setColUpper(int elementIndex, double elementValue);
 
  virtual void setColBounds(int elementIndex,
    double lower, double upper);
 
#if 0 // we are using the default implementation of OsiSolverInterface
 
      virtual void setColSetBounds(const int* indexFirst,
                                   const int* indexLast,
                                   const double* boundList);
#endif
 
  virtual void setRowLower(int elementIndex, double elementValue);
 
  virtual void setRowUpper(int elementIndex, double elementValue);
 
  virtual void setRowBounds(int elementIndex,
    double lower, double upper);
 
  virtual void setRowType(int index, char sense, double rightHandSide,
    double range);
 
#if 0 // we are using the default implementation of OsiSolverInterface
 
      virtual void setRowSetBounds(const int* indexFirst,
                                   const int* indexLast,
                                   const double* boundList);
 
      virtual void setRowSetTypes(const int* indexFirst,
                                  const int* indexLast,
                                  const char* senseList,
                                  const double* rhsList,
                                  const double* rangeList);
#endif
 
 
  //-------------------------------------------------------------------------
  virtual void setContinuous(int index);
  virtual void setInteger(int index);
#if 0 // we are using the default implementation of OsiSolverInterface
 
      virtual void setContinuous(const int* indices, int len);
      virtual void setInteger(const int* indices, int len);
#endif
 
 
  //-------------------------------------------------------------------------
  virtual void setObjSense(double s);
 
  virtual void setColSolution(const double *colsol);
 
  virtual void setRowPrice(const double *rowprice);
 
  //-------------------------------------------------------------------------
  virtual void addCol(const CoinPackedVectorBase &vec,
    const double collb, const double colub,
    const double obj);
 
#if 0 // we are using the default implementation of OsiSolverInterface
 
      virtual void addCols(const int numcols,
                           const CoinPackedVectorBase * const * cols,
                           const double* collb, const double* colub,   
                           const double* obj);
#endif
 
  virtual void deleteCols(const int num, const int *colIndices);
 
  virtual void addRow(const CoinPackedVectorBase &vec,
    const double rowlb, const double rowub);
  virtual void addRow(const CoinPackedVectorBase &vec,
    const char rowsen, const double rowrhs,
    const double rowrng);
 
#if 0 // we are using the default implementation of OsiSolverInterface
 
      virtual void addRows(const int numrows,
                           const CoinPackedVectorBase * const * rows,
                           const double* rowlb, const double* rowub);
      virtual void addRows(const int numrows,
                           const CoinPackedVectorBase * const * rows,
                           const char* rowsen, const double* rowrhs,   
                           const double* rowrng);
#endif
 
  virtual void deleteRows(const int num, const int *rowIndices);
 
#if 0 // we are using the default implementation of OsiSolverInterface \
  //-----------------------------------------------------------------------
 
      virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
                                            double effectivenessLb = 0.0);
#endif
 
 
 
  //---------------------------------------------------------------------------
 
  virtual void loadProblem(const CoinPackedMatrix &matrix,
    const double *collb, const double *colub,
    const double *obj,
    const double *rowlb, const double *rowub);
 
  virtual void assignProblem(CoinPackedMatrix *&matrix,
    double *&collb, double *&colub, double *&obj,
    double *&rowlb, double *&rowub);
 
  virtual void loadProblem(const CoinPackedMatrix &matrix,
    const double *collb, const double *colub,
    const double *obj,
    const char *rowsen, const double *rowrhs,
    const double *rowrng);
 
  virtual void assignProblem(CoinPackedMatrix *&matrix,
    double *&collb, double *&colub, double *&obj,
    char *&rowsen, double *&rowrhs,
    double *&rowrng);
 
  virtual void loadProblem(const int numcols, const int numrows,
    const int *start, const int *index,
    const double *value,
    const double *collb, const double *colub,
    const double *obj,
    const double *rowlb, const double *rowub);
 
  virtual void loadProblem(const int numcols, const int numrows,
    const int *start, const int *index,
    const double *value,
    const double *collb, const double *colub,
    const double *obj,
    const char *rowsen, const double *rowrhs,
    const double *rowrng);
 
  virtual int readMps(const char *filename,
    const char *extension = "mps");
 
  virtual void writeMps(const char *filename,
    const char *extension = "mps",
    double objSense = 0.0) const;
 
  //---------------------------------------------------------------------------
 
  OsiSpxSolverInterface();
 
  virtual OsiSolverInterface *clone(bool copyData = true) const;
 
  OsiSpxSolverInterface(const OsiSpxSolverInterface &);
 
  OsiSpxSolverInterface &operator=(const OsiSpxSolverInterface &rhs);
 
  virtual ~OsiSpxSolverInterface();
 
  enum keepCachedFlag {
    KEEPCACHED_NONE = 0,
    KEEPCACHED_COLUMN = 1,
    KEEPCACHED_ROW = 2,
    KEEPCACHED_MATRIX = 4,
    KEEPCACHED_RESULTS = 8,
    KEEPCACHED_PROBLEM = KEEPCACHED_COLUMN | KEEPCACHED_ROW | KEEPCACHED_MATRIX,
    KEEPCACHED_ALL = KEEPCACHED_PROBLEM | KEEPCACHED_RESULTS,
    FREECACHED_COLUMN = KEEPCACHED_PROBLEM & ~KEEPCACHED_COLUMN,
    FREECACHED_ROW = KEEPCACHED_PROBLEM & ~KEEPCACHED_ROW,
    FREECACHED_MATRIX = KEEPCACHED_PROBLEM & ~KEEPCACHED_MATRIX,
    FREECACHED_RESULTS = KEEPCACHED_ALL & ~KEEPCACHED_RESULTS
  };
  soplex::SoPlex *getLpPtr(int keepCached = KEEPCACHED_NONE);
 
  soplex::SPxOut *getSPxOut() { return spxout_; }
 
protected:
  virtual void applyRowCut(const OsiRowCut &rc);
 
  virtual void applyColCut(const OsiColCut &cc);
 
  soplex::SPxOut *spxout_;
  soplex::SoPlex *soplex_;
 
private:
 
  void freeCachedColRim();
 
  void freeCachedRowRim();
 
  void freeCachedResults();
 
  void freeCachedMatrix();
 
  void freeCachedData(int keepCached = KEEPCACHED_NONE);
 
  void freeAllMemory();
 
  soplex::DIdxSet *spxintvars_;
 
  void *hotStartCStat_;
  int hotStartCStatSize_;
  void *hotStartRStat_;
  int hotStartRStatSize_;
  int hotStartMaxIteration_;
 
  mutable soplex::DVector *obj_;
 
  mutable char *rowsense_;
 
  mutable double *rhs_;
 
  mutable double *rowrange_;
 
  mutable soplex::DVector *colsol_;
 
  mutable soplex::DVector *rowsol_;
 
  mutable soplex::DVector *redcost_;
 
  mutable soplex::DVector *rowact_;
 
  mutable CoinPackedMatrix *matrixByRow_;
 
  mutable CoinPackedMatrix *matrixByCol_;
 
};
 
//#############################################################################
void OsiSpxSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir);
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/