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