Changeset 1264:92ba3e62825d in lemon-0.x for src/work/athos/lp/lin_expr.h

Timestamp:

03/25/05 19:56:07 (21 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

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

Message:

Constraints (expressions containing <= or >=) can be passed to addRow()
and setRow()

File:

• src/work/athos/lp/lin_expr.h (modified) (4 diffs)

src/work/athos/lp/lin_expr.h

@@ -19 +19 @@
 
 #include<vector>
-
-
 #include<map>
-
+#include<lemon/utility.h>
 ///\file
 ///\brief Classes to handle linear expressions
@@ -40 +38 @@
     Coeff const_comp;
   public:
+    typedef True IsLinExpression;
     ///\e
     SparseLinExpr() : Base(), const_comp(0) { }
@@ -263 +262 @@
   ///
   template <class V>
+  SparseLinExpr<V> operator+(const V &v,const typename V::ExprValue &c) {
+    SparseLinExpr<V> tmp(v);
+    tmp.constComp()=c;
+    return tmp;
+  }
+
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator-(const V &v,const typename V::ExprValue &c) {
+    SparseLinExpr<V> tmp(v);
+    tmp.constComp()=-c;
+    return tmp;
+  }
+
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator+(const typename V::ExprValue &c,const V &v) {
+    SparseLinExpr<V> tmp(v);
+    tmp.constComp()=c;
+    return tmp;
+  }
+
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator-(const typename V::ExprValue &c,const V &v) {
+    SparseLinExpr<V> tmp(c);
+    tmp[v]=-1;
+    return tmp;
+  }
+
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
   SparseLinExpr<V> operator+(const V &v1,const V &v2) {
     SparseLinExpr<V> tmp(v1);
@@ -303 +346 @@
 
 
+  //////////////////////////////////////////////////////////////////////
+  /// Constraints
+  //////////////////////////////////////////////////////////////////////
+  
+  template <class E>
+  class LinConstr
+  {
+  public:
+    typedef E Expr;
+    typedef typename E::Var Var;
+    typedef typename E::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;
+    
+    LinConstr() : expr(), lb(NaN), ub(NaN) {}
+    LinConstr(Coeff _lb,const Expr &e,Coeff _ub) :
+      expr(e), lb(_lb), ub(_ub) {}
+    LinConstr(const Expr &e,Coeff _ub) : 
+      expr(e), lb(NaN), ub(_ub) {}
+    LinConstr(Coeff _lb,const Expr &e) :
+      expr(e), lb(_lb), ub(NaN) {}
+  };
+
+  template<class E>
+  const typename LinConstr<E>::Coeff LinConstr<E>::INF=
+    std::numeric_limits<Coeff>::infinity();
+  template<class E>
+  const typename LinConstr<E>::Coeff LinConstr<E>::NaN=
+    std::numeric_limits<Coeff>::quiet_NaN();
+
+  
+  template<class E>
+  typename enable_if<typename E::IsLinExpression, LinConstr<E> >::type
+  operator<=(const E &e,const E &f) 
+  {
+    return LinConstr<E>(-LinConstr<E>::INF,e-f,0);
+  }
+
+  template<class E>
+  typename enable_if<typename E::IsLinExpression, LinConstr<E> >::type
+  operator>=(const E &e,const E &f) 
+  {
+    return LinConstr<E>(-LinConstr<E>::INF,f-e,0);
+  }
+
+  template<class E>
+  typename enable_if<typename E::IsLinExpression, LinConstr<E> >::type
+  operator==(const E &e,const E &f) 
+  {
+    return LinConstr<E>(0,e-f,0);
+  }
+  
+  //////////////////////////////
+
+  template<class E>
+  typename enable_if<typename E::IsLinExpression, LinConstr<E> >::type
+  operator<=(const E &e,const typename E::Coeff &n) 
+  {
+    return LinConstr<E>(e,n);
+  }
+
+  template<class E>
+  typename enable_if<typename E::IsLinExpression, LinConstr<E> >::type
+  operator>=(const E &e,const typename E::Coeff &n) 
+  {
+    return LinConstr<E>(n,e);
+  }
+
+  template<class E>
+  typename enable_if<typename E::IsLinExpression, LinConstr<E> >::type
+  operator==(const E &e,const typename E::Coeff &n) 
+  {
+    return LinConstr<E>(n,e,n);
+  }
+
+  //////////////////////////////
+
+  template<class E>
+  typename enable_if<typename E::IsLinExpression, LinConstr<E> >::type
+  operator<=(const typename E::Coeff &n,const E &e) 
+  {
+    return LinConstr<E>(n,e);
+  }
+
+  template<class E>
+  typename enable_if<typename E::IsLinExpression, LinConstr<E> >::type
+  operator>=(const typename E::Coeff &n,const E &e) 
+  {
+    return LinConstr<E>(e,n);
+  }
+
+  template<class E>
+  typename enable_if<typename E::IsLinExpression, LinConstr<E> >::type
+  operator==(const typename E::Coeff &n,const E &e) 
+  {
+    return LinConstr<E>(n,e,n);
+  }
+
+  //////////////////////////////
+
+  template<class E>
+  typename enable_if<typename E::IsLinExpression, LinConstr<E> >::type
+  operator<=(const typename E::Coeff &n,const LinConstr<E> &c) 
+  {
+    LinConstr<E> tmp(c);
+    if(tmp.lb!=tmp.NaN) throw LogicError();
+    else tmp.lb=n;
+    return tmp;
+  }
+
+  template<class E>
+  typename enable_if<typename E::IsLinExpression, LinConstr<E> >::type
+  operator>=(const typename E::Coeff &n,const LinConstr<E> &c) 
+  {
+    LinConstr<E> tmp(c);
+    if(tmp.ub!=tmp.NaN) throw LogicError();
+    else tmp.ub=n;
+    return tmp;
+  }
+
+  template<class E>
+  typename enable_if<typename E::IsLinExpression, LinConstr<E> >::type
+  operator<=(const LinConstr<E> &c,const typename E::Coeff &n) 
+  {
+    LinConstr<E> tmp(c);
+    if(tmp.ub!=tmp.NaN) throw LogicError();
+    else tmp.ub=n;
+    return tmp;
+  }
+
+  template<class E>
+  typename enable_if<typename E::IsLinExpression, LinConstr<E> >::type
+  operator>=(const LinConstr<E> &c,const typename E::Coeff &n) 
+  {
+    LinConstr<E> tmp(c);
+    if(tmp.lb!=tmp.NaN) throw LogicError();
+    else tmp.lb=n;
+    return tmp;
+  }
+
+  
+
 } //namespace lemon