Thrust

## ◆ unique() [1/4]

template<typename DerivedPolicy , typename ForwardIterator >
 __host__ __device__ ForwardIterator thrust::unique ( const thrust::detail::execution_policy_base< DerivedPolicy > & exec, ForwardIterator first, ForwardIterator last )

For each group of consecutive elements in the range `[first, last)` with the same value, `unique` removes all but the first element of the group. The return value is an iterator `new_last` such that no two consecutive elements in the range `[first, new_last)` are equal. The iterators in the range `[new_last, last)` are all still dereferenceable, but the elements that they point to are unspecified. `unique` is stable, meaning that the relative order of elements that are not removed is unchanged.

This version of `unique` uses `operator==` to test for equality.

The algorithm's execution is parallelized as determined by `exec`.

Parameters
 exec The execution policy to use for parallelization. first The beginning of the input range. last The end of the input range.
Returns
The end of the unique range `[first, new_last)`.
Template Parameters
 DerivedPolicy The name of the derived execution policy. ForwardIterator is a model of Forward Iterator, and `ForwardIterator` is mutable, and `ForwardIterator's` `value_type` is a model of Equality Comparable.

The following code snippet demonstrates how to use `unique` to compact a sequence of numbers to remove consecutive duplicates using the `thrust::host` execution policy for parallelization:

#include <thrust/unique.h>
...
const int N = 7;
int A[N] = {1, 3, 3, 3, 2, 2, 1};
int *new_end = thrust::unique(thrust::host, A, A + N);
// The first four values of A are now {1, 3, 2, 1}
// Values beyond new_end are unspecified.