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, 0 insertions, 360 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 deleted file mode 100644 index c24b45859d9..00000000000 --- a/src/third_party/boost-1.56.0/boost/accumulators/numeric/functional/valarray.hpp +++ /dev/null @@ -1,360 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////// -/// \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 - |