OsiLPEngine.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2008 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAUROSILPENGINE_H
#define MINOTAUROSILPENGINE_H
 
#include "LPEngine.h"
#include "WarmStart.h"
 
class CoinWarmStart;
class OsiSolverInterface;
 
namespace Minotaur {
 
class Timer;
class Environment;
class Problem;
class Solution;
class WarmStart;
typedef Environment *EnvPtr;
typedef Problem *ProblemPtr;
typedef Solution *SolutionPtr;
typedef WarmStart *WarmStartPtr;
 
struct OsiLPStats {
  UInt calls;      
  UInt strCalls;   
  double time;     
  double strTime;  
  UInt iters;      
  UInt strIters;   
};
 
typedef enum {
  OsiClpEngine,
  OsiGlpkEngine,
  OsiGrbEngine,
  OsiMskEngine,
  OsiSpxEngine,
  OsiXprEngine,
  OsiUndefEngine
} OsiLPEngineName;
 
class OsiLPWarmStart : public WarmStart {
 public:
  friend class Problem;
 
  OsiLPWarmStart();
 
  ~OsiLPWarmStart();
 
  CoinWarmStart *getCoinWarmStart() const;
 
  // Implement Engine::hasInfo().
  bool hasInfo();
 
  void setCoinWarmStart(CoinWarmStart *coin_ws, bool must_delete);
 
  void setDualWarmStart(int size, const double *dual);
 
  // Implement Engine::write().
  void write(std::ostream &out) const;
 
 private:
  CoinWarmStart *coinWs_;
 
  bool mustDelete_;
};
typedef OsiLPWarmStart *OsiLPWarmStartPtr;
typedef const OsiLPWarmStart *ConstOsiLPWarmStartPtr;
 
class OsiLPEngine : public LPEngine {
 public:
  OsiLPEngine(EnvPtr env);
 
  ~OsiLPEngine();
 
  // Implement Engine::addConstraint().
  void addConstraint(ConstraintPtr);
 
  // Change bounds on a constraint.
  void changeBound(ConstraintPtr cons, BoundType lu, double new_val);
 
  // Implement Engine::changeBound(VariablePtr, BoundType, double).
  void changeBound(VariablePtr var, BoundType lu, double new_val);
 
  // Implement Engine::changeBound(VariablePtr, double, double).
  void changeBound(VariablePtr var, double new_lb, double new_ub);
 
  // Implement Engine::changeConstraint().
  void changeConstraint(ConstraintPtr con, LinearFunctionPtr lf, double lb,
                        double ub);
 
  // Implement Engine::changeConstraint().
  void changeConstraint(ConstraintPtr c, NonlinearFunctionPtr nlf);
 
  // change the objective function.
  void changeObj(FunctionPtr f, double cb);
 
  void clear();
 
  // Implement Engine::disableStrBrSetup()
  void disableStrBrSetup();
 
  EnginePtr emptyCopy();
 
  void enableFactorization();
 
  void disableFactorization();
 
  // Implement Engine::enableStrBrSetup()
  void enableStrBrSetup();
 
  // Implement Engine::fillStats()
  void fillStats(std::vector<double> &);
 
  // Get the indices of the basic variables from the tableau
  void getBasics(int *index);
 
  /* Get the basic row of the corresponding row index
   * param[in] row - Row index for which the optimal tableau row is required
   * param[out] z - Row corresponding to original variables
   * param[out] slack - Row corresponding to slack variables
   */
  void getBInvARow(int row, double *z, double *slack);
 
  /* \brief Get basic status of the variables in the sovler
   * param[out] cstat - A vector for column status (Variables of the problem)
   * param[in] rstat - A vector for row status (Constraints of the problem)
   * Output values are
   * 0 : Free variable
   * 1 : Basic
   * 2 : At upper bound (Non-basic)
   * 3 : At lower bound (Non-basic)
   */
  void getBasisStatus(int *cstat, int *rstat);
 
  // Get lower bounds of the variables in the solver
  const double *getColLower();
 
  // Get upper bounds of the variables in the solver
  const double *getColUpper();
 
  // Get lower bounds of the constraints in the solver
  const double *getRowLower();
 
  // Get upper bounds of the constraints in the solver
  const double *getRowUpper();
 
  // Get right hand side of the rows in the simplex tableau
  const double *getRightHandSide();
 
  // Get number of columns to the solver
  int getNumCols();
 
  // Get number of rows to the solver
  int getNumRows();
 
  // Get row activity
  const double *getRowActivity();
 
  // To get the original tableau from the solver
  const double *getOriginalTableau();
 
  // Get start index for each row in the original tableau
  const int *getRowStarts();
 
  // Gets indices of variables in the elements of the original tableau
  const int *getIndicesofVars();
 
  // Get the length of each row in the original tableau
  const int *getRowLength();
 
  double getSolutionValue();
 
  // Implement Engine::getSolution().
  ConstSolutionPtr getSolution();
 
  // Implement Engine::getStatus().
  EngineStatus getStatus();
 
  int getIterationCount();
 
  // get name.
  std::string getName() const;
 
  // OsiSolverInterface * getSolver();
 
  // Implement Engine::getWarmStart().
  // See OsiLPSolver.hpp to see Osi's description of warm-start pointer.
  // It differs from solver to solver. We just return NULL for now.
  ConstWarmStartPtr getWarmStart() {
    assert(!"not implemented!");
    return WarmStartPtr();
  };
 
  // Implement Engine::getWarmStartCopy().
  WarmStartPtr getWarmStartCopy();
 
  // Returns true if Optimal basis is available with the sovler
  bool IsOptimalBasisAvailable();
 
  void load(ProblemPtr problem);
 
  // Implement Engine::loadFromWarmStart().
  void loadFromWarmStart(const WarmStartPtr ws);
 
  // Load dual warm start info in the solver
  void loadDualWarmStart(int size, double *dualVec);
 
  // Convert 'min f' to 'min -f'.
  void negateObj();
 
  // base class method.
  void removeCons(std::vector<ConstraintPtr> &delcons);
 
  // Implement Engine::resetIterationLimit().
  void resetIterationLimit();
 
  // Implement Engine::setIterationLimit().
  void setIterationLimit(int limit);
 
  // Implement Engine::setDualObjLimit().
  int setDualObjLimit(double) { return 1; };
 
  EngineStatus solve();
 
  void writeLP(const char *filename) const;
 
  void writeStats(std::ostream &out) const;
 
 private:
  bool bndChanged_;
 
  bool consChanged_;
 
  EnvPtr env_;
 
  OsiLPEngineName eName_;
 
  int maxIterLimit_;
 
  static const std::string me_;
 
  bool objChanged_;
 
  OsiSolverInterface *osilp_;
 
  bool pickLPMeth_;
 
  ProblemPtr problem_;
 
  SolutionPtr sol_;
 
  OsiLPStats *stats_;
 
  bool strBr_;
 
  Timer *timer_;
 
  // Create a new solver (cplex, or clp or ..)
  OsiSolverInterface *newSolver_(OsiLPEngineName ename);
};
 
typedef OsiLPEngine *OsiLPEnginePtr;
}  // namespace Minotaur
 
#endif