std::priority_queue

Defined in header <queue> template< class T, class Container = std::vector<T>, class Compare = std::less<typename Container::value_type> > class priority_queue; A priority queue is a container adaptor that provides constant time lookup of the largest (by default) element, at the expense of logarithmic insertion and extraction. A user-provided Compare can be supplied to change the ordering, e.g. using std::greater<T> would cause the smalle

std::printf

Defined in header <cstdio> int printf( const char* format, ... ); (1) int fprintf( std::FILE* stream, const char* format, ... ); (2) int sprintf( char* buffer, const char* format, ... ); (3) int snprintf( char* buffer, std::size_t buf_size, const char* format, ... ); (4) (since C++11) Loads the data from the given locations, converts them to character string equivalents and writes the results to a variety of sinks. 1) Writes the results to stdout. 2) Wri

std::pow(std::complex)

Defined in header <complex> template< class T > complex<T> pow( const complex<T>& x, const complex<T>& y); template< class T > complex<T> pow( const complex<T>& x, const T& y); template< class T > complex<T> pow( const T& x, const complex<T>& y); template< class T, class U > complex</*Promoted*/> pow( const complex<T>& x, const complex<U>& y);

std::pow(std::valarray)

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

std::prev_permutation

Defined in header <algorithm> template< class BidirIt > bool prev_permutation( BidirIt first, BidirIt last); (1) template< class BidirIt, class Compare > bool prev_permutation( BidirIt first, BidirIt last, Compare comp); (2) Transforms the range [first, last) into the previous 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 th

std::prev

Defined in header <iterator> template< class BidirIt > BidirIt prev( BidirIt it, typename std::iterator_traits<BidirIt>::difference_type n = 1 ); (since C++11) Return the nth predecessor of iterator it. Parameters it - an iterator n - number of elements it should be descended Type requirements - BidirIt must meet the requirements of BidirectionalIterator. Return value The nth predecessor of iterator it. Possible implement

std::poisson_distribution::reset

void reset(); (since C++11) Resets the internal state of the distribution object. After a call to this function, the next call to operator() on the distribution object will not be dependent on previous calls to operator(). Parameters (none). Return value (none). Complexity Constant.

std::pop_heap

Defined in header <algorithm> template< class RandomIt > void pop_heap( RandomIt first, RandomIt last ); (1) template< class RandomIt, class Compare > void pop_heap( RandomIt first, RandomIt last, Compare comp ); (2) Swaps the value in the position first and the value in the position last-1 and makes the subrange [first, last-1) into a max heap. This has the effect of removing the first (largest) element from the heap defined by the range [first, last). Th

std::pow

Defined in header <cmath> float pow( float base, float exp ); (1) double pow( double base, double exp ); (2) long double pow( long double base, long double exp ); (3) float pow( float base, int iexp ); (4) (until C++11) double pow( double base, int iexp ); (5) (until C++11) long double pow( long double base, int iexp ); (6) (until C++11) Promoted pow( Arithmetic1 base, Arithmetic2 exp ); (7) (since C++11) 1-6) Co

std::polar(std::complex)

Defined in header <complex> template< class T > complex<T> polar( const T& r, const T& theta = 0 ); Returns a complex number with magnitude r and phase angle theta. The behavior is undefined if r is negative or NaN, or if theta is infinite (since C++17) Parameters r - magnitude theta - phase angle Return value a complex number determined by r and theta. See also abs(std::complex) returns the magnitude of a complex number (f