You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1552 lines
73 KiB
1552 lines
73 KiB
/* |
|
* Copyright 2008-2012 NVIDIA Corporation |
|
* |
|
* Licensed under the Apache License, Version 2.0 (the "License"); |
|
* you may not use this file except in compliance with the License. |
|
* You may obtain a copy of the License at |
|
* |
|
* http://www.apache.org/licenses/LICENSE-2.0 |
|
* |
|
* Unless required by applicable law or agreed to in writing, software |
|
* distributed under the License is distributed on an "AS IS" BASIS, |
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
* See the License for the specific language governing permissions and |
|
* limitations under the License. |
|
*/ |
|
|
|
|
|
/*! \file scan.h |
|
* \brief Functions for computing prefix sums |
|
*/ |
|
|
|
#pragma once |
|
|
|
#include <thrust/detail/config.h> |
|
#include <thrust/detail/execution_policy.h> |
|
|
|
namespace thrust |
|
{ |
|
|
|
|
|
/*! \addtogroup algorithms |
|
*/ |
|
|
|
|
|
/*! \addtogroup prefixsums Prefix Sums |
|
* \ingroup algorithms |
|
* \{ |
|
*/ |
|
|
|
|
|
/*! \p 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, <tt>*first</tt> is |
|
* assigned to <tt>*result</tt> and the sum of <tt>*first</tt> and |
|
* <tt>*(first + 1)</tt> is assigned to <tt>*(result + 1)</tt>, and so on. |
|
* This version of \p inclusive_scan assumes plus as the associative operator. |
|
* When the input and output sequences are the same, the scan is performed |
|
* in-place. |
|
|
|
* \p inclusive_scan is similar to \c std::partial_sum in the STL. The primary |
|
* difference between the two functions is that \c std::partial_sum guarantees |
|
* a serial summation order, while \p inclusive_scan requires associativity of |
|
* the binary operation to parallelize the prefix sum. |
|
* |
|
* The algorithm's execution is parallelized as determined by \p exec. |
|
* |
|
* \param exec The execution policy to use for parallelization. |
|
* \param first The beginning of the input sequence. |
|
* \param last The end of the input sequence. |
|
* \param result The beginning of the output sequence. |
|
* \return The end of the output sequence. |
|
* |
|
* \tparam DerivedPolicy The name of the derived execution policy. |
|
* \tparam InputIterator is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* and \c InputIterator's \c value_type is convertible to |
|
* \c OutputIterator's \c value_type. |
|
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a>, |
|
* and if \c x and \c y are objects of \c OutputIterator's |
|
* \c value_type, then <tt>x + y</tt> is defined. If \c T is |
|
* \c OutputIterator's \c value_type, then <tt>T(0)</tt> is |
|
* defined. |
|
* |
|
* \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p inclusive_scan to compute an in-place |
|
* prefix sum using the \p thrust::host execution policy for parallelization: |
|
* |
|
* \code |
|
* #include <thrust/scan.h> |
|
* #include <thrust/execution_policy.h> |
|
* ... |
|
* |
|
* int data[6] = {1, 0, 2, 2, 1, 3}; |
|
* |
|
* thrust::inclusive_scan(thrust::host, data, data + 6, data); // in-place scan |
|
* |
|
* // data is now {1, 1, 3, 5, 6, 9} |
|
* \endcode |
|
* |
|
* \see http://www.sgi.com/tech/stl/partial_sum.html |
|
* |
|
*/ |
|
template<typename DerivedPolicy, |
|
typename InputIterator, |
|
typename OutputIterator> |
|
OutputIterator inclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, |
|
InputIterator first, |
|
InputIterator last, |
|
OutputIterator result); |
|
|
|
|
|
/*! \p 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, <tt>*first</tt> is |
|
* assigned to <tt>*result</tt> and the sum of <tt>*first</tt> and |
|
* <tt>*(first + 1)</tt> is assigned to <tt>*(result + 1)</tt>, and so on. |
|
* This version of \p inclusive_scan assumes plus as the associative operator. |
|
* When the input and output sequences are the same, the scan is performed |
|
* in-place. |
|
|
|
* \p inclusive_scan is similar to \c std::partial_sum in the STL. The primary |
|
* difference between the two functions is that \c std::partial_sum guarantees |
|
* a serial summation order, while \p inclusive_scan requires associativity of |
|
* the binary operation to parallelize the prefix sum. |
|
* |
|
* \param first The beginning of the input sequence. |
|
* \param last The end of the input sequence. |
|
* \param result The beginning of the output sequence. |
|
* \return The end of the output sequence. |
|
* |
|
* \tparam InputIterator is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* and \c InputIterator's \c value_type is convertible to |
|
* \c OutputIterator's \c value_type. |
|
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a>, |
|
* and if \c x and \c y are objects of \c OutputIterator's |
|
* \c value_type, then <tt>x + y</tt> is defined. If \c T is |
|
* \c OutputIterator's \c value_type, then <tt>T(0)</tt> is |
|
* defined. |
|
* |
|
* \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p inclusive_scan |
|
* |
|
* \code |
|
* #include <thrust/scan.h> |
|
* |
|
* int data[6] = {1, 0, 2, 2, 1, 3}; |
|
* |
|
* thrust::inclusive_scan(data, data + 6, data); // in-place scan |
|
* |
|
* // data is now {1, 1, 3, 5, 6, 9} |
|
* \endcode |
|
* |
|
* \see http://www.sgi.com/tech/stl/partial_sum.html |
|
* |
|
*/ |
|
template<typename InputIterator, |
|
typename OutputIterator> |
|
OutputIterator inclusive_scan(InputIterator first, |
|
InputIterator last, |
|
OutputIterator result); |
|
|
|
|
|
/*! \p 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 in-place. |
|
* |
|
* \p inclusive_scan is similar to \c std::partial_sum in the STL. The primary |
|
* difference between the two functions is that \c std::partial_sum guarantees |
|
* a serial summation order, while \p inclusive_scan requires associativity of |
|
* the binary operation to parallelize the prefix sum. |
|
* |
|
* The algorithm's execution is parallelized as determined by \p exec. |
|
* |
|
* \param exec The execution policy to use for parallelization. |
|
* \param first The beginning of the input sequence. |
|
* \param last The end of the input sequence. |
|
* \param result The beginning of the output sequence. |
|
* \param binary_op The associatve operator used to 'sum' values. |
|
* \return The end of the output sequence. |
|
* |
|
* \tparam DerivedPolicy The name of the derived execution policy. |
|
* \tparam InputIterator is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* and \c InputIterator's \c value_type is convertible to |
|
* \c OutputIterator's \c value_type. |
|
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a> |
|
* and \c OutputIterator's \c value_type is convertible to |
|
* both \c AssociativeOperator's \c first_argument_type and |
|
* \c second_argument_type. |
|
* \tparam AssociativeOperator is a model of <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">Binary Function</a> |
|
* and \c AssociativeOperator's \c result_type is |
|
* convertible to \c OutputIterator's \c value_type. |
|
* |
|
* \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p inclusive_scan to compute an in-place |
|
* prefix sum using the \p thrust::host execution policy for parallelization: |
|
* |
|
* \code |
|
* int data[10] = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8}; |
|
* |
|
* thrust::maximum<int> binary_op; |
|
* |
|
* thrust::inclusive_scan(thrust::host, data, data + 10, data, binary_op); // in-place scan |
|
* |
|
* // data is now {-5, 0, 2, 2, 2, 4, 4, 4, 4, 8} |
|
* \endcode |
|
* |
|
* \see http://www.sgi.com/tech/stl/partial_sum.html |
|
*/ |
|
template<typename DerivedPolicy, |
|
typename InputIterator, |
|
typename OutputIterator, |
|
typename AssociativeOperator> |
|
OutputIterator inclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, |
|
InputIterator first, |
|
InputIterator last, |
|
OutputIterator result, |
|
AssociativeOperator binary_op); |
|
|
|
|
|
/*! \p 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 in-place. |
|
* |
|
* \p inclusive_scan is similar to \c std::partial_sum in the STL. The primary |
|
* difference between the two functions is that \c std::partial_sum guarantees |
|
* a serial summation order, while \p inclusive_scan requires associativity of |
|
* the binary operation to parallelize the prefix sum. |
|
* |
|
* \param first The beginning of the input sequence. |
|
* \param last The end of the input sequence. |
|
* \param result The beginning of the output sequence. |
|
* \param binary_op The associatve operator used to 'sum' values. |
|
* \return The end of the output sequence. |
|
* |
|
* \tparam InputIterator is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* and \c InputIterator's \c value_type is convertible to |
|
* \c OutputIterator's \c value_type. |
|
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a> |
|
* and \c OutputIterator's \c value_type is convertible to |
|
* both \c AssociativeOperator's \c first_argument_type and |
|
* \c second_argument_type. |
|
* \tparam AssociativeOperator is a model of <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">Binary Function</a> |
|
* and \c AssociativeOperator's \c result_type is |
|
* convertible to \c OutputIterator's \c value_type. |
|
* |
|
* \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p inclusive_scan |
|
* |
|
* \code |
|
* int data[10] = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8}; |
|
* |
|
* thrust::maximum<int> binary_op; |
|
* |
|
* thrust::inclusive_scan(data, data + 10, data, binary_op); // in-place scan |
|
* |
|
* // data is now {-5, 0, 2, 2, 2, 4, 4, 4, 4, 8} |
|
* \endcode |
|
* |
|
* \see http://www.sgi.com/tech/stl/partial_sum.html |
|
*/ |
|
template<typename InputIterator, |
|
typename OutputIterator, |
|
typename AssociativeOperator> |
|
OutputIterator inclusive_scan(InputIterator first, |
|
InputIterator last, |
|
OutputIterator result, |
|
AssociativeOperator binary_op); |
|
|
|
|
|
/*! \p 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, |
|
* <tt>0</tt> is assigned to <tt>*result</tt> and the sum of |
|
* <tt>0</tt> and <tt>*first</tt> is assigned to <tt>*(result + 1)</tt>, |
|
* and so on. This version of \p exclusive_scan assumes plus as the |
|
* associative operator and \c 0 as the initial value. When the input and |
|
* output sequences are the same, the scan is performed in-place. |
|
* |
|
* The algorithm's execution is parallelized as determined by \p exec. |
|
* |
|
* \param exec The execution policy to use for parallelization. |
|
* \param first The beginning of the input sequence. |
|
* \param last The end of the input sequence. |
|
* \param result The beginning of the output sequence. |
|
* \return The end of the output sequence. |
|
* |
|
* \tparam DerivedPolicy The name of the derived execution policy. |
|
* \tparam InputIterator is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* and \c InputIterator's \c value_type is convertible to |
|
* \c OutputIterator's \c value_type. |
|
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a>, |
|
* and if \c x and \c y are objects of \c OutputIterator's |
|
* \c value_type, then <tt>x + y</tt> is defined. If \c T is |
|
* \c OutputIterator's \c value_type, then <tt>T(0)</tt> is |
|
* defined. |
|
* |
|
* \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p exclusive_scan to compute an in-place |
|
* prefix sum using the \p thrust::host execution policy for parallelization: |
|
* |
|
* \code |
|
* #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} |
|
* \endcode |
|
* |
|
* \see http://www.sgi.com/tech/stl/partial_sum.html |
|
*/ |
|
template<typename DerivedPolicy, |
|
typename InputIterator, |
|
typename OutputIterator> |
|
OutputIterator exclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, |
|
InputIterator first, |
|
InputIterator last, |
|
OutputIterator result); |
|
|
|
|
|
/*! \p 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, |
|
* <tt>0</tt> is assigned to <tt>*result</tt> and the sum of |
|
* <tt>0</tt> and <tt>*first</tt> is assigned to <tt>*(result + 1)</tt>, |
|
* and so on. This version of \p exclusive_scan assumes plus as the |
|
* associative operator and \c 0 as the initial value. When the input and |
|
* output sequences are the same, the scan is performed in-place. |
|
* |
|
* \param first The beginning of the input sequence. |
|
* \param last The end of the input sequence. |
|
* \param result The beginning of the output sequence. |
|
* \return The end of the output sequence. |
|
* |
|
* \tparam InputIterator is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* and \c InputIterator's \c value_type is convertible to |
|
* \c OutputIterator's \c value_type. |
|
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a>, |
|
* and if \c x and \c y are objects of \c OutputIterator's |
|
* \c value_type, then <tt>x + y</tt> is defined. If \c T is |
|
* \c OutputIterator's \c value_type, then <tt>T(0)</tt> is |
|
* defined. |
|
* |
|
* \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p exclusive_scan |
|
* |
|
* \code |
|
* #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} |
|
* \endcode |
|
* |
|
* \see http://www.sgi.com/tech/stl/partial_sum.html |
|
*/ |
|
template<typename InputIterator, |
|
typename OutputIterator> |
|
OutputIterator exclusive_scan(InputIterator first, |
|
InputIterator last, |
|
OutputIterator result); |
|
|
|
|
|
/*! \p 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, |
|
* \p init is assigned to <tt>*result</tt> and the sum of \p init and |
|
* <tt>*first</tt> is assigned to <tt>*(result + 1)</tt>, and so on. |
|
* This version of \p exclusive_scan assumes plus as the associative |
|
* operator but requires an initial value \p init. When the input and |
|
* output sequences are the same, the scan is performed in-place. |
|
* |
|
* The algorithm's execution is parallelized as determined by \p exec. |
|
* |
|
* \param exec The execution policy to use for parallelization. |
|
* \param first The beginning of the input sequence. |
|
* \param last The end of the input sequence. |
|
* \param result The beginning of the output sequence. |
|
* \param init The initial value. |
|
* \return The end of the output sequence. |
|
* |
|
* \tparam DerivedPolicy The name of the derived execution policy. |
|
* \tparam InputIterator is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* and \c InputIterator's \c value_type is convertible to |
|
* \c OutputIterator's \c value_type. |
|
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a>, |
|
* and if \c x and \c y are objects of \c OutputIterator's |
|
* \c value_type, then <tt>x + y</tt> is defined. |
|
* \tparam T is convertible to \c OutputIterator's \c value_type. |
|
* |
|
* \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p exclusive_scan to compute an in-place |
|
* prefix sum using the \p thrust::host execution policy for parallelization: |
|
* |
|
* \code |
|
* #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} |
|
* \endcode |
|
* |
|
* \see http://www.sgi.com/tech/stl/partial_sum.html |
|
*/ |
|
template<typename DerivedPolicy, |
|
typename InputIterator, |
|
typename OutputIterator, |
|
typename T> |
|
OutputIterator exclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, |
|
InputIterator first, |
|
InputIterator last, |
|
OutputIterator result, |
|
T init); |
|
|
|
|
|
/*! \p 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, |
|
* \p init is assigned to <tt>*result</tt> and the sum of \p init and |
|
* <tt>*first</tt> is assigned to <tt>*(result + 1)</tt>, and so on. |
|
* This version of \p exclusive_scan assumes plus as the associative |
|
* operator but requires an initial value \p init. When the input and |
|
* output sequences are the same, the scan is performed in-place. |
|
* |
|
* \param first The beginning of the input sequence. |
|
* \param last The end of the input sequence. |
|
* \param result The beginning of the output sequence. |
|
* \param init The initial value. |
|
* \return The end of the output sequence. |
|
* |
|
* \tparam InputIterator is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* and \c InputIterator's \c value_type is convertible to |
|
* \c OutputIterator's \c value_type. |
|
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a>, |
|
* and if \c x and \c y are objects of \c OutputIterator's |
|
* \c value_type, then <tt>x + y</tt> is defined. |
|
* \tparam T is convertible to \c OutputIterator's \c value_type. |
|
* |
|
* \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p exclusive_scan |
|
* |
|
* \code |
|
* #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} |
|
* \endcode |
|
* |
|
* \see http://www.sgi.com/tech/stl/partial_sum.html |
|
*/ |
|
template<typename InputIterator, |
|
typename OutputIterator, |
|
typename T> |
|
OutputIterator exclusive_scan(InputIterator first, |
|
InputIterator last, |
|
OutputIterator result, |
|
T init); |
|
|
|
|
|
/*! \p 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, |
|
* \p init is assigned to <tt>\*result</tt> and the value |
|
* <tt>binary_op(init, \*first)</tt> is assigned to <tt>\*(result + 1)</tt>, |
|
* and so on. This version of the function requires both and associative |
|
* operator and an initial value \p init. When the input and output |
|
* sequences are the same, the scan is performed in-place. |
|
* |
|
* The algorithm's execution is parallelized as determined by \p exec. |
|
* |
|
* \param exec The execution policy to use for parallelization. |
|
* \param first The beginning of the input sequence. |
|
* \param last The end of the input sequence. |
|
* \param result The beginning of the output sequence. |
|
* \param init The initial value. |
|
* \param binary_op The associatve operator used to 'sum' values. |
|
* \return The end of the output sequence. |
|
* |
|
* \tparam DerivedPolicy The name of the derived execution policy. |
|
* \tparam InputIterator is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* and \c InputIterator's \c value_type is convertible to |
|
* \c OutputIterator's \c value_type. |
|
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a> |
|
* and \c OutputIterator's \c value_type is convertible to |
|
* both \c AssociativeOperator's \c first_argument_type and |
|
* \c second_argument_type. |
|
* \tparam T is convertible to \c OutputIterator's \c value_type. |
|
* \tparam AssociativeOperator is a model of <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">Binary Function</a> |
|
* and \c AssociativeOperator's \c result_type is |
|
* convertible to \c OutputIterator's \c value_type. |
|
* |
|
* \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p exclusive_scan to compute an in-place |
|
* prefix sum using the \p thrust::host execution policy for parallelization: |
|
* |
|
* \code |
|
* #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}; |
|
* |
|
* thrust::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 } |
|
* \endcode |
|
* |
|
* \see http://www.sgi.com/tech/stl/partial_sum.html |
|
*/ |
|
template<typename DerivedPolicy, |
|
typename InputIterator, |
|
typename OutputIterator, |
|
typename T, |
|
typename AssociativeOperator> |
|
OutputIterator exclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, |
|
InputIterator first, |
|
InputIterator last, |
|
OutputIterator result, |
|
T init, |
|
AssociativeOperator binary_op); |
|
|
|
|
|
/*! \p 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, |
|
* \p init is assigned to <tt>\*result</tt> and the value |
|
* <tt>binary_op(init, \*first)</tt> is assigned to <tt>\*(result + 1)</tt>, |
|
* and so on. This version of the function requires both and associative |
|
* operator and an initial value \p init. When the input and output |
|
* sequences are the same, the scan is performed in-place. |
|
* |
|
* \param first The beginning of the input sequence. |
|
* \param last The end of the input sequence. |
|
* \param result The beginning of the output sequence. |
|
* \param init The initial value. |
|
* \param binary_op The associatve operator used to 'sum' values. |
|
* \return The end of the output sequence. |
|
* |
|
* \tparam InputIterator is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* and \c InputIterator's \c value_type is convertible to |
|
* \c OutputIterator's \c value_type. |
|
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a> |
|
* and \c OutputIterator's \c value_type is convertible to |
|
* both \c AssociativeOperator's \c first_argument_type and |
|
* \c second_argument_type. |
|
* \tparam T is convertible to \c OutputIterator's \c value_type. |
|
* \tparam AssociativeOperator is a model of <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">Binary Function</a> |
|
* and \c AssociativeOperator's \c result_type is |
|
* convertible to \c OutputIterator's \c value_type. |
|
* |
|
* \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p exclusive_scan |
|
* |
|
* \code |
|
* #include <thrust/scan.h> |
|
* #include <thrust/functional.h> |
|
* |
|
* int data[10] = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8}; |
|
* |
|
* thrust::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 } |
|
* \endcode |
|
* |
|
* \see http://www.sgi.com/tech/stl/partial_sum.html |
|
*/ |
|
template<typename InputIterator, |
|
typename OutputIterator, |
|
typename T, |
|
typename AssociativeOperator> |
|
OutputIterator exclusive_scan(InputIterator first, |
|
InputIterator last, |
|
OutputIterator result, |
|
T init, |
|
AssociativeOperator binary_op); |
|
|
|
|
|
/*! \addtogroup segmentedprefixsums Segmented Prefix Sums |
|
* \ingroup prefixsums |
|
* \{ |
|
*/ |
|
|
|
|
|
/*! \p 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 \p inclusive_scan_by_key assumes \c equal_to as the binary |
|
* predicate used to compare adjacent keys. Specifically, consecutive iterators |
|
* <tt>i</tt> and <tt>i+1</tt> in the range <tt>[first1, last1)</tt> |
|
* belong to the same segment if <tt>*i == *(i+1)</tt>, and belong to |
|
* different segments otherwise. |
|
* |
|
* This version of \p inclusive_scan_by_key assumes \c 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 \p exec. |
|
* |
|
* \param exec The execution policy to use for parallelization. |
|
* \param first1 The beginning of the key sequence. |
|
* \param last1 The end of the key sequence. |
|
* \param first2 The beginning of the input value sequence. |
|
* \param result The beginning of the output value sequence. |
|
* \return The end of the output sequence. |
|
* |
|
* \tparam DerivedPolicy The name of the derived execution policy. |
|
* \tparam InputIterator1 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* \tparam InputIterator2 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type. |
|
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a>, |
|
* and if \c x and \c y are objects of \c OutputIterator's \c value_type, then |
|
* <tt>binary_op(x,y)</tt> is defined. |
|
* |
|
* \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p inclusive_scan_by_key using the \p thrust::host |
|
* execution policy for parallelization: |
|
* |
|
* \code |
|
* #include <thrust/scan.h> |
|
* #include <thrust/execution_policy.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}; |
|
* \endcode |
|
* |
|
* \see inclusive_scan |
|
* \see exclusive_scan_by_key |
|
* |
|
*/ |
|
template<typename DerivedPolicy, |
|
typename InputIterator1, |
|
typename InputIterator2, |
|
typename OutputIterator> |
|
OutputIterator inclusive_scan_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, |
|
InputIterator1 first1, |
|
InputIterator1 last1, |
|
InputIterator2 first2, |
|
OutputIterator result); |
|
|
|
|
|
/*! \p 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 \p inclusive_scan_by_key assumes \c equal_to as the binary |
|
* predicate used to compare adjacent keys. Specifically, consecutive iterators |
|
* <tt>i</tt> and <tt>i+1</tt> in the range <tt>[first1, last1)</tt> |
|
* belong to the same segment if <tt>*i == *(i+1)</tt>, and belong to |
|
* different segments otherwise. |
|
* |
|
* This version of \p inclusive_scan_by_key assumes \c 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. |
|
* |
|
* \param first1 The beginning of the key sequence. |
|
* \param last1 The end of the key sequence. |
|
* \param first2 The beginning of the input value sequence. |
|
* \param result The beginning of the output value sequence. |
|
* \return The end of the output sequence. |
|
* |
|
* \tparam InputIterator1 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* \tparam InputIterator2 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type. |
|
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a>, |
|
* and if \c x and \c y are objects of \c OutputIterator's \c value_type, then |
|
* <tt>binary_op(x,y)</tt> is defined. |
|
* |
|
* \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p inclusive_scan_by_key |
|
* |
|
* \code |
|
* #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}; |
|
* \endcode |
|
* |
|
* \see inclusive_scan |
|
* \see exclusive_scan_by_key |
|
* |
|
*/ |
|
template<typename InputIterator1, |
|
typename InputIterator2, |
|
typename OutputIterator> |
|
OutputIterator inclusive_scan_by_key(InputIterator1 first1, |
|
InputIterator1 last1, |
|
InputIterator2 first2, |
|
OutputIterator result); |
|
|
|
|
|
/*! \p 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 \p inclusive_scan_by_key uses the binary predicate |
|
* \c pred to compare adjacent keys. Specifically, consecutive iterators |
|
* <tt>i</tt> and <tt>i+1</tt> in the range <tt>[first1, last1)</tt> |
|
* belong to the same segment if <tt>binary_pred(*i, *(i+1))</tt> is true, and belong to |
|
* different segments otherwise. |
|
* |
|
* This version of \p inclusive_scan_by_key assumes \c 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 \p exec. |
|
* |
|
* \param exec The execution policy to use for parallelization. |
|
* \param first1 The beginning of the key sequence. |
|
* \param last1 The end of the key sequence. |
|
* \param first2 The beginning of the input value sequence. |
|
* \param result The beginning of the output value sequence. |
|
* \param binary_pred The binary predicate used to determine equality of keys. |
|
* \return The end of the output sequence. |
|
* |
|
* \tparam DerivedPolicy The name of the derived execution policy. |
|
* \tparam InputIterator1 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* \tparam InputIterator2 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type. |
|
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a>, |
|
* and if \c x and \c y are objects of \c OutputIterator's \c value_type, then |
|
* <tt>binary_op(x,y)</tt> is defined. |
|
* \tparam BinaryPredicate is a model of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a>. |
|
* |
|
* \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p inclusive_scan_by_key using the \p thrust::host |
|
* execution policy for parallelization: |
|
* |
|
* \code |
|
* #include <thrust/scan.h> |
|
* #include <thrust/functional.h> |
|
* #include <thrust/execution_policy.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::equal_to<int> binary_pred; |
|
* |
|
* 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}; |
|
* \endcode |
|
* |
|
* \see inclusive_scan |
|
* \see exclusive_scan_by_key |
|
* |
|
*/ |
|
template<typename DerivedPolicy, |
|
typename InputIterator1, |
|
typename InputIterator2, |
|
typename OutputIterator, |
|
typename BinaryPredicate> |
|
OutputIterator inclusive_scan_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, |
|
InputIterator1 first1, |
|
InputIterator1 last1, |
|
InputIterator2 first2, |
|
OutputIterator result, |
|
BinaryPredicate binary_pred); |
|
|
|
|
|
/*! \p 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 \p inclusive_scan_by_key uses the binary predicate |
|
* \c pred to compare adjacent keys. Specifically, consecutive iterators |
|
* <tt>i</tt> and <tt>i+1</tt> in the range <tt>[first1, last1)</tt> |
|
* belong to the same segment if <tt>binary_pred(*i, *(i+1))</tt> is true, and belong to |
|
* different segments otherwise. |
|
* |
|
* This version of \p inclusive_scan_by_key assumes \c 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. |
|
* |
|
* \param first1 The beginning of the key sequence. |
|
* \param last1 The end of the key sequence. |
|
* \param first2 The beginning of the input value sequence. |
|
* \param result The beginning of the output value sequence. |
|
* \param binary_pred The binary predicate used to determine equality of keys. |
|
* \return The end of the output sequence. |
|
* |
|
* \tparam InputIterator1 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* \tparam InputIterator2 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type. |
|
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a>, |
|
* and if \c x and \c y are objects of \c OutputIterator's \c value_type, then |
|
* <tt>binary_op(x,y)</tt> is defined. |
|
* \tparam BinaryPredicate is a model of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a>. |
|
* |
|
* \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p inclusive_scan_by_key |
|
* |
|
* \code |
|
* #include <thrust/scan.h> |
|
* #include <thrust/functional.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::equal_to<int> binary_pred; |
|
* |
|
* 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}; |
|
* \endcode |
|
* |
|
* \see inclusive_scan |
|
* \see exclusive_scan_by_key |
|
* |
|
*/ |
|
template<typename InputIterator1, |
|
typename InputIterator2, |
|
typename OutputIterator, |
|
typename BinaryPredicate> |
|
OutputIterator inclusive_scan_by_key(InputIterator1 first1, |
|
InputIterator1 last1, |
|
InputIterator2 first2, |
|
OutputIterator result, |
|
BinaryPredicate binary_pred); |
|
|
|
|
|
/*! \p 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 \p inclusive_scan_by_key uses the binary predicate |
|
* \c pred to compare adjacent keys. Specifically, consecutive iterators |
|
* <tt>i</tt> and <tt>i+1</tt> in the range <tt>[first1, last1)</tt> |
|
* belong to the same segment if <tt>binary_pred(*i, *(i+1))</tt> is true, and belong to |
|
* different segments otherwise. |
|
* |
|
* This version of \p inclusive_scan_by_key uses the associative operator |
|
* \c 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 \p exec. |
|
* |
|
* \param exec The execution policy to use for parallelization. |
|
* \param first1 The beginning of the key sequence. |
|
* \param last1 The end of the key sequence. |
|
* \param first2 The beginning of the input value sequence. |
|
* \param result The beginning of the output value sequence. |
|
* \param binary_pred The binary predicate used to determine equality of keys. |
|
* \param binary_op The associatve operator used to 'sum' values. |
|
* \return The end of the output sequence. |
|
* |
|
* \tparam DerivedPolicy The name of the derived execution policy. |
|
* \tparam InputIterator1 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* \tparam InputIterator2 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type. |
|
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a>, |
|
* and if \c x and \c y are objects of \c OutputIterator's \c value_type, then |
|
* <tt>binary_op(x,y)</tt> is defined. |
|
* \tparam BinaryPredicate is a model of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a>. |
|
* \tparam AssociativeOperator is a model of <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">Binary Function</a> |
|
* and \c AssociativeOperator's \c result_type is |
|
* convertible to \c OutputIterator's \c value_type. |
|
* |
|
* \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p inclusive_scan_by_key using the \p thrust::host |
|
* execution policy for parallelization: |
|
* |
|
* \code |
|
* #include <thrust/scan.h> |
|
* #include <thrust/functional.h> |
|
* #include <thrust/execution_policy.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::equal_to<int> binary_pred; |
|
* thrust::plus<int> binary_op; |
|
* |
|
* 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}; |
|
* \endcode |
|
* |
|
* \see inclusive_scan |
|
* \see exclusive_scan_by_key |
|
* |
|
*/ |
|
template<typename DerivedPolicy, |
|
typename InputIterator1, |
|
typename InputIterator2, |
|
typename OutputIterator, |
|
typename BinaryPredicate, |
|
typename AssociativeOperator> |
|
OutputIterator 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); |
|
|
|
|
|
/*! \p 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 \p inclusive_scan_by_key uses the binary predicate |
|
* \c pred to compare adjacent keys. Specifically, consecutive iterators |
|
* <tt>i</tt> and <tt>i+1</tt> in the range <tt>[first1, last1)</tt> |
|
* belong to the same segment if <tt>binary_pred(*i, *(i+1))</tt> is true, and belong to |
|
* different segments otherwise. |
|
* |
|
* This version of \p inclusive_scan_by_key uses the associative operator |
|
* \c binary_op to perform the prefix sum. When the input and output sequences |
|
* are the same, the scan is performed in-place. |
|
* |
|
* \param first1 The beginning of the key sequence. |
|
* \param last1 The end of the key sequence. |
|
* \param first2 The beginning of the input value sequence. |
|
* \param result The beginning of the output value sequence. |
|
* \param binary_pred The binary predicate used to determine equality of keys. |
|
* \param binary_op The associatve operator used to 'sum' values. |
|
* \return The end of the output sequence. |
|
* |
|
* \tparam InputIterator1 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* \tparam InputIterator2 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type. |
|
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a>, |
|
* and if \c x and \c y are objects of \c OutputIterator's \c value_type, then |
|
* <tt>binary_op(x,y)</tt> is defined. |
|
* \tparam BinaryPredicate is a model of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a>. |
|
* \tparam AssociativeOperator is a model of <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">Binary Function</a> |
|
* and \c AssociativeOperator's \c result_type is |
|
* convertible to \c OutputIterator's \c value_type. |
|
* |
|
* \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p inclusive_scan_by_key |
|
* |
|
* \code |
|
* #include <thrust/scan.h> |
|
* #include <thrust/functional.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::equal_to<int> binary_pred; |
|
* thrust::plus<int> binary_op; |
|
* |
|
* 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}; |
|
* \endcode |
|
* |
|
* \see inclusive_scan |
|
* \see exclusive_scan_by_key |
|
* |
|
*/ |
|
template<typename InputIterator1, |
|
typename InputIterator2, |
|
typename OutputIterator, |
|
typename BinaryPredicate, |
|
typename AssociativeOperator> |
|
OutputIterator inclusive_scan_by_key(InputIterator1 first1, |
|
InputIterator1 last1, |
|
InputIterator2 first2, |
|
OutputIterator result, |
|
BinaryPredicate binary_pred, |
|
AssociativeOperator binary_op); |
|
|
|
|
|
/*! \p exclusive_scan_by_key computes an exclusive segmented prefix |
|
* |
|
* This version of \p exclusive_scan_by_key uses the value \c 0 to |
|
* initialize the exclusive scan operation. |
|
* |
|
* This version of \p exclusive_scan_by_key assumes \c 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 \p exclusive_scan_by_key assumes \c equal_to as the binary |
|
* predicate used to compare adjacent keys. Specifically, consecutive iterators |
|
* <tt>i</tt> and <tt>i+1</tt> in the range <tt>[first1, last1</tt> |
|
* belong to the same segment if <tt>*i == *(i+1)</tt>, and belong to |
|
* different segments otherwise. |
|
* |
|
* Refer to the most general form of \p exclusive_scan_by_key for additional details. |
|
* |
|
* The algorithm's execution is parallelized as determined by \p exec. |
|
* |
|
* \param exec The execution policy to use for parallelization. |
|
* \param first1 The beginning of the key sequence. |
|
* \param last1 The end of the key sequence. |
|
* \param first2 The beginning of the input value sequence. |
|
* \param result The beginning of the output value sequence. |
|
* |
|
* \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p exclusive_scan_by_key using the |
|
* \p thrust::host execution policy for parallelization: |
|
* |
|
* \code |
|
* #include <thrust/scan.h> |
|
* #include <thrust/execution_policy.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}; |
|
* \endcode |
|
* |
|
* \see exclusive_scan |
|
* |
|
*/ |
|
template<typename DerivedPolicy, |
|
typename InputIterator1, |
|
typename InputIterator2, |
|
typename OutputIterator> |
|
OutputIterator exclusive_scan_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, |
|
InputIterator1 first1, |
|
InputIterator1 last1, |
|
InputIterator2 first2, |
|
OutputIterator result); |
|
|
|
|
|
/*! \p exclusive_scan_by_key computes an exclusive segmented prefix |
|
* |
|
* This version of \p exclusive_scan_by_key uses the value \c 0 to |
|
* initialize the exclusive scan operation. |
|
* |
|
* This version of \p exclusive_scan_by_key assumes \c 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 \p exclusive_scan_by_key assumes \c equal_to as the binary |
|
* predicate used to compare adjacent keys. Specifically, consecutive iterators |
|
* <tt>i</tt> and <tt>i+1</tt> in the range <tt>[first1, last1</tt> |
|
* belong to the same segment if <tt>*i == *(i+1)</tt>, and belong to |
|
* different segments otherwise. |
|
* |
|
* Refer to the most general form of \p exclusive_scan_by_key for additional details. |
|
* |
|
* \param first1 The beginning of the key sequence. |
|
* \param last1 The end of the key sequence. |
|
* \param first2 The beginning of the input value sequence. |
|
* \param result The beginning of the output value sequence. |
|
* |
|
* \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p exclusive_scan_by_key. |
|
* |
|
* \code |
|
* #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}; |
|
* \endcode |
|
* |
|
* \see exclusive_scan |
|
* |
|
*/ |
|
template<typename InputIterator1, |
|
typename InputIterator2, |
|
typename OutputIterator> |
|
OutputIterator exclusive_scan_by_key(InputIterator1 first1, |
|
InputIterator1 last1, |
|
InputIterator2 first2, |
|
OutputIterator result); |
|
|
|
|
|
/*! \p 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 \p exclusive_scan_by_key uses the value \c init to |
|
* initialize the exclusive scan operation. |
|
* |
|
* The algorithm's execution is parallelized as determined by \p exec. |
|
* |
|
* \param exec The execution policy to use for parallelization. |
|
* \param first1 The beginning of the key sequence. |
|
* \param last1 The end of the key sequence. |
|
* \param first2 The beginning of the input value sequence. |
|
* \param result The beginning of the output value sequence. |
|
* \param init The initial of the exclusive sum value. |
|
* \return The end of the output sequence. |
|
* |
|
* \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p exclusive_scan_by_key using the \p |
|
* thrust::host execution policy for parallelization: |
|
* |
|
* \code |
|
* #include <thrust/scan.h> |
|
* #include <thrust/functional.h> |
|
* #include <thrust/execution_policy.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}; |
|
* \endcode |
|
* |
|
* \see exclusive_scan |
|
* \see inclusive_scan_by_key |
|
* |
|
*/ |
|
template<typename DerivedPolicy, |
|
typename InputIterator1, |
|
typename InputIterator2, |
|
typename OutputIterator, |
|
typename T> |
|
OutputIterator exclusive_scan_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, |
|
InputIterator1 first1, |
|
InputIterator1 last1, |
|
InputIterator2 first2, |
|
OutputIterator result, |
|
T init); |
|
|
|
|
|
/*! \p 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 \p exclusive_scan_by_key uses the value \c init to |
|
* initialize the exclusive scan operation. |
|
* |
|
* \param first1 The beginning of the key sequence. |
|
* \param last1 The end of the key sequence. |
|
* \param first2 The beginning of the input value sequence. |
|
* \param result The beginning of the output value sequence. |
|
* \param init The initial of the exclusive sum value. |
|
* \return The end of the output sequence. |
|
* |
|
* \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p exclusive_scan_by_key |
|
* |
|
* \code |
|
* #include <thrust/scan.h> |
|
* #include <thrust/functional.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}; |
|
* \endcode |
|
* |
|
* \see exclusive_scan |
|
* \see inclusive_scan_by_key |
|
* |
|
*/ |
|
template<typename InputIterator1, |
|
typename InputIterator2, |
|
typename OutputIterator, |
|
typename T> |
|
OutputIterator exclusive_scan_by_key(InputIterator1 first1, |
|
InputIterator1 last1, |
|
InputIterator2 first2, |
|
OutputIterator result, |
|
T init); |
|
|
|
|
|
/*! \p 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 \p exclusive_scan_by_key uses the value \c init to |
|
* initialize the exclusive scan operation. |
|
* |
|
* This version of \p exclusive_scan_by_key uses the binary predicate \c binary_pred |
|
* to compare adjacent keys. Specifically, consecutive iterators <tt>i</tt> and |
|
* <tt>i+1</tt> in the range <tt>[first1, last1)</tt> belong to the same segment if |
|
* <tt>binary_pred(*i, *(i+1))</tt> is true, and belong to different segments otherwise. |
|
* |
|
* The algorithm's execution is parallelized as determined by \p exec. |
|
* |
|
* \param exec The execution policy to use for parallelization. |
|
* \param first1 The beginning of the key sequence. |
|
* \param last1 The end of the key sequence. |
|
* \param first2 The beginning of the input value sequence. |
|
* \param result The beginning of the output value sequence. |
|
* \param init The initial of the exclusive sum value. |
|
* \param binary_pred The binary predicate used to determine equality of keys. |
|
* \return The end of the output sequence. |
|
* |
|
* \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p exclusive_scan_by_key using the |
|
* \p thrust::host execution policy for parallelization: |
|
* |
|
* \code |
|
* #include <thrust/scan.h> |
|
* #include <thrust/functional.h> |
|
* #include <thrust/execution_policy.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::equal_to<int> binary_pred; |
|
* |
|
* 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}; |
|
* \endcode |
|
* |
|
* \see exclusive_scan |
|
* \see inclusive_scan_by_key |
|
* |
|
*/ |
|
template<typename DerivedPolicy, |
|
typename InputIterator1, |
|
typename InputIterator2, |
|
typename OutputIterator, |
|
typename T, |
|
typename BinaryPredicate> |
|
OutputIterator 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); |
|
|
|
|
|
/*! \p 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 \p exclusive_scan_by_key uses the value \c init to |
|
* initialize the exclusive scan operation. |
|
* |
|
* This version of \p exclusive_scan_by_key uses the binary predicate \c binary_pred |
|
* to compare adjacent keys. Specifically, consecutive iterators <tt>i</tt> and |
|
* <tt>i+1</tt> in the range <tt>[first1, last1)</tt> belong to the same segment if |
|
* <tt>binary_pred(*i, *(i+1))</tt> is true, and belong to different segments otherwise. |
|
* |
|
* \param first1 The beginning of the key sequence. |
|
* \param last1 The end of the key sequence. |
|
* \param first2 The beginning of the input value sequence. |
|
* \param result The beginning of the output value sequence. |
|
* \param init The initial of the exclusive sum value. |
|
* \param binary_pred The binary predicate used to determine equality of keys. |
|
* \return The end of the output sequence. |
|
* |
|
* \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p exclusive_scan_by_key |
|
* |
|
* \code |
|
* #include <thrust/scan.h> |
|
* #include <thrust/functional.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::equal_to<int> binary_pred; |
|
* |
|
* 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}; |
|
* \endcode |
|
* |
|
* \see exclusive_scan |
|
* \see inclusive_scan_by_key |
|
* |
|
*/ |
|
template<typename InputIterator1, |
|
typename InputIterator2, |
|
typename OutputIterator, |
|
typename T, |
|
typename BinaryPredicate> |
|
OutputIterator exclusive_scan_by_key(InputIterator1 first1, |
|
InputIterator1 last1, |
|
InputIterator2 first2, |
|
OutputIterator result, |
|
T init, |
|
BinaryPredicate binary_pred); |
|
|
|
|
|
/*! \p 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 \p exclusive_scan_by_key uses the value \c init to |
|
* initialize the exclusive scan operation. |
|
* |
|
* This version of \p exclusive_scan_by_key uses the binary predicate \c binary_pred |
|
* to compare adjacent keys. Specifically, consecutive iterators <tt>i</tt> and |
|
* <tt>i+1</tt> in the range <tt>[first1, last1)</tt> belong to the same segment if |
|
* <tt>binary_pred(*i, *(i+1))</tt> is true, and belong to different segments otherwise. |
|
* |
|
* This version of \p exclusive_scan_by_key uses the associative operator |
|
* \c 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 \p exec. |
|
* |
|
* \param exec The execution policy to use for parallelization. |
|
* \param first1 The beginning of the key sequence. |
|
* \param last1 The end of the key sequence. |
|
* \param first2 The beginning of the input value sequence. |
|
* \param result The beginning of the output value sequence. |
|
* \param init The initial of the exclusive sum value. |
|
* \param binary_pred The binary predicate used to determine equality of keys. |
|
* \param binary_op The associatve operator used to 'sum' values. |
|
* \return The end of the output sequence. |
|
* |
|
* \tparam DerivedPolicy The name of the derived execution policy. |
|
* \tparam InputIterator1 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* \tparam InputIterator2 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type. |
|
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a>, |
|
* and if \c x and \c y are objects of \c OutputIterator's \c value_type, then |
|
* <tt>binary_op(x,y)</tt> is defined. |
|
* \tparam T is convertible to \c OutputIterator's \c value_type. |
|
* \tparam BinaryPredicate is a model of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a>. |
|
* \tparam AssociativeOperator is a model of <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">Binary Function</a> |
|
* and \c AssociativeOperator's \c result_type is convertible to \c OutputIterator's \c value_type. |
|
* |
|
* \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p exclusive_scan_by_key using the |
|
* \p thrust::host execution policy for parallelization: |
|
* |
|
* \code |
|
* #include <thrust/scan.h> |
|
* #include <thrust/functional.h> |
|
* #include <thrust/execution_policy.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::equal_to<int> binary_pred; |
|
* thrust::plus<int> binary_op; |
|
* |
|
* 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}; |
|
* \endcode |
|
* |
|
* \see exclusive_scan |
|
* \see inclusive_scan_by_key |
|
* |
|
*/ |
|
template<typename DerivedPolicy, |
|
typename InputIterator1, |
|
typename InputIterator2, |
|
typename OutputIterator, |
|
typename T, |
|
typename BinaryPredicate, |
|
typename AssociativeOperator> |
|
OutputIterator 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); |
|
|
|
|
|
/*! \p 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 \p exclusive_scan_by_key uses the value \c init to |
|
* initialize the exclusive scan operation. |
|
* |
|
* This version of \p exclusive_scan_by_key uses the binary predicate \c binary_pred |
|
* to compare adjacent keys. Specifically, consecutive iterators <tt>i</tt> and |
|
* <tt>i+1</tt> in the range <tt>[first1, last1)</tt> belong to the same segment if |
|
* <tt>binary_pred(*i, *(i+1))</tt> is true, and belong to different segments otherwise. |
|
* |
|
* This version of \p exclusive_scan_by_key uses the associative operator |
|
* \c binary_op to perform the prefix sum. When the input and output sequences |
|
* are the same, the scan is performed in-place. |
|
* |
|
* \param first1 The beginning of the key sequence. |
|
* \param last1 The end of the key sequence. |
|
* \param first2 The beginning of the input value sequence. |
|
* \param result The beginning of the output value sequence. |
|
* \param init The initial of the exclusive sum value. |
|
* \param binary_pred The binary predicate used to determine equality of keys. |
|
* \param binary_op The associatve operator used to 'sum' values. |
|
* \return The end of the output sequence. |
|
* |
|
* \tparam InputIterator1 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* \tparam InputIterator2 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> |
|
* and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type. |
|
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a>, |
|
* and if \c x and \c y are objects of \c OutputIterator's \c value_type, then |
|
* <tt>binary_op(x,y)</tt> is defined. |
|
* \tparam T is convertible to \c OutputIterator's \c value_type. |
|
* \tparam BinaryPredicate is a model of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a>. |
|
* \tparam AssociativeOperator is a model of <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">Binary Function</a> |
|
* and \c AssociativeOperator's \c result_type is convertible to \c OutputIterator's \c value_type. |
|
* |
|
* \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise. |
|
* |
|
* The following code snippet demonstrates how to use \p exclusive_scan_by_key |
|
* |
|
* \code |
|
* #include <thrust/scan.h> |
|
* #include <thrust/functional.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::equal_to<int> binary_pred; |
|
* thrust::plus<int> binary_op; |
|
* |
|
* 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}; |
|
* \endcode |
|
* |
|
* \see exclusive_scan |
|
* \see inclusive_scan_by_key |
|
* |
|
*/ |
|
template<typename InputIterator1, |
|
typename InputIterator2, |
|
typename OutputIterator, |
|
typename T, |
|
typename BinaryPredicate, |
|
typename AssociativeOperator> |
|
OutputIterator exclusive_scan_by_key(InputIterator1 first1, |
|
InputIterator1 last1, |
|
InputIterator2 first2, |
|
OutputIterator result, |
|
T init, |
|
BinaryPredicate binary_pred, |
|
AssociativeOperator binary_op); |
|
|
|
|
|
/*! \} // end segmentedprefixsums |
|
*/ |
|
|
|
|
|
/*! \} // end prefix sums |
|
*/ |
|
|
|
|
|
} // end namespace thrust |
|
|
|
#include <thrust/detail/scan.inl> |
|
|
|
|