RhodeCode

namespace lemon {

    _prob = new ClpSimplex();

    _init_temporals();

    messageLevel(MESSAGE_NO_OUTPUT);

  }

    _prob = new ClpSimplex(*other._prob);

    rows = other.rows;

    cols = other.cols;

    messageLevel(MESSAGE_NO_OUTPUT);

  }

    delete _prob;

    _clear_temporals();

  }

    _primal_ray = 0;

    _dual_ray = 0;

  }

    if (_primal_ray) {

      delete[] _primal_ray;

      _primal_ray = 0;

    }

  }

    return newlp;

  }

    return copylp;

  }

    _prob->addColumn(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX, 0.0);

    return _prob->numberColumns() - 1;

  }

    _prob->addRow(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX);

    return _prob->numberRows() - 1;

  }

    _col_names_ref.erase(_prob->getColumnName(c));

    _prob->deleteColumns(1, &c);

  }

    _row_names_ref.erase(_prob->getRowName(r));

    _prob->deleteRows(1, &r);

  }

    cols.eraseIndex(i);

    cols.shiftIndices(i);

  }

    rows.eraseIndex(i);

    rows.shiftIndices(i);

  }

    name = _prob->getColumnName(c);

  }

    _prob->setColumnName(c, const_cast<std::string&>(name));

    _col_names_ref[name] = c;

  }

    std::map<std::string, int>::const_iterator it = _col_names_ref.find(name);

    return it != _col_names_ref.end() ? it->second : -1;

  }

    name = _prob->getRowName(r);

  }

    _prob->setRowName(r, const_cast<std::string&>(name));

    _row_names_ref[name] = r;

  }

    std::map<std::string, int>::const_iterator it = _row_names_ref.find(name);

    return it != _row_names_ref.end() ? it->second : -1;

  }

    std::map<int, Value> coeffs;

    int n = _prob->clpMatrix()->getNumCols();

    }

  }

    int n = _prob->clpMatrix()->getNumCols();

    const int* indices = _prob->clpMatrix()->getIndices();

    }

  }

    std::map<int, Value> coeffs;

    CoinBigIndex begin = _prob->clpMatrix()->getVectorStarts()[ix];

    }

  }

    CoinBigIndex begin = _prob->clpMatrix()->getVectorStarts()[ix];

    CoinBigIndex end = begin + _prob->clpMatrix()->getVectorLengths()[ix];

    }

  }

    _prob->modifyCoefficient(ix, jx, value);

  }

    CoinBigIndex begin = _prob->clpMatrix()->getVectorStarts()[ix];

    CoinBigIndex end = begin + _prob->clpMatrix()->getVectorLengths()[ix];

    }

  }

    _prob->setColumnLower(i, lo == - INF ? - COIN_DBL_MAX : lo);

  }

    double val = _prob->getColLower()[i];

    return val == - COIN_DBL_MAX ? - INF : val;

  }

    _prob->setColumnUpper(i, up == INF ? COIN_DBL_MAX : up);

  }

    double val = _prob->getColUpper()[i];

    return val == COIN_DBL_MAX ? INF : val;

  }

    _prob->setRowLower(i, lo == - INF ? - COIN_DBL_MAX : lo);

  }

    double val = _prob->getRowLower()[i];

    return val == - COIN_DBL_MAX ? - INF : val;

  }

    _prob->setRowUpper(i, up == INF ? COIN_DBL_MAX : up);

  }

    double val = _prob->getRowUpper()[i];

    return val == COIN_DBL_MAX ? INF : val;

  }

    int num = _prob->clpMatrix()->getNumCols();

    for (int i = 0; i < num; ++i) {

      _prob->setObjectiveCoefficient(i, 0.0);

    }

  }

    int num = _prob->clpMatrix()->getNumCols();

    for (int i = 0; i < num; ++i) {

      Value coef = _prob->getObjCoefficients()[i];

    }

  }

    _prob->setObjectiveCoefficient(i, obj_coef);

  }

    return _prob->getObjCoefficients()[i];

  }

    return _prob->primal() >= 0 ? SOLVED : UNSOLVED;

  }

    return _prob->primal() >= 0 ? SOLVED : UNSOLVED;

  }

    return _prob->dual() >= 0 ? SOLVED : UNSOLVED;

  }

    return _prob->barrier() >= 0 ? SOLVED : UNSOLVED;

  }

    return _prob->primalColumnSolution()[i];

  }

    return _prob->objectiveValue();

  }

    return _prob->dualRowSolution()[i];

  }

    if (!_primal_ray) {

      _primal_ray = _prob->unboundedRay();

      LEMON_ASSERT(_primal_ray != 0, "Primal ray is not provided");

    return _primal_ray[i];

  }

    if (!_dual_ray) {

      _dual_ray = _prob->infeasibilityRay();

      LEMON_ASSERT(_dual_ray != 0, "Dual ray is not provided");

    return _dual_ray[i];

  }

    switch (_prob->getColumnStatus(i)) {

    case ClpSimplex::basic:

      return BASIC;

    }

  }

    switch (_prob->getColumnStatus(i)) {

    case ClpSimplex::basic:

      return BASIC;

  }

    if (_prob->isProvenOptimal()) {

      return OPTIMAL;

    } else if (_prob->isProvenPrimalInfeasible()) {

    }

  }

    if (_prob->isProvenOptimal()) {

      return OPTIMAL;

    } else if (_prob->isProvenDualInfeasible()) {

    }

  }

    switch (sense) {

    case MIN:

      _prob->setOptimizationDirection(1);

    }

  }

    double dir = _prob->optimizationDirection();

    if (dir > 0.0) {

      return MIN;

    }

  }

    delete _prob;

    _prob = new ClpSimplex();

    rows.clear();

    _clear_temporals();

  }

    _prob->setLogLevel(static_cast<int>(m));

  }

  /// Clp library is an object oriented lp solver library developed at

  /// the IBM. The CLP is part of the COIN-OR package and it can be

  /// used with Common Public License.

  protected:

    ClpSimplex* _prob;

  public:

    /// \e

    /// \e

    /// \e

  protected:

  protected:

    virtual const char* _solverName() const;

    cols.clear();

  }

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

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

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

    _col_status.clear();

    _row_status.clear();

    _primal_ray.clear();

  // value does not necessarily mean that a solution exists. Use query

  // routines CPXsolninfo, CPXgetstat, and CPXsolution to obtain

  // further information about the status of the optimization.

#if CPX_VERSION >= 800

    if (status == 0) {

      switch (CPXgetstat(cplexEnv(), _prob)) {

#endif

  }

    _clear_temporals();

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

  }

    _clear_temporals();

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

  }

    _clear_temporals();

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

  }

    _clear_temporals();

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

  }

    Value x;

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

    return x;

  }

    Value y;

    CPXgetpi(cplexEnv(), _prob, &y, i, i);

    return y;

  }

    Value objval;

    CPXgetobjval(cplexEnv(), _prob, &objval);

    return objval;

  }

    if (_col_status.empty()) {

      _col_status.resize(CPXgetnumcols(cplexEnv(), _prob));

      CPXgetbase(cplexEnv(), _prob, &_col_status.front(), 0);

      return UPPER;

    default:

      LEMON_ASSERT(false, "Wrong column status");

    }

  }

    if (_row_status.empty()) {

      _row_status.resize(CPXgetnumrows(cplexEnv(), _prob));

      CPXgetbase(cplexEnv(), _prob, 0, &_row_status.front());

      return UPPER;

    default:

      LEMON_ASSERT(false, "Wrong row status");

    }

  }

    if (_primal_ray.empty()) {

      _primal_ray.resize(CPXgetnumcols(cplexEnv(), _prob));

      CPXgetray(cplexEnv(), _prob, &_primal_ray.front());

    return _primal_ray[i];

  }

    if (_dual_ray.empty()) {

    }

  void statusSwitch(CPXENVptr,int&){}

#endif

    // Unboundedness not treated well: the following is from cplex 9.0 doc

    // About Unboundedness

  // CPX_STAT_OPTIMAL_RELAXED

  // CPX_STAT_UNBOUNDED

    int stat = CPXgetstat(cplexEnv(), _prob);

#if CPX_VERSION >= 800

    switch (stat) {

#endif

  }

    : LpBase(), CplexBase(), MipSolver() {

#if CPX_VERSION < 800

#endif

  }

    : LpBase(), CplexBase(env), MipSolver() {

#if CPX_VERSION < 800

  }

    : LpBase(), CplexBase(other), MipSolver() {}

    // Note If a variable is to be changed to binary, a call to CPXchgbds

    // should also be made to change the bounds to 0 and 1.

    }

  }

    char t;

    CPXgetctype (cplexEnv(), _prob, &t, i, i);

    switch (t) {

  }

    int status;

    status = CPXmipopt (cplexEnv(), _prob);

    if (status==0)

  }

    int stat = CPXgetstat(cplexEnv(), _prob);

    // has a feasible solution.

  }

    Value x;

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

    return x;

  }

    Value objval;

    CPXgetmipobjval(cplexEnv(), _prob, &objval);

    return objval;

  ///

  /// This class implements an interface for the CPLEX LP solver.

  ///\ingroup lp_group

  public:

    /// \e

    /// \e

    /// \e

    /// \e

  private:

  protected:

    virtual const char* _solverName() const;

  ///

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

  ///\ingroup lp_group

  public:

    /// \e

    /// \e

    /// \e

    /// \e

  protected:

    virtual const char* _solverName() const;

    cols.clear();

  }

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

    messageLevel(MESSAGE_NO_OUTPUT);

  }

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

    messageLevel(MESSAGE_NO_OUTPUT);

  }

    _primal_ray.clear();

    _dual_ray.clear();

  }

    return solvePrimal();

  }

    _clear_temporals();

    glp_smcp smcp;

    return SOLVED;

  }

    _clear_temporals();

    glp_smcp smcp;

    return SOLVED;

  }

    return glp_get_col_prim(lp, i);

  }

    return glp_get_row_dual(lp, i);

  }

    return glp_get_obj_val(lp);

  }

    switch (glp_get_col_stat(lp, i)) {

    case GLP_BS:

      return BASIC;

      return FIXED;

    default:

      LEMON_ASSERT(false, "Wrong column status");

    }

  }

    switch (glp_get_row_stat(lp, i)) {

    case GLP_BS:

      return BASIC;

      return FIXED;

    default:

      LEMON_ASSERT(false, "Wrong row status");

    }

  }

    if (_primal_ray.empty()) {

      int row_num = glp_get_num_rows(lp);

      int col_num = glp_get_num_cols(lp);

    return _primal_ray[i];

  }

    if (_dual_ray.empty()) {

      int row_num = glp_get_num_rows(lp);

    return _dual_ray[i];

  }

    if (glp_get_status(lp) == GLP_OPT)

      return OPTIMAL;

    switch (glp_get_prim_stat(lp)) {

      return INFEASIBLE;

    default:

      LEMON_ASSERT(false, "Wrong primal type");

    }

  }

    if (glp_get_status(lp) == GLP_OPT)

      return OPTIMAL;

    switch (glp_get_dual_stat(lp)) {

      return INFEASIBLE;

    default:

      LEMON_ASSERT(false, "Wrong primal type");

    }

  }

    lpx_set_int_parm(lp, LPX_K_PRESOL, b ? 1 : 0);

  }

    _message_level = m;

  }

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

    messageLevel(MESSAGE_NO_OUTPUT);

  }

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

    messageLevel(MESSAGE_NO_OUTPUT);

  }

    switch (col_type) {

    case INTEGER:

      glp_set_col_kind(lp, i, GLP_IV);

    }

  }

    switch (glp_get_col_kind(lp, i)) {

    case GLP_IV:

    case GLP_BV:

  }

    glp_smcp smcp;

    glp_init_smcp(&smcp);

  }

    switch (glp_get_status(lp)) {

    case GLP_OPT:

      switch (glp_mip_status(lp)) {

        return OPTIMAL;

      default:

        LEMON_ASSERT(false, "Wrong problem type.");

      }

    case GLP_NOFEAS:

      return INFEASIBLE;

      }

    default:

      LEMON_ASSERT(false, "Wrong problem type.");

    }

  }

    return glp_mip_col_val(lp, i);

  }

    return glp_mip_obj_val(lp);

  }

    _message_level = m;

  }

  ///

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

  ///\ingroup lp_group

  public:

    ///\e

    ///\e

  private:

  protected:

    virtual const char* _solverName() const;

  ///

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

  ///\ingroup lp_group

  public:

    ///\e

    ///\e

  protected:

    virtual const char* _solverName() const;

  ///The default LP solver.

  ///\ingroup lp_group

  ///

  ///The default MIP solver identifier

  ///The default MIP solver.

  ///\ingroup lp_group

  ///