stl_nume.h
上传用户:nizebo
上传日期:2022-05-14
资源大小:882k
文件大小:8k
源码类别:

STL

开发平台:

Visual C++

  1. /*
  2.  *
  3.  * Copyright (c) 1994
  4.  * Hewlett-Packard Company
  5.  *
  6.  * Permission to use, copy, modify, distribute and sell this software
  7.  * and its documentation for any purpose is hereby granted without fee,
  8.  * provided that the above copyright notice appear in all copies and
  9.  * that both that copyright notice and this permission notice appear
  10.  * in supporting documentation.  Hewlett-Packard Company makes no
  11.  * representations about the suitability of this software for any
  12.  * purpose.  It is provided "as is" without express or implied warranty.
  13.  *
  14.  *
  15.  * Copyright (c) 1996,1997
  16.  * Silicon Graphics Computer Systems, Inc.
  17.  *
  18.  * Permission to use, copy, modify, distribute and sell this software
  19.  * and its documentation for any purpose is hereby granted without fee,
  20.  * provided that the above copyright notice appear in all copies and
  21.  * that both that copyright notice and this permission notice appear
  22.  * in supporting documentation.  Silicon Graphics makes no
  23.  * representations about the suitability of this software for any
  24.  * purpose.  It is provided "as is" without express or implied warranty.
  25.  */
  26. /* NOTE: This is an internal header file, included by other STL headers.
  27.  *   You should not attempt to use it directly.
  28.  */
  29. #ifndef __SGI_STL_INTERNAL_NUMERIC_H
  30. #define __SGI_STL_INTERNAL_NUMERIC_H
  31. __STL_BEGIN_NAMESPACE
  32. template <class _InputIterator, class _Tp>
  33. _Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
  34. {
  35.   __STL_REQUIRES(_InputIterator, _InputIterator);
  36.   for ( ; __first != __last; ++__first)
  37.     __init = __init + *__first;
  38.   return __init;
  39. }
  40. template <class _InputIterator, class _Tp, class _BinaryOperation>
  41. _Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,
  42.                _BinaryOperation __binary_op)
  43. {
  44.   __STL_REQUIRES(_InputIterator, _InputIterator);
  45.   for ( ; __first != __last; ++__first)
  46.     __init = __binary_op(__init, *__first);
  47.   return __init;
  48. }
  49. template <class _InputIterator1, class _InputIterator2, class _Tp>
  50. _Tp inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
  51.                   _InputIterator2 __first2, _Tp __init)
  52. {
  53.   __STL_REQUIRES(_InputIterator2, _InputIterator);
  54.   __STL_REQUIRES(_InputIterator2, _InputIterator);
  55.   for ( ; __first1 != __last1; ++__first1, ++__first2)
  56.     __init = __init + (*__first1 * *__first2);
  57.   return __init;
  58. }
  59. template <class _InputIterator1, class _InputIterator2, class _Tp,
  60.           class _BinaryOperation1, class _BinaryOperation2>
  61. _Tp inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
  62.                   _InputIterator2 __first2, _Tp __init, 
  63.                   _BinaryOperation1 __binary_op1,
  64.                   _BinaryOperation2 __binary_op2)
  65. {
  66.   __STL_REQUIRES(_InputIterator2, _InputIterator);
  67.   __STL_REQUIRES(_InputIterator2, _InputIterator);
  68.   for ( ; __first1 != __last1; ++__first1, ++__first2)
  69.     __init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
  70.   return __init;
  71. }
  72. template <class _InputIterator, class _OutputIterator, class _Tp>
  73. _OutputIterator 
  74. __partial_sum(_InputIterator __first, _InputIterator __last,
  75.               _OutputIterator __result, _Tp*)
  76. {
  77.   _Tp __value = *__first;
  78.   while (++__first != __last) {
  79.     __value = __value + *__first;
  80.     *++__result = __value;
  81.   }
  82.   return ++__result;
  83. }
  84. template <class _InputIterator, class _OutputIterator>
  85. _OutputIterator 
  86. partial_sum(_InputIterator __first, _InputIterator __last,
  87.             _OutputIterator __result)
  88. {
  89.   __STL_REQUIRES(_InputIterator, _InputIterator);
  90.   __STL_REQUIRES(_OutputIterator, _OutputIterator);
  91.   if (__first == __last) return __result;
  92.   *__result = *__first;
  93.   return __partial_sum(__first, __last, __result, __VALUE_TYPE(__first));
  94. }
  95. template <class _InputIterator, class _OutputIterator, class _Tp,
  96.           class _BinaryOperation>
  97. _OutputIterator 
  98. __partial_sum(_InputIterator __first, _InputIterator __last, 
  99.               _OutputIterator __result, _Tp*, _BinaryOperation __binary_op)
  100. {
  101.   _Tp __value = *__first;
  102.   while (++__first != __last) {
  103.     __value = __binary_op(__value, *__first);
  104.     *++__result = __value;
  105.   }
  106.   return ++__result;
  107. }
  108. template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
  109. _OutputIterator 
  110. partial_sum(_InputIterator __first, _InputIterator __last,
  111.             _OutputIterator __result, _BinaryOperation __binary_op)
  112. {
  113.   __STL_REQUIRES(_InputIterator, _InputIterator);
  114.   __STL_REQUIRES(_OutputIterator, _OutputIterator);
  115.   if (__first == __last) return __result;
  116.   *__result = *__first;
  117.   return __partial_sum(__first, __last, __result, __VALUE_TYPE(__first), 
  118.                        __binary_op);
  119. }
  120. template <class _InputIterator, class _OutputIterator, class _Tp>
  121. _OutputIterator 
  122. __adjacent_difference(_InputIterator __first, _InputIterator __last,
  123.                       _OutputIterator __result, _Tp*)
  124. {
  125.   _Tp __value = *__first;
  126.   while (++__first != __last) {
  127.     _Tp __tmp = *__first;
  128.     *++__result = __tmp - __value;
  129.     __value = __tmp;
  130.   }
  131.   return ++__result;
  132. }
  133. template <class _InputIterator, class _OutputIterator>
  134. _OutputIterator
  135. adjacent_difference(_InputIterator __first,
  136.                     _InputIterator __last, _OutputIterator __result)
  137. {
  138.   __STL_REQUIRES(_InputIterator, _InputIterator);
  139.   __STL_REQUIRES(_OutputIterator, _OutputIterator);
  140.   if (__first == __last) return __result;
  141.   *__result = *__first;
  142.   return __adjacent_difference(__first, __last, __result,
  143.                                __VALUE_TYPE(__first));
  144. }
  145. template <class _InputIterator, class _OutputIterator, class _Tp, 
  146.           class _BinaryOperation>
  147. _OutputIterator
  148. __adjacent_difference(_InputIterator __first, _InputIterator __last, 
  149.                       _OutputIterator __result, _Tp*,
  150.                       _BinaryOperation __binary_op) {
  151.   _Tp __value = *__first;
  152.   while (++__first != __last) {
  153.     _Tp __tmp = *__first;
  154.     *++__result = __binary_op(__tmp, __value);
  155.     __value = __tmp;
  156.   }
  157.   return ++__result;
  158. }
  159. template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
  160. _OutputIterator 
  161. adjacent_difference(_InputIterator __first, _InputIterator __last,
  162.                     _OutputIterator __result, _BinaryOperation __binary_op)
  163. {
  164.   __STL_REQUIRES(_InputIterator, _InputIterator);
  165.   __STL_REQUIRES(_OutputIterator, _OutputIterator);
  166.   if (__first == __last) return __result;
  167.   *__result = *__first;
  168.   return __adjacent_difference(__first, __last, __result,
  169.                                __VALUE_TYPE(__first),
  170.                                __binary_op);
  171. }
  172. // Returns __x ** __n, where __n >= 0.  _Note that "multiplication"
  173. // is required to be associative, but not necessarily commutative.
  174.  
  175. template <class _Tp, class _Integer, class _MonoidOperation>
  176. _Tp __power(_Tp __x, _Integer __n, _MonoidOperation __opr)
  177. {
  178.   if (__n == 0)
  179.     return identity_element(__opr);
  180.   else {
  181.     while ((__n & 1) == 0) {
  182.       __n >>= 1;
  183.       __x = __opr(__x, __x);
  184.     }
  185.     _Tp __result = __x;
  186.     __n >>= 1;
  187.     while (__n != 0) {
  188.       __x = __opr(__x, __x);
  189.       if ((__n & 1) != 0)
  190.         __result = __opr(__result, __x);
  191.       __n >>= 1;
  192.     }
  193.     return __result;
  194.   }
  195. }
  196. template <class _Tp, class _Integer>
  197. inline _Tp __power(_Tp __x, _Integer __n)
  198. {
  199.   return __power(__x, __n, multiplies<_Tp>());
  200. }
  201. // Alias for the internal name __power.  Note that power is an extension,
  202. // not part of the C++ standard.
  203. template <class _Tp, class _Integer, class _MonoidOperation>
  204. inline _Tp power(_Tp __x, _Integer __n, _MonoidOperation __opr)
  205. {
  206.   return __power(__x, __n, __opr);
  207. }
  208. template <class _Tp, class _Integer>
  209. inline _Tp power(_Tp __x, _Integer __n)
  210. {
  211.   return __power(__x, __n);
  212. }
  213. // iota is not part of the C++ standard.  It is an extension.
  214. template <class _ForwardIter, class _Tp>
  215. void 
  216. iota(_ForwardIter __first, _ForwardIter __last, _Tp __value)
  217. {
  218.   __STL_REQUIRES(_ForwardIter, _Mutable_ForwardIterator);
  219.   __STL_CONVERTIBLE(_Tp, typename iterator_traits<_ForwardIter>::value_type);
  220.   while (__first != __last)
  221.     *__first++ = __value++;
  222. }
  223. __STL_END_NAMESPACE
  224. #endif /* __SGI_STL_INTERNAL_NUMERIC_H */
  225. // Local Variables:
  226. // mode:C++
  227. // End: