cppdraft_translate/cppdraft/alg/set/operations.md

[alg.set.operations]

26 Algorithms library [algorithms]

26.8 Sorting and related operations [alg.sorting]

26.8.7 Set operations on sorted structures [alg.set.operations]

26.8.7.1 General [alg.set.operations.general]

1

#

Subclause [alg.set.operations] defines all the basic set operations on sorted structures.

They also work with multisets ([multiset]) containing multiple copies of equivalent elements.

The semantics of the set operations are generalized to multisets in a standard way by defining set_union to contain the maximum number of occurrences of every element,set_intersection to contain the minimum, and so on.

26.8.7.2 includes [includes]

🔗

`template<class InputIterator1, class InputIterator2> constexpr bool includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2); template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2> bool includes(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);

template<class InputIterator1, class InputIterator2, class Compare> constexpr bool includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp); template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Compare> bool includes(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, Compare comp);

template<input_iterator I1, sentinel_for S1, input_iterator I2, sentinel_for S2, class Proj1 = identity, class Proj2 = identity, indirect_strict_weak_order<projected<I1, Proj1>, projected<I2, Proj2>> Comp = ranges::less> constexpr bool ranges::includes(I1 first1, S1 last1, I2 first2, S2 last2, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); template<input_range R1, input_range R2, class Proj1 = identity, class Proj2 = identity, indirect_strict_weak_order<projected<iterator_t, Proj1>, projected<iterator_t, Proj2>> Comp = ranges::less> constexpr bool ranges::includes(R1&& r1, R2&& r2, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});

template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for S1, random_access_iterator I2, sized_sentinel_for S2, class Proj1 = identity, class Proj2 = identity, indirect_strict_weak_order<projected<I1, Proj1>, projected<I2, Proj2>> Comp = ranges::less> bool ranges::includes(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2, class Proj1 = identity, class Proj2 = identity, indirect_strict_weak_order<projected<iterator_t, Proj1>, projected<iterator_t, Proj2>> Comp = ranges::less> bool ranges::includes(Ep&& exec, R1&& r1, R2&& r2, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); `

1

#

Let comp be less{},proj1 be identity{}, andproj2 be identity{}, for the overloads with no parameters by those names.

2

#

Preconditions: The ranges [first1, last1) and [first2, last2) are sorted with respect to comp and proj1 or proj2, respectively.

3

#

Returns: true if and only if [first2, last2) is a subsequence of [first1, last1).

[Note 1:

A sequence S is a subsequence of another sequence T if S can be obtained from T by removing some, all, or none of T's elements and keeping the remaining elements in the same order.

— end note]

4

#

Complexity: At most 2 * ((last1 - first1) + (last2 - first2)) - 1 comparisons and applications of each projection.

26.8.7.3 set_union [set.union]

🔗

`template<class InputIterator1, class InputIterator2, class OutputIterator> constexpr OutputIterator set_union(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result); template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator> ForwardIterator set_union(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, ForwardIterator result);

template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare> constexpr OutputIterator set_union(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator, class Compare> ForwardIterator set_union(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, ForwardIterator result, Compare comp);

template<input_iterator I1, sentinel_for S1, input_iterator I2, sentinel_for S2, weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> requires mergeable<I1, I2, O, Comp, Proj1, Proj2> constexpr ranges::set_union_result<I1, I2, O> ranges::set_union(I1 first1, S1 last1, I2 first2, S2 last2, O result, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> requires mergeable<iterator_t, iterator_t, O, Comp, Proj1, Proj2> constexpr ranges::set_union_result<borrowed_iterator_t, borrowed_iterator_t, O> ranges::set_union(R1&& r1, R2&& r2, O result, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});

template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for S1, random_access_iterator I2, sized_sentinel_for S2, random_access_iterator O, sized_sentinel_for OutS, class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> requires mergeable<I1, I2, O, Comp, Proj1, Proj2> ranges::set_union_result<I1, I2, O> ranges::set_union(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2, O result, OutS result_last, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2, sized-random-access-range OutR, class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> requires mergeable<iterator_t, iterator_t, iterator_t, Comp, Proj1, Proj2> ranges::set_union_result<borrowed_iterator_t, borrowed_iterator_t, borrowed_iterator_t> ranges::set_union(Ep&& exec, R1&& r1, R2&& r2, OutR&& result_r, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); `

1

#

Let:

• (1.1)

comp be less{}, and proj1 and proj2 be identity{} for the overloads with no parameters by those names;

• (1.2)

M be last1 - first1 plus the number of elements in [first2, last2) that are not present in [first1, last1);

• (1.3)

result_last be result + M for the overloads with no parameter result_last or result_r;

• (1.4)

N be min(M, result_last - result).

2

#

Preconditions: The ranges [first1, last1) and [first2, last2) are sorted with respect to comp and proj1 or proj2, respectively.

The resulting range does not overlap with either of the original ranges.

3

#

Effects: Constructs a sorted union of N elements from the two ranges; that is, the set of elements that are present in one or both of the ranges.

4

#

Returns:

• (4.1)

  result_last for the overloads in namespace std.

• (4.2)

  {last1, last2, result + N} for the overloads in namespace ranges, if N is equal to M.

• (4.3)

  Otherwise, {j1, j2, result_last} for the overloads in namespace ranges, where the iterators j1 and j2 point to positions past the last copied or skipped elements in [first1, last1) and [first2, last2), respectively.

5

#

Complexity: At most 2 * ((last1 - first1) + (last2 - first2)) - 1 comparisons and applications of each projection.

6

#

Remarks: Stable ([algorithm.stable]).

If [first1, last1) contains m elements that are equivalent to each other and [first2, last2) contains n elements that are equivalent to them, then all m elements from the first range are copied to the output range, in order, and then the final max(n−m,0) elements from the second range are copied to the output range, in order.

26.8.7.4 set_intersection [set.intersection]

🔗

`template<class InputIterator1, class InputIterator2, class OutputIterator> constexpr OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result); template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator> ForwardIterator set_intersection(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, ForwardIterator result);

template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare> constexpr OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator, class Compare> ForwardIterator set_intersection(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, ForwardIterator result, Compare comp);

template<input_iterator I1, sentinel_for S1, input_iterator I2, sentinel_for S2, weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> requires mergeable<I1, I2, O, Comp, Proj1, Proj2> constexpr ranges::set_intersection_result<I1, I2, O> ranges::set_intersection(I1 first1, S1 last1, I2 first2, S2 last2, O result, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> requires mergeable<iterator_t, iterator_t, O, Comp, Proj1, Proj2> constexpr ranges::set_intersection_result<borrowed_iterator_t, borrowed_iterator_t, O> ranges::set_intersection(R1&& r1, R2&& r2, O result, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});

template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for S1, random_access_iterator I2, sized_sentinel_for S2, random_access_iterator O, sized_sentinel_for OutS, class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> requires mergeable<I1, I2, O, Comp, Proj1, Proj2> ranges::set_intersection_result<I1, I2, O> ranges::set_intersection(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2, O result, OutS result_last, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2, sized-random-access-range OutR, class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> requires mergeable<iterator_t, iterator_t, iterator_t, Comp, Proj1, Proj2> ranges::set_intersection_result<borrowed_iterator_t, borrowed_iterator_t, borrowed_iterator_t> ranges::set_intersection(Ep&& exec, R1&& r1, R2&& r2, OutR&& result_r, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); `

1

#

Let:

• (1.1)

comp be less{}, and proj1 and proj2 be identity{} for the overloads with no parameters by those names;

• (1.2)

M be the number of elements in [first1, last1) that are present in [first2, last2);

• (1.3)

result_last be result + M for the overloads with no parameter result_last or result_r;

• (1.4)

N be min(M, result_last - result).

2

#

Preconditions: The ranges [first1, last1) and [first2, last2) are sorted with respect to comp and proj1 or proj2, respectively.

The resulting range does not overlap with either of the original ranges.

3

#

Effects: Constructs a sorted intersection of N elements from the two ranges; that is, the set of elements that are present in both of the ranges.

4

#

Returns:

• (4.1)

  result_last for the overloads in namespace std.

• (4.2)

  {last1, last2, result + N} for the overloads in namespace ranges, if N is equal to M.

• (4.3)

  Otherwise, {j1, j2, result_last} for the overloads in namespace ranges, where the iterators j1 and j2 point to positions past the last copied or skipped elements in [first1, last1) and [first2, last2), respectively.

5

#

Complexity: At most 2 * ((last1 - first1) + (last2 - first2)) - 1 comparisons and applications of each projection.

6

#

Remarks: Stable ([algorithm.stable]).

If [first1, last1) contains m elements that are equivalent to each other and [first2, last2) contains n elements that are equivalent to them, the first min(m,n) elements are copied from the first range to the output range, in order.

26.8.7.5 set_difference [set.difference]

🔗

`template<class InputIterator1, class InputIterator2, class OutputIterator> constexpr OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result); template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator> ForwardIterator set_difference(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, ForwardIterator result);

template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare> constexpr OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator, class Compare> ForwardIterator set_difference(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, ForwardIterator result, Compare comp);

template<input_iterator I1, sentinel_for S1, input_iterator I2, sentinel_for S2, weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> requires mergeable<I1, I2, O, Comp, Proj1, Proj2> constexpr ranges::set_difference_result<I1, O> ranges::set_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> requires mergeable<iterator_t, iterator_t, O, Comp, Proj1, Proj2> constexpr ranges::set_difference_result<borrowed_iterator_t, O> ranges::set_difference(R1&& r1, R2&& r2, O result, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});

template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for S1, random_access_iterator I2, sized_sentinel_for S2, random_access_iterator O, sized_sentinel_for OutS, class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> requires mergeable<I1, I2, O, Comp, Proj1, Proj2> ranges::set_difference_result<I1, O> ranges::set_difference(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2, O result, OutS result_last, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2, sized-random-access-range OutR, class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> requires mergeable<iterator_t, iterator_t, iterator_t, Comp, Proj1, Proj2> ranges::set_difference_result<borrowed_iterator_t, borrowed_iterator_t> ranges::set_difference(Ep&& exec, R1&& r1, R2&& r2, OutR&& result_r, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); `

1

#

Let:

• (1.1)

comp be less{}, and proj1 and proj2 be identity{} for the overloads with no parameters by those names;

• (1.2)

M be the number of elements in [first1, last1) that are not present in [first2, last2);

• (1.3)

result_last be result + M for the overloads with no parameter result_last or result_r;

• (1.4)

N be min(M, result_last - result).

2

#

Preconditions: The ranges [first1, last1) and [first2, last2) are sorted with respect to comp and proj1 or proj2, respectively.

The resulting range does not overlap with either of the original ranges.

3

#

Effects: Copies N elements of the range [first1, last1) which are not present in the range [first2, last2) to the range [result, result + N).

The elements in the constructed range are sorted.

4

#

Returns:

• (4.1)

  result_last for the overloads in namespace std.

• (4.2)

  {last1, result + N} for the overloads in namespace ranges, if N is equal to M.

• (4.3)

  Otherwise, {j1, result_last} for the overloads in namespace ranges, where the iterator j1 points to positions past the last copied or skipped elements in [first1, last1) and [first2, last2), respectively.

5

#

Complexity: At most 2 * ((last1 - first1) + (last2 - first2)) - 1 comparisons and applications of each projection.

6

#

Remarks: If [first1, last1) contains m elements that are equivalent to each other and [first2, last2) contains n elements that are equivalent to them, the last max(m−n,0) elements from [first1, last1) are copied to the output range, in order.

26.8.7.6 set_symmetric_difference [set.symmetric.difference]

🔗

`template<class InputIterator1, class InputIterator2, class OutputIterator> constexpr OutputIterator set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result); template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator> ForwardIterator set_symmetric_difference(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, ForwardIterator result);

template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare> constexpr OutputIterator set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator, class Compare> ForwardIterator set_symmetric_difference(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, ForwardIterator result, Compare comp);

template<input_iterator I1, sentinel_for S1, input_iterator I2, sentinel_for S2, weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> requires mergeable<I1, I2, O, Comp, Proj1, Proj2> constexpr ranges::set_symmetric_difference_result<I1, I2, O> ranges::set_symmetric_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> requires mergeable<iterator_t, iterator_t, O, Comp, Proj1, Proj2> constexpr ranges::set_symmetric_difference_result<borrowed_iterator_t, borrowed_iterator_t, O> ranges::set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});

template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for S1, random_access_iterator I2, sized_sentinel_for S2, random_access_iterator O, sized_sentinel_for OutS, class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> requires mergeable<I1, I2, O, Comp, Proj1, Proj2> ranges::set_symmetric_difference_result<I1, I2, O> ranges::set_symmetric_difference(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2, O result, OutS result_last, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2, sized-random-access-range OutR, class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> requires mergeable<iterator_t, iterator_t, iterator_t, Comp, Proj1, Proj2> ranges::set_symmetric_difference_result<borrowed_iterator_t, borrowed_iterator_t, borrowed_iterator_t> ranges::set_symmetric_difference(Ep&& exec, R1&& r1, R2&& r2, OutR&& result_r, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); `

1

#

Let:

• (1.1)

  comp be less{}, and proj1 and proj2 be identity{} for the overloads with no parameters by those names;

• (1.2)

  K be the number of elements in [first1, last1) that are not present in [first2, last2).

• (1.3)

  M be the number of elements in [first2, last2) that are not present in [first1, last1).

• (1.4)

  result_last be result + M + K for the overloads with no parameter result_last or result_r;

• (1.5)

  N be min(K+M, result_last - result).

2

#

Preconditions: The ranges [first1, last1) and [first2, last2) are sorted with respect to comp and proj1 or proj2, respectively.

The resulting range does not overlap with either of the original ranges.

3

#

Effects: Copies the elements of the range [first1, last1) that are not present in the range [first2, last2), and the elements of the range [first2, last2) that are not present in the range [first1, last1) to the range [result, result + N).

The elements in the constructed range are sorted.

4

#

Returns:

• (4.1)

  result_last for the overloads in namespace std.

• (4.2)

  {last1, last2, result + N} for the overloads in namespace ranges, if N is equal to M+K.

• (4.3)

  Otherwise, {j1, j2, result_last} for the overloads in namespace ranges, where the iterators j1 and j2 point to positions past the last copied or skipped elements in [first1, last1) and [first2, last2), respectively.

5

#

Complexity: At most 2 * ((last1 - first1) + (last2 - first2)) - 1 comparisons and applications of each projection.

6

#

Remarks: Stable ([algorithm.stable]).

If [first1, last1) contains m elements that are equivalent to each other and [first2, last2) contains n elements that are equivalent to them, then |m−n| of those elements shall be copied to the output range: the last m−n of these elements from [first1, last1) if m>n, and the last n−m of these elements from [first2, last2) if m<n.

In either case, the elements are copied in order.