sequence#

Overloads#

sequence(exec, first, last)#

template<typename DerivedPolicy, typename ForwardIterator>
void thrust::sequence(
const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
ForwardIterator first,
ForwardIterator last,
)#

sequence fills the range [first, last) with a sequence of numbers.

For each iterator i in the range [first, last), this version of sequence performs the assignment *i = (i - first).

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

The following code snippet demonstrates how to use sequence to fill a range with a sequence of numbers using the thrust::host execution policy for parallelization:

#include <thrust/sequence.h>
#include <thrust/execution_policy.h>
...
const int N = 10;
int A[N];
thrust::sequence(thrust::host, A, A + 10);
// A is now {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

See also

https://en.cppreference.com/w/cpp/algorithm/iota

Note

Unlike the similar C++ STL function std::iota, sequence offers no guarantee on order of execution.

Parameters:

  • exec – The execution policy to use for parallelization.

  • first – The beginning of the sequence.

  • last – The end of the sequence.

Template Parameters:

  • DerivedPolicy – The name of the derived execution policy.

  • ForwardIterator – is a model of Forward Iterator, and ForwardIterator is mutable, and if x and y are objects of ForwardIterator's value_type, then x + y is defined, and if T is ForwardIterator's value_type, then T(0) is defined.

sequence(first, last)#

template<typename ForwardIterator>
void thrust::sequence(
ForwardIterator first,
ForwardIterator last,
)#

sequence fills the range [first, last) with a sequence of numbers.

For each iterator i in the range [first, last), this version of sequence performs the assignment *i = (i - first).

The following code snippet demonstrates how to use sequence to fill a range with a sequence of numbers.

#include <thrust/sequence.h>
...
const int N = 10;
int A[N];
thrust::sequence(A, A + 10);
// A is now {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

See also

https://en.cppreference.com/w/cpp/algorithm/iota

Note

Unlike the similar C++ STL function std::iota, sequence offers no guarantee on order of execution.

Parameters:

  • first – The beginning of the sequence.

  • last – The end of the sequence.

Template Parameters:

ForwardIterator – is a model of Forward Iterator, and ForwardIterator is mutable, and if x and y are objects of ForwardIterator's value_type, then x + y is defined, and if T is ForwardIterator's value_type, then T(0) is defined.

sequence(exec, first, last, init)#

template<typename DerivedPolicy, typename ForwardIterator, typename T>
void thrust::sequence(
const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
ForwardIterator first,
ForwardIterator last,
T init,
)#

sequence fills the range [first, last) with a sequence of numbers.

For each iterator i in the range [first, last), this version of sequence performs the assignment *i = init + (i - first).

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

The following code snippet demonstrates how to use sequence to fill a range with a sequence of numbers starting from the value 1 using the thrust::host execution policy for parallelization:

#include <thrust/sequence.h>
#include <thrust/execution_policy.h>
...
const int N = 10;
int A[N];
thrust::sequence(thrust::host, A, A + 10, 1);
// A is now {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

See also

https://en.cppreference.com/w/cpp/algorithm/iota

Note

Unlike the similar C++ STL function std::iota, sequence offers no guarantee on order of execution.

Parameters:

  • exec – The execution policy to use for parallelization.

  • first – The beginning of the sequence.

  • last – The end of the sequence.

  • init – The first value of the sequence of numbers.

Template Parameters:

  • DerivedPolicy – The name of the derived execution policy.

  • ForwardIterator – is a model of Forward Iterator, and ForwardIterator is mutable, and if x and y are objects of ForwardIterator's value_type, then x + y is defined, and if T is ForwardIterator's value_type, then T(0) is defined.

  • T – is a model of Assignable, and T is convertible to ForwardIterator's value_type.

sequence(first, last, init)#

template<typename ForwardIterator, typename T>
void thrust::sequence(
ForwardIterator first,
ForwardIterator last,
T init,
)#

sequence fills the range [first, last) with a sequence of numbers.

For each iterator i in the range [first, last), this version of sequence performs the assignment *i = init + (i - first).

The following code snippet demonstrates how to use sequence to fill a range with a sequence of numbers starting from the value 1.

#include <thrust/sequence.h>
...
const int N = 10;
int A[N];
thrust::sequence(A, A + 10, 1);
// A is now {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

See also

https://en.cppreference.com/w/cpp/algorithm/iota

Note

Unlike the similar C++ STL function std::iota, sequence offers no guarantee on order of execution.

Parameters:

  • first – The beginning of the sequence.

  • last – The end of the sequence.

  • init – The first value of the sequence of numbers.

Template Parameters:

  • ForwardIterator – is a model of Forward Iterator, and ForwardIterator is mutable, and if x and y are objects of ForwardIterator's value_type, then x + y is defined, and if T is ForwardIterator's value_type, then T(0) is defined.

  • T – is a model of Assignable, and T is convertible to ForwardIterator's value_type.

sequence(exec, first, last, init, step)#

template<typename DerivedPolicy, typename ForwardIterator, typename T>
void thrust::sequence(
const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
ForwardIterator first,
ForwardIterator last,
T init,
T step,
)#

sequence fills the range [first, last) with a sequence of numbers.

For each iterator i in the range [first, last), this version of sequence performs the assignment *i = init + step * (i - first).

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

The following code snippet demonstrates how to use sequence to fill a range with a sequence of numbers starting from the value 1 with a step size of 3 using the thrust::host execution policy for parallelization:

#include <thrust/sequence.h>
#include <thrust/execution_policy.h>
...
const int N = 10;
int A[N];
thrust::sequence(thrust::host, A, A + 10, 1, 3);
// A is now {1, 4, 7, 10, 13, 16, 19, 22, 25, 28}

See also

https://en.cppreference.com/w/cpp/algorithm/iota

Note

Unlike the similar C++ STL function std::iota, sequence offers no guarantee on order of execution.

Parameters:

  • exec – The execution policy to use for parallelization.

  • first – The beginning of the sequence.

  • last – The end of the sequence.

  • init – The first value of the sequence of numbers

  • step – The difference between consecutive elements.

Template Parameters:

  • DerivedPolicy – The name of the derived execution policy.

  • ForwardIterator – is a model of Forward Iterator, and ForwardIterator is mutable, and if x and y are objects of ForwardIterator's value_type, then x + y is defined, and if T is ForwardIterator's value_type, then T(0) is defined.

  • T – is a model of Assignable, and T is convertible to ForwardIterator's value_type.

sequence(first, last, init, step)#

template<typename ForwardIterator, typename T>
void thrust::sequence(
ForwardIterator first,
ForwardIterator last,
T init,
T step,
)#

sequence fills the range [first, last) with a sequence of numbers.

For each iterator i in the range [first, last), this version of sequence performs the assignment *i = init + step * (i - first).

The following code snippet demonstrates how to use sequence to fill a range with a sequence of numbers starting from the value 1 with a step size of 3.

#include <thrust/sequence.h>
...
const int N = 10;
int A[N];
thrust::sequence(A, A + 10, 1, 3);
// A is now {1, 4, 7, 10, 13, 16, 19, 22, 25, 28}

See also

https://en.cppreference.com/w/cpp/algorithm/iota

Note

Unlike the similar C++ STL function std::iota, sequence offers no guarantee on order of execution.

Parameters:

  • first – The beginning of the sequence.

  • last – The end of the sequence.

  • init – The first value of the sequence of numbers

  • step – The difference between consecutive elements.

Template Parameters:

  • ForwardIterator – is a model of Forward Iterator, and ForwardIterator is mutable, and if x and y are objects of ForwardIterator's value_type, then x + y is defined, and if T is ForwardIterator's value_type, then T(0) is defined.

  • T – is a model of Assignable, and T is convertible to ForwardIterator's value_type.