| // |
| // Copyright (c) 2000-2002 |
| // Joerg Walter, Mathias Koch |
| // |
| // Distributed under the Boost Software License, Version 1.0. (See |
| // accompanying file LICENSE_1_0.txt or copy at |
| // http://www.boost.org/LICENSE_1_0.txt) |
| // |
| // The authors gratefully acknowledge the support of |
| // GeNeSys mbH & Co. KG in producing this work. |
| // |
| |
| #ifndef _BOOST_UBLAS_VECTOR_ |
| #define _BOOST_UBLAS_VECTOR_ |
| |
| #include <boost/numeric/ublas/storage.hpp> |
| #include <boost/numeric/ublas/vector_expression.hpp> |
| #include <boost/numeric/ublas/detail/vector_assign.hpp> |
| #include <boost/serialization/collection_size_type.hpp> |
| #include <boost/serialization/nvp.hpp> |
| |
| // Iterators based on ideas of Jeremy Siek |
| |
| namespace boost { namespace numeric { namespace ublas { |
| |
| // Array based vector class |
| template<class T, class A> |
| class vector: |
| public vector_container<vector<T, A> > { |
| |
| typedef vector<T, A> self_type; |
| public: |
| #ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS |
| using vector_container<self_type>::operator (); |
| #endif |
| typedef typename A::size_type size_type; |
| typedef typename A::difference_type difference_type; |
| typedef T value_type; |
| typedef typename type_traits<T>::const_reference const_reference; |
| typedef T &reference; |
| typedef T *pointer; |
| typedef const T *const_pointer; |
| typedef A array_type; |
| typedef const vector_reference<const self_type> const_closure_type; |
| typedef vector_reference<self_type> closure_type; |
| typedef self_type vector_temporary_type; |
| typedef dense_tag storage_category; |
| |
| // Construction and destruction |
| BOOST_UBLAS_INLINE |
| vector (): |
| vector_container<self_type> (), |
| data_ () {} |
| explicit BOOST_UBLAS_INLINE |
| vector (size_type size): |
| vector_container<self_type> (), |
| data_ (size) { |
| } |
| BOOST_UBLAS_INLINE |
| vector (size_type size, const array_type &data): |
| vector_container<self_type> (), |
| data_ (data) {} |
| BOOST_UBLAS_INLINE |
| vector (size_type size, const value_type &init): |
| vector_container<self_type> (), |
| data_ (size, init) {} |
| BOOST_UBLAS_INLINE |
| vector (const vector &v): |
| vector_container<self_type> (), |
| data_ (v.data_) {} |
| template<class AE> |
| BOOST_UBLAS_INLINE |
| vector (const vector_expression<AE> &ae): |
| vector_container<self_type> (), |
| data_ (ae ().size ()) { |
| vector_assign<scalar_assign> (*this, ae); |
| } |
| |
| // Random Access Container |
| BOOST_UBLAS_INLINE |
| size_type max_size () const { |
| return data_.max_size (); |
| } |
| |
| BOOST_UBLAS_INLINE |
| bool empty () const { |
| return data_.size () == 0; |
| } |
| // Accessors |
| BOOST_UBLAS_INLINE |
| size_type size () const { |
| return data_.size (); |
| } |
| |
| // Storage accessors |
| BOOST_UBLAS_INLINE |
| const array_type &data () const { |
| return data_; |
| } |
| BOOST_UBLAS_INLINE |
| array_type &data () { |
| return data_; |
| } |
| |
| // Resizing |
| BOOST_UBLAS_INLINE |
| void resize (size_type size, bool preserve = true) { |
| if (preserve) |
| data ().resize (size, typename A::value_type ()); |
| else |
| data ().resize (size); |
| } |
| |
| // Element support |
| BOOST_UBLAS_INLINE |
| pointer find_element (size_type i) { |
| return const_cast<pointer> (const_cast<const self_type&>(*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 { |
| return data () [i]; |
| } |
| BOOST_UBLAS_INLINE |
| reference operator () (size_type i) { |
| 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); |
| } |
| |
| // Element assignment |
| BOOST_UBLAS_INLINE |
| reference insert_element (size_type i, const_reference t) { |
| return (data () [i] = t); |
| } |
| BOOST_UBLAS_INLINE |
| void erase_element (size_type i) { |
| data () [i] = value_type/*zero*/(); |
| } |
| |
| // Zeroing |
| BOOST_UBLAS_INLINE |
| void clear () { |
| std::fill (data ().begin (), data ().end (), value_type/*zero*/()); |
| } |
| |
| // Assignment |
| BOOST_UBLAS_INLINE |
| vector &operator = (const vector &v) { |
| data () = v.data (); |
| return *this; |
| } |
| template<class C> // Container assignment without temporary |
| BOOST_UBLAS_INLINE |
| vector &operator = (const vector_container<C> &v) { |
| resize (v ().size (), false); |
| assign (v); |
| return *this; |
| } |
| BOOST_UBLAS_INLINE |
| vector &assign_temporary (vector &v) { |
| swap (v); |
| return *this; |
| } |
| template<class AE> |
| BOOST_UBLAS_INLINE |
| vector &operator = (const vector_expression<AE> &ae) { |
| self_type temporary (ae); |
| return assign_temporary (temporary); |
| } |
| template<class AE> |
| BOOST_UBLAS_INLINE |
| vector &assign (const vector_expression<AE> &ae) { |
| vector_assign<scalar_assign> (*this, ae); |
| return *this; |
| } |
| |
| // Computed assignment |
| template<class AE> |
| BOOST_UBLAS_INLINE |
| vector &operator += (const vector_expression<AE> &ae) { |
| self_type temporary (*this + ae); |
| return assign_temporary (temporary); |
| } |
| template<class C> // Container assignment without temporary |
| BOOST_UBLAS_INLINE |
| vector &operator += (const vector_container<C> &v) { |
| plus_assign (v); |
| return *this; |
| } |
| template<class AE> |
| BOOST_UBLAS_INLINE |
| vector &plus_assign (const vector_expression<AE> &ae) { |
| vector_assign<scalar_plus_assign> (*this, ae); |
| return *this; |
| } |
| template<class AE> |
| BOOST_UBLAS_INLINE |
| vector &operator -= (const vector_expression<AE> &ae) { |
| self_type temporary (*this - ae); |
| return assign_temporary (temporary); |
| } |
| template<class C> // Container assignment without temporary |
| BOOST_UBLAS_INLINE |
| vector &operator -= (const vector_container<C> &v) { |
| minus_assign (v); |
| return *this; |
| } |
| template<class AE> |
| BOOST_UBLAS_INLINE |
| vector &minus_assign (const vector_expression<AE> &ae) { |
| vector_assign<scalar_minus_assign> (*this, ae); |
| return *this; |
| } |
| template<class AT> |
| BOOST_UBLAS_INLINE |
| vector &operator *= (const AT &at) { |
| vector_assign_scalar<scalar_multiplies_assign> (*this, at); |
| return *this; |
| } |
| template<class AT> |
| BOOST_UBLAS_INLINE |
| vector &operator /= (const AT &at) { |
| vector_assign_scalar<scalar_divides_assign> (*this, at); |
| return *this; |
| } |
| |
| // Swapping |
| BOOST_UBLAS_INLINE |
| void swap (vector &v) { |
| if (this != &v) { |
| data ().swap (v.data ()); |
| } |
| } |
| 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; |
| |
| public: |
| #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; |
| #else |
| class const_iterator; |
| class iterator; |
| #endif |
| |
| // Element lookup |
| BOOST_UBLAS_INLINE |
| const_iterator find (size_type i) const { |
| #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR |
| return const_iterator (*this, data ().begin () + i); |
| #else |
| return const_iterator (*this, i); |
| #endif |
| } |
| BOOST_UBLAS_INLINE |
| iterator find (size_type i) { |
| #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR |
| return iterator (*this, data ().begin () + i); |
| #else |
| return iterator (*this, i); |
| #endif |
| } |
| |
| #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR |
| class const_iterator: |
| public container_const_reference<vector>, |
| public random_access_iterator_base<dense_random_access_iterator_tag, |
| const_iterator, value_type, difference_type> { |
| 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 |
| BOOST_UBLAS_INLINE |
| const_iterator (): |
| container_const_reference<self_type> (), it_ () {} |
| BOOST_UBLAS_INLINE |
| const_iterator (const self_type &v, const const_subiterator_type &it): |
| container_const_reference<self_type> (v), it_ (it) {} |
| BOOST_UBLAS_INLINE |
| const_iterator (const typename self_type::iterator &it): // ISSUE vector:: stops VC8 using std::iterator here |
| container_const_reference<self_type> (it ()), it_ (it.it_) {} |
| |
| // Arithmetic |
| 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); |
| } |
| |
| // 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 |
| const_iterator &operator = (const const_iterator &it) { |
| container_const_reference<self_type>::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_; |
| } |
| |
| private: |
| const_subiterator_type it_; |
| |
| friend class iterator; |
| }; |
| #endif |
| |
| BOOST_UBLAS_INLINE |
| const_iterator begin () const { |
| return find (0); |
| } |
| BOOST_UBLAS_INLINE |
| const_iterator end () const { |
| return find (data_.size ()); |
| } |
| |
| #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR |
| class iterator: |
| public container_reference<vector>, |
| public random_access_iterator_base<dense_random_access_iterator_tag, |
| iterator, value_type, difference_type> { |
| 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<self_type> (), it_ () {} |
| BOOST_UBLAS_INLINE |
| iterator (self_type &v, const subiterator_type &it): |
| container_reference<self_type> (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_; |
| } |
| |
| // 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_; |
| } |
| |
| // Assignment |
| BOOST_UBLAS_INLINE |
| iterator &operator = (const iterator &it) { |
| container_reference<self_type>::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_; |
| } |
| |
| private: |
| subiterator_type it_; |
| |
| friend class const_iterator; |
| }; |
| #endif |
| |
| BOOST_UBLAS_INLINE |
| iterator begin () { |
| return find (0); |
| } |
| BOOST_UBLAS_INLINE |
| iterator end () { |
| return find (data_.size ()); |
| } |
| |
| // Reverse iterator |
| typedef reverse_iterator_base<const_iterator> const_reverse_iterator; |
| typedef reverse_iterator_base<iterator> reverse_iterator; |
| |
| 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<class Archive> |
| void serialize(Archive & ar, const unsigned int /* file_version */){ |
| ar & serialization::make_nvp("data",data_); |
| } |
| |
| private: |
| array_type data_; |
| }; |
| |
| |
| // Bounded vector class |
| template<class T, std::size_t N> |
| class bounded_vector: |
| public vector<T, bounded_array<T, N> > { |
| |
| typedef vector<T, bounded_array<T, N> > 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<class A2> // Allow vector<T,bounded_array<N> construction |
| BOOST_UBLAS_INLINE |
| bounded_vector (const vector<T, A2> &v): |
| vector_type (v) {} |
| template<class AE> |
| BOOST_UBLAS_INLINE |
| bounded_vector (const vector_expression<AE> &ae): |
| vector_type (ae) {} |
| BOOST_UBLAS_INLINE |
| ~bounded_vector () {} |
| |
| // Assignment |
| BOOST_UBLAS_INLINE |
| bounded_vector &operator = (const bounded_vector &v) { |
| vector_type::operator = (v); |
| return *this; |
| } |
| template<class A2> // Generic vector assignment |
| BOOST_UBLAS_INLINE |
| bounded_vector &operator = (const vector<T, A2> &v) { |
| vector_type::operator = (v); |
| return *this; |
| } |
| template<class C> // Container assignment without temporary |
| BOOST_UBLAS_INLINE |
| bounded_vector &operator = (const vector_container<C> &v) { |
| vector_type::operator = (v); |
| return *this; |
| } |
| template<class AE> |
| BOOST_UBLAS_INLINE |
| bounded_vector &operator = (const vector_expression<AE> &ae) { |
| vector_type::operator = (ae); |
| return *this; |
| } |
| }; |
| |
| |
| // Zero vector class |
| template<class T, class ALLOC> |
| class zero_vector: |
| public vector_container<zero_vector<T, ALLOC> > { |
| |
| typedef const T *const_pointer; |
| typedef zero_vector<T, ALLOC> self_type; |
| public: |
| #ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS |
| using vector_container<self_type>::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 self_type> const_closure_type; |
| typedef vector_reference<self_type> closure_type; |
| typedef sparse_tag storage_category; |
| |
| // Construction and destruction |
| BOOST_UBLAS_INLINE |
| zero_vector (): |
| vector_container<self_type> (), |
| size_ (0) {} |
| explicit BOOST_UBLAS_INLINE |
| zero_vector (size_type size): |
| vector_container<self_type> (), |
| size_ (size) {} |
| BOOST_UBLAS_INLINE |
| zero_vector (const zero_vector &v): |
| vector_container<self_type> (), |
| size_ (v.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; |
| } |
| |
| // 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_; |
| } |
| |
| 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; |
| } |
| |
| // 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; |
| |
| // Element lookup |
| BOOST_UBLAS_INLINE |
| const_iterator find (size_type /*i*/) const { |
| return const_iterator (*this); |
| } |
| |
| class const_iterator: |
| public container_const_reference<zero_vector>, |
| public bidirectional_iterator_base<sparse_bidirectional_iterator_tag, |
| const_iterator, value_type> { |
| 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<self_type> () {} |
| BOOST_UBLAS_INLINE |
| const_iterator (const self_type &v): |
| container_const_reference<self_type> (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; |
| } |
| |
| // 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 |
| } |
| |
| // Assignment |
| BOOST_UBLAS_INLINE |
| const_iterator &operator = (const const_iterator &it) { |
| container_const_reference<self_type>::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; |
| } |
| }; |
| |
| 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); |
| } |
| |
| // Reverse iterator |
| typedef reverse_iterator_base<const_iterator> 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 ()); |
| } |
| |
| // Serialization |
| template<class Archive> |
| 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_; |
| }; |
| |
| template<class T, class ALLOC> |
| typename zero_vector<T, ALLOC>::const_value_type zero_vector<T, ALLOC>::zero_ = T(/*zero*/); |
| |
| |
| // Unit vector class |
| template<class T, class ALLOC> |
| class unit_vector: |
| public vector_container<unit_vector<T, ALLOC> > { |
| |
| typedef const T *const_pointer; |
| typedef unit_vector<T, ALLOC> self_type; |
| public: |
| #ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS |
| using vector_container<self_type>::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 self_type> const_closure_type; |
| typedef vector_reference<self_type> closure_type; |
| typedef sparse_tag storage_category; |
| |
| // Construction and destruction |
| BOOST_UBLAS_INLINE |
| unit_vector (): |
| vector_container<self_type> (), |
| size_ (0), index_ (0) {} |
| BOOST_UBLAS_INLINE |
| explicit unit_vector (size_type size, size_type index = 0): |
| vector_container<self_type> (), |
| size_ (size), index_ (index) {} |
| BOOST_UBLAS_INLINE |
| unit_vector (const unit_vector &v): |
| vector_container<self_type> (), |
| size_ (v.size_), index_ (v.index_) {} |
| |
| // Accessors |
| BOOST_UBLAS_INLINE |
| size_type size () const { |
| return size_; |
| } |
| BOOST_UBLAS_INLINE |
| size_type index () const { |
| return index_; |
| } |
| |
| // 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 { |
| 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); |
| } |
| |
| // 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); |
| } |
| |
| // 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_); |
| } |
| |
| class const_iterator: |
| public container_const_reference<unit_vector>, |
| public bidirectional_iterator_base<sparse_bidirectional_iterator_tag, |
| const_iterator, value_type> { |
| 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<unit_vector> (), it_ () {} |
| BOOST_UBLAS_INLINE |
| const_iterator (const unit_vector &v, const const_subiterator_type &it): |
| container_const_reference<unit_vector> (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; |
| } |
| |
| // 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_; |
| } |
| |
| // Assignment |
| BOOST_UBLAS_INLINE |
| const_iterator &operator = (const const_iterator &it) { |
| container_const_reference<unit_vector>::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_; |
| } |
| |
| private: |
| const_subiterator_type it_; |
| }; |
| |
| 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); |
| } |
| |
| // Reverse iterator |
| typedef reverse_iterator_base<const_iterator> 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 ()); |
| } |
| |
| // Serialization |
| template<class Archive> |
| 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_; |
| }; |
| |
| template<class T, class ALLOC> |
| typename unit_vector<T, ALLOC>::const_value_type unit_vector<T, ALLOC>::zero_ = T(/*zero*/); |
| template<class T, class ALLOC> |
| typename unit_vector<T, ALLOC>::const_value_type unit_vector<T, ALLOC>::one_ (1); // ISSUE: need 'one'-traits here |
| |
| |
| // Scalar vector class |
| template<class T, class ALLOC> |
| class scalar_vector: |
| public vector_container<scalar_vector<T, ALLOC> > { |
| |
| typedef const T *const_pointer; |
| typedef scalar_vector<T, ALLOC> self_type; |
| public: |
| #ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS |
| using vector_container<self_type>::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 self_type> const_closure_type; |
| typedef vector_reference<self_type> closure_type; |
| typedef dense_tag storage_category; |
| |
| // Construction and destruction |
| BOOST_UBLAS_INLINE |
| scalar_vector (): |
| vector_container<self_type> (), |
| size_ (0), value_ () {} |
| BOOST_UBLAS_INLINE |
| explicit scalar_vector (size_type size, const value_type &value = value_type(1)): |
| vector_container<self_type> (), |
| size_ (size), value_ (value) {} |
| BOOST_UBLAS_INLINE |
| scalar_vector (const scalar_vector &v): |
| vector_container<self_type> (), |
| size_ (v.size_), value_ (v.value_) {} |
| |
| // Accessors |
| BOOST_UBLAS_INLINE |
| size_type size () const { |
| return 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 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_; |
| } |
| |
| // 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); |
| } |
| |
| // Iterator types |
| private: |
| // Use an index |
| typedef size_type const_subiterator_type; |
| |
| public: |
| #ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR |
| typedef indexed_const_iterator<self_type, dense_random_access_iterator_tag> iterator; |
| typedef indexed_const_iterator<self_type, dense_random_access_iterator_tag> const_iterator; |
| #else |
| class const_iterator; |
| #endif |
| |
| // 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<scalar_vector>, |
| public random_access_iterator_base<dense_random_access_iterator_tag, |
| const_iterator, value_type> { |
| 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<scalar_vector> (), it_ () {} |
| BOOST_UBLAS_INLINE |
| const_iterator (const scalar_vector &v, const const_subiterator_type &it): |
| container_const_reference<scalar_vector> (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_; |
| } |
| |
| // 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_; |
| } |
| |
| // Assignment |
| BOOST_UBLAS_INLINE |
| const_iterator &operator = (const const_iterator &it) { |
| container_const_reference<scalar_vector>::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_; |
| } |
| |
| private: |
| const_subiterator_type it_; |
| }; |
| |
| 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_); |
| } |
| |
| // Reverse iterator |
| typedef reverse_iterator_base<const_iterator> 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 ()); |
| } |
| |
| // Serialization |
| template<class Archive> |
| 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_; |
| }; |
| |
| |
| // Array based vector class |
| template<class T, std::size_t N> |
| class c_vector: |
| public vector_container<c_vector<T, N> > { |
| |
| typedef c_vector<T, N> self_type; |
| public: |
| #ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS |
| using vector_container<self_type>::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 self_type> const_closure_type; |
| typedef vector_reference<self_type> closure_type; |
| typedef self_type vector_temporary_type; |
| typedef dense_tag storage_category; |
| |
| // Construction and destruction |
| 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 (); |
| *this = v; |
| } |
| template<class AE> |
| BOOST_UBLAS_INLINE |
| c_vector (const vector_expression<AE> &ae): |
| size_ (ae ().size ()) /* , data_ () */ { |
| if (size_ > N) |
| bad_size ().raise (); |
| vector_assign<scalar_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_; |
| } |
| |
| // 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<pointer> (const_cast<const self_type&>(*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]; |
| } |
| |
| 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*/()); |
| } |
| |
| // Assignment |
| BOOST_UBLAS_INLINE |
| c_vector &operator = (const c_vector &v) { |
| size_ = v.size_; |
| std::copy (v.data_, v.data_ + v.size_, data_); |
| return *this; |
| } |
| template<class C> // Container assignment without temporary |
| BOOST_UBLAS_INLINE |
| c_vector &operator = (const vector_container<C> &v) { |
| resize (v ().size (), false); |
| assign (v); |
| return *this; |
| } |
| BOOST_UBLAS_INLINE |
| c_vector &assign_temporary (c_vector &v) { |
| swap (v); |
| return *this; |
| } |
| template<class AE> |
| BOOST_UBLAS_INLINE |
| c_vector &operator = (const vector_expression<AE> &ae) { |
| self_type temporary (ae); |
| return assign_temporary (temporary); |
| } |
| template<class AE> |
| BOOST_UBLAS_INLINE |
| c_vector &assign (const vector_expression<AE> &ae) { |
| vector_assign<scalar_assign> (*this, ae); |
| return *this; |
| } |
| |
| // Computed assignment |
| template<class AE> |
| BOOST_UBLAS_INLINE |
| c_vector &operator += (const vector_expression<AE> &ae) { |
| self_type temporary (*this + ae); |
| return assign_temporary (temporary); |
| } |
| template<class C> // Container assignment without temporary |
| BOOST_UBLAS_INLINE |
| c_vector &operator += (const vector_container<C> &v) { |
| plus_assign (v); |
| return *this; |
| } |
| template<class AE> |
| BOOST_UBLAS_INLINE |
| c_vector &plus_assign (const vector_expression<AE> &ae) { |
| vector_assign<scalar_plus_assign> ( *this, ae); |
| return *this; |
| } |
| template<class AE> |
| BOOST_UBLAS_INLINE |
| c_vector &operator -= (const vector_expression<AE> &ae) { |
| self_type temporary (*this - ae); |
| return assign_temporary (temporary); |
| } |
| template<class C> // Container assignment without temporary |
| BOOST_UBLAS_INLINE |
| c_vector &operator -= (const vector_container<C> &v) { |
| minus_assign (v); |
| return *this; |
| } |
| template<class AE> |
| BOOST_UBLAS_INLINE |
| c_vector &minus_assign (const vector_expression<AE> &ae) { |
| vector_assign<scalar_minus_assign> (*this, ae); |
| return *this; |
| } |
| template<class AT> |
| BOOST_UBLAS_INLINE |
| c_vector &operator *= (const AT &at) { |
| vector_assign_scalar<scalar_multiplies_assign> (*this, at); |
| return *this; |
| } |
| template<class AT> |
| BOOST_UBLAS_INLINE |
| c_vector &operator /= (const AT &at) { |
| vector_assign_scalar<scalar_divides_assign> (*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); |
| } |
| |
| // Iterator types |
| private: |
| // Use pointers for iterator |
| typedef const_pointer const_subiterator_type; |
| typedef pointer subiterator_type; |
| |
| public: |
| #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; |
| #else |
| class const_iterator; |
| class iterator; |
| #endif |
| |
| // Element lookup |
| BOOST_UBLAS_INLINE |
| const_iterator find (size_type i) const { |
| #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR |
| return const_iterator (*this, &data_ [i]); |
| #else |
| return const_iterator (*this, i); |
| #endif |
| } |
| BOOST_UBLAS_INLINE |
| iterator find (size_type i) { |
| #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR |
| return iterator (*this, &data_ [i]); |
| #else |
| return iterator (*this, i); |
| #endif |
| } |
| |
| #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR |
| class const_iterator: |
| public container_const_reference<c_vector>, |
| public random_access_iterator_base<dense_random_access_iterator_tag, |
| const_iterator, value_type> { |
| 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<self_type> (), it_ () {} |
| BOOST_UBLAS_INLINE |
| const_iterator (const self_type &v, const const_subiterator_type &it): |
| container_const_reference<self_type> (v), it_ (it) {} |
| BOOST_UBLAS_INLINE |
| const_iterator (const typename self_type::iterator &it): // ISSUE self_type:: stops VC8 using std::iterator here |
| container_const_reference<self_type> (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_; |
| } |
| |
| // 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_; |
| } |
| |
| // Assignment |
| BOOST_UBLAS_INLINE |
| const_iterator &operator = (const const_iterator &it) { |
| container_const_reference<self_type>::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_; |
| } |
| |
| private: |
| const_subiterator_type it_; |
| |
| friend class iterator; |
| }; |
| #endif |
| |
| 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<c_vector>, |
| public random_access_iterator_base<dense_random_access_iterator_tag, |
| iterator, value_type> { |
| 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<self_type> (), it_ () {} |
| BOOST_UBLAS_INLINE |
| iterator (self_type &v, const subiterator_type &it): |
| container_reference<self_type> (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_; |
| } |
| |
| // 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_; |
| } |
| |
| // Assignment |
| BOOST_UBLAS_INLINE |
| iterator &operator = (const iterator &it) { |
| container_reference<self_type>::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_; |
| } |
| |
| private: |
| subiterator_type it_; |
| |
| friend class const_iterator; |
| }; |
| #endif |
| |
| BOOST_UBLAS_INLINE |
| iterator begin () { |
| return find (0); |
| } |
| BOOST_UBLAS_INLINE |
| iterator end () { |
| return find (size_); |
| } |
| |
| // Reverse iterator |
| typedef reverse_iterator_base<const_iterator> const_reverse_iterator; |
| typedef reverse_iterator_base<iterator> 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 ()); |
| } |
| |
| // Serialization |
| template<class Archive> |
| 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_; |
| }; |
| |
| }}} |
| |
| #endif |
