stl-numeric库使用

accumulate

累加运算。它的特点是参数中有初始值。

template <class InputIterator, class T>
T accumulate (InputIterator first, InputIterator last, T init);
	
template <class InputIterator, class T, class BinaryOperation>
T accumulate (InputIterator first, InputIterator last, T init,
             BinaryOperation binary_op);template <class InputIterator, class T>
   T accumulate (InputIterator first, InputIterator last, T init)
{
  while (first!=last) {
    init = init + *first;  // or: init=binary_op(init,*first) for the binary_op version
    ++first;
  }
  return init;
}

示例:

#include <iostream>   
#include <functional> //minus
#include <numeric>    

int MyAdd(int a, int b) { return a + 2 * b;}
class MyAddClass {
public:
    int operator()(int a, int b) { return a + 3 * b; }
}myAddClass;

int main () {
  int an[]={1, 2, 3};
  int nResult = 0;
  
  // 默认累加
  nResult = std::accumulate(an, an + _countof(an), 100);
  std::cout << nResult << '\n';
  // 106

  nResult = std::accumulate(an, an + _countof(an), 100, std::minus<int>());
  std::cout << "The result of 100-1-2-3 is " << nResult << "\n";
  //The result of 100-1-2-3 is 94.

  nResult = std::accumulate(an, an + _countof(an), 100, MyAdd);
  std::cout << "The result of 100+2+4+6 is " << nResult << "\n";
  //The result of 100+2+4+6 is 112

  nResult = std::accumulate(an, an + _countof(an), 100, myAddClass);
  std::cout << "The result of 100+3+6+9 is " << nResult << "\n";
  //The result of 100+3+6+9 is 118

  return 0;
}

partial_sum

也是累加运算，但保留每步的结果。

#include <iostream>   
#include <functional> 
#include <numeric>    


int main() {
    int an[] = { 10, 20, 30};
    int anResult[3] = {};
    int nCount = _countof(anResult);

    std::partial_sum(an, an+nCount, anResult);
    for (int i = 0; i < nCount; ++i) std::cout << anResult[i] << ' ';
    std::cout << '\n';
    // 10 30 60

    std::partial_sum(an, an + nCount, anResult, std::multiplies<int>());
    for (int i = 0; i < nCount; ++i) std::cout << anResult[i] << ' ';
    std::cout << '\n';
    // 10 200 6000

    return 0;
}

adjacent_diffentence

#include <iostream>   
#include <functional> //minus
#include <numeric>    

int myadd(int a, int b) { return a + b; }

int main () {
    int an[]={1, 2, 4, 7, 11};
    int anAdjDiff[5] = {};
    int nCount = _countof(anAdjDiff);
    
    std::adjacent_difference(an, an + nCount, anAdjDiff);
    
    for (int i = 0; i < nCount; ++i) std::cout << anAdjDiff[i] << ' ';
    std::cout << '\n';
    // 1 1 2 3 4
  
    std::adjacent_difference(an, an + nCount, anAdjDiff, std::multiplies<int>());
    for (int i = 0; i < nCount; ++i) std::cout << anAdjDiff[i] << ' ';
    std::cout << '\n';
    // 1 2 8 28 77
    
    std::adjacent_difference(an, an + nCount, anAdjDiff, myadd);
    for (int i = 0; i < nCount; ++i) std::cout << anAdjDiff[i] << ' ';
    std::cout << '\n';
    // 1 3 6 11 18

  return 0;
}

inner_product

可看作1xn, nx1的矩阵相乘。

template <class InputIterator1, class InputIterator2, class T>
T inner_product (InputIterator1 first1, InputIterator1 last1,
                InputIterator2 first2, T init)
{
  while (first1!=last1) {
    init = init + (*first1)*(*first2);
               // or: init = binary_op1 (init, binary_op2(*first1,*first2));
    ++first1; ++first2;
  }
  return init;
}

#include <iostream>   
#include <functional> 
#include <numeric>    


int main() {
    int anSeries1[] = { 10, 20, 30};
    int anSeries2[] = { 1, 2, 3};
    int nCount = _countof(anSeries2);

    std::cout << std::inner_product(anSeries1, anSeries1+nCount, anSeries2, 100) << '\n';
    // 100 + 10 * 1 + 20 * 2 + 30 * 3 == 240

    std::cout << std::inner_product(
        anSeries1,
        anSeries1 + nCount,
        anSeries2,
        100,
        std::minus<int>(),
        std::divides<int>());
    std::cout << '\n';
    // 100 - 10 / 1 - 20 / 2 - 30 / 3 == 70

    return 0;
}

iota

序列递增赋值。

这个就没有binary_op函数参数了。

#include <iostream>   
#include <numeric>    


int main() {
    int an[3] = { };
    int nCount = _countof(an);

    std::iota(an, an+nCount, 100);
    for (int& i : an) std::cout << i << ' ';
    std::cout << '\n';
    // 100 101 102

    return 0;
}