/Users/mourrain/Devel/mmx/basix/include/basix/category_meta.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : category_meta.hpp
* DESCRIPTION: Abstract categorical meta-properties of types
* COPYRIGHT  : (C) 2006  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#ifndef __CATEGORY_META_HPP
#define __CATEGORY_META_HPP
#include <basix/operators.hpp>


namespace mmx {

/******************************************************************************
* Boolean structure
******************************************************************************/

template<bool val>
struct boolean_helper {
  static const bool value;
};

template<bool val> const bool
boolean_helper<val>::value= val;

struct always {
  typedef boolean_helper<true> Cond;
  static inline bool value () { return Cond::value; }
  static inline generic lazy_value () {
    return as<generic> (true); }
};

struct never {
  typedef boolean_helper<false> Cond;
  static inline bool value () { return Cond::value; }
  static inline generic lazy_value () {
    return as<generic> (false); }
};

/******************************************************************************
* And
******************************************************************************/

template<typename T1, typename T2>
struct both_helper {
  static const bool value;
};

template<typename T1, typename T2> const bool
both_helper<T1,T2>::value= T1::value && T2::value;

template<typename T1, typename T2>
struct both {
  typedef both_helper<typename T1::Cond, typename T2::Cond> Cond;
  static inline bool value () { return Cond::value; }
  static inline generic lazy_value () {
    return gen (GEN_AND, T1::lazy_value (), T2::lazy_value ()); }
};

/******************************************************************************
* Different types
******************************************************************************/

template<typename T1, typename T2>
struct different_helper {
  static const bool value;
};

template<typename T1, typename T2> const bool
different_helper<T1,T2>::value= true;

template<typename T1>
struct different_helper<T1,T1> {
  static const bool value;
};

template<typename T1> const bool
different_helper<T1,T1>::value= false;

template<typename T1, typename T2>
struct different {
  typedef different_helper<T1,T2> Cond;
  static inline bool value () { return Cond::value; }
  static inline generic lazy_value () { return as_generic (Cond::value); }
};

/******************************************************************************
* Basic macros for defining structure
******************************************************************************/

template<typename T, typename Op>
struct has {
  typedef boolean_helper<false> Cond;
  static inline generic lazy_value () {
    return gen (GEN_HAS, T::name(), Op::name()); }
};

template<typename Op>
struct has<generic,Op> {
  typedef boolean_helper<true> Cond;
  static inline bool value () { return Cond::value; }
  static inline generic lazy_value () {
    return as<generic> (true); }
};

#define HAS(Op)                                 \
META_TMPL                                       \
struct has<META_TYPE,Op > {                     \
  typedef META_COND Type;                       \
  typedef META_TPNM Type::Cond Cond;            \
  static inline generic lazy_value () {         \
    return META_COND::lazy_value (); }          \
};

/******************************************************************************
* Basic arithmetic categories
******************************************************************************/

struct ring_cat {
  static generic name () { return "Ring"; }
};

#define HAS_RING()                              \
HAS(neg_op)                                     \
HAS(add_op)                                     \
HAS(sub_op)                                     \
HAS(mul_op)                                     \
HAS(square_op)                                  \
HAS(ring_cat)

struct euclidean_ring_cat {
  static generic name () { return "Euclidean_ring"; }
};

#define HAS_EUCLIDEAN_RING_ABOVE_RING()         \
HAS(quo_op)                                     \
HAS(rem_op)                                     \
HAS(euclidean_ring_cat)

#define HAS_EUCLIDEAN_RING()                    \
HAS_RING()                                      \
HAS_EUCLIDEAN_RING_ABOVE_RING()

struct field_cat {
  static generic name () { return "Field"; }
};

#define HAS_FIELD_ABOVE_EUCLIDEAN_RING()        \
HAS(div_op)                                     \
HAS(field_cat)

#define HAS_FIELD_ABOVE_RING()                  \
HAS_EUCLIDEAN_RING_ABOVE_RING()                 \
HAS_FIELD_ABOVE_EUCLIDEAN_RING()

#define HAS_FIELD()                             \
HAS_EUCLIDEAN_RING()                            \
HAS_FIELD_ABOVE_EUCLIDEAN_RING()

/******************************************************************************
* Factorial ring structure
******************************************************************************/

struct factorial_cat {
  static generic name () { return "Factorial"; }
};

#define HAS_FACTORIAL()                         \
HAS(gcd_op)                                     \
HAS(lcm_op)

/******************************************************************************
* Elementary functions
******************************************************************************/

struct elementary_cat {
  static generic name () { return "Elementary"; }
};

#define HAS_ELEMENTARY()                        \
HAS(sqrt_op)                                    \
HAS(pow_op)                                     \
HAS(exp_op)                                     \
HAS(log_op)                                     \
HAS(cos_op)                                     \
HAS(sin_op)                                     \
HAS(tan_op)                                     \
HAS(acos_op)                                    \
HAS(asin_op)                                    \
HAS(atan_op)                                    \
HAS(elementary_cat)

/******************************************************************************
* Ordered structures
******************************************************************************/

struct ordering_cat {
  static generic name () { return "Ordering"; }
};

#define HAS_ORDERING()                          \
HAS(less_op)                                    \
HAS(lesseq_op)                                  \
HAS(gtr_op)                                     \
HAS(gtreq_op)                                   \
HAS(ordering_cat)
 
/******************************************************************************
* Complex structure
******************************************************************************/

struct complex_cat {
  static generic name () { return "Complex"; }
};

#define HAS_COMPLEX()                           \
HAS(gaussian_op)                                \
HAS(Re_op)                                      \
HAS(Im_op)                                      \
HAS(abs_op)                                     \
HAS(arg_op)                                     \
HAS(conj_op)                                    \
HAS(complex_cat)
 
/******************************************************************************
* Ball structure
******************************************************************************/

struct ball_cat {
  static generic name () { return "Ball"; }
};

#define HAS_BALL()                              \
HAS(ball_op)                                    \
HAS(center_op)                                  \
HAS(radius_op)                                  \
HAS(ball_cat)

} // namespace mmx
#endif // __CATEGORY_META_HPP