thrust::transform

Defined in thrust/transform.h

template<typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename UnaryFunction>
OutputIterator thrust::transform(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, InputIterator first, InputIterator last, OutputIterator result, UnaryFunction op)

This version of transform applies a unary function to each element of an input sequence and stores the result in the corresponding position in an output sequence. Specifically, for each iterator i in the range [first, last) the operation op(*i) is performed and the result is assigned to *o, where o is the corresponding output iterator in the range [result, result + (last - first) ). The input and output sequences may coincide, resulting in an in-place transformation.

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

The following code snippet demonstrates how to use transform to negate a range in-place using the thrust::host execution policy for parallelization:

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

int data[10] = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8};

thrust::negate<int> op;

thrust::transform(thrust::host, data, data + 10, data, op); // in-place transformation

// data is now {5, 0, -2, 3, -2, -4, 0, 1, -2, -8};

Parameters
  • 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.

  • op – The transformation 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.

  • OutputIterator – is a model of Output Iterator.

  • UnaryFunction – is a model of Unary Function and UnaryFunction's result_type is convertible to OutputIterator's value_type.

Returns

The end of the output sequence.

Pre

first may equal result, but the range [first, last) shall not overlap the range [result, result + (last - first)) otherwise.