Changeset 1044:f97380557656 in lemon-0.x

Timestamp:

01/04/05 18:05:20 (20 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

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

Message:

• Missing 'const' keywords added
• Stupid implementation of 'AbsMap?' has been corrected.

File:

• src/lemon/maps.h (modified) (10 diffs)

src/lemon/maps.h

@@ -197 +197 @@
     ///
     AddMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
-    Value operator[](Key k) {return m1[k]+m2[k];}
+    Value operator[](Key k) const {return m1[k]+m2[k];}
   };
   
@@ -234 +234 @@
     ///
     SubMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
-    Value operator[](Key k) {return m1[k]-m2[k];}
+    Value operator[](Key k) const {return m1[k]-m2[k];}
   };
   
@@ -270 +270 @@
     ///
     MulMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
-    Value operator[](Key k) {return m1[k]*m2[k];}
+    Value operator[](Key k) const {return m1[k]*m2[k];}
   };
   
@@ -304 +304 @@
     ///
     DivMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
-    Value operator[](Key k) {return m1[k]/m2[k];}
+    Value operator[](Key k) const {return m1[k]/m2[k];}
   };
   
@@ -327 +327 @@
   ///  ComposeMap<M1,M2> cm(m1,m2);
   ///\endcode
-  ///<tt>cm[x]</tt> will be equal to <tt>m1[m2[x]]</tt>
+  /// <tt>cm[x]</tt> will be equal to <tt>m1[m2[x]]</tt>
   ///
   ///Its \c Key is inherited from \c M2 and its \c Value is from
@@ -348 +348 @@
     ///
     ComposeMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
-    Value operator[](Key k) {return m1[m2[k]];}
+    Value operator[](Key k) const {return m1[m2[k]];}
   };
   
@@ -382 +382 @@
     ///
     NegMap(const M &_m) : m(_m) {};
-    Value operator[](Key k) {return -m[k];}
+    Value operator[](Key k) const {return -m[k];}
   };
   
@@ -396 +396 @@
 
 
-  //\todo We need a unified way to handle the situation below!
-  struct _UnConvertible {};
-  template<class A> inline A t_abs(A a) {return _UnConvertible();}
-
-  template<> inline int t_abs<>(int n) {return abs(n);}
-  template<> inline long int t_abs<>(long int n) {return labs(n);}
-  //\bug llabs() is overloaded
-  template<> inline long long int t_abs<>(long long int n) {return ::llabs(n);}
-
-  template<> inline float t_abs<>(float n) {return fabsf(n);}
-  template<> inline double t_abs<>(double n) {return fabs(n);}
-  template<> inline long double t_abs<>(long double n) {return fabsl(n);}
-
   ///Absolute value of a map
 
@@ -414 +401 @@
   ///of the
   ///value returned by the
-  ///given map. Its \c Key and \c Value will be inherited from \c M.
-  ///The function <tt>Value abs(Value)<tt> must be defined, of course.
+  ///given map. Its \c Key and \c Value will be inherited
+  ///from <tt>M</tt>. <tt>Value</tt>
+  ///must be comparable to <tt>0</tt> and the unary <tt>-</tt>
+  ///operator must be defined for it, of course.
+  ///
+  ///\bug We need a unified way to handle the situation below:
+  ///\code
+  ///  struct _UnConvertible {};
+  ///  template<class A> inline A t_abs(A a) {return _UnConvertible();}
+  ///  template<> inline int t_abs<>(int n) {return abs(n);}
+  ///  template<> inline long int t_abs<>(long int n) {return labs(n);}
+  ///  template<> inline long long int t_abs<>(long long int n) {return ::llabs(n);}
+  ///  template<> inline float t_abs<>(float n) {return fabsf(n);}
+  ///  template<> inline double t_abs<>(double n) {return fabs(n);}
+  ///  template<> inline long double t_abs<>(long double n) {return fabsl(n);}
+  ///\endcode
+  
 
   template<class M> 
@@ -430 +432 @@
     ///
     AbsMap(const M &_m) : m(_m) {};
-    Value operator[](Key k) {return t_abs(m[k]);}
+    Value operator[](Key k) const {Value tmp=m[k]; return tmp>=0?tmp:-tmp;}
   };