RhodeCode

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

    }

    _cbc_model= new CbcModel(*_osi_solver);

    _cbc_model->initialSolve();

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

    cols.clear();

  }

  }

} //END OF NAMESPACE LEMON

    virtual void _clear();

  };

  ClpLp::ClpLp() {

    _prob = new ClpSimplex();

    _init_temporals();

  }

  ClpLp::ClpLp(const ClpLp& other) {

    rows = other.rows;

    cols = other.cols;

    _init_temporals();

  }

  ClpLp::~ClpLp() {

    _clear_temporals();

  }

  }

} //END OF NAMESPACE LEMON

    virtual void _clear();

  public:

    ///Solves LP with primal simplex method.

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

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

    rows = cplex.rows;

    cols = cplex.cols;

  }

  CplexBase::~CplexBase() {

    cols.clear();

  }

  // CplexLp members

  CplexLp::CplexLp()

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

  }

    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.

  // 20   CPX_PIVOT

  //       User pivot used

  //

  // ??case CPX_ABORT_DUAL_INFEAS

  // ??case CPX_ABORT_CROSSOVER

  // ??case CPX_INForUNBD

#else

    statusSwitch(cplexEnv(),stat);

    //CPXgetstat(cplexEnv(), _prob);

    switch (stat) {

    case 0:

      return UNDEFINED; //Undefined

#endif

  }

  // CPX_STAT_ABORT_DUAL_OBJ_LIM

  // CPX_STAT_ABORT_IT_LIM

  // CPX_STAT_ABORT_OBJ_LIM

  CplexMip::SolveExitStatus CplexMip::_solve() {

    int status;

    status = CPXmipopt (cplexEnv(), _prob);

    if (status==0)

      return SOLVED;

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

    glp_create_index(lp);

    rows = other.rows;

    cols = other.cols;

  }

  GlpkBase::~GlpkBase() {

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

  }

    glp_smcp smcp;

    glp_init_smcp(&smcp);

    smcp.presolve = _presolve;

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

    glp_smcp smcp;

    glp_init_smcp(&smcp);

    smcp.meth = GLP_DUAL;

    smcp.presolve = _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) {

    glp_smcp smcp;

    glp_init_smcp(&smcp);

    smcp.meth = GLP_DUAL;

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

    glp_iocp iocp;

    glp_init_iocp(&iocp);

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

    return SOLVED;

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

} //END OF NAMESPACE LEMON

    virtual void _clear();

  private:

    static void freeEnv();

    };

    static FreeEnvHelper freeEnvHelper;

  public:

    ///The presolver is off by default.

    void presolver(bool presolve);

  };

  /// \brief Interface for the GLPK MIP solver

    virtual Value _getSol(int i) const;

    virtual Value _getSolValue() const;

  };

      MAX

    };

    ///The floating point type used by the solver

    typedef double Value;

    ///The infinity constant

    virtual const char* _solverName() const = 0;

    //Own protected stuff

    //Constant component of the objective function

    ///Clears the problem

    void clear() { _clear(); }

    ///@}

  };

    row_num = col_num = 0;

  }

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

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

    ///\e

    virtual void _clear();

  };

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

#include <lemon/soplex.h>

#include <soplex.h>

///\file

  SoplexLp::SoplexLp() {

    soplex = new soplex::SoPlex;

  }

  SoplexLp::~SoplexLp() {

    _row_names = lp._row_names;

    _row_names_ref = lp._row_names_ref;

  }

  void SoplexLp::_clear_temporals() {

  SoplexLp::SolveExitStatus SoplexLp::_solve() {

    _clear_temporals();

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

    _clear_temporals();

  }

} //namespace lemon

    virtual void _clear();

  };

} //END OF NAMESPACE LEMON

    aTest(lp_cplex2);

    cloneTest<CplexLp>();

  } catch (CplexEnv::LicenseError& error) {

    check(false, error.what());

  }

#endif

    aTest(mip2);

    cloneTest<CplexMip>();

  } catch (CplexEnv::LicenseError& error) {

    check(false, error.what());

  }

#endif

        -e "s/\<\([Ff]\)orkWriteMap\>/\1orkMap/g"\

        -e "s/\<StoreBoolMap\>/LoggerBoolMap/g"\

        -e "s/\<storeBoolMap\>/loggerBoolMap/g"\

        -e "s/\<BoundingBox\>/Box/g"\

        -e "s/\<readNauty\>/readNautyGraph/g"\

        -e "s/\<RevDigraphAdaptor\>/ReverseDigraph/g"\