exclusive_scan#

Overloads#

exclusive_scan(exec, first, last, result)#

template<typename DerivedPolicy, typename InputIterator, typename OutputIterator>
OutputIterator thrust::exclusive_scan(
const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
InputIterator first,
InputIterator last,
OutputIterator result,
)#

exclusive_scan computes an exclusive prefix sum operation. The term ‘exclusive’ means that each result does not include the corresponding input operand in the partial sum. More precisely, 0 is assigned to *result and the sum of 0 and *first is assigned to *(result + 1), and so on. This version of exclusive_scan assumes plus as the associative operator and 0 as the initial value. When the input and output sequences are the same, the scan is performed in-place.

Results are not deterministic for pseudo-associative operators (e.g., addition of floating-point types). Results for pseudo-associative operators may vary from run to run.

The algorithm’s execution is parallelized as determined by exec.

The following code snippet demonstrates how to use exclusive_scan to compute an in-place prefix sum using the thrust::host execution policy for parallelization:

#include <thrust/scan.h>
#include <thrust/execution_policy.h>
...

int data[6] = {1, 0, 2, 2, 1, 3};

thrust::exclusive_scan(thrust::host, data, data + 6, data); // in-place scan

// data is now {0, 1, 1, 3, 5, 6}

See also

https://en.cppreference.com/w/cpp/algorithm/partial_sum

Parameters:

  • exec – The execution policy to use for parallelization.

  • first – The beginning of the input sequence.

  • last – The end of the input sequence.

  • result – The beginning of the output sequence.

Template Parameters:

  • DerivedPolicy – The name of the derived execution policy.

  • InputIterator – is a model of Input Iterator and InputIterator's value_type is convertible to OutputIterator's value_type.

  • OutputIterator – is a model of Output Iterator, and if x and y are objects of OutputIterator's value_type, then x + y is defined. If T is OutputIterator's value_type, then T(0) is defined.

Returns:

The end of the output sequence.

Pre:

first may equal result but the range [first, last) and the range [result, result + (last - first)) shall not overlap otherwise.

exclusive_scan(first, last, result)#

template<typename InputIterator, typename OutputIterator>
OutputIterator thrust::exclusive_scan(
InputIterator first,
InputIterator last,
OutputIterator result,
)#

exclusive_scan computes an exclusive prefix sum operation. The term ‘exclusive’ means that each result does not include the corresponding input operand in the partial sum. More precisely, 0 is assigned to *result and the sum of 0 and *first is assigned to *(result + 1), and so on. This version of exclusive_scan assumes plus as the associative operator and 0 as the initial value. When the input and output sequences are the same, the scan is performed in-place.

Results are not deterministic for pseudo-associative operators (e.g., addition of floating-point types). Results for pseudo-associative operators may vary from run to run.

The following code snippet demonstrates how to use exclusive_scan 

#include <thrust/scan.h>

int data[6] = {1, 0, 2, 2, 1, 3};

thrust::exclusive_scan(data, data + 6, data); // in-place scan

// data is now {0, 1, 1, 3, 5, 6}

See also

https://en.cppreference.com/w/cpp/algorithm/partial_sum

Parameters:

  • first – The beginning of the input sequence.

  • last – The end of the input sequence.

  • result – The beginning of the output sequence.

Template Parameters:

  • InputIterator – is a model of Input Iterator and InputIterator's value_type is convertible to OutputIterator's value_type.

  • OutputIterator – is a model of Output Iterator, and if x and y are objects of OutputIterator's value_type, then x + y is defined. If T is OutputIterator's value_type, then T(0) is defined.

Returns:

The end of the output sequence.

Pre:

first may equal result but the range [first, last) and the range [result, result + (last - first)) shall not overlap otherwise.

exclusive_scan(exec, first, last, result, init)#

template<typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename T>
OutputIterator thrust::exclusive_scan(
const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
InputIterator first,
InputIterator last,
OutputIterator result,
T init,
)#

exclusive_scan computes an exclusive prefix sum operation. The term ‘exclusive’ means that each result does not include the corresponding input operand in the partial sum. More precisely, init is assigned to *result and the sum of init and *first is assigned to *(result + 1), and so on. This version of exclusive_scan assumes plus as the associative operator but requires an initial value init. When the input and output sequences are the same, the scan is performed in-place.

Results are not deterministic for pseudo-associative operators (e.g., addition of floating-point types). Results for pseudo-associative operators may vary from run to run.

The algorithm’s execution is parallelized as determined by exec.

The following code snippet demonstrates how to use exclusive_scan to compute an in-place prefix sum using the thrust::host execution policy for parallelization:

#include <thrust/scan.h>
#include <thrust/execution_policy.h>

int data[6] = {1, 0, 2, 2, 1, 3};

thrust::exclusive_scan(thrust::host, data, data + 6, data, 4); // in-place scan

// data is now {4, 5, 5, 7, 9, 10}

See also

https://en.cppreference.com/w/cpp/algorithm/partial_sum

Parameters:

  • exec – The execution policy to use for parallelization.

  • first – The beginning of the input sequence.

  • last – The end of the input sequence.

  • result – The beginning of the output sequence.

  • init – The initial value.

Template Parameters:

  • DerivedPolicy – The name of the derived execution policy.

  • InputIterator – is a model of Input Iterator and InputIterator's value_type is convertible to OutputIterator's value_type.

  • OutputIterator – is a model of Output Iterator, and if x and y are objects of OutputIterator's value_type, then x + y is defined.

  • T – is convertible to OutputIterator's value_type.

Returns:

The end of the output sequence.

Pre:

first may equal result but the range [first, last) and the range [result, result + (last - first)) shall not overlap otherwise.

exclusive_scan(first, last, result, init)#

template<typename InputIterator, typename OutputIterator, typename T>
OutputIterator thrust::exclusive_scan(
InputIterator first,
InputIterator last,
OutputIterator result,
T init,
)#

exclusive_scan computes an exclusive prefix sum operation. The term ‘exclusive’ means that each result does not include the corresponding input operand in the partial sum. More precisely, init is assigned to *result and the sum of init and *first is assigned to *(result + 1), and so on. This version of exclusive_scan assumes plus as the associative operator but requires an initial value init. When the input and output sequences are the same, the scan is performed in-place.

Results are not deterministic for pseudo-associative operators (e.g., addition of floating-point types). Results for pseudo-associative operators may vary from run to run.

The following code snippet demonstrates how to use exclusive_scan 

#include <thrust/scan.h>

int data[6] = {1, 0, 2, 2, 1, 3};

thrust::exclusive_scan(data, data + 6, data, 4); // in-place scan

// data is now {4, 5, 5, 7, 9, 10}

See also

https://en.cppreference.com/w/cpp/algorithm/partial_sum

Parameters:

  • first – The beginning of the input sequence.

  • last – The end of the input sequence.

  • result – The beginning of the output sequence.

  • init – The initial value.

Template Parameters:

  • InputIterator – is a model of Input Iterator and InputIterator's value_type is convertible to OutputIterator's value_type.

  • OutputIterator – is a model of Output Iterator, and if x and y are objects of OutputIterator's value_type, then x + y is defined.

  • T – is convertible to OutputIterator's value_type.

Returns:

The end of the output sequence.

Pre:

first may equal result but the range [first, last) and the range [result, result + (last - first)) shall not overlap otherwise.

exclusive_scan(exec, first, last, result, init, binary_op)#

template<typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename T, typename AssociativeOperator>
OutputIterator thrust::exclusive_scan(
const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
InputIterator first,
InputIterator last,
OutputIterator result,
T init,
AssociativeOperator binary_op,
)#

exclusive_scan computes an exclusive prefix sum operation. The term ‘exclusive’ means that each result does not include the corresponding input operand in the partial sum. More precisely, init is assigned to *result and the value binary_op(init, *first) is assigned to *(result + 1), and so on. This version of the function requires both an associative operator and an initial value init. When the input and output sequences are the same, the scan is performed in-place.

Results are not deterministic for pseudo-associative operators (e.g., addition of floating-point types). Results for pseudo-associative operators may vary from run to run.

The algorithm’s execution is parallelized as determined by exec.

The following code snippet demonstrates how to use exclusive_scan to compute an in-place prefix sum using the thrust::host execution policy for parallelization:

#include <thrust/scan.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...

int data[10] = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8};

::cuda::maximum<int> binary_op;

thrust::exclusive_scan(thrust::host, data, data + 10, data, 1, binary_op); // in-place scan

// data is now {1, 1, 1, 2, 2, 2, 4, 4, 4, 4 }

See also

https://en.cppreference.com/w/cpp/algorithm/partial_sum

Parameters:

  • exec – The execution policy to use for parallelization.

  • first – The beginning of the input sequence.

  • last – The end of the input sequence.

  • result – The beginning of the output sequence.

  • init – The initial value.

  • binary_op – The associative operator used to ‘sum’ values.

Template Parameters:

  • DerivedPolicy – The name of the derived execution policy.

  • InputIterator – is a model of Input Iterator and InputIterator's value_type is convertible to OutputIterator's value_type.

  • OutputIterator – is a model of Output Iterator and OutputIterator's value_type is convertible to both AssociativeOperator's first and second argument type.

  • T – is convertible to OutputIterator's value_type.

  • AssociativeOperator – The function’s return type must be convertible to OutputIterator's value_type.

Returns:

The end of the output sequence.

Pre:

first may equal result but the range [first, last) and the range [result, result + (last - first)) shall not overlap otherwise.

exclusive_scan(first, last, result, init, binary_op)#

template<typename InputIterator, typename OutputIterator, typename T, typename AssociativeOperator>
OutputIterator thrust::exclusive_scan(
InputIterator first,
InputIterator last,
OutputIterator result,
T init,
AssociativeOperator binary_op,
)#

exclusive_scan computes an exclusive prefix sum operation. The term ‘exclusive’ means that each result does not include the corresponding input operand in the partial sum. More precisely, init is assigned to *result and the value binary_op(init, *first) is assigned to *(result + 1), and so on. This version of the function requires both an associative operator and an initial value init. When the input and output sequences are the same, the scan is performed in-place.

Results are not deterministic for pseudo-associative operators (e.g., addition of floating-point types). Results for pseudo-associative operators may vary from run to run.

The following code snippet demonstrates how to use exclusive_scan 

#include <thrust/scan.h>
#include <thrust/functional.h>

int data[10] = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8};

::cuda::maximum<int> binary_op;

thrust::exclusive_scan(data, data + 10, data, 1, binary_op); // in-place scan

// data is now {1, 1, 1, 2, 2, 2, 4, 4, 4, 4 }

See also

https://en.cppreference.com/w/cpp/algorithm/partial_sum

Parameters:

  • first – The beginning of the input sequence.

  • last – The end of the input sequence.

  • result – The beginning of the output sequence.

  • init – The initial value.

  • binary_op – The associative operator used to ‘sum’ values.

Template Parameters:

  • InputIterator – is a model of Input Iterator and InputIterator's value_type is convertible to OutputIterator's value_type.

  • OutputIterator – is a model of Output Iterator and OutputIterator's value_type is convertible to both AssociativeOperator's first and second argument type.

  • T – is convertible to OutputIterator's value_type.

  • AssociativeOperator – The function’s return type must be convertible to OutputIterator's value_type.

Returns:

The end of the output sequence.

Pre:

first may equal result but the range [first, last) and the range [result, result + (last - first)) shall not overlap otherwise.