[Boost-commit] svn:boost r84595 - trunk/boost/numeric/ublas

Subject: [Boost-commit] svn:boost r84595 - trunk/boost/numeric/ublas
From: david.bellot_at_[hidden]
Date: 2013-06-01 07:18:49

Author: david.bellot
Date: 2013-06-01 07:18:48 EDT (Sat, 01 Jun 2013)
New Revision: 84595
URL: http://svn.boost.org/trac/boost/changeset/84595

Log:
cosmetic changes after patch on assignment

Text files modified: 
   trunk/boost/numeric/ublas/matrix.hpp |   154 ++--                                    
   trunk/boost/numeric/ublas/vector.hpp |  1117 ++++++++++++++++++++------------------- 
   2 files changed, 643 insertions(+), 628 deletions(-)

Modified: trunk/boost/numeric/ublas/matrix.hpp
==============================================================================
--- trunk/boost/numeric/ublas/matrix.hpp	(original)
+++ trunk/boost/numeric/ublas/matrix.hpp	2013-06-01 07:18:48 EDT (Sat, 01 Jun 2013)
@@ -1,8 +1,14 @@
-//  Copyright (c) 2000-2011 Joerg Walter, Mathias Koch, Gunter Winkler, David Bellot
+//
+//  Copyright (c) 2000-2010
+//  Joerg Walter, Mathias Koch, Gunter Winkler, David Bellot
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
 
 #ifndef _BOOST_UBLAS_MATRIX_
 #define _BOOST_UBLAS_MATRIX_
@@ -17,21 +23,21 @@
 // Iterators based on ideas of Jeremy Siek
 
 namespace boost { namespace numeric { 
-    
-    /** \brief main namespace of uBLAS.
-     *
-     * Use this namespace for all operations with uBLAS. It can also be abbreviated with
-     * \code namespace ublas = boost::numeric::ublas; \endcode
-     *
-     * A common practice is to bring this namespace into the current scope with
-     * \code using namespace boost::numeric::ublas; \endcode.
-     *
-     * However, be warned that using the ublas namespace and the std::vector at the same time can lead to the compiler to confusion. 
-     * The solution is simply to prefix each ublas vector like \c boost::numeric::ublas::vector<T>. If you think it's too long to 
-     * write, you can define a new namespace like \c namespace ublas = boost::numeric::ublas and then just declare your vectors
-     * with \c ublas::vector<T>. STL vectors will be declared as vector<T>. No need to prefix with \c std::
-     */
-    namespace ublas {
+	
+	/** \brief main namespace of uBLAS.
+	 *
+	 * Use this namespace for all operations with uBLAS. It can also be abbreviated with
+	 * \code namespace ublas = boost::numeric::ublas; \endcode
+	 *
+	 * A common practice is to bring this namespace into the current scope with
+	 * \code using namespace boost::numeric::ublas; \endcode.
+	 *
+	 * However, be warned that using the ublas namespace and the std::vector at the same time can lead to the compiler to confusion. 
+	 * The solution is simply to prefix each ublas vector like \c boost::numeric::ublas::vector<T>. If you think it's too long to 
+	 * write, you can define a new namespace like \c namespace ublas = boost::numeric::ublas and then just declare your vectors
+	 * with \c ublas::vector<T>. STL vectors will be declared as vector<T>. No need to prefix with \c std::
+	 */
+	namespace ublas {
 
     namespace detail {
         using namespace boost::numeric::ublas;
@@ -108,54 +114,54 @@
         typedef typename L::orientation_category orientation_category;
 
         // Construction and destruction
-      
-      /// Default dense matrix constructor. Make a dense matrix of size (0,0)
-        BOOST_UBLAS_INLINE
-        matrix ():
-            matrix_container<self_type> (),
-            size1_ (0), size2_ (0), data_ () {}
-
-      /** Dense matrix constructor with defined size
-       * \param size1 number of rows
-       * \param size2 number of columns
-       */
-        BOOST_UBLAS_INLINE
-        matrix (size_type size1, size_type size2):
-            matrix_container<self_type> (),
-            size1_ (size1), size2_ (size2), data_ (layout_type::storage_size (size1, size2)) {
-        }
-
-      /** Dense matrix constructor with defined size a initial value for all the matrix elements
-       * \param size1 number of rows
-       * \param size2 number of columns
-       * \param init initial value assigned to all elements
-       */
-        matrix (size_type size1, size_type size2, const value_type &init):
-            matrix_container<self_type> (),
-            size1_ (size1), size2_ (size2), data_ (layout_type::storage_size (size1, size2), init) {
-        }
-
-      /** Dense matrix constructor with defined size and an initial data array
-       * \param size1 number of rows
-       * \param size2 number of columns
-       * \param data array to copy into the matrix. Must have the same dimension as the matrix
-       */
+	  
+	  /// Default dense matrix constructor. Make a dense matrix of size (0,0)
+	    BOOST_UBLAS_INLINE
+	    matrix ():
+	        matrix_container<self_type> (),
+	        size1_ (0), size2_ (0), data_ () {}
+	
+	  /** Dense matrix constructor with defined size
+	   * \param size1 number of rows
+	   * \param size2 number of columns
+	   */
+	    BOOST_UBLAS_INLINE
+	    matrix (size_type size1, size_type size2):
+	        matrix_container<self_type> (),
+	        size1_ (size1), size2_ (size2), data_ (layout_type::storage_size (size1, size2)) {
+	    }
+	
+	  /** Dense matrix constructor with defined size a initial value for all the matrix elements
+	   * \param size1 number of rows
+	   * \param size2 number of columns
+	   * \param init initial value assigned to all elements
+	   */
+	    matrix (size_type size1, size_type size2, const value_type &init):
+	        matrix_container<self_type> (),
+	        size1_ (size1), size2_ (size2), data_ (layout_type::storage_size (size1, size2), init) {
+	    }
+
+	  /** Dense matrix constructor with defined size and an initial data array
+	   * \param size1 number of rows
+	   * \param size2 number of columns
+	   * \param data array to copy into the matrix. Must have the same dimension as the matrix
+	   */
         BOOST_UBLAS_INLINE
         matrix (size_type size1, size_type size2, const array_type &data):
             matrix_container<self_type> (),
             size1_ (size1), size2_ (size2), data_ (data) {}
 
-      /** Copy-constructor of a dense matrix
-       * \param m is a dense matrix
-       */
+	  /** Copy-constructor of a dense matrix
+	   * \param m is a dense matrix
+	   */
         BOOST_UBLAS_INLINE
         matrix (const matrix &m):
             matrix_container<self_type> (),
             size1_ (m.size1_), size2_ (m.size2_), data_ (m.data_) {}
 
-      /** Copy-constructor of a dense matrix from a matrix expression
-       * \param ae is a matrix expression
-       */
+	  /** Copy-constructor of a dense matrix from a matrix expression
+	   * \param ae is a matrix expression
+	   */
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix (const matrix_expression<AE> &ae):
@@ -165,46 +171,46 @@
         }
 
         // Accessors
-      /** Return the number of rows of the matrix
-       * You can also use the free size<>() function in operation/size.hpp as size<1>(m) where m is a matrix
-       */
+	  /** Return the number of rows of the matrix
+	   * You can also use the free size<>() function in operation/size.hpp as size<1>(m) where m is a matrix
+	   */
         BOOST_UBLAS_INLINE
         size_type size1 () const {
             return size1_;
         }
 
-      /** Return the number of colums of the matrix
-       * You can also use the free size<>() function in operation/size.hpp as size<2>(m) where m is a matrix
-       */
+	  /** Return the number of colums of the matrix
+	   * You can also use the free size<>() function in operation/size.hpp as size<2>(m) where m is a matrix
+	   */
         BOOST_UBLAS_INLINE
         size_type size2 () const {
             return size2_;
         }
 
         // Storage accessors
-      /** Return a constant reference to the internal storage of a dense matrix, i.e. the raw data
-       * It's type depends on the type used by the matrix to store its data
-       */
+	  /** Return a constant reference to the internal storage of a dense matrix, i.e. the raw data
+	   * It's type depends on the type used by the matrix to store its data
+	   */
         BOOST_UBLAS_INLINE
         const array_type &data () const {
             return data_;
         }
-      /** Return a reference to the internal storage of a dense matrix, i.e. the raw data
-       * It's type depends on the type used by the matrix to store its data
-       */
+	  /** Return a reference to the internal storage of a dense matrix, i.e. the raw data
+	   * It's type depends on the type used by the matrix to store its data
+	   */
         BOOST_UBLAS_INLINE
         array_type &data () {
             return data_;
         }
 
         // Resizing
-      /** Resize a matrix to new dimensions
-       * If data are preserved, then if the size if bigger at least on one dimension, extra values are filled with zeros.
-       * If data are not preserved, then nothing has to be assumed regarding the content of the matrix after resizing.
-       * \param size1 the new number of rows
-       * \param size2 the new number of colums
-       * \param preserve a boolean to say if one wants the data to be preserved during the resizing. Default is true.
-       */
+	  /** Resize a matrix to new dimensions
+	   * If data are preserved, then if the size if bigger at least on one dimension, extra values are filled with zeros.
+	   * If data are not preserved, then nothing has to be assumed regarding the content of the matrix after resizing.
+	   * \param size1 the new number of rows
+	   * \param size2 the new number of colums
+	   * \param preserve a boolean to say if one wants the data to be preserved during the resizing. Default is true.
+	   */
         BOOST_UBLAS_INLINE
         void resize (size_type size1, size_type size2, bool preserve = true) {
             if (preserve) {
@@ -251,7 +257,7 @@
         }
 
         // Element assignment
-    
+
     /** Change the value of a matrix element. Return back a reference to it
      * \param i the first coordinate of the element. By default it's the row
      * \param j the second coordinate of the element. By default it's the column

Modified: trunk/boost/numeric/ublas/vector.hpp
==============================================================================
--- trunk/boost/numeric/ublas/vector.hpp	(original)
+++ trunk/boost/numeric/ublas/vector.hpp	2013-06-01 07:18:48 EDT (Sat, 01 Jun 2013)
@@ -1,8 +1,17 @@
-//  Copyright (c) 2000-2011 Joerg Walter, Mathias Koch, David Bellot
+//
+//  Copyright (c) 2000-2010
+//  Joerg Walter, Mathias Koch, David Bellot
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+//  And we acknowledge the support from all contributors.
+
+/// \file vector.hpp Definition for the class vector and its derivative
 
 #ifndef _BOOST_UBLAS_VECTOR_
 #define _BOOST_UBLAS_VECTOR_
@@ -37,221 +46,221 @@
         using vector_container<self_type>::operator ();
 #endif
 
-    typedef typename A::size_type size_type;
-        typedef typename A::difference_type difference_type;
-        typedef T value_type;
-        typedef typename type_traits<T>::const_reference const_reference;
-        typedef T &reference;
-        typedef T *pointer;
-        typedef const T *const_pointer;
-        typedef A array_type;
-        typedef const vector_reference<const self_type> const_closure_type;
-        typedef vector_reference<self_type> closure_type;
-        typedef self_type vector_temporary_type;
-        typedef dense_tag storage_category;
-
-        // Construction and destruction
-    
-    /// \brief Constructor of a vector
-    /// By default it is empty, i.e. \c size()==0.
-        BOOST_UBLAS_INLINE
-        vector ():
-            vector_container<self_type> (),
-            data_ () {}
-
-    /// \brief Constructor of a vector with a predefined size
-    /// By default, its elements are initialized to 0.
-    /// \param size initial size of the vector
-        explicit BOOST_UBLAS_INLINE
-        vector (size_type size):
-            vector_container<self_type> (),
-            data_ (size) {
-        }
-
-    /// \brief Constructor of a vector by copying from another container
-    /// This type has the generic name \c array_typ within the vector definition.
-    /// \param size initial size of the vector \bug this value is not used
-    /// \param data container of type \c A
-    /// \todo remove this definition because \c size is not used
-        BOOST_UBLAS_INLINE
-        vector (size_type size, const array_type &data):
-            vector_container<self_type> (),
-            data_ (data) {}
-
-    /// \brief Constructor of a vector by copying from another container
-    /// This type has the generic name \c array_typ within the vector definition.
-    /// \param data container of type \c A
+	typedef typename A::size_type size_type;
+	    typedef typename A::difference_type difference_type;
+	    typedef T value_type;
+	    typedef typename type_traits<T>::const_reference const_reference;
+	    typedef T &reference;
+	    typedef T *pointer;
+	    typedef const T *const_pointer;
+	    typedef A array_type;
+	    typedef const vector_reference<const self_type> const_closure_type;
+	    typedef vector_reference<self_type> closure_type;
+	    typedef self_type vector_temporary_type;
+	    typedef dense_tag storage_category;
+
+	    // Construction and destruction
+	
+	/// \brief Constructor of a vector
+	/// By default it is empty, i.e. \c size()==0.
+	    BOOST_UBLAS_INLINE
+	    vector ():
+	        vector_container<self_type> (),
+	        data_ () {}
+
+	/// \brief Constructor of a vector with a predefined size
+	/// By default, its elements are initialized to 0.
+	/// \param size initial size of the vector
+	    explicit BOOST_UBLAS_INLINE
+	    vector (size_type size):
+	        vector_container<self_type> (),
+	        data_ (size) {
+	    }
+
+	/// \brief Constructor of a vector by copying from another container
+	/// This type has the generic name \c array_typ within the vector definition.
+	/// \param size initial size of the vector \bug this value is not used
+	/// \param data container of type \c A
+	/// \todo remove this definition because \c size is not used
+	    BOOST_UBLAS_INLINE
+	    vector (size_type size, const array_type &data):
+	        vector_container<self_type> (),
+	        data_ (data) {}
+
+	/// \brief Constructor of a vector by copying from another container
+	/// This type has the generic name \c array_typ within the vector definition.
+	/// \param data container of type \c A
         BOOST_UBLAS_INLINE
         vector (const array_type &data):
             vector_container<self_type> (),
             data_ (data) {}
 
-    /// \brief Constructor of a vector with a predefined size and a unique initial value
-    /// \param size of the vector
-    /// \param init value to assign to each element of the vector
-        BOOST_UBLAS_INLINE
-        vector (size_type size, const value_type &init):
-            vector_container<self_type> (),
-            data_ (size, init) {}
-
-    /// \brief Copy-constructor of a vector
-    /// \param v is the vector to be duplicated
-        BOOST_UBLAS_INLINE
-        vector (const vector &v):
-            vector_container<self_type> (),
-            data_ (v.data_) {}
-
-    /// \brief Copy-constructor of a vector from a vector_expression
-    /// Depending on the vector_expression, this constructor can have the cost of the computations 
-    /// of the expression (trivial to say it, but it is to take into account in your complexity calculations).
-    /// \param ae the vector_expression which values will be duplicated into the vector
-        template<class AE>
-        BOOST_UBLAS_INLINE
-        vector (const vector_expression<AE> &ae):
-            vector_container<self_type> (),
-            data_ (ae ().size ()) {
-            vector_assign<scalar_assign> (*this, ae);
-        }
-
-    // -----------------------
-        // Random Access Container
-    // -----------------------
-    
-    /// \brief Return the maximum size of the data container.
-    /// Return the upper bound (maximum size) on the data container. Depending on the container, it can be bigger than the current size of the vector.
-        BOOST_UBLAS_INLINE
-        size_type max_size () const {
-            return data_.max_size ();
-        }
-        
-    /// \brief Return true if the vector is empty (\c size==0)
-    /// \return \c true if empty, \c false otherwise
-        BOOST_UBLAS_INLINE
-        bool empty () const {
-            return data_.size () == 0;
-        }
-
-    // ---------
-        // Accessors
-    // ---------
-    
-    /// \brief Return the size of the vector
+	/// \brief Constructor of a vector with a predefined size and a unique initial value
+	/// \param size of the vector
+	/// \param init value to assign to each element of the vector
+	    BOOST_UBLAS_INLINE
+	    vector (size_type size, const value_type &init):
+	        vector_container<self_type> (),
+	        data_ (size, init) {}
+
+	/// \brief Copy-constructor of a vector
+	/// \param v is the vector to be duplicated
+	    BOOST_UBLAS_INLINE
+	    vector (const vector &v):
+	        vector_container<self_type> (),
+	        data_ (v.data_) {}
+
+	/// \brief Copy-constructor of a vector from a vector_expression
+	/// Depending on the vector_expression, this constructor can have the cost of the computations 
+	/// of the expression (trivial to say it, but it is to take into account in your complexity calculations).
+	/// \param ae the vector_expression which values will be duplicated into the vector
+	    template<class AE>
+	    BOOST_UBLAS_INLINE
+	    vector (const vector_expression<AE> &ae):
+	        vector_container<self_type> (),
+	        data_ (ae ().size ()) {
+	        vector_assign<scalar_assign> (*this, ae);
+	    }
+
+	// -----------------------
+	// Random Access Container
+	// -----------------------
+	
+	/// \brief Return the maximum size of the data container.
+	/// Return the upper bound (maximum size) on the data container. Depending on the container, it can be bigger than the current size of the vector.
+	    BOOST_UBLAS_INLINE
+	    size_type max_size () const {
+	        return data_.max_size ();
+	    }
+	    
+	/// \brief Return true if the vector is empty (\c size==0)
+	/// \return \c true if empty, \c false otherwise
+	    BOOST_UBLAS_INLINE
+	    bool empty () const {
+	        return data_.size () == 0;
+	    }
+
+	// ---------
+	// Accessors
+	// ---------
+	
+	/// \brief Return the size of the vector
         BOOST_UBLAS_INLINE
         size_type size () const {
             return data_.size ();
         }
 
-    // -----------------
-        // Storage accessors
-    // -----------------
-    
-    /// \brief Return a \c const reference to the container. Useful to access data directly for specific type of container.
-        BOOST_UBLAS_INLINE
-        const array_type &data () const {
-            return data_;
-        }
-
-    /// \brief Return a reference to the container. Useful to speed-up write operations to the data in very specific case.
-        BOOST_UBLAS_INLINE
-        array_type &data () {
-            return data_;
-        }
-
-    // --------
-        // Resizing
-    // --------
-    
-    /// \brief Resize the vector
-    /// Resize the vector to a new size. If \c preserve is true, data are copied otherwise data are lost. If the new size is bigger, the remaining values are filled in with the initial value (0 by default) in the case of \c unbounded_array, which is the container by default. If the new size is smaller, last values are lost. This behaviour can be different if you explicitely specify another type of container.
-    /// \param size new size of the vector
-    /// \param preserve if true, keep values
-        BOOST_UBLAS_INLINE
-        void resize (size_type size, bool preserve = true) {
-            if (preserve)
-                data ().resize (size, typename A::value_type ());
-            else
-                data ().resize (size);
-        }
-
-    // ---------------
-        // Element support
-    // ---------------
-    
-    /// \brief Return a pointer to the element \f$i\f$
-    /// \param i index of the element
-    // XXX this semantic is not the one expected by the name of this method
-        BOOST_UBLAS_INLINE
-        pointer find_element (size_type i) {
-            return const_cast<pointer> (const_cast<const self_type&>(*this).find_element (i));
-        }
-
-    /// \brief Return a const pointer to the element \f$i\f$
-    /// \param i index of the element
-    // XXX  this semantic is not the one expected by the name of this method
-        BOOST_UBLAS_INLINE
-        const_pointer find_element (size_type i) const {
-            return & (data () [i]);
-        }
-
-    // --------------
-        // Element access
-    // --------------
-
-    /// \brief Return a const reference to the element \f$i\f$
-    /// Return a const reference to the element \f$i\f$. With some compilers, this notation will be faster than \c[i]
-    /// \param i index of the element
-        BOOST_UBLAS_INLINE
-        const_reference operator () (size_type i) const {
-            return data () [i];
-        }
-    
-    /// \brief Return a reference to the element \f$i\f$
-    /// Return a reference to the element \f$i\f$. With some compilers, this notation will be faster than \c[i]
-    /// \param i index of the element
-        BOOST_UBLAS_INLINE
-        reference operator () (size_type i) {
-            return data () [i];
-        }
-
-    /// \brief Return a const reference to the element \f$i\f$
-    /// \param i index of the element
-        BOOST_UBLAS_INLINE
-        const_reference operator [] (size_type i) const {
-            return (*this) (i);
-        }
-    
-    /// \brief Return a reference to the element \f$i\f$
-    /// \param i index of the element
-        BOOST_UBLAS_INLINE
-        reference operator [] (size_type i) {
-            return (*this) (i);
-        }
-
-    // ------------------
-        // Element assignment
-    // ------------------
-    
-    /// \brief Set element \f$i\f$ to the value \c t
-    /// \param i index of the element
-    /// \param t reference to the value to be set
-    // XXX semantic of this is to insert a new element and therefore size=size+1 ?
+	// -----------------
+	// Storage accessors
+	// -----------------
+	
+	/// \brief Return a \c const reference to the container. Useful to access data directly for specific type of container.
+	    BOOST_UBLAS_INLINE
+	    const array_type &data () const {
+	        return data_;
+	    }
+	
+	/// \brief Return a reference to the container. Useful to speed-up write operations to the data in very specific case.
+	    BOOST_UBLAS_INLINE
+	    array_type &data () {
+	        return data_;
+	    }
+	
+	// --------
+	    // Resizing
+	// --------
+	
+	/// \brief Resize the vector
+	/// Resize the vector to a new size. If \c preserve is true, data are copied otherwise data are lost. If the new size is bigger, the remaining values are filled in with the initial value (0 by default) in the case of \c unbounded_array, which is the container by default. If the new size is smaller, last values are lost. This behaviour can be different if you explicitely specify another type of container.
+	/// \param size new size of the vector
+	/// \param preserve if true, keep values
+	    BOOST_UBLAS_INLINE
+	    void resize (size_type size, bool preserve = true) {
+	        if (preserve)
+	            data ().resize (size, typename A::value_type ());
+	        else
+	            data ().resize (size);
+	    }
+	
+	// ---------------
+	    // Element support
+	// ---------------
+	
+	/// \brief Return a pointer to the element \f$i\f$
+	/// \param i index of the element
+	// XXX this semantic is not the one expected by the name of this method
+	    BOOST_UBLAS_INLINE
+	    pointer find_element (size_type i) {
+	        return const_cast<pointer> (const_cast<const self_type&>(*this).find_element (i));
+	    }
+	
+	/// \brief Return a const pointer to the element \f$i\f$
+	/// \param i index of the element
+	// XXX  this semantic is not the one expected by the name of this method
+	    BOOST_UBLAS_INLINE
+	    const_pointer find_element (size_type i) const {
+	        return & (data () [i]);
+	    }
+	
+	// --------------
+	    // Element access
+	// --------------
+	
+	/// \brief Return a const reference to the element \f$i\f$
+	/// Return a const reference to the element \f$i\f$. With some compilers, this notation will be faster than \c[i]
+	/// \param i index of the element
+	    BOOST_UBLAS_INLINE
+	    const_reference operator () (size_type i) const {
+	        return data () [i];
+	    }
+	
+	/// \brief Return a reference to the element \f$i\f$
+	/// Return a reference to the element \f$i\f$. With some compilers, this notation will be faster than \c[i]
+	/// \param i index of the element
+	    BOOST_UBLAS_INLINE
+	    reference operator () (size_type i) {
+	        return data () [i];
+	    }
+	
+	/// \brief Return a const reference to the element \f$i\f$
+	/// \param i index of the element
+	    BOOST_UBLAS_INLINE
+	    const_reference operator [] (size_type i) const {
+	        return (*this) (i);
+	    }
+	
+	/// \brief Return a reference to the element \f$i\f$
+	/// \param i index of the element
+	    BOOST_UBLAS_INLINE
+	    reference operator [] (size_type i) {
+	        return (*this) (i);
+	    }
+	
+	// ------------------
+	    // Element assignment
+	// ------------------
+	
+	/// \brief Set element \f$i\f$ to the value \c t
+	/// \param i index of the element
+	/// \param t reference to the value to be set
+	// XXX semantic of this is to insert a new element and therefore size=size+1 ?
         BOOST_UBLAS_INLINE
         reference insert_element (size_type i, const_reference t) {
             return (data () [i] = t);
         }
 
-    /// \brief Set element \f$i\f$ to the \e zero value
-    /// \param i index of the element
-        BOOST_UBLAS_INLINE
-        void erase_element (size_type i) {
-            data () [i] = value_type/*zero*/();
-        }
-        
-    // -------
-        // Zeroing
-    // -------
-    
-    /// \brief Clear the vector, i.e. set all values to the \c zero value.
+	/// \brief Set element \f$i\f$ to the \e zero value
+	/// \param i index of the element
+	    BOOST_UBLAS_INLINE
+	    void erase_element (size_type i) {
+	        data () [i] = value_type/*zero*/();
+	    }
+	    
+	// -------
+	    // Zeroing
+	// -------
+	
+	/// \brief Clear the vector, i.e. set all values to the \c zero value.
         BOOST_UBLAS_INLINE
         void clear () {
             std::fill (data ().begin (), data ().end (), value_type/*zero*/());
@@ -260,9 +269,9 @@
         // Assignment
 #ifdef BOOST_UBLAS_MOVE_SEMANTICS
 
-    /// \brief Assign a full vector (\e RHS-vector) to the current vector (\e LHS-vector)
-    /// \param v is the source vector
-    /// \return a reference to a vector (i.e. the destination vector)
+	/// \brief Assign a full vector (\e RHS-vector) to the current vector (\e LHS-vector)
+	/// \param v is the source vector
+	/// \return a reference to a vector (i.e. the destination vector)
         /*! @note "pass by value" the key idea to enable move semantics */
         BOOST_UBLAS_INLINE
         vector &operator = (vector v) {
@@ -270,9 +279,9 @@
             return *this;
         }
 #else
-    /// \brief Assign a full vector (\e RHS-vector) to the current vector (\e LHS-vector)
-    /// \param v is the source vector
-    /// \return a reference to a vector (i.e. the destination vector)
+	/// \brief Assign a full vector (\e RHS-vector) to the current vector (\e LHS-vector)
+	/// \param v is the source vector
+	/// \return a reference to a vector (i.e. the destination vector)
         BOOST_UBLAS_INLINE
         vector &operator = (const vector &v) {
             data () = v.data ();
@@ -280,32 +289,32 @@
         }
 #endif
 
-    /// \brief Assign a full vector (\e RHS-vector) to the current vector (\e LHS-vector)
-    /// Assign a full vector (\e RHS-vector) to the current vector (\e LHS-vector). This method does not create any temporary.
-    /// \param v is the source vector container
-    /// \return a reference to a vector (i.e. the destination vector)
-        template<class C>          // Container assignment without temporary
-        BOOST_UBLAS_INLINE
-        vector &operator = (const vector_container<C> &v) {
-            resize (v ().size (), false);
-            assign (v);
-            return *this;
-        }
-
-    /// \brief Assign a full vector (\e RHS-vector) to the current vector (\e LHS-vector)
-    /// \param v is the source vector
-    /// \return a reference to a vector (i.e. the destination vector)
-        BOOST_UBLAS_INLINE
-        vector &assign_temporary (vector &v) {
-            swap (v);
-            return *this;
-        }
-
-    /// \brief Assign the result of a vector_expression to the vector
-    /// Assign the result of a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
-    /// \tparam AE is the type of the vector_expression
-    /// \param ae is a const reference to the vector_expression
-    /// \return a reference to the resulting vector
+	/// \brief Assign a full vector (\e RHS-vector) to the current vector (\e LHS-vector)
+	/// Assign a full vector (\e RHS-vector) to the current vector (\e LHS-vector). This method does not create any temporary.
+	/// \param v is the source vector container
+	/// \return a reference to a vector (i.e. the destination vector)
+	    template<class C>          // Container assignment without temporary
+	    BOOST_UBLAS_INLINE
+	    vector &operator = (const vector_container<C> &v) {
+	        resize (v ().size (), false);
+	        assign (v);
+	        return *this;
+	    }
+	
+	/// \brief Assign a full vector (\e RHS-vector) to the current vector (\e LHS-vector)
+	/// \param v is the source vector
+	/// \return a reference to a vector (i.e. the destination vector)
+	    BOOST_UBLAS_INLINE
+	    vector &assign_temporary (vector &v) {
+	        swap (v);
+	        return *this;
+	    }
+	
+	/// \brief Assign the result of a vector_expression to the vector
+	/// Assign the result of a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
+	/// \tparam AE is the type of the vector_expression
+	/// \param ae is a const reference to the vector_expression
+	/// \return a reference to the resulting vector
         template<class AE>
         BOOST_UBLAS_INLINE
         vector &operator = (const vector_expression<AE> &ae) {
@@ -313,105 +322,105 @@
             return assign_temporary (temporary);
         }
 
-    /// \brief Assign the result of a vector_expression to the vector
-    /// Assign the result of a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
-    /// \tparam AE is the type of the vector_expression
-    /// \param ae is a const reference to the vector_expression
-    /// \return a reference to the resulting vector
-        template<class AE>
-        BOOST_UBLAS_INLINE
-        vector &assign (const vector_expression<AE> &ae) {
-            vector_assign<scalar_assign> (*this, ae);
-            return *this;
-        }
-
-    // -------------------
-        // Computed assignment
-    // -------------------
-    
-    /// \brief Assign the sum of the vector and a vector_expression to the vector
-    /// Assign the sum of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
-    /// A temporary is created for the computations.
-    /// \tparam AE is the type of the vector_expression
-    /// \param ae is a const reference to the vector_expression
-    /// \return a reference to the resulting vector
-        template<class AE>
-        BOOST_UBLAS_INLINE
-        vector &operator += (const vector_expression<AE> &ae) {
-            self_type temporary (*this + ae);
-            return assign_temporary (temporary);
-        }
-
-    /// \brief Assign the sum of the vector and a vector_expression to the vector
-    /// Assign the sum of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
-    /// No temporary is created. Computations are done and stored directly into the resulting vector.
-    /// \tparam AE is the type of the vector_expression
-    /// \param ae is a const reference to the vector_expression
-    /// \return a reference to the resulting vector
-        template<class C>          // Container assignment without temporary
-        BOOST_UBLAS_INLINE
-        vector &operator += (const vector_container<C> &v) {
-            plus_assign (v);
-            return *this;
-        }
-
-    /// \brief Assign the sum of the vector and a vector_expression to the vector
-    /// Assign the sum of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
-    /// No temporary is created. Computations are done and stored directly into the resulting vector.
-    /// \tparam AE is the type of the vector_expression
-    /// \param ae is a const reference to the vector_expression
-    /// \return a reference to the resulting vector
+	/// \brief Assign the result of a vector_expression to the vector
+	/// Assign the result of a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
+	/// \tparam AE is the type of the vector_expression
+	/// \param ae is a const reference to the vector_expression
+	/// \return a reference to the resulting vector
+	    template<class AE>
+	    BOOST_UBLAS_INLINE
+	    vector &assign (const vector_expression<AE> &ae) {
+	        vector_assign<scalar_assign> (*this, ae);
+	        return *this;
+	    }
+
+	// -------------------
+	    // Computed assignment
+	// -------------------
+	
+	/// \brief Assign the sum of the vector and a vector_expression to the vector
+	/// Assign the sum of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
+	/// A temporary is created for the computations.
+	/// \tparam AE is the type of the vector_expression
+	/// \param ae is a const reference to the vector_expression
+	/// \return a reference to the resulting vector
+	    template<class AE>
+	    BOOST_UBLAS_INLINE
+	    vector &operator += (const vector_expression<AE> &ae) {
+	        self_type temporary (*this + ae);
+	        return assign_temporary (temporary);
+	    }
+
+	/// \brief Assign the sum of the vector and a vector_expression to the vector
+	/// Assign the sum of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
+	/// No temporary is created. Computations are done and stored directly into the resulting vector.
+	/// \tparam AE is the type of the vector_expression
+	/// \param ae is a const reference to the vector_expression
+	/// \return a reference to the resulting vector
+	    template<class C>          // Container assignment without temporary
+	    BOOST_UBLAS_INLINE
+	    vector &operator += (const vector_container<C> &v) {
+	        plus_assign (v);
+	        return *this;
+	    }
+
+	/// \brief Assign the sum of the vector and a vector_expression to the vector
+	/// Assign the sum of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
+	/// No temporary is created. Computations are done and stored directly into the resulting vector.
+	/// \tparam AE is the type of the vector_expression
+	/// \param ae is a const reference to the vector_expression
+	/// \return a reference to the resulting vector
         template<class AE>
         BOOST_UBLAS_INLINE
         vector &plus_assign (const vector_expression<AE> &ae) {
             vector_assign<scalar_plus_assign> (*this, ae);
             return *this;
         }
-    
-    /// \brief Assign the difference of the vector and a vector_expression to the vector
-    /// Assign the difference of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
-    /// A temporary is created for the computations.
-    /// \tparam AE is the type of the vector_expression
-    /// \param ae is a const reference to the vector_expression
-        template<class AE>
-        BOOST_UBLAS_INLINE
-        vector &operator -= (const vector_expression<AE> &ae) {
-            self_type temporary (*this - ae);
-            return assign_temporary (temporary);
-        }
-
-    /// \brief Assign the difference of the vector and a vector_expression to the vector
-    /// Assign the difference of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
-    /// No temporary is created. Computations are done and stored directly into the resulting vector.
-    /// \tparam AE is the type of the vector_expression
-    /// \param ae is a const reference to the vector_expression
-    /// \return a reference to the resulting vector
-        template<class C>          // Container assignment without temporary
-        BOOST_UBLAS_INLINE
-        vector &operator -= (const vector_container<C> &v) {
-            minus_assign (v);
-            return *this;
-        }
-
-    /// \brief Assign the difference of the vector and a vector_expression to the vector
-    /// Assign the difference of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
-    /// No temporary is created. Computations are done and stored directly into the resulting vector.
-    /// \tparam AE is the type of the vector_expression
-    /// \param ae is a const reference to the vector_expression
-    /// \return a reference to the resulting vector
-        template<class AE>
-        BOOST_UBLAS_INLINE
-        vector &minus_assign (const vector_expression<AE> &ae) {
-            vector_assign<scalar_minus_assign> (*this, ae);
-            return *this;
-        }
-
-    /// \brief Assign the product of the vector and a scalar to the vector
-    /// Assign the product of the vector and a scalar to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
-    /// No temporary is created. Computations are done and stored directly into the resulting vector.
-    /// \tparam AE is the type of the vector_expression
-    /// \param at is a const reference to the scalar
-    /// \return a reference to the resulting vector
+	
+	/// \brief Assign the difference of the vector and a vector_expression to the vector
+	/// Assign the difference of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
+	/// A temporary is created for the computations.
+	/// \tparam AE is the type of the vector_expression
+	/// \param ae is a const reference to the vector_expression
+	    template<class AE>
+	    BOOST_UBLAS_INLINE
+	    vector &operator -= (const vector_expression<AE> &ae) {
+	        self_type temporary (*this - ae);
+	        return assign_temporary (temporary);
+	    }
+	
+	/// \brief Assign the difference of the vector and a vector_expression to the vector
+	/// Assign the difference of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
+	/// No temporary is created. Computations are done and stored directly into the resulting vector.
+	/// \tparam AE is the type of the vector_expression
+	/// \param ae is a const reference to the vector_expression
+	/// \return a reference to the resulting vector
+	    template<class C>          // Container assignment without temporary
+	    BOOST_UBLAS_INLINE
+	    vector &operator -= (const vector_container<C> &v) {
+	        minus_assign (v);
+	        return *this;
+	    }
+	
+	/// \brief Assign the difference of the vector and a vector_expression to the vector
+	/// Assign the difference of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
+	/// No temporary is created. Computations are done and stored directly into the resulting vector.
+	/// \tparam AE is the type of the vector_expression
+	/// \param ae is a const reference to the vector_expression
+	/// \return a reference to the resulting vector
+	    template<class AE>
+	    BOOST_UBLAS_INLINE
+	    vector &minus_assign (const vector_expression<AE> &ae) {
+	        vector_assign<scalar_minus_assign> (*this, ae);
+	        return *this;
+	    }
+	
+	/// \brief Assign the product of the vector and a scalar to the vector
+	/// Assign the product of the vector and a scalar to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
+	/// No temporary is created. Computations are done and stored directly into the resulting vector.
+	/// \tparam AE is the type of the vector_expression
+	/// \param at is a const reference to the scalar
+	/// \return a reference to the resulting vector
         template<class AT>
         BOOST_UBLAS_INLINE
         vector &operator *= (const AT &at) {
@@ -419,35 +428,35 @@
             return *this;
         }
 
-    /// \brief Assign the division of the vector by a scalar to the vector
-    /// Assign the division of the vector by a scalar to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
-    /// No temporary is created. Computations are done and stored directly into the resulting vector.
-    /// \tparam AE is the type of the vector_expression
-    /// \param at is a const reference to the scalar
-    /// \return a reference to the resulting vector
-        template<class AT>
-        BOOST_UBLAS_INLINE
-        vector &operator /= (const AT &at) {
-            vector_assign_scalar<scalar_divides_assign> (*this, at);
-            return *this;
-        }
-
-    // --------
-        // Swapping
-    // --------
-
-    /// \brief Swap the content of the vector with another vector
-    /// \param v is the vector to be swapped with
-        BOOST_UBLAS_INLINE
-        void swap (vector &v) {
-            if (this != &v) {
-                data ().swap (v.data ());
-            }
-        }
-
-    /// \brief Swap the content of two vectors
-    /// \param v1 is the first vector. It takes values from v2
-    /// \param v2 is the second vector It takes values from v1
+	/// \brief Assign the division of the vector by a scalar to the vector
+	/// Assign the division of the vector by a scalar to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
+	/// No temporary is created. Computations are done and stored directly into the resulting vector.
+	/// \tparam AE is the type of the vector_expression
+	/// \param at is a const reference to the scalar
+	/// \return a reference to the resulting vector
+	    template<class AT>
+	    BOOST_UBLAS_INLINE
+	    vector &operator /= (const AT &at) {
+	        vector_assign_scalar<scalar_divides_assign> (*this, at);
+	        return *this;
+	    }
+	
+	// --------
+	    // Swapping
+	// --------
+	
+	/// \brief Swap the content of the vector with another vector
+	/// \param v is the vector to be swapped with
+	    BOOST_UBLAS_INLINE
+	    void swap (vector &v) {
+	        if (this != &v) {
+	            data ().swap (v.data ());
+	        }
+	    }
+	
+	/// \brief Swap the content of two vectors
+	/// \param v1 is the first vector. It takes values from v2
+	/// \param v2 is the second vector It takes values from v1
         BOOST_UBLAS_INLINE
         friend void swap (vector &v1, vector &v2) {
             v1.swap (v2);
@@ -468,12 +477,12 @@
         class iterator;
 #endif
 
-    // --------------
-        // Element lookup
-    // --------------
-    
-    /// \brief Return a const iterator to the element \e i
-    /// \param i index of the element
+	// --------------
+	    // Element lookup
+	// --------------
+	
+	/// \brief Return a const iterator to the element \e i
+	/// \param i index of the element
         BOOST_UBLAS_INLINE
         const_iterator find (size_type i) const {
 #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
@@ -483,8 +492,8 @@
 #endif
         }
 
-    /// \brief Return an iterator to the element \e i
-    /// \param i index of the element
+	/// \brief Return an iterator to the element \e i
+	/// \param i index of the element
         BOOST_UBLAS_INLINE
         iterator find (size_type i) {
 #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
@@ -505,84 +514,84 @@
             typedef typename vector::const_reference reference;
             typedef const typename vector::pointer pointer;
 
-        // ----------------------------
-            // Construction and destruction
-        // ----------------------------
-
-
-            BOOST_UBLAS_INLINE
-            const_iterator ():
-                container_const_reference<self_type> (), it_ () {}
-            BOOST_UBLAS_INLINE
-            const_iterator (const self_type &v, const const_subiterator_type &it):
-                container_const_reference<self_type> (v), it_ (it) {}
-            BOOST_UBLAS_INLINE
-            const_iterator (const typename self_type::iterator &it):  // ISSUE vector:: stops VC8 using std::iterator here
-                container_const_reference<self_type> (it ()), it_ (it.it_) {}
-
-        // ----------
-            // Arithmetic
-        // ----------
-
-        /// \brief Increment by 1 the position of the iterator
-        /// \return a reference to the const iterator
-            BOOST_UBLAS_INLINE
-            const_iterator &operator ++ () {
-                ++ it_;
-                return *this;
-            }
-
-        /// \brief Decrement by 1 the position of the iterator
-        /// \return a reference to the const iterator
-            BOOST_UBLAS_INLINE
-            const_iterator &operator -- () {
-                -- it_;
-                return *this;
-            }
-      
-        /// \brief Increment by \e n the position of the iterator 
-        /// \return a reference to the const iterator
-            BOOST_UBLAS_INLINE
-            const_iterator &operator += (difference_type n) {
-                it_ += n;
-                return *this;
-            }
-
-        /// \brief Decrement by \e n the position of the iterator 
-        /// \return a reference to the const iterator
-            BOOST_UBLAS_INLINE
-            const_iterator &operator -= (difference_type n) {
-                it_ -= n;
-                return *this;
-            }
-
-        /// \brief Return the different in number of positions between 2 iterators
-            BOOST_UBLAS_INLINE
-            difference_type operator - (const const_iterator &it) const {
-                BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
-                return it_ - it.it_;
-            }
-
-            /// \brief Dereference an iterator
-            /// Dereference an iterator: a bounds' check is done before returning the value. A bad_index() expection is returned if out of bounds.
-        /// \return a const reference to the value pointed by the iterator
-            BOOST_UBLAS_INLINE
-            const_reference operator * () const {
-                BOOST_UBLAS_CHECK (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_, bad_index ());
-                return *it_;
-            }
-
-        /// \brief Dereference an iterator at the n-th forward value
-        /// Dereference an iterator at the n-th forward value, that is the value pointed by iterator+n.
-            /// A bounds' check is done before returning the value. A bad_index() expection is returned if out of bounds.
-        /// \return a const reference
-            BOOST_UBLAS_INLINE
-            const_reference operator [] (difference_type n) const {
-                return *(it_ + n);
-            }
-
-            // Index
-        /// \brief return the index of the element referenced by the iterator
+	    // ----------------------------
+	        // Construction and destruction
+	    // ----------------------------
+	
+	
+	        BOOST_UBLAS_INLINE
+	        const_iterator ():
+	            container_const_reference<self_type> (), it_ () {}
+	        BOOST_UBLAS_INLINE
+	        const_iterator (const self_type &v, const const_subiterator_type &it):
+	            container_const_reference<self_type> (v), it_ (it) {}
+	        BOOST_UBLAS_INLINE
+	        const_iterator (const typename self_type::iterator &it):  // ISSUE vector:: stops VC8 using std::iterator here
+	            container_const_reference<self_type> (it ()), it_ (it.it_) {}
+	
+	    // ----------
+	        // Arithmetic
+	    // ----------
+	
+	    /// \brief Increment by 1 the position of the iterator
+	    /// \return a reference to the const iterator
+	        BOOST_UBLAS_INLINE
+	        const_iterator &operator ++ () {
+	            ++ it_;
+	            return *this;
+	        }
+
+	    /// \brief Decrement by 1 the position of the iterator
+	    /// \return a reference to the const iterator
+	        BOOST_UBLAS_INLINE
+	        const_iterator &operator -- () {
+	            -- it_;
+	            return *this;
+	        }
+	  
+	    /// \brief Increment by \e n the position of the iterator 
+	    /// \return a reference to the const iterator
+	        BOOST_UBLAS_INLINE
+	        const_iterator &operator += (difference_type n) {
+	            it_ += n;
+	            return *this;
+	        }
+	
+	    /// \brief Decrement by \e n the position of the iterator 
+	    /// \return a reference to the const iterator
+	        BOOST_UBLAS_INLINE
+	        const_iterator &operator -= (difference_type n) {
+	            it_ -= n;
+	            return *this;
+	        }
+	
+	    /// \brief Return the different in number of positions between 2 iterators
+	        BOOST_UBLAS_INLINE
+	        difference_type operator - (const const_iterator &it) const {
+	            BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
+	            return it_ - it.it_;
+	        }
+	
+	        /// \brief Dereference an iterator
+	        /// Dereference an iterator: a bounds' check is done before returning the value. A bad_index() expection is returned if out of bounds.
+	    /// \return a const reference to the value pointed by the iterator
+	        BOOST_UBLAS_INLINE
+	        const_reference operator * () const {
+	            BOOST_UBLAS_CHECK (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_, bad_index ());
+	            return *it_;
+	        }
+	
+	    /// \brief Dereference an iterator at the n-th forward value
+	    /// Dereference an iterator at the n-th forward value, that is the value pointed by iterator+n.
+	        /// A bounds' check is done before returning the value. A bad_index() expection is returned if out of bounds.
+	    /// \return a const reference
+	        BOOST_UBLAS_INLINE
+	        const_reference operator [] (difference_type n) const {
+	            return *(it_ + n);
+	        }
+	
+	        // Index
+	    /// \brief return the index of the element referenced by the iterator
             BOOST_UBLAS_INLINE
             size_type index () const {
                 BOOST_UBLAS_CHECK (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_, bad_index ());
@@ -599,17 +608,17 @@
             }
 
             // Comparison
-        /// \brief compare the value of two itetarors
-        /// \return true if they reference the same element
-            BOOST_UBLAS_INLINE
-            bool operator == (const const_iterator &it) const {
-                BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
-                return it_ == it.it_;
-            }
-
-    
-        /// \brief compare the value of two iterators
-        /// \return return true if the left-hand-side iterator refers to a value placed before the right-hand-side iterator
+	    /// \brief compare the value of two itetarors
+	    /// \return true if they reference the same element
+	        BOOST_UBLAS_INLINE
+	        bool operator == (const const_iterator &it) const {
+	            BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
+	            return it_ == it.it_;
+	        }
+
+	
+	    /// \brief compare the value of two iterators
+	    /// \return return true if the left-hand-side iterator refers to a value placed before the right-hand-side iterator
             BOOST_UBLAS_INLINE
             bool operator < (const const_iterator &it) const {
                 BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
@@ -623,13 +632,13 @@
         };
 #endif
 
-    /// \brief return an iterator on the first element of the vector
-        BOOST_UBLAS_INLINE
-        const_iterator begin () const {
-            return find (0);
-        }
+	/// \brief return an iterator on the first element of the vector
+	    BOOST_UBLAS_INLINE
+	    const_iterator begin () const {
+	        return find (0);
+	    }
 
-    /// \brief return an iterator after the last element of the vector
+	/// \brief return an iterator after the last element of the vector
         BOOST_UBLAS_INLINE
         const_iterator end () const {
             return find (data_.size ());
@@ -727,53 +736,53 @@
         };
 #endif
 
-    /// \brief Return an iterator on the first element of the vector
-        BOOST_UBLAS_INLINE
-        iterator begin () {
-            return find (0);
-        }
-
-    /// \brief Return an iterator at the end of the vector
-        BOOST_UBLAS_INLINE
-        iterator end () {
-            return find (data_.size ());
-        }
-
-        // Reverse iterator
-        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
-        typedef reverse_iterator_base<iterator> reverse_iterator;
-
-    /// \brief Return a const reverse iterator before the first element of the reversed vector (i.e. end() of normal vector)
-        BOOST_UBLAS_INLINE
-        const_reverse_iterator rbegin () const {
-            return const_reverse_iterator (end ());
-        }
-
-    /// \brief Return a const reverse iterator on the end of the reverse vector (i.e. first element of the normal vector) 
-        BOOST_UBLAS_INLINE
-        const_reverse_iterator rend () const {
-            return const_reverse_iterator (begin ());
-        }
-
-    /// \brief Return a const reverse iterator before the first element of the reversed vector (i.e. end() of normal vector)
-        BOOST_UBLAS_INLINE
-        reverse_iterator rbegin () {
-            return reverse_iterator (end ());
-        }
-
-    /// \brief Return a const reverse iterator on the end of the reverse vector (i.e. first element of the normal vector) 
-        BOOST_UBLAS_INLINE
-        reverse_iterator rend () {
-            return reverse_iterator (begin ());
-        }
-
-    // -------------
-        // Serialization
-    // -------------
-    
-    /// Serialize a vector into and archive as defined in Boost
-    /// \param ar Archive object. Can be a flat file, an XML file or any other stream
-    /// \param file_version Optional file version (not yet used)
+	/// \brief Return an iterator on the first element of the vector
+	    BOOST_UBLAS_INLINE
+	    iterator begin () {
+	        return find (0);
+	    }
+	
+	/// \brief Return an iterator at the end of the vector
+	    BOOST_UBLAS_INLINE
+	    iterator end () {
+	        return find (data_.size ());
+	    }
+	
+	    // Reverse iterator
+	    typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
+	    typedef reverse_iterator_base<iterator> reverse_iterator;
+	
+	/// \brief Return a const reverse iterator before the first element of the reversed vector (i.e. end() of normal vector)
+	    BOOST_UBLAS_INLINE
+	    const_reverse_iterator rbegin () const {
+	        return const_reverse_iterator (end ());
+	    }
+	
+	/// \brief Return a const reverse iterator on the end of the reverse vector (i.e. first element of the normal vector) 
+	    BOOST_UBLAS_INLINE
+	    const_reverse_iterator rend () const {
+	        return const_reverse_iterator (begin ());
+	    }
+	
+	/// \brief Return a const reverse iterator before the first element of the reversed vector (i.e. end() of normal vector)
+	    BOOST_UBLAS_INLINE
+	    reverse_iterator rbegin () {
+	        return reverse_iterator (end ());
+	    }
+	
+	/// \brief Return a const reverse iterator on the end of the reverse vector (i.e. first element of the normal vector) 
+	    BOOST_UBLAS_INLINE
+	    reverse_iterator rend () {
+	        return reverse_iterator (begin ());
+	    }
+	
+	// -------------
+	    // Serialization
+	// -------------
+	
+	/// Serialize a vector into and archive as defined in Boost
+	/// \param ar Archive object. Can be a flat file, an XML file or any other stream
+	/// \param file_version Optional file version (not yet used)
         template<class Archive>
         void serialize(Archive & ar, const unsigned int /* file_version */){
             ar & serialization::make_nvp("data",data_);
@@ -1091,55 +1100,55 @@
         typedef sparse_tag storage_category;
 
         // Construction and destruction
-    /// \brief Simple constructor with dimension and index 0
-        BOOST_UBLAS_INLINE
-        unit_vector ():
-            vector_container<self_type> (),
-            size_ (0), index_ (0) {}
-
-    /// \brief Constructor of unit_vector
-    /// \param size is the dimension of the vector
-    /// \param index is the order of the vector
-        BOOST_UBLAS_INLINE
-        explicit unit_vector (size_type size, size_type index = 0):
-            vector_container<self_type> (),
-            size_ (size), index_ (index) {}
-
-    /// \brief Copy-constructor
-        BOOST_UBLAS_INLINE
-        unit_vector (const unit_vector &v):
-            vector_container<self_type> (),
-            size_ (v.size_), index_ (v.index_) {}
-
-        // Accessors
-    //----------
-    
-    /// \brief Return the size (dimension) of the vector
-        BOOST_UBLAS_INLINE
-        size_type size () const {
-            return size_;
-        }
-
-    /// \brief Return the order of the unit vector
-        BOOST_UBLAS_INLINE
-        size_type index () const {
-            return index_;
-        }
-
-        // Resizing
-    // --------
-    
-    /// \brief Resize the vector. The values are preserved by default (i.e. the index does not change)
-    /// \param size is the new size of the vector
-        BOOST_UBLAS_INLINE
-        void resize (size_type size, bool /*preserve*/ = true) {
-            size_ = size;
-        }
-
-        // Element support
-    // ---------------
-    
-    /// \brief Return a const pointer to the element of index i
+	/// \brief Simple constructor with dimension and index 0
+	    BOOST_UBLAS_INLINE
+	    unit_vector ():
+	        vector_container<self_type> (),
+	        size_ (0), index_ (0) {}
+	
+	/// \brief Constructor of unit_vector
+	/// \param size is the dimension of the vector
+	/// \param index is the order of the vector
+	    BOOST_UBLAS_INLINE
+	    explicit unit_vector (size_type size, size_type index = 0):
+	        vector_container<self_type> (),
+	        size_ (size), index_ (index) {}
+	
+	/// \brief Copy-constructor
+	    BOOST_UBLAS_INLINE
+	    unit_vector (const unit_vector &v):
+	        vector_container<self_type> (),
+	        size_ (v.size_), index_ (v.index_) {}
+	
+	    // Accessors
+	//----------
+	
+	/// \brief Return the size (dimension) of the vector
+	    BOOST_UBLAS_INLINE
+	    size_type size () const {
+	        return size_;
+	    }
+	
+	/// \brief Return the order of the unit vector
+	    BOOST_UBLAS_INLINE
+	    size_type index () const {
+	        return index_;
+	    }
+	
+	    // Resizing
+	// --------
+	
+	/// \brief Resize the vector. The values are preserved by default (i.e. the index does not change)
+	/// \param size is the new size of the vector
+	    BOOST_UBLAS_INLINE
+	    void resize (size_type size, bool /*preserve*/ = true) {
+	        size_ = size;
+	    }
+	
+	    // Element support
+	// ---------------
+	
+	/// \brief Return a const pointer to the element of index i
         BOOST_UBLAS_INLINE
         const_pointer find_element (size_type i) const {
             if (i == index_)