include/basix/defaults.hpp File Reference

#include <basix/basix.hpp>

Go to the source code of this file.

Classes

struct xgcd_matrix< C >

Namespaces

namespace mmx

Defines

#define TRUE_TO_EXACT_IDENTITY_SUGAR(TMPL, T)
#define HARD_TO_EXACT_IDENTITY_SUGAR(TMPL, T)
#define HARD_TO_TRUE_IDENTITY_SUGAR(TMPL, T)
#define TRUE_IDENTITY_OP_SUGAR(TMPL, T)
#define EXACT_IDENTITY_OP_SUGAR(TMPL, T)
#define HARD_IDENTITY_OP_SUGAR(TMPL, T)
#define EQUAL_INT_SUGAR(TMPL, T)
#define EQUAL_SCALAR_SUGAR(TMPL, T, C)
#define EQUAL_SCALAR_SUGAR_BIS(TMPL, T, C)
#define COPY_OP_SUGAR(TMPL, T)
#define ADDITIVE_INT_SUGAR(TMPL, T)
#define ADDITIVE_SCALAR_INT_SUGAR(TMPL, T)
#define ADDITIVE_SCALAR_SUGAR(TMPL, T, C)
#define ARITH_INT_SUGAR(TMPL, T)
#define ARITH_SCALAR_INT_SUGAR(TMPL, T)
#define ARITH_SCALAR_SUGAR(TMPL, T, C)
#define SHIFT_INT_SUGAR(TMPL, T)
#define ARITH_SWAP_TIMES_SUGAR(TMPL, T, C) TMPL inline T operator * (const C& x, const T& y) { return y * x; }
#define GCD_SUGAR(TMPL, C)
#define COMPARE_SUGAR(TMPL, T)
#define STRICT_COMPARE_SUGAR(TMPL, T)
#define COMPARE_INT_SUGAR(TMPL, T)
#define COMPARE_SCALAR_SUGAR(TMPL, T, C)
#define COMPARE_SCALAR_SUGAR_BIS(TMPL, T, C)
#define POOR_MAN_SQRT_SUGAR(TMPL, C)
#define POOR_MAN_ELEMENTARY_SUGAR(TMPL, C)
#define HYPOT_SUGAR(TMPL, C)
#define POW_SUGAR(TMPL, C)
#define ATAN2_SUGAR(TMPL, C)
#define INV_TRIGO_SUGAR(TMPL, C)
#define HYPER_SUGAR(TMPL, C)
#define INV_HYPER_SUGAR(TMPL, C)
#define ARG_HYPER_SUGAR(TMPL, C)

Typedefs

typedef void * void_ptr
typedef char * char_ptr

Functions

template<typename T , typename F > T as (const F &x)
template<typename T , typename F > T promote (const F &x, const T &y)
template<typename F > bool promote (const F &x, const bool &)
template<typename F > char promote (const F &x, const char &)
template<typename F > signed char promote (const F &x, const signed char &)
template<typename F > unsigned char promote (const F &x, const unsigned char &)
template<typename F > int promote (const F &x, const int &)
template<typename F > unsigned int promote (const F &x, const unsigned int &)
template<typename F > long int promote (const F &x, const long int &)
template<typename F > unsigned long int promote (const F &x, const unsigned long int &)
template<typename F > long long int promote (const F &x, const long long int &)
template<typename F > unsigned long long int promote (const F &x, const unsigned long long int &)
template<typename F > float promote (const F &x, const float &)
template<typename F > double promote (const F &x, const double &)
template<typename C > bool is_zero (const C &x)
template<typename C > bool is_exact_zero (const C &x)
char copy (char c)
signed char copy (signed char c)
unsigned char copy (unsigned char c)
short int copy (short int c)
short unsigned int copy (short unsigned int c)
int copy (int c)
unsigned int copy (unsigned int c)
long int copy (long int c)
long unsigned int copy (long unsigned int c)
long long int copy (long long int c)
long long unsigned int copy (long long unsigned int c)
float copy (float c)
double copy (double c)
template<typename C > void * copy (C *p)
template<typename C > C duplicate (const C &x)
template<typename C > void clear (C &x)
template<typename C , typename D > C & operator+= (C &x, const D &y)
template<typename C , typename D > C & operator-= (C &x, const D &y)
template<typename C , typename D > C & operator*= (C &x, const D &y)
template<typename C , typename D > C & operator/= (C &x, const D &y)
template<typename C , typename D > C quo (const C &x, const D &y)
template<typename C , typename D > C rem (const C &x, const D &y)
template<typename C > C skew_div (const C &x, const C &y, bool left=false)
template<typename C > C skew_quo (const C &x, const C &y, bool left=false)
template<typename C > C skew_rem (const C &x, const C &y, bool left=false)
template<typename C , typename S > C lshift2 (const C &x, const S &y)
template<typename C > C lshift2 (const C &x)
template<typename C , typename S > void lshift2_assign (C &x, const S &y)
template<typename C , typename S > void lshift2 (C &x, const C &y, const S &z)
template<typename C , typename S > C rshift2 (const C &x, const S &y)
template<typename C > C rshift2 (const C &x)
template<typename C , typename S > void rshift2_assign (C &x, const S &y)
template<typename C , typename S > void rshift2 (C &x, const C &y, const S &z)
template<typename C , typename S > C lshiftz (const C &x, const S &y)
template<typename C > C lshiftz (const C &x)
template<typename C , typename S > void lshiftz_assign (C &x, const S &y)
template<typename C , typename S > void lshiftz (C &x, const C &y, const S &z)
template<typename C , typename S > C rshiftz (const C &x, const S &y)
template<typename C > C rshiftz (const C &x)
template<typename C , typename S > void rshiftz_assign (C &x, const S &y=1)
template<typename C , typename S > void rshiftz (C &x, const C &y, const S &z)
template<typename C , typename S > C incexp2 (const C &x, const S &y)
template<typename C > C incexp2 (const C &x)
template<typename C , typename S > void incexp2_assign (C &x, const S &y)
template<typename C , typename S > void incexp2 (C &x, const C &y, const S &z)
template<typename C , typename S > C decexp2 (const C &x, const S &y)
template<typename C > C decexp2 (const C &x)
template<typename C , typename S > void decexp2_assign (C &x, const S &y)
template<typename C , typename S > void decexp2 (C &x, const C &y, const S &z)
template<typename C > int sign (const C &x)
template<> int sign (const unsigned char &x)
template<> int sign (const short unsigned int &x)
template<> int sign (const unsigned int &x)
template<> int sign (const long unsigned int &x)
template<> int sign (const long long unsigned int &x)
template<typename C > int compare (const C &x, const C &y)
template<> int compare (const unsigned char &x, const unsigned char &y)
template<> int compare (const short unsigned int &x, const short unsigned int &y)
template<> int compare (const unsigned int &x, const unsigned int &y)
template<> int compare (const long unsigned int &x, const long unsigned int &y)
template<> int compare (const long long unsigned int &x, const long long unsigned int &y)
template<typename C > C abs (const C &x)
template<> unsigned char abs (const unsigned char &x)
template<> short unsigned int abs (const short unsigned int &x)
template<> unsigned int abs (const unsigned int &x)
template<> long unsigned int abs (const long unsigned int &x)
template<> long long unsigned int abs (const long long unsigned int &x)
template<typename C > C min (const C &x, const C &y)
template<typename C > C max (const C &x, const C &y)
template<typename C > C inf (const C &x, const C &y)
template<typename C > C sup (const C &x, const C &y)
template<typename C > C square (const C &x)
template<typename C > C invert (const C &x)
template<typename C > bool is_invertible (const C &x)
template<typename C > C binpow (const C &i, const nat &n)
template<typename C > C powint (const C &i, const int &n)
template<typename C , typename ZZ > C sympow (const C &c, const ZZ &i)
template<typename C > C hypot (const C &x, const C &y)
template<typename C > C atan2 (const C &y, const C &x)
template<typename C > C cosh (const C &x)
template<typename C > C sinh (const C &x)
template<typename C > C tanh (const C &x)
template<typename C > C acosh (const C &x)
template<typename C > C asinh (const C &x)
template<typename C > C atanh (const C &x)
template<typename C > bool is_finite (const C &x)
template<typename C > bool is_infinite (const C &x)
template<typename C > bool is_fuzz (const C &x)
template<typename C > bool is_nan (const C &x)
template<typename C > bool is_reliable (const C &x)
template<typename C > double magnitude (const C &x)
template<typename C > C change_precision (const C &x, xnat)
template<typename C > C sharpen (const C &x)
template<typename C , typename D > C blur (const C &x, const D &y)
template<typename C > C Re (const C &x)
template<typename C > C Im (const C &x)
template<typename C > C conj (const C &x)
template<typename T , typename V > T derive (const T &f, const V &v, nat n)
template<typename C > C common_part (const C &x, const C &y)
template<typename C > bool always_false (const C &x)
template<typename C > bool always_true (const C &x)
template<typename C > void swap (C &x, C &y)
template<typename C > const C & read_only (const C &c)
void set_default (int &x)
void set_default (nat &x)
void set_default (long int &x)
void set_default (long unsigned int &x)
void set_maximal (int &x)
void set_minimal (int &x)
void set_maximal (nat &x)
void set_minimal (nat &x)
void set_maximal (long int &x)
void set_minimal (long int &x)
void set_maximal (long unsigned int &x)
void set_minimal (long unsigned int &x)
void set_default (double &x)
void set_nan (double &x)
void set_maximal (double &x)
void set_minimal (double &x)
void set_infinity (double &x)
void set_fuzz (double &x)
void set_smallest (double &x)
void set_largest (double &x)
void set_accuracy (double &x)
void set_log2 (double &x)
void set_pi (double &x)
void set_euler (double &x)
double times_infinity (const double &x)
double square (const double &x)
double invert (const double &x)
double sqrt (const double &x)
double exp (const double &x)
double exp2 (const double &x)
double log (const double &x)
double log2 (const double &x)
double cos (const double &x)
double sin (const double &x)
double tan (const double &x)
double cosh (const double &x)
double sinh (const double &x)
double tanh (const double &x)
double acos (const double &x)
double asin (const double &x)
double atan (const double &x)
double hypot (const double &x, const double &y)
double atan2 (const double &y, const double &x)
double pow (const double &x, const double &y)
double pow (const double &x, const int &y)
double pow (const int &x, const double &y)
template<typename S > double incexp2 (const double &x, const S &y)
double incexp2 (const double &x)
template<typename S > void incexp2_assign (double &x, const S &y)
template<typename S > void incexp2 (double &, const double &, const S &)
template<typename S > double decexp2 (const double &x, const S &y)
double decexp2 (const double &x)
template<typename S > void decexp2_assign (double &x, const S &y)
template<typename S > void decexp2 (double &, const double &, const S &)
double floor (const double &x)
double trunc (const double &x)
double ceil (const double &x)
double round (const double &x)

Detailed Description

Definition in file defaults.hpp.

Define Documentation

#define ADDITIVE_INT_SUGAR	(	TMPL,
		T		)

Value:

TMPL inline T operator + (const T& x, const int& y) {   \
  return x + promote (y, x); }                          \
TMPL inline T operator + (const int& x, const T& y) {   \
  return promote (x, y) + y; }                          \
TMPL inline T operator - (const T& x, const int& y) {   \
  return x - promote (y, x); }                          \
TMPL inline T operator - (const int& x, const T& y) {   \
  return promote (x, y) - y; }

Definition at line 179 of file defaults.hpp.

#define ADDITIVE_SCALAR_INT_SUGAR	(	TMPL,
		T		)

Value:

TMPL inline T operator + (const T& x, const int& y) {   \
  return x + promote_scalar (y, x); }                   \
TMPL inline T operator + (const int& x, const T& y) {   \
  return promote_scalar (x, y) + y; }                   \
TMPL inline T operator - (const T& x, const int& y) {   \
  return x - promote_scalar (y, x); }                   \
TMPL inline T operator - (const int& x, const T& y) {   \
  return promote_scalar (x, y) - y; }

Definition at line 189 of file defaults.hpp.

#define ADDITIVE_SCALAR_SUGAR	(	TMPL,
		T,
		C	)

Value:

TMPL inline T operator + (const T& x, const C& y) { return x + T(y); } \
TMPL inline T operator + (const C& x, const T& y) { return T(x) + y; } \
TMPL inline T operator - (const T& x, const C& y) { return x - T(y); } \
TMPL inline T operator - (const C& x, const T& y) { return T(x) - y; }

Definition at line 199 of file defaults.hpp.

#define ARG_HYPER_SUGAR	(	TMPL,
		C		)

Value:

TMPL inline C acosh (const C& x) {                                      \
  return log (x + sqrt (square (x) - promote (1, x))); }                \
TMPL inline C asinh (const C& x) {                                      \
  return log (x + sqrt (square (x) + promote (1, x))); }                \
TMPL inline C atanh (const C& x) {                                      \
  return log ((promote (1, x) + x) / (promote (1, x) - x)) / promote (2, x); }

Definition at line 681 of file defaults.hpp.

#define ARITH_INT_SUGAR	(	TMPL,
		T		)

Value:

TMPL inline T operator + (const T& x, const int& y) {   \
  return x + promote (y, x); }                          \
TMPL inline T operator + (const int& x, const T& y) {   \
  return promote (x, y) + y; }                          \
TMPL inline T operator - (const T& x, const int& y) {   \
  return x - promote (y, x); }                          \
TMPL inline T operator - (const int& x, const T& y) {   \
  return promote (x, y) - y; }                          \
TMPL inline T operator * (const T& x, const int& y) {   \
  return x * promote (y, x); }                          \
TMPL inline T operator * (const int& x, const T& y) {   \
  return promote (x, y) * y; }                          \
TMPL inline T operator / (const T& x, const int& y) {   \
  return x / promote (y, x); }                          \
TMPL inline T operator / (const int& x, const T& y) {   \
  return promote (x, y) / y; }

Definition at line 205 of file defaults.hpp.

#define ARITH_SCALAR_INT_SUGAR	(	TMPL,
		T		)

Value:

TMPL inline T operator + (const T& x, const int& y) {   \
  return x + promote_scalar (y, x); }                   \
TMPL inline T operator + (const int& x, const T& y) {   \
  return promote_scalar (x, y) + y; }                   \
TMPL inline T operator - (const T& x, const int& y) {   \
  return x - promote_scalar (y, x); }                   \
TMPL inline T operator - (const int& x, const T& y) {   \
  return promote_scalar (x, y) - y; }                   \
TMPL inline T operator * (const T& x, const int& y) {   \
  return x * promote_scalar (y, x); }                   \
TMPL inline T operator * (const int& x, const T& y) {   \
  return promote_scalar (x, y) * y; }                   \
TMPL inline T operator / (const T& x, const int& y) {   \
  return x / promote_scalar (y, x); }                   \
TMPL inline T operator / (const int& x, const T& y) {   \
  return promote_scalar (x, y) / y; }

Definition at line 223 of file defaults.hpp.

#define ARITH_SCALAR_SUGAR	(	TMPL,
		T,
		C	)

Value:

TMPL inline T operator + (const T& x, const C& y) { return x + T(y); } \
TMPL inline T operator + (const C& x, const T& y) { return T(x) + y; } \
TMPL inline T operator - (const T& x, const C& y) { return x - T(y); } \
TMPL inline T operator - (const C& x, const T& y) { return T(x) - y; } \
TMPL inline T operator * (const T& x, const C& y) { return x * T(y); } \
TMPL inline T operator * (const C& x, const T& y) { return T(x) * y; } \
TMPL inline T operator / (const T& x, const C& y) { return x / T(y); } \
TMPL inline T operator / (const C& x, const T& y) { return T(x) / y; }

Definition at line 241 of file defaults.hpp.

#define ARITH_SWAP_TIMES_SUGAR	(	TMPL,
		T,
		C	)	TMPL inline T operator * (const C& x, const T& y) { return y * x; }

Definition at line 257 of file defaults.hpp.

#define ATAN2_SUGAR	(	TMPL,
		C		)

Value:

TMPL inline C atan2 (const C& y, const C& x) {                          \
  if (x > promote (0, x))                                               \
    return atan (y/x);                                                  \
  else if (y == promote (0, x))                                         \
    return x == promote (0, x)?                                         \
           promote (0, x): promote (-4, x) * atan (promote (1, x));     \
  else if (x == promote (0, x))                                         \
    return promote (2 * sign (y), x) * atan (promote (1, x));           \
  else                                                                  \
    return promote (sign (y), x) *                                      \
           (promote (4, x) * atan (promote (1, x)) - atan (abs (y/x))); }

Definition at line 644 of file defaults.hpp.

#define COMPARE_INT_SUGAR	(	TMPL,
		T		)

Value:

TMPL inline bool operator <  (const T& x, const int& y) {       \
  return x <  promote (y, x); }                                 \
TMPL inline bool operator <= (const T& x, const int& y) {       \
  return x <= promote (y, x); }                                 \
TMPL inline bool operator >  (const T& x, const int& y) {       \
  return x >  promote (y, x); }                                 \
TMPL inline bool operator >= (const T& x, const int& y) {       \
  return x >= promote (y, x); }

Definition at line 498 of file defaults.hpp.

#define COMPARE_SCALAR_SUGAR	(	TMPL,
		T,
		C	)

Value:

TMPL inline bool operator <  (const T& x, const C& y) { return x <  T(y); }   \
TMPL inline bool operator <= (const T& x, const C& y) { return x <= T(y); }   \
TMPL inline bool operator >  (const T& x, const C& y) { return x >  T(y); }   \
TMPL inline bool operator >= (const T& x, const C& y) { return x >= T(y); }

Definition at line 508 of file defaults.hpp.

#define COMPARE_SCALAR_SUGAR_BIS	(	TMPL,
		T,
		C	)

Value:

TMPL inline bool operator <  (const C& x, const T& y) { return T(x) <  y; }   \
TMPL inline bool operator <= (const C& x, const T& y) { return T(x) <= y; }   \
TMPL inline bool operator >  (const C& x, const T& y) { return T(x) >  y; }   \
TMPL inline bool operator >= (const C& x, const T& y) { return T(x) >= y; }

Definition at line 514 of file defaults.hpp.

#define COMPARE_SUGAR	(	TMPL,
		T		)

Value:

TMPL inline bool operator <  (const T& x, const T& y) { \
  return compare (x,y) <  0; }                          \
TMPL inline bool operator <= (const T& x, const T& y) { \
  return compare (x,y) <= 0; }                          \
TMPL inline bool operator >  (const T& x, const T& y) { \
  return compare (x,y) >  0; }                          \
TMPL inline bool operator >= (const T& x, const T& y) { \
  return compare (x,y) >= 0; }

Definition at line 482 of file defaults.hpp.

#define COPY_OP_SUGAR	(	TMPL,
		T		)

Value:

TMPL inline T copy (const T& x) {               \
  return unary_map<id_op> (x); }                \
TMPL inline T duplicate (const T& x) {          \
  return unary_map<duplicate_op> (x); }

Definition at line 169 of file defaults.hpp.

#define EQUAL_INT_SUGAR	(	TMPL,
		T		)

Value:

TMPL inline bool operator == (const T& x, const int& y) {       \
  return x == promote (y, x); }                                 \
TMPL inline bool operator != (const T& x, const int& y) {       \
  return x != promote (y, x); }                                 \
TMPL inline bool exact_eq (const T& x, const int& y) {          \
  return exact_eq (x, promote (y, x)); }                        \
TMPL inline bool exact_neq (const T& x, const int& y) {         \
  return exact_neq (x, promote (y, x)); }

Definition at line 111 of file defaults.hpp.

#define EQUAL_SCALAR_SUGAR	(	TMPL,
		T,
		C	)

Value:

TMPL inline bool operator == (const T& x, const C& y) { \
  return x == T(y); }                                   \
TMPL inline bool operator != (const T& x, const C& y) { \
  return x != T(y); }                                   \
TMPL inline bool exact_eq (const T& x, const C& y) {    \
  return exact_eq (x, T(y)); }                          \
TMPL inline bool exact_neq (const T& x, const C& y) {   \
  return exact_neq (x, T(y)); }

Definition at line 121 of file defaults.hpp.

#define EQUAL_SCALAR_SUGAR_BIS	(	TMPL,
		T,
		C	)

Value:

TMPL inline bool operator == (const C& x, const T& y) { \
  return T(x) == y; }                                   \
TMPL inline bool operator != (const C& x, const T& y) { \
  return T(x) != y; }                                   \
TMPL inline bool exact_eq (const C& x, const T& y) {    \
  return exact_eq (T(x), y); }                          \
TMPL inline bool exact_neq (const C& x, const T& y) {   \
  return exact_neq (T(x), y); }

Definition at line 131 of file defaults.hpp.

#define EXACT_IDENTITY_OP_SUGAR	(	TMPL,
		T		)

Value:

TMPL inline nat exact_hash (const T& x) {               \
  return unary_hash<exact_hash_op> (x); }               \
TMPL inline bool exact_eq (const T& x, const T& y) {    \
  return binary_test<exact_eq_op> (x, y); }             \
TMPL inline bool exact_neq (const T& x, const T& y) {   \
  return !binary_test<exact_eq_op> (x, y); }

Definition at line 95 of file defaults.hpp.

#define GCD_SUGAR	(	TMPL,
		C		)

Value:

TMPL inline C gcd (const C& x, const C& y) {                            \
  return (x == promote (0, x) && y == promote (0, x))?                  \
         promote (0, x): promote (1, x); }                              \
TMPL inline C lcm (const C& x, const C& y) {                            \
  return (x == promote (0, x) || y == promote (0, x))?                  \
         promote (0, x): x*y; }                                         \
TMPL inline xgcd_matrix<C> xgcd (const C& x, const C& y) {              \
  if (x == 0) {                                                         \
    if (y == 0)                                                         \
      return xgcd_matrix<C> (promote (1, x), promote (0, x),            \
                             promote (0, x), promote (1, x));           \
    else                                                                \
      return xgcd_matrix<C> (promote (0, x), promote (1, x) / y,        \
                             promote (1, x), promote (0, x));           \
  }                                                                     \
  else {                                                                \
    if (y == 0)                                                         \
      return xgcd_matrix<C> (promote (1, x) / x, promote (0, x),        \
                             promote (0, x), promote (1, x));           \
    else                                                                \
      return xgcd_matrix<C> (promote (1, x) / x, promote (0, x),        \
                             -y, x);                                    \
  }                                                                     \
}

Definition at line 360 of file defaults.hpp.

#define HARD_IDENTITY_OP_SUGAR	(	TMPL,
		T		)

Value:

TMPL inline nat hard_hash (const T& x) {                \
  return unary_hash<hard_hash_op> (x); }                \
TMPL inline bool hard_eq (const T& x, const T& y) {     \
  return binary_test<hard_eq_op> (x, y); }              \
TMPL inline bool hard_neq (const T& x, const T& y) {    \
  return !binary_test<hard_eq_op> (x, y); }

Definition at line 103 of file defaults.hpp.

#define HARD_TO_EXACT_IDENTITY_SUGAR	(	TMPL,
		T		)

Value:

TMPL inline nat exact_hash (const T& x) {               \
  return hard_hash (x); }                               \
TMPL inline bool exact_eq (const T& x, const T& y) {    \
  return hard_eq (x, y); }                              \
TMPL inline bool exact_neq (const T& x, const T& y) {   \
  return hard_neq (x, y); }

Definition at line 71 of file defaults.hpp.

#define HARD_TO_TRUE_IDENTITY_SUGAR	(	TMPL,
		T		)

Value:

TMPL inline nat hash (const T& x) {                     \
  return hard_hash (x); }                               \
TMPL inline bool operator == (const T& x, const T& y) { \
  return hard_eq (x, y); }                              \
TMPL inline bool operator != (const T& x, const T& y) { \
  return hard_neq (x, y); }

Definition at line 79 of file defaults.hpp.

#define HYPER_SUGAR	(	TMPL,
		C		)

Value:

TMPL inline C cosh (const C& x) {                       \
  return (exp (x) + exp (-x)) / promote (2, x); }       \
TMPL inline C sinh (const C& x) {                       \
  return (exp (x) - exp (-x)) / promote (2, x); }       \
TMPL inline C tanh (const C& x) {                       \
  return (exp (x) - exp (-x)) / (exp (x) + exp (-x)); }

Definition at line 665 of file defaults.hpp.

#define HYPOT_SUGAR	(	TMPL,
		C		)

Value:

TMPL inline C hypot (const C& x, const C& y) {  \
  return sqrt (square (x) + square (y)); }

Definition at line 636 of file defaults.hpp.

#define INV_HYPER_SUGAR	(	TMPL,
		C		)

Value:

TMPL inline C sech (const C& x) {                       \
  return promote (2, x) / (exp (x) + exp (-x)); }       \
TMPL inline C csch (const C& x) {                       \
  return promote (2, x) / (exp (x) - exp (-x)); }       \
TMPL inline C coth (const C& x) {                       \
  return (exp (x) + exp (-x)) / (exp (x) - exp (-x)); }

Definition at line 673 of file defaults.hpp.

#define INV_TRIGO_SUGAR	(	TMPL,
		C		)

Value:

TMPL inline C sec (const C& x) {                \
  return promote (1, x) / cos (x); }            \
TMPL inline C csc (const C& x) {                \
  return promote (1, x) / sin (x); }            \
TMPL inline C cot (const C& x) {                \
  return cos (x) / sin (x); }

Definition at line 657 of file defaults.hpp.

#define POOR_MAN_ELEMENTARY_SUGAR	(	TMPL,
		C		)

Value:

TMPL inline C exp (const C& x) {                        \
  ASSERT (x == (promote (0, x)), "zero expected");      \
  return promote (1, x); }                              \
TMPL inline C log (const C& x) {                        \
  ASSERT (x == (promote (1, x)), "one expected");       \
  return promote (0, x); }                              \
TMPL inline C cos (const C& x) {                        \
  ASSERT (x == (promote (0, x)), "zero expected");      \
  return promote (1, x); }                              \
TMPL inline C sin (const C& x) {                        \
  ASSERT (x == (promote (0, x)), "zero expected");      \
  return promote (0, x); }                              \
TMPL inline C tan (const C& x) {                        \
  ASSERT (x == (promote (0, x)), "zero expected");      \
  return promote (0, x); }                              \
TMPL inline C acos (const C& x) {                       \
  ASSERT (x == (promote (1, x)), "one expected");       \
  return promote (0, x); }                              \
TMPL inline C asin (const C& x) {                       \
  ASSERT (x == (promote (0, x)), "zero expected");      \
  return promote (0, x); }                              \
TMPL inline C atan (const C& x) {                       \
  ASSERT (x == (promote (0, x)), "zero expected");      \
  return promote (0, x); }

Definition at line 610 of file defaults.hpp.

#define POOR_MAN_SQRT_SUGAR	(	TMPL,
		C		)

Value:

TMPL inline C sqrt (const C& x) {                                       \
  ASSERT (x == (C)(0) || x == (C)(1), "zero or one expected"); return x; }

Definition at line 606 of file defaults.hpp.

#define POW_SUGAR	(	TMPL,
		C		)

Value:

TMPL inline C pow (const C& x, const C& y) {    \
  return exp (y * log (x)); }

Definition at line 640 of file defaults.hpp.

#define SHIFT_INT_SUGAR	(	TMPL,
		T		)

Value:

TMPL inline T& operator <<= (T& x, const int& y) { return x= x << y; }      \
TMPL inline T& operator >>= (T& x, const int& y) { return x= x >> y; }      \
TMPL inline T& operator <<= (T& x, const long int& y) { return x= x << y; } \
TMPL inline T& operator >>= (T& x, const long int& y) { return x= x >> y; }

Definition at line 251 of file defaults.hpp.

#define STRICT_COMPARE_SUGAR	(	TMPL,
		T		)

Value:

TMPL inline bool operator <  (const T& x, const T& y) { \
  return x<=y && !(x==y); }                             \
TMPL inline bool operator >  (const T& x, const T& y) { \
  return x>=y && !(x==y); }

Definition at line 492 of file defaults.hpp.

#define TRUE_IDENTITY_OP_SUGAR	(	TMPL,
		T		)

Value:

TMPL inline nat hash (const T& x) {                     \
  return unary_hash<hash_op> (x); }                     \
TMPL inline bool operator == (const T& x, const T& y) { \
  return binary_test<equal_op> (x, y); }                \
TMPL inline bool operator != (const T& x, const T& y) { \
  return !binary_test<equal_op> (x, y); }

Definition at line 87 of file defaults.hpp.

#define TRUE_TO_EXACT_IDENTITY_SUGAR	(	TMPL,
		T		)

Value:

TMPL inline nat exact_hash (const T& x) {               \
  return hash (x); }                                    \
TMPL inline bool exact_eq (const T& x, const T& y) {    \
  return x == y; }                                      \
TMPL inline bool exact_neq (const T& x, const T& y) {   \
  return x != y; }

Definition at line 63 of file defaults.hpp.