Chris@16: //
Chris@16: //  Copyright (c) 2000-2002
Chris@16: //  Joerg Walter, Mathias Koch
Chris@16: //
Chris@16: //  Distributed under the Boost Software License, Version 1.0. (See
Chris@16: //  accompanying file LICENSE_1_0.txt or copy at
Chris@16: //  http://www.boost.org/LICENSE_1_0.txt)
Chris@16: //
Chris@16: //  The authors gratefully acknowledge the support of
Chris@16: //  GeNeSys mbH & Co. KG in producing this work.
Chris@16: //
Chris@16: 
Chris@16: #ifndef _BOOST_UBLAS_ITERATOR_
Chris@16: #define _BOOST_UBLAS_ITERATOR_
Chris@16: 
Chris@16: #include <boost/numeric/ublas/exception.hpp>
Chris@16: #include <iterator>
Chris@16: 
Chris@16: 
Chris@16: namespace boost { namespace numeric { namespace ublas {
Chris@16: 
Chris@16:   /** \brief Base class of all proxy classes that contain
Chris@16:    *       a (redirectable) reference to an immutable object.
Chris@16:    *
Chris@16:    *       \param C the type of the container referred to
Chris@16:    */
Chris@16:     template<class C>
Chris@16:     class container_const_reference:
Chris@16:         private nonassignable {
Chris@16:     public:
Chris@16:         typedef C container_type;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         container_const_reference ():
Chris@16:             c_ (0) {}
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         container_const_reference (const container_type &c):
Chris@16:             c_ (&c) {}
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const container_type &operator () () const {
Chris@16:             return *c_;
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         container_const_reference &assign (const container_type *c) {
Chris@16:             c_ = c;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         
Chris@16:         // Closure comparison
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool same_closure (const container_const_reference &cr) const {
Chris@16:             return c_ == cr.c_;
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         const container_type *c_;
Chris@16:     };
Chris@16: 
Chris@16:   /** \brief Base class of all proxy classes that contain
Chris@16:    *         a (redirectable) reference to a mutable object.
Chris@16:    *
Chris@16:    * \param C the type of the container referred to
Chris@16:    */
Chris@16:     template<class C>
Chris@16:     class container_reference:
Chris@16:         private nonassignable {
Chris@16:     public:
Chris@16:         typedef C container_type;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         container_reference ():
Chris@16:             c_ (0) {}
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         container_reference (container_type &c):
Chris@16:             c_ (&c) {}
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         container_type &operator () () const {
Chris@16:            return *c_;
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         container_reference &assign (container_type *c) {
Chris@16:             c_ = c;
Chris@16:             return *this;
Chris@16:         }
Chris@16: 
Chris@16:         // Closure comparison
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool same_closure (const container_reference &cr) const {
Chris@16:             return c_ == cr.c_;
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         container_type *c_;
Chris@16:     };
Chris@16: 
Chris@16:   /** \brief Base class of all forward iterators.
Chris@16:    * 
Chris@16:    *  \param IC the iterator category
Chris@16:    *  \param I the derived iterator type
Chris@16:    *  \param T the value type
Chris@16:    * 
Chris@16:    * The forward iterator can only proceed in one direction
Chris@16:    * via the post increment operator.
Chris@16:    */
Chris@16:     template<class IC, class I, class T>
Chris@16:     struct forward_iterator_base:
Chris@16:         public std::iterator<IC, T> {
Chris@16:         typedef I derived_iterator_type;
Chris@16:         typedef T derived_value_type;
Chris@16: 
Chris@16:         // Arithmetic
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         derived_iterator_type operator ++ (int) {
Chris@16:             derived_iterator_type &d (*static_cast<const derived_iterator_type *> (this));
Chris@16:             derived_iterator_type tmp (d);
Chris@16:             ++ d;
Chris@16:             return tmp;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend derived_iterator_type operator ++ (derived_iterator_type &d, int) {
Chris@16:             derived_iterator_type tmp (d);
Chris@16:             ++ d;
Chris@16:             return tmp;
Chris@16:         }
Chris@16: 
Chris@16:         // Comparison
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator != (const derived_iterator_type &it) const {
Chris@16:             const derived_iterator_type *d = static_cast<const derived_iterator_type *> (this);
Chris@16:             return ! (*d == it);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:   /** \brief Base class of all bidirectional iterators.
Chris@16:    *
Chris@16:    * \param IC the iterator category
Chris@16:    * \param I the derived iterator type
Chris@16:    * \param T the value type
Chris@16:    *
Chris@16:    * The bidirectional iterator can proceed in both directions
Chris@16:    * via the post increment and post decrement operator.
Chris@16:    */
Chris@16:     template<class IC, class I, class T>
Chris@16:     struct bidirectional_iterator_base:
Chris@16:         public std::iterator<IC, T> {
Chris@16:         typedef I derived_iterator_type;
Chris@16:         typedef T derived_value_type;
Chris@16: 
Chris@16:         // Arithmetic
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         derived_iterator_type operator ++ (int) {
Chris@16:             derived_iterator_type &d (*static_cast<const derived_iterator_type *> (this));
Chris@16:             derived_iterator_type tmp (d);
Chris@16:             ++ d;
Chris@16:             return tmp;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend derived_iterator_type operator ++ (derived_iterator_type &d, int) {
Chris@16:             derived_iterator_type tmp (d);
Chris@16:             ++ d;
Chris@16:             return tmp;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         derived_iterator_type operator -- (int) {
Chris@16:             derived_iterator_type &d (*static_cast<const derived_iterator_type *> (this));
Chris@16:             derived_iterator_type tmp (d);
Chris@16:             -- d;
Chris@16:             return tmp;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend derived_iterator_type operator -- (derived_iterator_type &d, int) {
Chris@16:             derived_iterator_type tmp (d);
Chris@16:             -- d;
Chris@16:             return tmp;
Chris@16:         }
Chris@16: 
Chris@16:         // Comparison
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator != (const derived_iterator_type &it) const {
Chris@16:             const derived_iterator_type *d = static_cast<const derived_iterator_type *> (this);
Chris@16:             return ! (*d == it);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:   /** \brief Base class of all random access iterators.
Chris@16:    *
Chris@16:    * \param IC the iterator category
Chris@16:    * \param I the derived iterator type
Chris@16:    * \param T the value type
Chris@16:    * \param D the difference type, default: std::ptrdiff_t
Chris@16:    *
Chris@16:    * The random access iterator can proceed in both directions
Chris@16:    * via the post increment/decrement operator or in larger steps
Chris@16:    * via the +, - and +=, -= operators. The random access iterator
Chris@16:    * is LessThan Comparable.
Chris@16:    */
Chris@16:     template<class IC, class I, class T, class D = std::ptrdiff_t>
Chris@16:     // ISSUE the default for D seems rather dangerous as it can easily be (silently) incorrect
Chris@16:     struct random_access_iterator_base:
Chris@16:         public std::iterator<IC, T> {
Chris@16:         typedef I derived_iterator_type;
Chris@16:         typedef T derived_value_type;
Chris@16:         typedef D derived_difference_type;
Chris@16: 
Chris@16:         /* FIXME Need to explicitly pass derived_reference_type as otherwise I undefined type or forward declared
Chris@16:         typedef typename derived_iterator_type::reference derived_reference_type;
Chris@16:         // Indexed element
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         derived_reference_type operator [] (derived_difference_type n) {
Chris@16:             return *(*this + n);
Chris@16:         }
Chris@16:         */
Chris@16: 
Chris@16:         // Arithmetic
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         derived_iterator_type operator ++ (int) {
Chris@16:             derived_iterator_type &d (*static_cast<derived_iterator_type *> (this));
Chris@16:             derived_iterator_type tmp (d);
Chris@16:             ++ d;
Chris@16:             return tmp;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend derived_iterator_type operator ++ (derived_iterator_type &d, int) {
Chris@16:             derived_iterator_type tmp (d);
Chris@16:             ++ d;
Chris@16:             return tmp;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         derived_iterator_type operator -- (int) {
Chris@16:             derived_iterator_type &d (*static_cast<derived_iterator_type *> (this));
Chris@16:             derived_iterator_type tmp (d);
Chris@16:             -- d;
Chris@16:             return tmp;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend derived_iterator_type operator -- (derived_iterator_type &d, int) {
Chris@16:             derived_iterator_type tmp (d);
Chris@16:             -- d;
Chris@16:             return tmp;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         derived_iterator_type operator + (derived_difference_type n) const {
Chris@16:             derived_iterator_type tmp (*static_cast<const derived_iterator_type *> (this));
Chris@16:             return tmp += n;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend derived_iterator_type operator + (const derived_iterator_type &d, derived_difference_type n) {
Chris@16:             derived_iterator_type tmp (d);
Chris@16:             return tmp += n;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend derived_iterator_type operator + (derived_difference_type n, const derived_iterator_type &d) {
Chris@16:             derived_iterator_type tmp (d);
Chris@16:             return tmp += n;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         derived_iterator_type operator - (derived_difference_type n) const {
Chris@16:             derived_iterator_type tmp (*static_cast<const derived_iterator_type *> (this));
Chris@16:             return tmp -= n;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend derived_iterator_type operator - (const derived_iterator_type &d, derived_difference_type n) {
Chris@16:             derived_iterator_type tmp (d);
Chris@16:             return tmp -= n;
Chris@16:         }
Chris@16: 
Chris@16:         // Comparison
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator != (const derived_iterator_type &it) const {
Chris@16:             const derived_iterator_type *d = static_cast<const derived_iterator_type *> (this);
Chris@16:             return ! (*d == it);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator <= (const derived_iterator_type &it) const {
Chris@16:             const derived_iterator_type *d = static_cast<const derived_iterator_type *> (this);
Chris@16:             return ! (it < *d);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator >= (const derived_iterator_type &it) const {
Chris@16:             const derived_iterator_type *d = static_cast<const derived_iterator_type *> (this);
Chris@16:             return ! (*d < it);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator > (const derived_iterator_type &it) const {
Chris@16:             const derived_iterator_type *d = static_cast<const derived_iterator_type *> (this);
Chris@16:             return it < *d;
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:   /** \brief Base class of all reverse iterators. (non-MSVC version)
Chris@16:    *
Chris@16:    * \param I the derived iterator type
Chris@16:    * \param T the value type
Chris@16:    * \param R the reference type
Chris@16:    *
Chris@16:    * The reverse iterator implements a bidirectional iterator
Chris@16:    * reversing the elements of the underlying iterator. It
Chris@16:    * implements most operators of a random access iterator.
Chris@16:    *
Chris@16:    * uBLAS extension: it.index()
Chris@16:    */
Chris@16: 
Chris@16:     // Renamed this class from reverse_iterator to get
Chris@16:     // typedef reverse_iterator<...> reverse_iterator
Chris@16:     // working. Thanks to Gabriel Dos Reis for explaining this.
Chris@16:     template <class I>
Chris@16:     class reverse_iterator_base:
Chris@16:         public std::reverse_iterator<I> {
Chris@16:     public:
Chris@16:         typedef typename I::container_type container_type;
Chris@16:         typedef typename container_type::size_type size_type;
Chris@16:         typedef typename I::difference_type difference_type;
Chris@16:         typedef I iterator_type;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base ():
Chris@16:             std::reverse_iterator<iterator_type> () {}
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base (const iterator_type &it):
Chris@16:             std::reverse_iterator<iterator_type> (it) {}
Chris@16: 
Chris@16:         // Arithmetic
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base &operator ++ () {
Chris@16:             return *this = -- this->base ();
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base operator ++ (int) {
Chris@16:             reverse_iterator_base tmp (*this);
Chris@16:             *this = -- this->base ();
Chris@16:             return tmp;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base &operator -- () {
Chris@16:             return *this = ++ this->base ();
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base operator -- (int) {
Chris@16:             reverse_iterator_base tmp (*this);
Chris@16:             *this = ++ this->base ();
Chris@16:             return tmp;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base &operator += (difference_type n) {
Chris@16:             return *this = this->base () - n;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base &operator -= (difference_type n) {
Chris@16:             return *this = this->base () + n;
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend reverse_iterator_base operator + (const reverse_iterator_base &it, difference_type n) {
Chris@16:             reverse_iterator_base tmp (it);
Chris@16:             return tmp += n;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend reverse_iterator_base operator + (difference_type n, const reverse_iterator_base &it) {
Chris@16:             reverse_iterator_base tmp (it);
Chris@16:             return tmp += n;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend reverse_iterator_base operator - (const reverse_iterator_base &it, difference_type n) {
Chris@16:             reverse_iterator_base tmp (it);
Chris@16:             return tmp -= n;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend difference_type operator - (const reverse_iterator_base &it1, const reverse_iterator_base &it2) {
Chris@16:             return it2.base () - it1.base ();
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const container_type &operator () () const {
Chris@16:             return this->base () ();
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type index () const {
Chris@16:             iterator_type tmp (this->base ());
Chris@16:             return (-- tmp).index ();
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:   /** \brief 1st base class of all matrix reverse iterators. (non-MSVC version)
Chris@16:    *
Chris@16:    * \param I the derived iterator type
Chris@16:    *
Chris@16:    * The reverse iterator implements a bidirectional iterator
Chris@16:    * reversing the elements of the underlying iterator. It
Chris@16:    * implements most operators of a random access iterator.
Chris@16:    *
Chris@16:    * uBLAS extension: it.index1(), it.index2() and access to
Chris@16:    * the dual iterator via begin(), end(), rbegin(), rend()
Chris@16:    */
Chris@16: 
Chris@16:     // Renamed this class from reverse_iterator1 to get
Chris@16:     // typedef reverse_iterator1<...> reverse_iterator1
Chris@16:     // working. Thanks to Gabriel Dos Reis for explaining this.
Chris@16:     template <class I>
Chris@16:     class reverse_iterator_base1:
Chris@16:         public std::reverse_iterator<I> {
Chris@16:     public:
Chris@16:         typedef typename I::container_type container_type;
Chris@16:         typedef typename container_type::size_type size_type;
Chris@16:         typedef typename I::difference_type difference_type;
Chris@16:         typedef I iterator_type;
Chris@16:         typedef typename I::dual_iterator_type dual_iterator_type;
Chris@16:         typedef typename I::dual_reverse_iterator_type dual_reverse_iterator_type;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base1 ():
Chris@16:             std::reverse_iterator<iterator_type> () {}
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base1 (const iterator_type &it):
Chris@16:             std::reverse_iterator<iterator_type> (it) {}
Chris@16: 
Chris@16:         // Arithmetic
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base1 &operator ++ () {
Chris@16:             return *this = -- this->base ();
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base1 operator ++ (int) {
Chris@16:             reverse_iterator_base1 tmp (*this);
Chris@16:             *this = -- this->base ();
Chris@16:             return tmp;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base1 &operator -- () {
Chris@16:             return *this = ++ this->base ();
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base1 operator -- (int) {
Chris@16:             reverse_iterator_base1 tmp (*this);
Chris@16:             *this = ++ this->base ();
Chris@16:             return tmp;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base1 &operator += (difference_type n) {
Chris@16:             return *this = this->base () - n;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base1 &operator -= (difference_type n) {
Chris@16:             return *this = this->base () + n;
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend reverse_iterator_base1 operator + (const reverse_iterator_base1 &it, difference_type n) {
Chris@16:             reverse_iterator_base1 tmp (it);
Chris@16:             return tmp += n;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend reverse_iterator_base1 operator + (difference_type n, const reverse_iterator_base1 &it) {
Chris@16:             reverse_iterator_base1 tmp (it);
Chris@16:             return tmp += n;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend reverse_iterator_base1 operator - (const reverse_iterator_base1 &it, difference_type n) {
Chris@16:             reverse_iterator_base1 tmp (it);
Chris@16:             return tmp -= n;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend difference_type operator - (const reverse_iterator_base1 &it1, const reverse_iterator_base1 &it2) {
Chris@16:             return it2.base () - it1.base ();
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const container_type &operator () () const {
Chris@16:             return this->base () ();
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type index1 () const {
Chris@16:             iterator_type tmp (this->base ());
Chris@16:             return (-- tmp).index1 ();
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type index2 () const {
Chris@16:             iterator_type tmp (this->base ());
Chris@16:             return (-- tmp).index2 ();
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_iterator_type begin () const {
Chris@16:             iterator_type tmp (this->base ());
Chris@16:             return (-- tmp).begin ();
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_iterator_type end () const {
Chris@16:             iterator_type tmp (this->base ());
Chris@16:             return (-- tmp).end ();
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_reverse_iterator_type rbegin () const {
Chris@16:             return dual_reverse_iterator_type (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_reverse_iterator_type rend () const {
Chris@16:             return dual_reverse_iterator_type (begin ());
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:   /** \brief 2nd base class of all matrix reverse iterators. (non-MSVC version)
Chris@16:    *
Chris@16:    * \param I the derived iterator type
Chris@16:    *
Chris@16:    * The reverse iterator implements a bidirectional iterator
Chris@16:    * reversing the elements of the underlying iterator. It
Chris@16:    * implements most operators of a random access iterator.
Chris@16:    *
Chris@16:    * uBLAS extension: it.index1(), it.index2() and access to
Chris@16:    * the dual iterator via begin(), end(), rbegin(), rend()
Chris@16:    *
Chris@16:    * Note: this type is _identical_ to reverse_iterator_base1
Chris@16:    */
Chris@16: 
Chris@16:     // Renamed this class from reverse_iterator2 to get
Chris@16:     // typedef reverse_iterator2<...> reverse_iterator2
Chris@16:     // working. Thanks to Gabriel Dos Reis for explaining this.
Chris@16:     template <class I>
Chris@16:     class reverse_iterator_base2:
Chris@16:         public std::reverse_iterator<I> {
Chris@16:     public:
Chris@16:         typedef typename I::container_type container_type;
Chris@16:         typedef typename container_type::size_type size_type;
Chris@16:         typedef typename I::difference_type difference_type;
Chris@16:         typedef I iterator_type;
Chris@16:         typedef typename I::dual_iterator_type dual_iterator_type;
Chris@16:         typedef typename I::dual_reverse_iterator_type dual_reverse_iterator_type;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base2 ():
Chris@16:             std::reverse_iterator<iterator_type> () {}
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base2 (const iterator_type &it):
Chris@16:             std::reverse_iterator<iterator_type> (it) {}
Chris@16: 
Chris@16:         // Arithmetic
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base2 &operator ++ () {
Chris@16:             return *this = -- this->base ();
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base2 operator ++ (int) {
Chris@16:             reverse_iterator_base2 tmp (*this);
Chris@16:             *this = -- this->base ();
Chris@16:             return tmp;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base2 &operator -- () {
Chris@16:             return *this = ++ this->base ();
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base2 operator -- (int) {
Chris@16:             reverse_iterator_base2 tmp (*this);
Chris@16:             *this = ++ this->base ();
Chris@16:             return tmp;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base2 &operator += (difference_type n) {
Chris@16:             return *this = this->base () - n;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator_base2 &operator -= (difference_type n) {
Chris@16:             return *this = this->base () + n;
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend reverse_iterator_base2 operator + (const reverse_iterator_base2 &it, difference_type n) {
Chris@16:             reverse_iterator_base2 tmp (it);
Chris@16:             return tmp += n;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend reverse_iterator_base2 operator + (difference_type n, const reverse_iterator_base2 &it) {
Chris@16:             reverse_iterator_base2 tmp (it);
Chris@16:             return tmp += n;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend reverse_iterator_base2 operator - (const reverse_iterator_base2 &it, difference_type n) {
Chris@16:             reverse_iterator_base2 tmp (it);
Chris@16:             return tmp -= n;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend difference_type operator - (const reverse_iterator_base2 &it1, const reverse_iterator_base2 &it2) {
Chris@16:             return it2.base () - it1.base ();
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const container_type &operator () () const {
Chris@16:             return this->base () ();
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type index1 () const {
Chris@16:             iterator_type tmp (this->base ());
Chris@16:             return (-- tmp).index1 ();
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type index2 () const {
Chris@16:             iterator_type tmp (this->base ());
Chris@16:             return (-- tmp).index2 ();
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_iterator_type begin () const {
Chris@16:             iterator_type tmp (this->base ());
Chris@16:             return (-- tmp).begin ();
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_iterator_type end () const {
Chris@16:             iterator_type tmp (this->base ());
Chris@16:             return (-- tmp).end ();
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_reverse_iterator_type rbegin () const {
Chris@16:             return dual_reverse_iterator_type (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_reverse_iterator_type rend () const {
Chris@16:             return dual_reverse_iterator_type (begin ());
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:   /** \brief A class implementing an indexed random access iterator.
Chris@16:    *
Chris@16:    * \param C the (mutable) container type
Chris@16:    * \param IC the iterator category
Chris@16:    *
Chris@16:    * This class implements a random access iterator. The current 
Chris@16:    * position is stored as the unsigned integer it_ and the
Chris@16:    * values are accessed via operator()(it_) of the container.
Chris@16:    *
Chris@16:    * uBLAS extension: index()
Chris@16:    */
Chris@16: 
Chris@16:     template<class C, class IC>
Chris@16:     class indexed_iterator:
Chris@16:         public container_reference<C>,
Chris@16:         public random_access_iterator_base<IC,
Chris@16:                                            indexed_iterator<C, IC>,
Chris@16:                                            typename C::value_type,
Chris@16:                                            typename C::difference_type> {
Chris@16:     public:
Chris@16:         typedef C container_type;
Chris@16:         typedef IC iterator_category;
Chris@16:         typedef typename container_type::size_type size_type;
Chris@16:         typedef typename container_type::difference_type difference_type;
Chris@16:         typedef typename container_type::value_type value_type;
Chris@16:         typedef typename container_type::reference reference;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator ():
Chris@16:             container_reference<container_type> (), it_ () {}
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator (container_type &c, size_type it):
Chris@16:             container_reference<container_type> (c), it_ (it) {}
Chris@16: 
Chris@16:         // Arithmetic
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator &operator ++ () {
Chris@16:             ++ it_;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator &operator -- () {
Chris@16:             -- it_;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator &operator += (difference_type n) {
Chris@16:             it_ += n;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator &operator -= (difference_type n) {
Chris@16:             it_ -= n;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         difference_type operator - (const indexed_iterator &it) const {
Chris@16:             BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
Chris@16:             return it_ - it.it_;
Chris@16:         }
Chris@16: 
Chris@16:         // Dereference
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator * () const {
Chris@16:             BOOST_UBLAS_CHECK (index () < (*this) ().size (), bad_index ());
Chris@16:             return (*this) () (it_);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator [] (difference_type n) const {
Chris@16:             return *((*this) + n);
Chris@16:         }
Chris@16: 
Chris@16:         // Index
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type index () const {
Chris@16:             return it_;
Chris@16:         }
Chris@16: 
Chris@16:         // Assignment
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator &operator = (const indexed_iterator &it) {
Chris@16:             // FIX: ICC needs full qualification?!
Chris@16:             // assign (&it ());
Chris@16:             container_reference<C>::assign (&it ());
Chris@16:             it_ = it.it_;
Chris@16:             return *this;
Chris@16:         }
Chris@16: 
Chris@16:         // Comparison
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator == (const indexed_iterator &it) const {
Chris@16:             BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
Chris@16:             return it_ == it.it_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator < (const indexed_iterator &it) const {
Chris@16:             BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
Chris@16:             return it_ < it.it_;
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         size_type it_;
Chris@16:     };
Chris@16: 
Chris@16:   /** \brief A class implementing an indexed random access iterator.
Chris@16:    *
Chris@16:    * \param C the (immutable) container type
Chris@16:    * \param IC the iterator category
Chris@16:    *
Chris@16:    * This class implements a random access iterator. The current 
Chris@16:    * position is stored as the unsigned integer \c it_ and the
Chris@16:    * values are accessed via \c operator()(it_) of the container.
Chris@16:    *
Chris@16:    * uBLAS extension: \c index()
Chris@16:    *
Chris@16:    * Note: there is an automatic conversion from 
Chris@16:    * \c indexed_iterator to \c indexed_const_iterator
Chris@16:    */
Chris@16: 
Chris@16:     template<class C, class IC>
Chris@16:     class indexed_const_iterator:
Chris@16:         public container_const_reference<C>,
Chris@16:         public random_access_iterator_base<IC,
Chris@16:                                            indexed_const_iterator<C, IC>,
Chris@16:                                            typename C::value_type,
Chris@16:                                            typename C::difference_type> {
Chris@16:     public:
Chris@16:         typedef C container_type;
Chris@16:         typedef IC iterator_category;
Chris@16:         typedef typename container_type::size_type size_type;
Chris@16:         typedef typename container_type::difference_type difference_type;
Chris@16:         typedef typename container_type::value_type value_type;
Chris@16:         typedef typename container_type::const_reference reference;
Chris@16:         typedef indexed_iterator<container_type, iterator_category> iterator_type;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator ():
Chris@16:             container_const_reference<container_type> (), it_ () {}
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator (const container_type &c, size_type it):
Chris@16:             container_const_reference<container_type> (c), it_ (it) {}
Chris@16:         BOOST_UBLAS_INLINE 
Chris@16:         indexed_const_iterator (const iterator_type &it):
Chris@16:             container_const_reference<container_type> (it ()), it_ (it.index ()) {}
Chris@16: 
Chris@16:         // Arithmetic
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator &operator ++ () {
Chris@16:             ++ it_;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator &operator -- () {
Chris@16:             -- it_;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator &operator += (difference_type n) {
Chris@16:             it_ += n;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator &operator -= (difference_type n) {
Chris@16:             it_ -= n;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         difference_type operator - (const indexed_const_iterator &it) const {
Chris@16:             BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
Chris@16:             return it_ - it.it_;
Chris@16:         }
Chris@16: 
Chris@16:         // Dereference
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator * () const {
Chris@16:             BOOST_UBLAS_CHECK (index () < (*this) ().size (), bad_index ());
Chris@16:             return (*this) () (it_);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator [] (difference_type n) const {
Chris@16:             return *((*this) + n);
Chris@16:         }
Chris@16: 
Chris@16:         // Index
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type index () const {
Chris@16:             return it_;
Chris@16:         }
Chris@16: 
Chris@16:         // Assignment
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator &operator = (const indexed_const_iterator &it) {
Chris@16:             // FIX: ICC needs full qualification?!
Chris@16:             // assign (&it ());
Chris@16:             container_const_reference<C>::assign (&it ());
Chris@16:             it_ = it.it_;
Chris@16:             return *this;
Chris@16:         }
Chris@16: 
Chris@16:         // Comparison
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator == (const indexed_const_iterator &it) const {
Chris@16:             BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
Chris@16:             return it_ == it.it_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator < (const indexed_const_iterator &it) const {
Chris@16:             BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
Chris@16:             return it_ < it.it_;
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         size_type it_;
Chris@16: 
Chris@16:         friend class indexed_iterator<container_type, iterator_category>;
Chris@16:     };
Chris@16: 
Chris@16:     template<class C, class IC>
Chris@16:     class indexed_iterator2;
Chris@16: 
Chris@16:   /** \brief A class implementing an indexed random access iterator 
Chris@16:    * of a matrix.
Chris@16:    *
Chris@16:    * \param C the (mutable) container type
Chris@16:    * \param IC the iterator category
Chris@16:    *
Chris@16:    * This class implements a random access iterator. The current
Chris@16:    * position is stored as two unsigned integers \c it1_ and \c it2_
Chris@16:    * and the values are accessed via \c operator()(it1_, it2_) of the
Chris@16:    * container. The iterator changes the first index.
Chris@16:    *
Chris@16:    * uBLAS extension: \c index1(), \c index2() and access to the
Chris@16:    * dual iterator via \c begin(), \c end(), \c rbegin() and \c rend()
Chris@16:    *
Chris@16:    * Note: The container has to support the \code find2(rank, i, j) \endcode 
Chris@16:    * method
Chris@16:    */
Chris@16: 
Chris@16:     template<class C, class IC>
Chris@16:     class indexed_iterator1:
Chris@16:         public container_reference<C>, 
Chris@16:         public random_access_iterator_base<IC,
Chris@16:                                            indexed_iterator1<C, IC>, 
Chris@16:                                            typename C::value_type,
Chris@16:                                            typename C::difference_type> {
Chris@16:     public:
Chris@16:         typedef C container_type;
Chris@16:         typedef IC iterator_category;
Chris@16:         typedef typename container_type::size_type size_type;
Chris@16:         typedef typename container_type::difference_type difference_type;
Chris@16:         typedef typename container_type::value_type value_type;
Chris@16:         typedef typename container_type::reference reference;
Chris@16: 
Chris@16:         typedef indexed_iterator2<container_type, iterator_category> dual_iterator_type;
Chris@16:         typedef reverse_iterator_base2<dual_iterator_type> dual_reverse_iterator_type;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator1 ():
Chris@16:             container_reference<container_type> (), it1_ (), it2_ () {}
Chris@16:         BOOST_UBLAS_INLINE 
Chris@16:         indexed_iterator1 (container_type &c, size_type it1, size_type it2):
Chris@16:             container_reference<container_type> (c), it1_ (it1), it2_ (it2) {}
Chris@16: 
Chris@16:         // Arithmetic
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator1 &operator ++ () {
Chris@16:             ++ it1_;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator1 &operator -- () {
Chris@16:             -- it1_;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator1 &operator += (difference_type n) {
Chris@16:             it1_ += n;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator1 &operator -= (difference_type n) {
Chris@16:             it1_ -= n;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         difference_type operator - (const indexed_iterator1 &it) const {
Chris@16:             BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
Chris@16:             BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
Chris@16:             return it1_ - it.it1_;
Chris@16:         }
Chris@16: 
Chris@16:         // Dereference
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator * () const {
Chris@16:             BOOST_UBLAS_CHECK (index1 () < (*this) ().size1 (), bad_index ());
Chris@16:             BOOST_UBLAS_CHECK (index2 () < (*this) ().size2 (), bad_index ());
Chris@16:             return (*this) () (it1_, it2_);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator [] (difference_type n) const {
Chris@16:             return *((*this) + n);
Chris@16:         }
Chris@16: 
Chris@16:         // Index
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type index1 () const {
Chris@16:             return it1_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type index2 () const {
Chris@16:             return it2_;
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_iterator_type begin () const {
Chris@16:             return (*this) ().find2 (1, index1 (), 0); 
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_iterator_type end () const {
Chris@16:             return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_reverse_iterator_type rbegin () const {
Chris@16:             return dual_reverse_iterator_type (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_reverse_iterator_type rend () const {
Chris@16:             return dual_reverse_iterator_type (begin ());
Chris@16:         }
Chris@16: 
Chris@16:         // Assignment
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator1 &operator = (const indexed_iterator1 &it) {
Chris@16:             // FIX: ICC needs full qualification?!
Chris@16:             // assign (&it ());
Chris@16:             container_reference<C>::assign (&it ());
Chris@16:             it1_ = it.it1_;
Chris@16:             it2_ = it.it2_;
Chris@16:             return *this;
Chris@16:         }
Chris@16: 
Chris@16:         // Comparison
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator == (const indexed_iterator1 &it) const {
Chris@16:             BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
Chris@16:             BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
Chris@16:             return it1_ == it.it1_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator < (const indexed_iterator1 &it) const {
Chris@16:             BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
Chris@16:             BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
Chris@16:             return it1_ < it.it1_;
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         size_type it1_;
Chris@16:         size_type it2_;
Chris@16:     };
Chris@16: 
Chris@16:     template<class C, class IC>
Chris@16:     class indexed_const_iterator2;
Chris@16: 
Chris@16:   /** \brief A class implementing an indexed random access iterator 
Chris@16:    * of a matrix.
Chris@16:    *
Chris@16:    * \param C the (immutable) container type
Chris@16:    * \param IC the iterator category
Chris@16:    *
Chris@16:    * This class implements a random access iterator. The current
Chris@16:    * position is stored as two unsigned integers \c it1_ and \c it2_
Chris@16:    * and the values are accessed via \c operator()(it1_, it2_) of the
Chris@16:    * container. The iterator changes the first index.
Chris@16:    *
Chris@16:    * uBLAS extension: \c index1(), \c index2() and access to the
Chris@16:    * dual iterator via \c begin(), \c end(), \c rbegin() and \c rend()
Chris@16:    *
Chris@16:    * Note 1: The container has to support the find2(rank, i, j) method
Chris@16:    *
Chris@16:    * Note 2: there is an automatic conversion from 
Chris@16:    * \c indexed_iterator1 to \c indexed_const_iterator1
Chris@16:    */
Chris@16: 
Chris@16:     template<class C, class IC>
Chris@16:     class indexed_const_iterator1:
Chris@16:         public container_const_reference<C>, 
Chris@16:         public random_access_iterator_base<IC,
Chris@16:                                            indexed_const_iterator1<C, IC>, 
Chris@16:                                            typename C::value_type,
Chris@16:                                            typename C::difference_type> {
Chris@16:     public:
Chris@16:         typedef C container_type;
Chris@16:         typedef IC iterator_category;
Chris@16:         typedef typename container_type::size_type size_type;
Chris@16:         typedef typename container_type::difference_type difference_type;
Chris@16:         typedef typename container_type::value_type value_type;
Chris@16:         typedef typename container_type::const_reference reference;
Chris@16: 
Chris@16:         typedef indexed_iterator1<container_type, iterator_category> iterator_type;
Chris@16:         typedef indexed_const_iterator2<container_type, iterator_category> dual_iterator_type;
Chris@16:         typedef reverse_iterator_base2<dual_iterator_type> dual_reverse_iterator_type;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator1 ():
Chris@16:             container_const_reference<container_type> (), it1_ (), it2_ () {}
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator1 (const container_type &c, size_type it1, size_type it2):
Chris@16:             container_const_reference<container_type> (c), it1_ (it1), it2_ (it2) {}
Chris@16:         BOOST_UBLAS_INLINE 
Chris@16:         indexed_const_iterator1 (const iterator_type &it):
Chris@16:             container_const_reference<container_type> (it ()), it1_ (it.index1 ()), it2_ (it.index2 ()) {}
Chris@16: 
Chris@16:         // Arithmetic
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator1 &operator ++ () {
Chris@16:             ++ it1_;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator1 &operator -- () {
Chris@16:             -- it1_;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator1 &operator += (difference_type n) {
Chris@16:             it1_ += n;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator1 &operator -= (difference_type n) {
Chris@16:             it1_ -= n;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         difference_type operator - (const indexed_const_iterator1 &it) const {
Chris@16:             BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
Chris@16:             BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
Chris@16:             return it1_ - it.it1_;
Chris@16:         }
Chris@16: 
Chris@16:         // Dereference
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator * () const {
Chris@16:             BOOST_UBLAS_CHECK (index1 () < (*this) ().size1 (), bad_index ());
Chris@16:             BOOST_UBLAS_CHECK (index2 () < (*this) ().size2 (), bad_index ());
Chris@16:             return (*this) () (it1_, it2_);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator [] (difference_type n) const {
Chris@16:             return *((*this) + n);
Chris@16:         }
Chris@16: 
Chris@16:         // Index
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type index1 () const {
Chris@16:             return it1_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type index2 () const {
Chris@16:             return it2_;
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_iterator_type begin () const {
Chris@16:             return (*this) ().find2 (1, index1 (), 0); 
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_iterator_type end () const {
Chris@16:             return (*this) ().find2 (1, index1 (), (*this) ().size2 ()); 
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_reverse_iterator_type rbegin () const {
Chris@16:             return dual_reverse_iterator_type (end ()); 
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_reverse_iterator_type rend () const {
Chris@16:             return dual_reverse_iterator_type (begin ()); 
Chris@16:         }
Chris@16: 
Chris@16:         // Assignment
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator1 &operator = (const indexed_const_iterator1 &it) {
Chris@16:             // FIX: ICC needs full qualification?!
Chris@16:             // assign (&it ());
Chris@16:             container_const_reference<C>::assign (&it ());
Chris@16:             it1_ = it.it1_;
Chris@16:             it2_ = it.it2_;
Chris@16:             return *this;
Chris@16:         }
Chris@16: 
Chris@16:         // Comparison
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator == (const indexed_const_iterator1 &it) const {
Chris@16:             BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
Chris@16:             BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
Chris@16:             return it1_ == it.it1_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator < (const indexed_const_iterator1 &it) const {
Chris@16:             BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
Chris@16:             BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
Chris@16:             return it1_ < it.it1_;
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         size_type it1_;
Chris@16:         size_type it2_;
Chris@16: 
Chris@16:         friend class indexed_iterator1<container_type, iterator_category>;
Chris@16:     };
Chris@16: 
Chris@16:   /** \brief A class implementing an indexed random access iterator 
Chris@16:    * of a matrix.
Chris@16:    *
Chris@16:    * \param C the (mutable) container type
Chris@16:    * \param IC the iterator category
Chris@16:    *
Chris@16:    * This class implements a random access iterator. The current
Chris@16:    * position is stored as two unsigned integers \c it1_ and \c it2_
Chris@16:    * and the values are accessed via \c operator()(it1_, it2_) of the
Chris@16:    * container. The iterator changes the second index.
Chris@16:    *
Chris@16:    * uBLAS extension: \c index1(), \c index2() and access to the
Chris@16:    * dual iterator via \c begin(), \c end(), \c rbegin() and \c rend()
Chris@16:    *
Chris@16:    * Note: The container has to support the find1(rank, i, j) method
Chris@16:    */
Chris@16:     template<class C, class IC>
Chris@16:     class indexed_iterator2:
Chris@16:         public container_reference<C>, 
Chris@16:         public random_access_iterator_base<IC,
Chris@16:                                            indexed_iterator2<C, IC>, 
Chris@16:                                            typename C::value_type,
Chris@16:                                            typename C::difference_type> {
Chris@16:     public:
Chris@16:         typedef C container_type;
Chris@16:         typedef IC iterator_category;
Chris@16:         typedef typename container_type::size_type size_type;
Chris@16:         typedef typename container_type::difference_type difference_type;
Chris@16:         typedef typename container_type::value_type value_type;
Chris@16:         typedef typename container_type::reference reference;
Chris@16: 
Chris@16:         typedef indexed_iterator1<container_type, iterator_category> dual_iterator_type;
Chris@16:         typedef reverse_iterator_base1<dual_iterator_type> dual_reverse_iterator_type;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator2 ():
Chris@16:             container_reference<container_type> (), it1_ (), it2_ () {}
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator2 (container_type &c, size_type it1, size_type it2):
Chris@16:             container_reference<container_type> (c), it1_ (it1), it2_ (it2) {}
Chris@16: 
Chris@16:         // Arithmetic
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator2 &operator ++ () {
Chris@16:             ++ it2_;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator2 &operator -- () {
Chris@16:             -- it2_;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator2 &operator += (difference_type n) {
Chris@16:             it2_ += n;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator2 &operator -= (difference_type n) {
Chris@16:             it2_ -= n;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         difference_type operator - (const indexed_iterator2 &it) const {
Chris@16:             BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
Chris@16:             BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
Chris@16:             return it2_ - it.it2_;
Chris@16:         }
Chris@16: 
Chris@16:         // Dereference
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator * () const {
Chris@16:             BOOST_UBLAS_CHECK (index1 () < (*this) ().size1 (), bad_index ());
Chris@16:             BOOST_UBLAS_CHECK (index2 () < (*this) ().size2 (), bad_index ());
Chris@16:             return (*this) () (it1_, it2_);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator [] (difference_type n) const {
Chris@16:             return *((*this) + n);
Chris@16:         }
Chris@16: 
Chris@16:         // Index
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type index1 () const {
Chris@16:             return it1_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type index2 () const {
Chris@16:             return it2_;
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_iterator_type begin () const {
Chris@16:             return (*this) ().find1 (1, 0, index2 ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_iterator_type end () const {
Chris@16:             return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_reverse_iterator_type rbegin () const {
Chris@16:             return dual_reverse_iterator_type (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_reverse_iterator_type rend () const {
Chris@16:             return dual_reverse_iterator_type (begin ());
Chris@16:         }
Chris@16: 
Chris@16:         // Assignment
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_iterator2 &operator = (const indexed_iterator2 &it) {
Chris@16:             // FIX: ICC needs full qualification?!
Chris@16:             // assign (&it ());
Chris@16:             container_reference<C>::assign (&it ());
Chris@16:             it1_ = it.it1_;
Chris@16:             it2_ = it.it2_;
Chris@16:             return *this;
Chris@16:         }
Chris@16: 
Chris@16:         // Comparison
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator == (const indexed_iterator2 &it) const {
Chris@16:             BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
Chris@16:             BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
Chris@16:             return it2_ == it.it2_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator < (const indexed_iterator2 &it) const {
Chris@16:             BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
Chris@16:             BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
Chris@16:             return it2_ < it.it2_;
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         size_type it1_;
Chris@16:         size_type it2_;
Chris@16:     };
Chris@16: 
Chris@16:   /** \brief A class implementing an indexed random access iterator 
Chris@16:    * of a matrix.
Chris@16:    *
Chris@16:    * \param C the (immutable) container type
Chris@16:    * \param IC the iterator category
Chris@16:    *
Chris@16:    * This class implements a random access iterator. The current
Chris@16:    * position is stored as two unsigned integers \c it1_ and \c it2_
Chris@16:    * and the values are accessed via \c operator()(it1_, it2_) of the
Chris@16:    * container. The iterator changes the second index.
Chris@16:    *
Chris@16:    * uBLAS extension: \c index1(), \c index2() and access to the
Chris@16:    * dual iterator via \c begin(), \c end(), \c rbegin() and \c rend()
Chris@16:    *
Chris@16:    * Note 1: The container has to support the \c find2(rank, i, j) method
Chris@16:    *
Chris@16:    * Note 2: there is an automatic conversion from 
Chris@16:    * \c indexed_iterator2 to \c indexed_const_iterator2
Chris@16:    */
Chris@16: 
Chris@16:     template<class C, class IC>
Chris@16:     class indexed_const_iterator2:
Chris@16:         public container_const_reference<C>,
Chris@16:         public random_access_iterator_base<IC,
Chris@16:                                            indexed_const_iterator2<C, IC>,
Chris@16:                                            typename C::value_type,
Chris@16:                                            typename C::difference_type> {
Chris@16:     public:
Chris@16:         typedef C container_type;
Chris@16:         typedef IC iterator_category;
Chris@16:         typedef typename container_type::size_type size_type;
Chris@16:         typedef typename container_type::difference_type difference_type;
Chris@16:         typedef typename container_type::value_type value_type;
Chris@16:         typedef typename container_type::const_reference reference;
Chris@16: 
Chris@16:         typedef indexed_iterator2<container_type, iterator_category> iterator_type;
Chris@16:         typedef indexed_const_iterator1<container_type, iterator_category> dual_iterator_type;
Chris@16:         typedef reverse_iterator_base1<dual_iterator_type> dual_reverse_iterator_type;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator2 ():
Chris@16:             container_const_reference<container_type> (), it1_ (), it2_ () {}
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator2 (const container_type &c, size_type it1, size_type it2):
Chris@16:             container_const_reference<container_type> (c), it1_ (it1), it2_ (it2) {}
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator2 (const iterator_type &it):
Chris@16:             container_const_reference<container_type> (it ()), it1_ (it.index1 ()), it2_ (it.index2 ()) {}
Chris@16: 
Chris@16:         // Arithmetic
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator2 &operator ++ () {
Chris@16:             ++ it2_;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator2 &operator -- () {
Chris@16:             -- it2_;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator2 &operator += (difference_type n) {
Chris@16:             it2_ += n;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator2 &operator -= (difference_type n) {
Chris@16:             it2_ -= n;
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         difference_type operator - (const indexed_const_iterator2 &it) const {
Chris@16:             BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
Chris@16:             BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
Chris@16:             return it2_ - it.it2_;
Chris@16:         }
Chris@16: 
Chris@16:         // Dereference
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator * () const {
Chris@16:             BOOST_UBLAS_CHECK (index1 () < (*this) ().size1 (), bad_index ());
Chris@16:             BOOST_UBLAS_CHECK (index2 () < (*this) ().size2 (), bad_index ());
Chris@16:             return (*this) () (it1_, it2_);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator [] (difference_type n) const {
Chris@16:             return *((*this) + n);
Chris@16:         }
Chris@16: 
Chris@16:         // Index
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type index1 () const {
Chris@16:             return it1_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type index2 () const {
Chris@16:             return it2_;
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_iterator_type begin () const {
Chris@16:             return (*this) ().find1 (1, 0, index2 ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_iterator_type end () const {
Chris@16:             return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_reverse_iterator_type rbegin () const {
Chris@16:             return dual_reverse_iterator_type (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         dual_reverse_iterator_type rend () const {
Chris@16:             return dual_reverse_iterator_type (begin ());
Chris@16:         }
Chris@16: 
Chris@16:         // Assignment
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indexed_const_iterator2 &operator = (const indexed_const_iterator2 &it) {
Chris@16:             // FIX: ICC needs full qualification?!
Chris@16:             // assign (&it ());
Chris@16:             container_const_reference<C>::assign (&it ());
Chris@16:             it1_ = it.it1_;
Chris@16:             it2_ = it.it2_;
Chris@16:             return *this;
Chris@16:         }
Chris@16: 
Chris@16:         // Comparison
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator == (const indexed_const_iterator2 &it) const {
Chris@16:             BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
Chris@16:             BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
Chris@16:             return it2_ == it.it2_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator < (const indexed_const_iterator2 &it) const {
Chris@16:             BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
Chris@16:             BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
Chris@16:             return it2_ < it.it2_;
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         size_type it1_;
Chris@16:         size_type it2_;
Chris@16: 
Chris@16:         friend class indexed_iterator2<container_type, iterator_category>;
Chris@16:     };
Chris@16: 
Chris@16: }}}
Chris@16: 
Chris@16: #endif