Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: /// \file valarray.hpp
Chris@16: ///
Chris@16: //  Copyright 2005 Eric Niebler. Distributed under the Boost
Chris@16: //  Software License, Version 1.0. (See accompanying file
Chris@16: //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Chris@16: 
Chris@16: #ifndef BOOST_NUMERIC_FUNCTIONAL_VALARRAY_HPP_EAN_12_12_2005
Chris@16: #define BOOST_NUMERIC_FUNCTIONAL_VALARRAY_HPP_EAN_12_12_2005
Chris@16: 
Chris@16: #ifdef BOOST_NUMERIC_FUNCTIONAL_HPP_INCLUDED
Chris@16: # error Include this file before boost/accumulators/numeric/functional.hpp
Chris@16: #endif
Chris@16: 
Chris@16: #include <valarray>
Chris@16: #include <functional>
Chris@16: #include <boost/assert.hpp>
Chris@16: #include <boost/mpl/and.hpp>
Chris@16: #include <boost/mpl/not.hpp>
Chris@16: #include <boost/mpl/assert.hpp>
Chris@16: #include <boost/utility/enable_if.hpp>
Chris@16: #include <boost/type_traits/is_same.hpp>
Chris@16: #include <boost/type_traits/is_scalar.hpp>
Chris@16: #include <boost/type_traits/remove_const.hpp>
Chris@16: #include <boost/typeof/std/valarray.hpp>
Chris@16: #include <boost/accumulators/numeric/functional_fwd.hpp>
Chris@16: 
Chris@16: namespace boost { namespace numeric
Chris@16: {
Chris@16:     namespace operators
Chris@16:     {
Chris@16:         namespace acc_detail
Chris@16:         {
Chris@16:             template<typename Fun>
Chris@16:             struct make_valarray
Chris@16:             {
Chris@16:                 typedef std::valarray<typename Fun::result_type> type;
Chris@16:             };
Chris@16:         }
Chris@16: 
Chris@16:         ///////////////////////////////////////////////////////////////////////////////
Chris@16:         // Handle valarray<Left> / Right where Right is a scalar and Right != Left.
Chris@16:         template<typename Left, typename Right>
Chris@16:         typename lazy_enable_if<
Chris@16:             mpl::and_<is_scalar<Right>, mpl::not_<is_same<Left, Right> > >
Chris@16:           , acc_detail::make_valarray<functional::divides<Left, Right> >
Chris@16:         >::type
Chris@16:         operator /(std::valarray<Left> const &left, Right const &right)
Chris@16:         {
Chris@16:             typedef typename functional::divides<Left, Right>::result_type value_type;
Chris@16:             std::valarray<value_type> result(left.size());
Chris@16:             for(std::size_t i = 0, size = result.size(); i != size; ++i)
Chris@16:             {
Chris@16:                 result[i] = numeric::divides(left[i], right);
Chris@16:             }
Chris@16:             return result;
Chris@16:         }
Chris@16: 
Chris@16:         ///////////////////////////////////////////////////////////////////////////////
Chris@16:         // Handle valarray<Left> * Right where Right is a scalar and Right != Left.
Chris@16:         template<typename Left, typename Right>
Chris@16:         typename lazy_enable_if<
Chris@16:             mpl::and_<is_scalar<Right>, mpl::not_<is_same<Left, Right> > >
Chris@16:           , acc_detail::make_valarray<functional::multiplies<Left, Right> >
Chris@16:         >::type
Chris@16:         operator *(std::valarray<Left> const &left, Right const &right)
Chris@16:         {
Chris@16:             typedef typename functional::multiplies<Left, Right>::result_type value_type;
Chris@16:             std::valarray<value_type> result(left.size());
Chris@16:             for(std::size_t i = 0, size = result.size(); i != size; ++i)
Chris@16:             {
Chris@16:                 result[i] = numeric::multiplies(left[i], right);
Chris@16:             }
Chris@16:             return result;
Chris@16:         }
Chris@16: 
Chris@16:         ///////////////////////////////////////////////////////////////////////////////
Chris@16:         // Handle valarray<Left> + valarray<Right> where Right != Left.
Chris@16:         template<typename Left, typename Right>
Chris@16:         typename lazy_disable_if<
Chris@16:             is_same<Left, Right>
Chris@16:           , acc_detail::make_valarray<functional::plus<Left, Right> >
Chris@16:         >::type
Chris@16:         operator +(std::valarray<Left> const &left, std::valarray<Right> const &right)
Chris@16:         {
Chris@16:             typedef typename functional::plus<Left, Right>::result_type value_type;
Chris@16:             std::valarray<value_type> result(left.size());
Chris@16:             for(std::size_t i = 0, size = result.size(); i != size; ++i)
Chris@16:             {
Chris@16:                 result[i] = numeric::plus(left[i], right[i]);
Chris@16:             }
Chris@16:             return result;
Chris@16:         }
Chris@16:     }
Chris@16: 
Chris@16:     namespace functional
Chris@16:     {
Chris@16:         struct std_valarray_tag;
Chris@16: 
Chris@16:         template<typename T>
Chris@16:         struct tag<std::valarray<T> >
Chris@16:         {
Chris@16:             typedef std_valarray_tag type;
Chris@16:         };
Chris@16: 
Chris@16:     #ifdef __GLIBCXX__
Chris@16:         template<typename T, typename U>
Chris@16:         struct tag<std::_Expr<T, U> >
Chris@16:         {
Chris@16:             typedef std_valarray_tag type;
Chris@16:         };
Chris@16:     #endif
Chris@16: 
Chris@16:         /// INTERNAL ONLY
Chris@16:         ///
Chris@16:         // This is necessary because the GCC stdlib uses expression templates, and
Chris@16:         // typeof(som-valarray-expression) is not an instance of std::valarray
Chris@16:     #define BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(Name, Op)                   \
Chris@16:         template<typename Left, typename Right>                                         \
Chris@16:         struct Name<Left, Right, std_valarray_tag, std_valarray_tag>                    \
Chris@16:           : std::binary_function<                                                       \
Chris@16:                 Left                                                                    \
Chris@16:               , Right                                                                   \
Chris@16:               , std::valarray<                                                          \
Chris@16:                     typename Name<                                                      \
Chris@16:                         typename Left::value_type                                       \
Chris@16:                       , typename Right::value_type                                      \
Chris@16:                     >::result_type                                                      \
Chris@16:                 >                                                                       \
Chris@16:             >                                                                           \
Chris@16:         {                                                                               \
Chris@16:             typedef typename Left::value_type left_value_type;                          \
Chris@16:             typedef typename Right::value_type right_value_type;                        \
Chris@16:             typedef                                                                     \
Chris@16:                 std::valarray<                                                          \
Chris@16:                     typename Name<left_value_type, right_value_type>::result_type       \
Chris@16:                 >                                                                       \
Chris@16:             result_type;                                                                \
Chris@16:             result_type                                                                 \
Chris@16:             operator ()(Left &left, Right &right) const                                 \
Chris@16:             {                                                                           \
Chris@16:                 return numeric::promote<std::valarray<left_value_type> >(left)          \
Chris@16:                     Op numeric::promote<std::valarray<right_value_type> >(right);       \
Chris@16:             }                                                                           \
Chris@16:         };                                                                              \
Chris@16:         template<typename Left, typename Right>                                         \
Chris@16:         struct Name<Left, Right, std_valarray_tag, void>                                \
Chris@16:           : std::binary_function<                                                       \
Chris@16:                 Left                                                                    \
Chris@16:               , Right                                                                   \
Chris@16:               , std::valarray<                                                          \
Chris@16:                     typename Name<typename Left::value_type, Right>::result_type        \
Chris@16:                 >                                                                       \
Chris@16:             >                                                                           \
Chris@16:         {                                                                               \
Chris@16:             typedef typename Left::value_type left_value_type;                          \
Chris@16:             typedef                                                                     \
Chris@16:                 std::valarray<                                                          \
Chris@16:                     typename Name<left_value_type, Right>::result_type                  \
Chris@16:                 >                                                                       \
Chris@16:             result_type;                                                                \
Chris@16:             result_type                                                                 \
Chris@16:             operator ()(Left &left, Right &right) const                                 \
Chris@16:             {                                                                           \
Chris@16:                 return numeric::promote<std::valarray<left_value_type> >(left) Op right;\
Chris@16:             }                                                                           \
Chris@16:         };                                                                              \
Chris@16:         template<typename Left, typename Right>                                         \
Chris@16:         struct Name<Left, Right, void, std_valarray_tag>                                \
Chris@16:           : std::binary_function<                                                       \
Chris@16:                 Left                                                                    \
Chris@16:               , Right                                                                   \
Chris@16:               , std::valarray<                                                          \
Chris@16:                     typename Name<Left, typename Right::value_type>::result_type        \
Chris@16:                 >                                                                       \
Chris@16:             >                                                                           \
Chris@16:         {                                                                               \
Chris@16:             typedef typename Right::value_type right_value_type;                        \
Chris@16:             typedef                                                                     \
Chris@16:                 std::valarray<                                                          \
Chris@16:                     typename Name<Left, right_value_type>::result_type                  \
Chris@16:                 >                                                                       \
Chris@16:             result_type;                                                                \
Chris@16:             result_type                                                                 \
Chris@16:             operator ()(Left &left, Right &right) const                                 \
Chris@16:             {                                                                           \
Chris@16:                 return left Op numeric::promote<std::valarray<right_value_type> >(right);\
Chris@16:             }                                                                           \
Chris@16:         };
Chris@16: 
Chris@16:         BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(plus, +)
Chris@16:         BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(minus, -)
Chris@16:         BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(multiplies, *)
Chris@16:         BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(divides, /)
Chris@16:         BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(modulus, %)
Chris@16: 
Chris@16:     #undef BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP
Chris@16: 
Chris@16:         ///////////////////////////////////////////////////////////////////////////////
Chris@16:         // element-wise min of std::valarray
Chris@16:         template<typename Left, typename Right>
Chris@16:         struct min_assign<Left, Right, std_valarray_tag, std_valarray_tag>
Chris@16:           : std::binary_function<Left, Right, void>
Chris@16:         {
Chris@16:             void operator ()(Left &left, Right &right) const
Chris@16:             {
Chris@16:                 BOOST_ASSERT(left.size() == right.size());
Chris@16:                 for(std::size_t i = 0, size = left.size(); i != size; ++i)
Chris@16:                 {
Chris@16:                     if(numeric::less(right[i], left[i]))
Chris@16:                     {
Chris@16:                         left[i] = right[i];
Chris@16:                     }
Chris@16:                 }
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         ///////////////////////////////////////////////////////////////////////////////
Chris@16:         // element-wise max of std::valarray
Chris@16:         template<typename Left, typename Right>
Chris@16:         struct max_assign<Left, Right, std_valarray_tag, std_valarray_tag>
Chris@16:           : std::binary_function<Left, Right, void>
Chris@16:         {
Chris@16:             void operator ()(Left &left, Right &right) const
Chris@16:             {
Chris@16:                 BOOST_ASSERT(left.size() == right.size());
Chris@16:                 for(std::size_t i = 0, size = left.size(); i != size; ++i)
Chris@16:                 {
Chris@16:                     if(numeric::greater(right[i], left[i]))
Chris@16:                     {
Chris@16:                         left[i] = right[i];
Chris@16:                     }
Chris@16:                 }
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         // partial specialization of numeric::fdiv<> for std::valarray.
Chris@16:         template<typename Left, typename Right, typename RightTag>
Chris@16:         struct fdiv<Left, Right, std_valarray_tag, RightTag>
Chris@16:           : mpl::if_<
Chris@16:                 are_integral<typename Left::value_type, Right>
Chris@16:               , divides<Left, double const>
Chris@16:               , divides<Left, Right>
Chris@16:             >::type
Chris@16:         {};
Chris@16: 
Chris@16:         // promote
Chris@16:         template<typename To, typename From>
Chris@16:         struct promote<To, From, std_valarray_tag, std_valarray_tag>
Chris@16:           : std::unary_function<From, To>
Chris@16:         {
Chris@16:             To operator ()(From &arr) const
Chris@16:             {
Chris@16:                 typename remove_const<To>::type res(arr.size());
Chris@16:                 for(std::size_t i = 0, size = arr.size(); i != size; ++i)
Chris@16:                 {
Chris@16:                     res[i] = numeric::promote<typename To::value_type>(arr[i]);
Chris@16:                 }
Chris@16:                 return res;
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         template<typename ToFrom>
Chris@16:         struct promote<ToFrom, ToFrom, std_valarray_tag, std_valarray_tag>
Chris@16:           : std::unary_function<ToFrom, ToFrom>
Chris@16:         {
Chris@16:             ToFrom &operator ()(ToFrom &tofrom) const
Chris@16:             {
Chris@16:                 return tofrom;
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         // for "promoting" a std::valarray<bool> to a bool, useful for
Chris@16:         // comparing 2 valarrays for equality:
Chris@16:         //   if(numeric::promote<bool>(a == b))
Chris@16:         template<typename From>
Chris@16:         struct promote<bool, From, void, std_valarray_tag>
Chris@16:           : std::unary_function<From, bool>
Chris@16:         {
Chris@16:             bool operator ()(From &arr) const
Chris@16:             {
Chris@16:                 BOOST_MPL_ASSERT((is_same<bool, typename From::value_type>));
Chris@16:                 for(std::size_t i = 0, size = arr.size(); i != size; ++i)
Chris@16:                 {
Chris@16:                     if(!arr[i])
Chris@16:                     {
Chris@16:                         return false;
Chris@16:                     }
Chris@16:                 }
Chris@16:                 return true;
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         template<typename From>
Chris@16:         struct promote<bool const, From, void, std_valarray_tag>
Chris@16:           : promote<bool, From, void, std_valarray_tag>
Chris@16:         {};
Chris@16: 
Chris@16:         ///////////////////////////////////////////////////////////////////////////////
Chris@16:         // functional::as_min
Chris@16:         template<typename T>
Chris@16:         struct as_min<T, std_valarray_tag>
Chris@16:             : std::unary_function<T, typename remove_const<T>::type>
Chris@16:         {
Chris@16:             typename remove_const<T>::type operator ()(T &arr) const
Chris@16:             {
Chris@16:                 return 0 == arr.size()
Chris@16:                   ? T()
Chris@16:                   : T(numeric::as_min(arr[0]), arr.size());
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         ///////////////////////////////////////////////////////////////////////////////
Chris@16:         // functional::as_max
Chris@16:         template<typename T>
Chris@16:         struct as_max<T, std_valarray_tag>
Chris@16:           : std::unary_function<T, typename remove_const<T>::type>
Chris@16:         {
Chris@16:             typename remove_const<T>::type operator ()(T &arr) const
Chris@16:             {
Chris@16:                 return 0 == arr.size()
Chris@16:                   ? T()
Chris@16:                   : T(numeric::as_max(arr[0]), arr.size());
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         ///////////////////////////////////////////////////////////////////////////////
Chris@16:         // functional::as_zero
Chris@16:         template<typename T>
Chris@16:         struct as_zero<T, std_valarray_tag>
Chris@16:           : std::unary_function<T, typename remove_const<T>::type>
Chris@16:         {
Chris@16:             typename remove_const<T>::type operator ()(T &arr) const
Chris@16:             {
Chris@16:                 return 0 == arr.size()
Chris@16:                   ? T()
Chris@16:                   : T(numeric::as_zero(arr[0]), arr.size());
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         ///////////////////////////////////////////////////////////////////////////////
Chris@16:         // functional::as_one
Chris@16:         template<typename T>
Chris@16:         struct as_one<T, std_valarray_tag>
Chris@16:           : std::unary_function<T, typename remove_const<T>::type>
Chris@16:         {
Chris@16:             typename remove_const<T>::type operator ()(T &arr) const
Chris@16:             {
Chris@16:                 return 0 == arr.size()
Chris@16:                   ? T()
Chris@16:                   : T(numeric::as_one(arr[0]), arr.size());
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:     } // namespace functional
Chris@16: 
Chris@16: }} // namespace boost::numeric
Chris@16: 
Chris@16: #endif
Chris@16: