thrust::transform_reduce

Defined in thrust/transform_reduce.h

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 : public unary_function<T,T>
{
  __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,
                                      thrust::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 – is a model of Unary Function, and UnaryFunction's result_type is convertible to OutputType.

  • OutputType – is a model of Assignable, and is convertible to BinaryFunction's first_argument_type and second_argument_type.

  • BinaryFunction – is a model of Binary Function, and BinaryFunction's result_type is convertible to OutputType.

Returns

The result of the transformed reduction.