[Boost-commit] svn:boost r63669 - branches/release/boost/numeric/ublas

Subject: [Boost-commit] svn:boost r63669 - branches/release/boost/numeric/ublas
From: david.bellot_at_[hidden]
Date: 2010-07-05 14:13:42

Author: david.bellot
Date: 2010-07-05 14:13:41 EDT (Mon, 05 Jul 2010)
New Revision: 63669
URL: http://svn.boost.org/trac/boost/changeset/63669

Log:
whoops, 2 files where missing during the merge !

Added:
   branches/release/boost/numeric/ublas/assignment.hpp   (contents, props changed)
   branches/release/boost/numeric/ublas/doxydoc.hpp   (contents, props changed)

Added: branches/release/boost/numeric/ublas/assignment.hpp
==============================================================================
--- (empty file)
+++ branches/release/boost/numeric/ublas/assignment.hpp	2010-07-05 14:13:41 EDT (Mon, 05 Jul 2010)
@@ -0,0 +1,1281 @@
+//
+//  Copyright (c) 2010 Athanasios Iliopoulos
+//
+//  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)
+//
+
+#ifndef ASSIGNMENT_HPP
+#define ASSIGNMENT_HPP
+#include <boost/numeric/ublas/vector_expression.hpp>
+#include <boost/numeric/ublas/matrix_expression.hpp>
+
+/*! \file assignment.hpp
+    \brief uBlas assignment operator <<=.
+*/
+
+namespace boost { namespace numeric { namespace ublas {
+
+/** \brief A CRTP and Barton-Nackman trick index manipulator wrapper class.
+ *
+ * This class is not meant to be used directly.
+ */
+template <class TV>
+class index_manipulator {
+public:
+    typedef TV type;
+    BOOST_UBLAS_INLINE
+    const type &operator () () const {
+        return *static_cast<const type *> (this);
+    }
+    BOOST_UBLAS_INLINE
+    type &operator () () {
+        return *static_cast<type *> (this);
+    }
+};
+
+/** \brief A move_to vector index manipulator.
+ *
+ * When member function \c manip is called the referenced
+ * index will be set to the manipulators' index.
+ *
+ * \sa move_to(T i)
+ */
+template <typename T>
+class vector_move_to_manip: public index_manipulator<vector_move_to_manip<T> > {
+public:
+    BOOST_UBLAS_INLINE
+    vector_move_to_manip(const T &k): i(k) { }
+
+    template <typename V>
+    BOOST_UBLAS_INLINE
+    void manip(V &k) const { k=i; }
+private:
+    T i;
+};
+
+/** \brief An object generator that returns a move_to vector index manipulator
+ *
+ * \param i The element number the manipulator will move to when \c manip member function is called
+ * \return A move_to vector manipulator
+ *
+ * Example usage:
+ * \code
+ * vector<double> a(6, 0);
+ * a <<= 1, 2, move_to(5), 3;
+ * \endcode
+ * will result in:
+ * \code
+ * 1 2 0 0 0 3
+ * \endcode
+ *
+ * \tparam T Size type
+ * \sa move_to()
+ */
+template <typename T>
+BOOST_UBLAS_INLINE vector_move_to_manip<T>  move_to(T i) {
+    return vector_move_to_manip<T>(i);
+}
+
+/** \brief A static move to vector manipulator.
+ *
+ * When member function \c manip is called the referenced
+ * index will be set to the manipulators' index
+ *
+ * \sa move_to(T i) and move_to()
+*/
+template <std::size_t I>
+class static_vector_move_to_manip: public index_manipulator<static_vector_move_to_manip<I> > {
+public:
+    template <typename V>
+    BOOST_UBLAS_INLINE
+    void manip(V &k) const { k=I; }
+};
+
+/** \brief An object generator that returns a static move_to vector index  manipulator.
+ *
+ * Typically faster than the dynamic version, but can be used only when the
+ * values are known at compile time.
+ *
+ * \return A static move_to vector manipulator
+ *
+ * Example usage:
+ * \code
+ * vector<double> a(6, 0);
+ * a <<= 1, 2, move_to<5>(), 3;
+ * \endcode
+ * will result in:
+ * \code
+ * 1 2 0 0 0 3
+ * \endcode
+ *
+ * \tparam I The number of elements the manipulator will traverse the index when \c manip function is called
+ */
+template <std::size_t I>
+BOOST_UBLAS_INLINE static_vector_move_to_manip<I>  move_to() {
+    return static_vector_move_to_manip<I>();
+}
+
+/** \brief A move vector index manipulator.
+ *
+ * When member function traverse is called the manipulators'
+ * index will be added to the referenced index.
+ *
+ * \see move(T i)
+ */
+template <typename T>
+class vector_move_manip: public index_manipulator<vector_move_manip<T> > {
+public:
+    BOOST_UBLAS_INLINE
+    vector_move_manip(const T &k): i(k) { }
+
+    template <typename V>
+    BOOST_UBLAS_INLINE void manip(V &k) const { k+=i; }
+private:
+    T i;
+};
+
+/**
+* \brief  An object generator that returns a move vector index manipulator
+*
+* \tparam T Size type
+* \param i The number of elements the manipulator will traverse the index when \c manip
+* member function is called. Negative values can be used.
+* \return A move vector manipulator
+*
+* Example usage:
+* \code
+* vector<double> a(6, 0);
+* a <<= 1, 2, move(3), 3;
+* \endcode
+* will result in:
+* \code
+* 1 2 0 0 0 3
+* \endcode
+*
+*/
+template <typename T>
+BOOST_UBLAS_INLINE vector_move_manip<T>  move(T i) {
+    return vector_move_manip<T>(i);
+}
+
+/**
+* \brief A static move vector manipulator
+*
+* When member function \c manip is called the manipulators
+* index will be added to the referenced index
+*
+* \sa move()
+*
+* \todo Doxygen has some problems with similar template functions. Correct that.
+*/
+template <std::size_t I>
+class static_vector_move_manip: public index_manipulator<static_vector_move_manip<I> > {
+public:
+    template <typename V>
+    BOOST_UBLAS_INLINE void manip(V &k) const { k+=I; }
+};
+
+/**
+* \brief An object generator that returns a static move vector index manipulator.
+*
+* Typically faster than the dynamic version, but can be used only when the
+* values are known at compile time.
+* \tparam I The Number of elements the manipulator will traverse the index when \c manip
+* function is called.Negative values can be used.
+* \return A static move vector manipulator
+*
+* Example usage:
+* \code
+* vector<double> a(6, 0);
+* a <<= 1, 2, move<3>(), 3;
+* \endcode
+* will result in:
+* \code
+* 1 2 0 0 0 3
+* \endcode
+*
+* \todo Doxygen has some problems with similar template functions. Correct that.
+*/
+template <std::size_t I>
+BOOST_UBLAS_INLINE static_vector_move_manip<I>  move() {
+    return static_vector_move_manip<I>();
+}
+
+/**
+* \brief A move_to matrix manipulator
+*
+* When member function \c manip is called the referenced
+* index will be set to the manipulators' index
+*
+* \sa move_to(T i, T j)
+*
+* \todo Doxygen has some problems with similar template functions. Correct that.
+*/
+template <typename T>
+class matrix_move_to_manip: public index_manipulator<matrix_move_to_manip<T> > {
+public:
+    BOOST_UBLAS_INLINE
+    matrix_move_to_manip(T k, T l): i(k), j(l) { }
+
+    template <typename V1, typename V2>
+    BOOST_UBLAS_INLINE
+    void manip(V1 &k, V2 &l) const {
+        k=i;
+        l=j;
+    }
+private:
+    T i, j;
+};
+
+/**
+* \brief  An object generator that returns a "move_to" matrix index manipulator
+*
+* \tparam size type
+* \param i The row number the manipulator will move to when \c manip
+* member function is called
+* \param j The column number the manipulator will move to when \c manip
+* member function is called
+* \return A move matrix manipulator
+*
+* Example usage:
+* \code:
+* matrix<double> A(3, 3, 0);
+* A <<= 1, 2, move_to(A.size1()-1, A.size1()-1), 3;
+* \endcode
+* will result in:
+* \code
+* 1 2 0
+* 0 0 0
+* 0 0 3
+* \endcode
+* \sa move_to(T i, T j) and static_matrix_move_to_manip
+*
+* \todo Doxygen has some problems with similar template functions. Correct that.
+*/
+template <typename T>
+BOOST_UBLAS_INLINE matrix_move_to_manip<T>  move_to(T i, T j) {
+    return matrix_move_to_manip<T>(i, j);
+}
+
+
+/**
+* \brief A static move_to matrix manipulator
+* When member function traverse is called the referenced
+* index will be set to the manipulators' index
+*
+* \sa move_to()
+*
+* \todo Doxygen has some problems with similar template functions. Correct that.
+*/
+template <std::size_t I, std::size_t J>
+class static_matrix_move_to_manip: public index_manipulator<static_matrix_move_to_manip<I, J> > {
+public:
+    template <typename V, typename K>
+    BOOST_UBLAS_INLINE
+    void manip(V &k, K &l) const {
+        k=I;
+        l=J;
+    }
+};
+
+/**
+* \brief  An object generator that returns a static move_to matrix index manipulator.
+*
+* Typically faster than the dynamic version, but can be used only when the
+* values are known at compile time.
+* \tparam I The row number the manipulator will set the matrix assigner index to.
+* \tparam J The column number the manipulator will set the matrix assigner index to.
+* \return A static move_to matrix manipulator
+*
+* Example usage:
+* \code:
+* matrix<double> A(3, 3, 0);
+* A <<= 1, 2, move_to<2,2>, 3;
+* \endcode
+* will result in:
+* \code
+* 1 2 0
+* 0 0 0
+* 0 0 3
+* \endcode
+* \sa move_to(T i, T j) and static_matrix_move_to_manip
+*/
+template <std::size_t I, std::size_t J>
+BOOST_UBLAS_INLINE static_matrix_move_to_manip<I, J>  move_to() {
+    return static_matrix_move_to_manip<I, J>();
+}
+
+/**
+* \brief A move matrix index manipulator.
+*
+* When member function \c manip is called the manipulator's
+* index will be added to the referenced' index.
+*
+* \sa move(T i, T j)
+*/
+template <typename T>
+class matrix_move_manip: public index_manipulator<matrix_move_manip<T> > {
+public:
+    BOOST_UBLAS_INLINE
+    matrix_move_manip(T k, T l): i(k), j(l) { }
+
+    template <typename V, typename K>
+    BOOST_UBLAS_INLINE
+    void manip(V &k, K &l) const {
+        k+=i;
+        l+=j;
+    }
+private:
+    T i, j;
+};
+
+/**
+* \brief  An object generator that returns a move matrix index manipulator
+*
+* \tparam size type
+* \param i The number of rows the manipulator will traverse the index when "manip"
+* member function is called
+* \param j The number of columns the manipulator will traverse the index when "manip"
+* member function is called
+* \return A move matrix manipulator
+*
+* Example:
+* \code:
+* matrix<double> A(3, 3, 0);
+* A <<= 1, 2, move(1,0),
+*            3,;
+* \endcode
+* will result in:
+* \code
+* 1 2 0
+* 0 0 3
+* 0 0 0
+* \endcode
+*/
+template <typename T>
+BOOST_UBLAS_INLINE matrix_move_manip<T>  move(T i, T j) {
+    return matrix_move_manip<T>(i, j);
+}
+
+/**
+* \brief A static move matrix index manipulator.
+*
+* When member function traverse is called the manipulator's
+* index will be added to the referenced' index.
+*
+* \sa move()
+*
+* \todo Doxygen has some problems with similar template functions. Correct that.
+*/
+template <std::size_t I, std::size_t J>
+class static_matrix_move_manip: public index_manipulator<static_matrix_move_manip<I, J> > {
+public:
+    template <typename V, typename K>
+    BOOST_UBLAS_INLINE
+    void manip(V &k, K &l) const {
+        k+=I;
+        l+=J;
+    }
+};
+
+/**
+* \brief  An object generator that returns a static "move" matrix index manipulator.
+*
+* Typically faster than the dynamic version, but can be used only when the
+* values are known at compile time. Negative values can be used.
+* \tparam I The number of rows the manipulator will trasverse the matrix assigner index.
+* \tparam J The number of columns the manipulator will trasverse the matrix assigner index.
+* \tparam size type
+* \return A static move matrix manipulator
+*
+* Example:
+* \code:
+* matrix<double> A(3, 3, 0);
+* A <<= 1, 2, move<1,0>(),
+*            3,;
+* \endcode
+* will result in:
+* \code
+* 1 2 0
+* 0 0 3
+* 0 0 0
+* \endcode
+*
+* \sa move_to()
+*
+* \todo Doxygen has some problems with similar template functions. Correct that.
+*/
+template <std::size_t I, std::size_t J>
+BOOST_UBLAS_INLINE static_matrix_move_manip<I, J>  move() {
+    return static_matrix_move_manip<I, J>();
+}
+
+/**
+* \brief A begining of row manipulator
+*
+* When member function \c manip is called the referenced
+* index will be be set to the begining of the row (i.e. column = 0)
+*
+* \sa begin1()
+*/
+class begin1_manip: public index_manipulator<begin1_manip > {
+public:
+    template <typename V, typename K>
+    BOOST_UBLAS_INLINE
+    void manip(V & k, K &/*l*/) const {
+        k=0;
+    }
+};
+
+/**
+* \brief  An object generator that returns a begin1 manipulator.
+*
+* The resulted manipulator will traverse the index to the begining
+* of the current column when its' \c manip member function is called.
+*
+* \return A begin1 matrix index manipulator
+*
+* Example usage:
+* \code:
+* matrix<double> A(3, 3, 0);
+* A <<= 1, 2, next_row(),
+*      3, 4, begin1(), 1;
+* \endcode
+* will result in:
+* \code
+* 1 2 1
+* 3 4 0
+* 0 0 0
+* \endcode
+* \sa begin2()
+*/
+BOOST_UBLAS_INLINE begin1_manip  begin1() {
+    return begin1_manip();
+}
+
+/**
+* \brief A begining of column manipulator
+*
+* When member function \c manip is called the referenced
+* index will be be set to the begining of the column (i.e. row = 0).
+*
+*
+* \sa begin2()
+*/
+class begin2_manip: public index_manipulator<begin2_manip > {
+public:
+    template <typename V, typename K>
+    BOOST_UBLAS_INLINE
+    void manip(V &/*k*/, K &l) const {
+        l=0;
+    }
+};
+
+/**
+* \brief  An object generator that returns a begin2 manipulator to be used to traverse a matrix.
+*
+* The resulted manipulator will traverse the index to the begining
+* of the current row when its' \c manip member function is called.
+*
+* \return A begin2 matrix manipulator
+*
+* Example:
+* \code:
+* matrix<double> A(3, 3, 0);
+* A <<= 1, 2, move<1,0>(),
+*      3, begin2(), 1;
+* \endcode
+* will result in:
+* \code
+* 1 2 0
+* 1 0 3
+* 0 0 0
+* \endcode
+* \sa begin1() begin2_manip
+*/
+BOOST_UBLAS_INLINE begin2_manip  begin2() {
+    return begin2_manip();
+}
+
+
+/**
+* \brief A next row matrix manipulator.
+*
+* When member function traverse is called the referenced
+* index will be traveresed to the begining of next row.
+*
+* \sa next_row()
+*/
+class next_row_manip: public index_manipulator<next_row_manip> {
+public:
+    template <typename V, typename K>
+    BOOST_UBLAS_INLINE
+    void manip(V &k, K &l) const {
+        k++;
+        l=0;
+    }
+};
+
+/**
+* \brief  An object generator that returns a next_row manipulator.
+*
+* The resulted manipulator will traverse the index to the begining
+* of the next row when it's manip member function is called.
+*
+* \return A next_row matrix manipulator.
+*
+* Example:
+* \code:
+* matrix<double> A(3, 3, 0);
+* A <<= 1, 2, next_row(),
+*      3, 4;
+* \endcode
+* will result in:
+* \code
+* 1 2 0
+* 3 4 0
+* 0 0 0
+* \endcode
+* \sa next_column()
+*/
+BOOST_UBLAS_INLINE next_row_manip  next_row() {
+    return next_row_manip();
+}
+
+/**
+* \brief A next column matrix manipulator.
+*
+* When member function traverse is called the referenced
+* index will be traveresed to the begining of next column.
+*
+* \sa next_column()
+*/
+class next_column_manip: public index_manipulator<next_column_manip> {
+public:
+    template <typename V, typename K>
+    BOOST_UBLAS_INLINE
+    void manip(V &k, K &l) const {
+        k=0;
+        l++;
+    }
+};
+
+/**
+* \brief  An object generator that returns a next_row manipulator.
+*
+* The resulted manipulator will traverse the index to the begining
+* of the next column when it's manip member function is called.
+*
+* \return A next_column matrix manipulator.
+*
+* Example:
+* \code:
+* matrix<double> A(3, 3, 0);
+* A <<= 1, 2, 0,
+*      3, next_column(), 4;
+* \endcode
+* will result in:
+* \code
+* 1 2 4
+* 3 0 0
+* 0 0 0
+* \endcode
+*
+*/
+BOOST_UBLAS_INLINE next_column_manip next_column() {
+    return next_column_manip();
+}
+
+/**
+* \brief  A wrapper for fill policy classes
+*
+*/
+template <class T>
+class fill_policy_wrapper {
+public:
+    typedef T type;
+};
+
+// Collection of the fill policies
+namespace fill_policy {
+
+    /**
+    * \brief  An index assign policy
+    *
+    * This policy is used to for the simplified ublas assign through
+    * normal indexing.
+    *
+    *
+    */
+    class index_assign :public fill_policy_wrapper<index_assign> {
+    public:
+        template <class T, typename S, typename V>
+        BOOST_UBLAS_INLINE
+        static void apply(T &e, const S &i, const V &v) {
+            e()(i) = v;
+        }
+        template <class T, typename S, typename V>
+        BOOST_UBLAS_INLINE
+        static void apply(T &e, const S &i, const S &j, const V &v) {
+            e()(i, j) = v;
+        }
+    };
+
+    /**
+    * \brief  An index plus assign policy
+    *
+    * This policy is used when the assignment is desired to be followed
+    * by an addition.
+    *
+    *
+    */
+    class index_plus_assign :public fill_policy_wrapper<index_plus_assign> {
+    public:
+        template <class T, typename S, typename V>
+        BOOST_UBLAS_INLINE
+        static void apply(T &e, const S &i, const V &v) {
+            e()(i) += v;
+        }
+        template <class T, typename S, typename V>
+        BOOST_UBLAS_INLINE
+        static void apply(T &e, const S &i, const S &j, const V &v) {
+            e()(i, j) += v;
+        }
+    };
+
+    /**
+    * \brief  An index minus assign policy
+    *
+    * This policy is used when the assignment is desired to be followed
+    * by a substraction.
+    *
+    *
+    */
+    class index_minus_assign :public fill_policy_wrapper<index_minus_assign> {
+    public:
+        template <class T, typename S, typename V>
+        BOOST_UBLAS_INLINE
+        static void apply(T &e, const S &i, const V &v) {
+            e()(i) -= v;
+        }
+        template <class T, typename S, typename V>
+        BOOST_UBLAS_INLINE
+        static void apply(T &e, const S &i, const S &j, const V &v) {
+            e()(i, j) -= v;
+        }
+    };
+
+    /**
+    * \brief  The sparse push_back fill policy.
+    *
+    * This policy is adequate for sparse types, when fast filling is required, where indexing
+    * assign is pretty slow.
+
+    * It is important to note that push_back assign cannot be used to add elements before elements
+    * already existing in a sparse container. To achieve that please use the sparse_insert fill policy.
+    */
+    class sparse_push_back :public fill_policy_wrapper<sparse_push_back > {
+    public:
+        template <class T, class S, class V>
+        BOOST_UBLAS_INLINE
+        static void apply(T &e, const S &i, const V &v) {
+            e().push_back(i, v);
+        }
+        template <class T, class S, class V>
+        BOOST_UBLAS_INLINE
+        static void apply(T &e, const S &i, const S &j, const V &v) {
+            e().push_back(i,j, v);
+        }
+    };
+
+    /**
+    * \brief  The sparse insert fill policy.
+    *
+    * This policy is adequate for sparse types, when fast filling is required, where indexing
+    * assign is pretty slow. It is slower than sparse_push_back fill policy, but it can be used to
+    * insert elements anywhere inside the container.
+    */
+    class sparse_insert :public fill_policy_wrapper<sparse_insert> {
+    public:
+        template <class T, class S, class V>
+        BOOST_UBLAS_INLINE
+        static void apply(T &e, const S &i, const V &v) {
+            e().insert_element(i, v);
+        }
+        template <class T, class S, class V>
+        BOOST_UBLAS_INLINE
+        static void apply(T &e, const S &i, const S &j, const V &v) {
+            e().insert_element(i,j, v);
+        }
+    };
+
+}
+
+/** \brief A wrapper for traverse policy classes
+*
+*/
+template <class T>
+class traverse_policy_wrapper {
+public:
+    typedef T type;
+};
+
+// Collection of the traverse policies
+namespace traverse_policy {
+
+
+    /**
+    * \brief  The no wrap policy.
+    *
+    * The no wrap policy does not allow wrapping when assigning to a matrix
+    */
+    struct no_wrap {
+        /**
+        * \brief  Element wrap method
+        */
+        template <class S1, class S2, class S3>
+        BOOST_UBLAS_INLINE
+        static void apply1(const S1 &/*s*/, S2 &/*i*/, S3 &/*j*/) {
+        }
+
+        /**
+        * \brief  Matrix block wrap method
+        */
+        template <class S1, class S2, class S3>
+        BOOST_UBLAS_INLINE
+        static void apply2(const S1 &/*s1*/, const S1 &/*s2*/, S2 &/*i1*/, S3 &/*i2*/) {
+        }
+    };
+
+    /**
+    * \brief  The wrap policy.
+    *
+    * The wrap policy enables element wrapping when assigning to a matrix
+    */
+    struct wrap {
+        /**
+        * \brief  Element wrap method
+        */
+        template <class S1, class S2, class S3>
+        BOOST_UBLAS_INLINE
+        static void apply1(const S1 &s, S2 &i1, S3 &i2) {
+            if (i2>=s) {
+                i1++;
+                i2=0;
+            }
+        }
+
+        /**
+        * \brief  Matrix block wrap method
+        */
+        template <class S1, class S2, class S3>
+        BOOST_UBLAS_INLINE
+        static void apply2(const S1 &s1, const S1 &s2, S2 &i1, S3 &i2) {
+            if (i2>=s2) i2=0;   // Wrap to the next block
+            else i1-=s1;        // Move up (or right) one block
+        }
+    };
+
+    /**
+    * \brief  The row_by_row traverse policy
+    *
+    * This policy is used when the assignment is desired to happen
+    * row_major wise for performance or other reasons.
+    *
+    * This is the default behaviour. To change it globally please define BOOST_UBLAS_DEFAULT_ASSIGN_BY_COLUMN
+    * in the compilation options or in an adequate header file.
+    *
+    * Please see EXAMPLES_LINK for usage information.
+    *
+    * \todo Add examples link
+    */
+    template <class Wrap = wrap>
+    class by_row_policy :public traverse_policy_wrapper<by_row_policy<Wrap> > {
+    public:
+        template <typename S1, typename S2>
+        BOOST_UBLAS_INLINE
+        static void advance(S1 &/*i*/, S2 &j) { j++;}
+
+        template <class E1, class E2, typename S1, typename S2, typename S3, typename S4, typename S5>
+        BOOST_UBLAS_INLINE
+        static bool next(const E1 &e, const E2 &me, S1 &i, S2 &j, const S3 &/*i0*/, const S3 &j0, S4 &k, S5 &l) {
+            l++; j++;
+            if (l>=e().size2()) {
+                l=0; k++; j=j0; i++;
+                // It is assumed that the iteration starts from 0 and happens only using this function from within
+                // an assigner object.
+                // Otherwise (i.e. if it is called outside the assigner object) apply2 should have been
+                // outside the if statement.
+                if (k>=e().size1()) {
+                    j=j0+e().size2();
+                    Wrap::apply2(e().size1(), me().size2(), i, j);
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        template <class E, typename S1, typename S2>
+        BOOST_UBLAS_INLINE
+        static void apply_wrap(const E& e, S1 &i, S2 &j) {
+            Wrap::apply1(e().size2(), i, j);
+        }
+    };
+
+    /**
+    * \brief  The column_by_column traverse policy
+    *
+    * This policy is used when the assignment is desired to happen
+    * column_major wise, for performance or other reasons.
+    *
+    * This is the NOT the default behaviour. To set this as the default define BOOST_UBLAS_DEFAULT_ASSIGN_BY_COLUMN
+    * in the compilation options or in an adequate header file.
+    *
+    * Please see EXAMPLES_LINK for usage information.
+    *
+    * \todo Add examples link
+    */
+    template <class Wrap = wrap>
+    class by_column_policy :public traverse_policy_wrapper<by_column_policy<Wrap> > {
+    public:
+        template <typename S1, typename S2>
+        BOOST_UBLAS_INLINE
+        static void advance(S1 &i, S2 &/*j*/) { i++;}
+
+        template <class E1, class E2, typename S1, typename S2, typename S3, typename S4, typename S5>
+        BOOST_UBLAS_INLINE
+        static bool next(const E1 &e, const E2 &me, S1 &i, S2 &j, const S3 &i0, const S3 &/*j0*/, S4 &k, S5 &l) {
+            k++; i++;
+            if (k>=e().size1()) {
+                k=0; l++; i=i0; j++;
+                // It is assumed that the iteration starts from 0 and happens only using this function from within
+                // an assigner object.
+                // Otherwise (i.e. if it is called outside the assigner object) apply2 should have been
+                // outside the if statement.
+                if (l>=e().size2()) {
+                    i=i0+e().size1();
+                    Wrap::apply2(e().size2(), me().size1(), j, i);
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        template <class E, typename S1, typename S2>
+        BOOST_UBLAS_INLINE
+        static void apply_wrap(const E& e, S1 &i, S2 &j) {
+            Wrap::apply1(e().size1(), j, i);
+        }
+    };
+}
+#ifndef BOOST_UBLAS_DEFAULT_NO_WRAP_POLICY
+    typedef traverse_policy::wrap DEFAULT_WRAP_POLICY;
+#else
+    typedef traverse_policy::no_wrap DEFAULT_WRAP_POLICY;
+#endif
+
+#ifndef BOOST_UBLAS_DEFAULT_ASSIGN_BY_COLUMN
+    typedef traverse_policy::by_row_policy<DEFAULT_WRAP_POLICY> DEFAULT_TRAVERSE_POLICY;
+#else
+    typedef traverse_policy::by_column<DEFAULT_WRAP_POLICY> DEFAULT_TRAVERSE_POLICY;
+#endif
+
+ // Traverse policy namespace
+namespace traverse_policy {
+
+    by_row_policy<DEFAULT_WRAP_POLICY> by_row() {
+    return by_row_policy<DEFAULT_WRAP_POLICY>();
+    }
+
+    by_row_policy<wrap> by_row_wrap() {
+        return by_row_policy<wrap>();
+    }
+
+    by_row_policy<no_wrap> by_row_no_wrap() {
+        return by_row_policy<no_wrap>();
+    }
+
+    by_column_policy<DEFAULT_WRAP_POLICY> by_column() {
+        return by_column_policy<DEFAULT_WRAP_POLICY>();
+    }
+
+    by_column_policy<wrap> by_column_wrap() {
+        return by_column_policy<wrap>();
+    }
+
+    by_column_policy<no_wrap> by_column_no_wrap() {
+        return by_column_policy<no_wrap>();
+    }
+
+}
+
+/**
+* \brief  An assigner object used to fill a vector using operator <<= and operator, (comma)
+*
+* This object is meant to be created by appropriate object generators.
+* Please see EXAMPLES_LINK for usage information.
+*
+* \todo Add examples link
+*/
+template <class E, class Fill_Policy = fill_policy::index_assign>
+class vector_expression_assigner {
+public:
+    typedef typename E::expression_type::value_type value_type;
+    typedef typename E::expression_type::size_type size_type;
+
+    BOOST_UBLAS_INLINE
+    vector_expression_assigner(E &e):ve(e), i(0) {
+    }
+
+    BOOST_UBLAS_INLINE
+    vector_expression_assigner(size_type k, E &e):ve(e), i(k) {
+        // Overloaded like that so it can be differentiated from (E, val).
+        // Otherwise there would be an ambiquity when value_type == size_type.
+    }
+
+    BOOST_UBLAS_INLINE
+    vector_expression_assigner(E &e, value_type val):ve(e), i(0) {
+        operator,(val);
+    }
+
+    template <class AE>
+    BOOST_UBLAS_INLINE
+    vector_expression_assigner(E &e, const vector_expression<AE> &nve):ve(e), i(0) {
+        operator,(nve);
+    }
+
+    template <typename T>
+    BOOST_UBLAS_INLINE
+    vector_expression_assigner(E &e, const index_manipulator<T> &ta):ve(e), i(0) {
+        operator,(ta);
+    }
+
+    BOOST_UBLAS_INLINE
+    vector_expression_assigner &operator, (const value_type& val) {
+        apply(val);
+        return *this;
+    }
+
+    template <class AE>
+    BOOST_UBLAS_INLINE
+    vector_expression_assigner &operator, (const vector_expression<AE> &nve) {
+        for (typename AE::size_type k = 0; k!= nve().size(); k++)
+            operator,(nve()(k));
+        return *this;
+    }
+
+    template <typename T>
+    BOOST_UBLAS_INLINE
+    vector_expression_assigner &operator, (const index_manipulator<T> &ta) {
+        ta().manip(i);
+        return *this;
+    }
+
+    template <class T>
+    BOOST_UBLAS_INLINE
+    vector_expression_assigner<E, T> operator, (fill_policy_wrapper<T>) const {
+        return vector_expression_assigner<E, T>(i, ve);
+    }
+
+private:
+    BOOST_UBLAS_INLINE
+    vector_expression_assigner &apply(const typename E::expression_type::value_type& val) {
+        Fill_Policy::apply(ve, i++, val);
+        return *this;
+    }
+
+private:
+    E &ve;
+    size_type i;
+};
+
+/*
+// The following static assigner is about 30% slower than the dynamic one, probably due to the recursive creation of assigner objects.
+// It remains commented here for future reference.
+
+template <class E, std::size_t I=0>
+class static_vector_expression_assigner {
+public:
+    typedef typename E::expression_type::value_type value_type;
+    typedef typename E::expression_type::size_type size_type;
+
+    BOOST_UBLAS_INLINE
+    static_vector_expression_assigner(E &e):ve(e) {
+    }
+
+    BOOST_UBLAS_INLINE
+    static_vector_expression_assigner(E &e, value_type val):ve(e) {
+        operator,(val);
+    }
+
+    BOOST_UBLAS_INLINE
+    static_vector_expression_assigner<E, I+1> operator, (const value_type& val) {
+        return apply(val);
+    }
+
+private:
+    BOOST_UBLAS_INLINE
+    static_vector_expression_assigner<E, I+1> apply(const typename E::expression_type::value_type& val) {
+        ve()(I)=val;
+        return static_vector_expression_assigner<E, I+1>(ve);
+    }
+
+private:
+    E &ve;
+};
+
+template <class E>
+BOOST_UBLAS_INLINE
+static_vector_expression_assigner<vector_expression<E>, 1 > test_static(vector_expression<E> &v, const typename E::value_type &val) {
+    v()(0)=val;
+    return static_vector_expression_assigner<vector_expression<E>, 1 >(v);
+}
+*/
+
+
+/**
+* \brief  A vector_expression_assigner generator used with operator<<= for simple types
+*
+* Please see EXAMPLES_LINK for usage information.
+*
+* \todo Add examples link
+*/
+template <class E>
+BOOST_UBLAS_INLINE
+vector_expression_assigner<vector_expression<E> > operator<<=(vector_expression<E> &v, const typename E::value_type &val) {
+    return vector_expression_assigner<vector_expression<E> >(v,val);
+}
+
+/**
+* \brief  ! A vector_expression_assigner generator used with operator<<= for vector expressions
+*
+* Please see EXAMPLES_LINK for usage information.
+*
+* \todo Add examples link
+*/
+template <class E1, class E2>
+BOOST_UBLAS_INLINE
+vector_expression_assigner<vector_expression<E1> > operator<<=(vector_expression<E1> &v, const vector_expression<E2> &ve) {
+    return vector_expression_assigner<vector_expression<E1> >(v,ve);
+}
+
+/**
+* \brief  A vector_expression_assigner generator used with operator<<= for traverse manipulators
+*
+* Please see EXAMPLES_LINK for usage information.
+*
+* \todo Add examples link
+*/
+template <class E, typename T>
+BOOST_UBLAS_INLINE
+vector_expression_assigner<vector_expression<E> > operator<<=(vector_expression<E> &v, const index_manipulator<T> &nv) {
+    return vector_expression_assigner<vector_expression<E> >(v,nv);
+}
+
+/**
+* \brief  A vector_expression_assigner generator used with operator<<= for choice of fill policy
+*
+* Please see EXAMPLES_LINK for usage information.
+*
+* \todo Add examples link
+*/
+template <class E, typename T>
+BOOST_UBLAS_INLINE
+vector_expression_assigner<vector_expression<E>, T> operator<<=(vector_expression<E> &v, fill_policy_wrapper<T>) {
+    return vector_expression_assigner<vector_expression<E>, T>(v);
+}
+
+/**
+* \brief  An assigner object used to fill a vector using operator <<= and operator, (comma)
+*
+* This object is meant to be created by appropriate object generators.
+* Please see EXAMPLES_LINK for usage information.
+*
+* \todo Add examples link
+*/
+template <class E, class Fill_Policy = fill_policy::index_assign, class Traverse_Policy = DEFAULT_TRAVERSE_POLICY >
+class matrix_expression_assigner {
+public:
+    typedef typename E::expression_type::size_type size_type;
+
+    BOOST_UBLAS_INLINE
+    matrix_expression_assigner(E &e): me(e), i(0), j(0) {
+    }
+
+    BOOST_UBLAS_INLINE
+    matrix_expression_assigner(E &e, size_type k, size_type l): me(e), i(k), j(l) {
+    }
+
+    BOOST_UBLAS_INLINE
+    matrix_expression_assigner(E &e, typename E::expression_type::value_type val): me(e), i(0), j(0) {
+        operator,(val);
+    }
+
+    template <class AE>
+    BOOST_UBLAS_INLINE
+    matrix_expression_assigner(E &e, const vector_expression<AE> &nve):me(e), i(0), j(0) {
+        operator,(nve);
+    }
+
+    template <class AE>
+    BOOST_UBLAS_INLINE
+    matrix_expression_assigner(E &e, const matrix_expression<AE> &nme):me(e), i(0), j(0) {
+        operator,(nme);
+    }
+
+    template <typename T>
+    BOOST_UBLAS_INLINE
+    matrix_expression_assigner(E &e, const index_manipulator<T> &ta):me(e), i(0), j(0) {
+        operator,(ta);
+    }
+
+    BOOST_UBLAS_INLINE
+    matrix_expression_assigner &operator, (const typename E::expression_type::value_type& val) {
+        Traverse_Policy::apply_wrap(me, i ,j);
+        return apply(val);
+    }
+
+    template <class AE>
+    BOOST_UBLAS_INLINE
+    matrix_expression_assigner &operator, (const vector_expression<AE> &nve) {
+        for (typename AE::size_type k = 0; k!= nve().size(); k++) {
+            operator,(nve()(k));
+        }
+        return *this;
+    }
+
+    template <class AE>
+    BOOST_UBLAS_INLINE
+    matrix_expression_assigner &operator, (const matrix_expression<AE> &nme) {
+        return apply(nme);
+    }
+
+    template <typename T>
+    BOOST_UBLAS_INLINE
+    matrix_expression_assigner &operator, (const index_manipulator<T> &ta) {
+        ta().manip(i, j);
+        return *this;
+    } 
+
+    template <class T>
+    BOOST_UBLAS_INLINE
+    matrix_expression_assigner<E, T, Traverse_Policy> operator, (fill_policy_wrapper<T>) const {
+        return matrix_expression_assigner<E, T, Traverse_Policy>(me, i, j);
+    }
+
+
+    template <class T>
+    BOOST_UBLAS_INLINE
+    matrix_expression_assigner<E, Fill_Policy, T> operator, (traverse_policy_wrapper<T>) {
+        Traverse_Policy::apply_wrap(me, i ,j);
+        return matrix_expression_assigner<E, Fill_Policy, T>(me, i, j);
+    }
+
+private:
+    BOOST_UBLAS_INLINE
+    matrix_expression_assigner &apply(const typename E::expression_type::value_type& val) {
+        Fill_Policy::apply(me, i, j, val);
+        Traverse_Policy::advance(i,j);
+        return *this;
+    }
+
+    template <class AE>
+    BOOST_UBLAS_INLINE
+    matrix_expression_assigner &apply(const matrix_expression<AE> &nme) {
+        size_type bi = i;
+        size_type bj = j;
+        typename AE::size_type k=0, l=0;
+        Fill_Policy::apply(me, i, j, nme()(k, l));
+        while (Traverse_Policy::next(nme, me, i, j, bi, bj, k, l))
+            Fill_Policy::apply(me, i, j, nme()(k, l));
+        return *this;
+    }
+
+private:
+    E &me;
+    size_type i, j;
+};
+
+/**
+* \brief  A matrix_expression_assigner generator used with operator<<= for simple types
+*
+* Please see EXAMPLES_LINK for usage information.
+*
+* \todo Add examples link
+*/
+template <class E>
+BOOST_UBLAS_INLINE
+matrix_expression_assigner<matrix_expression<E> > operator<<=(matrix_expression<E> &me, const typename E::value_type &val) {
+    return matrix_expression_assigner<matrix_expression<E> >(me,val);
+}
+
+/**
+* \brief  A matrix_expression_assigner generator used with operator<<= for choice of fill policy
+*
+* Please see EXAMPLES_LINK for usage information.
+*
+* \todo Add examples link
+*/
+template <class E, typename T>
+BOOST_UBLAS_INLINE
+matrix_expression_assigner<matrix_expression<E>, T> operator<<=(matrix_expression<E> &me, fill_policy_wrapper<T>) {
+    return matrix_expression_assigner<matrix_expression<E>, T>(me);
+}
+
+/**
+* \brief  A matrix_expression_assigner generator used with operator<<= for traverse manipulators
+*
+* Please see EXAMPLES_LINK for usage information.
+*
+* \todo Add examples link
+*/
+template <class E, typename T>
+BOOST_UBLAS_INLINE
+matrix_expression_assigner<matrix_expression<E> > operator<<=(matrix_expression<E> &me, const index_manipulator<T> &ta) {
+    return matrix_expression_assigner<matrix_expression<E> >(me,ta);
+}
+
+/**
+* \brief  A matrix_expression_assigner generator used with operator<<= for traverse manipulators
+*
+* Please see EXAMPLES_LINK for usage information.
+*
+* \todo Add examples link
+*/
+template <class E, typename T>
+BOOST_UBLAS_INLINE
+matrix_expression_assigner<matrix_expression<E>, fill_policy::index_assign, T> operator<<=(matrix_expression<E> &me, traverse_policy_wrapper<T>) {
+    return matrix_expression_assigner<matrix_expression<E>, fill_policy::index_assign, T>(me);
+}
+
+/**
+* \brief  A matrix_expression_assigner generator used with operator<<= for vector expressions
+*
+* Please see EXAMPLES_LINK for usage information.
+*
+* \todo Add examples link
+*/
+template <class E1, class E2>
+BOOST_UBLAS_INLINE
+matrix_expression_assigner<matrix_expression<E1> > operator<<=(matrix_expression<E1> &me, const vector_expression<E2> &ve) {
+    return matrix_expression_assigner<matrix_expression<E1> >(me,ve);
+}
+
+/**
+* \brief  A matrix_expression_assigner generator used with operator<<= for matrix expressions
+*
+* Please see EXAMPLES_LINK for usage information.
+*
+* \todo Add examples link
+*/
+template <class E1, class E2>
+BOOST_UBLAS_INLINE
+matrix_expression_assigner<matrix_expression<E1> > operator<<=(matrix_expression<E1> &me1, const matrix_expression<E2> &me2) {
+    return matrix_expression_assigner<matrix_expression<E1> >(me1,me2);
+}
+
+} } }
+
+#endif // ASSIGNMENT_HPP

Added: branches/release/boost/numeric/ublas/doxydoc.hpp
==============================================================================
--- (empty file)
+++ branches/release/boost/numeric/ublas/doxydoc.hpp	2010-07-05 14:13:41 EDT (Mon, 05 Jul 2010)
@@ -0,0 +1,65 @@
+//
+//  Copyright (c) 2010
+//  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)
+//
+//  And we acknowledge the support from all contributors.
+
+/** \mainpage BOOST uBLAS: a Linear Algebra Library
+ *
+ * This is the API Reference Documentation. 
+ *
+ * For introduction, documentations and tutorial, please refer
+ * to http://www.boost.org/doc/libs/1_44_0/libs/numeric/ublas/doc/index.htm
+ * 
+ * \section main_classes Main classes
+ * 
+ * \subsection listvector Vectors
+ * - \link #boost::numeric::ublas::vector					vector \endlink
+ * - \link #boost::numeric::ublas::bounded_vector			bounded_vector \endlink
+ * - \link #boost::numeric::ublas::zero_vector				zero_vector \endlink
+ * - \link #boost::numeric::ublas::unit_vector				unit_vector \endlink
+ * - \link #boost::numeric::ublas::scalar_vector			scalar_vector \endlink
+ * - \link #boost::numeric::ublas::c_vector				c_vector \endlink
+ * - \link #boost::numeric::ublas::vector_slice				vector_slice \endlink
+ * - \link #boost::numeric::ublas::vector_range				vector_range \endlink
+ * - \link #boost::numeric::ublas::vector_indirect			vector_indirect \endlink
+ * - \link #boost::numeric::ublas::mapped_vector			mapped_vector \endlink
+ * - \link #boost::numeric::ublas::compressed_vector			compressed_vector \endlink
+ * - \link #boost::numeric::ublas::coordinate_vector			coordinate_vector \endlink
+ * - \link #boost::numeric::ublas::matrix_row				matrix_row \endlink
+ * - \link #boost::numeric::ublas::matrix_column			matrix_column \endlink
+ *
+ * \subsection listmatrix Matrices
+ * - \link #boost::numeric::ublas::matrix					matrix \endlink
+ * - \link #boost::numeric::ublas::banded_matrix			banded_matrix \endlink
+ * - \link #boost::numeric::ublas::diagonal_matrix			diagonal_matrix \endlink
+ * - \link #boost::numeric::ublas::banded_adaptor			banded_adaptor \endlink
+ * - \link #boost::numeric::ublas::diagonal_adaptor			diagonal_adaptor \endlink
+ * - \link #boost::numeric::ublas::hermitian_matrix			hermitian_matrix \endlink
+ * - \link #boost::numeric::ublas::hermitian_adaptor			hermitian_adaptor \endlink
+ * - \link #boost::numeric::ublas::symmetric_matrix			symmetric_matrix \endlink
+ * - \link #boost::numeric::ublas::symmetric_adaptor			symmetric_adaptor \endlink
+ * - \link #boost::numeric::ublas::triangular_matrix			triangular_matrix \endlink
+ * - \link #boost::numeric::ublas::triangular_adaptor			triangular_adaptor \endlink
+ * - \link #boost::numeric::ublas::vector_of_vector			vector_of_vector \endlink
+ * - \link #boost::numeric::ublas::bounded_matrix			bounded_matrix \endlink
+ * - \link #boost::numeric::ublas::zero_matrix 				zero_matrix  \endlink
+ * - \link #boost::numeric::ublas::identity_matrix			identity_matrix \endlink
+ * - \link #boost::numeric::ublas::scalar_matrix 			scalar_matrix  \endlink
+ * - \link #boost::numeric::ublas::c_matrix				c_matrix \endlink
+ * - \link #boost::numeric::ublas::matrix_vector_range		matrix_vector_range \endlink
+ * - \link #boost::numeric::ublas::matrix_vector_slice		matrix_vector_slice \endlink
+ * - \link #boost::numeric::ublas::matrix_vector_indirect		matrix_vector_indirect \endlink
+ * - \link #boost::numeric::ublas::matrix_range				matrix_range \endlink
+ * - \link #boost::numeric::ublas::matrix_slice				matrix_slice \endlink
+ * - \link #boost::numeric::ublas::matrix_indirect			matrix_indirect \endlink
+ * - \link #boost::numeric::ublas::mapped_matrix			mapped_matrix \endlink
+ * - \link #boost::numeric::ublas::mapped_vector_of_mapped_vector	mapped_vector_of_mapped_vector \endlink
+ * - \link #boost::numeric::ublas::compressed_matrix			compressed_matrix \endlink
+ * - \link #boost::numeric::ublas::coordinate_matrix			coordinate_matrix \endlink
+ * - \link #boost::numeric::ublas::generalized_vector_of_vector	generalized_vector_of_vector \endlink
+ */