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

Go to the documentation of this file.

/******************************************************************************
* MODULE     : function.hpp
* DESCRIPTION: Function classes for any arity
* COPYRIGHT  : (C) 2007  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 __MMX_FUNCTION_HPP
#define __MMX_FUNCTION_HPP
#include <basix/operators.hpp>

namespace mmx {

template<typename T> inline syntactic flatten_type () {
  return as_syntactic (type_name (type_information<T>::id)); }

/******************************************************************************
* Add const& to function arguments
******************************************************************************/

template<typename T>
struct argument_helper {
  typedef const T& arg_type;
};

template<typename T>
struct argument_helper<T&> {
  typedef T& arg_type;
};

template<typename T>
struct argument_helper<T*> {
  typedef T* arg_type;
};

template<typename T>
struct argument_helper<const T&> {
  typedef const T& arg_type;
};

template<typename T>
struct argument_helper<const T*> {
  typedef const T* arg_type;
};

#ifdef OPTIMIZED_ARGUMENTS
#define Argument(T) typename argument_helper<T>::arg_type
#else
#define Argument(T) T
#endif

/******************************************************************************
* Nullary functions
******************************************************************************/

template<typename D>
struct function_0_rep REP_STRUCT {
  inline function_0_rep () {}
  virtual ~function_0_rep () {}
  virtual D apply () = 0;
};

template<typename D>
struct def_function_0_rep: public function_0_rep<D> {
  D (*fun) ();
  inline def_function_0_rep (D (*fun2) ()): fun (fun2) {}
  D apply () { return fun (); }
};

template<typename D>
struct function_0 {
  function_0_rep<D>* rep;
  inline function_0 (): rep (NULL) {}
  inline function_0 (function_0_rep<D>* rep2): rep (rep2) {}
  inline function_0 (const function_0& f):
    rep (f.rep) { INC_NULL_COUNT(rep); }
  inline function_0 (D (*fun) ()):
    rep (new def_function_0_rep<D> (fun)) {}
  inline ~function_0 () { DEC_NULL_COUNT (rep); }
  inline function_0& operator = (const function_0& f) {
    INC_NULL_COUNT (f.rep); DEC_NULL_COUNT (rep);
    rep= f.rep; return *this; }
  inline D operator () () const { return rep->apply (); }
};

#define TMPL template<typename D>
#define Function function_0<D>
TMPL inline syntactic flatten (const Function& f) {
  return apply ("function", flatten_type<D> ()); }
TMPL inline nat hard_hash (const Function& f) {
  return as_hash (f.rep); }
TMPL inline bool hard_eq (const Function& f, const Function& g) {
  return (f.rep) == (g.rep); }
TMPL inline bool hard_neq (const Function& f, const Function& g) {
  return (f.rep) != (g.rep); }
HARD_TO_EXACT_IDENTITY_SUGAR(TMPL,Function)
HARD_TO_TRUE_IDENTITY_SUGAR(TMPL,Function)
#undef Function
#undef TMPL

/******************************************************************************
* Unary functions
******************************************************************************/

template<typename D, typename S1>
struct function_1_rep REP_STRUCT {
  inline function_1_rep () {}
  virtual ~function_1_rep () {}
  virtual D apply (S1 x1) = 0;
};

template<typename D, typename S1>
struct def_function_1_rep: public function_1_rep<D,S1> {
  D (*fun) (S1);
  inline def_function_1_rep (D (*fun2) (S1)): fun (fun2) {}
  D apply (S1 x1) { return fun (x1); }
};

template<typename D, typename S1>
struct function_1 {
  function_1_rep<D,S1>* rep;
  inline function_1 (): rep (NULL) {}
  inline function_1 (function_1_rep<D,S1>* rep2): rep (rep2) {}
  inline function_1 (const function_1& f):
    rep (f.rep) { INC_NULL_COUNT(rep); }
  inline function_1 (D (*fun) (S1)):
    rep (new def_function_1_rep<D,S1> (fun)) {}
  inline ~function_1 () { DEC_NULL_COUNT (rep); }
  inline function_1& operator = (const function_1& f) {
    INC_NULL_COUNT (f.rep); DEC_NULL_COUNT (rep);
    rep= f.rep; return *this; }
  inline D operator () (S1 x1) const { return rep->apply (x1); }
};

#define TMPL template<typename D, typename S1>
#define Function function_1<D,S1>
TMPL inline syntactic flatten (const Function& f) {
  return apply ("function", flatten_type<S1> (), flatten_type<D> ()); }
TMPL inline nat hard_hash (const Function& f) {
  return as_hash (f.rep); }
TMPL inline bool hard_eq (const Function& f, const Function& g) {
  return (f.rep) == (g.rep); }
TMPL inline bool hard_neq (const Function& f, const Function& g) {
  return (f.rep) != (g.rep); }
HARD_TO_EXACT_IDENTITY_SUGAR(TMPL,Function)
HARD_TO_TRUE_IDENTITY_SUGAR(TMPL,Function)
#undef Function
#undef TMPL

template<typename FT, typename R, typename C, typename Fun>
struct format_function_helper {
  static inline format<R>
  op (const Fun& fun, const format<C>& fm) {
    return get_format (fun (get_sample (fm))); }
};

template<typename FT, typename C, typename Fun>
struct format_function_helper<FT,C,C,Fun> {
  static inline format<C>
  op (const Fun&, const format<C>& fm) {
    return fm; }
};

template<typename R, typename C, typename Fun>
struct format_function_helper<empty_format,R,C,Fun> {
  static inline format<R>
  op (const Fun& fun, const format<C>&) {
    return format<R> (); }
};

template<typename C, typename Fun>
struct format_function_helper<empty_format,C,C,Fun> {
  static inline format<C>
  op (const Fun&, const format<C>& fm) {
    return fm; }
};

template<typename C, typename R> format<R>
map (const function_1<R,Argument(C) >& fun, const format<C>& fm) {
  typedef function_1<R,Argument(C) > Fun;
  typedef typename format<R>::FT FT;
  return format_function_helper<FT,R,C,Fun>::op (fun, fm);
}

template<typename C, typename R> format<R>
map (R (*fun) (const C&), const format<C>& fm) {
  typedef R (*Fun) (const C&);
  typedef typename format<R>::FT FT;
  return format_function_helper<FT,R,C,Fun>::op (fun, fm);
}

/******************************************************************************
* Binary functions
******************************************************************************/

template<typename D, typename S1, typename S2>
struct function_2_rep REP_STRUCT {
  inline function_2_rep () {}
  virtual ~function_2_rep () {}
  virtual D apply (S1 x1, S2 x2) = 0;
};

template<typename D, typename S1, typename S2>
struct def_function_2_rep: public function_2_rep<D,S1,S2> {
  D (*fun) (S1, S2);
  inline def_function_2_rep (D (*fun2) (S1, S2)): fun (fun2) {}
  D apply (S1 x1, S2 x2) { return fun (x1, x2); }
};

template<typename D, typename S1, typename S2>
struct function_2 {
  function_2_rep<D,S1,S2>* rep;
  inline function_2 (): rep (NULL) {}
  inline function_2 (function_2_rep<D,S1,S2>* rep2): rep (rep2) {}
  inline function_2 (const function_2& f):
    rep (f.rep) { INC_NULL_COUNT(rep); }
  inline function_2 (D (*fun) (S1, S2)):
    rep (new def_function_2_rep<D,S1,S2> (fun)) {}
  inline ~function_2 () { DEC_NULL_COUNT (rep); }
  inline function_2& operator = (const function_2& f) {
    INC_NULL_COUNT (f.rep); DEC_NULL_COUNT (rep);
    rep= f.rep; return *this; }
  inline D operator () (S1 x1, S2 x2) const {
    return rep->apply (x1, x2); }
};

#define TMPL template<typename D, typename S1, typename S2>
#define Function function_2<D,S1,S2>
TMPL inline syntactic flatten (const Function& f) {
  return apply ("function",
                flatten_type<S1> (), flatten_type<S2> (), flatten_type<D> ()); }
TMPL inline nat hard_hash (const Function& f) {
  return as_hash (f.rep); }
TMPL inline bool hard_eq (const Function& f, const Function& g) {
  return (f.rep) == (g.rep); }
TMPL inline bool hard_neq (const Function& f, const Function& g) {
  return (f.rep) != (g.rep); }
HARD_TO_EXACT_IDENTITY_SUGAR(TMPL,Function)
HARD_TO_TRUE_IDENTITY_SUGAR(TMPL,Function)
#undef Function
#undef TMPL

/******************************************************************************
* Ternary functions
******************************************************************************/

template<typename D, typename S1, typename S2, typename S3>
struct function_3_rep REP_STRUCT {
  inline function_3_rep () {}
  virtual ~function_3_rep () {}
  virtual D apply (S1 x1, S2 x2, S3 x3) = 0;
};

template<typename D, typename S1, typename S2, typename S3>
struct def_function_3_rep: public function_3_rep<D,S1,S2,S3> {
  D (*fun) (S1, S2, S3);
  inline def_function_3_rep (D (*fun2) (S1, S2, S3)):
    fun (fun2) {}
  D apply (S1 x1, S2 x2, S3 x3) { 
    return fun (x1, x2, x3); }
};

template<typename D, typename S1, typename S2, typename S3>
struct function_3 {
  function_3_rep<D,S1,S2,S3>* rep;
  inline function_3 (): rep (NULL) {}
  inline function_3 (function_3_rep<D,S1,S2,S3>* rep2): rep (rep2) {}
  inline function_3 (const function_3& f):
    rep (f.rep) { INC_NULL_COUNT(rep); }
  inline function_3 (D (*fun) (S1, S2, S3)):
    rep (new def_function_3_rep<D,S1,S2,S3> (fun)) {}
  inline ~function_3 () { DEC_NULL_COUNT (rep); }
  inline function_3& operator = (const function_3& f) {
    INC_NULL_COUNT (f.rep); DEC_NULL_COUNT (rep);
    rep= f.rep; return *this; }
  inline D operator () (S1 x1, S2 x2, S3 x3) const {
    return rep->apply (x1, x2, x3); }
};

#define TMPL template<typename D, typename S1, typename S2, typename S3>
#define Function function_3<D,S1,S2,S3>
TMPL inline syntactic flatten (const Function& f) {
  return "function"; }
TMPL inline nat hard_hash (const Function& f) {
  return as_hash (f.rep); }
TMPL inline bool hard_eq (const Function& f, const Function& g) {
  return (f.rep) == (g.rep); }
TMPL inline bool hard_neq (const Function& f, const Function& g) {
  return (f.rep) != (g.rep); }
HARD_TO_EXACT_IDENTITY_SUGAR(TMPL,Function)
HARD_TO_TRUE_IDENTITY_SUGAR(TMPL,Function)
#undef Function
#undef TMPL

/******************************************************************************
* Tetragonal functions
******************************************************************************/

template<typename D, typename S1, typename S2, typename S3, typename S4>
struct function_4_rep REP_STRUCT {
  inline function_4_rep () {}
  virtual ~function_4_rep () {}
  virtual D apply (S1 x1, S2 x2, S3 x3, S4 x4) = 0;
};

template<typename D, typename S1, typename S2, typename S3, typename S4>
struct def_function_4_rep: public function_4_rep<D,S1,S2,S3,S4> {
  D (*fun) (S1, S2, S3, S4);
  inline def_function_4_rep (D (*fun2) (S1, S2, S3, S4)):
    fun (fun2) {}
  D apply (S1 x1, S2 x2, S3 x3, S4 x4) { 
    return fun (x1, x2, x3, x4); }
};

template<typename D, typename S1, typename S2, typename S3, typename S4>
struct function_4 {
  function_4_rep<D,S1,S2,S3,S4>* rep;
  inline function_4 (): rep (NULL) {}
  inline function_4 (function_4_rep<D,S1,S2,S3,S4>* rep2): rep (rep2) {}
  inline function_4 (const function_4& f):
    rep (f.rep) { INC_NULL_COUNT(rep); }
  inline function_4 (D (*fun) (S1, S2, S3, S4)):
    rep (new def_function_4_rep<D,S1,S2,S3,S4> (fun)) {}
  inline ~function_4 () { DEC_NULL_COUNT (rep); }
  inline function_4& operator = (const function_4& f) {
    INC_NULL_COUNT (f.rep); DEC_NULL_COUNT (rep);
    rep= f.rep; return *this; }
  inline D operator () (S1 x1, S2 x2, S3 x3, S4 x4) const {
    return rep->apply (x1, x2, x3, x4); }
};

#define TMPL template<typename D, typename S1, typename S2, typename S3, typename S4>
#define Function function_4<D,S1,S2,S3,S4>
TMPL inline syntactic flatten (const Function& f) {
  return "function"; }
TMPL inline nat hard_hash (const Function& f) {
  return as_hash (f.rep); }
TMPL inline bool hard_eq (const Function& f, const Function& g) {
  return (f.rep) == (g.rep); }
TMPL inline bool hard_neq (const Function& f, const Function& g) {
  return (f.rep) != (g.rep); }
HARD_TO_EXACT_IDENTITY_SUGAR(TMPL,Function)
HARD_TO_TRUE_IDENTITY_SUGAR(TMPL,Function)
#undef Function
#undef TMPL

/******************************************************************************
* Pentagonal functions
******************************************************************************/

template<typename D, typename S1, typename S2, typename S3, typename S4, typename S5>
struct function_5_rep REP_STRUCT {
  inline function_5_rep () {}
  virtual ~function_5_rep () {}
  virtual D apply (S1 x1, S2 x2, S3 x3, S4 x4, S5 x5) = 0;
};

template<typename D, typename S1, typename S2, typename S3, typename S4, typename S5>
struct def_function_5_rep: public function_5_rep<D,S1,S2,S3,S4,S5> {
  D (*fun) (S1, S2, S3, S4, S5);
  inline def_function_5_rep (D (*fun2) (S1, S2, S3, S4, S5)):
    fun (fun2) {}
  D apply (S1 x1, S2 x2, S3 x3, S4 x4, S5 x5) { 
    return fun (x1, x2, x3, x4, x5); }
};

template<typename D, typename S1, typename S2, typename S3, typename S4, typename S5>
struct function_5 {
  function_5_rep<D,S1,S2,S3,S4,S5>* rep;
  inline function_5 (): rep (NULL) {}
  inline function_5 (function_5_rep<D,S1,S2,S3,S4,S5>* rep2): rep (rep2) {}
  inline function_5 (const function_5& f):
    rep (f.rep) { INC_NULL_COUNT(rep); }
  inline function_5 (D (*fun) (S1, S2, S3, S4, S5)):
    rep (new def_function_5_rep<D,S1,S2,S3,S4,S5> (fun)) {}
  inline ~function_5 () { DEC_NULL_COUNT (rep); }
  inline function_5& operator = (const function_5& f) {
    INC_NULL_COUNT (f.rep); DEC_NULL_COUNT (rep);
    rep= f.rep; return *this; }
  inline D operator () (S1 x1, S2 x2, S3 x3, S4 x4, S5 x5) const {
    return rep->apply (x1, x2, x3, x4, x5); }
};

#define TMPL template<typename D, typename S1, typename S2, typename S3, typename S4, typename S5>
#define Function function_5<D,S1,S2,S3,S4,S5>
TMPL inline syntactic flatten (const Function& f) {
  return "function"; }
TMPL inline nat hard_hash (const Function& f) {
  return as_hash (f.rep); }
TMPL inline bool hard_eq (const Function& f, const Function& g) {
  return (f.rep) == (g.rep); }
TMPL inline bool hard_neq (const Function& f, const Function& g) {
  return (f.rep) != (g.rep); }
HARD_TO_EXACT_IDENTITY_SUGAR(TMPL,Function)
HARD_TO_TRUE_IDENTITY_SUGAR(TMPL,Function)
#undef Function
#undef TMPL

/******************************************************************************
* Hexagonal functions
******************************************************************************/

template<typename D, typename S1, typename S2, typename S3, typename S4, typename S5, typename S6>
struct function_6_rep REP_STRUCT {
  inline function_6_rep () {}
  virtual ~function_6_rep () {}
  virtual D apply (S1 x1, S2 x2, S3 x3, S4 x4, S5 x5, S6 x6) = 0;
};

template<typename D, typename S1, typename S2, typename S3, typename S4, typename S5, typename S6>
struct def_function_6_rep: public function_6_rep<D,S1,S2,S3,S4,S5,S6> {
  D (*fun) (S1, S2, S3, S4, S5, S6);
  inline def_function_6_rep (D (*fun2) (S1, S2, S3, S4, S5, S6)):
    fun (fun2) {}
  D apply (S1 x1, S2 x2, S3 x3, S4 x4, S5 x5, S6 x6) { 
    return fun (x1, x2, x3, x4, x5, x6); }
};

template<typename D, typename S1, typename S2, typename S3, typename S4, typename S5, typename S6>
struct function_6 {
  function_6_rep<D,S1,S2,S3,S4,S5,S6>* rep;
  inline function_6 (): rep (NULL) {}
  inline function_6 (function_6_rep<D,S1,S2,S3,S4,S5,S6>* rep2): rep (rep2) {}
  inline function_6 (const function_6& f):
    rep (f.rep) { INC_NULL_COUNT(rep); }
  inline function_6 (D (*fun) (S1, S2, S3, S4, S5, S6)):
    rep (new def_function_6_rep<D,S1,S2,S3,S4,S5,S6> (fun)) {}
  inline ~function_6 () { DEC_NULL_COUNT (rep); }
  inline function_6& operator = (const function_6& f) {
    INC_NULL_COUNT (f.rep); DEC_NULL_COUNT (rep);
    rep= f.rep; return *this; }
  inline D operator () (S1 x1, S2 x2, S3 x3, S4 x4, S5 x5, S6 x6) const {
    return rep->apply (x1, x2, x3, x4, x5, x6); }
};

#define TMPL template<typename D, typename S1, typename S2, typename S3, typename S4, typename S5, typename S6>
#define Function function_6<D,S1,S2,S3,S4,S5,S6>
TMPL inline syntactic flatten (const Function& f) {
  return "function"; }
TMPL inline nat hard_hash (const Function& f) {
  return as_hash (f.rep); }
TMPL inline bool hard_eq (const Function& f, const Function& g) {
  return (f.rep) == (g.rep); }
TMPL inline bool hard_neq (const Function& f, const Function& g) {
  return (f.rep) != (g.rep); }
HARD_TO_EXACT_IDENTITY_SUGAR(TMPL,Function)
HARD_TO_TRUE_IDENTITY_SUGAR(TMPL,Function)
#undef Function
#undef TMPL

/******************************************************************************
* Heptagonal functions
******************************************************************************/

template<typename D, typename S1, typename S2, typename S3, typename S4, typename S5, typename S6, typename S7>
struct function_7_rep REP_STRUCT {
  inline function_7_rep () {}
  virtual ~function_7_rep () {}
  virtual D apply (S1 x1, S2 x2, S3 x3, S4 x4, S5 x5, S6 x6, S7 x7) = 0;
};

template<typename D, typename S1, typename S2, typename S3, typename S4, typename S5, typename S6, typename S7>
struct def_function_7_rep: public function_7_rep<D,S1,S2,S3,S4,S5,S6,S7> {
  D (*fun) (S1, S2, S3, S4, S5, S6, S7);
  inline def_function_7_rep (D (*fun2) (S1, S2, S3, S4, S5, S6, S7)):
    fun (fun2) {}
  D apply (S1 x1, S2 x2, S3 x3, S4 x4, S5 x5, S6 x6, S7 x7) { 
    return fun (x1, x2, x3, x4, x5, x6, x7); }
};

template<typename D, typename S1, typename S2, typename S3, typename S4, typename S5, typename S6, typename S7>
struct function_7 {
  function_7_rep<D,S1,S2,S3,S4,S5,S6,S7>* rep;
  inline function_7 (): rep (NULL) {}
  inline function_7 (function_7_rep<D,S1,S2,S3,S4,S5,S6,S7>* rep2): rep (rep2) {}
  inline function_7 (const function_7& f):
    rep (f.rep) { INC_NULL_COUNT(rep); }
  inline function_7 (D (*fun) (S1, S2, S3, S4, S5, S6, S7)):
    rep (new def_function_7_rep<D,S1,S2,S3,S4,S5,S6,S7> (fun)) {}
  inline ~function_7 () { DEC_NULL_COUNT (rep); }
  inline function_7& operator = (const function_7& f) {
    INC_NULL_COUNT (f.rep); DEC_NULL_COUNT (rep);
    rep= f.rep; return *this; }
  inline D operator () (S1 x1, S2 x2, S3 x3, S4 x4, S5 x5, S6 x6, S7 x7) const {
    return rep->apply (x1, x2, x3, x4, x5, x6, x7); }
};

#define TMPL template<typename D, typename S1, typename S2, typename S3, typename S4, typename S5, typename S6, typename S7>
#define Function function_7<D,S1,S2,S3,S4,S5,S6,S7>
TMPL inline syntactic flatten (const Function& f) {
  return "function"; }
TMPL inline nat hard_hash (const Function& f) {
  return as_hash (f.rep); }
TMPL inline bool hard_eq (const Function& f, const Function& g) {
  return (f.rep) == (g.rep); }
TMPL inline bool hard_neq (const Function& f, const Function& g) {
  return (f.rep) != (g.rep); }
HARD_TO_EXACT_IDENTITY_SUGAR(TMPL,Function)
HARD_TO_TRUE_IDENTITY_SUGAR(TMPL,Function)
#undef Function
#undef TMPL

/******************************************************************************
* Octagonal functions
******************************************************************************/

template<typename D, typename S1, typename S2, typename S3, typename S4, typename S5, typename S6, typename S7, typename S8>
struct function_8_rep REP_STRUCT {
  inline function_8_rep () {}
  virtual ~function_8_rep () {}
  virtual D apply (S1 x1, S2 x2, S3 x3, S4 x4, S5 x5, S6 x6, S7 x7, S8 x8) = 0;
};

template<typename D, typename S1, typename S2, typename S3, typename S4, typename S5, typename S6, typename S7, typename S8>
struct def_function_8_rep: public function_8_rep<D,S1,S2,S3,S4,S5,S6,S7,S8> {
  D (*fun) (S1, S2, S3, S4, S5, S6, S7, S8);
  inline def_function_8_rep (D (*fun2) (S1, S2, S3, S4, S5, S6, S7, S8)):
    fun (fun2) {}
  D apply (S1 x1, S2 x2, S3 x3, S4 x4, S5 x5, S6 x6, S7 x7, S8 x8) { 
    return fun (x1, x2, x3, x4, x5, x6, x7, x8); }
};

template<typename D, typename S1, typename S2, typename S3, typename S4, typename S5, typename S6, typename S7, typename S8>
struct function_8 {
  function_8_rep<D,S1,S2,S3,S4,S5,S6,S7,S8>* rep;
  inline function_8 (): rep (NULL) {}
  inline function_8 (function_8_rep<D,S1,S2,S3,S4,S5,S6,S7,S8>* rep2): rep (rep2) {}
  inline function_8 (const function_8& f):
    rep (f.rep) { INC_NULL_COUNT(rep); }
  inline function_8 (D (*fun) (S1, S2, S3, S4, S5, S6, S7, S8)):
    rep (new def_function_8_rep<D,S1,S2,S3,S4,S5,S6,S7,S8> (fun)) {}
  inline ~function_8 () { DEC_NULL_COUNT (rep); }
  inline function_8& operator = (const function_8& f) {
    INC_NULL_COUNT (f.rep); DEC_NULL_COUNT (rep);
    rep= f.rep; return *this; }
  inline D operator () (S1 x1, S2 x2, S3 x3, S4 x4, S5 x5, S6 x6, S7 x7, S8 x8) const {
    return rep->apply (x1, x2, x3, x4, x5, x6, x7, x8); }
};

#define TMPL template<typename D, typename S1, typename S2, typename S3, typename S4, typename S5, typename S6, typename S7, typename S8>
#define Function function_8<D,S1,S2,S3,S4,S5,S6,S7,S8>
TMPL inline syntactic flatten (const Function& f) {
  return "function"; }
TMPL inline nat hard_hash (const Function& f) {
  return as_hash (f.rep); }
TMPL inline bool hard_eq (const Function& f, const Function& g) {
  return (f.rep) == (g.rep); }
TMPL inline bool hard_neq (const Function& f, const Function& g) {
  return (f.rep) != (g.rep); }
HARD_TO_EXACT_IDENTITY_SUGAR(TMPL,Function)
HARD_TO_TRUE_IDENTITY_SUGAR(TMPL,Function)
#undef Function
#undef TMPL

} // namespace mmx

using namespace mmx;
#endif // __MMX_FUNCTION_HPP