RhodeCode

  CbcMip::CbcMip() {

    _prob = new CoinModel();

    _prob->setProblemName("LEMON");

    _osi_solver = 0;

    _cbc_model = 0;

  }

  CbcMip::CbcMip(const CbcMip& other) {

    _prob = new CoinModel(*other._prob);

    _osi_solver = 0;

    _cbc_model = 0;

  }

  CbcMip::~CbcMip() {

    delete _prob;

    if (_osi_solver) delete _osi_solver;

    if (_cbc_model) delete _cbc_model;

    if (_cbc_model) {

      delete _cbc_model;

    }

    _cbc_model= new CbcModel(*_osi_solver);

    _cbc_model->initialSolve();

    _cbc_model->solver()->setHintParam(OsiDoReducePrint, true, OsiHintTry);

    if (!_cbc_model->isInitialSolveAbandoned() &&

        _cbc_model->isInitialSolveProvenOptimal() &&

    _prob = new CoinModel();

    rows.clear();

    cols.clear();

  }

  }

} //END OF NAMESPACE LEMON

    virtual ProblemType _getType() const;

    virtual Value _getSol(int i) const;

    virtual Value _getSolValue() const;

    virtual void _clear();

  };

}

namespace lemon {

  ClpLp::ClpLp() {

    _prob = new ClpSimplex();

    _init_temporals();

  }

  ClpLp::ClpLp(const ClpLp& other) {

    _prob = new ClpSimplex(*other._prob);

    rows = other.rows;

    cols = other.cols;

    _init_temporals();

  }

  ClpLp::~ClpLp() {

    delete _prob;

    _clear_temporals();

  }

    rows.clear();

    cols.clear();

    _col_names_ref.clear();

    _clear_temporals();

  }

  }

} //END OF NAMESPACE LEMON

    virtual ProblemType _getPrimalType() const;

    virtual ProblemType _getDualType() const;

    virtual void _clear();

  public:

    ///Solves LP with primal simplex method.

    SolveExitStatus solvePrimal();

    ///Solves LP with dual simplex method.

    ///Returns the constraint identifier understood by CLP.

    int clpRow(Row r) const { return rows(id(r)); }

    ///Returns the variable identifier understood by CLP.

    int clpCol(Col c) const { return cols(id(c)); }

  };

} //END OF NAMESPACE LEMON

#endif //LEMON_CLP_H

    }

  }

  CplexBase::CplexBase() : LpBase() {

    int status;

    _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");

  }

  CplexBase::CplexBase(const CplexEnv& env)

    : LpBase(), _env(env) {

    int status;

    _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");

  }

  CplexBase::CplexBase(const CplexBase& cplex)

    : LpBase() {

    int status;

    _prob = CPXcloneprob(cplexEnv(), cplex._prob, &status);

    rows = cplex.rows;

    cols = cplex.cols;

  }

  CplexBase::~CplexBase() {

    CPXfreeprob(cplexEnv(),&_prob);

  }

    int status;

    _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");

    rows.clear();

    cols.clear();

  }

  // CplexLp members

  CplexLp::CplexLp()

    : LpBase(), LpSolver(), CplexBase() {}

  CplexLp::CplexLp(const CplexEnv& env)

    }

#endif

  }

  CplexLp::SolveExitStatus CplexLp::_solve() {

    _clear_temporals();

    return convertStatus(CPXlpopt(cplexEnv(), _prob));

  }

  CplexLp::SolveExitStatus CplexLp::solvePrimal() {

    _clear_temporals();

    return convertStatus(CPXprimopt(cplexEnv(), _prob));

  }

  CplexLp::SolveExitStatus CplexLp::solveDual() {

    _clear_temporals();

    return convertStatus(CPXdualopt(cplexEnv(), _prob));

  }

  CplexLp::SolveExitStatus CplexLp::solveBarrier() {

    _clear_temporals();

    return convertStatus(CPXbaropt(cplexEnv(), _prob));

  }

  CplexLp::Value CplexLp::_getPrimal(int i) const {

    Value x;

    CPXgetx(cplexEnv(), _prob, &x, i, i);

    if (_dual_ray.empty()) {

    }

    return _dual_ray[i];

  }

  // This table lists the statuses, returned by the CPXgetstat()

  // routine, for solutions to LP problems or mixed integer problems. If

  // no solution exists, the return value is zero.

  // For Simplex, Barrier

  // 1          CPX_OPTIMAL

  //          Aborted in crossover

  // 19          CPX_INForUNBD

  //          Infeasible or unbounded

  // 20   CPX_PIVOT

  //       User pivot used

  //

  // ??case CPX_ABORT_DUAL_INFEAS

  // ??case CPX_ABORT_CROSSOVER

  // ??case CPX_INForUNBD

  // ??case CPX_PIVOT

  //Some more interesting stuff:

      default:

        return UNDEFINED;

      }

#else

    statusSwitch(cplexEnv(),stat);

    //CPXgetstat(cplexEnv(), _prob);

    switch (stat) {

    case 0:

      return UNDEFINED; //Undefined

    case CPX_OPTIMAL://Optimal

      return OPTIMAL;

    case CPX_UNBOUNDED://Unbounded

      return UNDEFINED; //Everything else comes here

      //FIXME error

    }

#endif

  }

  // CPX_STAT_ABORT_DUAL_OBJ_LIM

  // CPX_STAT_ABORT_IT_LIM

  // CPX_STAT_ABORT_OBJ_LIM

  // CPX_STAT_ABORT_PRIM_OBJ_LIM

  // CPX_STAT_ABORT_TIME_LIM

  // CPX_STAT_ABORT_USER

    }

  }

  CplexMip::SolveExitStatus CplexMip::_solve() {

    int status;

    status = CPXmipopt (cplexEnv(), _prob);

    if (status==0)

      return SOLVED;

    else

      return UNSOLVED;

    virtual void _setSense(Sense sense);

    virtual Sense _getSense() const;

    virtual void _clear();

  public:

    /// Returns the used \c CplexEnv instance

    const CplexEnv& env() const { return _env; }

    ///

    const cpxenv* cplexEnv() const { return _env.cplexEnv(); }

    cpxlp* cplexLp() { return _prob; }

    const cpxlp* cplexLp() const { return _prob; }

  };

  /// \brief Interface for the CPLEX LP solver

  ///

  // GlpkBase members

  GlpkBase::GlpkBase() : LpBase() {

    lp = glp_create_prob();

    glp_create_index(lp);

  }

  GlpkBase::GlpkBase(const GlpkBase &other) : LpBase() {

    lp = glp_create_prob();

    glp_copy_prob(lp, other.lp, GLP_ON);

    glp_create_index(lp);

    rows = other.rows;

    cols = other.cols;

  }

  GlpkBase::~GlpkBase() {

    glp_delete_prob(lp);

  }

  }

  void GlpkBase::freeEnv() {

    glp_free_env();

  }

  GlpkBase::FreeEnvHelper GlpkBase::freeEnvHelper;

  // GlpkLp members

  GlpkLp::GlpkLp()

    : LpBase(), LpSolver(), GlpkBase() {

    presolver(false);

  }

  GlpkLp::GlpkLp(const GlpkLp& other)

    : LpBase(other), LpSolver(other), GlpkBase(other) {

    presolver(false);

  }

  GlpkLp* GlpkLp::newSolver() const { return new GlpkLp; }

  GlpkLp* GlpkLp::cloneSolver() const { return new GlpkLp(*this); }

  GlpkLp::SolveExitStatus GlpkLp::solvePrimal() {

    _clear_temporals();

    glp_smcp smcp;

    glp_init_smcp(&smcp);

    smcp.presolve = _presolve;

    // If the basis is not valid we get an error return value.

    // In this case we can try to create a new basis.

    switch (glp_simplex(lp, &smcp)) {

    case 0:

  GlpkLp::SolveExitStatus GlpkLp::solveDual() {

    _clear_temporals();

    glp_smcp smcp;

    glp_init_smcp(&smcp);

    smcp.meth = GLP_DUAL;

    smcp.presolve = _presolve;

    // If the basis is not valid we get an error return value.

    // In this case we can try to create a new basis.

    switch (glp_simplex(lp, &smcp)) {

  }

  void GlpkLp::presolver(bool presolve) {

    _presolve = presolve;

  }

  // GlpkMip members

  GlpkMip::GlpkMip()

    : LpBase(), MipSolver(), GlpkBase() {

  }

  GlpkMip::GlpkMip(const GlpkMip& other)

    : LpBase(), MipSolver(), GlpkBase(other) {

  }

  void GlpkMip::_setColType(int i, GlpkMip::ColTypes col_type) {

    switch (col_type) {

    case INTEGER:

      glp_set_col_kind(lp, i, GLP_IV);

  }

  GlpkMip::SolveExitStatus GlpkMip::_solve() {

    glp_smcp smcp;

    glp_init_smcp(&smcp);

    smcp.meth = GLP_DUAL;

    // If the basis is not valid we get an error return value.

    // In this case we can try to create a new basis.

    switch (glp_simplex(lp, &smcp)) {

    case 0:

    if (glp_get_status(lp) != GLP_OPT) return SOLVED;

    glp_iocp iocp;

    glp_init_iocp(&iocp);

    if (glp_intopt(lp, &iocp) != 0) return UNSOLVED;

    return SOLVED;

  }

  GlpkMip* GlpkMip::newSolver() const { return new GlpkMip; }

  GlpkMip* GlpkMip::cloneSolver() const {return new GlpkMip(*this); }

  const char* GlpkMip::_solverName() const { return "GlpkMip"; }

} //END OF NAMESPACE LEMON

    virtual void _setSense(Sense);

    virtual Sense _getSense() const;

    virtual void _clear();

  private:

    static void freeEnv();

    struct FreeEnvHelper {

      ~FreeEnvHelper() {

        freeEnv();

      }

    };

    static FreeEnvHelper freeEnvHelper;

  public:

    ///Pointer to the underlying GLPK data structure.

    LPX *lpx() {return lp;}

    ///Const pointer to the underlying GLPK data structure.

    const LPX *lpx() const {return lp;}

    ///Turns on (\c b is \c true) or off (\c b is \c false) the presolver

    ///

    ///The presolver is off by default.

    void presolver(bool presolve);

  };

  /// \brief Interface for the GLPK MIP solver

  ///

  /// This class implements an interface for the GLPK MIP solver.

  ///\ingroup lp_group

    virtual SolveExitStatus _solve();

    virtual ProblemType _getType() const;

    virtual Value _getSol(int i) const;

    virtual Value _getSolValue() const;

  };

} //END OF NAMESPACE LEMON

#endif //LEMON_GLPK_H

      /// Minimization

      MIN,

      /// Maximization

      MAX

    };

    ///The floating point type used by the solver

    typedef double Value;

    ///The infinity constant

    static const Value INF;

    ///The not a number constant

    static const Value NaN;

    virtual Sense _getSense() const = 0;

    virtual void _clear() = 0;

    virtual const char* _solverName() const = 0;

    //Own protected stuff

    //Constant component of the objective function

    Value obj_const_comp;

    LpBase() : rows(), cols(), obj_const_comp(0) {}

    ///Set the sense to maximization

    void min() { _setSense(MIN); }

    ///Clears the problem

    void clear() { _clear(); }

    ///@}

  };

  /// Addition

  { return MIN; }

  void SkeletonSolverBase::_clear() {

    row_num = col_num = 0;

  }

  LpSkeleton::SolveExitStatus LpSkeleton::_solve() { return SOLVED; }

  LpSkeleton::Value LpSkeleton::_getPrimal(int) const { return 0; }

  LpSkeleton::Value LpSkeleton::_getDual(int) const { return 0; }

  LpSkeleton::Value LpSkeleton::_getPrimalValue() const { return 0; }

    ///\e

    virtual Sense _getSense() const;

    ///\e

    virtual void _clear();

  };

  /// \brief Skeleton class for an LP solver interface

  ///

  ///This class does nothing, but it can serve as a skeleton when

  ///implementing an interface to new solvers.

 */

#include <iostream>

#include <lemon/soplex.h>

#include <soplex.h>

///\file

///\brief Implementation of the LEMON-SOPLEX lp solver interface.

namespace lemon {

  SoplexLp::SoplexLp() {

    soplex = new soplex::SoPlex;

  }

  SoplexLp::~SoplexLp() {

    delete soplex;

  }

    _col_names = lp._col_names;

    _col_names_ref = lp._col_names_ref;

    _row_names = lp._row_names;

    _row_names_ref = lp._row_names_ref;

  }

  void SoplexLp::_clear_temporals() {

    _primal_values.clear();

    _dual_values.clear();

  }

  }

  SoplexLp::SolveExitStatus SoplexLp::_solve() {

    _clear_temporals();

    soplex::SPxSolver::Status status = soplex->solve();

    switch (status) {

    case soplex::SPxSolver::OPTIMAL:

    case soplex::SPxSolver::INFEASIBLE:

    case soplex::SPxSolver::UNBOUNDED:

    _row_names_ref.clear();

    cols.clear();

    rows.clear();

    _clear_temporals();

  }

} //namespace lemon

    virtual ProblemType _getPrimalType() const;

    virtual ProblemType _getDualType() const;

    virtual void _clear();

  };

} //END OF NAMESPACE LEMON

#endif //LEMON_SOPLEX_H