SGISTL源码阅读二十六 数值算法 （stl_numeric.h）

SGISTL源码阅读二十六 数值算法 （stl_numeric.h）

前言

上一篇博客我们简要介绍了一下STL中的算法，所有的数值算法都是放在<stl_numeric.h中的。

深入源码

accumulate

该算法是做累加操作，将指向范围的元素累加到init上，并且将init作为返回值返回，若init为0，则是计算迭代器指定范围值的累加和。要求迭代器类型至少为InputIterator

//版本1
template <class InputIterator, class T>
T accumulate(InputIterator first, InputIterator last, T init) {
  //将迭代器指定范围的元素值全部累加到init上
  for ( ; first != last; ++first)
    init = init + *first;
  return init;
}
//版本2
template <class InputIterator, class T, class BinaryOperation>
T accumulate(InputIterator first, InputIterator last, T init,
             BinaryOperation binary_op) {
  for ( ; first != last; ++first)
  	//对每个元素进行二元操作（外界提供的仿函数）
    init = binary_op(init, *first);
  return init;
}

inner_product

该算法用于计算两个序列，[first1,last)和[first2, first2+(last1-first1))的一般内积，用init暂存结果并返回，若init为0，则是计算迭代器指定范围的两个序列的一般内积。

//版本1
template <class InputIterator1, class InputIterator2, class T>
T inner_product(InputIterator1 first1, InputIterator1 last1,
                InputIterator2 first2, T init) {
  //做内积需要两个长度相同的序列，所以只需用迭代器指定一个序列的范围即可
  for ( ; first1 != last1; ++first1, ++first2)
    init = init + (*first1 * *first2);
  return init;
}
//版本2
template <class InputIterator1, class InputIterator2, class T,
          class BinaryOperation1, class BinaryOperation2>
T inner_product(InputIterator1 first1, InputIterator1 last1,
                InputIterator2 first2, T init, BinaryOperation1 binary_op1,
                BinaryOperation2 binary_op2) {
  for ( ; first1 != last1; ++first1, ++first2)
    //指定二元操作，外界提供的仿函数
    init = binary_op1(init, binary_op2(*first1, *first2));
  return init;
}

partial_sum

该算法用于计算局部和，这样说可能会被误解，我们用图示来解释。

//版本1
template <class InputIterator, class OutputIterator, class T>
OutputIterator __partial_sum(InputIterator first, InputIterator last,
                             OutputIterator result, T*) {
  //将value赋初值为*first
  T value = *first;
  //遍历[first, last)
  while (++first != last) {
    value = value + *first;
    //给result赋值同时移动它
    *++result = value;
  }
  return ++result;
}

template <class InputIterator, class OutputIterator>
OutputIterator partial_sum(InputIterator first, InputIterator last,
                           OutputIterator result) {
  //如果first和last是同一个迭代器，则直接返回result
  if (first == last) return result;
  //让result位置直接等于first
  *result = *first;
  //调用__partial_sum进行后续计算
  return __partial_sum(first, last, result, value_type(first));
}
//版本2
//核心思想与版本1类似，只是外界传入了指定的伪函数binary_op作为二元操作符
template <class InputIterator, class OutputIterator, class T,
          class BinaryOperation>
OutputIterator __partial_sum(InputIterator first, InputIterator last,
                             OutputIterator result, T*,
                             BinaryOperation binary_op) {
  T value = *first;
  while (++first != last) {
    value = binary_op(value, *first);
    *++result = value;
  }
  return ++result;
}
template <class InputIterator, class OutputIterator, class BinaryOperation>
OutputIterator partial_sum(InputIterator first, InputIterator last,
                           OutputIterator result, BinaryOperation binary_op) {
  if (first == last) return result;
  *result = *first;
  return __partial_sum(first, last, result, value_type(first), binary_op);
}

adjacent_difference

partial_sum算法用于计算局部和，而adjacent_difference用来计算[first, last)相邻元素的差，如图

//版本1
template <class InputIterator, class OutputIterator, class T>
OutputIterator __adjacent_difference(InputIterator first, InputIterator last,
                                     OutputIterator result, T*) {
  //将value赋初值为first
  T value = *first;
  //遍历[first, last)计算相邻元素的差
  while (++first != last) {
    //暂存当前元素的值
    T tmp = *first;
    //给result赋值为当前元素和前一个元素的差
    //并将result移位
    *++result = tmp - value;
    value = tmp;
  }
  return ++result;
}

template <class InputIterator, class OutputIterator>
OutputIterator adjacent_difference(InputIterator first, InputIterator last,
                                   OutputIterator result) {
  //如果first和last是同一个迭代器，则直接返回result
  if (first == last) return result;
  //result序列的第一个值为first
  *result = *first;
  //调用__adjacent_difference进行后续计算
  return __adjacent_difference(first, last, result, value_type(first));
}
//版本2
//核心思想与版本1类似，只是外界传入了指定的伪函数binary_op作为二元操作符
template <class InputIterator, class OutputIterator, class T,
          class BinaryOperation>
OutputIterator __adjacent_difference(InputIterator first, InputIterator last,
                                     OutputIterator result, T*,
                                     BinaryOperation binary_op) {
  T value = *first;
  while (++first != last) {
    T tmp = *first;
    *++result = binary_op(tmp, value);
    value = tmp;
  }
  return ++result;
}
template <class InputIterator, class OutputIterator, class BinaryOperation>
OutputIterator adjacent_difference(InputIterator first, InputIterator last,
                                   OutputIterator result,
                                   BinaryOperation binary_op) {
  if (first == last) return result;
  *result = *first;
  return __adjacent_difference(first, last, result, value_type(first),
                               binary_op);
}

power

这个算法是SGI专属，不在STL标准之列。
这个算法并不陌生，用于计算某数的n次方，使用了快速幂算法，区分奇偶,计算x^n的值,只需要O(logn)的复杂度,而不是O(n)。

• b为偶数：a^b = (a²⁾b/2
• b为奇数：a^b = (a²⁾b/2*a

//版本1
//指定操作符op
template <class T, class Integer, class MonoidOperation>
T power(T x, Integer n, MonoidOperation op) {
  if (n == 0)
    return identity_element(op);
  else {
    //当n为偶数,不断的执行op,然后将n/2,直到n为奇数
    while ((n & 1) == 0) {
      n >>= 1;
      x = op(x, x);
    }
	//对n为奇数时进行计算
    T result = x;
    n >>= 1;
    while (n != 0) {
      x = op(x, x);
      if ((n & 1) != 0)
        result = op(result, x);
      n >>= 1;
    }
    return result;
  }
}
//版本2，调用了版本1
//缺省为乘法运算
template <class T, class Integer>
inline T power(T x, Integer n) {
  return power(x, n, multiplies<T>());
}

iota

这个算法是SGI专属，不在STL标准之列。
用来设定某个区间的内容，使其内的每一个元素从指定的value开始呈现递增状态
在[first, last)区间内将元素的值依次设置为value, value + 1, value + 2…
是一种质变算法。

template <class ForwardIterator, class T>
void iota(ForwardIterator first, ForwardIterator last, T value) {
  while (first != last) *first++ = value++;
}

总结

我们可以看到以上的算法基本上都有两个版本，一个缺省操作符，另一个可由外界提供。
算法也并不难理解，值得学习的是power中的快速幂算法。