include/basix/basix.hpp File Reference

#include <basix/fast_new.hpp>
#include <cmath>
#include <stdint.h>

Go to the source code of this file.

Classes

struct rep_struct
struct fixed_value< C, x >
struct variable_value< C, V >
struct local_value< C, V >
struct vector_variant_helper< C >
struct uniform_threshold< n >
struct threshold_helper< C, Th >
struct threshold_helper< C, uniform_threshold< n > >
struct threshold_helper_1< C, Th >
struct threshold_helper_1< C, uniform_threshold< n > >

Namespaces

namespace mmx

Defines

#define LESSGTR <>
#define STMPL template<>
#define INDIRECT_PROTO(T, R)
Prototype of the target class T with representation R.
#define INDIRECT_PROTO_1(T, R, X)
Prototype of the target class T<X> with representation R<X>.
#define INDIRECT_PROTO_2(T, R, X, Y)
Prototype of the target class T<X,Y> with representation R<X,Y>.
#define INDIRECT_PROTO_3(T, R, X, Y, Z)
Prototype of the target class T<X,Y,Z> with representation R<X,Y,Z>.
#define INDIRECT_PROTO_4(T, R, W, X, Y, Z)
Prototype of the target class T<W,X,Y,Z> with representation R<W,X,Y,Z>.
#define REP_STRUCT :public rep_struct
#define REP_STRUCT_1(X) :public rep_struct, public format<X >
#define REP_STRUCT_2(X, Y) :public rep_struct, public encapsulate1<format<X > >, public encapsulate2<format<Y> >
#define INC_COUNT(x) { (x)->ref_count++; }
#define DEC_COUNT(x) { if (0==--((x)->ref_count)) delete (x); }
#define INC_NULL_COUNT(x) { if ((x)!=NULL) (x)->ref_count++; }
#define DEC_NULL_COUNT(x)
#define INDIRECT_IMPL(T, R)
#define INDIRECT_NULL_IMPL(T, R)
#define INDIRECT_IMPL_1(T, R, XX, X)
#define INDIRECT_NULL_IMPL_1(T, R, XX, X)
#define INDIRECT_IMPL_2(T, R, XX, X, YY, Y)
#define INDIRECT_IMPL_3(T, R, XX, X, YY, Y, ZZ, Z)
#define INDIRECT_IMPL_4(T, R, WW, W, XX, X, YY, Y, ZZ, Z)
#define DEFINE_VARIANT(L, R)
#define DEFINE_VARIANT_1(XX, X, L, R)
#define Threshold(C, Th) threshold_helper<C,Th >::impl::val
#define Threshold_1(C, Th, d) threshold_helper_1<C,Th>::val(d)

Enumerations

enum print_format {
  blank, stroke, indent, unindent,
  reset_indent, cr, lf, hrule,
  flush_now, black_foreground, red_foreground, green_foreground,
  yellow_foreground, blue_foreground, magenta_foreground, cyan_foreground,
  white_foreground, black_background, red_background, green_background,
  yellow_background, blue_background, magenta_background, cyan_background,
  white_background, bold, underline, blink,
  reset_attributes
}
Special objects that affect output when printed.
More...

Functions

double hypot (double, double) __attribute__((const ))
void noop ()
template<typename C > C copy (const C &x)
template<typename C > nat as_hash (const C *p)
nat hash (char c)
nat hash (signed char c)
nat hash (unsigned char c)
nat hash (short int c)
nat hash (short unsigned int c)
nat hash (int c)
nat hash (unsigned int c)
nat hash (long int c)
nat hash (long unsigned int c)
nat hash (long long int c)
nat hash (long long unsigned int c)
nat hash (const float &x)
nat hash (const double &x)
template<typename C > nat hash (C *p)
nat exact_hash (char c)
nat exact_hash (signed char c)
nat exact_hash (unsigned char c)
nat exact_hash (short int c)
nat exact_hash (short unsigned int c)
nat exact_hash (int c)
nat exact_hash (unsigned int c)
nat exact_hash (long int c)
nat exact_hash (long unsigned int c)
nat exact_hash (long long int c)
nat exact_hash (long long unsigned int c)
nat exact_hash (const float &x)
nat exact_hash (const double &x)
template<typename C > nat exact_hash (C *p)
bool exact_eq (char c1, char c2)
bool exact_eq (signed char c1, signed char c2)
bool exact_eq (unsigned char c1, unsigned char c2)
bool exact_eq (short int c1, short int c2)
bool exact_eq (short unsigned int c1, short unsigned int c2)
bool exact_eq (int c1, int c2)
bool exact_eq (unsigned int c1, unsigned int c2)
bool exact_eq (long int c1, long int c2)
bool exact_eq (long unsigned int c1, long unsigned int c2)
bool exact_eq (long long int c1, long long int c2)
bool exact_eq (long long unsigned int c1, long long unsigned int c2)
bool exact_eq (float x, float y)
bool exact_eq (double x, double y)
template<typename C > bool exact_eq (C *p1, C *p2)
bool exact_neq (char c1, char c2)
bool exact_neq (signed char c1, signed char c2)
bool exact_neq (unsigned char c1, unsigned char c2)
bool exact_neq (short int c1, short int c2)
bool exact_neq (short unsigned int c1, short unsigned int c2)
bool exact_neq (int c1, int c2)
bool exact_neq (unsigned int c1, unsigned int c2)
bool exact_neq (long int c1, long int c2)
bool exact_neq (long unsigned int c1, long unsigned int c2)
bool exact_neq (long long int c1, long long int c2)
bool exact_neq (long long unsigned int c1, long long unsigned int c2)
bool exact_neq (float x, float y)
bool exact_neq (double x, double y)
template<typename C > bool exact_neq (C *p1, C *p2)
template<typename C > nat hard_hash (const C &x)
template<typename C > bool hard_eq (const C &x, const C &y)
template<typename C > bool hard_neq (const C &x, const C &y)
template<typename C > bool hard_less (const C &x, const C &y)
template<typename C > bool hard_gtr (const C &x, const C &y)

Variables

int mmx_argc
char ** mmx_argv

Detailed Description

Definition in file basix.hpp.

Define Documentation

#define DEC_COUNT ( x ) { if (0==--((x)->ref_count)) delete (x); }

Definition at line 173 of file basix.hpp.

Referenced by Indirect< R >::operator=(), and Indirect< R >::~Indirect().

#define DEC_NULL_COUNT ( x )

Value:

{ \
  if ((x)!=NULL && 0==--((x)->ref_count)) delete (x); }

Definition at line 175 of file basix.hpp.

#define DEFINE_VARIANT	(	L,
		R		)

Value:

struct L: public R {}; \
template<typename FF, typename MM> \
struct implementation<FF,MM,L >: \
  public implementation<FF,MM,R > {};

Definition at line 493 of file basix.hpp.

#define DEFINE_VARIANT_1	(	XX,
		X,
		L,
		R	)

Value:

template<XX> struct L: public R {}; \
template<typename FF, typename MM, XX> \
struct implementation<FF,MM,L<X> >: \
  public implementation<FF,MM,R > {};

Definition at line 499 of file basix.hpp.

#define INC_COUNT ( x ) { (x)->ref_count++; }

Definition at line 172 of file basix.hpp.

Referenced by function_0< void >::function_0(), function_1< bool, typename argument_helper< T >::arg_type >::function_1(), function_2< D, S1, S2 >::function_2(), function_3< D, S1, S2, S3 >::function_3(), function_4< D, S1, S2, S3, S4 >::function_4(), function_5< D, S1, S2, S3, S4, S5 >::function_5(), function_6< D, S1, S2, S3, S4, S5, S6 >::function_6(), function_7< D, S1, S2, S3, S4, S5, S6, S7 >::function_7(), function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 >::function_8(), Indirect< R >::Indirect(), Indirect< R >::operator=(), and symbol< string >::symbol().

#define INC_NULL_COUNT ( x ) { if ((x)!=NULL) (x)->ref_count++; }

Definition at line 174 of file basix.hpp.

#define INDIRECT_IMPL	(	T,
		R		)

Value:

inline T::T (R* rep2): rep(rep2) {}                                     \
  inline T::T (const R* rep2, bool with_inc):                           \
    rep((R*) (void*) rep2) { (void) with_inc; INC_COUNT (rep); }        \
  inline T::T (const T& x): rep(x.rep) { INC_COUNT (rep); }             \
  inline T::~T () { DEC_COUNT (rep); }                                  \
  inline const R* T::operator -> () const { return rep; }               \
  inline T& T::operator = (const T& x) {                                \
    INC_COUNT (x.rep); DEC_COUNT (rep);                                 \
    rep=x.rep; return *this; }                                          \
  inline void T::secure () {                                            \
    if (rep->ref_count>1) *this= copy (*this); }                        \
  inline R* inside (const T& x) {                                       \
    return const_cast<R*> (x.operator -> ()); }                         \
  STMPL inline nat hard_hash (const T& x) {                             \
    return as_hash (x.operator -> ()); }                                \
  STMPL inline bool hard_eq (const T& x, const T& y) {                  \
    return (x.operator -> ()) == (y.operator -> ()); }                  \
  STMPL inline bool hard_neq (const T& x, const T& y) {                 \
    return (x.operator -> ()) != (y.operator -> ()); }

Definition at line 278 of file basix.hpp.

#define INDIRECT_IMPL_1	(	T,
		R,
		XX,
		X	)

Value:

template<XX> inline T<X >::T (R<X >* rep2): rep(rep2) {}                \
  template<XX> inline T<X >::T (const R<X >* rep2, bool with_inc):      \
    rep((R<X >*) (void*) rep2) { (void) with_inc; INC_COUNT (rep); }    \
  template<XX> inline T<X >::T (const T<X >& x): rep(x.rep) {           \
    INC_COUNT (rep); }                                                  \
  template<XX> inline T<X >::~T () { DEC_COUNT (rep); }                 \
  template<XX> inline const R<X >* T<X >::operator -> () const {        \
    return rep; }                                                       \
  template<XX> inline R<X >* T<X >::operator -> () {                    \
    return rep; }                                                       \
  template<XX> inline T<X >&                                            \
  T<X >::operator = (const T<X >& x) {                                  \
    INC_COUNT (x.rep); DEC_COUNT (rep);                                 \
    rep=x.rep; return *this; }                                          \
  template<XX> inline void T<X >::secure () {                           \
    if (rep->ref_count>1) *this= copy (*this); }                        \
  template<XX> R<X >* inside (const T<X >& x) {                         \
    return const_cast<R<X >*> (x.operator -> ()); }                     \
  template<XX> inline nat hard_hash (const T<X >& x) {                  \
    return as_hash (x.operator -> ()); }                                \
  template<XX> inline bool hard_eq (const T<X >& x, const T<X >& y) {   \
    return (x.operator -> ()) == (y.operator -> ()); }                  \
  template<XX> inline bool hard_neq (const T<X >& x, const T<X >& y) {  \
    return (x.operator -> ()) != (y.operator -> ()); }

Definition at line 320 of file basix.hpp.

#define INDIRECT_IMPL_2	(	T,
		R,
		XX,
		X,
		YY,
		Y	)

Value:

template<XX,YY> inline T<X,Y >::T (R<X,Y >* rep2): rep(rep2) {}       \
  template<XX,YY> inline T<X,Y >::T (const R<X,Y >* rep2, bool inc):          \
    rep((R<X,Y >*) (void*) rep2) { (void) inc; INC_COUNT (rep); }             \
  template<XX,YY> inline T<X,Y >::T (const T<X,Y >& x): rep(x.rep) {          \
    INC_COUNT (rep); }                                                        \
  template<XX,YY> inline T<X,Y >::~T () { DEC_COUNT (rep); }                  \
  template<XX,YY> inline const R<X,Y >* T<X,Y >::operator -> () const {       \
    return rep; }                                                             \
  template<XX,YY> inline T<X,Y >&                                             \
  T<X,Y >::operator = (const T<X,Y >& x) {                                    \
    INC_COUNT (x.rep); DEC_COUNT (rep);                                       \
    rep=x.rep; return *this; }                                                \
  template<XX,YY> inline void T<X,Y >::secure () {                            \
    if (rep->ref_count>1) *this= copy (*this); }                              \
  template<XX,YY> R<X,Y >* inside (const T<X,Y >& x) {                        \
    return const_cast<R<X,Y >*> (x.operator -> ()); }                         \
  template<XX,YY> inline nat hard_hash (const T<X,Y >& x) {                   \
    return as_hash (x.operator -> ()); }                                      \
  template<XX,YY> inline bool hard_eq (const T<X,Y >& x, const T<X,Y >& y) {  \
    return (x.operator -> ()) == (y.operator -> ()); }                        \
  template<XX,YY> inline bool hard_neq (const T<X,Y >& x, const T<X,Y >& y) { \
    return (x.operator -> ()) != (y.operator -> ()); }

Definition at line 372 of file basix.hpp.

#define INDIRECT_IMPL_3	(	T,
		R,
		XX,
		X,
		YY,
		Y,
		ZZ,
		Z	)

Value:

template<XX,YY,ZZ> inline T<X,Y,Z >::T (R<X,Y,Z >* rep2):               \
    rep(rep2) {}                                                        \
  template<XX,YY,ZZ> inline                                             \
  T<X,Y,Z >::T (const R<X,Y,Z >* rep2, bool inc):                       \
    rep((R<X,Y,Z >*) (void*) rep2) { (void) inc; INC_COUNT (rep); }     \
  template<XX,YY,ZZ> inline T<X,Y,Z >::T (const T<X,Y,Z >& x):          \
    rep(x.rep) { INC_COUNT (rep); }                                     \
  template<XX,YY,ZZ> inline T<X,Y,Z >::~T () { DEC_COUNT (rep); }       \
  template<XX,YY,ZZ> inline const R<X,Y,Z >*                            \
  T<X,Y,Z >::operator -> () const {                                     \
    return rep; }                                                       \
  template<XX,YY,ZZ> inline T<X,Y,Z >&                                  \
  T<X,Y,Z >::operator = (const T<X,Y,Z >& x) {                          \
    INC_COUNT (x.rep); DEC_COUNT (rep);                                 \
    rep=x.rep; return *this; }                                          \
  template<XX,YY,ZZ> inline void T<X,Y,Z >::secure () {                 \
    if (rep->ref_count>1) *this= copy (*this); }                        \
  template<XX,YY,ZZ> R<X,Y,Z >* inside (const T<X,Y,Z >& x) {           \
    return const_cast<R<X,Y,Z >*> (x.operator -> ()); }                 \
  template<XX,YY,ZZ> inline nat hard_hash (const T<X,Y,Z>& x) {         \
    return as_hash (x.operator -> ()); }                                \
  template<XX,YY,ZZ> inline bool                                        \
  hard_eq (const T<X,Y,Z >& x, const T<X,Y,Z >& y) {                    \
    return (x.operator -> ()) == (y.operator -> ()); }                  \
  template<XX,YY,ZZ> inline bool                                        \
  hard_neq (const T<X,Y,Z >& x, const T<X,Y,Z >& y) {                   \
    return (x.operator -> ()) != (y.operator -> ()); }

Definition at line 396 of file basix.hpp.

#define INDIRECT_IMPL_4	(	T,
		R,
		WW,
		W,
		XX,
		X,
		YY,
		Y,
		ZZ,
		Z	)

Value:

template<WW,XX,YY,ZZ> inline T<W,X,Y,Z >::T (R<W,X,Y,Z >* rep2):        \
    rep(rep2) {}                                                        \
  template<WW,XX,YY,ZZ> inline                                          \
  T<W,X,Y,Z >::T (const R<W,X,Y,Z >* rep2, bool inc):                   \
    rep((R<W,X,Y,Z >*) (void*) rep2) { (void) inc; INC_COUNT (rep); }   \
  template<WW,XX,YY,ZZ> inline T<W,X,Y,Z >::T (const T<W,X,Y,Z >& x):   \
    rep(x.rep) { INC_COUNT (rep); }                                     \
  template<WW,XX,YY,ZZ> inline T<W,X,Y,Z >::~T () { DEC_COUNT (rep); }  \
  template<WW,XX,YY,ZZ> inline const R<W,X,Y,Z >*                       \
  T<W,X,Y,Z >::operator -> () const {                                   \
    return rep; }                                                       \
  template<WW,XX,YY,ZZ> inline T<W,X,Y,Z >&                             \
  T<W,X,Y,Z >::operator = (const T<W,X,Y,Z >& x) {                      \
    INC_COUNT (x.rep); DEC_COUNT (rep);                                 \
    rep=x.rep; return *this; }                                          \
  template<WW,XX,YY,ZZ> inline void T<W,X,Y,Z >::secure () {            \
    if (rep->ref_count>1) *this= copy (*this); }                        \
  template<WW,XX,YY,ZZ> R<W,X,Y,Z >* inside (const T<W,X,Y,Z >& x) {    \
    return const_cast<R<W,X,Y,Z >*> (x.operator -> ()); }               \
  template<WW,XX,YY,ZZ> inline nat hard_hash (const T<W,X,Y,Z>& x) {    \
    return as_hash (x.operator -> ()); }                                \
  template<WW,XX,YY,ZZ> inline bool                                     \
  hard_eq (const T<W,X,Y,Z >& x, const T<W,X,Y,Z >& y) {                \
    return (x.operator -> ()) == (y.operator -> ()); }                  \
  template<WW,XX,YY,ZZ> inline bool                                     \
  hard_neq (const T<W,X,Y,Z >& x, const T<W,X,Y,Z >& y) {               \
    return (x.operator -> ()) != (y.operator -> ()); }

Definition at line 425 of file basix.hpp.

#define INDIRECT_NULL_IMPL	(	T,
		R		)

Value:

inline T::T (R* rep2): rep(rep2) {}                                     \
  inline T::T (const R* rep2, bool with_inc):                           \
    rep((R*) (void*) rep2) { (void) with_inc; INC_NULL_COUNT (rep); }   \
  inline T::T (const T& x): rep(x.rep) { INC_NULL_COUNT (rep); }        \
  inline T::~T () { DEC_NULL_COUNT (rep); }                             \
  inline const R* T::operator -> () const { return rep; }               \
  inline T& T::operator = (const T& x) {                                \
    INC_NULL_COUNT (x.rep); DEC_NULL_COUNT (rep);                       \
    rep=x.rep; return *this; }                                          \
  inline void T::secure () {                                            \
    if (rep->ref_count>1) *this= copy (*this); }                        \
  inline R* inside (const T& x) {                                       \
    return const_cast<R*> (x.operator -> ()); }                         \
  STMPL inline nat hard_hash (const T& x) {                             \
    return as_hash (x.operator -> ()); }                                \
  STMPL inline bool hard_eq (const T& x, const T& y) {                  \
    return (x.operator -> ()) == (y.operator -> ()); }                  \
  STMPL inline bool hard_neq (const T& x, const T& y) {                 \
    return (x.operator -> ()) != (y.operator -> ()); }

Definition at line 299 of file basix.hpp.

#define INDIRECT_NULL_IMPL_1	(	T,
		R,
		XX,
		X	)

Value:

template<XX> inline T<X >::T (R<X >* rep2): rep(rep2) {}                  \
  template<XX> inline T<X >::T (const R<X >* rep2, bool with_inc):        \
    rep((R<X >*) (void*) rep2) { (void) with_inc; INC_NULL_COUNT (rep); } \
  template<XX> inline T<X >::T (const T<X >& x): rep(x.rep) {             \
    INC_NULL_COUNT (rep); }                                               \
  template<XX> inline T<X >::~T () { DEC_NULL_COUNT (rep); }              \
  template<XX> inline const R<X >* T<X >::operator -> () const {          \
    return rep; }                                                         \
  template<XX> inline R<X >* T<X >::operator -> () {                      \
    return rep; }                                                         \
  template<XX> inline T<X >&                                              \
  T<X >::operator = (const T<X >& x) {                                    \
    INC_NULL_COUNT (x.rep); DEC_NULL_COUNT (rep);                         \
    rep=x.rep; return *this; }                                            \
  template<XX> inline void T<X >::secure () {                             \
    if (rep->ref_count>1) *this= copy (*this); }                          \
  template<XX> R<X >* inside (const T<X >& x) {                           \
    return const_cast<R<X >*> (x.operator -> ()); }                       \
  template<XX> inline nat hard_hash (const T<X >& x) {                    \
    return as_hash (x.operator -> ()); }                                  \
  template<XX> inline bool hard_eq (const T<X >& x, const T<X >& y) {     \
    return (x.operator -> ()) == (y.operator -> ()); }                    \
  template<XX> inline bool hard_neq (const T<X >& x, const T<X >& y) {    \
    return (x.operator -> ()) != (y.operator -> ()); }

Definition at line 346 of file basix.hpp.

#define INDIRECT_PROTO	(	T,
		R		)

Value:

MMX_ALLOCATORS                                  \
protected:                                      \
  R* rep;                                       \
public:                                         \
  inline T (R* rep2);                           \
  inline T (const R* rep2, bool with_inc);      \
  inline T (const T& x);                        \
  inline ~T ();                                 \
  inline T& operator= (const T& x);             \
  inline const R* operator-> () const;          \
  inline void secure ();

Prototype of the target class T with representation R.

Definition at line 83 of file basix.hpp.

#define INDIRECT_PROTO_1	(	T,
		R,
		X	)

Value:

MMX_ALLOCATORS                                  \
protected:                                      \
  R<X >* rep;                                   \
public:                                         \
  inline T (R<X >* rep2);                       \
  inline T (const R<X >* rep2, bool with_inc);  \
  inline T (const T& x);                        \
  inline ~T ();                                 \
  inline T& operator= (const T& x);             \
  inline const R<X >* operator-> () const;      \
  inline R<X >* operator-> ();                  \
  inline void secure ();                        \
  typedef X value_type;

Prototype of the target class T<X> with representation R<X>.

Definition at line 98 of file basix.hpp.

#define INDIRECT_PROTO_2	(	T,
		R,
		X,
		Y	)

Value:

MMX_ALLOCATORS                                  \
protected:                                      \
  R<X,Y >* rep;                                 \
public:                                         \
  inline T (R<X,Y >* rep2);                     \
  inline T (const R<X,Y >* rep2, bool inc);     \
  inline T (const T& x);                        \
  inline ~T ();                                 \
  inline T& operator= (const T& x);             \
  inline const R<X,Y >* operator-> () const;    \
  inline void secure ();

Prototype of the target class T<X,Y> with representation R<X,Y>.

Definition at line 115 of file basix.hpp.

#define INDIRECT_PROTO_3	(	T,
		R,
		X,
		Y,
		Z	)

Value:

MMX_ALLOCATORS                                  \
protected:                                      \
  R<X,Y,Z >* rep;                               \
public:                                         \
  inline T (R<X,Y,Z >* rep2);                   \
  inline T (const R<X,Y,Z >* rep2, bool inc);   \
  inline T (const T& x);                        \
  inline ~T ();                                 \
  inline T& operator= (const T& x);             \
  inline const R<X,Y,Z >* operator-> () const;  \
  inline void secure ();

Prototype of the target class T<X,Y,Z> with representation R<X,Y,Z>.

Definition at line 130 of file basix.hpp.

#define INDIRECT_PROTO_4	(	T,
		R,
		W,
		X,
		Y,
		Z	)

Value:

MMX_ALLOCATORS                                  \
protected:                                      \
  R<W,X,Y,Z >* rep;                             \
public:                                         \
  inline T (R<W,X,Y,Z >* rep2);                 \
  inline T (const R<W,X,Y,Z >* rep2, bool inc); \
  inline T (const T& x);                        \
  inline ~T ();                                 \
  inline T& operator= (const T& x);             \
  inline const R<W,X,Y,Z >* operator-> () const;\
  inline void secure ();

Prototype of the target class T<W,X,Y,Z> with representation R<W,X,Y,Z>.

Definition at line 145 of file basix.hpp.

#define LESSGTR <>

Definition at line 34 of file basix.hpp.

#define REP_STRUCT :public rep_struct

Definition at line 169 of file basix.hpp.

#define REP_STRUCT_1 ( X ) :public rep_struct, public format<X >

Definition at line 170 of file basix.hpp.

#define REP_STRUCT_2	(	X,
		Y		)	:public rep_struct, public encapsulate1<format<X > >, public encapsulate2<format<Y> >

Definition at line 171 of file basix.hpp.

#define STMPL template<>

Definition at line 35 of file basix.hpp.

#define Threshold	(	C,
		Th		)	threshold_helper<C,Th >::impl::val

Definition at line 521 of file basix.hpp.

#define Threshold_1	(	C,
		Th,
		d	)	threshold_helper_1<C,Th>::val(d)

Definition at line 537 of file basix.hpp.

Function Documentation

double hypot	(	double	,
		double
	)			const