|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r61383 - branches/ublas-doxygen
From: david.bellot_at_[hidden]
Date: 2010-04-18 16:50:24
Author: david.bellot
Date: 2010-04-18 16:50:24 EDT (Sun, 18 Apr 2010)
New Revision: 61383
URL: http://svn.boost.org/trac/boost/changeset/61383
Log:
first commit to kick off things on the doxygen documentation
Text files modified:
branches/ublas-doxygen/vector.hpp | 299 +++++++++++++++++++++++++++++++++++++++
1 files changed, 292 insertions(+), 7 deletions(-)
Modified: branches/ublas-doxygen/vector.hpp
==============================================================================
--- branches/ublas-doxygen/vector.hpp (original)
+++ branches/ublas-doxygen/vector.hpp 2010-04-18 16:50:24 EDT (Sun, 18 Apr 2010)
@@ -1,6 +1,6 @@
//
-// Copyright (c) 2000-2002
-// Joerg Walter, Mathias Koch
+// 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
@@ -8,8 +8,8 @@
//
// The authors gratefully acknowledge the support of
// GeNeSys mbH & Co. KG in producing this work.
-// ----------------------------------------------------------------
-//
+//
+// And we acknowledge the support from all contributors.
#ifndef _BOOST_UBLAS_VECTOR_
#define _BOOST_UBLAS_VECTOR_
@@ -20,11 +20,18 @@
#include <boost/serialization/collection_size_type.hpp>
#include <boost/serialization/nvp.hpp>
+/// \file This file contains definition for the class vector and all its derivative.
+
// Iterators based on ideas of Jeremy Siek
namespace boost { namespace numeric { namespace ublas {
- // Array based vector class
+ /// \brief Array-based vector class
+ ///
+ /// Array-based vector class: this templated vector class is the base container adaptor for dense vectors. For a \f$n\-dimensional vector \f$v\f$ and \f$0 \leq i < n\f$ every element \f$v_i\f$ is mapped to the \f$i\f$-th element of the container. The 2 templates parameters respectively defines the following:
+ /// \tparam T type of the objects stored in the vector: it can be anything even if most of the time, scalar types will be used like \c double or \c int. Complex types can be used, or even classes.
+ /// \tparam A The type of the storage array of the vector. By default it is \c unbounded_array<T>. Common other value can be \c <bounded_array<T> and \c std::vector<T>.
+ /// Also note that, expect when making an empty vector, all other constructors imply a \f$O(n)\f$ time complexity during construction due to the initialization. Because \e uBLAS tries to avoid the creation of temporaries into expressions, this penalty only occurs when explicitely creating vectors in your code. If you want to create many vectors without initialization, consider using a different storage type like \c std::vector<T> for example.
template<class T, class A>
class vector:
public vector_container<vector<T, A> > {
@@ -34,7 +41,20 @@
#ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
using vector_container<self_type>::operator ();
#endif
- typedef typename A::size_type size_type;
+ /// \typedef size_type
+ /// \typedef difference_type
+ /// \typedef value_type
+ /// \typedef const_reference
+ /// \typedef reference
+ /// \typedef pointer
+ /// \typedef const_pointer
+ /// \typedef array_type
+ /// \typedef const_closure_type
+ /// \typedef closure_type
+ /// \typedef vector_temporary_type
+ /// \typedef storage_category
+
+ 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;
@@ -48,27 +68,59 @@
typedef dense_tag storage_category;
// Construction and destruction
+
+ /// \brief Constructor of a vector
+ /// Constructor for 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
+ /// Constructor for 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
+ /// Constructor for a vector by copying from another container of the same type (\c A) as the template definition. 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
+ /// Constructor for a vector by copying from another container of the same type (\c A) as the template definition. 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
+ /// 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):
@@ -77,33 +129,58 @@
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 of 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)
@@ -112,46 +189,83 @@
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$
+ /// \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$
+ /// \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.
BOOST_UBLAS_INLINE
void clear () {
std::fill (data ().begin (), data ().end (), value_type/*zero*/());
@@ -160,6 +274,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)
/*! @note "pass by value" the key idea to enable move semantics */
BOOST_UBLAS_INLINE
vector &operator = (vector v) {
@@ -167,12 +284,20 @@
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)
BOOST_UBLAS_INLINE
vector &operator = (const vector &v) {
data () = v.data ();
return *this;
}
#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) {
@@ -180,17 +305,33 @@
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) {
self_type temporary (ae);
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) {
@@ -198,49 +339,106 @@
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
template<class AT>
BOOST_UBLAS_INLINE
vector &operator *= (const AT &at) {
vector_assign_scalar<scalar_multiplies_assign> (*this, at);
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) {
@@ -248,13 +446,22 @@
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);
@@ -267,6 +474,9 @@
typedef typename A::iterator subiterator_type;
public:
+ /// \typedef iterator
+ /// \typedef const_iterator
+
#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
typedef indexed_iterator<self_type, dense_random_access_iterator_tag> iterator;
typedef indexed_const_iterator<self_type, dense_random_access_iterator_tag> const_iterator;
@@ -275,7 +485,12 @@
class iterator;
#endif
+ // --------------
// 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
@@ -284,6 +499,9 @@
return const_iterator (*this, i);
#endif
}
+
+ /// \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
@@ -304,7 +522,11 @@
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_ () {}
@@ -315,45 +537,69 @@
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_;
}
- // Dereference
+ /// \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 ());
@@ -362,6 +608,7 @@
// Assignment
BOOST_UBLAS_INLINE
+ /// \brief assign the value of an iterator to the iterator
const_iterator &operator = (const const_iterator &it) {
container_const_reference<self_type>::assign (&it ());
it_ = it.it_;
@@ -369,11 +616,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
BOOST_UBLAS_INLINE
bool operator < (const const_iterator &it) const {
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
@@ -387,10 +640,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 after the last element of the vector
BOOST_UBLAS_INLINE
const_iterator end () const {
return find (data_.size ());
@@ -798,6 +1054,11 @@
// Unit vector class
+ /// \brief unit_vector represents a canonical unit vector
+ /// unit_vector represents a canonical unit vector. The \e k-th unit vector of dimension \f$n\f$ holds 0 for every value \f$u_i\f$ s.t. \f$i \neq k\f$ and 1 when \f$i=k\f$.
+ /// At construction, the value \e k is given after the dimension of the vector.
+ /// \tparam T is the type of elements in the vector. They must be 0 and 1 assignable in order for the vector to have its unit-vector semantic.
+ /// \tparam ALLOC a specific allocator can be specified if needed. Most of the time this parameter is omited.
template<class T, class ALLOC>
class unit_vector:
public vector_container<unit_vector<T, ALLOC> > {
@@ -818,36 +1079,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
BOOST_UBLAS_INLINE
const_pointer find_element (size_type i) const {
if (i == index_)
@@ -1023,6 +1303,11 @@
// Scalar vector class
+ /// \brief vector having a unique value
+ ///
+ /// A scalar vector is a vector having a unique value whatever its size. Changing its value means changing all the element at once to the new value.
+ /// \tparam T type of the objects stored in the vector: it can be anything even if most of the time, scalar types will be used like \c double or \c int. Complex types can be used, or even classes.
+ /// \tparam ALLOC
template<class T, class ALLOC>
class scalar_vector:
public vector_container<scalar_vector<T, ALLOC> > {
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk