This appendix presents a synopsis of the TR1 library headers <regex>
(Section A.1), <unordered_set>
(Section A.2), and <unordered_-map>
(Section A.3), and of each of the headers from the standard C++ library that has been extended by the TR1 library: <float.h>
(Section A.4), <math.h>
(Section A.5), <functional>
(Section A.6), <memory>
(Section A.7), and <utility>
(Section A.8).
<regex>
Synopsisnamespace std { // C++ standard library
namespace tr1 { // TR1 additions
// CLASS TEMPLATE regex_traits AND basic_regex
template <class Elem>
struct regex_traits ;
template <>
struct regex_traits <char>;
template <>
struct regex_traits <wchar_t>;
template <class Elem,
class RXtraits = regex_traits <Elem>,
class basic_regex;
typedef basic_regex <char> regex;
typedef basic_regex <wchar_t> wregex ;
// CLASS TEMPLATE sub_match
template <class BidIt>
class sub_match ;
typedef sub_match <const char*> csub_match;
typedef sub_match <const wchar_t *> wcsub_match;
typedef sub_match <string :: const_iterator> ssub_match;
typedef sub_match <wstring :: const_iterator> wssub_match;
// CLASS TEMPLATE match_results
template <class BidIt,
class Alloc = allocator <
typename iterator_traits <BidIt>:: value_type> >
class match_results ;
typedef match_results <const char*> cmatch ;
typedef match_results <const wchar_t *> wcmatch ;
typedef match_results <string :: const_iterator> smatch ;
typedef match_results <wstring :: const_iterator> wsmatch ;
// NAMESPACE regex_constants
namespace regex_constants {
typedef T1 syntax_option_type ;
static const syntax_option_type
awk, basic, collate, ECMAScript, egrep,
extended, grep, icase, nosubs, optimize ;
typedef T2 match_flag_type ;
static const match_flag_type match_any, match_default,
match_not_bol, match_not_bow, match_continuous,
match_not_eol, match_not_eow, match_not_null,
match_prev_avail ;
typedef T3 error_type;
static const error_type error_badbrace, error_badrepeat,
error_brace, error_brack, error_collate,
error_complexity, error_ctype, error_escape,
error_paren, error_range, error_space, error_stack,
error_backref ;
}
// CLASS regex_error
class regex_error;
// FUNCTION TEMPLATE regex_match
template <class BidIt, class Alloc, class Elem,
class RXtraits>
bool regex_match(BidIt first, Bidit last,
match_results <BidIt, Alloc>&,
const basic_regex <Elem, RXtraits>&,
match_flag_types = match_default);
template <class BidIt, class Elem, class RXtraits>
bool regex_match(BidIt first, Bidit last,
const basic_regex <Elem, RXtraits>&,
match_flag_types = match_default);
template <class Elem, class Alloc, class RXtraits>
bool regex_match(const Elem*,
match_results <const Elem*, Alloc>&,
const basic_regex <Elem, RXtraits>&,
match_flag_types = match_default);
template <class Elem, class RXtraits>
bool regex_match(const Elem*,
const basic_regex <Elem, RXtraits>&,
match_flag_types = match_default);
template <class IOtraits, class IOalloc,
class Alloc, class Elem, class RXtraits>
bool regex_match(
const basic_string <Elem, IOtraits, IOalloc>&,
match_results <typename
basic_string <
Elem, IOtraits, IOalloc>:: const_iterator,
Alloc>&,
const basic_regex <Elem, RXtraits>&,
match_flag_types = match_default);
template <class IOtraits, class IOalloc,
class Alloc, class Elem, class RXtraits>
bool regex_match(
const basic_string <Elem, IOtraits, IOalloc>&,
const basic_regex <Elem, RXtraits>&,
match_flag_types = match_default);
// FUNCTION TEMPLATE regex_search
template <class BidIt, class Alloc,
class Elem, class RXtraits>
bool regex_search(BidIt first, Bidit last,
match_results <BidIt, Alloc>&,
const basic_regex <Elem, RXtraits>&,
match_flag_types = match_default);
template <class BidIt, class Elem, class RXtraits>
bool regex_search(BidIt first, Bidit last,
const basic_regex <Elem, RXtraits>&,
match_flag_types = match_default);
template <class Elem, class Alloc, class RXtraits>
bool regex_search(const Elem*,
match_results <const Elem*, Alloc>&,
const basic_regex <Elem, RXtraits>&,
match_flag_types = match_default);
template <class Elem, class RXtraits>
bool regex_search(const Elem*,
const basic_regex <Elem, RXtraits>&,
match_flag_types = match_default);
template <class IOtraits, class IOalloc,
class Alloc, class Elem, class RXtraits>
bool regex_search(
const basic_string <Elem , IOtraits , IOalloc>& ,
match_results <typename
basic_string <
Elem, IOtraits, IOalloc>:: const_iterator ,
Alloc>&,
const basic_regex <Elem, RXtraits>& ,
match_flag_types = match_default);
template <class IOtraits, class IOalloc ,
class Alloc, class Elem, class RXtraits>
bool regex_search(
const basic_string <Elem , IOtraits , IOalloc>& ,
const basic_regex <Elem , RXtraits>& ,
match_flag_types = match_default);
// FUNCTION TEMPLATE regex_replace
template <class OutIt, class BidIt,
class RXtraits, class Elem>
OutIt regex_replace (OutIt out , BidIt first , BidIt last ,
const basic_regex <Elem , RXtraits>& ,
const basic_string <Elem>& fmt ,
match_flag_type flags = match_default);
template <class RXtraits , class Elem>
basic_string <Elem> regex_replace (
const basic_string <Elem>&,
const basic_regex <Elem, RXtraits>&,
const basic_string <Elem>& fmt,
match_flag_type flags = match_default);
// REGULAR EXPRESSION ITERATORS
template <class BidIt,
class Elem = iterator_traits <BidIt>:: value_type,
class RXtraits = regex_traits <Elem>>
class regex_iterator ;
typedef regex_iterator <const char*> cregex_iterator ;
typedef regex_iterator <const wchar_t *> wcregex_iterator ;
typedef regex_iterator <string :: const_iterator>
sregex_iterator ;
typedef regex_iterator <wstring :: const_iterator>
wsregex_iterator ;
template <class BidIt, class Elem =
iterator_traits <BidIt>:: value_type,
class RXtraits = regex_traits <Elem>>
class regex_token_iterator ;
typedef regex_token_iterator <const char*>
cregex_token_iterator ;
typedef regex_token_iterator <const wchar_t *>
wcregex_token_iterator ;
typedef regex_token_iterator <string :: const_iterator>
sregex_token_iterator ;
typedef regex_token_iterator <wstring :: const_iterator>
wsregex_token_iterator ;
// STREAM INSERTER
template <class Elem, class IOtraits,
class Alloc, class BidIt>
basic_ostream <Elem, IOtraits>&
operator <<( basic_ostream <Elem, IOtraits>&,
const sub_match <BidIt>&);
// TEMPLATE swap FUNCTIONS
template <class Elem, class RXtraits>
void swap(basic_regex <Elem, RXtraits>& left,
basic_regex <Elem, RXtraits>& right) throw ();
template <class Elem, class IOtraits,
class BidIt, class Alloc>
void swap(match_results <BidIt, Alloc>& left,
match_results <BidIt, Alloc>& right) throw ();
// COMPARISON OPERATORS FOR match_results
template <class BidIt , class Alloc>
bool operator ==( const match_results <BidIt, Alloc>&,
const match_results <BidIt, Alloc>&);
template <class BidIt , class Alloc>
bool operator !=( const match_results <BidIt, Alloc>&,
const match_results <BidIt , Alloc>&);
// COMPARISON OPERATORS FOR sub_match
template <class BidIt>
bool operator ==( const sub_match <BidIt >&,
const sub_match <BidIt>&);
template <class BidIt>
bool operator !=( const sub_match <BidIt >&,
const sub_match <BidIt>&);
template <class BidIt >
bool operator <( const sub_match <BidIt >&,
const sub_match <BidIt>&);
template <class BidIt>
bool operator <=( const sub_match <BidIt >&,
const sub_match <BidIt>&);
template <class BidIt>
bool operator>( const sub_match <BidIt >&,
const sub_match <BidIt >&);
template <class BidIt >
bool operator>=( const sub_match <BidIt >&,
const sub_match <BidIt >&);
template <class BidIt, class IOtraits, class Alloc>
bool operator ==(
const basic_string <
typename iterator_traits <BidIt >:: value_type,
IOtraits, Alloc>&,
const sub_match <BidIt >&);
template <class BidIt, class IOtraits, class Alloc>
bool operator !=(
const basic_string <
typename iterator_traits <BidIt >:: value_type,
IOtraits, Alloc>&,
const sub_match <BidIt >&);
template <class BidIt, class IOtraits, class Alloc>
bool operator <(
const basic_string <
typename iterator_traits <BidIt >:: value_type,
IOtraits, Alloc>&,
const sub_match <BidIt >&);
template <class BidIt, class IOtraits, class Alloc>
bool operator <=(
const basic_string <
typename iterator_traits <BidIt >:: value_type,
IOtraits, Alloc>&,
const sub_match <BidIt >&);
template <class BidIt, class IOtraits, class Alloc>
bool operator>(
const basic_string <
typename iterator_traits <BidIt >:: value_type,
IOtraits, Alloc>&,
const sub_match <BidIt >&);
template <class BidIt, class IOtraits, class Alloc>
bool operator>=(
const basic_string <
typename iterator_traits <BidIt >:: value_type,
IOtraits, Alloc>&,
const sub_match <BidIt >&);
template <class BidIt, class IOtraits, class Alloc>
bool operator ==( const sub_match <BidIt >&,
const basic_string <
typename iterator_traits <BidIt >:: value_type,
IOtraits, Alloc>&);
template <class BidIt, class IOtraits, class Alloc>
bool operator !=( const sub_match <BidIt >&,
const basic_string <
typename iterator_traits <BidIt >:: value_type,
IOtraits, Alloc>&);
template <class BidIt, class IOtraits, class Alloc>
bool operator <( const sub_match <BidIt >&,
const basic_string <
typename iterator_traits <BidIt >:: value_type,
IOtraits, Alloc>&);
template <class BidIt, class IOtraits, class Alloc>
bool operator <=( const sub_match <BidIt >&,
const basic_string <
typename iterator_traits <BidIt >:: value_type,
IOtraits, Alloc>&);
template <class BidIt, class IOtraits, class Alloc>
bool operator>( const sub_match <BidIt >&,
const basic_string <
typename iterator_traits <BidIt >:: value_type,
IOtraits, Alloc>&);
template <class BidIt, class IOtraits, class Alloc>
bool operator>=( const sub_match <BidIt >&,
const basic_string <
typename iterator_traits <BidIt >:: value_type,
IOtraits, Alloc>&);
template <class BidIt >
bool operator ==(
const typename iterator_traits <BidIt >:: value_type*,
const sub_match <BidIt >&);
template <class BidIt >
bool operator !=(
const typename iterator_traits <BidIt >:: value_type*,
const sub_match <BidIt >&);
template <class BidIt >
bool operator <(
const typename iterator_traits <BidIt >:: value_type*,
const sub_match <BidIt >&);
template <class BidIt >
bool operator <=(
const typename iterator_traits <BidIt >:: value_type*,
const sub_match <BidIt >&);
template <class BidIt >
bool operator>(
const typename iterator_traits <BidIt >:: value_type*,
const sub_match <BidIt >&);
template <class BidIt >
bool operator>=(
const typename iterator_traits <BidIt >:: value_type*,
const sub_match <BidIt >&);
template <class BidIt >
bool operator ==( const sub_match <BidIt >&,
const typename iterator_traits <BidIt >:: value_type *);
template <class BidIt >
bool operator !=( const sub_match <BidIt >&,
const typename iterator_traits <BidIt >:: value_type *);
template <class BidIt>
bool operator <( const sub_match <BidIt >&,
const typename iterator_traits <BidIt >:: value_type *);
template <class BidIt>
bool operator <=( const sub_match <BidIt >&,
const typename iterator_traits <BidIt >:: value_type *);
template <class BidIt>
bool operator>( const sub_match <BidIt >&,
const typename iterator_traits <BidIt >:: value_type *);
template <class BidIt>
bool operator>=( const sub_match <BidIt >&,
const typename iterator_traits <BidIt >:: value_type *);
template <class BidIt>
bool operator ==(
const typename iterator_traits <BidIt >:: value_type&,
const sub_match <BidIt >&);
template <class BidIt>
bool operator !=(
const typename iterator_traits <BidIt >:: value_type&,
const sub_match <BidIt >&);
template <class BidIt>
bool operator <(
const typename iterator_traits <BidIt >:: value_type&,
const sub_match <BidIt >&);
template <class BidIt>
bool operator <=(
const typename iterator_traits <BidIt >:: value_type&,
const sub_match <BidIt >&);
template <class BidIt>
bool operator>(
const typename iterator_traits <BidIt >:: value_type&,
const sub_match <BidIt >&);
template <class BidIt>
bool operator>=(
const typename iterator_traits <BidIt >:: value_type&,
const sub_match <BidIt >&);
template <class BidIt>
bool operator ==( const sub_match <BidIt >&,
const typename iterator_traits <BidIt >:: value_type &);
template <class BidIt>
bool operator !=( const sub_match <BidIt >&,
const typename iterator_traits <BidIt >:: value_type &);
template <class BidIt>
bool operator <( const sub_match <BidIt >&,
const typename iterator_traits <BidIt >:: value_type &);
template <class BidIt>
bool operator <=( const sub_match <BidIt >&,
const typename iterator_traits <BidIt >:: value_type &);
template <class BidIt>
bool operator>( const sub_match <BidIt >&,
const typename iterator_traits <BidIt >:: value_type &);
template <class BidIt>
bool operator>=( const sub_match <BidIt >&,
const typename iterator_traits <BidIt >:: value_type &);
} }
<unordered_set>
Synopsisnamespace std { // C++ standard library
namespace tr1 { // TR1 additions
// CLASS TEMPLATE unordered_set
template < class Key,
class Hash = hash <Key>,
class Pred = equal_to <Key >,
class Alloc = allocator <Key >>
class unordered_set ;
// CLASS TEMPLATE unordered_multiset
template <class Key,
class Hash = hash <Key >,
class Pred = equal_to <Key >,
class Alloc = allocator <Key >>
class unordered_multiset ;
// FUNCTION TEMPLATES swap
template <class Key, class Hash, class Pred, class Alloc>
void swap (unordered_set (Key, Hash, Pred, Alloc>& left,
unordered_set (Key, Hash, Pred, Alloc>& right);
template <class Key, class Hash, class Pred, class Alloc>
void swap ( unordered_multiset (Key, Hash, Pred, Alloc>& left,
unordered_multiset (Key, Hash, Pred, Alloc>& right);
// CLASS TEMPLATE unordered_set
template <class Key,
class Hash = hash <Key >,
class Pred = equal_to <Key >,
class Alloc = allocator <Key >>
class unordered_set {
public :
// NESTED TYPES
typedef Key key_type ;
typedef Hash hasher ;
typedef Pred key_equal ;
typedef Key value_type ;
typedef Alloc allocator_type ;
typedef Alloc :: pointer pointer ;
typedef Alloc :: const_pointer const_pointer ;
typedef Alloc :: reference reference ;
typedef Alloc :: const_reference const_reference ;
typedef T0 iterator ;
typedef T1 const_iterator ;
typedef T2 local_iterator ;
typedef T3 const_local_iterator ;
typedef T4 size_type ;
typedef T5 difference_type ;
// CONSTRUCTING AND ASSIGNING
explicit unordered_set (
size_type n = n0 , // implementation-defined
const hasher & h = hasher (),
const key_equal & comp = key_equal (),
const allocator_type & alloc = allocator_type ());
template <class InIt>
unordered_set (InIt first, InIt last,
size_type n = n0 , // implementation-defined
const hasher & h = hasher (),
const key_equal & comp = key_equal (),
const allocator_type & alloc = allocator_type ());
unordered_set (const unordered_set & right);
unordered_set & operator= (const unordered_set & right );
// MODIFYING
pair <iterator, bool> insert (const value_type & val);
iterator insert (
iterator where, const value_type & val);
const_iterator insert (
const_iterator where, const value_type& val);
template <class InIt>
void insert (InIt first, InIt last);
iterator erase (iterator where);
const_iterator erase ( const_iterator where);
size_type erase (const Key & key);
iterator erase (
iterator first, iterator last);
const_iterator erase (
const_iterator first, const_iterator last);
void clear ();
void swap (unordered_set & right);
// ITERATING
iterator begin ();
iterator end ();
const_iterator begin () const;
const_iterator end () const ;
// SEARCHING
iterator find (const Key & key);
const_iterator find (const Key & key) const;
size_type count (const Key & key) const;
pair <iterator, iterator>
equal_range (const Key & key);
pair <const_iterator, const_iterator>
equal_range (const Key & key) const;
// QUERYING
size_type size () const ;
size_type max_size () const;
bool empty () const;
allocator_type get_allocator () const;
hasher hash_function () const ;
key_equal key_eq () const ;
// TUNING
local_iterator begin (size_type n);
const_local_iterator begin (size_type n) const;
local_iterator end (size_type n);
const_local_iterator end (size_type n) const ;
size_type bucket_count () const ;
size_type max_bucket_count () const ;
size_type bucket_size (size_type n) const;
size_type bucket (const key_type & val) const ;
float load_factor () const ;
float max_load_factor () const;
void max_load_factor (float fact);
void rehash (size_type n);
};
// CLASS TEMPLATE unordered_multiset
template <class Key,
class Ty,
class Hash = hash <Key >,
class Pred = equal_to <Key >,
class Alloc = allocator <Key >
class unordered_multiset {
// CONTENTS ARE THE SAME AS unordered_set
};
} }
<unordered_map>
Synopsisnamespace std { // C++ standard library
namespace tr1 { // TR1 additions
// CLASS TEMPLATE unordered_map
template <class Key, class Ty,
class Hash = hash <Key>,
class Pred = equal_to <Key>,
class Alloc = allocator <pair <const Key, Ty>>>
class unordered_map ;
// CLASS TEMPLATE unordered_multimap
template <class Key, class Ty,
class Hash = hash <Key>,
class Pred = equal_to <Key>,
class Alloc = allocator <pair <const Key, Ty>>>
class unordered_multimap ;
// FUNCTION TEMPLATES swap
template <class Key, class Ty, class Hash,
class Pred, class Alloc>
void swap (unordered_map (Key, Ty, Hash, Pred, Alloc>& left,
unordered_map (Key, Ty, Hash, Pred, Alloc>& right);
template <class Key, class Ty, class Hash, class Pred,
class Alloc>
void swap (
unordered_multimap (Key, Ty, Hash, Pred, Alloc>& left,
unordered_multimap (Key, Ty, Hash, Pred, Alloc>& right);
// CLASS TEMPLATE unordered_map
template <class Key,
class Ty,
class Hash = hash <Key>,
class Pred = equal_to <Key>,
class Alloc = allocator <pair <const Key, Ty>>>
class unordered_map {
public :
// NESTED TYPES
typedef Key key_type ;
typedef Hash hasher ;
typedef Pred key_equal ;
typedef pair <const Key, Ty> value_type ;
typedef Ty mapped_type ;
typedef Alloc allocator_type ;
typedef Alloc :: pointer pointer ;
typedef Alloc :: const_pointer const_pointer ;
typedef Alloc :: reference reference ;
typedef Alloc :: const_reference const_reference ;
typedef T0 iterator ;
typedef T1 const_iterator ;
typedef T2 local_iterator ;
typedef T3 const_local_iterator ;
typedef T4 size_type ;
typedef T5 difference_type ;
// CONSTRUCTING AND ASSIGNING
explicit unordered_map (
size_type n = n0, // implementation-defined
const hasher & h = hasher (),
const key_equal & comp = key_equal (),
const allocator_type & alloc = allocator_type ());
template <class InIt>
unordered_map (InIt first, InIt last,
size_type n = n0, // implementation-defined
const hasher & h = hasher (),
const key_equal & comp = key_equal (),
const allocator_type & alloc = allocator_type ());
unordered_map (const unordered_map & right);
unordered_map & operator= (const unordered_map & right);
// MODIFYING
pair <iterator, bool> insert (const value_type & val);
iterator insert (
iterator where, const value_type & val);
const_iterator insert (
const_iterator where, const value_type& val);
template <class InIt>
void insert (InIt first, InIt last);
iterator erase (iterator where);
const_iterator erase ( const_iterator where);
size_type erase (const Key & keyval);
iterator erase (
iterator first, iterator last);
const_iterator erase (
const_iterator first, const_iterator last);
void clear ();
void swap (unordered_map & right);
// ITERATING
iterator begin ();
iterator end ();
const_iterator begin () const;
const_iterator end () const ;
// SEARCHING
iterator find (const Key & keyval);
const_iterator find (const Key & keyval) const;
size_type count (const Key & keyval) const;
pair <iterator, iterator>
equal_range (const Key & keyval);
pair <const_iterator, const_iterator>
equal_range (const Key & keyval) const;
mapped_type & operator []( const Key & keyval);
const mapped_type & operator []( const Key & keyval) const;
// QUERYING
size_type size () const ;
size_type max_size () const;
bool empty () const;
allocator_type get_allocator () const;
hasher hash_function () const ;
key_equal key_eq () const ;
// TUNING
local_iterator begin (size_type n);
const_local_iterator begin (size_type n) const;
local_iterator end (size_type n);
const_local_iterator end (size_type n) const ;
size_type bucket_count () const;
size_type max_bucket_count () const ;
size_type bucket_size (size_type n) const;
size_type bucket (const key_type & val) const ;
float load_factor () const ;
float max_load_factor () const ;
void max_load_factor (float fact);
void rehash (size_type n);
};
// CLASS TEMPLATE unordered_multimap
template <class Key,
class Ty,
class Hash = hash <Key>,
class Pred = equal_to <Key>,
class Alloc = allocator <pair <const Key, Ty>>>
class unordered_multimap {
// CONTENTS ARE THE SAME AS unordered_map WITHOUT operator[]
};
} }
<float.h>
Synopsis# define FLT_RADIX <# if expression >= 2 >
# define FLT_ROUNDS < integer rvalue >
# define FLT_EVAL_METHOD <# if expression >
# define DECIMAL_DIG <# if expression >= 10 >
# define DBL_DIG <# if expression >= 10 >
# define DBL_EPSILON < double constant <= 10-9 >
# define DBL_MANT_DIG <# if expression >
# define DBL_MAX < double constant >= 1037 >
# define DBL_MAX_10_EXP <# if expression >= 37 >
# define DBL_MAX_EXP <# if expression >
# define DBL_MIN < double constant <= 10-37 >
# define DBL_MIN_10_EXP <# if expression <= -37 >
# define DBL_MIN_EXP <# if expression >
# define FLT_DIG <# if expression >= 6 >
# define FLT_EPSILON < float constant <= 10-5 >
# define FLT_MANT_DIG <# if expression >
# define FLT_MAX < float constant >= 1037 >
# define FLT_MAX_10_EXP <# if expression >= 37 >
# define FLT_MAX_EXP <# if expression >
# define FLT_MIN < float constant <= 10-37 >
# define FLT_MIN_10_EXP <# if expression <= -37 >
# define FLT_MIN_EXP <# if expression >
# define LDBL_DIG <# if expression >= 10 >
# define LDBL_EPSILON < long double constant <= 10-9 >
# define LDBL_MANT_DIG <# if expression >
# define LDBL_MAX < long double constant >= 1037 >
# define LDBL_MAX_10_EXP <# if expression >= 37 >
# define LDBL_MAX_EXP <# if expression >
# define LDBL_MIN < long double constant <= 10-37 >
# define LDBL_MIN_10_EXP <# if expression <= -37 >
# define LDBL_MIN_EXP <# if expression >
<math.h>
Synopsis // MACROS
#define HUGE_VAL <double rvalue>
#define HUGE_VALF <float rvalue>
#define HUGE_VALL <long double rvalue>
#define INFINITY <float rvalue>
#define NAN <float rvalue>
#define FP_FAST_FMA <integer constant expression>
#define FP_FAST_FMAF <integer constant expression>
#define FP_FAST_FMAL <integer constant expression>
#define FP_INFINITE <integer constant expression>
#define FP_NAN <integer constant expression>
#define FP_NORMAL <integer constant expression>
#define FP_SUBNORMAL <integer constant expression>
#define FP_ZERO <integer constant expression>
#define FP_ILOGB0 <integer constant expression>
#define FP_ILOGBNAN <integer constant expression>
#define MATH_ERRNO 1
#define MATH_ERREXCEPT 2
#define math_errhandling <int rvalue // [0,4)>
// TYPES
typedef f-type double_t ;
typedef f-type float_t ;
// GENERIC FUNCTION MACROS macros in C, functions in C++
#define signbit (x) <int rvalue>
#define fpclassify (x) <int rvalue>
#define isfinite (x) <int rvalue>
#define isinf (x) <int rvalue>
#define isnan (x) <int rvalue>
#define isnormal (x) <int rvalue>
#define isgreater (x, y) <int rvalue>
#define isgreaterequal (x, y) <int rvalue>
#define isless (x, y) <int rvalue>
#define islessequal (x, y) <int rvalue>
#define islessgreater (x, y) <int rvalue>
#define isunordered (x, y) <int rvalue>
// FUNCTIONS
double abs (double x); // C++ only
float abs (float x); // C++ only
long double abs (long double x); // C++ only
double acos (double x);
float acos (float x); // C++ only
long double acos (long double x); // C++ only
float acosf (float x); // required with C99
long double acosl (long double x); // required with C99
double asin (double x);
float asin (float x); // C++ only
long double asin (long double x); // C++ only
float asinf (float x); // required with C99
long double asinl (long double x); // required with C99
double atan (double x);
float atan (float x); // C++ only
long double atan (long double x); // C++ only
float atanf (float x); // required with C99
long double atanl (long double x); // required with C99
double atan2 (double y, double x);
float atan2 (float y, float x); // C++ only
long double atan2 (long double y, long double x); // C++ only
float atan2f (float y, float x); // required with C99
long double atan2l (long double y,
long double x); // required with C99
double ceil (double x);
float ceil (float x); // C++ only
long double ceil (long double x); // C++ only
float ceilf (float x); // required with C99
long double ceill (long double x); // required with C99
double cos (double x);
float cos (float x); // C++ only
long double cos (long double x); // C++ only
float cosf (float x); // required with C99
long double cosl (long double x); // required with C99
double cosh (double x);
float cosh (float x); // C++ only
long double cosh (long double x); // C++ only
float coshf (float x); // required with C99
long double coshl (long double x); // required with C99
double exp (double x);
float exp (float x); // C++ only
long double exp (long double x); // C++ only
float expf (float x); // required with C99
long double expl (long double x); // required with C99
double fabs (double x);
float fabs (float x); // C++ only
long double fabs (long double x); // C++ only
float fabsf (float x); // required with C99
long double fabsl (long double x); // required with C99
double floor (double x);
float floor (float x); // C++ only
long double floor (long double x); // C++ only
float floorf (float x); // required with C99
long double floorl (long double x); // required with C99
double fmod (double x, double y);
float fmod (float x, float y); // C++ only
long double fmod (long double x, long double y); // C++ only
float fmodf (float x, float y); // required with C99
long double fmodl (long double x,
long double y); // required with C99
double frexp (double x, int * pexp);
float frexp (float x, int *pexp); // C++ only
long double frexp (long double x, int *pexp); // C++ only
float frexpf (float x, int * pexp); // required with C99
long double frexpl (long double x, int *pexp);// required with C99
double ldexp (double x, int ex);
float ldexp (float x, int ex); // C++ only
long double ldexp (long double x, int ex); // C++ only
float ldexpf (float x, int ex); // required with C99
long double ldexpl (long double x, int ex); // required with C99
double log (double x);
float log (float x); // C++ only
long double log (long double x); // C++ only
float logf (float x); // required with C99
long double logl (long double x); // required with C99
double log10 (double x);
float log10 (float x); // C++ only
long double log10 (long double x); // C++ only
float log10f (float x); // required with C99
long double log10l (long double x); // required with C99
double modf (double x, double *pint);
float modf (float x, float *pint); // C++ only
long double modf (long double x,
long double * pint); // C++ only
float modff (float x, float * pint); // required with C99
long double modfl (long double x,
long double * pint); // required with C99
double pow (double x, double y);
float pow (float x, float y); // C++ only
long double pow (long double x, long double y); // C++ only
double pow (double x, int y); // C++ only
float pow (float x, int y); // C++ only
long double pow (long double x, int y); // C++ only
float powf (float x, float y); // required with C99
long double powl (long double x,
long double y); // required with C99
double sin (double x);
float sin (float x); // C++ only
long double sin (long double x); // C++ only
float sinf (float x); // required with C99
long double sinl (long double x); // required with C99
double sinh (double x);
float sinh (float x); // C++ only
long double sinh (long double x); // C++ only
float sinhf (float x); // required with C99
long double sinhl (long double x); // required with C99
double sqrt (double x);
float sqrt (float x); // C++ only
long double sqrt (long double x); // C++ only
float sqrtf (float x); // required with C99
long double sqrtl (long double x); // required with C99
double tan (double x);
float tan (float x); // C++ only
long double tan (long double x); // C++ only
float tanf (float x); // required with C99
long double tanl (long double x); // required with C99
double tanh (double x);
float tanh (float x); // C++ only
long double tanh (long double x); // C++ only
float tanhf (float x); // required with C99
long double tanhl (long double x); // required with C99
double acosh (double x);
float acosh (float x); // C++ only
long double acosh (long double x); // C++ only
float acoshf (float x);
long double acoshl (long double x);
double asinh (double x);
float asinh (float x); // C++ only
long double asinh (long double x); // C++ only
float asinhf (float x);
long double asinhl (long double x);
double atanh (double x);
float atanh (float x); // C++ only
long double atanh (long double x); // C++ only
float atanhf (float x);
long double atanhl (long double x);
double cbrt (double x);
float cbrt (float x); // C++ only
long double cbrt (long double x); // C++ only
float cbrtf (float x);
long double cbrtl (long double x);
double copysign (double x, double y);
float copysign (float x, float y); // C++ only
long double copysign (long double x,
long double y); // C++ only
float copysignf (float x, float y);
long double copysignl (long double x, long double y);
double erf (double x);
float erf (float x); // C++ only
long double erf (long double x); // C++ only
float erff (float x);
long double erfl (long double x);
double erfc (double x);
float erfc (float x); // C++ only
long double erfc (long double x); // C++ only
float erfcf (float x);
long double erfcl (long double x);
double exp2 (double x);
float exp2 (float x); // C++ only
long double exp2 (long double x); // C++ only
float exp2f (float x);
long double exp2l (long double x);
double expm1 (double x);
float expm1 (float x); // C++ only
long double expm1 (long double x); // C++ only
float expm1f (float x);
long double expm1l (long double x);
double fdim (double x, double y);
float fdim (float x, float y); // C++ only
long double fdim (long double x, long double y); // C++ only
float fdimf (float x, float y);
long double fdiml (long double x, long double y);
double fma (double x, double y, double z);
float fma (float x, float y, float z); // C++ only
long double fma (long double x, long double y,
long double z); // C++ only
float fmaf (float x, float y, float z);
long double fmal (long double x, long double y,
long double z);
double fmax (double x, double y);
float fmax (float x, float y); // C++ only
long double fmax (long double x, long double y); // C++ only
float fmaxf (float x, float y);
long double fmaxl (long double x, long double y);
double fmin (double x, double y);
float fmin (float x, float y); // C++ only
long double fmin (long double x, long double y); // C++ only
float fminf (float x, float y);
long double fminl (long double x, long double y);
double hypot (double x, double y);
float hypot (float x, float y); // C++ only
long double hypot (long double x, long double y); // C++ only
float hypotf (float x, float y);
long double hypotl (long double x, long double y);
int ilogb (double x);
int ilogb (float x); // C++ only
int ilogb (long double x); // C++ only
int ilogbf (float x);
int ilogbl (long double x);
double lgamma (double x);
float lgamma (float x); // C++ only
long double lgamma (long double x); // C++ only
float lgammaf (float x);
long double lgammal (long double x);
long long llrint (double x);
long long llrint (float x); // C++ only
long long llrint (long double x); // C++ only
long long llrintf (float x);
long long llrintl (long double x);
long long llround (double x);
long long llround (float x); // C++ only
long long llround (long double x); // C++ only
long long llroundf (float x);
long long llroundl (long double x);
double log1p (double x);
float log1p (float x); // C++ only
long double log1p (long double x); // C++ only
float log1pf (float x);
long double log1pl (long double x);
double log2 (double x);
float log2 (float x); // C++ only
long double log2 (long double x); // C++ only
float log2f (float x);
long double log2l (long double x);
double logb (double x);
float logb (float x); // C++ only
long double logb (long double x); // C++ only
float logbf (float x);
long double logbl (long double x);
long lrint (double x);
long lrint (float x); // C++ only
long lrint (long double x); // C++ only
long lrintf (float x);
long lrintl (long double x);
long lround (double x);
long lround (float x); // C++ only
long lround (long double x); // C++ only
long lroundf (float x);
long lroundl (long double x);
double nan (const char *str);
float nanf (const char *str);
long double nanl (const char *str);
double nearbyint (double x);
float nearbyint (float x); // C++ only
long double nearbyint (long double x); // C++ only
float nearbyintf (float x);
long double nearbyintl (long double x);
double nextafter (double x, double y);
float nextafter (float x, float y); // C++ only
long double nextafter (long double x,
long double y); // C++ only
float nextafterf (float x, float y);
long double nextafterl (long double x, long double y);
double nexttoward (double x, long double y);
float nexttoward (float x, long double y); // C++ only
long double nexttoward (long double x,
long double y); // C++ only
float nexttowardf (float x, long double y);
long double nexttowardl (long double x, long double y);
double remainder (double x, double y);
float remainder (float x, float y); // C++ only
long double remainder (long double x,
long double y); // C++ only
float remainderf (float x, float y);
long double remainderl (long double x, long double y);
double remquo (double x, double y, int *pquo);
float remquo (float x, float y, int *pquo); // C++ only
long double remquo (long double x, long double y,
int *pquo); // C++ only
float remquof (float x, float y, int * pquo);
long double remquol (long double x, long double y,
int *pquo);
double rint (double x);
float rint (float x); // C++ only
long double rint (long double x); // C++ only
float rintf (float x);
long double rintl (long double x);
double round (double x);
float round (float x); // C++ only
long double round (long double x); // C++ only
float roundf (float x);
long double roundl (long double x);
double scalbln (double x, long ex);
float scalbln (float x, long ex); // C++ only
long double scalbln (long double x, long ex); // C++ only
float scalblnf (float x, long ex);
long double scalblnl (long double x, long ex);
double scalbn (double x, int ex);
float scalbn (float x, int ex); // C++ only
long double scalbn (long double x, int ex); // C++ only
float scalbnf (float x, int ex);
long double scalbnl (long double x, int ex);
double tgamma (double x);
float tgamma (float x); // C++ only
long double tgamma (long double x); // C++ only
float tgammaf (float x);
long double tgammal (long double x);
double trunc (double x);
float trunc (float x); // C++ only
long double trunc (long double x); // C++ only
float truncf (float x);
long double truncl (long double x);
double laguerre (unsigned n, double x);
float laguerre (unsigned n, float x); // C++ only
long double laguerre (unsigned n, long double x); // C++ only
float laguerref (unsigned n, float x);
long double laguerrel (unsigned n, long double x);
double assoc_laguerre (unsigned n, unsigned m,
double x);
float assoc_laguerre (unsigned n, unsigned m,
float x); // C++ only
long double assoc_laguerre (unsigned n, unsigned m,
long double x); // C++ only
float assoc_laguerref (unsigned n, unsigned m,
float x);
long double assoc_laguerrel (unsigned n, unsigned m,
long double x);
double legendre (unsigned l, double x);
float legendre (unsigned l, float x); // C++ only
long double legendre (unsigned l, long double x); // C++ only
float legendref (unsigned l, float x);
long double legendrel (unsigned l, long double x);
double assoc_legendre (unsigned l, unsigned m,
double x);
float assoc_legendre (unsigned l, unsigned m,
float x); // C++ only
long double assoc_legendre (unsigned l, unsigned m,
long double x); // C++ only
float assoc_legendref (unsigned l, unsigned m,
float x);
long double assoc_legendrel (unsigned l, unsigned m,
long double x);
double sph_legendre (unsigned l, unsigned m,
double theta);
float sph_legendre (unsigned l, unsigned m,
float theta); // C++ only
long double sph_legendre (unsigned l, unsigned m,
long double theta); // C++ only
float sph_legendref (unsigned l, unsigned m,
float theta);
long double sph_legendrel (unsigned l, unsigned m,
long double theta);
double beta (double x, double y);
float beta (float x, float y); // C++ only
long double beta (long double x, long double y); // C++ only
float betaf (float x, float y);
long double betal (long double x, long double y);
double ellint_1 (double k, double phi);
float ellint_1 (float k, float phi); // C++ only
long double ellint_1 (long double k,
long double phi); // C++ only
float ellint_1f (float k, float phi);
long double ellint_1l (long double k, long double phi);
double ellint_2 (double k, double phi);
float ellint_2 (float k, float phi); // C++ only
long double ellint_2 (long double k,
long double phi); // C++ only
float ellint_2f (float k, float phi);
long double ellint_2l (long double k, long double phi);
double ellint_3 (double k, double nu,
double phi);
float ellint_3 (float k, float nu,
float phi); // C++ only
long double ellint_3 (long double k, long double nu,
long double phi); // C++ only
float ellint_3f (float k, float nu,
float phi);
long double ellint_3l (long double k, long double nu,
long double phi);
double comp_ellint_1 (double k);
float comp_ellint_1 (float k); // C++ only
long double comp_ellint_1 (long double k); // C++ only
float comp_ellint_1f (float k);
long double comp_ellint_1l (long double k);
double comp_ellint_2 (double k);
float comp_ellint_2 (float k); // C++ only
long double comp_ellint_2 (long double k); // C++ only
float comp_ellint_2f (float k);
long double comp_ellint_2l (long double k);
double comp_ellint_3 (double k, double nu);
float comp_ellint_3 (float k, float nu); // C++ only
long double comp_ellint_3 (long double k,
long double nu); // C++ only
float comp_ellint_3f (float k, float nu);
long double comp_ellint_3l (long double k, long double nu);
double cyl_bessel_i (double nu, double x);
float cyl_bessel_i (float nu, float x); // C++ only
long double cyl_bessel_i (long double nu,
long double x); // C++ only
float cyl_bessel_if (float nu, float x);
long double cyl_bessel_il (long double nu, long double x);
double cyl_bessel_j (double nu, double x);
float cyl_bessel_j (float nu, float x); // C++ only
long double cyl_bessel_j (long double nu,
long double x); // C++ only
float cyl_bessel_jf (float nu, float x);
long double cyl_bessel_jl (long double nu, long double x);
double cyl_bessel_k (double nu, double x);
float cyl_bessel_k (float nu, float x); // C++ only
long double cyl_bessel_k (long double nu,
long double x); // C++ only
float cyl_bessel_kf (float nu, float x);
long double cyl_bessel_kl (long double nu, long double x);
double sph_bessel (unsigned n, double x);
float sph_bessel (unsigned n, float x); // C++ only
long double sph_bessel (unsigned n, long double x); // C++ only
float sph_besself (unsigned n, float x);
long double sph_bessell (unsigned n, long double x);
double cyl_neumann (double nu, double x);
float cyl_neumann (float nu, float x); // C++ only
long double cyl_neumann (long double nu,
long double x); // C++ only
float cyl_neumannf (float nu, float x);
long double cyl_neumannl (long double nu, long double x);
double sph_neumann (unsigned n, double x);
float sph_neumann (unsigned n, float x); // C++ only
long double sph_neumann (unsigned n,
long double x); // C++ only
float sph_neumannf (unsigned n, float x);
long double sph_neumannl (unsigned n, long double x);
double expint (double x);
float expint (float x); // C++ only
long double expint (long double x); // C++ only
float expintf (float x);
long double expintl (long double x);
double hermite (unsigned n, double x);
float hermite (unsigned n, float x); // C++ only
long double hermite (unsigned n, long double x); // C++ only
float hermitef (unsigned n, float x);
long double hermitel (unsigned n, long double x);
double riemann_zeta (double x);
float riemann_zeta (float x); // C++ only
long double riemann_zeta (long double x); // C++ only
float riemann_zetaf (float x);
long double riemann_zetal (long double x);
<functional>
Synopsisnamespace std {
template <class Arg, class Result>
struct unary_function ;
template <class Arg1, class Arg2, class Result>
struct binary_function ;
template <class Ty>
struct plus ;
template <class Ty>
struct minus ;
template <class Ty>
struct multiplies ;
template <class Ty>
struct divides ;
template <class Ty>
struct modulus ;
template <class Ty>
struct negate ;
template <class Ty>
struct equal_to ;
template <class Ty>
struct not_equal_to ;
template <class Ty>
struct greater ;
template <class Ty>
struct less ;
template <class Ty>
struct greater_equal ;
template <class Ty>
struct less_equal ;
template <class Ty>
struct logical_and ;
template <class Ty>
struct logical_or ;
template <class Ty>
struct logical_not ;
template <class Fn1>
struct unary_negate ;
template <class Fn2>
struct binary_negate ;
template <class Fn2>
class binder1st ;
template <class Fn2>
class binder2nd ;
template <class Arg, class Result>
class pointer_to_unary_function ;
template <class Arg1, class Arg2, class Result>
class pointer_to_binary_function ;
template <class Result, class Ty>
struct mem_fun_t ;
template <class Result, class Ty, class Arg>
struct mem_fun1_t ;
template <class Result, class Ty>
struct const_mem_fun_t ;
template <class Result, class Ty, class Arg>
struct const_mem_fun1_t ;
template <class Result, class Ty>
struct mem_fun_ref_t ;
template <class Result, class Ty, class Arg>
struct mem_fun1_ref_t ;
template <class Result, class Ty>
struct const_mem_fun_ref_t ;
template <class Result, class Ty, class Arg>
struct const_mem_fun1_ref_t ;
// TEMPLATE FUNCTIONS
template <class Fn1>
unary_negate <Fn1> not1 (const Fn1 & func);
template <class Fn2>
binary_negate <Fn2> not2 (const Fn2 & func);
template <class Fn2, class Ty>
binder1st <Fn2> bind1st (const Fn2 & func, const Ty& left);
template <class Fn2, class Ty>
binder2nd <Fn2> bind2nd (
const Fn2 & func, const Ty& right);
template <class Arg, class Result>
pointer_to_unary_function <Arg, Result>
ptr_fun (Result (*)( Arg));
template <class Arg1, class Arg2, class Result>
pointer_to_binary_function <Arg1, Arg2, Result>
ptr_fun (Result (*)( Arg1, Arg2));
template <class Result, class Ty>
mem_fun_t <Result, Ty> mem_fun (Result (Ty::* pm)());
template <class Result, class Ty, class Arg>
mem_fun1_t <Result, Ty, Arg> mem_fun (
Result (Ty::* pm)(Arg left));
template <class Result, class Ty>
const_mem_fun_t <Result, Ty> mem_fun (
Result (Ty::* pm)() const);
template <class Result, class Ty, class Arg>
const_mem_fun1_t <Result, Ty, Arg> mem_fun (
Result (Ty::* pm)(Arg left) const);
template <class Result, class Ty>
mem_fun_ref_t <Result, Ty> mem_fun_ref (
Result (Ty::* pm)());
template <class Result, class Ty, class Arg>
mem_fun1_ref_t <Result, Ty, Arg>
mem_fun_ref (Result (Ty::* pm)(Arg left));
template <class Result, class Ty>
const_mem_fun_ref_t <Result, Ty> mem_fun_ref (
Result (Ty::* pm)() const);
template <class Result, class Ty, class Arg>
const_mem_fun1_ref_t <Result, Ty, Arg>
mem_fun_ref (Result (Ty::* pm)(Arg left) const);
namespace tr1 {
// REFERENCE WRAPPERS
template <class Ty> reference_wrapper <Ty>
ref (Ty&);
template <class Ty> reference_wrapper <Ty>
ref (reference_wrapper <Ty>&);
template <class Ty> reference_wrapper <const Ty>
cref (const Ty&);
template <class Ty> reference_wrapper <const Ty>
cref (const reference_wrapper <Ty>&);
template <class Ty>
struct reference_wrapper ;
// FUNCTION OBJECT RETURN TYPES
template <class Ty>
struct result_of ;
// ENHANCED MEMBER POINTER ADAPTER
template <class Ret, class Ty>
unspecified mem_fn (Ret Ty ::*);
// FUNCTION OBJECT WRAPPERS
class bad_function_call ;
template <class Fty>
class function ;
template <class Fty>
void swap (function <Fty>& f1,
function <Fty>& f2);
template <class Fty>
bool operator!= (const function <Fty>&,
null_ptr_type);
template <class Fty>
bool operator!= (null_ptr_type,
const function <Fty>&);
template <class Fty>
bool operator== (const function <Fty>&,
null_ptr_type);
template <class Fty>
bool operator== (null_ptr_type,
const function <Fty>&);
// ENHANCED BINDERS
template <class Fty, class T1, class T2, …, class TN>
unspecified bind (Fty, T1, T2, …, TN);
template <class Ret,
class Fty, class T1, class T2, …, class TN>
unspecified bind (Fty, T1, T2, …, TN);
template <class Ret,
class Ty, class T1, class T2, …, class TN>
unspecified bind (Ret Ty::*, T1, T2, …, TN);
template <class Ty>
struct is_bind_expression ;
template <class Ty>
struct is_placeholder ;
namespace placeholders {
extern unspecified _1 ; // _2, _3, … _M
}// namespace placeholders
} // namespace tr1
} // namespace std
<memory>
Synopsisnamespace std {
template <class Ty>
class allocator ;
template <>
class allocator<void> ;
template <class FwdIt, class Ty>
class raw_storage_iterator ;
template <class Ty>
class auto_ptr ;
template <class Ty>
class auto_ptr_ref ;
// TEMPLATE OPERATORS
template <class Ty>
bool operator== (allocator <Ty>& left,
allocator <Ty>& right);
template <class Ty>
bool operator!= (allocator <Ty>& left,
allocator <Ty>& right);
// TEMPLATE FUNCTIONS
template <class Ty>
pair <Ty *, ptrdiff_t>
get_temporary_buffer (ptrdiff_t count);
template <class Ty>
void return_temporary_buffer (Ty *pbuf);
template <class InIt, class FwdIt>
FwdIt uninitialized_copy (InIt first, InIt last,
FwdIt dest);
template <class FwdIt, class Ty>
void uninitialized_fill (FwdIt first, FwdIt last,
const Ty& val);
template <class FwdIt, class Size, class Ty>
void uninitialized_fill_n (FwdIt first, Size count,
const Ty& val);
namespace tr1 {
// TEMPLATE SHARED POINTERS
template <class Ty>
class shared_ptr ;
template <class Ty1, class Ty2>
bool operator== (const shared_ptr <Ty1>&,
const shared_ptr <Ty2>&);
template <class Ty1, class Ty2>
bool operator!= (const shared_ptr <Ty1>&,
const shared_ptr <Ty2>&);
template <class Ty1, class Ty2>
bool operator< (const shared_ptr <Ty1>&,
const shared_ptr <Ty2>&);
template <class Elem, class Tr, class Ty>
std :: basic_ostream <Elem, Tr>& operator<< (
std :: basic_ostream <Elem, Tr>&, const shared_ptr <Ty>&);
template <class Ty>
void swap (shared_ptr <Ty>&, shared_ptr <Ty>&);
template <class D, class Ty>
D *get_deleter (const shared_ptr <Ty>&);
// TEMPLATE WEAK POINTERS
template <class Ty>
class weak_ptr ;
template <class Ty1, class Ty2>
bool operator< (const weak_ptr <Ty1>&,
const weak_ptr <Ty2>&);
template <class Ty>
void swap (weak_ptr <Ty>&, weak_ptr <Ty>&);
// UTILITY TEMPLATE CLASSES
template <class Ty>
class enable_shared_from_this ;
class bad_weak_ptr ;
// TEMPLATE FUNCTIONS
template <class Ty, class Other>
shared_ptr <Ty> const_pointer_cast (
const shared_ptr <Other>&);
template <class Ty, class Other>
shared_ptr <Ty> dynamic_pointer_cast (
const shared_ptr <Other>&);
template <class Ty, class Other>
shared_ptr <Ty> static_pointer_cast (
const shared_ptr <Other>&);
} // namespace tr1
} // namespace std
<utility>
Synopsisnamespace std {
template <class T, class Ty2>
struct pair ;
// TEMPLATE FUNCTIONS
template <class Ty1, class Ty2>
pair <Ty, Ty2> make_pair (Ty1 val1, Ty2 val2);
template <class Ty1, class Ty2>
bool operator== (const pair <Ty, Ty2>& left,
const pair <Ty1, Ty2>& right);
template <class Ty1, class Ty2>
bool operator!= (const pair <Ty, Ty2>& left,
const pair <Ty1, Ty2>& right);
template <class Ty1, class Ty2>
bool operator< (const pair <Ty, Ty2>& left,
const pair <Ty1, Ty2>& right);
template <class Ty1, class Ty2>
bool operator> (const pair <Ty1, Ty2>& left,
const pair <Ty1, Ty2>& right);
template <class Ty1, class Ty2>
bool operator<= (const pair <Ty1, Ty2>& left,
const pair <Ty1, Ty2>& right);
template <class Ty1, class Ty2>
bool operator>= (const pair <Ty1, Ty2>& left,
const pair <Ty1, Ty2>& right);
namespace rel_ops {
template <class Ty>
bool operator!= (const Ty& left, const Ty& right);
template <class Ty>
bool operator<= (const Ty& left, const Ty& right);
template <class Ty>
bool operator> (const Ty& left, const Ty& right);
template <class Ty>
bool operator>= (const Ty& left, const Ty& right);
} // namespace rel ops
namespace tr1 {
template <int Idx, class T1, class T2>
RI& get (pair <T1, T2>& pr);
template <int Idx, class T1, class T2>
const RI& get (const pair <T1, T2>& pr);
template <class T1, class T2>
class tuple_element <0, pair <T1, T2>>;
template <class T1, class T2>
class tuple_element <1, pair <T1, T2>>;
template <class T1, class T2>
class tuple_size <pair <T1, T2>>;
} // namespace tr1
} // namespace std
3.138.36.38