diff --git a/include/boost/numeric/ublas/vector.hpp b/include/boost/numeric/ublas/vector.hpp index 29106d9c..fb1cd090 100644 --- a/include/boost/numeric/ublas/vector.hpp +++ b/include/boost/numeric/ublas/vector.hpp @@ -90,10 +90,10 @@ namespace boost { namespace numeric { namespace ublas { /// \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 (), - data_ (data) {} + BOOST_UBLAS_INLINE + vector (const array_type &data): + vector_container (), + data_ (data) {} /// \brief Constructor of a vector with a predefined size and a unique initial value /// \param size of the vector @@ -344,12 +344,12 @@ namespace boost { namespace numeric { namespace ublas { /// \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 - BOOST_UBLAS_INLINE - vector &operator += (const vector_expression &ae) { - self_type temporary (*this + ae); - return assign_temporary (temporary); - } + template + BOOST_UBLAS_INLINE + vector &operator += (const vector_expression &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. @@ -357,12 +357,12 @@ namespace boost { namespace numeric { namespace ublas { /// \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 // Container assignment without temporary - BOOST_UBLAS_INLINE - vector &operator += (const vector_container &v) { - plus_assign (v); - return *this; - } + template // Container assignment without temporary + BOOST_UBLAS_INLINE + vector &operator += (const vector_container &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. @@ -382,51 +382,51 @@ namespace boost { namespace numeric { namespace ublas { /// 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 - BOOST_UBLAS_INLINE - vector &operator -= (const vector_expression &ae) { - self_type temporary (*this - ae); - return assign_temporary (temporary); - } - + template + BOOST_UBLAS_INLINE + vector &operator -= (const vector_expression &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 // Container assignment without temporary - BOOST_UBLAS_INLINE - vector &operator -= (const vector_container &v) { - minus_assign (v); - return *this; - } - + template // Container assignment without temporary + BOOST_UBLAS_INLINE + vector &operator -= (const vector_container &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 - BOOST_UBLAS_INLINE - vector &minus_assign (const vector_expression &ae) { - vector_assign (*this, ae); - return *this; - } - + template + BOOST_UBLAS_INLINE + vector &minus_assign (const vector_expression &ae) { + vector_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 - BOOST_UBLAS_INLINE - vector &operator *= (const AT &at) { - vector_assign_scalar (*this, at); - return *this; - } + template + BOOST_UBLAS_INLINE + vector &operator *= (const AT &at) { + vector_assign_scalar (*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. @@ -453,28 +453,28 @@ namespace boost { namespace numeric { namespace ublas { 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); - } + BOOST_UBLAS_INLINE + friend void swap (vector &v1, vector &v2) { + v1.swap (v2); + } - // Iterator types - private: - // Use the storage array iterator - typedef typename A::const_iterator const_subiterator_type; - typedef typename A::iterator subiterator_type; + // Iterator types + private: + // Use the storage array iterator + typedef typename A::const_iterator const_subiterator_type; + typedef typename A::iterator subiterator_type; - public: + public: #ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR - typedef indexed_iterator iterator; - typedef indexed_const_iterator const_iterator; + typedef indexed_iterator iterator; + typedef indexed_const_iterator const_iterator; #else - class const_iterator; - class iterator; + class const_iterator; + class iterator; #endif // -------------- @@ -483,36 +483,36 @@ namespace boost { namespace numeric { namespace ublas { /// \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 { + BOOST_UBLAS_INLINE + const_iterator find (size_type i) const { #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR - return const_iterator (*this, data ().begin () + i); + return const_iterator (*this, data ().begin () + i); #else - return const_iterator (*this, i); + 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) { + BOOST_UBLAS_INLINE + iterator find (size_type i) { #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR - return iterator (*this, data ().begin () + i); + return iterator (*this, data ().begin () + i); #else - return iterator (*this, i); + return iterator (*this, i); #endif - } + } #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR - class const_iterator: - public container_const_reference, - public random_access_iterator_base, + public random_access_iterator_base { - public: - typedef typename vector::difference_type difference_type; - typedef typename vector::value_type value_type; - typedef typename vector::const_reference reference; - typedef const typename vector::pointer pointer; + public: + typedef typename vector::difference_type difference_type; + typedef typename vector::value_type value_type; + typedef typename vector::const_reference reference; + typedef const typename vector::pointer pointer; // ---------------------------- // Construction and destruction @@ -592,22 +592,22 @@ namespace boost { namespace numeric { namespace ublas { // 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 ()); - return it_ - (*this) ().begin ().it_; - } + BOOST_UBLAS_INLINE + size_type index () const { + BOOST_UBLAS_CHECK (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_, bad_index ()); + return it_ - (*this) ().begin ().it_; + } - // Assignment - BOOST_UBLAS_INLINE - /// \brief assign the value of an iterator to the iterator - const_iterator &operator = (const const_iterator &it) { - container_const_reference::assign (&it ()); - it_ = it.it_; - return *this; - } + // Assignment + BOOST_UBLAS_INLINE + /// \brief assign the value of an iterator to the iterator + const_iterator &operator = (const const_iterator &it) { + container_const_reference::assign (&it ()); + it_ = it.it_; + return *this; + } - // Comparison + // Comparison /// \brief compare the value of two itetarors /// \return true if they reference the same element BOOST_UBLAS_INLINE @@ -619,17 +619,17 @@ namespace boost { namespace numeric { namespace ublas { /// \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 ()); - return it_ < it.it_; - } + BOOST_UBLAS_INLINE + bool operator < (const const_iterator &it) const { + BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); + return it_ < it.it_; + } - private: - const_subiterator_type it_; + private: + const_subiterator_type it_; - friend class iterator; - }; + friend class iterator; + }; #endif /// \brief return an iterator on the first element of the vector @@ -639,101 +639,101 @@ namespace boost { namespace numeric { namespace ublas { } /// \brief return an iterator after the last element of the vector - BOOST_UBLAS_INLINE - const_iterator end () const { - return find (data_.size ()); - } + BOOST_UBLAS_INLINE + const_iterator end () const { + return find (data_.size ()); + } #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR - class iterator: - public container_reference, - public random_access_iterator_base { - public: - typedef typename vector::difference_type difference_type; - typedef typename vector::value_type value_type; - typedef typename vector::reference reference; - typedef typename vector::pointer pointer; + class iterator: + public container_reference, + public random_access_iterator_base { + public: + typedef typename vector::difference_type difference_type; + typedef typename vector::value_type value_type; + typedef typename vector::reference reference; + typedef typename vector::pointer pointer; - // Construction and destruction - BOOST_UBLAS_INLINE - iterator (): - container_reference (), it_ () {} - BOOST_UBLAS_INLINE - iterator (self_type &v, const subiterator_type &it): - container_reference (v), it_ (it) {} + // Construction and destruction + BOOST_UBLAS_INLINE + iterator (): + container_reference (), it_ () {} + BOOST_UBLAS_INLINE + iterator (self_type &v, const subiterator_type &it): + container_reference (v), it_ (it) {} - // Arithmetic - BOOST_UBLAS_INLINE - iterator &operator ++ () { - ++ it_; - return *this; - } - BOOST_UBLAS_INLINE - iterator &operator -- () { - -- it_; - return *this; - } - BOOST_UBLAS_INLINE - iterator &operator += (difference_type n) { - it_ += n; - return *this; - } - BOOST_UBLAS_INLINE - iterator &operator -= (difference_type n) { - it_ -= n; - return *this; - } - BOOST_UBLAS_INLINE - difference_type operator - (const iterator &it) const { - BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); - return it_ - it.it_; - } + // Arithmetic + BOOST_UBLAS_INLINE + iterator &operator ++ () { + ++ it_; + return *this; + } + BOOST_UBLAS_INLINE + iterator &operator -- () { + -- it_; + return *this; + } + BOOST_UBLAS_INLINE + iterator &operator += (difference_type n) { + it_ += n; + return *this; + } + BOOST_UBLAS_INLINE + iterator &operator -= (difference_type n) { + it_ -= n; + return *this; + } + BOOST_UBLAS_INLINE + difference_type operator - (const iterator &it) const { + BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); + return it_ - it.it_; + } - // Dereference - BOOST_UBLAS_INLINE - reference operator * () const { - BOOST_UBLAS_CHECK (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_ , bad_index ()); - return *it_; - } - BOOST_UBLAS_INLINE - reference operator [] (difference_type n) const { - return *(it_ + n); - } + // Dereference + BOOST_UBLAS_INLINE + reference operator * () const { + BOOST_UBLAS_CHECK (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_ , bad_index ()); + return *it_; + } + BOOST_UBLAS_INLINE + reference operator [] (difference_type n) const { + return *(it_ + n); + } - // Index - BOOST_UBLAS_INLINE - size_type index () const { - BOOST_UBLAS_CHECK (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_ , bad_index ()); - return it_ - (*this) ().begin ().it_; - } + // Index + BOOST_UBLAS_INLINE + size_type index () const { + BOOST_UBLAS_CHECK (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_ , bad_index ()); + return it_ - (*this) ().begin ().it_; + } - // Assignment - BOOST_UBLAS_INLINE - iterator &operator = (const iterator &it) { - container_reference::assign (&it ()); - it_ = it.it_; - return *this; - } + // Assignment + BOOST_UBLAS_INLINE + iterator &operator = (const iterator &it) { + container_reference::assign (&it ()); + it_ = it.it_; + return *this; + } - // Comparison - BOOST_UBLAS_INLINE - bool operator == (const iterator &it) const { - BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); - return it_ == it.it_; - } - BOOST_UBLAS_INLINE - bool operator < (const iterator &it) const { - BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); - return it_ < it.it_; - } + // Comparison + BOOST_UBLAS_INLINE + bool operator == (const iterator &it) const { + BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); + return it_ == it.it_; + } + BOOST_UBLAS_INLINE + bool operator < (const iterator &it) const { + BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); + return it_ < it.it_; + } - private: - subiterator_type it_; + private: + subiterator_type it_; - friend class const_iterator; - }; + friend class const_iterator; + }; #endif /// \brief Return an iterator on the first element of the vector @@ -783,323 +783,323 @@ namespace boost { namespace numeric { namespace ublas { /// 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 - void serialize(Archive & ar, const unsigned int /* file_version */){ - ar & serialization::make_nvp("data",data_); - } + template + void serialize(Archive & ar, const unsigned int /* file_version */){ + ar & serialization::make_nvp("data",data_); + } - private: - array_type data_; - }; + private: + array_type data_; + }; - // -------------------- - // Bounded vector class - // -------------------- + // -------------------- + // Bounded vector class + // -------------------- - /// \brief a dense vector of values of type \c T, of variable size but with maximum \f$N\f$. - /// A dense vector of values of type \c T, of variable size but with maximum \f$N\f$. The default constructor - /// creates the vector with size \f$N\f$. Elements are constructed by the storage type \c bounded_array, which \b need \b not \b initialise their value. - template - class bounded_vector: - public vector > { + /// \brief a dense vector of values of type \c T, of variable size but with maximum \f$N\f$. + /// A dense vector of values of type \c T, of variable size but with maximum \f$N\f$. The default constructor + /// creates the vector with size \f$N\f$. Elements are constructed by the storage type \c bounded_array, which \b need \b not \b initialise their value. + template + class bounded_vector: + public vector > { - typedef vector > vector_type; - public: - typedef typename vector_type::size_type size_type; - static const size_type max_size = N; + typedef vector > vector_type; + public: + typedef typename vector_type::size_type size_type; + static const size_type max_size = N; - // Construction and destruction - BOOST_UBLAS_INLINE - bounded_vector (): - vector_type (N) {} - BOOST_UBLAS_INLINE - bounded_vector (size_type size): - vector_type (size) {} - BOOST_UBLAS_INLINE - bounded_vector (const bounded_vector &v): - vector_type (v) {} - template // Allow vector construction - BOOST_UBLAS_INLINE - bounded_vector (const vector &v): - vector_type (v) {} - template - BOOST_UBLAS_INLINE - bounded_vector (const vector_expression &ae): - vector_type (ae) {} - BOOST_UBLAS_INLINE - ~bounded_vector () {} + // Construction and destruction + BOOST_UBLAS_INLINE + bounded_vector (): + vector_type (N) {} + BOOST_UBLAS_INLINE + bounded_vector (size_type size): + vector_type (size) {} + BOOST_UBLAS_INLINE + bounded_vector (const bounded_vector &v): + vector_type (v) {} + template // Allow vector construction + BOOST_UBLAS_INLINE + bounded_vector (const vector &v): + vector_type (v) {} + template + BOOST_UBLAS_INLINE + bounded_vector (const vector_expression &ae): + vector_type (ae) {} + BOOST_UBLAS_INLINE + ~bounded_vector () {} - // Assignment + // Assignment #ifdef BOOST_UBLAS_MOVE_SEMANTICS - /*! @note "pass by value" the key idea to enable move semantics */ - BOOST_UBLAS_INLINE - bounded_vector &operator = (bounded_vector v) { - vector_type::operator = (v); - return *this; - } + /*! @note "pass by value" the key idea to enable move semantics */ + BOOST_UBLAS_INLINE + bounded_vector &operator = (bounded_vector v) { + vector_type::operator = (v); + return *this; + } #else - BOOST_UBLAS_INLINE - bounded_vector &operator = (const bounded_vector &v) { - vector_type::operator = (v); - return *this; - } + BOOST_UBLAS_INLINE + bounded_vector &operator = (const bounded_vector &v) { + vector_type::operator = (v); + return *this; + } #endif - template // Generic vector assignment - BOOST_UBLAS_INLINE - bounded_vector &operator = (const vector &v) { - vector_type::operator = (v); - return *this; - } - template // Container assignment without temporary - BOOST_UBLAS_INLINE - bounded_vector &operator = (const vector_container &v) { - vector_type::operator = (v); - return *this; - } - template - BOOST_UBLAS_INLINE - bounded_vector &operator = (const vector_expression &ae) { - vector_type::operator = (ae); - return *this; - } - }; + template // Generic vector assignment + BOOST_UBLAS_INLINE + bounded_vector &operator = (const vector &v) { + vector_type::operator = (v); + return *this; + } + template // Container assignment without temporary + BOOST_UBLAS_INLINE + bounded_vector &operator = (const vector_container &v) { + vector_type::operator = (v); + return *this; + } + template + BOOST_UBLAS_INLINE + bounded_vector &operator = (const vector_expression &ae) { + vector_type::operator = (ae); + return *this; + } + }; - // ----------------- - // Zero vector class - // ----------------- - - /// \brief A zero vector of type \c T and a given \c size - /// A zero vector of type \c T and a given \c size. This is a virtual vector in the sense that no memory is allocated - /// for storing the zero values: it still acts like any other vector. However assigning values to it will not change the zero - /// vector into a normal vector. It must first be assigned to another normal vector by any suitable means. Its memory footprint is constant. - template - class zero_vector: - public vector_container > { + // ----------------- + // Zero vector class + // ----------------- + + /// \brief A zero vector of type \c T and a given \c size + /// A zero vector of type \c T and a given \c size. This is a virtual vector in the sense that no memory is allocated + /// for storing the zero values: it still acts like any other vector. However assigning values to it will not change the zero + /// vector into a normal vector. It must first be assigned to another normal vector by any suitable means. Its memory footprint is constant. + template + class zero_vector: + public vector_container > { - typedef const T *const_pointer; - typedef zero_vector self_type; - public: + typedef const T *const_pointer; + typedef zero_vector self_type; + public: #ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS - using vector_container::operator (); + using vector_container::operator (); #endif - typedef typename ALLOC::size_type size_type; - typedef typename ALLOC::difference_type difference_type; - typedef T value_type; - typedef const T &const_reference; - typedef T &reference; - typedef const vector_reference const_closure_type; - typedef vector_reference closure_type; - typedef sparse_tag storage_category; + typedef typename ALLOC::size_type size_type; + typedef typename ALLOC::difference_type difference_type; + typedef T value_type; + typedef const T &const_reference; + typedef T &reference; + typedef const vector_reference const_closure_type; + typedef vector_reference closure_type; + typedef sparse_tag storage_category; - // Construction and destruction - BOOST_UBLAS_INLINE - zero_vector (): - vector_container (), - size_ (0) {} - explicit BOOST_UBLAS_INLINE - zero_vector (size_type size): - vector_container (), - size_ (size) {} - BOOST_UBLAS_INLINE - zero_vector (const zero_vector &v): - vector_container (), - size_ (v.size_) {} + // Construction and destruction + BOOST_UBLAS_INLINE + zero_vector (): + vector_container (), + size_ (0) {} + explicit BOOST_UBLAS_INLINE + zero_vector (size_type size): + vector_container (), + size_ (size) {} + BOOST_UBLAS_INLINE + zero_vector (const zero_vector &v): + vector_container (), + size_ (v.size_) {} - // Accessors - BOOST_UBLAS_INLINE - size_type size () const { - return size_; - } + // Accessors + BOOST_UBLAS_INLINE + size_type size () const { + return size_; + } - // Resizing - BOOST_UBLAS_INLINE - void resize (size_type size, bool /*preserve*/ = true) { - size_ = size; - } + // Resizing + BOOST_UBLAS_INLINE + void resize (size_type size, bool /*preserve*/ = true) { + size_ = size; + } - // Element support - BOOST_UBLAS_INLINE - const_pointer find_element (size_type i) const { - return & zero_; - } + // Element support + BOOST_UBLAS_INLINE + const_pointer find_element (size_type i) const { + return & zero_; + } - // Element access - BOOST_UBLAS_INLINE - const_reference operator () (size_type /* i */) const { - return zero_; - } + // Element access + BOOST_UBLAS_INLINE + const_reference operator () (size_type /* i */) const { + return zero_; + } - BOOST_UBLAS_INLINE - const_reference operator [] (size_type i) const { - return (*this) (i); - } + BOOST_UBLAS_INLINE + const_reference operator [] (size_type i) const { + return (*this) (i); + } - // Assignment - BOOST_UBLAS_INLINE - zero_vector &operator = (const zero_vector &v) { - size_ = v.size_; - return *this; - } - BOOST_UBLAS_INLINE - zero_vector &assign_temporary (zero_vector &v) { - swap (v); - return *this; - } + // Assignment + BOOST_UBLAS_INLINE + zero_vector &operator = (const zero_vector &v) { + size_ = v.size_; + return *this; + } + BOOST_UBLAS_INLINE + zero_vector &assign_temporary (zero_vector &v) { + swap (v); + return *this; + } - // Swapping - BOOST_UBLAS_INLINE - void swap (zero_vector &v) { - if (this != &v) { - std::swap (size_, v.size_); - } - } - BOOST_UBLAS_INLINE - friend void swap (zero_vector &v1, zero_vector &v2) { - v1.swap (v2); - } + // Swapping + BOOST_UBLAS_INLINE + void swap (zero_vector &v) { + if (this != &v) { + std::swap (size_, v.size_); + } + } + BOOST_UBLAS_INLINE + friend void swap (zero_vector &v1, zero_vector &v2) { + v1.swap (v2); + } - // Iterator types - public: - class const_iterator; + // Iterator types + public: + class const_iterator; - // Element lookup - BOOST_UBLAS_INLINE - const_iterator find (size_type /*i*/) const { - return const_iterator (*this); - } + // Element lookup + BOOST_UBLAS_INLINE + const_iterator find (size_type /*i*/) const { + return const_iterator (*this); + } - class const_iterator: - public container_const_reference, - public bidirectional_iterator_base { - public: - typedef typename zero_vector::difference_type difference_type; - typedef typename zero_vector::value_type value_type; - typedef typename zero_vector::const_reference reference; - typedef typename zero_vector::const_pointer pointer; + class const_iterator: + public container_const_reference, + public bidirectional_iterator_base { + public: + typedef typename zero_vector::difference_type difference_type; + typedef typename zero_vector::value_type value_type; + typedef typename zero_vector::const_reference reference; + typedef typename zero_vector::const_pointer pointer; - // Construction and destruction - BOOST_UBLAS_INLINE - const_iterator (): - container_const_reference () {} - BOOST_UBLAS_INLINE - const_iterator (const self_type &v): - container_const_reference (v) {} + // Construction and destruction + BOOST_UBLAS_INLINE + const_iterator (): + container_const_reference () {} + BOOST_UBLAS_INLINE + const_iterator (const self_type &v): + container_const_reference (v) {} - // Arithmetic - BOOST_UBLAS_INLINE - const_iterator &operator ++ () { - BOOST_UBLAS_CHECK_FALSE (bad_index ()); - return *this; - } - BOOST_UBLAS_INLINE - const_iterator &operator -- () { - BOOST_UBLAS_CHECK_FALSE (bad_index ()); - return *this; - } + // Arithmetic + BOOST_UBLAS_INLINE + const_iterator &operator ++ () { + BOOST_UBLAS_CHECK_FALSE (bad_index ()); + return *this; + } + BOOST_UBLAS_INLINE + const_iterator &operator -- () { + BOOST_UBLAS_CHECK_FALSE (bad_index ()); + return *this; + } - // Dereference - BOOST_UBLAS_INLINE - const_reference operator * () const { - BOOST_UBLAS_CHECK_FALSE (bad_index ()); - return zero_; // arbitary return value - } + // Dereference + BOOST_UBLAS_INLINE + const_reference operator * () const { + BOOST_UBLAS_CHECK_FALSE (bad_index ()); + return zero_; // arbitary return value + } - // Index - BOOST_UBLAS_INLINE - size_type index () const { - BOOST_UBLAS_CHECK_FALSE (bad_index ()); - return 0; // arbitary return value - } + // Index + BOOST_UBLAS_INLINE + size_type index () const { + BOOST_UBLAS_CHECK_FALSE (bad_index ()); + return 0; // arbitary return value + } - // Assignment - BOOST_UBLAS_INLINE - const_iterator &operator = (const const_iterator &it) { - container_const_reference::assign (&it ()); - return *this; - } + // Assignment + BOOST_UBLAS_INLINE + const_iterator &operator = (const const_iterator &it) { + container_const_reference::assign (&it ()); + return *this; + } - // Comparison - BOOST_UBLAS_INLINE - bool operator == (const const_iterator &it) const { - BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); - detail::ignore_unused_variable_warning(it); - return true; - } - }; + // Comparison + BOOST_UBLAS_INLINE + bool operator == (const const_iterator &it) const { + BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); + detail::ignore_unused_variable_warning(it); + return true; + } + }; - typedef const_iterator iterator; + typedef const_iterator iterator; - BOOST_UBLAS_INLINE - const_iterator begin () const { - return const_iterator (*this); - } - BOOST_UBLAS_INLINE - const_iterator end () const { - return const_iterator (*this); - } + BOOST_UBLAS_INLINE + const_iterator begin () const { + return const_iterator (*this); + } + BOOST_UBLAS_INLINE + const_iterator end () const { + return const_iterator (*this); + } - // Reverse iterator - typedef reverse_iterator_base const_reverse_iterator; + // Reverse iterator + typedef reverse_iterator_base const_reverse_iterator; - BOOST_UBLAS_INLINE - const_reverse_iterator rbegin () const { - return const_reverse_iterator (end ()); - } - BOOST_UBLAS_INLINE - const_reverse_iterator rend () const { - return const_reverse_iterator (begin ()); - } + BOOST_UBLAS_INLINE + const_reverse_iterator rbegin () const { + return const_reverse_iterator (end ()); + } + BOOST_UBLAS_INLINE + const_reverse_iterator rend () const { + return const_reverse_iterator (begin ()); + } - // Serialization - template - void serialize(Archive & ar, const unsigned int /* file_version */){ - serialization::collection_size_type s (size_); - ar & serialization::make_nvp("size",s); - if (Archive::is_loading::value) { - size_ = s; - } - } + // Serialization + template + void serialize(Archive & ar, const unsigned int /* file_version */){ + serialization::collection_size_type s (size_); + ar & serialization::make_nvp("size",s); + if (Archive::is_loading::value) { + size_ = s; + } + } - private: - size_type size_; - typedef const value_type const_value_type; - static const_value_type zero_; - }; + private: + size_type size_; + typedef const value_type const_value_type; + static const_value_type zero_; + }; - template - typename zero_vector::const_value_type zero_vector::zero_ = T(/*zero*/); + template + typename zero_vector::const_value_type zero_vector::zero_ = T(/*zero*/); - // 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 unit_vector: - public vector_container > { + // 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 unit_vector: + public vector_container > { - typedef const T *const_pointer; - typedef unit_vector self_type; - public: + typedef const T *const_pointer; + typedef unit_vector self_type; + public: #ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS - using vector_container::operator (); + using vector_container::operator (); #endif - typedef typename ALLOC::size_type size_type; - typedef typename ALLOC::difference_type difference_type; - typedef T value_type; - typedef const T &const_reference; - typedef T &reference; - typedef const vector_reference const_closure_type; - typedef vector_reference closure_type; - typedef sparse_tag storage_category; + typedef typename ALLOC::size_type size_type; + typedef typename ALLOC::difference_type difference_type; + typedef T value_type; + typedef const T &const_reference; + typedef T &reference; + typedef const vector_reference const_closure_type; + typedef vector_reference closure_type; + typedef sparse_tag storage_category; - // Construction and destruction + // Construction and destruction /// \brief Simple constructor with dimension and index 0 BOOST_UBLAS_INLINE unit_vector (): @@ -1149,928 +1149,928 @@ namespace boost { namespace numeric { namespace ublas { // --------------- /// \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_) - return & one_; - else - return & zero_; - } + BOOST_UBLAS_INLINE + const_pointer find_element (size_type i) const { + if (i == index_) + return & one_; + else + return & zero_; + } - // Element access - BOOST_UBLAS_INLINE - const_reference operator () (size_type i) const { - if (i == index_) - return one_; - else - return zero_; - } + // Element access + BOOST_UBLAS_INLINE + const_reference operator () (size_type i) const { + if (i == index_) + return one_; + else + return zero_; + } - BOOST_UBLAS_INLINE - const_reference operator [] (size_type i) const { - return (*this) (i); - } + BOOST_UBLAS_INLINE + const_reference operator [] (size_type i) const { + return (*this) (i); + } - // Assignment - BOOST_UBLAS_INLINE - unit_vector &operator = (const unit_vector &v) { - size_ = v.size_; - index_ = v.index_; - return *this; - } - BOOST_UBLAS_INLINE - unit_vector &assign_temporary (unit_vector &v) { - swap (v); - return *this; - } + // Assignment + BOOST_UBLAS_INLINE + unit_vector &operator = (const unit_vector &v) { + size_ = v.size_; + index_ = v.index_; + return *this; + } + BOOST_UBLAS_INLINE + unit_vector &assign_temporary (unit_vector &v) { + swap (v); + return *this; + } - // Swapping - BOOST_UBLAS_INLINE - void swap (unit_vector &v) { - if (this != &v) { - std::swap (size_, v.size_); - std::swap (index_, v.index_); - } - } - BOOST_UBLAS_INLINE - friend void swap (unit_vector &v1, unit_vector &v2) { - v1.swap (v2); - } + // Swapping + BOOST_UBLAS_INLINE + void swap (unit_vector &v) { + if (this != &v) { + std::swap (size_, v.size_); + std::swap (index_, v.index_); + } + } + BOOST_UBLAS_INLINE + friend void swap (unit_vector &v1, unit_vector &v2) { + v1.swap (v2); + } - // Iterator types - private: - // Use bool to indicate begin (one_ as value) - typedef bool const_subiterator_type; - public: - class const_iterator; + // Iterator types + private: + // Use bool to indicate begin (one_ as value) + typedef bool const_subiterator_type; + public: + class const_iterator; - // Element lookup - BOOST_UBLAS_INLINE - const_iterator find (size_type i) const { - return const_iterator (*this, i <= index_); - } + // Element lookup + BOOST_UBLAS_INLINE + const_iterator find (size_type i) const { + return const_iterator (*this, i <= index_); + } - class const_iterator: - public container_const_reference, - public bidirectional_iterator_base { - public: - typedef typename unit_vector::difference_type difference_type; - typedef typename unit_vector::value_type value_type; - typedef typename unit_vector::const_reference reference; - typedef typename unit_vector::const_pointer pointer; + class const_iterator: + public container_const_reference, + public bidirectional_iterator_base { + public: + typedef typename unit_vector::difference_type difference_type; + typedef typename unit_vector::value_type value_type; + typedef typename unit_vector::const_reference reference; + typedef typename unit_vector::const_pointer pointer; - // Construction and destruction - BOOST_UBLAS_INLINE - const_iterator (): - container_const_reference (), it_ () {} - BOOST_UBLAS_INLINE - const_iterator (const unit_vector &v, const const_subiterator_type &it): - container_const_reference (v), it_ (it) {} + // Construction and destruction + BOOST_UBLAS_INLINE + const_iterator (): + container_const_reference (), it_ () {} + BOOST_UBLAS_INLINE + const_iterator (const unit_vector &v, const const_subiterator_type &it): + container_const_reference (v), it_ (it) {} - // Arithmetic - BOOST_UBLAS_INLINE - const_iterator &operator ++ () { - BOOST_UBLAS_CHECK (it_, bad_index ()); - it_ = !it_; - return *this; - } - BOOST_UBLAS_INLINE - const_iterator &operator -- () { - BOOST_UBLAS_CHECK (!it_, bad_index ()); - it_ = !it_; - return *this; - } + // Arithmetic + BOOST_UBLAS_INLINE + const_iterator &operator ++ () { + BOOST_UBLAS_CHECK (it_, bad_index ()); + it_ = !it_; + return *this; + } + BOOST_UBLAS_INLINE + const_iterator &operator -- () { + BOOST_UBLAS_CHECK (!it_, bad_index ()); + it_ = !it_; + return *this; + } - // Dereference - BOOST_UBLAS_INLINE - const_reference operator * () const { - BOOST_UBLAS_CHECK (it_, bad_index ()); - return one_; - } + // Dereference + BOOST_UBLAS_INLINE + const_reference operator * () const { + BOOST_UBLAS_CHECK (it_, bad_index ()); + return one_; + } - // Index - BOOST_UBLAS_INLINE - size_type index () const { - BOOST_UBLAS_CHECK (it_, bad_index ()); - return (*this) ().index_; - } + // Index + BOOST_UBLAS_INLINE + size_type index () const { + BOOST_UBLAS_CHECK (it_, bad_index ()); + return (*this) ().index_; + } - // Assignment - BOOST_UBLAS_INLINE - const_iterator &operator = (const const_iterator &it) { - container_const_reference::assign (&it ()); - it_ = it.it_; - return *this; - } + // Assignment + BOOST_UBLAS_INLINE + const_iterator &operator = (const const_iterator &it) { + container_const_reference::assign (&it ()); + it_ = it.it_; + return *this; + } - // Comparison - BOOST_UBLAS_INLINE - bool operator == (const const_iterator &it) const { - BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); - return it_ == it.it_; - } + // Comparison + BOOST_UBLAS_INLINE + bool operator == (const const_iterator &it) const { + BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); + return it_ == it.it_; + } - private: - const_subiterator_type it_; - }; + private: + const_subiterator_type it_; + }; - typedef const_iterator iterator; + typedef const_iterator iterator; - BOOST_UBLAS_INLINE - const_iterator begin () const { - return const_iterator (*this, true); - } - BOOST_UBLAS_INLINE - const_iterator end () const { - return const_iterator (*this, false); - } + BOOST_UBLAS_INLINE + const_iterator begin () const { + return const_iterator (*this, true); + } + BOOST_UBLAS_INLINE + const_iterator end () const { + return const_iterator (*this, false); + } - // Reverse iterator - typedef reverse_iterator_base const_reverse_iterator; + // Reverse iterator + typedef reverse_iterator_base const_reverse_iterator; - BOOST_UBLAS_INLINE - const_reverse_iterator rbegin () const { - return const_reverse_iterator (end ()); - } - BOOST_UBLAS_INLINE - const_reverse_iterator rend () const { - return const_reverse_iterator (begin ()); - } + BOOST_UBLAS_INLINE + const_reverse_iterator rbegin () const { + return const_reverse_iterator (end ()); + } + BOOST_UBLAS_INLINE + const_reverse_iterator rend () const { + return const_reverse_iterator (begin ()); + } - // Serialization - template - void serialize(Archive & ar, const unsigned int /* file_version */){ - serialization::collection_size_type s (size_); - ar & serialization::make_nvp("size",s); - if (Archive::is_loading::value) { - size_ = s; - } - ar & serialization::make_nvp("index", index_); - } + // Serialization + template + void serialize(Archive & ar, const unsigned int /* file_version */){ + serialization::collection_size_type s (size_); + ar & serialization::make_nvp("size",s); + if (Archive::is_loading::value) { + size_ = s; + } + ar & serialization::make_nvp("index", index_); + } - private: - size_type size_; - size_type index_; - typedef const value_type const_value_type; - static const_value_type zero_; - static const_value_type one_; - }; + private: + size_type size_; + size_type index_; + typedef const value_type const_value_type; + static const_value_type zero_; + static const_value_type one_; + }; - template - typename unit_vector::const_value_type unit_vector::zero_ = T(/*zero*/); - template - typename unit_vector::const_value_type unit_vector::one_ (1); // ISSUE: need 'one'-traits here + template + typename unit_vector::const_value_type unit_vector::zero_ = T(/*zero*/); + template + typename unit_vector::const_value_type unit_vector::one_ (1); // ISSUE: need 'one'-traits here - /// \brief A scalar (i.e. unique value) vector of type \c T and a given \c size - /// A scalar (i.e. unique value) vector of type \c T and a given \c size. This is a virtual vector in the sense that no memory is allocated - /// for storing the unique value more than once: it still acts like any other vector. However assigning a new value will change all the value at once. - /// vector into a normal vector. It must first be assigned to another normal vector by any suitable means. Its memory footprint is constant. - /// \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 like boost::interval. - template - class scalar_vector: - public vector_container > { + /// \brief A scalar (i.e. unique value) vector of type \c T and a given \c size + /// A scalar (i.e. unique value) vector of type \c T and a given \c size. This is a virtual vector in the sense that no memory is allocated + /// for storing the unique value more than once: it still acts like any other vector. However assigning a new value will change all the value at once. + /// vector into a normal vector. It must first be assigned to another normal vector by any suitable means. Its memory footprint is constant. + /// \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 like boost::interval. + template + class scalar_vector: + public vector_container > { - typedef const T *const_pointer; - typedef scalar_vector self_type; - public: + typedef const T *const_pointer; + typedef scalar_vector self_type; + public: #ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS - using vector_container::operator (); + using vector_container::operator (); #endif - typedef typename ALLOC::size_type size_type; - typedef typename ALLOC::difference_type difference_type; - typedef T value_type; - typedef const T &const_reference; - typedef T &reference; - typedef const vector_reference const_closure_type; - typedef vector_reference closure_type; - typedef dense_tag storage_category; + typedef typename ALLOC::size_type size_type; + typedef typename ALLOC::difference_type difference_type; + typedef T value_type; + typedef const T &const_reference; + typedef T &reference; + typedef const vector_reference const_closure_type; + typedef vector_reference closure_type; + typedef dense_tag storage_category; - // Construction and destruction - BOOST_UBLAS_INLINE - scalar_vector (): - vector_container (), - size_ (0), value_ () {} - BOOST_UBLAS_INLINE - explicit scalar_vector (size_type size, const value_type &value = value_type(1)): - vector_container (), - size_ (size), value_ (value) {} - BOOST_UBLAS_INLINE - scalar_vector (const scalar_vector &v): - vector_container (), - size_ (v.size_), value_ (v.value_) {} + // Construction and destruction + BOOST_UBLAS_INLINE + scalar_vector (): + vector_container (), + size_ (0), value_ () {} + BOOST_UBLAS_INLINE + explicit scalar_vector (size_type size, const value_type &value = value_type(1)): + vector_container (), + size_ (size), value_ (value) {} + BOOST_UBLAS_INLINE + scalar_vector (const scalar_vector &v): + vector_container (), + size_ (v.size_), value_ (v.value_) {} - // Accessors - BOOST_UBLAS_INLINE - size_type size () const { - return size_; - } + // Accessors + BOOST_UBLAS_INLINE + size_type size () const { + return size_; + } - // Resizing - BOOST_UBLAS_INLINE - void resize (size_type size, bool /*preserve*/ = true) { - size_ = size; - } + // Resizing + BOOST_UBLAS_INLINE + void resize (size_type size, bool /*preserve*/ = true) { + size_ = size; + } - // Element support - BOOST_UBLAS_INLINE - const_pointer find_element (size_type /*i*/) const { - return & value_; - } + // Element support + BOOST_UBLAS_INLINE + const_pointer find_element (size_type /*i*/) const { + return & value_; + } - // Element access - BOOST_UBLAS_INLINE - const_reference operator () (size_type /*i*/) const { - return value_; - } + // Element access + BOOST_UBLAS_INLINE + const_reference operator () (size_type /*i*/) const { + return value_; + } - BOOST_UBLAS_INLINE - const_reference operator [] (size_type /*i*/) const { - return value_; - } + BOOST_UBLAS_INLINE + const_reference operator [] (size_type /*i*/) const { + return value_; + } - // Assignment - BOOST_UBLAS_INLINE - scalar_vector &operator = (const scalar_vector &v) { - size_ = v.size_; - value_ = v.value_; - return *this; - } - BOOST_UBLAS_INLINE - scalar_vector &assign_temporary (scalar_vector &v) { - swap (v); - return *this; - } + // Assignment + BOOST_UBLAS_INLINE + scalar_vector &operator = (const scalar_vector &v) { + size_ = v.size_; + value_ = v.value_; + return *this; + } + BOOST_UBLAS_INLINE + scalar_vector &assign_temporary (scalar_vector &v) { + swap (v); + return *this; + } - // Swapping - BOOST_UBLAS_INLINE - void swap (scalar_vector &v) { - if (this != &v) { - std::swap (size_, v.size_); - std::swap (value_, v.value_); - } - } - BOOST_UBLAS_INLINE - friend void swap (scalar_vector &v1, scalar_vector &v2) { - v1.swap (v2); - } + // Swapping + BOOST_UBLAS_INLINE + void swap (scalar_vector &v) { + if (this != &v) { + std::swap (size_, v.size_); + std::swap (value_, v.value_); + } + } + BOOST_UBLAS_INLINE + friend void swap (scalar_vector &v1, scalar_vector &v2) { + v1.swap (v2); + } - // Iterator types - private: - // Use an index - typedef size_type const_subiterator_type; + // Iterator types + private: + // Use an index + typedef size_type const_subiterator_type; - public: + public: #ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR - typedef indexed_const_iterator iterator; - typedef indexed_const_iterator const_iterator; + typedef indexed_const_iterator iterator; + typedef indexed_const_iterator const_iterator; #else - class const_iterator; + class const_iterator; #endif - // Element lookup - BOOST_UBLAS_INLINE - const_iterator find (size_type i) const { - return const_iterator (*this, i); - } + // Element lookup + BOOST_UBLAS_INLINE + const_iterator find (size_type i) const { + return const_iterator (*this, i); + } #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR - class const_iterator: - public container_const_reference, - public random_access_iterator_base { - public: - typedef typename scalar_vector::difference_type difference_type; - typedef typename scalar_vector::value_type value_type; - typedef typename scalar_vector::const_reference reference; - typedef typename scalar_vector::const_pointer pointer; + class const_iterator: + public container_const_reference, + public random_access_iterator_base { + public: + typedef typename scalar_vector::difference_type difference_type; + typedef typename scalar_vector::value_type value_type; + typedef typename scalar_vector::const_reference reference; + typedef typename scalar_vector::const_pointer pointer; - // Construction and destruction - BOOST_UBLAS_INLINE - const_iterator (): - container_const_reference (), it_ () {} - BOOST_UBLAS_INLINE - const_iterator (const scalar_vector &v, const const_subiterator_type &it): - container_const_reference (v), it_ (it) {} + // Construction and destruction + BOOST_UBLAS_INLINE + const_iterator (): + container_const_reference (), it_ () {} + BOOST_UBLAS_INLINE + const_iterator (const scalar_vector &v, const const_subiterator_type &it): + container_const_reference (v), it_ (it) {} - // Arithmetic - BOOST_UBLAS_INLINE - const_iterator &operator ++ () { - ++ it_; - return *this; - } - BOOST_UBLAS_INLINE - const_iterator &operator -- () { - -- it_; - return *this; - } - BOOST_UBLAS_INLINE - const_iterator &operator += (difference_type n) { - it_ += n; - return *this; - } - BOOST_UBLAS_INLINE - const_iterator &operator -= (difference_type n) { - it_ -= n; - return *this; - } - BOOST_UBLAS_INLINE - difference_type operator - (const const_iterator &it) const { - BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); - return it_ - it.it_; - } + // Arithmetic + BOOST_UBLAS_INLINE + const_iterator &operator ++ () { + ++ it_; + return *this; + } + BOOST_UBLAS_INLINE + const_iterator &operator -- () { + -- it_; + return *this; + } + BOOST_UBLAS_INLINE + const_iterator &operator += (difference_type n) { + it_ += n; + return *this; + } + BOOST_UBLAS_INLINE + const_iterator &operator -= (difference_type n) { + it_ -= n; + return *this; + } + BOOST_UBLAS_INLINE + difference_type operator - (const const_iterator &it) const { + BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); + return it_ - it.it_; + } - // Dereference - BOOST_UBLAS_INLINE - const_reference operator * () const { - BOOST_UBLAS_CHECK (it_ < (*this) ().size (), bad_index ()); - return (*this) () (index ()); - } - BOOST_UBLAS_INLINE - const_reference operator [] (difference_type n) const { - return *(*this + n); - } + // Dereference + BOOST_UBLAS_INLINE + const_reference operator * () const { + BOOST_UBLAS_CHECK (it_ < (*this) ().size (), bad_index ()); + return (*this) () (index ()); + } + BOOST_UBLAS_INLINE + const_reference operator [] (difference_type n) const { + return *(*this + n); + } - // Index - BOOST_UBLAS_INLINE - size_type index () const { - BOOST_UBLAS_CHECK (it_ < (*this) ().size (), bad_index ()); - return it_; - } + // Index + BOOST_UBLAS_INLINE + size_type index () const { + BOOST_UBLAS_CHECK (it_ < (*this) ().size (), bad_index ()); + return it_; + } - // Assignment - BOOST_UBLAS_INLINE - const_iterator &operator = (const const_iterator &it) { - container_const_reference::assign (&it ()); - it_ = it.it_; - return *this; - } + // Assignment + BOOST_UBLAS_INLINE + const_iterator &operator = (const const_iterator &it) { + container_const_reference::assign (&it ()); + it_ = it.it_; + return *this; + } - // Comparison - BOOST_UBLAS_INLINE - bool operator == (const const_iterator &it) const { - BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); - return it_ == it.it_; - } - BOOST_UBLAS_INLINE - bool operator < (const const_iterator &it) const { - BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); - return it_ < it.it_; - } + // Comparison + BOOST_UBLAS_INLINE + bool operator == (const const_iterator &it) const { + BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); + return it_ == it.it_; + } + BOOST_UBLAS_INLINE + bool operator < (const const_iterator &it) const { + BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); + return it_ < it.it_; + } - private: - const_subiterator_type it_; - }; + private: + const_subiterator_type it_; + }; - typedef const_iterator iterator; + typedef const_iterator iterator; #endif - BOOST_UBLAS_INLINE - const_iterator begin () const { - return find (0); - } - BOOST_UBLAS_INLINE - const_iterator end () const { - return find (size_); - } + BOOST_UBLAS_INLINE + const_iterator begin () const { + return find (0); + } + BOOST_UBLAS_INLINE + const_iterator end () const { + return find (size_); + } - // Reverse iterator - typedef reverse_iterator_base const_reverse_iterator; + // Reverse iterator + typedef reverse_iterator_base const_reverse_iterator; - BOOST_UBLAS_INLINE - const_reverse_iterator rbegin () const { - return const_reverse_iterator (end ()); - } - BOOST_UBLAS_INLINE - const_reverse_iterator rend () const { - return const_reverse_iterator (begin ()); - } + BOOST_UBLAS_INLINE + const_reverse_iterator rbegin () const { + return const_reverse_iterator (end ()); + } + BOOST_UBLAS_INLINE + const_reverse_iterator rend () const { + return const_reverse_iterator (begin ()); + } - // Serialization - template - void serialize(Archive & ar, const unsigned int /* file_version */){ - serialization::collection_size_type s (size_); - ar & serialization::make_nvp("size",s); - if (Archive::is_loading::value) { - size_ = s; - } - ar & serialization::make_nvp("value", value_); - } + // Serialization + template + void serialize(Archive & ar, const unsigned int /* file_version */){ + serialization::collection_size_type s (size_); + ar & serialization::make_nvp("size",s); + if (Archive::is_loading::value) { + size_ = s; + } + ar & serialization::make_nvp("value", value_); + } - private: - size_type size_; - value_type value_; - }; + private: + size_type size_; + value_type value_; + }; - // ------------------------ - // Array based vector class - // ------------------------ + // ------------------------ + // Array based vector class + // ------------------------ - /// \brief A dense vector of values of type \c T with the given \c size. The data is stored as an ordinary C++ array \c T \c data_[M] - template - class c_vector: - public vector_container > { + /// \brief A dense vector of values of type \c T with the given \c size. The data is stored as an ordinary C++ array \c T \c data_[M] + template + class c_vector: + public vector_container > { - typedef c_vector self_type; - public: + typedef c_vector self_type; + public: #ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS - using vector_container::operator (); + using vector_container::operator (); #endif - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; - typedef T value_type; - typedef const T &const_reference; - typedef T &reference; - typedef value_type array_type[N]; - typedef T *pointer; - typedef const T *const_pointer; - typedef const vector_reference const_closure_type; - typedef vector_reference closure_type; - typedef self_type vector_temporary_type; - typedef dense_tag storage_category; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + typedef T value_type; + typedef const T &const_reference; + typedef T &reference; + typedef value_type array_type[N]; + typedef T *pointer; + typedef const T *const_pointer; + typedef const vector_reference const_closure_type; + typedef vector_reference closure_type; + typedef self_type vector_temporary_type; + typedef dense_tag storage_category; - // Construction and destruction - BOOST_UBLAS_INLINE - c_vector (): - size_ (N) /* , data_ () */ {} - explicit BOOST_UBLAS_INLINE - c_vector (size_type size): - size_ (size) /* , data_ () */ { - if (size_ > N) - bad_size ().raise (); - } - BOOST_UBLAS_INLINE - c_vector (const c_vector &v): - size_ (v.size_) /* , data_ () */ { - if (size_ > N) - bad_size ().raise (); - assign(v); - } - template - BOOST_UBLAS_INLINE - c_vector (const vector_expression &ae): - size_ (ae ().size ()) /* , data_ () */ { - if (size_ > N) - bad_size ().raise (); - vector_assign (*this, ae); - } + // Construction and destruction + BOOST_UBLAS_INLINE + c_vector (): + size_ (N) /* , data_ () */ {} + explicit BOOST_UBLAS_INLINE + c_vector (size_type size): + size_ (size) /* , data_ () */ { + if (size_ > N) + bad_size ().raise (); + } + BOOST_UBLAS_INLINE + c_vector (const c_vector &v): + size_ (v.size_) /* , data_ () */ { + if (size_ > N) + bad_size ().raise (); + assign(v); + } + template + BOOST_UBLAS_INLINE + c_vector (const vector_expression &ae): + size_ (ae ().size ()) /* , data_ () */ { + if (size_ > N) + bad_size ().raise (); + vector_assign (*this, ae); + } - // Accessors - BOOST_UBLAS_INLINE - size_type size () const { - return size_; - } - BOOST_UBLAS_INLINE - const_pointer data () const { - return data_; - } - BOOST_UBLAS_INLINE - pointer data () { - return data_; - } + // Accessors + BOOST_UBLAS_INLINE + size_type size () const { + return size_; + } + BOOST_UBLAS_INLINE + const_pointer data () const { + return data_; + } + BOOST_UBLAS_INLINE + pointer data () { + return data_; + } - // Resizing - BOOST_UBLAS_INLINE - void resize (size_type size, bool preserve = true) { - if (size > N) - bad_size ().raise (); - size_ = size; - } + // Resizing + BOOST_UBLAS_INLINE + void resize (size_type size, bool preserve = true) { + if (size > N) + bad_size ().raise (); + size_ = size; + } - // Element support - BOOST_UBLAS_INLINE - pointer find_element (size_type i) { - return const_cast (const_cast(*this).find_element (i)); - } - BOOST_UBLAS_INLINE - const_pointer find_element (size_type i) const { - return & data_ [i]; - } + // Element support + BOOST_UBLAS_INLINE + pointer find_element (size_type i) { + return const_cast (const_cast(*this).find_element (i)); + } + BOOST_UBLAS_INLINE + const_pointer find_element (size_type i) const { + return & data_ [i]; + } - // Element access - BOOST_UBLAS_INLINE - const_reference operator () (size_type i) const { - BOOST_UBLAS_CHECK (i < size_, bad_index ()); - return data_ [i]; - } - BOOST_UBLAS_INLINE - reference operator () (size_type i) { - BOOST_UBLAS_CHECK (i < size_, bad_index ()); - return data_ [i]; - } + // Element access + BOOST_UBLAS_INLINE + const_reference operator () (size_type i) const { + BOOST_UBLAS_CHECK (i < size_, bad_index ()); + return data_ [i]; + } + BOOST_UBLAS_INLINE + reference operator () (size_type i) { + BOOST_UBLAS_CHECK (i < size_, bad_index ()); + return data_ [i]; + } - BOOST_UBLAS_INLINE - const_reference operator [] (size_type i) const { - return (*this) (i); - } - BOOST_UBLAS_INLINE - reference operator [] (size_type i) { - return (*this) (i); - } + BOOST_UBLAS_INLINE + const_reference operator [] (size_type i) const { + return (*this) (i); + } + BOOST_UBLAS_INLINE + reference operator [] (size_type i) { + return (*this) (i); + } - // Element assignment - BOOST_UBLAS_INLINE - reference insert_element (size_type i, const_reference t) { - BOOST_UBLAS_CHECK (i < size_, bad_index ()); - return (data_ [i] = t); - } - BOOST_UBLAS_INLINE - void erase_element (size_type i) { - BOOST_UBLAS_CHECK (i < size_, bad_index ()); - data_ [i] = value_type/*zero*/(); - } - - // Zeroing - BOOST_UBLAS_INLINE - void clear () { - std::fill (data_, data_ + size_, value_type/*zero*/()); - } + // Element assignment + BOOST_UBLAS_INLINE + reference insert_element (size_type i, const_reference t) { + BOOST_UBLAS_CHECK (i < size_, bad_index ()); + return (data_ [i] = t); + } + BOOST_UBLAS_INLINE + void erase_element (size_type i) { + BOOST_UBLAS_CHECK (i < size_, bad_index ()); + data_ [i] = value_type/*zero*/(); + } + + // Zeroing + BOOST_UBLAS_INLINE + void clear () { + std::fill (data_, data_ + size_, value_type/*zero*/()); + } - // Assignment + // Assignment #ifdef BOOST_UBLAS_MOVE_SEMANTICS - /*! @note "pass by value" the key idea to enable move semantics */ - BOOST_UBLAS_INLINE - c_vector &operator = (c_vector v) { - assign_temporary(v); - return *this; - } + /*! @note "pass by value" the key idea to enable move semantics */ + BOOST_UBLAS_INLINE + c_vector &operator = (c_vector v) { + assign_temporary(v); + return *this; + } #else - BOOST_UBLAS_INLINE - c_vector &operator = (const c_vector &v) { - size_ = v.size_; - std::copy (v.data_, v.data_ + v.size_, data_); - return *this; - } + BOOST_UBLAS_INLINE + c_vector &operator = (const c_vector &v) { + size_ = v.size_; + std::copy (v.data_, v.data_ + v.size_, data_); + return *this; + } #endif - template // Container assignment without temporary - BOOST_UBLAS_INLINE - c_vector &operator = (const vector_container &v) { - resize (v ().size (), false); - assign (v); - return *this; - } - BOOST_UBLAS_INLINE - c_vector &assign_temporary (c_vector &v) { - swap (v); - return *this; - } - template - BOOST_UBLAS_INLINE - c_vector &operator = (const vector_expression &ae) { - self_type temporary (ae); - return assign_temporary (temporary); - } - template - BOOST_UBLAS_INLINE - c_vector &assign (const vector_expression &ae) { - vector_assign (*this, ae); - return *this; - } + template // Container assignment without temporary + BOOST_UBLAS_INLINE + c_vector &operator = (const vector_container &v) { + resize (v ().size (), false); + assign (v); + return *this; + } + BOOST_UBLAS_INLINE + c_vector &assign_temporary (c_vector &v) { + swap (v); + return *this; + } + template + BOOST_UBLAS_INLINE + c_vector &operator = (const vector_expression &ae) { + self_type temporary (ae); + return assign_temporary (temporary); + } + template + BOOST_UBLAS_INLINE + c_vector &assign (const vector_expression &ae) { + vector_assign (*this, ae); + return *this; + } - // Computed assignment - template - BOOST_UBLAS_INLINE - c_vector &operator += (const vector_expression &ae) { - self_type temporary (*this + ae); - return assign_temporary (temporary); - } - template // Container assignment without temporary - BOOST_UBLAS_INLINE - c_vector &operator += (const vector_container &v) { - plus_assign (v); - return *this; - } - template - BOOST_UBLAS_INLINE - c_vector &plus_assign (const vector_expression &ae) { - vector_assign ( *this, ae); - return *this; - } - template - BOOST_UBLAS_INLINE - c_vector &operator -= (const vector_expression &ae) { - self_type temporary (*this - ae); - return assign_temporary (temporary); - } - template // Container assignment without temporary - BOOST_UBLAS_INLINE - c_vector &operator -= (const vector_container &v) { - minus_assign (v); - return *this; - } - template - BOOST_UBLAS_INLINE - c_vector &minus_assign (const vector_expression &ae) { - vector_assign (*this, ae); - return *this; - } - template - BOOST_UBLAS_INLINE - c_vector &operator *= (const AT &at) { - vector_assign_scalar (*this, at); - return *this; - } - template - BOOST_UBLAS_INLINE - c_vector &operator /= (const AT &at) { - vector_assign_scalar (*this, at); - return *this; - } + // Computed assignment + template + BOOST_UBLAS_INLINE + c_vector &operator += (const vector_expression &ae) { + self_type temporary (*this + ae); + return assign_temporary (temporary); + } + template // Container assignment without temporary + BOOST_UBLAS_INLINE + c_vector &operator += (const vector_container &v) { + plus_assign (v); + return *this; + } + template + BOOST_UBLAS_INLINE + c_vector &plus_assign (const vector_expression &ae) { + vector_assign ( *this, ae); + return *this; + } + template + BOOST_UBLAS_INLINE + c_vector &operator -= (const vector_expression &ae) { + self_type temporary (*this - ae); + return assign_temporary (temporary); + } + template // Container assignment without temporary + BOOST_UBLAS_INLINE + c_vector &operator -= (const vector_container &v) { + minus_assign (v); + return *this; + } + template + BOOST_UBLAS_INLINE + c_vector &minus_assign (const vector_expression &ae) { + vector_assign (*this, ae); + return *this; + } + template + BOOST_UBLAS_INLINE + c_vector &operator *= (const AT &at) { + vector_assign_scalar (*this, at); + return *this; + } + template + BOOST_UBLAS_INLINE + c_vector &operator /= (const AT &at) { + vector_assign_scalar (*this, at); + return *this; + } - // Swapping - BOOST_UBLAS_INLINE - void swap (c_vector &v) { - if (this != &v) { - BOOST_UBLAS_CHECK (size_ == v.size_, bad_size ()); - std::swap (size_, v.size_); - std::swap_ranges (data_, data_ + size_, v.data_); - } - } - BOOST_UBLAS_INLINE - friend void swap (c_vector &v1, c_vector &v2) { - v1.swap (v2); - } + // Swapping + BOOST_UBLAS_INLINE + void swap (c_vector &v) { + if (this != &v) { + BOOST_UBLAS_CHECK (size_ == v.size_, bad_size ()); + std::swap (size_, v.size_); + std::swap_ranges (data_, data_ + size_, v.data_); + } + } + BOOST_UBLAS_INLINE + friend void swap (c_vector &v1, c_vector &v2) { + v1.swap (v2); + } - // Iterator types - private: - // Use pointers for iterator - typedef const_pointer const_subiterator_type; - typedef pointer subiterator_type; + // Iterator types + private: + // Use pointers for iterator + typedef const_pointer const_subiterator_type; + typedef pointer subiterator_type; - public: + public: #ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR - typedef indexed_iterator iterator; - typedef indexed_const_iterator const_iterator; + typedef indexed_iterator iterator; + typedef indexed_const_iterator const_iterator; #else - class const_iterator; - class iterator; + class const_iterator; + class iterator; #endif - // Element lookup - BOOST_UBLAS_INLINE - const_iterator find (size_type i) const { + // Element lookup + BOOST_UBLAS_INLINE + const_iterator find (size_type i) const { #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR - return const_iterator (*this, &data_ [i]); + return const_iterator (*this, &data_ [i]); #else - return const_iterator (*this, i); + return const_iterator (*this, i); #endif - } - BOOST_UBLAS_INLINE - iterator find (size_type i) { + } + BOOST_UBLAS_INLINE + iterator find (size_type i) { #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR - return iterator (*this, &data_ [i]); + return iterator (*this, &data_ [i]); #else - return iterator (*this, i); + return iterator (*this, i); #endif - } + } #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR - class const_iterator: - public container_const_reference, - public random_access_iterator_base { - public: - typedef typename c_vector::difference_type difference_type; - typedef typename c_vector::value_type value_type; - typedef typename c_vector::const_reference reference; - typedef typename c_vector::const_pointer pointer; + class const_iterator: + public container_const_reference, + public random_access_iterator_base { + public: + typedef typename c_vector::difference_type difference_type; + typedef typename c_vector::value_type value_type; + typedef typename c_vector::const_reference reference; + typedef typename c_vector::const_pointer pointer; - // Construction and destruction - BOOST_UBLAS_INLINE - const_iterator (): - container_const_reference (), it_ () {} - BOOST_UBLAS_INLINE - const_iterator (const self_type &v, const const_subiterator_type &it): - container_const_reference (v), it_ (it) {} - BOOST_UBLAS_INLINE - const_iterator (const typename self_type::iterator &it): // ISSUE self_type:: stops VC8 using std::iterator here - container_const_reference (it ()), it_ (it.it_) {} + // Construction and destruction + BOOST_UBLAS_INLINE + const_iterator (): + container_const_reference (), it_ () {} + BOOST_UBLAS_INLINE + const_iterator (const self_type &v, const const_subiterator_type &it): + container_const_reference (v), it_ (it) {} + BOOST_UBLAS_INLINE + const_iterator (const typename self_type::iterator &it): // ISSUE self_type:: stops VC8 using std::iterator here + container_const_reference (it ()), it_ (it.it_) {} - // Arithmetic - BOOST_UBLAS_INLINE - const_iterator &operator ++ () { - ++ it_; - return *this; - } - BOOST_UBLAS_INLINE - const_iterator &operator -- () { - -- it_; - return *this; - } - BOOST_UBLAS_INLINE - const_iterator &operator += (difference_type n) { - it_ += n; - return *this; - } - BOOST_UBLAS_INLINE - const_iterator &operator -= (difference_type n) { - it_ -= n; - return *this; - } - BOOST_UBLAS_INLINE - difference_type operator - (const const_iterator &it) const { - BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); - return it_ - it.it_; - } + // Arithmetic + BOOST_UBLAS_INLINE + const_iterator &operator ++ () { + ++ it_; + return *this; + } + BOOST_UBLAS_INLINE + const_iterator &operator -- () { + -- it_; + return *this; + } + BOOST_UBLAS_INLINE + const_iterator &operator += (difference_type n) { + it_ += n; + return *this; + } + BOOST_UBLAS_INLINE + const_iterator &operator -= (difference_type n) { + it_ -= n; + return *this; + } + BOOST_UBLAS_INLINE + difference_type operator - (const const_iterator &it) const { + BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); + return it_ - it.it_; + } - // Dereference - BOOST_UBLAS_INLINE - const_reference operator * () const { - BOOST_UBLAS_CHECK (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_, bad_index ()); - return *it_; - } - BOOST_UBLAS_INLINE - const_reference operator [] (difference_type n) const { - return *(it_ + n); - } + // Dereference + BOOST_UBLAS_INLINE + const_reference operator * () const { + BOOST_UBLAS_CHECK (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_, bad_index ()); + return *it_; + } + BOOST_UBLAS_INLINE + const_reference operator [] (difference_type n) const { + return *(it_ + n); + } - // Index - BOOST_UBLAS_INLINE - size_type index () const { - BOOST_UBLAS_CHECK (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_, bad_index ()); - const self_type &v = (*this) (); - return it_ - v.begin ().it_; - } + // Index + BOOST_UBLAS_INLINE + size_type index () const { + BOOST_UBLAS_CHECK (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_, bad_index ()); + const self_type &v = (*this) (); + return it_ - v.begin ().it_; + } - // Assignment - BOOST_UBLAS_INLINE - const_iterator &operator = (const const_iterator &it) { - container_const_reference::assign (&it ()); - it_ = it.it_; - return *this; - } + // Assignment + BOOST_UBLAS_INLINE + const_iterator &operator = (const const_iterator &it) { + container_const_reference::assign (&it ()); + it_ = it.it_; + return *this; + } - // Comparison - BOOST_UBLAS_INLINE - bool operator == (const const_iterator &it) const { - BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); - return it_ == it.it_; - } - BOOST_UBLAS_INLINE - bool operator < (const const_iterator &it) const { - BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); - return it_ < it.it_; - } + // Comparison + BOOST_UBLAS_INLINE + bool operator == (const const_iterator &it) const { + BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); + return it_ == it.it_; + } + BOOST_UBLAS_INLINE + bool operator < (const const_iterator &it) const { + BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); + return it_ < it.it_; + } - private: - const_subiterator_type it_; + private: + const_subiterator_type it_; - friend class iterator; - }; + friend class iterator; + }; #endif - BOOST_UBLAS_INLINE - const_iterator begin () const { - return find (0); - } - BOOST_UBLAS_INLINE - const_iterator end () const { - return find (size_); - } + BOOST_UBLAS_INLINE + const_iterator begin () const { + return find (0); + } + BOOST_UBLAS_INLINE + const_iterator end () const { + return find (size_); + } #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR - class iterator: - public container_reference, - public random_access_iterator_base { - public: - typedef typename c_vector::difference_type difference_type; - typedef typename c_vector::value_type value_type; - typedef typename c_vector::reference reference; - typedef typename c_vector::pointer pointer; + class iterator: + public container_reference, + public random_access_iterator_base { + public: + typedef typename c_vector::difference_type difference_type; + typedef typename c_vector::value_type value_type; + typedef typename c_vector::reference reference; + typedef typename c_vector::pointer pointer; - // Construction and destruction - BOOST_UBLAS_INLINE - iterator (): - container_reference (), it_ () {} - BOOST_UBLAS_INLINE - iterator (self_type &v, const subiterator_type &it): - container_reference (v), it_ (it) {} + // Construction and destruction + BOOST_UBLAS_INLINE + iterator (): + container_reference (), it_ () {} + BOOST_UBLAS_INLINE + iterator (self_type &v, const subiterator_type &it): + container_reference (v), it_ (it) {} - // Arithmetic - BOOST_UBLAS_INLINE - iterator &operator ++ () { - ++ it_; - return *this; - } - BOOST_UBLAS_INLINE - iterator &operator -- () { - -- it_; - return *this; - } - BOOST_UBLAS_INLINE - iterator &operator += (difference_type n) { - it_ += n; - return *this; - } - BOOST_UBLAS_INLINE - iterator &operator -= (difference_type n) { - it_ -= n; - return *this; - } - BOOST_UBLAS_INLINE - difference_type operator - (const iterator &it) const { - BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); - return it_ - it.it_; - } + // Arithmetic + BOOST_UBLAS_INLINE + iterator &operator ++ () { + ++ it_; + return *this; + } + BOOST_UBLAS_INLINE + iterator &operator -- () { + -- it_; + return *this; + } + BOOST_UBLAS_INLINE + iterator &operator += (difference_type n) { + it_ += n; + return *this; + } + BOOST_UBLAS_INLINE + iterator &operator -= (difference_type n) { + it_ -= n; + return *this; + } + BOOST_UBLAS_INLINE + difference_type operator - (const iterator &it) const { + BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); + return it_ - it.it_; + } - // Dereference - BOOST_UBLAS_INLINE - reference operator * () const { - BOOST_UBLAS_CHECK (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_, bad_index ()); - return *it_; - } - BOOST_UBLAS_INLINE - reference operator [] (difference_type n) const { - return *(it_ + n); - } + // Dereference + BOOST_UBLAS_INLINE + reference operator * () const { + BOOST_UBLAS_CHECK (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_, bad_index ()); + return *it_; + } + BOOST_UBLAS_INLINE + reference operator [] (difference_type n) const { + return *(it_ + n); + } - // Index - BOOST_UBLAS_INLINE - size_type index () const { - BOOST_UBLAS_CHECK (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_, bad_index ()); - // EDG won't allow const self_type it doesn't allow friend access to it_ - self_type &v = (*this) (); - return it_ - v.begin ().it_; - } + // Index + BOOST_UBLAS_INLINE + size_type index () const { + BOOST_UBLAS_CHECK (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_, bad_index ()); + // EDG won't allow const self_type it doesn't allow friend access to it_ + self_type &v = (*this) (); + return it_ - v.begin ().it_; + } - // Assignment - BOOST_UBLAS_INLINE - iterator &operator = (const iterator &it) { - container_reference::assign (&it ()); - it_ = it.it_; - return *this; - } + // Assignment + BOOST_UBLAS_INLINE + iterator &operator = (const iterator &it) { + container_reference::assign (&it ()); + it_ = it.it_; + return *this; + } - // Comparison - BOOST_UBLAS_INLINE - bool operator == (const iterator &it) const { - BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); - return it_ == it.it_; - } - BOOST_UBLAS_INLINE - bool operator < (const iterator &it) const { - BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); - return it_ < it.it_; - } + // Comparison + BOOST_UBLAS_INLINE + bool operator == (const iterator &it) const { + BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); + return it_ == it.it_; + } + BOOST_UBLAS_INLINE + bool operator < (const iterator &it) const { + BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ()); + return it_ < it.it_; + } - private: - subiterator_type it_; + private: + subiterator_type it_; - friend class const_iterator; - }; + friend class const_iterator; + }; #endif - BOOST_UBLAS_INLINE - iterator begin () { - return find (0); - } - BOOST_UBLAS_INLINE - iterator end () { - return find (size_); - } + BOOST_UBLAS_INLINE + iterator begin () { + return find (0); + } + BOOST_UBLAS_INLINE + iterator end () { + return find (size_); + } - // Reverse iterator - typedef reverse_iterator_base const_reverse_iterator; - typedef reverse_iterator_base reverse_iterator; + // Reverse iterator + typedef reverse_iterator_base const_reverse_iterator; + typedef reverse_iterator_base reverse_iterator; - BOOST_UBLAS_INLINE - const_reverse_iterator rbegin () const { - return const_reverse_iterator (end ()); - } - BOOST_UBLAS_INLINE - const_reverse_iterator rend () const { - return const_reverse_iterator (begin ()); - } - BOOST_UBLAS_INLINE - reverse_iterator rbegin () { - return reverse_iterator (end ()); - } - BOOST_UBLAS_INLINE - reverse_iterator rend () { - return reverse_iterator (begin ()); - } + BOOST_UBLAS_INLINE + const_reverse_iterator rbegin () const { + return const_reverse_iterator (end ()); + } + BOOST_UBLAS_INLINE + const_reverse_iterator rend () const { + return const_reverse_iterator (begin ()); + } + BOOST_UBLAS_INLINE + reverse_iterator rbegin () { + return reverse_iterator (end ()); + } + BOOST_UBLAS_INLINE + reverse_iterator rend () { + return reverse_iterator (begin ()); + } - // Serialization - template - void serialize(Archive & ar, const unsigned int /* file_version */){ - serialization::collection_size_type s (size_); - ar & serialization::make_nvp("size",s); - - // copy the value back if loading - if (Archive::is_loading::value) { - if (s > N) bad_size("too large size in bounded_vector::load()\n").raise(); - size_ = s; - } - // ISSUE: this writes the full array - ar & serialization::make_nvp("data",data_); - } + // Serialization + template + void serialize(Archive & ar, const unsigned int /* file_version */){ + serialization::collection_size_type s (size_); + ar & serialization::make_nvp("size",s); + + // copy the value back if loading + if (Archive::is_loading::value) { + if (s > N) bad_size("too large size in bounded_vector::load()\n").raise(); + size_ = s; + } + // ISSUE: this writes the full array + ar & serialization::make_nvp("data",data_); + } - private: - size_type size_; - array_type data_; - }; + private: + size_type size_; + array_type data_; + }; }}}