include/basix/type_props.hpp File Reference

#include <basix/exception.hpp>

Go to the source code of this file.

Classes

Namespaces

Defines

Enumerations

Functions


Detailed Description

Definition in file type_props.hpp.


Define Documentation

#define Abs_type (  )     typename unary_return_type_helper<abs_op,C >::RET

Definition at line 78 of file type_props.hpp.

#define Accuracy (  )     accuracy_cst<C>()

Definition at line 973 of file type_props.hpp.

Referenced by accuracy_as_op::op().

#define As_matrix_type (  )     typename as_matrix_type_helper<C >::val

Definition at line 175 of file type_props.hpp.

#define As_vector_type (  )     typename as_vector_type_helper<C >::val

Definition at line 174 of file type_props.hpp.

Referenced by solve_vector_lde_op::diff_op().

#define Binary_return_type ( Op,
C1,
C2   )     typename binary_return_type_helper<Op,C1,C2>::RET

Definition at line 58 of file type_props.hpp.

Referenced by mmx::binary_map(), and mmx::binary_map_scalar().

#define BINARY_RETURN_TYPE ( TMPL,
op,
C1,
C2,
Ret   ) 
Value:
TMPL                                            \
 struct binary_return_type_helper<op,C1,C2 > {  \
  typedef Ret RET;                              \
};

Definition at line 44 of file type_props.hpp.

#define Catalan (  )     catalan_cst<C>()

Definition at line 967 of file type_props.hpp.

Referenced by catalan_as_op::op().

#define Center_type (  )     typename unary_return_type_helper<center_op,C >::RET

Definition at line 82 of file type_props.hpp.

#define Coefficient1_type (  )     typename coefficient1_type_helper<C >::val

Definition at line 168 of file type_props.hpp.

#define Coefficient2_type (  )     typename coefficient2_type_helper<C >::val

Definition at line 169 of file type_props.hpp.

#define Coefficient3_type (  )     typename coefficient3_type_helper<C >::val

Definition at line 170 of file type_props.hpp.

#define Complete_type (  )     typename unary_return_type_helper<complete_op,C >::RET

Definition at line 96 of file type_props.hpp.

#define Complex_type (  )     typename binary_return_type_helper<gaussian_op,C,C >::RET

Definition at line 80 of file type_props.hpp.

#define Default (  )     default_cst<C>()

Definition at line 963 of file type_props.hpp.

Referenced by default_as_op::op().

#define Default_radius_type (  )     typename default_radius_type_helper<C >::val

Definition at line 173 of file type_props.hpp.

#define DEFINE_BINARY_FORMAT_2 (  ) 
Value:
template<typename T1, typename T2> struct format<C<T1,T2> >:    \
  public binary_format_helper<typename format<T1>::FT,          \
                              typename format<T2>::FT>::FT      \
{                                                               \
  typedef typename format<T1 >::FT FT1;                         \
  typedef typename format<T2 >::FT FT2;                         \
  typedef typename binary_format_helper<FT1,FT2>::FT FT;        \
  inline format (): FT () {}                                    \
  template<typename T> inline format (const T& x): FT (x) {}    \
  inline format (const no_format& nfm): FT (nfm) {}             \
  inline format (const FT& x): FT (x) {}                        \
  inline format (const format<T1>& fm1, const format<T2>& fm2): \
    FT ((FT1) fm1, (FT2) fm2) {}                                \
  inline format (const format<C<T1,T2> >& fm): FT (fm.rfm()) {} \
  inline format<C<T1,T2> > tfm () const { return *this; }       \
  inline C<T1,T2> sample () const {                             \
    return C<T1,T2> (format<T1> (this->format1 ()),             \
                     format<T2> (this->format2 ())); }          \
};                                                              \
template<typename T1, typename T2>                              \
struct coefficient1_type_helper<C<T1,T2> > {                    \
  typedef T1 val;                                               \
};                                                              \
template<typename T1, typename T2>                              \
struct coefficient2_type_helper<C<T1,T2> > {                    \
  typedef T2 val;                                               \
};

Definition at line 414 of file type_props.hpp.

#define DEFINE_BINARY_FORMAT_3 (  ) 
Value:
template<typename T1, typename T2, typename X3>                         \
  struct format<C<T1,T2,X3> >:                                          \
  public binary_format_helper<typename format<T1>::FT,                  \
                              typename format<T2>::FT>::FT              \
{                                                                       \
  typedef typename format<T1 >::FT FT1;                                 \
  typedef typename format<T2 >::FT FT2;                                 \
  typedef typename binary_format_helper<FT1,FT2>::FT FT;                \
  inline format (): FT () {}                                            \
  template<typename T> inline format (const T& x): FT (x) {}            \
  inline format (const no_format& nfm): FT (nfm) {}                     \
  inline format (const FT& x): FT (x) {}                                \
  inline format (const format<T1>& fm1, const format<T2>& fm2):         \
    FT ((FT1) fm1, (FT2) fm2) {}                                        \
  inline format (const format<C<T1,T2,X3> >& fm): FT (fm.rfm()) {}      \
  inline format<C<T1,T2,X3> > tfm () const { return *this; }            \
  inline C<T1,T2,X3> sample () const {                                  \
    return C<T1,T2,X3> (format<T1> (this->format1 ()),                  \
                        format<T2> (this->format2 ())); }               \
};                                                                      \
template<typename T1, typename T2, typename X3>                         \
struct coefficient1_type_helper<C<T1,T2,X3> > {                         \
  typedef T1 val;                                                       \
};                                                                      \
template<typename T1, typename T2, typename X3>                         \
struct coefficient2_type_helper<C<T1,T2,X3> > {                         \
  typedef T2 val;                                                       \
};

Definition at line 443 of file type_props.hpp.

#define DEFINE_TERNARY_FORMAT_3 (  ) 
Value:
template<typename T1, typename T2, typename T3>                 \
struct format<C<T1,T2,T3> >:                                    \
  public ternary_format_helper<typename format<T1>::FT,         \
                               typename format<T2>::FT,         \
                               typename format<T3>::FT>::FT     \
{                                                               \
  typedef typename format<T1 >::FT FT1;                         \
  typedef typename format<T2 >::FT FT2;                         \
  typedef typename format<T3 >::FT FT3;                         \
  typedef typename ternary_format_helper<FT1,FT2,FT3>::FT FT;   \
  inline format (): FT () {}                                    \
  template<typename T> inline format (const T& x): FT (x) {}    \
  inline format (const no_format& nfm): FT (nfm) {}             \
  inline format (const FT& x): FT (x) {}                        \
  inline format (const format<T1>& fm1,                         \
                 const format<T1>& fm2,                         \
                 const format<T2>& fm3):                        \
    FT ((FT1) fm1, (FT2) fm2, (FT3) fm3) {}                     \
  inline format (const format<C<T1,T2,T3> >& fm):               \
    FT (fm.rfm()) {}                                            \
  inline format<C<T1,T2,T3> > tfm () const { return *this; }    \
  inline C<T1,T2,T3> sample () const {                          \
    return C<T1,T2,T3> (format<T1> (this->format1 ()),          \
                        format<T2> (this->format2 ()),          \
                        format<T3> (this->format3 ())); }       \
};                                                              \
template<typename T1, typename T2, typename T3>                 \
struct coefficient1_type_helper<C<T1,T2,T3> > {                 \
  typedef T1 val;                                               \
};                                                              \
template<typename T1, typename T2, typename T3>                 \
struct coefficient2_type_helper<C<T1,T2,T3> > {                 \
  typedef T2 val;                                               \
};                                                              \
template<typename T1, typename T2, typename T3>                 \
struct coefficient3_type_helper<C<T1,T2,T3> > {                 \
  typedef T3 val;                                               \
};

Definition at line 503 of file type_props.hpp.

#define DEFINE_UNARY_FORMAT_1 (  ) 
Value:
template<typename T1> struct format<C<T1> >:                    \
  public unary_format_helper<typename format<T1>::FT>::FT       \
{                                                               \
  typedef typename format<T1>::FT FT1;                          \
  typedef typename unary_format_helper<FT1>::FT FT;             \
  inline format (): FT () {}                                    \
  template<typename T> inline format (const T& x): FT (x) {}    \
  inline format (const no_format& nfm): FT (nfm) {}             \
  inline format (const FT& x): FT (x) {}                        \
  inline format (const format<T1>& fm1): FT ((FT1) fm1) {}      \
  inline format (const format<C<T1> >& fm): FT (fm.rfm()) {}    \
  inline format<C<T1> > tfm () const { return *this; }          \
  inline C<T1> sample () const {                                \
    return C<T1> (format<T1> (this->format1 ())); }             \
};                                                              \
template<typename T1>                                           \
struct coefficient1_type_helper<C<T1> > {                       \
  typedef T1 val;                                               \
};

Definition at line 302 of file type_props.hpp.

#define DEFINE_UNARY_FORMAT_2 (  ) 
Value:
template<typename T1, typename X2> struct format<C<T1,X2> >:            \
  public unary_format_helper<typename format<T1>::FT>::FT               \
{                                                                       \
  typedef typename format<T1>::FT FT1;                                  \
  typedef typename unary_format_helper<FT1>::FT FT;                     \
  inline format (): FT () {}                                            \
  template<typename T> inline format (const T& x): FT (x) {}            \
  inline format (const no_format& nfm): FT (nfm) {}                     \
  inline format (const FT& x): FT (x) {}                                \
  inline format (const format<T1>& fm1): FT ((FT1) fm1) {}              \
  inline format (const format<C<T1,X2> >& fm): FT (fm.rfm()) {}         \
  inline format<C<T1,X2> > tfm () const { return *this; }               \
  inline C<T1,X2> sample () const {                                     \
    return C<T1,X2> (format<T1> (this->format1 ())); }                  \
};                                                                      \
template<typename T1, typename X2>                                      \
struct coefficient1_type_helper<C<T1,X2> > {                            \
  typedef T1 val;                                                       \
};

Definition at line 323 of file type_props.hpp.

#define DEFINE_UNARY_FORMAT_3 (  ) 
Value:
template<typename T1, typename X2, typename X3>                         \
  struct format<C<T1,X2,X3> >:                                          \
  public unary_format_helper<typename format<T1>::FT>::FT               \
{                                                                       \
  typedef typename format<T1>::FT FT1;                                  \
  typedef typename unary_format_helper<FT1>::FT FT;                     \
  inline format (): FT () {}                                            \
  template<typename T> inline format (const T& x): FT (x) {}            \
  inline format (const no_format& nfm): FT (nfm) {}                     \
  inline format (const FT& x): FT (x) {}                                \
  inline format (const format<T1>& fm1): FT ((FT1) fm1) {}              \
  inline format (const format<C<T1,X2,X3> >& fm): FT (fm.rfm()) {}      \
  inline format<C<T1,X2,X3> > tfm () const { return *this; }            \
  inline C<T1,X2,X3> sample () const {                                  \
    return C<T1,X2,X3> (format<T1> (this->format1 ())); }               \
};                                                                      \
template<typename T1, typename X2, typename X3>                         \
struct coefficient1_type_helper<C<T1,X2,X3> > {                         \
  typedef T1 val;                                                       \
};

Definition at line 344 of file type_props.hpp.

#define DEFINE_UNARY_FORMAT_3_bis (  ) 
Value:
template<typename X1, typename T2, typename X3>                         \
  struct format<C<X1,T2,X3> >:                                          \
  public unary_format_helper<typename format<T2>::FT>::FT               \
{                                                                       \
  typedef typename format<T2>::FT FT2;                                  \
  typedef typename unary_format_helper<FT2>::FT FT;                     \
  inline format (): FT () {}                                            \
  template<typename T> inline format (const T& x): FT (x) {}            \
  inline format (const no_format& nfm): FT (nfm) {}                     \
  inline format (const FT& x): FT (x) {}                                \
  inline format (const format<T2>& fm1): FT ((FT2) fm1) {}              \
  inline format (const format<C<X1,T2,X3> >& fm): FT (fm.rfm()) {}      \
  inline format<C<X1,T2,X3> > tfm () const { return *this; }            \
  inline C<X1,T2,X3> sample () const {                                  \
    return C<X1,T2,X3> (format<T2> (this->format1 ())); }               \
};                                                                      \
template<typename X1, typename T2, typename X3>                         \
struct coefficient1_type_helper<C<X1,T2,X3> > {                         \
  typedef T2 val;                                                       \
};

Definition at line 366 of file type_props.hpp.

#define Denominator_type (  )     typename unary_return_type_helper<denominator_op,C >::RET

Definition at line 86 of file type_props.hpp.

#define Euler (  )     euler_cst<C>()

Definition at line 966 of file type_props.hpp.

Referenced by euler_as_op::op().

#define Evaluate_type ( C,
 )     typename binary_return_type_helper<evaluate_op,C,D>::RET

Definition at line 98 of file type_props.hpp.

#define Fast_type (  )     typename fast_helper<T>::fast_type

Definition at line 779 of file type_props.hpp.

#define Fuzz (  )     fuzz_cst<C>()

Definition at line 970 of file type_props.hpp.

Referenced by fuzz_as_op::op().

#define Imaginary (  )     imaginary_cst<C>()

Definition at line 968 of file type_props.hpp.

Referenced by mmx::gaussian(), imaginary_as_op::op(), and mmx::polar().

#define Infinity (  )     infinity_cst<C>()

Definition at line 974 of file type_props.hpp.

Referenced by infinity_as_op::op().

#define Largest (  )     largest_cst<C>()

Definition at line 972 of file type_props.hpp.

Referenced by largest_as_op::op().

#define Lift_type (  )     typename unary_return_type_helper<lift_op,C >::RET

Definition at line 88 of file type_props.hpp.

#define Log2 (  )     log2_cst<C>()

Definition at line 965 of file type_props.hpp.

Referenced by log2_as_op::op().

#define Maximal (  )     maximal_cst<C>()
#define Minimal (  )     minimal_cst<C>()
#define Monomial_type (  )     typename monomial_type_helper<C >::val

Definition at line 172 of file type_props.hpp.

#define Nan (  )     nan_cst<C>()

Definition at line 969 of file type_props.hpp.

Referenced by nan_as_op::op().

#define Numerator_type (  )     typename unary_return_type_helper<numerator_op,C >::RET

Definition at line 84 of file type_props.hpp.

#define Pi (  )     pi_cst<C>()

Definition at line 964 of file type_props.hpp.

Referenced by pi_as_op::op().

#define Project_type (  )     typename unary_return_type_helper<project_op,C >::RET

Definition at line 90 of file type_props.hpp.

#define Projective (  )     projective_helper<C>::val

Definition at line 1124 of file type_props.hpp.

#define Radius_type (  )     typename unary_return_type_helper<radius_op,C >::RET

Definition at line 83 of file type_props.hpp.

#define Real_type (  )     typename unary_return_type_helper<Re_op,C >::RET

Definition at line 79 of file type_props.hpp.

#define Reconstruct_type (  )     typename unary_return_type_helper<reconstruct_op,C >::RET

Definition at line 92 of file type_props.hpp.

#define Round_down (  )     typename rounding_helper<C>::DV

Definition at line 1065 of file type_props.hpp.

#define Round_up (  )     typename rounding_helper<C>::UV

Definition at line 1064 of file type_props.hpp.

#define Scalar_type (  )     typename scalar_type_helper<C >::val
#define Smallest (  )     smallest_cst<C>()

Definition at line 971 of file type_props.hpp.

Referenced by smallest_as_op::op().

#define STYPE_TO_TYPE ( TMPL,
name,
C,
expr   ) 
Value:
TMPL                                            \
struct name##_helper<C > {                      \
  typedef expr val;                             \
};

Definition at line 146 of file type_props.hpp.

#define Ternary_return_type ( Op,
C1,
C2,
C3   )     typename ternary_return_type_helper<Op,C1,C2,C3>::RET

Definition at line 60 of file type_props.hpp.

#define TERNARY_RETURN_TYPE ( TMPL,
op,
C1,
C2,
C3,
Ret   ) 
Value:
TMPL                                                \
 struct ternary_return_type_helper<op,C1,C2,C3 > {  \
  typedef Ret RET;                                  \
};

Definition at line 50 of file type_props.hpp.

#define Truncate_type (  )     typename binary_return_type_helper<truncate_op,C,nat>::RET

Definition at line 94 of file type_props.hpp.

#define TYPE_TO_TYPE ( name,
expr   ) 
Value:
template<typename C>                            \
struct name##_helper {                          \
  typedef expr val;                             \
};

Definition at line 140 of file type_props.hpp.

#define Unary_return_type ( Op,
 )     typename unary_return_type_helper<Op,C>::RET
#define UNARY_RETURN_TYPE ( TMPL,
op,
C,
Ret   ) 
Value:
TMPL                                            \
struct unary_return_type_helper<op,C > {        \
  typedef Ret RET;                              \
};

Definition at line 38 of file type_props.hpp.


Generated on 6 Dec 2012 for basix by  doxygen 1.6.1