/Users/mourrain/Devel/mmx/basix/src/generic.cpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : generic.cpp
* 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.
******************************************************************************/

#include <basix/compound.hpp>
#include <basix/evaluator.hpp>
#include <basix/vector.hpp>
#include <basix/tuple.hpp>
#include <basix/mmx_syntax.hpp>
#include <basix/memoize.hpp>
#include <basix/string.hpp>
#include <basix/table.hpp>
#include <basix/routine.hpp>
namespace mmx {

/******************************************************************************
* Automatic addition of new types
******************************************************************************/

nat type_id (const generic& name);

nat
new_type_id () {
  static nat counter= 2;
  ASSERT (counter < 65000, "too many types");
  return counter++;
}

nat
new_type_id (const char* s) {
  static table<nat, string> t;
  if (!contains (t, s)) {
    nat id= new_type_id ();
    inside_set (t, s, id);
    return id;
  }
  return t[s];
}

nat type_information<generic>::id= 0;
// type identifier 1 for unknown type

/******************************************************************************
* Binary input/output
******************************************************************************/

static table<generic,string> binary_readers;

generic gen_vec () {
  return as<generic> (vec<generic> ()); }
generic gen_vec (const generic& g1) {
  return as<generic> (vec<generic> (g1)); }
generic gen_vec (const generic& g1, const generic& g2) {
  return as<generic> (vec<generic> (g1, g2)); }
generic gen_vec (const generic& g1, const generic& g2, const generic& g3) {
  return as<generic> (vec<generic> (g1, g2, g3)); }
generic vector_size (const generic& g) {
  if (!is<vector<generic> > (g)) return 0;
  else return N(as<vector<generic> > (g)); }
generic vector_access (const generic& g, nat i) {
  return as<vector<generic> > (g) [i]; }

void
attach_generic_binary_assembler (const generic& tp, unary_generic r) {
  if (!is<string> (tp) || as<string> (tp) != "?")
    current_ev->set (gen ("assembler", tp),
                     as<generic> (unary_routine ("binary_assembler", r)));
}

generic
binary_type_generic (const generic& g) {
  return g->binary_type ();
}

generic
binary_disassemble_generic (const generic& g) {
  return g->binary_disassemble ();
}

generic
binary_assemble_generic (const generic& tp, const generic& val) {
  if (!current_ev->contains (gen ("assembler", tp)))
    mmerr << "val= " << val << "\n";
  ASSERT (current_ev->contains (gen ("assembler", tp)),
          "unsupported type for generic binary assemble");
  routine r= as<routine> (current_ev->get (gen ("assembler", tp)));
  return r->apply (val);
}

void
attach_generic_binary_reader (const string& s, unary_generic r) {
  if (s != "?")
    binary_readers[s]= as<generic> (unary_routine ("binary_reader", r));
}

void
binary_write_generic (const port& out, const generic& g) {
  g->binary_write (out);
}

generic
binary_read_generic (const port& in) {
  string name;
  char buf[1];
  while (true) {
    mmx::read (in, buf, 1);
    if (buf[0] == ':') break;
    name << buf[0];
  }
  if (!binary_readers->contains (name))
    mmerr << "name= " << name << "\n";
  ASSERT (binary_readers->contains (name),
          "unsupported type for generic binary read");
  routine r= as<routine> (binary_readers[name]);
  return r->apply (as<generic> (in));
}

/******************************************************************************
* Different copying routines and printing generic expressions
******************************************************************************/

generic
duplicate (const generic& x1) {
  return x1->duplicate_me ();
}

syntactic
flatten (const generic& g) {
  MEMOIZE_UNARY (std_memoizer,syntactic,generic,flatten,g,
                 g->expression());
}

/******************************************************************************
* N-ary operations
******************************************************************************/

generic
void_value () {
  static generic val= as<generic> (tuple<generic> (gen (GEN_TUPLE)));
  return val;
}

void
xgen_sub (vector<generic>& v, const generic& g) {
  if (is<compound> (g) && N(g) >= 1 && exact_eq (g[0], GEN_COMMA)) {
    int i, n= N(g);
    for (i=1; i<n; i++)
      xgen_sub (v, g[i]);
  }
  else v << g;
}

generic
xgen (const generic& f, const generic& args) {
  vector<generic> v;
  v << f;
  xgen_sub (v, args);
  return vector_to_compound (v);
}

generic comma () {
  return gen (generic (GEN_COMMA)); }
generic comma (const generic& g1, const generic& g2) {
  return gen (GEN_COMMA, g1, g2); }
generic xaccess (const generic& f, const generic& args) {
  return xgen (GEN_ACCESS, comma (f, args)); }
generic xtuple (const generic& g) {
  return xgen (GEN_TUPLE, g); }
generic xsqtuple (const generic& g) {
  return xgen (GEN_SQTUPLE, g); }
generic xrow (const generic& g) {
  return xgen (GEN_ROW, g); }
generic access (const generic& g, const generic& x) {
  return gen (GEN_ACCESS, g, x); }
generic access (const generic& g, const generic& x, const generic& y) {
  return gen (GEN_ACCESS, g, x, y); }
generic access (const generic& g, const vector<generic>& args) {
  vector<generic> v= vec<generic> (generic (GEN_ACCESS), g);
  return vector_to_compound (append (v, args)); }

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

generic
construct (const int& i) {
  return current_ev->construct (as<generic> (i));
}

generic
construct (const nat& i) {
  return current_ev->construct (as<generic> ((int) i));
}

generic
construct (const double& x) {
  return current_ev->construct (as<generic> (x));
}

generic
construct (const float& x) {
  return current_ev->construct (as<generic> ((double) x));
}

generic
construct (const generic& x) {
  return current_ev->construct (x);
}

generic
eval (const generic& x) {
  return current_ev->eval (x);
}

/******************************************************************************
* Constructors
******************************************************************************/

generic::generic (int i):
  rep (new generic_concrete_rep<int> (i))
{
  if (inside (current_ev) != NULL)
    // FIXME: fixes initialization bug in algebramix when --enable-embedded
    *this= current_ev->construct (*this);
}

generic::generic (nat i):
  rep (new generic_concrete_rep<int> ((int) i))
{
  ASSERT (((int) i) >= 0, "nat does not fit inside an int");
  if (inside (current_ev) != NULL)
    // FIXME: fixes initialization bug in algebramix when --enable-embedded
    *this= current_ev->construct (*this);
}

/******************************************************************************
* Constants
******************************************************************************/

void set_smallest (generic& x) { x= GEN_SMALLEST; }
void set_largest (generic& x) { x= GEN_LARGEST; }
void set_accuracy (generic& x) { x= GEN_ACCURACY; }
void set_pi (generic& x) { x= GEN_PI; }
void set_log2 (generic& x) { x= log (generic (2)); }
void set_euler (generic& x) { x= GEN_EULER; }
void set_catalan (generic& x) { x= GEN_CATALAN; }
void set_imaginary (generic& x) { x= GEN_I; }
void set_nan (generic& x) { x= GEN_NAN; }
void set_fuzz (generic& x) { x= GEN_FUZZ; }
void set_infinity (generic& x) { x= GEN_INFINITY; }
void set_maximal (generic& x) { x= GEN_INFINITY; }
void set_minimal (generic& x) { x= -GEN_INFINITY; }

/******************************************************************************
* Function application
******************************************************************************/

generic apply (const generic& g, const generic& x) {
  return current_ev->apply (g, x); }
generic apply (const generic& g, const generic& x, const generic& y) {
  return current_ev->apply (g, x, y); }
generic apply (const generic& g, const generic& x,
               const generic& y, const generic& z) {
  return current_ev->apply (g, vec (x, y, z)); }
generic apply (const generic& g, const vector<generic>& args) {
  return current_ev->apply (g, args); }

/******************************************************************************
* Accelerator management
******************************************************************************/

nat generic_rep::acc_id () const { return -1; }
routine* generic_rep::acc_construct (nat id) const { return NULL; }
routine* generic_rep::acc_apply (nat code) const { return NULL; }

generic
convert (const generic& from, const generic& to) {
  if (same_type (from, to)) return from;
  routine* cv= to->acc_construct (from->acc_id ());
  if (cv != NULL && !is_nil (*cv)) return (*cv) (from);
  return current_ev->apply (GEN_CONVERT, from, type_name (to));
}

inline bool as_bool (const generic& g) {
  return is<bool> (g) && as<bool> (g); }

#define ACC_UNARY(code,x1)                              \
  routine* r= x1->acc_apply (code);                     \
  if (r != NULL && !is_nil (*r)) return (*r) (x1);

#define ACC_BINARY(code,x1,x2)                          \
  if (same_type (x1, x2)) {                             \
    routine* r= x1->acc_apply (code);                   \
    if (r != NULL && !is_nil (*r))                      \
      return (*r) (x1, x2);                             \
  }                                                     \
  else {                                                \
    routine* cv= x1->acc_construct (x2->acc_id ());     \
    if (cv != NULL && !is_nil (*cv)) {                  \
      routine* r= x1->acc_apply (code);                 \
      if (r != NULL && !is_nil (*r))                    \
        return (*r) (x1, (*cv) (x2));                   \
    }                                                   \
    cv= x2->acc_construct (x1->acc_id ());              \
    if (cv != NULL && !is_nil (*cv)) {                  \
      routine* r= x2->acc_apply (code);                 \
      if (r != NULL && !is_nil (*r))                    \
        return (*r) ((*cv) (x1), x2);                   \
    }                                                   \
  }

#define ACC_TEST(code,x1,x2)                            \
  if (same_type (x1, x2)) {                             \
    routine* r= x1->acc_apply (code);                   \
    if (r != NULL && !is_nil (*r))                      \
      return as_bool ((*r) (x1, x2));                   \
  }                                                     \
  else {                                                \
    routine* cv= x1->acc_construct (x2->acc_id ());     \
    if (cv != NULL && !is_nil (*cv)) {                  \
      routine* r= x1->acc_apply (code);                 \
      if (r != NULL && !is_nil (*r))                    \
        return as_bool ((*r) (x1, (*cv) (x2)));         \
    }                                                   \
    cv= x2->acc_construct (x1->acc_id ());              \
    if (cv != NULL && !is_nil (*cv)) {                  \
      routine* r= x2->acc_apply (code);                 \
      if (r != NULL && !is_nil (*r))                    \
        return as_bool ((*r) ((*cv) (x1), x2));         \
    }                                                   \
  }

#define ACC_BINARY_SCALAR(code,x1,x2)                   \
  routine* r= x1->acc_apply (code);                     \
  if (r != NULL && !is_nil (*r)) return (*r) (x1, x2);

void
fill_out (vec_routine& v, nat& n, nat i, const routine& r) {
  if (i >= n) {
    nat      new_n= (nat) (1.2 * ((double) (i + 2)));
    routine* new_v= mmx_new<routine> (new_n, routine ());
    for (nat j=0; j<n; j++) new_v[j]= v[j];
    if (v != NULL) mmx_delete<routine> (v, n);
    n= new_n;
    v= new_v;
  }
  v[i]= r;
}

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

generic
operator - (const generic& x1) {
  ACC_UNARY (ACC_NEGATE, x1);
  return current_ev->apply (GEN_MINUS, x1);
}

generic
square (const generic& x1) {
  ACC_UNARY (ACC_SQUARE, x1);
  return current_ev->apply (GEN_TIMES, x1, x1);
}

generic
invert (const generic& x1) {
  ACC_UNARY (ACC_INVERT, x1);
  return current_ev->apply (GEN_OVER, 1, x1);
}

generic
operator + (const generic& x1, const generic& x2) {
  ACC_BINARY (ACC_ADD, x1, x2);
  return current_ev->apply (GEN_PLUS, x1, x2);
}

generic
operator - (const generic& x1, const generic& x2) {
  ACC_BINARY (ACC_SUB, x1, x2);
  return current_ev->apply (GEN_MINUS, x1, x2);
}

generic
operator * (const generic& x1, const generic& x2) {
  ACC_BINARY (ACC_MUL, x1, x2);
  return current_ev->apply (GEN_TIMES, x1, x2);
}

generic
operator / (const generic& x1, const generic& x2) {
  ACC_BINARY (ACC_DIV, x1, x2);
  return current_ev->apply (GEN_OVER, x1, x2);
}

generic operator + (const generic& x1, const int& x2) {
  return x1 + generic (x2); }
generic operator - (const generic& x1, const int& x2) {
  return x1 - generic (x2); }
generic operator * (const generic& x1, const int& x2) {
  return x1 * generic (x2); }
generic operator / (const generic& x1, const int& x2) {
  return x1 / generic (x2); }
generic operator + (const int& x1, const generic& x2) {
  return generic (x1) + x2; }
generic operator - (const int& x1, const generic& x2) {
  return generic (x1) - x2; }
generic operator * (const int& x1, const generic& x2) {
  return generic (x1) * x2; }
generic operator / (const int& x1, const generic& x2) {
  return generic (x1) / x2; }

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

generic
sqrt (const generic& x1) {
  ACC_UNARY (ACC_SQRT, x1);
  return current_ev->apply (GEN_SQRT, x1);
}

generic
exp (const generic& x1) {
  ACC_UNARY (ACC_EXP, x1);
  return current_ev->apply (GEN_EXP, x1);
}

generic
log (const generic& x1) {
  ACC_UNARY (ACC_LOG, x1);
  return current_ev->apply (GEN_LOG, x1);
}

generic
cos (const generic& x1) {
  ACC_UNARY (ACC_COS, x1);
  return current_ev->apply (GEN_COS, x1);
}

generic
sin (const generic& x1) {
  ACC_UNARY (ACC_SIN, x1);
  return current_ev->apply (GEN_SIN, x1);
}

generic
tan (const generic& x1) {
  ACC_UNARY (ACC_TAN, x1);
  return current_ev->apply (GEN_TAN, x1);
}

generic
acos (const generic& x1) {
  ACC_UNARY (ACC_ACOS, x1);
  return current_ev->apply (GEN_ARCCOS, x1);
}

generic
asin (const generic& x1) {
  ACC_UNARY (ACC_ASIN, x1);
  return current_ev->apply (GEN_ARCSIN, x1);
}

generic
atan (const generic& x1) {
  ACC_UNARY (ACC_ATAN, x1);
  return current_ev->apply (GEN_ARCTAN, x1);
}

generic
cosh (const generic& x1) {
  ACC_UNARY (ACC_COSH, x1);
  return (exp (x1) + exp (-x1)) / 2;
}

generic
sinh (const generic& x1) {
  ACC_UNARY (ACC_SINH, x1);
  return (exp (x1) - exp (-x1)) / 2;
}

generic
tanh (const generic& x1) {
  ACC_UNARY (ACC_TANH, x1);
  return (exp (x1) - exp (-x1)) / (exp (x1) + exp (-x1));
}

generic
acosh (const generic& x1) {
  ACC_UNARY (ACC_ACOSH, x1);
  return log (x1 + sqrt (square (x1) - 1));
}

generic
asinh (const generic& x1) {
  ACC_UNARY (ACC_ASINH, x1);
  return log (x1 + sqrt (square (x1) + 1));
}

generic
atanh (const generic& x1) {
  ACC_UNARY (ACC_ATANH, x1);
  return log ((1 + x1) / (1 - x1)) / 2;
}

generic
hypot (const generic& x, const generic& y) {
  ACC_BINARY (ACC_HYPOT, x, y);
  return sqrt (square (x) + square (y));
}

generic
atan2 (const generic& x, const generic& y) {
  ACC_BINARY (ACC_ATAN2, x, y);
  if (x > 0) return atan (y/x);
  else if (y == 0)
    return x == 0? generic (0): generic (-4) * atan (generic (1));
  else if (x == 0)
    return generic (2 * sign (y)) * atan (generic (1));
  else return sign (y) * (4 * atan (generic (1)) - atan (abs (y/x)));
}

generic
pow (const generic& x1, const generic& x2) {
  ACC_BINARY (ACC_POW, x1, x2);
  return current_ev->apply (GEN_POWER, x1, x2);
}

generic pow (const generic& x1, const int& x2) {
  return pow (x1, generic (x2)); }
generic pow (const int& x1, const generic& x2) {
  return pow (generic (x1), x2); }
generic pow (const generic& x1, const nat& x2) {
  return pow (x1, generic (x2)); }
generic pow (const nat& x1, const generic& x2) {
  return pow (generic (x1), x2); }
generic trig (const generic& x1) {
  return xsqtuple (comma (cos (x1), sin (x1))); }

/******************************************************************************
* Predicates
******************************************************************************/

bool
operator == (const generic& x1, const generic& x2) {
  if (same_type (x1, x2))
    return x1->is_equal (x2);
  else {
    routine* cv= x1->acc_construct (x2->acc_id ());
    if (cv != NULL && !is_nil (*cv))
      return x1 -> is_equal ((*cv) (x2));
    cv= x2->acc_construct (x1->acc_id ());
    if (cv != NULL && !is_nil (*cv))
      return (*cv) (x1) -> is_equal (x2);
  }
  return as_bool (current_ev->apply (GEN_EQUAL, x1, x2));
}

bool
operator == (const generic& x1, const int& x2) {
  if (is<int> (x1)) return as<int> (x1) == x2;
  else {
    routine* cv= x1->acc_construct (accelerator<int>::id);
    if (cv != NULL && !is_nil (*cv))
      return x1 -> is_equal ((*cv) (as<generic> (x2)));
  }
  return x1 == generic (x2);
}

bool operator != (const generic& x1, const generic& x2) { return !(x1 == x2); }
bool operator != (const generic& x1, const int& x2) { return !(x1 == x2); }
bool operator == (const int& x1, const generic& x2) { return x2 == x1; }
bool operator != (const int& x1, const generic& x2) { return x2 != x1; }

bool
exact_eq (const generic& x1, const generic& x2) {
  if (same_type (x1, x2))
    return x1->is_exact_eq (x2);
  else {
    routine* cv= x1->acc_construct (x2->acc_id ());
    if (cv != NULL && !is_nil (*cv))
      return x1 -> is_exact_eq ((*cv) (x2));
    cv= x2->acc_construct (x1->acc_id ());
    if (cv != NULL && !is_nil (*cv))
      return (*cv) (x1) -> is_exact_eq (x2);
  }
  return false;
}

bool
exact_eq (const generic& x1, const int& x2) {
  if (is<int> (x1)) return as<int> (x1) == x2;
  else {
    routine* cv= x1->acc_construct (accelerator<int>::id);
    if (cv != NULL && !is_nil (*cv))
      return x1 -> is_exact_eq ((*cv) (as<generic> (x2)));
  }
  return false;
}

bool exact_neq (const generic& x1, const generic& x2) {
  return !exact_eq (x1, x2); }
bool exact_neq (const generic& x1, const int& x2) {
  return !exact_eq (x1, x2); }
bool exact_eq (const int& x1, const generic& x2) {
  return exact_eq (x2, x1); }
bool exact_neq (const int& x1, const generic& x2) {
  return exact_neq (x2, x1); }

/******************************************************************************
* Ordering
******************************************************************************/

bool
operator < (const generic& x1, const generic& x2) {
  ACC_TEST (ACC_LESS, x1, x2);
  return as_bool (current_ev->apply (GEN_LESS, x1, x2));
}

bool
operator <= (const generic& x1, const generic& x2) {
  ACC_TEST (ACC_LESSEQ, x1, x2);
  return as_bool (current_ev->apply (GEN_LESSEQ, x1, x2));
}

bool
operator > (const generic& x1, const generic& x2) {
  ACC_TEST (ACC_GTR, x1, x2);
  return as_bool (current_ev->apply (GEN_GTR, x1, x2));
}

bool
operator >= (const generic& x1, const generic& x2) {
  ACC_TEST (ACC_GTREQ, x1, x2);
  return as_bool (current_ev->apply (GEN_GTREQ, x1, x2));
}

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

/******************************************************************************
* Calculus
******************************************************************************/

generic
derive (const generic& x1) {
  ACC_UNARY (ACC_DERIVE, x1);
  return current_ev->apply (GEN_CACHED_DERIVE, x1);
}

generic
integrate (const generic& x1) {
  ACC_UNARY (ACC_INTEGRATE, x1);
  return current_ev->apply (GEN_INTEGRATE, x1);
}

generic
derive (const generic& x1, const generic& v) {
  ACC_BINARY_SCALAR (ACC_DERIVE_WRT, x1, v);
  MEMOIZE_BINARY (std_memoizer,generic,generic,generic,derive,x1,v,
                  current_ev->apply (GEN_CACHED_DERIVE, x1, v));
}

generic
integrate (const generic& x1, const generic& v) {
  ACC_BINARY_SCALAR (ACC_DERIVE_WRT, x1, v);
  return current_ev->apply (GEN_INTEGRATE, x1, v);
}

generic prime (const generic& x1) {
  return current_ev->apply ("'", x1); }
generic substitute (const generic& x1, const generic& x2) {
  return current_ev->apply (GEN_SUBSTITUTE, x1, x2); }
generic compose (const generic& x1, const generic& x2) {
  return current_ev->apply (GEN_COMPOSE, x1, x2); }
generic dilate (const generic& x1, const generic& x2) {
  return current_ev->apply ("dilate", x1, x2); }
generic solve (const generic& x1, const generic& x2) {
  return current_ev->apply (GEN_SOLVE, x1, x2); }

/******************************************************************************
* Further arithmetic
******************************************************************************/

generic quo (const generic& x1, const generic& x2) {
  return current_ev->apply (GEN_DIV, x1, x2); }
generic rem (const generic& x1, const generic& x2) {
  return current_ev->apply (GEN_MOD, x1, x2); }
generic numerator (const generic& x) {
  return current_ev->apply (GEN_NUMERATOR, x); }
generic denominator (const generic& x) {
  return current_ev->apply (GEN_DENOMINATOR, x); }
generic gcd (const generic& x1, const generic& x2) {
  return current_ev->apply (GEN_GCD, x1, x2); }
generic lcm (const generic& x1, const generic& x2) {
  return current_ev->apply (GEN_LCM, x1, x2); }

/******************************************************************************
* Real and complex structures
******************************************************************************/

generic min (const generic& x1, const generic& x2) {
  return current_ev->apply (GEN_MIN, x1, x2); }
generic max (const generic& x1, const generic& x2) {
  return current_ev->apply (GEN_MAX, x1, x2); }
generic abs (const generic& x1) {
  return current_ev->apply (GEN_ABS, x1); }
generic arg (const generic& x1) {
  return current_ev->apply (GEN_ARG, x1); }
generic Re (const generic& x1) {
  return current_ev->apply (GEN_RE, x1); }
generic Im (const generic& x1) {
  return current_ev->apply (GEN_IM, x1); }
generic conj (const generic& x1) {
  return current_ev->apply (GEN_CONJ, x1); }
generic gaussian (const generic& x1, const generic& x2) {
  return x1 + x2 * Imaginary (generic); }
generic polar (const generic& x1, const generic& x2) {
  return x1 * exp (x2 * Imaginary (generic)); }

/******************************************************************************
* Rounding towards nearest integers
******************************************************************************/

generic floor (const generic& x) {
  return current_ev->apply (GEN_FLOOR, x); }
generic trunc (const generic& x) {
  return current_ev->apply (GEN_TRUNC, x); }
generic ceil (const generic& x) {
  return current_ev->apply (GEN_CEIL, x); }
generic round (const generic& x) {
  return current_ev->apply (GEN_ROUND, x); }

/******************************************************************************
* Miscellaneous routines for numerics
******************************************************************************/

generic change_precision (const generic& x, xnat p) {
  return current_ev->apply (GEN_CHANGE_PRECISION, x, as<generic> ((int) p)); }
xnat precision (const generic& x) {
  generic r= current_ev->apply (GEN_PRECISION, x);
  ASSERT (is<int> (r), "Int return value expected");
  return as<int> (r); }
generic next_above (const generic& x) {
  return current_ev->apply (GEN_NEXT_ABOVE, x); }
generic next_below (const generic& x) {
  return current_ev->apply (GEN_NEXT_BELOW, x); }
generic rounding_error (const generic& x) {
  return current_ev->apply (GEN_ROUNDING_ERROR, x); }
generic additive_error (const generic& x) {
  return current_ev->apply (GEN_ADDITIVE_ERROR, x); }
generic multiplicative_error (const generic& x) {
  return current_ev->apply (GEN_MULTIPLICATIVE_ERROR, x); }
generic elementary_error (const generic& x) {
  return current_ev->apply (GEN_ELEMENTARY_ERROR, x); }

xint exponent (const generic& x) {
  generic r= current_ev->apply (GEN_EXPONENT, x);
  ASSERT (is<int> (r), "Int return value expected");
  return as<int> (r); }
double magnitude (const generic& x) {
  generic r= current_ev->apply (GEN_MAGNITUDE, x);
  ASSERT (is<double> (r), "Double return value expected");
  return as<double> (r); }
generic incexp2 (const generic& x1, const xint& x2) {
  return current_ev->apply ("increase_exponent", x1, as<generic> ((int) x2)); }
generic decexp2 (const generic& x1, const xint& x2) {
  return current_ev->apply ("decrease_exponent", x1, as<generic> ((int) x2)); }
generic operator << (const generic& x1, const generic& x2) {
  return current_ev->apply (GEN_LESSLESS, x1, x2); }
generic operator >> (const generic& x1, const generic& x2) {
  return current_ev->apply (GEN_GTRGTR, x1, x2); }

/******************************************************************************
* Analytic continuation
******************************************************************************/

generic sqrt_init (const generic& x1, const generic& x2) {
  return current_ev->apply ("sqrt_init", x1, x2); }
generic log_init (const generic& x1, const generic& x2) {
  return current_ev->apply ("log_init", x1, x2); }
generic acos_init (const generic& x1, const generic& x2) {
  return current_ev->apply ("acos_init", x1, x2); }
generic asin_init (const generic& x1, const generic& x2) {
  return current_ev->apply ("asin_init", x1, x2); }
generic atan_init (const generic& x1, const generic& x2) {
  return current_ev->apply ("atan_init", x1, x2); }
generic integrate_init (const generic& x1, const generic& x2) {
  return current_ev->apply ("integrate_init", x1, x2); }
generic solve_lde_init (const generic& x1, const generic& x2) {
  return current_ev->apply ("solve_lde_init", x1, x2); }

/******************************************************************************
* Ball arithmetic
******************************************************************************/

generic center (const generic& x1) {
  return current_ev->apply ("center", x1); }  
generic radius (const generic& x1) {
  return current_ev->apply ("radius", x1); }
generic sharpen (const generic& x1) {
  return current_ev->apply ("sharpen", x1); }
generic blur (const generic& x1, const generic& x2) {
  return current_ev->apply ("blur", x1, x2); }

/******************************************************************************
* Miscellaneous
******************************************************************************/

generic lshiftz (const generic& x1, const generic& x2) {
  return current_ev->apply ("lshiftz", x1, x2); }
generic rshiftz (const generic& x1, const generic& x2) {
  return current_ev->apply ("rshiftz", x1, x2); }
generic operator | (const generic& x1, const generic& x2) {
  return current_ev->apply (GEN_OR, x1, x2); }
generic operator & (const generic& x1, const generic& x2) {
  return current_ev->apply (GEN_AND, x1, x2); }
generic lres (const generic& x1, const generic& x2) {
  return current_ev->apply ("lres", x1, x2); }
generic rres (const generic& x1, const generic& x2) {
  return current_ev->apply ("rres", x1, x2); }
generic uniform (const generic& x1, const generic& x2) {
  return current_ev->apply ("uniform", x1, x2); }
generic specialize (const generic& x1, const generic& x2) {
  return current_ev->apply ("specialize", x1, x2); }

} // namespace mmx