Template Function thrust::transform_reduce(InputIterator, InputIterator, UnaryFunction, OutputType, BinaryFunction)

Function Documentation

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.
Return

The result of the transformed reduction.

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: 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.

#include <thrust/transform_reduce.h>
#include <thrust/functional.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(data, data + 6,
                                      absolute_value<int>(),
                                      0,
                                      thrust::maximum<int>());
// result == 3

See

transform

See

reduce