
//版本1
template <class InputIterator,class T>
T accumulate(InputIterator first,InputIterator last,T init){for(;first != last; ++first){init += *first; //将每个元素数值累加到init身上}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;
}

accumulate用于计算init和[first , last)内部所有元素的总和。需要提供一个init，表示当[first,last)为空的区间仍然可以获取一个明确定义的数值，如果想获得[first,last)内所有数值的总和，应将init设为0
二元操作符不必满足交换律和结合律，是的accumulate的行为顺序有着明确的定义：先将init初始化，然后针对[first,last)区间内的每一个迭代器i，依次执行init = init + *i(第一版本) 或者 init = binary_op(init, *i) (第二版本)

使用例子

#include <iostream>   //std::cout
#include <functional> //std::minuc
#include <numeric>    //std::accumulateint my_function(int x,int y){return x + 2*y;}
struct my_class{int operator()(int x,int y){return x + 3*y;}
}my_object;int main(){int init = 100;int numbers[] = {10,20,30};
//    std::cout << << std::endl;std::cout << "using default accumulate" << std::endl;std::cout << std::accumulate(numbers,numbers+3,init) << std::endl;std::cout << "using functional's accumulate" << std::endl;std::cout << std::accumulate(numbers,numbers+3,init,std::minus<int>()) << std::endl;std::cout << "using custom function" << std::endl;std::cout << std::accumulate(numbers,numbers+3,init, my_function) << std::endl;std::cout << "using custom object" << std::endl;std::cout << std::accumulate(numbers,numbers+3,init, my_object) << std::endl;}

adjacent_difference

用于计算[first,last)中相邻元素的差额
将*first 赋值给*result，并针对[first+1,last)内的每个迭代器i 将*i-*（i-1）的数值赋值给*（result+（i-first））
使用就地方式也就是让result 等于first 函数为质变算法
存储第一元素的数值然后存储后继元素的差值，便可=可以重建输入区间的原始内容
adjacent_difference 和 partial_sum互为逆运算，如果对区间1 2 3 4 5 执行adjacent_difference结果为1 1 1 1 1，如果对这个结果执行partial_sum 便会得到原始的区间数值为1 2 3 4 5

#include <iostream>   //std::cout
#include <functional> //std::minuc
#include <numeric>    //std::adjacent_differencetemplate <class InputIterator,class OutputIterator>
OutputIterator adjacent_difference(InputIterator first,InputIterator last,OutputIterator result){if(first != last){typename std::iterator_traits<InputIterator>::value_type val,prev;*result = prev = *first;while (++first != last){val = *first;*++result = val - prev; //*++result = binary_op(val,prev);prev = val;}++result;}return result;
}template <class InputIterator,class OutputIterator,class BinaryOperation>
OutputIterator adjacent_difference(InputIterator first,InputIterator last,OutputIterator result,BinaryOperation binary_op){if (first!=last){typename std::iterator_traits<InputIterator>::value_type val,prev;*result = prev = *first;while(++first != last){val = *first;*++result = binary_op(val,prev);prev = val;}}return result;
}//int my_function(int x,int y){return x + 2*y;}
//struct my_class{
//    int operator()(int x,int y){
//        return x + 3*y;
//    }
//}my_object;int myop(int x,int y){return x+y;
}int main(){int val[] = {4,2,3,5,9,11,12};int result[7];std::adjacent_difference(val,val+7,result);std::cout << "using default adjacent_difference" << std::endl;for (int i = 0; i < 7; ++i) {std::cout << result[i] << ' ';}std::cout << std::endl;std::adjacent_difference(val,val+7,result,std::multiplies<int>());std::cout << "using functional operation multiplies" << std::endl;for (int i = 0; i < 7; ++i) {std::cout << result[i] << ' ';}std::cout << std::endl;std::adjacent_difference(val,val+7,result, myop);std::cout << "using custom function" << std::endl;for (int i = 0; i < 7; ++i) {std::cout << result[i] << ' ';}std::cout << std::endl;//    using default adjacent_difference
//    4 -2 1 2 4 2 1
//    using functional operation multiplies
//    4 8 6 15 45 99 132
//    using custom function
//    4 6 5 8 14 20 23}

inner_product

执行两个序列的一般内积
算法计算 [first1,last1) 和 [first2,first2 + （last1 - first1）)的一般内积
需要提供初始数值，用于区间为空的时候得到一个明确定义的结果

#include <iostream>   //std::cout
#include <functional> //std::minuc
#include <numeric>    //std::adjacent_differencetemplate <class InputIterator,class OutputIterator,class T>
T inner_product(InputIterator first1,InputIterator last1,InputIterator first2,T init){while (first1 != last1){init =init + (*first1) * (*first2);++first1;++first2;}return init;
}template <class InputIterator,class OutputIterator,class T,class BinaryOperation1,class BinaryOperation2>
T inner_product(InputIterator first1,InputIterator last1,InputIterator first2,T init,BinaryOperation1 binary_op1,BinaryOperation2 binary_op2){//以第一序列的元素个数为依据，将两个序列都遍历一遍while (first1 != last1){init = binary_op1(init,binary_op2(*first1,*first2));++first1;++first2;}return init;
}int myaccumulator(int x,int y){return x-y;}
int myproduct(int x,int y){return x+y;}int main(){int init = 100;int series1[] = {10,20,30};int series2[] = {1,2,3};std::cout << "using default inner_product" << std::endl;std::cout << std::inner_product(series1,series1+3,series2,init);
//    for (int i = 0; i < 7; ++i) {
//        std::cout << result[i] << ' ';
//    }std::cout << std::endl;std::cout << "using functional operations" << std::endl;std::cout << std::inner_product(series1,series1+3,series2,init,std::minus<int>(),std::divides<int>());
//    for (int i = 0; i < 7; ++i) {
//        std::cout << result[i] << ' ';
//    }std::cout << std::endl;std::cout << "using custom functions" << std::endl;std::cout << std::inner_product(series1,series1+3,series2,init, myaccumulator, myproduct);
//    for (int i = 0; i < 7; ++i) {
//        std::cout << result[i] << ' ';
//    }std::cout << std::endl;
//    using default inner_product
//    240 = 100 + (10*1) + (20*2) + (30*3)
//    using functional operations
//    70 = 100 - (10/1) - (20/2) - (30/3) 
//    using custom functions
//    34 = 100 - (10+1) - (20+2) - (30+3)
}

partial_sum

partial_sum用于计算局部总和，将*first赋值给*result，将*first和*（first+1）的数值的和赋值给*（result+1）
可以转化为质变算法
函数返回 result + （last - first）
和先前介绍的adjacent_difference互为逆运算

#include <iostream>   //std::cout
#include <functional> //std::minuc
#include <numeric>    //std::adjacent_differencetemplate <class InputIterator,class OutputIterator>
OutputIterator partial_sum(InputIterator first,InputIterator last,OutputIterator result){if (first != last){typename  std::iterator_traits<InputIterator>::value_type val = *first;*result = val;while (++first!=last){val = val + *first;*++result = val;}++result;}return result;
}template <class InputIterator,class OutputIterator,class BinaryOperation>
OutputIterator partial_sum(InputIterator first,InputIterator last,BinaryOperation binary_op,OutputIterator result){if (first != last){typename  std::iterator_traits<InputIterator>::value_type val = *first;*result = val;while (++first!=last){val = binary_op(val,*first);*++result = val;}++result;}return result;
}//int myaccumulator(int x,int y){return x-y;}
//int myproduct(int x,int y){return x+y;}int myop(int x,int y){return x+y+1;}int main(){
//    int init = 100;int series1[] = {1,2,3,4,5};int result[5];std::cout << "using default partial_sum" << std::endl;std::partial_sum(series1,series1+5,result);for (int i = 0; i < 5; ++i) {std::cout << result[i] << ' ';}std::cout << std::endl;std::cout << "using functional operation multiplies" << std::endl;std::partial_sum(series1,series1+5,result,std::multiplies<int>());for (int i = 0; i < 5; ++i) {std::cout << result[i] << ' ';}std::cout << std::endl;std::cout << "using custom functions" << std::endl;std::partial_sum(series1,series1+5, result,myop);for (int i = 0; i < 5; ++i) {std::cout << result[i] << ' ';}std::cout << std::endl;
//    using default partial_sum
//    1 3 6 10 15
//    using functional operation multiplies
//    1 2 6 24 120
//    using custom functions
//    1 4 8 13 19
}

Power

计算某数的n幂次方即自己对自己进行某种运算到达n次
运算类型可以由外界指定，如果指定为乘法那就是乘幂
目前使用pow替代

//版本1 乘幂
template <class T,class Integer>
inline T power(T x,Integer n){return power(x,n,std::multiplies<T>());
}//幂次方 指定为乘法运算，则当n >= 0 返回 x^n
//需要满足结合律 但是不需要满足交换律
template <class T,class Integer,class MonoidOperation>
T power(T x,Integer n,MonoidOperation op){if (n==0){return identity_element(op);} else{while((n&1)==0){n>>=1;x = op(x,x);}T result = x;n >> 1;while(n!=0){x = op(x,x);if ((n&1)!=0)result = op(result,x);n >>= 1;}return result;}
}

itoa

用于设定某个区间的内容，使其内的每一个元素从指定的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++;}
}

参考链接

accumulate - C++ Reference
adjacent_difference - C++ Reference
inner_product - C++ Reference
https://www.cplusplus.com/reference/numeric/partial_sum/?kw=partial_sum
pow - C++ Reference

STL源码剖析数值算法 accumulate | adjacent_difference | inner_product | partial_sum | power | itoa

使用例子

adjacent_difference

inner_product

partial_sum

Power

itoa

参考链接

相关文章

python官网网址是什么意思_大家都是怎么部署python网站的？

java回形数矩阵

STL源码剖析基本算法 equal | fill | iter_awap | lexicographical_compare | max | min | swap |mismatch

svm分类器训练详细步骤_「五分钟机器学习」向量支持机SVM——学霸中的战斗机...

java一维数组的复制

STL源码剖析数值算法 copy 算法

python输入数字成数组_python – Numpy：将数值插入数组的最快方法,使得数组按顺序排列...

java 一维数组的反转

STL源码剖析数值算法 copy_backward 算法

java线性查找和二分查找

python开发web项目_Django2：Web项目开发入门笔记（20）

STL源码剖析 Set相关算法并集 set_union|交集 set_intersection|差集 set_difference |对称差集 set_symmetric_difference

python sqlserver 数据操作_python对Excel数据进行读写操作

Arrays数组工具类

通过解析URL实现通过Wifi的用户查找

anaconda中怎么sh_【好工具】深度学习炼丹，你怎么能少了这款工具！JupyterLab 远程访问指南...

java 类和对象属性和行为成员变量和局部变量

STL源码剖析数值算法 heap算法

java 学生对象数组

STL源码剖析 lower_bound | upper_bound | binary_search

STL源码剖析 数值算法 accumulate | adjacent_difference | inner_product | partial_sum | power | itoa

使用例子

adjacent_difference

inner_product

partial_sum

Power

itoa

参考链接

相关文章

STL源码剖析数值算法 accumulate | adjacent_difference | inner_product | partial_sum | power | itoa