Defined in header <cmath> float fmax( float x, float y ); (1) (since C++11) double fmax( double x, double y ); (2) (since C++11) long double fmax( long double x, long double y ); (3) (since C++11) Promoted fmax( Arithmetic1 x, Arithmetic2 y ); (4) (since C++11) 1-3) Returns the larger of two floating point arguments, treating NaNs as missing data (between a NaN and a numeric value, the numeric value is chosen) 4) A set of overloads or a fun

Defined in header <valarray> template< class T > valarray<T> pow( const valarray<T>& base, const valarray<T>& exp ); (1) template< class T > valarray<T> pow( const valarray<T>& base, const T& vexp ); (2) template< class T > valarray<T> pow( const T& vbase, const valarray<T>& exp ); (3) Raises a value to a power. 1) Computes the values of each element in the numeric array base

Unordered associative containers are Containers that provide fast lookup of objects based on keys. Worst case complexity is linear but on average much faster for most of the operations. Unordered associative containers are parametrized by Key; Hash, a Hash function object which acts as hash function on Key; and Pred, a BinaryPredicate evaluating equivalence between Keys. std::unordered_map and std::unordered_multimap also have a mapped type T associated with the Key. If two Keys are equal accor

static T round_error(); (until C++11) static constexpr T round_error(); (since C++11) Returns the largest possible rounding error in ULPs (units in the last place) as defined by ISO 10967, which can vary from 0.5 (rounding to the nearest digit) to 1.0 (rounding to zero or to infinity). It is only meaningful if std::numeric_limits<T>::is_integer == false. Return value T std::numeric_limits<T>::round_error() /* non-specialized */ T(); bool false char ​0

unique_lock(); (1) (since C++11) unique_lock( unique_lock&& other ); (2) (since C++11) explicit unique_lock( mutex_type& m ); (3) (since C++11) unique_lock( mutex_type& m, std::defer_lock_t t ); (4) (since C++11) unique_lock( mutex_type& m, std::try_to_lock_t t ); (5) (since C++11) unique_lock( mutex_type& m, std::adopt_lock_t t ); (6) (since C++11) template< class Rep, class Period > unique_lock( mutex_type& m,

Defined in header <locale> template< class CharT > class collate; Class std::collate encapsulates locale-specific collation (comparison) and hashing of strings. This facet is used by std::basic_regex and can be applied, by means of std::locale::operator(), directly to all standard algorithms that expect a string comparison predicate. Inheritance diagram. Two standalone (locale-independent) specializations are provided by the standard library: Defined in header

Defined in header <locale> template< class CharT > class collate_byname : public std::collate<CharT>; std::collate_byname is a std::collate facet which encapsulates locale-specific collation (comparison) and hashing of strings. Just like std::collate, it can be imbued in std::regex and applied, by means of std::locale::operator(), directly to all standard algorithms that expect a string comparison predicate. Two specializations are provided by the standard libra

Defined in header <iterator> struct input_iterator_tag { }; struct output_iterator_tag { }; struct forward_iterator_tag : public input_iterator_tag { }; struct bidirectional_iterator_tag : public forward_iterator_tag { }; struct random_access_iterator_tag : public bidirectional_iterator_tag { }; Defines the category of an iterator. Each tag is an empty type and corresponds to one of the five iterator categories: input_iterator_tag corresponds to Inp

Defined in header <random> template< class RealType = double > class gamma_distribution; (since C++11) Produces random positive floating-point values x, distributed according to probability density function: P(x|α,β) = e-x/β βα · Γ(α) · xα-1 where α is known as the shape parameter and β is known as the scale parameter. For floating-point α, the value obtained is the sum of α independent exponentially distributed random variables, each of which has a mean of β st

Defined in header <strstream> class strstream : public std::iostream (deprecated) The class strstream implements input and output operations on array-backed streams. It essentially wraps a raw array I/O device implementation (std::strstreambuf) into the higher-level interface of std::basic_iostream. The typical implementation of strstream holds only one non-derived data member: an object of type std::strstreambuf. Notes After any call to str(), a call to freeze(false) is