Index: lemon/bits/bezier.h
===================================================================
--- lemon/bits/bezier.h	(revision 157)
+++ lemon/bits/bezier.h	(revision 184)
@@ -33,5 +33,5 @@
 class BezierBase {
 public:
-  typedef Point<double> Point;
+  typedef lemon::dim2::Point<double> Point;
 protected:
   static Point conv(Point x,Point y,double t) {return (1-t)*x+t*y;}
Index: lemon/bits/traits.h
===================================================================
--- lemon/bits/traits.h	(revision 139)
+++ lemon/bits/traits.h	(revision 184)
@@ -151,6 +151,6 @@
     typedef typename Map::Value Value;
 
-    typedef const Value ConstReturnValue;
-    typedef const Value ReturnValue;
+    typedef Value ConstReturnValue;
+    typedef Value ReturnValue;
   };
 
@@ -179,6 +179,6 @@
     typedef typename MatrixMap::Value Value;
 
-    typedef const Value ConstReturnValue;
-    typedef const Value ReturnValue;
+    typedef Value ConstReturnValue;
+    typedef Value ReturnValue;
   };
 
Index: lemon/dijkstra.h
===================================================================
--- lemon/dijkstra.h	(revision 169)
+++ lemon/dijkstra.h	(revision 184)
@@ -24,4 +24,5 @@
 ///\brief Dijkstra algorithm.
 
+#include <limits>
 #include <lemon/list_graph.h>
 #include <lemon/bin_heap.h>
Index: lemon/graph_to_eps.h
===================================================================
--- lemon/graph_to_eps.h	(revision 157)
+++ lemon/graph_to_eps.h	(revision 184)
@@ -1016,5 +1016,5 @@
       else for(ArcIt e(g);e!=INVALID;++e)
 	if((!_undirected||g.source(e)<g.target(e))&&_arcWidths[e]>0
-	   &&g.source(e)!=g.target(e))
+	   &&g.source(e)!=g.target(e)) {
 	  if(_drawArrows) {
 	    dim2::Point<double> d(mycoords[g.target(e)]-mycoords[g.source(e)]);
@@ -1036,5 +1036,5 @@
 	       << _arcColors[e].green() << ' '
 	       << _arcColors[e].blue() << " arr\n";
-	  }
+	  } 
 	  else os << mycoords[g.source(e)].x << ' '
 		  << mycoords[g.source(e)].y << ' '
@@ -1045,4 +1045,5 @@
 		  << _arcColors[e].blue() << ' '
 		  << _arcWidths[e]*_arcWidthScale << " l\n";
+	}
       os << "grestore\n";
     }
Index: lemon/list_graph.h
===================================================================
--- lemon/list_graph.h	(revision 149)
+++ lemon/list_graph.h	(revision 184)
@@ -116,5 +116,5 @@
       for(n = first_node; 
 	  n!=-1 && nodes[n].first_in == -1; 
-	  n = nodes[n].next);
+	  n = nodes[n].next) {}
       arc.id = (n == -1) ? -1 : nodes[n].first_in;
     }
@@ -126,6 +126,6 @@
 	int n;
 	for(n = nodes[arcs[arc.id].target].next;
-	  n!=-1 && nodes[n].first_in == -1; 
-	  n = nodes[n].next);
+	    n!=-1 && nodes[n].first_in == -1; 
+	    n = nodes[n].next) {}
 	arc.id = (n == -1) ? -1 : nodes[n].first_in;
       }      
Index: lemon/random.h
===================================================================
--- lemon/random.h	(revision 116)
+++ lemon/random.h	(revision 178)
@@ -67,7 +67,17 @@
 #include <vector>
 #include <limits>
+#include <fstream>
 
 #include <lemon/math.h>
 #include <lemon/dim2.h>
+
+#ifndef WIN32
+#include <sys/time.h>
+#include <ctime>
+#include <sys/types.h>
+#include <unistd.h>
+#else
+#include <windows.h>
+#endif
 
 ///\ingroup misc
@@ -527,4 +537,12 @@
   public:
 
+    ///\name Initialization
+    ///
+    /// @{
+
+    ///\name Initialization
+    ///
+    /// @{
+
     /// \brief Default constructor
     ///
@@ -595,4 +613,71 @@
     }
 
+    /// \brief Seeding from file or from process id and time
+    ///
+    /// By default, this function calls the \c seedFromFile() member
+    /// function with the <tt>/dev/urandom</tt> file. If it does not success,
+    /// it uses the \c seedFromTime().
+    /// \return Currently always true.
+    bool seed() {
+#ifndef WIN32
+      if (seedFromFile("/dev/urandom", 0)) return true;
+#endif
+      if (seedFromTime()) return true;
+      return false;
+    }
+    
+    /// \brief Seeding from file
+    ///
+    /// Seeding the random sequence from file. The linux kernel has two
+    /// devices, <tt>/dev/random</tt> and <tt>/dev/urandom</tt> which
+    /// could give good seed values for pseudo random generators (The
+    /// difference between two devices is that the <tt>random</tt> may
+    /// block the reading operation while the kernel can give good
+    /// source of randomness, while the <tt>urandom</tt> does not
+    /// block the input, but it could give back bytes with worse
+    /// entropy).
+    /// \param file The source file
+    /// \param offset The offset, from the file read.
+    /// \return True when the seeding successes.
+#ifndef WIN32
+    bool seedFromFile(const std::string& file = "/dev/urandom", int offset = 0) 
+#else
+    bool seedFromFile(const std::string& file = "", int offset = 0) 
+#endif
+    {
+      std::ifstream rs(file.c_str());
+      const int size = 4;
+      Word buf[size];
+      if (offset != 0 && !rs.seekg(offset)) return false;
+      if (!rs.read(reinterpret_cast<char*>(buf), sizeof(buf))) return false;
+      seed(buf, buf + size);
+      return true;
+    }
+
+    /// \brief Seding from process id and time
+    ///
+    /// Seding from process id and time. This function uses the
+    /// current process id and the current time for initialize the
+    /// random sequence.
+    /// \return Currently always true.
+    bool seedFromTime() { 	
+#ifndef WIN32
+      timeval tv;
+      gettimeofday(&tv, 0);
+      seed(getpid() + tv.tv_sec + tv.tv_usec);
+#else
+      FILETIME time;
+      GetSystemTimeAsFileTime(&time);
+      seed(GetCurrentProcessId() + time.dwHighDateTime + time.dwLowDateTime);
+#endif
+      return true;
+    }
+
+    /// @}
+
+    ///\name Uniform distributions
+    ///
+    /// @{
+
     /// \brief Returns a random real number from the range [0, 1)
     ///
@@ -623,4 +708,10 @@
       return real<Number>() * (b - a) + a; 
     }
+
+    /// @}
+
+    ///\name Uniform distributions
+    ///
+    /// @{
 
     /// \brief Returns a random real number from the range [0, 1)
@@ -680,4 +771,6 @@
       return _random_bits::IntConversion<Number, Word>::convert(core);
     }
+
+    /// @}
 
     unsigned int uinteger() {
@@ -709,4 +802,6 @@
       return bool_producer.convert(core);
     }
+
+    /// @}
 
     ///\name Non-uniform distributions
