thrust::transform_reduce#

Overloads#

transform_reduce(exec, first, last, unary_op, init, binary_op)#

template<typename DerivedPolicy, typename InputIterator, typename UnaryFunction, typename OutputType, typename BinaryFunction>
OutputType thrust::transform_reduce(
const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
InputIterator first,
InputIterator last,
UnaryFunction unary_op,
OutputType init,
BinaryFunction binary_op,
)#

transform_reduce fuses the transform and reduce operations. transform_reduce is equivalent to performing a transformation defined by unary_op into a temporary sequence and then performing reduce on the transformed sequence. In most cases, fusing these two operations together is more efficient, since fewer memory reads and writes are required.

transform_reduce performs a reduction on the transformation of the sequence [first, last) according to unary_op. Specifically, unary_op is applied to each element of the sequence and then the result is reduced to a single value with binary_op using the initial value init. Note that the transformation unary_op is not applied to the initial value init. The order of reduction is not specified, so binary_op must be both commutative and associative.

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

The following code snippet demonstrates how to use transform_reduce to compute the maximum value of the absolute value of the elements of a range using the thrust::host execution policy for parallelization:

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

template<typename T>
struct absolute_value
{
  __host__ __device__ T operator()(const T &x) const
  {
    return x < T(0) ? -x : x;
  }
};

...

int data[6] = {-1, 0, -2, -2, 1, -3};
int result = thrust::transform_reduce(thrust::host,
                                      data, data + 6,
                                      absolute_value<int>(),
                                      0,
                                      ::cuda::maximum<int>());
// result == 3

See also

transform

See also

reduce

Parameters:

  • exec – The execution policy to use for parallelization.

  • first – The beginning of the sequence.

  • last – The end of the sequence.

  • unary_op – The function to apply to each element of the input sequence.

  • init – The result is initialized to this value.

  • binary_op – The reduction operation.

Template Parameters:

  • DerivedPolicy – The name of the derived execution policy.

  • InputIterator – is a model of Input Iterator, and InputIterator's value_type is convertible to UnaryFunction's argument type.

  • UnaryFunction – The function’s return type must be convertible to OutputType.

  • OutputType – is a model of Assignable, and is convertible to BinaryFunction's first and second argument type.

  • BinaryFunction – The function’s return type must be convertible to OutputType.

Returns:

The result of the transformed reduction.

transform_reduce(first, last, unary_op, init, binary_op)#

template<typename InputIterator, typename UnaryFunction, typename OutputType, typename BinaryFunction>
OutputType thrust::transform_reduce(
InputIterator first,
InputIterator last,
UnaryFunction unary_op,
OutputType init,
BinaryFunction binary_op,
)#

transform_reduce fuses the transform and reduce operations. transform_reduce is equivalent to performing a transformation defined by unary_op into a temporary sequence and then performing reduce on the transformed sequence. In most cases, fusing these two operations together is more efficient, since fewer memory reads and writes are required.

transform_reduce performs a reduction on the transformation of the sequence [first, last) according to unary_op. Specifically, unary_op is applied to each element of the sequence and then the result is reduced to a single value with binary_op using the initial value init. Note that the transformation unary_op is not applied to the initial value init. The order of reduction is not specified, so binary_op must be both commutative and associative.

The following code snippet demonstrates how to use transform_reduce to compute the maximum value of the absolute value of the elements of a range.

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

template<typename T>
struct absolute_value
{
  __host__ __device__ T operator()(const T &x) const
  {
    return x < T(0) ? -x : x;
  }
};

...

int data[6] = {-1, 0, -2, -2, 1, -3};
int result = thrust::transform_reduce(data, data + 6,
                                      absolute_value<int>(),
                                      0,
                                      ::cuda::maximum<int>());
// result == 3

See also

transform

See also

reduce

Parameters:

  • first – The beginning of the sequence.

  • last – The end of the sequence.

  • unary_op – The function to apply to each element of the input sequence.

  • init – The result is initialized to this value.

  • binary_op – The reduction operation.

Template Parameters:

  • InputIterator – is a model of Input Iterator, and InputIterator's value_type is convertible to UnaryFunction's argument type.

  • UnaryFunction – The function’s return type must be convertible to OutputType.

  • OutputType – is a model of Assignable, and is convertible to BinaryFunction's first and second argument type.

  • BinaryFunction – The function’s return type must be convertible to OutputType.

Returns:

The result of the transformed reduction.