RhodeCode

#include <coin/ClpSimplex.hpp>

namespace lemon {

    _prob = new ClpSimplex();

    _init_temporals();

    messageLevel(MESSAGE_NO_OUTPUT);

  }

    _prob = new ClpSimplex(*other._prob);

    rows = other.rows;

    cols = other.cols;

    _init_temporals();

    messageLevel(MESSAGE_NO_OUTPUT);

  }

    delete _prob;

    _clear_temporals();

  }

    _primal_ray = 0;

    _dual_ray = 0;

  }

    if (_primal_ray) {

      delete[] _primal_ray;

      _primal_ray = 0;

    }

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

      _prob->modifyCoefficient(ix, it->first, it->second);

    }

  }

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

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

    const double* elements = _prob->clpMatrix()->getElements();

      }

    }

  }

    std::map<int, Value> coeffs;

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

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

      _prob->modifyCoefficient(it->first, ix, it->second);

    }

  }

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

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

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

      ++b;

    }

  }

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

  }

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

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

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

      return 0.0;

    }

  }

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

    }

      _prob->setObjectiveCoefficient(it->first, it->second);

    }

  }

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

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

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

      if (coef != 0.0) {

      }

    }

  }

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

    case ClpSimplex::isFree:

      return VarStatus();

    }

  }

    switch (_prob->getColumnStatus(i)) {

    case ClpSimplex::basic:

      return BASIC;

    case ClpSimplex::isFree:

    }

  }

    if (_prob->isProvenOptimal()) {

      return OPTIMAL;

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

      return INFEASIBLE;

      return UNDEFINED;

    }

  }

    if (_prob->isProvenOptimal()) {

      return OPTIMAL;

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

      return INFEASIBLE;

      return UNDEFINED;

    }

  }

    switch (sense) {

    case MIN:

      _prob->setOptimizationDirection(1);

      break;

      break;

    }

  }

    double dir = _prob->optimizationDirection();

    if (dir > 0.0) {

      return MIN;

    } else {

      return MAX;

    }

  }

    delete _prob;

    _prob = new ClpSimplex();

    rows.clear();

    cols.clear();

    _col_names_ref.clear();

    _clear_temporals();

  }

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

  }

} //END OF NAMESPACE LEMON

  /// This class implements an interface for the Clp LP solver.  The

  /// 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:

    mutable double* _primal_ray;

    void _clear_temporals();

  protected:

    virtual const char* _solverName() const;

    virtual int _addCol();

    rows.clear();

    cols.clear();

  }

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

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

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

    _col_status.clear();

    _row_status.clear();

    _primal_ray.clear();

    _dual_ray.clear();

  // unbounded, are not considered errors. Note that a zero return

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

      case CPX_STAT_OPTIMAL:

    }

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

    }

    case CPX_AT_UPPER:

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

    }

    case CPX_AT_UPPER:

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

    }

    return _dual_ray[i];

#else

  void statusSwitch(CPXENVptr,int&){}

#endif

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

    // About Unboundedness

    // The treatment of models that are unbounded involves a few

  // CPX_STAT_OPTIMAL_INFEAS

  // CPX_STAT_OPTIMAL_RELAXED

  // CPX_STAT_UNBOUNDED

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

#if CPX_VERSION >= 800

    switch (stat) {

    case CPX_STAT_OPTIMAL:

    }

#endif

  }

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

#if CPX_VERSION < 800

    CPXchgprobtype(cplexEnv(),  _prob, CPXPROB_MIP);

    CPXchgprobtype(cplexEnv(),  _prob, CPXPROB_MILP);

#endif

  }

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

#if CPX_VERSION < 800

    CPXchgprobtype(cplexEnv(),  _prob, CPXPROB_MIP);

#endif

  }

    : 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.

      break;

    }

  }

    char t;

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

    switch (t) {

    case 'I':

    }

  }

    int status;

    status = CPXmipopt (cplexEnv(), _prob);

    if (status==0)

      return SOLVED;

  }

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

    //Fortunately, MIP statuses did not change for cplex 8.0

    // to determine whether ILOG CPLEX has also concluded that the model

    // has a feasible solution.

  }

    Value x;

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

    return x;

  }

    Value objval;

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

    return objval;

  }

  /// \brief Interface for the CPLEX LP solver

  ///

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

  ///\ingroup lp_group

  public:

    /// \e

    /// \e

    /// \e

    /// \e

  private:

    // these values cannot retrieved element by element

    SolveExitStatus convertStatus(int status);

  protected:

    virtual const char* _solverName() const;

    virtual SolveExitStatus _solve();

  /// \brief Interface for the CPLEX MIP solver

  ///

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

  ///\ingroup lp_group

  public:

    /// \e

    /// \e

    /// \e

    /// \e

  protected:

    virtual const char* _solverName() const;

    virtual ColTypes _getColType(int col) const;

    rows.clear();

    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;

    glp_init_smcp(&smcp);

    if (glp_simplex(lp, &smcp) != 0) return UNSOLVED;

    return SOLVED;

  }

    _clear_temporals();

    glp_smcp smcp;

    glp_init_smcp(&smcp);

    if (glp_simplex(lp, &smcp) != 0) return UNSOLVED;

    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;

    case GLP_UP:

    case GLP_NS:

      return FIXED;

    default:

      LEMON_ASSERT(false, "Wrong column status");

    }

  }

    switch (glp_get_row_stat(lp, i)) {

    case GLP_BS:

      return BASIC;

    case GLP_UP:

    case GLP_NS:

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

      _dual_ray.resize(row_num + 1, 0.0);

    }

    return _dual_ray[i];

  }

    if (glp_get_status(lp) == GLP_OPT)

      return OPTIMAL;

    switch (glp_get_prim_stat(lp)) {

    case GLP_UNDEF:

    case GLP_NOFEAS:

      return INFEASIBLE;

    default:

      LEMON_ASSERT(false, "Wrong primal type");

    }

  }

    if (glp_get_status(lp) == GLP_OPT)

      return OPTIMAL;

    switch (glp_get_dual_stat(lp)) {

    case GLP_UNDEF:

    case GLP_NOFEAS:

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

      break;

      break;

    }

  }

    switch (glp_get_col_kind(lp, i)) {

    case GLP_IV:

    case GLP_BV:

      return INTEGER;

    }

  }

    glp_smcp smcp;

    glp_init_smcp(&smcp);

    switch (_message_level) {

    return SOLVED;

  }

    switch (glp_get_status(lp)) {

    case GLP_OPT:

      switch (glp_mip_status(lp)) {

      case GLP_UNDEF:

      case GLP_OPT:

        return OPTIMAL;

      default:

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

      }

    case GLP_NOFEAS:

      return INFEASIBLE;

    case GLP_INFEAS:

        return UNDEFINED;

      }

    default:

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

    }

  }

    return glp_mip_col_val(lp, i);

  }