include/continewz/riemann_germ.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : riemann_germ.hpp
* DESCRIPTION: germ building blocks for digital 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_GERM_HPP
#define __MMX_RIEMANN_GERM_HPP
#include <analyziz/polynomial_double.hpp>

namespace mmx {
class std_germ {};
#define TMPL_DEF template<typename R,typename V= std_germ>
#define TMPL template<typename R,typename V>
#define C complex<R>
#define Germ riemann_germ<R,V>
#define Germ_rep riemann_germ_rep<R,V>

/******************************************************************************
* Germ neighbourhoods on Riemann surfaces
******************************************************************************/

TMPL_DEF
class riemann_germ_rep REP_STRUCT {
public:
  polynomial<C > p;
  C c;
  R r;
public:
  inline riemann_germ_rep (const polynomial<C >& p2, const C& c2, const R& r2):
    p (p2), c (c2), r (r2) {}
};

TMPL_DEF
class riemann_germ {
INDIRECT_PROTO_2 (riemann_germ, riemann_germ_rep, R, V)
public:
  inline riemann_germ ():
    rep (new Germ_rep (polynomial<C > (), C (), R ())) {}
  inline riemann_germ (const format<R>& fm):
    rep (new Germ_rep (polynomial<C > (C (promote (0, fm))),
                       C (promote (0, fm)), promote (0, fm))) {}
  inline riemann_germ (const polynomial<C >& p, const C& c, const R& r):
    rep (new Germ_rep (p, c, r)) {}
};
INDIRECT_IMPL_2 (riemann_germ, riemann_germ_rep,
                 typename R, R, typename V, V)
DEFINE_UNARY_FORMAT_2 (riemann_germ)

TMPL inline C center (const Germ& g) { return g->c; }
TMPL inline R radius (const Germ& g) { return g->r; }
TMPL inline format<R> CF (const Germ& g) {
  return get_format (radius (g)); }
TMPL inline C eval (const Germ& g, const C& z) {
  return eval (g->p, z - g->c); }
TMPL inline bool inside (const C& z, const Germ& g) {
  return abs (z - g->c) < g->r; }
TMPL inline bool better (const C& z, const Germ& g1, const Germ& g2) {
  return abs (z - g1->c) < abs (z - g2->c); }

/******************************************************************************
* Required functions
******************************************************************************/

template<typename Op, typename R, typename V> nat
unary_hash (const Germ& s) {
  return hard_hash (s);
}

template<typename Op, typename R, typename V> bool
binary_test (const Germ& s1, const Germ& s2) {
  return hard_eq (s1, s2);
}

TRUE_IDENTITY_OP_SUGAR(TMPL,Germ)
EXACT_IDENTITY_OP_SUGAR(TMPL,Germ)

TMPL syntactic
flatten (const Germ& g) {
  return apply ("germ", flatten (g->p), flatten (g->c), flatten (g->r));
}

TMPL
struct binary_helper<Germ >: public void_binary_helper<Germ > {
  static inline string short_type_name () {
    return "Rger" * Short_type_name (R); }
  static inline generic full_type_name () {
    return gen ("Riemann_germ", Full_type_name (R)); }
  static inline generic disassemble (const Germ& g) {
    return gen_vec (as<generic> (g->p),
                    as<generic> (center (g)),
                    as<generic> (radius (g))); }
  static inline Germ assemble (const generic& v) {
    return Germ (as<polynomial<C> > (vector_access (v, 0)),
                 as<C > (vector_access (v, 1)),
                 as<R > (vector_access (v, 2))); }
  static inline void write (const port& out, const Germ& g) {
    binary_write<polynomial<C > > (out, g->p);
    binary_write<C > (out, center (g));
    binary_write<R > (out, radius (g)); }
  static inline Germ read (const port& in) {
    polynomial<C > p= binary_read<polynomial<C> > (in);
    C c= binary_read<C > (in);
    R r= binary_read<R > (in);
    return Germ (p, c, r); }
};

#undef TMPL_DEF
#undef TMPL
#undef C
#undef Germ
#undef Germ_rep
} // namespace mmx
#endif // __MMX_RIEMANN_GERM_HPP

---