SGISTL源码探究-stl_numeric.h中的数值算法

前言

上一小节中,我们对stl中的算法部分做了一个大致的说明。本小节我们将进入到其中关于数值算法的部分,都在stl_numeric.h文件中。废话不多说,直接看源码吧。

stl_numeric

accumulate

注意该算法要求了迭代器的类型至少是InputIterator类型,如果是OutputIterator类型,肯定是不行的。
用于计算元素总和,init加上[first, last)范围内的元素之和。

template <class InputIterator, class T>
T accumulate(InputIterator first, InputIterator last, T init) {
  /* 将[first, last)的值累加到init上
   * 最后返回结果
   */
  for ( ; first != last; ++first)
    init = init + *first;
  return init;
}
//这里多提供了一个BinaryOperation参数。之前是执行的求和运算,现在换成binary_op,对每个元素执行binary_op操作,换成减法、乘法都可以,但是并不建议换成违背函数本意的操作。
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, last1)和[first2, first2 + (last1 - first1))的点积,最后加上init的值。

template <class InputIterator1, class InputIterator2, class T>
T inner_product(InputIterator1 first1, InputIterator1 last1,
                InputIterator2 first2, T init) {
  //遍历[first1, last)以及[first2, first2 + (last1 - first1))
  for ( ; first1 != last1; ++first1, ++first2)
    init = init + (*first1 * *first2);
  return init;
}

//该版本的inner_product不是执行init + (*fist1 ) * (*first2)操作,而是执行传入的binary_op1以及binary_op2操作
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

该函数用于计算局部的和。将*result赋值为*first,将*(result+1)赋值为*first + *(first+1)依次类推。
当传入的迭代器result为first,这就变成了一个质变算法了。

//该函数供partial_sum调用
template <class InputIterator, class OutputIterator, class T>
OutputIterator __partial_sum(InputIterator first, InputIterator last,
                             OutputIterator result, T*) {
  //从first + 1指向的位置开始进行累加并赋值给*result
  T value = *first;
  while (++first != last) {
    value = value + *first;
    *++result = value;
  }
  //注意返回的是result + (last - first)的位置,即当前被赋值末尾元素的下一个位置
  return ++result;
}

//partial_sum算法,版本一
template <class InputIterator, class OutputIterator>
OutputIterator partial_sum(InputIterator first, InputIterator last,
                           OutputIterator result) {
  //处理特殊情况,若first等于last,直接返回
  if (first == last) return result;
  //将*result赋值为*first
  *result = *first;
  //从first + 1开始遍历累加,并将结果返回
  return __partial_sum(first, last, result, value_type(first));
}

//这是针对提供了BinaryOperation的partial_sum算法版本实现的
template <class InputIterator, class OutputIterator, class T,
          class BinaryOperation>
OutputIterator __partial_sum(InputIterator first, InputIterator last,
                             OutputIterator result, T*,
                             BinaryOperation binary_op) {
  //不同之处在于之前的累加操作换成了binary_op二元操作
  T value = *first;
  while (++first != last) {
    value = binary_op(value, *first);
    *++result = value;
  }
  return ++result;
}

//partial_sum版本二,提供了自己的二元操作
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

该函数用于计算[first, last)中相邻元素之间的差。它将*result的值赋为*first,然后在[first+1, last)范围内的元素,分别计算*(first) - *(first-1)的值,然后分别赋值给*(result + 1)。
在不使用自己提供的binary_op情况下,它和partial_sum互为逆运算。比如{1, 2, 3, 4, 5},执行adjacent_difference之后,结果为{1, 1, 1, 1, 1},然后再对{1, 1, 1, 1, 1}执行partial_sum,结果又恢复成了原样,为{1, 2, 3, 4, 5}。

//该函数实现了adjacent_difference函数的主要功能,供adjacent_difference调用。和__partial_sum的实现很像,就是执行的二元操作不一样而已。
template <class InputIterator, class OutputIterator, class T>
OutputIterator __adjacent_difference(InputIterator first, InputIterator last,
                                     OutputIterator result, T*) {
  T value = *first;
  while (++first != last) {
    T tmp = *first;
    *++result = tmp - value;
    value = tmp;
  }
  return ++result;
}

//adjacent_difference,版本一
template <class InputIterator, class OutputIterator>
OutputIterator adjacent_difference(InputIterator first, InputIterator last,
                                   OutputIterator result) {
  if (first == last) return result;
  *result = *first;
  return __adjacent_difference(first, last, result, value_type(first));
}

//为提供了binary_op的adjacent_difference版本提供主要操作
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;
}

//adjacent_difference,版本二
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的标准中。它的作用是计算x的n次方,当然也可以自己指定运算的类型,比如加法除法之类的。

// Returns x ** n, where n >= 0.  Note that "multiplication"
//  is required to be associative, but not necessarily commutative.

//指定运算类型    
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;
  }
}

//调用上面的版本,通过multiplies<T>()表示做乘法运算
template <class T, class Integer>
inline T power(T x, Integer n) {
  return power(x, n, multiplies<T>());
}

上面计算x的n次方的计算方式并不是依次相乘,而是采用的快速幂算法。区分奇偶,计算x^n的值,只需要O(logn)的复杂度,而不是O(n)。
快速幂算法的公式如下:

• a^b = (a^2)^b/2,b为偶数
• a^b = (a^2)^b/2*a,b为奇数

比如2的4次方,并没有采用(2)*(2)*(2)*(2)这样依次相乘的算法,而是采用(2*2)*(2*2),这样的做法,这种只用2次运算,而依次相乘需要4次运算。

itoa

该函数由SGISTL提供,并不在STL标准中。
它并不是那个C语言里面实现的整数转字符串的函数。
而是在[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++;
}

小结

本小节对stl_numeric.h中的算法进行了分析,里面大部分算法都很简单,也就power算法稍微需要理解下,如果有算法基础也很容易理解。除了注重算法本身,也要注意它是如何实现泛化的,这点同样也很重要。