Difference between revisions of "cpp/algorithm/is partitioned"

Latest revision as of 01:54, 28 March 2024

Defined in header `<algorithm>`
template< class InputIt, class UnaryPred > bool is_partitioned( InputIt first, InputIt last, UnaryPred p );	(1)	(since C++11) (constexpr since C++20)
template< class ExecutionPolicy, class ForwardIt, class UnaryPred > bool is_partitioned( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, UnaryPred p );	(2)	(since C++17)

1) Checks whether [first, last) is partitioned by the predicate p: all elements satisfy p appear before all elements that do not.

2) Same as (1), but executed according to policy.

This overload participates in overload resolution only if

std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> is true.	(until C++20)
std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> is true.	(since C++20)

first, last	-	the range of elements to check
policy	-	the execution policy to use. See execution policy for details.
p	-	unary predicate which returns true for the elements expected to be found in the beginning of the range. The expression p(v) must be convertible to bool for every argument `v` of type (possibly const) `VT`, where `VT` is the value type of `InputIt`, regardless of value category, and must not modify `v`. Thus, a parameter type of VT&is not allowed, nor is VT unless for `VT` a move is equivalent to a copy(since C++11).
Type requirements
- `InputIt` must meet the requirements of LegacyInputIterator.
- `ForwardIt` must meet the requirements of LegacyForwardIterator. and its value type must be convertible to `UnaryPred`'s parameter type.
- `UnaryPred` must meet the requirements of Predicate.

[edit] Return value

true if the elements e of [first, last) are partitioned with respect to the expression p(e). false otherwise.

[edit] Complexity

At most std::distance(first, last) applications of p.

[edit] Exceptions

The overload with a template parameter named ExecutionPolicy reports errors as follows:

If execution of a function invoked as part of the algorithm throws an exception and ExecutionPolicy is one of the standard policies, std::terminate is called. For any other ExecutionPolicy, the behavior is implementation-defined.
If the algorithm fails to allocate memory, std::bad_alloc is thrown.

[edit] Possible implementation

template<class InputIt, class UnaryPred>
bool is_partitioned(InputIt first, InputIt last, UnaryPred p)
{
    for (; first != last; ++first)
        if (!p(*first))
            break;
    for (; first != last; ++first)
        if (p(*first))
            return false;
    return true;
}

[edit] Example

Run this code

#include <algorithm>
#include <array>
#include <iostream>
 
int main()
{
    std::array<int, 9> v {1, 2, 3, 4, 5, 6, 7, 8, 9};
 
    auto is_even = [](int i) { return i % 2 == 0; };
    std::cout.setf(std::ios_base::boolalpha);
    std::cout << std::is_partitioned(v.begin(), v.end(), is_even) << ' ';
 
    std::partition(v.begin(), v.end(), is_even);
    std::cout << std::is_partitioned(v.begin(), v.end(), is_even) << ' ';
 
    std::reverse(v.begin(), v.end());
    std::cout << std::is_partitioned(v.cbegin(), v.cend(), is_even) << ' ';
    std::cout << std::is_partitioned(v.crbegin(), v.crend(), is_even) << '\n';
}

Output:

false true false true

[edit] See also

partition	divides a range of elements into two groups (function template) [edit]
partition_point (C++11)	locates the partition point of a partitioned range (function template) [edit]
ranges::is_partitioned (C++20)	determines if the range is partitioned by the given predicate (niebloid)[edit]

@@ Line 2: / Line 2: @@
 {{cpp/algorithm/navbar}}
 {{dcl begin}}
-{{dcl header | algorithm}}
+{{dcl header|algorithm}}
-{{dcl | since=c++11 | num= 1 |1=
+{{dcl|num=1|since=c++11|notes={{mark constexpr since c++20}}|
-template< class InputIt, class UnaryPredicate >
+template< class InputIt, class UnaryPred >
-bool is_partitioned( InputIt first, InputIt last, UnaryPredicate p );
+bool is_partitioned( InputIt first, InputIt last, UnaryPred p );
+}}
+{{dcl|num=2|since=c++17|
+template< class ExecutionPolicy, class ForwardIt, class UnaryPred >
+bool is_partitioned( ExecutionPolicy&& policy,
+                     ForwardIt first, ForwardIt last, UnaryPred p );
 }}
-{{dcl | since=c++17 | num= 2 |1=
-template< class ExecutionPolicy, class InputIt, class UnaryPredicate >
-bool is_partitioned( ExecutionPolicy&& policy, InputIt first, InputIt last, UnaryPredicate p );}}
 {{dcl end}}
-@1@ Returns {{c|true}} if all elements in the range {{tt|[first, last)}} that satisfy the predicate {{tt|p}} appear before all elements that don't. Also returns {{c|true}} if {{tt|[first, last)}} is empty.
+@1@ Checks whether {{range|first|last}} is partitioned by the predicate {{c|p}}: all elements satisfy {{c|p}} appear before all elements that do not.
-@2@ Same as {{v|1}}, but executed according to {{tt|policy}}. This overload does not participate in overload resolution unless {{c|std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>}} is true
+@2@ Same as {{v|1}}, but executed according to {{c|policy}}.
+@@ {{cpp/algorithm/parallel overload precondition}}
 ===Parameters===
 {{par begin}}
-{{par | first, last | the range of elements to check}}
+{{par|first, last|the range of elements to check}}
 {{par exec pol}}
-{{par pred1 | p | for the elements expected to be found in the beginning of the range | p1=InputIt}}
+{{par pred1|p|for the elements expected to be found in the beginning of the range|p1=InputIt}}
 {{par hreq}}
-{{par req concept | InputIt | InputIterator}}
+{{par req named|InputIt|InputIterator}}
-{{par req concept | UnaryPredicate | Predicate}}
+{{par req named|ForwardIt|ForwardIterator|notes=and its value type must be convertible to {{tt|UnaryPred}}'s parameter type.}}
+{{par req named|UnaryPred|Predicate}}
 {{par end}}
 ===Return value===
+{{c|true}} if the elements {{c|e}} of {{range|first|last}} are {{rlp|/#Requirements|partitioned}} with respect to the expression {{c|p(e)}}. {{c|false}} otherwise.
-{{c|true}} if the range {{tt|[first, last)}} is empty or is partitioned by {{tt|p}}. {{c|false}} otherwise.
 ===Complexity===
+At most {{c|std::distance(first, last)}} applications of {{c|p}}.
-At most {{tt|std::distance(first, last)}} applications of {{tt|p}}.
 ===Exceptions===
-{{cpp/algorithm/parallel_exceptions_reporting_behavior|singular=yes}}
+{{cpp/algorithm/parallel exceptions reporting behavior|singular=yes}}
 ===Possible implementation===
-{{eq fun | 1=
+{{eq fun|1=
-template< class InputIt, class UnaryPredicate >
+template<class InputIt, class UnaryPred>
-bool is_partitioned(InputIt first, InputIt last, UnaryPredicate p)
+bool is_partitioned(InputIt first, InputIt last, UnaryPred p)
 {
      for (; first != last; ++first)
@@ Line 54: / Line 56: @@
 ===Example===
 {{example
- |
+|
- | code=
+|code=
 #include <algorithm>
 #include <array>
@@ Line 62: / Line 64: @@
 int main()
 {
-     std::array<int, 9> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+     std::array<int, 9> v {1, 2, 3, 4, 5, 6, 7, 8, 9};
-     auto is_even = [](int i){ return i % 2 == 0; };
+     auto is_even = [](int i) { return i % 2 == 0; };
      std::cout.setf(std::ios_base::boolalpha);
      std::cout << std::is_partitioned(v.begin(), v.end(), is_even) << ' ';
@@ Line 72: / Line 74: @@
      std::reverse(v.begin(), v.end());
-     std::cout << std::is_partitioned(v.begin(), v.end(), is_even);
+     std::cout << std::is_partitioned(v.cbegin(), v.cend(), is_even) << ' ';
+    std::cout << std::is_partitioned(v.crbegin(), v.crend(), is_even) << '\n';
 }
- | output=
+|output=
-false true false
+false true false true
 }}
 ===See also===
 {{dsc begin}}
-{{dsc inc | cpp/algorithm/dsc partition}}
+{{dsc inc|cpp/algorithm/dsc partition}}
-{{dsc inc | cpp/algorithm/dsc partition_point}}
+{{dsc inc|cpp/algorithm/dsc partition_point}}
-{{dsc inc | cpp/experimental/parallelism/dsc algorithm | is_partitioned}}
+{{dsc inc|cpp/algorithm/ranges/dsc is_partitioned}}
 {{dsc end}}
-[[de:cpp/algorithm/is partitioned]]
+{{langlinks|de|es|fr|it|ja|pt|ru|zh}}
-[[es:cpp/algorithm/is partitioned]]
-[[fr:cpp/algorithm/is partitioned]]
-[[it:cpp/algorithm/is partitioned]]
-[[ja:cpp/algorithm/is partitioned]]
-[[pt:cpp/algorithm/is partitioned]]
-[[ru:cpp/algorithm/is partitioned]]
-[[zh:cpp/algorithm/is partitioned]]

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.com

Namespaces

Variants

Views

Actions

Difference between revisions of "cpp/algorithm/is partitioned"

Latest revision as of 01:54, 28 March 2024

Contents

[edit] Parameters