Developer documentation

mmx::texp Namespace Reference

Namespaces

 structure
 

Classes

struct  abs_value
 
struct  As
 
struct  binary_operator
 
struct  binary_operator_prototype
 
struct  binary_operator_structure_prototype
 
struct  binary_operator_structure_prototype< _add_, X, Y, structure::vector, structure::vector >
 
struct  binary_operator_structure_prototype< _add_, X, Y, SX, SY >
 
struct  binary_operator_structure_prototype< _div_, M, S, structure::matrix, structure::scalar >
 
struct  binary_operator_structure_prototype< _div_, X, Y, structure::vector, structure::scalar >
 
struct  binary_operator_structure_prototype< _div_, X, Y, SX, SY >
 
struct  binary_operator_structure_prototype< _mul_, X, Y, structure::matrix, structure::scalar >
 
struct  binary_operator_structure_prototype< _mul_, X, Y, structure::matrix, structure::vector >
 
struct  binary_operator_structure_prototype< _mul_, X, Y, structure::scalar, structure::matrix >
 
struct  binary_operator_structure_prototype< _mul_, X, Y, structure::scalar, structure::vector >
 
struct  binary_operator_structure_prototype< _mul_, X, Y, structure::vector, structure::scalar >
 
struct  binary_operator_structure_prototype< _mul_, X, Y, structure::vector, structure::vector >
 
struct  binary_operator_structure_prototype< _mul_, X, Y, SX, SY >
 
struct  binary_operator_structure_prototype< _sub_, X, Y, structure::vector, structure::vector >
 
struct  binary_operator_structure_prototype< _sub_, X, Y, SX, SY >
 
struct  BoolType
 
struct  BoolType< true >
 
struct  cst
 return T = const Y from X = Y or X = const Y More...
 
struct  cst< const X >
 
struct  deconst
 
struct  deconst< const X >
 
struct  Eq
 
struct  Eq< A, A >
 
struct  equal
 ask for type equality return T in { false_t, true_t } and V in {0,1} More...
 
struct  equal< X, X >
 
struct  false_t
 structure defining a negative answer More...
 
struct  fieldof
 x (in X) + y (in Y) is subset of fieldof<X,Y>::T More...
 
struct  fieldof_
 
struct  fieldof_< double, int >
 
struct  fieldof_< double, unsigned int >
 
struct  fieldof_< int, double >
 
struct  fieldof_< int, unsigned int >
 
struct  fieldof_< std::complex< X >, std::complex< X > >
 
struct  fieldof_< std::complex< X >, std::complex< Y > >
 
struct  fieldof_< unsigned int, double >
 
struct  fieldof_< unsigned int, int >
 
struct  gentlist
 helper for type list definition More...
 
struct  gentlist< X, null_t >
 
struct  hasfunction
 
struct  haskernel
 return true_t if the number type X comes from a kernel. More...
 
struct  hasproperty
 
struct  If
 
struct  If< false, A, B >
 
struct  instanceof
 
struct  instanceof< R< X >, Y >
 
struct  instanceof< R< X, N >, Y >
 
struct  instanceof< V< C, R >, Y >
 
struct  Int
 
struct  integerof
 
struct  integerof_
 
struct  is_ptr
 
struct  isapproximate
 Traits class which specifies if the type X is not exact. More...
 
struct  isexact
 
struct  isexact_
 
struct  isfield
 
struct  isfield_
 
struct  isfield_< double >
 
struct  isfield_< float >
 
struct  isfield_< long double >
 
struct  isring
 
struct  isring_
 
struct  isring_< double >
 
struct  isring_< float >
 
struct  isring_< int >
 
struct  isring_< long double >
 
struct  isring_< long int >
 
struct  issubsetof
 X can be seen as an arithmetic subset of Y (eg. "Z in Q") return texp::true_t if all x in X are in Y. specialization must be done on subsetof_. More...
 
struct  issubsetof_
 
struct  issubsetof_< int, Y >
 
struct  issubsetof_< R< X >, R< Y > >
 
struct  issupersetof
 
struct  issupersetof< X, texp::tlist< A, Tail > >
 
struct  issupersetof< X, texp::tlist< A, texp::null_t > >
 
struct  kernel
 
struct  kernel_fieldof
 
struct  kernel_fieldof< K, typename K::floating, typename K::ieee >
 
struct  kernel_fieldof< K, typename K::ieee, typename K::floating >
 
struct  kernel_fieldof< null_t, X, Y >
 
struct  kernel_integerof
 
struct  kernel_integerof< null_t, X >
 
struct  kernel_isexact
 
struct  kernel_isexact< K, typename K::floating >
 
struct  kernel_isexact< K, typename K::ieee >
 
struct  kernel_isexact< K, typename K::integer >
 
struct  kernel_isexact< K, typename K::rational >
 
struct  kernel_isexact< null_t, X >
 
struct  kernel_isfield
 
struct  kernel_isfield< K, typename K::integer >
 
struct  kernel_isfield< null_t, X >
 
struct  kernel_isring
 
struct  kernel_isring< null_t, X >
 
struct  kernel_issubsetof
 kernel version of issubsetof More...
 
struct  kernel_issubsetof< K, double, typename K::floating >
 
struct  kernel_issubsetof< K, typename K::floating, typename K::rational >
 
struct  kernel_issubsetof< K, typename K::integer, algebraic< K > >
 
struct  kernel_issubsetof< K, typename K::integer, double >
 
struct  kernel_issubsetof< K, typename K::integer, typename K::floating >
 neglecting the overflow problem we assume that floating is superset of integer More...
 
struct  kernel_issubsetof< K, typename K::integer, typename K::rational >
 
struct  kernel_issubsetof< null_t, X, Y >
 
struct  kernel_rationalof
 
struct  kernel_rationalof< K, X, false_t >
 
struct  kernel_rationalof< K, X, true_t >
 
struct  kernel_rationalof< null_t, X, extended >
 
struct  kernel_ringof
 
struct  kernel_ringof< K, typename K::floating, typename K::ieee >
 
struct  kernel_ringof< K, typename K::floating, typename K::integer >
 
struct  kernel_ringof< K, typename K::floating, typename K::rational >
 
struct  kernel_ringof< K, typename K::ieee, typename K::floating >
 
struct  kernel_ringof< K, typename K::ieee, typename K::integer >
 
struct  kernel_ringof< K, typename K::ieee, typename K::rational >
 
struct  kernel_ringof< K, typename K::integer, typename K::floating >
 
struct  kernel_ringof< K, typename K::integer, typename K::ieee >
 
struct  kernel_ringof< K, typename K::integer, typename K::rational >
 
struct  kernel_ringof< K, typename K::rational, typename K::floating >
 
struct  kernel_ringof< K, typename K::rational, typename K::ieee >
 
struct  kernel_ringof< K, typename K::rational, typename K::integer >
 
struct  kernel_structureof
 
struct  kernel_structureof< K, typename K::floating >
 
struct  kernel_structureof< K, typename K::ieee >
 
struct  kernel_structureof< K, typename K::integer >
 
struct  kernel_structureof< K, typename K::rational >
 
struct  kernel_structureof< null_t, X >
 
struct  kernelof
 return the arithmetic kernel from which the type X comes from. More...
 
struct  kernelof_
 return the arithmetic kernel from which the unqualified type X comes from. More...
 
struct  kernelof_< algebraic< K > >
 
struct  kernelof_< GMP::extended_integer >
 
struct  kernelof_< GMP::extended_rational >
 
struct  kernelof_< GMP::floating >
 
struct  kernelof_< GMP::ieee >
 
struct  kernelof_< GMP::integer >
 
struct  kernelof_< GMP::rational >
 
struct  kernelof_< IEEE754::floating >
 
struct  kernelof_< IEEE754::integer >
 
struct  kernelof_< Interval< X, r > >
 
struct  null_t
 structure defining a the empty list More...
 
struct  operator_iscommutative
 
struct  operator_isinplace
 
struct  Pair
 
struct  ptr
 return T = Y * from X = Y or X = Y * More...
 
struct  ptr< X * >
 
struct  ptr< X *const >
 
struct  rationalof
 
struct  rationalof_
 
struct  ref
 return T = Y & from X = Y or X = Y & More...
 
struct  ref< X & >
 
struct  ringof
 x (in X) + y (in Y) is subset of ringof<X,Y>::T More...
 
struct  ringof_
 
struct  ringof_< double, int >
 
struct  ringof_< int, double >
 
struct  ringof_< int, unsigned int >
 
struct  ringof_< unsigned int, int >
 
struct  scalar_type
 
struct  sfirstnn
 
struct  sfirstnnl
 select the first non null type of a type-list. More...
 
struct  sfirstnnl< tlist< car, cdr > >
 
struct  sfirstnnl< tlist< null_t, cdr > >
 
struct  sfirstnnl< tlist< null_t, null_t > >
 
struct  structureof
 
struct  structureof_
 
struct  Sup
 
struct  sup
 
struct  sup_
 
struct  sup_container
 
struct  template_expression
 
struct  template_expression< binary_operator<O, A, B > >
 
struct  template_expression< unary_operator<O, A > >
 
struct  template_expression_operand
 
struct  template_expression_operand< int >
 
struct  tlist
 type list node More...
 
struct  tmap
 
struct  tmap< TypeFunctor, tlist< Head, null_t > >
 
struct  tmap< TypeFunctor, tlist< Head, Tail > >
 
struct  tnot
 
struct  tnot< false_t >
 
struct  tnot< null_t >
 
struct  true_t
 structure defining a positive answer More...
 
struct  tselect
 select a type based on condition X, X is assumed to be in { null_t, false_t, true_t } More...
 
struct  tselect< false_t, A, B >
 
struct  tselect< null_t, A, B >
 
struct  TYPE
 
struct  ucst
 return T = Y from X = Y or X = const Y More...
 
struct  ucst< const X >
 
struct  ucstref
 return T = Y from X = const Y, Y, Y &, const Y & More...
 
struct  unary_operator
 
struct  unary_operator_prototype
 
struct  uptr
 return T = Y from X = Y or X = Y * More...
 
struct  uptr< X * >
 
struct  uref
 return T = Y from X = Y or X = Y & More...
 
struct  uref< X & >
 
struct  value_type
 
struct  value_type_
 
struct  value_type_< C * >
 
struct  value_type_< C[N] >
 
struct  value_type_< const C * >
 
struct  value_type_< R< X > >
 
struct  ValueType
 
struct  ValueType< A * >
 
struct  ValueType< A[n] >
 
struct  vselect
 select a type base on condition V, V is assumed to be in { 0, 1 } More...
 
struct  vselect< 0, A, B >
 

Functions

template<class X >
const char * name ()
 
template<class X >
std::ostream & print (std::ostream &o)
 
template<class X >
std::ostream & operator<< (std::ostream &o, const TYPE< X > &t)
 
void add (double &a, double b, double c)
 
void sub (double &a, double b, double c)
 
void mul (double &a, double b, double c)
 
void div (double &a, double b, double c)
 
template<class A >
std::ostream & operator<< (std::ostream &o, const template_expression< A > &e)
 
template<class O , class A >
std::ostream & operator<< (std::ostream &o, const template_expression< unary_operator<O, A > > &a)
 
template<class O , class A , class B >
std::ostream & operator<< (std::ostream &o, const template_expression< binary_operator<O, A, B > > &a)
 
 simple_trait (hasgcd, false_t)
 
 simple_trait (hassqrt, false_t)
 
 simple_trait (hasisqrt, false_t)
 
 define_binary_operator (_add_, operator+, add)
 
 define_binary_operator (_sub_, operator-, sub)
 
 define_binary_operator (_mul_, operator*, mul)
 
 define_binary_operator (_div_, operator/, div)
 
 define_binary_operator (_pow_, operator^, pow)
 
 define_binary_operator (_mod_, operator%, mod)
 
 define_unary_operator (_neg_, operator-, neg)
 
template<class op , class X , class Y >
std::ostream & operator<< (std::ostream &o, const binary_operator_prototype< op, X, Y > &b)
 

Function Documentation

void mmx::texp::add ( double &  a,
double  b,
double  c 
)
inline
mmx::texp::define_binary_operator ( _add_  ,
operator+  ,
add   
)
mmx::texp::define_binary_operator ( _sub_  ,
operator-  ,
sub   
)
mmx::texp::define_binary_operator ( _mul_  ,
operator*  ,
mul   
)
mmx::texp::define_binary_operator ( _div_  ,
operator/  ,
div   
)
mmx::texp::define_binary_operator ( _pow_  ,
operator^  ,
pow   
)
mmx::texp::define_binary_operator ( _mod_  ,
operator%  ,
mod   
)
mmx::texp::define_unary_operator ( _neg_  ,
operator-  ,
neg   
)
void mmx::texp::div ( double &  a,
double  b,
double  c 
)
inline
void mmx::texp::mul ( double &  a,
double  b,
double  c 
)
inline
template<class X >
const char* mmx::texp::name ( )
inline
template<class X >
std::ostream& mmx::texp::operator<< ( std::ostream &  o,
const TYPE< X > &  t 
)
inline
template<class op , class X , class Y >
std::ostream& mmx::texp::operator<< ( std::ostream &  o,
const binary_operator_prototype< op, X, Y > &  b 
)
template<class A >
std::ostream& mmx::texp::operator<< ( std::ostream &  o,
const template_expression< A > &  e 
)
inline
template<class O , class A >
std::ostream& mmx::texp::operator<< ( std::ostream &  o,
const template_expression< unary_operator<O, A > > &  a 
)
inline
template<class O , class A , class B >
std::ostream& mmx::texp::operator<< ( std::ostream &  o,
const template_expression< binary_operator<O, A, B > > &  a 
)
inline
template<class X >
std::ostream& mmx::texp::print ( std::ostream &  o)
inline
mmx::texp::simple_trait ( hasgcd  ,
false_t   
)
mmx::texp::simple_trait ( hassqrt  ,
false_t   
)
mmx::texp::simple_trait ( hasisqrt  ,
false_t   
)
void mmx::texp::sub ( double &  a,
double  b,
double  c 
)
inline
Home