stl_numeric.h
上传用户:sichengcw
上传日期:2009-02-17
资源大小:202k
文件大小:6k
源码类别:

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 T>
  33. T accumulate(InputIterator first, InputIterator last, T init) {
  34.   for ( ; first != last; ++first)
  35.     init = init + *first;
  36.   return init;
  37. }
  38. template <class InputIterator, class T, class BinaryOperation>
  39. T accumulate(InputIterator first, InputIterator last, T init,
  40.              BinaryOperation binary_op) {
  41.   for ( ; first != last; ++first)
  42.     init = binary_op(init, *first);
  43.   return init;
  44. }
  45. template <class InputIterator1, class InputIterator2, class T>
  46. T inner_product(InputIterator1 first1, InputIterator1 last1,
  47.                 InputIterator2 first2, T init) {
  48.   for ( ; first1 != last1; ++first1, ++first2)
  49.     init = init + (*first1 * *first2);
  50.   return init;
  51. }
  52. template <class InputIterator1, class InputIterator2, class T,
  53.           class BinaryOperation1, class BinaryOperation2>
  54. T inner_product(InputIterator1 first1, InputIterator1 last1,
  55.                 InputIterator2 first2, T init, BinaryOperation1 binary_op1,
  56.                 BinaryOperation2 binary_op2) {
  57.   for ( ; first1 != last1; ++first1, ++first2)
  58.     init = binary_op1(init, binary_op2(*first1, *first2));
  59.   return init;
  60. }
  61. template <class InputIterator, class OutputIterator, class T>
  62. OutputIterator __partial_sum(InputIterator first, InputIterator last,
  63.                              OutputIterator result, T*) {
  64.   T value = *first;
  65.   while (++first != last) {
  66.     value = value + *first;
  67.     *++result = value;
  68.   }
  69.   return ++result;
  70. }
  71. template <class InputIterator, class OutputIterator>
  72. OutputIterator partial_sum(InputIterator first, InputIterator last,
  73.                            OutputIterator result) {
  74.   if (first == last) return result;
  75.   *result = *first;
  76.   return __partial_sum(first, last, result, value_type(first));
  77. }
  78. template <class InputIterator, class OutputIterator, class T,
  79.           class BinaryOperation>
  80. OutputIterator __partial_sum(InputIterator first, InputIterator last,
  81.                              OutputIterator result, T*,
  82.                              BinaryOperation binary_op) {
  83.   T value = *first;
  84.   while (++first != last) {
  85.     value = binary_op(value, *first);
  86.     *++result = value;
  87.   }
  88.   return ++result;
  89. }
  90. template <class InputIterator, class OutputIterator, class BinaryOperation>
  91. OutputIterator partial_sum(InputIterator first, InputIterator last,
  92.                            OutputIterator result, BinaryOperation binary_op) {
  93.   if (first == last) return result;
  94.   *result = *first;
  95.   return __partial_sum(first, last, result, value_type(first), binary_op);
  96. }
  97. template <class InputIterator, class OutputIterator, class T>
  98. OutputIterator __adjacent_difference(InputIterator first, InputIterator last, 
  99.                                      OutputIterator result, T*) {
  100.   T value = *first;
  101.   while (++first != last) {
  102.     T tmp = *first;
  103.     *++result = tmp - value;
  104.     value = tmp;
  105.   }
  106.   return ++result;
  107. }
  108. template <class InputIterator, class OutputIterator>
  109. OutputIterator adjacent_difference(InputIterator first, InputIterator last, 
  110.                                    OutputIterator result) {
  111.   if (first == last) return result;
  112.   *result = *first;
  113.   return __adjacent_difference(first, last, result, value_type(first));
  114. }
  115. template <class InputIterator, class OutputIterator, class T, 
  116.           class BinaryOperation>
  117. OutputIterator __adjacent_difference(InputIterator first, InputIterator last, 
  118.                                      OutputIterator result, T*,
  119.                                      BinaryOperation binary_op) {
  120.   T value = *first;
  121.   while (++first != last) {
  122.     T tmp = *first;
  123.     *++result = binary_op(tmp, value);
  124.     value = tmp;
  125.   }
  126.   return ++result;
  127. }
  128. template <class InputIterator, class OutputIterator, class BinaryOperation>
  129. OutputIterator adjacent_difference(InputIterator first, InputIterator last,
  130.                                    OutputIterator result,
  131.                                    BinaryOperation binary_op) {
  132.   if (first == last) return result;
  133.   *result = *first;
  134.   return __adjacent_difference(first, last, result, value_type(first),
  135.                                binary_op);
  136. }
  137. // Returns x ** n, where n >= 0.  Note that "multiplication"
  138. //  is required to be associative, but not necessarily commutative.
  139.     
  140. template <class T, class Integer, class MonoidOperation>
  141. T power(T x, Integer n, MonoidOperation op) {
  142.   if (n == 0)
  143.     return identity_element(op);
  144.   else {
  145.     while ((n & 1) == 0) {
  146.       n >>= 1;
  147.       x = op(x, x);
  148.     }
  149.     T result = x;
  150.     n >>= 1;
  151.     while (n != 0) {
  152.       x = op(x, x);
  153.       if ((n & 1) != 0)
  154.         result = op(result, x);
  155.       n >>= 1;
  156.     }
  157.     return result;
  158.   }
  159. }
  160. template <class T, class Integer>
  161. inline T power(T x, Integer n) {
  162.   return power(x, n, multiplies<T>());
  163. }
  164. template <class ForwardIterator, class T>
  165. void iota(ForwardIterator first, ForwardIterator last, T value) {
  166.   while (first != last) *first++ = value++;
  167. }
  168. __STL_END_NAMESPACE
  169. #endif /* __SGI_STL_INTERNAL_NUMERIC_H */
  170. // Local Variables:
  171. // mode:C++
  172. // End: