Changeset 1259:11a09f1319b3 in lemon-0.x for src/work/athos/lp/lin_expr.h

Timestamp:

03/25/05 13:58:52 (20 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

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

Message:

• Largely extended linear expressions
• Better docs

File:

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

src/work/athos/lp/lin_expr.h

@@ -28 +28 @@
   
   /// Class to handle sparse linear expressions
-  template <class _V,class _C>
-  class SparseLinExpr : public std::map<_V, _C>
+  template <class _V>
+  class SparseLinExpr : public std::map<_V, typename _V::ExprValue>
   {
   public:
     typedef _V Var; 
-    typedef _C Coeff;
+    typedef typename _V::ExprValue Coeff;
     
   protected:
-    typedef typename std::map<_V, _C> Base;
+    typedef typename std::map<_V, typename _V::ExprValue> Base;
 
     Coeff const_comp;
   public:
-    SparseLinExpr() { }
-    SparseLinExpr(const Var &v) : const_comp(v) {
+    ///\e
+    SparseLinExpr() : Base(), const_comp(0) { }
+    ///\e
+    SparseLinExpr(const Var &v) : const_comp(0) {
       Base::insert(std::make_pair(v, 1));
     }
+    ///\e
     SparseLinExpr(const Coeff &v) : const_comp(v) {}
     
+    ///\e
     void set(const Var &v,const Coeff &c) {
       return Base::insert(std::make_pair(v, c));
@@ -52 +56 @@
 //     const Coeff &operator[](const Var &v) const { return data[v]; }
 
+    ///\e
     Coeff &constComp() { return const_comp; }
+    ///\e
     const Coeff &constComp() const { return const_comp; }
 
@@ -65 +71 @@
     }
    
+    ///\e
+    SparseLinExpr &operator+=(const SparseLinExpr &e) {
+      for (typename 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
+    SparseLinExpr &operator-=(const SparseLinExpr &e) {
+      for (typename Base::const_iterator j=e.begin(); j!=e.end(); ++j)
+        (*this)[j->first]-=j->second;
+      const_comp-=e.const_comp;
+      return *this;
+    }
+    ///\e
+    SparseLinExpr &operator*=(const Coeff &c) {
+      for (typename Base::iterator j=Base::begin(); j!=Base::end(); ++j)
+        j->second*=c;
+      const_comp*=c;
+      return *this;
+    }
+    ///\e
+    SparseLinExpr &operator/=(const Coeff &c) {
+      for (typename Base::iterator j=Base::begin(); j!=Base::end(); ++j)
+        j->second/=c;
+      const_comp/=c;
+      return *this;
+    }
+    
   };
 
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator+(const SparseLinExpr<V> &a,
+                                const SparseLinExpr<V> &b) {
+    SparseLinExpr<V> tmp(a);
+    tmp+=b; ///\todo Don't STL have some special 'merge' algorithm?
+    return tmp;
+  }
+  
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator-(const SparseLinExpr<V> &a,
+                                const SparseLinExpr<V> &b) {
+    SparseLinExpr<V> tmp(a);
+    tmp-=b; ///\todo Don't STL have some special 'merge' algorithm?
+    return tmp;
+  }
+  
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator*(const typename V::ExprValue &c,
+                               const SparseLinExpr<V> &e) {
+    SparseLinExpr<V> tmp(e);
+    tmp*=c;
+    return tmp;
+  }
+  
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator*(const SparseLinExpr<V> &e,
+                               const typename V::ExprValue &c) {
+    SparseLinExpr<V> tmp(e);
+    tmp*=c;
+    return tmp;
+  }
+  
+  
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator/(const SparseLinExpr<V> &e,
+                               const typename V::ExprValue &c) {
+    SparseLinExpr<V> tmp(e);
+    tmp/=c;
+    return tmp;
+  }
+  
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator+(const typename V::ExprValue &c,
+                             const SparseLinExpr<V> &e) {
+    SparseLinExpr<V> tmp(e);
+    tmp.constComp()+=c;
+    return tmp;
+  }
+
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator+(const SparseLinExpr<V> &e,
+                             const typename V::ExprValue &c) {
+    SparseLinExpr<V> tmp(e);
+    tmp.constComp()+=c;
+    return tmp;
+  }
+
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator+(const V &v,const SparseLinExpr<V> &e) {
+    SparseLinExpr<V> tmp(e);
+    tmp[v]+=1;
+    return tmp;
+  }
+
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator+(const SparseLinExpr<V> &e,const V &v) {
+    SparseLinExpr<V> tmp(e);
+    tmp[v]+=1;
+    return tmp;
+  }
+
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator-(const typename V::ExprValue &c,
+                             const SparseLinExpr<V> &e) {
+    SparseLinExpr<V> tmp(e);
+    tmp*=-1;
+    tmp.constComp()+=c;
+    return tmp;
+  }
+
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator-(const SparseLinExpr<V> &e,
+                             const typename V::ExprValue &c) {
+    SparseLinExpr<V> tmp(e);
+    tmp.constComp()-=c;
+    return tmp;
+  }
+
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator-(const V &v,const SparseLinExpr<V> &e) {
+    SparseLinExpr<V> tmp(e);
+    tmp*=-1;
+    tmp[v]+=1;
+    return tmp;
+  }
+
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator-(const SparseLinExpr<V> &e,const V &v) {
+    SparseLinExpr<V> tmp(e);
+    tmp[v]-=1;
+    return tmp;
+  }
+
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator+(const V &v1,const V &v2) {
+    SparseLinExpr<V> tmp(v1);
+    tmp[v2]+=1;
+    return tmp;
+  }
+
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator*(const V &v,const typename V::ExprValue &c) {
+    SparseLinExpr<V> tmp;
+    tmp[v]=c;
+    return tmp;
+  }
+
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator*(const typename V::ExprValue &c,const V &v) {
+    SparseLinExpr<V> tmp;
+    tmp[v]=c;
+    return tmp;
+  }
+
+  ///\e
+  
+  ///\relates SparseLinExpr
+  ///
+  template <class V>
+  SparseLinExpr<V> operator/(const V &v,const typename V::ExprValue &c) {
+    SparseLinExpr<V> tmp;
+    tmp[v]=1/c;
+    return tmp;
+  }
+
+
 } //namespace lemon