Namespaces
Variants

Parallelized version of existing algorithms (parallelism TS)

From cppreference.net
C++
Experimental
Extensions for parallelism
ISO C++に統合されました このページで説明されている機能は、2016年3月時点で主要なISO C++標準に統合されました。詳細は アルゴリズムライブラリ (C++17以降) を参照してください

C++並列処理TS拡張は、以下の69個の既存アルゴリズムの並列化バージョンを提供します。以下の各並列化アルゴリズムは

  • std::experimental::parallel 名前空間で宣言されています。
  • is_execution_policy<std::decay_t<ExecutionPolicy>>::value が true でない限り、オーバーロード解決に参加しません。
  • 並列アルゴリズム のページで注記されている場合を除き、C++標準ライブラリの対応する既存のアルゴリズムと同じセマンティクスを持ちます。


HTMLタグ、属性、およびC++コード内のテキストは翻訳せず、元のフォーマットを保持しました。C++固有の用語（`template`、`class`、`bool`、`any_of`、`ExecutionPolicy`、`InputIt`、`UnaryPred`など）は翻訳していません。 **翻訳結果:** **注記:** このページには翻訳すべきテキストコンテンツが含まれていません。すべての内容が以下のいずれかに該当します： - HTMLタグと属性 - ` `タグ内のC++コード - C++固有の用語 - 既に翻訳対象外と指定された要素 HTMLタグ、属性、C++コード内のテキストは翻訳せず、元のフォーマットを保持しました。C++固有の用語も翻訳していません。 **注記**: 指定された要件に基づき、HTMLタグ、属性、コードブロック内のテキスト、C++固有の用語は翻訳せず、元のフォーマットを保持しています。翻訳対象となる自然言語のテキストが存在しないため、出力は入力と同一となります。 このページには翻訳すべきテキストがほとんど含まれていません。HTMLタグ、属性、コードブロック内のテキストは翻訳しないという指示に従い、C++のテンプレート宣言と関数シグネチャはそのまま保持されています。唯一の翻訳対象となる可能性がある要素はタイトル属性ですが、これもC++の関数名を含んでいるため翻訳していません。 HTMLタグ、属性、コードブロック内のテキストは翻訳せず、元のフォーマットを保持しました。C++固有の用語も翻訳していません。 HTMLタグ、属性、C++コード、C++専門用語は翻訳せず、元のフォーマットを保持しました。 HTMLタグ、属性、C++コード、C++固有の用語はすべて原文のまま保持されています。翻訳対象のテキストが存在しないため、元のフォーマットが完全に保持されています。 **注記**: 指定された要件に従い、HTMLタグ、属性、コードブロック内のテキストは翻訳せず、C++固有の用語も保持しています。このコードフラグメントには翻訳対象となる自然言語テキストが含まれていないため、元のフォーマットをそのまま保持しています。 **翻訳結果:** HTMLタグ、属性、コードブロック内のテキストは翻訳せず、元のフォーマットを保持しています。C++固有の用語も翻訳していません。 このページの内容はC++のテンプレート関数`std::copy_n`の宣言を表示しており、HTML構造とC++コードはそのまま保持されています。 **翻訳結果:** **注記:** このコードはC++テンプレート関数の宣言を含んでおり、指示に従って以下の対応を行いました： - HTMLタグと属性は一切翻訳せず保持 - ` `、` 
`、``タグ内のテキストは翻訳対象外（このケースでは該当せず）
- C++固有の用語（template, class, const, ExecutionPolicy, OutputItなど）は翻訳せず保持
- 元のフォーマットと構造を完全に維持
 **翻訳結果:** - HTMLタグ、属性、コードブロック内のテキストは翻訳せず、元のフォーマットを保持 - C++固有の用語（transform, template, class, ExecutionPolicy, InputIt, OutputIt, UnaryOp, BinaryOpなど）は翻訳せず - 関数シグネチャと構文はそのまま維持 HTMLタグ、属性、C++コード部分は翻訳せず、元のフォーマットを保持しました。C++固有の用語も翻訳していません。 **翻訳結果:** **注記:** 指定された要件に従い、以下の要素は翻訳していません: - HTMLタグと属性 - ` `, ` 
`, ``タグ内のテキスト（このケースでは該当なし）
- C++固有の用語（template, class, ExecutionPolicy, ForwardIt, UnaryPred, remove_ifなど）
- コード構文全体
C++コード部分は完全に原文のまま保持されています。
 HTMLタグ、属性、コードブロック内のテキスト、C++固有の用語は翻訳せず、元のフォーマットを保持しています。 HTMLタグ、属性、コードブロック内のテキストは翻訳せず、元のフォーマットを保持しています。C++固有の用語も翻訳していません。 HTMLタグ、属性、および` `内のC++コードは翻訳せず、元のフォーマットを保持しています。 HTMLタグ、属性、コードブロック内のテキストは翻訳せず、元のフォーマットを保持しました。C++固有の用語も翻訳していません。 HTMLタグ、属性、C++コード内のテキストは翻訳せず、元のフォーマットを保持しました。C++固有の用語も翻訳していません。 HTMLタグ、属性、C++コード内のテキストは翻訳せず、元のフォーマットを保持しました。C++固有の用語も翻訳していません。 **注記**: このコードはC++テンプレート関数の宣言であり、HTMLタグ内のコード部分は翻訳対象外です。表示されるテキスト要素が存在しないため、翻訳すべき自然言語のテキストは含まれていません。 HTMLタグ、属性、C++コード内のテキストは翻訳せず、元のフォーマットを保持しました。C++固有の用語も翻訳していません。 HTMLタグ、属性、C++コード内のテキストは翻訳せず、元のフォーマットを保持しました。C++固有の用語も翻訳していません。 HTMLタグ、属性、コードブロック内のテキスト、C++固有の用語は翻訳せず、元のフォーマットを保持しています。 HTMLタグ、属性、コードブロック内のテキストは翻訳せず、元のフォーマットを保持しています。C++固有の用語も翻訳していません。 **日本語訳:** **注記:** - HTMLタグ、属性、コードブロック内のC++コードは翻訳せず、元のまま保持しています - C++固有の用語（template, class, ExecutionPolicy, ForwardIt, BinaryPredなど）は翻訳していません - 関数名の`unique`はC++標準ライブラリの関数名であるため翻訳していません HTMLタグ、属性、コードブロック内のテキストは翻訳せず、C++固有の用語もそのまま保持しました。テンプレート宣言と関数シグネチャは元の形式を完全に維持しています。 **翻訳結果:** **注記:** このコードはC++テンプレート関数の宣言を含んでおり、指示に従って以下の点を厳守しました： - HTMLタグと属性は一切翻訳せず - ` `、` 
`、``タグ内のテキストは翻訳せず（この場合は``内）
- C++固有の用語（`template`, `class`, `bool`, `is_partitioned`, `ExecutionPolicy`, `InputIt`, `UnaryPred`など）は翻訳せず
- 元のフォーマットを完全に保持
 **翻訳結果:** **注記:** 指定された要件に従い、HTMLタグ、属性、` `/` 
`/``タグ内のテキスト、およびC++固有の用語（`template`, `class`, `ExecutionPolicy`, `ForwardIt`, `UnaryPred`, `std::partition`など）は翻訳せず、元のフォーマットを保持しています。このコードブロックには翻訳対象の自然言語テキストが含まれていないため、出力は入力と同一となります。
 HTMLタグ、属性、コードブロック内のテキストは翻訳せず、C++固有の用語もそのまま保持しました。元の書式は完全に維持されています。 **翻訳結果:** **注記:** この翻訳では以下のルールに従っています： - HTMLタグと属性は翻訳せず保持 - ` `, ` 
`, ``タグ内のテキストは翻訳せず保持（このケースではC++コード部分）
- C++固有の用語（`template`, `class`, `ExecutionPolicy`, `ForwardIt`, `Compare`など）は翻訳せず保持
- 元のフォーマットと構造を完全に維持
 HTMLタグ、属性、コードブロック内のテキストは翻訳せず、元のフォーマットを保持しました。C++固有の用語も翻訳していません。 **注記**: このコードはC++テンプレート関数の宣言を含んでおり、HTMLタグ内のコード部分は翻訳対象外です。`partial_sort`関数の宣言と関連するC++構文はそのまま保持されています。 **翻訳結果:** HTMLタグ、属性、` `、` 
`、``タグ内のテキスト、およびC++固有の用語は翻訳せず、元のフォーマットを保持しています。
 **翻訳結果:** - HTMLタグ、属性、コードブロック内のテキストは翻訳せず、元のフォーマットを保持 - C++固有の用語（stable_sort、ExecutionPolicy、RandomIt、Compareなど）は翻訳せず - プロフェッショナルで正確な翻訳を実施 HTMLタグ、属性、コードブロック内のテキストは翻訳せず、C++固有の用語もそのまま保持しました。テンプレート宣言と関数シグネチャは元の形式を完全に維持しています。 **注記**: このコードはC++のテンプレート関数宣言を含んでおり、HTMLタグ内のコード部分は翻訳対象外です。C++のキーワード（template, class, OutputItなど）や関数名（merge）は翻訳せず、HTML構造も完全に保持されています。 **注記**: このC++コード部分は翻訳対象外のため、元のまま保持されています。HTMLタグ、属性、および` `内のC++コードは一切翻訳していません。 **注記**: このC++コードは以下の理由で翻訳されていません： - HTMLタグと属性は翻訳対象外 - ` `内のC++コードは翻訳対象外 - C++固有の用語（template, class, bool, includesなど）は翻訳対象外 - 元のフォーマットは完全に保持されています コード部分はC++のテンプレート関数宣言であり、技術的な正確性を保つために翻訳していません。 **注記**: 提供されたテキストは主にC++コードとHTMLタグで構成されており、翻訳対象となる自然言語のテキストがほとんど含まれていません。C++コード、HTMLタグ、属性、およびC++固有の用語はすべて原文のまま保持されています。 HTMLタグ、属性、コードブロック内のテキストは翻訳せず、C++固有の用語もそのまま保持しました。元のフォーマットは完全に維持されています。 HTMLタグ、属性、C++コード内のテキストは翻訳せず、元のフォーマットを保持しました。 **注記**: 提供されたHTMLコードはC++テンプレート関数の宣言を含んでおり、以下の理由から翻訳対象外です： - すべてのテキストが` `タグ内に含まれている（コードブロックとして扱うべき） - C++のキーワード（template, class, ForwardItなど）、関数名（max_element）、構文要素は翻訳不可 - HTMLタグ、属性、リンクは保持する必要がある 翻訳が必要な部分は存在しません。 HTMLタグ、属性、コードブロック内のテキストは翻訳せず、元のフォーマットを保持しました。C++固有の用語も翻訳していません。 **注記**: このHTML断片には翻訳対象となる自然言語テキストが含まれていません。すべてのテキストは以下のいずれかに該当します： - HTMLタグおよび属性 - ` `内のC++コード - C++固有の用語（`template`, `class`, `std::pair`, `minmax_element`など） したがって、指示に従い翻訳は行われていません。 **翻訳結果:** - C++コード部分は翻訳せず、そのまま保持しました - HTMLタグ、属性、 タグ内のテキストは翻訳していません - 関数名`lexicographical_compare`はC++専門用語として翻訳していません - 元の書式と構造を完全に保持しています **注記**: このコードはC++のテンプレート関数定義であり、HTMLタグ内のコード部分は翻訳対象外です。`adjacent_difference`関数の宣言のみが含まれており、翻訳すべき自然言語テキストは存在しません。 **翻訳結果の説明:** - HTMLタグ、属性、コードブロック（` `, ` 
`, ``）内のテキストは翻訳せず、元のまま保持しています
- C++固有の用語（`template`, `class`, `ExecutionPolicy`, `InputIt1`, `inner_product`など）は翻訳していません
- 関数シグネチャと構文は完全に保持されています
- 元の書式と構造はそのまま維持されています
 **注記:** このコードはC++の関数テンプレート宣言を含んでおり、以下の理由から翻訳対象外です： - HTMLタグと属性は保持 - ` `内のC++コードは保持 - C++固有の用語（template, class, ExecutionPolicy, InputIt, Size, ForwardItなど）は保持 - 関数名`uninitialized_copy_n`は保持 翻訳が必要なテキスト要素が存在しないため、元のHTML構造とC++コードをそのまま保持しています。 HTMLタグ、属性、コードブロック内のテキストは翻訳せず、元のフォーマットを保持しています。C++固有の用語も翻訳していません。

目次

非変更シーケンス操作
並列化アルゴリズム 既存アルゴリズム
template < class ExecutionPolicy, class InputIt, class UnaryPred >

bool all_of ( ExecutionPolicy && policy, InputIt first, InputIt last,
UnaryPred p ) ;

std::all_of
template < class ExecutionPolicy, class InputIt, class UnaryPred >

bool any_of ( ExecutionPolicy && policy, InputIt first, InputIt last,
UnaryPred p ) ;

std::any_of
template < class ExecutionPolicy, class InputIt, class UnaryPred >

bool none_of ( ExecutionPolicy && policy, InputIt first, InputIt last,
UnaryPred p ) ;

std::none_of
template < class ExecutionPolicy, class InputIt, class T >

typename iterator_traits < InputIt > :: difference_type
count ( ExecutionPolicy && policy, InputIt first, InputIt last,
const T & value ) ;

std::count
template < class ExecutionPolicy, class InputIt, class T >

typename iterator_traits < InputIt > :: difference_type
count ( ExecutionPolicy && policy, InputIt first, InputIt last,
const T & value ) ;

std::count
template < class ExecutionPolicy, class InputIt, class UnaryPred >

typename iterator_traits < InputIt > :: difference_type
count_if ( ExecutionPolicy && policy, InputIt first, InputIt last,
UnaryPred p ) ;

std::count_if
template < class ExecutionPolicy, class InputIt1, class InputIt2 >

std:: pair < InputIt1,InputIt2 >
mismatch ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2 ) ;

template < class ExecutionPolicy, class InputIt1,
class InputIt2, class BinaryPred >
std:: pair < InputIt1,InputIt2 >
mismatch ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, BinaryPred p ) ;

template < class ExecutionPolicy, class InputIt1, class InputIt2 >
std:: pair < InputIt1,InputIt2 >
mismatch ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2 ) ;

template < class ExecutionPolicy, class InputIt1,
class InputIt2, class BinaryPred >
std:: pair < InputIt1,InputIt2 >
mismatch ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2, BinaryPred p ) ;

std::mismatch
template < class ExecutionPolicy, class InputIt1, class InputIt2 >

bool equal ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2 ) ;

template < class ExecutionPolicy, class InputIt1,
class InputIt2, class BinaryPred >
bool equal ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, BinaryPred p ) ;

template < class ExecutionPolicy, class InputIt1, class InputIt2 >
bool equal ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2 ) ;

template < class ExecutionPolicy, class InputIt1,
class InputIt2, class BinaryPred >
bool equal ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2, BinaryPred p ) ;

std::equal
template < class ExecutionPolicy, class InputIt, class T >

InputIt find ( ExecutionPolicy && policy, InputIt first, InputIt last,
const T & value ) ;

std::find
template < class ExecutionPolicy, class InputIt, class UnaryPred >

InputIt find_if ( ExecutionPolicy && policy, InputIt first, InputIt last,
UnaryPred p ) ;

std::find_if
template < class ExecutionPolicy, class InputIt, class UnaryPred >

InputIt find_if_not ( ExecutionPolicy && policy,
InputIt first, InputIt last,
UnaryPred p ) ;

std::find_if_not
template < class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >

ForwardIt1 find_end ( ExecutionPolicy && policy,
ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last ) ;

template < class ExecutionPolicy, class ForwardIt1,
class ForwardIt2, class BinaryPred >
ForwardIt1 find_end ( ExecutionPolicy && policy,
ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last,
BinaryPred p ) ;

std::find_end
template < class ExecutionPolicy, class InputIt, class ForwardIt >

InputIt find_first_of ( ExecutionPolicy && policy,
InputIt first, InputIt last,
ForwardIt s_first, ForwardIt s_last ) ;

template < class ExecutionPolicy, class InputIt,
class ForwardIt, class BinaryPred >
InputIt find_first_of ( ExecutionPolicy && policy,
InputIt first, InputIt last,
ForwardIt s_first, ForwardIt s_last,
BinaryPred p ) ;

std::find_first_of
template < class ExecutionPolicy, class ForwardIt >

ForwardIt adjacent_find ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last ) ;

template < class ExecutionPolicy, class ForwardIt, class BinaryPred >
ForwardIt adjacent_find ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last,
BinaryPred p ) ;

std::adjacent_find
template < class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >

ForwardIt1 search ( ExecutionPolicy && policy,
ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last ) ;

template < class ExecutionPolicy, class ForwardIt1,
class ForwardIt2, class BinaryPred >
ForwardIt1 search ( ExecutionPolicy && policy,
ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last,
BinaryPred p ) ;

std::search
template < class ExecutionPolicy, class ForwardIt, class Size, class T >

ForwardIt search_n ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last,
Size count, const T & value ) ;

template < class ExecutionPolicy, class ForwardIt,
class Size, class T, class BinaryPred >
ForwardIt search_n ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last,
Size count, const T & value,
BinaryPred p ) ;

std::search_n
変更操作シーケンス
並列化アルゴリズム 既存アルゴリズム
template < class ExecutionPolicy, class InputIt, class OutputIt >

OutputIt copy ( ExecutionPolicy && policy, InputIt first, InputIt last,
OutputIt d_first ) ;

std::copy
template < class ExecutionPolicy, class InputIt,

class OutputIt, class UnaryPred >
OutputIt copy_if ( ExecutionPolicy && policy, InputIt first, InputIt last,
OutputIt d_first, UnaryPred pred ) ;

std::copy_if
template < class ExecutionPolicy, class InputIt,

class Size, class OutputIt >
OutputIt copy_n ( ExecutionPolicy && policy, InputIt first, Size count,
OutputIt result ) ;

std::copy_n
template < class ExecutionPolicy, class InputIt,

class Size, class OutputIt >
OutputIt copy_n ( ExecutionPolicy && policy, InputIt first, Size count,
OutputIt result ) ;

std::copy_n
template < class ExecutionPolicy, class InputIt, class OutputIt >

OutputIt move ( ExecutionPolicy && policy, InputIt first, InputIt last,
OutputIt d_first ) ;

std::move
template < class ExecutionPolicy, class ForwardIt, class T >

void fill ( ExecutionPolicy && policy, ForwardIt first, ForwardIt last,
const T & value ) ;

std::fill
template < class ExecutionPolicy, class OutputIt, class Size, class T >

OutputIt fill_n ( ExecutionPolicy && policy, OutputIt first, Size count,
const T & value ) ;

std::fill_n
template < class ExecutionPolicy, class OutputIt, class Size, class T >

OutputIt fill_n ( ExecutionPolicy && policy, OutputIt first, Size count,
const T & value ) ;

std::fill_n
template < class ExecutionPolicy, class InputIt,

class OutputIt, class UnaryOp >
OutputIt transform ( ExecutionPolicy && policy,
InputIt first1, InputIt last1,
OutputIt d_first, UnaryOp unary_op ) ;

template < class ExecutionPolicy, class InputIt1, class InputIt2,
class OutputIt, class BinaryOp >
OutputIt transform ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, OutputIt d_first,
BinaryOp binary_op ) ;

std::transform
template < class ExecutionPolicy, class ForwardIt, class Generator >

void generate ( ExecutionPolicy && policy, ForwardIt first, ForwardIt last,
Generator g ) ;

std::generate
template < class ExecutionPolicy, class OutputIt,

class Size, class Generator >
OutputIt generate_n ( ExecutionPolicy && policy, OutputIt first,
Size count, Generator g ) ;

std::generate_n
template < class ExecutionPolicy, class ForwardIt, class T >

ForwardIt remove ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last, const T & value ) ;

std::remove
template < class ExecutionPolicy, class ForwardIt, class UnaryPred >

ForwardIt remove_if ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last, UnaryPred p ) ;

std::remove_if
template < class ExecutionPolicy, class ForwardIt, class UnaryPred >

ForwardIt remove_if ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last, UnaryPred p ) ;

std::remove_if
template < class ExecutionPolicy, class InputIt, class OutputIt, class T >

OutputIt remove_copy ( ExecutionPolicy && policy,
InputIt first, InputIt last,
OutputIt d_first, const T & value ) ;

std::remove_copy
template < class ExecutionPolicy, class InputIt,

class OutputIt, class UnaryPred >
OutputIt remove_copy_if ( ExecutionPolicy && policy,
InputIt first, InputIt last,
OutputIt d_first, UnaryPred p ) ;

std::remove_copy_if
template < class ExecutionPolicy, class ForwardIt, class T >

void replace ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last,
const T & old_value, const T & new_value ) ;

std::replace
template < class ExecutionPolicy, class ForwardIt,

class UnaryPred, class T >
void replace_if ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last,
UnaryPred p, const T & new_value ) ;

std::replace_if
template < class ExecutionPolicy, class InputIt, class OutputIt, class T >

OutputIt replace_copy ( ExecutionPolicy && policy,
InputIt first, InputIt last, OutputIt d_first,
const T & old_value, const T & new_value ) ;

std::replace_copy
template < class ExecutionPolicy, class InputIt, class OutputIt,

class UnaryPred, class T >
OutputIt replace_copy_if ( ExecutionPolicy && policy,
InputIt first, InputIt last, OutputIt d_first,
UnaryPred p, const T & new_value ) ;

std::replace_copy_if
template < class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >

ForwardIt2 swap_ranges ( ExecutionPolicy && policy,
ForwardIt1 first1, ForwardIt1 last1,
ForwardIt2 first2 ) ;

std::swap_ranges
template < class ExecutionPolicy, class BidirIt >

void reverse ( ExecutionPolicy && policy, BidirIt first, BidirIt last ) ;

std::reverse
template < class ExecutionPolicy, class BidirIt, class OutputIt >

OutputIt reverse_copy ( ExecutionPolicy && policy,
BidirIt first, BidirIt last, OutputIt d_first ) ;

std::reverse_copy
template < class ExecutionPolicy, class ForwardIt >

ForwardIt rotate ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt n_first, ForwardIt last ) ;

std::rotate
template < class ExecutionPolicy, class ForwardIt, class OutputIt >

OutputIt rotate_copy ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt n_first, ForwardIt last,
OutputIt d_first ) ;

std::rotate_copy
template < class ExecutionPolicy, class ForwardIt >

ForwardIt unique ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last ) ;

template < class ExecutionPolicy, class ForwardIt, class BinaryPred >
ForwardIt unique ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last, BinaryPred p ) ;

std::unique
template < class ExecutionPolicy, class ForwardIt >

ForwardIt unique ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last ) ;

template < class ExecutionPolicy, class ForwardIt, class BinaryPred >
ForwardIt unique ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last, BinaryPred p ) ;

std::unique
template < class ExecutionPolicy, class InputIt, class OutputIt >

OutputIt unique_copy ( ExecutionPolicy && policy,
InputIt first, InputIt last,
OutputIt d_first ) ;

template < class ExecutionPolicy, class InputIt,
class OutputIt, class BinaryPred >
OutputIt unique_copy ( ExecutionPolicy && policy,
InputIt first, InputIt last,
OutputIt d_first, BinaryPred p ) ;

std::unique_copy
パーティショニング操作
並列化アルゴリズム 既存アルゴリズム
template < class ExecutionPolicy, class InputIt, class UnaryPred >

bool is_partitioned ( ExecutionPolicy && policy,
InputIt first, InputIt last, UnaryPred p ) ;

std::is_partitioned
template < class ExecutionPolicy, class InputIt, class UnaryPred >

bool is_partitioned ( ExecutionPolicy && policy,
InputIt first, InputIt last, UnaryPred p ) ;

std::is_partitioned
template < class ExecutionPolicy, class ForwardIt, class UnaryPred >

ForwardIt partition ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last, UnaryPred p ) ;

std::partition
template < class ExecutionPolicy, class ForwardIt, class UnaryPred >

ForwardIt partition ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last, UnaryPred p ) ;

std::partition
template < class ExecutionPolicy, class InputIt, class OutputIt1,

class OutputIt2, class UnaryPred >
std:: pair < OutputIt1, OutputIt2 >
partition_copy ( ExecutionPolicy && policy,
InputIt first, InputIt last,
OutputIt1 d_first_true, OutputIt2 d_first_false,
UnaryPred p ) ;

std::partition_copy
template < class ExecutionPolicy, class BidirIt, class UnaryPred >

BidirIt stable_partition ( ExecutionPolicy && policy,
BidirIt first, BidirIt last, UnaryPred p ) ;

std::stable_partition
ソート操作
並列化アルゴリズム 既存アルゴリズム
template < class ExecutionPolicy, class ForwardIt >

bool is_sorted ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last ) ;

template < class ExecutionPolicy, class ForwardIt, class Compare >
bool is_sorted ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last, Compare cmp ) ;

std::is_sorted
template < class ExecutionPolicy, class ForwardIt >

ForwardIt is_sorted_until ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last ) ;

template < class ExecutionPolicy, class ForwardIt, class Compare >
ForwardIt is_sorted_until ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last,
Compare cmp ) ;

std::is_sorted_until
template < class ExecutionPolicy, class ForwardIt >

ForwardIt is_sorted_until ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last ) ;

template < class ExecutionPolicy, class ForwardIt, class Compare >
ForwardIt is_sorted_until ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last,
Compare cmp ) ;

std::is_sorted_until
template < class ExecutionPolicy, class RandomIt >

void sort ( ExecutionPolicy && policy, RandomIt first, RandomIt last ) ;

template < class ExecutionPolicy, class RandomIt, class Compare >
void sort ( ExecutionPolicy && policy,
RandomIt first, RandomIt last, Compare cmp ) ;

std::sort
template < class ExecutionPolicy, class RandomIt >

void partial_sort ( ExecutionPolicy && policy,
RandomIt first, RandomIt middle, RandomIt last ) ;

template < class ExecutionPolicy, class RandomIt, class Compare >
void partial_sort ( ExecutionPolicy && policy,
RandomIt first, RandomIt middle, RandomIt last,
Compare cmp ) ;

std::partial_sort
template < class ExecutionPolicy, class InputIt, class RandomIt >

RandomIt partial_sort_copy ( ExecutionPolicy && policy,
InputIt first, InputIt last,
RandomIt d_first, RandomIt d_last ) ;

template < class ExecutionPolicy, class InputIt,
class RandomIt, class Compare >
RandomIt partial_sort_copy ( ExecutionPolicy && policy,
InputIt first, InputIt last,
RandomIt d_first, RandomIt d_last,
Compare cmp ) ;

std::partial_sort_copy
template < class ExecutionPolicy, class RandomIt >

void stable_sort ( ExecutionPolicy && policy,
RandomIt first, RandomIt last ) ;

template < class ExecutionPolicy, class RandomIt, class Compare >
void stable_sort ( ExecutionPolicy && policy,
RandomIt first, RandomIt last, Compare cmp ) ;

std::stable_sort
template < class ExecutionPolicy, class RandomIt >

void nth_element ( ExecutionPolicy && policy,
RandomIt first, RandomIt nth, RandomIt last ) ;

template < class ExecutionPolicy, class RandomIt, class Compare >
void nth_element ( ExecutionPolicy && policy,
RandomIt first, RandomIt nth, RandomIt last,
Compare cmp ) ;

std::nth_element
集合演算（ソート済み範囲に対する）
並列化アルゴリズム 既存アルゴリズム
template < class ExecutionPolicy, class InputIt1,

class InputIt2, class OutputIt >
OutputIt merge ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2,
OutputIt d_first ) ;

template < class ExecutionPolicy, class InputIt1, class InputIt2,
class OutputIt, class Compare >
OutputIt merge ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2,
OutputIt d_first, Compare cmp ) ;

std::merge
template < class ExecutionPolicy, class BidirIt >

void inplace_merge ( ExecutionPolicy && policy,
BidirIt first, BidirIt middle, BidirIt last ) ;

template < class ExecutionPolicy, class BidirIt, class Compare >
void inplace_merge ( ExecutionPolicy && policy,
BidirIt first, BidirIt middle, BidirIt last,
Compare cmp ) ;

std::inplace_merge
template < class ExecutionPolicy, class InputIt1, class InputIt2 >

bool includes ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2 ) ;

template < class ExecutionPolicy, class InputIt1,
class InputIt2, class Compare >
bool includes ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2, Compare cmp ) ;

std::includes
template < class ExecutionPolicy, class InputIt1,

class InputIt2, class OutputIt >
OutputIt set_difference ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2,
OutputIt d_first ) ;

template < class ExecutionPolicy, class InputIt1, class InputIt2,
class OutputIt, class Compare >
OutputIt set_difference ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2,
OutputIt d_first, Compare cmp ) ;

std::set_difference
template < class ExecutionPolicy, class InputIt1,

class InputIt2, class OutputIt >
OutputIt set_intersection ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2,
OutputIt d_first ) ;

template < class ExecutionPolicy, class InputIt1, class InputIt2,
class OutputIt, class Compare >
OutputIt set_intersection ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2,
OutputIt d_first, Compare cmp ) ;

std::set_intersection
template < class ExecutionPolicy, class InputIt1,

class InputIt2, class OutputIt >
OutputIt set_symmetric_difference ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2,
OutputIt d_first ) ;

template < class ExecutionPolicy, class InputIt1, class InputIt2,
class OutputIt, class Compare >
OutputIt set_symmetric_difference ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2,
OutputIt d_first, Compare cmp ) ;

std::set_symmetric_difference
template < class ExecutionPolicy, class InputIt1,

class InputIt2, class OutputIt >
OutputIt set_union ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2,
OutputIt d_first ) ;

template < class ExecutionPolicy, class InputIt1, class InputIt2,
class OutputIt, class Compare >
OutputIt set_union ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2,
OutputIt d_first, Compare cmp ) ;

std::set_union
ヒープ操作
並列化アルゴリズム 既存アルゴリズム
template < class ExecutionPolicy, class RandomIt >

bool is_heap ( ExecutionPolicy && policy,
RandomIt first, RandomIt last ) ;

template < class ExecutionPolicy, class RandomIt, class Compare >
bool is_heap ( ExecutionPolicy && policy,
RandomIt first, RandomIt last, Compare cmp ) ;

std::is_heap
template < class ExecutionPolicy, class RandomIt >

RandomIt is_heap_until ( ExecutionPolicy && policy,
RandomIt first, RandomIt last ) ;

template < class ExecutionPolicy, class RandomIt, class Compare >
RandomIt is_heap_until ( ExecutionPolicy && policy,
RandomIt first, RandomIt last, Compare cmp ) ;

std::is_heap_until
最小値/最大値操作
並列化アルゴリズム 既存アルゴリズム
template < class ExecutionPolicy, class ForwardIt >

ForwardIt max_element ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last ) ;

template < class ExecutionPolicy, class ForwardIt, class Compare >
ForwardIt max_element ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last, Compare cmp ) ;

std::max_element
template < class ExecutionPolicy, class ForwardIt >

ForwardIt min_element ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last ) ;

template < class ExecutionPolicy, class ForwardIt, class Compare >
ForwardIt min_element ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last, Compare cmp ) ;

std::min_element
template < class ExecutionPolicy, class ForwardIt >

std:: pair < ForwardIt,ForwardIt >
minmax_element ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last ) ;

template < class ExecutionPolicy, class ForwardIt, class Compare >
std:: pair < ForwardIt,ForwardIt >
minmax_element ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last, Compare cmp ) ;

std::minmax_element
template < class ExecutionPolicy, class InputIt1, class InputIt2 >

bool lexicographical_compare ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2 ) ;

template < class ExecutionPolicy, class InputIt1,
class InputIt2, class Compare >
bool lexicographical_compare ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2,
Compare cmp ) ;

std::lexicographical_compare
数値演算
並列化アルゴリズム 既存アルゴリズム
template < class ExecutionPolicy, class InputIt, class OutputIt >

OutputIt adjacent_difference ( ExecutionPolicy && policy,
InputIt first, InputIt last,
OutputIt d_first ) ;

template < class ExecutionPolicy, class InputIt,
class OutputIt, class BinaryOp >
OutputIt adjacent_difference ( ExecutionPolicy && policy,
InputIt first, InputIt last,
OutputIt d_first, BinaryOp op ) ;

std::adjacent_difference
template < class ExecutionPolicy, class InputIt1,

class InputIt2, class T >
T inner_product ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1, InputIt2 first2,
T value ) ;

template < class ExecutionPolicy, class InputIt1, class InputIt2,
class T, class BinaryOp1, class BinaryOp2 >
T inner_product ( ExecutionPolicy && policy,
InputIt1 first1, InputIt1 last1, InputIt2 first2,
T value, BinaryOp1 op1, BinaryOp2 op2 ) ;

std::inner_product
未初期化メモリに対する操作
並列化アルゴリズム 既存アルゴリズム
template < class ExecutionPolicy, class InputIt, class ForwardIt >

ForwardIt uninitialized_copy ( ExecutionPolicy && policy,
InputIt first, InputIt last,
ForwardIt d_first ) ;

std::uninitialized_copy
template < class ExecutionPolicy, class InputIt,

class Size, class ForwardIt >
ForwardIt uninitialized_copy_n ( ExecutionPolicy && policy,
InputIt first, Size count,
ForwardIt d_first ) ;

std::uninitialized_copy_n
template < class ExecutionPolicy, class ForwardIt, class T >

void uninitialized_fill ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last,
const T & value ) ;

std::uninitialized_fill
template < class ExecutionPolicy, class ForwardIt, class Size, class T >

ForwardIt uninitialized_fill_n ( ExecutionPolicy && policy,
ForwardIt first, Size count,
const T & value ) ;

std::uninitialized_fill_n