Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::transf...clusive_scan(3) C++ Standard Libarystd::transf...clusive_scan(3)

NAME
       std::transform_exclusive_scan - std::transform_exclusive_scan

Synopsis
	  Defined in header <numeric>
	  template< class InputIt, class OutputIt, class T,

		    class BinaryOp, class UnaryOp >
	  OutputIt  transform_exclusive_scan			    (1)	(since
       C++17)
	      (	InputIt	first, InputIt last, OutputIt d_first, T       (const-
       expr since C++20)
	  init,

		BinaryOp binary_op, UnaryOp unary_op );
	  template< class ExecutionPolicy,

		    class ForwardIt1, class ForwardIt2,	class T,
		    class BinaryOp, class UnaryOp >
	  ForwardIt2 transform_exclusive_scan			   (2)	(since
       C++17)
	      (	ExecutionPolicy&& policy,
		ForwardIt1 first, ForwardIt1 last, ForwardIt2
	  d_first, T init,

		BinaryOp binary_op, UnaryOp unary_op );

	  1) Computes the exclusive prefix sum using op.
	  For  each integer i in [0, std::distance(first, last)), performs the
       following
	  operations in	order:
	   1. Creates a	sequence which is formed by init followed by the  val-
       ues transformed
	      from  the	 elements of [first, iter) in order by unary_op, where
       iter is the next
	      i
	      th iterator of first.
	   2. Computes the generalized noncommutative sum of the sequence over
       binary_op.
	   3. Assigns the result to *dest, where dest is the next i
	      th iterator of d_first.
	  2) Same as (1), but executed according to policy.
	  This overload	participates in	overload resolution only if

	  std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>  is	 true.
       (until
										    C++20)
	  std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>  is
       true. (since
										    C++20)

	  The generalized noncommutative sum of	a sequence of elements over  a
       binary operation
	  binary_op is defined as follows:

	    *  If  the	sequence only has one element, the sum is the value of
       the element.
	    * Otherwise, performs the following	operations in order:
	   1. Selects any two adjacent elements	elem1 and elem2	from  the  se-
       quence.
	   2. Calculates binary_op(elem1, elem2) and replaces the two elements
       in the sequence
	      with the result.
	   3. Repeats steps 1 and 2 until there	is only	one element in the se-
       quence.

	  The  result is non-deterministic if the binary_op is not associative
       (such as
	  floating-point addition).

	  If any of the	following values is not	convertible to T, the  program
       is ill-formed:

	    * binary_op(init, init)
	    * binary_op(init, unary_op(*first))
	    * binary_op(unary_op(*first), unary_op(*first))

	  If any of the	following conditions is	satisfied, the behavior	is un-
       defined:

	    * T	is not MoveConstructible.
	    * unary_op or binary_op modifies any element of [first, last).
	    *  unary_op	 or  binary_op invalidates any iterator	or subrange of
       [first, last].

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 ele-
       ment 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.

Type requirements
	  -
	  InputIt must meet the	requirements of	LegacyInputIterator.
	  -
	  OutputIt must	meet the requirements of LegacyOutputIterator.
	  -
	  ForwardIt1, ForwardIt2 must  meet  the  requirements	of  LegacyFor-
       wardIterator.

Return value
	  Iterator to the element past the last	element	written.

Complexity
	  Given	\(\scriptsize N\)N as std::distance(first, last):

	  1,2) \(\scriptsize O(N)\)O(N)	applications of	unary_op and binary_op
       respectively.

Exceptions
	  The overload with a template parameter named ExecutionPolicy reports
       errors as
	  follows:

	    *  If  execution  of  a  function invoked as part of the algorithm
       throws an exception
	      and ExecutionPolicy is one of the	standard policies, std::termi-
       nate is called.
	      For any other ExecutionPolicy, the behavior  is  implementation-
       defined.
	    *  If  the	algorithm  fails to allocate memory, std::bad_alloc is
       thrown.

Notes
	  unary_op is never applied to init.

Example
       // Run this code

	#include <functional>
	#include <iostream>
	#include <iterator>
	#include <numeric>
	#include <vector>

	int main()
	{
	    std::vector	data{3,	1, 4, 1, 5, 9, 2, 6};

	    auto times_10 = [](int x) {	return x * 10; };

	    std::cout << "10 times exclusive sum: ";
	    std::transform_exclusive_scan(data.begin(),	data.end(),
					  std::ostream_itera-
       tor<int>(std::cout, " "),
					  0, std::plus<int>{}, times_10);
	    std::cout << "\n10 times inclusive sum: ";
	    std::transform_inclusive_scan(data.begin(),	data.end(),
					  std::ostream_itera-
       tor<int>(std::cout, " "),
					  std::plus<int>{}, times_10);
	    std::cout << '\n';
	}

Output:
	10 times exclusive sum:	0 30 40	80 90 140 230 250
	10 times inclusive sum:	30 40 80 90 140	230 250	310

See also
	  partial_sum		   computes the	partial	sum of a range of ele-
       ments
				   (function template)
	  exclusive_scan	   similar to std::partial_sum,	 excludes  the
       i^th input
	  (C++17)		   element from	the i^th sum
				   (function template)
	  transform_inclusive_scan  applies  an	invocable, then	calculates in-
       clusive scan
	  (C++17)		   (function template)

http://cppreference.com		  2024.06.10	 std::transf...clusive_scan(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::transform_exclusive_scan&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>

home | help