thrust
Functions
Segmented Prefix Sums

Functions

template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
__host__ __device__ OutputIterator thrust::inclusive_scan_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator thrust::inclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryPredicate >
__host__ __device__ OutputIterator thrust::inclusive_scan_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryPredicate binary_pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryPredicate >
OutputIterator thrust::inclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryPredicate binary_pred)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryPredicate , typename AssociativeOperator >
__host__ __device__ OutputIterator thrust::inclusive_scan_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryPredicate binary_pred, AssociativeOperator binary_op)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryPredicate , typename AssociativeOperator >
OutputIterator thrust::inclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryPredicate binary_pred, AssociativeOperator binary_op)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
__host__ __device__ OutputIterator thrust::exclusive_scan_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator thrust::exclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T >
__host__ __device__ OutputIterator thrust::exclusive_scan_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, T init)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T >
OutputIterator thrust::exclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, T init)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T , typename BinaryPredicate >
__host__ __device__ OutputIterator thrust::exclusive_scan_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, T init, BinaryPredicate binary_pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T , typename BinaryPredicate >
OutputIterator thrust::exclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, T init, BinaryPredicate binary_pred)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T , typename BinaryPredicate , typename AssociativeOperator >
__host__ __device__ OutputIterator thrust::exclusive_scan_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, T init, BinaryPredicate binary_pred, AssociativeOperator binary_op)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T , typename BinaryPredicate , typename AssociativeOperator >
OutputIterator thrust::exclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, T init, BinaryPredicate binary_pred, AssociativeOperator binary_op)
 

Detailed Description

Function Documentation

template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
__host__ __device__ OutputIterator thrust::exclusive_scan_by_key ( const thrust::detail::execution_policy_base< DerivedPolicy > &  exec,
InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
OutputIterator  result 
)

exclusive_scan_by_key computes an exclusive segmented prefix

This version of exclusive_scan_by_key uses the value 0 to initialize the exclusive scan operation.

This version of exclusive_scan_by_key assumes plus as the associative operator used to perform the prefix sum. When the input and output sequences are the same, the scan is performed in-place.

This version of exclusive_scan_by_key assumes equal_to as the binary predicate used to compare adjacent keys. Specifically, consecutive iterators i and i+1 in the range [first1, last1 belong to the same segment if *i == *(i+1), and belong to different segments otherwise.

Refer to the most general form of exclusive_scan_by_key for additional details.

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

Parameters
execThe execution policy to use for parallelization.
first1The beginning of the key sequence.
last1The end of the key sequence.
first2The beginning of the input value sequence.
resultThe beginning of the output value sequence.
Precondition
first1 may equal result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
first2 may equal result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.

The following code snippet demonstrates how to use exclusive_scan_by_key using the thrust::host execution policy for parallelization:

#include <thrust/scan.h>
...
int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
thrust::exclusive_scan_by_key(thrust::host, key, key + 10, vals, vals); // in-place scan
// vals is now {0, 1, 2, 0, 1, 0, 0, 1, 2, 3};
See Also
exclusive_scan
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator thrust::exclusive_scan_by_key ( InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
OutputIterator  result 
)

exclusive_scan_by_key computes an exclusive segmented prefix

This version of exclusive_scan_by_key uses the value 0 to initialize the exclusive scan operation.

This version of exclusive_scan_by_key assumes plus as the associative operator used to perform the prefix sum. When the input and output sequences are the same, the scan is performed in-place.

This version of exclusive_scan_by_key assumes equal_to as the binary predicate used to compare adjacent keys. Specifically, consecutive iterators i and i+1 in the range [first1, last1 belong to the same segment if *i == *(i+1), and belong to different segments otherwise.

Refer to the most general form of exclusive_scan_by_key for additional details.

Parameters
first1The beginning of the key sequence.
last1The end of the key sequence.
first2The beginning of the input value sequence.
resultThe beginning of the output value sequence.
Precondition
first1 may equal result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
first2 may equal result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.

The following code snippet demonstrates how to use exclusive_scan_by_key.

#include <thrust/scan.h>
int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
thrust::exclusive_scan_by_key(key, key + 10, vals, vals); // in-place scan
// vals is now {0, 1, 2, 0, 1, 0, 0, 1, 2, 3};
See Also
exclusive_scan
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T >
__host__ __device__ OutputIterator thrust::exclusive_scan_by_key ( const thrust::detail::execution_policy_base< DerivedPolicy > &  exec,
InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
OutputIterator  result,
init 
)

exclusive_scan_by_key computes an exclusive key-value or 'segmented' prefix sum operation. The term 'exclusive' means that each result does not include the corresponding input operand in the partial sum. The term 'segmented' means that the partial sums are broken into distinct segments. In other words, within each segment a separate exclusive scan operation is computed. Refer to the code sample below for example usage.

This version of exclusive_scan_by_key uses the value init to initialize the exclusive scan operation.

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

Parameters
execThe execution policy to use for parallelization.
first1The beginning of the key sequence.
last1The end of the key sequence.
first2The beginning of the input value sequence.
resultThe beginning of the output value sequence.
initThe initial of the exclusive sum value.
Returns
The end of the output sequence.
Precondition
first1 may equal result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
first2 may equal result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.

The following code snippet demonstrates how to use exclusive_scan_by_key using the thrust::host execution policy for parallelization:

#include <thrust/scan.h>
...
int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
int init = 5;
thrust::exclusive_scan_by_key(thrust::host, key, key + 10, vals, vals, init); // in-place scan
// vals is now {5, 6, 7, 5, 6, 5, 5, 6, 7, 8};
See Also
exclusive_scan
inclusive_scan_by_key
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T >
OutputIterator thrust::exclusive_scan_by_key ( InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
OutputIterator  result,
init 
)

exclusive_scan_by_key computes an exclusive key-value or 'segmented' prefix sum operation. The term 'exclusive' means that each result does not include the corresponding input operand in the partial sum. The term 'segmented' means that the partial sums are broken into distinct segments. In other words, within each segment a separate exclusive scan operation is computed. Refer to the code sample below for example usage.

This version of exclusive_scan_by_key uses the value init to initialize the exclusive scan operation.

Parameters
first1The beginning of the key sequence.
last1The end of the key sequence.
first2The beginning of the input value sequence.
resultThe beginning of the output value sequence.
initThe initial of the exclusive sum value.
Returns
The end of the output sequence.
Precondition
first1 may equal result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
first2 may equal result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.

The following code snippet demonstrates how to use exclusive_scan_by_key

#include <thrust/scan.h>
int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
int init = 5;
thrust::exclusive_scan_by_key(key, key + 10, vals, vals, init); // in-place scan
// vals is now {5, 6, 7, 5, 6, 5, 5, 6, 7, 8};
See Also
exclusive_scan
inclusive_scan_by_key
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T , typename BinaryPredicate >
__host__ __device__ OutputIterator thrust::exclusive_scan_by_key ( const thrust::detail::execution_policy_base< DerivedPolicy > &  exec,
InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
OutputIterator  result,
init,
BinaryPredicate  binary_pred 
)

exclusive_scan_by_key computes an exclusive key-value or 'segmented' prefix sum operation. The term 'exclusive' means that each result does not include the corresponding input operand in the partial sum. The term 'segmented' means that the partial sums are broken into distinct segments. In other words, within each segment a separate exclusive scan operation is computed. Refer to the code sample below for example usage.

This version of exclusive_scan_by_key uses the value init to initialize the exclusive scan operation.

This version of exclusive_scan_by_key uses the binary predicate binary_pred to compare adjacent keys. Specifically, consecutive iterators i and i+1 in the range [first1, last1) belong to the same segment if binary_pred(*i, *(i+1)) is true, and belong to different segments otherwise.

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

Parameters
execThe execution policy to use for parallelization.
first1The beginning of the key sequence.
last1The end of the key sequence.
first2The beginning of the input value sequence.
resultThe beginning of the output value sequence.
initThe initial of the exclusive sum value.
binary_predThe binary predicate used to determine equality of keys.
Returns
The end of the output sequence.
Precondition
first1 may equal result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
first2 may equal result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.

The following code snippet demonstrates how to use exclusive_scan_by_key using the thrust::host execution policy for parallelization:

#include <thrust/scan.h>
...
int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
int init = 5;
thrust::exclusive_scan_by_key(thrust::host, key, key + 10, vals, vals, init, binary_pred); // in-place scan
// vals is now {5, 6, 7, 5, 6, 5, 5, 6, 7, 8};
See Also
exclusive_scan
inclusive_scan_by_key
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T , typename BinaryPredicate >
OutputIterator thrust::exclusive_scan_by_key ( InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
OutputIterator  result,
init,
BinaryPredicate  binary_pred 
)

exclusive_scan_by_key computes an exclusive key-value or 'segmented' prefix sum operation. The term 'exclusive' means that each result does not include the corresponding input operand in the partial sum. The term 'segmented' means that the partial sums are broken into distinct segments. In other words, within each segment a separate exclusive scan operation is computed. Refer to the code sample below for example usage.

This version of exclusive_scan_by_key uses the value init to initialize the exclusive scan operation.

This version of exclusive_scan_by_key uses the binary predicate binary_pred to compare adjacent keys. Specifically, consecutive iterators i and i+1 in the range [first1, last1) belong to the same segment if binary_pred(*i, *(i+1)) is true, and belong to different segments otherwise.

Parameters
first1The beginning of the key sequence.
last1The end of the key sequence.
first2The beginning of the input value sequence.
resultThe beginning of the output value sequence.
initThe initial of the exclusive sum value.
binary_predThe binary predicate used to determine equality of keys.
Returns
The end of the output sequence.
Precondition
first1 may equal result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
first2 may equal result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.

The following code snippet demonstrates how to use exclusive_scan_by_key

#include <thrust/scan.h>
int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
int init = 5;
thrust::exclusive_scan_by_key(key, key + 10, vals, vals, init, binary_pred); // in-place scan
// vals is now {5, 6, 7, 5, 6, 5, 5, 6, 7, 8};
See Also
exclusive_scan
inclusive_scan_by_key
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T , typename BinaryPredicate , typename AssociativeOperator >
__host__ __device__ OutputIterator thrust::exclusive_scan_by_key ( const thrust::detail::execution_policy_base< DerivedPolicy > &  exec,
InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
OutputIterator  result,
init,
BinaryPredicate  binary_pred,
AssociativeOperator  binary_op 
)

exclusive_scan_by_key computes an exclusive key-value or 'segmented' prefix sum operation. The term 'exclusive' means that each result does not include the corresponding input operand in the partial sum. The term 'segmented' means that the partial sums are broken into distinct segments. In other words, within each segment a separate exclusive scan operation is computed. Refer to the code sample below for example usage.

This version of exclusive_scan_by_key uses the value init to initialize the exclusive scan operation.

This version of exclusive_scan_by_key uses the binary predicate binary_pred to compare adjacent keys. Specifically, consecutive iterators i and i+1 in the range [first1, last1) belong to the same segment if binary_pred(*i, *(i+1)) is true, and belong to different segments otherwise.

This version of exclusive_scan_by_key uses the associative operator binary_op to perform the prefix sum. When the input and output sequences are the same, the scan is performed in-place.

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

Parameters
execThe execution policy to use for parallelization.
first1The beginning of the key sequence.
last1The end of the key sequence.
first2The beginning of the input value sequence.
resultThe beginning of the output value sequence.
initThe initial of the exclusive sum value.
binary_predThe binary predicate used to determine equality of keys.
binary_opThe associatve operator used to 'sum' values.
Returns
The end of the output sequence.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is a model of Input Iterator
InputIterator2is a model of Input Iterator and InputIterator2's value_type is convertible to OutputIterator's value_type.
OutputIteratoris a model of Output Iterator, and if x and y are objects of OutputIterator's value_type, then binary_op(x,y) is defined.
Tis convertible to OutputIterator's value_type.
BinaryPredicateis a model of Binary Predicate.
AssociativeOperatoris a model of Binary Function and AssociativeOperator's result_type is convertible to OutputIterator's value_type.
Precondition
first1 may equal result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
first2 may equal result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.

The following code snippet demonstrates how to use exclusive_scan_by_key using the thrust::host execution policy for parallelization:

#include <thrust/scan.h>
...
int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
int init = 5;
thrust::exclusive_scan_by_key(thrust::host, key, key + 10, vals, vals, init, binary_pred, binary_op); // in-place scan
// vals is now {5, 6, 7, 5, 6, 5, 5, 6, 7, 8};
See Also
exclusive_scan
inclusive_scan_by_key
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T , typename BinaryPredicate , typename AssociativeOperator >
OutputIterator thrust::exclusive_scan_by_key ( InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
OutputIterator  result,
init,
BinaryPredicate  binary_pred,
AssociativeOperator  binary_op 
)

exclusive_scan_by_key computes an exclusive key-value or 'segmented' prefix sum operation. The term 'exclusive' means that each result does not include the corresponding input operand in the partial sum. The term 'segmented' means that the partial sums are broken into distinct segments. In other words, within each segment a separate exclusive scan operation is computed. Refer to the code sample below for example usage.

This version of exclusive_scan_by_key uses the value init to initialize the exclusive scan operation.

This version of exclusive_scan_by_key uses the binary predicate binary_pred to compare adjacent keys. Specifically, consecutive iterators i and i+1 in the range [first1, last1) belong to the same segment if binary_pred(*i, *(i+1)) is true, and belong to different segments otherwise.

This version of exclusive_scan_by_key uses the associative operator binary_op to perform the prefix sum. When the input and output sequences are the same, the scan is performed in-place.

Parameters
first1The beginning of the key sequence.
last1The end of the key sequence.
first2The beginning of the input value sequence.
resultThe beginning of the output value sequence.
initThe initial of the exclusive sum value.
binary_predThe binary predicate used to determine equality of keys.
binary_opThe associatve operator used to 'sum' values.
Returns
The end of the output sequence.
Template Parameters
InputIterator1is a model of Input Iterator
InputIterator2is a model of Input Iterator and InputIterator2's value_type is convertible to OutputIterator's value_type.
OutputIteratoris a model of Output Iterator, and if x and y are objects of OutputIterator's value_type, then binary_op(x,y) is defined.
Tis convertible to OutputIterator's value_type.
BinaryPredicateis a model of Binary Predicate.
AssociativeOperatoris a model of Binary Function and AssociativeOperator's result_type is convertible to OutputIterator's value_type.
Precondition
first1 may equal result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
first2 may equal result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.

The following code snippet demonstrates how to use exclusive_scan_by_key

#include <thrust/scan.h>
int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
int init = 5;
thrust::exclusive_scan_by_key(key, key + 10, vals, vals, init, binary_pred, binary_op); // in-place scan
// vals is now {5, 6, 7, 5, 6, 5, 5, 6, 7, 8};
See Also
exclusive_scan
inclusive_scan_by_key
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
__host__ __device__ OutputIterator thrust::inclusive_scan_by_key ( const thrust::detail::execution_policy_base< DerivedPolicy > &  exec,
InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
OutputIterator  result 
)

inclusive_scan_by_key computes an inclusive key-value or 'segmented' prefix sum operation. The term 'inclusive' means that each result includes the corresponding input operand in the partial sum. The term 'segmented' means that the partial sums are broken into distinct segments. In other words, within each segment a separate inclusive scan operation is computed. Refer to the code sample below for example usage.

This version of inclusive_scan_by_key assumes equal_to as the binary predicate used to compare adjacent keys. Specifically, consecutive iterators i and i+1 in the range [first1, last1) belong to the same segment if *i == *(i+1), and belong to different segments otherwise.

This version of inclusive_scan_by_key assumes plus as the associative operator used to perform the prefix sum. When the input and output sequences are the same, the scan is performed in-place.

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

Parameters
execThe execution policy to use for parallelization.
first1The beginning of the key sequence.
last1The end of the key sequence.
first2The beginning of the input value sequence.
resultThe beginning of the output value sequence.
Returns
The end of the output sequence.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is a model of Input Iterator
InputIterator2is a model of Input Iterator and InputIterator2's value_type is convertible to OutputIterator's value_type.
OutputIteratoris a model of Output Iterator, and if x and y are objects of OutputIterator's value_type, then binary_op(x,y) is defined.
Precondition
first1 may equal result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
first2 may equal result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.

The following code snippet demonstrates how to use inclusive_scan_by_key using the thrust::host execution policy for parallelization:

#include <thrust/scan.h>
...
int data[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
thrust::inclusive_scan_by_key(thrust::host, keys, keys + 10, vals, vals); // in-place scan
// data is now {1, 2, 3, 1, 2, 1, 1, 2, 3, 4};
See Also
inclusive_scan
exclusive_scan_by_key
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator thrust::inclusive_scan_by_key ( InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
OutputIterator  result 
)

inclusive_scan_by_key computes an inclusive key-value or 'segmented' prefix sum operation. The term 'inclusive' means that each result includes the corresponding input operand in the partial sum. The term 'segmented' means that the partial sums are broken into distinct segments. In other words, within each segment a separate inclusive scan operation is computed. Refer to the code sample below for example usage.

This version of inclusive_scan_by_key assumes equal_to as the binary predicate used to compare adjacent keys. Specifically, consecutive iterators i and i+1 in the range [first1, last1) belong to the same segment if *i == *(i+1), and belong to different segments otherwise.

This version of inclusive_scan_by_key assumes plus as the associative operator used to perform the prefix sum. When the input and output sequences are the same, the scan is performed in-place.

Parameters
first1The beginning of the key sequence.
last1The end of the key sequence.
first2The beginning of the input value sequence.
resultThe beginning of the output value sequence.
Returns
The end of the output sequence.
Template Parameters
InputIterator1is a model of Input Iterator
InputIterator2is a model of Input Iterator and InputIterator2's value_type is convertible to OutputIterator's value_type.
OutputIteratoris a model of Output Iterator, and if x and y are objects of OutputIterator's value_type, then binary_op(x,y) is defined.
Precondition
first1 may equal result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
first2 may equal result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.

The following code snippet demonstrates how to use inclusive_scan_by_key

#include <thrust/scan.h>
int data[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
thrust::inclusive_scan_by_key(keys, keys + 10, vals, vals); // in-place scan
// data is now {1, 2, 3, 1, 2, 1, 1, 2, 3, 4};
See Also
inclusive_scan
exclusive_scan_by_key
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryPredicate >
__host__ __device__ OutputIterator thrust::inclusive_scan_by_key ( const thrust::detail::execution_policy_base< DerivedPolicy > &  exec,
InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
OutputIterator  result,
BinaryPredicate  binary_pred 
)

inclusive_scan_by_key computes an inclusive key-value or 'segmented' prefix sum operation. The term 'inclusive' means that each result includes the corresponding input operand in the partial sum. The term 'segmented' means that the partial sums are broken into distinct segments. In other words, within each segment a separate inclusive scan operation is computed. Refer to the code sample below for example usage.

This version of inclusive_scan_by_key uses the binary predicate pred to compare adjacent keys. Specifically, consecutive iterators i and i+1 in the range [first1, last1) belong to the same segment if binary_pred(*i, *(i+1)) is true, and belong to different segments otherwise.

This version of inclusive_scan_by_key assumes plus as the associative operator used to perform the prefix sum. When the input and output sequences are the same, the scan is performed in-place.

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

Parameters
execThe execution policy to use for parallelization.
first1The beginning of the key sequence.
last1The end of the key sequence.
first2The beginning of the input value sequence.
resultThe beginning of the output value sequence.
binary_predThe binary predicate used to determine equality of keys.
Returns
The end of the output sequence.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is a model of Input Iterator
InputIterator2is a model of Input Iterator and InputIterator2's value_type is convertible to OutputIterator's value_type.
OutputIteratoris a model of Output Iterator, and if x and y are objects of OutputIterator's value_type, then binary_op(x,y) is defined.
BinaryPredicateis a model of Binary Predicate.
Precondition
first1 may equal result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
first2 may equal result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.

The following code snippet demonstrates how to use inclusive_scan_by_key using the thrust::host execution policy for parallelization:

#include <thrust/scan.h>
...
int data[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
thrust::inclusive_scan_by_key(thrust::host, keys, keys + 10, vals, vals, binary_pred); // in-place scan
// data is now {1, 2, 3, 1, 2, 1, 1, 2, 3, 4};
See Also
inclusive_scan
exclusive_scan_by_key
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryPredicate >
OutputIterator thrust::inclusive_scan_by_key ( InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
OutputIterator  result,
BinaryPredicate  binary_pred 
)

inclusive_scan_by_key computes an inclusive key-value or 'segmented' prefix sum operation. The term 'inclusive' means that each result includes the corresponding input operand in the partial sum. The term 'segmented' means that the partial sums are broken into distinct segments. In other words, within each segment a separate inclusive scan operation is computed. Refer to the code sample below for example usage.

This version of inclusive_scan_by_key uses the binary predicate pred to compare adjacent keys. Specifically, consecutive iterators i and i+1 in the range [first1, last1) belong to the same segment if binary_pred(*i, *(i+1)) is true, and belong to different segments otherwise.

This version of inclusive_scan_by_key assumes plus as the associative operator used to perform the prefix sum. When the input and output sequences are the same, the scan is performed in-place.

Parameters
first1The beginning of the key sequence.
last1The end of the key sequence.
first2The beginning of the input value sequence.
resultThe beginning of the output value sequence.
binary_predThe binary predicate used to determine equality of keys.
Returns
The end of the output sequence.
Template Parameters
InputIterator1is a model of Input Iterator
InputIterator2is a model of Input Iterator and InputIterator2's value_type is convertible to OutputIterator's value_type.
OutputIteratoris a model of Output Iterator, and if x and y are objects of OutputIterator's value_type, then binary_op(x,y) is defined.
BinaryPredicateis a model of Binary Predicate.
Precondition
first1 may equal result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
first2 may equal result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.

The following code snippet demonstrates how to use inclusive_scan_by_key

#include <thrust/scan.h>
int data[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
thrust::inclusive_scan_by_key(keys, keys + 10, vals, vals, binary_pred); // in-place scan
// data is now {1, 2, 3, 1, 2, 1, 1, 2, 3, 4};
See Also
inclusive_scan
exclusive_scan_by_key
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryPredicate , typename AssociativeOperator >
__host__ __device__ OutputIterator thrust::inclusive_scan_by_key ( const thrust::detail::execution_policy_base< DerivedPolicy > &  exec,
InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
OutputIterator  result,
BinaryPredicate  binary_pred,
AssociativeOperator  binary_op 
)

inclusive_scan_by_key computes an inclusive key-value or 'segmented' prefix sum operation. The term 'inclusive' means that each result includes the corresponding input operand in the partial sum. The term 'segmented' means that the partial sums are broken into distinct segments. In other words, within each segment a separate inclusive scan operation is computed. Refer to the code sample below for example usage.

This version of inclusive_scan_by_key uses the binary predicate pred to compare adjacent keys. Specifically, consecutive iterators i and i+1 in the range [first1, last1) belong to the same segment if binary_pred(*i, *(i+1)) is true, and belong to different segments otherwise.

This version of inclusive_scan_by_key uses the associative operator binary_op to perform the prefix sum. When the input and output sequences are the same, the scan is performed in-place.

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

Parameters
execThe execution policy to use for parallelization.
first1The beginning of the key sequence.
last1The end of the key sequence.
first2The beginning of the input value sequence.
resultThe beginning of the output value sequence.
binary_predThe binary predicate used to determine equality of keys.
binary_opThe associatve operator used to 'sum' values.
Returns
The end of the output sequence.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is a model of Input Iterator
InputIterator2is a model of Input Iterator and InputIterator2's value_type is convertible to OutputIterator's value_type.
OutputIteratoris a model of Output Iterator, and if x and y are objects of OutputIterator's value_type, then binary_op(x,y) is defined.
BinaryPredicateis a model of Binary Predicate.
AssociativeOperatoris a model of Binary Function and AssociativeOperator's result_type is convertible to OutputIterator's value_type.
Precondition
first1 may equal result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
first2 may equal result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.

The following code snippet demonstrates how to use inclusive_scan_by_key using the thrust::host execution policy for parallelization:

#include <thrust/scan.h>
...
int data[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
thrust::inclusive_scan_by_key(thrust::host, keys, keys + 10, vals, vals, binary_pred, binary_op); // in-place scan
// data is now {1, 2, 3, 1, 2, 1, 1, 2, 3, 4};
See Also
inclusive_scan
exclusive_scan_by_key
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryPredicate , typename AssociativeOperator >
OutputIterator thrust::inclusive_scan_by_key ( InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
OutputIterator  result,
BinaryPredicate  binary_pred,
AssociativeOperator  binary_op 
)

inclusive_scan_by_key computes an inclusive key-value or 'segmented' prefix sum operation. The term 'inclusive' means that each result includes the corresponding input operand in the partial sum. The term 'segmented' means that the partial sums are broken into distinct segments. In other words, within each segment a separate inclusive scan operation is computed. Refer to the code sample below for example usage.

This version of inclusive_scan_by_key uses the binary predicate pred to compare adjacent keys. Specifically, consecutive iterators i and i+1 in the range [first1, last1) belong to the same segment if binary_pred(*i, *(i+1)) is true, and belong to different segments otherwise.

This version of inclusive_scan_by_key uses the associative operator binary_op to perform the prefix sum. When the input and output sequences are the same, the scan is performed in-place.

Parameters
first1The beginning of the key sequence.
last1The end of the key sequence.
first2The beginning of the input value sequence.
resultThe beginning of the output value sequence.
binary_predThe binary predicate used to determine equality of keys.
binary_opThe associatve operator used to 'sum' values.
Returns
The end of the output sequence.
Template Parameters
InputIterator1is a model of Input Iterator
InputIterator2is a model of Input Iterator and InputIterator2's value_type is convertible to OutputIterator's value_type.
OutputIteratoris a model of Output Iterator, and if x and y are objects of OutputIterator's value_type, then binary_op(x,y) is defined.
BinaryPredicateis a model of Binary Predicate.
AssociativeOperatoris a model of Binary Function and AssociativeOperator's result_type is convertible to OutputIterator's value_type.
Precondition
first1 may equal result but the range [first1, last1) and the range [result, result + (last1 - first1)) shall not overlap otherwise.
first2 may equal result but the range [first2, first2 + (last1 - first1) and range [result, result + (last1 - first1)) shall not overlap otherwise.

The following code snippet demonstrates how to use inclusive_scan_by_key

#include <thrust/scan.h>
int data[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
thrust::inclusive_scan_by_key(keys, keys + 10, vals, vals, binary_pred, binary_op); // in-place scan
// data is now {1, 2, 3, 1, 2, 1, 1, 2, 3, 4};
See Also
inclusive_scan
exclusive_scan_by_key