par::cpp Namespace Reference

A namespace that is related to C++ issues. More...


Classes

class  __ABT
 A trick class to get basic operators regardess whether or not T is an array type or not.
class  __ABT< T[1]>
class  __ABT< T[n]>
 A trick class to get type conversion.
class  __ABTCopy
class  __ABTCopy< T[1]>
class  __ABTCopy< T[n]>
class  __ABTVoid
class  __ABTVoid< T[1]>
class  __ABTVoid< T[n]>
class  __print1< __print_tmp< T > >
class  __print1< char const [] >
class  __print1< char const [d] >
class  __print1< char[] >
class  __print1< char[d] >
class  __print1< T const [1] >
class  __print1< T const [d] >
class  __print1< T[1] >
class  __print1< T[d] >
class  __print2
class  __print2< format, T1 >
class  __print3
class  __print3< format, T1, T2 >
class  __print4
class  __print4< format, T1, T2, T3 >
class  __print5
class  __print5< format, T1, T2, T3, T4 >
class  __print6
class  __print6< format, T1, T2, T3, T4, T5 >
class  __print7
class  __print7< format, T1, T2, T3, T4, T5, T6 >
class  __print8
class  __print8< format, T1, T2, T3, T4, T5, T6, T7 >
class  __print9
class  __print9< format, T1, T2, T3, T4, T5, T6, T7, T8 >
class  __print_enum< bool >
class  __print_enum< par::cpp::mode_t >
class  __print_enum< par::cpp::nonchar >
class  __print_tmp
class  __printA< format, T1, T2, T3, T4, T5, T6, T7, T8, T9 >
class  __printB< format, T1, T2, T3, T4, T5, T6, T7, T8, T9, TA >
struct  __search_t< T[1] >
struct  __search_t< T[n] >
struct  _fastrcp
struct  _half_of< uint16_t >
struct  _half_of< uint32_t >
struct  _half_of< uint64_t >
struct  _is_signed
struct  _max_min_of
struct  _max_min_of< bool >
struct  _max_min_of< char >
struct  _max_min_of< int16_t >
struct  _max_min_of< int32_t >
struct  _max_min_of< int64_t >
struct  _max_min_of< int8_t >
struct  _max_min_of< uint16_t >
struct  _max_min_of< uint32_t >
struct  _max_min_of< uint64_t >
struct  _max_min_of< uint8_t >
class  _monotone
 A function class for monotone subsequences according to predicate predOP, i.e such that each consecutive pair fulfills predicate predOP.
struct  _plist
struct  _prod
struct  _registerline
struct  _signed_of< char >
struct  _signed_of< long >
struct  _signed_of< schar >
struct  _signed_of< short >
struct  _signed_of< signed >
struct  _signed_of< uchar >
struct  _signed_of< ulong >
struct  _signed_of< unsigned >
struct  _signed_of< ushort >
struct  _size_of
struct  _size_of< T const >
struct  _size_of< T const volatile >
struct  _size_of< T volatile >
struct  _size_of< void >
struct  _templ_vecAnd< T, d, false >
struct  _templ_vecAnd< T, d, true >
struct  _templ_vecAssign< T, d, false >
struct  _templ_vecAssign< T, d, true >
struct  _templ_vecBitand< T, d, false >
struct  _templ_vecBitand< T, d, true >
struct  _templ_vecBitor< T, d, false >
struct  _templ_vecBitor< T, d, true >
struct  _templ_vecBitxor< T, d, false >
struct  _templ_vecBitxor< T, d, true >
struct  _templ_vecCompl< T, d, false >
struct  _templ_vecCompl< T, d, true >
struct  _templ_vecDivide< T, d, false >
struct  _templ_vecDivide< T, d, true >
struct  _templ_vecEq< T, d, false >
struct  _templ_vecEq< T, d, true >
struct  _templ_vecMax< T, d, false >
struct  _templ_vecMax< T, d, true >
struct  _templ_vecMin< T, d, false >
struct  _templ_vecMin< T, d, true >
struct  _templ_vecMinus< T, d, false >
struct  _templ_vecMinus< T, d, true >
struct  _templ_vecModulo< T, d, false >
struct  _templ_vecModulo< T, d, true >
struct  _templ_vecMultiply< T, d, false >
struct  _templ_vecMultiply< T, d, true >
struct  _templ_vecNeg< T, d, false >
struct  _templ_vecNeg< T, d, true >
struct  _templ_vecNot< T, d, false >
struct  _templ_vecNot< T, d, true >
struct  _templ_vecOr< T, d, false >
struct  _templ_vecOr< T, d, true >
struct  _templ_vecPlus< T, d, false >
struct  _templ_vecPlus< T, d, true >
struct  _templ_vecSLeft< T, d, false >
struct  _templ_vecSLeft< T, d, true >
struct  _templ_vecSRight< T, d, false >
struct  _templ_vecSRight< T, d, true >
struct  _templ_vecSum< T, d, false >
struct  _templ_vecSum< T, d, true >
struct  _templ_vecXor< T, d, false >
struct  _templ_vecXor< T, d, true >
struct  _template_merge
struct  _template_merge< T, predOp, 1, 1 >
struct  _template_merge< T, predOp, 1, n1 >
struct  _template_merge< T, predOp, n0, 1 >
struct  _template_sortOP
 same as op(T const*, size_t) but only returns if the predicate is fulfilled by all consecutive pairs.
struct  _template_sortOP< T, predOp, 1 >
struct  _template_sortOP< T, predOp, 2 >
struct  _template_sortOP< T, predOp, 3 >
struct  _Tn
 A dummy type used in PAR_ASIZE for type checking.
struct  _traditional
struct  _type_attribute_
struct  _type_attribute_< T const >
struct  _type_attribute_< T const volatile >
struct  _type_attribute_< T volatile >
class  aqueue
 A simple round robin implementation of a queue of T. More...
class  aqueue< 0, T >
 Specialization of a fixed length queue over type T for which the length can be chosen dynamically on construction. More...
struct  assignAnd
 Wrapper for binary assignment operation with the logical-and. More...
struct  assignBitand
 Wrapper for binary assignment operation with operator&=(T const& ). More...
struct  assignBitor
 Wrapper for binary assignment operation with operator|=(T const& ). More...
struct  assignBitxor
 Wrapper for binary assignment operation with operator^=(T const& ). More...
struct  assignConstruct
 Wrapper for unary and binary construction with the void-constructor or copy-constructor respectively. More...
struct  assignDec
 Wrapper for unary operation with operator++(T&). More...
struct  assignDestruct
 Wrapper for unary destruction operation. More...
struct  assignDivide
 Wrapper for binary assignment operation with operator/=(T const& ). More...
struct  assignEq
 Wrapper for binary assignment operation with test for equallity. More...
struct  assignInc
 Wrapper for unary operation with operator++(T&). More...
struct  assignMax
 Wrapper for binary assignment operation with of the maximum of two values. More...
struct  assignMin
 Wrapper for binary assignment operation with of the minimum of two values. More...
struct  assignMinus
 Wrapper for binary assignment operation with operator-=(T const& ). More...
struct  assignModulo
 Wrapper for binary assignment operation with operator%=(T const& ). More...
struct  assignMultiply
 Wrapper for binary assignment operation with operator*=(T const& ). More...
struct  assignNeg
 Wrapper for unary and binary operation with operator-(T&). More...
struct  assignNot
 Wrapper for unary and binary operation with operator!(T&). More...
struct  assignOr
 Wrapper for binary assignment operation with the logical-or. More...
struct  assignPlus
 Wrapper for unary and binary operation with operator+(T&). More...
struct  assignSLeft
 Wrapper for binary assignment operation with operator<<=(T const& ). More...
struct  assignSRight
 Wrapper for binary assignment operation with operator>>=(T const& ). More...
struct  assignSum
 Wrapper for binary assignment operation with operator+=(T const& ). More...
struct  assignTo
 Wrapper for binary assignment operation with operator=(T const& ). More...
struct  assignZero
 Wrapper for unary assignment with Zero. More...
struct  bckgd
 Start printing with background color x. More...
class  block
 An internal type to handle any data structure of size N. More...
struct  color
 Start printing in color x. More...
struct  double64_t
 A wrapped union type to access a 64 bit double through different angles. More...
class  dqueue
 A simple round-robin queue with a maximal size that is determined at construction time. More...
class  edge
 dim dimensional edges, a basic data structure for graphs More...
struct  enumbits
struct  error
 Struct that all of par::cpp uses to throw errors. More...
struct  float32_t
 A wrapped union type to access a 32 bit float through different angles. More...
class  garbage
 The garbage collection engine for data structure T. More...
class  garbage< typename par::cpp::block< N > >
 The garbage collection engine for data structures of size N. More...
class  hashfunc
 An interface that uses a predefined state to hash integers effectively. More...
class  id
 A universal type to identify objects. More...
class  link
 Store a number in a word by keeping b bits clean for some application flags. More...
class  lnew_constructor
 These classes are used by LNEW() to effectively do the allocation and construction of the individual elements in the new vector. More...
class  lnew_stacker
 Auxiliary data type for LNEW() to anchor vector allocation and de-allocation on the stack. More...
class  min_max_t
 An auxiliary class to be able to partially instantiate the corresponding functions. More...
class  mix
 A two-way hash function for integer type T. More...
class  opt_med_cl
class  opt_med_cl< T, 4 >
class  opt_med_cl< T, 5 >
class  partition
 Generate one bucket of a partition of integers randomly with twist twist. More...
class  partition< 0, gT, lT >
 Generate one bucket of a partition of integers deterministicly. More...
class  predEQ
 a wrapper class for operator== More...
class  predEQ< T[1] >
struct  predEQ< T[n] >
class  predEV
 a wrapper class for the equivalence operator (a <= b && a >= b). More...
class  predEV< T[1] >
struct  predEV< T[n] >
class  predGE
 a wrapper class for operator>= More...
class  predGE< T[1] >
class  predGE< T[n] >
class  predGT
 a wrapper class for operator> More...
class  predGT< T[1] >
class  predGT< T[n] >
class  predLE
 a wrapper class for operator<= More...
class  predLE< T[1] >
class  predLE< T[n] >
class  predLT
 a wrapper class for operator< More...
class  predLT< T[1] >
class  predLT< T[n] >
class  predNE
 a wrapper class for operator!= More...
class  predNE< T[1] >
struct  predNE< T[n] >
class  predNV
 a wrapper class for the equivalence operator (a < b || a > b). More...
class  predNV< T[1] >
struct  predNV< T[n] >
class  primes
 Provides us with a large number of different prime numbers. More...
class  quit_action_close
 Wrapper type to glue an action to a specific type. More...
class  quit_action_close< T * >
class  quit_action_close< void >
class  quit_action_lock
 Wrapper type to glue an action to a specific type. More...
class  quit_action_lock< T * >
class  quit_action_lock< void >
class  quit_action_open
 Wrapper type to glue an action to a specific type. More...
class  quit_action_open< T * >
class  quit_action_open< void >
class  quit_action_rdlock
 Wrapper type to glue an action to a specific type. More...
class  quit_action_rdlock< T * >
class  quit_action_rdlock< void >
class  quit_action_reclaim
 Wrapper type to glue an action to a specific type. More...
class  quit_action_reclaim< T * >
class  quit_action_reclaim< void >
class  quit_action_release
 Wrapper type to glue an action to a specific type. More...
class  quit_action_release< T * >
class  quit_action_release< void >
class  quit_action_require
 Wrapper type to glue an action to a specific type. More...
class  quit_action_require< T * >
class  quit_action_require< void >
class  quit_action_unlock
 Wrapper type to glue an action to a specific type. More...
class  quit_action_unlock< T * >
class  quit_action_unlock< void >
class  quit_action_wrlock
 Wrapper type to glue an action to a specific type. More...
class  quit_action_wrlock< T * >
class  quit_action_wrlock< void >
struct  quit_trigger_close
 Associate an action to termination. More...
struct  quit_trigger_lock
 Associate an action to termination. More...
struct  quit_trigger_open
 Associate an action to termination. More...
struct  quit_trigger_rdlock
 Associate an action to termination. More...
struct  quit_trigger_reclaim
 Associate an action to termination. More...
struct  quit_trigger_release
 Associate an action to termination. More...
struct  quit_trigger_require
 Associate an action to termination. More...
struct  quit_trigger_unlock
 Associate an action to termination. More...
struct  quit_trigger_wrlock
 Associate an action to termination. More...
struct  registerline
class  relptr
 A relocatable pointer type. More...
class  relptr< void >
class  relptr< void const >
class  relptr< void const volatile >
class  relptr< void volatile >
class  relptr_void
 The specialization that implements the main functionality. More...
class  relref
class  relref< T const >
struct  secs
 Interpret a double value as seconds and print it in human perceivable form, ie as years, days, hours etc. More...
class  simplex
 A wrapper class to handle dim dimensional simplices. More...
class  statistic
 Handle a statistic of random variable of base type D. More...
class  statistic2
 A class for two-dimensional statistics. More...
struct  svErr
 Compile time error detection for the par::cpp::subvector functions. More...
class  terminal
 Class wrapper around par::cpp::terminal_rel that does the correct allocations on the heap. More...
class  terminal_rel
 A simple class to draw on a terminal. More...
struct  termpos
 Position the cursor at point (x, y). More...
struct  termup
 Move the cursor up x lines (or down if negative). More...
class  uhash
class  uhash< 0, T >
class  uhash< 1, T >

Typedefs

typedef __print_tmp< char const * > format
 Promote a char const* to a format specification for par::cpp::print.
typedef off_t pair [2]
typedef char str [32]
 An auxiliary `string' type.
typedef void(* void_f )(void)

Enumerations

enum  { theTolerance = 5, largestCase = 25 }
enum  Color {
  Black, Red, Green, Yellow,
  Blue, Magenta, Cyan, White,
  Default
}
 Colors as supported by most terminals. More...
enum  mode_t { modifiable = no_mode, readonly = const_mode, modifiable_volatile = modifiable | volatile_mode, readonly_volatile = const_mode | volatile_mode }
 Data access and persistence modes. More...
enum  nonchar {
  _NUL, _SOH, _STX, _ETX,
  _EOT, _ENQ, _ACK, _BEL,
  _BS, _HT, _LF, _VT,
  _FF, _CR, _SO, _SI,
  _DLE, _DC1, _DC2, _DC3,
  _DC4, _NAK, _SYN, _ETB,
  _CAN, _EM, _SUB, _ESC,
  _FS, _GS, _RS, _US,
  _SP, _EXL, _DQT, _HSH,
  _DOL, _PCT, _AMP, _TK,
  _LPR, _RPR, _AST, _PLS,
  _CMA, _HYP, _PNT, _SLS,
  _CH0, _CH1, _CH2, _CH3,
  _CH4, _CH5, _CH6, _CH7,
  _CH8, _CH9, _CLN, _SCN,
  _LT, _EQ, _GT, _QMK,
  _AT, _CHA, _CHB, _CHC,
  _CHD, _CHE, _CHF, _CHG,
  _CHH, _CHI, _CHJ, _CHK,
  _CHL, _CHM, _CHN, _CHO,
  _CHP, _CHQ, _CHR, _CHS,
  _CHT, _CHU, _CHV, _CHW,
  _CHX, _CHY, _CHZ, _BKT,
  _BSL, _UBKT, _HAT, _USC,
  _BTK, _CHa, _CHb, _CHc,
  _CHd, _CHe, _CHf, _CHg,
  _CHh, _CHi, _CHj, _CHk,
  _CHl, _CHm, _CHn, _CHo,
  _CHp, _CHq, _CHr, _CHs,
  _CHt, _CHu, _CHv, _CHw,
  _CHx, _CHy, _CHz, _BRC,
  _PIP, _UBRC, _TLD, _DEL,
  _NBSP = (0x80 | _SP)
}
 Give names to all 127 ASCII characters. More...

Functions

void * aligned (size_t alignment, size_t size)
template<typename T , unsigned n>
bool all2EQ (T const (&source)[n])
 same as _monotone::all2(T const*, size_t, T const*)
template<typename T >
bool all2EQ (T const *source, size_t len, T const *carry)
 same as _monotone::all2(T const*, size_t, T const*)
template<typename T >
bool all2EQ (T const *source, size_t len)
 same as _monotone::all2(T const*, size_t)
template bool all2EQ (long double const (&source)[5])
template bool all2EQ (long double const (&source)[4])
template bool all2EQ (long double const (&source)[3])
template bool all2EQ (long double const (&source)[2])
template bool all2EQ (long double const (&source)[1])
template bool all2EQ (long double const *source, size_t len, long double const *carry)
template bool all2EQ (long double const *source, size_t len)
template bool all2EQ (double const (&source)[5])
template bool all2EQ (double const (&source)[4])
template bool all2EQ (double const (&source)[3])
template bool all2EQ (double const (&source)[2])
template bool all2EQ (double const (&source)[1])
template bool all2EQ (double const *source, size_t len, double const *carry)
template bool all2EQ (double const *source, size_t len)
template bool all2EQ (float const (&source)[5])
template bool all2EQ (float const (&source)[4])
template bool all2EQ (float const (&source)[3])
template bool all2EQ (float const (&source)[2])
template bool all2EQ (float const (&source)[1])
template bool all2EQ (float const *source, size_t len, float const *carry)
template bool all2EQ (float const *source, size_t len)
template bool all2EQ (unsigned long long const (&source)[5])
template bool all2EQ (unsigned long long const (&source)[4])
template bool all2EQ (unsigned long long const (&source)[3])
template bool all2EQ (unsigned long long const (&source)[2])
template bool all2EQ (unsigned long long const (&source)[1])
template bool all2EQ (unsigned long long const *source, size_t len, unsigned long long const *carry)
template bool all2EQ (unsigned long long const *source, size_t len)
template bool all2EQ (long long const (&source)[5])
template bool all2EQ (long long const (&source)[4])
template bool all2EQ (long long const (&source)[3])
template bool all2EQ (long long const (&source)[2])
template bool all2EQ (long long const (&source)[1])
template bool all2EQ (long long const *source, size_t len, long long const *carry)
template bool all2EQ (long long const *source, size_t len)
template bool all2EQ (ulong const (&source)[5])
template bool all2EQ (ulong const (&source)[4])
template bool all2EQ (ulong const (&source)[3])
template bool all2EQ (ulong const (&source)[2])
template bool all2EQ (ulong const (&source)[1])
template bool all2EQ (ulong const *source, size_t len, ulong const *carry)
template bool all2EQ (ulong const *source, size_t len)
template bool all2EQ (long const (&source)[5])
template bool all2EQ (long const (&source)[4])
template bool all2EQ (long const (&source)[3])
template bool all2EQ (long const (&source)[2])
template bool all2EQ (long const (&source)[1])
template bool all2EQ (long const *source, size_t len, long const *carry)
template bool all2EQ (long const *source, size_t len)
template bool all2EQ (unsigned const (&source)[5])
template bool all2EQ (unsigned const (&source)[4])
template bool all2EQ (unsigned const (&source)[3])
template bool all2EQ (unsigned const (&source)[2])
template bool all2EQ (unsigned const (&source)[1])
template bool all2EQ (unsigned const *source, size_t len, unsigned const *carry)
template bool all2EQ (unsigned const *source, size_t len)
template bool all2EQ (signed const (&source)[5])
template bool all2EQ (signed const (&source)[4])
template bool all2EQ (signed const (&source)[3])
template bool all2EQ (signed const (&source)[2])
template bool all2EQ (signed const (&source)[1])
template bool all2EQ (signed const *source, size_t len, signed const *carry)
template bool all2EQ (signed const *source, size_t len)
template bool all2EQ (ushort const (&source)[5])
template bool all2EQ (ushort const (&source)[4])
template bool all2EQ (ushort const (&source)[3])
template bool all2EQ (ushort const (&source)[2])
template bool all2EQ (ushort const (&source)[1])
template bool all2EQ (ushort const *source, size_t len, ushort const *carry)
template bool all2EQ (ushort const *source, size_t len)
template bool all2EQ (short const (&source)[5])
template bool all2EQ (short const (&source)[4])
template bool all2EQ (short const (&source)[3])
template bool all2EQ (short const (&source)[2])
template bool all2EQ (short const (&source)[1])
template bool all2EQ (short const *source, size_t len, short const *carry)
template bool all2EQ (short const *source, size_t len)
template bool all2EQ (uchar const (&source)[5])
template bool all2EQ (uchar const (&source)[4])
template bool all2EQ (uchar const (&source)[3])
template bool all2EQ (uchar const (&source)[2])
template bool all2EQ (uchar const (&source)[1])
template bool all2EQ (uchar const *source, size_t len, uchar const *carry)
template bool all2EQ (uchar const *source, size_t len)
template bool all2EQ (schar const (&source)[5])
template bool all2EQ (schar const (&source)[4])
template bool all2EQ (schar const (&source)[3])
template bool all2EQ (schar const (&source)[2])
template bool all2EQ (schar const (&source)[1])
template bool all2EQ (schar const *source, size_t len, schar const *carry)
template bool all2EQ (schar const *source, size_t len)
template bool all2EQ (char const (&source)[5])
template bool all2EQ (char const (&source)[4])
template bool all2EQ (char const (&source)[3])
template bool all2EQ (char const (&source)[2])
template bool all2EQ (char const (&source)[1])
template bool all2EQ (char const *source, size_t len, char const *carry)
template bool all2EQ (char const *source, size_t len)
template bool all2EQ (bool const (&source)[5])
template bool all2EQ (bool const (&source)[4])
template bool all2EQ (bool const (&source)[3])
template bool all2EQ (bool const (&source)[2])
template bool all2EQ (bool const (&source)[1])
template bool all2EQ (bool const *source, size_t len, bool const *carry)
template bool all2EQ (bool const *source, size_t len)
template<typename T , unsigned n>
bool all2EV (T const (&source)[n])
 same as _monotone::all2(T const*, size_t, T const*)
template<typename T >
bool all2EV (T const *source, size_t len, T const *carry)
 same as _monotone::all2(T const*, size_t, T const*)
template<typename T >
bool all2EV (T const *source, size_t len)
 same as _monotone::all2(T const*, size_t)
template<typename T , unsigned n>
bool all2GE (T const (&source)[n])
 same as _monotone::all2(T const*, size_t, T const*)
template<typename T >
bool all2GE (T const *source, size_t len, T const *carry)
 same as _monotone::all2(T const*, size_t, T const*)
template<typename T >
bool all2GE (T const *source, size_t len)
 same as _monotone::all2(T const*, size_t)
template bool all2GE (long double const (&source)[5])
template bool all2GE (long double const (&source)[4])
template bool all2GE (long double const (&source)[3])
template bool all2GE (long double const (&source)[2])
template bool all2GE (long double const (&source)[1])
template bool all2GE (long double const *source, size_t len, long double const *carry)
template bool all2GE (long double const *source, size_t len)
template bool all2GE (double const (&source)[5])
template bool all2GE (double const (&source)[4])
template bool all2GE (double const (&source)[3])
template bool all2GE (double const (&source)[2])
template bool all2GE (double const (&source)[1])
template bool all2GE (double const *source, size_t len, double const *carry)
template bool all2GE (double const *source, size_t len)
template bool all2GE (float const (&source)[5])
template bool all2GE (float const (&source)[4])
template bool all2GE (float const (&source)[3])
template bool all2GE (float const (&source)[2])
template bool all2GE (float const (&source)[1])
template bool all2GE (float const *source, size_t len, float const *carry)
template bool all2GE (float const *source, size_t len)
template bool all2GE (unsigned long long const (&source)[5])
template bool all2GE (unsigned long long const (&source)[4])
template bool all2GE (unsigned long long const (&source)[3])
template bool all2GE (unsigned long long const (&source)[2])
template bool all2GE (unsigned long long const (&source)[1])
template bool all2GE (unsigned long long const *source, size_t len, unsigned long long const *carry)
template bool all2GE (unsigned long long const *source, size_t len)
template bool all2GE (long long const (&source)[5])
template bool all2GE (long long const (&source)[4])
template bool all2GE (long long const (&source)[3])
template bool all2GE (long long const (&source)[2])
template bool all2GE (long long const (&source)[1])
template bool all2GE (long long const *source, size_t len, long long const *carry)
template bool all2GE (long long const *source, size_t len)
template bool all2GE (ulong const (&source)[5])
template bool all2GE (ulong const (&source)[4])
template bool all2GE (ulong const (&source)[3])
template bool all2GE (ulong const (&source)[2])
template bool all2GE (ulong const (&source)[1])
template bool all2GE (ulong const *source, size_t len, ulong const *carry)
template bool all2GE (ulong const *source, size_t len)
template bool all2GE (long const (&source)[5])
template bool all2GE (long const (&source)[4])
template bool all2GE (long const (&source)[3])
template bool all2GE (long const (&source)[2])
template bool all2GE (long const (&source)[1])
template bool all2GE (long const *source, size_t len, long const *carry)
template bool all2GE (long const *source, size_t len)
template bool all2GE (unsigned const (&source)[5])
template bool all2GE (unsigned const (&source)[4])
template bool all2GE (unsigned const (&source)[3])
template bool all2GE (unsigned const (&source)[2])
template bool all2GE (unsigned const (&source)[1])
template bool all2GE (unsigned const *source, size_t len, unsigned const *carry)
template bool all2GE (unsigned const *source, size_t len)
template bool all2GE (signed const (&source)[5])
template bool all2GE (signed const (&source)[4])
template bool all2GE (signed const (&source)[3])
template bool all2GE (signed const (&source)[2])
template bool all2GE (signed const (&source)[1])
template bool all2GE (signed const *source, size_t len, signed const *carry)
template bool all2GE (signed const *source, size_t len)
template bool all2GE (ushort const (&source)[5])
template bool all2GE (ushort const (&source)[4])
template bool all2GE (ushort const (&source)[3])
template bool all2GE (ushort const (&source)[2])
template bool all2GE (ushort const (&source)[1])
template bool all2GE (ushort const *source, size_t len, ushort const *carry)
template bool all2GE (ushort const *source, size_t len)
template bool all2GE (short const (&source)[5])
template bool all2GE (short const (&source)[4])
template bool all2GE (short const (&source)[3])
template bool all2GE (short const (&source)[2])
template bool all2GE (short const (&source)[1])
template bool all2GE (short const *source, size_t len, short const *carry)
template bool all2GE (short const *source, size_t len)
template bool all2GE (uchar const (&source)[5])
template bool all2GE (uchar const (&source)[4])
template bool all2GE (uchar const (&source)[3])
template bool all2GE (uchar const (&source)[2])
template bool all2GE (uchar const (&source)[1])
template bool all2GE (uchar const *source, size_t len, uchar const *carry)
template bool all2GE (uchar const *source, size_t len)
template bool all2GE (schar const (&source)[5])
template bool all2GE (schar const (&source)[4])
template bool all2GE (schar const (&source)[3])
template bool all2GE (schar const (&source)[2])
template bool all2GE (schar const (&source)[1])
template bool all2GE (schar const *source, size_t len, schar const *carry)
template bool all2GE (schar const *source, size_t len)
template bool all2GE (char const (&source)[5])
template bool all2GE (char const (&source)[4])
template bool all2GE (char const (&source)[3])
template bool all2GE (char const (&source)[2])
template bool all2GE (char const (&source)[1])
template bool all2GE (char const *source, size_t len, char const *carry)
template bool all2GE (char const *source, size_t len)
template bool all2GE (bool const (&source)[5])
template bool all2GE (bool const (&source)[4])
template bool all2GE (bool const (&source)[3])
template bool all2GE (bool const (&source)[2])
template bool all2GE (bool const (&source)[1])
template bool all2GE (bool const *source, size_t len, bool const *carry)
template bool all2GE (bool const *source, size_t len)
template<typename T , unsigned n>
bool all2GT (T const (&source)[n])
 same as _monotone::all2(T const*, size_t, T const*)
template<typename T >
bool all2GT (T const *source, size_t len, T const *carry)
 same as _monotone::all2(T const*, size_t, T const*)
template<typename T >
bool all2GT (T const *source, size_t len)
 same as _monotone::all2(T const*, size_t)
template bool all2GT (long double const (&source)[5])
template bool all2GT (long double const (&source)[4])
template bool all2GT (long double const (&source)[3])
template bool all2GT (long double const (&source)[2])
template bool all2GT (long double const (&source)[1])
template bool all2GT (long double const *source, size_t len, long double const *carry)
template bool all2GT (long double const *source, size_t len)
template bool all2GT (double const (&source)[5])
template bool all2GT (double const (&source)[4])
template bool all2GT (double const (&source)[3])
template bool all2GT (double const (&source)[2])
template bool all2GT (double const (&source)[1])
template bool all2GT (double const *source, size_t len, double const *carry)
template bool all2GT (double const *source, size_t len)
template bool all2GT (float const (&source)[5])
template bool all2GT (float const (&source)[4])
template bool all2GT (float const (&source)[3])
template bool all2GT (float const (&source)[2])
template bool all2GT (float const (&source)[1])
template bool all2GT (float const *source, size_t len, float const *carry)
template bool all2GT (float const *source, size_t len)
template bool all2GT (unsigned long long const (&source)[5])
template bool all2GT (unsigned long long const (&source)[4])
template bool all2GT (unsigned long long const (&source)[3])
template bool all2GT (unsigned long long const (&source)[2])
template bool all2GT (unsigned long long const (&source)[1])
template bool all2GT (unsigned long long const *source, size_t len, unsigned long long const *carry)
template bool all2GT (unsigned long long const *source, size_t len)
template bool all2GT (long long const (&source)[5])
template bool all2GT (long long const (&source)[4])
template bool all2GT (long long const (&source)[3])
template bool all2GT (long long const (&source)[2])
template bool all2GT (long long const (&source)[1])
template bool all2GT (long long const *source, size_t len, long long const *carry)
template bool all2GT (long long const *source, size_t len)
template bool all2GT (ulong const (&source)[5])
template bool all2GT (ulong const (&source)[4])
template bool all2GT (ulong const (&source)[3])
template bool all2GT (ulong const (&source)[2])
template bool all2GT (ulong const (&source)[1])
template bool all2GT (ulong const *source, size_t len, ulong const *carry)
template bool all2GT (ulong const *source, size_t len)
template bool all2GT (long const (&source)[5])
template bool all2GT (long const (&source)[4])
template bool all2GT (long const (&source)[3])
template bool all2GT (long const (&source)[2])
template bool all2GT (long const (&source)[1])
template bool all2GT (long const *source, size_t len, long const *carry)
template bool all2GT (long const *source, size_t len)
template bool all2GT (unsigned const (&source)[5])
template bool all2GT (unsigned const (&source)[4])
template bool all2GT (unsigned const (&source)[3])
template bool all2GT (unsigned const (&source)[2])
template bool all2GT (unsigned const (&source)[1])
template bool all2GT (unsigned const *source, size_t len, unsigned const *carry)
template bool all2GT (unsigned const *source, size_t len)
template bool all2GT (signed const (&source)[5])
template bool all2GT (signed const (&source)[4])
template bool all2GT (signed const (&source)[3])
template bool all2GT (signed const (&source)[2])
template bool all2GT (signed const (&source)[1])
template bool all2GT (signed const *source, size_t len, signed const *carry)
template bool all2GT (signed const *source, size_t len)
template bool all2GT (ushort const (&source)[5])
template bool all2GT (ushort const (&source)[4])
template bool all2GT (ushort const (&source)[3])
template bool all2GT (ushort const (&source)[2])
template bool all2GT (ushort const (&source)[1])
template bool all2GT (ushort const *source, size_t len, ushort const *carry)
template bool all2GT (ushort const *source, size_t len)
template bool all2GT (short const (&source)[5])
template bool all2GT (short const (&source)[4])
template bool all2GT (short const (&source)[3])
template bool all2GT (short const (&source)[2])
template bool all2GT (short const (&source)[1])
template bool all2GT (short const *source, size_t len, short const *carry)
template bool all2GT (short const *source, size_t len)
template bool all2GT (uchar const (&source)[5])
template bool all2GT (uchar const (&source)[4])
template bool all2GT (uchar const (&source)[3])
template bool all2GT (uchar const (&source)[2])
template bool all2GT (uchar const (&source)[1])
template bool all2GT (uchar const *source, size_t len, uchar const *carry)
template bool all2GT (uchar const *source, size_t len)
template bool all2GT (schar const (&source)[5])
template bool all2GT (schar const (&source)[4])
template bool all2GT (schar const (&source)[3])
template bool all2GT (schar const (&source)[2])
template bool all2GT (schar const (&source)[1])
template bool all2GT (schar const *source, size_t len, schar const *carry)
template bool all2GT (schar const *source, size_t len)
template bool all2GT (char const (&source)[5])
template bool all2GT (char const (&source)[4])
template bool all2GT (char const (&source)[3])
template bool all2GT (char const (&source)[2])
template bool all2GT (char const (&source)[1])
template bool all2GT (char const *source, size_t len, char const *carry)
template bool all2GT (char const *source, size_t len)
template bool all2GT (bool const (&source)[5])
template bool all2GT (bool const (&source)[4])
template bool all2GT (bool const (&source)[3])
template bool all2GT (bool const (&source)[2])
template bool all2GT (bool const (&source)[1])
template bool all2GT (bool const *source, size_t len, bool const *carry)
template bool all2GT (bool const *source, size_t len)
template<typename T , unsigned n>
bool all2LE (T const (&source)[n])
 same as _monotone::all2(T const*, size_t, T const*)
template<typename T >
bool all2LE (T const *source, size_t len, T const *carry)
 same as _monotone::all2(T const*, size_t, T const*)
template<typename T >
bool all2LE (T const *source, size_t len)
 same as _monotone::all2(T const*, size_t)
template bool all2LE (long double const (&source)[5])
template bool all2LE (long double const (&source)[4])
template bool all2LE (long double const (&source)[3])
template bool all2LE (long double const (&source)[2])
template bool all2LE (long double const (&source)[1])
template bool all2LE (long double const *source, size_t len, long double const *carry)
template bool all2LE (long double const *source, size_t len)
template bool all2LE (double const (&source)[5])
template bool all2LE (double const (&source)[4])
template bool all2LE (double const (&source)[3])
template bool all2LE (double const (&source)[2])
template bool all2LE (double const (&source)[1])
template bool all2LE (double const *source, size_t len, double const *carry)
template bool all2LE (double const *source, size_t len)
template bool all2LE (float const (&source)[5])
template bool all2LE (float const (&source)[4])
template bool all2LE (float const (&source)[3])
template bool all2LE (float const (&source)[2])
template bool all2LE (float const (&source)[1])
template bool all2LE (float const *source, size_t len, float const *carry)
template bool all2LE (float const *source, size_t len)
template bool all2LE (unsigned long long const (&source)[5])
template bool all2LE (unsigned long long const (&source)[4])
template bool all2LE (unsigned long long const (&source)[3])
template bool all2LE (unsigned long long const (&source)[2])
template bool all2LE (unsigned long long const (&source)[1])
template bool all2LE (unsigned long long const *source, size_t len, unsigned long long const *carry)
template bool all2LE (unsigned long long const *source, size_t len)
template bool all2LE (long long const (&source)[5])
template bool all2LE (long long const (&source)[4])
template bool all2LE (long long const (&source)[3])
template bool all2LE (long long const (&source)[2])
template bool all2LE (long long const (&source)[1])
template bool all2LE (long long const *source, size_t len, long long const *carry)
template bool all2LE (long long const *source, size_t len)
template bool all2LE (ulong const (&source)[5])
template bool all2LE (ulong const (&source)[4])
template bool all2LE (ulong const (&source)[3])
template bool all2LE (ulong const (&source)[2])
template bool all2LE (ulong const (&source)[1])
template bool all2LE (ulong const *source, size_t len, ulong const *carry)
template bool all2LE (ulong const *source, size_t len)
template bool all2LE (long const (&source)[5])
template bool all2LE (long const (&source)[4])
template bool all2LE (long const (&source)[3])
template bool all2LE (long const (&source)[2])
template bool all2LE (long const (&source)[1])
template bool all2LE (long const *source, size_t len, long const *carry)
template bool all2LE (long const *source, size_t len)
template bool all2LE (unsigned const (&source)[5])
template bool all2LE (unsigned const (&source)[4])
template bool all2LE (unsigned const (&source)[3])
template bool all2LE (unsigned const (&source)[2])
template bool all2LE (unsigned const (&source)[1])
template bool all2LE (unsigned const *source, size_t len, unsigned const *carry)
template bool all2LE (unsigned const *source, size_t len)
template bool all2LE (signed const (&source)[5])
template bool all2LE (signed const (&source)[4])
template bool all2LE (signed const (&source)[3])
template bool all2LE (signed const (&source)[2])
template bool all2LE (signed const (&source)[1])
template bool all2LE (signed const *source, size_t len, signed const *carry)
template bool all2LE (signed const *source, size_t len)
template bool all2LE (ushort const (&source)[5])
template bool all2LE (ushort const (&source)[4])
template bool all2LE (ushort const (&source)[3])
template bool all2LE (ushort const (&source)[2])
template bool all2LE (ushort const (&source)[1])
template bool all2LE (ushort const *source, size_t len, ushort const *carry)
template bool all2LE (ushort const *source, size_t len)
template bool all2LE (short const (&source)[5])
template bool all2LE (short const (&source)[4])
template bool all2LE (short const (&source)[3])
template bool all2LE (short const (&source)[2])
template bool all2LE (short const (&source)[1])
template bool all2LE (short const *source, size_t len, short const *carry)
template bool all2LE (short const *source, size_t len)
template bool all2LE (uchar const (&source)[5])
template bool all2LE (uchar const (&source)[4])
template bool all2LE (uchar const (&source)[3])
template bool all2LE (uchar const (&source)[2])
template bool all2LE (uchar const (&source)[1])
template bool all2LE (uchar const *source, size_t len, uchar const *carry)
template bool all2LE (uchar const *source, size_t len)
template bool all2LE (schar const (&source)[5])
template bool all2LE (schar const (&source)[4])
template bool all2LE (schar const (&source)[3])
template bool all2LE (schar const (&source)[2])
template bool all2LE (schar const (&source)[1])
template bool all2LE (schar const *source, size_t len, schar const *carry)
template bool all2LE (schar const *source, size_t len)
template bool all2LE (char const (&source)[5])
template bool all2LE (char const (&source)[4])
template bool all2LE (char const (&source)[3])
template bool all2LE (char const (&source)[2])
template bool all2LE (char const (&source)[1])
template bool all2LE (char const *source, size_t len, char const *carry)
template bool all2LE (char const *source, size_t len)
template bool all2LE (bool const (&source)[5])
template bool all2LE (bool const (&source)[4])
template bool all2LE (bool const (&source)[3])
template bool all2LE (bool const (&source)[2])
template bool all2LE (bool const (&source)[1])
template bool all2LE (bool const *source, size_t len, bool const *carry)
template bool all2LE (bool const *source, size_t len)
template<typename T , unsigned n>
bool all2LT (T const (&source)[n])
 same as _monotone::all2(T const*, size_t, T const*)
template<typename T >
bool all2LT (T const *source, size_t len, T const *carry)
 same as _monotone::all2(T const*, size_t, T const*)
template<typename T >
bool all2LT (T const *source, size_t len)
 same as _monotone::all2(T const*, size_t)
template bool all2LT (long double const (&source)[5])
template bool all2LT (long double const (&source)[4])
template bool all2LT (long double const (&source)[3])
template bool all2LT (long double const (&source)[2])
template bool all2LT (long double const (&source)[1])
template bool all2LT (long double const *source, size_t len, long double const *carry)
template bool all2LT (long double const *source, size_t len)
template bool all2LT (double const (&source)[5])
template bool all2LT (double const (&source)[4])
template bool all2LT (double const (&source)[3])
template bool all2LT (double const (&source)[2])
template bool all2LT (double const (&source)[1])
template bool all2LT (double const *source, size_t len, double const *carry)
template bool all2LT (double const *source, size_t len)
template bool all2LT (float const (&source)[5])
template bool all2LT (float const (&source)[4])
template bool all2LT (float const (&source)[3])
template bool all2LT (float const (&source)[2])
template bool all2LT (float const (&source)[1])
template bool all2LT (float const *source, size_t len, float const *carry)
template bool all2LT (float const *source, size_t len)
template bool all2LT (unsigned long long const (&source)[5])
template bool all2LT (unsigned long long const (&source)[4])
template bool all2LT (unsigned long long const (&source)[3])
template bool all2LT (unsigned long long const (&source)[2])
template bool all2LT (unsigned long long const (&source)[1])
template bool all2LT (unsigned long long const *source, size_t len, unsigned long long const *carry)
template bool all2LT (unsigned long long const *source, size_t len)
template bool all2LT (long long const (&source)[5])
template bool all2LT (long long const (&source)[4])
template bool all2LT (long long const (&source)[3])
template bool all2LT (long long const (&source)[2])
template bool all2LT (long long const (&source)[1])
template bool all2LT (long long const *source, size_t len, long long const *carry)
template bool all2LT (long long const *source, size_t len)
template bool all2LT (ulong const (&source)[5])
template bool all2LT (ulong const (&source)[4])
template bool all2LT (ulong const (&source)[3])
template bool all2LT (ulong const (&source)[2])
template bool all2LT (ulong const (&source)[1])
template bool all2LT (ulong const *source, size_t len, ulong const *carry)
template bool all2LT (ulong const *source, size_t len)
template bool all2LT (long const (&source)[5])
template bool all2LT (long const (&source)[4])
template bool all2LT (long const (&source)[3])
template bool all2LT (long const (&source)[2])
template bool all2LT (long const (&source)[1])
template bool all2LT (long const *source, size_t len, long const *carry)
template bool all2LT (long const *source, size_t len)
template bool all2LT (unsigned const (&source)[5])
template bool all2LT (unsigned const (&source)[4])
template bool all2LT (unsigned const (&source)[3])
template bool all2LT (unsigned const (&source)[2])
template bool all2LT (unsigned const (&source)[1])
template bool all2LT (unsigned const *source, size_t len, unsigned const *carry)
template bool all2LT (unsigned const *source, size_t len)
template bool all2LT (signed const (&source)[5])
template bool all2LT (signed const (&source)[4])
template bool all2LT (signed const (&source)[3])
template bool all2LT (signed const (&source)[2])
template bool all2LT (signed const (&source)[1])
template bool all2LT (signed const *source, size_t len, signed const *carry)
template bool all2LT (signed const *source, size_t len)
template bool all2LT (ushort const (&source)[5])
template bool all2LT (ushort const (&source)[4])
template bool all2LT (ushort const (&source)[3])
template bool all2LT (ushort const (&source)[2])
template bool all2LT (ushort const (&source)[1])
template bool all2LT (ushort const *source, size_t len, ushort const *carry)
template bool all2LT (ushort const *source, size_t len)
template bool all2LT (short const (&source)[5])
template bool all2LT (short const (&source)[4])
template bool all2LT (short const (&source)[3])
template bool all2LT (short const (&source)[2])
template bool all2LT (short const (&source)[1])
template bool all2LT (short const *source, size_t len, short const *carry)
template bool all2LT (short const *source, size_t len)
template bool all2LT (uchar const (&source)[5])
template bool all2LT (uchar const (&source)[4])
template bool all2LT (uchar const (&source)[3])
template bool all2LT (uchar const (&source)[2])
template bool all2LT (uchar const (&source)[1])
template bool all2LT (uchar const *source, size_t len, uchar const *carry)
template bool all2LT (uchar const *source, size_t len)
template bool all2LT (schar const (&source)[5])
template bool all2LT (schar const (&source)[4])
template bool all2LT (schar const (&source)[3])
template bool all2LT (schar const (&source)[2])
template bool all2LT (schar const (&source)[1])
template bool all2LT (schar const *source, size_t len, schar const *carry)
template bool all2LT (schar const *source, size_t len)
template bool all2LT (char const (&source)[5])
template bool all2LT (char const (&source)[4])
template bool all2LT (char const (&source)[3])
template bool all2LT (char const (&source)[2])
template bool all2LT (char const (&source)[1])
template bool all2LT (char const *source, size_t len, char const *carry)
template bool all2LT (char const *source, size_t len)
template bool all2LT (bool const (&source)[5])
template bool all2LT (bool const (&source)[4])
template bool all2LT (bool const (&source)[3])
template bool all2LT (bool const (&source)[2])
template bool all2LT (bool const (&source)[1])
template bool all2LT (bool const *source, size_t len, bool const *carry)
template bool all2LT (bool const *source, size_t len)
template<typename T , unsigned n>
bool all2NE (T const (&source)[n])
 same as _monotone::all2(T const*, size_t, T const*)
template<typename T >
bool all2NE (T const *source, size_t len, T const *carry)
 same as _monotone::all2(T const*, size_t, T const*)
template<typename T >
bool all2NE (T const *source, size_t len)
 same as _monotone::all2(T const*, size_t)
template bool all2NE (long double const (&source)[5])
template bool all2NE (long double const (&source)[4])
template bool all2NE (long double const (&source)[3])
template bool all2NE (long double const (&source)[2])
template bool all2NE (long double const (&source)[1])
template bool all2NE (long double const *source, size_t len, long double const *carry)
template bool all2NE (long double const *source, size_t len)
template bool all2NE (double const (&source)[5])
template bool all2NE (double const (&source)[4])
template bool all2NE (double const (&source)[3])
template bool all2NE (double const (&source)[2])
template bool all2NE (double const (&source)[1])
template bool all2NE (double const *source, size_t len, double const *carry)
template bool all2NE (double const *source, size_t len)
template bool all2NE (float const (&source)[5])
template bool all2NE (float const (&source)[4])
template bool all2NE (float const (&source)[3])
template bool all2NE (float const (&source)[2])
template bool all2NE (float const (&source)[1])
template bool all2NE (float const *source, size_t len, float const *carry)
template bool all2NE (float const *source, size_t len)
template bool all2NE (unsigned long long const (&source)[5])
template bool all2NE (unsigned long long const (&source)[4])
template bool all2NE (unsigned long long const (&source)[3])
template bool all2NE (unsigned long long const (&source)[2])
template bool all2NE (unsigned long long const (&source)[1])
template bool all2NE (unsigned long long const *source, size_t len, unsigned long long const *carry)
template bool all2NE (unsigned long long const *source, size_t len)
template bool all2NE (long long const (&source)[5])
template bool all2NE (long long const (&source)[4])
template bool all2NE (long long const (&source)[3])
template bool all2NE (long long const (&source)[2])
template bool all2NE (long long const (&source)[1])
template bool all2NE (long long const *source, size_t len, long long const *carry)
template bool all2NE (long long const *source, size_t len)
template bool all2NE (ulong const (&source)[5])
template bool all2NE (ulong const (&source)[4])
template bool all2NE (ulong const (&source)[3])
template bool all2NE (ulong const (&source)[2])
template bool all2NE (ulong const (&source)[1])
template bool all2NE (ulong const *source, size_t len, ulong const *carry)
template bool all2NE (ulong const *source, size_t len)
template bool all2NE (long const (&source)[5])
template bool all2NE (long const (&source)[4])
template bool all2NE (long const (&source)[3])
template bool all2NE (long const (&source)[2])
template bool all2NE (long const (&source)[1])
template bool all2NE (long const *source, size_t len, long const *carry)
template bool all2NE (long const *source, size_t len)
template bool all2NE (unsigned const (&source)[5])
template bool all2NE (unsigned const (&source)[4])
template bool all2NE (unsigned const (&source)[3])
template bool all2NE (unsigned const (&source)[2])
template bool all2NE (unsigned const (&source)[1])
template bool all2NE (unsigned const *source, size_t len, unsigned const *carry)
template bool all2NE (unsigned const *source, size_t len)
template bool all2NE (signed const (&source)[5])
template bool all2NE (signed const (&source)[4])
template bool all2NE (signed const (&source)[3])
template bool all2NE (signed const (&source)[2])
template bool all2NE (signed const (&source)[1])
template bool all2NE (signed const *source, size_t len, signed const *carry)
template bool all2NE (signed const *source, size_t len)
template bool all2NE (ushort const (&source)[5])
template bool all2NE (ushort const (&source)[4])
template bool all2NE (ushort const (&source)[3])
template bool all2NE (ushort const (&source)[2])
template bool all2NE (ushort const (&source)[1])
template bool all2NE (ushort const *source, size_t len, ushort const *carry)
template bool all2NE (ushort const *source, size_t len)
template bool all2NE (short const (&source)[5])
template bool all2NE (short const (&source)[4])
template bool all2NE (short const (&source)[3])
template bool all2NE (short const (&source)[2])
template bool all2NE (short const (&source)[1])
template bool all2NE (short const *source, size_t len, short const *carry)
template bool all2NE (short const *source, size_t len)
template bool all2NE (uchar const (&source)[5])
template bool all2NE (uchar const (&source)[4])
template bool all2NE (uchar const (&source)[3])
template bool all2NE (uchar const (&source)[2])
template bool all2NE (uchar const (&source)[1])
template bool all2NE (uchar const *source, size_t len, uchar const *carry)
template bool all2NE (uchar const *source, size_t len)
template bool all2NE (schar const (&source)[5])
template bool all2NE (schar const (&source)[4])
template bool all2NE (schar const (&source)[3])
template bool all2NE (schar const (&source)[2])
template bool all2NE (schar const (&source)[1])
template bool all2NE (schar const *source, size_t len, schar const *carry)
template bool all2NE (schar const *source, size_t len)
template bool all2NE (char const (&source)[5])
template bool all2NE (char const (&source)[4])
template bool all2NE (char const (&source)[3])
template bool all2NE (char const (&source)[2])
template bool all2NE (char const (&source)[1])
template bool all2NE (char const *source, size_t len, char const *carry)
template bool all2NE (char const *source, size_t len)
template bool all2NE (bool const (&source)[5])
template bool all2NE (bool const (&source)[4])
template bool all2NE (bool const (&source)[3])
template bool all2NE (bool const (&source)[2])
template bool all2NE (bool const (&source)[1])
template bool all2NE (bool const *source, size_t len, bool const *carry)
template bool all2NE (bool const *source, size_t len)
template<typename T , unsigned n>
bool all2NV (T const (&source)[n])
 same as _monotone::all2(T const*, size_t, T const*)
template<typename T >
bool all2NV (T const *source, size_t len, T const *carry)
 same as _monotone::all2(T const*, size_t, T const*)
template<typename T >
bool all2NV (T const *source, size_t len)
 same as _monotone::all2(T const*, size_t)
template<typename T >
par::cpp::_traditional
< unsigned long > 
base16 (T const &v)
 Print a value v as a hexadecimal number.
template<typename T >
par::cpp::_traditional
< unsigned long > 
base8 (T const &v)
 Print a value v as an octal number.
template<int t>
void be (unsigned long long &val)
template<int t>
void be (ulong &val)
template<int t>
void be (unsigned &val)
template<int t>
void be (ushort &val)
template<int t>
void be (uchar &val)
template<typename T >
void bezout (T &a, T &d, T const &divisor)
 Same as bezout<T>(T&, T&) but such that all arithmetic is done mod divisor.
template<typename T >
void bezout (T &a, T &d)
 Find values that fulfill Bezout's identity gcd(a,b) = x*a + y*b.
template<int t>
bool bit (unsigned long long const &val)
template<int t>
bool bit (ulong const &val)
template<int t>
bool bit (unsigned const &val)
template<int t>
bool bit (ushort const &val)
template<int t>
bool bit (uchar const &val)
void bzerothrough (void *target, size_t len)
 An analogous to par::setthrough(target, 0, len).
template<>
int compare (par::sys::sfd_segment_private const *a, par::sys::sfd_segment_private const *b)
 Compares two shared segments. Comparison between segment is done based on their name.
template<>
int compare (par::sys::sfd_file_private const *a, par::sys::sfd_file_private const *b)
 Compares two shared file descriptors. Comparison between disk file descriptors is done based on their device/inode location.
template<>
int compare (const flock_entry *a, const flock_entry *b)
template<>
int compare (const sys::fd::rawlock *a, const sys::fd::rawlock *b)
template<class T >
int compare (T const *restrict a, T const *restrict b)
 A generic interface for a comparision function analogous to strcmp.
template<>
int compare< char > (char const *a, char const *b)
 Common usage is to assume that char pointers point to strings and are 0 terminated. Cross fingers.
template<>
int compare< cntrl::svm::receive_buffer const > (cntrl::svm::receive_buffer const *a, cntrl::svm::receive_buffer const *b)
template<>
int compare< cntrl::svm::send_buffer const > (cntrl::svm::send_buffer const *a, cntrl::svm::send_buffer const *b)
 compare too send requests for storing them in an par::sys::stree.
template<>
int compare< mem::obid > (mem::obid const *restrict a, mem::obid const *restrict b)
template<>
int compare< mem::url_t::keyvalue > (mem::url_t::keyvalue const *a, mem::url_t::keyvalue const *b)
template<>
int compare< par::mem::obid > (par::mem::obid const *restrict a, par::mem::obid const *restrict b)
template<>
int compare< par::sys::str > (par::sys::str const *a, par::sys::str const *b)
template<>
int compare< sys::dentry< par::sys::str > > (sys::dentry< par::sys::str > const *a, sys::dentry< par::sys::str > const *b)
template<typename T >
T * copythrough (T *target, T const *source, size_t len)
 Analog to memcpy but writes through without polluting the caches with target.
template<>
void * copythrough< void > (void *target, void const *source, size_t len)
char const * demangle (char const *name, char const *ignored=par::identify_compiler< __LINE__ >())
 Demangle a C++ symbol.
template<class T >
size_t divide (T *restrict tab, size_t size, T const &splitter)
 Classify all elements in tab according to splitter.
template<unsigned p>
double doubleword (double x, uint32_t val)
template<unsigned p>
uint32_t doubleword (double val)
template<typename T >
void dump (registerline< T > const &cache, registerline< T > &mem)
par::cpp::_traditional< doubleengineering (double const &v, char const *sep=" ")
 Print value v with `thousands' postfixes such as `35 k' for 35000.0 or `27.5 n' for 2.75E-8.
template<class T >
bool equal (T const &restrict a, T const &restrict b)
 Template for the comparison of two items.
template<class T >
bool equiv (T const &restrict a, T const &restrict b)
 Template for the comparison of two items.
double fabs (register double x)
double fabs (double x)
double fastdivide (double numerator, double denominator)
 Compute an approximation of the quotient of numerator and denominator.
double fastldexp (double x, int a)
template<unsigned deg>
double fastlog1p (double x)
 Approximate the natural logarithm of (1 + x), for $ 0 \leq x < 1 $.
template<>
double fastlog1p< 1 > (double x)
template<>
double fastlog1p< 2 > (double x)
template<>
double fastlog1p< 3 > (double x)
template<>
double fastlog1p< 4 > (double x)
template<>
double fastlog1p< 5 > (double x)
template<unsigned deg>
double fastlog2 (double x)
 Approximate the logarithm base 2 of x.
double fastmax (double a, double b)
 Return the maximum of the two arguments.
double fastmin (double a, double b)
 Return the minimum of the two arguments.
template<unsigned dn, unsigned dd>
double fastrational (double const (&num)[dn], double const (&den)[dd], double x)
template<typename T , unsigned iteration>
fastrcp (T x)
 Compute an approximation of the reciproc (1/x) of x.
template<typename T >
fastrsqrt (T x)
 Compute an approximation of the reciproc of the square root of x, i.e 1/sqrt(x).
template<>
double fastrsqrt< double > (double x)
template<>
float fastrsqrt< float > (float x)
template<signed s>
double fastShiftLeft (double val)
 Fast emulation of a multiplication with 2^s.
template<signed s>
double fastShiftRight (double val)
double fasttrunc (double x)
 Truncate x, similar to trunc.
double fexp (register double x)
double fexp (double x)
template<typename T >
int ffs (T a)
 find the least significant bit that is not zero.
template<>
int ffs< signed > (signed a)
template<>
int ffs< unsigned > (unsigned a)
template<typename T >
void fill (typename registerline< T >::line &cache, registerline< T > const &mem)
template<typename T , unsigned size>
size_t find_max (T const (&restrict p)[size])
template<typename T >
size_t find_max (T const *restrict tab, size_t size)
 Return the index of a maximal element in tab.
template<typename T >
size_t find_max (T const &restrict tab0, size_t pos0, T const &restrict tab1, size_t pos1, T const &restrict tab2, size_t pos2, T const &restrict tab3, size_t pos3, T const &restrict tab4, size_t pos4)
template<typename T >
size_t find_max (T const &restrict tab0, size_t pos0, T const &restrict tab1, size_t pos1, T const &restrict tab2, size_t pos2, T const &restrict tab3, size_t pos3)
template<typename T >
size_t find_max (T const &restrict tab0, size_t pos0, T const &restrict tab1, size_t pos1, T const &restrict tab2, size_t pos2)
template<typename T >
size_t find_max (T const &restrict tab0, size_t pos0, T const &restrict tab1, size_t pos1)
template<typename T >
size_t find_max (T const &restrict tab0)
template<typename T , unsigned size>
size_t find_min (T const (&restrict p)[size])
template<typename T >
size_t find_min (T const *restrict tab, size_t size)
 Return the index of a minimal element in tab.
template<typename T >
size_t find_min (T const &restrict tab0, size_t pos0, T const &restrict tab1, size_t pos1, T const &restrict tab2, size_t pos2, T const &restrict tab3, size_t pos3, T const &restrict tab4, size_t pos4)
template<typename T >
size_t find_min (T const &restrict tab0, size_t pos0, T const &restrict tab1, size_t pos1, T const &restrict tab2, size_t pos2, T const &restrict tab3, size_t pos3)
template<typename T >
size_t find_min (T const &restrict tab0, size_t pos0, T const &restrict tab1, size_t pos1, T const &restrict tab2, size_t pos2)
template<typename T >
size_t find_min (T const &restrict tab0, size_t pos0, T const &restrict tab1, size_t pos1)
template<typename T >
size_t find_min (T const &restrict tab0)
template<typename T , unsigned size>
void find_min_max (T(&restrict p)[size])
template<typename T >
void find_min_max (T *restrict tab, size_t size)
 Swap a minimal element to tab[0] and a maximal one to tab[size-1].
template<typename T >
double flogfak (T k)
 compute the log of the factorial of k, log(k!).
int ftrace (char const *name, int line)
int ftrace (char const *name, int line, char const *format,...)
double fxtract (double x, double &y)
 Analog to frexp, splits x into mantissa (return value) and exponent (returned in y).
template<typename T , typename D >
gcd (T a, D b)
 Find th Greates Common Divisor of two numbers a and b.
template<class T >
bool geq (T const &restrict a, T const &restrict b)
 Template for the comparison of two items.
template<unsigned pos>
off_t get (off_t flags)
 Get the flag at pos.
template<class T >
bool greater (T const &restrict a, T const &restrict b)
 Template for the comparison of two items.
template<unsigned dim>
void head (par::cpp::link< 1 > *tarr, edge< dim >const *sarr, size_t length)
template<typename T >
__print_tmp< T > human (T const &v)
 Switch the printout of a T expression to human readable format.
template<class T >
void identity (T *restrict tab, size_t size)
int ilogb (double x)
 A fast implementation of a the integer log base two.
template<typename T >
infty (void)
template<>
double infty< double > (void)
template<>
float infty< float > (void)
template<>
long double infty< long double > (void)
template<typename T >
invers (T a, T const &prime)
 Compute the multiplative invers of relative to the prime prime.
template<>
uint32_t invers< uint32_t > (uint32_t a, uint32_t const &prime)
template<>
uint64_t invers< uint64_t > (uint64_t a, uint64_t const &prime)
template<typename T , unsigned k>
ipow (T x)
template<class T >
bool is_sorted (size_t const length, T const *restrict arr)
 This tests if the input array is sorted.
template<typename T >
bool ispow2 (T val)
double ldexp (double x, int a)
template<class T >
bool leq (T const &restrict a, T const &restrict b)
 Template for the comparison of two items.
template<class T >
bool less (T const &restrict a, T const &restrict b)
 Template for the comparison of two items.
template<unsigned b, unsigned length>
bool less (par::cpp::link< b > const (&restrict a)[length], par::cpp::link< b > const (&restrict c)[length])
template<unsigned b>
bool less (par::cpp::link< b > const &restrict a, par::cpp::link< b > const &restrict c)
template bool less< 1 > (link< 1 > const &restrict a, link< 1 > const &restrict c)
template bool less< 1, 1 > (link< 1 > const (&restrict a)[1], link< 1 > const (&restrict c)[1])
template bool less< 1, 2 > (link< 1 > const (&restrict a)[2], link< 1 > const (&restrict c)[2])
template bool less< 1, 3 > (link< 1 > const (&restrict a)[3], link< 1 > const (&restrict c)[3])
template bool less< 1, 4 > (link< 1 > const (&restrict a)[4], link< 1 > const (&restrict c)[4])
template bool less< 1, 5 > (link< 1 > const (&restrict a)[5], link< 1 > const (&restrict c)[5])
template bool less< 1, 6 > (link< 1 > const (&restrict a)[6], link< 1 > const (&restrict c)[6])
template bool less< 1, 7 > (link< 1 > const (&restrict a)[7], link< 1 > const (&restrict c)[7])
template bool less< 1, 8 > (link< 1 > const (&restrict a)[8], link< 1 > const (&restrict c)[8])
template bool less< 1, 9 > (link< 1 > const (&restrict a)[9], link< 1 > const (&restrict c)[9])
template bool less< 10 > (link< 10 > const &restrict a, link< 10 > const &restrict c)
template bool less< 10, 1 > (link< 10 > const (&restrict a)[1], link< 10 > const (&restrict c)[1])
template bool less< 10, 2 > (link< 10 > const (&restrict a)[2], link< 10 > const (&restrict c)[2])
template bool less< 10, 3 > (link< 10 > const (&restrict a)[3], link< 10 > const (&restrict c)[3])
template bool less< 10, 4 > (link< 10 > const (&restrict a)[4], link< 10 > const (&restrict c)[4])
template bool less< 10, 5 > (link< 10 > const (&restrict a)[5], link< 10 > const (&restrict c)[5])
template bool less< 10, 6 > (link< 10 > const (&restrict a)[6], link< 10 > const (&restrict c)[6])
template bool less< 10, 7 > (link< 10 > const (&restrict a)[7], link< 10 > const (&restrict c)[7])
template bool less< 10, 8 > (link< 10 > const (&restrict a)[8], link< 10 > const (&restrict c)[8])
template bool less< 10, 9 > (link< 10 > const (&restrict a)[9], link< 10 > const (&restrict c)[9])
template bool less< 2 > (link< 2 > const &restrict a, link< 2 > const &restrict c)
template bool less< 2, 1 > (link< 2 > const (&restrict a)[1], link< 2 > const (&restrict c)[1])
template bool less< 2, 2 > (link< 2 > const (&restrict a)[2], link< 2 > const (&restrict c)[2])
template bool less< 2, 3 > (link< 2 > const (&restrict a)[3], link< 2 > const (&restrict c)[3])
template bool less< 2, 4 > (link< 2 > const (&restrict a)[4], link< 2 > const (&restrict c)[4])
template bool less< 2, 5 > (link< 2 > const (&restrict a)[5], link< 2 > const (&restrict c)[5])
template bool less< 2, 6 > (link< 2 > const (&restrict a)[6], link< 2 > const (&restrict c)[6])
template bool less< 2, 7 > (link< 2 > const (&restrict a)[7], link< 2 > const (&restrict c)[7])
template bool less< 2, 8 > (link< 2 > const (&restrict a)[8], link< 2 > const (&restrict c)[8])
template bool less< 2, 9 > (link< 2 > const (&restrict a)[9], link< 2 > const (&restrict c)[9])
template bool less< 3 > (link< 3 > const &restrict a, link< 3 > const &restrict c)
template bool less< 3, 1 > (link< 3 > const (&restrict a)[1], link< 3 > const (&restrict c)[1])
template bool less< 3, 2 > (link< 3 > const (&restrict a)[2], link< 3 > const (&restrict c)[2])
template bool less< 3, 3 > (link< 3 > const (&restrict a)[3], link< 3 > const (&restrict c)[3])
template bool less< 3, 4 > (link< 3 > const (&restrict a)[4], link< 3 > const (&restrict c)[4])
template bool less< 3, 5 > (link< 3 > const (&restrict a)[5], link< 3 > const (&restrict c)[5])
template bool less< 3, 6 > (link< 3 > const (&restrict a)[6], link< 3 > const (&restrict c)[6])
template bool less< 3, 7 > (link< 3 > const (&restrict a)[7], link< 3 > const (&restrict c)[7])
template bool less< 3, 8 > (link< 3 > const (&restrict a)[8], link< 3 > const (&restrict c)[8])
template bool less< 3, 9 > (link< 3 > const (&restrict a)[9], link< 3 > const (&restrict c)[9])
template bool less< 4 > (link< 4 > const &restrict a, link< 4 > const &restrict c)
template bool less< 4, 1 > (link< 4 > const (&restrict a)[1], link< 4 > const (&restrict c)[1])
template bool less< 4, 2 > (link< 4 > const (&restrict a)[2], link< 4 > const (&restrict c)[2])
template bool less< 4, 3 > (link< 4 > const (&restrict a)[3], link< 4 > const (&restrict c)[3])
template bool less< 4, 4 > (link< 4 > const (&restrict a)[4], link< 4 > const (&restrict c)[4])
template bool less< 4, 5 > (link< 4 > const (&restrict a)[5], link< 4 > const (&restrict c)[5])
template bool less< 4, 6 > (link< 4 > const (&restrict a)[6], link< 4 > const (&restrict c)[6])
template bool less< 4, 7 > (link< 4 > const (&restrict a)[7], link< 4 > const (&restrict c)[7])
template bool less< 4, 8 > (link< 4 > const (&restrict a)[8], link< 4 > const (&restrict c)[8])
template bool less< 4, 9 > (link< 4 > const (&restrict a)[9], link< 4 > const (&restrict c)[9])
template bool less< 5 > (link< 5 > const &restrict a, link< 5 > const &restrict c)
template bool less< 5, 1 > (link< 5 > const (&restrict a)[1], link< 5 > const (&restrict c)[1])
template bool less< 5, 2 > (link< 5 > const (&restrict a)[2], link< 5 > const (&restrict c)[2])
template bool less< 5, 3 > (link< 5 > const (&restrict a)[3], link< 5 > const (&restrict c)[3])
template bool less< 5, 4 > (link< 5 > const (&restrict a)[4], link< 5 > const (&restrict c)[4])
template bool less< 5, 5 > (link< 5 > const (&restrict a)[5], link< 5 > const (&restrict c)[5])
template bool less< 5, 6 > (link< 5 > const (&restrict a)[6], link< 5 > const (&restrict c)[6])
template bool less< 5, 7 > (link< 5 > const (&restrict a)[7], link< 5 > const (&restrict c)[7])
template bool less< 5, 8 > (link< 5 > const (&restrict a)[8], link< 5 > const (&restrict c)[8])
template bool less< 5, 9 > (link< 5 > const (&restrict a)[9], link< 5 > const (&restrict c)[9])
template bool less< 6 > (link< 6 > const &restrict a, link< 6 > const &restrict c)
template bool less< 6, 1 > (link< 6 > const (&restrict a)[1], link< 6 > const (&restrict c)[1])
template bool less< 6, 2 > (link< 6 > const (&restrict a)[2], link< 6 > const (&restrict c)[2])
template bool less< 6, 3 > (link< 6 > const (&restrict a)[3], link< 6 > const (&restrict c)[3])
template bool less< 6, 4 > (link< 6 > const (&restrict a)[4], link< 6 > const (&restrict c)[4])
template bool less< 6, 5 > (link< 6 > const (&restrict a)[5], link< 6 > const (&restrict c)[5])
template bool less< 6, 6 > (link< 6 > const (&restrict a)[6], link< 6 > const (&restrict c)[6])
template bool less< 6, 7 > (link< 6 > const (&restrict a)[7], link< 6 > const (&restrict c)[7])
template bool less< 6, 8 > (link< 6 > const (&restrict a)[8], link< 6 > const (&restrict c)[8])
template bool less< 6, 9 > (link< 6 > const (&restrict a)[9], link< 6 > const (&restrict c)[9])
template bool less< 7 > (link< 7 > const &restrict a, link< 7 > const &restrict c)
template bool less< 7, 1 > (link< 7 > const (&restrict a)[1], link< 7 > const (&restrict c)[1])
template bool less< 7, 2 > (link< 7 > const (&restrict a)[2], link< 7 > const (&restrict c)[2])
template bool less< 7, 3 > (link< 7 > const (&restrict a)[3], link< 7 > const (&restrict c)[3])
template bool less< 7, 4 > (link< 7 > const (&restrict a)[4], link< 7 > const (&restrict c)[4])
template bool less< 7, 5 > (link< 7 > const (&restrict a)[5], link< 7 > const (&restrict c)[5])
template bool less< 7, 6 > (link< 7 > const (&restrict a)[6], link< 7 > const (&restrict c)[6])
template bool less< 7, 7 > (link< 7 > const (&restrict a)[7], link< 7 > const (&restrict c)[7])
template bool less< 7, 8 > (link< 7 > const (&restrict a)[8], link< 7 > const (&restrict c)[8])
template bool less< 7, 9 > (link< 7 > const (&restrict a)[9], link< 7 > const (&restrict c)[9])
template bool less< 8 > (link< 8 > const &restrict a, link< 8 > const &restrict c)
template bool less< 8, 1 > (link< 8 > const (&restrict a)[1], link< 8 > const (&restrict c)[1])
template bool less< 8, 2 > (link< 8 > const (&restrict a)[2], link< 8 > const (&restrict c)[2])
template bool less< 8, 3 > (link< 8 > const (&restrict a)[3], link< 8 > const (&restrict c)[3])
template bool less< 8, 4 > (link< 8 > const (&restrict a)[4], link< 8 > const (&restrict c)[4])
template bool less< 8, 5 > (link< 8 > const (&restrict a)[5], link< 8 > const (&restrict c)[5])
template bool less< 8, 6 > (link< 8 > const (&restrict a)[6], link< 8 > const (&restrict c)[6])
template bool less< 8, 7 > (link< 8 > const (&restrict a)[7], link< 8 > const (&restrict c)[7])
template bool less< 8, 8 > (link< 8 > const (&restrict a)[8], link< 8 > const (&restrict c)[8])
template bool less< 8, 9 > (link< 8 > const (&restrict a)[9], link< 8 > const (&restrict c)[9])
template bool less< 9 > (link< 9 > const &restrict a, link< 9 > const &restrict c)
template bool less< 9, 1 > (link< 9 > const (&restrict a)[1], link< 9 > const (&restrict c)[1])
template bool less< 9, 2 > (link< 9 > const (&restrict a)[2], link< 9 > const (&restrict c)[2])
template bool less< 9, 3 > (link< 9 > const (&restrict a)[3], link< 9 > const (&restrict c)[3])
template bool less< 9, 4 > (link< 9 > const (&restrict a)[4], link< 9 > const (&restrict c)[4])
template bool less< 9, 5 > (link< 9 > const (&restrict a)[5], link< 9 > const (&restrict c)[5])
template bool less< 9, 6 > (link< 9 > const (&restrict a)[6], link< 9 > const (&restrict c)[6])
template bool less< 9, 7 > (link< 9 > const (&restrict a)[7], link< 9 > const (&restrict c)[7])
template bool less< 9, 8 > (link< 9 > const (&restrict a)[8], link< 9 > const (&restrict c)[8])
template bool less< 9, 9 > (link< 9 > const (&restrict a)[9], link< 9 > const (&restrict c)[9])
template<>
bool less< char const * > (char const *const &restrict a, char const *const &restrict b)
template<unsigned b, unsigned length>
 link< b > (&clear(par::cpp::link< b >(&o)[length]))[length]
 Apply the operation to all ellements of the vector.
template<unsigned left, unsigned right>
double lmask (double val)
template<typename T >
void loadline (typename registerline< T >::line &L, T x)
 Load all elements of a line with the same value x.
double log2mul (double x, double y)
 Compute log2(x) and multiply the result by y.
template<typename T >
low2 (T val0)
template<unsigned s>
double lshiftLeft (double val)
template<unsigned s>
double lshiftRight (double val)
int main (int argc, char **argv, char **env)
template<typename T , unsigned size>
T const & max (T const (&restrict p)[size])
 Return the maximum of size values.
template<typename T >
T & maxEQ (T &a, T &b)
 Return a reference to the smaller of the two arguments.
template<typename T >
T & maxEV (T &a, T &b)
 Return a reference to the smaller of the two arguments.
template<typename T >
T & maxGE (T &a, T &b)
 Return a reference to the smaller of the two arguments.
template<typename T >
T & maxGT (T &a, T &b)
 Return a reference to the smaller of the two arguments.
template<typename T >
T & maxLE (T &a, T &b)
 Return a reference to the smaller of the two arguments.
template<typename T >
T & maxLT (T &a, T &b)
 Return a reference to the smaller of the two arguments.
template<typename T >
T & maxNE (T &a, T &b)
 Return a reference to the smaller of the two arguments.
template<typename T >
T & maxNV (T &a, T &b)
 Return a reference to the smaller of the two arguments.
template<class T >
static size_t median (T(&restrict p)[25])
template<class T >
static size_t median (T(&restrict p)[9])
template<class T >
static size_t median (T(&restrict p)[7])
template<class T >
static size_t median (T const (&restrict p)[5])
template<class T >
static size_t median (T const (&restrict p)[3])
template<class T >
size_t median (T *restrict tab, size_t size, size_t pivot)
template<class T >
size_t median (T *restrict tab, size_t size, size_t pivot, size_t tolerance, size_t sample=0)
template<class T >
size_t median (size_t const pivot, T(&restrict tab)[5])
template<class T >
size_t median (size_t pivot, T const &restrict tab0, size_t pos0, T const &restrict tab1, size_t pos1, T const &restrict tab2, size_t pos2, T const &restrict tab3, size_t pos3)
template<class T >
size_t median (size_t pivot, T const &restrict tab0, size_t pos0, T const &restrict tab1, size_t pos1, T const &restrict tab2, size_t pos2)
template<class T >
size_t median (size_t pivot, T const &restrict tab0, size_t pos0, T const &restrict tab1, size_t pos1)
template<class T >
size_t median (T const &restrict tab0)
template<class T >
static void medianSwap (T &restrict place, T(&restrict p)[5])
template<class T >
static void medianSwap (T &restrict place, T(&restrict p)[3])
template<typename T , typename predOp , unsigned n0, unsigned n1>
void merge (T(&restrict t)[n0+n1], T(&restrict s0)[n0], T(&restrict s1)[n1])
template<typename T , unsigned size>
T const & min (T const (&restrict p)[size])
 Return the minimum of size values.
template<typename T >
T & minEQ (T &a, T &b)
 Return a reference to the smaller of the two arguments.
template<typename T >
T & minEV (T &a, T &b)
 Return a reference to the smaller of the two arguments.
template<typename T >
T & minGE (T &a, T &b)
 Return a reference to the smaller of the two arguments.
template<typename T >
T & minGT (T &a, T &b)
 Return a reference to the smaller of the two arguments.
template<typename T >
T & minLE (T &a, T &b)
 Return a reference to the smaller of the two arguments.
template<typename T >
T & minLT (T &a, T &b)
 Return a reference to the smaller of the two arguments.
template<typename T >
T & minNE (T &a, T &b)
 Return a reference to the smaller of the two arguments.
template<typename T >
T & minNV (T &a, T &b)
 Return a reference to the smaller of the two arguments.
template<typename T , unsigned k>
void mix2 (T &a, T &b, T const &c)
void monom (double *const (double) X, size_t d, double const x)
template<unsigned d>
void monom (double((double)&X)[d], double const x)
void monom (double *const (double *) X, size_t d, double const x)
template<typename T >
size_t monotoneEQ (T const *source, size_t len, T const *carry)
 same as _monotone::op(T const*, size_t, T const*)
template<typename T >
size_t monotoneEQ (T const *source, size_t len)
 same as _monotone::op(T const*, size_t)
template<typename T >
size_t monotoneEQ (T *target, T const *source, size_t len, T const *carry)
 same as _monotone::op(T*, T const*, size_t, T const*)
template<typename T >
size_t monotoneEQ (T *target, T const *source, size_t len)
 same as _monotone::op(T*, T const*, size_t)
template size_t monotoneEQ< bool > (bool const *source, size_t len, bool const *carry)
template size_t monotoneEQ< bool > (bool const *source, size_t len)
template size_t monotoneEQ< bool > (bool *target, bool const *source, size_t len, bool const *carry)
template size_t monotoneEQ< bool > (bool *target, bool const *source, size_t len)
template size_t monotoneEQ< char > (char const *source, size_t len, char const *carry)
template size_t monotoneEQ< char > (char const *source, size_t len)
template size_t monotoneEQ< char > (char *target, char const *source, size_t len, char const *carry)
template size_t monotoneEQ< char > (char *target, char const *source, size_t len)
template size_t monotoneEQ< double > (double const *source, size_t len, double const *carry)
template size_t monotoneEQ< double > (double const *source, size_t len)
template size_t monotoneEQ< double > (double *target, double const *source, size_t len, double const *carry)
template size_t monotoneEQ< double > (double *target, double const *source, size_t len)
template size_t monotoneEQ< float > (float const *source, size_t len, float const *carry)
template size_t monotoneEQ< float > (float const *source, size_t len)
template size_t monotoneEQ< float > (float *target, float const *source, size_t len, float const *carry)
template size_t monotoneEQ< float > (float *target, float const *source, size_t len)
template size_t monotoneEQ< long > (long const *source, size_t len, long const *carry)
template size_t monotoneEQ< long > (long const *source, size_t len)
template size_t monotoneEQ< long > (long *target, long const *source, size_t len, long const *carry)
template size_t monotoneEQ< long > (long *target, long const *source, size_t len)
template size_t monotoneEQ< long double > (long double const *source, size_t len, long double const *carry)
template size_t monotoneEQ< long double > (long double const *source, size_t len)
template size_t monotoneEQ< long double > (long double *target, long double const *source, size_t len, long double const *carry)
template size_t monotoneEQ< long double > (long double *target, long double const *source, size_t len)
template size_t monotoneEQ< long long > (long long const *source, size_t len, long long const *carry)
template size_t monotoneEQ< long long > (long long const *source, size_t len)
template size_t monotoneEQ< long long > (long long *target, long long const *source, size_t len, long long const *carry)
template size_t monotoneEQ< long long > (long long *target, long long const *source, size_t len)
template size_t monotoneEQ< schar > (schar const *source, size_t len, schar const *carry)
template size_t monotoneEQ< schar > (schar const *source, size_t len)
template size_t monotoneEQ< schar > (schar *target, schar const *source, size_t len, schar const *carry)
template size_t monotoneEQ< schar > (schar *target, schar const *source, size_t len)
template size_t monotoneEQ< short > (short const *source, size_t len, short const *carry)
template size_t monotoneEQ< short > (short const *source, size_t len)
template size_t monotoneEQ< short > (short *target, short const *source, size_t len, short const *carry)
template size_t monotoneEQ< short > (short *target, short const *source, size_t len)
template size_t monotoneEQ< signed > (signed const *source, size_t len, signed const *carry)
template size_t monotoneEQ< signed > (signed const *source, size_t len)
template size_t monotoneEQ< signed > (signed *target, signed const *source, size_t len, signed const *carry)
template size_t monotoneEQ< signed > (signed *target, signed const *source, size_t len)
template size_t monotoneEQ< uchar > (uchar const *source, size_t len, uchar const *carry)
template size_t monotoneEQ< uchar > (uchar const *source, size_t len)
template size_t monotoneEQ< uchar > (uchar *target, uchar const *source, size_t len, uchar const *carry)
template size_t monotoneEQ< uchar > (uchar *target, uchar const *source, size_t len)
template size_t monotoneEQ< ulong > (ulong const *source, size_t len, ulong const *carry)
template size_t monotoneEQ< ulong > (ulong const *source, size_t len)
template size_t monotoneEQ< ulong > (ulong *target, ulong const *source, size_t len, ulong const *carry)
template size_t monotoneEQ< ulong > (ulong *target, ulong const *source, size_t len)
template size_t monotoneEQ< unsigned > (unsigned const *source, size_t len, unsigned const *carry)
template size_t monotoneEQ< unsigned > (unsigned const *source, size_t len)
template size_t monotoneEQ< unsigned > (unsigned *target, unsigned const *source, size_t len, unsigned const *carry)
template size_t monotoneEQ< unsigned > (unsigned *target, unsigned const *source, size_t len)
template size_t monotoneEQ< unsigned long long > (unsigned long long const *source, size_t len, unsigned long long const *carry)
template size_t monotoneEQ< unsigned long long > (unsigned long long const *source, size_t len)
template size_t monotoneEQ< unsigned long long > (unsigned long long *target, unsigned long long const *source, size_t len, unsigned long long const *carry)
template size_t monotoneEQ< unsigned long long > (unsigned long long *target, unsigned long long const *source, size_t len)
template size_t monotoneEQ< ushort > (ushort const *source, size_t len, ushort const *carry)
template size_t monotoneEQ< ushort > (ushort const *source, size_t len)
template size_t monotoneEQ< ushort > (ushort *target, ushort const *source, size_t len, ushort const *carry)
template size_t monotoneEQ< ushort > (ushort *target, ushort const *source, size_t len)
template<typename T >
size_t monotoneEV (T const *source, size_t len, T const *carry)
 same as _monotone::op(T const*, size_t, T const*)
template<typename T >
size_t monotoneEV (T const *source, size_t len)
 same as _monotone::op(T const*, size_t)
template<typename T >
size_t monotoneEV (T *target, T const *source, size_t len, T const *carry)
 same as _monotone::op(T*, T const*, size_t, T const*)
template<typename T >
size_t monotoneEV (T *target, T const *source, size_t len)
 same as _monotone::op(T*, T const*, size_t)
template<typename T >
size_t monotoneGE (T const *source, size_t len, T const *carry)
 same as _monotone::op(T const*, size_t, T const*)
template<typename T >
size_t monotoneGE (T const *source, size_t len)
 same as _monotone::op(T const*, size_t)
template<typename T >
size_t monotoneGE (T *target, T const *source, size_t len, T const *carry)
 same as _monotone::op(T*, T const*, size_t, T const*)
template<typename T >
size_t monotoneGE (T *target, T const *source, size_t len)
 same as _monotone::op(T*, T const*, size_t)
template size_t monotoneGE< bool > (bool const *source, size_t len, bool const *carry)
template size_t monotoneGE< bool > (bool const *source, size_t len)
template size_t monotoneGE< bool > (bool *target, bool const *source, size_t len, bool const *carry)
template size_t monotoneGE< bool > (bool *target, bool const *source, size_t len)
template size_t monotoneGE< char > (char const *source, size_t len, char const *carry)
template size_t monotoneGE< char > (char const *source, size_t len)
template size_t monotoneGE< char > (char *target, char const *source, size_t len, char const *carry)
template size_t monotoneGE< char > (char *target, char const *source, size_t len)
template size_t monotoneGE< double > (double const *source, size_t len, double const *carry)
template size_t monotoneGE< double > (double const *source, size_t len)
template size_t monotoneGE< double > (double *target, double const *source, size_t len, double const *carry)
template size_t monotoneGE< double > (double *target, double const *source, size_t len)
template size_t monotoneGE< float > (float const *source, size_t len, float const *carry)
template size_t monotoneGE< float > (float const *source, size_t len)
template size_t monotoneGE< float > (float *target, float const *source, size_t len, float const *carry)
template size_t monotoneGE< float > (float *target, float const *source, size_t len)
template size_t monotoneGE< long > (long const *source, size_t len, long const *carry)
template size_t monotoneGE< long > (long const *source, size_t len)
template size_t monotoneGE< long > (long *target, long const *source, size_t len, long const *carry)
template size_t monotoneGE< long > (long *target, long const *source, size_t len)
template size_t monotoneGE< long double > (long double const *source, size_t len, long double const *carry)
template size_t monotoneGE< long double > (long double const *source, size_t len)
template size_t monotoneGE< long double > (long double *target, long double const *source, size_t len, long double const *carry)
template size_t monotoneGE< long double > (long double *target, long double const *source, size_t len)
template size_t monotoneGE< long long > (long long const *source, size_t len, long long const *carry)
template size_t monotoneGE< long long > (long long const *source, size_t len)
template size_t monotoneGE< long long > (long long *target, long long const *source, size_t len, long long const *carry)
template size_t monotoneGE< long long > (long long *target, long long const *source, size_t len)
template size_t monotoneGE< schar > (schar const *source, size_t len, schar const *carry)
template size_t monotoneGE< schar > (schar const *source, size_t len)
template size_t monotoneGE< schar > (schar *target, schar const *source, size_t len, schar const *carry)
template size_t monotoneGE< schar > (schar *target, schar const *source, size_t len)
template size_t monotoneGE< short > (short const *source, size_t len, short const *carry)
template size_t monotoneGE< short > (short const *source, size_t len)
template size_t monotoneGE< short > (short *target, short const *source, size_t len, short const *carry)
template size_t monotoneGE< short > (short *target, short const *source, size_t len)
template size_t monotoneGE< signed > (signed const *source, size_t len, signed const *carry)
template size_t monotoneGE< signed > (signed const *source, size_t len)
template size_t monotoneGE< signed > (signed *target, signed const *source, size_t len, signed const *carry)
template size_t monotoneGE< signed > (signed *target, signed const *source, size_t len)
template size_t monotoneGE< uchar > (uchar const *source, size_t len, uchar const *carry)
template size_t monotoneGE< uchar > (uchar const *source, size_t len)
template size_t monotoneGE< uchar > (uchar *target, uchar const *source, size_t len, uchar const *carry)
template size_t monotoneGE< uchar > (uchar *target, uchar const *source, size_t len)
template size_t monotoneGE< ulong > (ulong const *source, size_t len, ulong const *carry)
template size_t monotoneGE< ulong > (ulong const *source, size_t len)
template size_t monotoneGE< ulong > (ulong *target, ulong const *source, size_t len, ulong const *carry)
template size_t monotoneGE< ulong > (ulong *target, ulong const *source, size_t len)
template size_t monotoneGE< unsigned > (unsigned const *source, size_t len, unsigned const *carry)
template size_t monotoneGE< unsigned > (unsigned const *source, size_t len)
template size_t monotoneGE< unsigned > (unsigned *target, unsigned const *source, size_t len, unsigned const *carry)
template size_t monotoneGE< unsigned > (unsigned *target, unsigned const *source, size_t len)
template size_t monotoneGE< unsigned long long > (unsigned long long const *source, size_t len, unsigned long long const *carry)
template size_t monotoneGE< unsigned long long > (unsigned long long const *source, size_t len)
template size_t monotoneGE< unsigned long long > (unsigned long long *target, unsigned long long const *source, size_t len, unsigned long long const *carry)
template size_t monotoneGE< unsigned long long > (unsigned long long *target, unsigned long long const *source, size_t len)
template size_t monotoneGE< ushort > (ushort const *source, size_t len, ushort const *carry)
template size_t monotoneGE< ushort > (ushort const *source, size_t len)
template size_t monotoneGE< ushort > (ushort *target, ushort const *source, size_t len, ushort const *carry)
template size_t monotoneGE< ushort > (ushort *target, ushort const *source, size_t len)
template<typename T >
size_t monotoneGT (T const *source, size_t len, T const *carry)
 same as _monotone::op(T const*, size_t, T const*)
template<typename T >
size_t monotoneGT (T const *source, size_t len)
 same as _monotone::op(T const*, size_t)
template<typename T >
size_t monotoneGT (T *target, T const *source, size_t len, T const *carry)
 same as _monotone::op(T*, T const*, size_t, T const*)
template<typename T >
size_t monotoneGT (T *target, T const *source, size_t len)
 same as _monotone::op(T*, T const*, size_t)
template size_t monotoneGT< bool > (bool const *source, size_t len, bool const *carry)
template size_t monotoneGT< bool > (bool const *source, size_t len)
template size_t monotoneGT< bool > (bool *target, bool const *source, size_t len, bool const *carry)
template size_t monotoneGT< bool > (bool *target, bool const *source, size_t len)
template size_t monotoneGT< char > (char const *source, size_t len, char const *carry)
template size_t monotoneGT< char > (char const *source, size_t len)
template size_t monotoneGT< char > (char *target, char const *source, size_t len, char const *carry)
template size_t monotoneGT< char > (char *target, char const *source, size_t len)
template size_t monotoneGT< double > (double const *source, size_t len, double const *carry)
template size_t monotoneGT< double > (double const *source, size_t len)
template size_t monotoneGT< double > (double *target, double const *source, size_t len, double const *carry)
template size_t monotoneGT< double > (double *target, double const *source, size_t len)
template size_t monotoneGT< float > (float const *source, size_t len, float const *carry)
template size_t monotoneGT< float > (float const *source, size_t len)
template size_t monotoneGT< float > (float *target, float const *source, size_t len, float const *carry)
template size_t monotoneGT< float > (float *target, float const *source, size_t len)
template size_t monotoneGT< long > (long const *source, size_t len, long const *carry)
template size_t monotoneGT< long > (long const *source, size_t len)
template size_t monotoneGT< long > (long *target, long const *source, size_t len, long const *carry)
template size_t monotoneGT< long > (long *target, long const *source, size_t len)
template size_t monotoneGT< long double > (long double const *source, size_t len, long double const *carry)
template size_t monotoneGT< long double > (long double const *source, size_t len)
template size_t monotoneGT< long double > (long double *target, long double const *source, size_t len, long double const *carry)
template size_t monotoneGT< long double > (long double *target, long double const *source, size_t len)
template size_t monotoneGT< long long > (long long const *source, size_t len, long long const *carry)
template size_t monotoneGT< long long > (long long const *source, size_t len)
template size_t monotoneGT< long long > (long long *target, long long const *source, size_t len, long long const *carry)
template size_t monotoneGT< long long > (long long *target, long long const *source, size_t len)
template size_t monotoneGT< schar > (schar const *source, size_t len, schar const *carry)
template size_t monotoneGT< schar > (schar const *source, size_t len)
template size_t monotoneGT< schar > (schar *target, schar const *source, size_t len, schar const *carry)
template size_t monotoneGT< schar > (schar *target, schar const *source, size_t len)
template size_t monotoneGT< short > (short const *source, size_t len, short const *carry)
template size_t monotoneGT< short > (short const *source, size_t len)
template size_t monotoneGT< short > (short *target, short const *source, size_t len, short const *carry)
template size_t monotoneGT< short > (short *target, short const *source, size_t len)
template size_t monotoneGT< signed > (signed const *source, size_t len, signed const *carry)
template size_t monotoneGT< signed > (signed const *source, size_t len)
template size_t monotoneGT< signed > (signed *target, signed const *source, size_t len, signed const *carry)
template size_t monotoneGT< signed > (signed *target, signed const *source, size_t len)
template size_t monotoneGT< uchar > (uchar const *source, size_t len, uchar const *carry)
template size_t monotoneGT< uchar > (uchar const *source, size_t len)
template size_t monotoneGT< uchar > (uchar *target, uchar const *source, size_t len, uchar const *carry)
template size_t monotoneGT< uchar > (uchar *target, uchar const *source, size_t len)
template size_t monotoneGT< ulong > (ulong const *source, size_t len, ulong const *carry)
template size_t monotoneGT< ulong > (ulong const *source, size_t len)
template size_t monotoneGT< ulong > (ulong *target, ulong const *source, size_t len, ulong const *carry)
template size_t monotoneGT< ulong > (ulong *target, ulong const *source, size_t len)
template size_t monotoneGT< unsigned > (unsigned const *source, size_t len, unsigned const *carry)
template size_t monotoneGT< unsigned > (unsigned const *source, size_t len)
template size_t monotoneGT< unsigned > (unsigned *target, unsigned const *source, size_t len, unsigned const *carry)
template size_t monotoneGT< unsigned > (unsigned *target, unsigned const *source, size_t len)
template size_t monotoneGT< unsigned long long > (unsigned long long const *source, size_t len, unsigned long long const *carry)
template size_t monotoneGT< unsigned long long > (unsigned long long const *source, size_t len)
template size_t monotoneGT< unsigned long long > (unsigned long long *target, unsigned long long const *source, size_t len, unsigned long long const *carry)
template size_t monotoneGT< unsigned long long > (unsigned long long *target, unsigned long long const *source, size_t len)
template size_t monotoneGT< ushort > (ushort const *source, size_t len, ushort const *carry)
template size_t monotoneGT< ushort > (ushort const *source, size_t len)
template size_t monotoneGT< ushort > (ushort *target, ushort const *source, size_t len, ushort const *carry)
template size_t monotoneGT< ushort > (ushort *target, ushort const *source, size_t len)
template<typename T >
size_t monotoneLE (T const *source, size_t len, T const *carry)
 same as _monotone::op(T const*, size_t, T const*)
template<typename T >
size_t monotoneLE (T const *source, size_t len)
 same as _monotone::op(T const*, size_t)
template<typename T >
size_t monotoneLE (T *target, T const *source, size_t len, T const *carry)
 same as _monotone::op(T*, T const*, size_t, T const*)
template<typename T >
size_t monotoneLE (T *target, T const *source, size_t len)
 same as _monotone::op(T*, T const*, size_t)
template size_t monotoneLE< bool > (bool const *source, size_t len, bool const *carry)
template size_t monotoneLE< bool > (bool const *source, size_t len)
template size_t monotoneLE< bool > (bool *target, bool const *source, size_t len, bool const *carry)
template size_t monotoneLE< bool > (bool *target, bool const *source, size_t len)
template size_t monotoneLE< char > (char const *source, size_t len, char const *carry)
template size_t monotoneLE< char > (char const *source, size_t len)
template size_t monotoneLE< char > (char *target, char const *source, size_t len, char const *carry)
template size_t monotoneLE< char > (char *target, char const *source, size_t len)
template size_t monotoneLE< double > (double const *source, size_t len, double const *carry)
template size_t monotoneLE< double > (double const *source, size_t len)
template size_t monotoneLE< double > (double *target, double const *source, size_t len, double const *carry)
template size_t monotoneLE< double > (double *target, double const *source, size_t len)
template size_t monotoneLE< float > (float const *source, size_t len, float const *carry)
template size_t monotoneLE< float > (float const *source, size_t len)
template size_t monotoneLE< float > (float *target, float const *source, size_t len, float const *carry)
template size_t monotoneLE< float > (float *target, float const *source, size_t len)
template size_t monotoneLE< long > (long const *source, size_t len, long const *carry)
template size_t monotoneLE< long > (long const *source, size_t len)
template size_t monotoneLE< long > (long *target, long const *source, size_t len, long const *carry)
template size_t monotoneLE< long > (long *target, long const *source, size_t len)
template size_t monotoneLE< long double > (long double const *source, size_t len, long double const *carry)
template size_t monotoneLE< long double > (long double const *source, size_t len)
template size_t monotoneLE< long double > (long double *target, long double const *source, size_t len, long double const *carry)
template size_t monotoneLE< long double > (long double *target, long double const *source, size_t len)
template size_t monotoneLE< long long > (long long const *source, size_t len, long long const *carry)
template size_t monotoneLE< long long > (long long const *source, size_t len)
template size_t monotoneLE< long long > (long long *target, long long const *source, size_t len, long long const *carry)
template size_t monotoneLE< long long > (long long *target, long long const *source, size_t len)
template size_t monotoneLE< schar > (schar const *source, size_t len, schar const *carry)
template size_t monotoneLE< schar > (schar const *source, size_t len)
template size_t monotoneLE< schar > (schar *target, schar const *source, size_t len, schar const *carry)
template size_t monotoneLE< schar > (schar *target, schar const *source, size_t len)
template size_t monotoneLE< short > (short const *source, size_t len, short const *carry)
template size_t monotoneLE< short > (short const *source, size_t len)
template size_t monotoneLE< short > (short *target, short const *source, size_t len, short const *carry)
template size_t monotoneLE< short > (short *target, short const *source, size_t len)
template size_t monotoneLE< signed > (signed const *source, size_t len, signed const *carry)
template size_t monotoneLE< signed > (signed const *source, size_t len)
template size_t monotoneLE< signed > (signed *target, signed const *source, size_t len, signed const *carry)
template size_t monotoneLE< signed > (signed *target, signed const *source, size_t len)
template size_t monotoneLE< uchar > (uchar const *source, size_t len, uchar const *carry)
template size_t monotoneLE< uchar > (uchar const *source, size_t len)
template size_t monotoneLE< uchar > (uchar *target, uchar const *source, size_t len, uchar const *carry)
template size_t monotoneLE< uchar > (uchar *target, uchar const *source, size_t len)
template size_t monotoneLE< ulong > (ulong const *source, size_t len, ulong const *carry)
template size_t monotoneLE< ulong > (ulong const *source, size_t len)
template size_t monotoneLE< ulong > (ulong *target, ulong const *source, size_t len, ulong const *carry)
template size_t monotoneLE< ulong > (ulong *target, ulong const *source, size_t len)
template size_t monotoneLE< unsigned > (unsigned const *source, size_t len, unsigned const *carry)
template size_t monotoneLE< unsigned > (unsigned const *source, size_t len)
template size_t monotoneLE< unsigned > (unsigned *target, unsigned const *source, size_t len, unsigned const *carry)
template size_t monotoneLE< unsigned > (unsigned *target, unsigned const *source, size_t len)
template size_t monotoneLE< unsigned long long > (unsigned long long const *source, size_t len, unsigned long long const *carry)
template size_t monotoneLE< unsigned long long > (unsigned long long const *source, size_t len)
template size_t monotoneLE< unsigned long long > (unsigned long long *target, unsigned long long const *source, size_t len, unsigned long long const *carry)
template size_t monotoneLE< unsigned long long > (unsigned long long *target, unsigned long long const *source, size_t len)
template size_t monotoneLE< ushort > (ushort const *source, size_t len, ushort const *carry)
template size_t monotoneLE< ushort > (ushort const *source, size_t len)
template size_t monotoneLE< ushort > (ushort *target, ushort const *source, size_t len, ushort const *carry)
template size_t monotoneLE< ushort > (ushort *target, ushort const *source, size_t len)
template<typename T >
size_t monotoneLT (T const *source, size_t len, T const *carry)
 same as _monotone::op(T const*, size_t, T const*)
template<typename T >
size_t monotoneLT (T const *source, size_t len)
 same as _monotone::op(T const*, size_t)
template<typename T >
size_t monotoneLT (T *target, T const *source, size_t len, T const *carry)
 same as _monotone::op(T*, T const*, size_t, T const*)
template<typename T >
size_t monotoneLT (T *target, T const *source, size_t len)
 same as _monotone::op(T*, T const*, size_t)
template size_t monotoneLT< bool > (bool const *source, size_t len, bool const *carry)
template size_t monotoneLT< bool > (bool const *source, size_t len)
template size_t monotoneLT< bool > (bool *target, bool const *source, size_t len, bool const *carry)
template size_t monotoneLT< bool > (bool *target, bool const *source, size_t len)
template size_t monotoneLT< char > (char const *source, size_t len, char const *carry)
template size_t monotoneLT< char > (char const *source, size_t len)
template size_t monotoneLT< char > (char *target, char const *source, size_t len, char const *carry)
template size_t monotoneLT< char > (char *target, char const *source, size_t len)
template size_t monotoneLT< double > (double const *source, size_t len, double const *carry)
template size_t monotoneLT< double > (double const *source, size_t len)
template size_t monotoneLT< double > (double *target, double const *source, size_t len, double const *carry)
template size_t monotoneLT< double > (double *target, double const *source, size_t len)
template size_t monotoneLT< float > (float const *source, size_t len, float const *carry)
template size_t monotoneLT< float > (float const *source, size_t len)
template size_t monotoneLT< float > (float *target, float const *source, size_t len, float const *carry)
template size_t monotoneLT< float > (float *target, float const *source, size_t len)
template size_t monotoneLT< long > (long const *source, size_t len, long const *carry)
template size_t monotoneLT< long > (long const *source, size_t len)
template size_t monotoneLT< long > (long *target, long const *source, size_t len, long const *carry)
template size_t monotoneLT< long > (long *target, long const *source, size_t len)
template size_t monotoneLT< long double > (long double const *source, size_t len, long double const *carry)
template size_t monotoneLT< long double > (long double const *source, size_t len)
template size_t monotoneLT< long double > (long double *target, long double const *source, size_t len, long double const *carry)
template size_t monotoneLT< long double > (long double *target, long double const *source, size_t len)
template size_t monotoneLT< long long > (long long const *source, size_t len, long long const *carry)
template size_t monotoneLT< long long > (long long const *source, size_t len)
template size_t monotoneLT< long long > (long long *target, long long const *source, size_t len, long long const *carry)
template size_t monotoneLT< long long > (long long *target, long long const *source, size_t len)
template size_t monotoneLT< schar > (schar const *source, size_t len, schar const *carry)
template size_t monotoneLT< schar > (schar const *source, size_t len)
template size_t monotoneLT< schar > (schar *target, schar const *source, size_t len, schar const *carry)
template size_t monotoneLT< schar > (schar *target, schar const *source, size_t len)
template size_t monotoneLT< short > (short const *source, size_t len, short const *carry)
template size_t monotoneLT< short > (short const *source, size_t len)
template size_t monotoneLT< short > (short *target, short const *source, size_t len, short const *carry)
template size_t monotoneLT< short > (short *target, short const *source, size_t len)
template size_t monotoneLT< signed > (signed const *source, size_t len, signed const *carry)
template size_t monotoneLT< signed > (signed const *source, size_t len)
template size_t monotoneLT< signed > (signed *target, signed const *source, size_t len, signed const *carry)
template size_t monotoneLT< signed > (signed *target, signed const *source, size_t len)
template size_t monotoneLT< uchar > (uchar const *source, size_t len, uchar const *carry)
template size_t monotoneLT< uchar > (uchar const *source, size_t len)
template size_t monotoneLT< uchar > (uchar *target, uchar const *source, size_t len, uchar const *carry)
template size_t monotoneLT< uchar > (uchar *target, uchar const *source, size_t len)
template size_t monotoneLT< ulong > (ulong const *source, size_t len, ulong const *carry)
template size_t monotoneLT< ulong > (ulong const *source, size_t len)
template size_t monotoneLT< ulong > (ulong *target, ulong const *source, size_t len, ulong const *carry)
template size_t monotoneLT< ulong > (ulong *target, ulong const *source, size_t len)
template size_t monotoneLT< unsigned > (unsigned const *source, size_t len, unsigned const *carry)
template size_t monotoneLT< unsigned > (unsigned const *source, size_t len)
template size_t monotoneLT< unsigned > (unsigned *target, unsigned const *source, size_t len, unsigned const *carry)
template size_t monotoneLT< unsigned > (unsigned *target, unsigned const *source, size_t len)
template size_t monotoneLT< unsigned long long > (unsigned long long const *source, size_t len, unsigned long long const *carry)
template size_t monotoneLT< unsigned long long > (unsigned long long const *source, size_t len)
template size_t monotoneLT< unsigned long long > (unsigned long long *target, unsigned long long const *source, size_t len, unsigned long long const *carry)
template size_t monotoneLT< unsigned long long > (unsigned long long *target, unsigned long long const *source, size_t len)
template size_t monotoneLT< ushort > (ushort const *source, size_t len, ushort const *carry)
template size_t monotoneLT< ushort > (ushort const *source, size_t len)
template size_t monotoneLT< ushort > (ushort *target, ushort const *source, size_t len, ushort const *carry)
template size_t monotoneLT< ushort > (ushort *target, ushort const *source, size_t len)
template<typename T >
size_t monotoneNE (T const *source, size_t len, T const *carry)
 same as _monotone::op(T const*, size_t, T const*)
template<typename T >
size_t monotoneNE (T const *source, size_t len)
 same as _monotone::op(T const*, size_t)
template<typename T >
size_t monotoneNE (T *target, T const *source, size_t len, T const *carry)
 same as _monotone::op(T*, T const*, size_t, T const*)
template<typename T >
size_t monotoneNE (T *target, T const *source, size_t len)
 same as _monotone::op(T*, T const*, size_t)
template size_t monotoneNE< bool > (bool const *source, size_t len, bool const *carry)
template size_t monotoneNE< bool > (bool const *source, size_t len)
template size_t monotoneNE< bool > (bool *target, bool const *source, size_t len, bool const *carry)
template size_t monotoneNE< bool > (bool *target, bool const *source, size_t len)
template size_t monotoneNE< char > (char const *source, size_t len, char const *carry)
template size_t monotoneNE< char > (char const *source, size_t len)
template size_t monotoneNE< char > (char *target, char const *source, size_t len, char const *carry)
template size_t monotoneNE< char > (char *target, char const *source, size_t len)
template size_t monotoneNE< double > (double const *source, size_t len, double const *carry)
template size_t monotoneNE< double > (double const *source, size_t len)
template size_t monotoneNE< double > (double *target, double const *source, size_t len, double const *carry)
template size_t monotoneNE< double > (double *target, double const *source, size_t len)
template size_t monotoneNE< float > (float const *source, size_t len, float const *carry)
template size_t monotoneNE< float > (float const *source, size_t len)
template size_t monotoneNE< float > (float *target, float const *source, size_t len, float const *carry)
template size_t monotoneNE< float > (float *target, float const *source, size_t len)
template size_t monotoneNE< long > (long const *source, size_t len, long const *carry)
template size_t monotoneNE< long > (long const *source, size_t len)
template size_t monotoneNE< long > (long *target, long const *source, size_t len, long const *carry)
template size_t monotoneNE< long > (long *target, long const *source, size_t len)
template size_t monotoneNE< long double > (long double const *source, size_t len, long double const *carry)
template size_t monotoneNE< long double > (long double const *source, size_t len)
template size_t monotoneNE< long double > (long double *target, long double const *source, size_t len, long double const *carry)
template size_t monotoneNE< long double > (long double *target, long double const *source, size_t len)
template size_t monotoneNE< long long > (long long const *source, size_t len, long long const *carry)
template size_t monotoneNE< long long > (long long const *source, size_t len)
template size_t monotoneNE< long long > (long long *target, long long const *source, size_t len, long long const *carry)
template size_t monotoneNE< long long > (long long *target, long long const *source, size_t len)
template size_t monotoneNE< schar > (schar const *source, size_t len, schar const *carry)
template size_t monotoneNE< schar > (schar const *source, size_t len)
template size_t monotoneNE< schar > (schar *target, schar const *source, size_t len, schar const *carry)
template size_t monotoneNE< schar > (schar *target, schar const *source, size_t len)
template size_t monotoneNE< short > (short const *source, size_t len, short const *carry)
template size_t monotoneNE< short > (short const *source, size_t len)
template size_t monotoneNE< short > (short *target, short const *source, size_t len, short const *carry)
template size_t monotoneNE< short > (short *target, short const *source, size_t len)
template size_t monotoneNE< signed > (signed const *source, size_t len, signed const *carry)
template size_t monotoneNE< signed > (signed const *source, size_t len)
template size_t monotoneNE< signed > (signed *target, signed const *source, size_t len, signed const *carry)
template size_t monotoneNE< signed > (signed *target, signed const *source, size_t len)
template size_t monotoneNE< uchar > (uchar const *source, size_t len, uchar const *carry)
template size_t monotoneNE< uchar > (uchar const *source, size_t len)
template size_t monotoneNE< uchar > (uchar *target, uchar const *source, size_t len, uchar const *carry)
template size_t monotoneNE< uchar > (uchar *target, uchar const *source, size_t len)
template size_t monotoneNE< ulong > (ulong const *source, size_t len, ulong const *carry)
template size_t monotoneNE< ulong > (ulong const *source, size_t len)
template size_t monotoneNE< ulong > (ulong *target, ulong const *source, size_t len, ulong const *carry)
template size_t monotoneNE< ulong > (ulong *target, ulong const *source, size_t len)
template size_t monotoneNE< unsigned > (unsigned const *source, size_t len, unsigned const *carry)
template size_t monotoneNE< unsigned > (unsigned const *source, size_t len)
template size_t monotoneNE< unsigned > (unsigned *target, unsigned const *source, size_t len, unsigned const *carry)
template size_t monotoneNE< unsigned > (unsigned *target, unsigned const *source, size_t len)
template size_t monotoneNE< unsigned long long > (unsigned long long const *source, size_t len, unsigned long long const *carry)
template size_t monotoneNE< unsigned long long > (unsigned long long const *source, size_t len)
template size_t monotoneNE< unsigned long long > (unsigned long long *target, unsigned long long const *source, size_t len, unsigned long long const *carry)
template size_t monotoneNE< unsigned long long > (unsigned long long *target, unsigned long long const *source, size_t len)
template size_t monotoneNE< ushort > (ushort const *source, size_t len, ushort const *carry)
template size_t monotoneNE< ushort > (ushort const *source, size_t len)
template size_t monotoneNE< ushort > (ushort *target, ushort const *source, size_t len, ushort const *carry)
template size_t monotoneNE< ushort > (ushort *target, ushort const *source, size_t len)
template<typename T >
size_t monotoneNV (T const *source, size_t len, T const *carry)
 same as _monotone::op(T const*, size_t, T const*)
template<typename T >
size_t monotoneNV (T const *source, size_t len)
 same as _monotone::op(T const*, size_t)
template<typename T >
size_t monotoneNV (T *target, T const *source, size_t len, T const *carry)
 same as _monotone::op(T*, T const*, size_t, T const*)
template<typename T >
size_t monotoneNV (T *target, T const *source, size_t len)
 same as _monotone::op(T*, T const*, size_t)
template<typename T , typename D >
void mult (T &a, D b)
 Specialized form of binary operator*.
template<typename BT >
void multcarry (BT a, BT b, BT &C0, BT &C1)
 Multiply with carry in case of overflow.
template<typename BT >
void multcarry (typename par::cpp::_half_of< BT >::_H a, typename par::cpp::_half_of< BT >::_H b, typename par::cpp::_half_of< BT >::_H &c0, BT &c1)
 Multiply with carry in case of overflow.
template<typename T >
multremain (T a, T b, T const &divisor)
 Accurately compute (a * b) mod divisor, even if (a * b) would overflow within in type T.
template<>
int32_t multremain< int32_t > (int32_t a, int32_t b, int32_t const &divisor)
template<>
int64_t multremain< int64_t > (int64_t a, int64_t b, int64_t const &divisor)
template<>
uint32_t multremain< uint32_t > (uint32_t a, uint32_t b, uint32_t const &divisor)
template<>
uint64_t multremain< uint64_t > (uint64_t a, uint64_t b, uint64_t const &divisor)
template<class T >
static size_t nearMedian13 (T const (&restrict p)[81])
template<class T >
static size_t nearMedian13_min (T const (&restrict p)[81])
template<class T >
static void nearMedian13_minSwap (T &restrict place, T(&restrict p)[81])
template<class T >
static void nearMedian13Swap (T &restrict place, T(&restrict p)[81])
template<class T >
static size_t nearMedian26 (T(&restrict p)[125])
template<class T >
static void nearMedian26Swap (T &restrict place, T(&restrict p)[125])
template<class T >
static size_t nearMedian3 (T const (&restrict p)[9])
template<class T >
static void nearMedian3Swap (T &restrict place, T(&restrict p)[9])
template<class T >
static size_t nearMedian7 (T const (&restrict p)[27])
template<class T >
static void nearMedian7Swap (T &restrict place, T(&restrict p)[27])
template<class T >
static size_t nearMedian8 (T(&restrict p)[25])
template<class T >
static void nearMedian8Swap (T &restrict place, T(&restrict p)[25])
template<size_t dim, typename T , typename S >
bool nextPoint (T(&i)[dim], S const b[])
template<typename T >
void nop (T &val)
template<unsigned pos>
off_t off (off_t flags)
 Switch the flag at pos to false.
template<unsigned pos>
off_t on (off_t flags)
 Switch the flag at pos to true.
template<unsigned dim>
bool operator< (edge< dim > const &restrict a, edge< dim > const &restrict b)
template<unsigned dim>
bool operator<= (edge< dim > const &restrict a, edge< dim > const &restrict b)
template<unsigned dim>
bool operator> (edge< dim > const &restrict a, edge< dim > const &restrict b)
template<unsigned dim>
bool operator>= (edge< dim > const &restrict a, edge< dim > const &restrict b)
template<typename BT >
bool overflow (BT a, BT b)
 Check if multiplication of a and b would overflow.
double physDistance (double lat)
double physLatency (double dist)
template<typename T >
cpp::_plist< T > plist (T *p, size_t l)
 Print a list of l elements in array given by pointer p.
template<class T >
void pnext (T volatile *&restrict p, size_t amount=1)
template<class T >
void pnext (T *&restrict p, size_t amount=1)
template<class T >
void pnext (T volatile *restrict &restrict p, size_t amount=1)
template<class T >
void pnext (T *restrict &restrict p, size_t amount=1)
 Pointer increment and prefetch.
template<class T >
void pprev (T volatile *&restrict p, size_t amount=1)
template<class T >
void pprev (T *&restrict p, size_t amount=1)
template<class T >
void pprev (T volatile *restrict &restrict p, size_t amount=1)
template<class T >
void pprev (T *restrict &restrict p, size_t amount=1)
 Pointer decrement and prefetch.
template<class T >
void prefixMax (size_t const length, T *restrict arrinout)
 Compute the prefix maximum values of the values in arrinout in place.
template<class T >
void prefixMax (T *restrict arrout, size_t const length, T const *restrict arrin)
 Compute the prefix maximum values of the values in arr and return them in arrout.
template<class T >
void prefixMin (size_t const length, T *restrict arrinout)
 Compute the prefix minimum values of the values in arrinout in place.
template<class T >
void prefixMin (T *restrict arrout, size_t const length, T const *restrict arrin)
 Compute the prefix minimum values of the values in arr and return them in arrout.
template<class T , class assignOp >
void prefixOp (size_t const length, T *const arr)
 An in place version of par::prefixOp(T*, size_t length, T const*).
template<class T , class assignOp >
void prefixOp (T *const ret, size_t const length, T const *const arr)
 Semi-optimized prefix sum for operator class assignOp.
template<class T >
void prefixSum (size_t const length, T *restrict arrinout)
 Compute the prefix sum of the values in arrinout in place.
template<class T >
void prefixSum (T *restrict arrout, size_t const length, T const *restrict arrin)
 Compute the prefix sum of the values in arr and return them in arrout.
template<typename T , unsigned k>
press (T x)
 Press x into k bits, by trying not to loose too much of entropy.
template<typename T0 , typename T1 >
void print (FILE *of, format const &fo, T0 const &a0, T1 const &a1)
template<typename T0 >
void print (FILE *of, format const &fo, T0 const &a0)
template<>
void print (FILE *of, format const &fo)
template<typename T0 >
void print (FILE *of, T0 const &a0)
template<unsigned d>
void print (FILE *of, char const o[d])
template<>
void print (str &s, void const *volatile const &o)
template<>
void print (FILE *of, void const *volatile const &o)
template<>
void print (str &s, void const *const &o)
template<>
void print (FILE *of, void const *const &o)
template<>
void print (str &s, schar const *volatile const &o)
template<>
void print (FILE *of, schar const *volatile const &o)
template<>
void print (str &s, schar const *const &o)
template<>
void print (FILE *of, schar const *const &o)
template<>
void print (str &s, uchar const *volatile const &o)
template<>
void print (FILE *of, uchar const *volatile const &o)
template<>
void print (str &s, uchar const *const &o)
template<>
void print (FILE *of, uchar const *const &o)
template<>
void print (str &s, void *volatile const &o)
template<>
void print (FILE *of, void *volatile const &o)
template<>
void print (str &s, void *const &o)
template<>
void print (FILE *of, void *const &o)
template<>
void print (str &s, schar *volatile const &o)
template<>
void print (FILE *of, schar *volatile const &o)
template<>
void print (str &s, schar *const &o)
template<>
void print (FILE *of, schar *const &o)
template<>
void print (str &s, uchar *volatile const &o)
template<>
void print (FILE *of, uchar *volatile const &o)
template<>
void print (str &s, uchar *const &o)
template<>
void print (FILE *of, uchar *const &o)
template<>
void print (str &s, float volatile const &o)
template<>
void print (FILE *of, float volatile const &o)
template<>
void print (str &s, float const &o)
template<>
void print (FILE *of, float const &o)
template<>
void print (str &s, double volatile const &o)
template<>
void print (FILE *of, double volatile const &o)
template<>
void print (str &s, double const &o)
template<>
void print (FILE *of, double const &o)
template<>
void print (str &s, schar volatile const &o)
template<>
void print (FILE *of, schar volatile const &o)
template<>
void print (str &s, schar const &o)
template<>
void print (FILE *of, schar const &o)
template<>
void print (str &s, uchar volatile const &o)
template<>
void print (FILE *of, uchar volatile const &o)
template<>
void print (str &s, uchar const &o)
template<>
void print (FILE *of, uchar const &o)
template<>
void print (str &s, short volatile const &o)
template<>
void print (FILE *of, short volatile const &o)
template<>
void print (str &s, short const &o)
template<>
void print (FILE *of, short const &o)
template<>
void print (str &s, ushort volatile const &o)
template<>
void print (FILE *of, ushort volatile const &o)
template<>
void print (str &s, ushort const &o)
template<>
void print (FILE *of, ushort const &o)
template<>
void print (str &s, ulong volatile const &o)
template<>
void print (FILE *of, ulong volatile const &o)
template<>
void print (str &s, ulong const &o)
template<>
void print (FILE *of, ulong const &o)
template<>
void print (str &s, long volatile const &o)
template<>
void print (FILE *of, long volatile const &o)
template<>
void print (str &s, long const &o)
template<>
void print (FILE *of, long const &o)
template<>
void print (str &s, unsigned volatile const &o)
template<>
void print (FILE *of, unsigned volatile const &o)
template<>
void print (str &s, unsigned const &o)
template<>
void print (FILE *of, unsigned const &o)
template<>
void print (str &s, signed volatile const &o)
template<>
void print (FILE *of, signed volatile const &o)
template<>
void print (str &s, signed const &o)
template<>
void print (FILE *of, signed const &o)
template<typename T >
void print (str &s, T const &o)
 Get the `name' of the value of o, i.e convert o to a readable string.
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
void print (FILE *of, T0 const &a0, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5, T6 const &a6, T7 const &a7, T8 const &a8)
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
void print (FILE *of, T0 const &a0, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5, T6 const &a6, T7 const &a7)
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
void print (FILE *of, T0 const &a0, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5, T6 const &a6)
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
void print (FILE *of, T0 const &a0, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5)
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
void print (FILE *of, T0 const &a0, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4)
template<typename T0 , typename T1 , typename T2 , typename T3 >
void print (FILE *of, T0 const &a0, T1 const &a1, T2 const &a2, T3 const &a3)
template<typename T0 , typename T1 , typename T2 >
void print (FILE *of, T0 const &a0, T1 const &a1, T2 const &a2)
template<typename T0 , typename T1 >
void print (FILE *of, T0 const &a0, T1 const &a1)
template<typename T >
void print (size_t len, FILE *of, T const *o)
 Print a vector o of length len as a comma seperated list to file of.
template<typename T >
void print (FILE *of, T const &o)
 A primitive interface to print out variables of type T.
template<>
void print< bool > (str &s, bool const &o) 2299"<stdin>"
template<>
void print< bool > (FILE *of, bool const &o)
template<>
void print< bool volatile > (str &s, bool volatile const &o) 2299"<stdin>"
template<>
void print< bool volatile > (FILE *of, bool volatile const &o)
template<>
void print< char * > (str &s, char *const &o) 2299"<stdin>"
template<>
void print< char * > (FILE *of, char *const &o)
template<>
void print< char *volatile > (str &s, char *volatile const &o) 2299"<stdin>"
template<>
void print< char *volatile > (FILE *of, char *volatile const &o)
template<>
void print< char > (str &s, char const &o) 2299"<stdin>"
template<>
void print< char > (FILE *of, char const &o)
template<>
void print< char const * > (str &s, char const *const &o) 2299"<stdin>"
template<>
void print< char const * > (FILE *of, char const *const &o)
template<>
void print< char const *volatile > (str &s, char const *volatile const &o) 2299"<stdin>"
template<>
void print< char const *volatile > (FILE *of, char const *volatile const &o)
template<>
void print< char const [1] > (FILE *of, char const (&o)[1])
template<>
void print< char volatile > (str &s, char volatile const &o) 2299"<stdin>"
template<>
void print< char volatile > (FILE *of, char volatile const &o)
template<>
void print< char[1] > (FILE *of, char const (&o)[1])
template<>
void print< double > (str &s, double const &o) 2299"<stdin>"
template<>
void print< double > (FILE *of, double const &o)
template<>
void print< double volatile > (str &s, double volatile const &o) 2299"<stdin>"
template<>
void print< double volatile > (FILE *of, double volatile const &o)
template<>
void print< float > (str &s, float const &o) 2299"<stdin>"
template<>
void print< float > (FILE *of, float const &o)
template<>
void print< float volatile > (str &s, float volatile const &o) 2299"<stdin>"
template<>
void print< float volatile > (FILE *of, float volatile const &o)
template<>
void print< long > (str &s, long const &o) 2299"<stdin>"
template<>
void print< long > (FILE *of, long const &o)
template<>
void print< long volatile > (str &s, long volatile const &o) 2299"<stdin>"
template<>
void print< long volatile > (FILE *of, long volatile const &o)
template<>
void print< par::cpp::mode_t > (FILE *of, par::cpp::mode_t const &o)
template<>
void print< par::cpp::mode_t > (str &s, par::cpp::mode_t const &o)
template<>
void print< par::cpp::mode_t volatile > (FILE *of, par::cpp::mode_t const volatile &o)
template<>
void print< par::cpp::mode_t volatile > (str &s, par::cpp::mode_t const volatile &o)
template<>
void print< par::cpp::nonchar > (FILE *of, par::cpp::nonchar const &o)
template<>
void print< par::cpp::nonchar > (str &s, par::cpp::nonchar const &o)
template<>
void print< par::cpp::nonchar volatile > (FILE *of, par::cpp::nonchar const volatile &o)
template<>
void print< par::cpp::nonchar volatile > (str &s, par::cpp::nonchar const volatile &o)
template<>
void print< schar * > (str &s, schar *const &o) 2299"<stdin>"
template<>
void print< schar * > (FILE *of, schar *const &o)
template<>
void print< schar *volatile > (str &s, schar *volatile const &o) 2299"<stdin>"
template<>
void print< schar *volatile > (FILE *of, schar *volatile const &o)
template<>
void print< schar > (str &s, schar const &o) 2299"<stdin>"
template<>
void print< schar > (FILE *of, schar const &o)
template<>
void print< schar const * > (str &s, schar const *const &o) 2299"<stdin>"
template<>
void print< schar const * > (FILE *of, schar const *const &o)
template<>
void print< schar const *volatile > (str &s, schar const *volatile const &o) 2299"<stdin>"
template<>
void print< schar const *volatile > (FILE *of, schar const *volatile const &o)
template<>
void print< schar volatile > (str &s, schar volatile const &o) 2299"<stdin>"
template<>
void print< schar volatile > (FILE *of, schar volatile const &o)
template<>
void print< short > (str &s, short const &o) 2299"<stdin>"
template<>
void print< short > (FILE *of, short const &o)
template<>
void print< short volatile > (str &s, short volatile const &o) 2299"<stdin>"
template<>
void print< short volatile > (FILE *of, short volatile const &o)
template<>
void print< signed > (str &s, signed const &o) 2299"<stdin>"
template<>
void print< signed > (FILE *of, signed const &o)
template<>
void print< signed volatile > (str &s, signed volatile const &o) 2299"<stdin>"
template<>
void print< signed volatile > (FILE *of, signed volatile const &o)
template<>
void print< uchar * > (str &s, uchar *const &o) 2299"<stdin>"
template<>
void print< uchar * > (FILE *of, uchar *const &o)
template<>
void print< uchar *volatile > (str &s, uchar *volatile const &o) 2299"<stdin>"
template<>
void print< uchar *volatile > (FILE *of, uchar *volatile const &o)
template<>
void print< uchar > (str &s, uchar const &o) 2299"<stdin>"
template<>
void print< uchar > (FILE *of, uchar const &o)
template<>
void print< uchar const * > (str &s, uchar const *const &o) 2299"<stdin>"
template<>
void print< uchar const * > (FILE *of, uchar const *const &o)
template<>
void print< uchar const *volatile > (str &s, uchar const *volatile const &o) 2299"<stdin>"
template<>
void print< uchar const *volatile > (FILE *of, uchar const *volatile const &o)
template<>
void print< uchar volatile > (str &s, uchar volatile const &o) 2299"<stdin>"
template<>
void print< uchar volatile > (FILE *of, uchar volatile const &o)
template<>
void print< ulong > (str &s, ulong const &o) 2299"<stdin>"
template<>
void print< ulong > (FILE *of, ulong const &o)
template<>
void print< ulong volatile > (str &s, ulong volatile const &o) 2299"<stdin>"
template<>
void print< ulong volatile > (FILE *of, ulong volatile const &o)
template<>
void print< unsigned > (str &s, unsigned const &o) 2299"<stdin>"
template<>
void print< unsigned > (FILE *of, unsigned const &o)
template<>
void print< unsigned volatile > (str &s, unsigned volatile const &o) 2299"<stdin>"
template<>
void print< unsigned volatile > (FILE *of, unsigned volatile const &o)
template<>
void print< ushort > (str &s, ushort const &o) 2299"<stdin>"
template<>
void print< ushort > (FILE *of, ushort const &o)
template<>
void print< ushort volatile > (str &s, ushort volatile const &o) 2299"<stdin>"
template<>
void print< ushort volatile > (FILE *of, ushort volatile const &o)
template<>
void print< void * > (str &s, void *const &o) 2299"<stdin>"
template<>
void print< void * > (FILE *of, void *const &o)
template<>
void print< void *volatile > (str &s, void *volatile const &o) 2299"<stdin>"
template<>
void print< void *volatile > (FILE *of, void *volatile const &o)
template<>
void print< void const * > (str &s, void const *const &o) 2299"<stdin>"
template<>
void print< void const * > (FILE *of, void const *const &o)
template<>
void print< void const *volatile > (str &s, void const *volatile const &o) 2299"<stdin>"
template<>
void print< void const *volatile > (FILE *of, void const *volatile const &o)
template<typename E >
void print_bits (FILE *of, unsigned long long val)
template<typename E >
void print_bits (FILE *of, ulong val)
template<typename E >
void print_bits (FILE *of, unsigned val)
template<typename E >
void print_bits (FILE *of, ushort val)
template<typename E >
void print_bits (FILE *of, uchar val)
template<class T >
void probe (T *restrict tab, size_t size, size_t pivot, T *restrict samp, size_t amount)
template<typename T , unsigned d>
prod (T const (&(double) Y)[d], T const (&(double) X)[d])
template<typename T , unsigned d>
prod (T const (&(double[2]) Y)[d], T const (&(double[2]) X)[d])
template<unsigned dn, unsigned dd>
double rational (double const (&num)[dn], double const (&den)[dd], double x)
template<typename T , typename D >
remain (T const &a, D const &divisor)
 Specialized form of operator%.
template<unsigned dim>
size_t removeLoops (edge< dim > E[], size_t len)
int report (char const *format,...)((deprecated))
template<unsigned dim, unsigned where>
void restr (par::cpp::link< 1 > *tarr, edge< dim >const *sarr, size_t length)
template<unsigned b, unsigned length>
void reverse (par::cpp::link< b >(&restrict a)[length], par::cpp::link< b > const (&restrict c)[length])
template<unsigned dim>
void reverse (edge< dim > *tarr, edge< dim >const *sarr, size_t length)
template<unsigned dim>
void reverse (edge< dim > &restrict a, edge< dim > const &restrict b)
template void reverse< 1, 1 > (link< 1 >(&restrict a)[1], link< 1 > const (&restrict c)[1])
template void reverse< 1, 2 > (link< 1 >(&restrict a)[2], link< 1 > const (&restrict c)[2])
template void reverse< 1, 3 > (link< 1 >(&restrict a)[3], link< 1 > const (&restrict c)[3])
template void reverse< 1, 4 > (link< 1 >(&restrict a)[4], link< 1 > const (&restrict c)[4])
template void reverse< 1, 5 > (link< 1 >(&restrict a)[5], link< 1 > const (&restrict c)[5])
template void reverse< 1, 6 > (link< 1 >(&restrict a)[6], link< 1 > const (&restrict c)[6])
template void reverse< 1, 7 > (link< 1 >(&restrict a)[7], link< 1 > const (&restrict c)[7])
template void reverse< 1, 8 > (link< 1 >(&restrict a)[8], link< 1 > const (&restrict c)[8])
template void reverse< 1, 9 > (link< 1 >(&restrict a)[9], link< 1 > const (&restrict c)[9])
template void reverse< 10, 1 > (link< 10 >(&restrict a)[1], link< 10 > const (&restrict c)[1])
template void reverse< 10, 2 > (link< 10 >(&restrict a)[2], link< 10 > const (&restrict c)[2])
template void reverse< 10, 3 > (link< 10 >(&restrict a)[3], link< 10 > const (&restrict c)[3])
template void reverse< 10, 4 > (link< 10 >(&restrict a)[4], link< 10 > const (&restrict c)[4])
template void reverse< 10, 5 > (link< 10 >(&restrict a)[5], link< 10 > const (&restrict c)[5])
template void reverse< 10, 6 > (link< 10 >(&restrict a)[6], link< 10 > const (&restrict c)[6])
template void reverse< 10, 7 > (link< 10 >(&restrict a)[7], link< 10 > const (&restrict c)[7])
template void reverse< 10, 8 > (link< 10 >(&restrict a)[8], link< 10 > const (&restrict c)[8])
template void reverse< 10, 9 > (link< 10 >(&restrict a)[9], link< 10 > const (&restrict c)[9])
template void reverse< 2, 1 > (link< 2 >(&restrict a)[1], link< 2 > const (&restrict c)[1])
template void reverse< 2, 2 > (link< 2 >(&restrict a)[2], link< 2 > const (&restrict c)[2])
template void reverse< 2, 3 > (link< 2 >(&restrict a)[3], link< 2 > const (&restrict c)[3])
template void reverse< 2, 4 > (link< 2 >(&restrict a)[4], link< 2 > const (&restrict c)[4])
template void reverse< 2, 5 > (link< 2 >(&restrict a)[5], link< 2 > const (&restrict c)[5])
template void reverse< 2, 6 > (link< 2 >(&restrict a)[6], link< 2 > const (&restrict c)[6])
template void reverse< 2, 7 > (link< 2 >(&restrict a)[7], link< 2 > const (&restrict c)[7])
template void reverse< 2, 8 > (link< 2 >(&restrict a)[8], link< 2 > const (&restrict c)[8])
template void reverse< 2, 9 > (link< 2 >(&restrict a)[9], link< 2 > const (&restrict c)[9])
template void reverse< 3, 1 > (link< 3 >(&restrict a)[1], link< 3 > const (&restrict c)[1])
template void reverse< 3, 2 > (link< 3 >(&restrict a)[2], link< 3 > const (&restrict c)[2])
template void reverse< 3, 3 > (link< 3 >(&restrict a)[3], link< 3 > const (&restrict c)[3])
template void reverse< 3, 4 > (link< 3 >(&restrict a)[4], link< 3 > const (&restrict c)[4])
template void reverse< 3, 5 > (link< 3 >(&restrict a)[5], link< 3 > const (&restrict c)[5])
template void reverse< 3, 6 > (link< 3 >(&restrict a)[6], link< 3 > const (&restrict c)[6])
template void reverse< 3, 7 > (link< 3 >(&restrict a)[7], link< 3 > const (&restrict c)[7])
template void reverse< 3, 8 > (link< 3 >(&restrict a)[8], link< 3 > const (&restrict c)[8])
template void reverse< 3, 9 > (link< 3 >(&restrict a)[9], link< 3 > const (&restrict c)[9])
template void reverse< 4, 1 > (link< 4 >(&restrict a)[1], link< 4 > const (&restrict c)[1])
template void reverse< 4, 2 > (link< 4 >(&restrict a)[2], link< 4 > const (&restrict c)[2])
template void reverse< 4, 3 > (link< 4 >(&restrict a)[3], link< 4 > const (&restrict c)[3])
template void reverse< 4, 4 > (link< 4 >(&restrict a)[4], link< 4 > const (&restrict c)[4])
template void reverse< 4, 5 > (link< 4 >(&restrict a)[5], link< 4 > const (&restrict c)[5])
template void reverse< 4, 6 > (link< 4 >(&restrict a)[6], link< 4 > const (&restrict c)[6])
template void reverse< 4, 7 > (link< 4 >(&restrict a)[7], link< 4 > const (&restrict c)[7])
template void reverse< 4, 8 > (link< 4 >(&restrict a)[8], link< 4 > const (&restrict c)[8])
template void reverse< 4, 9 > (link< 4 >(&restrict a)[9], link< 4 > const (&restrict c)[9])
template void reverse< 5, 1 > (link< 5 >(&restrict a)[1], link< 5 > const (&restrict c)[1])
template void reverse< 5, 2 > (link< 5 >(&restrict a)[2], link< 5 > const (&restrict c)[2])
template void reverse< 5, 3 > (link< 5 >(&restrict a)[3], link< 5 > const (&restrict c)[3])
template void reverse< 5, 4 > (link< 5 >(&restrict a)[4], link< 5 > const (&restrict c)[4])
template void reverse< 5, 5 > (link< 5 >(&restrict a)[5], link< 5 > const (&restrict c)[5])
template void reverse< 5, 6 > (link< 5 >(&restrict a)[6], link< 5 > const (&restrict c)[6])
template void reverse< 5, 7 > (link< 5 >(&restrict a)[7], link< 5 > const (&restrict c)[7])
template void reverse< 5, 8 > (link< 5 >(&restrict a)[8], link< 5 > const (&restrict c)[8])
template void reverse< 5, 9 > (link< 5 >(&restrict a)[9], link< 5 > const (&restrict c)[9])
template void reverse< 6, 1 > (link< 6 >(&restrict a)[1], link< 6 > const (&restrict c)[1])
template void reverse< 6, 2 > (link< 6 >(&restrict a)[2], link< 6 > const (&restrict c)[2])
template void reverse< 6, 3 > (link< 6 >(&restrict a)[3], link< 6 > const (&restrict c)[3])
template void reverse< 6, 4 > (link< 6 >(&restrict a)[4], link< 6 > const (&restrict c)[4])
template void reverse< 6, 5 > (link< 6 >(&restrict a)[5], link< 6 > const (&restrict c)[5])
template void reverse< 6, 6 > (link< 6 >(&restrict a)[6], link< 6 > const (&restrict c)[6])
template void reverse< 6, 7 > (link< 6 >(&restrict a)[7], link< 6 > const (&restrict c)[7])
template void reverse< 6, 8 > (link< 6 >(&restrict a)[8], link< 6 > const (&restrict c)[8])
template void reverse< 6, 9 > (link< 6 >(&restrict a)[9], link< 6 > const (&restrict c)[9])
template void reverse< 7, 1 > (link< 7 >(&restrict a)[1], link< 7 > const (&restrict c)[1])
template void reverse< 7, 2 > (link< 7 >(&restrict a)[2], link< 7 > const (&restrict c)[2])
template void reverse< 7, 3 > (link< 7 >(&restrict a)[3], link< 7 > const (&restrict c)[3])
template void reverse< 7, 4 > (link< 7 >(&restrict a)[4], link< 7 > const (&restrict c)[4])
template void reverse< 7, 5 > (link< 7 >(&restrict a)[5], link< 7 > const (&restrict c)[5])
template void reverse< 7, 6 > (link< 7 >(&restrict a)[6], link< 7 > const (&restrict c)[6])
template void reverse< 7, 7 > (link< 7 >(&restrict a)[7], link< 7 > const (&restrict c)[7])
template void reverse< 7, 8 > (link< 7 >(&restrict a)[8], link< 7 > const (&restrict c)[8])
template void reverse< 7, 9 > (link< 7 >(&restrict a)[9], link< 7 > const (&restrict c)[9])
template void reverse< 8, 1 > (link< 8 >(&restrict a)[1], link< 8 > const (&restrict c)[1])
template void reverse< 8, 2 > (link< 8 >(&restrict a)[2], link< 8 > const (&restrict c)[2])
template void reverse< 8, 3 > (link< 8 >(&restrict a)[3], link< 8 > const (&restrict c)[3])
template void reverse< 8, 4 > (link< 8 >(&restrict a)[4], link< 8 > const (&restrict c)[4])
template void reverse< 8, 5 > (link< 8 >(&restrict a)[5], link< 8 > const (&restrict c)[5])
template void reverse< 8, 6 > (link< 8 >(&restrict a)[6], link< 8 > const (&restrict c)[6])
template void reverse< 8, 7 > (link< 8 >(&restrict a)[7], link< 8 > const (&restrict c)[7])
template void reverse< 8, 8 > (link< 8 >(&restrict a)[8], link< 8 > const (&restrict c)[8])
template void reverse< 8, 9 > (link< 8 >(&restrict a)[9], link< 8 > const (&restrict c)[9])
template void reverse< 9, 1 > (link< 9 >(&restrict a)[1], link< 9 > const (&restrict c)[1])
template void reverse< 9, 2 > (link< 9 >(&restrict a)[2], link< 9 > const (&restrict c)[2])
template void reverse< 9, 3 > (link< 9 >(&restrict a)[3], link< 9 > const (&restrict c)[3])
template void reverse< 9, 4 > (link< 9 >(&restrict a)[4], link< 9 > const (&restrict c)[4])
template void reverse< 9, 5 > (link< 9 >(&restrict a)[5], link< 9 > const (&restrict c)[5])
template void reverse< 9, 6 > (link< 9 >(&restrict a)[6], link< 9 > const (&restrict c)[6])
template void reverse< 9, 7 > (link< 9 >(&restrict a)[7], link< 9 > const (&restrict c)[7])
template void reverse< 9, 8 > (link< 9 >(&restrict a)[8], link< 9 > const (&restrict c)[8])
template void reverse< 9, 9 > (link< 9 >(&restrict a)[9], link< 9 > const (&restrict c)[9])
template<typename T , unsigned k>
rot (T const x)
 Rotate x by k bits to the left.
template<>
signed char rot< signed char, 0 > (signed char const x)
template<>
signed int rot< signed int, 0 > (signed int const x)
template<>
signed long rot< signed long, 0 > (signed long const x)
template<>
signed short rot< signed short, 0 > (signed short const x)
template<>
unsigned char rot< unsigned char, 0 > (unsigned char const x)
template<>
unsigned int rot< unsigned int, 0 > (unsigned int const x)
template<>
unsigned long rot< unsigned long, 0 > (unsigned long const x)
template<>
unsigned short rot< unsigned short, 0 > (unsigned short const x)
template<class T , size_t len>
void scalarMax (T &restrict a, T const (&arr)[len])
template<class T >
void scalarMax (T &restrict a, size_t len, T const *restrict arr)
 Compute the maximum value of arr and return it in a.
template<class T , size_t len>
void scalarMin (T &restrict a, T const (&arr)[len])
template<class T >
void scalarMin (T &restrict a, size_t len, T const *restrict arr)
 Compute the minimum value of arr and return it in a.
template<class T , size_t d, class assignOp >
void scalarOp (T &restrict a, T const (&arr)[d])
 Perform an operation assignOp on all elements and accumulate the result in a.
template<class T , class assignOp >
void scalarOp (T &restrict a, size_t const length, T const *restrict arr)
 Perform an operation assignOp on all elements and accumulate the result in a.
template<class T , size_t len>
void scalarSum (T &restrict a, T const (&arr)[len])
template<class T >
void scalarSum (T &restrict a, size_t len, T const *restrict arr)
 Compute the sum of arr and return it in a.
template<typename T >
par::cpp::_traditional< doublescientific (T const &v)
 Print value v in scientific format, such as 3.14E+01.
template<class T >
size_t search (typename par::cpp::__ABT< T >::type const &restrict d, T const &restrict arr)
template<class T >
size_t search (T const &restrict d, size_t const length, T const *restrict arr)
 Optimized generic binary search.
template<unsigned pos>
off_t set (off_t flags, bool val)
 Set the flag at pos to val.
void * setthrough (void *target, int c, size_t len)
 An analogous to memset but writing through the caches.
template<signed s>
double shiftLeft (double val)
 Fast emulation of a multiplication with 2^s.
template<signed s>
double shiftRight (double val)
template<unsigned dim>
size_t simplexPos (ssize_t const (&restrict p)[dim], size_t &restrict dist)
 The position of point p inside its simplex.
size_t simplexSize (size_t dim, size_t dist)
 A wrapper class to handle dim dimensional simplices.
template<class T >
bool sort (T(&restrict a)[3])
template<class T >
bool sort (T(&restrict a)[2])
template<class T >
bool sort (T &restrict a, T &restrict b)
 Conditionaly swap the two argument values to ensure that a is not larger than b.
template<typename T , unsigned n>
void sortEQ (T(&s)[n])
 Sort vector s according to predicate predEQ.
template void sortEQ (long double(&source)[5])
template void sortEQ (long double(&source)[4])
template void sortEQ (long double(&source)[3])
template void sortEQ (long double(&source)[2])
template void sortEQ (long double(&source)[1])
template void sortEQ (double(&source)[5])
template void sortEQ (double(&source)[4])
template void sortEQ (double(&source)[3])
template void sortEQ (double(&source)[2])
template void sortEQ (double(&source)[1])
template void sortEQ (float(&source)[5])
template void sortEQ (float(&source)[4])
template void sortEQ (float(&source)[3])
template void sortEQ (float(&source)[2])
template void sortEQ (float(&source)[1])
template void sortEQ (unsigned long long(&source)[5])
template void sortEQ (unsigned long long(&source)[4])
template void sortEQ (unsigned long long(&source)[3])
template void sortEQ (unsigned long long(&source)[2])
template void sortEQ (unsigned long long(&source)[1])
template void sortEQ (long long(&source)[5])
template void sortEQ (long long(&source)[4])
template void sortEQ (long long(&source)[3])
template void sortEQ (long long(&source)[2])
template void sortEQ (long long(&source)[1])
template void sortEQ (ulong(&source)[5])
template void sortEQ (ulong(&source)[4])
template void sortEQ (ulong(&source)[3])
template void sortEQ (ulong(&source)[2])
template void sortEQ (ulong(&source)[1])
template void sortEQ (long(&source)[5])
template void sortEQ (long(&source)[4])
template void sortEQ (long(&source)[3])
template void sortEQ (long(&source)[2])
template void sortEQ (long(&source)[1])
template void sortEQ (unsigned(&source)[5])
template void sortEQ (unsigned(&source)[4])
template void sortEQ (unsigned(&source)[3])
template void sortEQ (unsigned(&source)[2])
template void sortEQ (unsigned(&source)[1])
template void sortEQ (signed(&source)[5])
template void sortEQ (signed(&source)[4])
template void sortEQ (signed(&source)[3])
template void sortEQ (signed(&source)[2])
template void sortEQ (signed(&source)[1])
template void sortEQ (ushort(&source)[5])
template void sortEQ (ushort(&source)[4])
template void sortEQ (ushort(&source)[3])
template void sortEQ (ushort(&source)[2])
template void sortEQ (ushort(&source)[1])
template void sortEQ (short(&source)[5])
template void sortEQ (short(&source)[4])
template void sortEQ (short(&source)[3])
template void sortEQ (short(&source)[2])
template void sortEQ (short(&source)[1])
template void sortEQ (uchar(&source)[5])
template void sortEQ (uchar(&source)[4])
template void sortEQ (uchar(&source)[3])
template void sortEQ (uchar(&source)[2])
template void sortEQ (uchar(&source)[1])
template void sortEQ (schar(&source)[5])
template void sortEQ (schar(&source)[4])
template void sortEQ (schar(&source)[3])
template void sortEQ (schar(&source)[2])
template void sortEQ (schar(&source)[1])
template void sortEQ (char(&source)[5])
template void sortEQ (char(&source)[4])
template void sortEQ (char(&source)[3])
template void sortEQ (char(&source)[2])
template void sortEQ (char(&source)[1])
template void sortEQ (bool(&source)[5])
template void sortEQ (bool(&source)[4])
template void sortEQ (bool(&source)[3])
template void sortEQ (bool(&source)[2])
template void sortEQ (bool(&source)[1])
template<typename T , unsigned n>
void sortEV (T(&s)[n])
 Sort vector s according to predicate predEV.
template<typename T , unsigned n>
void sortGE (T(&s)[n])
 Sort vector s according to predicate predGE.
template void sortGE (long double(&source)[5])
template void sortGE (long double(&source)[4])
template void sortGE (long double(&source)[3])
template void sortGE (long double(&source)[2])
template void sortGE (long double(&source)[1])
template void sortGE (double(&source)[5])
template void sortGE (double(&source)[4])
template void sortGE (double(&source)[3])
template void sortGE (double(&source)[2])
template void sortGE (double(&source)[1])
template void sortGE (float(&source)[5])
template void sortGE (float(&source)[4])
template void sortGE (float(&source)[3])
template void sortGE (float(&source)[2])
template void sortGE (float(&source)[1])
template void sortGE (unsigned long long(&source)[5])
template void sortGE (unsigned long long(&source)[4])
template void sortGE (unsigned long long(&source)[3])
template void sortGE (unsigned long long(&source)[2])
template void sortGE (unsigned long long(&source)[1])
template void sortGE (long long(&source)[5])
template void sortGE (long long(&source)[4])
template void sortGE (long long(&source)[3])
template void sortGE (long long(&source)[2])
template void sortGE (long long(&source)[1])
template void sortGE (ulong(&source)[5])
template void sortGE (ulong(&source)[4])
template void sortGE (ulong(&source)[3])
template void sortGE (ulong(&source)[2])
template void sortGE (ulong(&source)[1])
template void sortGE (long(&source)[5])
template void sortGE (long(&source)[4])
template void sortGE (long(&source)[3])
template void sortGE (long(&source)[2])
template void sortGE (long(&source)[1])
template void sortGE (unsigned(&source)[5])
template void sortGE (unsigned(&source)[4])
template void sortGE (unsigned(&source)[3])
template void sortGE (unsigned(&source)[2])
template void sortGE (unsigned(&source)[1])
template void sortGE (signed(&source)[5])
template void sortGE (signed(&source)[4])
template void sortGE (signed(&source)[3])
template void sortGE (signed(&source)[2])
template void sortGE (signed(&source)[1])
template void sortGE (ushort(&source)[5])
template void sortGE (ushort(&source)[4])
template void sortGE (ushort(&source)[3])
template void sortGE (ushort(&source)[2])
template void sortGE (ushort(&source)[1])
template void sortGE (short(&source)[5])
template void sortGE (short(&source)[4])
template void sortGE (short(&source)[3])
template void sortGE (short(&source)[2])
template void sortGE (short(&source)[1])
template void sortGE (uchar(&source)[5])
template void sortGE (uchar(&source)[4])
template void sortGE (uchar(&source)[3])
template void sortGE (uchar(&source)[2])
template void sortGE (uchar(&source)[1])
template void sortGE (schar(&source)[5])
template void sortGE (schar(&source)[4])
template void sortGE (schar(&source)[3])
template void sortGE (schar(&source)[2])
template void sortGE (schar(&source)[1])
template void sortGE (char(&source)[5])
template void sortGE (char(&source)[4])
template void sortGE (char(&source)[3])
template void sortGE (char(&source)[2])
template void sortGE (char(&source)[1])
template void sortGE (bool(&source)[5])
template void sortGE (bool(&source)[4])
template void sortGE (bool(&source)[3])
template void sortGE (bool(&source)[2])
template void sortGE (bool(&source)[1])
template<typename T , unsigned n>
void sortGT (T(&s)[n])
 Sort vector s according to predicate predGT.
template void sortGT (long double(&source)[5])
template void sortGT (long double(&source)[4])
template void sortGT (long double(&source)[3])
template void sortGT (long double(&source)[2])
template void sortGT (long double(&source)[1])
template void sortGT (double(&source)[5])
template void sortGT (double(&source)[4])
template void sortGT (double(&source)[3])
template void sortGT (double(&source)[2])
template void sortGT (double(&source)[1])
template void sortGT (float(&source)[5])
template void sortGT (float(&source)[4])
template void sortGT (float(&source)[3])
template void sortGT (float(&source)[2])
template void sortGT (float(&source)[1])
template void sortGT (unsigned long long(&source)[5])
template void sortGT (unsigned long long(&source)[4])
template void sortGT (unsigned long long(&source)[3])
template void sortGT (unsigned long long(&source)[2])
template void sortGT (unsigned long long(&source)[1])
template void sortGT (long long(&source)[5])
template void sortGT (long long(&source)[4])
template void sortGT (long long(&source)[3])
template void sortGT (long long(&source)[2])
template void sortGT (long long(&source)[1])
template void sortGT (ulong(&source)[5])
template void sortGT (ulong(&source)[4])
template void sortGT (ulong(&source)[3])
template void sortGT (ulong(&source)[2])
template void sortGT (ulong(&source)[1])
template void sortGT (long(&source)[5])
template void sortGT (long(&source)[4])
template void sortGT (long(&source)[3])
template void sortGT (long(&source)[2])
template void sortGT (long(&source)[1])
template void sortGT (unsigned(&source)[5])
template void sortGT (unsigned(&source)[4])
template void sortGT (unsigned(&source)[3])
template void sortGT (unsigned(&source)[2])
template void sortGT (unsigned(&source)[1])
template void sortGT (signed(&source)[5])
template void sortGT (signed(&source)[4])
template void sortGT (signed(&source)[3])
template void sortGT (signed(&source)[2])
template void sortGT (signed(&source)[1])
template void sortGT (ushort(&source)[5])
template void sortGT (ushort(&source)[4])
template void sortGT (ushort(&source)[3])
template void sortGT (ushort(&source)[2])
template void sortGT (ushort(&source)[1])
template void sortGT (short(&source)[5])
template void sortGT (short(&source)[4])
template void sortGT (short(&source)[3])
template void sortGT (short(&source)[2])
template void sortGT (short(&source)[1])
template void sortGT (uchar(&source)[5])
template void sortGT (uchar(&source)[4])
template void sortGT (uchar(&source)[3])
template void sortGT (uchar(&source)[2])
template void sortGT (uchar(&source)[1])
template void sortGT (schar(&source)[5])
template void sortGT (schar(&source)[4])
template void sortGT (schar(&source)[3])
template void sortGT (schar(&source)[2])
template void sortGT (schar(&source)[1])
template void sortGT (char(&source)[5])
template void sortGT (char(&source)[4])
template void sortGT (char(&source)[3])
template void sortGT (char(&source)[2])
template void sortGT (char(&source)[1])
template void sortGT (bool(&source)[5])
template void sortGT (bool(&source)[4])
template void sortGT (bool(&source)[3])
template void sortGT (bool(&source)[2])
template void sortGT (bool(&source)[1])
template<typename T , unsigned n>
void sortLE (T(&s)[n])
 Sort vector s according to predicate predLE.
template void sortLE (long double(&source)[5])
template void sortLE (long double(&source)[4])
template void sortLE (long double(&source)[3])
template void sortLE (long double(&source)[2])
template void sortLE (long double(&source)[1])
template void sortLE (double(&source)[5])
template void sortLE (double(&source)[4])
template void sortLE (double(&source)[3])
template void sortLE (double(&source)[2])
template void sortLE (double(&source)[1])
template void sortLE (float(&source)[5])
template void sortLE (float(&source)[4])
template void sortLE (float(&source)[3])
template void sortLE (float(&source)[2])
template void sortLE (float(&source)[1])
template void sortLE (unsigned long long(&source)[5])
template void sortLE (unsigned long long(&source)[4])
template void sortLE (unsigned long long(&source)[3])
template void sortLE (unsigned long long(&source)[2])
template void sortLE (unsigned long long(&source)[1])
template void sortLE (long long(&source)[5])
template void sortLE (long long(&source)[4])
template void sortLE (long long(&source)[3])
template void sortLE (long long(&source)[2])
template void sortLE (long long(&source)[1])
template void sortLE (ulong(&source)[5])
template void sortLE (ulong(&source)[4])
template void sortLE (ulong(&source)[3])
template void sortLE (ulong(&source)[2])
template void sortLE (ulong(&source)[1])
template void sortLE (long(&source)[5])
template void sortLE (long(&source)[4])
template void sortLE (long(&source)[3])
template void sortLE (long(&source)[2])
template void sortLE (long(&source)[1])
template void sortLE (unsigned(&source)[5])
template void sortLE (unsigned(&source)[4])
template void sortLE (unsigned(&source)[3])
template void sortLE (unsigned(&source)[2])
template void sortLE (unsigned(&source)[1])
template void sortLE (signed(&source)[5])
template void sortLE (signed(&source)[4])
template void sortLE (signed(&source)[3])
template void sortLE (signed(&source)[2])
template void sortLE (signed(&source)[1])
template void sortLE (ushort(&source)[5])
template void sortLE (ushort(&source)[4])
template void sortLE (ushort(&source)[3])
template void sortLE (ushort(&source)[2])
template void sortLE (ushort(&source)[1])
template void sortLE (short(&source)[5])
template void sortLE (short(&source)[4])
template void sortLE (short(&source)[3])
template void sortLE (short(&source)[2])
template void sortLE (short(&source)[1])
template void sortLE (uchar(&source)[5])
template void sortLE (uchar(&source)[4])
template void sortLE (uchar(&source)[3])
template void sortLE (uchar(&source)[2])
template void sortLE (uchar(&source)[1])
template void sortLE (schar(&source)[5])
template void sortLE (schar(&source)[4])
template void sortLE (schar(&source)[3])
template void sortLE (schar(&source)[2])
template void sortLE (schar(&source)[1])
template void sortLE (char(&source)[5])
template void sortLE (char(&source)[4])
template void sortLE (char(&source)[3])
template void sortLE (char(&source)[2])
template void sortLE (char(&source)[1])
template void sortLE (bool(&source)[5])
template void sortLE (bool(&source)[4])
template void sortLE (bool(&source)[3])
template void sortLE (bool(&source)[2])
template void sortLE (bool(&source)[1])
template<typename T , unsigned n>
void sortLT (T(&s)[n])
 Sort vector s according to predicate predLT.
template void sortLT (long double(&source)[5])
template void sortLT (long double(&source)[4])
template void sortLT (long double(&source)[3])
template void sortLT (long double(&source)[2])
template void sortLT (long double(&source)[1])
template void sortLT (double(&source)[5])
template void sortLT (double(&source)[4])
template void sortLT (double(&source)[3])
template void sortLT (double(&source)[2])
template void sortLT (double(&source)[1])
template void sortLT (float(&source)[5])
template void sortLT (float(&source)[4])
template void sortLT (float(&source)[3])
template void sortLT (float(&source)[2])
template void sortLT (float(&source)[1])
template void sortLT (unsigned long long(&source)[5])
template void sortLT (unsigned long long(&source)[4])
template void sortLT (unsigned long long(&source)[3])
template void sortLT (unsigned long long(&source)[2])
template void sortLT (unsigned long long(&source)[1])
template void sortLT (long long(&source)[5])
template void sortLT (long long(&source)[4])
template void sortLT (long long(&source)[3])
template void sortLT (long long(&source)[2])
template void sortLT (long long(&source)[1])
template void sortLT (ulong(&source)[5])
template void sortLT (ulong(&source)[4])
template void sortLT (ulong(&source)[3])
template void sortLT (ulong(&source)[2])
template void sortLT (ulong(&source)[1])
template void sortLT (long(&source)[5])
template void sortLT (long(&source)[4])
template void sortLT (long(&source)[3])
template void sortLT (long(&source)[2])
template void sortLT (long(&source)[1])
template void sortLT (unsigned(&source)[5])
template void sortLT (unsigned(&source)[4])
template void sortLT (unsigned(&source)[3])
template void sortLT (unsigned(&source)[2])
template void sortLT (unsigned(&source)[1])
template void sortLT (signed(&source)[5])
template void sortLT (signed(&source)[4])
template void sortLT (signed(&source)[3])
template void sortLT (signed(&source)[2])
template void sortLT (signed(&source)[1])
template void sortLT (ushort(&source)[5])
template void sortLT (ushort(&source)[4])
template void sortLT (ushort(&source)[3])
template void sortLT (ushort(&source)[2])
template void sortLT (ushort(&source)[1])
template void sortLT (short(&source)[5])
template void sortLT (short(&source)[4])
template void sortLT (short(&source)[3])
template void sortLT (short(&source)[2])
template void sortLT (short(&source)[1])
template void sortLT (uchar(&source)[5])
template void sortLT (uchar(&source)[4])
template void sortLT (uchar(&source)[3])
template void sortLT (uchar(&source)[2])
template void sortLT (uchar(&source)[1])
template void sortLT (schar(&source)[5])
template void sortLT (schar(&source)[4])
template void sortLT (schar(&source)[3])
template void sortLT (schar(&source)[2])
template void sortLT (schar(&source)[1])
template void sortLT (char(&source)[5])
template void sortLT (char(&source)[4])
template void sortLT (char(&source)[3])
template void sortLT (char(&source)[2])
template void sortLT (char(&source)[1])
template void sortLT (bool(&source)[5])
template void sortLT (bool(&source)[4])
template void sortLT (bool(&source)[3])
template void sortLT (bool(&source)[2])
template void sortLT (bool(&source)[1])
template<typename T , unsigned n>
void sortNE (T(&s)[n])
 Sort vector s according to predicate predNE.
template void sortNE (long double(&source)[5])
template void sortNE (long double(&source)[4])
template void sortNE (long double(&source)[3])
template void sortNE (long double(&source)[2])
template void sortNE (long double(&source)[1])
template void sortNE (double(&source)[5])
template void sortNE (double(&source)[4])
template void sortNE (double(&source)[3])
template void sortNE (double(&source)[2])
template void sortNE (double(&source)[1])
template void sortNE (float(&source)[5])
template void sortNE (float(&source)[4])
template void sortNE (float(&source)[3])
template void sortNE (float(&source)[2])
template void sortNE (float(&source)[1])
template void sortNE (unsigned long long(&source)[5])
template void sortNE (unsigned long long(&source)[4])
template void sortNE (unsigned long long(&source)[3])
template void sortNE (unsigned long long(&source)[2])
template void sortNE (unsigned long long(&source)[1])
template void sortNE (long long(&source)[5])
template void sortNE (long long(&source)[4])
template void sortNE (long long(&source)[3])
template void sortNE (long long(&source)[2])
template void sortNE (long long(&source)[1])
template void sortNE (ulong(&source)[5])
template void sortNE (ulong(&source)[4])
template void sortNE (ulong(&source)[3])
template void sortNE (ulong(&source)[2])
template void sortNE (ulong(&source)[1])
template void sortNE (long(&source)[5])
template void sortNE (long(&source)[4])
template void sortNE (long(&source)[3])
template void sortNE (long(&source)[2])
template void sortNE (long(&source)[1])
template void sortNE (unsigned(&source)[5])
template void sortNE (unsigned(&source)[4])
template void sortNE (unsigned(&source)[3])
template void sortNE (unsigned(&source)[2])
template void sortNE (unsigned(&source)[1])
template void sortNE (signed(&source)[5])
template void sortNE (signed(&source)[4])
template void sortNE (signed(&source)[3])
template void sortNE (signed(&source)[2])
template void sortNE (signed(&source)[1])
template void sortNE (ushort(&source)[5])
template void sortNE (ushort(&source)[4])
template void sortNE (ushort(&source)[3])
template void sortNE (ushort(&source)[2])
template void sortNE (ushort(&source)[1])
template void sortNE (short(&source)[5])
template void sortNE (short(&source)[4])
template void sortNE (short(&source)[3])
template void sortNE (short(&source)[2])
template void sortNE (short(&source)[1])
template void sortNE (uchar(&source)[5])
template void sortNE (uchar(&source)[4])
template void sortNE (uchar(&source)[3])
template void sortNE (uchar(&source)[2])
template void sortNE (uchar(&source)[1])
template void sortNE (schar(&source)[5])
template void sortNE (schar(&source)[4])
template void sortNE (schar(&source)[3])
template void sortNE (schar(&source)[2])
template void sortNE (schar(&source)[1])
template void sortNE (char(&source)[5])
template void sortNE (char(&source)[4])
template void sortNE (char(&source)[3])
template void sortNE (char(&source)[2])
template void sortNE (char(&source)[1])
template void sortNE (bool(&source)[5])
template void sortNE (bool(&source)[4])
template void sortNE (bool(&source)[3])
template void sortNE (bool(&source)[2])
template void sortNE (bool(&source)[1])
template<typename T , unsigned n>
void sortNV (T(&s)[n])
 Sort vector s according to predicate predNV.
template<typename T , typename predOp , unsigned n>
void sortOP (T(&s)[n])
template<char sep, char noise>
char const *const * split_argument (char **strVec, char *repStr, char const *copStr)
 Split a string according to occurences of characters sep and noise.
template<typename BT >
void splitWord (BT const &a, typename par::cpp::_half_of< BT >::_H &a0, BT &a1)
 Split word a into two. The least significant half will be given in a0, the most significant half in a1.
template<typename T , typename D >
sqrremain (T a, D const &divisor)
 Accurately compute a^2 mod divisor, even if a^2 would overflow within in type T.
template<unsigned dim, unsigned dim0>
void subedge (edge< dim0 > *tarr, edge< dim >const *sarr, size_t length, unsigned offset)
template<class T , unsigned magic>
void subtab (T *restrict tab, size_t size, size_t pivot)
 Apply a particular median or nearMedian function to blocks of size magic.
template<class T , unsigned magic>
void subtab_func (T &restrict place, T(&restrict tab)[magic])
template<class T , unsigned magic>
size_t subtab_func (T(&restrict tab)[magic])
 A median or near median function that is the best for block size magic.
template<typename T , unsigned d1, size_t length>
T &[d1] subvector (T *A)
template<typename T , unsigned d1>
T &[d1] subvector (T *A, size_t length)
template<typename T , unsigned d0, unsigned d1, unsigned off>
T &[d1] subvector (T[d0]&A)
template<typename T , unsigned d0, unsigned d1>
T &[d1] subvector (T[d0]&A, size_t off)
template<class T >
void swap2 (T *restrict tab, size_t size, size_t amount)
 Unconditionaly swap elements of a vector internally.
template<class T >
void swap2 (T &restrict a, T &restrict b)
 Unconditionaly swap the two argument values.
template<unsigned dim>
void tail (par::cpp::link< 1 > *tarr, edge< dim >const *sarr, size_t length)
void throw_error (char const *st, int er=0)((noreturn)) throw (par::cpp::error)
template<unsigned pos>
off_t toggle (off_t flags)
 Toggle the flag at pos.
int trace (char const *name, int line)((deprecated))
int trace (char const *name, int line, char const *format,...)((deprecated))
template<typename T >
par::cpp::_traditional< T > traditional (T const &v, char const *f)
 Print a value v with traditional C printf format f.
double trunc (register double x)
double trunc (double x)
size_t uconvert (double val)
 Convert an unsigned (= positiv) double to an unsigned integer.
template<typename T , unsigned d>
T(& vecAnd (T(&A)[d], T const (&B)[d], T const (&C)[d]))[d]
template<typename T >
T * vecAnd (T *A, size_t length, T const *B, T const *C)
template<typename T >
T & vecAnd (T &A, T const &B, T const &C)
template<typename T , unsigned d>
T(& vecAnd (T(&A)[d], T const (&B)[d]))[d]
template<typename T >
T * vecAnd (T *A, size_t length, T const *B)
template<typename T >
T & vecAnd (T &A, T const &B)
template<typename T >
T ** vecAssign (T **const A, size_t length, T *const *const B)
template<typename T , unsigned d>
T(& vecAssign (T(&A)[d], T const (&B)[d], T const (&C)[d]))[d]
template<typename T >
T * vecAssign (T *A, size_t length, T const *B, T const *C)
template<typename T >
T & vecAssign (T &A, T const &B, T const &C)
template<typename T , unsigned d>
T(& vecAssign (T(&A)[d], T const (&B)[d]))[d]
template<typename T >
T * vecAssign (T *A, size_t length, T const *B)
template<typename T >
T & vecAssign (T &A, T const &B)
template<>
bool ** vecAssign< bool * > (bool **const A, size_t length, bool *const *const B)
template<>
bool * vecAssign< bool > (bool *const A, size_t length, bool const *const B)
template<>
char ** vecAssign< char * > (char **const A, size_t length, char *const *const B)
template<>
char * vecAssign< char > (char *const A, size_t length, char const *const B)
template<>
double ** vecAssign< double * > (double **const A, size_t length, double *const *const B)
template<>
doublevecAssign< double > (double *const A, size_t length, double const *const B)
template<>
float ** vecAssign< float * > (float **const A, size_t length, float *const *const B)
template<>
float * vecAssign< float > (float *const A, size_t length, float const *const B)
template<>
long ** vecAssign< long * > (long **const A, size_t length, long *const *const B)
template<>
long * vecAssign< long > (long *const A, size_t length, long const *const B)
template<>
schar ** vecAssign< schar * > (schar **const A, size_t length, schar *const *const B)
template<>
scharvecAssign< schar > (schar *const A, size_t length, schar const *const B)
template<>
short ** vecAssign< short * > (short **const A, size_t length, short *const *const B)
template<>
short * vecAssign< short > (short *const A, size_t length, short const *const B)
template<>
signed ** vecAssign< signed * > (signed **const A, size_t length, signed *const *const B)
template<>
signed * vecAssign< signed > (signed *const A, size_t length, signed const *const B)
template<>
uchar ** vecAssign< uchar * > (uchar **const A, size_t length, uchar *const *const B)
template<>
ucharvecAssign< uchar > (uchar *const A, size_t length, uchar const *const B)
template<>
ulong ** vecAssign< ulong * > (ulong **const A, size_t length, ulong *const *const B)
template<>
ulongvecAssign< ulong > (ulong *const A, size_t length, ulong const *const B)
template<>
unsigned ** vecAssign< unsigned * > (unsigned **const A, size_t length, unsigned *const *const B)
template<>
unsigned * vecAssign< unsigned > (unsigned *const A, size_t length, unsigned const *const B)
template<>
ushort ** vecAssign< ushort * > (ushort **const A, size_t length, ushort *const *const B)
template<>
ushortvecAssign< ushort > (ushort *const A, size_t length, ushort const *const B)
template<>
void * vecAssign< void > (void *const A, size_t length, void const *const B)
template<>
wchar_t ** vecAssign< wchar_t * > (wchar_t **const A, size_t length, wchar_t *const *const B)
template<>
wchar_t * vecAssign< wchar_t > (wchar_t *const A, size_t length, wchar_t const *const B)
template<typename T , unsigned d>
T(& vecBitand (T(&A)[d], T const (&B)[d], T const (&C)[d]))[d]
template<typename T >
T * vecBitand (T *A, size_t length, T const *B, T const *C)
template<typename T >
T & vecBitand (T &A, T const &B, T const &C)
template<typename T , unsigned d>
T(& vecBitand (T(&A)[d], T const (&B)[d]))[d]
template<typename T >
T * vecBitand (T *A, size_t length, T const *B)
template<typename T >
T & vecBitand (T &A, T const &B)
template<typename T , unsigned d>
T(& vecBitor (T(&A)[d], T const (&B)[d], T const (&C)[d]))[d]
template<typename T >
T * vecBitor (T *A, size_t length, T const *B, T const *C)
template<typename T >
T & vecBitor (T &A, T const &B, T const &C)
template<typename T , unsigned d>
T(& vecBitor (T(&A)[d], T const (&B)[d]))[d]
template<typename T >
T * vecBitor (T *A, size_t length, T const *B)
template<typename T >
T & vecBitor (T &A, T const &B)
template<typename T , unsigned d>
T(& vecBitxor (T(&A)[d], T const (&B)[d], T const (&C)[d]))[d]
template<typename T >
T * vecBitxor (T *A, size_t length, T const *B, T const *C)
template<typename T >
T & vecBitxor (T &A, T const &B, T const &C)
template<typename T , unsigned d>
T(& vecBitxor (T(&A)[d], T const (&B)[d]))[d]
template<typename T >
T * vecBitxor (T *A, size_t length, T const *B)
template<typename T >
T & vecBitxor (T &A, T const &B)
template<typename T >
par::cpp::__ABT< T >::type & vecBottom (T &p)
template<typename T , unsigned d>
T(& vecCompl (T(&A)[d], T const (&B)[d]))[d]
template<typename T >
T * vecCompl (T *A, size_t length, T const *B)
template<typename T >
T & vecCompl (T &A, T const &B)
template<typename T , unsigned d>
T &[d] vecCompl (T[d]&A)
template<typename T >
T * vecCompl (T *A, size_t length)
template<typename T >
T & vecCompl (T &A)
template<typename T >
T ** vecConstruct (T **const A, size_t length)
template<typename T >
T * vecConstruct (T *const A, size_t length, T const *const B)
template<typename T >
void vecConstruct (T &p, T const &q)
template<typename T >
void vecConstruct (T &p)
template<typename T >
T * vecConstruct (T *here, size_t len)
template<>
bool ** vecConstruct< bool * > (bool **const A, size_t length)
template<>
bool * vecConstruct< bool > (bool *const A, size_t length)
template<>
char ** vecConstruct< char * > (char **const A, size_t length)
template<>
char *