CplexMILPEngine.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2008 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURCPLEXMILPENGINE_H
#define MINOTAURCPLEXMILPENGINE_H
//#include <ilcplex/ilocplex.h>
#include <ilcplex/cplexx.h>
#include <string.h>
#include "MILPEngine.h"
#include "STOAHandler.h"
 
 
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 CplexMILPStats {
    UInt calls;     
    double time;    
  };
 
  class CplexMILPEngine : public MILPEngine {
  public:
    
    //static int lazycallback(CPXCENVptr env, void *cbdata, int wherefrom,
             //void *cbhandle, int *useraction_p);
    
    void doNothing();
    
    CplexMILPEngine(EnvPtr env);
 
    ~CplexMILPEngine();
 
    // 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();
 
    void disableStrBrSetup() {};
 
    EnginePtr emptyCopy();
 
    void enableStrBrSetup() {};
 
    UInt getNumSols();
 
    double getSolutionValue();
 
    // Implement Engine::getSolution().
    ConstSolutionPtr getSolution();
 
    // Get a particular solution from solution pool (-1 fetches incumbent).
    ConstSolutionPtr getSolutionFromPool(int index);
 
    // Implement Engine::getStatus().
    EngineStatus getStatus();
 
    // get name.
    std::string getName() const;
 
    ConstWarmStartPtr getWarmStart() {return WarmStartPtr();};
 
    WarmStartPtr getWarmStartCopy()  {return WarmStartPtr();};
 
    void load(ProblemPtr problem);
 
    void loadFromWarmStart(const WarmStartPtr ) {};
 
    // Convert 'min f' to 'min -f'.
    void negateObj();
 
    // Print a point x
    void printx(double *x, UInt size);
 
    // base class method.
    void removeCons(std::vector<ConstraintPtr> &delcons);
 
    // Implement Engine::resetIterationLimit().
    void resetIterationLimit();
 
    // Implement Engine::setIterationLimit().
    void setIterationLimit(int);
 
    // Implement Engine::setDualObjLimit().
    int setDualObjLimit(double) {return 1;};
 
    // Implement Engine::setTimeLimit().
    void setTimeLimit(double);
 
    // Implement Engine::setUpperCutoff().
    void setUpperCutoff(double);
    
    // Implement the solve() function of Cplex
    EngineStatus solve();
 
    // Implement the solve() function for single tree OA with general
    // callbacks
    EngineStatus solveST(double* objLb, SolutionPtr* sol,
                         STOAHandlerPtr stoa_hand,
                         SolveStatus* solveStatus);
 
    // Implement the solve() function for single tree OA with lazy cuts
    // callback
    EngineStatus solveSTLazy(double* objLb, SolutionPtr* sol,
                         STOAHandlerPtr stoa_hand,
                         SolveStatus* solveStatus);
 
    void writeLP(const char *filename) const;
 
    void writeLP();
 
    void writeStats(std::ostream &out) const;
 
  private:
    /* This simple (CPLEX) routine frees up the pointer *ptr, and sets *ptr to NULL */
    void free_(char **ptr);
 
    CPXENVptr cpxenv_;
 
    CPXLPptr cpxlp_;
   
    int cpxstatus_;
 
    double timeLimit_;
 
    double upperCutoff_;
 
    bool bndChanged_;
 
    bool consChanged_;
 
    EnvPtr env_;
 
    int maxIterLimit_;
 
    std::string mipStartFile_;
 
    static const std::string me_;
 
    bool objChanged_;
 
    ProblemPtr problem_;
 
    SolutionPtr sol_;
 
    CplexMILPStats *stats_;
 
    Timer *timer_;
 
    bool writeMipStarts_;
 
    void load_();
  };
  
  typedef CplexMILPEngine* CplexMILPEnginePtr;
}
 
#endif