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_VECTOR_EXPRESSION_
Chris@16: #define _BOOST_UBLAS_VECTOR_EXPRESSION_
Chris@16: 
Chris@16: #include <boost/numeric/ublas/expression_types.hpp>
Chris@16: 
Chris@16: 
Chris@16: // Expression templates based on ideas of Todd Veldhuizen and Geoffrey Furnish
Chris@16: // Iterators based on ideas of Jeremy Siek
Chris@16: //
Chris@16: // Classes that model the Vector Expression concept
Chris@16: 
Chris@16: namespace boost { namespace numeric { namespace ublas {
Chris@16: 
Chris@16:     template<class E>
Chris@16:     class vector_reference:
Chris@16:         public vector_expression<vector_reference<E> > {
Chris@16: 
Chris@16:         typedef vector_reference<E> self_type;
Chris@16:     public:
Chris@16: #ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
Chris@16:         using vector_expression<vector_reference<E> >::operator ();
Chris@16: #endif
Chris@16:         typedef typename E::size_type size_type;
Chris@16:         typedef typename E::difference_type difference_type;
Chris@16:         typedef typename E::value_type value_type;
Chris@16:         typedef typename E::const_reference const_reference;
Chris@16:         typedef typename boost::mpl::if_<boost::is_const<E>,
Chris@16:                                           typename E::const_reference,
Chris@16:                                           typename E::reference>::type reference;
Chris@16:         typedef E referred_type;
Chris@16:         typedef const self_type const_closure_type;
Chris@16:         typedef self_type closure_type;
Chris@16:         typedef typename E::storage_category storage_category;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         explicit vector_reference (referred_type &e):
Chris@16:             e_ (e) {}
Chris@16: 
Chris@16:         // Accessors
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type size () const {
Chris@16:             return expression ().size ();
Chris@16:         }
Chris@16: 
Chris@16:     public:
Chris@16:         // Expression accessors - const correct
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const referred_type &expression () const {
Chris@16:             return e_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         referred_type &expression () {
Chris@16:             return e_;
Chris@16:         }
Chris@16: 
Chris@16:     public:
Chris@16:         // Element access
Chris@16: #ifndef BOOST_UBLAS_REFERENCE_CONST_MEMBER
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator () (size_type i) const {
Chris@16:             return expression () (i);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator () (size_type i) {
Chris@16:             return expression () (i);
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator [] (size_type i) const {
Chris@16:             return expression () [i];
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator [] (size_type i) {
Chris@16:             return expression () [i];
Chris@16:         }
Chris@16: #else
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator () (size_type i) const {
Chris@16:             return expression () (i);
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator [] (size_type i) const {
Chris@16:             return expression () [i];
Chris@16:         }
Chris@16: #endif
Chris@16: 
Chris@16:         // Assignment
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         vector_reference &operator = (const vector_reference &v) {
Chris@16:             expression ().operator = (v);
Chris@16:             return *this;
Chris@16:         }
Chris@16:         template<class AE>
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         vector_reference &operator = (const vector_expression<AE> &ae) {
Chris@16:             expression ().operator = (ae);
Chris@16:             return *this;
Chris@16:         }
Chris@16:         template<class AE>
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         vector_reference &assign (const vector_expression<AE> &ae) {
Chris@16:             expression ().assign (ae);
Chris@16:             return *this;
Chris@16:         }
Chris@16:         template<class AE>
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         vector_reference &operator += (const vector_expression<AE> &ae) {
Chris@16:             expression ().operator += (ae);
Chris@16:             return *this;
Chris@16:         }
Chris@16:         template<class AE>
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         vector_reference &plus_assign (const vector_expression<AE> &ae) {
Chris@16:             expression ().plus_assign (ae);
Chris@16:             return *this;
Chris@16:         }
Chris@16:         template<class AE>
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         vector_reference &operator -= (const vector_expression<AE> &ae) {
Chris@16:             expression ().operator -= (ae);
Chris@16:             return *this;
Chris@16:         }
Chris@16:         template<class AE>
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         vector_reference &minus_assign (const vector_expression<AE> &ae) {
Chris@16:             expression ().minus_assign (ae);
Chris@16:             return *this;
Chris@16:         }
Chris@16:         template<class AT>
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         vector_reference &operator *= (const AT &at) {
Chris@16:             expression ().operator *= (at);
Chris@16:             return *this;
Chris@16:         }
Chris@16:         template<class AT>
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         vector_reference &operator /= (const AT &at) {
Chris@16:             expression ().operator /= (at);
Chris@16:             return *this;
Chris@16:         }
Chris@16: 
Chris@16:         // Swapping
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void swap (vector_reference &v) {
Chris@16:             expression ().swap (v.expression ());
Chris@16:         }
Chris@16: 
Chris@16:         // Closure comparison
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool same_closure (const vector_reference &vr) const {
Chris@16:             return &(*this).e_ == &vr.e_;
Chris@16:         }
Chris@16: 
Chris@16:         // Iterator types
Chris@16:         typedef typename E::const_iterator const_iterator;
Chris@16:         typedef typename boost::mpl::if_<boost::is_const<E>,
Chris@16:                                           typename E::const_iterator,
Chris@16:                                           typename E::iterator>::type iterator;
Chris@16: 
Chris@16:         // Element lookup
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator find (size_type i) const {
Chris@16:             return expression ().find (i);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         iterator find (size_type i) {
Chris@16:             return expression ().find (i);
Chris@16:         }
Chris@16: 
Chris@16:         // Iterator is the iterator of the referenced expression.
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator begin () const {
Chris@16:             return expression ().begin ();
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cbegin () const {
Chris@101:             return begin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator end () const {
Chris@16:             return expression ().end ();
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cend () const {
Chris@101:             return end ();
Chris@101:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         iterator begin () {
Chris@16:             return expression ().begin ();
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         iterator end () {
Chris@16:             return expression ().end ();
Chris@16:         }
Chris@16: 
Chris@16:         // Reverse iterator
Chris@16:         typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
Chris@16:         typedef reverse_iterator_base<iterator> reverse_iterator;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rbegin () const {
Chris@16:             return const_reverse_iterator (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crbegin () const {
Chris@101:             return rbegin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rend () const {
Chris@16:             return const_reverse_iterator (begin ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crend () const {
Chris@101:             return rend ();
Chris@101:         }
Chris@101: 
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator rbegin () {
Chris@16:             return reverse_iterator (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator rend () {
Chris@16:             return reverse_iterator (begin ());
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         referred_type &e_;
Chris@16:     };
Chris@16: 
Chris@16: 
Chris@16:     template<class E, class F>
Chris@16:     class vector_unary:
Chris@16:         public vector_expression<vector_unary<E, F> > {
Chris@16: 
Chris@16:         typedef F functor_type;
Chris@16:         typedef typename boost::mpl::if_<boost::is_same<F, scalar_identity<typename E::value_type> >,
Chris@16:                                           E,
Chris@16:                                           const E>::type expression_type;
Chris@16:         typedef typename boost::mpl::if_<boost::is_const<expression_type>,
Chris@16:                                           typename E::const_closure_type,
Chris@16:                                           typename E::closure_type>::type expression_closure_type;
Chris@16:         typedef vector_unary<E, F> self_type;
Chris@16:     public:
Chris@16: #ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
Chris@16:         using vector_expression<vector_unary<E, F> >::operator ();
Chris@16: #endif
Chris@16:         typedef typename E::size_type size_type;
Chris@16:         typedef typename E::difference_type difference_type;
Chris@16:         typedef typename F::result_type value_type;
Chris@16:         typedef value_type const_reference;
Chris@16:         typedef typename boost::mpl::if_<boost::is_same<F, scalar_identity<value_type> >,
Chris@16:                                           typename E::reference,
Chris@16:                                           value_type>::type reference;
Chris@16:         typedef const self_type const_closure_type;
Chris@16:         typedef self_type closure_type;
Chris@16:         typedef unknown_storage_tag storage_category;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         // May be used as mutable expression.
Chris@16:         explicit vector_unary (expression_type &e):
Chris@16:             e_ (e) {}
Chris@16: 
Chris@16:         // Accessors
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type size () const {
Chris@16:             return e_.size ();
Chris@16:         }
Chris@16: 
Chris@16:     public:
Chris@16:         // Expression accessors
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const expression_closure_type &expression () const {
Chris@16:             return e_;
Chris@16:         }
Chris@16: 
Chris@16:     public:
Chris@16:         // Element access
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator () (size_type i) const {
Chris@16:             return functor_type::apply (e_ (i));
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator () (size_type i) {
Chris@16:             BOOST_STATIC_ASSERT ((boost::is_same<functor_type, scalar_identity<value_type > >::value));
Chris@16:             return e_ (i);
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator [] (size_type i) const {
Chris@16:             return functor_type::apply (e_ [i]);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator [] (size_type i) {
Chris@16:             BOOST_STATIC_ASSERT ((boost::is_same<functor_type, scalar_identity<value_type > >::value));
Chris@16:             return e_ [i];
Chris@16:         }
Chris@16: 
Chris@16:         // Closure comparison
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool same_closure (const vector_unary &vu) const {
Chris@16:             return (*this).expression ().same_closure (vu.expression ());
Chris@16:         }
Chris@16: 
Chris@16:         // Iterator types
Chris@16:     private:
Chris@16:         typedef typename E::const_iterator const_subiterator_type;
Chris@16:         typedef const value_type *const_pointer;
Chris@16: 
Chris@16:     public:
Chris@16: #ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
Chris@16:         typedef indexed_const_iterator<const_closure_type, typename const_subiterator_type::iterator_category> const_iterator;
Chris@16:         typedef const_iterator iterator;
Chris@16: #else
Chris@16:         class const_iterator;
Chris@16:         typedef const_iterator iterator;
Chris@16: #endif
Chris@16: 
Chris@16:         // Element lookup
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator find (size_type i) const {
Chris@16: #ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
Chris@16:             const_subiterator_type it (e_.find (i));
Chris@16:             return const_iterator (*this, it.index ());
Chris@16: #else
Chris@16:             return const_iterator (*this, e_.find (i));
Chris@16: #endif
Chris@16:         }
Chris@16: 
Chris@16:         // Iterator enhances the iterator of the referenced expression
Chris@16:         // with the unary functor.
Chris@16: 
Chris@16: #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
Chris@16:         class const_iterator:
Chris@16:             public container_const_reference<vector_unary>,
Chris@16:             public iterator_base_traits<typename E::const_iterator::iterator_category>::template
Chris@16:                         iterator_base<const_iterator, value_type>::type {
Chris@16:         public:
Chris@16:             typedef typename E::const_iterator::iterator_category iterator_category;
Chris@16:             typedef typename vector_unary::difference_type difference_type;
Chris@16:             typedef typename vector_unary::value_type value_type;
Chris@16:             typedef typename vector_unary::const_reference reference;
Chris@16:             typedef typename vector_unary::const_pointer pointer;
Chris@16: 
Chris@16:             // Construction and destruction
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator ():
Chris@16:                 container_const_reference<self_type> (), it_ () {}
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator (const self_type &vu, const const_subiterator_type &it):
Chris@16:                 container_const_reference<self_type> (vu), it_ (it) {}
Chris@16: 
Chris@16:             // Arithmetic
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator ++ () {
Chris@16:                 ++ it_;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator -- () {
Chris@16:                 -- it_;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator += (difference_type n) {
Chris@16:                 it_ += n;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             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 const_iterator &it) const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
Chris@16:                 return it_ - it.it_;
Chris@16:             }
Chris@16: 
Chris@16:             // Dereference
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_reference operator * () const {
Chris@16:                 return functor_type::apply (*it_);
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_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_.index ();
Chris@16:             }
Chris@16: 
Chris@16:             // Assignment
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator = (const const_iterator &it) {
Chris@16:                 container_const_reference<self_type>::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 const_iterator &it) const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
Chris@16:                 return it_ == it.it_;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             bool operator < (const const_iterator &it) const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
Chris@16:                 return it_ < it.it_;
Chris@16:             }
Chris@16: 
Chris@16:         private:
Chris@16:             const_subiterator_type it_;
Chris@16:         };
Chris@16: #endif
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator begin () const {
Chris@16:             return find (0); 
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cbegin () const {
Chris@101:             return begin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator end () const {
Chris@16:             return find (size ());
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cend () const {
Chris@101:             return end ();
Chris@101:         }
Chris@16: 
Chris@16:         // Reverse iterator
Chris@16:         typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rbegin () const {
Chris@16:             return const_reverse_iterator (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crbegin () const {
Chris@101:             return rbegin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rend () const {
Chris@16:             return const_reverse_iterator (begin ());
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crend () const {
Chris@101:             return rend ();
Chris@101:         }
Chris@16: 
Chris@16:     private:
Chris@16:         expression_closure_type e_;
Chris@16:     };
Chris@16: 
Chris@16:     template<class E, class F>
Chris@16:     struct vector_unary_traits {
Chris@16:         typedef vector_unary<E, F> expression_type;
Chris@16: //FIXME
Chris@16: // #ifndef BOOST_UBLAS_SIMPLE_ET_DEBUG
Chris@16:         typedef expression_type result_type;
Chris@16: // #else
Chris@16: //         typedef typename E::vector_temporary_type result_type;
Chris@16: // #endif
Chris@16:     };
Chris@16: 
Chris@16:     // (- v) [i] = - v [i]
Chris@16:     template<class E> 
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename vector_unary_traits<E, scalar_negate<typename E::value_type> >::result_type
Chris@16:     operator - (const vector_expression<E> &e) {
Chris@16:         typedef typename vector_unary_traits<E, scalar_negate<typename E::value_type> >::expression_type expression_type;
Chris@16:         return expression_type (e ());
Chris@16:     }
Chris@16: 
Chris@16:     // (conj v) [i] = conj (v [i])
Chris@16:     template<class E> 
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename vector_unary_traits<E, scalar_conj<typename E::value_type> >::result_type
Chris@16:     conj (const vector_expression<E> &e) {
Chris@16:         typedef typename vector_unary_traits<E, scalar_conj<typename E::value_type> >::expression_type expression_type;
Chris@16:         return expression_type (e ());
Chris@16:     }
Chris@16: 
Chris@16:     // (real v) [i] = real (v [i])
Chris@16:     template<class E>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename vector_unary_traits<E, scalar_real<typename E::value_type> >::result_type
Chris@16:     real (const vector_expression<E> &e) {
Chris@16:         typedef typename vector_unary_traits<E, scalar_real<typename E::value_type> >::expression_type expression_type;
Chris@16:         return expression_type (e ());
Chris@16:     }
Chris@16: 
Chris@16:     // (imag v) [i] = imag (v [i])
Chris@16:     template<class E>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename vector_unary_traits<E, scalar_imag<typename E::value_type> >::result_type
Chris@16:     imag (const vector_expression<E> &e) {
Chris@16:         typedef typename vector_unary_traits<E, scalar_imag<typename E::value_type> >::expression_type expression_type;
Chris@16:         return expression_type (e ());
Chris@16:     }
Chris@16: 
Chris@16:     // (trans v) [i] = v [i]
Chris@16:     template<class E>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename vector_unary_traits<const E, scalar_identity<typename E::value_type> >::result_type
Chris@16:     trans (const vector_expression<E> &e) {
Chris@16:         typedef typename vector_unary_traits<const E, scalar_identity<typename E::value_type> >::expression_type expression_type;
Chris@16:         return expression_type (e ());
Chris@16:     }
Chris@16:     template<class E>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename vector_unary_traits<E, scalar_identity<typename E::value_type> >::result_type
Chris@16:     trans (vector_expression<E> &e) {
Chris@16:         typedef typename vector_unary_traits<E, scalar_identity<typename E::value_type> >::expression_type expression_type;
Chris@16:         return expression_type (e ());
Chris@16:     }
Chris@16: 
Chris@16:     // (herm v) [i] = conj (v [i])
Chris@16:     template<class E>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename vector_unary_traits<E, scalar_conj<typename E::value_type> >::result_type
Chris@16:     herm (const vector_expression<E> &e) {
Chris@16:         typedef typename vector_unary_traits<E, scalar_conj<typename E::value_type> >::expression_type expression_type;
Chris@16:         return expression_type (e ());
Chris@16:     }
Chris@16: 
Chris@16:     template<class E1, class E2, class F>
Chris@16:     class vector_binary:
Chris@16:         public vector_expression<vector_binary<E1, E2, F> > {
Chris@16: 
Chris@16:         typedef E1 expression1_type;
Chris@16:         typedef E2 expression2_type;
Chris@16:         typedef F functor_type;
Chris@16:         typedef typename E1::const_closure_type expression1_closure_type;
Chris@16:         typedef typename E2::const_closure_type expression2_closure_type;
Chris@16:         typedef vector_binary<E1, E2, F> self_type;
Chris@16:     public:
Chris@16: #ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
Chris@16:         using vector_expression<vector_binary<E1, E2, F> >::operator ();
Chris@16: #endif
Chris@16:         typedef typename promote_traits<typename E1::size_type, typename E2::size_type>::promote_type size_type;
Chris@16:         typedef typename promote_traits<typename E1::difference_type, typename E2::difference_type>::promote_type difference_type;
Chris@16:         typedef typename F::result_type value_type;
Chris@16:         typedef value_type const_reference;
Chris@16:         typedef const_reference reference;
Chris@16:         typedef const self_type const_closure_type;
Chris@16:         typedef const_closure_type closure_type;
Chris@16:         typedef unknown_storage_tag storage_category;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         vector_binary (const expression1_type &e1, const expression2_type &e2):
Chris@16:             e1_ (e1), e2_ (e2) {}
Chris@16: 
Chris@16:         // Accessors
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type size () const { 
Chris@16:             return BOOST_UBLAS_SAME (e1_.size (), e2_.size ()); 
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         // Accessors
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const expression1_closure_type &expression1 () const {
Chris@16:             return e1_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const expression2_closure_type &expression2 () const {
Chris@16:             return e2_;
Chris@16:         }
Chris@16: 
Chris@16:     public:
Chris@16:         // Element access
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator () (size_type i) const {
Chris@16:             return functor_type::apply (e1_ (i), e2_ (i));
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator [] (size_type i) const {
Chris@16:             return functor_type::apply (e1_ [i], e2_ [i]);
Chris@16:         }
Chris@16: 
Chris@16:         // Closure comparison
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool same_closure (const vector_binary &vb) const {
Chris@16:             return (*this).expression1 ().same_closure (vb.expression1 ()) &&
Chris@16:                    (*this).expression2 ().same_closure (vb.expression2 ());
Chris@16:         }
Chris@16: 
Chris@16:         // Iterator types
Chris@16:     private:
Chris@16:         typedef typename E1::const_iterator const_subiterator1_type;
Chris@16:         typedef typename E2::const_iterator const_subiterator2_type;
Chris@16:         typedef const value_type *const_pointer;
Chris@16: 
Chris@16:     public:
Chris@16: #ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
Chris@16:         typedef typename iterator_restrict_traits<typename const_subiterator1_type::iterator_category,
Chris@16:                                                   typename const_subiterator2_type::iterator_category>::iterator_category iterator_category;
Chris@16:         typedef indexed_const_iterator<const_closure_type, iterator_category> const_iterator;
Chris@16:         typedef const_iterator iterator;
Chris@16: #else
Chris@16:         class const_iterator;
Chris@16:         typedef const_iterator iterator;
Chris@16: #endif
Chris@16: 
Chris@16:         // Element lookup
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator find (size_type i) const {
Chris@16:             const_subiterator1_type it1 (e1_.find (i));
Chris@16:             const_subiterator1_type it1_end (e1_.find (size ()));
Chris@16:             const_subiterator2_type it2 (e2_.find (i));
Chris@16:             const_subiterator2_type it2_end (e2_.find (size ()));
Chris@16:             i = (std::min) (it1 != it1_end ? it1.index () : size (),
Chris@16:                           it2 != it2_end ? it2.index () : size ());
Chris@16: #ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
Chris@16:             return const_iterator (*this, i);
Chris@16: #else
Chris@16:             return const_iterator (*this, i, it1, it1_end, it2, it2_end);
Chris@16: #endif
Chris@16:         }
Chris@16: 
Chris@16:         // Iterator merges the iterators of the referenced expressions and
Chris@16:         // enhances them with the binary functor.
Chris@16: 
Chris@16: #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
Chris@16:         class const_iterator:
Chris@16:             public container_const_reference<vector_binary>,
Chris@16:             public iterator_base_traits<typename iterator_restrict_traits<typename E1::const_iterator::iterator_category,
Chris@16:                                                                           typename E2::const_iterator::iterator_category>::iterator_category>::template
Chris@16:                         iterator_base<const_iterator, value_type>::type {
Chris@16:         public:
Chris@16:             typedef typename iterator_restrict_traits<typename E1::const_iterator::iterator_category,
Chris@16:                                                       typename E2::const_iterator::iterator_category>::iterator_category iterator_category;
Chris@16:             typedef typename vector_binary::difference_type difference_type;
Chris@16:             typedef typename vector_binary::value_type value_type;
Chris@16:             typedef typename vector_binary::const_reference reference;
Chris@16:             typedef typename vector_binary::const_pointer pointer;
Chris@16: 
Chris@16:             // Construction and destruction
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator ():
Chris@16:                 container_const_reference<self_type> (), i_ (), it1_ (), it1_end_ (), it2_ (), it2_end_ () {}
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator (const self_type &vb, size_type i,
Chris@16:                             const const_subiterator1_type &it1, const const_subiterator1_type &it1_end,
Chris@16:                             const const_subiterator2_type &it2, const const_subiterator2_type &it2_end):
Chris@16:                 container_const_reference<self_type> (vb), i_ (i), it1_ (it1), it1_end_ (it1_end), it2_ (it2), it2_end_ (it2_end) {}
Chris@16: 
Chris@16:         private: 
Chris@16:             // Dense specializations
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             void increment (dense_random_access_iterator_tag) {
Chris@16:                 ++ i_; ++ it1_; ++ it2_;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             void decrement (dense_random_access_iterator_tag) {
Chris@16:                 -- i_; -- it1_; -- it2_;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             void increment (dense_random_access_iterator_tag, difference_type n) {
Chris@16:                 i_ += n; it1_ += n; it2_ += n;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             void decrement (dense_random_access_iterator_tag, difference_type n) {
Chris@16:                 i_ -= n; it1_ -= n; it2_ -= n;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             value_type dereference (dense_random_access_iterator_tag) const {
Chris@16:                 return functor_type::apply (*it1_, *it2_);
Chris@16:             }
Chris@16: 
Chris@16:             // Packed specializations
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             void increment (packed_random_access_iterator_tag) {
Chris@16:                 if (it1_ != it1_end_)
Chris@16:                     if (it1_.index () <= i_)
Chris@16:                         ++ it1_;
Chris@16:                 if (it2_ != it2_end_)
Chris@16:                     if (it2_.index () <= i_)
Chris@16:                         ++ it2_;
Chris@16:                 ++ i_;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             void decrement (packed_random_access_iterator_tag) {
Chris@16:                 if (it1_ != it1_end_)
Chris@16:                     if (i_ <= it1_.index ())
Chris@16:                         -- it1_;
Chris@16:                 if (it2_ != it2_end_)
Chris@16:                     if (i_ <= it2_.index ())
Chris@16:                         -- it2_;
Chris@16:                 -- i_;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             void increment (packed_random_access_iterator_tag, difference_type n) {
Chris@16:                 while (n > 0) {
Chris@16:                     increment (packed_random_access_iterator_tag ());
Chris@16:                     --n;
Chris@16:                 }
Chris@16:                 while (n < 0) {
Chris@16:                     decrement (packed_random_access_iterator_tag ());
Chris@16:                     ++n;
Chris@16:                 }
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             void decrement (packed_random_access_iterator_tag, difference_type n) {
Chris@16:                 while (n > 0) {
Chris@16:                     decrement (packed_random_access_iterator_tag ());
Chris@16:                     --n;
Chris@16:                 }
Chris@16:                 while (n < 0) {
Chris@16:                     increment (packed_random_access_iterator_tag ());
Chris@16:                     ++n;
Chris@16:                 }
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             value_type dereference (packed_random_access_iterator_tag) const {
Chris@16:                 value_type t1 = value_type/*zero*/();
Chris@16:                 if (it1_ != it1_end_)
Chris@16:                     if (it1_.index () == i_)
Chris@16:                         t1 = *it1_;
Chris@16:                 value_type t2 = value_type/*zero*/();
Chris@16:                 if (it2_ != it2_end_)
Chris@16:                     if (it2_.index () == i_)
Chris@16:                         t2 = *it2_;
Chris@16:                 return functor_type::apply (t1, t2);
Chris@16:             }
Chris@16: 
Chris@16:             // Sparse specializations
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             void increment (sparse_bidirectional_iterator_tag) {
Chris@16:                 size_type index1 = (*this) ().size ();
Chris@16:                 if (it1_ != it1_end_) {
Chris@16:                     if  (it1_.index () <= i_)
Chris@16:                         ++ it1_;
Chris@16:                     if (it1_ != it1_end_)
Chris@16:                         index1 = it1_.index ();
Chris@16:                 }
Chris@16:                 size_type index2 = (*this) ().size ();
Chris@16:                 if (it2_ != it2_end_) {
Chris@16:                     if (it2_.index () <= i_)
Chris@16:                         ++ it2_;
Chris@16:                     if (it2_ != it2_end_)
Chris@16:                         index2 = it2_.index ();
Chris@16:                 }
Chris@16:                 i_ = (std::min) (index1, index2);
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             void decrement (sparse_bidirectional_iterator_tag) {
Chris@16:                 size_type index1 = (*this) ().size ();
Chris@16:                 if (it1_ != it1_end_) {
Chris@16:                     if (i_ <= it1_.index ())
Chris@16:                         -- it1_;
Chris@16:                     if (it1_ != it1_end_)
Chris@16:                         index1 = it1_.index ();
Chris@16:                 }
Chris@16:                 size_type index2 = (*this) ().size ();
Chris@16:                 if (it2_ != it2_end_) {
Chris@16:                     if (i_ <= it2_.index ())
Chris@16:                         -- it2_;
Chris@16:                     if (it2_ != it2_end_)
Chris@16:                         index2 = it2_.index ();
Chris@16:                 }
Chris@16:                 i_ = (std::max) (index1, index2);
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             void increment (sparse_bidirectional_iterator_tag, difference_type n) {
Chris@16:                 while (n > 0) {
Chris@16:                     increment (sparse_bidirectional_iterator_tag ());
Chris@16:                     --n;
Chris@16:                 }
Chris@16:                 while (n < 0) {
Chris@16:                     decrement (sparse_bidirectional_iterator_tag ());
Chris@16:                     ++n;
Chris@16:                 }
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             void decrement (sparse_bidirectional_iterator_tag, difference_type n) {
Chris@16:                 while (n > 0) {
Chris@16:                     decrement (sparse_bidirectional_iterator_tag ());
Chris@16:                     --n;
Chris@16:                 }
Chris@16:                 while (n < 0) {
Chris@16:                     increment (sparse_bidirectional_iterator_tag ());
Chris@16:                     ++n;
Chris@16:                 }
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             value_type dereference (sparse_bidirectional_iterator_tag) const {
Chris@16:                 value_type t1 = value_type/*zero*/();
Chris@16:                 if (it1_ != it1_end_)
Chris@16:                     if (it1_.index () == i_)
Chris@16:                         t1 = *it1_;
Chris@16:                 value_type t2 = value_type/*zero*/();
Chris@16:                 if (it2_ != it2_end_)
Chris@16:                     if (it2_.index () == i_)
Chris@16:                         t2 = *it2_;
Chris@16:                 return functor_type::apply (t1, t2);
Chris@16:             }
Chris@16: 
Chris@16:         public: 
Chris@16:             // Arithmetic
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator ++ () {
Chris@16:                 increment (iterator_category ());
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator -- () {
Chris@16:                 decrement (iterator_category ());
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator += (difference_type n) {
Chris@16:                 increment (iterator_category (), n);
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator -= (difference_type n) {
Chris@16:                 decrement (iterator_category (), n);
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             difference_type operator - (const const_iterator &it) const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
Chris@16:                 return index () - it.index ();
Chris@16:             }
Chris@16: 
Chris@16:             // Dereference
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_reference operator * () const {
Chris@16:                 return dereference (iterator_category ());
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_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 i_;
Chris@16:             }
Chris@16: 
Chris@16:             // Assignment
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator = (const const_iterator &it) {
Chris@16:                 container_const_reference<self_type>::assign (&it ());
Chris@16:                 i_ = it.i_;
Chris@16:                 it1_ = it.it1_;
Chris@16:                 it1_end_ = it.it1_end_;
Chris@16:                 it2_ = it.it2_;
Chris@16:                 it2_end_ = it.it2_end_;
Chris@16:                 return *this;
Chris@16:             }
Chris@16: 
Chris@16:             // Comparison
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             bool operator == (const const_iterator &it) const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
Chris@16:                 return index () == it.index ();
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             bool operator < (const const_iterator &it) const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
Chris@16:                 return index () < it.index ();
Chris@16:             }
Chris@16: 
Chris@16:         private:
Chris@16:             size_type i_;
Chris@16:             const_subiterator1_type it1_;
Chris@16:             const_subiterator1_type it1_end_;
Chris@16:             const_subiterator2_type it2_;
Chris@16:             const_subiterator2_type it2_end_;
Chris@16:         };
Chris@16: #endif
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator begin () const {
Chris@16:             return find (0);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cbegin () const {
Chris@101:             return begin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator end () const {
Chris@16:             return find (size ());
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cend () const {
Chris@101:             return end ();
Chris@101:         }
Chris@16: 
Chris@16:         // Reverse iterator
Chris@16:         typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rbegin () const {
Chris@16:             return const_reverse_iterator (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crbegin () const {
Chris@101:             return rbegin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rend () const {
Chris@16:             return const_reverse_iterator (begin ());
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crend () const {
Chris@101:             return rend ();
Chris@101:         }
Chris@16: 
Chris@16:     private:
Chris@16:         expression1_closure_type e1_;
Chris@16:         expression2_closure_type e2_;
Chris@16:     };
Chris@16: 
Chris@16:     template<class E1, class E2, class F>
Chris@16:     struct vector_binary_traits {
Chris@16:         typedef vector_binary<E1, E2, F> expression_type;
Chris@16: #ifndef BOOST_UBLAS_SIMPLE_ET_DEBUG
Chris@16:         typedef expression_type result_type; 
Chris@16: #else
Chris@16:         typedef typename E1::vector_temporary_type result_type;
Chris@16: #endif
Chris@16:     };
Chris@16: 
Chris@16:     // (v1 + v2) [i] = v1 [i] + v2 [i]
Chris@16:     template<class E1, class E2>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename vector_binary_traits<E1, E2, scalar_plus<typename E1::value_type, 
Chris@16:                                                       typename E2::value_type> >::result_type
Chris@16:     operator + (const vector_expression<E1> &e1,
Chris@16:                 const vector_expression<E2> &e2) {
Chris@16:         typedef typename vector_binary_traits<E1, E2, scalar_plus<typename E1::value_type,
Chris@16:                                                                               typename E2::value_type> >::expression_type expression_type;
Chris@16:         return expression_type (e1 (), e2 ());
Chris@16:     }
Chris@16: 
Chris@16:     // (v1 - v2) [i] = v1 [i] - v2 [i]
Chris@16:     template<class E1, class E2>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename vector_binary_traits<E1, E2, scalar_minus<typename E1::value_type,
Chris@16:                                                        typename E2::value_type> >::result_type
Chris@16:     operator - (const vector_expression<E1> &e1,
Chris@16:                 const vector_expression<E2> &e2) {
Chris@16:         typedef typename vector_binary_traits<E1, E2, scalar_minus<typename E1::value_type,
Chris@16:                                                                                typename E2::value_type> >::expression_type expression_type;
Chris@16:         return expression_type (e1 (), e2 ());
Chris@16:     }
Chris@16: 
Chris@16:     // (v1 * v2) [i] = v1 [i] * v2 [i]
Chris@16:     template<class E1, class E2>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename vector_binary_traits<E1, E2, scalar_multiplies<typename E1::value_type,
Chris@16:                                                             typename E2::value_type> >::result_type
Chris@16:     element_prod (const vector_expression<E1> &e1,
Chris@16:                   const vector_expression<E2> &e2) {
Chris@16:         typedef typename vector_binary_traits<E1, E2, scalar_multiplies<typename E1::value_type,
Chris@16:                                                                                     typename E2::value_type> >::expression_type expression_type;
Chris@16:         return expression_type (e1 (), e2 ());
Chris@16:     }
Chris@16: 
Chris@16:     // (v1 / v2) [i] = v1 [i] / v2 [i]
Chris@16:     template<class E1, class E2>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename vector_binary_traits<E1, E2, scalar_divides<typename E1::value_type,
Chris@16:                                                          typename E2::value_type> >::result_type
Chris@16:     element_div (const vector_expression<E1> &e1,
Chris@16:                  const vector_expression<E2> &e2) {
Chris@16:         typedef typename vector_binary_traits<E1, E2, scalar_divides<typename E1::value_type,
Chris@16:                                                                                  typename E2::value_type> >::expression_type expression_type;
Chris@16:         return expression_type (e1 (), e2 ());
Chris@16:     }
Chris@16: 
Chris@16: 
Chris@16:     template<class E1, class E2, class F>
Chris@16:     class vector_binary_scalar1:
Chris@16:         public vector_expression<vector_binary_scalar1<E1, E2, F> > {
Chris@16: 
Chris@16:         typedef F functor_type;
Chris@16:         typedef E1 expression1_type;
Chris@16:         typedef E2 expression2_type;
Chris@16:     public:
Chris@16:         typedef const E1& expression1_closure_type;
Chris@16:         typedef typename E2::const_closure_type expression2_closure_type;
Chris@16:     private:
Chris@16:         typedef vector_binary_scalar1<E1, E2, F> self_type;
Chris@16:     public:
Chris@16: #ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
Chris@16:         using vector_expression<vector_binary_scalar1<E1, E2, F> >::operator ();
Chris@16: #endif
Chris@16:         typedef typename E2::size_type size_type;
Chris@16:         typedef typename E2::difference_type difference_type;
Chris@16:         typedef typename F::result_type value_type;
Chris@16:         typedef value_type const_reference;
Chris@16:         typedef const_reference reference;
Chris@16:         typedef const self_type const_closure_type;
Chris@16:         typedef const_closure_type closure_type;
Chris@16:         typedef unknown_storage_tag storage_category;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         vector_binary_scalar1 (const expression1_type &e1, const expression2_type &e2):
Chris@16:             e1_ (e1), e2_ (e2) {}
Chris@16: 
Chris@16:         // Accessors
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type size () const {
Chris@16:             return e2_.size ();
Chris@16:         }
Chris@16: 
Chris@16:     public:
Chris@16:         // Element access
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator () (size_type i) const {
Chris@16:             return functor_type::apply (e1_, e2_ (i));
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator [] (size_type i) const {
Chris@16:             return functor_type::apply (e1_, e2_ [i]);
Chris@16:         }
Chris@16: 
Chris@16:         // Closure comparison
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool same_closure (const vector_binary_scalar1 &vbs1) const {
Chris@16:             return &e1_ == &(vbs1.e1_) &&
Chris@16:                    (*this).e2_.same_closure (vbs1.e2_);
Chris@16:         }
Chris@16: 
Chris@16:         // Iterator types
Chris@16:     private:
Chris@16:         typedef expression1_type const_subiterator1_type;
Chris@16:         typedef typename expression2_type::const_iterator const_subiterator2_type;
Chris@16:         typedef const value_type *const_pointer;
Chris@16: 
Chris@16:     public:
Chris@16: #ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
Chris@16:         typedef indexed_const_iterator<const_closure_type, typename const_subiterator2_type::iterator_category> const_iterator;
Chris@16:         typedef const_iterator iterator;
Chris@16: #else
Chris@16:         class const_iterator;
Chris@16:         typedef const_iterator iterator;
Chris@16: #endif
Chris@16: 
Chris@16:         // Element lookup
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator find (size_type i) const {
Chris@16: #ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
Chris@16:             const_subiterator2_type it (e2_.find (i));
Chris@16:             return const_iterator (*this, it.index ());
Chris@16: #else
Chris@16:             return const_iterator (*this, const_subiterator1_type (e1_), e2_.find (i));
Chris@16: #endif
Chris@16:         }
Chris@16: 
Chris@16:         // Iterator enhances the iterator of the referenced vector expression
Chris@16:         // with the binary functor.
Chris@16: 
Chris@16: #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
Chris@16:         class const_iterator:
Chris@16:             public container_const_reference<vector_binary_scalar1>,
Chris@16:             public iterator_base_traits<typename E2::const_iterator::iterator_category>::template
Chris@16:                         iterator_base<const_iterator, value_type>::type {
Chris@16:         public:
Chris@16:             typedef typename E2::const_iterator::iterator_category iterator_category;
Chris@16:             typedef typename vector_binary_scalar1::difference_type difference_type;
Chris@16:             typedef typename vector_binary_scalar1::value_type value_type;
Chris@16:             typedef typename vector_binary_scalar1::const_reference reference;
Chris@16:             typedef typename vector_binary_scalar1::const_pointer pointer;
Chris@16: 
Chris@16:             // Construction and destruction
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator ():
Chris@16:                 container_const_reference<self_type> (), it1_ (), it2_ () {}
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator (const self_type &vbs, const const_subiterator1_type &it1, const const_subiterator2_type &it2):
Chris@16:                 container_const_reference<self_type> (vbs), it1_ (it1), it2_ (it2) {}
Chris@16: 
Chris@16:             // Arithmetic
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator ++ () {
Chris@16:                 ++ it2_;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator -- () {
Chris@16:                 -- it2_;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator += (difference_type n) {
Chris@16:                 it2_ += n;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &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 const_iterator &it) const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
Chris@16:                 // FIXME we shouldn't compare floats
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:             const_reference operator * () const {
Chris@16:                 return functor_type::apply (it1_, *it2_);
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_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 it2_.index ();
Chris@16:             }
Chris@16: 
Chris@16:             // Assignment 
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator = (const const_iterator &it) {
Chris@16:                 container_const_reference<self_type>::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 const_iterator &it) const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
Chris@16:                 // FIXME we shouldn't compare floats
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 const_iterator &it) const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
Chris@16:                 // FIXME we shouldn't compare floats
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:             const_subiterator1_type it1_;
Chris@16:             const_subiterator2_type it2_;
Chris@16:         };
Chris@16: #endif
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator begin () const {
Chris@16:             return find (0); 
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cbegin () const {
Chris@101:             return begin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator end () const {
Chris@16:             return find (size ()); 
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cend () const {
Chris@101:             return end ();
Chris@101:         }
Chris@16: 
Chris@16:         // Reverse iterator
Chris@16:         typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rbegin () const {
Chris@16:             return const_reverse_iterator (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crbegin () const {
Chris@101:             return rbegin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rend () const {
Chris@16:             return const_reverse_iterator (begin ());
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crend () const {
Chris@101:             return end ();
Chris@101:         }
Chris@16: 
Chris@16:     private:
Chris@16:         expression1_closure_type e1_;
Chris@16:         expression2_closure_type e2_;
Chris@16:     };
Chris@16: 
Chris@16:     template<class E1, class E2, class F>
Chris@16:     struct vector_binary_scalar1_traits {
Chris@16:         typedef vector_binary_scalar1<E1, E2, F> expression_type;   // allow E1 to be builtin type
Chris@16: #ifndef BOOST_UBLAS_SIMPLE_ET_DEBUG
Chris@16:         typedef expression_type result_type;
Chris@16: #else
Chris@16:         typedef typename E2::vector_temporary_type result_type;
Chris@16: #endif
Chris@16:     };
Chris@16: 
Chris@16:     // (t * v) [i] = t * v [i]
Chris@16:     template<class T1, class E2>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename enable_if< is_convertible<T1, typename E2::value_type >,    
Chris@16:     typename vector_binary_scalar1_traits<const T1, E2, scalar_multiplies<T1, typename E2::value_type> >::result_type
Chris@16:     >::type
Chris@16:     operator * (const T1 &e1,
Chris@16:                 const vector_expression<E2> &e2) {
Chris@16:         typedef typename vector_binary_scalar1_traits<const T1, E2, scalar_multiplies<T1, typename E2::value_type> >::expression_type expression_type;
Chris@16:         return expression_type (e1, e2 ());
Chris@16:     }
Chris@16: 
Chris@16: 
Chris@16:     template<class E1, class E2, class F>
Chris@16:     class vector_binary_scalar2:
Chris@16:         public vector_expression<vector_binary_scalar2<E1, E2, F> > {
Chris@16: 
Chris@16:         typedef F functor_type;
Chris@16:         typedef E1 expression1_type;
Chris@16:         typedef E2 expression2_type;
Chris@16:         typedef typename E1::const_closure_type expression1_closure_type;
Chris@16:         typedef const E2& expression2_closure_type;
Chris@16:         typedef vector_binary_scalar2<E1, E2, F> self_type;
Chris@16:     public:
Chris@16: #ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
Chris@16:         using vector_expression<vector_binary_scalar2<E1, E2, F> >::operator ();
Chris@16: #endif
Chris@16:         typedef typename E1::size_type size_type;
Chris@16:         typedef typename E1::difference_type difference_type;
Chris@16:         typedef typename F::result_type value_type;
Chris@16:         typedef value_type const_reference;
Chris@16:         typedef const_reference reference;
Chris@16:         typedef const self_type const_closure_type;
Chris@16:         typedef const_closure_type closure_type;
Chris@16:         typedef unknown_storage_tag storage_category;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         vector_binary_scalar2 (const expression1_type &e1, const expression2_type &e2):
Chris@16:             e1_ (e1), e2_ (e2) {}
Chris@16: 
Chris@16:         // Accessors
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type size () const {
Chris@16:             return e1_.size (); 
Chris@16:         }
Chris@16: 
Chris@16:     public:
Chris@16:         // Element access
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator () (size_type i) const {
Chris@16:             return functor_type::apply (e1_ (i), e2_);
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator [] (size_type i) const {
Chris@16:             return functor_type::apply (e1_ [i], e2_);
Chris@16:         }
Chris@16: 
Chris@16:         // Closure comparison
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool same_closure (const vector_binary_scalar2 &vbs2) const {
Chris@16:             return (*this).e1_.same_closure (vbs2.e1_) &&
Chris@16:                    &e2_ == &(vbs2.e2_);
Chris@16:         }
Chris@16: 
Chris@16:         // Iterator types
Chris@16:     private:
Chris@16:         typedef typename expression1_type::const_iterator const_subiterator1_type;
Chris@16:         typedef expression2_type const_subiterator2_type;
Chris@16:         typedef const value_type *const_pointer;
Chris@16: 
Chris@16:     public:
Chris@16: #ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
Chris@16:         typedef indexed_const_iterator<const_closure_type, typename const_subiterator2_type::iterator_category> const_iterator;
Chris@16:         typedef const_iterator iterator;
Chris@16: #else
Chris@16:         class const_iterator;
Chris@16:         typedef const_iterator iterator;
Chris@16: #endif
Chris@16: 
Chris@16:         // Element lookup
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator find (size_type i) const {
Chris@16: #ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
Chris@16:             const_subiterator1_type it (e1_.find (i));
Chris@16:             return const_iterator (*this, it.index ());
Chris@16: #else
Chris@16:             return const_iterator (*this, e1_.find (i), const_subiterator2_type (e2_));
Chris@16: #endif
Chris@16:         }
Chris@16: 
Chris@16:         // Iterator enhances the iterator of the referenced vector expression
Chris@16:         // with the binary functor.
Chris@16: 
Chris@16: #ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
Chris@16:         class const_iterator:
Chris@16:             public container_const_reference<vector_binary_scalar2>,
Chris@16:             public iterator_base_traits<typename E1::const_iterator::iterator_category>::template
Chris@16:                         iterator_base<const_iterator, value_type>::type {
Chris@16:         public:
Chris@16:             typedef typename E1::const_iterator::iterator_category iterator_category;
Chris@16:             typedef typename vector_binary_scalar2::difference_type difference_type;
Chris@16:             typedef typename vector_binary_scalar2::value_type value_type;
Chris@16:             typedef typename vector_binary_scalar2::const_reference reference;
Chris@16:             typedef typename vector_binary_scalar2::const_pointer pointer;
Chris@16: 
Chris@16:             // Construction and destruction
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator ():
Chris@16:                 container_const_reference<self_type> (), it1_ (), it2_ () {}
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator (const self_type &vbs, const const_subiterator1_type &it1, const const_subiterator2_type &it2):
Chris@16:                 container_const_reference<self_type> (vbs), it1_ (it1), it2_ (it2) {}
Chris@16: 
Chris@16:             // Arithmetic
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator ++ () {
Chris@16:                 ++ it1_;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator -- () {
Chris@16:                 -- it1_;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator += (difference_type n) {
Chris@16:                 it1_ += n;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &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 const_iterator &it) const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
Chris@16:                 // FIXME we shouldn't compare floats
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:             const_reference operator * () const {
Chris@16:                 return functor_type::apply (*it1_, it2_);
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_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 it1_.index ();
Chris@16:             }
Chris@16: 
Chris@16:             // Assignment
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator = (const const_iterator &it) {
Chris@16:                 container_const_reference<self_type>::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 const_iterator &it) const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
Chris@16:                 // FIXME we shouldn't compare floats
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 const_iterator &it) const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
Chris@16:                 // FIXME we shouldn't compare floats
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:             const_subiterator1_type it1_;
Chris@16:             const_subiterator2_type it2_;
Chris@16:         };
Chris@16: #endif
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator begin () const {
Chris@16:             return find (0);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cbegin () const {
Chris@101:             return begin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator end () const {
Chris@16:             return find (size ());
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cend () const {
Chris@101:             return end ();
Chris@101:         }
Chris@16: 
Chris@16:         // Reverse iterator
Chris@16:         typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rbegin () const {
Chris@16:             return const_reverse_iterator (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crbegin () const {
Chris@101:             return rbegin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rend () const {
Chris@16:             return const_reverse_iterator (begin ());
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crend () const {
Chris@101:             return rend ();
Chris@101:         }
Chris@16: 
Chris@16:     private:
Chris@16:         expression1_closure_type e1_;
Chris@16:         expression2_closure_type e2_;
Chris@16:     };
Chris@16: 
Chris@16:     template<class E1, class E2, class F>
Chris@16:     struct vector_binary_scalar2_traits {
Chris@16:         typedef vector_binary_scalar2<E1, E2, F> expression_type;   // allow E2 to be builtin type
Chris@16: #ifndef BOOST_UBLAS_SIMPLE_ET_DEBUG
Chris@16:         typedef expression_type result_type;
Chris@16: #else
Chris@16:         typedef typename E1::vector_temporary_type result_type;
Chris@16: #endif
Chris@16:     };
Chris@16: 
Chris@16:     // (v * t) [i] = v [i] * t
Chris@16:     template<class E1, class T2>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename enable_if< is_convertible<T2, typename E1::value_type >,    
Chris@16:     typename vector_binary_scalar2_traits<E1, const T2, scalar_multiplies<typename E1::value_type, T2> >::result_type
Chris@16:     >::type
Chris@16:     operator * (const vector_expression<E1> &e1,
Chris@16:                 const T2 &e2) {
Chris@16:         typedef typename vector_binary_scalar2_traits<E1, const T2, scalar_multiplies<typename E1::value_type, T2> >::expression_type expression_type;
Chris@16:         return expression_type (e1 (), e2);
Chris@16:     }
Chris@16: 
Chris@16:     // (v / t) [i] = v [i] / t
Chris@16:     template<class E1, class T2>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename enable_if< is_convertible<T2, typename E1::value_type >,    
Chris@16:     typename vector_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2> >::result_type
Chris@16:     >::type
Chris@16:     operator / (const vector_expression<E1> &e1,
Chris@16:                 const T2 &e2) {
Chris@16:         typedef typename vector_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2> >::expression_type expression_type;
Chris@16:         return expression_type (e1 (), e2);
Chris@16:     }
Chris@16: 
Chris@16: 
Chris@16:     template<class E, class F>
Chris@16:     class vector_scalar_unary:
Chris@16:         public scalar_expression<vector_scalar_unary<E, F> > {
Chris@16: 
Chris@16:         typedef E expression_type;
Chris@16:         typedef F functor_type;
Chris@16:         typedef typename E::const_closure_type expression_closure_type;
Chris@16:         typedef typename E::const_iterator::iterator_category iterator_category;
Chris@16:         typedef vector_scalar_unary<E, F> self_type;
Chris@16:     public:
Chris@16:         typedef typename F::result_type value_type;
Chris@16:         typedef typename E::difference_type difference_type;
Chris@16:         typedef const self_type const_closure_type;
Chris@16:         typedef const_closure_type closure_type;
Chris@16:         typedef unknown_storage_tag storage_category;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         explicit vector_scalar_unary (const expression_type &e):
Chris@16:             e_ (e) {}
Chris@16: 
Chris@16:     private:
Chris@16:         // Expression accessors
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const expression_closure_type &expression () const {
Chris@16:             return e_;
Chris@16:         }
Chris@16: 
Chris@16:     public:
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         operator value_type () const {
Chris@16:             return evaluate (iterator_category ());
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         // Dense random access specialization
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         value_type evaluate (dense_random_access_iterator_tag) const {
Chris@16: #ifdef BOOST_UBLAS_USE_INDEXING
Chris@16:             return functor_type::apply (e_);
Chris@16: #elif BOOST_UBLAS_USE_ITERATING
Chris@16:             difference_type size = e_.size ();
Chris@16:             return functor_type::apply (size, e_.begin ());
Chris@16: #else
Chris@16:             difference_type size = e_.size ();
Chris@16:             if (size >= BOOST_UBLAS_ITERATOR_THRESHOLD)
Chris@16:                 return functor_type::apply (size, e_.begin ());
Chris@16:             else
Chris@16:                 return functor_type::apply (e_);
Chris@16: #endif
Chris@16:         }
Chris@16: 
Chris@16:         // Packed bidirectional specialization
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         value_type evaluate (packed_random_access_iterator_tag) const {
Chris@16:             return functor_type::apply (e_.begin (), e_.end ());
Chris@16:         }
Chris@16: 
Chris@16:         // Sparse bidirectional specialization
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         value_type evaluate (sparse_bidirectional_iterator_tag) const {
Chris@16:             return functor_type::apply (e_.begin (), e_.end ());
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         expression_closure_type e_;
Chris@16:     };
Chris@16: 
Chris@16:     template<class E, class F>
Chris@16:     struct vector_scalar_unary_traits {
Chris@16:         typedef vector_scalar_unary<E, F> expression_type;
Chris@16: #if !defined (BOOST_UBLAS_SIMPLE_ET_DEBUG) && defined (BOOST_UBLAS_USE_SCALAR_ET)
Chris@16: // FIXME don't define USE_SCALAR_ET other then for testing
Chris@16: // They do not work for complex types
Chris@16:          typedef expression_type result_type;
Chris@16: #else
Chris@16:          typedef typename F::result_type result_type;
Chris@16: #endif
Chris@16:     };
Chris@16: 
Chris@16:     // sum v = sum (v [i])
Chris@16:     template<class E>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename vector_scalar_unary_traits<E, vector_sum<E> >::result_type
Chris@16:     sum (const vector_expression<E> &e) {
Chris@16:         typedef typename vector_scalar_unary_traits<E, vector_sum<E> >::expression_type expression_type;
Chris@16:         return expression_type (e ());
Chris@16:     }
Chris@16: 
Chris@16:     // real: norm_1 v = sum (abs (v [i]))
Chris@16:     // complex: norm_1 v = sum (abs (real (v [i])) + abs (imag (v [i])))
Chris@16:     template<class E>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename vector_scalar_unary_traits<E, vector_norm_1<E> >::result_type
Chris@16:     norm_1 (const vector_expression<E> &e) {
Chris@16:         typedef typename vector_scalar_unary_traits<E, vector_norm_1<E> >::expression_type expression_type;
Chris@16:         return expression_type (e ());
Chris@16:     }
Chris@16: 
Chris@16:     // real: norm_2 v = sqrt (sum (v [i] * v [i]))
Chris@16:     // complex: norm_2 v = sqrt (sum (v [i] * conj (v [i])))
Chris@16:     template<class E>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename vector_scalar_unary_traits<E, vector_norm_2<E> >::result_type
Chris@16:     norm_2 (const vector_expression<E> &e) {
Chris@16:         typedef typename vector_scalar_unary_traits<E, vector_norm_2<E> >::expression_type expression_type;
Chris@16:         return expression_type (e ());
Chris@16:     }
Chris@16: 
Chris@16:     // real: norm_inf v = maximum (abs (v [i]))
Chris@16:     // complex: norm_inf v = maximum (maximum (abs (real (v [i])), abs (imag (v [i]))))
Chris@16:     template<class E>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename vector_scalar_unary_traits<E, vector_norm_inf<E> >::result_type
Chris@16:     norm_inf (const vector_expression<E> &e) {
Chris@16:         typedef typename vector_scalar_unary_traits<E, vector_norm_inf<E> >::expression_type expression_type;
Chris@16:         return expression_type (e ());
Chris@16:     }
Chris@16: 
Chris@16:     // real: index_norm_inf v = minimum (i: abs (v [i]) == maximum (abs (v [i])))
Chris@16:     template<class E>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename vector_scalar_unary_traits<E, vector_index_norm_inf<E> >::result_type
Chris@16:     index_norm_inf (const vector_expression<E> &e) {
Chris@16:         typedef typename vector_scalar_unary_traits<E, vector_index_norm_inf<E> >::expression_type expression_type;
Chris@16:         return expression_type (e ());
Chris@16:     }
Chris@16: 
Chris@16:     template<class E1, class E2, class F>
Chris@16:     class vector_scalar_binary:
Chris@16:         public scalar_expression<vector_scalar_binary<E1, E2, F> > {
Chris@16: 
Chris@16:         typedef E1 expression1_type;
Chris@16:         typedef E2 expression2_type;
Chris@16:         typedef F functor_type;
Chris@16:         typedef typename E1::const_closure_type expression1_closure_type;
Chris@16:         typedef typename E2::const_closure_type expression2_closure_type;
Chris@16:         typedef typename iterator_restrict_traits<typename E1::const_iterator::iterator_category,
Chris@16:                                                   typename E2::const_iterator::iterator_category>::iterator_category iterator_category;
Chris@16:         typedef vector_scalar_binary<E1, E2, F> self_type;
Chris@16:     public:
Chris@16:         static const unsigned complexity = 1;
Chris@16:         typedef typename F::result_type value_type;
Chris@16:         typedef typename E1::difference_type difference_type;
Chris@16:         typedef const self_type const_closure_type;
Chris@16:         typedef const_closure_type closure_type;
Chris@16:         typedef unknown_storage_tag storage_category;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         vector_scalar_binary (const expression1_type &e1, const expression2_type  &e2):
Chris@16:             e1_ (e1), e2_ (e2) {}
Chris@16: 
Chris@16:     private:
Chris@16:         // Accessors
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const expression1_closure_type &expression1 () const {
Chris@16:             return e1_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const expression2_closure_type &expression2 () const {
Chris@16:             return e2_;
Chris@16:         }
Chris@16: 
Chris@16:     public:
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         operator value_type () const {
Chris@16:             return evaluate (iterator_category ());
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         // Dense random access specialization
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         value_type evaluate (dense_random_access_iterator_tag) const {
Chris@16:             BOOST_UBLAS_CHECK (e1_.size () == e2_.size (), external_logic());
Chris@16: #ifdef BOOST_UBLAS_USE_INDEXING
Chris@16:             return functor_type::apply (e1_, e2_);
Chris@16: #elif BOOST_UBLAS_USE_ITERATING
Chris@16:             difference_type size = BOOST_UBLAS_SAME (e1_.size (), e2_.size ());
Chris@16:             return functor_type::apply (size, e1_.begin (), e2_.begin ());
Chris@16: #else
Chris@16:             difference_type size = BOOST_UBLAS_SAME (e1_.size (), e2_.size ());
Chris@16:             if (size >= BOOST_UBLAS_ITERATOR_THRESHOLD)
Chris@16:                 return functor_type::apply (size, e1_.begin (), e2_.begin ());
Chris@16:             else
Chris@16:                 return functor_type::apply (e1_, e2_);
Chris@16: #endif
Chris@16:         }
Chris@16: 
Chris@16:         // Packed bidirectional specialization
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         value_type evaluate (packed_random_access_iterator_tag) const {
Chris@16:             BOOST_UBLAS_CHECK (e1_.size () == e2_.size (), external_logic());
Chris@16:             return functor_type::apply (e1_.begin (), e1_.end (), e2_.begin (), e2_.end ());
Chris@16:         }
Chris@16: 
Chris@16:         // Sparse bidirectional specialization
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         value_type evaluate (sparse_bidirectional_iterator_tag) const {
Chris@16:             BOOST_UBLAS_CHECK (e1_.size () == e2_.size (), external_logic());
Chris@16:             return functor_type::apply (e1_.begin (), e1_.end (), e2_.begin (), e2_.end (), sparse_bidirectional_iterator_tag ());
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         expression1_closure_type e1_;
Chris@16:         expression2_closure_type e2_;
Chris@16:     };
Chris@16: 
Chris@16:     template<class E1, class E2, class F>
Chris@16:     struct vector_scalar_binary_traits {
Chris@16:         typedef vector_scalar_binary<E1, E2, F> expression_type;
Chris@16: #if !defined (BOOST_UBLAS_SIMPLE_ET_DEBUG) && defined (BOOST_UBLAS_USE_SCALAR_ET)
Chris@16: // FIXME don't define USE_SCALAR_ET other then for testing
Chris@16: // They do not work for complex types
Chris@16:         typedef expression_type result_type;
Chris@16: #else
Chris@16:         typedef typename F::result_type result_type;
Chris@16: #endif
Chris@16:     };
Chris@16: 
Chris@16:     // inner_prod (v1, v2) = sum (v1 [i] * v2 [i])
Chris@16:     template<class E1, class E2>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename vector_scalar_binary_traits<E1, E2, vector_inner_prod<E1, E2,
Chris@16:                                                                    typename promote_traits<typename E1::value_type,
Chris@16:                                                                                            typename E2::value_type>::promote_type> >::result_type
Chris@16:     inner_prod (const vector_expression<E1> &e1,
Chris@16:                 const vector_expression<E2> &e2) {
Chris@16:         typedef typename vector_scalar_binary_traits<E1, E2, vector_inner_prod<E1, E2,
Chris@16:                                                                    typename promote_traits<typename E1::value_type,
Chris@16:                                                                                            typename E2::value_type>::promote_type> >::expression_type expression_type;
Chris@16:         return expression_type (e1 (), e2 ());
Chris@16:     }
Chris@16: 
Chris@16:     template<class E1, class E2>
Chris@16:     BOOST_UBLAS_INLINE
Chris@16:     typename vector_scalar_binary_traits<E1, E2, vector_inner_prod<E1, E2,
Chris@16:                                                                    typename type_traits<typename promote_traits<typename E1::value_type,
Chris@16:                                                                                                                 typename E2::value_type>::promote_type>::precision_type> >::result_type
Chris@16:     prec_inner_prod (const vector_expression<E1> &e1,
Chris@16:                      const vector_expression<E2> &e2) {
Chris@16:         typedef typename vector_scalar_binary_traits<E1, E2, vector_inner_prod<E1, E2,
Chris@16:                                                                    typename type_traits<typename promote_traits<typename E1::value_type,
Chris@16:                                                                                                                 typename E2::value_type>::promote_type>::precision_type> >::expression_type expression_type;
Chris@16:         return expression_type (e1 (), e2 ());
Chris@16:     }
Chris@16: 
Chris@16: }}}
Chris@16: 
Chris@16: #endif