thrust

◆ transform() [3/4]

template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryFunction >
__host__ __device__ OutputIterator thrust::transform ( const thrust::detail::execution_policy_base< DerivedPolicy > &  exec,
InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
OutputIterator  result,
BinaryFunction  op 
)

This version of transform applies a binary function to each pair of elements from two input sequences and stores the result in the corresponding position in an output sequence. Specifically, for each iterator i in the range [first1, last1) and j = first + (i - first1) in the range [first2, last2) the operation op(*i,*j) 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.

Parameters
execThe execution policy to use for parallelization.
first1The beginning of the first input sequence.
last1The end of the first input sequence.
first2The beginning of the second input sequence.
resultThe beginning of the output sequence.
opThe tranformation operation.
Returns
The end of the output sequence.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is a model of Input Iterator and InputIterator1's value_type is convertible to BinaryFunction's first_argument_type.
InputIterator2is a model of Input Iterator and InputIterator2's value_type is convertible to BinaryFunction's second_argument_type.
OutputIteratoris a model of Output Iterator.
BinaryFunctionis a model of Binary Function and BinaryFunction's result_type is convertible to OutputIterator's value_type.
Precondition
first1 may equal result, but the range [first1, last1) shall not overlap the range [result, result + (last1 - first1)) otherwise.
first2 may equal result, but the range [first2, first2 + (last1 - first1)) shall not overlap the range [result, result + (last1 - first1)) otherwise.

The following code snippet demonstrates how to use transform to compute the sum of two ranges using the thrust::host execution policy for parallelization:

...
int input1[6] = {-5, 0, 2, 3, 2, 4};
int input2[6] = { 3, 6, -2, 1, 2, 3};
int output[6];
thrust::transform(thrust::host, input1, input1 + 6, input2, output, op);
// output is now {-2, 6, 0, 4, 4, 7};
See also
http://www.sgi.com/tech/stl/transform.html