RhodeCode

      _primal_ray = 0;

    }

    if (_dual_ray) {

      delete[] _dual_ray;

      _dual_ray = 0;

    }

  }

    ClpLp* newlp = new ClpLp;

    return newlp;

  }

    ClpLp* copylp = new ClpLp(*this);

    return copylp;

  }

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

  int ClpLp::_addCol() {

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

    /// \e

    ClpLp();

    /// \e

    ClpLp(const ClpLp&);

    /// \e

    ~ClpLp();

  protected:

    mutable double* _primal_ray;

    mutable double* _dual_ray;

    void _init_temporals();

    void _clear_temporals();

  protected:

    virtual const char* _solverName() const;

    virtual int _addCol();

    virtual int _addRow();

    virtual void _eraseCol(int i);

    virtual void _eraseRow(int i);

  CplexLp::CplexLp(const CplexEnv& env)

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

  CplexLp::CplexLp(const CplexLp& other)

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

  CplexLp::~CplexLp() {}

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

  void CplexLp::_clear_temporals() {

    _col_status.clear();

    _row_status.clear();

    _primal_ray.clear();

    _dual_ray.clear();

  }

  CplexMip::CplexMip(const CplexMip& other)

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

  CplexMip::~CplexMip() {}

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

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

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

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

  };

  /// \brief Interface for the CPLEX LP solver

  ///

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

  ///\ingroup lp_group

  public:

    /// \e

    CplexLp();

    /// \e

    CplexLp(const CplexEnv&);

    /// \e

    CplexLp(const CplexLp&);

    /// \e

    virtual ~CplexLp();

  private:

    // these values cannot retrieved element by element

    mutable std::vector<int> _col_status;

    mutable std::vector<int> _row_status;

    mutable std::vector<Value> _primal_ray;

    mutable std::vector<Value> _dual_ray;

    void _clear_temporals();

    SolveExitStatus convertStatus(int status);

  protected:

    virtual const char* _solverName() const;

    virtual SolveExitStatus _solve();

    virtual Value _getPrimal(int i) const;

    virtual Value _getDual(int i) const;

    virtual Value _getPrimalValue() const;

    virtual VarStatus _getColStatus(int i) const;

    SolveExitStatus solveBarrier();

  };

  /// \brief Interface for the CPLEX MIP solver

  ///

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

  ///\ingroup lp_group

  public:

    /// \e

    CplexMip();

    /// \e

    CplexMip(const CplexEnv&);

    /// \e

    CplexMip(const CplexMip&);

    /// \e

    messageLevel(MESSAGE_NO_OUTPUT);

  }

  GlpkLp::GlpkLp(const GlpkLp& other)

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

    messageLevel(MESSAGE_NO_OUTPUT);

  }

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

  void GlpkLp::_clear_temporals() {

    _primal_ray.clear();

    _dual_ray.clear();

  }

  GlpkMip::Value GlpkMip::_getSol(int i) const {

    return glp_mip_col_val(lp, i);

  }

  GlpkMip::Value GlpkMip::_getSolValue() const {

    return glp_mip_obj_val(lp);

  }

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

  void GlpkMip::messageLevel(MessageLevel m) {

    _message_level = m;

  }

} //END OF NAMESPACE LEMON

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

  };

  /// \brief Interface for the GLPK LP solver

  ///

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

  ///\ingroup lp_group

  public:

    ///\e

    GlpkLp();

    ///\e

    GlpkLp(const GlpkLp&);

  private:

    mutable std::vector<double> _primal_ray;

    mutable std::vector<double> _dual_ray;

    void _clear_temporals();

  protected:

    virtual const char* _solverName() const;

    virtual SolveExitStatus _solve();

    virtual Value _getPrimal(int i) const;

    virtual Value _getDual(int i) const;

    virtual Value _getPrimalValue() const;

    ///\param m is the level of the messages output by the solver routines.

    void messageLevel(MessageLevel m);

  };

  /// \brief Interface for the GLPK MIP solver

  ///

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

  ///\ingroup lp_group

  public:

    ///\e

    GlpkMip();

    ///\e

    GlpkMip(const GlpkMip&);

  protected:

    virtual const char* _solverName() const;

    virtual ColTypes _getColType(int col) const;

    virtual void _setColType(int col, ColTypes col_type);

    virtual SolveExitStatus _solve();

    virtual ProblemType _getType() const;

    virtual Value _getSol(int i) const;

        return _host_it != it._host_it;

      }

    };

  protected:

    //Abstract virtual functions

    virtual int _addColId(int col) { return cols.addIndex(col); }

    virtual int _addRowId(int row) { return rows.addIndex(row); }

    virtual void _eraseColId(int col) { cols.eraseIndex(col); }

    virtual void _eraseRowId(int row) { rows.eraseIndex(row); }

    virtual int _addCol() = 0;

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

  public:

    /// Virtual destructor

    virtual ~LpBase() {}

    ///Gives back the name of the solver.

    const char* solverName() const {return _solverName();}

    ///\name Build up and modify the LP

    ///@{

    ///Add a new empty column (i.e a new variable) to the LP

    virtual VarStatus _getColStatus(int i) const = 0;

    virtual VarStatus _getRowStatus(int i) const = 0;

    virtual ProblemType _getPrimalType() const = 0;

    virtual ProblemType _getDualType() const = 0;

  public:

    ///\name Solve the LP

    ///@{

    ///\e Solve the LP problem at hand

    ///

    ///\return The result of the optimization procedure. Possible

    ///values and their meanings can be found in the documentation of

    ///\return

    ///- \ref INF or -\ref INF means either infeasibility or unboundedness

    /// of the primal problem, depending on whether we minimize or maximize.

    ///- \ref NaN if no primal solution is found.

    ///- The (finite) objective value if an optimal solution is found.

    Value primal() const { return _getPrimalValue()+obj_const_comp;}

    ///@}

  protected:

  };

  /// \ingroup lp_group

  ///

  /// \brief Common base class for MIP solvers

  ///

  /// This class is an abstract base class for MIP solvers. This class

      ///Optimal solution exists and found

      OPTIMAL = 3,

      ///The cost function is unbounded

      ///

      ///The Mip or at least the relaxed problem is unbounded

      UNBOUNDED = 4

    };

    ///\name Solve the MIP

    ///@{

    /// Solve the MIP problem at hand

    ///

    ///\return The result of the optimization procedure. Possible

    ///values and their meanings can be found in the documentation of

    virtual SolveExitStatus _solve() = 0;

    virtual ColTypes _getColType(int col) const = 0;

    virtual void _setColType(int col, ColTypes col_type) = 0;

    virtual ProblemType _getType() const = 0;

    virtual Value _getSol(int i) const = 0;

    virtual Value _getSolValue() const = 0;

  };

} //namespace lemon

#endif //LEMON_LP_BASE_H

  { return UNDEFINED; }

  LpSkeleton::VarStatus LpSkeleton::_getColStatus(int) const

  { return BASIC; }

  LpSkeleton::VarStatus LpSkeleton::_getRowStatus(int) const

  { return BASIC; }

  { return static_cast<LpSkeleton*>(0); }

  { return static_cast<LpSkeleton*>(0); }

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

  MipSkeleton::SolveExitStatus MipSkeleton::_solve()

  { return SOLVED; }

  MipSkeleton::Value MipSkeleton::_getSol(int) const { return 0; }

  MipSkeleton::Value MipSkeleton::_getSolValue() const { return 0; }

  MipSkeleton::ProblemType MipSkeleton::_getType() const

  { return UNDEFINED; }

  { return static_cast<MipSkeleton*>(0); }

  { return static_cast<MipSkeleton*>(0); }

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

} //namespace lemon

 */

#ifndef LEMON_LP_SKELETON_H

#define LEMON_LP_SKELETON_H

#include <lemon/lp_base.h>

///\file

namespace lemon {

  class SkeletonSolverBase : public virtual LpBase {

    int col_num,row_num;

  protected:

    SkeletonSolverBase()

      : col_num(-1), row_num(-1) {}

    ///\e

    virtual Sense _getSense() const;

    ///\e

    virtual void _clear();

  };

  ///

  ///\ingroup lp_group

  public:

  protected:

    ///\e

    virtual SolveExitStatus _solve();

    ///\e

    virtual Value _getPrimal(int i) const;

    ///\e

    virtual ProblemType _getDualType() const;

    ///\e

    virtual VarStatus _getColStatus(int i) const;

    ///\e

    virtual VarStatus _getRowStatus(int i) const;

    ///\e

    virtual const char* _solverName() const;

  };

  ///

  ///\ingroup lp_group

  public:

  protected:

    ///\e

    ///\bug Wrong interface

    ///

    virtual SolveExitStatus _solve();

    ///\e

    ///\bug Wrong interface

    ///

    virtual ProblemType _getType() const;

    ///\e

    virtual const char* _solverName() const;

  };

} //namespace lemon

#endif

  }

  void SoplexLp::_clear_temporals() {

    _primal_values.clear();

    _dual_values.clear();

  }

    SoplexLp* newlp = new SoplexLp();

    return newlp;

  }

    SoplexLp* newlp = new SoplexLp(*this);

    return newlp;

  }

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

  int SoplexLp::_addCol() {

    soplex::LPCol c;

  public:

    /// \e

    SoplexLp();

    /// \e

    SoplexLp(const SoplexLp&);

    /// \e

    ~SoplexLp();

  protected:

    virtual const char* _solverName() const;

    virtual int _addCol();

    virtual int _addRow();

    virtual void _eraseCol(int i);

    virtual void _eraseRow(int i);

    buf << "Coeff. of p2 should be 0.01";

    check(e[p2]>0, buf.str());

    tolerance=0.02;

    e.simplify(tolerance);

    buf << "Coeff. of p2 should be 0";

    check(const_cast<const LpSolver::Expr&>(e)[p2]==0, buf.str());

  }

  {

    LP::DualExpr e,f,g;

    LP::Row p1 = INVALID, p2 = INVALID, p3 = INVALID,

      p4 = INVALID, p5 = INVALID;

  std::ostringstream buf;

  buf << "PrimalType should be: " << int(stat) << int(lp.primalType());

  check(lp.primalType()==stat, buf.str());

  if (stat ==  LpSolver::OPTIMAL) {

    std::ostringstream sbuf;

    check(std::abs(lp.primal()-exp_opt) < 1e-3, sbuf.str());

  }

}

void aTest(LpSolver & lp)

{

  typedef LpSolver LP;

  solveAndCheck(lp, LpSolver::UNBOUNDED, expected_opt);

  //Infeasibilty

  lp.addRow(x1+x2 <=-2);

  solveAndCheck(lp, LpSolver::INFEASIBLE, expected_opt);

}

int main()

{

  LpSkeleton lp_skel;

  lpTest(lp_skel);

#ifdef HAVE_GLPK

  {

    GlpkLp lp_glpk1,lp_glpk2;

    lpTest(lp_glpk1);

    aTest(lp_glpk2);

  }

#endif

#ifdef HAVE_CPLEX

  try {

    CplexLp lp_cplex1,lp_cplex2;

    lpTest(lp_cplex1);

    aTest(lp_cplex2);

  } catch (CplexEnv::LicenseError& error) {

#ifdef LEMON_FORCE_CPLEX_CHECK

    check(false, error.what());

#else

    std::cerr << error.what() << std::endl;

    std::cerr << "Cplex license check failed, lp check skipped" << std::endl;

#endif

  }

#endif

#ifdef HAVE_SOPLEX

  {

    SoplexLp lp_soplex1,lp_soplex2;

    lpTest(lp_soplex1);

    aTest(lp_soplex2);

  }

#endif

#ifdef HAVE_CLP

  {

    ClpLp lp_clp1,lp_clp2;

    lpTest(lp_clp1);

    aTest(lp_clp2);

  }

#endif

  return 0;

}

  mip.colType(x1,MipSolver::INTEGER);

  expected_opt=0;

  solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt);

}

int main()

{

#ifdef HAVE_GLPK

  {

    GlpkMip mip1;

    aTest(mip1);

  }

#endif

#ifdef HAVE_CPLEX

  try {

    CplexMip mip2;

    aTest(mip2);

  } catch (CplexEnv::LicenseError& error) {

#ifdef LEMON_FORCE_CPLEX_CHECK

    check(false, error.what());

#else

    std::cerr << error.what() << std::endl;

    std::cerr << "Cplex license check failed, lp check skipped" << std::endl;

#endif

  }

#endif

  return 0;

}