Defined in header <algorithm> template< class BidirIt > bool next_permutation( BidirIt first, BidirIt last ); (1) template< class BidirIt, class Compare > bool next_permutation( BidirIt first, BidirIt last, Compare comp ); (2) Transforms the range [first, last) into the next permutation from the set of all permutations that are lexicographically ordered with respect to operator< or comp. Returns true if such permutation exists, otherwise transforms the

virtual bool equivalent( int code, const std::error_condition& condition ) const; (1) (since C++11) virtual bool equivalent( const std::error_code& code, int condition ) const; (2) (since C++11) Checks whether error code is equivalent to an error condition for the error category represented by *this. 1) Equivalent to default_error_condition(code) == condition. 2) Equivalent to *this == code.category() && code.val

void unlock(); (since C++14) Unlocks the mutex. The mutex must be locked by the current thread of execution, otherwise, the behavior is undefined. This operation synchronizes-with (as defined in std::memory_order) any subsequent lock operation that obtains ownership of the same mutex. Parameters (none). Return value (none). Exceptions (none). Notes unlock() is usually not called directly: std::unique_lock and std::lock_guard are used to manage exclusive locking. Example

The atomic library provides components for fine-grained atomic operations allowing for lockless concurrent programming. Each atomic operation is indivisible with regards to any other atomic operation that involves the same object. Atomic objects are the only C++ objects free of data races; that is, if one thread writes to an atomic while another thread reads from it, the behavior is well-defined. Defined in header <atomic> Atomic types atomic (C++11) atomic class template

Defined in header <complex> template< class T > complex<T> sinh( const complex<T>& z ); (since C++11) Computes complex hyperbolic sine of a complex value z. Parameters z - complex value Return value If no errors occur, complex hyperbolic sine of z is returned. Error handling and special values Errors are reported consistent with math_errhandling. If the implementation supports IEEE floating-point arithmetic, std::sinh(std::conj(z)) =

result_type min() const; (since C++11) Returns the minimum value potentially generated by the distribution. Parameters (none). Return value The minimum value potentially generated by the distribution. Complexity Constant. See also max returns the maximum potentially generated value (public member function)

size_type count( const Key& key ) const; (1) (since C++11) Returns the number of elements with key key. Parameters key - key value of the elements to count Return value Number of elements with key key. Complexity Constant on average, worst case linear in the size of the container. See also find finds element with specific key (public member function) equal_range returns range of elements matching a specific key (public member function)

size_type rfind( const basic_string& str, size_type pos = npos ) const; (1) size_type rfind( const CharT* s, size_type pos, size_type count ) const; (2) size_type rfind( const CharT* s, size_type pos = npos ) const; (3) size_type rfind( CharT ch, size_type pos = npos ) const; (4) Finds the last substring equal to the given character sequence. Search begins at pos, i.e. the found substring must not begin in a position following pos. If npos or any value not smaller

std::pair<iterator,bool> insert( const value_type& value ); (1) std::pair<iterator,bool> insert( value_type&& value ); (2) (since C++11) (3) iterator insert( iterator hint, const value_type& value ); (until C++11) iterator insert( const_iterator hint, const value_type& value ); (since C++11) iterator insert( const_iterator hint, value_type&& value ); (4) (since C++11) template< class InputIt > void insert( InputIt firs

Defined in header <algorithm> template< class BidirIt1, class BidirIt2 > BidirIt2 move_backward( BidirIt1 first, BidirIt1 last, BidirIt2 d_last ); (since C++11) Moves the elements from the range [first, last), to another range ending at d_last. The elements are moved in reverse order (the last element is moved first), but their relative order is preserved. The behavior is undefined if d_last is within (first, last]. std::move must be used instead of std::move_backwar