LEMON/LEMON-official Changeset - r587:9db62975c32b

Repositories » LEMON » LEMON-official

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r587:9db62975c32b

« 586:547e96

588:89e29e »

r587:9db62975c32b

Thu, 26 Feb 2009 08:39:16

[Not Reviewed]

0 comments (0 inline)

alpar (Alpar Juttner)
alpar@cs.elte.hu

Fix newSolver()/cloneSolver() API in LP tools + doc improvements (#230) - More logical structure for newSolver()/cloneSolver() - Fix compilation problem with gcc-3.3 - Doc improvements

0 13 0

default

13 files changed with 118 insertions and 78 deletions:

lemon/clp.cc

lemon/clp.h

lemon/cplex.cc

lemon/cplex.h

lemon/glpk.cc

lemon/glpk.h

lemon/lp_base.h

lemon/lp_skeleton.cc

lemon/lp_skeleton.h

lemon/soplex.cc

lemon/soplex.h

test/lp_test.cc

test/mip_test.cc

↑ Collapse diff ↑

0 comments (0 inline)

...	...	@@ -53,18 +53,18 @@
53	53	if (_dual_ray) {
54	54	delete[] _dual_ray;
55	55	_dual_ray = 0;
56	56	}
57	57	}
58	58
59		ClpLp* ClpLp::~~_newSolver~~() const {
	59	ClpLp* ClpLp::newSolver() const {
60	60	ClpLp* newlp = new ClpLp;
61	61	return newlp;
62	62	}
63	63
64		ClpLp* ClpLp::~~_cloneSolver~~() const {
	64	ClpLp* ClpLp::cloneSolver() const {
65	65	ClpLp* copylp = new ClpLp(*this);
66	66	return copylp;
67	67	}
68	68
69	69	const char* ClpLp::_solverName() const { return "ClpLp"; }
70	70

@@ -53,25 +53,27 @@
 		    ClpLp();
 		    /// \e
 		    ClpLp(const ClpLp&);
 		    /// \e
 		    ~ClpLp();
 		    /// \e
 		    virtual ClpLp* newSolver() const;
 		    /// \e
 		    virtual ClpLp* cloneSolver() const;
 		  protected:
 		    mutable double* _primal_ray;
 		    mutable double* _dual_ray;
 		    void _init_temporals();
 		    void _clear_temporals();
 		  protected:
 		    virtual ClpLp* _newSolver() const;
 		    virtual ClpLp* _cloneSolver() const;
 		    virtual const char* _solverName() const;
 		    virtual int _addCol();
 		    virtual int _addRow();
 		    virtual void _eraseCol(int i);

@@ -448,14 +448,14 @@
 		  CplexLp::CplexLp(const CplexLp& other)
 		    : LpBase(), CplexBase(other), LpSolver() {}
 		  CplexLp::~CplexLp() {}
 		  CplexLp* CplexLp::_newSolver() const { return new CplexLp; }
 		  CplexLp* CplexLp::_cloneSolver() const {return new CplexLp(*this); }
 		  CplexLp* CplexLp::newSolver() const { return new CplexLp; }
 		  CplexLp* CplexLp::cloneSolver() const {return new CplexLp(*this); }
 		  const char* CplexLp::_solverName() const { return "CplexLp"; }
 		  void CplexLp::_clear_temporals() {
 		    _col_status.clear();
 		    _row_status.clear();
@@ -820,14 +820,14 @@
 		  CplexMip::CplexMip(const CplexMip& other)
 		    : LpBase(), CplexBase(other), MipSolver() {}
 		  CplexMip::~CplexMip() {}
 		  CplexMip* CplexMip::_newSolver() const { return new CplexMip; }
 		  CplexMip* CplexMip::_cloneSolver() const {return new CplexMip(*this); }
 		  CplexMip* CplexMip::newSolver() const { return new CplexMip; }
 		  CplexMip* CplexMip::cloneSolver() const {return new CplexMip(*this); }
 		  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

@@ -157,23 +157,28 @@
 		  };
 		  /// \brief Interface for the CPLEX LP solver
 		  ///
 		  /// This class implements an interface for the CPLEX LP solver.
 		  ///\ingroup lp_group
-		  class CplexLp : public CplexBase, public LpSolver {
+		  class CplexLp : public LpSolver, public CplexBase {
 		  public:
 		    /// \e
 		    CplexLp();
 		    /// \e
 		    CplexLp(const CplexEnv&);
 		    /// \e
 		    CplexLp(const CplexLp&);
 		    /// \e
 		    virtual ~CplexLp();
 		    /// \e
 		    virtual CplexLp* cloneSolver() const;
 		    /// \e
 		    virtual CplexLp* newSolver() const;
 		  private:
 		    // these values cannot retrieved element by element
 		    mutable std::vector<int> _col_status;
 		    mutable std::vector<int> _row_status;
@@ -183,15 +188,12 @@
 		    void _clear_temporals();
 		    SolveExitStatus convertStatus(int status);
 		  protected:
 		    virtual CplexLp* _cloneSolver() const;
 		    virtual CplexLp* _newSolver() const;
 		    virtual const char* _solverName() const;
 		    virtual SolveExitStatus _solve();
 		    virtual Value _getPrimal(int i) const;
 		    virtual Value _getDual(int i) const;
 		    virtual Value _getPrimalValue() const;
@@ -219,13 +221,13 @@
 		  };
 		  /// \brief Interface for the CPLEX MIP solver
 		  ///
 		  /// This class implements an interface for the CPLEX MIP solver.
 		  ///\ingroup lp_group
-		  class CplexMip : public CplexBase, public MipSolver {
+		  class CplexMip : public MipSolver, public CplexBase {
 		  public:
 		    /// \e
 		    CplexMip();
 		    /// \e
 		    CplexMip(const CplexEnv&);
 		    /// \e

@@ -531,14 +531,14 @@
 		  GlpkLp::GlpkLp(const GlpkLp& other)
 		    : LpBase(other), GlpkBase(other), LpSolver(other) {
 		    messageLevel(MESSAGE_NO_OUTPUT);
+		  }
 		  GlpkLp* GlpkLp::_newSolver() const { return new GlpkLp; }
 		  GlpkLp* GlpkLp::_cloneSolver() const { return new GlpkLp(*this); }
 		  GlpkLp* GlpkLp::newSolver() const { return new GlpkLp; }
 		  GlpkLp* GlpkLp::cloneSolver() const { return new GlpkLp(*this); }
 		  const char* GlpkLp::_solverName() const { return "GlpkLp"; }
 		  void GlpkLp::_clear_temporals() {
 		    _primal_ray.clear();
 		    _dual_ray.clear();
@@ -937,14 +937,14 @@
+		  }
 		  GlpkMip::Value GlpkMip::_getSolValue() const {
 		    return glp_mip_obj_val(lp);
+		  }
 		  GlpkMip* GlpkMip::_newSolver() const { return new GlpkMip; }
 		  GlpkMip* GlpkMip::_cloneSolver() const {return new GlpkMip(*this); }
 		  GlpkMip* GlpkMip::newSolver() const { return new GlpkMip; }
 		  GlpkMip* GlpkMip::cloneSolver() const {return new GlpkMip(*this); }
 		  const char* GlpkMip::_solverName() const { return "GlpkMip"; }
 		  void GlpkMip::messageLevel(MessageLevel m) {
 		    _message_level = m;
+		  }

RhodeCode

Login to your account

@@ -116,32 +116,34 @@
 		  };
 		  /// \brief Interface for the GLPK LP solver
 		  ///
 		  /// This class implements an interface for the GLPK LP solver.
 		  ///\ingroup lp_group
-		  class GlpkLp : public GlpkBase, public LpSolver {
+		  class GlpkLp : public LpSolver, public GlpkBase {
 		  public:
 		    ///\e
 		    GlpkLp();
 		    ///\e
 		    GlpkLp(const GlpkLp&);
 		    ///\e
 		    virtual GlpkLp* cloneSolver() const;
 		    ///\e
 		    virtual GlpkLp* newSolver() const;
 		  private:
 		    mutable std::vector<double> _primal_ray;
 		    mutable std::vector<double> _dual_ray;
 		    void _clear_temporals();
 		  protected:
 		    virtual GlpkLp* _cloneSolver() const;
 		    virtual GlpkLp* _newSolver() const;
 		    virtual const char* _solverName() const;
 		    virtual SolveExitStatus _solve();
 		    virtual Value _getPrimal(int i) const;
 		    virtual Value _getDual(int i) const;
@@ -200,25 +202,25 @@
 		  };
 		  /// \brief Interface for the GLPK MIP solver
 		  ///
 		  /// This class implements an interface for the GLPK MIP solver.
 		  ///\ingroup lp_group
-		  class GlpkMip : public GlpkBase, public MipSolver {
+		  class GlpkMip : public MipSolver, public GlpkBase {
 		  public:
 		    ///\e
 		    GlpkMip();
 		    ///\e
 		    GlpkMip(const GlpkMip&);
 		    virtual GlpkMip* cloneSolver() const;
 		    virtual GlpkMip* newSolver() const;
 		  protected:
 		    virtual GlpkMip* _cloneSolver() const;
 		    virtual GlpkMip* _newSolver() const;
 		    virtual const char* _solverName() const;
 		    virtual ColTypes _getColType(int col) const;
 		    virtual void _setColType(int col, ColTypes col_type);
 		    virtual SolveExitStatus _solve();

@@ -915,14 +915,12 @@
 		    };
 		  protected:
 		    //Abstract virtual functions
 		    virtual LpBase* _newSolver() const = 0;
 		    virtual LpBase* _cloneSolver() const = 0;
 		    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); }
@@ -984,17 +982,12 @@
 		  public:
 		    /// Virtual destructor
 		    virtual ~LpBase() {}
 		    ///Creates a new LP problem
 		    LpBase* newSolver() {return _newSolver();}
 		    ///Makes a copy of the LP problem
 		    LpBase* cloneSolver() {return _cloneSolver();}
 		    ///Gives back the name of the solver.
 		    const char* solverName() const {return _solverName();}
 		    ///\name Build up and modify the LP
 		    ///@{
@@ -1818,12 +1811,17 @@
 		    virtual ProblemType _getPrimalType() const = 0;
 		    virtual ProblemType _getDualType() const = 0;
 		  public:
 		    ///Allocate a new LP problem instance
 		    virtual LpSolver* newSolver() const = 0;
 		    ///Make a copy of the LP problem
 		    virtual LpSolver* cloneSolver() const = 0;
 		    ///\name Solve the LP
 		    ///@{
 		    ///\e Solve the LP problem at hand
 		    ///
@@ -1932,19 +1930,14 @@
 		    /// 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;}
 		    ///@}
 		    LpSolver* newSolver() {return _newSolver();}
 		    LpSolver* cloneSolver() {return _cloneSolver();}
 		  protected:
 		    virtual LpSolver* _newSolver() const = 0;
 		    virtual LpSolver* _cloneSolver() const = 0;
 		  };
 		  /// \ingroup lp_group
 		  ///
 		  /// \brief Common base class for MIP solvers
@@ -1972,12 +1965,17 @@
 		      ///The cost function is unbounded
 		      ///
 		      ///The Mip or at least the relaxed problem is unbounded
 		      UNBOUNDED = 4
 		    };
 		    ///Allocate a new MIP problem instance
 		    virtual MipSolver* newSolver() const = 0;
 		    ///Make a copy of the MIP problem
 		    virtual MipSolver* cloneSolver() const = 0;
 		    ///\name Solve the MIP
 		    ///@{
 		    /// Solve the MIP problem at hand
 		    ///
@@ -2059,21 +2057,12 @@
 		    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;
 		  public:
 		    MipSolver* newSolver() {return _newSolver();}
 		    MipSolver* cloneSolver() {return _cloneSolver();}
 		  protected:
 		    virtual MipSolver* _newSolver() const = 0;
 		    virtual MipSolver* _cloneSolver() const = 0;
 		  };
 		} //namespace lemon

@@ -102,16 +102,16 @@
 		  LpSkeleton::VarStatus LpSkeleton::_getColStatus(int) const
 		  { return BASIC; }
 		  LpSkeleton::VarStatus LpSkeleton::_getRowStatus(int) const
 		  { return BASIC; }
-		  LpSkeleton* LpSkeleton::_newSolver() const
+		  LpSkeleton* LpSkeleton::newSolver() const
 		  { return static_cast<LpSkeleton*>(0); }
-		  LpSkeleton* LpSkeleton::_cloneSolver() const
+		  LpSkeleton* LpSkeleton::cloneSolver() const
 		  { return static_cast<LpSkeleton*>(0); }
 		  const char* LpSkeleton::_solverName() const { return "LpSkeleton"; }
 		  MipSkeleton::SolveExitStatus MipSkeleton::_solve()
 		  { return SOLVED; }
@@ -119,16 +119,16 @@
 		  MipSkeleton::Value MipSkeleton::_getSol(int) const { return 0; }
 		  MipSkeleton::Value MipSkeleton::_getSolValue() const { return 0; }
 		  MipSkeleton::ProblemType MipSkeleton::_getType() const
 		  { return UNDEFINED; }
-		  MipSkeleton* MipSkeleton::_newSolver() const
+		  MipSkeleton* MipSkeleton::newSolver() const
 		  { return static_cast<MipSkeleton*>(0); }
-		  MipSkeleton* MipSkeleton::_cloneSolver() const
+		  MipSkeleton* MipSkeleton::cloneSolver() const
 		  { return static_cast<MipSkeleton*>(0); }
 		  const char* MipSkeleton::_solverName() const { return "MipSkeleton"; }
 		} //namespace lemon

@@ -19,16 +19,22 @@
 		#ifndef LEMON_LP_SKELETON_H
 		#define LEMON_LP_SKELETON_H
 		#include <lemon/lp_base.h>
 		///\file
-		///\brief A skeleton file to implement LP solver interfaces
+		///\brief Skeleton file to implement LP/MIP solver interfaces
 		///
 		///The classes in this file do nothing, but they can serve as skeletons when
 		///implementing an interface to new solvers.
 		namespace lemon {
-		  ///A skeleton class to implement LP solver interfaces
+		  ///A skeleton class to implement LP/MIP solver base interface
 		  ///This class does nothing, but it can serve as a skeleton when
 		  ///implementing an interface to new solvers.
 		  class SkeletonSolverBase : public virtual LpBase {
 		    int col_num,row_num;
 		  protected:
 		    SkeletonSolverBase()
@@ -133,20 +139,26 @@
 		    ///\e
 		    virtual void _clear();
 		  };
-		  /// \brief Interface for a skeleton LP solver
+		  /// \brief Skeleton class for an LP solver interface
 		  ///
-		  /// This class implements an interface for a skeleton LP solver.
+		  ///This class does nothing, but it can serve as a skeleton when
 		  ///implementing an interface to new solvers.
 		  ///\ingroup lp_group
-		  class LpSkeleton : public SkeletonSolverBase, public LpSolver {
+		  class LpSkeleton : public LpSolver, public SkeletonSolverBase {
 		  public:
 		    LpSkeleton() : SkeletonSolverBase(), LpSolver() {}
 		    ///\e
 		    LpSkeleton() : LpSolver(), SkeletonSolverBase() {}
 		    ///\e
 		    virtual LpSkeleton* newSolver() const;
 		    ///\e
 		    virtual LpSkeleton* cloneSolver() const;
 		  protected:
 		    ///\e
 		    virtual SolveExitStatus _solve();
 		    ///\e
@@ -170,27 +182,29 @@
 		    ///\e
 		    virtual VarStatus _getColStatus(int i) const;
 		    ///\e
 		    virtual VarStatus _getRowStatus(int i) const;
 		    ///\e
 		    virtual LpSkeleton* _newSolver() const;
 		    ///\e
 		    virtual LpSkeleton* _cloneSolver() const;
 		    ///\e
 		    virtual const char* _solverName() const;
 		  };
-		  /// \brief Interface for a skeleton MIP solver
+		  /// \brief Skeleton class for a MIP solver interface
 		  ///
-		  /// This class implements an interface for a skeleton MIP solver.
+		  ///This class does nothing, but it can serve as a skeleton when
 		  ///implementing an interface to new solvers.
 		  ///\ingroup lp_group
-		  class MipSkeleton : public SkeletonSolverBase, public MipSolver {
+		  class MipSkeleton : public MipSolver, public SkeletonSolverBase {
 		  public:
-		    MipSkeleton() : SkeletonSolverBase(), MipSolver() {}
+		    ///\e
 		    MipSkeleton() : MipSolver(), SkeletonSolverBase() {}
 		    ///\e
 		    virtual MipSkeleton* newSolver() const;
 		    ///\e
 		    virtual MipSkeleton* cloneSolver() const;
 		  protected:
 		    ///\e
 		    ///\bug Wrong interface
 		    ///
@@ -212,18 +226,12 @@
 		    ///\bug Wrong interface
 		    ///
 		    virtual ProblemType _getType() const;
 		    ///\e
 		    virtual MipSkeleton* _newSolver() const;
 		    ///\e
 		    virtual MipSkeleton* _cloneSolver() const;
 		    ///\e
 		    virtual const char* _solverName() const;
 		  };
 		} //namespace lemon
 		#endif

@@ -51,18 +51,18 @@
 		  void SoplexLp::_clear_temporals() {
 		    _primal_values.clear();
 		    _dual_values.clear();
+		  }
-		  SoplexLp* SoplexLp::_newSolver() const {
+		  SoplexLp* SoplexLp::newSolver() const {
 		    SoplexLp* newlp = new SoplexLp();
 		    return newlp;
+		  }
-		  SoplexLp* SoplexLp::_cloneSolver() const {
+		  SoplexLp* SoplexLp::cloneSolver() const {
 		    SoplexLp* newlp = new SoplexLp(*this);
 		    return newlp;
+		  }
 		  const char* SoplexLp::_solverName() const { return "SoplexLp"; }

@@ -70,18 +70,19 @@
 		    /// \e
 		    SoplexLp();
 		    /// \e
 		    SoplexLp(const SoplexLp&);
 		    /// \e
 		    ~SoplexLp();
 		    /// \e
 		    virtual SoplexLp* newSolver() const;
 		    /// \e
 		    virtual SoplexLp* cloneSolver() const;
 		  protected:
 		    virtual SoplexLp* _newSolver() const;
 		    virtual SoplexLp* _cloneSolver() const;
 		    virtual const char* _solverName() const;
 		    virtual int _addCol();
 		    virtual int _addRow();
 		    virtual void _eraseCol(int i);

@@ -194,12 +194,17 @@
 		    tolerance=0.02;
 		    e.simplify(tolerance);
 		    buf << "Coeff. of p2 should be 0";
 		    check(const_cast<const LpSolver::Expr&>(e)[p2]==0, buf.str());
 		    //Test for clone/new
 		    LP* lpnew = lp.newSolver();
 		    LP* lpclone = lp.cloneSolver();
 		    delete lpnew;
 		    delete lpclone;
+		  }
+		  {
 		    LP::DualExpr e,f,g;
 		    LP::Row p1 = INVALID, p2 = INVALID, p3 = INVALID,
@@ -244,13 +249,14 @@
 		  buf << "PrimalType should be: " << int(stat) << int(lp.primalType());
 		  check(lp.primalType()==stat, buf.str());
 		  if (stat ==  LpSolver::OPTIMAL) {
 		    std::ostringstream sbuf;
-		    sbuf << "Wrong optimal value: the right optimum is " << exp_opt;
+		    sbuf << "Wrong optimal value (" << lp.primal() <<") with "
 		         << lp.solverName() <<"\n     the right optimum is " << exp_opt;
 		    check(std::abs(lp.primal()-exp_opt) < 1e-3, sbuf.str());
+		  }
+		}
 		void aTest(LpSolver & lp)
+		{
@@ -352,22 +358,36 @@
 		  //Infeasibilty
 		  lp.addRow(x1+x2 <=-2);
 		  solveAndCheck(lp, LpSolver::INFEASIBLE, expected_opt);
+		}
 		template<class LP>
 		void cloneTest()
+		{
 		  //Test for clone/new
 		  LP* lp = new LP();
 		  LP* lpnew = lp->newSolver();
 		  LP* lpclone = lp->cloneSolver();
 		  delete lp;
 		  delete lpnew;
 		  delete lpclone;
+		}
 		int main()
+		{
 		  LpSkeleton lp_skel;
 		  lpTest(lp_skel);
 		#ifdef HAVE_GLPK
+		  {
 		    GlpkLp lp_glpk1,lp_glpk2;
 		    lpTest(lp_glpk1);
 		    aTest(lp_glpk2);
 		    cloneTest<GlpkLp>();
+		  }
 		#endif
 		#ifdef HAVE_CPLEX
 		  try {
 		    CplexLp lp_cplex1,lp_cplex2;
@@ -378,26 +398,29 @@
 		    check(false, error.what());
 		#else
 		    std::cerr << error.what() << std::endl;
 		    std::cerr << "Cplex license check failed, lp check skipped" << std::endl;
 		#endif
+		  }
 		    cloneTest<CplexLp>();
 		#endif
 		#ifdef HAVE_SOPLEX
+		  {
 		    SoplexLp lp_soplex1,lp_soplex2;
 		    lpTest(lp_soplex1);
 		    aTest(lp_soplex2);
 		    cloneTest<SoplexLp>();
+		  }
 		#endif
 		#ifdef HAVE_CLP
+		  {
 		    ClpLp lp_clp1,lp_clp2;
 		    lpTest(lp_clp1);
 		    aTest(lp_clp2);
 		    cloneTest<ClpLp>();
+		  }
 		#endif
 		  return 0;
+		}

@@ -103,20 +103,32 @@
 		  solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt);
+		}
 		template<class MIP>
 		void cloneTest()
+		{
 		  MIP* mip = new MIP();
 		  MIP* mipnew = mip->newSolver();
 		  MIP* mipclone = mip->cloneSolver();
 		  delete mip;
 		  delete mipnew;
 		  delete mipclone;
+		}
 		int main()
+		{
 		#ifdef HAVE_GLPK
+		  {
 		    GlpkMip mip1;
 		    aTest(mip1);
 		    cloneTest<GlpkMip>();
+		  }
 		#endif
 		#ifdef HAVE_CPLEX
 		  try {
 		    CplexMip mip2;
@@ -126,11 +138,12 @@
 		    check(false, error.what());
 		#else
 		    std::cerr << error.what() << std::endl;
 		    std::cerr << "Cplex license check failed, lp check skipped" << std::endl;
 		#endif
+		  }
 		  cloneTest<CplexMip>();
 		#endif
 		  return 0;
+		}