Index: lemon/dim2.h
===================================================================
--- lemon/dim2.h	(revision 49)
+++ lemon/dim2.h	(revision 209)
@@ -1,5 +1,5 @@
-/* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
  *
- * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
  *
  * Copyright (C) 2003-2008
@@ -25,5 +25,5 @@
 ///\ingroup misc
 ///\file
-///\brief A simple two dimensional vector and a bounding box implementation 
+///\brief A simple two dimensional vector and a bounding box implementation
 ///
 /// The class \ref lemon::dim2::Point "dim2::Point" implements
@@ -60,6 +60,6 @@
       T x;
       ///Second coordinate
-      T y;     
-      
+      T y;
+
       ///Default constructor
       Point() {}
@@ -71,5 +71,5 @@
 
       ///The dimension of the vector.
-      ///This function always returns 2. 
+      ///This function always returns 2.
       int size() const { return 2; }
 
@@ -93,5 +93,5 @@
         return x*x+y*y;
       }
-  
+
       ///Increment the left hand side by \c u
       Point<T>& operator +=(const Point<T>& u) {
@@ -100,5 +100,5 @@
         return *this;
       }
-  
+
       ///Decrement the left hand side by \c u
       Point<T>& operator -=(const Point<T>& u) {
@@ -121,10 +121,10 @@
         return *this;
       }
-  
+
       ///Return the scalar product of two vectors
       T operator *(const Point<T>& u) const {
         return x*u.x+y*u.y;
       }
-  
+
       ///Return the sum of two vectors
       Point<T> operator+(const Point<T> &u) const {
@@ -170,5 +170,5 @@
     };
 
-  ///Return a Point 
+  ///Return a Point
 
   ///Return a Point.
@@ -260,5 +260,5 @@
   }
 
-  
+
 
   /// A class to calculate or store the bounding box of plainvectors.
@@ -271,5 +271,5 @@
       bool _empty;
     public:
-      
+
       ///Default constructor: creates an empty bounding box
       BoundingBox() { _empty = true; }
@@ -277,7 +277,7 @@
       ///Construct an instance from one point
       BoundingBox(Point<T> a) { bottom_left=top_right=a; _empty = false; }
-      
+
       ///Construct an instance from two points
-      
+
       ///Construct an instance from two points.
       ///\param a The bottom left corner.
@@ -287,9 +287,9 @@
       BoundingBox(Point<T> a,Point<T> b)
       {
-	bottom_left=a;
-	top_right=b;
-	_empty = false;
-      }
-      
+        bottom_left=a;
+        top_right=b;
+        _empty = false;
+      }
+
       ///Construct an instance from four numbers
 
@@ -300,23 +300,23 @@
       ///\param t The top of the box.
       ///\warning The left side must be no more than the right side and
-      ///bottom must be no more than the top. 
+      ///bottom must be no more than the top.
       BoundingBox(T l,T b,T r,T t)
       {
-	bottom_left=Point<T>(l,b);
-	top_right=Point<T>(r,t);
-	_empty = false;
-      }
-      
+        bottom_left=Point<T>(l,b);
+        top_right=Point<T>(r,t);
+        _empty = false;
+      }
+
       ///Return \c true if the bounding box is empty.
-      
+
       ///Return \c true if the bounding box is empty (i.e. return \c false
       ///if at least one point was added to the box or the coordinates of
       ///the box were set).
       ///
-      ///The coordinates of an empty bounding box are not defined. 
+      ///The coordinates of an empty bounding box are not defined.
       bool empty() const {
         return _empty;
       }
-      
+
       ///Make the BoundingBox empty
       void clear() {
@@ -337,5 +337,5 @@
       ///It should only be used for non-empty box.
       void bottomLeft(Point<T> p) {
-	bottom_left = p;
+        bottom_left = p;
       }
 
@@ -353,5 +353,5 @@
       ///It should only be used for non-empty box.
       void topRight(Point<T> p) {
-	top_right = p;
+        top_right = p;
       }
 
@@ -369,8 +369,8 @@
       ///It should only be used for non-empty box.
       void bottomRight(Point<T> p) {
-	top_right.x = p.x;
-	bottom_left.y = p.y;
-      }
- 
+        top_right.x = p.x;
+        bottom_left.y = p.y;
+      }
+
       ///Give back the top left corner of the box
 
@@ -386,6 +386,6 @@
       ///It should only be used for non-empty box.
       void topLeft(Point<T> p) {
-	top_right.y = p.y;
-	bottom_left.x = p.x;
+        top_right.y = p.y;
+        bottom_left.x = p.x;
       }
 
@@ -403,5 +403,5 @@
       ///It should only be used for non-empty box.
       void bottom(T t) {
-	bottom_left.y = t;
+        bottom_left.y = t;
       }
 
@@ -419,5 +419,5 @@
       ///It should only be used for non-empty box.
       void top(T t) {
-	top_right.y = t;
+        top_right.y = t;
       }
 
@@ -429,5 +429,5 @@
         return bottom_left.x;
       }
- 
+
       ///Set the left side of the box
 
@@ -435,5 +435,5 @@
       ///It should only be used for non-empty box.
       void left(T t) {
-	bottom_left.x = t;
+        bottom_left.x = t;
       }
 
@@ -451,5 +451,5 @@
       ///It should only be used for non-empty box.
       void right(T t) {
-	top_right.x = t;
+        top_right.x = t;
       }
 
@@ -479,5 +479,5 @@
         }
       }
-  
+
       ///Increments a bounding box with a point
 
@@ -497,7 +497,7 @@
         return *this;
       }
-    
+
       ///Increments a bounding box to contain another bounding box
-      
+
       ///Increments a bounding box to contain another bounding box.
       ///
@@ -505,9 +505,9 @@
         if ( !u.empty() ){
           this->add(u.bottomLeft());
-	  this->add(u.topRight());
+          this->add(u.topRight());
         }
         return *this;
       }
-  
+
       ///Intersection of two bounding boxes
 
@@ -517,13 +517,13 @@
         BoundingBox b;
         if (this->_empty || u._empty) {
-	  b._empty = true;
-	} else {
-	  b.bottom_left.x = std::max(this->bottom_left.x,u.bottom_left.x);
-	  b.bottom_left.y = std::max(this->bottom_left.y,u.bottom_left.y);
-	  b.top_right.x = std::min(this->top_right.x,u.top_right.x);
-	  b.top_right.y = std::min(this->top_right.y,u.top_right.y);
-	  b._empty = b.bottom_left.x > b.top_right.x ||
-	             b.bottom_left.y > b.top_right.y;
-	} 
+          b._empty = true;
+        } else {
+          b.bottom_left.x = std::max(this->bottom_left.x,u.bottom_left.x);
+          b.bottom_left.y = std::max(this->bottom_left.y,u.bottom_left.y);
+          b.top_right.x = std::min(this->top_right.x,u.top_right.x);
+          b.top_right.y = std::min(this->top_right.y,u.top_right.y);
+          b._empty = b.bottom_left.x > b.top_right.x ||
+                     b.bottom_left.y > b.top_right.y;
+        }
         return b;
       }
@@ -538,5 +538,5 @@
   ///
   template<class M>
-  class XMap 
+  class XMap
   {
     M& _map;
@@ -550,5 +550,5 @@
     void set(Key k,Value v) {_map.set(k,typename M::Value(v,_map[k].y));}
   };
-    
+
   ///Returns an \ref XMap class
 
@@ -557,12 +557,12 @@
   ///\ingroup maps
   ///\relates XMap
-  template<class M> 
-  inline XMap<M> xMap(M &m) 
+  template<class M>
+  inline XMap<M> xMap(M &m)
   {
     return XMap<M>(m);
   }
 
-  template<class M> 
-  inline XMap<M> xMap(const M &m) 
+  template<class M>
+  inline XMap<M> xMap(const M &m)
   {
     return XMap<M>(m);
@@ -575,5 +575,5 @@
   ///
   template<class M>
-  class ConstXMap 
+  class ConstXMap
   {
     const M& _map;
@@ -586,5 +586,5 @@
     Value operator[](Key k) const {return _map[k].x;}
   };
-    
+
   ///Returns a \ref ConstXMap class
 
@@ -593,6 +593,6 @@
   ///\ingroup maps
   ///\relates ConstXMap
-  template<class M> 
-  inline ConstXMap<M> xMap(const M &m) 
+  template<class M>
+  inline ConstXMap<M> xMap(const M &m)
   {
     return ConstXMap<M>(m);
@@ -600,10 +600,10 @@
 
   ///Map of y-coordinates of a \ref Point "Point"-map
-    
+
   ///\ingroup maps
   ///Map of y-coordinates of a \ref Point "Point"-map.
   ///
   template<class M>
-  class YMap 
+  class YMap
   {
     M& _map;
@@ -624,12 +624,12 @@
   ///\ingroup maps
   ///\relates YMap
-  template<class M> 
-  inline YMap<M> yMap(M &m) 
+  template<class M>
+  inline YMap<M> yMap(M &m)
   {
     return YMap<M>(m);
   }
 
-  template<class M> 
-  inline YMap<M> yMap(const M &m) 
+  template<class M>
+  inline YMap<M> yMap(const M &m)
   {
     return YMap<M>(m);
@@ -642,5 +642,5 @@
   ///
   template<class M>
-  class ConstYMap 
+  class ConstYMap
   {
     const M& _map;
@@ -653,5 +653,5 @@
     Value operator[](Key k) const {return _map[k].y;}
   };
-    
+
   ///Returns a \ref ConstYMap class
 
@@ -660,6 +660,6 @@
   ///\ingroup maps
   ///\relates ConstYMap
-  template<class M> 
-  inline ConstYMap<M> yMap(const M &m) 
+  template<class M>
+  inline ConstYMap<M> yMap(const M &m)
   {
     return ConstYMap<M>(m);
@@ -674,5 +674,5 @@
   ///\ingroup maps
   template<class M>
-  class NormSquareMap 
+  class NormSquareMap
   {
     const M& _map;
@@ -685,5 +685,5 @@
     Value operator[](Key k) const {return _map[k].normSquare();}
   };
-    
+
   ///Returns a \ref NormSquareMap class
 
@@ -692,6 +692,6 @@
   ///\ingroup maps
   ///\relates NormSquareMap
-  template<class M> 
-  inline NormSquareMap<M> normSquareMap(const M &m) 
+  template<class M>
+  inline NormSquareMap<M> normSquareMap(const M &m)
   {
     return NormSquareMap<M>(m);
@@ -701,5 +701,5 @@
 
   } //namespce dim2
-  
+
 } //namespace lemon
 
