RhodeCode

    _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;

      delete _cbc_model;

    }

    _cbc_model= new CbcModel(*_osi_solver);

    _cbc_model->initialSolve();

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

    rows.clear();

    cols.clear();

  }

  }

} //END OF NAMESPACE LEMON

    virtual Value _getSolValue() const;

    virtual void _clear();

  };

}

  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;

    _col_names_ref.clear();

    _clear_temporals();

  }

  }

} //END OF NAMESPACE LEMON

    virtual ProblemType _getDualType() const;

    virtual void _clear();

  public:

    ///Solves LP with primal simplex method.

    SolveExitStatus solvePrimal();

    ///Returns the variable identifier understood by CLP.

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

  };

} //END OF NAMESPACE LEMON

  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);

    rows.clear();

    cols.clear();

  }

  // CplexLp members

  CplexLp::CplexLp()

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

  }

  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 {

    }

    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.

  //          Infeasible or unbounded

  // 20   CPX_PIVOT

  //       User pivot used

  //

  // ??case CPX_ABORT_DUAL_INFEAS

  // ??case CPX_ABORT_CROSSOVER

  // ??case CPX_INForUNBD

  // ??case CPX_PIVOT

      }

#else

    statusSwitch(cplexEnv(),stat);

    //CPXgetstat(cplexEnv(), _prob);

    switch (stat) {

    case 0:

      return UNDEFINED; //Undefined

    case CPX_OPTIMAL://Optimal

    }

#endif

  }

  // CPX_STAT_ABORT_DUAL_OBJ_LIM

  // CPX_STAT_ABORT_IT_LIM

  // CPX_STAT_ABORT_OBJ_LIM

  // CPX_STAT_ABORT_PRIM_OBJ_LIM

  }

  CplexMip::SolveExitStatus CplexMip::_solve() {

    int status;

    status = CPXmipopt (cplexEnv(), _prob);

    if (status==0)

      return SOLVED;

    else

    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; }

  };

  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; }

    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.

    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.

  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) {

  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.

    glp_iocp iocp;

    glp_init_iocp(&iocp);

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

    return SOLVED;

  }

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

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

} //END OF NAMESPACE LEMON

    virtual Sense _getSense() const;

    virtual void _clear();

  private:

    static void freeEnv();

      }

    };

    static FreeEnvHelper freeEnvHelper;

  public:

    ///Pointer to the underlying GLPK data structure.

    ///

    ///The presolver is off by default.

    void presolver(bool presolve);

  };

  /// \brief Interface for the GLPK MIP solver

  ///

    virtual ProblemType _getType() const;

    virtual Value _getSol(int i) const;

    virtual Value _getSolValue() const;

  };

} //END OF NAMESPACE LEMON

      /// Maximization

      MAX

    };

    ///The floating point type used by the solver

    typedef double Value;

    ///The infinity constant

    static const Value INF;

    virtual void _clear() = 0;

    virtual const char* _solverName() const = 0;

    //Own protected stuff

    //Constant component of the objective function

    Value obj_const_comp;

    ///Clears the problem

    void clear() { _clear(); }

    ///@}

  };

  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; }

    ///\e

    virtual void _clear();

  };

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

  ///

#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;

    _row_names = lp._row_names;

    _row_names_ref = lp._row_names_ref;

  }

  void SoplexLp::_clear_temporals() {

    _primal_values.clear();

  SoplexLp::SolveExitStatus SoplexLp::_solve() {

    _clear_temporals();

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

    switch (status) {

    rows.clear();

    _clear_temporals();

  }

} //namespace lemon

    virtual ProblemType _getDualType() const;

    virtual void _clear();

  };

} //END OF NAMESPACE LEMON