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

Go to the documentation of this file.

/******************************************************************************
* MODULE     : syntactic.hpp
* DESCRIPTION: Syntactic expressions with basic simplification
* COPYRIGHT  : (C) 2008  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 __SYNTACTIC_HPP
#define __SYNTACTIC_HPP
#include <basix/generic.hpp>


namespace mmx {

/******************************************************************************
* The syntactic wrapper type
******************************************************************************/

class syntactic {
MMX_ALLOCATORS
protected:
  generic rep;
  inline syntactic (const generic& g): rep (g) {}
public:
  inline syntactic (): rep () {}
  inline syntactic (const char* s): rep (s) {}
  inline syntactic (const string& s): rep (s) {}
  syntactic (const int& i);
  inline generic operator * () const { return rep; }
  friend syntactic as_syntactic (const generic& g);
  inline friend nat N (const syntactic& g) { return N (g.rep); }
  inline syntactic operator [] (nat i) const { return syntactic (rep[i]); }
};

template<typename C> syntactic 
generic_concrete_rep<C>::expression () const {
  return flatten (rep); }

/******************************************************************************
* Syntactic routines
******************************************************************************/

inline generic as_generic (const syntactic& g) { return *g; }
inline syntactic as_syntactic (const generic& g) { return syntactic (g); }
inline nat hash (const syntactic& c) { return hash (*c); }
inline nat exact_hash (const syntactic& c) { return exact_hash (*c); }
inline nat hard_hash (const syntactic& c) { return hard_hash (*c); }
inline bool operator == (const syntactic& c1, const syntactic& c2) {
  return (*c1) == (*c2); }
inline bool operator != (const syntactic& c1, const syntactic& c2) {
  return (*c1) != (*c2); }
inline bool exact_eq (const syntactic& c1, const syntactic& c2) {
  return exact_eq (*c1, *c2); }
inline bool exact_neq (const syntactic& c1, const syntactic& c2) {
  return exact_neq (*c1, *c2); }
inline bool hard_eq (const syntactic& c1, const syntactic& c2) {
  return hard_eq (*c1, *c2); }
inline bool hard_neq (const syntactic& c1, const syntactic& c2) {
  return hard_neq (*c1, *c2); }
inline syntactic flatten (const syntactic& g) { return g; }
  
bool is_atom (const syntactic& g);
string as_string (const syntactic& g);

bool is_func (const syntactic& g, const char* f);
bool is_func (const syntactic& g, const char* f, nat n);
bool is_func (const syntactic& g, const syntactic& f);
bool is_func (const syntactic& g, const syntactic& f, nat n);
bool is_func (const syntactic& g, const generic& f);
bool is_func (const syntactic& g, const generic& f, nat n);

syntactic access (const syntactic& g, const syntactic& i);
syntactic access (const syntactic& g, const syntactic& i, const syntactic& j);

vector<syntactic> components (const syntactic& g);
vector<syntactic> arguments (const syntactic& g);

/******************************************************************************
* Syntactic function application
******************************************************************************/

inline syntactic syn (const syntactic& f) {
  return as_syntactic (gen (*f)); }
inline syntactic syn (const syntactic& f, const syntactic& a1) {
  return as_syntactic (gen (*f, *a1)); }
inline syntactic syn (const syntactic& f, const syntactic& a1,
                      const syntactic& a2) {
  return as_syntactic (gen (*f, *a1, *a2)); }
inline syntactic syn (const syntactic& f, const syntactic& a1,
                      const syntactic& a2, const syntactic& a3) {
  return as_syntactic (gen (*f, *a1, *a2, *a3)); }
inline syntactic syn (const syntactic& f,
                      const syntactic& a1, const syntactic& a2,
                      const syntactic& a3, const syntactic& a4) {
  return as_syntactic (gen (*f, *a1, *a2, *a3, *a4)); }
inline syntactic syn (const syntactic& f, const vector<syntactic>& a) {
  const vector<generic>* ptr= (vector<generic>*) ((void*) (&a));
  return as_syntactic (gen (*f, *ptr)); }

inline syntactic syn (const char* f) {
  return as_syntactic (gen (generic (f))); }
inline syntactic syn (const char* f, const syntactic& a1) {
  return as_syntactic (gen (generic (f), *a1)); }
inline syntactic syn (const char* f, const syntactic& a1,
                      const syntactic& a2) {
  return as_syntactic (gen (generic (f), *a1, *a2)); }
inline syntactic syn (const char* f, const syntactic& a1,
                      const syntactic& a2, const syntactic& a3) {
  return as_syntactic (gen (generic (f), *a1, *a2, *a3)); }
inline syntactic syn (const char* f,
                      const syntactic& a1, const syntactic& a2,
                      const syntactic& a3, const syntactic& a4) {
  return as_syntactic (gen (generic (f), *a1, *a2, *a3, *a4)); }
inline syntactic syn (const char* f, const vector<syntactic>& a) {
  const vector<generic>* ptr= (vector<generic>*) ((void*) (&a));
  return as_syntactic (gen (generic (f), *ptr)); }

inline syntactic syn (const generic& f) {
  return as_syntactic (gen (f)); }
inline syntactic syn (const generic& f, const syntactic& a1) {
  return as_syntactic (gen (f, *a1)); }
inline syntactic syn (const generic& f, const syntactic& a1,
                      const syntactic& a2) {
  return as_syntactic (gen (f, *a1, *a2)); }
inline syntactic syn (const generic& f, const syntactic& a1,
                      const syntactic& a2, const syntactic& a3) {
  return as_syntactic (gen (f, *a1, *a2, *a3)); }
inline syntactic syn (const generic& f,
                      const syntactic& a1, const syntactic& a2,
                      const syntactic& a3, const syntactic& a4) {
  return as_syntactic (gen (f, *a1, *a2, *a3, *a4)); }
inline syntactic syn (const generic& f, const vector<syntactic>& a) {
  const vector<generic>* ptr= (vector<generic>*) ((void*) (&a));
  return as_syntactic (gen (f, *ptr)); }

/******************************************************************************
* Semantic function application
******************************************************************************/

syntactic apply (const syntactic& f);
syntactic apply (const syntactic& f, const syntactic& a1);
syntactic apply (const syntactic& f, const syntactic& a1, const syntactic& a2);
syntactic apply (const syntactic& f, const syntactic& a1, const syntactic& a2,
                 const syntactic& a3);
syntactic apply (const syntactic& f, const syntactic& a1, const syntactic& a2,
                 const syntactic& a3, const syntactic& a4);
syntactic apply (const syntactic& f, const syntactic& a1,
                 const syntactic& a2, const syntactic& a3,
                 const syntactic& a4, const syntactic& a5);
syntactic apply (const syntactic& f, const syntactic& a1,
                 const syntactic& a2, const syntactic& a3,
                 const syntactic& a4, const syntactic& a5,
                 const syntactic& a6);
syntactic apply (const syntactic& f, const vector<syntactic>& a);

inline syntactic apply (const char* f) {
  return apply (syntactic (f)); }
inline syntactic apply (const char* f, const syntactic& a1) {
  return apply (syntactic (f), a1); }
inline syntactic apply (const char* f, const syntactic& a1,
                        const syntactic& a2) {
  return apply (syntactic (f), a1, a2); }
inline syntactic apply (const char* f, const syntactic& a1,
                        const syntactic& a2, const syntactic& a3) {
  return apply (syntactic (f), a1, a2, a3); }
inline syntactic apply (const char* f,
                        const syntactic& a1, const syntactic& a2,
                        const syntactic& a3, const syntactic& a4) {
  return apply (syntactic (f), a1, a2, a3, a4); }
inline syntactic apply (const char* f,
                        const syntactic& a1, const syntactic& a2,
                        const syntactic& a3, const syntactic& a4,
                        const syntactic& a5) {
  return apply (syntactic (f), a1, a2, a3, a4, a5); }
inline syntactic apply (const char* f,
                        const syntactic& a1, const syntactic& a2,
                        const syntactic& a3, const syntactic& a4,
                        const syntactic& a5, const syntactic& a6) {
  return apply (syntactic (f), a1, a2, a3, a4, a5, a6); }
inline syntactic apply (const char* f, const vector<syntactic>& a) {
  return apply (syntactic (f), a); }

inline syntactic apply (const generic& f) {
  return apply (as_syntactic (f)); }
inline syntactic apply (const generic& f, const syntactic& a1) {
  return apply (as_syntactic (f), a1); }
inline syntactic apply (const generic& f, const syntactic& a1,
                        const syntactic& a2) {
  return apply (as_syntactic (f), a1, a2); }
inline syntactic apply (const generic& f, const syntactic& a1,
                        const syntactic& a2, const syntactic& a3) {
  return apply (as_syntactic (f), a1, a2, a3); }
inline syntactic apply (const generic& f,
                        const syntactic& a1, const syntactic& a2,
                        const syntactic& a3, const syntactic& a4) {
  return apply (as_syntactic (f), a1, a2, a3, a4); }
inline syntactic apply (const generic& f,
                        const syntactic& a1, const syntactic& a2,
                        const syntactic& a3, const syntactic& a4,
                        const syntactic& a5) {
  return apply (as_syntactic (f), a1, a2, a3, a4, a5); }
inline syntactic apply (const generic& f,
                        const syntactic& a1, const syntactic& a2,
                        const syntactic& a3, const syntactic& a4,
                        const syntactic& a5, const syntactic& a6) {
  return apply (as_syntactic (f), a1, a2, a3, a4, a5, a6); }
inline syntactic apply (const generic& f, const vector<syntactic>& a) {
  return apply (as_syntactic (f), a); }

/******************************************************************************
* Mathematical functions
******************************************************************************/

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

bool set_frac_flag (bool new_val);
syntactic migrate_negate (const syntactic& g, nat maximal);
syntactic operator - (const syntactic& g);
syntactic square (const syntactic& g);
syntactic invert (const syntactic& g);
syntactic operator + (const syntactic& g1, const syntactic& g2);
syntactic operator - (const syntactic& g1, const syntactic& g2);
syntactic operator * (const syntactic& g1, const syntactic& g2);
syntactic operator / (const syntactic& g1, const syntactic& g2);
syntactic gcd (const syntactic& g1, const syntactic& g2);
syntactic lcm (const syntactic& g1, const syntactic& g2);
syntactic xgcd (const syntactic& g1, const syntactic& g2);
syntactic ordered_sum (const vector<syntactic>& v);
syntactic ordered_product (const vector<syntactic>& v);

syntactic sqrt (const syntactic& g);
syntactic exp (const syntactic& g);
syntactic log (const syntactic& g);
syntactic cos (const syntactic& g);
syntactic sin (const syntactic& g);
syntactic tan (const syntactic& g);
syntactic acos (const syntactic& g);
syntactic asin (const syntactic& g);
syntactic atan (const syntactic& g);
syntactic cosh (const syntactic& g);
syntactic sinh (const syntactic& g);
syntactic tanh (const syntactic& g);
syntactic acosh (const syntactic& g);
syntactic asinh (const syntactic& g);
syntactic atanh (const syntactic& g);
syntactic pow (const syntactic& g1, const syntactic& g2);
syntactic pow (const syntactic& g1, const int& g2);
syntactic pow (const int& g1, const syntactic& g2);
syntactic hypot (const syntactic& g1, const syntactic& g2);
syntactic atan2 (const syntactic& g1, const syntactic& g2);
syntactic trig (const syntactic& g);
syntactic Re (const syntactic& g1);
syntactic Im (const syntactic& g1);
syntactic abs (const syntactic& g1);
syntactic arg (const syntactic& g1);
syntactic conj (const syntactic& g1);
syntactic gaussian (const syntactic& g1, const syntactic& g2);
syntactic polar (const syntactic& g1, const syntactic& g2);

syntactic center (const syntactic& g1);
syntactic radius (const syntactic& g1);
syntactic numerator (const syntactic& x);
syntactic denominator (const syntactic& x);

syntactic operator << (const syntactic& x1, const syntactic& x2);
syntactic operator >> (const syntactic& x1, const syntactic& x2);
syntactic lshiftz (const syntactic& g, const syntactic& sh);
syntactic rshiftz (const syntactic& g, const syntactic& sh);
syntactic derive (const syntactic& g);
syntactic derive (const syntactic& g, const syntactic& v);
syntactic xderive (const syntactic& g);
syntactic xderive (const syntactic& g, const syntactic& v);
syntactic integrate (const syntactic& g);
syntactic integrate (const syntactic& g, const syntactic& v);
syntactic sqrt_init (const syntactic& x, const syntactic& c);
syntactic log_init (const syntactic& x, const syntactic& c);
syntactic acos_init (const syntactic& x, const syntactic& c);
syntactic asin_init (const syntactic& x, const syntactic& c);
syntactic atan_init (const syntactic& x, const syntactic& c);
syntactic integrate_init (const syntactic& x, const syntactic& c);
syntactic integrate_init (const syntactic& g, const syntactic& v,
                          const syntactic& c);
syntactic solve_lde_init (const syntactic& x, const syntactic& c);
syntactic inject (const syntactic& x, const syntactic& y, const syntactic& z);
syntactic project (const syntactic& x, const syntactic& y);

/******************************************************************************
* Flattening
******************************************************************************/

extern string as_string (void* ptr);

template<typename C> inline syntactic
flatten (C* const & x) {
  return as_string ((void*) x);
}

syntactic flatten (const bool& b);
syntactic flatten (const char& i);
syntactic flatten (const signed char& i);
syntactic flatten (const unsigned char& i);
syntactic flatten (const short int& i);
syntactic flatten (const short unsigned int& i);
syntactic flatten (const int& i);
syntactic flatten (const unsigned int& i);
syntactic flatten (const long int& i);
syntactic flatten (const long unsigned int& i);
syntactic flatten (const long long int& i);
syntactic flatten (const long long unsigned int& i);
syntactic flatten (const float& x);
syntactic flatten (const double& x);
syntactic flatten (const long double& x);
syntactic flatten (const char* const & s);
syntactic flatten (const string& s);

} // namespace mmx
#endif // __SYNTACTIC_HPP