Index: boost/numeric/ublas/io.hpp
===================================================================
--- boost/numeric/ublas/io.hpp	(revision 58644)
+++ boost/numeric/ublas/io.hpp	(working copy)
@@ -1,6 +1,6 @@
 //
-//  Copyright (c) 2000-2002
-//  Joerg Walter, Mathias Koch
+//  Copyright (c) 2000-2010
+//  Joerg Walter, Mathias Koch, Michael Baars
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -13,103 +13,144 @@
 #ifndef _BOOST_UBLAS_IO_
 #define _BOOST_UBLAS_IO_
 
-// Only forward definition required to define stream operations
 #include <iosfwd>
 #include <sstream>
 #include <boost/numeric/ublas/matrix_expression.hpp>
 
+namespace boost
+{ 
+  namespace numeric 
+  {
+    namespace ublas 
+    {
 
-namespace boost { namespace numeric { namespace ublas {
+      template<class E, class T, class VE>
+      std::basic_ostream<E, T> &operator << 
+	(std::basic_ostream<E, T> &os, const vector_expression<VE> &v) 
+      {
+	typedef typename VE::size_type size_type;
 
-    template<class E, class T, class VE>
-    // BOOST_UBLAS_INLINE This function seems to be big. So we do not let the compiler inline it.
-    std::basic_ostream<E, T> &operator << (std::basic_ostream<E, T> &os,
-                                           const vector_expression<VE> &v) {
-        typedef typename VE::size_type size_type;
-        size_type size = v ().size ();
-        std::basic_ostringstream<E, T, std::allocator<E> > s;
-        s.flags (os.flags ());
-        s.imbue (os.getloc ());
-        s.precision (os.precision ());
-        s << '[' << size << "](";
-        if (size > 0)
-            s << v () (0);
-        for (size_type i = 1; i < size; ++ i)
-            s << ',' << v () (i);
-        s << ')';
-        return os << s.str ().c_str ();
-    }
+	size_type size = v().size();
+    
+	std::basic_ostringstream< E, T, std::allocator<E> > s;
 
-    template<class E, class T, class VT, class VA>
-    // BOOST_UBLAS_INLINE This function seems to be big. So we do not let the compiler inline it.
-    std::basic_istream<E, T> &operator >> (std::basic_istream<E, T> &is,
-                                           vector<VT, VA> &v) {
-        typedef typename vector<VT, VA>::size_type size_type;
-        E ch;
+	s.flags (os.flags());
+	s.imbue (os.getloc());
+	s.precision (os.precision());
+
+	s << '[' << size << "](";
+
+	if (size > 0)
+	{
+	  s << v()(0);
+	}
+    
+	for (size_type i = 1; i < size; ++ i)
+	{
+	  s << ',' << v()(i);
+	  s << ')';
+	}
+
+	return os << s.str ().c_str ();
+      }
+
+      template<class E, class T, class VT, class VA>
+      std::basic_istream<E, T> &operator >>
+	(std::basic_istream<E, T> &is, vector<VT, VA> &v)
+      {
+	typedef typename vector<VT, VA>::size_type size_type;
+        
+	E ch;
         size_type size;
-        if (is >> ch && ch != '[') {
-            is.putback (ch);
-            is.setstate (std::ios_base::failbit);
-        } else if (is >> size >> ch && ch != ']') {
-            is.putback (ch);
-            is.setstate (std::ios_base::failbit);
-        } else if (! is.fail ()) {
-            vector<VT, VA> s (size);
-            if (is >> ch && ch != '(') {
+        
+	if (is >> ch && ch != '[')
+	{
+	  is.putback (ch);
+	  is.setstate (std::ios_base::failbit);
+        }
+	else if (is >> size >> ch && ch != ']')
+	{
+	  is.putback (ch);
+	  is.setstate (std::ios_base::failbit);
+        }
+	else if (! is.fail ())
+	{
+	  vector<VT, VA> s (size);
+
+	  if (is >> ch && ch != '(')
+	  {
+	    is.putback (ch);
+	    is.setstate (std::ios_base::failbit);
+          }
+	  else if (! is.fail ())
+	  {
+	    for (size_type i = 0; i < size; i ++)
+	    {
+	      if (is >> s (i) >> ch && ch != ',')
+	      {
                 is.putback (ch);
-                is.setstate (std::ios_base::failbit);
-            } else if (! is.fail ()) {
-                for (size_type i = 0; i < size; i ++) {
-                    if (is >> s (i) >> ch && ch != ',') {
-                        is.putback (ch);
-                        if (i < size - 1)
-                            is.setstate (std::ios_base::failbit);
-                        break;
-                    }
-                }
-                if (is >> ch && ch != ')') {
-                    is.putback (ch);
-                    is.setstate (std::ios_base::failbit);
-                }
+                if (i < size - 1) is.setstate (std::ios_base::failbit);
+                break;
+              }
             }
-            if (! is.fail ())
-                v.swap (s);
+            if (is >> ch && ch != ')')
+	    {
+	      is.putback (ch);
+              is.setstate (std::ios_base::failbit);
+            }
+          }
+          if (! is.fail()) v.swap (s);
         }
+
         return is;
-    }
+      }
 
-    template<class E, class T, class ME>
-    // BOOST_UBLAS_INLINE This function seems to be big. So we do not let the compiler inline it.
-    std::basic_ostream<E, T> &operator << (std::basic_ostream<E, T> &os,
-                                           const matrix_expression<ME> &m) {
-        typedef typename ME::size_type size_type;
+      template<class E, class T, class ME>
+      std::basic_ostream<E, T> &operator <<
+        (std::basic_ostream<E, T> &os, const matrix_expression<ME> &m)
+      {
+	typedef typename ME::size_type size_type;
+
         size_type size1 = m ().size1 ();
         size_type size2 = m ().size2 ();
+
         std::basic_ostringstream<E, T, std::allocator<E> > s;
         s.flags (os.flags ());
         s.imbue (os.getloc ());
         s.precision (os.precision ());
-        s << '[' << size1 << ',' << size2 << "](";
-        if (size1 > 0) {
-            s << '(' ;
-            if (size2 > 0)
-                s << m () (0, 0);
-            for (size_type j = 1; j < size2; ++ j)
-                s << ',' << m () (0, j);
-            s << ')';
-        }
-        for (size_type i = 1; i < size1; ++ i) {
-            s << ",(" ;
-            if (size2 > 0)
-                s << m () (i, 0);
-            for (size_type j = 1; j < size2; ++ j)
-                s << ',' << m () (i, j);
-            s << ')';
-        }
-        s << ')';
-        return os << s.str ().c_str ();
-    }
 
+	s << '[' << size1 << ',' << size2 << "](";
+
+	if (size1 > 0)
+	{
+	  s << '(' ;
+          if (size2 > 0) s << m()(0, 0);
+          for (size_type j = 1; j < size2; ++ j)
+	  {
+	    s << ',' << m () (0, j);
+	  }
+          s << ')';
+	}
+
+	for (size_type i = 1; i < size1; ++ i) 
+	{
+          s << ",(" ;
+          if (size2 > 0) s << m () (i, 0);
+          for (size_type j = 1; j < size2; ++ j)
+	  { 
+	    s << ',' << m () (i, j);
+	  }
+          s << ')';
+	}
+
+	s << ')';
+
+	return os << s.str ().c_str ();
+      }
+
+      // end of temporary modifications
+
+
     template<class E, class T, class MT, class MF, class MA>
     // BOOST_UBLAS_INLINE This function seems to be big. So we do not let the compiler inline it.
     std::basic_istream<E, T> &operator >> (std::basic_istream<E, T> &is,