/Src/Dependencies/Boost/boost/accumulators/numeric/functional/valarray.hpp

http://hadesmem.googlecode.com/ · C++ Header · 360 lines · 299 code · 28 blank · 33 comment · 23 complexity · 1218ef9b8ad3306c7a92b01a7e5df66c MD5 · raw file

  1. ///////////////////////////////////////////////////////////////////////////////
  2. /// \file valarray.hpp
  3. ///
  4. // Copyright 2005 Eric Niebler. Distributed under the Boost
  5. // Software License, Version 1.0. (See accompanying file
  6. // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  7. #ifndef BOOST_NUMERIC_FUNCTIONAL_VALARRAY_HPP_EAN_12_12_2005
  8. #define BOOST_NUMERIC_FUNCTIONAL_VALARRAY_HPP_EAN_12_12_2005
  9. #ifdef BOOST_NUMERIC_FUNCTIONAL_HPP_INCLUDED
  10. # error Include this file before boost/accumulators/numeric/functional.hpp
  11. #endif
  12. #include <valarray>
  13. #include <functional>
  14. #include <boost/assert.hpp>
  15. #include <boost/mpl/and.hpp>
  16. #include <boost/mpl/not.hpp>
  17. #include <boost/mpl/assert.hpp>
  18. #include <boost/utility/enable_if.hpp>
  19. #include <boost/type_traits/is_same.hpp>
  20. #include <boost/type_traits/is_scalar.hpp>
  21. #include <boost/type_traits/remove_const.hpp>
  22. #include <boost/typeof/std/valarray.hpp>
  23. #include <boost/accumulators/numeric/functional_fwd.hpp>
  24. namespace boost { namespace numeric
  25. {
  26. namespace operators
  27. {
  28. namespace acc_detail
  29. {
  30. template<typename Fun>
  31. struct make_valarray
  32. {
  33. typedef std::valarray<typename Fun::result_type> type;
  34. };
  35. }
  36. ///////////////////////////////////////////////////////////////////////////////
  37. // Handle valarray<Left> / Right where Right is a scalar and Right != Left.
  38. template<typename Left, typename Right>
  39. typename lazy_enable_if<
  40. mpl::and_<is_scalar<Right>, mpl::not_<is_same<Left, Right> > >
  41. , acc_detail::make_valarray<functional::divides<Left, Right> >
  42. >::type
  43. operator /(std::valarray<Left> const &left, Right const &right)
  44. {
  45. typedef typename functional::divides<Left, Right>::result_type value_type;
  46. std::valarray<value_type> result(left.size());
  47. for(std::size_t i = 0, size = result.size(); i != size; ++i)
  48. {
  49. result[i] = numeric::divides(left[i], right);
  50. }
  51. return result;
  52. }
  53. ///////////////////////////////////////////////////////////////////////////////
  54. // Handle valarray<Left> * Right where Right is a scalar and Right != Left.
  55. template<typename Left, typename Right>
  56. typename lazy_enable_if<
  57. mpl::and_<is_scalar<Right>, mpl::not_<is_same<Left, Right> > >
  58. , acc_detail::make_valarray<functional::multiplies<Left, Right> >
  59. >::type
  60. operator *(std::valarray<Left> const &left, Right const &right)
  61. {
  62. typedef typename functional::multiplies<Left, Right>::result_type value_type;
  63. std::valarray<value_type> result(left.size());
  64. for(std::size_t i = 0, size = result.size(); i != size; ++i)
  65. {
  66. result[i] = numeric::multiplies(left[i], right);
  67. }
  68. return result;
  69. }
  70. ///////////////////////////////////////////////////////////////////////////////
  71. // Handle valarray<Left> + valarray<Right> where Right != Left.
  72. template<typename Left, typename Right>
  73. typename lazy_disable_if<
  74. is_same<Left, Right>
  75. , acc_detail::make_valarray<functional::plus<Left, Right> >
  76. >::type
  77. operator +(std::valarray<Left> const &left, std::valarray<Right> const &right)
  78. {
  79. typedef typename functional::plus<Left, Right>::result_type value_type;
  80. std::valarray<value_type> result(left.size());
  81. for(std::size_t i = 0, size = result.size(); i != size; ++i)
  82. {
  83. result[i] = numeric::plus(left[i], right[i]);
  84. }
  85. return result;
  86. }
  87. }
  88. namespace functional
  89. {
  90. struct std_valarray_tag;
  91. template<typename T>
  92. struct tag<std::valarray<T> >
  93. {
  94. typedef std_valarray_tag type;
  95. };
  96. #ifdef __GLIBCXX__
  97. template<typename T, typename U>
  98. struct tag<std::_Expr<T, U> >
  99. {
  100. typedef std_valarray_tag type;
  101. };
  102. #endif
  103. /// INTERNAL ONLY
  104. ///
  105. // This is necessary because the GCC stdlib uses expression templates, and
  106. // typeof(som-valarray-expression) is not an instance of std::valarray
  107. #define BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(Name, Op) \
  108. template<typename Left, typename Right> \
  109. struct Name<Left, Right, std_valarray_tag, std_valarray_tag> \
  110. : std::binary_function< \
  111. Left \
  112. , Right \
  113. , std::valarray< \
  114. typename Name< \
  115. typename Left::value_type \
  116. , typename Right::value_type \
  117. >::result_type \
  118. > \
  119. > \
  120. { \
  121. typedef typename Left::value_type left_value_type; \
  122. typedef typename Right::value_type right_value_type; \
  123. typedef \
  124. std::valarray< \
  125. typename Name<left_value_type, right_value_type>::result_type \
  126. > \
  127. result_type; \
  128. result_type \
  129. operator ()(Left &left, Right &right) const \
  130. { \
  131. return numeric::promote<std::valarray<left_value_type> >(left) \
  132. Op numeric::promote<std::valarray<right_value_type> >(right); \
  133. } \
  134. }; \
  135. template<typename Left, typename Right> \
  136. struct Name<Left, Right, std_valarray_tag, void> \
  137. : std::binary_function< \
  138. Left \
  139. , Right \
  140. , std::valarray< \
  141. typename Name<typename Left::value_type, Right>::result_type \
  142. > \
  143. > \
  144. { \
  145. typedef typename Left::value_type left_value_type; \
  146. typedef \
  147. std::valarray< \
  148. typename Name<left_value_type, Right>::result_type \
  149. > \
  150. result_type; \
  151. result_type \
  152. operator ()(Left &left, Right &right) const \
  153. { \
  154. return numeric::promote<std::valarray<left_value_type> >(left) Op right;\
  155. } \
  156. }; \
  157. template<typename Left, typename Right> \
  158. struct Name<Left, Right, void, std_valarray_tag> \
  159. : std::binary_function< \
  160. Left \
  161. , Right \
  162. , std::valarray< \
  163. typename Name<Left, typename Right::value_type>::result_type \
  164. > \
  165. > \
  166. { \
  167. typedef typename Right::value_type right_value_type; \
  168. typedef \
  169. std::valarray< \
  170. typename Name<Left, right_value_type>::result_type \
  171. > \
  172. result_type; \
  173. result_type \
  174. operator ()(Left &left, Right &right) const \
  175. { \
  176. return left Op numeric::promote<std::valarray<right_value_type> >(right);\
  177. } \
  178. };
  179. BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(plus, +)
  180. BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(minus, -)
  181. BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(multiplies, *)
  182. BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(divides, /)
  183. BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(modulus, %)
  184. #undef BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP
  185. ///////////////////////////////////////////////////////////////////////////////
  186. // element-wise min of std::valarray
  187. template<typename Left, typename Right>
  188. struct min_assign<Left, Right, std_valarray_tag, std_valarray_tag>
  189. : std::binary_function<Left, Right, void>
  190. {
  191. void operator ()(Left &left, Right &right) const
  192. {
  193. BOOST_ASSERT(left.size() == right.size());
  194. for(std::size_t i = 0, size = left.size(); i != size; ++i)
  195. {
  196. if(numeric::less(right[i], left[i]))
  197. {
  198. left[i] = right[i];
  199. }
  200. }
  201. }
  202. };
  203. ///////////////////////////////////////////////////////////////////////////////
  204. // element-wise max of std::valarray
  205. template<typename Left, typename Right>
  206. struct max_assign<Left, Right, std_valarray_tag, std_valarray_tag>
  207. : std::binary_function<Left, Right, void>
  208. {
  209. void operator ()(Left &left, Right &right) const
  210. {
  211. BOOST_ASSERT(left.size() == right.size());
  212. for(std::size_t i = 0, size = left.size(); i != size; ++i)
  213. {
  214. if(numeric::greater(right[i], left[i]))
  215. {
  216. left[i] = right[i];
  217. }
  218. }
  219. }
  220. };
  221. // partial specialization of numeric::average<> for std::valarray.
  222. template<typename Left, typename Right, typename RightTag>
  223. struct average<Left, Right, std_valarray_tag, RightTag>
  224. : mpl::if_<
  225. are_integral<typename Left::value_type, Right>
  226. , divides<Left, double const>
  227. , divides<Left, Right>
  228. >::type
  229. {};
  230. // promote
  231. template<typename To, typename From>
  232. struct promote<To, From, std_valarray_tag, std_valarray_tag>
  233. : std::unary_function<From, To>
  234. {
  235. To operator ()(From &arr) const
  236. {
  237. typename remove_const<To>::type res(arr.size());
  238. for(std::size_t i = 0, size = arr.size(); i != size; ++i)
  239. {
  240. res[i] = numeric::promote<typename To::value_type>(arr[i]);
  241. }
  242. return res;
  243. }
  244. };
  245. template<typename ToFrom>
  246. struct promote<ToFrom, ToFrom, std_valarray_tag, std_valarray_tag>
  247. : std::unary_function<ToFrom, ToFrom>
  248. {
  249. ToFrom &operator ()(ToFrom &tofrom) const
  250. {
  251. return tofrom;
  252. }
  253. };
  254. // for "promoting" a std::valarray<bool> to a bool, useful for
  255. // comparing 2 valarrays for equality:
  256. // if(numeric::promote<bool>(a == b))
  257. template<typename From>
  258. struct promote<bool, From, void, std_valarray_tag>
  259. : std::unary_function<From, bool>
  260. {
  261. bool operator ()(From &arr) const
  262. {
  263. BOOST_MPL_ASSERT((is_same<bool, typename From::value_type>));
  264. for(std::size_t i = 0, size = arr.size(); i != size; ++i)
  265. {
  266. if(!arr[i])
  267. {
  268. return false;
  269. }
  270. }
  271. return true;
  272. }
  273. };
  274. template<typename From>
  275. struct promote<bool const, From, void, std_valarray_tag>
  276. : promote<bool, From, void, std_valarray_tag>
  277. {};
  278. ///////////////////////////////////////////////////////////////////////////////
  279. // functional::as_min
  280. template<typename T>
  281. struct as_min<T, std_valarray_tag>
  282. : std::unary_function<T, typename remove_const<T>::type>
  283. {
  284. typename remove_const<T>::type operator ()(T &arr) const
  285. {
  286. return 0 == arr.size()
  287. ? T()
  288. : T(numeric::as_min(arr[0]), arr.size());
  289. }
  290. };
  291. ///////////////////////////////////////////////////////////////////////////////
  292. // functional::as_max
  293. template<typename T>
  294. struct as_max<T, std_valarray_tag>
  295. : std::unary_function<T, typename remove_const<T>::type>
  296. {
  297. typename remove_const<T>::type operator ()(T &arr) const
  298. {
  299. return 0 == arr.size()
  300. ? T()
  301. : T(numeric::as_max(arr[0]), arr.size());
  302. }
  303. };
  304. ///////////////////////////////////////////////////////////////////////////////
  305. // functional::as_zero
  306. template<typename T>
  307. struct as_zero<T, std_valarray_tag>
  308. : std::unary_function<T, typename remove_const<T>::type>
  309. {
  310. typename remove_const<T>::type operator ()(T &arr) const
  311. {
  312. return 0 == arr.size()
  313. ? T()
  314. : T(numeric::as_zero(arr[0]), arr.size());
  315. }
  316. };
  317. ///////////////////////////////////////////////////////////////////////////////
  318. // functional::as_one
  319. template<typename T>
  320. struct as_one<T, std_valarray_tag>
  321. : std::unary_function<T, typename remove_const<T>::type>
  322. {
  323. typename remove_const<T>::type operator ()(T &arr) const
  324. {
  325. return 0 == arr.size()
  326. ? T()
  327. : T(numeric::as_one(arr[0]), arr.size());
  328. }
  329. };
  330. } // namespace functional
  331. }} // namespace boost::numeric
  332. #endif