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

Go to the documentation of this file.

/******************************************************************************
* MODULE     : glue.hpp
* DESCRIPTION: Routines for defining glue
* 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 __GLUE_HPP
#define __GLUE_HPP
#include <basix/evaluator.hpp>
#include <basix/routine.hpp>
#include <basix/identifiers.hpp>
#include <basix/primitive.hpp>
#include <basix/tuple.hpp>
#include <basix/alias.hpp>


namespace mmx {
#define TMPL template<typename C>
#define Acc accelerator<C>

template<typename C> inline generic type_name ();
void define_prerequisites ();

/******************************************************************************
* Register and call glued functions
******************************************************************************/

void register_glue (const string&, void(*)(void));
void call_glue (const string&);

/******************************************************************************
* Accelerators
******************************************************************************/

TMPL inline void Acc::set_construct (nat id, const routine& r) {
  fill_out (construct, nr_construct, id, r); }
TMPL inline void Acc::set_apply (nat code, const routine& r) {
  fill_out (apply, nr_apply, code, r); }

nat accelerate_number ();

TMPL void
accelerate_initialize () {
  if (Acc::id == ((nat) (-1)))
    Acc::id= accelerate_number ();
}

template<typename C, typename S1> void
accelerate_converter (const generic& name, C (*f) (const S1&)) {
  (void) name;
  accelerate_initialize<C> ();
  accelerate_initialize<S1> ();
  generic con= gen (GEN_INTO, type_name<S1> (), type_name<C> ());
  routine fun= unary_routine (con, f);
  Acc::set_construct (accelerator<S1>::id, fun);
}

template<typename C, typename S> inline void
accelerate_converter (const generic&, C (*) (const alias<S>&)) {}
template<typename C, typename S> inline void
accelerate_converter (const generic&, C (*) (const generic_alias<S>&)) {}
template<typename S> inline void
accelerate_converter (const generic&, int (*) (const S&)) {}
template<typename S> inline void
accelerate_converter (const generic&, int (*) (const alias<S>&)) {}
template<typename S> inline void
accelerate_converter (const generic&, int (*) (const generic_alias<S>&)) {}

template<typename C, typename S1> inline void
accelerate (const generic& name, C (*f) (const S1&)) {
  if (name == GEN_CAST)
    accelerate_converter (name, f);
}

TMPL void
accelerate (const generic& name, C (*f) (const C&)) {
  routine fun= unary_routine (name, f);
  if (name == GEN_MINUS)
    Acc::set_apply (ACC_NEGATE, fun);
  else if (name == GEN_SQUARE)
    Acc::set_apply (ACC_SQUARE, fun);
  else if (name == GEN_INVERT)
    Acc::set_apply (ACC_INVERT, fun);
  else if (name == GEN_SQRT)
    Acc::set_apply (ACC_SQRT, fun);
  else if (name == GEN_EXP)
    Acc::set_apply (ACC_EXP, fun);
  else if (name == GEN_LOG)
    Acc::set_apply (ACC_LOG, fun);
  else if (name == GEN_COS)
    Acc::set_apply (ACC_COS, fun);
  else if (name == GEN_SIN)
    Acc::set_apply (ACC_SIN, fun);
  else if (name == GEN_TAN)
    Acc::set_apply (ACC_TAN, fun);
  else if (name == GEN_CH)
    Acc::set_apply (ACC_COSH, fun);
  else if (name == GEN_SH)
    Acc::set_apply (ACC_SINH, fun);
  else if (name == GEN_TH)
    Acc::set_apply (ACC_TANH, fun);
  else if (name == GEN_ARCCOS)
    Acc::set_apply (ACC_ACOS, fun);
  else if (name == GEN_ARCSIN)
    Acc::set_apply (ACC_ASIN, fun);
  else if (name == GEN_ARCTAN)
    Acc::set_apply (ACC_ATAN, fun);
  else if (name == GEN_ARGCH)
    Acc::set_apply (ACC_ACOSH, fun);
  else if (name == GEN_ARGSH)
    Acc::set_apply (ACC_ASINH, fun);
  else if (name == GEN_ARGTH)
    Acc::set_apply (ACC_ATANH, fun);
  else if (name == GEN_DERIVE)
    Acc::set_apply (ACC_DERIVE, fun);
  else if (name == GEN_INTEGRATE)
    Acc::set_apply (ACC_INTEGRATE, fun);
}

template<typename C, typename S1, typename S2> inline void
accelerate (const generic&, C (*) (const S1&, const S2&)) {}

TMPL void
accelerate (const generic& name, C (*f) (const C&, const C&)) {
  routine fun= binary_routine (name, f);
  if (name == GEN_PLUS)
    Acc::set_apply (ACC_ADD, fun);
  else if (name == GEN_MINUS)
    Acc::set_apply (ACC_SUB, fun);
  else if (name == GEN_TIMES)
    Acc::set_apply (ACC_MUL, fun);
  else if (name == GEN_OVER)
    Acc::set_apply (ACC_DIV, fun);
  else if (name == GEN_HYPOT)
    Acc::set_apply (ACC_HYPOT, fun);
  else if (name == GEN_ARCTAN2)
    Acc::set_apply (ACC_ATAN2, fun);
  else if (name == GEN_POWER)
    Acc::set_apply (ACC_POW, fun);
}

TMPL void
accelerate (const generic& name, bool (*f) (const C&, const C&)) {
  routine fun= binary_routine (name, f);
  if (name == GEN_LESS)
    Acc::set_apply (ACC_LESS, fun);
  else if (name == GEN_LESSEQ)
    Acc::set_apply (ACC_LESSEQ, fun);
  else if (name == GEN_GTR)
    Acc::set_apply (ACC_GTR, fun);
  else if (name == GEN_GTREQ)
    Acc::set_apply (ACC_GTREQ, fun);
}

inline void
accelerate (const generic&, bool (*) (const bool&, const bool&)) {}

/******************************************************************************
* Main functions for gluing routines to the current evaluator
******************************************************************************/

template<typename D> inline void
define_constant (const generic& name, const D& x) {
  current_ev->set (name, as<generic> (x));
}

template<typename D> inline void
define_constructor (generic (*fun) (const D&)) {
  current_ev->overload (GEN_NEW, as<generic> (unary_routine (GEN_NEW, fun)));
}

inline void
define_primitive (const generic& name, generic (*fun) (const generic&)) {
  current_ev->set (name, as<generic> (primitive (name, fun)));
}

template<typename D> inline void
define (const generic& name, D (*fun) ()) {
  current_ev->overload (name, as<generic> (nullary_routine (name, fun)));
}

template<typename D, typename S1> inline void
define (const generic& name, D (*fun) (const S1&)) {
  current_ev->overload (name, as<generic> (unary_routine (name, fun)));
  accelerate (name, fun);
}

template<typename D, typename S1, typename S2> inline void
define (const generic& name, D (*fun) (const S1&, const S2&)) {
  current_ev->overload (name, as<generic> (binary_routine (name, fun)));
  accelerate (name, fun);
}

template<typename D, typename S1, typename S2, typename S3>
inline void
define (const generic& name, D (*fun) (const S1&, const S2&, const S3&)) {
  current_ev->overload (name, as<generic> (ternary_routine (name, fun)));
}

template<typename D, typename S1, typename S2, typename S3, typename S4>
inline void
define (const generic& name, D (*fun) (const S1&, const S2&, const S3&,
                                       const S4&)) {
  current_ev->overload (name, as<generic> (quaternary_routine (name, fun)));
}

template<typename D, typename S1, typename S2, typename S3,
         typename S4, typename S5>
inline void
define (const generic& name, D (*fun) (const S1&, const S2&, const S3&,
                                       const S4&, const S5&)) {
  current_ev->overload (name, as<generic> (quintary_routine (name, fun)));
}

template<typename C, typename S1> inline void
define_converter (const generic& name, C (*f) (const S1&), nat p) {
  generic con= gen (GEN_INTO, type_name<S1> (), type_name<C> ());
  routine fun= unary_routine (con, f);
  current_ev->overload (name, as<generic> (fun), p);
  accelerate_converter (name, f);
}

/******************************************************************************
* Gluing new data types
******************************************************************************/

template<typename C>
struct define_type_helper {
  static bool helper_equal (const C& x, const C& y) { return x==y; }
  static bool helper_unequal (const C& x, const C& y) { return x!=y; }
  static syntactic helper_flatten (const C& x) { return flatten (x); }
  static inline void def_type (const generic& name);
  static inline void def_default ();
};

template<typename C> inline void
define_type_helper<C>::def_type (const generic& name) {
  define_type_sub (name, type_id<C> ());
  define_type_sub (gen (GEN_TUPLE_TYPE, name), type_id<tuple<C> > ());
  define_type_sub (gen (GEN_ALIAS_TYPE, name), type_id<alias<C> > ());
  define_type_sub (gen (GEN_GENERIC_ALIAS_TYPE, name),
                   type_id<generic_alias<C> > ());

  attach_generic_binary_assembler<C> ();
  attach_generic_binary_assembler<tuple<C> > ();
  attach_generic_binary_assembler<alias<C> > ();
  attach_generic_binary_reader<C> ();
  attach_generic_binary_reader<tuple<C> > ();
  attach_generic_binary_reader<alias<C> > ();

  define (GEN_ALIAS, new_alias<C>);
  routine specializer= unary_routine (GEN_SPECIALIZE, new_genalias<C>);
  alias_specializer (type_id<C> (), specializer);
  routine getter= unary_routine (GEN_UNALIAS, get_genalias<C>);
  alias_getter (type_id<generic_alias<C> > (), getter);  
  getter= unary_routine (GEN_UNALIAS, get_alias<C>);
  alias_getter (type_id<alias<C> > (), getter);  
  routine setter= binary_routine (GEN_UNALIAS, set_genalias<C>);
  alias_setter (type_id<generic_alias<C> > (), setter);  
  setter= binary_routine (GEN_UNALIAS, set_alias<C>);
  alias_setter (type_id<alias<C> > (), setter);

  define_converter<C,alias<C> >
    (GEN_REWRITE, get_alias<C>, PENALTY_AUTOMATIC);
  define_converter<C,generic_alias<C> >
    (GEN_REWRITE, get_genalias<C>, PENALTY_AUTOMATIC);
  define_converter<alias<generic>,generic_alias<C> >
    (GEN_REWRITE, generalize_genalias<C>, PENALTY_AUTOMATIC);
  define_converter<alias<C>,generic_alias<C> >
    (GEN_REWRITE, incarnate_genalias<C>, PENALTY_AUTOMATIC);
}

template<typename C> inline void
define_type_helper<C>::def_default () {
  define<bool,C,C> (GEN_EQUAL, helper_equal);
  define<bool,C,C> (GEN_UNEQUAL, helper_unequal);
  define<syntactic,C> (GEN_FLATTEN, helper_flatten);
}

template<> inline void
define_type_helper<generic>::def_default () {
}

template<typename C> inline void
define_type (const generic& name) {
  define_type_helper<C>::def_type (name);
  define_type_helper<C>::def_default ();
}

#undef TMPL
#undef Acc
} // namespace mmx
#endif // __GLUE_HPP