# Boost-Commit :

Subject: [Boost-commit] svn:boost r62066 - branches/ublas-doxygen
From: david.bellot_at_[hidden]
Date: 2010-05-17 09:33:07

Author: david.bellot
Date: 2010-05-17 09:33:06 EDT (Mon, 17 May 2010)
New Revision: 62066
URL: http://svn.boost.org/trac/boost/changeset/62066

Log:
more documentation... :-)

Text files modified:
branches/ublas-doxygen/doxydoc.hpp | 227 +++++++++++----------------------------
1 files changed, 64 insertions(+), 163 deletions(-)

Modified: branches/ublas-doxygen/doxydoc.hpp
==============================================================================
--- branches/ublas-doxygen/doxydoc.hpp (original)
+++ branches/ublas-doxygen/doxydoc.hpp 2010-05-17 09:33:06 EDT (Mon, 17 May 2010)
@@ -10,7 +10,9 @@

///
-/// \brief
+/// \brief An iterator on const values from a column perspective
+/// An iterator on const values from a column perspective: if it points to a matrix value at \f$(i,j)\f$, incrementing it (resp. decrementing it) will make it point to \f$(i+1,j)\f$ (resp. \f$(i-1,j\f$) assuming this position is valid. It has reached the bottom of the matrix when its value equals end1().
+/// Iterator1 follows the same semantic as STL iterators. Setting its value to begin()1 will point it to the position \f$(0,0)\f$ of the matrix. To start at another column the method find() can be used (e.g. find(0,10) to start at the 11-th column).
///

///
@@ -30,12 +32,15 @@

///
/// \class boost::numeric::ublas::banded_matrix
-/// \brief
+/// \brief A banded matrix is a generalization of a diagonal matrix.
+/// A banded matrix is a generalization of a diagonal matrix. For a \f$(mxn)\f$-dimensional banded matrix with \f$l\f$ lower and \f$u\f$ upper diagonals and \f$0 \leq i < m\f$ and \f$0 \leq j < n\f$, if \f$i>j+l\f$ or \f$i<j-u\f$ then \f$b_{i,j}=0\f$. The storage of banded matrices is packed.
///

///
/// \class boost::numeric::ublas::banded_matrix::const_iterator1
-/// \brief
+/// \brief An iterator on const values from a column perspective
+/// An iterator on const values from a column perspective: if it points to a matrix value at \f$(i,j)\f$, incrementing it (resp. decrementing it) will make it point to \f$(i+1,j)\f$ (resp. \f$(i-1,j\f$) assuming this position is valid. It has reached the bottom of the matrix when its value equals end1().
+/// Iterator1 follows the same semantic as STL iterators. Setting its value to begin()1 will point it to the position \f$(0,0)\f$ of the matrix. To start at another column the method find() can be used (e.g. find(0,10) to start at the 11-th column).
///

///
@@ -45,7 +50,7 @@

///
/// \class boost::numeric::ublas::banded_matrix::iterator1
-/// \brief
+/// \brief an iterator moving from line to line for a specified column in a banded matrix.
///

///
@@ -95,12 +100,16 @@

///
/// \class boost::numeric::ublas::c_matrix
-/// \brief
+/// \brief An array based matrix class which size is defined at type specification or object instanciation
+/// An array based matrix class which size is defined at type specification or object instanciation. This matrix is directly based on a predefinec C-style arry of data, thus providing the fastest implementation possible. The constraint is that dimensions of the matrix must be specified at the instanciation or the type specification. For instance, \code typedef c_matrix<double,4,4> my_4by4_matrix\encode defines a 4x4 double-precision matrix. You can also instantiate it directly with \code c_matrix<int,8,5> my_fast_matrix\endcode. This will make a 8 by 5 integer matrix. The price to pay for this speed is that you cannot resize it to a size larger than the one defined in the template parameters. In the previous example, a size of 4 by 5 or 3 by 2 is acceptable, but a new size of 9 by 5 or even 10 by 10 will raise a bad_size() exception.
+///
///

///
/// \class boost::numeric::ublas::c_matrix::const_iterator1
-/// \brief
+/// \brief An iterator on const values from a column perspective
+/// An iterator on const values from a column perspective: if it points to a matrix value at \f$(i,j)\f$, incrementing it (resp. decrementing it) will make it point to \f$(i+1,j)\f$ (resp. \f$(i-1,j\f$) assuming this position is valid. It has reached the bottom of the matrix when its value equals end1().
+/// Iterator1 follows the same semantic as STL iterators. Setting its value to begin()1 will point it to the position \f$(0,0)\f$ of the matrix. To start at another column the method find() can be used (e.g. find(0,10) to start at the 11-th column).
///

///
@@ -125,7 +134,9 @@

///
/// \class boost::numeric::ublas::compressed_matrix::const_iterator1
-/// \brief
+/// \brief An iterator on const values from a column perspective
+/// An iterator on const values from a column perspective: if it points to a matrix value at \f$(i,j)\f$, incrementing it (resp. decrementing it) will make it point to \f$(i+1,j)\f$ (resp. \f$(i-1,j\f$) assuming this position is valid. It has reached the bottom of the matrix when its value equals end1().
+/// Iterator1 follows the same semantic as STL iterators. Setting its value to begin()1 will point it to the position \f$(0,0)\f$ of the matrix. To start at another column the method find() can be used (e.g. find(0,10) to start at the 11-th column).
///

///
@@ -150,7 +161,9 @@

///
/// \class boost::numeric::ublas::compressed_matrix_view::const_iterator1
-/// \brief
+/// \brief An iterator on const values from a column perspective
+/// An iterator on const values from a column perspective: if it points to a matrix value at \f$(i,j)\f$, incrementing it (resp. decrementing it) will make it point to \f$(i+1,j)\f$ (resp. \f$(i-1,j\f$) assuming this position is valid. It has reached the bottom of the matrix when its value equals end1().
+/// Iterator1 follows the same semantic as STL iterators. Setting its value to begin()1 will point it to the position \f$(0,0)\f$ of the matrix. To start at another column the method find() can be used (e.g. find(0,10) to start at the 11-th column).
///

///
@@ -190,7 +203,9 @@

///
/// \class boost::numeric::ublas::coordinate_matrix::const_iterator1
-/// \brief
+/// \brief An iterator on const values from a column perspective
+/// An iterator on const values from a column perspective: if it points to a matrix value at \f$(i,j)\f$, incrementing it (resp. decrementing it) will make it point to \f$(i+1,j)\f$ (resp. \f$(i-1,j\f$) assuming this position is valid. It has reached the bottom of the matrix when its value equals end1().
+/// Iterator1 follows the same semantic as STL iterators. Setting its value to begin()1 will point it to the position \f$(0,0)\f$ of the matrix. To start at another column the method find() can be used (e.g. find(0,10) to start at the 11-th column).
///

///
@@ -225,9 +240,12 @@

///
/// \class boost::numeric::ublas::c_vector
-/// \brief
+/// \brief An array based vector class which size is defined at type specification or object instanciation.
+/// An array based matrix class which size is defined at type specification or object instanciation. This matrix is directly based on a predefinec C-style arry of data, thus providing the fastest implementation possible. The constraint is that dimensions of the matrix must be specified at the instanciation or the type specification. For instance, \code typedef c_matrix<double,4,4> my_4by4_matrix\encode defines a 4x4 double-precision matrix. You can also instantiate it directly with \code c_matrix<int,8,5> my_fast_matrix\endcode. This will make a 8 by 5 integer matrix. The price to pay for this speed is that you cannot resize it to a size larger than the one defined in the template parameters. In the previous example, a size of 4 by 5 or 3 by 2 is acceptable, but a new size of 9 by 5 or even 10 by 10 will raise a bad_size() exception.
+///
///

+
///
/// \class boost::numeric::ublas::c_vector::const_iterator
/// \brief
@@ -305,7 +323,9 @@

///
/// \class boost::numeric::ublas::hermitian_matrix::const_iterator1
-/// \brief
+/// \brief An iterator on const values from a column perspective
+/// An iterator on const values from a column perspective: if it points to a matrix value at \f$(i,j)\f$, incrementing it (resp. decrementing it) will make it point to \f$(i+1,j)\f$ (resp. \f$(i-1,j\f$) assuming this position is valid. It has reached the bottom of the matrix when its value equals end1().
+/// Iterator1 follows the same semantic as STL iterators. Setting its value to begin()1 will point it to the position \f$(0,0)\f$ of the matrix. To start at another column the method find() can be used (e.g. find(0,10) to start at the 11-th column).
///

///
@@ -335,7 +355,9 @@

///
/// \class boost::numeric::ublas::identity_matrix::const_iterator1
-/// \brief
+/// \brief An iterator on const values from a column perspective
+/// An iterator on const values from a column perspective: if it points to a matrix value at \f$(i,j)\f$, incrementing it (resp. decrementing it) will make it point to \f$(i+1,j)\f$ (resp. \f$(i-1,j\f$) assuming this position is valid. It has reached the bottom of the matrix when its value equals end1().
+/// Iterator1 follows the same semantic as STL iterators. Setting its value to begin()1 will point it to the position \f$(0,0)\f$ of the matrix. To start at another column the method find() can be used (e.g. find(0,10) to start at the 11-th column).
///

///
@@ -415,7 +437,9 @@

///
/// \class boost::numeric::ublas::mapped_matrix::const_iterator1
-/// \brief
+/// \brief An iterator on const values from a column perspective
+/// An iterator on const values from a column perspective: if it points to a matrix value at \f$(i,j)\f$, incrementing it (resp. decrementing it) will make it point to \f$(i+1,j)\f$ (resp. \f$(i-1,j\f$) assuming this position is valid. It has reached the bottom of the matrix when its value equals end1().
+/// Iterator1 follows the same semantic as STL iterators. Setting its value to begin()1 will point it to the position \f$(0,0)\f$ of the matrix. To start at another column the method find() can be used (e.g. find(0,10) to start at the 11-th column).
///

///
@@ -480,7 +504,8 @@

///
/// \class boost::numeric::ublas::matrix
-/// \brief
+/// \brief A standard dense matrix
+/// A standard dense matrix.
///

///
@@ -545,7 +570,9 @@

///
/// \class boost::numeric::ublas::matrix::const_iterator1
-/// \brief
+/// \brief An iterator on const values from a column perspective
+/// An iterator on const values from a column perspective: if it points to a matrix value at \f$(i,j)\f$, incrementing it (resp. decrementing it) will make it point to \f$(i+1,j)\f$ (resp. \f$(i-1,j\f$) assuming this position is valid. It has reached the bottom of the matrix when its value equals end1().
+/// Iterator1 follows the same semantic as STL iterators. Setting its value to begin()1 will point it to the position \f$(0,0)\f$ of the matrix. To start at another column the method find() can be used (e.g. find(0,10) to start at the 11-th column).
///

///
@@ -565,12 +592,14 @@

///
/// \class boost::numeric::ublas::matrix_indirect
-/// \brief
+/// \brief A matrix view defined by another container or even another matrix.
///

///
/// \class boost::numeric::ublas::matrix_indirect::const_iterator1
-/// \brief
+/// \brief An iterator on const values from a column perspective
+/// An iterator on const values from a column perspective: if it points to a matrix value at \f$(i,j)\f$, incrementing it (resp. decrementing it) will make it point to \f$(i+1,j)\f$ (resp. \f$(i-1,j\f$) assuming this position is valid. It has reached the bottom of the matrix when its value equals end1().
+/// Iterator1 follows the same semantic as STL iterators. Setting its value to begin()1 will point it to the position \f$(0,0)\f$ of the matrix. To start at another column the method find() can be used (e.g. find(0,10) to start at the 11-th column).
///

///
@@ -620,7 +649,9 @@

///
/// \class boost::numeric::ublas::matrix_range::const_iterator1
-/// \brief
+/// \brief An iterator on const values from a column perspective
+/// An iterator on const values from a column perspective: if it points to a matrix value at \f$(i,j)\f$, incrementing it (resp. decrementing it) will make it point to \f$(i+1,j)\f$ (resp. \f$(i-1,j\f$) assuming this position is valid. It has reached the bottom of the matrix when its value equals end1().
+/// Iterator1 follows the same semantic as STL iterators. Setting its value to begin()1 will point it to the position \f$(0,0)\f$ of the matrix. To start at another column the method find() can be used (e.g. find(0,10) to start at the 11-th column).
///

///
@@ -670,7 +701,9 @@

///
/// \class boost::numeric::ublas::matrix_slice::const_iterator1
-/// \brief
+/// \brief An iterator on const values from a column perspective
+/// An iterator on const values from a column perspective: if it points to a matrix value at \f$(i,j)\f$, incrementing it (resp. decrementing it) will make it point to \f$(i+1,j)\f$ (resp. \f$(i-1,j\f$) assuming this position is valid. It has reached the bottom of the matrix when its value equals end1().
+/// Iterator1 follows the same semantic as STL iterators. Setting its value to begin()1 will point it to the position \f$(0,0)\f$ of the matrix. To start at another column the method find() can be used (e.g. find(0,10) to start at the 11-th column).
///

///
@@ -825,7 +858,9 @@

///
/// \class boost::numeric::ublas::scalar_matrix::const_iterator1
-/// \brief
+/// \brief An iterator on const values from a column perspective
+/// An iterator on const values from a column perspective: if it points to a matrix value at \f$(i,j)\f$, incrementing it (resp. decrementing it) will make it point to \f$(i+1,j)\f$ (resp. \f$(i-1,j\f$) assuming this position is valid. It has reached the bottom of the matrix when its value equals end1().
+/// Iterator1 follows the same semantic as STL iterators. Setting its value to begin()1 will point it to the position \f$(0,0)\f$ of the matrix. To start at another column the method find() can be used (e.g. find(0,10) to start at the 11-th column).
///

///
@@ -910,7 +945,9 @@

///
/// \class boost::numeric::ublas::symmetric_matrix::const_iterator1
-/// \brief
+/// \brief An iterator on const values from a column perspective
+/// An iterator on const values from a column perspective: if it points to a matrix value at \f$(i,j)\f$, incrementing it (resp. decrementing it) will make it point to \f$(i+1,j)\f$ (resp. \f$(i-1,j\f$) assuming this position is valid. It has reached the bottom of the matrix when its value equals end1().
+/// Iterator1 follows the same semantic as STL iterators. Setting its value to begin()1 will point it to the position \f$(0,0)\f$ of the matrix. To start at another column the method find() can be used (e.g. find(0,10) to start at the 11-th column).
///

///
@@ -960,7 +997,9 @@

///
/// \class boost::numeric::ublas::triangular_matrix::const_iterator1
-/// \brief
+/// \brief An iterator on const values from a column perspective
+/// An iterator on const values from a column perspective: if it points to a matrix value at \f$(i,j)\f$, incrementing it (resp. decrementing it) will make it point to \f$(i+1,j)\f$ (resp. \f$(i-1,j\f$) assuming this position is valid. It has reached the bottom of the matrix when its value equals end1().
+/// Iterator1 follows the same semantic as STL iterators. Setting its value to begin()1 will point it to the position \f$(0,0)\f$ of the matrix. To start at another column the method find() can be used (e.g. find(0,10) to start at the 11-th column).
///

///
@@ -1170,7 +1209,9 @@

///
/// \class boost::numeric::ublas::zero_matrix::const_iterator1
-/// \brief
+/// \brief An iterator on const values from a column perspective
+/// An iterator on const values from a column perspective: if it points to a matrix value at \f$(i,j)\f$, incrementing it (resp. decrementing it) will make it point to \f$(i+1,j)\f$ (resp. \f$(i-1,j\f$) assuming this position is valid. It has reached the bottom of the matrix when its value equals end1().
+/// Iterator1 follows the same semantic as STL iterators. Setting its value to begin()1 will point it to the position \f$(0,0)\f$ of the matrix. To start at another column the method find() can be used (e.g. find(0,10) to start at the 11-th column).
///

///
@@ -1494,146 +1535,6 @@
///

///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///
-/// \fn boost::numeric::ublas::axpy_prod
-/// \brief
-///
-
-///