CplexLPEngine.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2008 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURCPLEXLPENGINE_H
#define MINOTAURCPLEXLPENGINE_H
#include <ilcplex/cplexx.h>
#include <string.h>
#include "LPEngine.h"
#include "STOAHandler.h"
#include "WarmStart.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 CplexLPStats {
    UInt calls;     
    UInt strCalls;  
    double time;    
    double strTime; 
    UInt iters;     
    UInt strIters;  
  };
 
  class CpxLPWarmStart;
  typedef CpxLPWarmStart* CpxLPWarmStartPtr;
  typedef const CpxLPWarmStart* ConstCpxLPWarmStartPtr;
 
  class CpxLPWarmStart : public WarmStart {
 
  public:
    CpxLPWarmStart();
 
    ~CpxLPWarmStart();
 
    //CpxLPSolPtr getPoint();
 
    // Implement WarmStart::hasInfo().
    bool hasInfo();
 
    /*
     Overwrite the primal and dual values of warm-start. Sometimes, the
     warm-start data is initialized and needs to be updated. This
     should be called in place of deleting and creating a new warm-start
     object. */
    //void setPoint(CpxLPSolPtr sol);
 
    // Implement WarmStart::write().
    void write(std::ostream &) const {};
 
    // Return varstat array from warmstart
    //int *getVarStat() const { return varstat_;}
 
    // Return constat array from warmstart
    //int *getConStat() const { return constat_;}
 
    // Return the size of constat_ (number of constraints)
    //int getNumCons() const { return numCons_;}
 
    // Return solution from warmstart
    SolutionPtr getSolution() const { return sol_;}
 
    // Return the size of constat_ (number of constraints)
    //void setNumCons(int num) { numCons_ = num;}
 
    // Set varstat array for warmstart
    //void setVarStat(int *varstat, int numvars);
 
    // Set constat array for warmstart
    //void setConStat(int *constat, int numrows);
 
  private:
    bool mustDelete_;
 
    SolutionPtr sol_;
 
    //int * constat_;
 
    //int * varstat_;
 
    int numCons_;
  };
 
 
// ----------------------------------------------------------------------- //
// ----------------------------------------------------------------------- //
 
 
  class CplexLPEngine : public LPEngine {
  public:
    
    //static int lazycallback(CPXCENVptr env, void *cbdata, int wherefrom,
             //void *cbhandle, int *useraction_p);
    
    void doNothing();
    
    CplexLPEngine(EnvPtr env);
 
    ~CplexLPEngine();
 
    // 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();
 
    // Implement Engine::fillStats()
    void fillStats(std::vector<double> &);
 
    double getSolutionValue();
 
    // Implement Engine::getSolution().
    ConstSolutionPtr getSolution();
 
    // Implement Engine::getStatus().
    EngineStatus getStatus();
 
    // Return name of the solver.
    std::string getName() const;
 
    ConstWarmStartPtr getWarmStart() {return WarmStartPtr();};
 
    // Implement Engine::getWarmStartCopy().
    WarmStartPtr getWarmStartCopy();
 
    void load(ProblemPtr problem);
 
    void loadFromWarmStart(const WarmStartPtr){};
 
    // Convert 'min f' to 'min -f'.
    void negateObj();
 
    // Print a point x
    void printx(double *, UInt );
 
    // Print a point x
    void printx(const int *, UInt );
    
    // 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);
 
    // Implement Engine::setTimeLimit().
    void setTimeLimit(double);
 
    // Implement the LP solve() function of Cplex
    EngineStatus solve();
 
    void writeLP(const char *filename) const;
 
    void writeLP();
 
    void writeStats(std::ostream &out) const;
 
  private:
 
    CPXENVptr cpxenv_;
 
    CPXLPptr cpxlp_;
   
    int cpxstatus_;
 
    double timeLimit_;
 
    bool bndChanged_;
 
    bool consChanged_;
 
    EnvPtr env_;
 
    int maxIterLimit_;
 
    static const std::string me_;
 
    bool objChanged_;
 
    double dualObjLimit_;
 
    ProblemPtr problem_;
 
    SolutionPtr sol_;
 
    CplexLPStats *stats_;
 
    bool strBr_;
 
    CpxLPWarmStartPtr ws_;
 
    Timer *timer_;
 
    void load_();
  };
  
  typedef CplexLPEngine* CplexLPEnginePtr;
}
 
#endif