diff --git a/Eigen/src/Core/DenseBase.h b/Eigen/src/Core/DenseBase.h index f69c0b2dc..b00f418c9 100644 --- a/Eigen/src/Core/DenseBase.h +++ b/Eigen/src/Core/DenseBase.h @@ -572,15 +572,25 @@ template class DenseBase } EIGEN_DEVICE_FUNC void reverseInPlace(); + #ifdef EIGEN_PARSED_BY_DOXYGEN + /** STL-like \link https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator RandomAccessIterator \endlink + * iterator type as returned by the begin() and end() methods. + */ + typedef random_access_iterator_type iterator; + /** This is the const version of iterator (aka read-only) */ + typedef random_access_iterator_type const_iterator; + #else typedef typename internal::conditional< (Flags&DirectAccessBit)==DirectAccessBit, - PointerBasedStlIterator, - DenseStlIterator + internal::pointer_based_stl_iterator, + internal::generic_randaccess_stl_iterator >::type iterator; typedef typename internal::conditional< (Flags&DirectAccessBit)==DirectAccessBit, - PointerBasedStlIterator, - DenseStlIterator + internal::pointer_based_stl_iterator, + internal::generic_randaccess_stl_iterator >::type const_iterator; + #endif + inline iterator begin(); inline const_iterator begin() const; inline const_iterator cbegin() const; diff --git a/Eigen/src/Core/StlIterators.h b/Eigen/src/Core/StlIterators.h index 04d3d3c8d..8713964bd 100644 --- a/Eigen/src/Core/StlIterators.h +++ b/Eigen/src/Core/StlIterators.h @@ -9,20 +9,17 @@ namespace Eigen { +namespace internal { + template -class IndexedBasedStlIteratorBase +class indexed_based_stl_iterator_base { public: typedef Index difference_type; typedef std::random_access_iterator_tag iterator_category; - IndexedBasedStlIteratorBase() : mp_xpr(0), m_index(0) {} - IndexedBasedStlIteratorBase(XprType& xpr, Index index) : mp_xpr(&xpr), m_index(index) {} - - void swap(IndexedBasedStlIteratorBase& other) { - std::swap(mp_xpr,other.mp_xpr); - std::swap(m_index,other.m_index); - } + indexed_based_stl_iterator_base() : mp_xpr(0), m_index(0) {} + indexed_based_stl_iterator_base(XprType& xpr, Index index) : mp_xpr(&xpr), m_index(index) {} Derived& operator++() { ++m_index; return derived(); } Derived& operator--() { --m_index; return derived(); } @@ -30,22 +27,22 @@ public: Derived operator++(int) { Derived prev(derived()); operator++(); return prev;} Derived operator--(int) { Derived prev(derived()); operator--(); return prev;} - friend Derived operator+(const IndexedBasedStlIteratorBase& a, Index b) { Derived ret(a.derived()); ret += b; return ret; } - friend Derived operator-(const IndexedBasedStlIteratorBase& a, Index b) { Derived ret(a.derived()); ret -= b; return ret; } - friend Derived operator+(Index a, const IndexedBasedStlIteratorBase& b) { Derived ret(b.derived()); ret += a; return ret; } - friend Derived operator-(Index a, const IndexedBasedStlIteratorBase& b) { Derived ret(b.derived()); ret -= a; return ret; } + friend Derived operator+(const indexed_based_stl_iterator_base& a, Index b) { Derived ret(a.derived()); ret += b; return ret; } + friend Derived operator-(const indexed_based_stl_iterator_base& a, Index b) { Derived ret(a.derived()); ret -= b; return ret; } + friend Derived operator+(Index a, const indexed_based_stl_iterator_base& b) { Derived ret(b.derived()); ret += a; return ret; } + friend Derived operator-(Index a, const indexed_based_stl_iterator_base& b) { Derived ret(b.derived()); ret -= a; return ret; } Derived& operator+=(Index b) { m_index += b; return derived(); } Derived& operator-=(Index b) { m_index -= b; return derived(); } - difference_type operator-(const IndexedBasedStlIteratorBase& other) const { eigen_assert(mp_xpr == other.mp_xpr);return m_index - other.m_index; } + difference_type operator-(const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr);return m_index - other.m_index; } - bool operator==(const IndexedBasedStlIteratorBase& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index == other.m_index; } - bool operator!=(const IndexedBasedStlIteratorBase& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index != other.m_index; } - bool operator< (const IndexedBasedStlIteratorBase& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index < other.m_index; } - bool operator<=(const IndexedBasedStlIteratorBase& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index <= other.m_index; } - bool operator> (const IndexedBasedStlIteratorBase& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index > other.m_index; } - bool operator>=(const IndexedBasedStlIteratorBase& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index >= other.m_index; } + bool operator==(const indexed_based_stl_iterator_base& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index == other.m_index; } + bool operator!=(const indexed_based_stl_iterator_base& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index != other.m_index; } + bool operator< (const indexed_based_stl_iterator_base& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index < other.m_index; } + bool operator<=(const indexed_based_stl_iterator_base& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index <= other.m_index; } + bool operator> (const indexed_based_stl_iterator_base& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index > other.m_index; } + bool operator>=(const indexed_based_stl_iterator_base& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index >= other.m_index; } protected: @@ -57,7 +54,7 @@ protected: }; template -class PointerBasedStlIterator +class pointer_based_stl_iterator { enum { is_lvalue = internal::is_lvalue::value }; public: @@ -67,8 +64,8 @@ public: typedef typename internal::conditional::type pointer; typedef typename internal::conditional::type reference; - PointerBasedStlIterator() : m_ptr(0) {} - PointerBasedStlIterator(XprType& xpr, Index index) : m_incr(xpr.innerStride()) + pointer_based_stl_iterator() : m_ptr(0) {} + pointer_based_stl_iterator(XprType& xpr, Index index) : m_incr(xpr.innerStride()) { m_ptr = xpr.data() + index * m_incr.value(); } @@ -77,30 +74,30 @@ public: reference operator[](Index i) const { return *(m_ptr+i*m_incr.value()); } pointer operator->() const { return m_ptr; } - PointerBasedStlIterator& operator++() { m_ptr += m_incr.value(); return *this; } - PointerBasedStlIterator& operator--() { m_ptr -= m_incr.value(); return *this; } + pointer_based_stl_iterator& operator++() { m_ptr += m_incr.value(); return *this; } + pointer_based_stl_iterator& operator--() { m_ptr -= m_incr.value(); return *this; } - PointerBasedStlIterator operator++(int) { PointerBasedStlIterator prev(*this); operator++(); return prev;} - PointerBasedStlIterator operator--(int) { PointerBasedStlIterator prev(*this); operator--(); return prev;} + pointer_based_stl_iterator operator++(int) { pointer_based_stl_iterator prev(*this); operator++(); return prev;} + pointer_based_stl_iterator operator--(int) { pointer_based_stl_iterator prev(*this); operator--(); return prev;} - friend PointerBasedStlIterator operator+(const PointerBasedStlIterator& a, Index b) { PointerBasedStlIterator ret(a); ret += b; return ret; } - friend PointerBasedStlIterator operator-(const PointerBasedStlIterator& a, Index b) { PointerBasedStlIterator ret(a); ret -= b; return ret; } - friend PointerBasedStlIterator operator+(Index a, const PointerBasedStlIterator& b) { PointerBasedStlIterator ret(b); ret += a; return ret; } - friend PointerBasedStlIterator operator-(Index a, const PointerBasedStlIterator& b) { PointerBasedStlIterator ret(b); ret -= a; return ret; } + friend pointer_based_stl_iterator operator+(const pointer_based_stl_iterator& a, Index b) { pointer_based_stl_iterator ret(a); ret += b; return ret; } + friend pointer_based_stl_iterator operator-(const pointer_based_stl_iterator& a, Index b) { pointer_based_stl_iterator ret(a); ret -= b; return ret; } + friend pointer_based_stl_iterator operator+(Index a, const pointer_based_stl_iterator& b) { pointer_based_stl_iterator ret(b); ret += a; return ret; } + friend pointer_based_stl_iterator operator-(Index a, const pointer_based_stl_iterator& b) { pointer_based_stl_iterator ret(b); ret -= a; return ret; } - PointerBasedStlIterator& operator+=(Index b) { m_ptr += b*m_incr.value(); return *this; } - PointerBasedStlIterator& operator-=(Index b) { m_ptr -= b*m_incr.value(); return *this; } + pointer_based_stl_iterator& operator+=(Index b) { m_ptr += b*m_incr.value(); return *this; } + pointer_based_stl_iterator& operator-=(Index b) { m_ptr -= b*m_incr.value(); return *this; } - difference_type operator-(const PointerBasedStlIterator& other) const { + difference_type operator-(const pointer_based_stl_iterator& other) const { return (m_ptr - other.m_ptr)/m_incr.value(); } - bool operator==(const PointerBasedStlIterator& other) { return m_ptr == other.m_ptr; } - bool operator!=(const PointerBasedStlIterator& other) { return m_ptr != other.m_ptr; } - bool operator< (const PointerBasedStlIterator& other) { return m_ptr < other.m_ptr; } - bool operator<=(const PointerBasedStlIterator& other) { return m_ptr <= other.m_ptr; } - bool operator> (const PointerBasedStlIterator& other) { return m_ptr > other.m_ptr; } - bool operator>=(const PointerBasedStlIterator& other) { return m_ptr >= other.m_ptr; } + bool operator==(const pointer_based_stl_iterator& other) { return m_ptr == other.m_ptr; } + bool operator!=(const pointer_based_stl_iterator& other) { return m_ptr != other.m_ptr; } + bool operator< (const pointer_based_stl_iterator& other) { return m_ptr < other.m_ptr; } + bool operator<=(const pointer_based_stl_iterator& other) { return m_ptr <= other.m_ptr; } + bool operator> (const pointer_based_stl_iterator& other) { return m_ptr > other.m_ptr; } + bool operator>=(const pointer_based_stl_iterator& other) { return m_ptr >= other.m_ptr; } protected: @@ -109,7 +106,7 @@ protected: }; template -class DenseStlIterator : public IndexedBasedStlIteratorBase > +class generic_randaccess_stl_iterator : public indexed_based_stl_iterator_base > { public: typedef typename XprType::Scalar value_type; @@ -121,7 +118,7 @@ protected: is_lvalue = internal::is_lvalue::value }; - typedef IndexedBasedStlIteratorBase Base; + typedef indexed_based_stl_iterator_base Base; using Base::m_index; using Base::mp_xpr; @@ -135,67 +132,22 @@ public: typedef typename internal::conditional::type pointer; typedef typename internal::conditional::type reference; - DenseStlIterator() : Base() {} - DenseStlIterator(XprType& xpr, Index index) : Base(xpr,index) {} + generic_randaccess_stl_iterator() : Base() {} + generic_randaccess_stl_iterator(XprType& xpr, Index index) : Base(xpr,index) {} reference operator*() const { return (*mp_xpr)(m_index); } reference operator[](Index i) const { return (*mp_xpr)(m_index+i); } pointer operator->() const { return &((*mp_xpr)(m_index)); } }; -template -void swap(IndexedBasedStlIteratorBase& a, IndexedBasedStlIteratorBase& b) { - a.swap(b); -} - -template -inline typename DenseBase::iterator DenseBase::begin() -{ - EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived); - return iterator(derived(), 0); -} - -template -inline typename DenseBase::const_iterator DenseBase::begin() const -{ - return cbegin(); -} - -template -inline typename DenseBase::const_iterator DenseBase::cbegin() const -{ - EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived); - return const_iterator(derived(), 0); -} - -template -inline typename DenseBase::iterator DenseBase::end() -{ - EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived); - return iterator(derived(), size()); -} - -template -inline typename DenseBase::const_iterator DenseBase::end() const -{ - return cend(); -} - -template -inline typename DenseBase::const_iterator DenseBase::cend() const -{ - EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived); - return const_iterator(derived(), size()); -} - template -class SubVectorStlIterator : public IndexedBasedStlIteratorBase > +class subvector_stl_iterator : public indexed_based_stl_iterator_base > { protected: enum { is_lvalue = internal::is_lvalue::value }; - typedef IndexedBasedStlIteratorBase Base; + typedef indexed_based_stl_iterator_base Base; using Base::m_index; using Base::mp_xpr; @@ -207,20 +159,81 @@ public: typedef value_type* pointer; typedef value_type reference; - SubVectorStlIterator() : Base() {} - SubVectorStlIterator(XprType& xpr, Index index) : Base(xpr,index) {} + subvector_stl_iterator() : Base() {} + subvector_stl_iterator(XprType& xpr, Index index) : Base(xpr,index) {} reference operator*() const { return (*mp_xpr).template subVector(m_index); } reference operator[](Index i) const { return (*mp_xpr).template subVector(m_index+i); } pointer operator->() const { return &((*mp_xpr).template subVector(m_index)); } }; +} // namespace internal + + +/** returns an iterator to the first element of the 1D vector or array + * \only_for_vectors + * \sa end(), cbegin() + */ +template +inline typename DenseBase::iterator DenseBase::begin() +{ + EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived); + return iterator(derived(), 0); +} + +/** const version of begin() */ +template +inline typename DenseBase::const_iterator DenseBase::begin() const +{ + return cbegin(); +} + +/** returns a read-only const_iterator to the first element of the 1D vector or array + * \only_for_vectors + * \sa cend(), begin() + */ +template +inline typename DenseBase::const_iterator DenseBase::cbegin() const +{ + EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived); + return const_iterator(derived(), 0); +} + +/** returns an iterator to the element following the last element of the 1D vector or array + * \only_for_vectors + * \sa begin(), cend() + */ +template +inline typename DenseBase::iterator DenseBase::end() +{ + EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived); + return iterator(derived(), size()); +} + +/** const version of end() */ +template +inline typename DenseBase::const_iterator DenseBase::end() const +{ + return cend(); +} + +/** returns a read-only const_iterator to the element following the last element of the 1D vector or array + * \only_for_vectors + * \sa begin(), cend() + */ +template +inline typename DenseBase::const_iterator DenseBase::cend() const +{ + EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived); + return const_iterator(derived(), size()); +} + template class SubVectorsProxy { public: - typedef SubVectorStlIterator iterator; - typedef SubVectorStlIterator const_iterator; + typedef internal::subvector_stl_iterator iterator; + typedef internal::subvector_stl_iterator const_iterator; SubVectorsProxy(XprType& xpr) : m_xpr(xpr) {} diff --git a/Eigen/src/Core/util/ForwardDeclarations.h b/Eigen/src/Core/util/ForwardDeclarations.h index 5fa7e5267..a9332e940 100644 --- a/Eigen/src/Core/util/ForwardDeclarations.h +++ b/Eigen/src/Core/util/ForwardDeclarations.h @@ -133,11 +133,11 @@ template class ArrayWrapper; template class MatrixWrapper; template class SolverBase; template class InnerIterator; -template class DenseStlIterator; -template class PointerBasedStlIterator; template class SubVectorsProxy; namespace internal { +template class generic_randaccess_stl_iterator; +template class pointer_based_stl_iterator; template struct kernel_retval_base; template struct kernel_retval; template struct image_retval_base; diff --git a/Eigen/src/plugins/ReshapedMethods.h b/Eigen/src/plugins/ReshapedMethods.h index ca9251ed2..2466d24cb 100644 --- a/Eigen/src/plugins/ReshapedMethods.h +++ b/Eigen/src/plugins/ReshapedMethods.h @@ -43,11 +43,11 @@ reshaped(NRowsType nRows, NColsType nCols) const; /// \tparam Order specifies whether the coefficients should be processed in column-major-order (ColMajor), in row-major-order (RowMajor), /// or follows the \em natural order of the nested expression (AutoOrder). The default is ColMajor. /// -/// This overloads is essentially a shortcut for `A.reshaped(AutoSize,fix<1>). +/// This overloads is essentially a shortcut for `A.reshaped(AutoSize,fix<1>)`. /// -/// - If Order==ColMajor (the default), then it returns a column-vector from the stacked columns of \c *this. -/// - If Order==RowMajor, then it returns a column-vector from the stacked rows of \c *this. -/// - If Order==AutoOrder, then it returns a column-vector with elements stacked following the storage order of \c *this. +/// - If `Order==ColMajor` (the default), then it returns a column-vector from the stacked columns of \c *this. +/// - If `Order==RowMajor`, then it returns a column-vector from the stacked rows of \c *this. +/// - If `Order==AutoOrder`, then it returns a column-vector with elements stacked following the storage order of \c *this. /// This mode is the recommended one when the particular ordering of the element is not relevant. /// /// Example: diff --git a/test/stl_iterators.cpp b/test/stl_iterators.cpp index 5d501dcd6..2dde0352a 100644 --- a/test/stl_iterators.cpp +++ b/test/stl_iterators.cpp @@ -17,20 +17,42 @@ make_reverse_iterator( Iterator i ) return std::reverse_iterator(i); } -template -bool is_PointerBasedStlIterator(const PointerBasedStlIterator &) { return true; } +#if !EIGEN_HAS_CXX11 +template +ForwardIt is_sorted_until(ForwardIt firstIt, ForwardIt lastIt) +{ + if (firstIt != lastIt) { + ForwardIt next = firstIt; + while (++next != lastIt) { + if (*next < *firstIt) + return next; + firstIt = next; + } + } + return lastIt; +} +template +bool is_sorted(ForwardIt firstIt, ForwardIt lastIt) +{ + return ::is_sorted_until(firstIt, lastIt) == lastIt; +} +#else +using std::is_sorted; +#endif template -bool is_DenseStlIterator(const DenseStlIterator &) { return true; } +bool is_pointer_based_stl_iterator(const internal::pointer_based_stl_iterator &) { return true; } + +template +bool is_generic_randaccess_stl_iterator(const internal::generic_randaccess_stl_iterator &) { return true; } template -void test_range_for_loop(int rows=Rows, int cols=Cols) +void test_stl_iterators(int rows=Rows, int cols=Cols) { - using std::begin; - using std::end; - typedef Matrix VectorType; + #if EIGEN_HAS_CXX11 typedef Matrix RowVectorType; + #endif typedef Matrix ColMatrixType; typedef Matrix RowMatrixType; VectorType v = VectorType::Random(rows); @@ -41,53 +63,90 @@ void test_range_for_loop(int rows=Rows, int cols=Cols) Index i, j; - VERIFY( is_PointerBasedStlIterator(v.begin()) ); - VERIFY( is_PointerBasedStlIterator(v.end()) ); - VERIFY( is_PointerBasedStlIterator(cv.begin()) ); - VERIFY( is_PointerBasedStlIterator(cv.end()) ); + // Check we got a fast pointer-based iterator when expected + { + VERIFY( is_pointer_based_stl_iterator(v.begin()) ); + VERIFY( is_pointer_based_stl_iterator(v.end()) ); + VERIFY( is_pointer_based_stl_iterator(cv.begin()) ); + VERIFY( is_pointer_based_stl_iterator(cv.end()) ); - j = internal::random(0,A.cols()-1); - VERIFY( is_PointerBasedStlIterator(A.col(j).begin()) ); - VERIFY( is_PointerBasedStlIterator(A.col(j).end()) ); - VERIFY( is_PointerBasedStlIterator(cA.col(j).begin()) ); - VERIFY( is_PointerBasedStlIterator(cA.col(j).end()) ); + j = internal::random(0,A.cols()-1); + VERIFY( is_pointer_based_stl_iterator(A.col(j).begin()) ); + VERIFY( is_pointer_based_stl_iterator(A.col(j).end()) ); + VERIFY( is_pointer_based_stl_iterator(cA.col(j).begin()) ); + VERIFY( is_pointer_based_stl_iterator(cA.col(j).end()) ); - i = internal::random(0,A.rows()-1); - VERIFY( is_PointerBasedStlIterator(A.row(i).begin()) ); - VERIFY( is_PointerBasedStlIterator(A.row(i).end()) ); - VERIFY( is_PointerBasedStlIterator(cA.row(i).begin()) ); - VERIFY( is_PointerBasedStlIterator(cA.row(i).end()) ); + i = internal::random(0,A.rows()-1); + VERIFY( is_pointer_based_stl_iterator(A.row(i).begin()) ); + VERIFY( is_pointer_based_stl_iterator(A.row(i).end()) ); + VERIFY( is_pointer_based_stl_iterator(cA.row(i).begin()) ); + VERIFY( is_pointer_based_stl_iterator(cA.row(i).end()) ); - VERIFY( is_PointerBasedStlIterator(A.reshaped().begin()) ); - VERIFY( is_PointerBasedStlIterator(A.reshaped().end()) ); - VERIFY( is_PointerBasedStlIterator(cA.reshaped().begin()) ); - VERIFY( is_PointerBasedStlIterator(cA.reshaped().end()) ); + VERIFY( is_pointer_based_stl_iterator(A.reshaped().begin()) ); + VERIFY( is_pointer_based_stl_iterator(A.reshaped().end()) ); + VERIFY( is_pointer_based_stl_iterator(cA.reshaped().begin()) ); + VERIFY( is_pointer_based_stl_iterator(cA.reshaped().end()) ); - VERIFY( is_PointerBasedStlIterator(B.template reshaped().begin()) ); - VERIFY( is_PointerBasedStlIterator(B.template reshaped().end()) ); + VERIFY( is_pointer_based_stl_iterator(B.template reshaped().begin()) ); + VERIFY( is_pointer_based_stl_iterator(B.template reshaped().end()) ); + + VERIFY( is_generic_randaccess_stl_iterator(A.template reshaped().begin()) ); + VERIFY( is_generic_randaccess_stl_iterator(A.template reshaped().end()) ); + } - VERIFY( is_DenseStlIterator(A.template reshaped().begin()) ); - VERIFY( is_DenseStlIterator(A.template reshaped().end()) ); - #if EIGEN_HAS_CXX11 - i = 0; - for(auto x : v) { VERIFY_IS_EQUAL(x,v[i++]); } + // check swappable + { + using std::swap; + // pointer-based + { + VectorType v_copy = v; + auto a = v.begin(); + auto b = v.end()-1; + swap(a,b); + VERIFY_IS_EQUAL(v,v_copy); + VERIFY_IS_EQUAL(*b,*v.begin()); + VERIFY_IS_EQUAL(*b,v(0)); + VERIFY_IS_EQUAL(*a,v.end()[-1]); + VERIFY_IS_EQUAL(*a,v(last)); + } - j = internal::random(0,A.cols()-1); - i = 0; - for(auto x : A.col(j)) { VERIFY_IS_EQUAL(x,A(i++,j)); } + // generic + { + RowMatrixType B_copy = B; + auto Br = B.reshaped(); + auto a = Br.begin(); + auto b = Br.end()-1; + swap(a,b); + VERIFY_IS_EQUAL(B,B_copy); + VERIFY_IS_EQUAL(*b,*Br.begin()); + VERIFY_IS_EQUAL(*b,Br(0)); + VERIFY_IS_EQUAL(*a,Br.end()[-1]); + VERIFY_IS_EQUAL(*a,Br(last)); + } + } - i = 0; - for(auto x : (v+A.col(j))) { VERIFY_IS_APPROX(x,v(i)+A(i,j)); ++i; } + // check non-const iterator with for-range loops + { + i = 0; + for(auto x : v) { VERIFY_IS_EQUAL(x,v[i++]); } - j = 0; - i = internal::random(0,A.rows()-1); - for(auto x : A.row(i)) { VERIFY_IS_EQUAL(x,A(i,j++)); } + j = internal::random(0,A.cols()-1); + i = 0; + for(auto x : A.col(j)) { VERIFY_IS_EQUAL(x,A(i++,j)); } - i = 0; - for(auto x : A.reshaped()) { VERIFY_IS_EQUAL(x,A(i++)); } + i = 0; + for(auto x : (v+A.col(j))) { VERIFY_IS_APPROX(x,v(i)+A(i,j)); ++i; } - // check const_iterator + j = 0; + i = internal::random(0,A.rows()-1); + for(auto x : A.row(i)) { VERIFY_IS_EQUAL(x,A(i,j++)); } + + i = 0; + for(auto x : A.reshaped()) { VERIFY_IS_EQUAL(x,A(i++)); } + } + + // same for const_iterator { i = 0; for(auto x : cv) { VERIFY_IS_EQUAL(x,v[i++]); } @@ -100,49 +159,51 @@ void test_range_for_loop(int rows=Rows, int cols=Cols) for(auto x : cA.row(i)) { VERIFY_IS_EQUAL(x,A(i,j++)); } } - Matrix Bc = B; - i = 0; - for(auto x : B.reshaped()) { VERIFY_IS_EQUAL(x,Bc(i++)); } - - VectorType w(v.size()); - i = 0; - for(auto& x : w) { x = v(i++); } - VERIFY_IS_EQUAL(v,w); - + // check reshaped() on row-major { - j = internal::random(0,A.cols()-1); - auto it = A.col(j).begin(); - for(i=0;i Bc = B; + for(auto x : B.reshaped()) { VERIFY_IS_EQUAL(x,Bc(i++)); } + } + + // check write access + { + VectorType w(v.size()); + i = 0; + for(auto& x : w) { x = v(i++); } + VERIFY_IS_EQUAL(v,w); + } + + // check for dangling pointers + { + // no dangling because pointer-based + { + j = internal::random(0,A.cols()-1); + auto it = A.col(j).begin(); + for(i=0;i(0,A.rows()-1); + auto it = A.row(i).begin(); + for(j=0;j(0,A.cols()-1); + // this would produce a dangling pointer: + // auto it = (A+2*A).col(j).begin(); + // we need to name the temporary expression: + auto tmp = (A+2*A).col(j); + auto it = tmp.begin(); + for(i=0;i(0,A.rows()-1); - auto it = A.row(i).begin(); - for(j=0;j(0,A.cols()-1); - // this would produce a dangling pointer: - // auto it = (A+2*A).col(j).begin(); - // we need to name the temporary expression: - auto tmp = (A+2*A).col(j); - auto it = tmp.begin(); - for(i=0;i(0,A.cols()-1); - // auto it = (A+2*A).col(j).begin(); - // for(i=0;i=3) { @@ -155,108 +216,125 @@ void test_range_for_loop(int rows=Rows, int cols=Cols) VERIFY_IS_EQUAL((A.allCols().begin()+cols/2)[1], A.col(cols/2+1)); } - if(rows>=2) + // check std::sort { - v(1) = v(0)-Scalar(1); - VERIFY(!std::is_sorted(begin(v),end(v))); - } - std::sort(begin(v),end(v)); - VERIFY(std::is_sorted(begin(v),end(v))); - VERIFY(!std::is_sorted(make_reverse_iterator(end(v)),make_reverse_iterator(begin(v)))); + // first check that is_sorted returns false when required + if(rows>=2) + { + v(1) = v(0)-Scalar(1); + #if EIGEN_HAS_CXX11 + VERIFY(!is_sorted(std::begin(v),std::end(v))); + #else + VERIFY(!is_sorted(v.cbegin(),v.cend())); + #endif + } - // std::sort with pointer-based iterator and default increment - { - j = internal::random(0,A.cols()-1); - // std::sort(begin(A.col(j)),end(A.col(j))); // does not compile because this returns const iterators - typename ColMatrixType::ColXpr Acol = A.col(j); - std::sort(begin(Acol),end(Acol)); - VERIFY(std::is_sorted(Acol.cbegin(),Acol.cend())); - A.setRandom(); + // on a vector + { + std::sort(v.begin(),v.end()); + VERIFY(is_sorted(v.begin(),v.end())); + VERIFY(!::is_sorted(make_reverse_iterator(v.end()),make_reverse_iterator(v.begin()))); + } - std::sort(A.col(j).begin(),A.col(j).end()); - VERIFY(std::is_sorted(A.col(j).cbegin(),A.col(j).cend())); - A.setRandom(); - } - - // std::sort with pointer-based iterator and runtime increment - { - i = internal::random(0,A.rows()-1); - typename ColMatrixType::RowXpr Arow = A.row(i); - VERIFY_IS_EQUAL( std::distance(begin(Arow),end(Arow)), cols); - std::sort(begin(Arow),end(Arow)); - VERIFY(std::is_sorted(Arow.cbegin(),Arow.cend())); - A.setRandom(); - - std::sort(A.row(i).begin(),A.row(i).end()); - VERIFY(std::is_sorted(A.row(i).cbegin(),A.row(i).cend())); - A.setRandom(); - } - - // std::sort with generic iterator - { - auto B1 = B.reshaped(); - std::sort(begin(B1),end(B1)); - VERIFY(std::is_sorted(B1.cbegin(),B1.cend())); - B.setRandom(); - - // assertion because nested expressions are different - // std::sort(B.reshaped().begin(),B.reshaped().end()); - // VERIFY(std::is_sorted(B.reshaped().cbegin(),B.reshaped().cend())); - // B.setRandom(); + // on a column of a column-major matrix -> pointer-based iterator and default increment + { + j = internal::random(0,A.cols()-1); + // std::sort(begin(A.col(j)),end(A.col(j))); // does not compile because this returns const iterators + typename ColMatrixType::ColXpr Acol = A.col(j); + std::sort(Acol.begin(),Acol.end()); + VERIFY(is_sorted(Acol.cbegin(),Acol.cend())); + A.setRandom(); + + std::sort(A.col(j).begin(),A.col(j).end()); + VERIFY(is_sorted(A.col(j).cbegin(),A.col(j).cend())); + A.setRandom(); + } + + // on a row of a rowmajor matrix -> pointer-based iterator and runtime increment + { + i = internal::random(0,A.rows()-1); + typename ColMatrixType::RowXpr Arow = A.row(i); + VERIFY_IS_EQUAL( std::distance(Arow.begin(),Arow.end()), cols); + std::sort(Arow.begin(),Arow.end()); + VERIFY(is_sorted(Arow.cbegin(),Arow.cend())); + A.setRandom(); + + std::sort(A.row(i).begin(),A.row(i).end()); + VERIFY(is_sorted(A.row(i).cbegin(),A.row(i).cend())); + A.setRandom(); + } + + // with a generic iterator + { + Reshaped B1 = B.reshaped(); + std::sort(B1.begin(),B1.end()); + VERIFY(is_sorted(B1.cbegin(),B1.cend())); + B.setRandom(); + + // assertion because nested expressions are different + // std::sort(B.reshaped().begin(),B.reshaped().end()); + // VERIFY(is_sorted(B.reshaped().cbegin(),B.reshaped().cend())); + // B.setRandom(); + } } + // check with partial_sum { j = internal::random(0,A.cols()-1); typename ColMatrixType::ColXpr Acol = A.col(j); - std::partial_sum(begin(Acol), end(Acol), begin(v)); + std::partial_sum(Acol.begin(), Acol.end(), v.begin()); VERIFY_IS_EQUAL(v(seq(1,last)), v(seq(0,last-1))+Acol(seq(1,last))); // inplace - std::partial_sum(begin(Acol), end(Acol), begin(Acol)); + std::partial_sum(Acol.begin(), Acol.end(), Acol.begin()); VERIFY_IS_EQUAL(v, Acol); } + // stress random access as required by std::nth_element if(rows>=3) { - // stress random access v.setRandom(); VectorType v1 = v; - std::sort(begin(v1),end(v1)); + std::sort(v1.begin(),v1.end()); std::nth_element(v.begin(), v.begin()+rows/2, v.end()); VERIFY_IS_APPROX(v1(rows/2), v(rows/2)); v.setRandom(); v1 = v; - std::sort(begin(v1)+rows/2,end(v1)); + std::sort(v1.begin()+rows/2,v1.end()); std::nth_element(v.begin()+rows/2, v.begin()+rows/4, v.end()); VERIFY_IS_APPROX(v1(rows/4), v(rows/4)); } #if EIGEN_HAS_CXX11 - j = 0; - for(auto c : A.allCols()) { VERIFY_IS_APPROX(c.sum(), A.col(j).sum()); ++j; } - j = 0; - for(auto c : B.allCols()) { VERIFY_IS_APPROX(c.sum(), B.col(j).sum()); ++j; } + // check rows/cols iterators with range-for loops + { + j = 0; + for(auto c : A.allCols()) { VERIFY_IS_APPROX(c.sum(), A.col(j).sum()); ++j; } + j = 0; + for(auto c : B.allCols()) { VERIFY_IS_APPROX(c.sum(), B.col(j).sum()); ++j; } - j = 0; - for(auto c : B.allCols()) { - i = 0; - for(auto& x : c) { - VERIFY_IS_EQUAL(x, B(i,j)); - x = A(i,j); - ++i; + j = 0; + for(auto c : B.allCols()) { + i = 0; + for(auto& x : c) { + VERIFY_IS_EQUAL(x, B(i,j)); + x = A(i,j); + ++i; + } + ++j; } - ++j; + VERIFY_IS_APPROX(A,B); + B.setRandom(); + + i = 0; + for(auto r : A.allRows()) { VERIFY_IS_APPROX(r.sum(), A.row(i).sum()); ++i; } + i = 0; + for(auto r : B.allRows()) { VERIFY_IS_APPROX(r.sum(), B.row(i).sum()); ++i; } } - VERIFY_IS_APPROX(A,B); - B = Bc; // restore B - - i = 0; - for(auto r : A.allRows()) { VERIFY_IS_APPROX(r.sum(), A.row(i).sum()); ++i; } - i = 0; - for(auto r : B.allRows()) { VERIFY_IS_APPROX(r.sum(), B.row(i).sum()); ++i; } + // check rows/cols iterators with STL algorithms { RowVectorType row = RowVectorType::Random(cols); A.rowwise() = row; @@ -265,6 +343,16 @@ void test_range_for_loop(int rows=Rows, int cols=Cols) VectorType col = VectorType::Random(rows); A.colwise() = col; VERIFY( std::all_of(A.allCols().begin(), A.allCols().end(), [&col](typename ColMatrixType::ColXpr x) { return internal::isApprox(x.norm(),col.norm()); }) ); + + i = internal::random(0,A.rows()-1); + A.setRandom(); + A.row(i).setZero(); + VERIFY_IS_EQUAL( std::find_if(A.allRows().begin(), A.allRows().end(), [](typename ColMatrixType::RowXpr x) { return x.norm() == Scalar(0); })-A.allRows().begin(), i ); + + j = internal::random(0,A.cols()-1); + A.setRandom(); + A.col(j).setZero(); + VERIFY_IS_EQUAL( std::find_if(A.allCols().begin(), A.allCols().end(), [](typename ColMatrixType::ColXpr x) { return x.norm() == Scalar(0); })-A.allCols().begin(), j ); } #endif @@ -273,9 +361,9 @@ void test_range_for_loop(int rows=Rows, int cols=Cols) EIGEN_DECLARE_TEST(stl_iterators) { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST_1(( test_range_for_loop() )); - CALL_SUBTEST_1(( test_range_for_loop() )); - CALL_SUBTEST_1(( test_range_for_loop(internal::random(5,10), internal::random(5,10)) )); - CALL_SUBTEST_1(( test_range_for_loop(internal::random(10,200), internal::random(10,200)) )); + CALL_SUBTEST_1(( test_stl_iterators() )); + CALL_SUBTEST_1(( test_stl_iterators() )); + CALL_SUBTEST_1(( test_stl_iterators(internal::random(5,10), internal::random(5,10)) )); + CALL_SUBTEST_1(( test_stl_iterators(internal::random(10,200), internal::random(10,200)) )); } }