include/continewz/riemann_point.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : riemann_point.hpp
* DESCRIPTION: points on Riemann surfaces
* 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 __MMX_RIEMANN_POINT_HPP
#define __MMX_RIEMANN_POINT_HPP
#include <continewz/riemann_square.hpp>

namespace mmx {
#define TMPL_DEF template<typename R,typename V= std_riemann>
#define TMPL template<typename R,typename V>
#define C complex<R>
#define Square riemann_square<R,V>
#define Point riemann_point<R,V>

/******************************************************************************
* Points on Riemann surfaces
******************************************************************************/

TMPL_DEF
class riemann_point {
MMX_ALLOCATORS;
public:
  Square s;
  C      z;
  inline riemann_point () {}
  inline riemann_point (const format<R>& fm): s (fm), z (promote (0, fm)) {}
  inline riemann_point (const Square& s2, const C& z2): s (s2), z (z2) {}
};
DEFINE_UNARY_FORMAT_2 (riemann_point)

TMPL inline Square owner (const Point& p) { return p.s; }
TMPL inline C project (const Point& p) { return p.z; }
TMPL inline format<R> CF (const Point& p) { return CF (owner (p)); }

/******************************************************************************
* Required routines
******************************************************************************/

template<typename Op, typename R, typename V> nat
unary_hash (const Point& p) {
  nat h= Op::op (p.s);
  return (h<<1) ^ (h<<3) ^ (h<<9) ^ (h>>29) ^ Op::op (p.z);
}

template<typename Op, typename R, typename V> bool
binary_test (const Point& p1, const Point& p2) {
  return Op::op (p1.s, p2.s) && Op::op (p1.z, p2.z);
}

TRUE_IDENTITY_OP_SUGAR(TMPL,Point)
EXACT_IDENTITY_OP_SUGAR(TMPL,Point)
HARD_IDENTITY_OP_SUGAR(TMPL,Point)

TMPL inline syntactic
flatten (const Point& p) {
  return apply ("point", flatten (p.z), flatten (p.s));
}

TMPL
struct binary_helper<Point >: public void_binary_helper<Point > {
  static inline string short_type_name () {
    return "Rpnt" * Short_type_name (R); }
  static inline generic full_type_name () {
    return gen ("Riemann_point", Full_type_name (R)); }
  static inline generic disassemble (const Point& p) {
    return gen_vec (as<generic> (owner (p)),
                    as<generic> (project (p))); }
  static inline Point assemble (const generic& v) {
    return Point (as<Square > (vector_access (v, 0)),
                  as<C > (vector_access (v, 1))); }
  static inline void write (const port& out, const Point& p) {
    binary_write<Square > (out, owner (p));
    binary_write<C > (out, project (p)); }
  static inline Point read (const port& in) {
    Square o= binary_read<Square > (in);
    C p= binary_read<C > (in);
    return Point (o, p); }
};

#undef TMPL_DEF
#undef TMPL
#undef C
#undef Square
#undef Point
} // namespace mmx
#endif // __MMX_RIEMANN_POINT_HPP

---