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

Go to the documentation of this file.

/******************************************************************************
* MODULE     : generic.hpp
* DESCRIPTION: Generic expressions
* COPYRIGHT  : (C) 2005  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 __GENERIC_HPP
#define __GENERIC_HPP
#include <typeinfo>
#include <basix/defaults.hpp>


namespace mmx {
#define TMPL template<typename C>
#define Acc accelerator<C>
class generic;
class syntactic;
class port;
class string;
class routine;
class routine_rep;
struct exact_eq_table;
template<typename T,typename F> struct as_helper;
template<typename T,typename F> inline T as (const F& x);
template<typename C> struct vector_as_helper;
TMPL struct inspector;
TMPL struct binary_helper;
generic gen_vec ();
generic gen_vec (const generic& g1);
generic gen_vec (const generic& g1, const generic& g2);
generic gen_vec (const generic& g1, const generic& g2, const generic& g3);
generic vector_access (const generic& g, nat i);
TMPL generic binary_disassemble (const C& x);
TMPL void binary_write (const port& out, const C& x);
TMPL inline port operator << (const port& out, const C& x);
void write (const port& p, const char* s, nat n);
void write (const port& p, const string& s);
extern port mmout;
extern port mmerr;
extern bool booting_done;
extern generic GEN_CONVERT;

/******************************************************************************
* Accelerated methods
******************************************************************************/

#define ACC_NEGATE          0
#define ACC_SQUARE          1
#define ACC_INVERT          2
#define ACC_ADD             3
#define ACC_SUB             4
#define ACC_MUL             5
#define ACC_DIV             6
#define ACC_SQRT            8
#define ACC_EXP             9
#define ACC_LOG            10
#define ACC_COS            11
#define ACC_SIN            12
#define ACC_TAN            13
#define ACC_ACOS           14
#define ACC_ASIN           15
#define ACC_ATAN           16
#define ACC_COSH           17
#define ACC_SINH           18
#define ACC_TANH           19
#define ACC_ACOSH          20
#define ACC_ASINH          21
#define ACC_ATANH          22
#define ACC_HYPOT          23
#define ACC_ATAN2          24
#define ACC_POW            25
#define ACC_LESS           26
#define ACC_LESSEQ         27
#define ACC_GTR            28
#define ACC_GTREQ          29
#define ACC_DERIVE         30
#define ACC_DERIVE_WRT     31
#define ACC_INTEGRATE      32
#define ACC_INTEGRATE_WRT  33

/******************************************************************************
* The generic class
******************************************************************************/

class generic_rep: public rep_struct {
public:
  virtual nat get_type () const = 0;
  virtual bool same_type (const generic& g) const = 0;
  virtual nat get_symbolic_type () const = 0;
  virtual nat get_species_type () const = 0;
  virtual nat get_length () const = 0;
  virtual generic get_child (nat i) const = 0;
  virtual nat get_hard_hash_value () const = 0;
  virtual nat get_exact_hash_value () const = 0;
  virtual nat get_hash_value () const = 0;
  virtual bool is_hard_eq (const generic& rep) const = 0;
  virtual bool is_exact_eq (const generic& rep) const = 0;
  virtual bool is_equal (const generic& rep) const = 0;
  virtual generic duplicate_me () const = 0;
  virtual syntactic expression () const = 0;
  virtual generic binary_type () const = 0;
  virtual generic binary_disassemble () const = 0;
  virtual void binary_write (const port& p) const = 0;
  virtual generic make_abstract_vector () const = 0;
  virtual generic make_concrete_vector (const generic& v) const = 0;

  virtual nat      acc_id () const;
  virtual routine* acc_construct (nat id) const;
  virtual routine* acc_apply (nat code) const;

public:
  inline generic_rep () {}
  inline virtual ~generic_rep () {}
  inline generic me () const;

  friend class generic;
};
  
class generic {
INDIRECT_PROTO (generic, generic_rep)
public:
  generic ();
  generic (const char* s);
  generic (const string& s);
  generic (int i);
  generic (nat i);
  generic operator () () const;
  generic operator () (const generic& g1) const;
  generic operator () (const generic& g1, const generic& g2) const;
  generic operator () (const generic& g1, const generic& g2,
                       const generic& g3) const;

  inline generic operator [] (nat i) const { return rep->get_child (i); }
  inline friend generic_rep* inspect (const generic& g) { return g.rep; };
  friend syntactic flatten (const generic& g);

  friend class generic_rep;
};
INDIRECT_IMPL (generic, generic_rep)

inline generic generic_rep::me () const {
  return generic (this, true); }
inline nat type (const generic& g) {
  return g->get_type (); }
inline nat symbolic_type (const generic& g) {
  return g->get_symbolic_type (); }
inline nat species_type (const generic& g) {
  return g->get_species_type (); }
inline nat N (const generic& g) {
  return g->get_length (); }
inline nat gen_hash (const generic& g) {
  return g->get_hard_hash_value (); }
inline nat exact_hash (const generic& g) {
  return g->get_exact_hash_value (); }
inline nat hash (const generic& g) {
  return g->get_hash_value (); }
inline bool gen_eq (const generic& g1, const generic& g2) {
  return g1->is_hard_eq (g2); }
inline bool gen_neq (const generic& g1, const generic& g2) {
  return !g1->is_hard_eq (g2); }

/******************************************************************************
* Type information
******************************************************************************/

nat new_type_id ();
nat new_type_id (const char*);

template<typename T>
inline nat global_type_id () { return new_type_id (typeid (T ()).name()); }  
inline nat binary_id (nat id1, nat id2) { return id1 ^ (0x10115 * id2); }
template<typename T> struct type_information { static nat id; };
template<typename T> nat type_information<T>::id= global_type_id<T> ();
STMPL struct type_information<generic> { static nat id; };
TMPL inline bool is (const generic& x) {
  return type (x) == type_information<C>::id; }
inline bool same_type (const generic& x1, const generic& x2) {
  return x1->same_type (x2); }
vector<generic> all_type_names ();
void define_type_sub (const generic& name, nat id);
nat type_id (const generic& name);
generic type_name (nat id);
generic type_name (const generic& g);
template<typename C> inline nat type_id () {
  return type_information<C>::id; }
template<typename C> inline generic type_name () {
  return type_name (type_id<C> ()); }

#define SYMBOLIC_UNSPECIFIED  0
#define SYMBOLIC_INTEGER      1
#define SYMBOLIC_RATIONAL     2
#define SYMBOLIC_FLOATING     3
#define SYMBOLIC_BALL         4
#define SYMBOLIC_REAL         5
#define SYMBOLIC_LITERAL      6
#define SYMBOLIC_COMPOUND     7
#define SYMBOLIC_SUM          8
#define SYMBOLIC_PRODUCT      9
#define SYMBOLIC_DERIVATIVE  10
#define SYMBOLIC_FUNCTION    11

template<typename T> struct symbolic_type_information {
  static const nat id= SYMBOLIC_UNSPECIFIED; };

#define SPECIES_DEFAULT   0
#define SPECIES_VECTOR    1
#define SPECIES_LIST      2
#define SPECIES_TABLE     3

template<typename T> struct species_type_information {
  static const nat id= SPECIES_DEFAULT; };
inline bool is_vector (const generic& x) {
  return species_type (x) == SPECIES_VECTOR; }
inline bool is_list (const generic& x) {
  return species_type (x) == SPECIES_LIST; }
inline bool is_table (const generic& x) {
  return species_type (x) == SPECIES_TABLE; }

/******************************************************************************
* Syntactic manipulation of generic objects
******************************************************************************/

generic lit (const char* s);
generic lit (const string& s);

generic gen (const generic& x1, const vector<generic>& v);
generic gen ();
generic gen (const generic& x1);
generic gen (const generic& x1, const string& x2);
generic gen (const generic& x1, const generic& x2);
generic gen (const generic& x1, const generic& x2, const generic& x3);
generic gen (const generic& x1, const generic& x2,
             const generic& x3, const generic& x4);
generic gen (const generic& x1, const generic& x2,
             const generic& x3, const generic& x4, const generic& x5);
generic gen (const generic& x1, const generic& x2,
             const generic& x3, const generic& x4,
             const generic& x5, const generic& x6);

generic void_value ();
generic comma ();
generic comma (const generic& x1, const generic& x2);
generic xgen (const generic& f, const generic& args);
generic xaccess (const generic& f, const generic& args);
generic xtuple (const generic& args);
generic xsqtuple (const generic& args);
generic xrow (const generic& args);
generic access (const generic& f, const generic& x);
generic access (const generic& f, const generic& x, const generic& y);
generic access (const generic& f, const vector<generic>& x);

generic as_object (const generic& v, nat tp_id);
generic as_object (const generic& v, const generic& tp);
generic as_generic (const generic& obj, nat tp_id);
generic as_generic (const generic& obj, const generic& tp);

generic range (const generic& g, nat start, nat end);
generic append (const generic& g1, const generic& g2);
generic cons (const generic& g1, const generic& g2);
generic cons (const generic& g1, const generic& g2, const generic& g3);
generic car (const generic& g);
generic cdr (const generic& g);

bool is_func (const generic& g, const char* f);
bool is_func (const generic& g, const char* f, nat n);
bool is_func (const generic& g, const generic& f);
bool is_func (const generic& g, const generic& f, nat n);
nat size (const generic& g);
int big_small_compare (const generic& g1, const generic& g2);
int small_big_compare (const generic& g1, const generic& g2);

/******************************************************************************
* Generic functions
******************************************************************************/

generic convert (const generic& from, const generic& to);

void set_smallest (generic& x);
void set_largest (generic& x);
void set_accuracy (generic& x);
void set_pi (generic& x);
void set_log2 (generic& x);
void set_euler (generic& x);
void set_catalan (generic& x);
void set_imaginary (generic& x);
void set_nan (generic& x);
void set_fuzz (generic& x);
void set_infinity (generic& x);
void set_maximal (generic& x);
void set_minimal (generic& x);

generic operator - (const generic& x1);
generic square (const generic &x1);
generic invert (const generic &x1);
generic operator + (const generic& x1, const generic& x2);
generic operator - (const generic& x1, const generic& x2);
generic operator * (const generic& x1, const generic& x2);
generic operator / (const generic& x1, const generic& x2);
generic operator + (const generic& x1, const int& x2);
generic operator - (const generic& x1, const int& x2);
generic operator * (const generic& x1, const int& x2);
generic operator / (const generic& x1, const int& x2);
generic operator + (const int& x1, const generic& x2);
generic operator - (const int& x1, const generic& x2);
generic operator * (const int& x1, const generic& x2);
generic operator / (const int& x1, const generic& x2);

generic sqrt (const generic& x1);
generic exp (const generic& x1);
generic log (const generic& x1);
generic cos (const generic& x1);
generic sin (const generic& x1);
generic tan (const generic& x1);
generic acos (const generic& x1);
generic asin (const generic& x1);
generic atan (const generic& x1);
generic cosh (const generic& x1);
generic sinh (const generic& x1);
generic tanh (const generic& x1);
generic acosh (const generic& x1);
generic asinh (const generic& x1);
generic atanh (const generic& x1);
generic hypot (const generic& x1, const generic& x2);
generic atan2 (const generic& x1, const generic& x2);
generic pow (const generic& x1, const generic& x2);
generic pow (const generic& x1, const int& x2);
generic pow (const int& x1, const generic& x2);

bool operator == (const generic& x1, const generic& x2);
bool operator != (const generic& x1, const generic& x2);
bool operator == (const generic& x1, const int& x2);
bool operator != (const generic& x1, const int& x2);
bool operator == (const int& x1, const generic& x2);
bool operator != (const int& x1, const generic& x2);
bool exact_eq  (const generic& x1, const generic& x2);
bool exact_neq (const generic& x1, const generic& x2);
bool exact_eq  (const generic& x1, const int& x2);
bool exact_neq (const generic& x1, const int& x2);
bool exact_eq  (const int& x1, const generic& x2);
bool exact_neq (const int& x1, const generic& x2);
inline bool is_exact_zero (const generic& g1) { return exact_eq (g1, 0); }

bool operator < (const generic& x1, const generic& x2);
bool operator <= (const generic& x1, const generic& x2);
bool operator > (const generic& x1, const generic& x2);
bool operator >= (const generic& x1, const generic& x2);
bool operator < (const generic& x1, const int& x2);
bool operator <= (const generic& x1, const int& x2);
bool operator > (const generic& x1, const int& x2);
bool operator >= (const generic& x1, const int& x2);
bool operator < (const int& x1, const generic& x2);
bool operator <= (const int& x1, const generic& x2);
bool operator > (const int& x1, const generic& x2);
bool operator >= (const int& x1, const generic& x2);

generic derive (const generic& x1);
generic integrate (const generic& x1);
generic derive (const generic& x1, const generic& x2);
generic integrate (const generic& x1, const generic& x2);

/******************************************************************************
* Routines based on the current evaluator
******************************************************************************/

generic construct (const int& i);
generic construct (const nat& i);
generic construct (const double& x);
generic construct (const float& x);
generic construct (const generic& x);
generic eval (const generic& x);

generic apply (const generic& f, const generic& x);
generic apply (const generic& f, const generic& x, const generic& y);
generic apply (const generic& f, const generic& x,
               const generic& y, const generic& z);
generic apply (const generic& f, const vector<generic>& x);

generic quo (const generic& x1, const generic& x2);
generic rem (const generic& x1, const generic& x2);
generic numerator (const generic& x);
generic denominator (const generic& x);
generic gcd (const generic& x1, const generic& x2);
generic lcm (const generic& x1, const generic& x2);
TMPL struct xgcd_matrix;
xgcd_matrix<generic> xgcd (const generic& x1, const generic& x2);

generic pow (const generic& x1, const nat& x2);
generic pow (const nat& x1, const generic& x2);
generic trig (const generic& x1);

generic min (const generic& x1, const generic& x2);
generic max (const generic& x1, const generic& x2);
generic abs (const generic& x1);
generic arg (const generic& x1);
generic Re (const generic& x1);
generic Im (const generic& x1);
generic conj (const generic& x1);
generic gaussian (const generic& x1, const generic& x2);
generic polar (const generic& x1, const generic& x2);

generic floor (const generic& x);
generic trunc (const generic& x);
generic ceil (const generic& x);
generic round (const generic& x);

generic prime (const generic& x1);
generic substitute (const generic& x1, const generic& x2);
generic compose (const generic& x1, const generic& x2);
generic dilate (const generic& x1, const generic& x2);
generic solve (const generic& x1, const generic& x2);

generic sqrt_init (const generic& x, const generic& c);
generic log_init (const generic& x, const generic& c);
generic acos_init (const generic& x, const generic& c);
generic asin_init (const generic& x, const generic& c);
generic atan_init (const generic& x, const generic& c);
generic integrate_init (const generic& x, const generic& c);
generic solve_lde_init (const generic& x, const generic& c);

generic change_precision (const generic& x, xnat p);
xnat    precision (const generic& x);
generic next_above (const generic& x);
generic next_below (const generic& x);
generic rounding_error (const generic& x);
generic additive_error (const generic& x);
generic multiplicative_error (const generic& x);
generic elementary_error (const generic& x);
xint    exponent (const generic& x);
double  magnitude (const generic& x);
generic incexp2 (const generic& x1, const xint& x2);
generic decexp2 (const generic& x1, const xint& x2);
generic operator << (const generic& x1, const generic& x2);
generic operator >> (const generic& x1, const generic& x2);

generic lshiftz (const generic& x1, const generic& x2);
generic rshiftz (const generic& x1, const generic& x2);
generic operator | (const generic& x1, const generic& x2);
generic operator & (const generic& x1, const generic& x2);
generic lres (const generic& x1, const generic& x2);
generic rres (const generic& x1, const generic& x2);
generic uniform (const generic& x1, const generic& x2);
generic specialize (const generic& x1, const generic& x2);

generic center (const generic& x1);
generic radius (const generic& x1);
generic sharpen (const generic& x1);
generic blur (const generic& x1, const generic& x2);

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

TMPL
struct accelerator {
  static nat id;
  static routine *construct;
  static nat nr_construct;
  static routine *apply;
  static nat nr_apply;
  static void set_construct (nat id, const routine& r);
  static void set_apply (nat code, const routine& r);
};

TMPL nat Acc::id= (nat) -1;
TMPL routine *Acc::construct= NULL;
TMPL nat Acc::nr_construct= (nat) 0;
TMPL routine *Acc::apply= NULL;
TMPL nat Acc::nr_apply= (nat) 0;

typedef routine* vec_routine;
void fill_out (vec_routine& v, nat& n, nat i, const routine& r);

/******************************************************************************
* Concrete instances
******************************************************************************/

TMPL
class generic_concrete_rep: public generic_rep {
public:
  C rep;

protected:
  nat get_type () const { return type_information<C>::id; }
  bool same_type (const generic& g) const { return is<C> (g); }
  nat get_symbolic_type () const { return symbolic_type_information<C>::id; }
  nat get_species_type () const { return species_type_information<C>::id; }
  nat get_length () const { return inspector<C>::length (rep); }
  generic get_child (nat i) const { return inspector<C>::access (rep, i); }
  nat get_hard_hash_value () const { return hard_hash (rep); }
  nat get_exact_hash_value () const { return exact_hash (rep); }
  nat get_hash_value () const { return hash (rep); }
  bool is_hard_eq (const generic& g) const {
    if (type (g) != type_information<C>::id) return false;
    return hard_eq (rep, ((generic_concrete_rep<C>*) inspect (g)) -> rep); }
  bool is_exact_eq (const generic& g) const {
    if (type (g) != type_information<C>::id) return false;
    return exact_eq (rep, ((generic_concrete_rep<C>*) inspect (g)) -> rep); }
  bool is_equal (const generic& g) const {
    if (type (g) != type_information<C>::id) return false;
    return rep == ((generic_concrete_rep<C>*) inspect (g)) -> rep; }
  generic duplicate_me () const { return as<generic> (duplicate (rep)); }
  syntactic expression () const; // definition in syntactic.hpp
  generic binary_type () const {
    return binary_helper<C>::full_type_name (); }
  generic binary_disassemble () const {
    return mmx::binary_disassemble (rep); }
  void binary_write (const port& out) const {
    mmx::write (out, binary_helper<C>::short_type_name ());
    mmx::write (out, ":", 1);
    mmx::binary_write (out, rep); }
  generic make_abstract_vector () const {
    return vector_as_helper<C>::abstract (rep); }
  generic make_concrete_vector (const generic& v) const {
    return as<generic> (vector_as_helper<C>::concrete (v)); }

  inline nat acc_id () const {
    return Acc::id; }
  inline routine* acc_construct (nat id) const {
    if (id < Acc::nr_construct)
      return (routine*) (void*)
        (((routine_rep**) (void*) Acc::construct) + id);
    else return NULL; }
  inline routine* acc_apply (nat code) const {
    if (code < Acc::nr_apply)
      return (routine*) (void*)
        (((routine_rep**) (void*) Acc::apply) + code);
    else return NULL; }

public:
  generic_concrete_rep (const C& rep2): rep (rep2) {}
};

TMPL
struct as_helper<generic,C> {
  static inline generic cv (const C& x) {
    return new generic_concrete_rep<C> (x); }
};

TMPL
struct as_helper<C,generic> {
  static inline C cv (const generic& x) {
    return ((generic_concrete_rep<C>*) inspect(x)) -> rep; }
};

STMPL
struct as_helper<generic,generic> {
  static inline generic cv (const generic& x) { return x; }
};

TMPL generic
as_generic (const C& c) {
  return construct (new generic_concrete_rep<C> (c));
}

TMPL inline void
set_as (generic& r, const C& x) {
  r= new generic_concrete_rep<C> (x);
}

TMPL inline void
set_as (C& r, const generic& x) {
  r= ((generic_concrete_rep<C>*) inspect(x)) -> rep;
}

inline void
set_as (generic& r, const generic& x) {
 r= x;
}

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