lp_solver_interface.hxx

Go to the documentation of this file.

#ifndef OPENGM_LP_SOLVER_INTERFACE_HXX_
#define OPENGM_LP_SOLVER_INTERFACE_HXX_

#include <opengm/inference/auxiliary/lpdef.hxx>

/*********************
 * class definition *
 *********************/
namespace opengm {

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
class LPSolverInterface {
public:
   // typedefs
   typedef LP_SOLVER_TYPE         SolverType;
   typedef VALUE_TYPE             SolverValueType;
   typedef INDEX_TYPE             SolverIndexType;
   typedef SOLUTION_ITERATOR_TYPE SolverSolutionIteratorType;
   typedef SOLVER_TIMING_TYPE     SolverTimingType;

   // enums
   enum Objective {Minimize, Maximize};

   // parameter
   struct Parameter {
      // constructor
      Parameter();

      // parameter
      int                 numberOfThreads_;
      bool                verbose_;
      double              cutUp_;
      double              epOpt_;
      double              epMrk_;
      double              epRHS_;
      double              epInt_;
      double              epAGap_;
      double              epGap_;
      double              workMem_;
      double              treeMemoryLimit_;
      double              timeLimit_;
      int                 probingLevel_;
      LPDef::LP_SOLVER    rootAlg_;
      LPDef::LP_SOLVER    nodeAlg_;
      LPDef::MIP_EMPHASIS mipEmphasis_;
      LPDef::LP_PRESOLVE  presolve_;
      LPDef::MIP_CUT      cutLevel_;
      LPDef::MIP_CUT      cliqueCutLevel_;
      LPDef::MIP_CUT      coverCutLevel_;
      LPDef::MIP_CUT      gubCutLevel_;
      LPDef::MIP_CUT      mirCutLevel_;
      LPDef::MIP_CUT      iboundCutLevel_;
      LPDef::MIP_CUT      flowcoverCutLevel_;
      LPDef::MIP_CUT      flowpathCutLevel_;
      LPDef::MIP_CUT      disjunctCutLevel_;
      LPDef::MIP_CUT      gomoryCutLevel_;
   };

   // solver infinity value
   static SolverValueType infinity();

   // constructor
   LPSolverInterface(const Parameter& parameter = Parameter());

   // destructor
   ~LPSolverInterface();

   // add Variables
   void addContinuousVariables(const SolverIndexType numVariables, const SolverValueType lowerBound, const SolverValueType upperBound);
   void addIntegerVariables(const SolverIndexType numVariables, const SolverValueType lowerBound, const SolverValueType upperBound);
   void addBinaryVariables(const SolverIndexType numVariables);

   // objective function
   void setObjective(const Objective objective);
   void setObjectiveValue(const SolverIndexType variable, const SolverValueType value);
   template<class ITERATOR_TYPE>
   void setObjectiveValue(ITERATOR_TYPE begin, const ITERATOR_TYPE end);
   template<class VARIABLES_ITERATOR_TYPE, class COEFFICIENTS_ITERATOR_TYPE>
   void setObjectiveValue(VARIABLES_ITERATOR_TYPE variableIDsBegin, const VARIABLES_ITERATOR_TYPE variableIDsEnd, COEFFICIENTS_ITERATOR_TYPE coefficientsBegin);

   // constraints
   template<class VARIABLES_ITERATOR_TYPE, class COEFFICIENTS_ITERATOR_TYPE>
   void addEqualityConstraint(VARIABLES_ITERATOR_TYPE variableIDsBegin, const VARIABLES_ITERATOR_TYPE variableIDsEnd, COEFFICIENTS_ITERATOR_TYPE coefficientsBegin, const SolverValueType bound, const std::string& constraintName = "");
   template<class VARIABLES_ITERATOR_TYPE, class COEFFICIENTS_ITERATOR_TYPE>
   void addLessEqualConstraint(VARIABLES_ITERATOR_TYPE variableIDsBegin, const VARIABLES_ITERATOR_TYPE variableIDsEnd, COEFFICIENTS_ITERATOR_TYPE coefficientsBegin, const SolverValueType bound, const std::string& constraintName = "");
   template<class VARIABLES_ITERATOR_TYPE, class COEFFICIENTS_ITERATOR_TYPE>
   void addGreaterEqualConstraint(VARIABLES_ITERATOR_TYPE variableIDsBegin, const VARIABLES_ITERATOR_TYPE variableIDsEnd, COEFFICIENTS_ITERATOR_TYPE coefficientsBegin, const SolverValueType bound, const std::string& constraintName = "");

   void addConstraintsFinished();
   void addConstraintsFinished(SolverTimingType& timing);

   // parameter
   template <class PARAMETER_TYPE, class PARAMETER_VALUE_TYPE>
   void setParameter(const PARAMETER_TYPE parameter, const PARAMETER_VALUE_TYPE value);

   // solve
   bool solve();
   bool solve(SolverTimingType& timing);

   // solution
   SolverSolutionIteratorType solutionBegin() const;
   SolverSolutionIteratorType solutionEnd() const;
   SolverValueType solution(const SolverIndexType variable) const;

   SolverValueType objectiveFunctionValue() const;
   SolverValueType objectiveFunctionValueBound() const;

   // model export
   void exportModel(const std::string& filename) const;
protected:
   // storage
   const Parameter parameter_;
};

} // namespace opengm

/***********************
 * class documentation *
 ***********************/
/******************
 * implementation *
 ******************/
namespace opengm {

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::Parameter::Parameter()
   : numberOfThreads_(LPDef::default_numberOfThreads_),
     verbose_(LPDef::default_verbose_), cutUp_(LPDef::default_cutUp_),
     epOpt_(LPDef::default_epOpt_), epMrk_(LPDef::default_epMrk_),
     epRHS_(LPDef::default_epRHS_), epInt_(LPDef::default_epInt_),
     epAGap_(LPDef::default_epAGap_), epGap_(LPDef::default_epGap_),
     workMem_(LPDef::default_workMem_),
     treeMemoryLimit_(LPDef::default_treeMemoryLimit_),
     timeLimit_(LPDef::default_timeLimit_),
     probingLevel_(LPDef::default_probingLevel_),
     rootAlg_(LPDef::default_rootAlg_), nodeAlg_(LPDef::default_nodeAlg_),
     mipEmphasis_(LPDef::default_mipEmphasis_),
     presolve_(LPDef::default_presolve_), cutLevel_(LPDef::default_cutLevel_),
     cliqueCutLevel_(LPDef::default_cliqueCutLevel_),
     coverCutLevel_(LPDef::default_coverCutLevel_),
     gubCutLevel_(LPDef::default_gubCutLevel_),
     mirCutLevel_(LPDef::default_mirCutLevel_),
     iboundCutLevel_(LPDef::default_iboundCutLevel_),
     flowcoverCutLevel_(LPDef::default_flowcoverCutLevel_),
     flowpathCutLevel_(LPDef::default_flowpathCutLevel_),
     disjunctCutLevel_(LPDef::default_disjunctCutLevel_),
     gomoryCutLevel_(LPDef::default_gomoryCutLevel_) {

}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline typename LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::SolverValueType LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::infinity() {
   return SolverType::infinity_impl();
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::LPSolverInterface(const Parameter& parameter)
   : parameter_(parameter) {

}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::~LPSolverInterface() {

}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline void LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::addContinuousVariables(const SolverIndexType numVariables, const SolverValueType lowerBound, const SolverValueType upperBound) {
   static_cast<SolverType*>(this)->addContinuousVariables_impl(numVariables, lowerBound, upperBound);
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline void LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::addIntegerVariables(const SolverIndexType numVariables, const SolverValueType lowerBound, const SolverValueType upperBound) {
   static_cast<SolverType*>(this)->addIntegerVariables_impl(numVariables, lowerBound, upperBound);
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline void LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::addBinaryVariables(const SolverIndexType numVariables) {
   static_cast<SolverType*>(this)->addBinaryVariables_impl(numVariables);
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline void LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::setObjective(const Objective objective) {
   static_cast<SolverType*>(this)->setObjective_impl(objective);
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline void LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::setObjectiveValue(const SolverIndexType variable, const SolverValueType value) {
   static_cast<SolverType*>(this)->setObjectiveValue_impl(variable, value);
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
template<class ITERATOR_TYPE>
inline void LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::setObjectiveValue(ITERATOR_TYPE begin, const ITERATOR_TYPE end) {
   static_cast<SolverType*>(this)->setObjectiveValue_impl(begin, end);
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
template<class VARIABLES_ITERATOR_TYPE, class COEFFICIENTS_ITERATOR_TYPE>
inline void LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::setObjectiveValue(VARIABLES_ITERATOR_TYPE variableIDsBegin, const VARIABLES_ITERATOR_TYPE variableIDsEnd, COEFFICIENTS_ITERATOR_TYPE coefficientsBegin) {
   static_cast<SolverType*>(this)->setObjectiveValue_impl(variableIDsBegin, variableIDsEnd, coefficientsBegin);
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
template<class VARIABLES_ITERATOR_TYPE, class COEFFICIENTS_ITERATOR_TYPE>
inline void LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::addEqualityConstraint(VARIABLES_ITERATOR_TYPE variableIDsBegin, const VARIABLES_ITERATOR_TYPE variableIDsEnd, COEFFICIENTS_ITERATOR_TYPE coefficientsBegin, const SolverValueType bound, const std::string& constraintName) {
   static_cast<SolverType*>(this)->addEqualityConstraint_impl(variableIDsBegin, variableIDsEnd, coefficientsBegin, bound, constraintName);
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
template<class VARIABLES_ITERATOR_TYPE, class COEFFICIENTS_ITERATOR_TYPE>
inline void LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::addLessEqualConstraint(VARIABLES_ITERATOR_TYPE variableIDsBegin, const VARIABLES_ITERATOR_TYPE variableIDsEnd, COEFFICIENTS_ITERATOR_TYPE coefficientsBegin, const SolverValueType bound, const std::string& constraintName) {
   static_cast<SolverType*>(this)->addLessEqualConstraint_impl(variableIDsBegin, variableIDsEnd, coefficientsBegin, bound, constraintName);
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
template<class VARIABLES_ITERATOR_TYPE, class COEFFICIENTS_ITERATOR_TYPE>
inline void LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::addGreaterEqualConstraint(VARIABLES_ITERATOR_TYPE variableIDsBegin, const VARIABLES_ITERATOR_TYPE variableIDsEnd, COEFFICIENTS_ITERATOR_TYPE coefficientsBegin, const SolverValueType bound, const std::string& constraintName) {
   static_cast<SolverType*>(this)->addGreaterEqualConstraint_impl(variableIDsBegin, variableIDsEnd, coefficientsBegin, bound, constraintName);
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline void LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::addConstraintsFinished() {
   static_cast<SolverType*>(this)->addConstraintsFinished_impl();
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline void LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::addConstraintsFinished(SolverTimingType& timing) {
   static_cast<SolverType*>(this)->addConstraintsFinished_impl(timing);
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
template <class PARAMETER_TYPE, class PARAMETER_VALUE_TYPE>
inline void LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::setParameter(const PARAMETER_TYPE parameter, const PARAMETER_VALUE_TYPE value) {
   static_cast<SolverType*>(this)->setParameter_impl(parameter, value);
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline bool LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::solve() {
   return static_cast<SolverType*>(this)->solve_impl();
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline bool LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::solve(SolverTimingType& timing) {
   return static_cast<SolverType*>(this)->solve_impl(timing);
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline typename LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::SolverSolutionIteratorType LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::solutionBegin() const {
   return static_cast<const SolverType*>(this)->solutionBegin_impl();
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline typename LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::SolverSolutionIteratorType LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::solutionEnd() const {
   return static_cast<const SolverType*>(this)->solutionEnd_impl();
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline typename LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::SolverValueType LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::solution(const SolverIndexType variable) const {
   return static_cast<const SolverType*>(this)->solution_impl(variable);
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline typename LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::SolverValueType LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::objectiveFunctionValue() const {
   return static_cast<const SolverType*>(this)->objectiveFunctionValue_impl();
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline typename LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::SolverValueType LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::objectiveFunctionValueBound() const {
   return static_cast<const SolverType*>(this)->objectiveFunctionValueBound_impl();
}

template <class LP_SOLVER_TYPE, class VALUE_TYPE, class INDEX_TYPE, class SOLUTION_ITERATOR_TYPE, class SOLVER_TIMING_TYPE>
inline void LPSolverInterface<LP_SOLVER_TYPE, VALUE_TYPE, INDEX_TYPE, SOLUTION_ITERATOR_TYPE, SOLVER_TIMING_TYPE>::exportModel(const std::string& filename) const {
   static_cast<const SolverType*>(this)->exportModel_impl(filename);
}

} // namespace opengm

#endif /* OPENGM_LP_SOLVER_INTERFACE_HXX_ */