Changeset 1364:ee5959aa4410 in lemon-0.x

Timestamp:

04/17/05 20:57:22 (20 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1809

Message:

• compile failure fixed
• newLp(), copyLp() added
• more doc.

Location:

src/lemon

Files:

• lp_base.cc (modified) (1 diff)
• lp_base.h (modified) (14 diffs)
• lp_glpk.cc (modified) (1 diff)
• lp_glpk.h (modified) (2 diffs)
• lp_skeleton.cc (modified) (1 diff)
• lp_skeleton.h (modified) (1 diff)

src/lemon/lp_base.cc

@@ -26 +26 @@
   LpSolverBase::NaN = std::numeric_limits<Value>::quiet_NaN();
 
-  const LpSolverBase::Constr::Value
-  LpSolverBase::Constr::INF = std::numeric_limits<Value>::infinity();
-  const LpSolverBase::Constr::Value
-  LpSolverBase::Constr::NaN = std::numeric_limits<Value>::quiet_NaN();
+//   const LpSolverBase::Constr::Value
+//   LpSolverBase::Constr::INF = std::numeric_limits<Value>::infinity();
+//   const LpSolverBase::Constr::Value
+//   LpSolverBase::Constr::NaN = std::numeric_limits<Value>::quiet_NaN();
   
 } //namespace lemon

src/lemon/lp_base.h

@@ -199 +199 @@
     ///container.
     ///- Its it fully compatible with \c std::map<Col,double>, so for expamle
-    ///if \c e is an Expr and \c v and \c w are of type \ref Col then you can
+    ///if \c e is an Expr and \c v and \c w are of type \ref Col, then you can
     ///read and modify the coefficients like
     ///these.
@@ -319 +319 @@
     ///Linear constraint
 
-    ///\todo document please
-    ///
+    ///This data stucture represents a linear constraint in the LP.
+    ///Basically it is a linear expression with a lower or an upper bound
+    ///(or both). These parts of the constraint can be obtained by the member
+    ///functions \ref expr(), \ref lowerBound() and \ref upperBound(),
+    ///respectively.
+    ///There are two ways to construct a constraint.
+    ///- You can set the linear expression and the bounds directly
+    ///  by the functions above.
+    ///- The operators <tt>\<=</tt>, <tt>==</tt> and  <tt>\>=</tt>
+    ///  are defined between expressions, or even between constraints whenever
+    ///  it makes sense. Therefore if \c e and \c f are linear expressions and
+    ///  \c s and \c t are numbers, then the followings are valid expressions
+    ///  and thus they can be used directly e.g. in \ref addRow() whenever
+    ///  it makes sense.
+    ///  \code
+    ///  e<=s
+    ///  e<=f
+    ///  s<=e<=t
+    ///  e>=t
+    ///  \endcode
+    ///\warning The validity of a constraint is checked only at run time, so
+    ///e.g. \ref addRow(<tt>x[1]\<=x[2]<=5</tt>) will compile, but will throw a
+    ///\ref LogicError exception.
     class Constr
     {
@@ -328 +349 @@
       typedef Expr::Value Value;
       
-      static const Value INF;
-      static const Value NaN;
-      //     static const Value INF=0;
-      //     static const Value NaN=1;
-      
+//       static const Value INF;
+//       static const Value NaN;
+
     protected:
       Expr _expr;
@@ -357 +376 @@
         _lb=_ub=NaN;
       }
-      ///\e
+
+      ///Reference to the linear expression 
       Expr &expr() { return _expr; }
-      ///\e
+      ///Cont reference to the linear expression 
       const Expr &expr() const { return _expr; }
-      ///\e
+      ///Reference to the lower bound.
+
+      ///\return
+      ///- -\ref INF: the constraint is lower unbounded.
+      ///- -\ref NaN: lower bound has not been set.
+      ///- finite number: the lower bound
       Value &lowerBound() { return _lb; }
-      ///\e
+      ///The const version of \ref lowerBound()
       const Value &lowerBound() const { return _lb; }
-      ///\e
+      ///Reference to the upper bound.
+
+      ///\return
+      ///- -\ref INF: the constraint is upper unbounded.
+      ///- -\ref NaN: upper bound has not been set.
+      ///- finite number: the upper bound
       Value &upperBound() { return _ub; }
-      ///\e
+      ///The const version of \ref upperBound()
       const Value &upperBound() const { return _ub; }
-      ///\e
+      ///Is the constraint lower bounded?
       bool lowerBounded() const { 
         using namespace std;
         return isfinite(_lb);
       }
-      ///\e
+      ///Is the constraint upper bounded?
       bool upperBounded() const {
         using namespace std;
@@ -387 +417 @@
 
     //Abstract virtual functions
+    virtual LpSolverBase &_newLp() = 0;
+    virtual LpSolverBase &_copyLp() = 0;
+
     virtual int _addCol() = 0;
     virtual int _addRow() = 0;
@@ -427 +460 @@
     virtual ~LpSolverBase() {}
 
+    ///Creates a new LP problem
+    LpSolverBase &newLp() {return _newLp();}
+    ///Make a copy of the LP problem
+    LpSolverBase &copyLp() {return _copyLp();}
+    
     ///\name Build up and modify of the LP
 
@@ -452 +490 @@
     ///like
     ///\code
-    ///std::map<AnyStatus,LpSolverBase::Col>
+    ///std::map<AnyType,LpSolverBase::Col>
     ///\endcode
     ///- an iterable lemon \ref concept::WriteMap "write map" like 
@@ -460 +498 @@
     ///\endcode
     ///\return The number of the created column.
-    ///\bug Iterable nodemap hasn't been implemented yet.
 #ifdef DOXYGEN
     template<class T>
@@ -669 +706 @@
     ///- \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.
+    ///- \ref NaN if no primal solution is found.
     ///- The (finite) objective value if an optimal solution is found.
     Value primalValue() { return _getPrimalValue()+obj_const_comp;}
@@ -684 +721 @@
   {
     LpSolverBase::Expr tmp(a);
-    tmp+=b; ///\todo Don't STL have some special 'merge' algorithm?
+    tmp+=b; ///\todo Doesn't STL have some special 'merge' algorithm?
     return tmp;
   }
@@ -695 +732 @@
   {
     LpSolverBase::Expr tmp(a);
-    tmp-=b; ///\todo Don't STL have some special 'merge' algorithm?
+    tmp-=b; ///\todo Doesn't STL have some special 'merge' algorithm?
     return tmp;
   }
@@ -706 +743 @@
   {
     LpSolverBase::Expr tmp(a);
-    tmp*=b; ///\todo Don't STL have some special 'merge' algorithm?
+    tmp*=b; ///\todo Doesn't STL have some special 'merge' algorithm?
     return tmp;
   }
@@ -718 +755 @@
   {
     LpSolverBase::Expr tmp(b);
-    tmp*=a; ///\todo Don't STL have some special 'merge' algorithm?
+    tmp*=a; ///\todo Doesn't STL have some special 'merge' algorithm?
     return tmp;
   }
@@ -729 +766 @@
   {
     LpSolverBase::Expr tmp(a);
-    tmp/=b; ///\todo Don't STL have some special 'merge' algorithm?
+    tmp/=b; ///\todo Doesn't STL have some special 'merge' algorithm?
     return tmp;
   }

src/lemon/lp_glpk.cc

@@ -25 +25 @@
 namespace lemon {
 
+  ///\e
+
+  ///\bug Unimplemented!
+  ///
+  LpSolverBase &LpGlpk::_newLp()
+  {
+    return *((LpSolverBase *)0);
+  }
+  
+  ///\e
+
+  ///\bug Unimplemented!
+  ///
+  LpSolverBase &LpGlpk::_copyLp()
+  {
+    return *((LpSolverBase *)0);
+  }
+
   LpGlpk::LpGlpk() : Parent(), 
                      lp(lpx_create_prob()) {

src/lemon/lp_glpk.h

@@ -32 +32 @@
   /// \brief Wrapper for GLPK solver
   /// 
-  /// This class implements a lemon wrapper for GLPK.
+  /// This class implements an interface for GLPK.
   ///\ingroup gen_opt_group
   class LpGlpk : public LpSolverBase {
@@ -46 +46 @@
     
   protected:
+    virtual LpSolverBase &_newLp();
+    virtual LpSolverBase &_copyLp();
+
     virtual int _addCol();
     virtual int _addRow();

src/lemon/lp_skeleton.cc

@@ -22 +22 @@
 namespace lemon {
   
+  LpSolverBase &LpSkeleton::_newLp()
+  {
+    return *((LpSolverBase *)0);
+  }
+  
+  LpSolverBase &LpSkeleton::_copyLp()
+  {
+    return *((LpSolverBase *)0);
+  }
+
   int LpSkeleton::_addCol()
   {

src/lemon/lp_skeleton.h

@@ -30 +30 @@
     
   protected:
+    ///\e
+    virtual LpSolverBase &_newLp();
+    ///\e
+    virtual LpSolverBase &_copyLp();
     /// \e
     virtual int _addCol();