| /////////////////////////////////////////////////////////////////////////////// |
| /// \file vector.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_VECTOR_HPP_EAN_12_12_2005 |
| #define BOOST_NUMERIC_FUNCTIONAL_VECTOR_HPP_EAN_12_12_2005 |
| |
| #ifdef BOOST_NUMERIC_FUNCTIONAL_HPP_INCLUDED |
| # error Include this file before boost/accumulators/numeric/functional.hpp |
| #endif |
| |
| #include <vector> |
| #include <functional> |
| #include <boost/assert.hpp> |
| #include <boost/mpl/and.hpp> |
| #include <boost/mpl/not.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/vector.hpp> |
| #include <boost/accumulators/numeric/functional_fwd.hpp> |
| |
| namespace boost { namespace numeric |
| { |
| namespace operators |
| { |
| namespace acc_detail |
| { |
| template<typename Fun> |
| struct make_vector |
| { |
| typedef std::vector<typename Fun::result_type> type; |
| }; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Handle vector<Left> / Right where Right is a scalar. |
| template<typename Left, typename Right> |
| typename lazy_enable_if< |
| is_scalar<Right> |
| , acc_detail::make_vector<functional::divides<Left, Right> > |
| >::type |
| operator /(std::vector<Left> const &left, Right const &right) |
| { |
| typedef typename functional::divides<Left, Right>::result_type value_type; |
| std::vector<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 vector<Left> / vector<Right>. |
| template<typename Left, typename Right> |
| std::vector<typename functional::divides<Left, Right>::result_type> |
| operator /(std::vector<Left> const &left, std::vector<Right> const &right) |
| { |
| typedef typename functional::divides<Left, Right>::result_type value_type; |
| std::vector<value_type> result(left.size()); |
| for(std::size_t i = 0, size = result.size(); i != size; ++i) |
| { |
| result[i] = numeric::divides(left[i], right[i]); |
| } |
| return result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Handle vector<Left> * Right where Right is a scalar. |
| template<typename Left, typename Right> |
| typename lazy_enable_if< |
| is_scalar<Right> |
| , acc_detail::make_vector<functional::multiplies<Left, Right> > |
| >::type |
| operator *(std::vector<Left> const &left, Right const &right) |
| { |
| typedef typename functional::multiplies<Left, Right>::result_type value_type; |
| std::vector<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 Left * vector<Right> where Left is a scalar. |
| template<typename Left, typename Right> |
| typename lazy_enable_if< |
| is_scalar<Left> |
| , acc_detail::make_vector<functional::multiplies<Left, Right> > |
| >::type |
| operator *(Left const &left, std::vector<Right> const &right) |
| { |
| typedef typename functional::multiplies<Left, Right>::result_type value_type; |
| std::vector<value_type> result(right.size()); |
| for(std::size_t i = 0, size = result.size(); i != size; ++i) |
| { |
| result[i] = numeric::multiplies(left, right[i]); |
| } |
| return result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Handle vector<Left> * vector<Right> |
| template<typename Left, typename Right> |
| std::vector<typename functional::multiplies<Left, Right>::result_type> |
| operator *(std::vector<Left> const &left, std::vector<Right> const &right) |
| { |
| typedef typename functional::multiplies<Left, Right>::result_type value_type; |
| std::vector<value_type> result(left.size()); |
| for(std::size_t i = 0, size = result.size(); i != size; ++i) |
| { |
| result[i] = numeric::multiplies(left[i], right[i]); |
| } |
| return result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Handle vector<Left> + vector<Right> |
| template<typename Left, typename Right> |
| std::vector<typename functional::plus<Left, Right>::result_type> |
| operator +(std::vector<Left> const &left, std::vector<Right> const &right) |
| { |
| typedef typename functional::plus<Left, Right>::result_type value_type; |
| std::vector<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; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Handle vector<Left> - vector<Right> |
| template<typename Left, typename Right> |
| std::vector<typename functional::minus<Left, Right>::result_type> |
| operator -(std::vector<Left> const &left, std::vector<Right> const &right) |
| { |
| typedef typename functional::minus<Left, Right>::result_type value_type; |
| std::vector<value_type> result(left.size()); |
| for(std::size_t i = 0, size = result.size(); i != size; ++i) |
| { |
| result[i] = numeric::minus(left[i], right[i]); |
| } |
| return result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Handle vector<Left> += vector<Left> |
| template<typename Left> |
| std::vector<Left> & |
| operator +=(std::vector<Left> &left, std::vector<Left> const &right) |
| { |
| BOOST_ASSERT(left.size() == right.size()); |
| for(std::size_t i = 0, size = left.size(); i != size; ++i) |
| { |
| numeric::plus_assign(left[i], right[i]); |
| } |
| return left; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Handle -vector<Arg> |
| template<typename Arg> |
| std::vector<typename functional::unary_minus<Arg>::result_type> |
| operator -(std::vector<Arg> const &arg) |
| { |
| typedef typename functional::unary_minus<Arg>::result_type value_type; |
| std::vector<value_type> result(arg.size()); |
| for(std::size_t i = 0, size = result.size(); i != size; ++i) |
| { |
| result[i] = numeric::unary_minus(arg[i]); |
| } |
| return result; |
| } |
| } |
| |
| namespace functional |
| { |
| struct std_vector_tag; |
| |
| template<typename T, typename Al> |
| struct tag<std::vector<T, Al> > |
| { |
| typedef std_vector_tag type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // element-wise min of std::vector |
| template<typename Left, typename Right> |
| struct min_assign<Left, Right, std_vector_tag, std_vector_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::vector |
| template<typename Left, typename Right> |
| struct max_assign<Left, Right, std_vector_tag, std_vector_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 for std::vector. |
| template<typename Left, typename Right> |
| struct average<Left, Right, std_vector_tag, void> |
| : 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_vector_tag, std_vector_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_vector_tag, std_vector_tag> |
| : std::unary_function<ToFrom, ToFrom> |
| { |
| ToFrom &operator ()(ToFrom &tofrom) const |
| { |
| return tofrom; |
| } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // functional::as_min |
| template<typename T> |
| struct as_min<T, std_vector_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(arr.size(), numeric::as_min(arr[0])); |
| } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // functional::as_max |
| template<typename T> |
| struct as_max<T, std_vector_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(arr.size(), numeric::as_max(arr[0])); |
| } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // functional::as_zero |
| template<typename T> |
| struct as_zero<T, std_vector_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(arr.size(), numeric::as_zero(arr[0])); |
| } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // functional::as_one |
| template<typename T> |
| struct as_one<T, std_vector_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(arr.size(), numeric::as_one(arr[0])); |
| } |
| }; |
| |
| } // namespace functional |
| |
| }} // namespace boost::numeric |
| |
| #endif |
| |