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

Go to the documentation of this file.

/******************************************************************************
* MODULE     : routine.hpp
* DESCRIPTION: Abstract routines for generic expressions
* 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 __ROUTINE_HPP
#define __ROUTINE_HPP
#include <basix/evaluator.hpp>
#include <basix/vector.hpp>
#include <basix/wrap.hpp>
#include <basix/compound.hpp>


namespace mmx {
class environment;

/******************************************************************************
* Abstraction
*****************************************************************************/

template<typename T>
struct generic_converter {
  static inline T make_concrete (const generic& x) {
    return as<T,generic> (x); }
  static inline generic make_abstract (const T& x) {
    // NOTE: returning as<generic,T> does not seem to call the appropriate
    // converter in the case when T=bool. A compiler bug?
    return new generic_concrete_rep<T> (x); }
};

STMPL
struct generic_converter<generic> {
  static inline generic make_concrete (const generic& x) {
    return x; }
  static inline generic make_abstract (const generic& x) {
    return x; }
};

template<typename T> inline T
make_concrete (const generic& x) {
  return generic_converter<T>::make_concrete (x);
}

template<typename T> inline generic
make_abstract (const T& x) {
  return generic_converter<T>::make_abstract (x);
}

/******************************************************************************
* Abstract generic routines
******************************************************************************/

class routine;
class routine_rep: public rep_struct {
public:
  generic name;
public:
  inline routine_rep (const generic& name2): name (name2) {}
  virtual inline ~routine_rep () {}
  virtual generic apply () const;
  virtual generic apply (const generic& g1) const;
  virtual generic apply (const generic& g1, const generic& g2) const;
  virtual generic apply (const vector<generic>& args) const;
  virtual vector<nat> signature () const;
  virtual void overload (const routine& fun) const;
  virtual bool is_overloaded () const;
  virtual vector<routine> meanings () const;
  virtual generic function_body () const;
  virtual generic function_type () const;
  virtual routine clone () const;
};

class routine {
INDIRECT_PROTO (routine, routine_rep)
public:
  inline const routine_rep* operator * () const { return rep; }
  inline routine (): rep (NULL) {}
  inline generic operator () () {
    return rep->apply (); }
  inline generic operator () (const generic& g1) {
    return rep->apply (g1); }
  inline generic operator () (const generic& g1, const generic& g2) {
    return rep->apply (g1, g2); }
  inline generic operator () (const vector<generic>& v) {
    return rep->apply (v); }
  friend inline bool is_nil (const routine& fun);
};
INDIRECT_NULL_IMPL (routine, routine_rep)

inline bool is_nil (const routine& fun) {
  return fun.rep == NULL; }
inline syntactic flatten (const routine& fun) {
  if (is_nil (fun)) return as_syntactic (GEN_NIL);
  else return as_syntactic (fun->name); }

WRAP_INDIRECT_IMPL(inline,routine)

/******************************************************************************
* Evaluation
******************************************************************************/

inline generic
eval (const routine& f, const vector<generic>& v) {
  return f->apply (v);
}

template<typename C> inline C
eval (const routine& f, const vector<C>& v) {
  return as<C> (f->apply (as<vector<generic> > (v)));
}

template<typename C> vector<C>
eval (const vector<routine>& f, const vector<C>& v) {
  vector<C> r= fill<C> (N(f));
  for (nat i=0; i<N(f); i++)
    r[i]= eval (f[i], v);
  return r;
}

/******************************************************************************
* Concrete generic routines
******************************************************************************/

template<typename D>
class nullary_routine_rep: public routine_rep {
  typedef D (*function_type) ();
  function_type fun;
public:
  nullary_routine_rep (const generic& name, function_type fun2):
    routine_rep (name), fun (fun2) {}
  generic apply () const {
    return make_abstract<D> (fun ());
  }
  generic apply (const vector<generic>& v) const {
    ASSERT (N(v) == 0, "zero arguments expected");
    return apply ();
  }
  vector<nat> signature () const {
    return vec<nat> (type_information<D>::id);
  }
};

template<>
class nullary_routine_rep<void>: public routine_rep {
  typedef void (*function_type) ();
  function_type fun;
public:
  nullary_routine_rep (const generic& name, function_type fun2):
    routine_rep (name), fun (fun2) {}
  generic apply () const {
    fun ();
    return void_value ();
  }
  generic apply (const vector<generic>& v) const {
    ASSERT (N(v) == 0, "zero arguments expected");
    return apply ();
  }
  vector<nat> signature () const {
    return vec<nat> ((nat) 0);
  }
};

template<typename D> routine
nullary_routine (const generic& name, D (*fun) ()) {
  return new nullary_routine_rep<D> (name, fun);
}

extern generic type_name (nat id);

template<typename D, typename S1>
class unary_routine_rep: public routine_rep {
  typedef D (*function_type) (const S1&);
  function_type fun;
public:
  unary_routine_rep (const generic& name, function_type fun2):
    routine_rep (name), fun (fun2) {}
  generic apply (const generic& x1) const {
    return make_abstract<D> (fun (make_concrete<S1> (x1)));
  }
  generic apply (const vector<generic>& v) const {
    ASSERT (N(v) == 1, "one argument expected");
    return apply (v[0]);
  }
  vector<nat> signature () const {
    return vec<nat> (type_information<D>::id, type_information<S1>::id);
  }
};

template<typename S1>
class unary_routine_rep<void,S1>: public routine_rep {
  typedef void (*function_type) (const S1&);
  function_type fun;
public:
  unary_routine_rep (const generic& name, function_type fun2):
    routine_rep (name), fun (fun2) {}
  generic apply (const generic& x1) const {
    fun (make_concrete<S1> (x1));
    return void_value ();
  }
  generic apply (const vector<generic>& v) const {
    ASSERT (N(v) == 1, "one argument expected");
    return apply (v[0]);
  }
  vector<nat> signature () const {
    return vec<nat> ((nat) 0, type_information<S1>::id);
  }
};

template<typename D, typename S1> routine
unary_routine (const generic& name, D (*fun) (const S1&)) {
  return new unary_routine_rep<D,S1> (name, fun);
}

template<typename D, typename S1, typename S2>
class binary_routine_rep: public routine_rep {
  typedef D (*function_type) (const S1&, const S2&);
  function_type fun;
public:
  binary_routine_rep (const generic& name, function_type fun2):
    routine_rep (name), fun (fun2) {}
  generic apply (const generic& x1, const generic& x2) const {
    return make_abstract<D> (fun (make_concrete<S1> (x1),
                                  make_concrete<S2> (x2)));
  }
  generic apply (const vector<generic>& v) const {
    ASSERT (N(v) == 2, "two arguments expected");
    return apply (v[0], v[1]);
  }
  vector<nat> signature () const {
    return vec<nat> (type_information<D>::id,
                     type_information<S1>::id,
                     type_information<S2>::id);
  }
};

template<typename S1, typename S2>
class binary_routine_rep<void,S1,S2>: public routine_rep {
  typedef void (*function_type) (const S1&, const S2&);
  function_type fun;
public:
  binary_routine_rep (const generic& name, function_type fun2):
    routine_rep (name), fun (fun2) {}
  generic apply (const generic& x1, const generic& x2) const {
    fun (make_concrete<S1> (x1), make_concrete<S2> (x2));
    return void_value ();
  }
  generic apply (const vector<generic>& v) const {
    ASSERT (N(v) == 2, "two arguments expected");
    return apply (v[0], v[1]);
  }
  vector<nat> signature () const {
    return vec<nat> ((nat) 0,
                     type_information<S1>::id,
                     type_information<S2>::id);
  }
};

template<typename D, typename S1, typename S2> routine
binary_routine (const generic& name, D (*f) (const S1&, const S2&)) {
  return new binary_routine_rep<D,S1,S2> (name, f);
}

template<typename D, typename S1, typename S2, typename S3>
class ternary_routine_rep: public routine_rep {
  typedef D (*function_type) (const S1&, const S2&, const S3&);
  function_type fun;
public:
  ternary_routine_rep (const generic& name, function_type fun2):
    routine_rep (name), fun (fun2) {}
  generic apply (const vector<generic>& v) const {
    ASSERT (N(v) == 3, "three arguments expected");
    return make_abstract<D> (fun (make_concrete<S1> (v[0]),
                                  make_concrete<S2> (v[1]),
                                  make_concrete<S3> (v[2])));
  }
  vector<nat> signature () const {
    return vec<nat> (type_information<D>::id,
                     type_information<S1>::id,
                     type_information<S2>::id,
                     type_information<S3>::id);
  }
};

template<typename S1, typename S2, typename S3>
class ternary_routine_rep<void,S1,S2,S3>: public routine_rep {
  typedef void (*function_type) (const S1&, const S2&, const S3&);
  function_type fun;
public:
  ternary_routine_rep (const generic& name, function_type fun2):
    routine_rep (name), fun (fun2) {}
  generic apply (const vector<generic>& v) const {
    ASSERT (N(v) == 3, "three arguments expected");
    fun (make_concrete<S1> (v[0]),
         make_concrete<S2> (v[1]),
         make_concrete<S3> (v[2]));
    return void_value ();
  }
  vector<nat> signature () const {
    return vec<nat> ((nat) 0,
                     type_information<S1>::id,
                     type_information<S2>::id,
                     type_information<S3>::id);
  }
};

template<typename D, typename S1, typename S2, typename S3> routine
ternary_routine (const generic& name,
                 D (*f) (const S1&, const S2&, const S3&)) {
  return new ternary_routine_rep<D,S1,S2,S3> (name, f);
}

template<typename D, typename S1, typename S2, typename S3, typename S4>
class quaternary_routine_rep: public routine_rep {
  typedef D (*function_type) (const S1&, const S2&, const S3&, const S4&);
  function_type fun;
public:
  quaternary_routine_rep (const generic& name, function_type fun2):
    routine_rep (name), fun (fun2) {}
  generic apply (const vector<generic>& v) const {
    ASSERT (N(v) == 4, "four arguments expected");
    return make_abstract<D> (fun (make_concrete<S1> (v[0]),
                                  make_concrete<S2> (v[1]),
                                  make_concrete<S3> (v[2]),
                                  make_concrete<S4> (v[3])));
  }
  vector<nat> signature () const {
    return vec<nat> (type_information<D>::id,
                     type_information<S1>::id,
                     type_information<S2>::id,
                     type_information<S3>::id,
                     type_information<S4>::id);
  }
};

template<typename S1, typename S2, typename S3, typename S4>
class quaternary_routine_rep<void,S1,S2,S3,S4>: public routine_rep {
  typedef void (*function_type) (const S1&, const S2&, const S3&, const S4&);
  function_type fun;
public:
  quaternary_routine_rep (const generic& name, function_type fun2):
    routine_rep (name), fun (fun2) {}
  generic apply (const vector<generic>& v) const {
    ASSERT (N(v) == 4, "four arguments expected");
    fun (make_concrete<S1> (v[0]),
         make_concrete<S2> (v[1]),
         make_concrete<S3> (v[2]),
         make_concrete<S4> (v[3]));
    return void_value ();
  }
  vector<nat> signature () const {
    return vec<nat> ((nat) 0,
                     type_information<S1>::id,
                     type_information<S2>::id,
                     type_information<S3>::id,
                     type_information<S4>::id);
  }
};

template<typename D, typename S1, typename S2, typename S3, typename S4> routine
quaternary_routine (const generic& name,
                    D (*f) (const S1&, const S2&, const S3&,const S4&)) {
  return new quaternary_routine_rep<D,S1,S2,S3,S4> (name, f);
}

template<typename D, typename S1, typename S2, typename S3,
         typename S4, typename S5>
class quintary_routine_rep: public routine_rep {
  typedef D (*function_type) (const S1&, const S2&, const S3&,
                              const S4&, const S5&);
  function_type fun;
public:
  quintary_routine_rep (const generic& name, function_type fun2):
    routine_rep (name), fun (fun2) {}
  generic apply (const vector<generic>& v) const {
    ASSERT (N(v) == 5, "five arguments expected");
    return make_abstract<D> (fun (make_concrete<S1> (v[0]),
                                  make_concrete<S2> (v[1]),
                                  make_concrete<S3> (v[2]),
                                  make_concrete<S4> (v[3]),
                                  make_concrete<S4> (v[4])));
  }
  vector<nat> signature () const {
    return vec<nat> (type_information<D>::id,
                     type_information<S1>::id,
                     type_information<S2>::id,
                     type_information<S3>::id,
                     type_information<S4>::id,
                     type_information<S5>::id);
  }
};

template<typename S1, typename S2, typename S3, typename S4, typename S5>
class quintary_routine_rep<void,S1,S2,S3,S4,S5>: public routine_rep {
  typedef void (*function_type) (const S1&, const S2&, const S3&,
                                 const S4&, const S5&);
  function_type fun;
public:
  quintary_routine_rep (const generic& name, function_type fun2):
    routine_rep (name), fun (fun2) {}
  generic apply (const vector<generic>& v) const {
    ASSERT (N(v) == 4, "four arguments expected");
    fun (make_concrete<S1> (v[0]),
         make_concrete<S2> (v[1]),
         make_concrete<S3> (v[2]),
         make_concrete<S4> (v[3]),
         make_concrete<S4> (v[4]));
    return void_value ();
  }
  vector<nat> signature () const {
    return vec<nat> ((nat) 0,
                     type_information<S1>::id,
                     type_information<S2>::id,
                     type_information<S3>::id,
                     type_information<S4>::id,
                     type_information<S5>::id);
  }
};

template<typename D, typename S1, typename S2, typename S3,
         typename S4, typename S5> routine
quintary_routine (const generic& name,
                  D (*f) (const S1&, const S2&, const S3&,
                          const S4&, const S5&)) {
  return new quintary_routine_rep<D,S1,S2,S3,S4,S5> (name, f);
}

/******************************************************************************
* Other types of routines
******************************************************************************/

routine identity_routine (const vector<nat>& sig);
routine compose (const routine& fun, const vector<routine>& args);
inline routine compose (const routine& fun, const routine& arg) {
  return compose (fun, vec (arg)); }
routine change_signature (const routine& r, const vector<nat>& sig);
routine default_routine (const generic& name);
routine integrate (const routine& fun);

} // namespace mmx
#endif // __ROUTINE_HPP