std::transform_inclusive_scan
Defined in header <numeric>


template< class InputIt, class OutputIt, class BinaryOperation, class UnaryOperation > 
(1)  (since C++17) 
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryOperation, class UnaryOperation > 
(2)  (since C++17) 
template< class InputIt, class OutputIt, class BinaryOperation, class UnaryOperation, class T > 
(3)  (since C++17) 
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryOperation, class UnaryOperation, class T > 
(4)  (since C++17) 
Transforms each element in the range [first, last)
with unary_op
, then computes an inclusive prefix sum operation using binary_op
over the resulting range, optionally with init
as the initial value, and writes the results to the range beginning at d_first
. "inclusive" means that the ith input element is included in the ith sum.
Formally, assigns through each iterator i
in [d_first, d_first + (last  first)) the value of
 for overloads (12), the generalized noncommutative sum of
unary_op(*j)...
for everyj
in [first, first + (i  d_first + 1)) overbinary_op
,  for overloads (34), the generalized noncommutative sum of
init, unary_op(*j)...
for everyj
in [first, first + (i  d_first + 1)) overbinary_op
,
where generalized noncommutative sum GNSUM(op, a
1, ..., a
N) is defined as follows:
 if N=1, a
1  if N > 1, op(GNSUM(op, a
1, ..., a
K), GNSUM(op, a
M, ..., a
N)) for any K where 1 < K+1 = M ≤ N
In other words, the summation operations may be performed in arbitrary order, and the behavior is nondeterministic if binary_op
is not associative.
Overloads (2, 4) are executed according to policy
, and do not participate in overload resolution unless std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> is true.
unary_op
and binary_op
shall not invalidate iterators (including the end iterators) or subranges, nor modify elements in the ranges [first, last) or [d_first, d_first + (last  first)). Otherwise, the behavior is undefined.
Parameters
first, last    the range of elements to sum 
d_first    the beginning of the destination range; may be equal to first

policy    the execution policy to use. See execution policy for details. 
init    the initial value 
unary_op    unary FunctionObject that will be applied to each element of the input range. The return type must be acceptable as input to binary_op .

binary_op    binary FunctionObject that will be applied in to the result of unary_op , the results of other binary_op , and init if provided.

Type requirements  
InputIt must meet the requirements of InputIterator.
 
OutputIt must meet the requirements of OutputIterator.
 
ForwardIt1 must meet the requirements of ForwardIterator. and, if init is not provided, ForwardIt1's value_type must be MoveConstructible and binary_op(unary_op(*first), unary_op(*first)) must be convertible to ForwardIt1's value type
 
ForwardIt2 must meet the requirements of ForwardIterator.
 
T (if init is provided) must meet the requirements of MoveConstructible. All of binary_op(init, unary_op(*first)) , binary_op(init, init) , and binary_op(unary_op(*first), unary_op(*first)) must be convertible to T

Return value
Iterator to the element past the last element written.
Complexity
O(last  first) applications of each of binary_op
and unary_op
.
Exceptions
The overloads with a template parameter named ExecutionPolicy
report errors as follows:
 If execution of a function invoked as part of the algorithm throws an exception and
ExecutionPolicy
is one of the three standard policies, std::terminate is called. For any otherExecutionPolicy
, the behavior is implementationdefined.  If the algorithm fails to allocate memory, std::bad_alloc is thrown.
Notes
unary_op
is not applied to init
.
The parameter init
appears last, differing from std::transform_exclusive_scan, because it is optional for this function.
Example
This section is incomplete Reason: no example 
See also
computes the partial sum of a range of elements (function template)  
applies a function to a range of elements (function template)  
(C++17) 
similar to std::partial_sum, includes the ith input element in the ith sum (function template) 
(C++17) 
applies a functor, then calculates exclusive scan (function template) 