mmx Namespace Reference

Classes

Typedefs

Functions

Variables

Typedef Documentation

typedef long long unsigned int llnat

Definition at line 46 of file analytic.hpp.

Function Documentation

Abs_type ( C   )  const [inline]
V Abs_type ( typename unvectorize< C >::val   )  [inline]
Type Constraints

Definition at line 597 of file analytic.hpp.

References default_order().

00597                                                  {
00598   return upper_bound (f, r, default_order (f));
00599 }

V Abs_type ( C   )  const [inline]

Referenced by REP_STRUCT< C, V >::homp(), and mul_bound().

list<C> mmx::absolute_to_delta ( const list< C > &  l,
const C &  pos = C(0) 
) [inline]

Definition at line 259 of file analytic_matrix.hpp.

00259                                                          {
00260   if (is_nil (l)) return l;
00261   else return cons (car (l) - pos, absolute_to_delta (cdr (l), car (l)));
00262 }

analytic< C, V > access ( const analytic< vector< C >, V > &  f,
nat  i 
) [inline]

Definition at line 93 of file analytic_vector.hpp.

References Analytic_rep, and f.

00093                                                {
00094   return (Analytic_rep*) new vector_access_analytic_rep<C,V> (f, i);
00095 }

analytic< C, V > access ( const analytic< matrix< C >, V > &  f,
nat  i,
nat  j 
) [inline]

Definition at line 102 of file analytic_matrix.hpp.

References Analytic_rep, and f.

Referenced by as_matrix(), as_vector(), vector_access_analytic_rep< C, V >::Derive(), matrix_access_analytic_rep< C, V >::Derive(), vector_access_analytic_rep< C, V >::Expand(), matrix_access_analytic_rep< C, V >::Expand(), head_extremum(), vector_access_analytic_rep< C, V >::Move(), and matrix_access_analytic_rep< C, V >::Move().

00102                                                       {
00103   return (Analytic_rep*) new matrix_access_analytic_rep<C,V> (f, i, j);
00104 }

analytic< C, V > acos ( const analytic< C, V > &  f  )  [inline]

Definition at line 1521 of file analytic.hpp.

Referenced by GLUE_43().

01521                          {
01522   return unary_recursive_analytic<acos_op> (f);
01523 }

analytic<C,V> mmx::acos_init ( const analytic< C, V > &  f,
const C &  c 
) [inline]

Definition at line 1526 of file analytic.hpp.

01526                                           {
01527   return unary_recursive_analytic<acos_op> (f, c);
01528 }

bool mmx::adjacent ( const riemann_square< R, V > &  s1,
const riemann_square< R, V > &  s2 
) [inline]

Definition at line 145 of file riemann_square.hpp.

References center(), R, and radius().

Referenced by GLUE_5(), and is_plane().

00145                                               {
00146   R d= radius (s1) + radius (s2);
00147   return
00148     (abs (Re (center (s1)) - Re (center (s2))) == d &&
00149      abs (Im (center (s1)) - Im (center (s2))) < d) ||
00150     (abs (Re (center (s1)) - Re (center (s2))) < d &&
00151      abs (Im (center (s1)) - Im (center (s2))) == d);
00152 }

bool mmx::admissible ( const riemann_square< R, V > &  s  )  [inline]

Definition at line 119 of file riemann_square.hpp.

References C, center(), R, and radius().

Referenced by digital_disk_sub(), and GLUE_2().

00119                              {
00120   R r= radius (s);
00121   C z= center (s) / r;
00122   R I= promote (1, r);
00123   R Z= promote (2, r);
00124   R x= Re(z) - Z * floor (Re (z) / Z);
00125   R y= Im(z) - Z * floor (Im (z) / Z);
00126   return x == I && y == I;
00127 }

analytic<Complex_type(Real) > mmx::analytic_complex ( const vector< Real > &  v  )  [inline]

Definition at line 1019 of file analytic.hpp.

Referenced by GLUE_1(), and GLUE_3().

01019                                          {
01020   return analytic<Complex_type(Real) > (as<vector<Complex_type(Real) > > (v));
01021 }

mmx::ARITH_SCALAR_INT_SUGAR ( template< typename C, typename V >  ,
analytic< C, V >   
)
analytic< vector< C >, V > as_analytic ( const vector< analytic< C, V > > &  v  )  [inline]

Definition at line 160 of file analytic_vector.hpp.

References V.

00160                                          {
00161   return (analytic_rep<vector<C>,V>*) new vector_analytic_rep<C,V> (v);
00162 }

analytic< matrix< C >, V > as_analytic ( const matrix< analytic< C, V > > &  m  )  [inline]

Definition at line 178 of file analytic_matrix.hpp.

References V.

Referenced by cos_sin(), vector_analytic_rep< C, V >::Derive(), matrix_analytic_rep< C, V >::Derive(), vector_analytic_rep< C, V >::Move(), matrix_analytic_rep< C, V >::Move(), solve_lde(), and solve_lde_init().

00178                                          {
00179   return (analytic_rep<matrix<C>,V>*) new matrix_analytic_rep<C,V> (m);
00180 }

matrix< analytic< C, V > > as_matrix ( const analytic< matrix< C >, V > &  f  )  [inline]

Definition at line 107 of file analytic_matrix.hpp.

References access(), Analytic, CF(), and f.

Referenced by solve_lde(), and solve_lde_init().

00107                                            {
00108   nat nr= rows (f[0]), nc= cols (f[0]);
00109   matrix<Analytic > m (Analytic (0, get_format1 (CF(f))), nr, nc);
00110   for (nat i=0; i<nr; i++)
00111     for (nat j=0; j<nc; j++)
00112       m (i, j)= access (f, i, j);
00113   return m;
00114 }

multivariate< sparse_polynomial< modular< modulus< C >, modular_local > > > as_mv_polynomial_modular ( const multivariate< sparse_polynomial< C > > &  f,
const modulus< C > &  p 
) [inline]

Definition at line 152 of file glue_ode_taylor_floating.cpp.

00152                                                                             {
00153     modular<modulus<C>, modular_local>::set_modulus (p);
00154     return as<Polynomial> (f); }

polynomial< modular< modulus< C >, modular_local > > as_polynomial_modular ( const polynomial< C > &  f,
const modulus< C > &  p 
) [inline]

Definition at line 53 of file glue_riemann_double.cpp.

00053                                                                         {
00054       modular<modulus<C>, modular_local>::set_modulus (p);
00055       return as<polynomial<modular<modulus<C>, modular_local> > > (f); }

vector< analytic< C, V > > as_vector ( const analytic< vector< C >, V > &  f  )  [inline]

Definition at line 98 of file analytic_vector.hpp.

References access(), Analytic, CF(), and f.

Referenced by cos_sin(), fixed_point_vector_analytic_rep< C >::Equation(), fixed_point_vector_analytic(), GLUE_1(), GLUE_2(), GLUE_3(), GLUE_4(), solve_ode_series_rep< C >::initialize(), solve_lde_init(), and solve_ode().

00098                                            {
00099   nat n= N(f[0]);
00100   vector<Analytic > v (Analytic (0, get_format1 (CF(f))), n);
00101   for (nat i=0; i<n; i++)
00102     v[i]= access (f, i);
00103   return v;
00104 }

analytic< C, V > asin ( const analytic< C, V > &  f  )  [inline]

Definition at line 1531 of file analytic.hpp.

Referenced by GLUE_44().

01531                          {
01532   return unary_recursive_analytic<asin_op> (f);
01533 }

analytic<C,V> mmx::asin_init ( const analytic< C, V > &  f,
const C &  c 
) [inline]

Definition at line 1536 of file analytic.hpp.

01536                                           {
01537   return unary_recursive_analytic<asin_op> (f, c);
01538 }

analytic< C, V > atan ( const analytic< C, V > &  f  )  [inline]

Definition at line 1541 of file analytic.hpp.

Referenced by GLUE_45().

01541                          {
01542   return unary_recursive_analytic<atan_op> (f);
01543 }

analytic<C,V> mmx::atan_init ( const analytic< C, V > &  f,
const C &  c 
) [inline]

Definition at line 1546 of file analytic.hpp.

01546                                           {
01547   return unary_recursive_analytic<atan_op> (f, c);
01548 }

bool mmx::better ( const complex< R > &  z,
const riemann_germ< R, V > &  g1,
const riemann_germ< R, V > &  g2 
) [inline]

Definition at line 64 of file riemann_germ.hpp.

00064                                                                      {
00065   return abs (z - g1->c) < abs (z - g2->c); }

bool mmx::better ( const P &  p,
const Germ &  g1,
const Germ &  g2 
) [inline]

Definition at line 37 of file riemann_bundle.hpp.

References inside().

Referenced by germ().

00037                                                     {
00038   return inside (p, g1);
00039 }

C mmx::big_max ( const C &  x  )  [inline]

Definition at line 623 of file analytic.hpp.

00623                      {
00624   return x;
00625 }

analytic<C,V> mmx::binary_analytic ( const analytic< C, V > &  f,
const analytic< C, V > &  g 
) [inline]

Definition at line 1152 of file analytic.hpp.

References Analytic_rep.

01152                                                        {
01153   return (Analytic_rep*) new binary_analytic_rep<Op,C,V> (f, g);
01154 }

analytic<C,V> mmx::binary_recursive_analytic ( const analytic< C, V > &  f,
const analytic< C, V > &  g 
) [inline]

Definition at line 1184 of file analytic.hpp.

References recursive().

01184                                                                  {
01185   return recursive (new binary_recursive_analytic_rep<Op,C,V> (f, g));
01186 }

analytic<C,V> mmx::binary_scalar_analytic ( const analytic< C, V > &  f,
const X &  x 
) [inline]

Definition at line 1210 of file analytic.hpp.

References Analytic_rep.

01210                                                        {
01211   return (Analytic_rep*) new binary_scalar_analytic_rep<Op,C,V,X> (f, x);
01212 }

bool mmx::binary_test ( const riemann_surface< R, V > &  rs1,
const riemann_surface< R, V > &  rs2 
) [inline]

Definition at line 88 of file riemann_surface.hpp.

00088                                                      {
00089   return hard_eq (rs1, rs2);
00090 }

bool mmx::binary_test ( const riemann_square< R, V > &  s1,
const riemann_square< R, V > &  s2 
) [inline]

Definition at line 81 of file riemann_square.hpp.

00081                                                  {
00082   return hard_eq (s1, s2);
00083 }

bool mmx::binary_test ( const riemann_point< R, V > &  p1,
const riemann_point< R, V > &  p2 
) [inline]

Definition at line 55 of file riemann_point.hpp.

00055                                                {
00056   return Op::op (p1.s, p2.s) && Op::op (p1.z, p2.z);
00057 }

bool mmx::binary_test ( const riemann_germ< R, V > &  s1,
const riemann_germ< R, V > &  s2 
) [inline]

Definition at line 77 of file riemann_germ.hpp.

00077                                              {
00078   return hard_eq (s1, s2);
00079 }

bool mmx::binary_test ( const riemann_bundle< Germ, R, V > &  b1,
const riemann_bundle< Germ, R, V > &  b2 
) [inline]

Definition at line 114 of file riemann_bundle.hpp.

00114                                                  {
00115   return hard_eq (b1, b2);
00116 }

riemann_surface<R,V> mmx::bundle_surface ( const riemann_bundle< Germ, R, V > &  b  )  [inline]

Definition at line 226 of file riemann_bundle.hpp.

Referenced by GLUE_20().

00226                                                      { // for glue
00227   return b->surface; }

analytic< C, V > cache_last ( const analytic< C, V > &  f  )  [inline]

Definition at line 179 of file analytic_meta.hpp.

References Analytic_rep.

Referenced by cache_last_analytic_rep< C, V >::Derive(), GLUE_5(), GLUE_8(), cache_last_analytic_rep< C, V >::Move(), radial(), and cache_last_analytic_rep< C, V >::Set_next().

00179                                {
00180   // cache_last (f) returns the same analytic functions as f,
00181   // but with special optimizations for accelerating continuation
00182   // along several slightly different paths
00183   return (Analytic_rep*) new cache_last_analytic_rep<C,V> (f);
00184 }

complex<R> mmx::center ( const riemann_square< R, V > &  s  )  [inline]

Definition at line 60 of file riemann_square.hpp.

00060 { return s->c; }

V complex<R> mmx::center ( const riemann_germ< R, V > &  g  )  [inline]

Definition at line 56 of file riemann_germ.hpp.

Referenced by adjacent(), admissible(), homotopy_stepper_rep< ball< C >, homotopy_ball >::certify_tube(), corners(), binary_helper< riemann_square< R, V > >::disassemble(), binary_helper< riemann_germ< R, V > >::disassemble(), flatten(), GLUE_15(), homotopy_stepper_rep< ball< C >, homotopy_ball >::hom(), homotopy_stepper_rep< ball< C >, homotopy_post_certify< V, W > >::homvp(), included(), inside(), intersect(), binary_helper< riemann_square< R, V > >::write(), and binary_helper< riemann_germ< R, V > >::write().

00056 { return g->c; }

V format<R> mmx::CF ( const riemann_surface< R, V > &  rs  )  [inline]

Definition at line 75 of file riemann_surface.hpp.

00075                                              {
00076   return get_format1 (CF2 (rs->squares)); }

format<R> mmx::CF ( const riemann_square< R, V > &  s  )  [inline]

Definition at line 63 of file riemann_square.hpp.

References radius().

00063 { return get_format (radius (s)); }

format<R> mmx::CF ( const riemann_point< R, V > &  p  )  [inline]

Definition at line 42 of file riemann_point.hpp.

References CF(), and owner().

00042 { return CF (owner (p)); }

format<R> mmx::CF ( const riemann_germ< R, V > &  g  )  [inline]

Definition at line 58 of file riemann_germ.hpp.

References radius().

00058                                          {
00059   return get_format (radius (g)); }

V format<R> mmx::CF ( const riemann_bundle< Germ, R, V > &  b  )  [inline]
Type Constraints

Definition at line 101 of file riemann_bundle.hpp.

00101                                            {
00102   return CF (b->surface); }

format<C> mmx::CF ( const analytic< C, V > &  f  )  [inline]

Definition at line 227 of file analytic.hpp.

Referenced by as_matrix(), as_vector(), CF(), coherence(), compose(), first_variation_series(), homotopy(), REP_STRUCT< C, V >::homv(), REP_STRUCT< C, V >::homvp(), integrate(), lift(), solve_ode_series(), and binary_helper< riemann_surface< R, V > >::write().

00227 { return f->tfm (); }

list<C> mmx::circle_path ( const C &  start,
const C &  center,
int  orient = 1,
nat  steps = 17 
) [inline]

Definition at line 243 of file analytic_matrix.hpp.

References C, and exp().

00243                                                                             {
00244   list<C> r;
00245   for (int i=0; ((nat) i)<steps; i++) {
00246     C z= exp ((C(-orient*2*i) * Pi(C) * Imaginary(C)) / C(steps));
00247     r= cons (center + z * (start - center), r);
00248   }
00249   return r;
00250 }

void mmx::clear_cache ( const analytic< C, V > &  f,
nat  which 
) [inline]

Definition at line 347 of file analytic.hpp.

References inside().

Referenced by vector_analytic_rep< C, V >::Clear_cache(), vector_access_analytic_rep< C, V >::Clear_cache(), rough_analytic_rep< C, V >::Clear_cache(), cache_last_analytic_rep< C, V >::Clear_cache(), fast_eval_analytic_rep< C, V >::Clear_cache(), matrix_analytic_rep< C, V >::Clear_cache(), matrix_access_analytic_rep< C, V >::Clear_cache(), reverse_analytic_rep< C, V >::Clear_cache(), compose_analytic_rep< C, V >::Clear_cache(), integrate_analytic_rep< C, V >::Clear_cache(), lshiftz_analytic_rep< C, V >::Clear_cache(), binary_scalar_analytic_rep< rmul_op, C, V, C >::Clear_cache(), binary_recursive_analytic_rep< Op, C, V >::Clear_cache(), binary_analytic_rep< mul_op, C, V >::Clear_cache(), unary_recursive_analytic_rep< Op, C, V >::Clear_cache(), unary_analytic_rep< neg_op, C, V >::Clear_cache(), and recursive_analytic_rep< vector< C > >::Clear_cache().

00347                                            {
00348   if (f->cache != NULL) inside (f) -> Clear_cache (which);
00349 }

xnat mmx::coherence ( const F &  f,
const vector< C > &  x,
const vector< C > &  y,
const matrix< C > &  J,
nat  k,
const vector< C > &  dd 
) [inline]

Definition at line 70 of file homotopy_euler.hpp.

References C, CF(), coherence(), eval(), and range().

00071                                                            {
00072   xnat p= precision (promote (1, CF(x))) >> 1;
00073   while (true) {
00074     C eta= decexp2 (promote (1, CF(x)), (xint) p);
00075     vector<C> dx =
00076       eta * append (range (dd, 0, k),
00077                     cons (promote (0, eta), range (dd, k, N(dd))));
00078     vector<C> x2 = x + dx;
00079     //mmerr << "x  = " << x << "\n";
00080     //mmerr << "x2 = " << x2 << "\n";
00081     //mmerr << "dx = " << dx << "\n";
00082     vector<C> df1= J * dx;
00083     vector<C> y2 = eval (f, x2);
00084     //mmerr << "y  = " << y << "\n";
00085     //mmerr << "y2 = " << y2 << "\n";
00086     vector<C> df2= y2 - y;
00087     //mmerr << "dy1= " << df1 << "\n";
00088     //mmerr << "dy2= " << df2 << "\n";
00089     xnat q= coherence (df1, df2, p);
00090     //mmerr << "Coherence= " << q << "\n";
00091     if (q >= (p >> 1) || p <= 10) { p= q; break; }
00092     p= p >> 1;
00093   }
00094   //mmerr << "Coherence= " << p << "\n";
00095   return p;
00096 }

xnat mmx::coherence ( const vector< C > &  v1,
const vector< C > &  v2,
xnat  p 
) [inline]

Definition at line 58 of file homotopy_euler.hpp.

Referenced by coherence(), homotopy_stepper_rep< C, homotopy_euler >::newton_step(), and homotopy_stepper_rep< ball< C >, homotopy_ball >::propose_tube().

00058                                                              {
00059   nat n= N (v1);
00060   for (nat i=0; i<n; i++) {
00061     if (v1[i] == 0) return 0;
00062     if (v1[i] == v2[i]) continue;
00063     xint e= exponent (v1[i] / (v1[i] - v2[i]));
00064     p= min (p, (xnat) max (e, (xint) 0));
00065   }
00066   return p;
00067 }

polynomial<C> mmx::compose ( const polynomial< C > &  p,
const analytic< C > &  post 
) [inline]

Definition at line 42 of file analytic_heuristic.hpp.

References CF(), mmx_order_ratio, order, range(), and truncate().

00042                                                           {
00043   nat prec = precision (promote (0, CF(p)));
00044   nat order= (nat) (mmx_order_ratio * ((double) prec));
00045   nat n= max (N(p), order);
00046   polynomial<C> q= truncate (post, n);
00047   polynomial<C> r= promote (0, CF(p));
00048   for (int i= n-1; i>=0; i--) {
00049     polynomial<C> s= q * r;
00050     r= range (s, 0, min (n, N(s))) + polynomial<C> (p[i]);
00051   }
00052   return r;
00053 }

analytic< C, V > compose ( const analytic< C, V > &  f,
const analytic< C, V > &  g 
) [inline]
Type Constraints

Definition at line 1588 of file analytic.hpp.

References Analytic_rep.

Referenced by reverse_analytic_rep< C, V >::Derive(), compose_analytic_rep< C, V >::Derive(), heuristic_analytic_rep< C, V >::Expand(), compose_analytic_rep< C, V >::Expand(), GLUE_34(), heuristic_analytic_rep< C, V >::Move(), and compose_analytic_rep< C, V >::Move().

01588                                                {
01589   return (Analytic_rep*) new compose_analytic_rep<C,V> (f, g);
01590 }

matrix<C> mmx::connection_matrix ( const matrix< analytic< C, V > > &  m,
const list< C > &  p 
) [inline]

Definition at line 271 of file analytic_matrix.hpp.

References C, eval(), move(), range(), and solve_lde().

00271                                                                  {
00272   nat n= N(p);
00273   if (n <= 1) {
00274     ASSERT (is_square_matrix (m), "square matrix expected");
00275     if (n == 0) return matrix<C> (C(1), rows (m), cols (m));
00276     else return eval (solve_lde (m), car (p));
00277   }
00278   else {
00279     list<C> p1= range (p, 0, n>>1);
00280     list<C> p2= range (p, n>>1, n);
00281     matrix<C> r1= connection_matrix (m, p1);
00282     matrix<C> r2= connection_matrix (move (m, p1), p2);
00283     return r2 * r1;
00284   }
00285 }

vector< complex<R> > mmx::corners ( const riemann_square< R, V > &  s  )  [inline]

Definition at line 66 of file riemann_square.hpp.

References C, center(), R, and radius().

Referenced by digital_disk_sub().

00066                           {
00067   R r= radius (s);
00068   return center (s) + vec<C > (C (r, r), C (r, -r), C (-r, r), C (-r, -r));
00069 }

analytic< C, V > cos ( const analytic< C, V > &  f  )  [inline]

Definition at line 184 of file analytic_vector.hpp.

Referenced by GLUE_40().

00184                         {
00185   return unary_recursive_analytic<cos_op> (f);
00186 }

vector< analytic< C, V > > cos_sin ( const analytic< C, V > &  f  )  [inline]

Definition at line 179 of file analytic_vector.hpp.

References as_analytic(), as_vector(), and trig().

00179                             {
00180   return as_vector (trig (as_analytic (vec (f))));
00181 }

C mmx::default_eval ( const analytic< C, V > &  f2,
const list< typename unvectorize< C >::val > &  l2 
) [inline]

Definition at line 813 of file analytic.hpp.

References Analytic, g, move(), Radius, shrink(), and simplify().

00813                                                            {
00814   Analytic f= f2;
00815   list<Scalar > l= l2;
00816   while (!is_nil (l)) {
00817     Radius r= shrink (radius_bound (f));
00818     l= simplify (l, r);
00819     Analytic g= move (f, car (l));
00820     //clear_cache (f, CACHE_MOVE);
00821     f= g;
00822     l= cdr (l);
00823   }
00824   return f[0];
00825 }

C mmx::default_eval ( const analytic< C, V > &  f,
const typename unvectorize< C >::val &  z 
) [inline]

Definition at line 715 of file analytic.hpp.

References C, and default_order().

Referenced by reverse_analytic_rep< C, V >::Eval(), compose_analytic_rep< C, V >::Eval(), lshiftz_analytic_rep< C, V >::Eval(), and unary_recursive_analytic_rep< Op, C, V >::Eval().

00715                                                   {
00716   nat order= max (default_order (f), (nat) 2);
00717   C sum= f[order-1];
00718   for (int i= order-2; i>=0; i--)
00719     sum= sum * z + f[i];
00720   if (is_reliable (sum))
00721     sum= blur (sum, tail_bound (f, abs(z), order));
00722   return sum;
00723 }

analytic<C,V> mmx::default_move ( const analytic< C, V > &  f2,
const list< typename unvectorize< C >::val > &  l2 
) [inline]

Definition at line 798 of file analytic.hpp.

References Analytic, g, move(), Radius, shrink(), and simplify().

00798                                                            {
00799   Analytic f= f2;
00800   list<Scalar > l= l2;
00801   while (!is_nil (l)) {
00802     Radius r= shrink (radius_bound (f));
00803     l= simplify (l, r);
00804     Analytic g= move (f, car (l));
00805     //clear_cache (f, CACHE_MOVE);
00806     f= g;
00807     l= cdr (l);
00808   }
00809   return f;
00810 }

V nat mmx::default_order ( const analytic< C, V > &  f  )  [inline]

Definition at line 581 of file analytic.hpp.

References mmx_order_ratio, and Radius.

Referenced by Abs_type(), and default_eval().

00581                                   {
00582   (void) f;
00583   return (nat) (mmx_order_ratio * ((double) precision (Radius (0))));
00584 }

mmx::DEFINE_UNARY_FORMAT_2 ( riemann_point   ) 
list<C> mmx::delta_to_absolute ( const list< C > &  l,
const C &  pos = C(0) 
) [inline]

Definition at line 253 of file analytic_matrix.hpp.

00253                                                          {
00254   if (is_nil (l)) return l;
00255   else return cons (pos + car (l), delta_to_absolute (cdr (l), pos + car (l)));
00256 }

analytic<C,V> mmx::derive ( const analytic< C, V > &  f  )  [inline]

Definition at line 375 of file analytic.hpp.

Referenced by vector_analytic_rep< C, V >::Derive(), vector_access_analytic_rep< C, V >::Derive(), rough_analytic_rep< C, V >::Derive(), cache_last_analytic_rep< C, V >::Derive(), fast_eval_analytic_rep< C, V >::Derive(), matrix_analytic_rep< C, V >::Derive(), matrix_access_analytic_rep< C, V >::Derive(), reverse_analytic_rep< C, V >::Derive(), compose_analytic_rep< C, V >::Derive(), polynomial_analytic_rep< C, V >::Derive(), recursive_container_analytic_rep< C, V >::Derive(), and GLUE_31().

00375                            {
00376   return f->Derive ();
00377 }

R mmx::diameter ( const riemann_square< R, V > &  s  )  [inline]

Definition at line 62 of file riemann_square.hpp.

00062 { return s->r + s->r; }

table<bool, riemann_square<R,V> > mmx::digital_disk ( const complex< R > &  z,
const R &  r,
nat  prec = 8 
) [inline]

Definition at line 189 of file riemann_square.hpp.

References C, R, and Squares.

00189                                                    {
00190   //mmout << "digital disk " << z << ", " << r << "\n";
00191   Squares ss;
00192   R scale= incexp2 (promote (1, r), exponent (r) + 2);
00193   R x= floor ((Re (z) - r) / scale) * scale;
00194   R y= floor ((Im (z) - r) / scale) * scale;
00195   digital_disk_sub<R,V> (ss, C (x, y), scale, z, r, prec);
00196   digital_disk_sub<R,V> (ss, C (x + scale, y), scale, z, r, prec);
00197   digital_disk_sub<R,V> (ss, C (x, y + scale), scale, z, r, prec);
00198   digital_disk_sub<R,V> (ss, C (x + scale, y + scale), scale, z, r, prec);
00199   return ss;
00200 }

void mmx::digital_disk_sub ( table< bool, riemann_square< R, V > > &  ss,
const complex< R > &  u,
const R &  d,
const complex< R > &  z,
const R &  r,
nat  prec 
) [inline]

Definition at line 165 of file riemann_square.hpp.

References admissible(), C, corners(), intersect(), R, and Square.

00168 {
00169   if (promote ((int) prec, r) * d >= r) {
00170     R h= d / promote (2, r);
00171     Square s (u + C (h, h), h);
00172     ASSERT (admissible (s), "admissibility hypothesis violated");
00173     vector<C > v= corners (s);
00174     nat count= 0;
00175     for (nat i=0; i<N(v); i++)
00176       if (abs (v[i] - z) < r) count++;
00177     if (count == 0 && !intersect (s, Square (z, r)));
00178     else if (count == 4) ss[s]= true;
00179     else {
00180       digital_disk_sub<R,V> (ss, u, h, z, r, prec);
00181       digital_disk_sub<R,V> (ss, u + C (h, promote (0, h)), h, z, r, prec);
00182       digital_disk_sub<R,V> (ss, u + C (promote (0, h), h), h, z, r, prec);
00183       digital_disk_sub<R,V> (ss, u + C (h, h), h, z, r, prec);
00184     }
00185   }
00186 }

complex<R> mmx::eval ( const riemann_germ< R, V > &  g,
const complex< R > &  z 
) [inline]

Definition at line 60 of file riemann_germ.hpp.

References eval().

00060                                                {
00061   return eval (g->p, z - g->c); }

matrix<C> mmx::eval ( const matrix< analytic< C, V > > &  m,
const C &  z 
) [inline]

Definition at line 198 of file analytic_matrix.hpp.

References C, and eval().

00198                                               {
00199   nat nr= rows (m), nc= cols (m);
00200   matrix<C> r (C (0), nr, nc);
00201   for (nat i=0; i<nr; i++)
00202     for (nat j=0; j<nc; j++)
00203       r (i, j)= eval (m (i, j), z);
00204   return r;  
00205 }

C mmx::eval ( const analytic< C, V > &  f,
const vector< typename unvectorize< C >::val > &  v 
) [inline]

Definition at line 853 of file analytic.hpp.

00853                                                    {
00854   return f->Eval (list<Scalar > (v));
00855 }

C mmx::eval ( const analytic< C, V > &  f,
const list< typename unvectorize< C >::val > &  l 
) [inline]

Definition at line 843 of file analytic.hpp.

00843                                                  {
00844   return f->Eval (l);
00845 }

C mmx::eval ( const analytic< C, V > &  f,
const typename unvectorize< C >::val &  z 
) [inline]

Definition at line 731 of file analytic.hpp.

References Analytic_rep, and inside().

Referenced by homotopy_stepper_rep< ball< C >, homotopy_ball >::certify_tube(), coherence(), connection_matrix(), vector_analytic_rep< C, V >::Eval(), vector_access_analytic_rep< C, V >::Eval(), cache_last_analytic_rep< C, V >::Eval(), eval(), matrix_analytic_rep< C, V >::Eval(), matrix_access_analytic_rep< C, V >::Eval(), lshiftz_analytic_rep< C, V >::Eval(), binary_recursive_analytic_rep< Op, C, V >::Eval(), binary_analytic_rep< mul_op, C, V >::Eval(), unary_recursive_analytic_rep< Op, C, V >::Eval(), unary_analytic_rep< neg_op, C, V >::Eval(), polynomial_analytic_rep< C, V >::Eval(), recursive_container_analytic_rep< C, V >::Eval(), GLUE_16(), GLUE_17(), GLUE_54(), solve_ode_series_rep< C >::initialize(), fixed_point_vector_analytic_rep< C >::Move(), fixed_point_analytic_rep< C >::Move(), reverse_analytic_rep< C, V >::Move(), integrate_analytic_rep< C, V >::Move(), unary_recursive_analytic_rep< Op, C, V >::Move(), nullary_recursive_analytic_rep< Op, C, V >::Move(), homotopy_stepper_rep< C, homotopy_euler >::newton_iterate(), homotopy_stepper_rep< C, homotopy_euler >::newton_step(), homotopy_stepper_rep< ball< C >, homotopy_ball >::newton_step(), homotopy_stepper_rep< ball< C >, homotopy_ball >::prepare_step(), homotopy_stepper_rep< C, homotopy_euler >::propose_next(), and heuristic_analytic_rep< C, V >::Radial_eval().

00731                                           {
00732   Analytic_rep* rep= inside (f);
00733   rep->init_next (z);
00734   if (rep->cache->eval_at == NULL)
00735     rep->cache->eval_at= mmx_new_one<C> (rep->Eval (z));
00736   return *rep->cache->eval_at;
00737 }

analytic< C, V > exp ( const analytic< C, V > &  f  )  [inline]

Definition at line 1494 of file analytic.hpp.

Referenced by circle_path(), GLUE_37(), and pow().

01494                         {
01495   return unary_recursive_analytic<exp_op> (f);
01496 }

series<C> mmx::expand ( const analytic< C, V > &  f,
nat  order 
) [inline]

Definition at line 358 of file analytic.hpp.

References expand(), and Series.

00358                                       {
00359   Series r= expand (f);
00360   if (order>0) (void) r[order-1];
00361   return r;
00362 }

series<C> mmx::expand ( const analytic< C, V > &  f  )  [inline]

Definition at line 352 of file analytic.hpp.

References inside().

Referenced by integrate_analytic_rep< C, V >::Abs_type(), lshiftz_analytic_rep< C, V >::Abs_type(), polynomial_analytic_rep< C, V >::Abs_type(), vector_analytic_rep< C, V >::Expand(), vector_access_analytic_rep< C, V >::Expand(), rough_analytic_rep< C, V >::Expand(), cache_last_analytic_rep< C, V >::Expand(), fast_eval_analytic_rep< C, V >::Expand(), matrix_analytic_rep< C, V >::Expand(), matrix_access_analytic_rep< C, V >::Expand(), reverse_analytic_rep< C, V >::Expand(), compose_analytic_rep< C, V >::Expand(), integrate_analytic_rep< C, V >::Expand(), lshiftz_analytic_rep< C, V >::Expand(), binary_scalar_analytic_rep< rmul_op, C, V, C >::Expand(), binary_recursive_analytic_rep< Op, C, V >::Expand(), binary_analytic_rep< mul_op, C, V >::Expand(), unary_recursive_analytic_rep< Op, C, V >::Expand(), unary_analytic_rep< neg_op, C, V >::Expand(), recursive_container_analytic_rep< C, V >::Expand(), expand(), flatten(), hash(), binary_recursive_analytic_rep< Op, C, V >::Initial(), unary_recursive_analytic_rep< Op, C, V >::Initial(), operator!=(), operator==(), range(), truncate(), and var().

00352                            {
00353   inside (f) -> init_cache ();
00354   return f->cache->expansion;
00355 }

analytic< C, V > fast_eval ( const analytic< C, V > &  f  )  [inline]

Definition at line 81 of file analytic_meta.hpp.

References Analytic_rep.

Referenced by fast_eval_analytic_rep< C, V >::Derive(), GLUE_4(), GLUE_7(), fast_eval_analytic_rep< C, V >::Move(), and radial().

00081                               {
00082   // radial (f) returns the same analytic functions as f,
00083   // but with special optimizations for fast numeric evaluation
00084   return (Analytic_rep*) new fast_eval_analytic_rep<C,V> (f);
00085 }

matrix< series<C> > mmx::first_variation ( const slp_tangent< series< C > > &  fun,
const vector< series< C > > &  at 
) [inline]

Definition at line 72 of file ode_series.hpp.

References solve_lde().

Referenced by first_variation_series().

00072                                                                         {
00073   matrix<Series > jac= jacobian (fun, at);
00074   return solve_lde (jac);
00075 }

matrix<generic> mmx::first_variation_series ( const vector< multivariate< sparse_polynomial< rational > > > &  f,
const vector< multivariate_coordinate<> > &  vars,
const vector< C > &  c 
) [inline]

Definition at line 89 of file ode_series.hpp.

References CF(), f, first_variation_series(), and Function_C.

00091                                             {
00092   Function_C fun= as_slp_tangent (f, vars, CF (c));
00093   return as<matrix<generic> > (first_variation_series (fun, c));
00094 }

matrix< series<C> > mmx::first_variation_series ( const slp_tangent< C > &  fun,
const vector< C > &  c 
) [inline]

Definition at line 83 of file ode_series.hpp.

References first_variation_series(), and solve_ode_series().

00083                                                                    {
00084   vector<Series > at= solve_ode_series (fun, c);
00085   return first_variation_series (fun, at);
00086 }

matrix< series<C> > mmx::first_variation_series ( const slp_tangent< C > &  fun,
const vector< series< C > > &  at 
) [inline]

Definition at line 78 of file ode_series.hpp.

References first_variation().

Referenced by first_variation_series().

00078                                                                           {
00079   return first_variation (as<Function_Series > (fun), at);
00080 }

analytic< C > fixed_point_analytic ( const routine &  fun,
const C &  c 
) [inline]

Definition at line 64 of file analytic_sugar.hpp.

References recursive().

Referenced by GLUE_48(), integrate_analytic(), and fixed_point_analytic_rep< C >::Move().

00064                                                       {
00065   return recursive (new fixed_point_analytic_rep<C> (fun, c));
00066 }

analytic< vector< C > > fixed_point_analytic_vector ( const routine &  fun,
const vector< C > &  c 
) [inline]

Definition at line 104 of file analytic_sugar.hpp.

References recursive().

Referenced by fixed_point_vector_analytic(), and fixed_point_vector_analytic_rep< C >::Move().

00104                                                                   {
00105   return recursive (new fixed_point_vector_analytic_rep<C> (fun, c));
00106 }

vector< analytic< C > > fixed_point_vector_analytic ( const routine &  fun,
const vector< C > &  c 
) [inline]

Definition at line 109 of file analytic_sugar.hpp.

References as_vector(), and fixed_point_analytic_vector().

Referenced by gen_fixed_point_vector_analytic().

00109                                                                   {
00110   return as_vector (fixed_point_analytic_vector (fun, c));
00111 }

riemann_surface<R,V> syntactic mmx::flatten ( const riemann_surface< R, V > &  rs  )  [inline]
Type Constraints

Definition at line 96 of file riemann_surface.hpp.

References flatten().

00096                             {
00097   //return apply ("surface", flatten (rs->squares));
00098   return apply ("surface", flatten (rs->squares), flatten (rs->neighbours));
00099 }

riemann_square<R,V> syntactic mmx::flatten ( const riemann_square< R, V > &  z  )  [inline]
Type Constraints

Definition at line 89 of file riemann_square.hpp.

References center(), flatten(), and radius().

00089                           {
00090   return apply ("square", flatten (center (z)), flatten (radius (z)));
00091 }

riemann_point<R,V> V syntactic mmx::flatten ( const riemann_point< R, V > &  p  )  [inline]

Definition at line 64 of file riemann_point.hpp.

References flatten().

00064                          {
00065   return apply ("point", flatten (p.z), flatten (p.s));
00066 }

riemann_germ<R,V> syntactic mmx::flatten ( const riemann_germ< R, V > &  g  )  [inline]
Type Constraints

Definition at line 85 of file riemann_germ.hpp.

References flatten().

00085                         {
00086   return apply ("germ", flatten (g->p), flatten (g->c), flatten (g->r));
00087 }

riemann_bundle<Germ,R,V> syntactic mmx::flatten ( const riemann_bundle< Germ, R, V > &  b  )  [inline]
Type Constraints

Definition at line 122 of file riemann_bundle.hpp.

References flatten().

00122                           {
00123   return apply ("bundle", flatten (b->surface), flatten (b->bundle));
00124 }

syntactic mmx::flatten ( const analytic< C, V > &  f  )  [inline]

Definition at line 434 of file analytic.hpp.

References flatten(), and var().

00434                             {
00435   return flatten (f, as_syntactic (var (f)));
00436 }

syntactic mmx::flatten ( const analytic< C, V > &  f,
const syntactic &  z 
) [inline]

Definition at line 428 of file analytic.hpp.

References expand().

Referenced by solve_ode_series_rep< C >::expression(), fixed_point_vector_analytic_rep< C >::expression(), fixed_point_analytic_rep< C >::expression(), rough_analytic_rep< C, V >::expression(), cache_last_analytic_rep< C, V >::expression(), fast_eval_analytic_rep< C, V >::expression(), heuristic_analytic_rep< C, V >::expression(), binary_recursive_analytic_rep< Op, C, V >::expression(), unary_recursive_analytic_rep< Op, C, V >::expression(), nullary_recursive_analytic_rep< Op, C, V >::expression(), recursive_container_analytic_rep< C, V >::expression(), and flatten().

00428                                                 {
00429   if (Series::get_formula_output ()) return f->expression (z);
00430   else return flatten (expand (f), z);
00431 }

analytic<matrix<C>,V> mmx::from_matrix ( const matrix< analytic< C, V > > &  m  )  [inline]

Definition at line 183 of file analytic_matrix.hpp.

References V.

00183                                          {
00184   return (analytic_rep<matrix<C>,V>*) new matrix_analytic_rep<C,V> (m);
00185 }

analytic<vector<C>,V> mmx::from_vector ( const vector< analytic< C, V > > &  v  )  [inline]

Definition at line 165 of file analytic_vector.hpp.

References V.

Referenced by fixed_point_vector_analytic_rep< C >::Equation(), and solve_ode_series_rep< C >::initialize().

00165                                          {
00166   return (analytic_rep<vector<C>,V>*) new vector_analytic_rep<C,V> (v);
00167 }

vector< generic > gen_fixed_point_vector_analytic ( const routine &  fun,
const vector< C > &  c 
) [inline]

Definition at line 114 of file analytic_sugar.hpp.

References fixed_point_vector_analytic().

Referenced by gen_integrate_vector_analytic(), GLUE_1(), GLUE_46(), and GLUE_55().

00114                                                                       {
00115   return as<vector<generic> > (fixed_point_vector_analytic (fun, c));
00116 }

vector<generic> mmx::gen_integrate_vector_analytic ( const routine &  fun,
const vector< C > &  c 
) [inline]

Definition at line 119 of file analytic_sugar.hpp.

References gen_fixed_point_vector_analytic(), and integrate().

Referenced by GLUE_2(), GLUE_47(), and GLUE_56().

00119                                                                     {
00120   return gen_fixed_point_vector_analytic (integrate (fun), c);
00121 }

Germ mmx::germ ( const riemann_bundle< Germ, R, V > &  b,
const riemann_point< R, V > &  p_old 
) [inline]

Definition at line 204 of file riemann_bundle.hpp.

References better(), germs(), inside(), Point, project(), and upgrade().

00204                                            {
00205   Point p= upgrade (b->surface, p_old);
00206   vector<Germ > v= germs (b, p);
00207   nat best= N(v);
00208   for (nat i=0; i<N(v); i++)
00209     if (inside (project (p), v[i]))
00210       if (best == N(v) || better (project (p), v[i], v[best]))
00211         best= i;
00212   if (best != N(v)) return v[best];
00213   mmout << "p= " << p << "\n";
00214   mmout << "v= " << v << "\n";
00215   ERROR ("germ not found");
00216   return v[0];
00217 }

vector<Germ > mmx::germs ( const riemann_bundle< Germ, R, V > &  b,
const riemann_point< R, V > &  p_old 
) [inline]

Definition at line 198 of file riemann_bundle.hpp.

References owner(), Point, and upgrade().

Referenced by germ().

00198                                             {
00199   Point p= upgrade (b->surface, p_old);
00200   return b->bundle[owner (p)];
00201 }

void mmx::glue ( riemann_surface< R, V > &  rs1,
const riemann_point< R, V > &  p1,
const riemann_surface< R, V > &  rs2 
) [inline]

Definition at line 406 of file riemann_surface.hpp.

References glue(), lift(), Point, and project().

00406                                                          {
00407   Point p2= lift (rs2, project (p1));
00408   glue (rs1, p1, rs2, p2);
00409 }

table<bool, riemann_square<R,V> > mmx::glue ( riemann_surface< R, V > &  rs1,
const riemann_point< R, V > &  p1,
const riemann_surface< R, V > &  rs2,
const riemann_point< R, V > &  p2 
) [inline]

Definition at line 382 of file riemann_surface.hpp.

References included(), inside(), Iterator, owners(), project(), Squares, and upgrade().

00382                                                                           {
00383   ASSERT (project (p1) == project (p2), "incompatible glue points");
00384   //mmout << "--- Add ---\n";
00385   inside (rs1)->add (rs2->squares);
00386   inside (rs1)->connect (rs2->neighbours);
00387   Squares os1= owners (rs1, upgrade (rs1, p1));
00388   Squares os2= owners (rs2, upgrade (rs2, p2));
00389   for (Iterator it1= entries (os1); busy (it1); ++it1)
00390     for (Iterator it2= entries (os2); busy (it2); ++it2)
00391       if (included (*it1, *it2) || included (*it2, *it1)) {
00392         //mmout << "--- Glue ---\n";
00393         inside (rs1)->glue (*it1, *it2);
00394         //mmout << "--- Normalize ---\n";
00395         inside (rs1)->normalize ();
00396         Squares replaced= rs1->replaced;
00397         inside (rs1)->clean ();
00398         //mmout << "--- Done ---\n";
00399         return replaced;
00400       }
00401   ERROR ("unexpected situation");
00402   return Squares (false, CF2(os1));
00403 }

table<bool, riemann_square<R,V> > mmx::glue ( riemann_surface< R, V > &  rs,
const riemann_point< R, V > &  p1,
const riemann_point< R, V > &  p2 
) [inline]

Definition at line 372 of file riemann_surface.hpp.

References inside(), owner(), project(), Squares, and upgrade().

00372                                                      {
00373   ASSERT (project (p1) == project (p2), "incompatible glue points");
00374   inside (rs)->glue (owner (upgrade (rs, p1)), owner (upgrade (rs, p2)));
00375   inside (rs)->normalize ();
00376   Squares replaced= rs->replaced;
00377   inside (rs)->clean ();
00378   return replaced;
00379 }

void mmx::glue ( riemann_bundle< Germ, R, V > &  b1,
const riemann_point< R, V > &  p1,
const riemann_bundle< Germ, R, V > &  b2 
) [inline]

Definition at line 192 of file riemann_bundle.hpp.

References glue(), lift(), Point, and project().

00192                                                      {
00193   Point p2= lift (b2->surface, project (p1));
00194   glue (b1, p1, b2, p2);
00195 }

table<bool, riemann_square<R,V> > mmx::glue ( riemann_bundle< Germ, R, V > &  b1,
const riemann_point< R, V > &  p1,
const riemann_bundle< Germ, R, V > &  b2,
const riemann_point< R, V > &  p2 
) [inline]

Definition at line 183 of file riemann_bundle.hpp.

References inside(), Iterator, merge(), and Squares.

Referenced by glue().

00183                                                                       {
00184   Squares replaced= glue (inside (b1)->surface, p1, b2->surface, p2);
00185   for (Iterator it= entries (b2->bundle); busy (it); ++it)
00186     inside (b1)->bundle[*it]= merge (*it, b1->bundle[*it], b2->bundle[*it]);
00187   inside (b1)->upgrade (replaced);
00188   return replaced;
00189 }

static riemann_square<double> mmx::GLUE_1 ( const complex< double > &  arg_1,
const double &  arg_2 
) [static]

Definition at line 75 of file glue_riemann_double.cpp.

00075                                                              {
00076     return riemann_square<double > (arg_1, arg_2);
00077   }

static vector<integer> mmx::GLUE_1 ( const vector< int > &  arg_1  )  [static]

Definition at line 160 of file glue_ode_taylor_floating.cpp.

00160                                     {
00161     return as<vector<integer> > (arg_1);
00162   }

static analytic< complex<mmx_floating> > mmx::GLUE_1 ( const tuple< mmx_floating > &  arg_1  )  [static]

Definition at line 81 of file glue_analytic_floating.cpp.

References analytic_complex(), and as_vector().

00081                                             {
00082     return analytic_complex (as_vector (arg_1));
00083   }

static analytic< complex<double> > mmx::GLUE_1 ( const tuple< double > &  arg_1  )  [static]

Definition at line 76 of file glue_analytic_double.cpp.

References analytic_complex(), and as_vector().

00076                                       {
00077     return analytic_complex (as_vector (arg_1));
00078   }

static vector<generic> mmx::GLUE_1 ( const routine &  arg_1,
const vector< generic > &  arg_2 
) [static]

Definition at line 87 of file glue_analytic_ball_floating.cpp.

References gen_fixed_point_vector_analytic().

Referenced by glue_homotopy_ball_double(), glue_homotopy_ball_floating(), glue_homotopy_double(), glue_homotopy_floating(), glue_ode_series_double(), glue_ode_series_floating(), glue_ode_taylor_double(), glue_ode_taylor_floating(), and glue_riemann_double().

00087                                                               {
00088     return gen_fixed_point_vector_analytic (arg_1, arg_2);
00089   }

static riemann_surface<double> mmx::GLUE_10 ( const complex< double > &  arg_1,
const double &  arg_2 
) [static]

Definition at line 120 of file glue_riemann_double.cpp.

References std_riemann_disk().

00120                                                               {
00121     return std_riemann_disk (arg_1, arg_2);
00122   }

static vector<generic> mmx::GLUE_10 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< complex< mmx_floating > > &  arg_3 
) [static]

Definition at line 205 of file glue_ode_taylor_floating.cpp.

References arg_1.

00205                                                                                                                                             {
00206     return solve_ode_taylor (arg_1, arg_2, arg_3);
00207   }

static vector<generic> mmx::GLUE_10 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< complex< double > > &  arg_3 
) [static]

Definition at line 200 of file glue_ode_taylor_double.cpp.

References arg_1.

00200                                                                                                                                       {
00201     return solve_ode_taylor (arg_1, arg_2, arg_3);
00202   }

static matrix<complex<mmx_floating> > mmx::GLUE_10 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const matrix< complex< mmx_floating > > &  arg_3,
const multivariate_coordinate<> &  arg_4,
const vector< complex< mmx_floating > > &  arg_5 
) [static]

Definition at line 205 of file glue_homotopy_floating.cpp.

References arg_1, and homotopy().

00205                                                                                                                                                                                                                       {
00206     return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00207   }

static matrix<complex<double> > mmx::GLUE_10 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const matrix< complex< double > > &  arg_3,
const multivariate_coordinate<> &  arg_4,
const vector< complex< double > > &  arg_5 
) [static]

Definition at line 201 of file glue_homotopy_double.cpp.

References arg_1, and homotopy().

00201                                                                                                                                                                                                           {
00202     return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00203   }

static vector<mmx_ball(mmx_floating, complex<mmx_floating> ) > mmx::GLUE_10 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< mmx_ball(mmx_floating, complex< mmx_floating >) > &  arg_3,
const multivariate_coordinate<> &  arg_4,
const mmx_ball(mmx_floating, complex< mmx_floating >)&  arg_5 
) [static]

Definition at line 211 of file glue_homotopy_ball_floating.cpp.

References homotopy().

00211                                                                                                                                                                                                                                                                {
00212     return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00213   }

static matrix<mmx_ball(double, complex<double> ) > mmx::GLUE_10 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const matrix< mmx_ball(double, complex< double >) > &  arg_3,
const multivariate_coordinate<> &  arg_4,
const vector< mmx_ball(double, complex< double >) > &  arg_5 
) [static]

Definition at line 207 of file glue_homotopy_ball_double.cpp.

References homotopy().

00207                                                                                                                                                                                                                                                 {
00208     return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00209   }

static mmx_floating mmx::GLUE_10 ( const analytic< complex< mmx_floating > > &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 126 of file glue_analytic_floating.cpp.

00126                                                                                                        {
00127     return lower_bound (arg_1, arg_2);
00128   }

static double mmx::GLUE_10 ( const analytic< complex< double > > &  arg_1,
const double &  arg_2 
) [static]

Definition at line 121 of file glue_analytic_double.cpp.

00121                                                                                      {
00122     return lower_bound (arg_1, arg_2);
00123   }

static analytic< mmx_ball(mmx_floating, complex<mmx_floating> ) > mmx::GLUE_10 ( const polynomial< mmx_ball(mmx_floating, complex< mmx_floating >) > &  arg_1  )  [static]

Definition at line 132 of file glue_analytic_ball_floating.cpp.

References std_heuristic().

00132                                                                                      {
00133     return std_heuristic (arg_1);
00134   }

static analytic< mmx_ball(double, complex<double> ) > mmx::GLUE_10 ( const polynomial< mmx_ball(double, complex< double >) > &  arg_1  )  [static]

Definition at line 127 of file glue_analytic_ball_double.cpp.

References std_heuristic().

Referenced by glue_homotopy_ball_double(), glue_homotopy_ball_floating(), glue_homotopy_double(), glue_homotopy_floating(), glue_ode_series_double(), glue_ode_series_floating(), glue_ode_taylor_double(), glue_ode_taylor_floating(), and glue_riemann_double().

00127                                                                          {
00128     return std_heuristic (arg_1);
00129   }

static void mmx::GLUE_11 ( const alias< riemann_surface< double > > &  arg_1,
const riemann_point< double > &  arg_2,
const riemann_surface< double > &  arg_3 
) [static]

Definition at line 125 of file glue_riemann_double.cpp.

References arg_1.

00125                                                                                                                                    {
00126     alias_glue (arg_1, arg_2, arg_3);
00127   }

static matrix<generic> mmx::GLUE_11 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< complex< mmx_floating > > &  arg_3 
) [static]

Definition at line 210 of file glue_ode_taylor_floating.cpp.

References arg_1.

00210                                                                                                                                             {
00211     return first_variation_taylor (arg_1, arg_2, arg_3);
00212   }

static matrix<generic> mmx::GLUE_11 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< complex< double > > &  arg_3 
) [static]

Definition at line 205 of file glue_ode_taylor_double.cpp.

References arg_1.

00205                                                                                                                                       {
00206     return first_variation_taylor (arg_1, arg_2, arg_3);
00207   }

static vector<mmx_ball(mmx_floating, complex<mmx_floating> ) > mmx::GLUE_11 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< mmx_ball(mmx_floating, complex< mmx_floating >) > &  arg_3,
const multivariate_coordinate<> &  arg_4,
const vector< mmx_ball(mmx_floating, complex< mmx_floating >) > &  arg_5 
) [static]

Definition at line 216 of file glue_homotopy_ball_floating.cpp.

References homotopy().

00216                                                                                                                                                                                                                                                                         {
00217     return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00218   }

static vector<mmx_ball(double, double) > mmx::GLUE_11 ( const vector< rational > &  arg_1  )  [static]

Definition at line 214 of file glue_ode_series_floating.cpp.

00214                                           {
00215     return as<vector<mmx_floating> > (arg_1);
00216   }

static mmx_floating mmx::GLUE_11 ( const analytic< complex< mmx_floating > > &  arg_1,
const mmx_floating &  arg_2,
const int &  arg_3 
) [static]

Definition at line 131 of file glue_analytic_floating.cpp.

00131                                                                                                                          {
00132     return head_bound (arg_1, arg_2, arg_3);
00133   }

static double mmx::GLUE_11 ( const analytic< complex< double > > &  arg_1,
const double &  arg_2,
const int &  arg_3 
) [static]

Definition at line 126 of file glue_analytic_double.cpp.

Referenced by glue_homotopy_ball_double(), glue_homotopy_ball_floating(), glue_homotopy_double(), glue_homotopy_floating(), glue_ode_series_double(), glue_ode_series_floating(), glue_ode_taylor_double(), glue_ode_taylor_floating(), and glue_riemann_double().

00126                                                                                                        {
00127     return head_bound (arg_1, arg_2, arg_3);
00128   }

static bool mmx::GLUE_12 ( const riemann_surface< double > &  arg_1  )  [static]

Definition at line 130 of file glue_riemann_double.cpp.

References is_plane().

00130                                                  {
00131     return is_plane (arg_1);
00132   }

static vector<generic> mmx::GLUE_12 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< complex< mmx_floating > > &  arg_3,
const complex< mmx_floating > &  arg_4 
) [static]

Definition at line 215 of file glue_ode_taylor_floating.cpp.

References arg_1.

00215                                                                                                                                                                                 {
00216     return integrate_ode_taylor (arg_1, arg_2, arg_3, arg_4);
00217   }

static vector<generic> mmx::GLUE_12 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< complex< double > > &  arg_3,
const complex< double > &  arg_4 
) [static]

Definition at line 210 of file glue_ode_taylor_double.cpp.

References arg_1.

00210                                                                                                                                                                     {
00211     return integrate_ode_taylor (arg_1, arg_2, arg_3, arg_4);
00212   }

static matrix<mmx_ball(mmx_floating, complex<mmx_floating> ) > mmx::GLUE_12 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const matrix< mmx_ball(mmx_floating, complex< mmx_floating >) > &  arg_3,
const multivariate_coordinate<> &  arg_4,
const mmx_ball(mmx_floating, complex< mmx_floating >)&  arg_5 
) [static]

Definition at line 221 of file glue_homotopy_ball_floating.cpp.

References homotopy().

00221                                                                                                                                                                                                                                                                {
00222     return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00223   }

static vector<mmx_ball(double, complex<double> ) > mmx::GLUE_12 ( const vector< rational > &  arg_1  )  [static]

Definition at line 219 of file glue_ode_series_floating.cpp.

00219                                           {
00220     return as<vector<complex<mmx_floating> > > (arg_1);
00221   }

static mmx_floating mmx::GLUE_12 ( const analytic< complex< mmx_floating > > &  arg_1,
const mmx_floating &  arg_2,
const int &  arg_3 
) [static]

Definition at line 136 of file glue_analytic_floating.cpp.

00136                                                                                                                          {
00137     return tail_bound (arg_1, arg_2, arg_3);
00138   }

static double mmx::GLUE_12 ( const analytic< complex< double > > &  arg_1,
const double &  arg_2,
const int &  arg_3 
) [static]

Definition at line 131 of file glue_analytic_double.cpp.

Referenced by glue_homotopy_ball_double(), glue_homotopy_ball_floating(), glue_homotopy_double(), glue_homotopy_floating(), glue_ode_series_double(), glue_ode_series_floating(), glue_ode_taylor_double(), glue_ode_taylor_floating(), and glue_riemann_double().

00131                                                                                                        {
00132     return tail_bound (arg_1, arg_2, arg_3);
00133   }

static riemann_point<double> mmx::GLUE_13 ( const riemann_surface< double > &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 135 of file glue_riemann_double.cpp.

References lift().

00135                                                                                {
00136     return lift (arg_1, arg_2);
00137   }

static vector<double> mmx::GLUE_13 ( const vector< rational > &  arg_1  )  [static]

Definition at line 220 of file glue_ode_taylor_floating.cpp.

00220                                           {
00221     return as<vector<mmx_floating> > (arg_1);
00222   }

static matrix<mmx_ball(mmx_floating, complex<mmx_floating> ) > mmx::GLUE_13 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const matrix< mmx_ball(mmx_floating, complex< mmx_floating >) > &  arg_3,
const multivariate_coordinate<> &  arg_4,
const vector< mmx_ball(mmx_floating, complex< mmx_floating >) > &  arg_5 
) [static]

Definition at line 226 of file glue_homotopy_ball_floating.cpp.

References homotopy().

00226                                                                                                                                                                                                                                                                         {
00227     return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00228   }

static vector<mmx_ball(double, complex<double> ) > mmx::GLUE_13 ( const vector< complex< rational > > &  arg_1  )  [static]

Definition at line 224 of file glue_ode_series_floating.cpp.

References arg_1.

00224                                                     {
00225     return as<vector<complex<mmx_floating> > > (arg_1);
00226   }

static analytic< complex<mmx_floating> > mmx::GLUE_13 ( const analytic< complex< mmx_floating > > &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 141 of file glue_analytic_floating.cpp.

References radial_move().

00141                                                                                                                 {
00142     return radial_move (arg_1, arg_2);
00143   }

static analytic< complex<double> > mmx::GLUE_13 ( const analytic< complex< double > > &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 136 of file glue_analytic_double.cpp.

References radial_move().

Referenced by glue_homotopy_ball_double(), glue_homotopy_ball_floating(), glue_homotopy_double(), glue_homotopy_floating(), glue_ode_series_double(), glue_ode_series_floating(), glue_ode_taylor_double(), glue_ode_taylor_floating(), and glue_riemann_double().

00136                                                                                               {
00137     return radial_move (arg_1, arg_2);
00138   }

static riemann_point<double> mmx::GLUE_14 ( const riemann_surface< double > &  arg_1,
const riemann_point< double > &  arg_2,
const complex< double > &  arg_3 
) [static]

Definition at line 140 of file glue_riemann_double.cpp.

References move().

00140                                                                                                                    {
00141     return move (arg_1, arg_2, arg_3);
00142   }

static vector<complex<double> > mmx::GLUE_14 ( const vector< rational > &  arg_1  )  [static]

Definition at line 225 of file glue_ode_taylor_floating.cpp.

00225                                           {
00226     return as<vector<complex<mmx_floating> > > (arg_1);
00227   }

static complex<mmx_floating> mmx::GLUE_14 ( const analytic< complex< mmx_floating > > &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 146 of file glue_analytic_floating.cpp.

References radial_eval().

00146                                                                                                                 {
00147     return radial_eval (arg_1, arg_2);
00148   }

static complex<double> mmx::GLUE_14 ( const analytic< complex< double > > &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 141 of file glue_analytic_double.cpp.

References radial_eval().

Referenced by glue_ode_taylor_double(), glue_ode_taylor_floating(), and glue_riemann_double().

00141                                                                                               {
00142     return radial_eval (arg_1, arg_2);
00143   }

static complex<double> mmx::GLUE_15 ( const riemann_germ< double > &  arg_1  )  [static]

Definition at line 145 of file glue_riemann_double.cpp.

References center().

00145                                               {
00146     return center (arg_1);
00147   }

static vector<complex<double> > mmx::GLUE_15 ( const vector< complex< rational > > &  arg_1  )  [static]

Definition at line 230 of file glue_ode_taylor_floating.cpp.

References arg_1.

00230                                                     {
00231     return as<vector<complex<mmx_floating> > > (arg_1);
00232   }

static analytic< complex<mmx_floating> > mmx::GLUE_15 ( const analytic< complex< mmx_floating > > &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 151 of file glue_analytic_floating.cpp.

References move().

00151                                                                                                                 {
00152     return move (arg_1, arg_2);
00153   }

static analytic< complex<double> > mmx::GLUE_15 ( const analytic< complex< double > > &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 146 of file glue_analytic_double.cpp.

References move().

Referenced by glue_ode_taylor_double(), glue_ode_taylor_floating(), and glue_riemann_double().

00146                                                                                               {
00147     return move (arg_1, arg_2);
00148   }

static complex<double> mmx::GLUE_16 ( const riemann_germ< double > &  arg_1  )  [static]

Definition at line 150 of file glue_riemann_double.cpp.

References radius().

00150                                               {
00151     return radius (arg_1);
00152   }

static complex<mmx_floating> mmx::GLUE_16 ( const analytic< complex< mmx_floating > > &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 156 of file glue_analytic_floating.cpp.

References eval().

00156                                                                                                                 {
00157     return eval (arg_1, arg_2);
00158   }

static complex<double> mmx::GLUE_16 ( const analytic< complex< double > > &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 151 of file glue_analytic_double.cpp.

References eval().

Referenced by glue_riemann_double().

00151                                                                                               {
00152     return eval (arg_1, arg_2);
00153   }

static complex<double> mmx::GLUE_17 ( const riemann_germ< double > &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 155 of file glue_riemann_double.cpp.

References eval().

00155                                                                             {
00156     return eval (arg_1, arg_2);
00157   }

static analytic< complex<mmx_floating> > mmx::GLUE_17 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 161 of file glue_analytic_floating.cpp.

00161                                                                             {
00162     return -arg_1;
00163   }

static analytic< complex<double> > mmx::GLUE_17 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 156 of file glue_analytic_double.cpp.

Referenced by glue_riemann_double().

00156                                                                 {
00157     return -arg_1;
00158   }

static riemann_bundle<riemann_germ< double >, double ,std_riemann> mmx::GLUE_18 ( const riemann_surface< double > &  arg_1,
const riemann_germ< double > &  arg_2 
) [static]

Definition at line 160 of file glue_riemann_double.cpp.

References simple_riemann_bundle.

00160                                                                                     {
00161     return (simple_riemann_bundle(double ) (arg_1, arg_2));
00162   }

static analytic< complex<mmx_floating> > mmx::GLUE_18 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 166 of file glue_analytic_floating.cpp.

00166                                                                             {
00167     return square (arg_1);
00168   }

static analytic< complex<double> > mmx::GLUE_18 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 161 of file glue_analytic_double.cpp.

Referenced by glue_riemann_double().

00161                                                                 {
00162     return square (arg_1);
00163   }

static void mmx::GLUE_19 ( const alias< riemann_bundle< riemann_germ< double >, double, std_riemann > > &  arg_1,
const riemann_point< double > &  arg_2,
const riemann_bundle< riemann_germ< double >, double, std_riemann > &  arg_3 
) [static]

Definition at line 165 of file glue_riemann_double.cpp.

References arg_1.

00165                                                                                                                                                {
00166     alias_glue (arg_1, arg_2, arg_3);
00167   }

static analytic< complex<mmx_floating> > mmx::GLUE_19 ( const analytic< complex< mmx_floating > > &  arg_1,
const analytic< complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 171 of file glue_analytic_floating.cpp.

00171                                                                                                                                              {
00172     return arg_1 + arg_2;
00173   }

static analytic< complex<double> > mmx::GLUE_19 ( const analytic< complex< double > > &  arg_1,
const analytic< complex< double > > &  arg_2 
) [static]

Definition at line 166 of file glue_analytic_double.cpp.

Referenced by glue_riemann_double().

00166                                                                                                                      {
00167     return arg_1 + arg_2;
00168   }

static bool mmx::GLUE_2 ( const riemann_square< double > &  arg_1  )  [static]

Definition at line 80 of file glue_riemann_double.cpp.

References admissible().

00080                                                {
00081     return admissible (arg_1);
00082   }

static vector<rational> mmx::GLUE_2 ( const vector< int > &  arg_1  )  [static]

Definition at line 165 of file glue_ode_taylor_floating.cpp.

00165                                     {
00166     return as<vector<rational> > (arg_1);
00167   }

static analytic< complex<mmx_floating> > mmx::GLUE_2 ( const tuple< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 86 of file glue_analytic_floating.cpp.

References as_vector(), and make_mmx_analytic().

00086                                                       {
00087     return make_mmx_analytic (as_vector (arg_1));
00088   }

static analytic< complex<double> > mmx::GLUE_2 ( const tuple< complex< double > > &  arg_1  )  [static]

Definition at line 81 of file glue_analytic_double.cpp.

References as_vector(), and make_mmx_analytic().

00081                                                 {
00082     return make_mmx_analytic (as_vector (arg_1));
00083   }

static vector<generic> mmx::GLUE_2 ( const routine &  arg_1,
const vector< generic > &  arg_2 
) [static]

Definition at line 92 of file glue_analytic_ball_floating.cpp.

References gen_integrate_vector_analytic().

Referenced by glue_homotopy_ball_double(), glue_homotopy_ball_floating(), glue_homotopy_double(), glue_homotopy_floating(), glue_ode_series_double(), glue_ode_series_floating(), glue_ode_taylor_double(), glue_ode_taylor_floating(), and glue_riemann_double().

00092                                                               {
00093     return gen_integrate_vector_analytic (arg_1, arg_2);
00094   }

static riemann_surface<double> mmx::GLUE_20 ( const riemann_bundle< riemann_germ< double >, double, std_riemann > &  arg_1  )  [static]

Definition at line 170 of file glue_riemann_double.cpp.

References bundle_surface().

00170                                                        {
00171     return bundle_surface (arg_1);
00172   }

static analytic< complex<mmx_floating> > mmx::GLUE_20 ( const analytic< complex< mmx_floating > > &  arg_1,
const analytic< complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 176 of file glue_analytic_floating.cpp.

00176                                                                                                                                              {
00177     return arg_1 - arg_2;
00178   }

static analytic< complex<double> > mmx::GLUE_20 ( const analytic< complex< double > > &  arg_1,
const analytic< complex< double > > &  arg_2 
) [static]

Definition at line 171 of file glue_analytic_double.cpp.

Referenced by glue_riemann_double().

00171                                                                                                                      {
00172     return arg_1 - arg_2;
00173   }

static riemann_germ<double> mmx::GLUE_21 ( const polynomial< complex< double > > &  arg_1,
const complex< double > &  arg_2,
const double &  arg_3 
) [static]

Definition at line 175 of file glue_riemann_double.cpp.

References arg_1.

00175                                                                                                          {
00176     return riemann_germ<double > (arg_1, arg_2, arg_3);
00177   }

static analytic< complex<mmx_floating> > mmx::GLUE_21 ( const analytic< complex< mmx_floating > > &  arg_1,
const analytic< complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 181 of file glue_analytic_floating.cpp.

00181                                                                                                                                              {
00182     return arg_1 * arg_2;
00183   }

static analytic< complex<double> > mmx::GLUE_21 ( const analytic< complex< double > > &  arg_1,
const analytic< complex< double > > &  arg_2 
) [static]

Definition at line 176 of file glue_analytic_double.cpp.

Referenced by glue_riemann_double().

00176                                                                                                                      {
00177     return arg_1 * arg_2;
00178   }

static analytic< complex<mmx_floating> > mmx::GLUE_22 ( const analytic< complex< mmx_floating > > &  arg_1,
const analytic< complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 186 of file glue_analytic_floating.cpp.

00186                                                                                                                                              {
00187     return arg_1 / arg_2;
00188   }

static analytic< complex<double> > mmx::GLUE_22 ( const analytic< complex< double > > &  arg_1,
const analytic< complex< double > > &  arg_2 
) [static]

Definition at line 181 of file glue_analytic_double.cpp.

00181                                                                                                                      {
00182     return arg_1 / arg_2;
00183   }

static analytic< complex<mmx_floating> > mmx::GLUE_23 ( const complex< mmx_floating > &  arg_1,
const analytic< complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 191 of file glue_analytic_floating.cpp.

00191                                                                                                                 {
00192     return arg_1 + arg_2;
00193   }

static analytic< complex<double> > mmx::GLUE_23 ( const complex< double > &  arg_1,
const analytic< complex< double > > &  arg_2 
) [static]

Definition at line 186 of file glue_analytic_double.cpp.

00186                                                                                               {
00187     return arg_1 + arg_2;
00188   }

static analytic< complex<mmx_floating> > mmx::GLUE_24 ( const analytic< complex< mmx_floating > > &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 196 of file glue_analytic_floating.cpp.

00196                                                                                                                 {
00197     return arg_1 + arg_2;
00198   }

static analytic< complex<double> > mmx::GLUE_24 ( const analytic< complex< double > > &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 191 of file glue_analytic_double.cpp.

00191                                                                                               {
00192     return arg_1 + arg_2;
00193   }

static analytic< complex<mmx_floating> > mmx::GLUE_25 ( const complex< mmx_floating > &  arg_1,
const analytic< complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 201 of file glue_analytic_floating.cpp.

00201                                                                                                                 {
00202     return arg_1 - arg_2;
00203   }

static analytic< complex<double> > mmx::GLUE_25 ( const complex< double > &  arg_1,
const analytic< complex< double > > &  arg_2 
) [static]

Definition at line 196 of file glue_analytic_double.cpp.

00196                                                                                               {
00197     return arg_1 - arg_2;
00198   }

static analytic< complex<mmx_floating> > mmx::GLUE_26 ( const analytic< complex< mmx_floating > > &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 206 of file glue_analytic_floating.cpp.

00206                                                                                                                 {
00207     return arg_1 - arg_2;
00208   }

static analytic< complex<double> > mmx::GLUE_26 ( const analytic< complex< double > > &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 201 of file glue_analytic_double.cpp.

00201                                                                                               {
00202     return arg_1 - arg_2;
00203   }

static analytic< complex<mmx_floating> > mmx::GLUE_27 ( const complex< mmx_floating > &  arg_1,
const analytic< complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 211 of file glue_analytic_floating.cpp.

00211                                                                                                                 {
00212     return arg_1 * arg_2;
00213   }

static analytic< complex<double> > mmx::GLUE_27 ( const complex< double > &  arg_1,
const analytic< complex< double > > &  arg_2 
) [static]

Definition at line 206 of file glue_analytic_double.cpp.

00206                                                                                               {
00207     return arg_1 * arg_2;
00208   }

static analytic< complex<mmx_floating> > mmx::GLUE_28 ( const analytic< complex< mmx_floating > > &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 216 of file glue_analytic_floating.cpp.

00216                                                                                                                 {
00217     return arg_1 * arg_2;
00218   }

static analytic< complex<double> > mmx::GLUE_28 ( const analytic< complex< double > > &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 211 of file glue_analytic_double.cpp.

00211                                                                                               {
00212     return arg_1 * arg_2;
00213   }

static analytic< complex<mmx_floating> > mmx::GLUE_29 ( const complex< mmx_floating > &  arg_1,
const analytic< complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 221 of file glue_analytic_floating.cpp.

00221                                                                                                                 {
00222     return arg_1 / arg_2;
00223   }

static analytic< complex<double> > mmx::GLUE_29 ( const complex< double > &  arg_1,
const analytic< complex< double > > &  arg_2 
) [static]

Definition at line 216 of file glue_analytic_double.cpp.

00216                                                                                               {
00217     return arg_1 / arg_2;
00218   }

static bool mmx::GLUE_3 ( const riemann_square< double > &  arg_1,
const riemann_square< double > &  arg_2 
) [static]

Definition at line 85 of file glue_riemann_double.cpp.

References intersect().

00085                                                                                     {
00086     return intersect (arg_1, arg_2);
00087   }

static vector<complex<rational> > mmx::GLUE_3 ( const vector< int > &  arg_1  )  [static]

Definition at line 170 of file glue_ode_taylor_floating.cpp.

00170                                     {
00171     return as<vector<complex<rational> > > (arg_1);
00172   }

static analytic< complex<mmx_floating> > mmx::GLUE_3 ( const complex< mmx_floating > &  arg_1  )  [static]

Definition at line 91 of file glue_analytic_floating.cpp.

References make_mmx_analytic().

00091                                               {
00092     return make_mmx_analytic (arg_1);
00093   }

static analytic< complex<double> > mmx::GLUE_3 ( const complex< double > &  arg_1  )  [static]

Definition at line 86 of file glue_analytic_double.cpp.

References make_mmx_analytic().

00086                                         {
00087     return make_mmx_analytic (arg_1);
00088   }

static analytic< mmx_ball(mmx_floating, complex<mmx_floating> ) > mmx::GLUE_3 ( const tuple< mmx_ball(mmx_floating, mmx_floating) > &  arg_1  )  [static]

Definition at line 97 of file glue_analytic_ball_floating.cpp.

References analytic_complex(), and as_vector().

00097                                                                      {
00098     return analytic_complex (as_vector (arg_1));
00099   }

static analytic< mmx_ball(double, complex<double> ) > mmx::GLUE_3 ( const tuple< mmx_ball(double, double) > &  arg_1  )  [static]

Definition at line 92 of file glue_analytic_ball_double.cpp.

References analytic_complex(), and as_vector().

Referenced by glue_homotopy_ball_double(), glue_homotopy_ball_floating(), glue_homotopy_double(), glue_homotopy_floating(), glue_ode_series_double(), glue_ode_series_floating(), glue_ode_taylor_double(), glue_ode_taylor_floating(), and glue_riemann_double().

00092                                                          {
00093     return analytic_complex (as_vector (arg_1));
00094   }

static analytic< complex<mmx_floating> > mmx::GLUE_30 ( const analytic< complex< mmx_floating > > &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 226 of file glue_analytic_floating.cpp.

00226                                                                                                                 {
00227     return arg_1 / arg_2;
00228   }

static analytic< complex<double> > mmx::GLUE_30 ( const analytic< complex< double > > &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 221 of file glue_analytic_double.cpp.

00221                                                                                               {
00222     return arg_1 / arg_2;
00223   }

static analytic< complex<mmx_floating> > mmx::GLUE_31 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 231 of file glue_analytic_floating.cpp.

References derive().

00231                                                                             {
00232     return derive (arg_1);
00233   }

static analytic< complex<double> > mmx::GLUE_31 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 226 of file glue_analytic_double.cpp.

References derive().

00226                                                                 {
00227     return derive (arg_1);
00228   }

static analytic< complex<mmx_floating> > mmx::GLUE_32 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 236 of file glue_analytic_floating.cpp.

References xderive().

00236                                                                             {
00237     return xderive (arg_1);
00238   }

static analytic< complex<double> > mmx::GLUE_32 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 231 of file glue_analytic_double.cpp.

References xderive().

00231                                                                 {
00232     return xderive (arg_1);
00233   }

static analytic< complex<mmx_floating> > mmx::GLUE_33 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 241 of file glue_analytic_floating.cpp.

References integrate().

00241                                                                             {
00242     return integrate (arg_1);
00243   }

static analytic< complex<double> > mmx::GLUE_33 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 236 of file glue_analytic_double.cpp.

References integrate().

00236                                                                 {
00237     return integrate (arg_1);
00238   }

static analytic< complex<mmx_floating> > mmx::GLUE_34 ( const analytic< complex< mmx_floating > > &  arg_1,
const analytic< complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 246 of file glue_analytic_floating.cpp.

References compose().

00246                                                                                                                                              {
00247     return compose (arg_1, arg_2);
00248   }

static analytic< complex<double> > mmx::GLUE_34 ( const analytic< complex< double > > &  arg_1,
const analytic< complex< double > > &  arg_2 
) [static]

Definition at line 241 of file glue_analytic_double.cpp.

References compose().

00241                                                                                                                      {
00242     return compose (arg_1, arg_2);
00243   }

static analytic< complex<mmx_floating> > mmx::GLUE_35 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 251 of file glue_analytic_floating.cpp.

References reverse().

00251                                                                             {
00252     return reverse (arg_1);
00253   }

static analytic< complex<double> > mmx::GLUE_35 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 246 of file glue_analytic_double.cpp.

References reverse().

00246                                                                 {
00247     return reverse (arg_1);
00248   }

static analytic< complex<mmx_floating> > mmx::GLUE_36 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 256 of file glue_analytic_floating.cpp.

References sqrt().

00256                                                                             {
00257     return sqrt (arg_1);
00258   }

static analytic< complex<double> > mmx::GLUE_36 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 251 of file glue_analytic_double.cpp.

References sqrt().

00251                                                                 {
00252     return sqrt (arg_1);
00253   }

static analytic< complex<mmx_floating> > mmx::GLUE_37 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 261 of file glue_analytic_floating.cpp.

References exp().

00261                                                                             {
00262     return exp (arg_1);
00263   }

static analytic< complex<double> > mmx::GLUE_37 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 256 of file glue_analytic_double.cpp.

References exp().

00256                                                                 {
00257     return exp (arg_1);
00258   }

static analytic< complex<mmx_floating> > mmx::GLUE_38 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 266 of file glue_analytic_floating.cpp.

References log().

00266                                                                             {
00267     return log (arg_1);
00268   }

static analytic< complex<double> > mmx::GLUE_38 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 261 of file glue_analytic_double.cpp.

References log().

00261                                                                 {
00262     return log (arg_1);
00263   }

static analytic< complex<mmx_floating> > mmx::GLUE_39 ( const analytic< complex< mmx_floating > > &  arg_1,
const analytic< complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 271 of file glue_analytic_floating.cpp.

References pow().

00271                                                                                                                                              {
00272     return pow (arg_1, arg_2);
00273   }

static analytic< complex<double> > mmx::GLUE_39 ( const analytic< complex< double > > &  arg_1,
const analytic< complex< double > > &  arg_2 
) [static]

Definition at line 266 of file glue_analytic_double.cpp.

References pow().

00266                                                                                                                      {
00267     return pow (arg_1, arg_2);
00268   }

static bool mmx::GLUE_4 ( const riemann_square< double > &  arg_1,
const riemann_square< double > &  arg_2 
) [static]

Definition at line 90 of file glue_riemann_double.cpp.

References included().

00090                                                                                     {
00091     return included (arg_1, arg_2);
00092   }

static vector<int> mmx::GLUE_4 ( const vector< integer > &  arg_1  )  [static]

Definition at line 175 of file glue_ode_taylor_floating.cpp.

00175                                         {
00176     return as<vector<int> > (arg_1);
00177   }

static analytic< complex<mmx_floating> > mmx::GLUE_4 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 96 of file glue_analytic_floating.cpp.

References fast_eval().

00096                                                                            {
00097     return fast_eval (arg_1);
00098   }

static analytic< complex<double> > mmx::GLUE_4 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 91 of file glue_analytic_double.cpp.

References fast_eval().

00091                                                                {
00092     return fast_eval (arg_1);
00093   }

static analytic< mmx_ball(mmx_floating, complex<mmx_floating> ) > mmx::GLUE_4 ( const tuple< mmx_ball(mmx_floating, complex< mmx_floating >) > &  arg_1  )  [static]

Definition at line 102 of file glue_analytic_ball_floating.cpp.

References as_vector(), and make_mmx_analytic().

00102                                                                                {
00103     return make_mmx_analytic (as_vector (arg_1));
00104   }

static analytic< mmx_ball(double, complex<double> ) > mmx::GLUE_4 ( const tuple< mmx_ball(double, complex< double >) > &  arg_1  )  [static]

Definition at line 97 of file glue_analytic_ball_double.cpp.

References as_vector(), and make_mmx_analytic().

Referenced by glue_homotopy_ball_double(), glue_homotopy_ball_floating(), glue_homotopy_double(), glue_homotopy_floating(), glue_ode_series_double(), glue_ode_series_floating(), glue_ode_taylor_double(), glue_ode_taylor_floating(), and glue_riemann_double().

00097                                                                    {
00098     return make_mmx_analytic (as_vector (arg_1));
00099   }

static analytic< complex<mmx_floating> > mmx::GLUE_40 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 276 of file glue_analytic_floating.cpp.

References cos().

00276                                                                             {
00277     return cos (arg_1);
00278   }

static analytic< complex<double> > mmx::GLUE_40 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 271 of file glue_analytic_double.cpp.

References cos().

00271                                                                 {
00272     return cos (arg_1);
00273   }

static analytic< complex<mmx_floating> > mmx::GLUE_41 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 281 of file glue_analytic_floating.cpp.

References sin().

00281                                                                             {
00282     return sin (arg_1);
00283   }

static analytic< complex<double> > mmx::GLUE_41 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 276 of file glue_analytic_double.cpp.

References sin().

00276                                                                 {
00277     return sin (arg_1);
00278   }

static analytic< complex<mmx_floating> > mmx::GLUE_42 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 286 of file glue_analytic_floating.cpp.

References tan().

00286                                                                             {
00287     return tan (arg_1);
00288   }

static analytic< complex<double> > mmx::GLUE_42 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 281 of file glue_analytic_double.cpp.

References tan().

00281                                                                 {
00282     return tan (arg_1);
00283   }

static analytic< complex<mmx_floating> > mmx::GLUE_43 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 291 of file glue_analytic_floating.cpp.

References acos().

00291                                                                             {
00292     return acos (arg_1);
00293   }

static analytic< complex<double> > mmx::GLUE_43 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 286 of file glue_analytic_double.cpp.

References acos().

00286                                                                 {
00287     return acos (arg_1);
00288   }

static analytic< complex<mmx_floating> > mmx::GLUE_44 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 296 of file glue_analytic_floating.cpp.

References asin().

00296                                                                             {
00297     return asin (arg_1);
00298   }

static analytic< complex<double> > mmx::GLUE_44 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 291 of file glue_analytic_double.cpp.

References asin().

00291                                                                 {
00292     return asin (arg_1);
00293   }

static analytic< complex<mmx_floating> > mmx::GLUE_45 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 301 of file glue_analytic_floating.cpp.

References atan().

00301                                                                             {
00302     return atan (arg_1);
00303   }

static analytic< complex<double> > mmx::GLUE_45 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 296 of file glue_analytic_double.cpp.

References atan().

00296                                                                 {
00297     return atan (arg_1);
00298   }

static vector< generic > GLUE_46 ( const routine &  arg_1,
const vector< generic > &  arg_2 
) [static]

Definition at line 306 of file glue_analytic_floating.cpp.

References gen_fixed_point_vector_analytic().

00306                                                                {
00307     return gen_fixed_point_vector_analytic (arg_1, arg_2);
00308   }

static vector< generic > GLUE_47 ( const routine &  arg_1,
const vector< generic > &  arg_2 
) [static]

Definition at line 311 of file glue_analytic_floating.cpp.

References gen_integrate_vector_analytic().

00311                                                                {
00312     return gen_integrate_vector_analytic (arg_1, arg_2);
00313   }

static analytic< complex<mmx_floating> > mmx::GLUE_48 ( const routine &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 316 of file glue_analytic_floating.cpp.

References fixed_point_analytic().

00316                                                                      {
00317     return fixed_point_analytic (arg_1, arg_2);
00318   }

static analytic< complex<double> > mmx::GLUE_48 ( const routine &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 311 of file glue_analytic_double.cpp.

References fixed_point_analytic().

00311                                                                {
00312     return fixed_point_analytic (arg_1, arg_2);
00313   }

static analytic< complex<mmx_floating> > mmx::GLUE_49 ( const routine &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 321 of file glue_analytic_floating.cpp.

References integrate_analytic().

00321                                                                      {
00322     return integrate_analytic (arg_1, arg_2);
00323   }

static analytic< complex<double> > mmx::GLUE_49 ( const routine &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 316 of file glue_analytic_double.cpp.

References integrate_analytic().

00316                                                                {
00317     return integrate_analytic (arg_1, arg_2);
00318   }

static bool mmx::GLUE_5 ( const riemann_square< double > &  arg_1,
const riemann_square< double > &  arg_2 
) [static]

Definition at line 95 of file glue_riemann_double.cpp.

References adjacent().

00095                                                                                     {
00096     return adjacent (arg_1, arg_2);
00097   }

static vector<mmx_ball(double, double) > mmx::GLUE_5 ( const vector< integer > &  arg_1  )  [static]

Definition at line 180 of file glue_ode_taylor_floating.cpp.

00180                                         {
00181     return as<vector<mmx_floating> > (arg_1);
00182   }

static analytic< complex<mmx_floating> > mmx::GLUE_5 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 101 of file glue_analytic_floating.cpp.

References cache_last().

00101                                                                            {
00102     return cache_last (arg_1);
00103   }

static analytic< complex<double> > mmx::GLUE_5 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 96 of file glue_analytic_double.cpp.

References cache_last().

00096                                                                {
00097     return cache_last (arg_1);
00098   }

static analytic< mmx_ball(mmx_floating, complex<mmx_floating> ) > mmx::GLUE_5 ( const mmx_ball(mmx_floating, complex< mmx_floating >)&  arg_1  )  [static]

Definition at line 107 of file glue_analytic_ball_floating.cpp.

References make_mmx_analytic().

00107                                                                        {
00108     return make_mmx_analytic (arg_1);
00109   }

static analytic< mmx_ball(double, complex<double> ) > mmx::GLUE_5 ( const mmx_ball(double, complex< double >)&  arg_1  )  [static]

Definition at line 102 of file glue_analytic_ball_double.cpp.

References make_mmx_analytic().

Referenced by glue_homotopy_ball_double(), glue_homotopy_ball_floating(), glue_homotopy_double(), glue_homotopy_floating(), glue_ode_series_double(), glue_ode_series_floating(), glue_ode_taylor_double(), glue_ode_taylor_floating(), and glue_riemann_double().

00102                                                            {
00103     return make_mmx_analytic (arg_1);
00104   }

static analytic< complex<mmx_floating> > mmx::GLUE_50 ( const polynomial< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 326 of file glue_analytic_floating.cpp.

References make_mmx_analytic().

00326                                                             {
00327     return make_mmx_analytic (arg_1);
00328   }

static analytic< complex<double> > mmx::GLUE_50 ( const polynomial< complex< double > > &  arg_1  )  [static]

Definition at line 321 of file glue_analytic_double.cpp.

References make_mmx_analytic().

00321                                                       {
00322     return make_mmx_analytic (arg_1);
00323   }

static analytic< complex<mmx_floating> > mmx::GLUE_51 ( const polynomial< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 331 of file glue_analytic_floating.cpp.

References std_heuristic().

00331                                                             {
00332     return std_heuristic (arg_1);
00333   }

static analytic< complex<double> > mmx::GLUE_51 ( const polynomial< complex< double > > &  arg_1  )  [static]

Definition at line 326 of file glue_analytic_double.cpp.

References std_heuristic().

00326                                                       {
00327     return std_heuristic (arg_1);
00328   }

static polynomial<complex<mmx_floating> > mmx::GLUE_52 ( const analytic< complex< mmx_floating > > &  arg_1,
const int &  arg_2,
const int &  arg_3 
) [static]

Definition at line 336 of file glue_analytic_floating.cpp.

References range().

00336                                                                                                                 {
00337     return range (arg_1, arg_2, arg_3);
00338   }

static polynomial<complex<double> > mmx::GLUE_52 ( const analytic< complex< double > > &  arg_1,
const int &  arg_2,
const int &  arg_3 
) [static]

Definition at line 331 of file glue_analytic_double.cpp.

References range().

00331                                                                                                     {
00332     return range (arg_1, arg_2, arg_3);
00333   }

static analytic< complex<mmx_floating> > mmx::GLUE_53 ( const analytic< complex< mmx_floating > > &  arg_1,
const vector< complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 341 of file glue_analytic_floating.cpp.

References move().

00341                                                                                                                          {
00342     return move (arg_1, arg_2);
00343   }

static analytic< complex<double> > mmx::GLUE_53 ( const analytic< complex< double > > &  arg_1,
const vector< complex< double > > &  arg_2 
) [static]

Definition at line 336 of file glue_analytic_double.cpp.

References move().

00336                                                                                                        {
00337     return move (arg_1, arg_2);
00338   }

static complex<mmx_floating> mmx::GLUE_54 ( const analytic< complex< mmx_floating > > &  arg_1,
const vector< complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 346 of file glue_analytic_floating.cpp.

References eval().

00346                                                                                                                          {
00347     return eval (arg_1, arg_2);
00348   }

static complex<double> mmx::GLUE_54 ( const analytic< complex< double > > &  arg_1,
const vector< complex< double > > &  arg_2 
) [static]

Definition at line 341 of file glue_analytic_double.cpp.

References eval().

00341                                                                                                        {
00342     return eval (arg_1, arg_2);
00343   }

static vector<generic> mmx::GLUE_55 ( const routine &  arg_1,
const vector< complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 351 of file glue_analytic_floating.cpp.

References gen_fixed_point_vector_analytic().

00351                                                                               {
00352     return gen_fixed_point_vector_analytic (arg_1, arg_2);
00353   }

static vector<generic> mmx::GLUE_55 ( const routine &  arg_1,
const vector< complex< double > > &  arg_2 
) [static]

Definition at line 346 of file glue_analytic_double.cpp.

References gen_fixed_point_vector_analytic().

00346                                                                         {
00347     return gen_fixed_point_vector_analytic (arg_1, arg_2);
00348   }

static vector<generic> mmx::GLUE_56 ( const routine &  arg_1,
const vector< complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 356 of file glue_analytic_floating.cpp.

References gen_integrate_vector_analytic().

00356                                                                               {
00357     return gen_integrate_vector_analytic (arg_1, arg_2);
00358   }

static vector<generic> mmx::GLUE_56 ( const routine &  arg_1,
const vector< complex< double > > &  arg_2 
) [static]

Definition at line 351 of file glue_analytic_double.cpp.

References gen_integrate_vector_analytic().

00351                                                                         {
00352     return gen_integrate_vector_analytic (arg_1, arg_2);
00353   }

static bool mmx::GLUE_6 ( const complex< double > &  arg_1,
const riemann_square< double > &  arg_2 
) [static]

Definition at line 100 of file glue_riemann_double.cpp.

References inside().

00100                                                                              {
00101     return inside (arg_1, arg_2);
00102   }

static vector<mmx_ball(double, complex<double> ) > mmx::GLUE_6 ( const vector< integer > &  arg_1  )  [static]

Definition at line 185 of file glue_ode_taylor_floating.cpp.

00185                                         {
00186     return as<vector<complex<mmx_floating> > > (arg_1);
00187   }

static analytic< complex<mmx_floating> > mmx::GLUE_6 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 106 of file glue_analytic_floating.cpp.

References rough().

00106                                                                            {
00107     return rough (arg_1);
00108   }

static analytic< complex<double> > mmx::GLUE_6 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 101 of file glue_analytic_double.cpp.

References rough().

00101                                                                {
00102     return rough (arg_1);
00103   }

static analytic< mmx_ball(mmx_floating, complex<mmx_floating> ) > mmx::GLUE_6 ( const polynomial< mmx_ball(mmx_floating, complex< mmx_floating >) > &  arg_1  )  [static]

Definition at line 112 of file glue_analytic_ball_floating.cpp.

References make_mmx_analytic().

00112                                                                                     {
00113     return make_mmx_analytic (arg_1);
00114   }

static analytic< mmx_ball(double, complex<double> ) > mmx::GLUE_6 ( const polynomial< mmx_ball(double, complex< double >) > &  arg_1  )  [static]

Definition at line 107 of file glue_analytic_ball_double.cpp.

References make_mmx_analytic().

Referenced by glue_homotopy_ball_double(), glue_homotopy_ball_floating(), glue_homotopy_double(), glue_homotopy_floating(), glue_ode_series_double(), glue_ode_series_floating(), glue_ode_taylor_double(), glue_ode_taylor_floating(), and glue_riemann_double().

00107                                                                         {
00108     return make_mmx_analytic (arg_1);
00109   }

static riemann_point<double> mmx::GLUE_7 ( const riemann_square< double > &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 105 of file glue_riemann_double.cpp.

00105                                                                              {
00106     return riemann_point<double > (arg_1, arg_2);
00107   }

static vector<generic> mmx::GLUE_7 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< mmx_floating > &  arg_3 
) [static]

Definition at line 190 of file glue_ode_taylor_floating.cpp.

References arg_1.

00190                                                                                                                                  {
00191     return solve_ode_taylor (arg_1, arg_2, arg_3);
00192   }

static vector<generic> mmx::GLUE_7 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< double > &  arg_3 
) [static]

Definition at line 185 of file glue_ode_taylor_double.cpp.

References arg_1.

00185                                                                                                                            {
00186     return solve_ode_taylor (arg_1, arg_2, arg_3);
00187   }

static vector<complex<mmx_floating> > mmx::GLUE_7 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< complex< mmx_floating > > &  arg_3,
const multivariate_coordinate<> &  arg_4,
const complex< mmx_floating > &  arg_5 
) [static]

Definition at line 190 of file glue_homotopy_floating.cpp.

References arg_1, and homotopy().

00190                                                                                                                                                                                                             {
00191     return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00192   }

static vector<complex<double> > mmx::GLUE_7 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< complex< double > > &  arg_3,
const multivariate_coordinate<> &  arg_4,
const complex< double > &  arg_5 
) [static]

Definition at line 186 of file glue_homotopy_double.cpp.

References arg_1, and homotopy().

00186                                                                                                                                                                                                 {
00187     return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00188   }

static vector<mmx_ball(mmx_floating, mmx_floating) > mmx::GLUE_7 ( const vector< rational > &  arg_1  )  [static]

Definition at line 196 of file glue_homotopy_ball_floating.cpp.

00196                                          {
00197     return as<vector<mmx_ball(mmx_floating, mmx_floating) > > (arg_1);
00198   }

static vector<mmx_ball(double, complex<double> ) > mmx::GLUE_7 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< mmx_ball(double, complex< double >) > &  arg_3,
const multivariate_coordinate<> &  arg_4,
const mmx_ball(double, complex< double >)&  arg_5 
) [static]

Definition at line 192 of file glue_homotopy_ball_double.cpp.

References homotopy().

00192                                                                                                                                                                                                                                       {
00193     return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00194   }

static complex<mmx_floating> mmx::GLUE_7 ( const analytic< complex< mmx_floating > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 111 of file glue_analytic_floating.cpp.

00111                                                                                              {
00112     return arg_1[arg_2];
00113   }

static complex<double> mmx::GLUE_7 ( const analytic< complex< double > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 106 of file glue_analytic_double.cpp.

00106                                                                                  {
00107     return arg_1[arg_2];
00108   }

static analytic< mmx_ball(mmx_floating, complex<mmx_floating> ) > mmx::GLUE_7 ( const analytic< mmx_ball(mmx_floating, complex< mmx_floating >) > &  arg_1  )  [static]

Definition at line 117 of file glue_analytic_ball_floating.cpp.

References fast_eval().

00117                                                                                                                              {
00118     return fast_eval (arg_1);
00119   }

static analytic< mmx_ball(double, complex<double> ) > mmx::GLUE_7 ( const analytic< mmx_ball(double, complex< double >) > &  arg_1  )  [static]

Definition at line 112 of file glue_analytic_ball_double.cpp.

References fast_eval().

Referenced by glue_homotopy_ball_double(), glue_homotopy_ball_floating(), glue_homotopy_double(), glue_homotopy_floating(), glue_ode_series_double(), glue_ode_series_floating(), glue_ode_taylor_double(), glue_ode_taylor_floating(), and glue_riemann_double().

00112                                                                                                      {
00113     return fast_eval (arg_1);
00114   }

static riemann_square<double> mmx::GLUE_8 ( const riemann_point< double > &  arg_1  )  [static]

Definition at line 110 of file glue_riemann_double.cpp.

References owner().

00110                                               {
00111     return owner (arg_1);
00112   }

static vector<generic> mmx::GLUE_8 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< mmx_floating > &  arg_3 
) [static]

Definition at line 195 of file glue_ode_taylor_floating.cpp.

References arg_1.

00195                                                                                                                                  {
00196     return first_variation_taylor (arg_1, arg_2, arg_3);
00197   }

static vector<generic> mmx::GLUE_8 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< double > &  arg_3 
) [static]

Definition at line 190 of file glue_ode_taylor_double.cpp.

References arg_1.

00190                                                                                                                            {
00191     return first_variation_taylor (arg_1, arg_2, arg_3);
00192   }

static vector<complex<mmx_floating> > mmx::GLUE_8 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< complex< mmx_floating > > &  arg_3,
const multivariate_coordinate<> &  arg_4,
const vector< complex< mmx_floating > > &  arg_5 
) [static]

Definition at line 195 of file glue_homotopy_floating.cpp.

References arg_1, and homotopy().

00195                                                                                                                                                                                                                      {
00196     return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00197   }

static vector<complex<double> > mmx::GLUE_8 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< complex< double > > &  arg_3,
const multivariate_coordinate<> &  arg_4,
const vector< complex< double > > &  arg_5 
) [static]

Definition at line 191 of file glue_homotopy_double.cpp.

References arg_1, and homotopy().

00191                                                                                                                                                                                                          {
00192     return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00193   }

static vector<mmx_ball(mmx_floating, complex<mmx_floating> ) > mmx::GLUE_8 ( const vector< rational > &  arg_1  )  [static]

Definition at line 201 of file glue_homotopy_ball_floating.cpp.

00201                                          {
00202     return as<vector<mmx_ball(mmx_floating, complex<mmx_floating> ) > > (arg_1);
00203   }

static vector<mmx_ball(double, complex<double> ) > mmx::GLUE_8 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< mmx_ball(double, complex< double >) > &  arg_3,
const multivariate_coordinate<> &  arg_4,
const vector< mmx_ball(double, complex< double >) > &  arg_5 
) [static]

Definition at line 197 of file glue_homotopy_ball_double.cpp.

References homotopy().

00197                                                                                                                                                                                                                                                {
00198     return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00199   }

static mmx_floating mmx::GLUE_8 ( const analytic< complex< mmx_floating > > &  arg_1  )  [static]

Definition at line 116 of file glue_analytic_floating.cpp.

00116                                                                            {
00117     return radius_bound (arg_1);
00118   }

static double mmx::GLUE_8 ( const analytic< complex< double > > &  arg_1  )  [static]

Definition at line 111 of file glue_analytic_double.cpp.

00111                                                                {
00112     return radius_bound (arg_1);
00113   }

static analytic< mmx_ball(mmx_floating, complex<mmx_floating> ) > mmx::GLUE_8 ( const analytic< mmx_ball(mmx_floating, complex< mmx_floating >) > &  arg_1  )  [static]

Definition at line 122 of file glue_analytic_ball_floating.cpp.

References cache_last().

00122                                                                                                                              {
00123     return cache_last (arg_1);
00124   }

static analytic< mmx_ball(double, complex<double> ) > mmx::GLUE_8 ( const analytic< mmx_ball(double, complex< double >) > &  arg_1  )  [static]

Definition at line 117 of file glue_analytic_ball_double.cpp.

References cache_last().

Referenced by glue_homotopy_ball_double(), glue_homotopy_ball_floating(), glue_homotopy_double(), glue_homotopy_floating(), glue_ode_series_double(), glue_ode_series_floating(), glue_ode_taylor_double(), glue_ode_taylor_floating(), and glue_riemann_double().

00117                                                                                                      {
00118     return cache_last (arg_1);
00119   }

static complex<double> mmx::GLUE_9 ( const riemann_point< double > &  arg_1  )  [static]

Definition at line 115 of file glue_riemann_double.cpp.

References project().

00115                                               {
00116     return project (arg_1);
00117   }

static vector<generic> mmx::GLUE_9 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< mmx_floating > &  arg_3,
const mmx_floating &  arg_4 
) [static]

Definition at line 200 of file glue_ode_taylor_floating.cpp.

References arg_1.

00200                                                                                                                                                             {
00201     return integrate_ode_taylor (arg_1, arg_2, arg_3, arg_4);
00202   }

static vector<generic> mmx::GLUE_9 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< double > &  arg_3,
const double &  arg_4 
) [static]

Definition at line 195 of file glue_ode_taylor_double.cpp.

References arg_1.

00195                                                                                                                                                 {
00196     return integrate_ode_taylor (arg_1, arg_2, arg_3, arg_4);
00197   }

static vector<generic> mmx::GLUE_9 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< complex< mmx_floating > > &  arg_3 
) [static]

Definition at line 204 of file glue_ode_series_floating.cpp.

References arg_1, and solve_ode_series().

00204                                                                                                                                            {
00205     return solve_ode_series (arg_1, arg_2, arg_3);
00206   }

static vector<generic> mmx::GLUE_9 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const vector< complex< double > > &  arg_3 
) [static]

Definition at line 200 of file glue_ode_series_double.cpp.

References arg_1, and solve_ode_series().

00200                                                                                                                                      {
00201     return solve_ode_series (arg_1, arg_2, arg_3);
00202   }

static matrix<complex<mmx_floating> > mmx::GLUE_9 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const matrix< complex< mmx_floating > > &  arg_3,
const multivariate_coordinate<> &  arg_4,
const complex< mmx_floating > &  arg_5 
) [static]

Definition at line 200 of file glue_homotopy_floating.cpp.

References arg_1, and homotopy().

00200                                                                                                                                                                                                             {
00201     return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00202   }

static matrix<complex<double> > mmx::GLUE_9 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const matrix< complex< double > > &  arg_3,
const multivariate_coordinate<> &  arg_4,
const complex< double > &  arg_5 
) [static]

Definition at line 196 of file glue_homotopy_double.cpp.

References arg_1, and homotopy().

00196                                                                                                                                                                                                 {
00197     return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00198   }

static vector<mmx_ball(mmx_floating, complex<mmx_floating> ) > mmx::GLUE_9 ( const vector< complex< rational > > &  arg_1  )  [static]

Definition at line 206 of file glue_homotopy_ball_floating.cpp.

00206                                                    {
00207     return as<vector<mmx_ball(mmx_floating, complex<mmx_floating> ) > > (arg_1);
00208   }

static matrix<mmx_ball(double, complex<double> ) > mmx::GLUE_9 ( const vector< multivariate< sparse_polynomial< rational > > > &  arg_1,
const vector< multivariate_coordinate<> > &  arg_2,
const matrix< mmx_ball(double, complex< double >) > &  arg_3,
const multivariate_coordinate<> &  arg_4,
const mmx_ball(double, complex< double >)&  arg_5 
) [static]

Definition at line 202 of file glue_homotopy_ball_double.cpp.

References homotopy().

00202                                                                                                                                                                                                                                       {
00203     return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00204   }

static mmx_floating mmx::GLUE_9 ( const analytic< complex< mmx_floating > > &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 121 of file glue_analytic_floating.cpp.

00121                                                                                                       {
00122     return upper_bound (arg_1, arg_2);
00123   }

static double mmx::GLUE_9 ( const analytic< complex< double > > &  arg_1,
const double &  arg_2 
) [static]

Definition at line 116 of file glue_analytic_double.cpp.

00116                                                                                     {
00117     return upper_bound (arg_1, arg_2);
00118   }

static analytic< mmx_ball(mmx_floating, complex<mmx_floating> ) > mmx::GLUE_9 ( const analytic< mmx_ball(mmx_floating, complex< mmx_floating >) > &  arg_1  )  [static]

Definition at line 127 of file glue_analytic_ball_floating.cpp.

References rough().

00127                                                                                                                              {
00128     return rough (arg_1);
00129   }

static analytic< mmx_ball(double, complex<double> ) > mmx::GLUE_9 ( const analytic< mmx_ball(double, complex< double >) > &  arg_1  )  [static]

Definition at line 122 of file glue_analytic_ball_double.cpp.

References rough().

Referenced by glue_homotopy_ball_double(), glue_homotopy_ball_floating(), glue_homotopy_double(), glue_homotopy_floating(), glue_ode_series_double(), glue_ode_series_floating(), glue_ode_taylor_double(), glue_ode_taylor_floating(), and glue_riemann_double().

00122                                                                                                      {
00123     return rough (arg_1);
00124   }

void mmx::glue_analytic_ball_double (  ) 

Referenced by glue_continewz().

void mmx::glue_analytic_ball_floating (  ) 

Referenced by glue_continewz().

void glue_analytic_double (  ) 

Referenced by glue_continewz().

void glue_analytic_floating (  ) 

Referenced by glue_continewz().

void mmx::glue_continewz (  ) 

Definition at line 21 of file glue_continewz.cpp.

References glue_analytic_ball_double(), glue_analytic_ball_floating(), glue_analytic_double(), glue_analytic_floating(), glue_homotopy_ball_double(), glue_homotopy_ball_floating(), glue_homotopy_double(), glue_homotopy_floating(), glue_ode_series_double(), glue_ode_series_floating(), glue_ode_taylor_double(), glue_ode_taylor_floating(), and glue_riemann_double().

00021                     {
00022     static bool done = false;
00023     if (done) return;
00024     done = true;
00025     register_glue (string ("glue_analytic_ball_double"), (& (glue_analytic_ball_double)));
00026     register_glue (string ("glue_analytic_ball_floating"), (& (glue_analytic_ball_floating)));
00027     register_glue (string ("glue_analytic_double"), (& (glue_analytic_double)));
00028     register_glue (string ("glue_analytic_floating"), (& (glue_analytic_floating)));
00029     register_glue (string ("glue_homotopy_ball_double"), (& (glue_homotopy_ball_double)));
00030     register_glue (string ("glue_homotopy_ball_floating"), (& (glue_homotopy_ball_floating)));
00031     register_glue (string ("glue_homotopy_double"), (& (glue_homotopy_double)));
00032     register_glue (string ("glue_homotopy_floating"), (& (glue_homotopy_floating)));
00033     register_glue (string ("glue_ode_series_double"), (& (glue_ode_series_double)));
00034     register_glue (string ("glue_ode_series_floating"), (& (glue_ode_series_floating)));
00035     register_glue (string ("glue_ode_taylor_double"), (& (glue_ode_taylor_double)));
00036     register_glue (string ("glue_ode_taylor_floating"), (& (glue_ode_taylor_floating)));
00037     register_glue (string ("glue_riemann_double"), (& (glue_riemann_double)));
00038     register_glue (string ("glue_continewz"), (& (glue_continewz)));
00039     dl_link ("multimix");
00040     glue_analytic_ball_double ();
00041     glue_analytic_ball_floating ();
00042     glue_analytic_double ();
00043     glue_analytic_floating ();
00044     glue_homotopy_ball_double ();
00045     glue_homotopy_ball_floating ();
00046     glue_homotopy_double ();
00047     glue_homotopy_floating ();
00048     glue_ode_series_double ();
00049     glue_ode_series_floating ();
00050     glue_ode_taylor_double ();
00051     glue_ode_taylor_floating ();
00052     glue_riemann_double ();
00053     include ("continewz/paths.mmx");
00054   }

void glue_homotopy_ball_double (  ) 

Definition at line 227 of file glue_homotopy_ball_double.cpp.

References GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_2(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_continewz().

00227                                {
00228     static bool done = false;
00229     if (done) return;
00230     done = true;
00231     call_glue (string ("glue_matrix_ball_double"));
00232     call_glue (string ("glue_mvpolynomial_rational"));
00233     static alias<int> mmx_significant_digits_alias = global_alias (((int&) mmx_significant_digits));
00234     define_constant<alias<int> > ("significant_digits", mmx_significant_digits_alias);
00235     static alias<int> mmx_bit_precision_alias = global_alias (((int&) mmx_bit_precision));
00236     define_constant<alias<int> > ("bit_precision", mmx_bit_precision_alias);
00237     static alias<int> mmx_discrepancy_alias = global_alias (((int&) mmx_discrepancy));
00238     define_constant<alias<int> > ("discrepancy", mmx_discrepancy_alias);
00239     static alias<bool> mmx_pretty_exponents_alias = global_alias (((bool&) mmx_pretty_exponents));
00240     define_constant<alias<bool> > ("pretty_exponents", mmx_pretty_exponents_alias);
00241     define_converter (":>", GLUE_1, PENALTY_INCLUSION);
00242     define_converter (":>", GLUE_2, PENALTY_INCLUSION);
00243     define_converter (":>", GLUE_3, PENALTY_HOMOMORPHISM);
00244     define_converter (":>", GLUE_4, PENALTY_INCLUSION);
00245     define_converter (":>", GLUE_5, PENALTY_INCLUSION);
00246     define_converter (":>", GLUE_6, PENALTY_HOMOMORPHISM);
00247     define ("homotopy", GLUE_7);
00248     define ("homotopy", GLUE_8);
00249     define ("homotopy", GLUE_9);
00250     define ("homotopy", GLUE_10);
00251     define_converter (":>", GLUE_11, PENALTY_INCLUSION);
00252     define_converter (":>", GLUE_12, PENALTY_HOMOMORPHISM);
00253     define_converter (":>", GLUE_13, PENALTY_INCLUSION);
00254   }

void glue_homotopy_ball_floating (  ) 

Definition at line 231 of file glue_homotopy_ball_floating.cpp.

References GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_2(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_continewz().

00231                                  {
00232     static bool done = false;
00233     if (done) return;
00234     done = true;
00235     call_glue (string ("glue_matrix_ball_floating"));
00236     call_glue (string ("glue_mvpolynomial_rational"));
00237     define_converter (":>", GLUE_1, PENALTY_INCLUSION);
00238     define_converter (":>", GLUE_2, PENALTY_INCLUSION);
00239     define_converter (":>", GLUE_3, PENALTY_HOMOMORPHISM);
00240     define_converter (":>", GLUE_4, PENALTY_INCLUSION);
00241     define_converter (":>", GLUE_5, PENALTY_INCLUSION);
00242     define_converter (":>", GLUE_6, PENALTY_HOMOMORPHISM);
00243     define_converter (":>", GLUE_7, PENALTY_INCLUSION);
00244     define_converter (":>", GLUE_8, PENALTY_HOMOMORPHISM);
00245     define_converter (":>", GLUE_9, PENALTY_INCLUSION);
00246     define ("homotopy", GLUE_10);
00247     define ("homotopy", GLUE_11);
00248     define ("homotopy", GLUE_12);
00249     define ("homotopy", GLUE_13);
00250   }

void glue_homotopy_double (  ) 

Definition at line 221 of file glue_homotopy_double.cpp.

References GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_2(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_continewz().

00221                           {
00222     static bool done = false;
00223     if (done) return;
00224     done = true;
00225     call_glue (string ("glue_matrix_double"));
00226     call_glue (string ("glue_mvpolynomial_rational"));
00227     static alias<int> mmx_significant_digits_alias = global_alias (((int&) mmx_significant_digits));
00228     define_constant<alias<int> > ("significant_digits", mmx_significant_digits_alias);
00229     static alias<int> mmx_bit_precision_alias = global_alias (((int&) mmx_bit_precision));
00230     define_constant<alias<int> > ("bit_precision", mmx_bit_precision_alias);
00231     static alias<int> mmx_discrepancy_alias = global_alias (((int&) mmx_discrepancy));
00232     define_constant<alias<int> > ("discrepancy", mmx_discrepancy_alias);
00233     static alias<bool> mmx_pretty_exponents_alias = global_alias (((bool&) mmx_pretty_exponents));
00234     define_constant<alias<bool> > ("pretty_exponents", mmx_pretty_exponents_alias);
00235     define_converter (":>", GLUE_1, PENALTY_INCLUSION);
00236     define_converter (":>", GLUE_2, PENALTY_INCLUSION);
00237     define_converter (":>", GLUE_3, PENALTY_HOMOMORPHISM);
00238     define_converter (":>", GLUE_4, PENALTY_INCLUSION);
00239     define_converter (":>", GLUE_5, PENALTY_INCLUSION);
00240     define_converter (":>", GLUE_6, PENALTY_HOMOMORPHISM);
00241     define ("homotopy", GLUE_7);
00242     define ("homotopy", GLUE_8);
00243     define ("homotopy", GLUE_9);
00244     define ("homotopy", GLUE_10);
00245     define_converter (":>", GLUE_11, PENALTY_INCLUSION);
00246     define_converter (":>", GLUE_12, PENALTY_HOMOMORPHISM);
00247     define_converter (":>", GLUE_13, PENALTY_INCLUSION);
00248   }

void glue_homotopy_floating (  ) 

Definition at line 225 of file glue_homotopy_floating.cpp.

References GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_2(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_continewz().

00225                             {
00226     static bool done = false;
00227     if (done) return;
00228     done = true;
00229     call_glue (string ("glue_matrix_floating"));
00230     call_glue (string ("glue_mvpolynomial_rational"));
00231     define_converter (":>", GLUE_1, PENALTY_INCLUSION);
00232     define_converter (":>", GLUE_2, PENALTY_INCLUSION);
00233     define_converter (":>", GLUE_3, PENALTY_HOMOMORPHISM);
00234     define_converter (":>", GLUE_4, PENALTY_INCLUSION);
00235     define_converter (":>", GLUE_5, PENALTY_INCLUSION);
00236     define_converter (":>", GLUE_6, PENALTY_HOMOMORPHISM);
00237     define ("homotopy", GLUE_7);
00238     define ("homotopy", GLUE_8);
00239     define ("homotopy", GLUE_9);
00240     define ("homotopy", GLUE_10);
00241     define_converter (":>", GLUE_11, PENALTY_INCLUSION);
00242     define_converter (":>", GLUE_12, PENALTY_HOMOMORPHISM);
00243     define_converter (":>", GLUE_13, PENALTY_INCLUSION);
00244   }

void glue_ode_series_double (  ) 

Definition at line 225 of file glue_ode_series_double.cpp.

References GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_2(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_continewz().

00225                             {
00226     static bool done = false;
00227     if (done) return;
00228     done = true;
00229     call_glue (string ("glue_matrix_double"));
00230     call_glue (string ("glue_mvpolynomial_rational"));
00231     static alias<int> mmx_significant_digits_alias = global_alias (((int&) mmx_significant_digits));
00232     define_constant<alias<int> > ("significant_digits", mmx_significant_digits_alias);
00233     static alias<int> mmx_bit_precision_alias = global_alias (((int&) mmx_bit_precision));
00234     define_constant<alias<int> > ("bit_precision", mmx_bit_precision_alias);
00235     static alias<int> mmx_discrepancy_alias = global_alias (((int&) mmx_discrepancy));
00236     define_constant<alias<int> > ("discrepancy", mmx_discrepancy_alias);
00237     static alias<bool> mmx_pretty_exponents_alias = global_alias (((bool&) mmx_pretty_exponents));
00238     define_constant<alias<bool> > ("pretty_exponents", mmx_pretty_exponents_alias);
00239     define_converter (":>", GLUE_1, PENALTY_INCLUSION);
00240     define_converter (":>", GLUE_2, PENALTY_INCLUSION);
00241     define_converter (":>", GLUE_3, PENALTY_HOMOMORPHISM);
00242     define_converter (":>", GLUE_4, PENALTY_INCLUSION);
00243     define_converter (":>", GLUE_5, PENALTY_INCLUSION);
00244     define_converter (":>", GLUE_6, PENALTY_HOMOMORPHISM);
00245     define ("solve_ode_series", GLUE_7);
00246     define ("first_variation_series", GLUE_8);
00247     define ("solve_ode_series", GLUE_9);
00248     define ("first_variation_series", GLUE_10);
00249     define_converter (":>", GLUE_11, PENALTY_INCLUSION);
00250     define_converter (":>", GLUE_12, PENALTY_HOMOMORPHISM);
00251     define_converter (":>", GLUE_13, PENALTY_INCLUSION);
00252   }

void glue_ode_series_floating (  ) 

Definition at line 229 of file glue_ode_series_floating.cpp.

References GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_2(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_continewz().

00229                               {
00230     static bool done = false;
00231     if (done) return;
00232     done = true;
00233     call_glue (string ("glue_matrix_floating"));
00234     call_glue (string ("glue_mvpolynomial_rational"));
00235     define_converter (":>", GLUE_1, PENALTY_INCLUSION);
00236     define_converter (":>", GLUE_2, PENALTY_INCLUSION);
00237     define_converter (":>", GLUE_3, PENALTY_HOMOMORPHISM);
00238     define_converter (":>", GLUE_4, PENALTY_INCLUSION);
00239     define_converter (":>", GLUE_5, PENALTY_INCLUSION);
00240     define_converter (":>", GLUE_6, PENALTY_HOMOMORPHISM);
00241     define ("solve_ode_series", GLUE_7);
00242     define ("first_variation_series", GLUE_8);
00243     define ("solve_ode_series", GLUE_9);
00244     define ("first_variation_series", GLUE_10);
00245     define_converter (":>", GLUE_11, PENALTY_INCLUSION);
00246     define_converter (":>", GLUE_12, PENALTY_HOMOMORPHISM);
00247     define_converter (":>", GLUE_13, PENALTY_INCLUSION);
00248   }

void glue_ode_taylor_double (  ) 

Definition at line 230 of file glue_ode_taylor_double.cpp.

References GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_14(), GLUE_15(), GLUE_2(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), GLUE_9(), mmx_ode_order, and mmx_ode_precision.

Referenced by glue_continewz().

00230                             {
00231     static bool done = false;
00232     if (done) return;
00233     done = true;
00234     call_glue (string ("glue_matrix_double"));
00235     call_glue (string ("glue_mvpolynomial_rational"));
00236     static alias<int> mmx_significant_digits_alias = global_alias (((int&) mmx_significant_digits));
00237     define_constant<alias<int> > ("significant_digits", mmx_significant_digits_alias);
00238     static alias<int> mmx_bit_precision_alias = global_alias (((int&) mmx_bit_precision));
00239     define_constant<alias<int> > ("bit_precision", mmx_bit_precision_alias);
00240     static alias<int> mmx_discrepancy_alias = global_alias (((int&) mmx_discrepancy));
00241     define_constant<alias<int> > ("discrepancy", mmx_discrepancy_alias);
00242     static alias<bool> mmx_pretty_exponents_alias = global_alias (((bool&) mmx_pretty_exponents));
00243     define_constant<alias<bool> > ("pretty_exponents", mmx_pretty_exponents_alias);
00244     static alias<int> mmx_ode_order_alias = global_alias (((int&) mmx_ode_order));
00245     define_constant<alias<int> > ("ode_order", mmx_ode_order_alias);
00246     static alias<int> mmx_ode_precision_alias = global_alias (((int&) mmx_ode_precision));
00247     define_constant<alias<int> > ("ode_precision", mmx_ode_precision_alias);
00248     define_converter (":>", GLUE_1, PENALTY_INCLUSION);
00249     define_converter (":>", GLUE_2, PENALTY_INCLUSION);
00250     define_converter (":>", GLUE_3, PENALTY_HOMOMORPHISM);
00251     define_converter (":>", GLUE_4, PENALTY_INCLUSION);
00252     define_converter (":>", GLUE_5, PENALTY_INCLUSION);
00253     define_converter (":>", GLUE_6, PENALTY_HOMOMORPHISM);
00254     define ("solve_ode_taylor", GLUE_7);
00255     define ("first_variation_taylor", GLUE_8);
00256     define ("integrate_ode_taylor", GLUE_9);
00257     define ("solve_ode_taylor", GLUE_10);
00258     define ("first_variation_taylor", GLUE_11);
00259     define ("integrate_ode_taylor", GLUE_12);
00260     define_converter (":>", GLUE_13, PENALTY_INCLUSION);
00261     define_converter (":>", GLUE_14, PENALTY_HOMOMORPHISM);
00262     define_converter (":>", GLUE_15, PENALTY_INCLUSION);
00263   }

void glue_ode_taylor_floating (  ) 

Definition at line 235 of file glue_ode_taylor_floating.cpp.

References GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_14(), GLUE_15(), GLUE_2(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), GLUE_9(), mmx_ode_order, and mmx_ode_precision.

Referenced by glue_continewz().

00235                               {
00236     static bool done = false;
00237     if (done) return;
00238     done = true;
00239     call_glue (string ("glue_matrix_floating"));
00240     call_glue (string ("glue_mvpolynomial_rational"));
00241     static alias<int> mmx_ode_order_alias = global_alias (((int&) mmx_ode_order));
00242     define_constant<alias<int> > ("ode_order", mmx_ode_order_alias);
00243     static alias<int> mmx_ode_precision_alias = global_alias (((int&) mmx_ode_precision));
00244     define_constant<alias<int> > ("ode_precision", mmx_ode_precision_alias);
00245     define_converter (":>", GLUE_1, PENALTY_INCLUSION);
00246     define_converter (":>", GLUE_2, PENALTY_INCLUSION);
00247     define_converter (":>", GLUE_3, PENALTY_HOMOMORPHISM);
00248     define_converter (":>", GLUE_4, PENALTY_INCLUSION);
00249     define_converter (":>", GLUE_5, PENALTY_INCLUSION);
00250     define_converter (":>", GLUE_6, PENALTY_HOMOMORPHISM);
00251     define ("solve_ode_taylor", GLUE_7);
00252     define ("first_variation_taylor", GLUE_8);
00253     define ("integrate_ode_taylor", GLUE_9);
00254     define ("solve_ode_taylor", GLUE_10);
00255     define ("first_variation_taylor", GLUE_11);
00256     define ("integrate_ode_taylor", GLUE_12);
00257     define_converter (":>", GLUE_13, PENALTY_INCLUSION);
00258     define_converter (":>", GLUE_14, PENALTY_HOMOMORPHISM);
00259     define_converter (":>", GLUE_15, PENALTY_INCLUSION);
00260   }

void glue_riemann_double (  ) 

Definition at line 180 of file glue_riemann_double.cpp.

References GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_14(), GLUE_15(), GLUE_16(), GLUE_17(), GLUE_18(), GLUE_19(), GLUE_2(), GLUE_20(), GLUE_21(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_continewz().

00180                          {
00181     static bool done = false;
00182     if (done) return;
00183     done = true;
00184     call_glue (string ("glue_polynomial_double"));
00185     define_type<riemann_square<double> > (gen (lit ("Riemann_square"), lit ("Double")));
00186     define_type<riemann_point<double> > (gen (lit ("Riemann_point"), lit ("Double")));
00187     define_type<riemann_surface<double> > (gen (lit ("Riemann_surface"), lit ("Double")));
00188     define_type<riemann_germ<double> > (gen (lit ("Riemann_germ"), lit ("Double")));
00189     define_type<simple_riemann_bundle(double) > (gen (lit ("Riemann_bundle"), lit ("Double")));
00190     define ("riemann_square", GLUE_1);
00191     define ("admissible?", GLUE_2);
00192     define ("intersect?", GLUE_3);
00193     define ("included?", GLUE_4);
00194     define ("adjacent?", GLUE_5);
00195     define ("inside?", GLUE_6);
00196     define ("riemann_point", GLUE_7);
00197     define ("owner", GLUE_8);
00198     define ("owner", GLUE_9);
00199     define ("riemann_disk", GLUE_10);
00200     define ("glue", GLUE_11);
00201     define ("plane?", GLUE_12);
00202     define ("lift", GLUE_13);
00203     define ("move", GLUE_14);
00204     define ("center", GLUE_15);
00205     define ("radius", GLUE_16);
00206     define ("eval", GLUE_17);
00207     define ("riemann_bundle", GLUE_18);
00208     define ("glue", GLUE_19);
00209     define ("surface", GLUE_20);
00210     define ("riemann_germ", GLUE_21);
00211   }

mmx::HARD_TO_EXACT_IDENTITY_SUGAR ( template< typename C, typename V >  ,
analytic< C, V >   
)
V nat mmx::hash ( const analytic< C, V > &  f  )  [inline]

Definition at line 420 of file analytic.hpp.

References expand().

00420                                          {
00421   return 7002007 + hash (expand (f)); }

vector< Abs_type(C) > mmx::head_extremum ( const analytic< vector< C >, V > &  f,
const Abs_type(typename unvectorize< C >::val)&  r,
nat  order,
int  type 
) [inline]

Definition at line 107 of file analytic_vector.hpp.

References access(), f, head_extremum(), and R.

00108                                                      {
00109   nat i, n= N(f[0]);
00110   vector<R > b (R (0), n);
00111   for (i=0; i<n; i++)
00112     b[i]= head_extremum (access (f, i), r, order, type);
00113   return b;
00114 }

matrix< Abs_type(C) > mmx::head_extremum ( const analytic< matrix< C >, V > &  f,
const Abs_type(typename unvectorize< C >::val)&  r,
nat  order,
int  type 
) [inline]

Definition at line 117 of file analytic_matrix.hpp.

References access(), f, and R.

Referenced by head_extremum().

00118                                                      {
00119   nat i, j, nr= rows (f[0]), nc= cols (f[0]);
00120   matrix<R > b (R (0), nr, nc);
00121   for (i=0; i<nr; i++)
00122     for (j=0; j<nc; j++)
00123       b (i, j)= head_extremum (access (f, i, j), r, order, type);
00124   return b;
00125 }

analytic< C, V > heuristic ( const heuristic_analytic_rep< C, V > *  prev,
const polynomial< C > &  p,
const analytic< C, V > &  phi,
const C &  t,
const C &  u 
) [inline]

Definition at line 181 of file analytic_heuristic.hpp.

References Analytic_rep.

00182                                                         {
00183   return (Analytic_rep*) new heuristic_analytic_rep<C,V> (prev, p, phi, t, u);
00184 }

analytic< C, V > heuristic ( const polynomial< C > &  f  )  [inline]

Definition at line 176 of file analytic_heuristic.hpp.

References Analytic_rep.

00176                                 {
00177   return (Analytic_rep*) new heuristic_analytic_rep<C,V> (p);
00178 }

void mmx::heuristic_change ( analytic< C > &  phi,
analytic< C > &  psi,
analytic< C > &  ret,
const analytic< C > &  src,
const C &  v1,
const C &  v2,
const Abs_type(C)&  r 
) [inline]

Definition at line 56 of file analytic_heuristic.hpp.

References C, and radial().

Referenced by heuristic_analytic_rep< C, V >::Move().

00059 {
00060   C u= v2 - v1;
00061   u= (u / abs (u)) * r;
00062   analytic<C> z (polynomial<C> (promote (1, v1), (nat) 1));
00063   phi= radial (u * z / (analytic<C> (u) + z));
00064   psi= radial (u * z / (analytic<C> (u) - z));
00065   ret= radial (u * src / (analytic<C> (u) + src));
00066   /*
00067   phi= radial (u * (1 - exp (- z / u)));
00068   psi= radial (- u * log (1 - z / u));
00069   ret= radial (u * (1 - exp (- src / u)));
00070   */
00071 }

matrix<C> mmx::homotopy ( const vector< multivariate< sparse_polynomial< rational > > > &  f,
const vector< multivariate_coordinate<> > &  vars,
const matrix< C > &  x,
const multivariate_coordinate<> &  var,
const Path &  p 
) [inline]

Definition at line 179 of file homotopy.hpp.

References f, and homotopy().

00183                          {
00184   return row_matrix (homotopy (f, vars, row_vectors (x), var, p));
00185 }

vector<vector<C> > mmx::homotopy ( const vector< multivariate< sparse_polynomial< rational > > > &  f,
const vector< multivariate_coordinate<> > &  vars,
const vector< vector< C > > &  x,
const multivariate_coordinate<> &  var,
const Path &  p 
) [inline]

Definition at line 164 of file homotopy.hpp.

References C, CF(), f, Function, Homotopy_variant, homx(), Stepper, and V.

00168                          {
00169   if (N(x) == 0) return x;
00170   typedef Homotopy_variant(C) V;
00171   Function ff= as_slp_tangent (f, vars, CF (x[0]));
00172   Stepper stepper (ff);
00173   nat k= find (vars, var);
00174   ASSERT (k < N(vars), "coordinate not found");
00175   return homx (stepper, x, k, p);
00176 }

vector<C> mmx::homotopy ( const vector< multivariate< sparse_polynomial< rational > > > &  f,
const vector< multivariate_coordinate<> > &  vars,
const vector< C > &  x,
const multivariate_coordinate<> &  var,
const Path &  p 
) [inline]

Definition at line 150 of file homotopy.hpp.

References C, CF(), f, Function, Homotopy_variant, homx(), Stepper, and V.

Referenced by GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_7(), GLUE_8(), GLUE_9(), and homotopy().

00154                          {
00155   typedef Homotopy_variant(C) V;
00156   Function ff= as_slp_tangent (f, vars, CF (x));
00157   Stepper stepper (ff);
00158   nat k= find (vars, var);
00159   ASSERT (k < N(vars), "coordinate not found");
00160   return homx (stepper, x, k, p);
00161 }

vector<vector<C> > mmx::homx ( const homotopy_stepper< C, V > &  stepper,
const vector< vector< C > > &  x,
nat  k,
const vector< C > &  p 
) [inline]

Definition at line 118 of file homotopy.hpp.

References inside(), and Stepper_rep.

00120 {
00121   return const_cast<Stepper_rep*> (inside (stepper)) -> homvp (x, k, p);
00122 }

vector<vector<C> > mmx::homx ( const homotopy_stepper< C, V > &  stepper,
const vector< vector< C > > &  x,
nat  k,
const C &  t1 
) [inline]

Definition at line 111 of file homotopy.hpp.

References inside(), and Stepper_rep.

00113 {
00114   return const_cast<Stepper_rep*> (inside (stepper)) -> homv (x, k, t1);
00115 }

vector<C> mmx::homx ( const homotopy_stepper< C, V > &  stepper,
const vector< C > &  x,
nat  k,
const vector< C > &  p 
) [inline]

Definition at line 105 of file homotopy.hpp.

References inside(), and Stepper_rep.

00106                                                      {
00107   return const_cast<Stepper_rep*> (inside (stepper)) -> homp (x, k, p);
00108 }

V vector<C> mmx::homx ( const homotopy_stepper< C, V > &  stepper,
const vector< C > &  x,
nat  k,
const C &  t1 
)

Definition at line 99 of file homotopy.hpp.

References inside(), and Stepper_rep.

Referenced by homotopy_stepper_rep< ball< C >, homotopy_post_certify< V, W > >::hom(), homotopy(), homotopy_stepper_rep< C, homotopy_floating< V, W > >::homp(), and homotopy_stepper_rep< ball< C >, homotopy_post_certify< V, W > >::homvp().

00100                                               {
00101   return const_cast<Stepper_rep*> (inside (stepper)) -> hom (x, k, t1);
00102 }

bool mmx::included ( const riemann_square< R, V > &  s1,
const riemann_square< R, V > &  s2 
) [inline]

Definition at line 137 of file riemann_square.hpp.

References center(), R, and radius().

Referenced by glue(), and GLUE_4().

00137                                               {
00138   R d= radius (s2) - radius (s1);
00139   return radius (s1) <= radius (s2) &&
00140          abs (Re (center (s1)) - Re (center (s2))) <= d &&
00141          abs (Im (center (s1)) - Im (center (s2))) <= d;
00142 }

mmx::INDIRECT_IMPL_2 ( riemann_surface  ,
riemann_surface_rep  ,
typename R  ,
R  ,
typename V  ,
V   
)
mmx::INDIRECT_IMPL_2 ( riemann_square  ,
riemann_square_rep  ,
typename R  ,
R  ,
typename V  ,
V   
)
mmx::INDIRECT_IMPL_2 ( riemann_germ  ,
riemann_germ_rep  ,
typename R  ,
R  ,
typename V  ,
V   
)
mmx::INDIRECT_IMPL_2 ( homotopy_stepper  ,
homotopy_stepper_rep  ,
typename C  ,
C  ,
typename V  ,
V   
)
mmx::INDIRECT_IMPL_2 ( analytic  ,
analytic_rep  ,
typename C  ,
C  ,
typename V  ,
V   
)
mmx::INDIRECT_IMPL_3 ( riemann_bundle  ,
riemann_bundle_rep  ,
typename Germ  ,
Germ  ,
typename R  ,
R  ,
typename V  ,
V   
)
bool mmx::inside ( const complex< R > &  z,
const riemann_square< R, V > &  s 
) [inline]

Definition at line 155 of file riemann_square.hpp.

References center(), and radius().

00155                                      {
00156   return abs (Re (z) - Re (center (s))) <= radius (s) &&
00157          abs (Im (z) - Im (center (s))) <= radius (s);
00158 }

bool mmx::inside ( const complex< R > &  z,
const riemann_germ< R, V > &  g 
) [inline]

Definition at line 62 of file riemann_germ.hpp.

00062                                                     {
00063   return abs (z - g->c) < g->r; }

bool mmx::inside ( const riemann_square< R, V > &  s,
const Germ &  g 
) [inline]

Definition at line 42 of file riemann_bundle.hpp.

References C, center(), inside(), R, and radius().

00042                                         {
00043   // Is the germ defined on the whole square s?
00044   R x= Re (center (s));
00045   R y= Im (center (s));
00046   R r= radius (s);
00047   return
00048     inside (C (x-r, y-r), g) &&
00049     inside (C (x-r, y+r), g) &&
00050     inside (C (x+r, y-r), g) &&
00051     inside (C (x+r, y+r), g);
00052 }

bool mmx::inside ( const P &  p,
const Germ &  g 
) [inline]

Referenced by binary_helper< riemann_surface< R, V > >::assemble(), better(), clear_cache(), eval(), expand(), germ(), glue(), GLUE_6(), homx(), inside(), lift(), lifts(), merge(), move(), binary_helper< riemann_surface< R, V > >::read(), riemann_disk(), and upgrade().

analytic< C, V > integrate ( const analytic< C, V > &  f  )  [inline]

Definition at line 1469 of file analytic.hpp.

References Analytic_rep, and CF().

Referenced by gen_integrate_vector_analytic(), GLUE_33(), solve_ode_series_rep< C >::initialize(), and integrate_analytic().

01469                               {
01470   return (Analytic_rep*)
01471     new integrate_analytic_rep<C,V> (f, promote (0, CF(f)));
01472 }

analytic<C> mmx::integrate_analytic ( const routine &  fun,
const C &  c 
) [inline]

Definition at line 69 of file analytic_sugar.hpp.

References fixed_point_analytic(), and integrate().

Referenced by GLUE_49().

00069                                                     {
00070   return fixed_point_analytic (integrate (fun), c);
00071 }

analytic< C, V > integrate_init ( const analytic< C, V > &  f,
const C &  c 
) [inline]

Definition at line 1475 of file analytic.hpp.

References Analytic_rep.

Referenced by integrate_analytic_rep< C, V >::Expand(), and integrate_analytic_rep< C, V >::Move().

01475                                                {
01476   return (Analytic_rep*) new integrate_analytic_rep<C,V> (f, c);
01477 }

bool mmx::intersect ( const riemann_square< R, V > &  s1,
const riemann_square< R, V > &  s2 
) [inline]

Definition at line 130 of file riemann_square.hpp.

References center(), R, and radius().

Referenced by digital_disk_sub(), and GLUE_3().

00130                                                {
00131   R d= radius (s1) + radius (s2);
00132   return abs (Re (center (s1)) - Re (center (s2))) <= d &&
00133          abs (Im (center (s1)) - Im (center (s2))) <= d;
00134 }

mmx::INV_TRIGO_SUGAR ( template< typename C, typename V >  ,
analytic< C, V >   
)
bool mmx::is_plane ( const riemann_surface< R, V > &  rs  )  [inline]

Definition at line 412 of file riemann_surface.hpp.

References adjacent(), and Iterator.

Referenced by GLUE_12().

00412                              {
00413   for (Iterator it1= entries (rs->squares); busy (it1); ++it1)
00414     for (Iterator it2= entries (rs->squares); busy (it2); ++it2)
00415       if (adjacent (*it1, *it2))
00416         if (!rs->neighbours[*it1]->contains (*it2))
00417           return false;
00418   return true;
00419 }

bool mmx::less ( const table< vector< C >, T > &  t,
const table< vector< C >, T > &  u,
bool  sure 
) [inline]

Definition at line 132 of file analytic.hpp.

References less().

00132                                                                            {
00133   for (iterator<T> it= entries (t); busy (it); ++it) {
00134     if (!contains (u, *it) || N(u[*it]) != N(t[*it])) return false;
00135     for (nat i=0; i<N(t[*it]); i++)
00136       if (!less (t[*it][i], u[*it][i], sure)) return false;
00137   }
00138   return true;
00139 }

bool mmx::less ( const ball< C > &  x,
const ball< C > &  y,
bool  sure 
) [inline]

Definition at line 126 of file analytic.hpp.

00126                                                      {
00127   if (sure) return upper (x) <= lower (y);
00128   else return lower (x) <= upper (y);
00129 }

bool mmx::less ( const C &  x,
const C &  y,
bool  sure 
) [inline]

Definition at line 121 of file analytic.hpp.

Referenced by less().

00121                                          {
00122   (void) sure; return x <= y;
00123 }

riemann_point<R,V> mmx::lift ( const riemann_surface< R, V > &  rs,
const complex< R > &  z 
) [inline]

Definition at line 422 of file riemann_surface.hpp.

References CF(), inside(), Iterator, and Point.

00422                                      {
00423   for (Iterator it= entries (rs->squares); busy (it); ++it)
00424     if (inside (z, *it)) return Point (*it, z);
00425   mmout << "rs= " << rs << "\n";
00426   mmout << "z= " << z << "\n";
00427   ERROR ("unable to lift point");
00428   return Point (CF(rs));
00429 }

riemann_point<R,V> mmx::lift ( const riemann_bundle< Germ, R, V > &  b,
const complex< R > &  z 
) [inline]

Definition at line 219 of file riemann_bundle.hpp.

Referenced by glue(), and GLUE_13().

00219                                                      {
00220   return lift (b->surface, z); }

vector< riemann_point<R,V> > mmx::lifts ( const riemann_surface< R, V > &  rs,
const complex< R > &  z 
) [inline]

Definition at line 432 of file riemann_surface.hpp.

References inside(), Iterator, and Point.

00432                                       {
00433   vector<Point > v;
00434   for (Iterator it= entries (rs->squares); busy (it); ++it)
00435     if (inside (z, *it)) v << Point (*it, z);
00436   return v;
00437 }

vector< riemann_point<R,V> > mmx::lifts ( const riemann_bundle< Germ, R, V > &  b,
const complex< R > &  z 
) [inline]

Definition at line 221 of file riemann_bundle.hpp.

00221                                                                {
00222   return lifts (b->surface, z); }

analytic< C, V > log ( const analytic< C, V > &  f  )  [inline]

Definition at line 1499 of file analytic.hpp.

Referenced by GLUE_38(), and pow().

01499                         {
01500   return unary_recursive_analytic<log_op> (f);
01501 }

analytic< C, V > log_init ( const analytic< C, V > &  f,
const C &  c 
) [inline]

Definition at line 1504 of file analytic.hpp.

01504                                          {
01505   return unary_recursive_analytic<log_op> (f, c);
01506 }

analytic< C, V > lshiftz ( const analytic< C, V > &  f,
const int &  shift = 1 
) [inline]

Definition at line 1423 of file analytic.hpp.

References Analytic_rep.

Referenced by lshiftz_analytic_rep< C, V >::Expand(), and xderive().

01423                                               {
01424   if (shift == 0) return f;
01425   return (Analytic_rep*) new lshiftz_analytic_rep<C,V> (f, shift);
01426 }

analytic<C> mmx::make_mmx_analytic ( const vector< C > &  cs  )  [inline]

Definition at line 1638 of file analytic.hpp.

01638                                         {
01639   return analytic<C> (cs);
01640 }

analytic<C> mmx::make_mmx_analytic ( const polynomial< C > &  p  )  [inline]

Definition at line 1633 of file analytic.hpp.

01633                                            {
01634   return analytic<C> (p);
01635 }

analytic<C> mmx::make_mmx_analytic ( const C &  c  )  [inline]

Definition at line 1628 of file analytic.hpp.

Referenced by GLUE_2(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_50(), and GLUE_6().

01628                                {
01629   return analytic<C> (c);
01630 }

matrix< C > matrix_new ( const vector< C > &  t  )  [inline]

Definition at line 110 of file glue_ode_taylor_floating.cpp.

References C.

00110                                   {
00111     nat j, rows= 1, cols= N(t);
00112     C dummy= zero_cst<C> ();
00113     matrix<C> r (dummy, rows, cols);
00114     for (j=0; j<cols; j++)
00115       r(0,j)= t[j];
00116     return r;
00117   }

matrix< C > matrix_new ( const vector< row_tuple< C > > &  t  )  [inline]

Definition at line 96 of file glue_ode_taylor_floating.cpp.

References C.

00096                                               {
00097     if (N(t) == 0) return matrix<C> ();
00098     nat i, j, rows= N(t), cols= N(t[0]);
00099     C dummy= zero_cst<C> ();
00100     matrix<C> r (dummy, rows, cols);
00101     for (i=0; i<rows; i++) {
00102       ASSERT (N(t[i]) == cols, "unequal row lengths");
00103       for (j=0; j<cols; j++)
00104         r(i,j)= t[i][j];
00105     }
00106     return r;
00107   }

vector<Germ > mmx::merge ( const riemann_square< R, V > &  s,
const vector< Germ > &  v1,
const vector< Germ > &  v2 
) [inline]

Definition at line 151 of file riemann_bundle.hpp.

References inside().

Referenced by glue().

00151                                                                           {
00152   if (N(v1) == 0) return v2;
00153   if (N(v2) == 0) return v1;
00154   if (N(v1) == 1 && inside (s, v1[0])) return v1;
00155   if (N(v2) == 1 && inside (s, v2[0])) return v2;
00156   vector<Germ > r= v1;
00157   nat i, j;
00158   for (i=0; i<N(v2); i++) {
00159     for (j=0; j<N(r); j++)
00160       if (v2[i] == r[j]) break;
00161     if (j == N(r)) r << v2[i];
00162   }
00163   return r;
00164 }

C mmx::minimum_quotients ( const table< vector< C >, T > &  t,
const table< vector< C >, T > &  u 
) [inline]

Definition at line 111 of file analytic.hpp.

References C, and safe_div().

00111                                                                              {
00112   C m= largest_cst (get_format1 (CF1(t)));
00113   for (iterator<T> it= entries (t); busy (it); ++it)
00114     if (contains (u, *it) && N(u[*it]) == N(t[*it]))
00115       for (nat i=0; i<N(t[*it]); i++)
00116         m= min (m, safe_div (t[*it][i], u[*it][i]));
00117   return m;
00118 }

static mmx::mmx_ball ( mmx_floating  ,
complex< mmx_floating >   
) const [static]
static mmx::mmx_ball ( double  ,
complex< double >   
) const [static]
riemann_point<R,V> mmx::move ( const riemann_surface< R, V > &  rs,
const riemann_point< R, V > &  p,
const complex< R > &  delta 
) [inline]

Definition at line 440 of file riemann_surface.hpp.

References upgrade().

00440                                                          {
00441   // Return p + t delta, where t <= 1 is maximal such that
00442   // the segment [p, p + t delta] lies on rs
00443   return rs->move (upgrade (rs, p), delta);
00444 }

riemann_point<R,V> mmx::move ( const riemann_bundle< Germ, R, V > &  b,
const riemann_point< R, V > &  p,
const complex< R > &  delta 
) [inline]

Definition at line 223 of file riemann_bundle.hpp.

References move().

00223                                                                          {
00224   return move (b->surface, p, delta); }

T mmx::move ( const T &  x,
const list< C > &  p 
) [inline]

Definition at line 265 of file analytic_matrix.hpp.

References move().

00265                                     {
00266   if (is_nil (p)) return x;
00267   else return move (move (x, car (p)), cdr (p));
00268 }

matrix< analytic<C,V> > mmx::move ( const matrix< analytic< C, V > > &  m,
const C &  z 
) [inline]

Definition at line 188 of file analytic_matrix.hpp.

References Analytic, and move().

00188                                               {
00189   nat nr= rows (m), nc= cols (m);
00190   matrix<Analytic > r (Analytic (0, get_format (z)), nr, nc);
00191   for (nat i=0; i<nr; i++)
00192     for (nat j=0; j<nc; j++)
00193       r (i, j)= move (m (i, j), z);
00194   return r;  
00195 }

analytic<C,V> mmx::move ( const analytic< C, V > &  f,
const vector< typename unvectorize< C >::val > &  v 
) [inline]

Definition at line 848 of file analytic.hpp.

00848                                                    {
00849   return f->Move (list<Scalar > (v));
00850 }

analytic<C,V> mmx::move ( const analytic< C, V > &  f,
const list< typename unvectorize< C >::val > &  l 
) [inline]

Definition at line 838 of file analytic.hpp.

00838                                                  {
00839   return f->Move (l);
00840 }

V analytic<C,V> mmx::move ( const analytic< C, V > &  f,
const typename unvectorize< C >::val &  z 
)

Definition at line 706 of file analytic.hpp.

References Analytic_rep, and inside().

Referenced by connection_matrix(), default_eval(), default_move(), GLUE_14(), GLUE_15(), GLUE_53(), heuristic_analytic_rep< C, V >::initialize(), vector_analytic_rep< C, V >::Move(), vector_access_analytic_rep< C, V >::Move(), rough_analytic_rep< C, V >::Move(), cache_last_analytic_rep< C, V >::Move(), fast_eval_analytic_rep< C, V >::Move(), move(), matrix_analytic_rep< C, V >::Move(), matrix_access_analytic_rep< C, V >::Move(), heuristic_analytic_rep< C, V >::Move(), reverse_analytic_rep< C, V >::Move(), compose_analytic_rep< C, V >::Move(), integrate_analytic_rep< C, V >::Move(), binary_scalar_analytic_rep< rmul_op, C, V, C >::Move(), binary_recursive_analytic_rep< Op, C, V >::Move(), binary_analytic_rep< mul_op, C, V >::Move(), unary_recursive_analytic_rep< Op, C, V >::Move(), unary_analytic_rep< neg_op, C, V >::Move(), recursive_container_analytic_rep< C, V >::Move(), and cache_last_analytic_rep< C, V >::Set_next().

00706                                           {
00707   Analytic_rep* rep= inside (f);
00708   rep->init_next (z);
00709   if (rep->cache->move_to == NULL)
00710     rep->cache->move_to= mmx_new_one<Analytic > (rep->Move (z));
00711   return *rep->cache->move_to;
00712 }

vector<Abs_type(C) > mmx::mul_bound ( const matrix< C > &  m,
const vector< C > &  v 
) [inline]

Definition at line 44 of file homotopy_euler.hpp.

References Abs_type(), C, and R.

Referenced by homotopy_stepper_rep< C, homotopy_euler >::newton_step().

00044                                                    {
00045   typedef Abs_type(C) R;
00046   ASSERT (N(v) == cols (m), "dimensions don't match");
00047   vector<R> r= fill<R> (0, rows (m));
00048   for (nat i=0; i<N(r); i++) {
00049     R sum= 0;
00050     for (nat j=0; j<cols(m); j++)
00051       sum += abs (m (i, j)) * abs (v[j]);
00052     r[i]= sum;
00053   }
00054   return r;
00055 }

analytic< C > nullary_recursive_analytic ( const C &  c = Op::template op<C> ()  )  [inline]

Definition at line 1054 of file analytic.hpp.

References recursive().

01054                                                              {
01055   return recursive (new nullary_recursive_analytic_rep<Op,C> (c));
01056 }

nat mmx::ode_order ( const C &  c  )  [inline]

Definition at line 37 of file ode_taylor.hpp.

References mmx_ode_order.

Referenced by ode_precision().

00037                        {
00038   if (mmx_ode_order != 0)
00039     return min ((nat) precision (c), (nat) mmx_ode_order);
00040   return precision (c);
00041 }

xnat mmx::ode_precision ( const C &  c  )  [inline]

Definition at line 44 of file ode_taylor.hpp.

References mmx_ode_precision, and ode_order().

00044                            {
00045   if (mmx_ode_precision != 0)
00046     return min ((xnat) precision (c), (xnat) mmx_ode_precision);
00047   return min ((xnat) precision (c), max ((xnat) ode_order (c), (xnat) 24));
00048 }

bool mmx::operator!= ( const analytic< C, V > &  f,
const analytic< C, V > &  g 
) [inline]

Definition at line 424 of file analytic.hpp.

References expand().

00424                                                                     {
00425   return expand (f) != expand (g); }

analytic< C, V > operator* ( const analytic< C, V > &  f,
const analytic< C, V > &  g 
) [inline]

Definition at line 1333 of file analytic.hpp.

References Analytic_rep.

01333                                                   {
01334   return (Analytic_rep*) new mul_analytic_rep<C,V> (f, g);
01335 }

analytic< C, V > operator* ( const analytic< C, V > &  f,
const C &  c 
) [inline]

Definition at line 1300 of file analytic.hpp.

References Analytic_rep.

01300                                            {
01301   return (Analytic_rep*) new sc_mul_analytic_rep<C,V> (f, c);
01302 }

analytic< C, V > operator* ( const K &  c,
const analytic< C, V > &  f 
) [inline]

Definition at line 1305 of file analytic.hpp.

References Analytic_rep.

01305                                            {
01306   return (Analytic_rep*) new sc_mul_analytic_rep<C,V> (f, c);
01307 }

analytic<C,V> mmx::operator+ ( const analytic< C, V > &  f,
const C &  g 
) [inline]

Definition at line 1241 of file analytic.hpp.

References Analytic, and Analytic_rep.

01241                                            {
01242   return (Analytic_rep*) new add_analytic_rep<C,V> (f, Analytic (g));
01243 }

analytic<C,V> mmx::operator+ ( const C &  f,
const analytic< C, V > &  g 
) [inline]

Definition at line 1236 of file analytic.hpp.

References Analytic, and Analytic_rep.

01236                                            {
01237   return (Analytic_rep*) new add_analytic_rep<C,V> (Analytic (f), g);
01238 }

analytic< C, V > operator+ ( const analytic< C, V > &  f,
const analytic< C, V > &  g 
) [inline]

Definition at line 1231 of file analytic.hpp.

References Analytic_rep.

01231                                                   {
01232   return (Analytic_rep*) new add_analytic_rep<C,V> (f, g);
01233 }

analytic<C,V> mmx::operator- ( const analytic< C, V > &  f,
const C &  g 
) [inline]

Definition at line 1284 of file analytic.hpp.

References Analytic, and Analytic_rep.

01284                                            {
01285   return (Analytic_rep*) new sub_analytic_rep<C,V> (f, Analytic (g));
01286 }

analytic<C,V> mmx::operator- ( const C &  f,
const analytic< C, V > &  g 
) [inline]

Definition at line 1279 of file analytic.hpp.

References Analytic, and Analytic_rep.

01279                                            {
01280   return (Analytic_rep*) new sub_analytic_rep<C,V> (Analytic (f), g);
01281 }

analytic< C, V > operator- ( const analytic< C, V > &  f,
const analytic< C, V > &  g 
) [inline]

Definition at line 1274 of file analytic.hpp.

References Analytic_rep.

01274                                                   {
01275   return (Analytic_rep*) new sub_analytic_rep<C,V> (f, g);
01276 }

analytic< C, V > operator- ( const analytic< C, V > &  f  )  [inline]

Definition at line 1257 of file analytic.hpp.

References Analytic_rep.

01257                                {
01258   return (Analytic_rep*) new neg_analytic_rep<C,V> (f);
01259 }

analytic<C,V> mmx::operator/ ( const C &  f,
const analytic< C, V > &  g 
) [inline]

Definition at line 1368 of file analytic.hpp.

References Analytic, and Analytic_rep.

01368                                            {
01369   return (Analytic_rep*) new div_analytic_rep<C,V> (Analytic (f), g);
01370 }

analytic< C, V > operator/ ( const analytic< C, V > &  f,
const analytic< C, V > &  g 
) [inline]

Definition at line 1363 of file analytic.hpp.

References Analytic_rep.

01363                                                   {
01364   return (Analytic_rep*) new div_analytic_rep<C,V> (f, g);
01365 }

analytic< C, V > operator/ ( const analytic< C, V > &  f,
const C &  c 
) [inline]

Definition at line 1310 of file analytic.hpp.

References Analytic_rep.

01310                                            {
01311   return (Analytic_rep*) new sc_mul_analytic_rep<C,V> (f, invert (c));
01312 }

bool mmx::operator== ( const analytic< C, V > &  f,
const analytic< C, V > &  g 
) [inline]

Definition at line 422 of file analytic.hpp.

References expand().

00422                                                                     {
00423   return expand (f) == expand (g); }

V riemann_square<R,V> mmx::owner ( const riemann_point< R, V > &  p  )  [inline]

Definition at line 40 of file riemann_point.hpp.

Referenced by CF(), binary_helper< riemann_point< R, V > >::disassemble(), germs(), glue(), GLUE_8(), owners(), upgrade(), and binary_helper< riemann_point< R, V > >::write().

00040 { return p.s; }

table<bool, riemann_square<R,V> > mmx::owners ( const riemann_surface< R, V > &  rs,
const riemann_point< R, V > &  p 
) [inline]

Definition at line 236 of file riemann_surface.hpp.

References owner(), and project().

Referenced by glue().

00236                                            {
00237   return rs->owners (owner (p), project (p));
00238 }

polynomial< C > polynomial_reverse ( const vector< C > &  v  )  [inline]

Definition at line 49 of file glue_riemann_double.cpp.

References reverse().

00049                                             {
00050       return polynomial<C> (reverse (v)); }

analytic<C,V> mmx::pow ( const analytic< C, V > &  f,
const analytic< C, V > &  g 
) [inline]

Definition at line 1514 of file analytic.hpp.

References exp(), and log().

01514                                            {
01515   return exp (g * log (f));
01516 }

analytic<C,V> mmx::pow ( const analytic< C, V > &  f,
const C &  c 
) [inline]

Definition at line 1509 of file analytic.hpp.

References exp(), and log().

Referenced by integrate_analytic_rep< C, V >::Abs_type(), lshiftz_analytic_rep< C, V >::Abs_type(), polynomial_analytic_rep< C, V >::Abs_type(), lshiftz_analytic_rep< C, V >::Eval(), and GLUE_39().

01509                                     {
01510   return exp (c * log (f));
01511 }

complex<R> mmx::project ( const riemann_point< R, V > &  p  )  [inline]

Definition at line 41 of file riemann_point.hpp.

Referenced by binary_helper< riemann_point< R, V > >::disassemble(), germ(), glue(), GLUE_9(), owners(), upgrade(), and binary_helper< riemann_point< R, V > >::write().

00041 { return p.z; }

analytic< C, V > radial ( const analytic< C, V > &  f  )  [inline]

Definition at line 187 of file analytic_meta.hpp.

References cache_last(), and fast_eval().

Referenced by heuristic_change().

00187                            {
00188   return cache_last (fast_eval (f));
00189 }

C mmx::radial_eval ( const analytic< C, V > &  f,
const typename unvectorize< C >::val &  z 
) [inline]

Definition at line 863 of file analytic.hpp.

Referenced by heuristic_analytic_rep< C, V >::check(), GLUE_14(), heuristic_analytic_rep< C, V >::Move(), and heuristic_analytic_rep< C, V >::Radial_eval().

00863                                                  {
00864   return f->Eval (list<Scalar > (z));
00865 }

analytic<C,V> mmx::radial_move ( const analytic< C, V > &  f,
const typename unvectorize< C >::val &  z 
) [inline]

Definition at line 858 of file analytic.hpp.

Referenced by GLUE_13(), heuristic_analytic_rep< C, V >::initialize(), and heuristic_analytic_rep< C, V >::Move().

00858                                                  {
00859   return f->Move (list<Scalar > (z));
00860 }

R mmx::radius ( const riemann_square< R, V > &  s  )  [inline]

Definition at line 61 of file riemann_square.hpp.

00061 { return s->r; }

R mmx::radius ( const riemann_germ< R, V > &  g  )  [inline]

Definition at line 57 of file riemann_germ.hpp.

Referenced by adjacent(), admissible(), homotopy_stepper_rep< ball< C >, homotopy_ball >::certify_tube(), CF(), corners(), binary_helper< riemann_square< R, V > >::disassemble(), binary_helper< riemann_germ< R, V > >::disassemble(), homotopy_stepper_rep< ball< C >, homotopy_ball >::final_tube(), flatten(), GLUE_16(), included(), inside(), intersect(), binary_helper< riemann_square< R, V > >::write(), and binary_helper< riemann_germ< R, V > >::write().

00057 { return g->r; }

polynomial<C> mmx::range ( const analytic< C, V > &  f,
nat  i,
nat  j 
) [inline]

Definition at line 370 of file analytic.hpp.

References expand().

Referenced by coherence(), compose(), connection_matrix(), GLUE_52(), homotopy_stepper_rep< C, homotopy_euler >::newton_step(), homotopy_stepper_rep< ball< C >, homotopy_ball >::newton_step(), homotopy_stepper_rep< ball< C >, homotopy_ball >::propose_tube(), and remove_entry().

00370                                         {
00371   return range (expand (f), i, j);
00372 }

analytic<C,V> mmx::recursive ( recursive_analytic_rep< C, V > *  f  )  [inline]

Definition at line 937 of file analytic.hpp.

References Analytic, and Analytic_rep.

Referenced by binary_recursive_analytic(), fixed_point_analytic(), fixed_point_analytic_vector(), nullary_recursive_analytic(), solve_ode(), and unary_recursive_analytic().

00937                                            {
00938   return (Analytic_rep*)
00939     new recursive_container_analytic_rep<C,V> (Analytic ((Analytic_rep*) f));
00940 }

matrix<C> mmx::remove_column ( const matrix< C > &  m,
nat  k 
) [inline]

Definition at line 29 of file homotopy_euler.hpp.

References C.

Referenced by homotopy_stepper_rep< ball< C >, homotopy_ball >::certify_tube(), homotopy_stepper_rep< C, homotopy_euler >::newton_step(), and homotopy_stepper_rep< ball< C >, homotopy_ball >::prepare_step().

00029                                           {
00030   matrix<C> r (C (0), rows (m), cols (m)-1);
00031   for (nat i=0; i<rows(r); i++)
00032     for (nat j=0; j<cols(r); j++)
00033       if (j<k) r(i,j)= m(i,j);
00034       else r(i,j)= m(i,j+1);
00035   return r;
00036 }

vector<C> mmx::remove_entry ( const vector< C > &  v,
nat  k 
) [inline]

Definition at line 39 of file homotopy_euler.hpp.

References range().

Referenced by homotopy_stepper_rep< ball< C >, homotopy_ball >::certify_tube().

00039                                          {
00040   return append (range (v, 0, k), range (v, k+1, N(v)));
00041 }

class analytic_rep mmx::REP_STRUCT_1 ( C   )  [inline]

Definition at line 154 of file analytic.hpp.

References Analytic, Assume, C, Format, me, order, R, Radius, Scalar, and Series.

00154                                    {
00155 public:
00156   analytic_cache<C,V>* cache;
00157   void init_cache ();
00158   void init_focus (const Radius& r);
00159   void init_next  (const Scalar& z);
00160   virtual void Clear_cache (nat which) const;
00161 
00162 public:
00163   inline analytic_rep (const Format& fm):
00164     Format (fm), cache (NULL) {}
00165   virtual ~analytic_rep () {
00166     if (cache != NULL) {
00167       if (cache->move_to != NULL) mmx_delete_one (cache->move_to);
00168       if (cache->eval_at != NULL) mmx_delete_one (cache->eval_at);
00169       delete cache;
00170     } }
00171   virtual syntactic expression (const syntactic& z) const;
00172 
00173 public:
00174   virtual Series   Expand () const = 0;
00175   virtual Radius   Radius_bound (nat order) const;
00176   virtual R        Tail_bound (const Radius& r, nat ord, Assume& a) const = 0;
00177   virtual Analytic Move (const Scalar& z) const = 0;
00178   virtual C        Eval (const Scalar& z) const;
00179   virtual Analytic Move (const list<Scalar >& z) const;
00180   virtual C        Eval (const list<Scalar >& z) const;
00181   virtual Analytic Derive () const = 0;
00182   inline  Analytic me () const;
00183   friend class Analytic;
00184 
00185   virtual C initial () const;
00186   virtual Analytic equation () const;
00187 };

analytic< C, V > reverse ( const analytic< C, V > &  f  )  [inline]

Definition at line 1617 of file analytic.hpp.

References Analytic_rep.

Referenced by reverse_analytic_rep< C, V >::Expand(), GLUE_35(), reverse_analytic_rep< C, V >::Move(), and polynomial_reverse().

01617                             {
01618   return (Analytic_rep*) new reverse_analytic_rep<C,V> (f);
01619 }

riemann_surface<R,V> mmx::riemann_disk ( const complex< R > &  z,
const R &  r,
nat  prec = 8 
) [inline]

Definition at line 361 of file riemann_surface.hpp.

References inside(), Squares, and Surface.

00361                                                    {
00362   Surface rs (get_format (r));
00363   Squares ds= digital_disk<R,V> (z, r, prec);
00364   inside (rs)->add (ds);
00365   inside (rs)->plane_connect (ds);
00366   inside (rs)->normalize ();
00367   inside (rs)->clean ();
00368   return rs;
00369 }

analytic<C,V> mmx::rough ( const analytic< C, V > &  f  )  [inline]

Definition at line 221 of file analytic_meta.hpp.

References Analytic_rep.

Referenced by rough_analytic_rep< C, V >::Derive(), GLUE_6(), GLUE_9(), and rough_analytic_rep< C, V >::Move().

00221                           {
00222   return (Analytic_rep*) new rough_analytic_rep<C,V> (f);
00223 }

analytic< C, V > rshiftz ( const analytic< C, V > &  f,
const int &  shift = 1 
) [inline]

Definition at line 1429 of file analytic.hpp.

References Analytic_rep.

01429                                               {
01430   if (shift == 0) return f;
01431   return (Analytic_rep*) new lshiftz_analytic_rep<C,V> (f, -shift);
01432 }

C mmx::safe_div ( const C &  n,
const C &  d 
) [inline]

Definition at line 105 of file analytic.hpp.

Referenced by minimum_quotients().

00105                                   {
00106   if (d == 0) return largest_cst (get_format (n));
00107   else return n / d;
00108 }

vector<vector<nat> > mmx::separate_balls ( const vector< vector< ball< C > > > &  v  )  [inline]

Definition at line 109 of file homotopy_post_certify.hpp.

References separate_balls().

00109                                                     {
00110   nat n= N(v);
00111   if (n == 0) return vector<vector<nat> > ();
00112   vector<nat> cnt= fill<nat> (n);
00113   for (nat i=0; i<n; i++) cnt[i]= i;
00114   vector<vector<nat> > sub= vec<vector<nat> > (cnt);
00115   nat d= N(v[0]);
00116   if (d == 0) return vec<vector<nat> > (cnt);
00117   for (nat i=0; i<d; i++) {
00118     vector<ball<C> > w= fill<ball<C> > (ball<C> (0), n);
00119     for (nat j=0; j<n; j++) {
00120       ASSERT (N(v[j]) == d, "vectors of same length expected");
00121       w[j]= v[j][i];
00122     }
00123     sub= separate_balls (w, sub);
00124   }
00125   return sub;
00126 }

vector<vector<nat> > mmx::separate_balls ( const vector< ball< complex< R > > > &  v  )  [inline]

Definition at line 103 of file homotopy_post_certify.hpp.

References separate_balls().

00103                                                      {
00104   vector<vector<nat> > sub= separate_balls (Re (v));
00105   return separate_balls (Im (v), sub);
00106 }

vector<vector<nat> > mmx::separate_balls ( const vector< ball< C > > &  v,
const vector< vector< nat > > &  in 
) [inline]

Definition at line 84 of file homotopy_post_certify.hpp.

References separate_balls().

00084                                                                            {
00085   vector<vector<nat> > out;
00086   for (nat i=0; i<N(in); i++) {
00087     nat n= N(in[i]);
00088     if (n <= 1) { out << in[i]; continue; }
00089     vector<ball<C> > w= extract (v, in[i]);
00090     vector<vector<nat> > sub= separate_balls (w);
00091     for (nat j=0; j<N(sub); j++) {
00092       //mmerr << "Extract " << sub[j] << " from " << in[i] << "\n";
00093       nat l= N(sub[j]);
00094       vector<nat> add= fill<nat> (l);
00095       for (nat k=0; k<l; k++) add[k]= in[i][sub[j][k]];
00096       out << add;
00097     }
00098   }
00099   return out;
00100 }

vector<vector<nat> > mmx::separate_balls ( const vector< ball< R > > &  v2  )  [inline]

Definition at line 51 of file homotopy_post_certify.hpp.

Referenced by homotopy_stepper_rep< ball< C >, homotopy_post_certify< V, W > >::homvp(), and separate_balls().

00051                                             {
00052   typedef ball<R> B;
00053   nat n= N(v2);
00054   if (n == 0) return vector<vector<nat> > ();
00055   vector<B> v= copy (v2);
00056   vector<nat> sigma;
00057   sort (v, sigma);
00058   //mmerr << "v= " << v << "\n";
00059   //mmerr << "s= " << sigma << "\n";
00060   vector<R> lo= lower (v);
00061   vector<R> up= upper (v);
00062   //mmerr << "l= " << lo << "\n";
00063   //mmerr << "u= " << up << "\n";
00064   for (nat i=1  ; i<n; i++) up[i]  = max (up[i-1], up[i]);
00065   for (nat i=n-1; i>0; i--) lo[i-1]= min (lo[i-1], lo[i]);
00066   //mmerr << "l= " << lo << "\n";
00067   //mmerr << "u= " << up << "\n";
00068   vector<vector<nat> > r;
00069   vector<nat> current;
00070   current << sigma[0];
00071   for (nat i=1; i<n; i++) {
00072     if (up[i-1] < lo[i]) {
00073       r << current;
00074       current= vector<nat> ();
00075     }
00076     current << sigma[i];
00077   }
00078   r << current;
00079   //mmerr << "r= " << r << "\n";
00080   return r;
00081 }

C mmx::shrink ( const C &  z  )  [inline]

Definition at line 792 of file analytic.hpp.

Referenced by default_eval(), default_move(), cache_last_analytic_rep< C, V >::Eval(), cache_last_analytic_rep< C, V >::Move(), and heuristic_analytic_rep< C, V >::Move().

00792                     {
00793   typedef radius_ratio_helper<C,typename format<C>::FT> H;
00794   return H::op (get_format (z)) * z;
00795 }

list<C> mmx::simplify ( const list< C > &  l,
const Abs_type(C)&  r 
) [inline]

Definition at line 744 of file analytic.hpp.

References C, and sqrt().

Referenced by default_eval(), default_move(), cache_last_analytic_rep< C, V >::Eval(), and cache_last_analytic_rep< C, V >::Move().

00744                                         {
00745   // Given a path l and a radius r, find the first intersection z
00746   // of l with the circle of radius r and replace l by the straightline
00747   // path to z and the remainder of the l. If there is no intersection,
00748   // then replace l by the straightline path to its end-point.
00749   if (is_nil (l)) return l;
00750   else if (abs (car (l)) < r) {
00751     if (is_nil (cdr (l))) return l;
00752     format<C> fm= get_format (car (l));
00753     C p1= car (l);
00754     C dp= car (cdr (l));
00755     C p2= p1 + dp;
00756     list<C> rl= cdr (cdr (l));
00757     if (abs (p2) < r)
00758       return simplify (cons<C> (p2, rl), r);
00759     else {
00760       C _2= promote (2, fm);
00761       C _4= promote (4, fm);
00762       C a = gaussian (square (Re (dp)) + square (Im (dp)), fm);
00763       C b = _2 * (Re (p1) * Im (dp) + Im (p1) * Re (dp));
00764       C c = gaussian (square (Re (p1)) + square (Im (p1)) - square (r), fm);
00765       C t = (-b + sqrt (square (b) - _4 * a * c)) / (_2 * a);
00766       C q1= p1 + t * dp;
00767       C q2= p2 - q1;
00768       return cons<C> (q1, cons<C> (q2, rl));
00769     }
00770   }
00771   else {
00772     C p = car (l);
00773     C q1= (p / abs (p)) * r;
00774     C q2= p - q1;
00775     return cons<C> (q1, cons<C> (q2, cdr (l)));
00776   }
00777 }

analytic< C, V > sin ( const analytic< C, V > &  f  )  [inline]

Definition at line 189 of file analytic_vector.hpp.

Referenced by GLUE_41().

00189                         {
00190   return unary_recursive_analytic<sin_op> (f);
00191 }

matrix< analytic< C, V > > solve_lde ( const matrix< analytic< C, V > > &  f  )  [inline]

Definition at line 217 of file analytic_matrix.hpp.

References as_analytic(), as_matrix(), C, and solve_matrix_lde_init().

Referenced by connection_matrix(), and first_variation().

00217                                        {
00218   ASSERT (is_square_matrix (f), "square matrix expected");
00219   matrix<C> c (C(1), rows (f), cols (f));
00220   return as_matrix (solve_matrix_lde_init (as_analytic (f), c));
00221 }

vector< analytic< C, V > > solve_lde_init ( const vector< analytic< C, V > > &  f,
const vector< C > &  c 
) [inline]

Definition at line 204 of file analytic_vector.hpp.

References as_analytic(), as_vector(), and solve_vector_lde_init().

00204                                                                 {
00205   return as_vector (solve_vector_lde_init (as_analytic (f), c));
00206 }

matrix< analytic< C, V > > solve_lde_init ( const matrix< analytic< C, V > > &  f,
const matrix< C > &  c 
) [inline]

Definition at line 224 of file analytic_matrix.hpp.

References as_analytic(), as_matrix(), and solve_matrix_lde_init().

00224                                                                 {
00225   ASSERT (is_square_matrix (f), "square matrix expected");
00226   ASSERT (rows (f) == rows (c), "dimensions don't match");
00227   return as_matrix (solve_matrix_lde_init (as_analytic (f), c));
00228 }

analytic< matrix< C >, V > solve_matrix_lde_init ( const analytic< matrix< C >, V > &  f,
const matrix< C > &  c 
) [inline]

Definition at line 212 of file analytic_matrix.hpp.

References f.

Referenced by solve_lde(), and solve_lde_init().

00212                                                                            {
00213   return unary_recursive_analytic<solve_matrix_lde_op> (f, c);
00214 }

vector< series<C> > mmx::solve_ode ( const slp_tangent< series< C > > &  fun,
const vector< C > &  c 
) [inline]

Definition at line 49 of file ode_series.hpp.

References as_vector(), and recursive().

Referenced by solve_ode_series().

00049                                                            {
00050   series_rep<vector<C> >* rep= new solve_ode_series_rep<C> (fun, c);
00051   return as_vector (recursive (series<vector<C> > (rep)));
00052 }

vector<generic> mmx::solve_ode_series ( const vector< multivariate< sparse_polynomial< rational > > > &  f,
const vector< multivariate_coordinate<> > &  vars,
const vector< C > &  c 
) [inline]

Definition at line 60 of file ode_series.hpp.

References CF(), f, Function_C, and solve_ode_series().

00062                                       {
00063   Function_C fun= as_slp_tangent (f, vars, CF (c));
00064   return as<vector<generic> > (solve_ode_series (fun, c));
00065 }

vector< series<C> > mmx::solve_ode_series ( const slp_tangent< C > &  fun,
const vector< C > &  c 
) [inline]

Definition at line 55 of file ode_series.hpp.

References solve_ode().

Referenced by first_variation_series(), GLUE_9(), and solve_ode_series().

00055                                                              {
00056   return solve_ode (as<Function_Series > (fun), c);
00057 }

analytic< vector< C >, V > solve_vector_lde_init ( const analytic< vector< C >, V > &  f,
const vector< C > &  c 
) [inline]

Definition at line 199 of file analytic_vector.hpp.

References f.

Referenced by solve_lde_init().

00199                                                                            {
00200   return unary_recursive_analytic<solve_vector_lde_op> (f, c);
00201 }

analytic< C, V > sqrt ( const analytic< C, V > &  f  )  [inline]

Definition at line 1484 of file analytic.hpp.

Referenced by homotopy_stepper_rep< ball< C >, homotopy_ball >::confirm_step(), GLUE_36(), homotopy_stepper_rep< C, homotopy_euler >::hom(), homotopy_stepper_rep< ball< C >, homotopy_ball >::hom(), REP_STRUCT< C, V >::homp(), simplify(), and start_index().

01484                          {
01485   return unary_recursive_analytic<sqrt_op> (f);
01486 }

analytic< C, V > sqrt_init ( const analytic< C, V > &  f,
const C &  c 
) [inline]

Definition at line 1489 of file analytic.hpp.

01489                                           {
01490   return unary_recursive_analytic<sqrt_op> (f, c);
01491 }

nat start_index ( const vector< C > &  v,
const C &  z 
) [inline]

Definition at line 125 of file homotopy.hpp.

References C, R, and sqrt().

Referenced by REP_STRUCT< C, V >::homp().

00125                                              {
00126   typedef Real_type(C) R;
00127   R eps= sqrt (sqrt (Accuracy (R)));
00128   // NOTE: take fourth root in order to compensate precision loss
00129   // when converting from half precision to full precision in
00130   // recursive methods
00131   if (N(v) >= 2)
00132     for (nat i=N(v)-1; i>0; i--) {
00133       C z1= v[i-1], z2= v[i];
00134       if (abs (z1 - z2) >= eps) {
00135         C t = (z - z1) / (z2 - z1);
00136         if (abs (Im (t)) < eps && Re (t) >= -eps &&
00137             Re (t) <= promote (1, eps) + eps)
00138           return i;
00139       }
00140       else if (abs (z2 - z) < eps) return i;
00141     }
00142   ERROR ("point not on path");
00143 }

analytic<C> mmx::std_heuristic ( const polynomial< C > &  p  )  [inline]

Definition at line 187 of file analytic_heuristic.hpp.

Referenced by GLUE_10(), and GLUE_51().

00187                                        {
00188   return heuristic<C,std_analytic> (p);
00189 }

riemann_surface<R> mmx::std_riemann_disk ( const complex< R > &  c,
const R &  r 
) [inline]

Definition at line 67 of file glue_riemann_double.cpp.

Referenced by GLUE_10().

00067                                                      {
00068     return riemann_disk<R,std_riemann> (c, r);
00069   }

list<C> mmx::straight_path ( const C &  start,
const C &  end,
nat  steps = 5 
) [inline]

Definition at line 235 of file analytic_matrix.hpp.

00235                                                            {
00236   list<C> r;
00237   for (nat i=steps; i>0; i--)
00238     r= cons (start + (i*(end-start)) / steps, r);
00239   return r;
00240 }

mmx::STYPE_TO_TYPE ( template< typename C, typename V >  ,
as_vector_type  ,
analytic< vector< C >, V >  ,
vector< analytic< C, V > >   
)
mmx::STYPE_TO_TYPE ( template< typename C, typename V >  ,
as_matrix_type  ,
analytic< matrix< C >, V >  ,
matrix< analytic< C, V > >   
)
analytic< C, V > tan ( const analytic< C, V > &  f  )  [inline]

Definition at line 194 of file analytic_vector.hpp.

Referenced by GLUE_42().

00194                         {
00195   return unary_recursive_analytic<tan_op> (f);
00196 }

nat mmx::total_size ( const table< vector< C >, T > &  t  )  [inline]

Definition at line 142 of file analytic.hpp.

00142                                          {
00143   nat sz= 0;
00144   for (iterator<T> it= entries (t); busy (it); ++it)
00145     sz += N(t[*it]);
00146   return sz;
00147 }

analytic< vector< C >, V > trig ( const analytic< vector< C >, V > &  f  )  [inline]

Definition at line 174 of file analytic_vector.hpp.

References f.

Referenced by cos_sin().

00174                                       {
00175   return unary_recursive_analytic<trig_op> (f);
00176 }

mmx::TRUE_IDENTITY_OP_SUGAR ( template< typename R, typename V >  ,
riemann_surface< R, V >   
)
mmx::TRUE_IDENTITY_OP_SUGAR ( template< typename R, typename V >  ,
riemann_square< R, V >   
)
mmx::TRUE_IDENTITY_OP_SUGAR ( template< typename R, typename V >  ,
riemann_point< R, V >   
)
mmx::TRUE_IDENTITY_OP_SUGAR ( template< typename R, typename V >  ,
riemann_germ< R, V >   
)
mmx::TRUE_IDENTITY_OP_SUGAR ( template< typename Germ, typename R, typename V >  ,
riemann_bundle< Germ, R, V >   
)
polynomial<C> mmx::truncate ( const analytic< C, V > &  f,
nat  n 
) [inline]

Definition at line 365 of file analytic.hpp.

References expand().

Referenced by rough_analytic_rep< C, V >::Abs_type(), compose(), and fast_eval_analytic_rep< C, V >::Eval().

00365                                     {
00366   return truncate (expand (f), n);
00367 }

analytic<C,V> mmx::unary_analytic ( const analytic< C, V > &  f  )  [inline]

Definition at line 1079 of file analytic.hpp.

References Analytic_rep.

01079                                    {
01080   return (Analytic_rep*) new unary_analytic_rep<Op,C,V> (f);
01081 }

nat mmx::unary_hash ( const riemann_surface< R, V > &  rs  )  [inline]

Definition at line 83 of file riemann_surface.hpp.

00083                                {
00084   return hard_hash (rs);
00085 }

nat mmx::unary_hash ( const riemann_square< R, V > &  s  )  [inline]

Definition at line 76 of file riemann_square.hpp.

00076                              {
00077   return hard_hash (s);
00078 }

nat mmx::unary_hash ( const riemann_point< R, V > &  p  )  [inline]

Definition at line 49 of file riemann_point.hpp.

00049                             {
00050   nat h= Op::op (p.s);
00051   return (h<<1) ^ (h<<3) ^ (h<<9) ^ (h>>29) ^ Op::op (p.z);
00052 }

nat mmx::unary_hash ( const riemann_germ< R, V > &  s  )  [inline]

Definition at line 72 of file riemann_germ.hpp.

00072                            {
00073   return hard_hash (s);
00074 }

nat mmx::unary_hash ( const riemann_bundle< Germ, R, V > &  b  )  [inline]

Definition at line 109 of file riemann_bundle.hpp.

00109                              {
00110   return hard_hash (b);
00111 }

analytic<C,V> mmx::unary_recursive_analytic ( const analytic< C, V > &  f,
const C &  c 
) [inline]

Definition at line 1126 of file analytic.hpp.

References recursive().

01126                                                          {
01127   return recursive (new unary_recursive_analytic_rep<Op,C,V> (f, c));
01128 }

analytic<C,V> mmx::unary_recursive_analytic ( const analytic< C, V > &  f  )  [inline]

Definition at line 1121 of file analytic.hpp.

References recursive().

01121                                              {
01122   return recursive (new unary_recursive_analytic_rep<Op,C,V> (f));
01123 }

riemann_point<R,V> mmx::upgrade ( const riemann_surface< R, V > &  rs,
const riemann_point< R, V > &  p 
) [inline]

Definition at line 295 of file riemann_surface.hpp.

References inside(), owner(), Point, and project().

Referenced by germ(), germs(), glue(), and move().

00295                                             {
00296   return Point (inside (rs)->upgrade (owner (p)), project (p));
00297 }

generic mmx::var ( const analytic< C, V > &  f  )  [inline]

Definition at line 389 of file analytic.hpp.

References expand().

Referenced by flatten().

00389                         {
00390   return var (expand (f));
00391 }

vector< generic > wrap_column_reduced_echelon_with_permutation ( const matrix< C > &  m  )  [inline]

Definition at line 120 of file glue_ode_taylor_floating.cpp.

00120                                                                     {
00121     permutation permut;
00122     generic tp=as<generic> (column_reduced_echelon (m, permut));
00123     return vec (tp, as<generic> (permut));
00124   }

vector< generic > wrap_column_reduced_echelon_with_transform ( const matrix< C > &  m  )  [inline]

Definition at line 127 of file glue_ode_taylor_floating.cpp.

00127                                                                   {
00128     matrix<C> k;
00129     generic tp=as<generic> (column_reduced_echelon (m, k));
00130     return vec (tp, as<generic> (k));
00131   }

vector< generic > wrap_row_reduced_echelon_with_transform ( const matrix< C > &  m  )  [inline]

Definition at line 134 of file glue_ode_taylor_floating.cpp.

00134                                                                {
00135     matrix<C> k;
00136     generic tp=as<generic> (row_reduced_echelon (m, k));
00137     return vec (tp, as<generic> (k));
00138   }

vector< generic > wrap_subresultants ( const polynomial< C > &  f,
const polynomial< C > &  g 
) [inline]

Definition at line 58 of file glue_riemann_double.cpp.

00058                                                                         {
00059       return as<vector<generic> > (subresultants (f, g)); }

analytic<C,V> mmx::xderive ( const analytic< C, V > &  f  )  [inline]

Definition at line 380 of file analytic.hpp.

References lshiftz().

Referenced by GLUE_32().

00380                             {
00381   return lshiftz (f->Derive ());
00382 }

Variable Documentation

analytic< C, V >

Definition at line 225 of file analytic.hpp.

static complex< mmx_floating > & arg_1

Definition at line 132 of file glue_analytic_ball_double.cpp.

Referenced by GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_15(), GLUE_19(), GLUE_21(), GLUE_7(), GLUE_8(), and GLUE_9().

C

Definition at line 225 of file analytic.hpp.

Referenced by admissible(), heuristic_analytic_rep< C, V >::check(), circle_path(), coherence(), connection_matrix(), corners(), unvectorize< matrix< C > >::decode(), digital_disk(), digital_disk_sub(), unvectorize< matrix< C > >::encode(), vector_analytic_rep< C, V >::Eval(), eval(), matrix_analytic_rep< C, V >::Eval(), lshiftz_analytic_rep< C, V >::Eval(), polynomial_analytic_rep< C, V >::Eval(), heuristic_change(), homotopy_stepper_rep< C, homotopy_euler >::hom(), homotopy_stepper_rep< ball< C >, homotopy_ball >::hom(), homotopy(), REP_STRUCT< C, V >::homp(), inside(), matrix_new(), minimum_quotients(), heuristic_analytic_rep< C, V >::Move(), reverse_analytic_rep< C, V >::Move(), polynomial_analytic_rep< C, V >::Move(), mul_bound(), homotopy_stepper_rep< ball< C >, homotopy_ball >::newton_step(), heuristic_analytic_rep< C, V >::Radial_eval(), binary_helper< riemann_square< R, V > >::read(), binary_helper< riemann_point< R, V > >::read(), binary_helper< riemann_germ< R, V > >::read(), remove_column(), REP_STRUCT_1(), solve_lde(), and start_index().

V & f

Definition at line 445 of file analytic.hpp.

Referenced by access(), as_matrix(), as_vector(), homotopy_stepper_rep< ball< C >, homotopy_ball >::certify_tube(), first_variation_series(), head_extremum(), homotopy_stepper_rep< C, homotopy_euler >::hom(), homotopy_stepper_rep< ball< C >, homotopy_ball >::hom(), homotopy(), homotopy_stepper_rep< C, homotopy_euler >::newton_iterate(), homotopy_stepper_rep< C, homotopy_euler >::newton_step(), homotopy_stepper_rep< C, homotopy_euler >::propose_next(), solve_matrix_lde_init(), solve_ode_series(), solve_vector_lde_init(), and trig().

V V const analytic<C,V> const analytic<C,V>& g

Definition at line 561 of file analytic.hpp.

Referenced by default_eval(), and default_move().

riemann_point<R,V> HARD_IDENTITY_OP_SUGAR(template< typename R, typename V >, riemann_point< R, V >) template< typename R
analytic<C,V> INV_HYPER_SUGAR(template< typename C, typename V >, analytic< C, V >) ARG_HYPER_SUGAR(template< typename C
analytic< C, V > me [inline]

Definition at line 561 of file analytic.hpp.

Referenced by integrate_analytic_rep< C, V >::Abs_type(), div_analytic_rep< C, V >::Abs_type(), mul_analytic_rep< C, V >::Abs_type(), polynomial_analytic_rep< C, V >::Abs_type(), reverse_analytic_rep< C, V >::Derive(), lshiftz_analytic_rep< C, V >::Derive(), binary_scalar_analytic_rep< rmul_op, C, V, C >::Derive(), binary_recursive_analytic_rep< Op, C, V >::Derive(), binary_analytic_rep< mul_op, C, V >::Derive(), unary_recursive_analytic_rep< Op, C, V >::Derive(), unary_analytic_rep< neg_op, C, V >::Derive(), nullary_recursive_analytic_rep< Op, C, V >::Derive(), fixed_point_vector_analytic_rep< C >::Equation(), fixed_point_analytic_rep< C >::Equation(), binary_recursive_analytic_rep< Op, C, V >::Equation(), unary_recursive_analytic_rep< Op, C, V >::Equation(), nullary_recursive_analytic_rep< Op, C, V >::Equation(), cache_last_analytic_rep< C, V >::Eval(), fast_eval_analytic_rep< C, V >::Eval(), reverse_analytic_rep< C, V >::Eval(), compose_analytic_rep< C, V >::Eval(), lshiftz_analytic_rep< C, V >::Eval(), unary_recursive_analytic_rep< Op, C, V >::Eval(), solve_ode_series_rep< C >::initialize(), fixed_point_vector_analytic_rep< C >::Move(), fixed_point_analytic_rep< C >::Move(), cache_last_analytic_rep< C, V >::Move(), reverse_analytic_rep< C, V >::Move(), integrate_analytic_rep< C, V >::Move(), lshiftz_analytic_rep< C, V >::Move(), unary_recursive_analytic_rep< Op, C, V >::Move(), nullary_recursive_analytic_rep< Op, C, V >::Move(), REP_STRUCT_1(), and cache_last_analytic_rep< C, V >::Set_next().

int mmx_ode_order = 0

Definition at line 26 of file analytic.cpp.

Referenced by glue_ode_taylor_double(), glue_ode_taylor_floating(), and ode_order().

int mmx_ode_precision = 0

Definition at line 28 of file analytic.cpp.

Referenced by glue_ode_taylor_double(), glue_ode_taylor_floating(), and ode_precision().

double mmx_order_ratio = 1.0

Definition at line 22 of file analytic.cpp.

Referenced by compose(), default_order(), fast_eval_analytic_rep< C, V >::Eval(), heuristic_analytic_rep< C, V >::initialize(), and heuristic_analytic_rep< C, V >::Move().

double mmx_radius_ratio = 0.4

Definition at line 17 of file analytic.cpp.

Referenced by radius_ratio_helper< C, empty_format >::op().

V const nat order

Definition at line 445 of file analytic.hpp.

Referenced by compose(), fast_eval_analytic_rep< C, V >::Eval(), and REP_STRUCT_1().

R

Definition at line 101 of file riemann_bundle.hpp.

Referenced by vector_analytic_rep< C, V >::Abs_type(), matrix_analytic_rep< C, V >::Abs_type(), heuristic_analytic_rep< C, V >::Abs_type(), integrate_analytic_rep< C, V >::Abs_type(), lshiftz_analytic_rep< C, V >::Abs_type(), div_analytic_rep< C, V >::Abs_type(), polynomial_analytic_rep< C, V >::Abs_type(), adjacent(), admissible(), homotopy_stepper_rep< ball< C >, homotopy_ball >::certify_tube(), corners(), digital_disk(), digital_disk_sub(), homotopy_stepper_rep< ball< C >, homotopy_ball >::finish(), binary_helper< riemann_surface< R, V > >::full_type_name(), binary_helper< riemann_square< R, V > >::full_type_name(), binary_helper< riemann_point< R, V > >::full_type_name(), binary_helper< riemann_germ< R, V > >::full_type_name(), binary_helper< riemann_bundle< Germ, R, V > >::full_type_name(), head_extremum(), REP_STRUCT< C, V >::homp(), included(), inside(), intersect(), heuristic_analytic_rep< C, V >::Move(), mul_bound(), homotopy_stepper_rep< C, homotopy_euler >::newton_iterate(), homotopy_stepper_rep< C, homotopy_euler >::propose_next(), homotopy_stepper_rep< ball< C >, homotopy_ball >::propose_tube(), binary_helper< riemann_square< R, V > >::read(), binary_helper< riemann_germ< R, V > >::read(), REP_STRUCT_1(), binary_helper< riemann_surface< R, V > >::short_type_name(), binary_helper< riemann_square< R, V > >::short_type_name(), binary_helper< riemann_point< R, V > >::short_type_name(), binary_helper< riemann_germ< R, V > >::short_type_name(), binary_helper< riemann_bundle< Germ, R, V > >::short_type_name(), and start_index().

scalar_type

Definition at line 225 of file analytic.hpp.

analytic< C, V > V

Definition at line 225 of file analytic.hpp.

Referenced by as_analytic(), homotopy_stepper_rep< ball< C >, homotopy_ball >::certify_tube(), vector_analytic_rep< C, V >::Clear_cache(), matrix_analytic_rep< C, V >::Clear_cache(), from_matrix(), from_vector(), and homotopy().

Generated on 6 Dec 2012 for continewz by  doxygen 1.6.1