thrust

Modules  
Segmented Prefix Sums  
Transformed Prefix Sums  
Functions  
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator >  
__host__ __device__ OutputIterator  thrust::inclusive_scan (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result) 
template<typename InputIterator , typename OutputIterator >  
OutputIterator  thrust::inclusive_scan (InputIterator first, InputIterator last, OutputIterator result) 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator , typename AssociativeOperator >  
__host__ __device__ OutputIterator  thrust::inclusive_scan (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result, AssociativeOperator binary_op) 
template<typename InputIterator , typename OutputIterator , typename AssociativeOperator >  
OutputIterator  thrust::inclusive_scan (InputIterator first, InputIterator last, OutputIterator result, AssociativeOperator binary_op) 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator >  
__host__ __device__ OutputIterator  thrust::exclusive_scan (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result) 
template<typename InputIterator , typename OutputIterator >  
OutputIterator  thrust::exclusive_scan (InputIterator first, InputIterator last, OutputIterator result) 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator , typename T >  
__host__ __device__ OutputIterator  thrust::exclusive_scan (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result, T init) 
template<typename InputIterator , typename OutputIterator , typename T >  
OutputIterator  thrust::exclusive_scan (InputIterator first, InputIterator last, OutputIterator result, T init) 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator , typename T , typename AssociativeOperator >  
__host__ __device__ OutputIterator  thrust::exclusive_scan (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result, T init, AssociativeOperator 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) 
__host__ __device__ 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 inplace.
The algorithm's execution is parallelized as determined by exec
.
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. 
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. 
first
may equal result
but the range [first, last)
and the range [result, result + (last  first))
shall not overlap otherwise.The following code snippet demonstrates how to use exclusive_scan
to compute an inplace prefix sum using the thrust::host
execution policy for parallelization:
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 inplace.
first  The beginning of the input sequence. 
last  The end of the input sequence. 
result  The beginning of the output sequence. 
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. 
first
may equal result
but the range [first, last)
and the range [result, result + (last  first))
shall not overlap otherwise.The following code snippet demonstrates how to use exclusive_scan
__host__ __device__ 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 inplace.
The algorithm's execution is parallelized as determined by exec
.
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. 
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 . 
first
may equal result
but the range [first, last)
and the range [result, result + (last  first))
shall not overlap otherwise.The following code snippet demonstrates how to use exclusive_scan
to compute an inplace prefix sum using the thrust::host
execution policy for parallelization:
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 inplace.
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. 
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 . 
first
may equal result
but the range [first, last)
and the range [result, result + (last  first))
shall not overlap otherwise.The following code snippet demonstrates how to use exclusive_scan
__host__ __device__ 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 and associative operator and an initial value init
. When the input and output sequences are the same, the scan is performed inplace.
The algorithm's execution is parallelized as determined by exec
.
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 associatve operator used to 'sum' values. 
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_argument_type and second_argument_type . 
T  is convertible to OutputIterator's value_type . 
AssociativeOperator  is a model of Binary Function and AssociativeOperator's result_type is convertible to OutputIterator's value_type . 
first
may equal result
but the range [first, last)
and the range [result, result + (last  first))
shall not overlap otherwise.The following code snippet demonstrates how to use exclusive_scan
to compute an inplace prefix sum using the thrust::host
execution policy for parallelization:
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 and associative operator and an initial value init
. When the input and output sequences are the same, the scan is performed inplace.
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 associatve operator used to 'sum' values. 
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_argument_type and second_argument_type . 
T  is convertible to OutputIterator's value_type . 
AssociativeOperator  is a model of Binary Function and AssociativeOperator's result_type is convertible to OutputIterator's value_type . 
first
may equal result
but the range [first, last)
and the range [result, result + (last  first))
shall not overlap otherwise.The following code snippet demonstrates how to use exclusive_scan
__host__ __device__ OutputIterator thrust::inclusive_scan  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
InputIterator  first,  
InputIterator  last,  
OutputIterator  result  
) 
inclusive_scan
computes an inclusive prefix sum operation. The term 'inclusive' means that each result includes the corresponding input operand in the partial sum. More precisely, *first
is assigned to *result
and the sum of *first
and *(first + 1)
is assigned to *(result + 1)
, and so on. This version of inclusive_scan
assumes plus as the associative operator. When the input and output sequences are the same, the scan is performed inplace.
inclusive_scan
is similar to std::partial_sum
in the STL. The primary difference between the two functions is that std::partial_sum
guarantees a serial summation order, while inclusive_scan
requires associativity of the binary operation to parallelize the prefix sum.
The algorithm's execution is parallelized as determined by exec
.
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. 
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. 
first
may equal result
but the range [first, last)
and the range [result, result + (last  first))
shall not overlap otherwise.The following code snippet demonstrates how to use inclusive_scan
to compute an inplace prefix sum using the thrust::host
execution policy for parallelization:
OutputIterator thrust::inclusive_scan  (  InputIterator  first, 
InputIterator  last,  
OutputIterator  result  
) 
inclusive_scan
computes an inclusive prefix sum operation. The term 'inclusive' means that each result includes the corresponding input operand in the partial sum. More precisely, *first
is assigned to *result
and the sum of *first
and *(first + 1)
is assigned to *(result + 1)
, and so on. This version of inclusive_scan
assumes plus as the associative operator. When the input and output sequences are the same, the scan is performed inplace.
inclusive_scan
is similar to std::partial_sum
in the STL. The primary difference between the two functions is that std::partial_sum
guarantees a serial summation order, while inclusive_scan
requires associativity of the binary operation to parallelize the prefix sum.
first  The beginning of the input sequence. 
last  The end of the input sequence. 
result  The beginning of the output sequence. 
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. 
first
may equal result
but the range [first, last)
and the range [result, result + (last  first))
shall not overlap otherwise.The following code snippet demonstrates how to use inclusive_scan
__host__ __device__ OutputIterator thrust::inclusive_scan  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
InputIterator  first,  
InputIterator  last,  
OutputIterator  result,  
AssociativeOperator  binary_op  
) 
inclusive_scan
computes an inclusive prefix sum operation. The term 'inclusive' means that each result includes the corresponding input operand in the partial sum. When the input and output sequences are the same, the scan is performed inplace.
inclusive_scan
is similar to std::partial_sum
in the STL. The primary difference between the two functions is that std::partial_sum
guarantees a serial summation order, while inclusive_scan
requires associativity of the binary operation to parallelize the prefix sum.
The algorithm's execution is parallelized as determined by exec
.
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. 
binary_op  The associatve operator used to 'sum' values. 
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_argument_type and second_argument_type . 
AssociativeOperator  is a model of Binary Function and AssociativeOperator's result_type is convertible to OutputIterator's value_type . 
first
may equal result
but the range [first, last)
and the range [result, result + (last  first))
shall not overlap otherwise.The following code snippet demonstrates how to use inclusive_scan
to compute an inplace prefix sum using the thrust::host
execution policy for parallelization:
OutputIterator thrust::inclusive_scan  (  InputIterator  first, 
InputIterator  last,  
OutputIterator  result,  
AssociativeOperator  binary_op  
) 
inclusive_scan
computes an inclusive prefix sum operation. The term 'inclusive' means that each result includes the corresponding input operand in the partial sum. When the input and output sequences are the same, the scan is performed inplace.
inclusive_scan
is similar to std::partial_sum
in the STL. The primary difference between the two functions is that std::partial_sum
guarantees a serial summation order, while inclusive_scan
requires associativity of the binary operation to parallelize the prefix sum.
first  The beginning of the input sequence. 
last  The end of the input sequence. 
result  The beginning of the output sequence. 
binary_op  The associatve operator used to 'sum' values. 
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_argument_type and second_argument_type . 
AssociativeOperator  is a model of Binary Function and AssociativeOperator's result_type is convertible to OutputIterator's value_type . 
first
may equal result
but the range [first, last)
and the range [result, result + (last  first))
shall not overlap otherwise.The following code snippet demonstrates how to use inclusive_scan