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

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 uintptr_t unsigned long int
#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,
lf, hrule, flush_now
}
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 hard_hash (const C &x)
template<typename C > nat as_hash (const C *p)
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 147 of file basix.hpp.

#define DEC_NULL_COUNT ( x )

Value:

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

Definition at line 149 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 383 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 389 of file basix.hpp.

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

Definition at line 146 of file basix.hpp.

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

Definition at line 148 of file basix.hpp.

Referenced by function_0< D >::function_0(), function_1< D, S1 >::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(), function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 >::operator=(), function_7< D, S1, S2, S3, S4, S5, S6, S7 >::operator=(), function_6< D, S1, S2, S3, S4, S5, S6 >::operator=(), function_5< D, S1, S2, S3, S4, S5 >::operator=(), function_4< D, S1, S2, S3, S4 >::operator=(), function_3< D, S1, S2, S3 >::operator=(), function_2< D, S1, S2 >::operator=(), function_1< D, S1 >::operator=(), and function_0< D >::operator=().

#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 168 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 210 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 262 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 286 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 315 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 189 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 236 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 57 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 72 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 89 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 104 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 119 of file basix.hpp.

#define LESSGTR <>

Definition at line 34 of file basix.hpp.

Referenced by mmx::REP_STRUCT_1(), and mmx::REP_STRUCT_2().

#define REP_STRUCT :public rep_struct

Definition at line 143 of file basix.hpp.

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

Definition at line 144 of file basix.hpp.

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

Definition at line 145 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 411 of file basix.hpp.

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

Definition at line 427 of file basix.hpp.

#define uintptr_t unsigned long int

Definition at line 23 of file basix.hpp.

Referenced by mmx::as_hash().

Function Documentation

double hypot	(	double	,
		double
	)		const