REP_STRUCT< C, V > Class Template Reference

#include <homotopy.hpp>

List of all members.

Public Member Functions

homotopy_stepper_rep (const slp_tangent< C > &f2)
virtual vector< C > hom (const vector< C > &init, nat k, const C &t1)=0
virtual vector< C > homp (const vector< C > &init, nat k, const vector< C > &p)
virtual vector< vector< C > > homv (const vector< vector< C > > &init, nat k, const C &t1)
virtual vector< vector< C > > homvp (const vector< vector< C > > &init, nat k, const vector< C > &p)
riemann_bundle_rep ()
riemann_bundle_rep (const format< R > &fm)
riemann_bundle_rep (const riemann_surface< R, V > &rs)
riemann_bundle_rep (const riemann_surface< R, V > &rs, const table< vector< Germ >, riemann_square< R, V > > &bun)
void upgrade (const table< bool, riemann_square< R, V > > &ss)
riemann_germ_rep (const polynomial< complex< R > > &p2, const complex< R > &c2, const R &r2)
riemann_square_rep (const complex< R > &c2, const R &r2)
riemann_surface_rep ()
riemann_surface_rep (const format< R > &fm)
bool add (const riemann_square< R, V > &s)
bool add (const table< bool, riemann_square< R, V > > &ss)
bool connect (const riemann_square< R, V > &s1, const riemann_square< R, V > &s2)
bool connect (const table< table< bool, riemann_square< R, V > >, riemann_square< R, V > > &t)
bool plane_connect (const table< bool, riemann_square< R, V > > &ss)
bool glue (const riemann_square< R, V > &s1, const riemann_square< R, V > &s2)
table< bool, riemann_square< R,
V > > owners (const riemann_square< R, V > &s, const complex< R > &p) const
void normalize ()
void clean ()
riemann_square< R, V > upgrade (const riemann_square< R, V > &s)
riemann_point< R, V > follow (const riemann_square< R, V > &orig, const complex< R > &from, const complex< R > &to) const
riemann_point< R, V > move (const riemann_point< R, V > &p, const complex< R > &delta) const

Public Attributes

slp_tangent< C > f
riemann_surface< R, V > surface
table< vector< Germ >
, riemann_square< R, V > > bundle
polynomial< complex< R > > p
complex< R > c
R r
double serial
table< bool, riemann_square< R,
V > > squares
table< table< bool,
riemann_square< R, V >
>, riemann_square< R, V > > neighbours
table< bool, riemann_square< R,
V > > invalid
table< bool, riemann_square< R,
V > > replaced
table< riemann_square< R, V >
, riemann_square< R, V > > upgrades

Detailed Description

template<typename C, typename V>
class mmx::REP_STRUCT< C, V >

Definition at line 33 of file homotopy.hpp.

Member Function Documentation

bool add ( const table< bool, riemann_square< R, V > > & ss )

bool add ( const riemann_square< R, V > & s )

void clean ( )

bool connect ( const table< table< bool, riemann_square< R, V > >, riemann_square< R, V > > & t )

bool connect	(	const riemann_square< R, V > &	s1,
		const riemann_square< R, V > &	s2
	)

riemann_point<R,V> follow	(	const riemann_square< R, V > &	orig,
		const complex< R > &	from,
		const complex< R > &	to
	)			const

bool glue	(	const riemann_square< R, V > &	s1,
		const riemann_square< R, V > &	s2
	)

virtual vector<C> hom	(	const vector< C > &	init,
		nat	k,
		const C &	t1
	)			`[pure virtual]`

homotopy_stepper_rep ( const slp_tangent< C > & f2 ) [inline]

Definition at line 37 of file homotopy.hpp.

00037 : f (f2) {}

virtual vector<C> homp	(	const vector< C > &	init,
		nat	k,
		const vector< C > &	p
	)			`[inline, virtual]`

Definition at line 43 of file homotopy.hpp.

References mmx::Abs_type(), mmx::C, mmx::R, mmx::sqrt(), and mmx::start_index().

00043                                                           {
00044     //mmerr << "From x = " << init << " via x[" << k << "] = " << p
00045     //<< " [base stepper]" << "\n";
00046     typedef Abs_type(C) R;
00047     R eps= sqrt (sqrt (Accuracy (R)));
00048     vector<C> v= init;
00049     for (nat i= start_index (p, init[k]); i<N(p); i++) {
00050       v= hom (v, k, p[i]);
00051       if (abs (v[k] - p[i]) >= eps) break;
00052     }
00053     return v;
00054   }

virtual vector<vector<C> > homv	(	const vector< vector< C > > &	init,
		nat	k,
		const C &	t1
	)			`[inline, virtual]`

Definition at line 57 of file homotopy.hpp.

References mmx::CF().

00057                                                             {
00058     //mmerr << "From x = " << init << " to x[" << k << "] = " << t1
00059     //<< " [base stepper]" << "\n";
00060     nat n= N(init);
00061     if (n == 0) return init;
00062     for (nat i=1; i<n; i++)
00063       if (init[i][k] != init[0][k]) {
00064         vector<vector<C> > fin= fill<vector<C> > (n, CF(init));
00065         for (nat j=0; j<n; j++)
00066           fin[j]= hom (init[j], k, t1);
00067         return fin;
00068       }
00069     return homvp (init, k, vec<C> (init[0][k], t1));
00070   }

virtual vector<vector<C> > homvp	(	const vector< vector< C > > &	init,
		nat	k,
		const vector< C > &	p
	)			`[inline, virtual]`

Definition at line 73 of file homotopy.hpp.

References mmx::CF().

00073                                                                     {
00074     //mmerr << "From x = " << init << " via x[" << k << "] = " << p
00075     //<< " [base stepper]" << "\n";
00076     nat n= N(init);
00077     vector<vector<C> > fin= fill<vector<C> > (n, CF(init));
00078     for (nat i=0; i<n; i++)
00079       fin[i]= homp (init[i], k, p);
00080     return fin;
00081   }

riemann_point<R,V> move	(	const riemann_point< R, V > &	p,
		const complex< R > &	delta
	)			const

void normalize ( )

table<bool, riemann_square<R,V> > owners	(	const riemann_square< R, V > &	s,
		const complex< R > &	p
	)			const

bool plane_connect ( const table< bool, riemann_square< R, V > > & ss )

riemann_bundle_rep	(	const riemann_surface< R, V > &	rs,
		const table< vector< Germ >, riemann_square< R, V > > &	bun
	)			`[inline]`

Definition at line 73 of file riemann_bundle.hpp.

00073                                                                  :
00074     surface (rs), bundle (bun) {}
  void upgrade (const Squares& ss);

riemann_bundle_rep ( const riemann_surface< R, V > & rs ) [inline]

Definition at line 70 of file riemann_bundle.hpp.

00070                                                :
00071     surface (rs), bundle (vector<Germ > (format<Germ > (CF(rs))),
00072                           format<Square > (CF(rs))) {}
  inline riemann_bundle_rep (const Surface& rs, const Table& bun):

riemann_bundle_rep ( const format< R > & fm ) [inline]

Definition at line 67 of file riemann_bundle.hpp.

00067                                                  :
00068     surface (fm), bundle (format<vector<Germ > > (format<Germ > (fm)),
00069                           format<Square > (fm)) {}
  inline riemann_bundle_rep (const Surface& rs):

riemann_bundle_rep ( ) [inline]

Definition at line 66 of file riemann_bundle.hpp.

00066 {}

riemann_germ_rep	(	const polynomial< complex< R > > &	p2,
		const complex< R > &	c2,
		const R &	r2
	)			`[inline]`

Definition at line 36 of file riemann_germ.hpp.

00036                                                                               :
00037     p (p2), c (c2), r (r2) {}
};

riemann_square_rep	(	const complex< R > &	c2,
		const R &	r2
	)			`[inline]`

Definition at line 40 of file riemann_square.hpp.

00040                                                       :
00041     c (c2), r (r2), serial (next_serial++) {}
};

riemann_surface_rep ( const format< R > & fm ) [inline]

Definition at line 44 of file riemann_surface.hpp.

00044                                                   :
00045     squares (false, format<Square > (fm)),
00046     neighbours (Squares (false, format<Square > (fm)), format<Square > (fm)),
00047     invalid (false, format<Square > (fm)),
00048     replaced (false, format<Square > (fm)),
00049     upgrades (format<Square > (fm), format<Square > (fm)) {}
  bool add (const Square& s);