[Lemon-commits] [lemon_svn] alpar: r1702 - hugo/trunk/src/work/athos/lp
Lemon SVN
svn at lemon.cs.elte.hu
Mon Nov 6 20:47:05 CET 2006
Author: alpar
Date: Wed Mar 30 10:28:44 2005
New Revision: 1702
Modified:
hugo/trunk/src/work/athos/lp/lp_base.cc
hugo/trunk/src/work/athos/lp/lp_base.h
hugo/trunk/src/work/athos/lp/lp_test.cc
Log:
- Non-template expressions and constraints (lin_expr.h isn't used)
Modified: hugo/trunk/src/work/athos/lp/lp_base.cc
==============================================================================
--- hugo/trunk/src/work/athos/lp/lp_base.cc (original)
+++ hugo/trunk/src/work/athos/lp/lp_base.cc Wed Mar 30 10:28:44 2005
@@ -25,5 +25,9 @@
const LpSolverBase::Value
LpSolverBase::NaN = std::numeric_limits<Value>::quiet_NaN();
-
+ const LpSolverBase::Constr::Coeff
+ LpSolverBase::Constr::INF = std::numeric_limits<Value>::infinity();
+ const LpSolverBase::Constr::Coeff
+ LpSolverBase::Constr::NaN = std::numeric_limits<Value>::quiet_NaN();
+
} //namespace lemon
Modified: hugo/trunk/src/work/athos/lp/lp_base.h
==============================================================================
--- hugo/trunk/src/work/athos/lp/lp_base.h (original)
+++ hugo/trunk/src/work/athos/lp/lp_base.h Wed Mar 30 10:28:44 2005
@@ -18,13 +18,15 @@
#define LEMON_LP_BASE_H
#include<vector>
+#include<map>
#include<limits>
#include<lemon/utility.h>
#include<lemon/error.h>
#include<lemon/invalid.h>
-#include"lin_expr.h"
+//#include"lin_expr.h"
+
///\file
///\brief The interface of the LP solver interface.
namespace lemon {
@@ -168,9 +170,105 @@
};
///Linear expression
- typedef SparseLinExpr<Col> Expr;
+ // typedef SparseLinExpr<Col> Expr;
+ class Expr : public std::map<Col,Col::ExprValue>
+ {
+ public:
+ typedef Col Var;
+ typedef Col::ExprValue Coeff;
+
+ protected:
+ typedef std::map<Col,Col::ExprValue> Base;
+
+ Coeff const_comp;
+ public:
+ typedef True IsLinExpression;
+ ///\e
+ Expr() : Base(), const_comp(0) { }
+ ///\e
+ Expr(const Var &v) : const_comp(0) {
+ Base::insert(std::make_pair(v, 1));
+ }
+ ///\e
+ Expr(const Coeff &v) : const_comp(v) {}
+ ///\e
+ void set(const Var &v,const Coeff &c) {
+ Base::insert(std::make_pair(v, c));
+ }
+ ///\e
+ Coeff &constComp() { return const_comp; }
+ ///\e
+ const Coeff &constComp() const { return const_comp; }
+
+ ///Removes the components with zero coefficient.
+ void simplify() {
+ for (Base::iterator i=Base::begin(); i!=Base::end();) {
+ Base::iterator j=i;
+ ++j;
+ if ((*i).second==0) Base::erase(i);
+ j=i;
+ }
+ }
+
+ ///\e
+ Expr &operator+=(const Expr &e) {
+ for (Base::const_iterator j=e.begin(); j!=e.end(); ++j)
+ (*this)[j->first]+=j->second;
+ ///\todo it might be speeded up using "hints"
+ const_comp+=e.const_comp;
+ return *this;
+ }
+ ///\e
+ Expr &operator-=(const Expr &e) {
+ for (Base::const_iterator j=e.begin(); j!=e.end(); ++j)
+ (*this)[j->first]-=j->second;
+ const_comp-=e.const_comp;
+ return *this;
+ }
+ ///\e
+ Expr &operator*=(const Coeff &c) {
+ for (Base::iterator j=Base::begin(); j!=Base::end(); ++j)
+ j->second*=c;
+ const_comp*=c;
+ return *this;
+ }
+ ///\e
+ Expr &operator/=(const Coeff &c) {
+ for (Base::iterator j=Base::begin(); j!=Base::end(); ++j)
+ j->second/=c;
+ const_comp/=c;
+ return *this;
+ }
+ };
+
///Linear constraint
- typedef LinConstr<Expr> Constr;
+ //typedef LinConstr<Expr> Constr;
+ class Constr
+ {
+ public:
+ typedef LpSolverBase::Expr Expr;
+ typedef Expr::Var Var;
+ typedef Expr::Coeff Coeff;
+
+ static const Coeff INF;
+ static const Coeff NaN;
+ // static const Coeff INF=0;
+ // static const Coeff NaN=1;
+
+ Expr expr;
+ Coeff lb,ub;
+
+ Constr() : expr(), lb(NaN), ub(NaN) {}
+ Constr(Coeff _lb,const Expr &e,Coeff _ub) :
+ expr(e), lb(_lb), ub(_ub) {}
+ Constr(const Expr &e,Coeff _ub) :
+ expr(e), lb(NaN), ub(_ub) {}
+ Constr(Coeff _lb,const Expr &e) :
+ expr(e), lb(_lb), ub(NaN) {}
+ Constr(const Expr &e) :
+ expr(e), lb(NaN), ub(NaN) {}
+ };
+
protected:
_FixId rows;
@@ -290,6 +388,21 @@
}
return s;
}
+ template<class T>
+ typename enable_if<typename T::ValueSet::value_type::LpSolverCol,
+ int>::type
+ addColSet(T &t,dummy<2> = 2) {
+ ///\bug <tt>return addColSet(t.valueSet());</tt> should also work.
+ int s=0;
+ for(typename T::ValueSet::iterator i=t.valueSet().begin();
+ i!=t.valueSet().end();
+ ++i)
+ {
+ *i=addCol();
+ s++;
+ }
+ return s;
+ }
#endif
///Add a new empty row (i.e a new constaint) to the LP
@@ -326,8 +439,6 @@
///\param r is the row to be modified
///\param c is a linear expression (see \ref Constr)
- ///\bug This is a temportary function. The interface will change to
- ///a better one.
void setRow(Row r, const Constr &c) {
Value lb= c.lb==NaN?-INF:lb;
Value ub= c.ub==NaN?INF:lb;
@@ -352,8 +463,6 @@
///\param c is a linear expression (see \ref Constr)
///\return The created row.
- ///\bug This is a temportary function. The interface will change to
- ///a better one.
Row addRow(const Constr &c) {
Row r=addRow();
setRow(r,c);
@@ -427,6 +536,186 @@
};
+ ///\e
+
+ ///\relates LpSolverBase::Expr
+ ///
+ inline LpSolverBase::Expr operator+(const LpSolverBase::Expr &a,
+ const LpSolverBase::Expr &b)
+ {
+ LpSolverBase::Expr tmp(a);
+ tmp+=b; ///\todo Don't STL have some special 'merge' algorithm?
+ return tmp;
+ }
+ ///\e
+
+ ///\relates LpSolverBase::Expr
+ ///
+ inline LpSolverBase::Expr operator-(const LpSolverBase::Expr &a,
+ const LpSolverBase::Expr &b)
+ {
+ LpSolverBase::Expr tmp(a);
+ tmp-=b; ///\todo Don't STL have some special 'merge' algorithm?
+ return tmp;
+ }
+ ///\e
+
+ ///\relates LpSolverBase::Expr
+ ///
+ inline LpSolverBase::Expr operator*(const LpSolverBase::Expr &a,
+ const LpSolverBase::Expr::Coeff &b)
+ {
+ LpSolverBase::Expr tmp(a);
+ tmp*=b; ///\todo Don't STL have some special 'merge' algorithm?
+ return tmp;
+ }
+
+ ///\e
+
+ ///\relates LpSolverBase::Expr
+ ///
+ inline LpSolverBase::Expr operator*(const LpSolverBase::Expr::Coeff &a,
+ const LpSolverBase::Expr &b)
+ {
+ LpSolverBase::Expr tmp(b);
+ tmp*=a; ///\todo Don't STL have some special 'merge' algorithm?
+ return tmp;
+ }
+ ///\e
+
+ ///\relates LpSolverBase::Expr
+ ///
+ inline LpSolverBase::Expr operator/(const LpSolverBase::Expr &a,
+ const LpSolverBase::Expr::Coeff &b)
+ {
+ LpSolverBase::Expr tmp(a);
+ tmp/=b; ///\todo Don't STL have some special 'merge' algorithm?
+ return tmp;
+ }
+
+ ///\e
+
+ ///\relates LpSolverBase::Constr
+ ///
+ inline LpSolverBase::Constr operator<=(const LpSolverBase::Expr &e,
+ const LpSolverBase::Expr &f)
+ {
+ return LpSolverBase::Constr(-LpSolverBase::INF,e-f,0);
+ }
+
+ ///\e
+
+ ///\relates LpSolverBase::Constr
+ ///
+ inline LpSolverBase::Constr operator<=(const LpSolverBase::Expr::Coeff &e,
+ const LpSolverBase::Expr &f)
+ {
+ return LpSolverBase::Constr(e,f);
+ }
+
+ ///\e
+
+ ///\relates LpSolverBase::Constr
+ ///
+ inline LpSolverBase::Constr operator<=(const LpSolverBase::Expr &e,
+ const LpSolverBase::Expr::Coeff &f)
+ {
+ return LpSolverBase::Constr(e,f);
+ }
+
+ ///\e
+
+ ///\relates LpSolverBase::Constr
+ ///
+ inline LpSolverBase::Constr operator>=(const LpSolverBase::Expr &e,
+ const LpSolverBase::Expr &f)
+ {
+ return LpSolverBase::Constr(-LpSolverBase::INF,f-e,0);
+ }
+
+
+ ///\e
+
+ ///\relates LpSolverBase::Constr
+ ///
+ inline LpSolverBase::Constr operator>=(const LpSolverBase::Expr::Coeff &e,
+ const LpSolverBase::Expr &f)
+ {
+ return LpSolverBase::Constr(f,e);
+ }
+
+
+ ///\e
+
+ ///\relates LpSolverBase::Constr
+ ///
+ inline LpSolverBase::Constr operator>=(const LpSolverBase::Expr &e,
+ const LpSolverBase::Expr::Coeff &f)
+ {
+ return LpSolverBase::Constr(f,e);
+ }
+
+ ///\e
+
+ ///\relates LpSolverBase::Constr
+ ///
+ inline LpSolverBase::Constr operator==(const LpSolverBase::Expr &e,
+ const LpSolverBase::Expr &f)
+ {
+ return LpSolverBase::Constr(0,e-f,0);
+ }
+
+ ///\e
+
+ ///\relates LpSolverBase::Constr
+ ///
+ inline LpSolverBase::Constr operator<=(const LpSolverBase::Constr::Coeff &n,
+ const LpSolverBase::Constr&c)
+ {
+ LpSolverBase::Constr tmp(c);
+ if(tmp.lb!=tmp.NaN) throw LogicError();
+ else tmp.lb=n;
+ return tmp;
+ }
+ ///\e
+
+ ///\relates LpSolverBase::Constr
+ ///
+ inline LpSolverBase::Constr operator<=(const LpSolverBase::Constr& c,
+ const LpSolverBase::Constr::Coeff &n)
+ {
+ LpSolverBase::Constr tmp(c);
+ if(tmp.ub!=tmp.NaN) throw LogicError();
+ else tmp.ub=n;
+ return tmp;
+ }
+
+ ///\e
+
+ ///\relates LpSolverBase::Constr
+ ///
+ inline LpSolverBase::Constr operator>=(const LpSolverBase::Constr::Coeff &n,
+ const LpSolverBase::Constr&c)
+ {
+ LpSolverBase::Constr tmp(c);
+ if(tmp.ub!=tmp.NaN) throw LogicError();
+ else tmp.ub=n;
+ return tmp;
+ }
+ ///\e
+
+ ///\relates LpSolverBase::Constr
+ ///
+ inline LpSolverBase::Constr operator>=(const LpSolverBase::Constr& c,
+ const LpSolverBase::Constr::Coeff &n)
+ {
+ LpSolverBase::Constr tmp(c);
+ if(tmp.lb!=tmp.NaN) throw LogicError();
+ else tmp.lb=n;
+ return tmp;
+ }
+
+
} //namespace lemon
#endif //LEMON_LP_BASE_H
Modified: hugo/trunk/src/work/athos/lp/lp_test.cc
==============================================================================
--- hugo/trunk/src/work/athos/lp/lp_test.cc (original)
+++ hugo/trunk/src/work/athos/lp/lp_test.cc Wed Mar 30 10:28:44 2005
@@ -24,13 +24,96 @@
lp.addColSet(z);
- LP::Expr e;
+ LP::Expr e,f,g;
+ LP::Col p1,p2,p3,p4,p5;
+ LP::Constr c;
+
+ e[p1]=2;
+ e.constComp()=12;
+ e[p1]+=2;
+ e.constComp()+=12;
+ e[p1]-=2;
+ e.constComp()-=12;
+
+ e=2;
+ e=2.2;
+ e=p1;
+ e=f;
+
+ e+=2;
+ e+=2.2;
+ e+=p1;
+ e+=f;
+
+ e-=2;
+ e-=2.2;
+ e-=p1;
+ e-=f;
+
+ e*=2;
+ e*=2.2;
+ e/=2;
+ e/=2.2;
+
+ e=((p1+p2)+(p1-p2)+(p1+12)+(12+p1)+(p1-12)+(12-p1)+
+ (f+12)+(12+f)+(p1+f)+(f+p1)+(f+g)+
+ (f-12)+(12-f)+(p1-f)+(f-p1)+(f-g)+
+ 2.2*f+f*2.2+f/2.2+
+ 2*f+f*2+f/2+
+ 2.2*p1+p1*2.2+p1/2.2+
+ 2*p1+p1*2+p1/2
+ );
+
+
+ c = (e <= f );
+ c = (e <= 2.2);
+ c = (e <= 2 );
+ c = (e <= p1 );
+ c = (2.2<= f );
+ c = (2 <= f );
+ c = (p1 <= f );
+ c = (p1 <= p2 );
+ c = (p1 <= 2.2);
+ c = (p1 <= 2 );
+ c = (2.2<= p2 );
+ c = (2 <= p2 );
+
+ c = (e >= f );
+ c = (e >= 2.2);
+ c = (e >= 2 );
+ c = (e >= p1 );
+ c = (2.2>= f );
+ c = (2 >= f );
+ c = (p1 >= f );
+ c = (p1 >= p2 );
+ c = (p1 >= 2.2);
+ c = (p1 >= 2 );
+ c = (2.2>= p2 );
+ c = (2 >= p2 );
+
+ c = (e == f );
+ c = (e == 2.2);
+ c = (e == 2 );
+ c = (e == p1 );
+ c = (2.2== f );
+ c = (2 == f );
+ c = (p1 == f );
+ //c = (p1 == p2 );
+ c = (p1 == 2.2);
+ c = (p1 == 2 );
+ c = (2.2== p2 );
+ c = (2 == p2 );
+
+ c = (2 <= e <= 3);
+ c = (2 <= p1<= 3);
+
+ c = (2 >= e >= 3);
+ c = (2 >= p1>= 3);
+
e[x[3]]=2;
e[x[3]]=4;
e[x[3]]=1;
e.constComp()=12;
-
- LP::Col p1,p2,p3,p4,p5;
lp.addRow(LP::INF,e,23);
lp.addRow(LP::INF,3.0*(p1+p2)-p3,23);
@@ -40,6 +123,8 @@
lp.addRow(x[1]+x[3]<=x[5]-3);
lp.addRow(-7<=x[1]+x[3]-12<=3);
+ //lp.addRow(x[1]<=x[5]);
+
}
@@ -57,8 +142,8 @@
typedef typename G::InEdgeIt InEdgeIt;
typename G::EdgeMap<LpGlpk::Col> x(g);
- // lp.addColSet(x);
- for(EdgeIt e(g);e!=INVALID;++e) x[e]=lp.addCol();
+ lp.addColSet(x);
+ //for(EdgeIt e(g);e!=INVALID;++e) x[e]=lp.addCol();
for(EdgeIt e(g);e!=INVALID;++e) {
lp.setColUpperBound(x[e],cap[e]);
More information about the Lemon-commits
mailing list