numerix_doc 0.4
Namespaces | Classes | Functions | Variables
mmx Namespace Reference

Namespaces

Classes

Functions

Variables

Function Documentation

affine<Abs_type(C),Abs_type(VC) > mmx::abs ( const affine< C, VC > &  z) [inline]
Examples:
ball_test.cpp, complex_ball_test.cpp, complex_test.cpp, and interval_test.cpp.

Definition at line 478 of file affine.hpp.

References Abs_affine, base(), limits(), and slope().

Referenced by implementation< ball_abs, IV, ball_infinities< BV > >::abs(), abs(), abs_down(), abs_up(), add_rough_additive_error(), add_rough_multiplicative_error(), additive_error(), implementation< ball_elementary, W, ball_rounded >::atan2(), implementation< ball_elementary, W, ball_rounded >::cos(), implementation< ball_elementary, W, ball_rounded >::cosh(), implementation< ball_elementary, IV, ball_complex< BV > >::cosh(), as_helper< signed char, integer >::cv(), modulus_mul_int_preinverse< modulus_add_int_naive< modulus_reduction_int_naive< modulus_normalization_int_naive< modulus_maximum_size_int< m > > > > >::dyn_r(), GLUE_14(), GLUE_23(), GLUE_24(), GLUE_35(), GLUE_36(), invert(), implementation< ball_multiplicative, W, ball_rough >::invert(), log(), make_mmx_ball(), implementation< ball_multiplicative, W, ball_rough >::mul(), modulus_normalization_int_naive< modulus_maximum_size_int< size > >::normalize(), operator/(), pow(), implementation< ball_elementary, W, ball_rounded >::sin(), implementation< ball_elementary, W, ball_rounded >::sinh(), implementation< ball_elementary, IV, ball_complex< BV > >::sinh(), and implementation< ball_multiplicative, W, ball_rough >::square().

                      {
  // FIXME: this is not really nice
  return Abs_affine (abs (base (z)), abs (slope (z)), limits (z));
}
ball<C,R,V> V ball<Abs_type(C),R,Abs_type(V) > mmx::abs ( const ball< C, R, V > &  z) [inline]

Definition at line 594 of file ball.hpp.

References abs(), and Abs_ball.

                    {
  typedef implementation<ball_abs,V> Impl;
  Abs_ball d; Impl::abs (d, z); return d;
}
C mmx::abs ( const complex< C > &  z) [inline]

Definition at line 211 of file complex.hpp.

References hypot(), Im(), and Re().

                       {
  return hypot (Re (z), Im (z));
}
floating<V> mmx::abs ( const floating< V > &  x1) [inline]

Definition at line 375 of file floating.hpp.

References Floating, and Rnd.

                                              {
  Floating r (*x1); mpfr_abs (*r, *x1, Rnd); return r; }
tangent<Abs_type(C),Abs_type(D) > mmx::abs ( const tangent< C, D > &  z) [inline]

Definition at line 390 of file tangent.hpp.

References abs(), Abs_tangent, base(), and slope().

                       {
  // FIXME: this is not really nice
  return Abs_tangent (abs (base (z)), abs (slope (z)));
}
interval< C, V > abs ( const interval< C, V > &  x) [inline]

Definition at line 263 of file interval.hpp.

References abs(), C, Interval, is_nan(), lower(), max(), min(), sign(), and upper().

                        {
  if (is_nan (x)) return x;
  C r= max (abs (lower (x)), abs (upper (x)));
  if (sign (lower (x)) * sign (upper (x)) <= 0) return Interval (C(0), r);
  return Interval (min (abs (lower (x)), abs (upper (x))), r);
}
R mmx::abs_down ( const ball< C, R, V > &  z) [inline]

Definition at line 115 of file ball.hpp.

References Rnd.

Referenced by implementation< ball_multiplicative, W, ball_rounded >::invert(), is_non_zero(), is_zero(), implementation< ball_elementary, IV, ball_complex< BV > >::log(), operator!=(), operator==(), implementation< ball_root, W, ball_rounded >::sqrt(), and implementation< ball_root, IV, ball_complex< BV > >::sqrt().

                                       {
  typedef implementation<ball_rounding,V> Rnd;
  return Rnd::abs_down (z); }
C mmx::abs_down ( const complex< interval< C > > &  z) [inline]

Definition at line 30 of file complex_interval.hpp.

References abs(), and lower().

                                                   {
  return lower (abs (z)); }
C mmx::abs_down ( const interval< C, V > &  x) [inline]

Definition at line 121 of file interval.hpp.

References abs(), and lower().

{ return lower (abs (x)); }
Abs_type ( C  ) const [inline]

Definition at line 704 of file ball.hpp.

References radius().

                              {
  return as<Abs_type(C) > (radius (z));
}
R mmx::abs_up ( const ball< C, R, V > &  z) [inline]

Definition at line 118 of file ball.hpp.

References Rnd.

Referenced by blur(), and implementation< ball_multiplicative, W, ball_rounded >::mul().

                                     {
  typedef implementation<ball_rounding,V> Rnd;
  return Rnd::abs_up (z); }
C mmx::abs_up ( const complex< interval< C > > &  z) [inline]

Definition at line 32 of file complex_interval.hpp.

References abs(), and upper().

                                                 {
  return upper (abs (z)); }
C mmx::abs_up ( const interval< C, V > &  x) [inline]

Definition at line 122 of file interval.hpp.

References abs(), and upper().

{ return upper (abs (x)); }
complex<C> mmx::acos ( const C &  z) [inline]

Definition at line 521 of file complex.hpp.

References acosh(), and over_i().

                  {
  return over_i (acosh (z));
}
interval<C,V> mmx::acos ( const interval< C, V > &  x)

Definition at line 563 of file interval.hpp.

References acos(), Interval, lower(), and upper().

                         {
  return Interval (Down::acos (upper (x)), Up::acos (lower (x)));
}
complex<C> mmx::acos ( const complex< C > &  z) [inline]

Definition at line 536 of file complex.hpp.

References acosh(), and over_i().

                        {
  return over_i (acosh (z));
}
ball<C,R,V> mmx::acos ( const ball< C, R, V > &  z) [inline]
Examples:
ball_test.cpp, complex_ball_test.cpp, and interval_test.cpp.

Definition at line 558 of file ball.hpp.

References Ball, C, Elementary_variant, and V.

Referenced by acos(), GLUE_18(), GLUE_19(), GLUE_23(), GLUE_28(), GLUE_29(), GLUE_32(), and GLUE_51().

                     {
  typedef Elementary_variant(C,V) EV;
  typedef implementation<ball_elementary,EV> Impl;
  Ball d; Impl::acos (d, z); return d;
}
tangent<C,D> mmx::acos ( const tangent< C, D > &  z)

Definition at line 282 of file tangent.hpp.

References acos(), base(), C, invert(), promote(), slope(), sqrt(), square(), and Tangent.

                        {
  C df= -invert (sqrt (promote (1, base (z)) - square (base (z))));
  return Tangent (acos (base (z)), df * slope (z));
}
floating<V> mmx::acos ( const floating< V > &  x1) [inline]

Definition at line 421 of file floating.hpp.

References Floating, and Rnd.

                                               {
  Floating r (*x1); mpfr_acos (*r, *x1, Rnd); return r; }
twin<C,D,V> mmx::acos ( const twin< C, D, V > &  x)

Definition at line 241 of file twin.hpp.

References acos(), car(), cdr(), and Twin.

                               {
  return Twin (acos (car (x)), acos (cdr (x))); }
floating<V> mmx::acosh ( const floating< V > &  x1) [inline]

Definition at line 435 of file floating.hpp.

References Floating, and Rnd.

Referenced by acos(), and acosh().

                                                {
  Floating r (*x1); mpfr_acosh (*r, *x1, Rnd); return r; }
twin<C,D,V> mmx::acosh ( const twin< C, D, V > &  x)

Definition at line 253 of file twin.hpp.

References acosh(), car(), cdr(), and Twin.

                                {
  return Twin (acosh (car (x)), acosh (cdr (x))); }
void mmx::add ( complex< C > &  r,
const complex< C > &  z1,
const complex< C > &  z2 
) [inline]

Definition at line 417 of file complex.hpp.

References Im(), and Re().

Referenced by implementation< ball_rounding, W, ball_rounded >::abs_up(), implementation< ball_additive, W, ball_rounded >::add(), implementation< ball_additive, IV, ball_infinities< BV > >::add(), implementation< ball_rounding, W, ball_rounded >::add_additive_error(), implementation< ball_rounding, W, ball_rounded >::add_elementary_error(), implementation< ball_rounding, W, ball_rounded >::add_multiplicative_error(), implementation< ball_rounding, W, ball_rounded >::add_rounding_error(), implementation< ball_elementary, W, ball_rounded >::atan(), implementation< ball_elementary, W, ball_rounded >::atan2(), blur(), implementation< ball_rounding, W, ball_rounded >::bnd_up(), implementation< ball_multiplicative, W, ball_rounded >::mul(), operator+(), interval< C, V >::operator+=(), operator-(), radius(), implementation< ball_multiplicative, W, ball_rounded >::square(), and implementation< ball_additive, W, ball_rounded >::sub().

                                                       {
  add (Re (r), Re (z1), Re (z2));
  add (Im (r), Im (z1), Im (z2));
}
void mmx::add ( floating< V > &  r,
const floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 327 of file floating.hpp.

References Rnd.

                                                                           {
  r.secure (); mpfr_add (*r, *x1, *x2, Rnd); }
void mmx::add_additive_error ( ball< C, R, V > &  z) [inline]

Definition at line 135 of file ball.hpp.

References Rnd.

Referenced by implementation< ball_additive, W, ball_rounded >::add(), ball< C, R, V >::ball(), set_as(), and implementation< ball_additive, W, ball_rounded >::sub().

                                              {
  typedef implementation<ball_rounding,V> Rnd;
  Rnd::add_additive_error (z); }
void mmx::add_elementary_error ( ball< C, R, V > &  z) [inline]

Definition at line 141 of file ball.hpp.

References Rnd.

Referenced by implementation< ball_elementary, W, ball_rounded >::acos(), implementation< ball_elementary, W, ball_rounded >::asin(), implementation< ball_elementary, W, ball_rounded >::atan(), implementation< ball_elementary, W, ball_rounded >::atan2(), implementation< ball_elementary, W, ball_rounded >::cos(), implementation< ball_elementary, IV, ball_complex< BV > >::cos(), implementation< ball_elementary, W, ball_rounded >::cosh(), implementation< ball_elementary, IV, ball_complex< BV > >::cosh(), implementation< ball_elementary, W, ball_rounded >::exp(), implementation< ball_elementary, IV, ball_complex< BV > >::exp(), implementation< ball_complex_construct, IV, ball_complex< BV > >::gauss(), implementation< ball_elementary, W, ball_rounded >::log(), implementation< ball_elementary, IV, ball_complex< BV > >::log(), implementation< ball_elementary, W, ball_rounded >::sin(), implementation< ball_elementary, IV, ball_complex< BV > >::sin(), implementation< ball_elementary, W, ball_rounded >::sinh(), and implementation< ball_elementary, IV, ball_complex< BV > >::sinh().

                                                {
  typedef implementation<ball_rounding,V> Rnd;
  Rnd::add_elementary_error (z); }
void mmx::add_mod ( C &  dest,
const C &  s,
const modulus< C, V > &  m 
) [inline]

Definition at line 118 of file modulus.hpp.

Referenced by add_mod(), operator+(), and operator+=().

                                                {
  V::add_mod (dest, s, m); }
void mmx::add_mod ( C &  dest,
const C &  s,
const modulus< C, V > &  m,
C &  carry 
) [inline]

Definition at line 122 of file modulus.hpp.

References add_mod().

                                                          {
  V::add_mod (dest, s, m, carry); }
void mmx::add_mod ( C &  dest,
const C &  s1,
const C &  s2,
const modulus< C, V > &  m 
) [inline]

Definition at line 126 of file modulus.hpp.

References add_mod().

                                                              {
  V::add_mod (dest, s1, s2, m); }
void mmx::add_mod ( C &  dest,
const C &  s1,
const C &  s2,
const modulus< C, V > &  m,
C &  carry 
) [inline]

Definition at line 130 of file modulus.hpp.

References add_mod().

                                                                        {
  V::add_mod (dest, s1, s2, m, carry); }
void mmx::add_multiplicative_error ( ball< C, R, V > &  z) [inline]

Definition at line 138 of file ball.hpp.

References Rnd.

Referenced by implementation< ball_abs, W, ball_rounded >::abs(), implementation< ball_root, W, ball_rounded >::hypot(), implementation< ball_multiplicative, W, ball_rounded >::invert(), implementation< ball_multiplicative, W, ball_rounded >::mul(), implementation< ball_shift, W, ball_rounded >::shiftl(), implementation< ball_shift, W, ball_rounded >::shiftr(), implementation< ball_root, W, ball_rounded >::sqrt(), implementation< ball_root, IV, ball_complex< BV > >::sqrt(), and implementation< ball_multiplicative, W, ball_rounded >::square().

                                                    {
  typedef implementation<ball_rounding,V> Rnd;
  Rnd::add_multiplicative_error (z); }
void mmx::add_rough_additive_error ( ball< C, R, V > &  d) [inline]

Definition at line 48 of file ball_rough.hpp.

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

Referenced by implementation< ball_additive, W, ball_rough >::add(), and implementation< ball_additive, W, ball_rough >::sub().

                                   {
  radius (d) += additive_error (center (d));
  radius (d) *= (1 + incexp2 (Accuracy (R), 2));
}
void mmx::add_rough_additive_error ( ball< double, double, V > &  d) [inline]

Definition at line 54 of file ball_rough.hpp.

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

                                                    {
  const double alpha= 1.000000000000008882;
  radius (d)= alpha * (radius (d) + ldexp (abs (center (d)), -50));
}
void mmx::add_rough_multiplicative_error ( ball< C, R, V > &  d) [inline]

Definition at line 117 of file ball_rough.hpp.

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

Referenced by implementation< ball_root, W, ball_rough >::hypot(), implementation< ball_multiplicative, W, ball_rough >::invert(), implementation< ball_multiplicative, W, ball_rough >::mul(), implementation< ball_root, W, ball_rough >::sqrt(), and implementation< ball_multiplicative, W, ball_rough >::square().

                                         {
  radius (d) += multiplicative_error (center (d));
  radius (d) *= (1 + incexp2 (Accuracy (R), 4));
  radius (d) += incexp2 (Smallest (R), 4);
}
void mmx::add_rough_multiplicative_error ( ball< double, double, V > &  d) [inline]

Definition at line 124 of file ball_rough.hpp.

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

                                                          {
  const double alpha= 1.000000000000001777;
  const double beta = 3.952525166729972354e-323;
  radius (d)= alpha * (radius (d) + ldexp (abs (center (d)), -50)) + beta;
}
void mmx::add_rounding_error ( ball< C, R, V > &  z) [inline]

Definition at line 132 of file ball.hpp.

References Rnd.

                                              {
  typedef implementation<ball_rounding,V> Rnd;
  Rnd::add_rounding_error (z); }
affine<C,VC> mmx::additive_error ( const affine< C, VC > &  z) [inline]

Definition at line 452 of file affine.hpp.

References Affine, base(), limits(), and slope().

Referenced by implementation< ball_rounding, W, ball_rounded >::add_additive_error(), add_rough_additive_error(), additive_error(), GLUE_45(), and GLUE_54().

                                                    {
  return Affine (additive_error (base (z)),
                 additive_error (slope (z)),
                 limits (z)); }
double mmx::additive_error ( const complex< double > &  z) [inline]

Definition at line 60 of file complex_double.hpp.

References abs(), Im(), and Re().

                                                        {
  return ldexp (abs (Re (z)) + abs (Im (z)), -49); }
ball<Abs_type(C),R,Abs_type(V) > mmx::additive_error ( const ball< C, R, V > &  x) [inline]

Definition at line 654 of file ball.hpp.

References Abs_ball, additive_error(), and center().

                                                    {
  return Abs_ball (additive_error (center (x))); }
tangent<C,D> mmx::additive_error ( const tangent< C, D > &  z) [inline]

Definition at line 367 of file tangent.hpp.

References additive_error(), base(), slope(), and Tangent.

                                                      {
  return Tangent (additive_error (base (z)), additive_error (slope (z))); }
floating<V> mmx::additive_error ( const floating< V > &  x) [inline]

Definition at line 483 of file floating.hpp.

References Floating.

                                                        {
  Floating r (*x);
  mpfr_abs (*r, *x, GMP_RNDN);
  mpfr_mul_2si (*r, *r, 1-mpfr_get_prec (*x), GMP_RNDN);
  mpfr_nextabove (*r);
  return r; }
ball< Real_type(C) ,R,V> mmx::arg ( const ball< C, R, V > &  z) [inline]
Examples:
complex_ball_test.cpp, and complex_test.cpp.

Definition at line 55 of file ball_complex.hpp.

References atan2(), Im(), and Re().

Referenced by GLUE_15(), GLUE_24(), log(), and pow().

                                                  {
  return atan2 (Im (z), Re (z)); }
C mmx::arg ( const complex< C > &  z) [inline]

Definition at line 216 of file complex.hpp.

References atan2(), Im(), and Re().

                       {
  return atan2 (Im (z), Re (z));
}
interval<C,V> mmx::ARG_HYPER_SUGAR ( template< typename C, typename V >  ,
interval< C, V >   
)
complex<C> mmx::ARG_HYPER_SUGAR ( template< typename C >  ,
complex< C >   
) const

Definition at line 569 of file complex.hpp.

References Im(), is_finite(), and Re().

                                              {
  return is_finite (Re (z)) && is_finite (Im (z)); }
mmx::ARITH_INT_SUGAR ( template< typename C, typename V >  ,
interval< C, V >   
)
mmx::ARITH_INT_SUGAR ( template< typename C, typename R, typename V >  ,
ball< C, R, V >   
)
mmx::ARITH_INT_SUGAR ( template< typename C, typename VC >  ,
affine< C, VC >   
)
mmx::ARITH_INT_SUGAR ( template< typename V >  ,
floating< V >   
)
mmx::ARITH_INT_SUGAR ( template< typename C, typename D >  ,
tangent< C, D >   
)
mmx::ARITH_INT_SUGAR ( template< typename C, typename D, typename V >  ,
twin< C, D, V >   
)
mmx::ARITH_SCALAR_INT_SUGAR ( template< typename C >  ,
complex< C >   
)
T mmx::as ( const F &  x) [inline]

Definition at line 86 of file kernel.hpp.

References as_helper< T, F >::cv().

{ return as_helper<T,F>::cv (x); }
double mmx::as_double ( const floating< V > &  x) [inline]

Definition at line 262 of file floating.hpp.

References Rnd.

Referenced by mmx::let::assign(), as_helper< double, rational >::cv(), as_helper< double, floating<> >::cv(), as_helper< double, integer >::cv(), as_helper< double, floating< V > >::cv(), fast_helper< floating< V > >::dd(), and GLUE_11().

                                                 {
  return mpfr_get_d (*x, Rnd); }
floating<V> mmx::as_floating ( const rational &  x)

Definition at line 237 of file floating.hpp.

                                {
  floating<V> r;
  mpfr_set_q (*r, *x, V::rnd());
  return r;
}
floating<W> mmx::as_floating ( const floating< V > &  x)

Definition at line 221 of file floating.hpp.

                                   {
  floating<W> r;
  mpfr_set (*r, *x, W::rnd());
  return r;
}
int mmx::as_int ( const floating< V > &  x) [inline]

Definition at line 258 of file floating.hpp.

References Rnd.

Referenced by binomial(), factorial(), GLUE_10(), GLUE_4(), and recompose().

                                           {
  return mpfr_get_si (*x, Rnd); }
integer mmx::as_integer ( const floating< V > &  x) [inline]

Definition at line 264 of file floating.hpp.

References Rnd.

Referenced by GLUE_12(), and nearest().

                                                   {
  integer r; mpfr_get_z (*r, *x, Rnd); return r; }
nat mmx::as_nat ( const floating< V > &  x) [inline]

Definition at line 260 of file floating.hpp.

References Rnd.

                                           {
  return mpfr_get_ui (*x, Rnd); }
string mmx::as_string ( const floating< V > &  x)

Definition at line 186 of file floating.hpp.

References mpfr_to_string().

Referenced by decompose_range(), binary_helper< integer >::disassemble(), flatten(), GLUE_13(), inc_mantissa(), make_range(), mpfr_to_string(), print(), recompose(), simple_construct_integer(), simple_construct_rational(), and zero_to_string().

                              {
  return mpfr_to_string (*x);
}
string mmx::as_string ( const C &  x,
xnat  dd 
)

Definition at line 31 of file string_scnot.hpp.

References flatten_as_string(), and trunc_digits().

                                {
  if (dd == 0) return flatten_as_string (x);
  else return trunc_digits (flatten_as_string (x), dd);
}
string mmx::as_string ( const integer &  i)

Definition at line 19 of file mmx_gmp.cpp.

                             {
  char* s= mpz_get_str (NULL, 10, *i);
  string r= s;
  mmx_free (s, strlen (s) + 1);
  /* FIXME: for upcoming version of GMP
  void (*free_func) (void *, size_t);
  mp_get_memory_functions (NULL, NULL, &free_func);
  free_func ((void*) s, strlen (s) + 1);
  */
  return r;
}
interval<C,V> mmx::asin ( const interval< C, V > &  x)

Definition at line 568 of file interval.hpp.

References asin(), Interval, lower(), and upper().

                         {
  return Interval (Down::asin (lower (x)), Up::asin (upper (x)));
}
complex<C> mmx::asin ( const C &  z) [inline]

Definition at line 526 of file complex.hpp.

References asinh(), over_i(), and times_i().

                  {
  return over_i (asinh (times_i (z)));
}
complex<C> mmx::asin ( const complex< C > &  z) [inline]

Definition at line 541 of file complex.hpp.

References asinh(), over_i(), and times_i().

                        {
  return over_i (asinh (times_i (z)));
}
ball<C,R,V> mmx::asin ( const ball< C, R, V > &  z) [inline]
Examples:
ball_test.cpp, complex_ball_test.cpp, and interval_test.cpp.

Definition at line 565 of file ball.hpp.

References Ball, C, Elementary_variant, and V.

Referenced by asin(), atan(), GLUE_19(), GLUE_20(), GLUE_24(), GLUE_29(), GLUE_30(), GLUE_33(), and GLUE_52().

                     {
  typedef Elementary_variant(C,V) EV;
  typedef implementation<ball_elementary,EV> Impl;
  Ball d; Impl::asin (d, z); return d;
}
tangent<C,D> mmx::asin ( const tangent< C, D > &  z)

Definition at line 288 of file tangent.hpp.

References asin(), base(), C, invert(), promote(), slope(), sqrt(), square(), and Tangent.

                        {
  C df= invert (sqrt (promote (1, base (z)) - square (base (z))));
  return Tangent (asin (base (z)), df * slope (z));
}
floating<V> mmx::asin ( const floating< V > &  x1) [inline]

Definition at line 423 of file floating.hpp.

References Floating, and Rnd.

                                               {
  Floating r (*x1); mpfr_asin (*r, *x1, Rnd); return r; }
twin<C,D,V> mmx::asin ( const twin< C, D, V > &  x)

Definition at line 243 of file twin.hpp.

References asin(), car(), cdr(), and Twin.

                               {
  return Twin (asin (car (x)), asin (cdr (x))); }
floating<V> mmx::asinh ( const floating< V > &  x1) [inline]

Definition at line 437 of file floating.hpp.

References Floating, and Rnd.

Referenced by asin(), and asinh().

                                                {
  Floating r (*x1); mpfr_asinh (*r, *x1, Rnd); return r; }
twin<C,D,V> mmx::asinh ( const twin< C, D, V > &  x)

Definition at line 255 of file twin.hpp.

References asinh(), car(), cdr(), and Twin.

                                {
  return Twin (asinh (car (x)), asinh (cdr (x))); }
interval<C,V> mmx::atan ( const interval< C, V > &  x)

Definition at line 573 of file interval.hpp.

References atan(), Interval, lower(), and upper().

                         {
  return Interval (Down::atan (lower (x)), Up::atan (upper (x)));
}
complex<C> mmx::atan ( const C &  z) [inline]

Definition at line 531 of file complex.hpp.

References atanh(), over_i(), and times_i().

                  {
  return over_i (atanh (times_i (z)));
}
complex<C> mmx::atan ( const complex< C > &  z) [inline]

Definition at line 546 of file complex.hpp.

References atanh(), over_i(), and times_i().

                        {
  return over_i (atanh (times_i (z)));
}
ball<C,R,V> mmx::atan ( const ball< C, R, V > &  z) [inline]
Examples:
ball_test.cpp, complex_ball_test.cpp, and interval_test.cpp.

Definition at line 572 of file ball.hpp.

References Ball, C, Elementary_variant, and V.

Referenced by atan(), atan2(), GLUE_20(), GLUE_21(), GLUE_25(), GLUE_30(), GLUE_31(), GLUE_34(), and GLUE_53().

                     {
  typedef Elementary_variant(C,V) EV;
  typedef implementation<ball_elementary,EV> Impl;
  Ball d; Impl::atan (d, z); return d;
}
tangent<C,D> mmx::atan ( const tangent< C, D > &  z)

Definition at line 294 of file tangent.hpp.

References asin(), base(), C, invert(), promote(), slope(), square(), and Tangent.

                        {
  C df= invert (promote (1, base (z)) + square (base (z)));
  return Tangent (asin (base (z)), df * slope (z));
}
floating<V> mmx::atan ( const floating< V > &  x1) [inline]

Definition at line 425 of file floating.hpp.

References Floating, and Rnd.

                                               {
  Floating r (*x1); mpfr_atan (*r, *x1, Rnd); return r; }
twin<C,D,V> mmx::atan ( const twin< C, D, V > &  x)

Definition at line 245 of file twin.hpp.

References atan(), car(), cdr(), and Twin.

                               {
  return Twin (atan (car (x)), atan (cdr (x))); }
interval<C,V> mmx::atan2 ( const interval< C, V > &  y,
const interval< C, V > &  x 
)

Definition at line 578 of file interval.hpp.

References atan(), C, Interval, lower(), sign(), and upper().

                                             {
  if (sign (lower (x)) > 0) return atan (y/x);
  if (sign (lower (y)) > 0) return atan (-x/y) + (Pi (Interval) >> 1);
  if (sign (upper (y)) < 0) return atan (-x/y) - (Pi (Interval) >> 1);
  if (sign (upper (x)) < 0) return atan (y/x) + Pi (Interval);
  C pi= Up::template pi<C> ();
  return Interval (-pi, pi);
}
ball<C,R,V> mmx::atan2 ( const ball< C, R, V > &  y,
const ball< C, R, V > &  x 
) [inline]
Examples:
ball_test.cpp, floating_test.cpp, and interval_test.cpp.

Definition at line 579 of file ball.hpp.

References Ball, C, Elementary_variant, and V.

Referenced by arg(), and atan2().

                                     {
  typedef Elementary_variant(C,V) EV;
  typedef implementation<ball_elementary,EV> Impl;
  Ball d; Impl::atan2 (d, y, x); return d;
}
tangent<C,D> mmx::atan2 ( const tangent< C, D > &  y,
const tangent< C, D > &  x 
)

Definition at line 300 of file tangent.hpp.

References atan2(), base(), and Tangent.

                                           {
  ERROR ("not yet implemented");
  return Tangent (atan2 (base (y), base (x)), 0);
}
twin<C,D,V> mmx::atan2 ( const twin< C, D, V > &  x,
const twin< C, D, V > &  y 
)

Definition at line 259 of file twin.hpp.

References atan2(), car(), cdr(), and Twin.

                                               {
  return Twin (atan2 (car (x), car (y)), atan2 (cdr (x), cdr (y))); }
mmx::ATAN2_SUGAR ( template< typename V >  ,
floating< V >   
)
floating<V> mmx::atanh ( const floating< V > &  x1) [inline]

Definition at line 439 of file floating.hpp.

References Floating, and Rnd.

Referenced by atan(), and atanh().

                                                {
  Floating r (*x1); mpfr_atanh (*r, *x1, Rnd); return r; }
twin<C,D,V> mmx::atanh ( const twin< C, D, V > &  x)

Definition at line 257 of file twin.hpp.

References atanh(), car(), cdr(), and Twin.

                                {
  return Twin (atanh (car (x)), atanh (cdr (x))); }
C base ( const tangent< C, D > &  z) [inline]

Definition at line 69 of file tangent.hpp.

{ return z.c; }
C & base ( tangent< C, D > &  z) [inline]

Definition at line 71 of file tangent.hpp.

{ return z.c; }
C base ( const affine< C, VC > &  z) [inline]

Definition at line 104 of file affine.hpp.

Referenced by abs(), acos(), additive_error(), asin(), atan(), atan2(), binary_test(), blur(), CF1(), change_precision(), copy(), cos(), cosh(), binary_helper< tangent< C, D > >::disassemble(), binary_helper< affine< C, VC > >::disassemble(), duplicate(), exp(), exponent(), flatten(), floating< V >::floating(), GLUE_16(), GLUE_3(), GLUE_36(), GLUE_4(), Im(), integer::integer(), invert(), is_finite(), is_fuzz(), is_infinite(), is_nan(), is_reliable(), log(), magnitude(), map(), operator*(), operator+(), operator-(), operator/(), operator<(), operator<<(), operator<=(), operator>(), operator>=(), operator>>(), precision(), Re(), set_accuracy(), set_euler(), set_fuzz(), set_imaginary(), set_infinity(), set_largest(), set_log2(), set_nan(), set_pi(), set_smallest(), sharpen(), sin(), sinh(), sqrt(), square(), truncate(), unary_hash(), binary_helper< tangent< C, D > >::write(), and binary_helper< affine< C, VC > >::write().

                                     {
  return z.cst; }
mmx::BINARY_RETURN_TYPE ( template< typename C, typename R, typename V >  ,
gaussian_op  ,
ball< C, R, V >  ,
ball< C, R, V >  ,
ball< complex< C >, R, V >   
)
bool mmx::binary_test ( const affine< C, VC > &  x1,
const affine< C, VC > &  x2 
)

Definition at line 144 of file affine.hpp.

References base(), limits(), and slope().

                                                 {
  return Op::op (base (x1), base (x2)) &&
         Op::op (slope (x1), slope (x2)) &&
         Op::op (limits (x1), limits (x2));
}
bool mmx::binary_test ( const tangent< C, D > &  x1,
const tangent< C, D > &  x2 
)

Definition at line 88 of file tangent.hpp.

References base(), and slope().

                                                   {
  return Op::op (base (x1), base (x2)) &&
         Op::op (slope (x1), slope (x2));
}
bool mmx::binary_test ( const ball< C, R, V > &  x1,
const ball< C, R, V > &  x2 
)

Definition at line 159 of file ball.hpp.

References center(), and radius().

                                             {
  return Op::op (center (x1), center (x2)) &&
         Op::op (radius (x1), radius (x2));
}
bool mmx::binary_test ( const interval< C, V > &  x1,
const interval< C, V > &  x2 
)

Definition at line 145 of file interval.hpp.

References lower(), and upper().

                                                     {
  return Op::op (lower (x1), lower (x2)) && Op::op (upper (x1), upper (x2));
}
bool mmx::binary_test ( const complex< C > &  z1,
const complex< C > &  z2 
)

Definition at line 126 of file complex.hpp.

References Im(), and Re().

                                                   {
  return Op::op (Re (z1), Re (z2)) && Op::op (Im (z1), Im (z2));
}
integer mmx::binomial ( nat  i,
nat  j 
) [inline]

Definition at line 1137 of file integer.hpp.

Referenced by binomial(), and GLUE_27().

                                       {
  integer r; mpz_bin_uiui (*r, i, j); return r; }
integer mmx::binomial ( const integer &  i,
const integer &  j 
) [inline]

Definition at line 1144 of file integer.hpp.

References as_int(), and binomial().

                                                             {
  ASSERT (i >= 0 && j >= 0, "positive argument expected");
  return binomial ((nat) as_int (i), (nat) as_int (j)); }
C mmx::binpow ( const C &  i,
const integer &  n 
)

Definition at line 1167 of file integer.hpp.

References C, promote(), and square().

                                      {
  if (n <= 1) return n == 0 ? promote (1, i) : i;
  C j= binpow (i, n >> 1);
  if ((n & 1) == 0) return square (j);
  else return square (j) * i;
}
interval<C,V> mmx::blur ( const interval< C, V > &  x,
const C &  r 
) [inline]

Definition at line 638 of file interval.hpp.

References Interval.

                                                          {
  return x + Interval (-r, r); }
interval<C,V> mmx::blur ( const interval< C, V > &  x,
const interval< C, V > &  r 
) [inline]

Definition at line 640 of file interval.hpp.

References abs_up(), and blur().

                                                                 {
  return blur (x, abs_up (r)); }
affine<C,VC> mmx::blur ( const affine< C, VC > &  z,
const affine< C2, VC2 > &  r 
) [inline]

Definition at line 469 of file affine.hpp.

References Affine, base(), limits(), and slope().

Referenced by blur(), and affine_limits_helper< C, VC >::get_domain().

                                                {
  return Affine (blur (base (z), base (r)), blur (slope (z), slope (r)),
                 limits (z)); }
complex<C> mmx::blur ( const complex< C > &  z,
const R &  r 
) [inline]

Definition at line 645 of file complex.hpp.

References blur(), Complex, Im(), and Re().

                                    {
  return Complex (blur (Re (z), r), blur (Im (z), r)); }
ball<C,R,V> mmx::blur ( const ball< C, R, V > &  z,
const ball< K, R, V > &  r 
) [inline]

Definition at line 684 of file ball.hpp.

References abs_up(), add(), Ball, center(), R, radius(), and Up.

                                           {
  typedef Round_up(R) Up;
  return Ball (center (z), Up::add (radius (z), abs_up (r))); }
ball<C,R,V> mmx::blur ( const ball< C, R, V > &  z,
const R &  r 
) [inline]

Definition at line 680 of file ball.hpp.

References add(), Ball, center(), R, radius(), and Up.

                                                  {
  typedef Round_up(R) Up;
  return Ball (center (z), Up::add (radius (z), r)); }
tangent<C,D> mmx::blur ( const tangent< C, D > &  z,
const tangent< C2, D2 > &  r 
) [inline]

Definition at line 382 of file tangent.hpp.

References base(), blur(), slope(), and Tangent.

                                                 {
  return Tangent (blur (base (z), base (r)), blur (slope (z), slope (r))); }
twin<C,D,V> mmx::blur ( const twin< C, D, V > &  z,
const twin< C2, D2, V2 > &  r 
) [inline]

Definition at line 297 of file twin.hpp.

References blur(), car(), cdr(), and Twin.

                                              {
  return Twin (blur (car (z), car (r)), blur (cdr (z), cdr (r))); }
R mmx::bnd_down ( const ball< C, R, V > &  z) [inline]

Definition at line 121 of file ball.hpp.

References Rnd.

Referenced by implementation< ball_elementary, W, ball_rounded >::acos(), implementation< ball_elementary, W, ball_rounded >::asin(), implementation< ball_elementary, W, ball_rounded >::atan(), implementation< ball_elementary, W, ball_rounded >::atan2(), implementation< ball_elementary, W, ball_rounded >::cos(), is_negative_or_zero(), is_positive(), implementation< ball_elementary, W, ball_rounded >::log(), and implementation< ball_elementary, W, ball_rounded >::sin().

                                       {
  typedef implementation<ball_rounding,V> Rnd;
  return Rnd::bnd_down (z); }
C mmx::bnd_down ( const interval< C, V > &  x) [inline]

Definition at line 123 of file interval.hpp.

References lower().

{ return lower (x); }
R mmx::bnd_up ( const ball< C, R, V > &  z) [inline]

Definition at line 124 of file ball.hpp.

References Rnd.

Referenced by implementation< ball_elementary, W, ball_rounded >::atan2(), implementation< ball_elementary, W, ball_rounded >::cos(), implementation< ball_elementary, IV, ball_complex< BV > >::cos(), implementation< ball_elementary, W, ball_rounded >::cosh(), implementation< ball_elementary, IV, ball_complex< BV > >::cosh(), implementation< ball_elementary, W, ball_rounded >::exp(), implementation< ball_elementary, IV, ball_complex< BV > >::exp(), is_negative(), is_positive_or_zero(), implementation< ball_elementary, W, ball_rounded >::sin(), implementation< ball_elementary, IV, ball_complex< BV > >::sin(), implementation< ball_elementary, W, ball_rounded >::sinh(), and implementation< ball_elementary, IV, ball_complex< BV > >::sinh().

                                     {
  typedef implementation<ball_rounding,V> Rnd;
  return Rnd::bnd_up (z); }
C mmx::bnd_up ( const interval< C, V > &  x) [inline]

Definition at line 124 of file interval.hpp.

References upper().

{ return upper (x); }
C car ( const twin< C, D, V > &  x) [inline]

Definition at line 77 of file twin.hpp.

Referenced by acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), blur(), CF1(), change_precision(), copy(), cos(), cosh(), as_helper< twin< C1, D1, V1 >, twin< C2, D2, V2 > >::cv(), binary_helper< twin< C, D, V > >::disassemble(), duplicate(), exp(), exponent(), hash(), hypot(), is_exact_zero(), is_finite(), is_fuzz(), is_infinite(), is_nan(), is_reliable(), log(), magnitude(), map(), operator!=(), operator*(), operator+(), operator-(), operator/(), operator<(), operator<<(), operator<=(), operator==(), operator>(), operator>=(), operator>>(), pow(), precision(), set_accuracy(), set_euler(), set_fuzz(), set_imaginary(), set_infinity(), set_largest(), set_log2(), set_nan(), set_pi(), set_smallest(), sharpen(), sin(), sinh(), sqrt(), tan(), tanh(), unary_hash(), and binary_helper< twin< C, D, V > >::write().

{ return x.x1; }
C & car ( twin< C, D, V > &  x) [inline]

Definition at line 79 of file twin.hpp.

{ return x.x1; }
floating<V> mmx::cbrt ( const floating< V > &  x1) [inline]

Definition at line 401 of file floating.hpp.

References Floating, and Rnd.

                                               {
  Floating r (*x1); mpfr_cbrt (*r, *x1, Rnd); return r; }
D cdr ( const twin< C, D, V > &  x) [inline]

Definition at line 78 of file twin.hpp.

Referenced by acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), blur(), CF2(), change_precision(), copy(), cos(), cosh(), as_helper< twin< C1, D1, V1 >, twin< C2, D2, V2 > >::cv(), binary_helper< twin< C, D, V > >::disassemble(), duplicate(), exact_eq(), exact_hash(), exact_neq(), exp(), flatten(), hard_eq(), hard_hash(), hard_neq(), hypot(), log(), map(), operator*(), operator+(), operator-(), operator/(), operator<<(), operator>>(), pow(), set_accuracy(), set_euler(), set_fuzz(), set_imaginary(), set_infinity(), set_largest(), set_log2(), set_nan(), set_pi(), set_smallest(), sharpen(), sin(), sinh(), sqrt(), tan(), tanh(), and binary_helper< twin< C, D, V > >::write().

{ return x.x2; }
D & cdr ( twin< C, D, V > &  x) [inline]

Definition at line 80 of file twin.hpp.

{ return x.x2; }
ball<C,R,V> mmx::ceil ( const ball< C, R, V > &  z) [inline]

Definition at line 624 of file ball.hpp.

References Ball.

Referenced by ceil(), implementation< ball_ordered, W, ball_rounded >::ceil(), GLUE_28(), GLUE_39(), and GLUE_40().

                     {
  typedef implementation<ball_ordered,V> Impl;
  Ball d; Impl::ceil (d, z); return d;
}
floating<V> mmx::ceil ( const floating< V > &  x1) [inline]

Definition at line 386 of file floating.hpp.

References Floating.

                                               {
  Floating r (*x1); mpfr_ceil (*r, *x1); return r; }
interval<C,V> mmx::ceil ( const interval< C, V > &  x)

Definition at line 291 of file interval.hpp.

References ceil(), Interval, lower(), and upper().

                         {
  return Interval (Down::ceil (lower (x)), Up::ceil (upper (x)));
}
C center ( const ball< C, R, V > &  z) [inline]
Examples:
ball_test.cpp, complex_ball_test.cpp, and interval_test.cpp.

Definition at line 104 of file ball.hpp.

Referenced by implementation< ball_abs, W, ball_rounded >::abs(), implementation< ball_rounding, W, ball_rounded >::abs_down(), implementation< ball_rounding, W, ball_rounded >::abs_up(), implementation< ball_elementary, W, ball_rounded >::acos(), implementation< ball_additive, W, ball_rounded >::add(), implementation< ball_additive, W, ball_rough >::add(), implementation< ball_additive, IV, ball_infinities< BV > >::add(), implementation< ball_rounding, W, ball_rounded >::add_additive_error(), implementation< ball_rounding, W, ball_rounded >::add_elementary_error(), implementation< ball_rounding, W, ball_rounded >::add_multiplicative_error(), add_rough_additive_error(), add_rough_multiplicative_error(), implementation< ball_rounding, W, ball_rounded >::add_rounding_error(), additive_error(), implementation< ball_elementary, W, ball_rounded >::asin(), implementation< ball_elementary, W, ball_rounded >::atan(), implementation< ball_elementary, W, ball_rounded >::atan2(), binary_test(), blur(), implementation< ball_rounding, W, ball_rounded >::bnd_down(), implementation< ball_rounding, W, ball_rounded >::bnd_up(), change_precision(), conj(), copy(), implementation< ball_elementary, W, ball_rounded >::cos(), implementation< ball_elementary, IV, ball_complex< BV > >::cos(), implementation< ball_elementary, W, ball_rounded >::cosh(), implementation< ball_elementary, IV, ball_complex< BV > >::cosh(), binary_helper< ball< C, R, V > >::disassemble(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::div(), duplicate(), elementary_error(), implementation< ball_elementary, W, ball_rounded >::exp(), implementation< ball_elementary, IV, ball_complex< BV > >::exp(), exponent(), flatten(), flatten_range(), implementation< ball_complex_construct, IV, ball_complex< BV > >::gauss(), GLUE_6(), implementation< ball_root, W, ball_rounded >::hypot(), implementation< ball_root, W, ball_rough >::hypot(), Im(), included(), implementation< ball_multiplicative, W, ball_rounded >::invert(), implementation< ball_multiplicative, W, ball_rough >::invert(), is_exact_zero(), is_finite(), is_fuzz(), is_infinite(), is_nan(), is_negative(), is_negative_or_zero(), is_non_zero(), is_positive(), is_positive_or_zero(), is_zero(), implementation< ball_elementary, W, ball_rounded >::log(), implementation< ball_elementary, IV, ball_complex< BV > >::log(), implementation< ball_rounding, W, ball_rounded >::lower(), magnitude(), implementation< ball_rounding, W, ball_rounded >::make_interval(), implementation< ball_ordered, W, ball_rounded >::max(), implementation< ball_ordered, W, ball_rounded >::min(), implementation< ball_multiplicative, W, ball_rounded >::mul(), implementation< ball_multiplicative, W, ball_rough >::mul(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::mul(), multiplicative_error(), implementation< ball_additive, W, ball_rounded >::neg(), implementation< ball_additive, W, ball_rough >::neg(), over_i(), precision(), radius(), Re(), set_as(), sharpen(), implementation< ball_shift, W, ball_rounded >::shiftl(), implementation< ball_shift, W, ball_rough >::shiftl(), implementation< ball_shift, W, ball_rounded >::shiftr(), implementation< ball_shift, W, ball_rough >::shiftr(), implementation< ball_elementary, W, ball_rounded >::sin(), implementation< ball_elementary, IV, ball_complex< BV > >::sin(), implementation< ball_elementary, W, ball_rounded >::sinh(), implementation< ball_elementary, IV, ball_complex< BV > >::sinh(), implementation< ball_root, W, ball_rounded >::sqrt(), implementation< ball_root, W, ball_rough >::sqrt(), implementation< ball_root, IV, ball_complex< BV > >::sqrt(), implementation< ball_multiplicative, W, ball_rounded >::square(), implementation< ball_multiplicative, W, ball_rough >::square(), implementation< ball_additive, W, ball_rounded >::sub(), implementation< ball_additive, W, ball_rough >::sub(), implementation< ball_additive, IV, ball_infinities< BV > >::sub(), times_i(), unary_hash(), implementation< ball_rounding, W, ball_rounded >::upper(), and binary_helper< ball< C, R, V > >::write().

{ return z.c; }
C & center ( ball< C, R, V > &  z) [inline]

Definition at line 106 of file ball.hpp.

{ return z.c; }
C mmx::center ( const interval< C, V > &  x) [inline]

Definition at line 111 of file interval.hpp.

References lower(), and upper().

                                         {
  return decexp2 (lower (x) + upper (x)); }
format<C> mmx::CF ( const complex< C > &  z) [inline]

Definition at line 110 of file complex.hpp.

References Re().

{ return get_format (Re(z)); }
format<C> mmx::CF ( const interval< C, V > &  x) [inline]

Definition at line 117 of file interval.hpp.

References lower().

                                             {
  return get_format (lower (x)); }
format<C> mmx::CF1 ( const affine< C, VC > &  z) [inline]

Definition at line 110 of file affine.hpp.

References base().

                                            {
  return get_format (base (z)); }
format<C> mmx::CF1 ( const tangent< C, D > &  z) [inline]

Definition at line 73 of file tangent.hpp.

References base().

{ return get_format (base (z)); }
format<C> mmx::CF1 ( const twin< C, D, V > &  z) [inline]

Definition at line 81 of file twin.hpp.

References car().

{ return get_format (car (z)); }
format<VC> mmx::CF2 ( const affine< C, VC > &  z) [inline]

Definition at line 112 of file affine.hpp.

References slope().

                                             {
  return get_format (slope (z)); }
format<D> mmx::CF2 ( const tangent< C, D > &  z) [inline]

Definition at line 74 of file tangent.hpp.

References slope().

{ return get_format (slope (z)); }
format<D> mmx::CF2 ( const twin< C, D, V > &  z) [inline]

Definition at line 82 of file twin.hpp.

References cdr().

{ return get_format (cdr (z)); }
affine<C,VC> mmx::change_precision ( const affine< C, VC > &  z,
xnat  prec 
) [inline]

Definition at line 446 of file affine.hpp.

References Affine, base(), limits(), and slope().

Referenced by change_precision().

                                                                 {
  return Affine (change_precision (base (z), prec),
                 change_precision (slope (z), prec),
                 change_precision (limits (z), prec)); }
interval<C,V> mmx::change_precision ( const interval< C, V > &  x,
xnat  prec 
) [inline]

Definition at line 607 of file interval.hpp.

References change_precision(), Interval, lower(), and upper().

                                                                     {
  return Interval (change_precision (lower (x), prec),
                   change_precision (upper (x), prec)); }
complex<C> mmx::change_precision ( const complex< C > &  z,
xnat  prec 
) [inline]

Definition at line 586 of file complex.hpp.

References change_precision(), Complex, Im(), and Re().

                                                                   {
  return Complex (change_precision (Re (z), prec),
                  change_precision (Im (z), prec)); }
ball<C,R,V> mmx::change_precision ( const ball< C, R, V > &  z,
xnat  prec 
) [inline]

Definition at line 650 of file ball.hpp.

References Ball, center(), change_precision(), and radius().

                                                             {
  return Ball (change_precision (center (z), prec), radius (z)); }
tangent<C,D> mmx::change_precision ( const tangent< C, D > &  z,
xnat  prec 
) [inline]

Definition at line 362 of file tangent.hpp.

References base(), change_precision(), slope(), and Tangent.

                                                                   {
  return Tangent (change_precision (base (z), prec),
                  change_precision (slope (z), prec)); }
floating<V> mmx::change_precision ( const floating< V > &  x,
xnat  prec 
) [inline]

Definition at line 467 of file floating.hpp.

References Floating, Floating_rep, and Rnd.

                                                                     {
  Floating r (new Floating_rep (prec)); mpfr_set (*r, *x, Rnd); return r; }
twin<C,D,V> mmx::change_precision ( const twin< C, D, V > &  x,
xnat  p 
) [inline]

Definition at line 279 of file twin.hpp.

References car(), cdr(), change_precision(), and Twin.

                                                          {
  return Twin (change_precision (car (x), p), cdr (x)); }
affine_limits_helper<C,VC>::VT mmx::common_limits ( const affine< C, VC > &  z1,
const affine< C, VC > &  z2 
) [inline]

Definition at line 117 of file affine.hpp.

References limits().

Referenced by operator*(), and operator+().

                                                                  {
  typedef affine_limits_helper<C,VC> Helper;
  return Helper::common (limits (z1), limits (z2)); }
mmx::COMPARE_INT_SUGAR ( template< typename C, typename D >  ,
tangent< C, D >   
)
mmx::COMPARE_INT_SUGAR ( template< typename V >  ,
floating< V >   
)
mmx::COMPARE_INT_SUGAR ( template< typename C, typename D, typename V >  ,
twin< C, D, V >   
)
mmx::COMPARE_INT_SUGAR ( template< typename C, typename VC >  ,
affine< C, VC >   
)
mmx::COMPARE_INT_SUGAR ( template< typename C, typename R, typename V >  ,
ball< C, R, V >   
)
mmx::COMPARE_INT_SUGAR ( template< typename C, typename V >  ,
interval< C, V >   
)
ball<Complex,R> mmx::complex_gaussian ( const ball< Real, R > &  re)

Definition at line 23 of file ball_complex.hpp.

References Ball_variant, promote(), R, and V.

                                          {
  typedef Ball_variant(R) V;
  typedef implementation<ball_complex_construct,ball_complex<V> > Impl;
  ball<Complex,R> z; Impl::gauss (z, re, promote (0, re)); return z;
}
ball<Complex,R> mmx::complex_gaussian ( const ball< Real, R > &  re,
const ball< Real, R > &  im 
)

Definition at line 30 of file ball_complex.hpp.

References Ball_variant, R, and V.

                                                                  {
  typedef Ball_variant(R) V;
  typedef implementation<ball_complex_construct,ball_complex<V> > Impl;
  ball<Complex,R> z; Impl::gauss (z, re, im); return z;
}
complex<C> mmx::conj ( const complex< C > &  z) [inline]

Definition at line 226 of file complex.hpp.

References Complex, Im(), and Re().

                        {
  return Complex (Re (z), -Im (z));
}
ball<C,R,V> mmx::conj ( const ball< C, R, V > &  z) [inline]
Examples:
complex_test.cpp.

Definition at line 57 of file ball_complex.hpp.

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

Referenced by GLUE_5(), and GLUE_6().

                                                      {
  return Complex_ball (conj (center (z)), radius (z)); }
generic construct ( const rational &  x)

Definition at line 37 of file mmx_gmp.cpp.

References construct().

                              {
  return construct (as<generic> (x));
}
generic mmx::construct ( const twin< C, D, V > &  x)

Definition at line 66 of file twin.hpp.

References construct().

                          {
  return construct (as<generic> (x));
}
generic construct ( const integer &  i)

Definition at line 32 of file mmx_gmp.cpp.

Referenced by construct().

                             {
  return construct (as<generic> (i));
}
affine<C,VC> mmx::copy ( const affine< C, VC > &  z) [inline]

Definition at line 130 of file affine.hpp.

References Affine, base(), limits(), and slope().

Referenced by copy(), and duplicate().

                                          {
  return Affine (copy (base (z)), copy (slope (z)), copy (limits (z))); }
floating< V > copy ( const floating< V > &  x) [inline]

Definition at line 163 of file floating.hpp.

References Floating, and Rnd.

                                              {
  Floating r; mpfr_set (*r, *x, Rnd); return r; }
rational mmx::copy ( const rational &  i)

Definition at line 72 of file rational.hpp.

                                                   {
    rational r; mpq_set (*r, *x1); return r; }
tangent<C,D> mmx::copy ( const tangent< C, D > &  z) [inline]

Definition at line 76 of file tangent.hpp.

References base(), copy(), slope(), and Tangent.

                                            {
  return Tangent (copy (base (z)), copy (slope (z))); }
ball<C,R,V> mmx::copy ( const ball< C, R, V > &  z) [inline]

Definition at line 145 of file ball.hpp.

References Ball, center(), copy(), and radius().

                                      {
  return Ball (copy (center (z)), copy (radius (z))); }
twin<C,D,V> mmx::copy ( const twin< C, D, V > &  x) [inline]

Definition at line 84 of file twin.hpp.

References car(), cdr(), copy(), and Twin.

                                      {
  return Twin (copy (car (x)), copy (cdr (x))); }
integer mmx::copy ( const integer &  i)

Definition at line 104 of file integer.hpp.

                                                 {
    integer r; mpz_set (*r, *x1); return r; }
interval<C,V> mmx::copy ( const interval< C, V > &  x) [inline]

Definition at line 130 of file interval.hpp.

References copy(), Interval, lower(), and upper().

                                              {
  return Interval (copy (lower (x)), copy (upper (x))); }
complex<C> mmx::copy ( const complex< C > &  z) [inline]

Definition at line 112 of file complex.hpp.

References Complex, copy(), Im(), and Re().

                                            {
  return Complex (copy (Re (z)), copy (Im (z))); }
interval<C,V> mmx::cos ( const interval< C, V > &  x)

Definition at line 496 of file interval.hpp.

References C, cos(), Interval, lower(), max(), min(), promote(), sign(), sin(), sub(), and upper().

                        {
  C pi_lo= promote (314159, lower (x)) / promote (100000, lower (x));
  if (Up::sub (upper (x), lower (x)) >= pi_lo)
    return Interval (promote (-1, lower (x)), promote (1, lower (x)));
  else {
    int s1= -sign (sin (lower (x)));
    int s2= -sign (sin (upper (x)));
    if (s1 >= 0 && s2 >= 0)
      return Interval (Down::cos (lower (x)), Up::cos (upper (x)));
    else if (s1 <= 0 && s2 <= 0)
      return Interval (Down::cos (upper (x)), Down::cos (lower (x)));
    else if (s1 >= 0)
      return Interval (min (Down::cos (lower (x)), Down::cos (upper (x))),
                       promote (1, lower (x)));
    else
      return Interval (promote (-1, lower (x)),
                       max (Down::cos (lower (x)), Down::cos (upper (x))));
  }
}
complex<C> mmx::cos ( const complex< C > &  z) [inline]

Definition at line 504 of file complex.hpp.

References Complex, cos(), cosh(), Im(), Re(), sin(), and sinh().

                       {
  return Complex (cos (Re (z)) * cosh (Im (z)),
                  -sin (Re (z)) * sinh (Im (z)));
}
ball<C,R,V> mmx::cos ( const ball< C, R, V > &  z) [inline]
Examples:
ball_test.cpp, complex_ball_test.cpp, complex_test.cpp, and interval_test.cpp.

Definition at line 516 of file ball.hpp.

References Ball, C, Elementary_variant, and V.

Referenced by cos(), cosh(), GLUE_15(), GLUE_16(), GLUE_20(), GLUE_25(), GLUE_26(), GLUE_29(), GLUE_48(), polar(), implementation< ball_complex_construct, IV, ball_complex< BV > >::polar(), sin(), implementation< ball_elementary, W, ball_rounded >::sin(), sinh(), and tan().

                    {
  typedef Elementary_variant(C,V) EV;
  typedef implementation<ball_elementary,EV> Impl;
  Ball d; Impl::cos (d, z); return d;
}
tangent<C,D> mmx::cos ( const tangent< C, D > &  z) [inline]

Definition at line 252 of file tangent.hpp.

References base(), cos(), sin(), slope(), and Tangent.

                       {
  return Tangent (cos (base (z)), -sin (base (z)) * slope (z));
}
floating<V> mmx::cos ( const floating< V > &  x1) [inline]

Definition at line 415 of file floating.hpp.

References Floating, and Rnd.

                                              {
  Floating r (*x1); mpfr_cos (*r, *x1, Rnd); return r; }
twin<C,D,V> mmx::cos ( const twin< C, D, V > &  x)

Definition at line 235 of file twin.hpp.

References car(), cdr(), cos(), and Twin.

                              {
  return Twin (cos (car (x)), cos (cdr (x))); }
interval<C,V> mmx::cosh ( const interval< C, V > &  x) [inline]

Definition at line 543 of file interval.hpp.

References cosh(), Interval, is_nan(), lower(), max(), and upper().

                         {
  if (is_nan (x)) return Nan (Interval);
  else if (lower (x) >= 0)
    return Interval (Down::cosh (lower (x)), Up::cosh (upper (x)));
  else if (upper (x) <= 0)
    return Interval (Down::cosh (upper (x)), Up::cosh (lower (x)));
  else return Interval (1, max (Up::cosh (lower (x)), Up::cosh (upper (x))));
}
complex<C> mmx::cosh ( const complex< C > &  z) [inline]

Definition at line 551 of file complex.hpp.

References Complex, cos(), cosh(), Im(), Re(), sin(), and sinh().

                        {
  return Complex (cosh (Re (z)) * cos (Im (z)),
                  sinh (Re (z)) * sin (Im (z)));
}
ball<C,R,V> mmx::cosh ( const ball< C, R, V > &  z) [inline]

Definition at line 537 of file ball.hpp.

References Ball, C, Elementary_variant, and V.

Referenced by cos(), cosh(), sin(), implementation< ball_elementary, IV, ball_complex< BV > >::sin(), sinh(), implementation< ball_elementary, W, ball_rounded >::sinh(), implementation< ball_elementary, IV, ball_complex< BV > >::sinh(), and tanh().

                     {
  typedef Elementary_variant(C,V) EV;
  typedef implementation<ball_elementary,EV> Impl;
  Ball d; Impl::cosh (d, z); return d;
}
tangent<C,D> mmx::cosh ( const tangent< C, D > &  z) [inline]

Definition at line 267 of file tangent.hpp.

References base(), cosh(), sinh(), slope(), and Tangent.

                        {
  return Tangent (cosh (base (z)), sinh (base (z)) * slope (z));
}
floating<V> mmx::cosh ( const floating< V > &  x1) [inline]

Definition at line 429 of file floating.hpp.

References Floating, and Rnd.

                                               {
  Floating r (*x1); mpfr_cosh (*r, *x1, Rnd); return r; }
twin<C,D,V> mmx::cosh ( const twin< C, D, V > &  x)

Definition at line 247 of file twin.hpp.

References car(), cdr(), cosh(), and Twin.

                               {
  return Twin (cosh (car (x)), cosh (cdr (x))); }
void mmx::decode_mod ( C &  dest,
const C &  s,
const modulus< C, V > &  m 
) [inline]

Definition at line 98 of file modulus.hpp.

Referenced by modular< M, modular_local >::operator*(), and modular< M, V >::operator*().

                                                   {
  V::decode_mod (dest, s, m); }
static void mmx::decompose ( const string &  s,
int &  sign,
string &  mant,
integer &  expo 
) [static]

Definition at line 18 of file string_scnot.cpp.

References dot(), and sign().

Referenced by decompose_range(), make_range(), and trunc_digits().

                                                                    {
  // Sign
  if (N(s) > 0 && (s[0] == '+' || s[0] == '-')) {
    decompose (s (1, N(s)), sign, mant, expo);
    if (s[0] == '-') sign= -sign;
    return;
  }

  // Special values
  sign= 1; mant= ""; expo= 0;
  if (locase (s) == "nan") { mant= "NaN"; return; }
  if (locase (s) == "fuzz") { mant= "Fuzz"; return; }
  if (locase (s) == "infty") { mant= "Infty"; return; }
  if (locase (s) == "infinity") { mant= "Infty"; return; }

  // Get mantissa and decimal point
  int dot= -1;
  nat i= 0, n= N(s);
  while (i<n && (s[i] == '.' || (s[i] >= '0' && s[i] <= '9'))) {
    if (s[i] == '.') {
      if (dot != -1) { mant= "NaN"; return; }
      dot= i++;
    }
    else mant << s[i++];
  }
  if (dot == -1) dot= i;

  // Get exponent
  if (i<n && (s[i] == 'e' || s[i] == 'E')) {
    i++;
    int expo_sign= 1;
    while (i<n && (s[i] == '+' || s[i] == '-')) {
      if (s[i] == '-') expo_sign= -expo_sign;
      i++;
    }
    while (i<n && s[i] >= '0' && s[i] <= '9') {
      expo= 10*expo + ((int) (s[i] - '0'));
      i++;
    }
    expo= expo_sign * expo;
  }

  // Finish
  if (i != n) { mant= "NaN"; return; }
  if (mant == "") { mant= "0"; dot++; }
  expo += (dot - 1);
  while (N(mant) > 1 && mant[0] == '0') {
    mant= mant (1, N(mant));
    expo= expo - 1;
  }
  if (s == "0") sign= 0;
}
void decompose_range ( const string &  s,
string &  l,
string &  r 
)

Definition at line 154 of file string_scnot.cpp.

References as_string(), decompose(), recompose(), and sign().

                                                        {
  int     sign;
  string  mant;
  integer expo;
  decompose (s, sign, mant, expo);
  if (locase (mant) == "fuzz") { l= "-Infty"; r= "Infty"; return; }
  if (locase (mant) == "nan") { l= "NaN"; r= "NaN"; return; }
  if (locase (mant) == "infty") { l= r= recompose (sign, mant, 0); return; }
  if (sign == 0) { l= r= "0"; }
  if (mant == "0") {
    l= recompose (-1, "1", expo);
    r= recompose (1, "1", expo);
  }
  else {
    string mant1= as_string (integer (mant) - 1) * "5";
    string mant2= mant * "5";
    l= recompose (sign, sign>0? mant1: mant2, expo);
    r= recompose (sign, sign>0? mant2: mant1, expo);
  }
}
mmx::DEFINE_BINARY_FORMAT_2 ( tangent  )
mmx::DEFINE_BINARY_FORMAT_2 ( affine  )
mmx::DEFINE_BINARY_FORMAT_2 ( twin  )
mmx::DEFINE_UNARY_FORMAT_1 ( complex  )
mmx::DEFINE_UNARY_FORMAT_1 ( interval  )
void mmx::div ( complex< C > &  r,
const complex< C > &  z,
const C &  c 
) [inline]

Definition at line 441 of file complex.hpp.

References Im(), and Re().

Referenced by implementation< ball_elementary, W, ball_rounded >::acos(), implementation< ball_elementary, W, ball_rounded >::asin(), implementation< ball_elementary, W, ball_rounded >::atan(), implementation< ball_elementary, W, ball_rounded >::atan2(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::div(), implementation< ball_multiplicative, W, ball_rounded >::invert(), implementation< ball_elementary, W, ball_rounded >::log(), implementation< ball_elementary, IV, ball_complex< BV > >::log(), operator/(), implementation< ball_root, W, ball_rounded >::sqrt(), and implementation< ball_root, IV, ball_complex< BV > >::sqrt().

                                               {
  div (Re (r), Re (z), c);
  div (Im (r), Im (z), c);
}
void mmx::div ( floating< V > &  r,
const floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 333 of file floating.hpp.

References Rnd.

                                                                            {
  r.secure (); mpfr_div (*r, *x1, *x2, Rnd); }
void mmx::div_mod ( C &  dest,
const C &  s,
const modulus< C, V > &  m 
) [inline]

Definition at line 174 of file modulus.hpp.

Referenced by div_mod(), operator/(), and operator/=().

                                                {
  V::div_mod (dest, s, m); }
void mmx::div_mod ( C &  dest,
const C &  s1,
const C &  s2,
const modulus< C, V > &  m 
) [inline]

Definition at line 178 of file modulus.hpp.

References div_mod().

                                                              {
  V::div_mod (dest, s1, s2, m); }
VC mmx::domain ( const affine< C, VC > &  z) [inline]

Definition at line 125 of file affine.hpp.

References limits().

                                        {
  typedef affine_limits_helper<C,VC> Helper;
  return Helper::get_domain (limits (z)); }
C mmx::dot ( const C &  x,
const C &  y 
) [inline]

Definition at line 37 of file affine.hpp.

Referenced by decompose(), and affine_limits_helper< C, VC >::truncate().

{ return x * y; }
affine<C,VC> mmx::duplicate ( const affine< C, VC > &  z) [inline]

Definition at line 132 of file affine.hpp.

References Affine, base(), limits(), and slope().

Referenced by duplicate().

                                               {
  return Affine (duplicate (base (z)), duplicate (slope (z)),
                 duplicate (limits (z))); }
floating<V> mmx::duplicate ( const floating< V > &  x) [inline]

Definition at line 165 of file floating.hpp.

References copy().

                                                   {
  return copy (x); }
rational mmx::duplicate ( const rational &  x) [inline]

Definition at line 250 of file rational.hpp.

References copy().

{ return copy (x); }
tangent<C,D> mmx::duplicate ( const tangent< C, D > &  z) [inline]

Definition at line 78 of file tangent.hpp.

References base(), duplicate(), slope(), and Tangent.

                                                 {
  return Tangent (duplicate (base (z)), duplicate (slope (z))); }
ball<C,R,V> mmx::duplicate ( const ball< C, R, V > &  z) [inline]

Definition at line 147 of file ball.hpp.

References Ball, center(), duplicate(), and radius().

                                           {
  return Ball (duplicate (center (z)), duplicate (radius (z))); }
twin<C,D,V> mmx::duplicate ( const twin< C, D, V > &  x) [inline]

Definition at line 86 of file twin.hpp.

References car(), cdr(), duplicate(), and Twin.

                                           {
  return Twin (duplicate (car (x)), duplicate (cdr (x))); }
integer mmx::duplicate ( const integer &  i) [inline]

Definition at line 1014 of file integer.hpp.

References copy().

{ return copy (i); }
complex<C> mmx::duplicate ( const complex< C > &  z) [inline]

Definition at line 114 of file complex.hpp.

References Complex, duplicate(), Im(), and Re().

                                                 {
  return Complex (duplicate (Re (z)), duplicate (Im (z))); }
interval<C,V> mmx::duplicate ( const interval< C, V > &  x) [inline]

Definition at line 132 of file interval.hpp.

References duplicate(), Interval, lower(), and upper().

                                                   {
  return Interval (duplicate (lower (x)), duplicate (upper (x))); }
nat mmx::dyadic_valuation ( const integer &  i) [inline]

Definition at line 1174 of file integer.hpp.

                                               {
  if (i == integer (0)) return (nat) -1;
  return mpz_scan1 (* i, 0);
}
nat mmx::dyadic_valuation ( const signed char &  i) [inline]

Definition at line 1187 of file integer.hpp.

nat mmx::dyadic_valuation ( const unsigned char &  i) [inline]

Definition at line 1188 of file integer.hpp.

nat mmx::dyadic_valuation ( const signed short &  i) [inline]

Definition at line 1189 of file integer.hpp.

nat mmx::dyadic_valuation ( const unsigned short &  i) [inline]

Definition at line 1190 of file integer.hpp.

nat mmx::dyadic_valuation ( const signed int &  i) [inline]

Definition at line 1191 of file integer.hpp.

nat mmx::dyadic_valuation ( const unsigned int &  i) [inline]

Definition at line 1192 of file integer.hpp.

nat mmx::dyadic_valuation ( const signed long &  i) [inline]

Definition at line 1193 of file integer.hpp.

nat mmx::dyadic_valuation ( const unsigned long &  i) [inline]

Definition at line 1194 of file integer.hpp.

nat mmx::dyadic_valuation ( const signed long long &  i) [inline]

Definition at line 1195 of file integer.hpp.

nat mmx::dyadic_valuation ( const unsigned long long &  i) [inline]

Definition at line 1196 of file integer.hpp.

ball<Abs_type(C),R,Abs_type(V) > mmx::elementary_error ( const ball< C, R, V > &  x) [inline]

Definition at line 658 of file ball.hpp.

References Abs_ball, and center().

Referenced by implementation< ball_rounding, W, ball_rounded >::add_elementary_error(), GLUE_47(), and GLUE_56().

                                                      {
  return Abs_ball (elementary_error (center (x))); }
void mmx::encode_mod ( C &  dest,
const C &  s,
const modulus< C, V > &  m 
) [inline]

Definition at line 94 of file modulus.hpp.

Referenced by modular< M, modular_local >::modular(), and modular< M, V >::modular().

                                                   {
  V::encode_mod (dest, s, m); }
mmx::EQUAL_INT_SUGAR ( template< typename C, typename D >  ,
tangent< C, D >   
)
mmx::EQUAL_INT_SUGAR ( template< typename C, typename D, typename V >  ,
twin< C, D, V >   
)
mmx::EQUAL_INT_SUGAR ( template< typename C, typename VC >  ,
affine< C, VC >   
)
mmx::EQUAL_INT_SUGAR ( template< typename C, typename V >  ,
interval< C, V >   
)
mmx::EQUAL_INT_SUGAR ( template< typename C, typename R, typename V >  ,
ball< C, R, V >   
)
floating<V> mmx::erf ( const floating< V > &  x1) [inline]

Definition at line 511 of file floating.hpp.

References Floating, and Rnd.

                                              {
  Floating r (*x1); mpfr_erf (*r, *x1, Rnd); return r; }
bool mmx::exact_eq ( const scalar_set< C > &  R1,
const scalar_set< C > &  R2 
) [inline]

Definition at line 53 of file kernel.hpp.

Referenced by exact_eq(), and exact_neq().

                                                             {
    return R1==R2;
  }
bool mmx::exact_eq ( const modular< M, modular_local > &  c1,
const modular< M, modular_local > &  c2 
)

Definition at line 399 of file modular.hpp.

References exact_eq(), and get_modulus().

                                                          {
  return exact_eq (*c1, *c2) && 
         exact_eq (get_modulus (c1), get_modulus (c2)); }
bool mmx::exact_eq ( const twin< C, D, V > &  x,
const twin< C, D, V > &  y 
)

Definition at line 154 of file twin.hpp.

References cdr(), and exact_eq().

                                                  {
  return exact_eq (cdr (x), cdr (y)); }
int mmx::exact_hash ( const scalar_set< C > &  R) [inline]

Definition at line 51 of file kernel.hpp.

Referenced by exact_hash().

{ return 1;}
nat mmx::exact_hash ( const modular< M, modular_local > &  c)

Definition at line 391 of file modular.hpp.

References exact_hash(), and get_modulus().

                              {
  nat h= exact_hash (*c);
  return (h<<1) ^ (h<<5) ^ (h>>29) ^ exact_hash (get_modulus (c)); }
nat mmx::exact_hash ( const twin< C, D, V > &  x)

Definition at line 151 of file twin.hpp.

References cdr(), and exact_hash().

{ return exact_hash (cdr (x)); }
mmx::EXACT_IDENTITY_OP_SUGAR ( template< typename C, typename R, typename V >  ,
ball< C, R, V >   
)
mmx::EXACT_IDENTITY_OP_SUGAR ( template< typename C, typename V >  ,
interval< C, V >   
)
bool mmx::exact_neq ( const modular< M, modular_local > &  c1,
const modular< M, modular_local > &  c2 
)

Definition at line 403 of file modular.hpp.

References exact_eq().

Referenced by exact_neq().

                                                           {
  return ! exact_eq (c1, c2); }
bool mmx::exact_neq ( const twin< C, D, V > &  x,
const twin< C, D, V > &  y 
)

Definition at line 156 of file twin.hpp.

References cdr(), and exact_neq().

                                                   {
  return exact_neq (cdr (x), cdr (y)); }
interval<C,V> mmx::exp ( const interval< C, V > &  x)

Definition at line 481 of file interval.hpp.

References exp(), Interval, lower(), and upper().

                        {
  return Interval (Down::exp (lower (x)), Up::exp (upper (x)));
}
complex<C> mmx::exp ( const complex< C > &  z) [inline]

Definition at line 466 of file complex.hpp.

References exp(), Im(), polar(), and Re().

                       {
  return polar (exp (Re (z)), Im (z));
}
ball<C,R,V> mmx::exp ( const ball< C, R, V > &  z) [inline]
Examples:
ball_test.cpp, complex_ball_test.cpp, complex_test.cpp, floating_test.cpp, and interval_test.cpp.

Definition at line 481 of file ball.hpp.

References Ball, C, Elementary_variant, and V.

Referenced by exp(), implementation< ball_elementary, W, ball_rounded >::exp(), implementation< ball_elementary, IV, ball_complex< BV > >::exp(), GLUE_12(), GLUE_13(), GLUE_17(), GLUE_23(), GLUE_26(), GLUE_45(), and pow().

                    {
  typedef Elementary_variant(C,V) EV;
  typedef implementation<ball_elementary,EV> Impl;
  Ball d; Impl::exp (d, z); return d;
}
tangent<C,D> mmx::exp ( const tangent< C, D > &  z) [inline]

Definition at line 236 of file tangent.hpp.

References base(), C, exp(), slope(), and Tangent.

                       {
  C e= exp (base (z));
  return Tangent (e, e * slope (z));
}
floating<V> mmx::exp ( const floating< V > &  x1) [inline]

Definition at line 405 of file floating.hpp.

References Floating, and Rnd.

                                              {
  Floating r (*x1); mpfr_exp (*r, *x1, Rnd); return r; }
twin<C,D,V> mmx::exp ( const twin< C, D, V > &  x)

Definition at line 227 of file twin.hpp.

References car(), cdr(), exp(), and Twin.

                              {
  return Twin (exp (car (x)), exp (cdr (x))); }
floating<V> mmx::exp2 ( const floating< V > &  x1) [inline]

Definition at line 407 of file floating.hpp.

References Floating, and Rnd.

                                               {
  Floating r (*x1); mpfr_exp2 (*r, *x1, Rnd); return r; }
xint mmx::exponent ( const affine< C, VC > &  z) [inline]

Definition at line 459 of file affine.hpp.

References base().

Referenced by exponent(), GLUE_27(), GLUE_40(), GLUE_48(), GLUE_49(), GLUE_59(), mpfr_to_string(), and zero_to_string().

                                            {
  return exponent (base (z)); }
xint mmx::exponent ( const interval< C, V > &  x) [inline]

Definition at line 613 of file interval.hpp.

References exponent(), lower(), max(), and upper().

                                              {
  return max (exponent (lower (x)), exponent (upper (x))); }
xint mmx::exponent ( const complex< C > &  z) [inline]

Definition at line 619 of file complex.hpp.

References exponent(), Im(), max(), and Re().

                                             {
  return max (exponent (Re (z)), exponent (Im (z))); }
xint mmx::exponent ( const ball< C, R, V > &  z) [inline]

Definition at line 661 of file ball.hpp.

References center(), exponent(), max(), and radius().

                                          {
  return max (exponent (center (z)), exponent (radius (z))); }
xint mmx::exponent ( const tangent< C, D > &  z) [inline]

Definition at line 372 of file tangent.hpp.

References base(), and exponent().

                                             {
  return exponent (base (z)); }
xint mmx::exponent ( const floating< V > &  x) [inline]

Definition at line 490 of file floating.hpp.

References mpfr_safe_get_exp().

                                              {
  return mpfr_safe_get_exp (*x); }
xint mmx::exponent ( const twin< C, D, V > &  x) [inline]

Definition at line 284 of file twin.hpp.

References car(), and exponent().

                                          {
  return exponent (car (x)); }
integer mmx::factorial ( nat  i) [inline]

Definition at line 1134 of file integer.hpp.

Referenced by factorial(), and GLUE_26().

                                 {
  integer r; mpz_fac_ui (*r, i); return r; }
integer mmx::factorial ( const integer &  i) [inline]

Definition at line 1140 of file integer.hpp.

References as_int(), and factorial().

                                            {
  ASSERT (i >= 0, "positive argument expected");
  return factorial ((nat) as_int (i)); }
syntactic mmx::flatten ( const scalar_set< double > &  Z) [inline]

Definition at line 74 of file kernel.hpp.

{ static inline T cv (const F& x) { return x; } };
syntactic mmx::flatten ( const scalar_set< integer > &  Z) [inline]

Definition at line 75 of file kernel.hpp.

{ static inline T cv (const F& x) { return x; } };
syntactic mmx::flatten ( const scalar_set< rational > &  Z) [inline]

Definition at line 76 of file kernel.hpp.

{ static inline T cv (const F& x) { return x; } };
syntactic mmx::flatten ( const scalar_set< complex< double > > &  Z) [inline]

Definition at line 78 of file kernel.hpp.

{ static inline T cv (const F& x) { return x; } };
syntactic mmx::flatten ( const scalar_set< floating<> > &  Z) [inline]

Definition at line 77 of file kernel.hpp.

{ static inline T cv (const F& x) { return x; } };
syntactic mmx::flatten ( const scalar_set< complex< floating<> > > &  Z) [inline]

Definition at line 79 of file kernel.hpp.

{ static inline T cv (const F& x) { return x; } };
syntactic mmx::flatten ( const floating< V > &  g)

Definition at line 191 of file floating.hpp.

References as_string(), and flatten_number().

                            {
  return flatten_number (as_string (g));
}
syntactic mmx::flatten ( const floating< V > &  g,
xnat  dd 
)

Definition at line 196 of file floating.hpp.

References as_string(), and flatten_number().

                                     {
  return flatten_number (as_string (g, dd));
}
syntactic mmx::flatten ( const modulus< unsigned char, V > &  c) [inline]

Definition at line 190 of file modulus.hpp.

                                            {
  return as_syntactic ((int) (*c)); }
syntactic mmx::flatten ( const modulus< char, V > &  c) [inline]

Definition at line 186 of file modulus.hpp.

                                   {
  return as_syntactic ((int) (*c)); }
syntactic flatten ( const rational &  x)

Definition at line 47 of file mmx_gmp.cpp.

References flatten().

                            {
  if (denominator (x) == 1) return flatten (numerator (x));
  return flatten (numerator (x)) / flatten (denominator (x));
}
affine<C,VC> VC syntactic mmx::flatten ( const affine< C, VC > &  z)

Definition at line 164 of file affine.hpp.

References base(), limits(), and slope().

Referenced by flatten().

                          {
  return apply ("affine", flatten (base (z)), flatten (slope (z)),
                flatten (limits (z)));
}
tangent<C,D> D syntactic mmx::flatten ( const tangent< C, D > &  z)

Definition at line 107 of file tangent.hpp.

References base(), flatten(), and slope().

                           {
  return apply ("tangent", flatten (base (z)), flatten (slope (z)));
}
ball<C,R,V> syntactic mmx::flatten ( const ball< C, R, V > &  z)

Definition at line 168 of file ball.hpp.

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

                        {
  return syn ("ball", flatten (center (z)), flatten (radius (z)));
}
syntactic mmx::flatten ( const ball< C, R, V > &  z,
xnat  dd 
)

Definition at line 173 of file ball.hpp.

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

                                 {
  return syn ("ball", flatten (center (z), dd), flatten (radius (z), dd));
}
syntactic mmx::flatten ( const twin< C, D, V > &  x) [inline]

Definition at line 97 of file twin.hpp.

References cdr(), and flatten().

                        {
  return flatten (cdr (x));
}
syntactic mmx::flatten ( const ball< double, R, V > &  z) [inline]

Definition at line 196 of file ball.hpp.

References flatten_range().

                                    {
  return flatten_range (z); }
syntactic mmx::flatten ( const ball< double, R, V > &  z,
xnat  dd 
) [inline]

Definition at line 199 of file ball.hpp.

References flatten_range().

                                             {
  return flatten_range (z, dd); }
syntactic mmx::flatten ( const ball< floating< FV >, R, V > &  z) [inline]

Definition at line 202 of file ball.hpp.

References flatten_range().

                                          {
  return flatten_range (z); }
syntactic mmx::flatten ( const ball< complex< C >, R, V > &  z)

Definition at line 100 of file ball_complex.hpp.

References flatten(), Im(), is_exact_zero(), is_fuzz(), is_infinite(), is_nan(), and Re().

                                {
  if (is_nan (z)) return Nan (syntactic);
  if (is_fuzz (z)) return Fuzz (syntactic);
  if (is_infinite (z)) return Infinity (syntactic);
  if (is_exact_zero (z)) return 0;
  if (Re (z) != 0 && Im (z) == 0)
    return flatten (Re (z));
  if (Re (z) == 0 && Im (z) != 0)
    return flatten (Im (z)) * Imaginary (syntactic);
  return flatten (Re (z)) + flatten (Im (z)) * Imaginary (syntactic);
}
syntactic mmx::flatten ( const ball< floating< FV >, R, V > &  z,
xnat  dd 
) [inline]

Definition at line 205 of file ball.hpp.

References flatten_range().

                                                   {
  return flatten_range (z, dd); }
syntactic mmx::flatten ( const ball< complex< C >, R, V > &  z,
nat  dd 
)

Definition at line 113 of file ball_complex.hpp.

References flatten(), Im(), is_exact_zero(), is_fuzz(), is_infinite(), is_nan(), and Re().

                                        {
  if (is_nan (z)) return Nan (syntactic);
  if (is_fuzz (z)) return Fuzz (syntactic);
  if (is_infinite (z)) return Infinity (syntactic);
  if (is_exact_zero (z)) return 0;
  if (Re (z) != 0 && Im (z) == 0)
    return flatten (Re (z), dd);
  if (Re (z) == 0 && Im (z) != 0)
    return flatten (Im (z), dd) * Imaginary (syntactic);
  return flatten (Re (z), dd) + flatten (Im (z), dd) * Imaginary (syntactic);
}
syntactic flatten ( const integer &  i)

Definition at line 42 of file mmx_gmp.cpp.

References as_string().

                           {
  return syntactic (as_string (i));
}
syntactic mmx::flatten ( const interval< C, V > &  x)

Definition at line 164 of file interval.hpp.

References flatten_range(), is_nan(), lower(), and upper().

                            {
  if (is_nan (x)) return Nan (syntactic);
  if (lower (x) == 0 && upper (x) == 0) return 0;
  return flatten_range (lower (x), upper (x));
  // return flatten ("interval", lower (x), upper (x));
}
syntactic mmx::flatten ( const interval< C, V > &  x,
xnat  dd 
)

Definition at line 172 of file interval.hpp.

References flatten_range(), is_nan(), lower(), and upper().

                                     {
  if (is_nan (x)) return Nan (syntactic);
  if (lower (x) == 0 && upper (x) == 0) return 0;
  return flatten_range (lower (x), upper (x), dd);
}
syntactic mmx::flatten ( const complex< C > &  z)

Definition at line 146 of file complex.hpp.

References flatten(), Im(), is_exact_zero(), is_fuzz(), is_infinite(), is_nan(), and Re().

                           {
  if (is_nan (z)) return Nan (syntactic);
  if (is_fuzz (z)) return Fuzz (syntactic);
  if (is_infinite (z)) return Infinity (syntactic);
  if (is_exact_zero (z)) return 0;
  if (Re (z) != 0 && Im (z) == 0)
    return flatten (Re (z));
  if (Re (z) == 0 && Im (z) != 0)
    return flatten (Im (z)) * Imaginary (syntactic);
  return flatten (Re (z)) + flatten (Im (z)) * Imaginary (syntactic);
}
syntactic mmx::flatten ( const complex< C > &  z,
xnat  dd 
)

Definition at line 159 of file complex.hpp.

References flatten(), Im(), is_exact_zero(), is_fuzz(), is_infinite(), is_nan(), and Re().

                                    {
  if (is_nan (z)) return Nan (syntactic);
  if (is_fuzz (z)) return Fuzz (syntactic);
  if (is_infinite (z)) return Infinity (syntactic);
  if (is_exact_zero (z)) return 0;
  if (Re (z) != 0 && Im (z) == 0)
    return flatten (Re (z), dd);
  if (Re (z) == 0 && Im (z) != 0)
    return flatten (Im (z), dd) * Imaginary (syntactic);
  return flatten (Re (z), dd) + flatten (Im (z), dd) * Imaginary (syntactic);
}
string mmx::flatten_as_mmx ( const generic &  g)

Referenced by flatten_as_string().

string mmx::flatten_as_string ( const C &  x)

Definition at line 26 of file string_scnot.hpp.

References flatten_as_mmx().

Referenced by as_string(), and flatten_range().

                               {
  return flatten_as_mmx (as_generic (x));
}
syntactic flatten_number ( const string &  s)

Definition at line 205 of file string_scnot.cpp.

References is_integer(), mmx_pretty_exponents, and pow().

Referenced by flatten(), and flatten_range().

                                 {
  if (N(s) == 0) return 0;
  if (s[0] == '-') return -flatten_number (s (1, N(s)));
  if (!mmx_pretty_exponents) return syntactic (s);
  nat i;
  for (i=N(s)-1; i!=0; i--)
    if (s[i] == 'e') break;
  if (i > 0 && is_integer (s (i+1, N(s))))
    return syntactic (s (0, i)) *
           pow (syntactic (10), syntactic (s (i+1, N(s))));
  return syntactic (s);
}
syntactic mmx::flatten_range ( const C &  x,
const C &  y 
)

Definition at line 37 of file string_scnot.hpp.

References flatten_as_string(), flatten_number(), and make_range().

                                       {
  const string s= make_range (flatten_as_string (x), flatten_as_string (y));
  return flatten_number (s);
}
syntactic mmx::flatten_range ( const C &  x,
const C &  y,
xnat  dd 
)

Definition at line 43 of file string_scnot.hpp.

References flatten_as_string(), flatten_number(), make_range(), mmx_significant_digits, and trunc_digits().

                                                {
  xnat old= mmx_significant_digits;
  mmx_significant_digits= 0;
  const string s= make_range (flatten_as_string (x), flatten_as_string (y));
  mmx_significant_digits= old;
  return flatten_number (trunc_digits (s, dd));
}
syntactic mmx::flatten_range ( const ball< C, R, V > &  z)

Definition at line 178 of file ball.hpp.

References center(), is_exact_zero(), is_fuzz(), is_nan(), lower(), precision(), and upper().

Referenced by flatten(), and flatten_range().

                              {
  mmx_local_bit_precision tmp (precision (center (z)));
  if (is_nan (z)) return Nan (syntactic);
  if (is_fuzz (z)) return Fuzz (syntactic);
  if (is_exact_zero (z)) return 0;
  return flatten_range (lower (z), upper (z));
}
syntactic mmx::flatten_range ( const ball< C, R, V > &  z,
xnat  dd 
)

Definition at line 187 of file ball.hpp.

References center(), flatten_range(), is_exact_zero(), is_fuzz(), is_nan(), lower(), precision(), and upper().

                                       {
  mmx_local_bit_precision tmp (precision (center (z)));
  if (is_nan (z)) return Nan (syntactic);
  if (is_fuzz (z)) return Fuzz (syntactic);
  if (is_exact_zero (z)) return 0;
  return flatten_range (lower (z), upper (z), dd);
}
ball<C,R,V> mmx::floor ( const ball< C, R, V > &  z) [inline]

Definition at line 612 of file ball.hpp.

References Ball.

Referenced by floor(), implementation< ball_ordered, W, ball_rounded >::floor(), GLUE_27(), GLUE_38(), GLUE_39(), and nearest().

                      {
  typedef implementation<ball_ordered,V> Impl;
  Ball d; Impl::floor (d, z); return d;
}
floating<V> mmx::floor ( const floating< V > &  x1) [inline]

Definition at line 382 of file floating.hpp.

References Floating.

                                                {
  Floating r (*x1); mpfr_floor (*r, *x1); return r; }
interval<C,V> mmx::floor ( const interval< C, V > &  x)

Definition at line 281 of file interval.hpp.

References floor(), Interval, lower(), and upper().

                          {
  return Interval (Down::floor (lower (x)), Up::floor (upper (x)));
}
floating<V> mmx::gamma ( const floating< V > &  x1) [inline]

Definition at line 507 of file floating.hpp.

References Floating, and Rnd.

                                                {
  Floating r (*x1); mpfr_gamma (*r, *x1, Rnd); return r; }
ball<complex<C>,R,V> mmx::gaussian ( const ball< C, R, V > &  re,
const ball< C, R, V > &  im = 0 
)
Examples:
complex_ball_test.cpp.

Definition at line 84 of file ball_complex.hpp.

References Complex_ball.

Referenced by gaussian_as().

                                             {
  typedef implementation<ball_complex_construct,ball_complex<V> > Impl;
  Complex_ball z; Impl::gauss (z, re, im); return z;
}
complex<C> mmx::gaussian ( const C &  re,
const C &  im = 0 
) [inline]

Definition at line 196 of file complex.hpp.

References Complex.

                                       {
  return Complex (re, im);
}
void mmx::gaussian_as ( C &  z,
const R &  x,
const R &  y 
) [inline]

Definition at line 201 of file complex.hpp.

References gaussian().

Referenced by implementation< ball_complex_construct, IV, ball_complex< BV > >::gauss().

                                           {
  z= gaussian (x, y);
}
modular<M,V> mmx::gcd ( const modular< M, V > &  a,
const modular< M, V > &  b 
) [inline]

Definition at line 273 of file modular.hpp.

Referenced by GLUE_17(), and GLUE_18().

                                         {
  if (a == 0) return b;
  return a; }
mmx::GCD_SUGAR ( template< typename C >  ,
complex< C >   
)
rational mmx::GCD_SUGAR ( rational  )
M mmx::get_modulus ( const modular< M, V > &  x) [inline]

Definition at line 151 of file modular.hpp.

Referenced by as_helper< modular< TM, modular_local >, modular< SM, SV > >::cv(), exact_eq(), exact_hash(), hard_eq(), hard_hash(), hash(), invert(), operator*(), operator*=(), operator+(), operator+=(), operator-(), operator-=(), operator/(), and operator/=().

                                             {
  (void) x; return Modular::get_modulus (); }
M mmx::get_modulus ( const modular< M, modular_local > &  x) [inline]

Definition at line 371 of file modular.hpp.

References modular< M, modular_local >::get_local_modulus().

                                                 {
  return x.get_local_modulus (); }
static mmx_floating mmx::GLUE_1 ( const literal &  arg_1) [static]

Definition at line 11 of file glue_floating.cpp.

References make_literal_floating.

                                {
    return make_literal_floating (arg_1);
  }
static generic mmx::GLUE_1 ( const int &  arg_1) [static]

Definition at line 12 of file glue_modular_int.cpp.

References integer_construct.

                            {
    return integer_construct (arg_1);
  }
static rational mmx::GLUE_1 ( const integer &  arg_1) [static]

Definition at line 8 of file glue_rational.cpp.

                                {
    return rational (arg_1);
  }
static complex<double> mmx::GLUE_1 ( const double &  arg_1) [static]

Definition at line 13 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                               {
    return complex<double > (arg_1);
  }
static complex<mmx_floating> mmx::GLUE_1 ( const mmx_floating &  arg_1) [static]

Definition at line 14 of file glue_complex_floating.cpp.

                                     {
    return complex<mmx_floating > (arg_1);
  }
static complex<generic> mmx::GLUE_1 ( const generic &  arg_1) [static]

Definition at line 7 of file glue_complex_generic.cpp.

                                {
    return complex<generic > (arg_1);
  }
static complex<rational> mmx::GLUE_1 ( const rational &  arg_1) [static]

Definition at line 9 of file glue_complex_rational.cpp.

                                 {
    return complex<rational > (arg_1);
  }
static complex<rational> mmx::GLUE_10 ( const complex< rational > &  arg_1) [static]

Definition at line 54 of file glue_complex_rational.cpp.

References square().

                                           {
    return square (arg_1);
  }
static int mmx::GLUE_10 ( const mmx_floating &  arg_1) [static]

Definition at line 56 of file glue_floating.cpp.

References as_int().

                                      {
    return as_int (arg_1);
  }
static integer mmx::GLUE_10 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 53 of file glue_integer.cpp.

                                                       {
    return arg_1 + arg_2;
  }
static interval<double> mmx::GLUE_10 ( const interval< double > &  arg_1,
const interval< double > &  arg_2 
) [static]

Definition at line 55 of file glue_interval_double.cpp.

                                                                         {
    return arg_1 + arg_2;
  }
static interval<mmx_floating> mmx::GLUE_10 ( const interval< mmx_floating > &  arg_1,
const interval< mmx_floating > &  arg_2 
) [static]

Definition at line 58 of file glue_interval_floating.cpp.

                                                                                     {
    return arg_1 + arg_2;
  }
static rational mmx::GLUE_10 ( const rational &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 53 of file glue_rational.cpp.

                                                         {
    return arg_1 + arg_2;
  }
static tangent<double, double> mmx::GLUE_10 ( const tangent< double, double > &  arg_1,
const tangent< double, double > &  arg_2 
) [static]

Definition at line 59 of file glue_tangent_double.cpp.

                                                                                       {
    return arg_1 * arg_2;
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_10 ( const tangent< mmx_floating, mmx_floating > &  arg_1,
const tangent< mmx_floating, mmx_floating > &  arg_2 
) [static]

Definition at line 60 of file glue_tangent_floating.cpp.

                                                                                                               {
    return arg_1 * arg_2;
  }
static tangent<generic, generic> mmx::GLUE_10 ( const tangent< generic, generic > &  arg_1,
const tangent< generic, generic > &  arg_2 
) [static]

Definition at line 52 of file glue_tangent_generic.cpp.

                                                                                           {
    return arg_1 / arg_2;
  }
static tangent<rational, rational> mmx::GLUE_10 ( const tangent< rational, rational > &  arg_1,
const tangent< rational, rational > &  arg_2 
) [static]

Definition at line 55 of file glue_tangent_rational.cpp.

                                                                                               {
    return arg_1 * arg_2;
  }
static complex<double> mmx::GLUE_10 ( const complex< double > &  arg_1) [static]

Definition at line 58 of file glue_complex_double.cpp.

References square().

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                                         {
    return square (arg_1);
  }
static complex<mmx_floating> mmx::GLUE_10 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 59 of file glue_complex_floating.cpp.

References square().

                                               {
    return square (arg_1);
  }
static complex<generic> mmx::GLUE_10 ( const complex< generic > &  arg_1,
const complex< generic > &  arg_2 
) [static]

Definition at line 52 of file glue_complex_generic.cpp.

                                                                         {
    return arg_1 + arg_2;
  }
static complex<rational> mmx::GLUE_11 ( const complex< rational > &  arg_1,
const complex< rational > &  arg_2 
) [static]

Definition at line 59 of file glue_complex_rational.cpp.

                                                                           {
    return arg_1 + arg_2;
  }
static double mmx::GLUE_11 ( const mmx_floating &  arg_1) [static]

Definition at line 61 of file glue_floating.cpp.

References as_double().

                                      {
    return as_double (arg_1);
  }
static integer mmx::GLUE_11 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 58 of file glue_integer.cpp.

                                                       {
    return arg_1 - arg_2;
  }
static interval<double> mmx::GLUE_11 ( const interval< double > &  arg_1,
const interval< double > &  arg_2 
) [static]

Definition at line 60 of file glue_interval_double.cpp.

                                                                         {
    return arg_1 - arg_2;
  }
static interval<mmx_floating> mmx::GLUE_11 ( const interval< mmx_floating > &  arg_1,
const interval< mmx_floating > &  arg_2 
) [static]

Definition at line 63 of file glue_interval_floating.cpp.

                                                                                     {
    return arg_1 - arg_2;
  }
static rational mmx::GLUE_11 ( const rational &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 58 of file glue_rational.cpp.

                                                         {
    return arg_1 - arg_2;
  }
static tangent<double, double> mmx::GLUE_11 ( const tangent< double, double > &  arg_1,
const tangent< double, double > &  arg_2 
) [static]

Definition at line 64 of file glue_tangent_double.cpp.

                                                                                       {
    return arg_1 / arg_2;
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_11 ( const tangent< mmx_floating, mmx_floating > &  arg_1,
const tangent< mmx_floating, mmx_floating > &  arg_2 
) [static]

Definition at line 65 of file glue_tangent_floating.cpp.

                                                                                                               {
    return arg_1 / arg_2;
  }
static tangent<generic, generic> mmx::GLUE_11 ( const tangent< generic, generic > &  arg_1) [static]

Definition at line 57 of file glue_tangent_generic.cpp.

References sqrt().

                                                   {
    return sqrt (arg_1);
  }
static tangent<rational, rational> mmx::GLUE_11 ( const tangent< rational, rational > &  arg_1,
const tangent< rational, rational > &  arg_2 
) [static]

Definition at line 60 of file glue_tangent_rational.cpp.

                                                                                               {
    return arg_1 / arg_2;
  }
static complex<double> mmx::GLUE_11 ( const complex< double > &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 63 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                                                                       {
    return arg_1 + arg_2;
  }
static complex<mmx_floating> mmx::GLUE_11 ( const complex< mmx_floating > &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 64 of file glue_complex_floating.cpp.

                                                                                   {
    return arg_1 + arg_2;
  }
static complex<generic> mmx::GLUE_11 ( const complex< generic > &  arg_1,
const complex< generic > &  arg_2 
) [static]

Definition at line 57 of file glue_complex_generic.cpp.

                                                                         {
    return arg_1 - arg_2;
  }
static complex<rational> mmx::GLUE_12 ( const complex< rational > &  arg_1,
const complex< rational > &  arg_2 
) [static]

Definition at line 64 of file glue_complex_rational.cpp.

                                                                           {
    return arg_1 - arg_2;
  }
static integer mmx::GLUE_12 ( const mmx_floating &  arg_1) [static]

Definition at line 66 of file glue_floating.cpp.

References as_integer().

                                      {
    return as_integer (arg_1);
  }
static integer mmx::GLUE_12 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 63 of file glue_integer.cpp.

                                                       {
    return arg_1 * arg_2;
  }
static interval<double> mmx::GLUE_12 ( const interval< double > &  arg_1,
const interval< double > &  arg_2 
) [static]

Definition at line 65 of file glue_interval_double.cpp.

                                                                         {
    return arg_1 * arg_2;
  }
static interval<mmx_floating> mmx::GLUE_12 ( const interval< mmx_floating > &  arg_1,
const interval< mmx_floating > &  arg_2 
) [static]

Definition at line 68 of file glue_interval_floating.cpp.

                                                                                     {
    return arg_1 * arg_2;
  }
static rational mmx::GLUE_12 ( const rational &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 63 of file glue_rational.cpp.

                                                         {
    return arg_1 * arg_2;
  }
static tangent<double, double> mmx::GLUE_12 ( const tangent< double, double > &  arg_1) [static]

Definition at line 69 of file glue_tangent_double.cpp.

References sqrt().

                                                 {
    return sqrt (arg_1);
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_12 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 70 of file glue_tangent_floating.cpp.

References sqrt().

                                                             {
    return sqrt (arg_1);
  }
static tangent<generic, generic> mmx::GLUE_12 ( const tangent< generic, generic > &  arg_1) [static]

Definition at line 62 of file glue_tangent_generic.cpp.

References exp().

                                                   {
    return exp (arg_1);
  }
static tangent<generic, generic> mmx::GLUE_12 ( const tangent< rational, rational > &  arg_1) [static]

Definition at line 65 of file glue_tangent_rational.cpp.

                                                     {
    return as<tangent<generic, generic> > (arg_1);
  }
static complex<double> mmx::GLUE_12 ( const complex< double > &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 68 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                                                                       {
    return arg_1 - arg_2;
  }
static complex<mmx_floating> mmx::GLUE_12 ( const complex< mmx_floating > &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 69 of file glue_complex_floating.cpp.

                                                                                   {
    return arg_1 - arg_2;
  }
static complex<generic> mmx::GLUE_12 ( const complex< generic > &  arg_1,
const complex< generic > &  arg_2 
) [static]

Definition at line 62 of file glue_complex_generic.cpp.

                                                                         {
    return arg_1 * arg_2;
  }
static complex<rational> mmx::GLUE_13 ( const complex< rational > &  arg_1,
const complex< rational > &  arg_2 
) [static]

Definition at line 69 of file glue_complex_rational.cpp.

                                                                           {
    return arg_1 * arg_2;
  }
static string mmx::GLUE_13 ( const mmx_floating &  arg_1) [static]

Definition at line 71 of file glue_floating.cpp.

References as_string().

                                      {
    return as_string (arg_1);
  }
static integer mmx::GLUE_13 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 68 of file glue_integer.cpp.

                                                       {
    return arg_1 / arg_2;
  }
static interval<double> mmx::GLUE_13 ( const double &  arg_1,
const interval< double > &  arg_2 
) [static]

Definition at line 70 of file glue_interval_double.cpp.

                                                               {
    return arg_1 + arg_2;
  }
static interval<mmx_floating> mmx::GLUE_13 ( const mmx_floating &  arg_1,
const interval< mmx_floating > &  arg_2 
) [static]

Definition at line 73 of file glue_interval_floating.cpp.

                                                                           {
    return arg_1 + arg_2;
  }
static rational mmx::GLUE_13 ( const rational &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 68 of file glue_rational.cpp.

                                                         {
    return arg_1 / arg_2;
  }
static tangent<complex<rational> , complex<rational> > mmx::GLUE_13 ( const complex< rational > &  arg_1) [static]

Definition at line 70 of file glue_tangent_rational.cpp.

                                           {
    return tangent<complex<rational>, complex<rational> > (arg_1);
  }
static tangent<double, double> mmx::GLUE_13 ( const tangent< double, double > &  arg_1) [static]

Definition at line 74 of file glue_tangent_double.cpp.

References exp().

                                                 {
    return exp (arg_1);
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_13 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 75 of file glue_tangent_floating.cpp.

References exp().

                                                             {
    return exp (arg_1);
  }
static tangent<generic, generic> mmx::GLUE_13 ( const tangent< generic, generic > &  arg_1) [static]

Definition at line 67 of file glue_tangent_generic.cpp.

References log().

                                                   {
    return log (arg_1);
  }
static complex<double> mmx::GLUE_13 ( const complex< double > &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 73 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                                                                       {
    return arg_1 * arg_2;
  }
static complex<mmx_floating> mmx::GLUE_13 ( const complex< mmx_floating > &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 74 of file glue_complex_floating.cpp.

                                                                                   {
    return arg_1 * arg_2;
  }
static complex<generic> mmx::GLUE_13 ( const complex< generic > &  arg_1,
const complex< generic > &  arg_2 
) [static]

Definition at line 67 of file glue_complex_generic.cpp.

                                                                         {
    return arg_1 / arg_2;
  }
static complex<rational> mmx::GLUE_14 ( const rational &  arg_1,
const complex< rational > &  arg_2 
) [static]

Definition at line 74 of file glue_complex_rational.cpp.

                                                                  {
    return arg_1 + arg_2;
  }
static mmx_floating mmx::GLUE_14 ( const mmx_floating &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 76 of file glue_floating.cpp.

References uniform_deviate().

                                                                 {
    return uniform_deviate (arg_1, arg_2);
  }
static integer mmx::GLUE_14 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 73 of file glue_integer.cpp.

                                                       {
    return quo (arg_1, arg_2);
  }
static interval<double> mmx::GLUE_14 ( const interval< double > &  arg_1,
const double &  arg_2 
) [static]

Definition at line 75 of file glue_interval_double.cpp.

                                                               {
    return arg_1 + arg_2;
  }
static interval<mmx_floating> mmx::GLUE_14 ( const interval< mmx_floating > &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 78 of file glue_interval_floating.cpp.

                                                                           {
    return arg_1 + arg_2;
  }
static tangent<double, double> mmx::GLUE_14 ( const tangent< double, double > &  arg_1) [static]

Definition at line 79 of file glue_tangent_double.cpp.

References log().

                                                 {
    return log (arg_1);
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_14 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 80 of file glue_tangent_floating.cpp.

References log().

                                                             {
    return log (arg_1);
  }
static tangent<complex<rational> , complex<rational> > mmx::GLUE_14 ( const complex< rational > &  arg_1) [static]

Definition at line 75 of file glue_tangent_rational.cpp.

                                           {
    return tangent<complex<rational>, complex<rational> > (arg_1);
  }
static tangent<generic, generic> mmx::GLUE_14 ( const tangent< generic, generic > &  arg_1,
const tangent< generic, generic > &  arg_2 
) [static]

Definition at line 72 of file glue_tangent_generic.cpp.

References pow().

                                                                                           {
    return pow (arg_1, arg_2);
  }
static complex<double> mmx::GLUE_14 ( const double &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 78 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                                                              {
    return arg_1 + arg_2;
  }
static complex<mmx_floating> mmx::GLUE_14 ( const mmx_floating &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 79 of file glue_complex_floating.cpp.

                                                                          {
    return arg_1 + arg_2;
  }
static generic mmx::GLUE_14 ( const complex< generic > &  arg_1) [static]

Definition at line 72 of file glue_complex_generic.cpp.

References abs().

                                          {
    return abs (arg_1);
  }
static complex<rational> mmx::GLUE_15 ( const complex< rational > &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 79 of file glue_complex_rational.cpp.

                                                                  {
    return arg_1 + arg_2;
  }
static mmx_floating mmx::GLUE_15 ( const mmx_floating &  arg_1) [static]

Definition at line 81 of file glue_floating.cpp.

                                      {
    return -arg_1;
  }
static tangent<complex<rational> , complex<rational> > mmx::GLUE_15 ( const complex< rational > &  arg_1,
const complex< rational > &  arg_2 
) [static]

Definition at line 80 of file glue_tangent_rational.cpp.

                                                                           {
    return tangent<complex<rational>, complex<rational> > (arg_1, arg_2);
  }
static integer mmx::GLUE_15 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 78 of file glue_integer.cpp.

                                                       {
    return rem (arg_1, arg_2);
  }
static interval<double> mmx::GLUE_15 ( const double &  arg_1,
const interval< double > &  arg_2 
) [static]

Definition at line 80 of file glue_interval_double.cpp.

                                                               {
    return arg_1 - arg_2;
  }
static interval<mmx_floating> mmx::GLUE_15 ( const mmx_floating &  arg_1,
const interval< mmx_floating > &  arg_2 
) [static]

Definition at line 83 of file glue_interval_floating.cpp.

                                                                           {
    return arg_1 - arg_2;
  }
static rational mmx::GLUE_15 ( const rational &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 78 of file glue_rational.cpp.

References pow().

                                                        {
    return pow (arg_1, arg_2);
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_15 ( const tangent< mmx_floating, mmx_floating > &  arg_1,
const tangent< mmx_floating, mmx_floating > &  arg_2 
) [static]

Definition at line 85 of file glue_tangent_floating.cpp.

References pow().

                                                                                                               {
    return pow (arg_1, arg_2);
  }
static tangent<generic, generic> mmx::GLUE_15 ( const tangent< generic, generic > &  arg_1) [static]

Definition at line 77 of file glue_tangent_generic.cpp.

References cos().

                                                   {
    return cos (arg_1);
  }
static complex<double> mmx::GLUE_15 ( const complex< double > &  arg_1,
const double &  arg_2 
) [static]

Definition at line 83 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                                                              {
    return arg_1 + arg_2;
  }
static tangent<double, double> mmx::GLUE_15 ( const tangent< double, double > &  arg_1,
const tangent< double, double > &  arg_2 
) [static]

Definition at line 84 of file glue_tangent_double.cpp.

References pow().

                                                                                       {
    return pow (arg_1, arg_2);
  }
static complex<mmx_floating> mmx::GLUE_15 ( const complex< mmx_floating > &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 84 of file glue_complex_floating.cpp.

                                                                          {
    return arg_1 + arg_2;
  }
static generic mmx::GLUE_15 ( const complex< generic > &  arg_1) [static]

Definition at line 77 of file glue_complex_generic.cpp.

References arg().

                                          {
    return arg (arg_1);
  }
static complex<rational> mmx::GLUE_16 ( const rational &  arg_1,
const complex< rational > &  arg_2 
) [static]

Definition at line 84 of file glue_complex_rational.cpp.

                                                                  {
    return arg_1 - arg_2;
  }
static mmx_floating mmx::GLUE_16 ( const mmx_floating &  arg_1) [static]

Definition at line 86 of file glue_floating.cpp.

References square().

                                      {
    return square (arg_1);
  }
static bool mmx::GLUE_16 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 83 of file glue_integer.cpp.

                                                       {
    return divides (arg_1, arg_2);
  }
static interval<double> mmx::GLUE_16 ( const interval< double > &  arg_1,
const double &  arg_2 
) [static]

Definition at line 85 of file glue_interval_double.cpp.

                                                               {
    return arg_1 - arg_2;
  }
static interval<mmx_floating> mmx::GLUE_16 ( const interval< mmx_floating > &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 88 of file glue_interval_floating.cpp.

                                                                           {
    return arg_1 - arg_2;
  }
static rational mmx::GLUE_16 ( const rational &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 83 of file glue_rational.cpp.

                                                         {
    return arg_1 / arg_2;
  }
static tangent<double, double> mmx::GLUE_16 ( const tangent< double, double > &  arg_1) [static]

Definition at line 89 of file glue_tangent_double.cpp.

References cos().

                                                 {
    return cos (arg_1);
  }
static tangent<generic, generic> mmx::GLUE_16 ( const tangent< generic, generic > &  arg_1) [static]

Definition at line 82 of file glue_tangent_generic.cpp.

References sin().

                                                   {
    return sin (arg_1);
  }
static complex<rational> mmx::GLUE_16 ( const tangent< complex< rational >, complex< rational > > &  arg_1) [static]

Definition at line 85 of file glue_tangent_rational.cpp.

References base().

                                                                         {
    return base (arg_1);
  }
static complex<double> mmx::GLUE_16 ( const double &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 88 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                                                              {
    return arg_1 - arg_2;
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_16 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 90 of file glue_tangent_floating.cpp.

References cos().

                                                             {
    return cos (arg_1);
  }
static complex<mmx_floating> mmx::GLUE_16 ( const mmx_floating &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 89 of file glue_complex_floating.cpp.

                                                                          {
    return arg_1 - arg_2;
  }
static complex<generic> mmx::GLUE_16 ( const complex< generic > &  arg_1) [static]

Definition at line 82 of file glue_complex_generic.cpp.

References sqrt().

                                          {
    return sqrt (arg_1);
  }
static complex<rational> mmx::GLUE_17 ( const complex< rational > &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 89 of file glue_complex_rational.cpp.

                                                                  {
    return arg_1 - arg_2;
  }
static mmx_floating mmx::GLUE_17 ( const mmx_floating &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 91 of file glue_floating.cpp.

                                                                 {
    return arg_1 + arg_2;
  }
static integer mmx::GLUE_17 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 88 of file glue_integer.cpp.

References gcd().

                                                       {
    return gcd (arg_1, arg_2);
  }
static interval<double> mmx::GLUE_17 ( const double &  arg_1,
const interval< double > &  arg_2 
) [static]

Definition at line 90 of file glue_interval_double.cpp.

                                                               {
    return arg_1 * arg_2;
  }
static bool mmx::GLUE_17 ( const rational &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 88 of file glue_rational.cpp.

                                                         {
    return divides (arg_1, arg_2);
  }
static tangent<double, double> mmx::GLUE_17 ( const tangent< double, double > &  arg_1) [static]

Definition at line 94 of file glue_tangent_double.cpp.

References sin().

                                                 {
    return sin (arg_1);
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_17 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 95 of file glue_tangent_floating.cpp.

References sin().

                                                             {
    return sin (arg_1);
  }
static interval<mmx_floating> mmx::GLUE_17 ( const mmx_floating &  arg_1,
const interval< mmx_floating > &  arg_2 
) [static]

Definition at line 93 of file glue_interval_floating.cpp.

                                                                           {
    return arg_1 * arg_2;
  }
static tangent<generic, generic> mmx::GLUE_17 ( const tangent< generic, generic > &  arg_1) [static]

Definition at line 87 of file glue_tangent_generic.cpp.

References tan().

                                                   {
    return tan (arg_1);
  }
static complex<rational> mmx::GLUE_17 ( const tangent< complex< rational >, complex< rational > > &  arg_1) [static]

Definition at line 90 of file glue_tangent_rational.cpp.

References slope().

                                                                         {
    return slope (arg_1);
  }
static complex<double> mmx::GLUE_17 ( const complex< double > &  arg_1,
const double &  arg_2 
) [static]

Definition at line 93 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                                                              {
    return arg_1 - arg_2;
  }
static complex<mmx_floating> mmx::GLUE_17 ( const complex< mmx_floating > &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 94 of file glue_complex_floating.cpp.

                                                                          {
    return arg_1 - arg_2;
  }
static complex<generic> mmx::GLUE_17 ( const complex< generic > &  arg_1) [static]

Definition at line 87 of file glue_complex_generic.cpp.

References exp().

                                          {
    return exp (arg_1);
  }
static complex<rational> mmx::GLUE_18 ( const rational &  arg_1,
const complex< rational > &  arg_2 
) [static]

Definition at line 94 of file glue_complex_rational.cpp.

                                                                  {
    return arg_1 * arg_2;
  }
static mmx_floating mmx::GLUE_18 ( const mmx_floating &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 96 of file glue_floating.cpp.

                                                                 {
    return arg_1 - arg_2;
  }
static interval<double> mmx::GLUE_18 ( const interval< double > &  arg_1,
const double &  arg_2 
) [static]

Definition at line 95 of file glue_interval_double.cpp.

                                                               {
    return arg_1 * arg_2;
  }
static integer mmx::GLUE_18 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 93 of file glue_integer.cpp.

References lcm().

                                                       {
    return lcm (arg_1, arg_2);
  }
static interval<mmx_floating> mmx::GLUE_18 ( const interval< mmx_floating > &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 98 of file glue_interval_floating.cpp.

                                                                           {
    return arg_1 * arg_2;
  }
static rational mmx::GLUE_18 ( const rational &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 93 of file glue_rational.cpp.

References gcd().

                                                         {
    return gcd (arg_1, arg_2);
  }
static tangent<double, double> mmx::GLUE_18 ( const tangent< double, double > &  arg_1) [static]

Definition at line 99 of file glue_tangent_double.cpp.

References tan().

                                                 {
    return tan (arg_1);
  }
static tangent<generic, generic> mmx::GLUE_18 ( const tangent< generic, generic > &  arg_1) [static]

Definition at line 92 of file glue_tangent_generic.cpp.

References acos().

                                                   {
    return acos (arg_1);
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_18 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 100 of file glue_tangent_floating.cpp.

References tan().

                                                             {
    return tan (arg_1);
  }
static tangent<complex<rational> , complex<rational> > mmx::GLUE_18 ( const tangent< complex< rational >, complex< rational > > &  arg_1) [static]

Definition at line 95 of file glue_tangent_rational.cpp.

                                                                         {
    return -arg_1;
  }
static complex<double> mmx::GLUE_18 ( const double &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 98 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                                                              {
    return arg_1 * arg_2;
  }
static complex<mmx_floating> mmx::GLUE_18 ( const mmx_floating &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 99 of file glue_complex_floating.cpp.

                                                                          {
    return arg_1 * arg_2;
  }
static complex<generic> mmx::GLUE_18 ( const complex< generic > &  arg_1) [static]

Definition at line 92 of file glue_complex_generic.cpp.

References log().

                                          {
    return log (arg_1);
  }
static complex<rational> mmx::GLUE_19 ( const complex< rational > &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 99 of file glue_complex_rational.cpp.

                                                                  {
    return arg_1 * arg_2;
  }
static mmx_floating mmx::GLUE_19 ( const mmx_floating &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 101 of file glue_floating.cpp.

                                                                 {
    return arg_1 * arg_2;
  }
static bool mmx::GLUE_19 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 98 of file glue_integer.cpp.

                                                       {
    return arg_1 < arg_2;
  }
static interval<double> mmx::GLUE_19 ( const interval< double > &  arg_1,
const double &  arg_2 
) [static]

Definition at line 100 of file glue_interval_double.cpp.

                                                               {
    return arg_1 / arg_2;
  }
static interval<mmx_floating> mmx::GLUE_19 ( const interval< mmx_floating > &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 103 of file glue_interval_floating.cpp.

                                                                           {
    return arg_1 / arg_2;
  }
static rational mmx::GLUE_19 ( const rational &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 98 of file glue_rational.cpp.

References lcm().

                                                         {
    return lcm (arg_1, arg_2);
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_19 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 105 of file glue_tangent_floating.cpp.

References acos().

                                                             {
    return acos (arg_1);
  }
static tangent<complex<rational> , complex<rational> > mmx::GLUE_19 ( const tangent< complex< rational >, complex< rational > > &  arg_1) [static]

Definition at line 100 of file glue_tangent_rational.cpp.

References square().

                                                                         {
    return square (arg_1);
  }
static tangent<generic, generic> mmx::GLUE_19 ( const tangent< generic, generic > &  arg_1) [static]

Definition at line 97 of file glue_tangent_generic.cpp.

References asin().

                                                   {
    return asin (arg_1);
  }
static tangent<double, double> mmx::GLUE_19 ( const tangent< double, double > &  arg_1) [static]

Definition at line 104 of file glue_tangent_double.cpp.

References acos().

                                                 {
    return acos (arg_1);
  }
static complex<double> mmx::GLUE_19 ( const complex< double > &  arg_1,
const double &  arg_2 
) [static]

Definition at line 103 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                                                              {
    return arg_1 * arg_2;
  }
static complex<mmx_floating> mmx::GLUE_19 ( const complex< mmx_floating > &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 104 of file glue_complex_floating.cpp.

                                                                          {
    return arg_1 * arg_2;
  }
static complex<generic> mmx::GLUE_19 ( const complex< generic > &  arg_1,
const complex< generic > &  arg_2 
) [static]

Definition at line 97 of file glue_complex_generic.cpp.

References pow().

                                                                         {
    return pow (arg_1, arg_2);
  }
static mmx_floating mmx::GLUE_2 ( const int &  arg_1) [static]

Definition at line 16 of file glue_floating.cpp.

References mmx_floating.

                            {
    return mmx_floating (arg_1);
  }
static rational mmx::GLUE_2 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 13 of file glue_rational.cpp.

References rational_new.

                                                      {
    return rational_new (arg_1, arg_2);
  }
static tangent<double, double> mmx::GLUE_2 ( const double &  arg_1) [static]

Definition at line 19 of file glue_tangent_double.cpp.

                               {
    return tangent<double, double > (arg_1);
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_2 ( const mmx_floating &  arg_1) [static]

Definition at line 20 of file glue_tangent_floating.cpp.

                                     {
    return tangent<mmx_floating, mmx_floating > (arg_1);
  }
static tangent<rational, rational> mmx::GLUE_2 ( const rational &  arg_1) [static]

Definition at line 15 of file glue_tangent_rational.cpp.

                                 {
    return tangent<rational, rational > (arg_1);
  }
static complex<double> mmx::GLUE_2 ( const double &  arg_1,
const double &  arg_2 
) [static]

Definition at line 18 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                                                    {
    return complex<double > (arg_1, arg_2);
  }
static complex<mmx_floating> mmx::GLUE_2 ( const mmx_floating &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 19 of file glue_complex_floating.cpp.

                                                                {
    return complex<mmx_floating > (arg_1, arg_2);
  }
static complex<generic> mmx::GLUE_2 ( const generic &  arg_1,
const generic &  arg_2 
) [static]

Definition at line 12 of file glue_complex_generic.cpp.

                                                      {
    return complex<generic > (arg_1, arg_2);
  }
static complex<rational> mmx::GLUE_2 ( const rational &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 14 of file glue_complex_rational.cpp.

                                                        {
    return complex<rational > (arg_1, arg_2);
  }
static complex<rational> mmx::GLUE_20 ( const complex< rational > &  arg_1,
const complex< rational > &  arg_2 
) [static]

Definition at line 104 of file glue_complex_rational.cpp.

                                                                           {
    return arg_1 / arg_2;
  }
static mmx_floating mmx::GLUE_20 ( const mmx_floating &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 106 of file glue_floating.cpp.

                                                                 {
    return arg_1 / arg_2;
  }
static bool mmx::GLUE_20 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 103 of file glue_integer.cpp.

                                                       {
    return arg_1 <= arg_2;
  }
static interval<double> mmx::GLUE_20 ( const interval< double > &  arg_1,
const interval< double > &  arg_2 
) [static]

Definition at line 105 of file glue_interval_double.cpp.

                                                                         {
    return arg_1 / arg_2;
  }
static interval<mmx_floating> mmx::GLUE_20 ( const interval< mmx_floating > &  arg_1,
const interval< mmx_floating > &  arg_2 
) [static]

Definition at line 108 of file glue_interval_floating.cpp.

                                                                                     {
    return arg_1 / arg_2;
  }
static tangent<double, double> mmx::GLUE_20 ( const tangent< double, double > &  arg_1) [static]

Definition at line 109 of file glue_tangent_double.cpp.

References asin().

                                                 {
    return asin (arg_1);
  }
static bool mmx::GLUE_20 ( const rational &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 103 of file glue_rational.cpp.

                                                         {
    return arg_1 < arg_2;
  }
static tangent<generic, generic> mmx::GLUE_20 ( const tangent< generic, generic > &  arg_1) [static]

Definition at line 102 of file glue_tangent_generic.cpp.

References atan().

                                                   {
    return atan (arg_1);
  }
static tangent<complex<rational> , complex<rational> > mmx::GLUE_20 ( const tangent< complex< rational >, complex< rational > > &  arg_1,
const tangent< complex< rational >, complex< rational > > &  arg_2 
) [static]

Definition at line 105 of file glue_tangent_rational.cpp.

                                                                                                                                       {
    return arg_1 + arg_2;
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_20 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 110 of file glue_tangent_floating.cpp.

References asin().

                                                             {
    return asin (arg_1);
  }
static complex<double> mmx::GLUE_20 ( const complex< double > &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 108 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                                                                       {
    return arg_1 / arg_2;
  }
static complex<mmx_floating> mmx::GLUE_20 ( const complex< mmx_floating > &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 109 of file glue_complex_floating.cpp.

                                                                                   {
    return arg_1 / arg_2;
  }
static complex<generic> mmx::GLUE_20 ( const complex< generic > &  arg_1) [static]

Definition at line 102 of file glue_complex_generic.cpp.

References cos().

                                          {
    return cos (arg_1);
  }
static complex<rational> mmx::GLUE_21 ( const rational &  arg_1,
const complex< rational > &  arg_2 
) [static]

Definition at line 109 of file glue_complex_rational.cpp.

                                                                  {
    return arg_1 / arg_2;
  }
static mmx_floating mmx::GLUE_21 ( const mmx_floating &  arg_1) [static]

Definition at line 111 of file glue_floating.cpp.

References sqrt().

                                      {
    return sqrt (arg_1);
  }
static interval<double> mmx::GLUE_21 ( const double &  arg_1,
const interval< double > &  arg_2 
) [static]

Definition at line 110 of file glue_interval_double.cpp.

                                                               {
    return arg_1 / arg_2;
  }
static interval<mmx_floating> mmx::GLUE_21 ( const mmx_floating &  arg_1,
const interval< mmx_floating > &  arg_2 
) [static]

Definition at line 113 of file glue_interval_floating.cpp.

                                                                           {
    return arg_1 / arg_2;
  }
static bool mmx::GLUE_21 ( const rational &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 108 of file glue_rational.cpp.

                                                         {
    return arg_1 <= arg_2;
  }
static tangent<double, double> mmx::GLUE_21 ( const tangent< double, double > &  arg_1) [static]

Definition at line 114 of file glue_tangent_double.cpp.

References atan().

                                                 {
    return atan (arg_1);
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_21 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 115 of file glue_tangent_floating.cpp.

References atan().

                                                             {
    return atan (arg_1);
  }
static bool mmx::GLUE_21 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 108 of file glue_integer.cpp.

                                                       {
    return arg_1 > arg_2;
  }
static complex<double> mmx::GLUE_21 ( const double &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 113 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), and glue_tangent_rational().

                                                              {
    return arg_1 / arg_2;
  }
static tangent<complex<rational> , complex<rational> > mmx::GLUE_21 ( const tangent< complex< rational >, complex< rational > > &  arg_1,
const tangent< complex< rational >, complex< rational > > &  arg_2 
) [static]

Definition at line 110 of file glue_tangent_rational.cpp.

                                                                                                                                       {
    return arg_1 - arg_2;
  }
static complex<mmx_floating> mmx::GLUE_21 ( const mmx_floating &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 114 of file glue_complex_floating.cpp.

                                                                          {
    return arg_1 / arg_2;
  }
static complex<generic> mmx::GLUE_21 ( const complex< generic > &  arg_1) [static]

Definition at line 107 of file glue_complex_generic.cpp.

References sin().

                                          {
    return sin (arg_1);
  }
static complex<rational> mmx::GLUE_22 ( const complex< rational > &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 114 of file glue_complex_rational.cpp.

                                                                  {
    return arg_1 / arg_2;
  }
static mmx_floating mmx::GLUE_22 ( const mmx_floating &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 116 of file glue_floating.cpp.

References pow().

                                                                 {
    return pow (arg_1, arg_2);
  }
static bool mmx::GLUE_22 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 113 of file glue_integer.cpp.

                                                       {
    return arg_1 >= arg_2;
  }
static interval<double> mmx::GLUE_22 ( const interval< double > &  arg_1) [static]

Definition at line 115 of file glue_interval_double.cpp.

References sqrt().

                                          {
    return sqrt (arg_1);
  }
static interval<mmx_floating> mmx::GLUE_22 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 118 of file glue_interval_floating.cpp.

References sqrt().

                                                {
    return sqrt (arg_1);
  }
static bool mmx::GLUE_22 ( const rational &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 113 of file glue_rational.cpp.

                                                         {
    return arg_1 > arg_2;
  }
static bool mmx::GLUE_22 ( const tangent< double, double > &  arg_1) [static]

Definition at line 119 of file glue_tangent_double.cpp.

References is_finite().

                                                 {
    return is_finite (arg_1);
  }
static bool mmx::GLUE_22 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 120 of file glue_tangent_floating.cpp.

References is_finite().

                                                             {
    return is_finite (arg_1);
  }
static complex<double> mmx::GLUE_22 ( const complex< double > &  arg_1,
const double &  arg_2 
) [static]

Definition at line 118 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), and glue_tangent_rational().

                                                              {
    return arg_1 / arg_2;
  }
static tangent<complex<rational> , complex<rational> > mmx::GLUE_22 ( const tangent< complex< rational >, complex< rational > > &  arg_1,
const tangent< complex< rational >, complex< rational > > &  arg_2 
) [static]

Definition at line 115 of file glue_tangent_rational.cpp.

                                                                                                                                       {
    return arg_1 * arg_2;
  }
static complex<mmx_floating> mmx::GLUE_22 ( const complex< mmx_floating > &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 119 of file glue_complex_floating.cpp.

                                                                          {
    return arg_1 / arg_2;
  }
static complex<generic> mmx::GLUE_22 ( const complex< generic > &  arg_1) [static]

Definition at line 112 of file glue_complex_generic.cpp.

References tan().

                                          {
    return tan (arg_1);
  }
static complex<generic> mmx::GLUE_23 ( const complex< rational > &  arg_1) [static]

Definition at line 119 of file glue_complex_rational.cpp.

                                           {
    return as<complex<generic> > (arg_1);
  }
static mmx_floating mmx::GLUE_23 ( const mmx_floating &  arg_1) [static]

Definition at line 121 of file glue_floating.cpp.

References exp().

                                      {
    return exp (arg_1);
  }
static integer mmx::GLUE_23 ( const integer &  arg_1) [static]

Definition at line 118 of file glue_integer.cpp.

References abs().

                                 {
    return abs (arg_1);
  }
static interval<double> mmx::GLUE_23 ( const interval< double > &  arg_1) [static]

Definition at line 120 of file glue_interval_double.cpp.

References exp().

                                          {
    return exp (arg_1);
  }
static interval<mmx_floating> mmx::GLUE_23 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 123 of file glue_interval_floating.cpp.

References exp().

                                                {
    return exp (arg_1);
  }
static bool mmx::GLUE_23 ( const rational &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 118 of file glue_rational.cpp.

                                                         {
    return arg_1 >= arg_2;
  }
static bool mmx::GLUE_23 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 125 of file glue_tangent_floating.cpp.

References is_infinite().

                                                             {
    return is_infinite (arg_1);
  }
static tangent<complex<rational> , complex<rational> > mmx::GLUE_23 ( const tangent< complex< rational >, complex< rational > > &  arg_1,
const tangent< complex< rational >, complex< rational > > &  arg_2 
) [static]

Definition at line 120 of file glue_tangent_rational.cpp.

                                                                                                                                       {
    return arg_1 / arg_2;
  }
static double mmx::GLUE_23 ( const complex< double > &  arg_1) [static]

Definition at line 123 of file glue_complex_double.cpp.

References abs().

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), and glue_tangent_rational().

                                         {
    return abs (arg_1);
  }
static bool mmx::GLUE_23 ( const tangent< double, double > &  arg_1) [static]

Definition at line 124 of file glue_tangent_double.cpp.

References is_infinite().

                                                 {
    return is_infinite (arg_1);
  }
static mmx_floating mmx::GLUE_23 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 124 of file glue_complex_floating.cpp.

References abs().

                                               {
    return abs (arg_1);
  }
static complex<generic> mmx::GLUE_23 ( const complex< generic > &  arg_1) [static]

Definition at line 117 of file glue_complex_generic.cpp.

References acos().

                                          {
    return acos (arg_1);
  }
static mmx_floating mmx::GLUE_24 ( const mmx_floating &  arg_1) [static]

Definition at line 126 of file glue_floating.cpp.

References log().

                                      {
    return log (arg_1);
  }
static integer mmx::GLUE_24 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 123 of file glue_integer.cpp.

References min().

                                                       {
    return min (arg_1, arg_2);
  }
static interval<double> mmx::GLUE_24 ( const interval< double > &  arg_1) [static]

Definition at line 125 of file glue_interval_double.cpp.

References log().

                                          {
    return log (arg_1);
  }
static interval<mmx_floating> mmx::GLUE_24 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 128 of file glue_interval_floating.cpp.

References log().

                                                {
    return log (arg_1);
  }
static bool mmx::GLUE_24 ( const tangent< double, double > &  arg_1) [static]

Definition at line 129 of file glue_tangent_double.cpp.

References is_nan().

                                                 {
    return is_nan (arg_1);
  }
static complex<generic> mmx::GLUE_24 ( const complex< generic > &  arg_1) [static]

Definition at line 122 of file glue_complex_generic.cpp.

References asin().

                                          {
    return asin (arg_1);
  }
static tangent<complex<rational> , complex<rational> > mmx::GLUE_24 ( const tangent< rational, rational > &  arg_1) [static]

Definition at line 125 of file glue_tangent_rational.cpp.

                                                     {
    return as<tangent<complex<rational> , complex<rational> > > (arg_1);
  }
static bool mmx::GLUE_24 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 130 of file glue_tangent_floating.cpp.

References is_nan().

                                                             {
    return is_nan (arg_1);
  }
static rational mmx::GLUE_24 ( const rational &  arg_1) [static]

Definition at line 123 of file glue_rational.cpp.

References abs().

                                  {
    return abs (arg_1);
  }
static double mmx::GLUE_24 ( const complex< double > &  arg_1) [static]

Definition at line 128 of file glue_complex_double.cpp.

References arg().

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), and glue_tangent_rational().

                                         {
    return arg (arg_1);
  }
static mmx_floating mmx::GLUE_24 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 129 of file glue_complex_floating.cpp.

References arg().

                                               {
    return arg (arg_1);
  }
static mmx_floating mmx::GLUE_25 ( const mmx_floating &  arg_1) [static]

Definition at line 131 of file glue_floating.cpp.

References cos().

                                      {
    return cos (arg_1);
  }
static integer mmx::GLUE_25 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 128 of file glue_integer.cpp.

References max().

                                                       {
    return max (arg_1, arg_2);
  }
static interval<double> mmx::GLUE_25 ( const interval< double > &  arg_1,
const interval< double > &  arg_2 
) [static]

Definition at line 130 of file glue_interval_double.cpp.

References pow().

                                                                         {
    return pow (arg_1, arg_2);
  }
static rational mmx::GLUE_25 ( const rational &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 128 of file glue_rational.cpp.

References min().

                                                         {
    return min (arg_1, arg_2);
  }
static tangent<double, double> mmx::GLUE_25 ( const tangent< double, double > &  arg_1) [static]

Definition at line 134 of file glue_tangent_double.cpp.

References times_infinity().

                                                 {
    return times_infinity (arg_1);
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_25 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 135 of file glue_tangent_floating.cpp.

References times_infinity().

                                                             {
    return times_infinity (arg_1);
  }
static tangent<generic, generic> mmx::GLUE_25 ( const tangent< complex< rational >, complex< rational > > &  arg_1) [static]

Definition at line 130 of file glue_tangent_rational.cpp.

                                                                         {
    return as<tangent<generic, generic> > (arg_1);
  }
static interval<mmx_floating> mmx::GLUE_25 ( const interval< mmx_floating > &  arg_1,
const interval< mmx_floating > &  arg_2 
) [static]

Definition at line 133 of file glue_interval_floating.cpp.

References pow().

                                                                                     {
    return pow (arg_1, arg_2);
  }
static complex<double> mmx::GLUE_25 ( const complex< double > &  arg_1) [static]

Definition at line 133 of file glue_complex_double.cpp.

References sqrt().

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), and glue_tangent_rational().

                                         {
    return sqrt (arg_1);
  }
static complex<mmx_floating> mmx::GLUE_25 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 134 of file glue_complex_floating.cpp.

References sqrt().

                                               {
    return sqrt (arg_1);
  }
static complex<generic> mmx::GLUE_25 ( const complex< generic > &  arg_1) [static]

Definition at line 127 of file glue_complex_generic.cpp.

References atan().

                                          {
    return atan (arg_1);
  }
static integer mmx::GLUE_26 ( const integer &  arg_1) [static]

Definition at line 133 of file glue_integer.cpp.

References factorial().

                                 {
    return factorial (arg_1);
  }
static interval<mmx_floating> mmx::GLUE_26 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 138 of file glue_interval_floating.cpp.

References cos().

                                                {
    return cos (arg_1);
  }
static mmx_floating mmx::GLUE_26 ( const mmx_floating &  arg_1) [static]

Definition at line 136 of file glue_floating.cpp.

References sin().

                                      {
    return sin (arg_1);
  }
static interval<double> mmx::GLUE_26 ( const interval< double > &  arg_1) [static]

Definition at line 135 of file glue_interval_double.cpp.

References cos().

                                          {
    return cos (arg_1);
  }
static rational mmx::GLUE_26 ( const rational &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 133 of file glue_rational.cpp.

References max().

                                                         {
    return max (arg_1, arg_2);
  }
static int mmx::GLUE_26 ( const tangent< double, double > &  arg_1) [static]

Definition at line 139 of file glue_tangent_double.cpp.

References precision().

                                                 {
    return precision (arg_1);
  }
static int mmx::GLUE_26 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 140 of file glue_tangent_floating.cpp.

References precision().

                                                             {
    return precision (arg_1);
  }
static complex<double> mmx::GLUE_26 ( const complex< double > &  arg_1) [static]

Definition at line 138 of file glue_complex_double.cpp.

References exp().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return exp (arg_1);
  }
static complex<mmx_floating> mmx::GLUE_26 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 139 of file glue_complex_floating.cpp.

References exp().

                                               {
    return exp (arg_1);
  }
static mmx_floating mmx::GLUE_27 ( const mmx_floating &  arg_1) [static]

Definition at line 141 of file glue_floating.cpp.

References tan().

                                      {
    return tan (arg_1);
  }
static integer mmx::GLUE_27 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 138 of file glue_integer.cpp.

References binomial().

                                                       {
    return binomial (arg_1, arg_2);
  }
static interval<double> mmx::GLUE_27 ( const interval< double > &  arg_1) [static]

Definition at line 140 of file glue_interval_double.cpp.

References sin().

                                          {
    return sin (arg_1);
  }
static interval<mmx_floating> mmx::GLUE_27 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 143 of file glue_interval_floating.cpp.

References sin().

                                                {
    return sin (arg_1);
  }
static rational mmx::GLUE_27 ( const rational &  arg_1) [static]

Definition at line 138 of file glue_rational.cpp.

References floor().

                                  {
    return floor (arg_1);
  }
static int mmx::GLUE_27 ( const tangent< double, double > &  arg_1) [static]

Definition at line 144 of file glue_tangent_double.cpp.

References exponent().

                                                 {
    return exponent (arg_1);
  }
static int mmx::GLUE_27 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 145 of file glue_tangent_floating.cpp.

References exponent().

                                                             {
    return exponent (arg_1);
  }
static complex<double> mmx::GLUE_27 ( const complex< double > &  arg_1) [static]

Definition at line 143 of file glue_complex_double.cpp.

References log().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return log (arg_1);
  }
static complex<mmx_floating> mmx::GLUE_27 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 144 of file glue_complex_floating.cpp.

References log().

                                               {
    return log (arg_1);
  }
static mmx_floating mmx::GLUE_28 ( const mmx_floating &  arg_1) [static]

Definition at line 146 of file glue_floating.cpp.

References acos().

                                      {
    return acos (arg_1);
  }
static bool mmx::GLUE_28 ( const integer &  arg_1) [static]

Definition at line 143 of file glue_integer.cpp.

References is_probable_prime().

                                 {
    return is_probable_prime (arg_1);
  }
static interval<double> mmx::GLUE_28 ( const interval< double > &  arg_1) [static]

Definition at line 145 of file glue_interval_double.cpp.

References tan().

                                          {
    return tan (arg_1);
  }
static interval<mmx_floating> mmx::GLUE_28 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 148 of file glue_interval_floating.cpp.

References tan().

                                                {
    return tan (arg_1);
  }
static double mmx::GLUE_28 ( const tangent< double, double > &  arg_1) [static]

Definition at line 149 of file glue_tangent_double.cpp.

References magnitude().

                                                 {
    return magnitude (arg_1);
  }
static double mmx::GLUE_28 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 150 of file glue_tangent_floating.cpp.

References magnitude().

                                                             {
    return magnitude (arg_1);
  }
static rational mmx::GLUE_28 ( const rational &  arg_1) [static]

Definition at line 143 of file glue_rational.cpp.

References ceil().

                                  {
    return ceil (arg_1);
  }
static complex<double> mmx::GLUE_28 ( const complex< double > &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 148 of file glue_complex_double.cpp.

References pow().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), and glue_tangent_floating().

                                                                       {
    return pow (arg_1, arg_2);
  }
static complex<mmx_floating> mmx::GLUE_28 ( const complex< mmx_floating > &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 149 of file glue_complex_floating.cpp.

References pow().

                                                                                   {
    return pow (arg_1, arg_2);
  }
static mmx_floating mmx::GLUE_29 ( const mmx_floating &  arg_1) [static]

Definition at line 151 of file glue_floating.cpp.

References asin().

                                      {
    return asin (arg_1);
  }
static interval<double> mmx::GLUE_29 ( const interval< double > &  arg_1) [static]

Definition at line 150 of file glue_interval_double.cpp.

References acos().

                                          {
    return acos (arg_1);
  }
static rational mmx::GLUE_29 ( const rational &  arg_1) [static]

Definition at line 148 of file glue_rational.cpp.

References trunc().

                                  {
    return trunc (arg_1);
  }
static tangent<double, double> mmx::GLUE_29 ( const tangent< double, double > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 154 of file glue_tangent_double.cpp.

                                                                   {
    return incexp2 (arg_1, arg_2);
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_29 ( const tangent< mmx_floating, mmx_floating > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 155 of file glue_tangent_floating.cpp.

                                                                               {
    return incexp2 (arg_1, arg_2);
  }
static interval<mmx_floating> mmx::GLUE_29 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 153 of file glue_interval_floating.cpp.

References acos().

                                                {
    return acos (arg_1);
  }
static complex<double> mmx::GLUE_29 ( const complex< double > &  arg_1) [static]

Definition at line 153 of file glue_complex_double.cpp.

References cos().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return cos (arg_1);
  }
static integer mmx::GLUE_29 ( const integer &  arg_1) [static]

Definition at line 148 of file glue_integer.cpp.

References probable_next_prime().

                                 {
    return probable_next_prime (arg_1);
  }
static complex<mmx_floating> mmx::GLUE_29 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 154 of file glue_complex_floating.cpp.

References cos().

                                               {
    return cos (arg_1);
  }
static complex<rational> mmx::GLUE_3 ( const rational &  arg_1) [static]

Definition at line 19 of file glue_complex_rational.cpp.

                                 {
    return complex<rational > (arg_1);
  }
static mmx_floating mmx::GLUE_3 ( const integer &  arg_1) [static]

Definition at line 21 of file glue_floating.cpp.

References mmx_floating.

                                {
    return mmx_floating (arg_1);
  }
static integer mmx::GLUE_3 ( const int &  arg_1) [static]

Definition at line 18 of file glue_integer.cpp.

                            {
    return integer (arg_1);
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_3 ( const mmx_floating &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 25 of file glue_tangent_floating.cpp.

                                                                {
    return tangent<mmx_floating, mmx_floating > (arg_1, arg_2);
  }
static generic mmx::GLUE_3 ( const tangent< generic, generic > &  arg_1) [static]

Definition at line 17 of file glue_tangent_generic.cpp.

References base().

                                                  {
    return base (arg_1);
  }
static tangent<rational, rational> mmx::GLUE_3 ( const rational &  arg_1,
const rational &  arg_2 
) [static]

Definition at line 20 of file glue_tangent_rational.cpp.

                                                        {
    return tangent<rational, rational > (arg_1, arg_2);
  }
static tangent<double, double> mmx::GLUE_3 ( const double &  arg_1,
const double &  arg_2 
) [static]

Definition at line 24 of file glue_tangent_double.cpp.

                                                    {
    return tangent<double, double > (arg_1, arg_2);
  }
static complex<double> mmx::GLUE_3 ( const double &  arg_1) [static]

Definition at line 23 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                               {
    return complex<double > (arg_1);
  }
static complex<mmx_floating> mmx::GLUE_3 ( const mmx_floating &  arg_1) [static]

Definition at line 24 of file glue_complex_floating.cpp.

                                     {
    return complex<mmx_floating > (arg_1);
  }
static generic mmx::GLUE_3 ( const complex< generic > &  arg_1) [static]

Definition at line 17 of file glue_complex_generic.cpp.

References Re().

                                         {
    return Re (arg_1);
  }
static mmx_floating mmx::GLUE_30 ( const mmx_floating &  arg_1) [static]

Definition at line 156 of file glue_floating.cpp.

References atan().

                                      {
    return atan (arg_1);
  }
static integer mmx::GLUE_30 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 153 of file glue_integer.cpp.

                                                       {
    return arg_1 & arg_2;
  }
static complex<mmx_floating> mmx::GLUE_30 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 159 of file glue_complex_floating.cpp.

References sin().

                                               {
    return sin (arg_1);
  }
static interval<mmx_floating> mmx::GLUE_30 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 158 of file glue_interval_floating.cpp.

References asin().

                                                {
    return asin (arg_1);
  }
static interval<double> mmx::GLUE_30 ( const interval< double > &  arg_1) [static]

Definition at line 155 of file glue_interval_double.cpp.

References asin().

                                          {
    return asin (arg_1);
  }
static rational mmx::GLUE_30 ( const rational &  arg_1) [static]

Definition at line 153 of file glue_rational.cpp.

References round().

                                  {
    return round (arg_1);
  }
static tangent<double, double> mmx::GLUE_30 ( const tangent< double, double > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 159 of file glue_tangent_double.cpp.

                                                                   {
    return decexp2 (arg_1, arg_2);
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_30 ( const tangent< mmx_floating, mmx_floating > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 160 of file glue_tangent_floating.cpp.

                                                                               {
    return decexp2 (arg_1, arg_2);
  }
static complex<double> mmx::GLUE_30 ( const complex< double > &  arg_1) [static]

Definition at line 158 of file glue_complex_double.cpp.

References sin().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return sin (arg_1);
  }
static bool mmx::GLUE_31 ( const mmx_floating &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 161 of file glue_floating.cpp.

                                                                 {
    return arg_1 < arg_2;
  }
static integer mmx::GLUE_31 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 158 of file glue_integer.cpp.

                                                       {
    return arg_1 | arg_2;
  }
static interval<double> mmx::GLUE_31 ( const interval< double > &  arg_1) [static]

Definition at line 160 of file glue_interval_double.cpp.

References atan().

                                          {
    return atan (arg_1);
  }
static interval<mmx_floating> mmx::GLUE_31 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 163 of file glue_interval_floating.cpp.

References atan().

                                                {
    return atan (arg_1);
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_31 ( const tangent< rational, rational > &  arg_1) [static]

Definition at line 165 of file glue_tangent_floating.cpp.

                                                     {
    return as<tangent<mmx_floating, mmx_floating> > (arg_1);
  }
static complex<double> mmx::GLUE_31 ( const complex< double > &  arg_1) [static]

Definition at line 163 of file glue_complex_double.cpp.

References tan().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return tan (arg_1);
  }
static complex<mmx_floating> mmx::GLUE_31 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 164 of file glue_complex_floating.cpp.

References tan().

                                               {
    return tan (arg_1);
  }
static tangent<generic, generic> mmx::GLUE_31 ( const tangent< double, double > &  arg_1) [static]

Definition at line 164 of file glue_tangent_double.cpp.

                                                 {
    return as<tangent<generic, generic> > (arg_1);
  }
static bool mmx::GLUE_32 ( const mmx_floating &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 166 of file glue_floating.cpp.

                                                                 {
    return arg_1 <= arg_2;
  }
static integer mmx::GLUE_32 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 163 of file glue_integer.cpp.

                                                       {
    return arg_1 ^ arg_2;
  }
static bool mmx::GLUE_32 ( const interval< double > &  arg_1,
const interval< double > &  arg_2 
) [static]

Definition at line 165 of file glue_interval_double.cpp.

                                                                         {
    return arg_1 < arg_2;
  }
static bool mmx::GLUE_32 ( const interval< mmx_floating > &  arg_1,
const interval< mmx_floating > &  arg_2 
) [static]

Definition at line 168 of file glue_interval_floating.cpp.

                                                                                     {
    return arg_1 < arg_2;
  }
static tangent<double, double> mmx::GLUE_32 ( const tangent< rational, rational > &  arg_1) [static]

Definition at line 169 of file glue_tangent_double.cpp.

                                                     {
    return as<tangent<double, double> > (arg_1);
  }
static tangent<generic, generic> mmx::GLUE_32 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 170 of file glue_tangent_floating.cpp.

                                                             {
    return as<tangent<generic, generic> > (arg_1);
  }
static complex<double> mmx::GLUE_32 ( const complex< double > &  arg_1) [static]

Definition at line 168 of file glue_complex_double.cpp.

References acos().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return acos (arg_1);
  }
static complex<mmx_floating> mmx::GLUE_32 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 169 of file glue_complex_floating.cpp.

References acos().

                                               {
    return acos (arg_1);
  }
static bool mmx::GLUE_33 ( const mmx_floating &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 171 of file glue_floating.cpp.

                                                                 {
    return arg_1 > arg_2;
  }
static bool mmx::GLUE_33 ( const interval< double > &  arg_1,
const interval< double > &  arg_2 
) [static]

Definition at line 170 of file glue_interval_double.cpp.

                                                                         {
    return arg_1 > arg_2;
  }
static integer mmx::GLUE_33 ( const integer &  arg_1) [static]

Definition at line 168 of file glue_integer.cpp.

                                 {
    return ~arg_1;
  }
static bool mmx::GLUE_33 ( const interval< mmx_floating > &  arg_1,
const interval< mmx_floating > &  arg_2 
) [static]

Definition at line 173 of file glue_interval_floating.cpp.

                                                                                     {
    return arg_1 > arg_2;
  }
static complex<double> mmx::GLUE_33 ( const complex< double > &  arg_1) [static]

Definition at line 173 of file glue_complex_double.cpp.

References asin().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return asin (arg_1);
  }
static complex<mmx_floating> mmx::GLUE_33 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 174 of file glue_complex_floating.cpp.

References asin().

                                               {
    return asin (arg_1);
  }
static int mmx::GLUE_34 ( const integer &  arg_1) [static]

Definition at line 173 of file glue_integer.cpp.

                                 {
    return bit_size (arg_1);
  }
static bool mmx::GLUE_34 ( const mmx_floating &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 176 of file glue_floating.cpp.

                                                                 {
    return arg_1 >= arg_2;
  }
static bool mmx::GLUE_34 ( const interval< mmx_floating > &  arg_1,
const interval< mmx_floating > &  arg_2 
) [static]

Definition at line 178 of file glue_interval_floating.cpp.

                                                                                     {
    return arg_1 <= arg_2;
  }
static bool mmx::GLUE_34 ( const interval< double > &  arg_1,
const interval< double > &  arg_2 
) [static]

Definition at line 175 of file glue_interval_double.cpp.

                                                                         {
    return arg_1 <= arg_2;
  }
static complex<double> mmx::GLUE_34 ( const complex< double > &  arg_1) [static]

Definition at line 178 of file glue_complex_double.cpp.

References atan().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return atan (arg_1);
  }
static complex<mmx_floating> mmx::GLUE_34 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 179 of file glue_complex_floating.cpp.

References atan().

                                               {
    return atan (arg_1);
  }
static mmx_floating mmx::GLUE_35 ( const mmx_floating &  arg_1) [static]

Definition at line 181 of file glue_floating.cpp.

References abs().

                                      {
    return abs (arg_1);
  }
static bool mmx::GLUE_35 ( const integer &  arg_1,
const int &  arg_2 
) [static]

Definition at line 178 of file glue_integer.cpp.

                                                   {
    return arg_1[arg_2];
  }
static bool mmx::GLUE_35 ( const interval< double > &  arg_1,
const interval< double > &  arg_2 
) [static]

Definition at line 180 of file glue_interval_double.cpp.

                                                                         {
    return arg_1 >= arg_2;
  }
static bool mmx::GLUE_35 ( const interval< mmx_floating > &  arg_1,
const interval< mmx_floating > &  arg_2 
) [static]

Definition at line 183 of file glue_interval_floating.cpp.

                                                                                     {
    return arg_1 >= arg_2;
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_35 ( const complex< double > &  arg_1,
const complex< double > &  arg_2 
) [static]

Definition at line 184 of file glue_tangent_double.cpp.

                                                                       {
    return tangent<complex<double>, complex<double> > (arg_1, arg_2);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_35 ( const complex< mmx_floating > &  arg_1,
const complex< mmx_floating > &  arg_2 
) [static]

Definition at line 185 of file glue_tangent_floating.cpp.

                                                                                   {
    return tangent<complex<mmx_floating>, complex<mmx_floating> > (arg_1, arg_2);
  }
static bool mmx::GLUE_35 ( const complex< double > &  arg_1) [static]

Definition at line 183 of file glue_complex_double.cpp.

References is_finite().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return is_finite (arg_1);
  }
static bool mmx::GLUE_35 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 184 of file glue_complex_floating.cpp.

References is_finite().

                                               {
    return is_finite (arg_1);
  }
static mmx_floating mmx::GLUE_36 ( const mmx_floating &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 186 of file glue_floating.cpp.

References min().

                                                                 {
    return min (arg_1, arg_2);
  }
static int mmx::GLUE_36 ( const integer &  arg_1) [static]

Definition at line 183 of file glue_integer.cpp.

                                 {
    return hamming_norm (arg_1);
  }
static interval<double> mmx::GLUE_36 ( const interval< double > &  arg_1) [static]

Definition at line 185 of file glue_interval_double.cpp.

References abs().

                                          {
    return abs (arg_1);
  }
static interval<mmx_floating> mmx::GLUE_36 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 188 of file glue_interval_floating.cpp.

References abs().

                                                {
    return abs (arg_1);
  }
static complex<mmx_floating> mmx::GLUE_36 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 190 of file glue_tangent_floating.cpp.

References base().

                                                                                 {
    return base (arg_1);
  }
static complex<double> mmx::GLUE_36 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 189 of file glue_tangent_double.cpp.

References base().

                                                                     {
    return base (arg_1);
  }
static bool mmx::GLUE_36 ( const complex< double > &  arg_1) [static]

Definition at line 188 of file glue_complex_double.cpp.

References is_infinite().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return is_infinite (arg_1);
  }
static bool mmx::GLUE_36 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 189 of file glue_complex_floating.cpp.

References is_infinite().

                                               {
    return is_infinite (arg_1);
  }
static mmx_floating mmx::GLUE_37 ( const mmx_floating &  arg_1,
const mmx_floating &  arg_2 
) [static]

Definition at line 191 of file glue_floating.cpp.

References max().

                                                                 {
    return max (arg_1, arg_2);
  }
static interval<double> mmx::GLUE_37 ( const interval< double > &  arg_1,
const interval< double > &  arg_2 
) [static]

Definition at line 190 of file glue_interval_double.cpp.

References min().

                                                                         {
    return min (arg_1, arg_2);
  }
static int mmx::GLUE_37 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 188 of file glue_integer.cpp.

                                                       {
    return hamming_distance (arg_1, arg_2);
  }
static interval<mmx_floating> mmx::GLUE_37 ( const interval< mmx_floating > &  arg_1,
const interval< mmx_floating > &  arg_2 
) [static]

Definition at line 193 of file glue_interval_floating.cpp.

References min().

                                                                                     {
    return min (arg_1, arg_2);
  }
static complex<mmx_floating> mmx::GLUE_37 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 195 of file glue_tangent_floating.cpp.

References slope().

                                                                                 {
    return slope (arg_1);
  }
static complex<double> mmx::GLUE_37 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 194 of file glue_tangent_double.cpp.

References slope().

                                                                     {
    return slope (arg_1);
  }
static bool mmx::GLUE_37 ( const complex< double > &  arg_1) [static]

Definition at line 193 of file glue_complex_double.cpp.

References is_nan().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return is_nan (arg_1);
  }
static bool mmx::GLUE_37 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 194 of file glue_complex_floating.cpp.

References is_nan().

                                               {
    return is_nan (arg_1);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_38 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 200 of file glue_tangent_floating.cpp.

                                                                                 {
    return -arg_1;
  }
static interval<double> mmx::GLUE_38 ( const interval< double > &  arg_1,
const interval< double > &  arg_2 
) [static]

Definition at line 195 of file glue_interval_double.cpp.

References max().

                                                                         {
    return max (arg_1, arg_2);
  }
static mmx_floating mmx::GLUE_38 ( const mmx_floating &  arg_1) [static]

Definition at line 196 of file glue_floating.cpp.

References floor().

                                      {
    return floor (arg_1);
  }
static interval<mmx_floating> mmx::GLUE_38 ( const interval< mmx_floating > &  arg_1,
const interval< mmx_floating > &  arg_2 
) [static]

Definition at line 198 of file glue_interval_floating.cpp.

References max().

                                                                                     {
    return max (arg_1, arg_2);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_38 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 199 of file glue_tangent_double.cpp.

                                                                     {
    return -arg_1;
  }
static complex<mmx_floating> mmx::GLUE_38 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 199 of file glue_complex_floating.cpp.

References times_infinity().

                                               {
    return times_infinity (arg_1);
  }
static complex<double> mmx::GLUE_38 ( const complex< double > &  arg_1) [static]

Definition at line 198 of file glue_complex_double.cpp.

References times_infinity().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return times_infinity (arg_1);
  }
static mmx_floating mmx::GLUE_39 ( const mmx_floating &  arg_1) [static]

Definition at line 201 of file glue_floating.cpp.

References ceil().

                                      {
    return ceil (arg_1);
  }
static interval<double> mmx::GLUE_39 ( const interval< double > &  arg_1) [static]

Definition at line 200 of file glue_interval_double.cpp.

References floor().

                                          {
    return floor (arg_1);
  }
static interval<mmx_floating> mmx::GLUE_39 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 203 of file glue_interval_floating.cpp.

References floor().

                                                {
    return floor (arg_1);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_39 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 204 of file glue_tangent_double.cpp.

References square().

                                                                     {
    return square (arg_1);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_39 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 205 of file glue_tangent_floating.cpp.

References square().

                                                                                 {
    return square (arg_1);
  }
static int mmx::GLUE_39 ( const complex< double > &  arg_1) [static]

Definition at line 203 of file glue_complex_double.cpp.

References precision().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return precision (arg_1);
  }
static int mmx::GLUE_39 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 204 of file glue_complex_floating.cpp.

References precision().

                                               {
    return precision (arg_1);
  }
static rational mmx::GLUE_4 ( const complex< rational > &  arg_1) [static]

Definition at line 24 of file glue_complex_rational.cpp.

References Re().

                                          {
    return Re (arg_1);
  }
static mmx_floating mmx::GLUE_4 ( const rational &  arg_1) [static]

Definition at line 26 of file glue_floating.cpp.

References mmx_floating.

                                 {
    return mmx_floating (arg_1);
  }
static int mmx::GLUE_4 ( const integer &  arg_1) [static]

Definition at line 23 of file glue_integer.cpp.

References as_int().

                                {
    return as_int (arg_1);
  }
static double mmx::GLUE_4 ( const interval< double > &  arg_1) [static]

Definition at line 25 of file glue_interval_double.cpp.

References lower().

                                         {
    return lower (arg_1);
  }
static mmx_floating mmx::GLUE_4 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 28 of file glue_interval_floating.cpp.

References lower().

                                               {
    return lower (arg_1);
  }
static int mmx::GLUE_4 ( const modulus< int > &  arg_1) [static]

Definition at line 27 of file glue_modular_int.cpp.

                                     {
    return *arg_1;
  }
static double mmx::GLUE_4 ( const tangent< double, double > &  arg_1) [static]

Definition at line 29 of file glue_tangent_double.cpp.

References base().

                                                {
    return base (arg_1);
  }
static mmx_floating mmx::GLUE_4 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 30 of file glue_tangent_floating.cpp.

References base().

                                                            {
    return base (arg_1);
  }
static rational mmx::GLUE_4 ( const tangent< rational, rational > &  arg_1) [static]

Definition at line 25 of file glue_tangent_rational.cpp.

References base().

                                                    {
    return base (arg_1);
  }
static double mmx::GLUE_4 ( const complex< double > &  arg_1) [static]

Definition at line 28 of file glue_complex_double.cpp.

References Re().

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                                        {
    return Re (arg_1);
  }
static mmx_floating mmx::GLUE_4 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 29 of file glue_complex_floating.cpp.

References Re().

                                              {
    return Re (arg_1);
  }
static generic mmx::GLUE_4 ( const complex< generic > &  arg_1) [static]

Definition at line 22 of file glue_complex_generic.cpp.

References Im().

                                         {
    return Im (arg_1);
  }
static generic mmx::GLUE_4 ( const tangent< generic, generic > &  arg_1) [static]

Definition at line 22 of file glue_tangent_generic.cpp.

References slope().

                                                  {
    return slope (arg_1);
  }
static mmx_floating mmx::GLUE_40 ( const mmx_floating &  arg_1) [static]

Definition at line 206 of file glue_floating.cpp.

References trunc().

                                      {
    return trunc (arg_1);
  }
static interval<double> mmx::GLUE_40 ( const interval< double > &  arg_1) [static]

Definition at line 205 of file glue_interval_double.cpp.

References ceil().

                                          {
    return ceil (arg_1);
  }
static interval<mmx_floating> mmx::GLUE_40 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 208 of file glue_interval_floating.cpp.

References ceil().

                                                {
    return ceil (arg_1);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_40 ( const tangent< complex< double >, complex< double > > &  arg_1,
const tangent< complex< double >, complex< double > > &  arg_2 
) [static]

Definition at line 209 of file glue_tangent_double.cpp.

                                                                                                                               {
    return arg_1 + arg_2;
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_40 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1,
const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 210 of file glue_tangent_floating.cpp.

                                                                                                                                                       {
    return arg_1 + arg_2;
  }
static int mmx::GLUE_40 ( const complex< double > &  arg_1) [static]

Definition at line 208 of file glue_complex_double.cpp.

References exponent().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return exponent (arg_1);
  }
static int mmx::GLUE_40 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 209 of file glue_complex_floating.cpp.

References exponent().

                                               {
    return exponent (arg_1);
  }
static mmx_floating mmx::GLUE_41 ( const mmx_floating &  arg_1) [static]

Definition at line 211 of file glue_floating.cpp.

References round().

                                      {
    return round (arg_1);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_41 ( const tangent< complex< double >, complex< double > > &  arg_1,
const tangent< complex< double >, complex< double > > &  arg_2 
) [static]

Definition at line 214 of file glue_tangent_double.cpp.

                                                                                                                               {
    return arg_1 - arg_2;
  }
static interval<double> mmx::GLUE_41 ( const interval< double > &  arg_1) [static]

Definition at line 210 of file glue_interval_double.cpp.

References trunc().

                                          {
    return trunc (arg_1);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_41 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1,
const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 215 of file glue_tangent_floating.cpp.

                                                                                                                                                       {
    return arg_1 - arg_2;
  }
static interval<mmx_floating> mmx::GLUE_41 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 213 of file glue_interval_floating.cpp.

References trunc().

                                                {
    return trunc (arg_1);
  }
static double mmx::GLUE_41 ( const complex< double > &  arg_1) [static]

Definition at line 213 of file glue_complex_double.cpp.

References magnitude().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return magnitude (arg_1);
  }
static double mmx::GLUE_41 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 214 of file glue_complex_floating.cpp.

References magnitude().

                                               {
    return magnitude (arg_1);
  }
static bool mmx::GLUE_42 ( const mmx_floating &  arg_1) [static]

Definition at line 216 of file glue_floating.cpp.

References is_finite().

                                      {
    return is_finite (arg_1);
  }
static complex<mmx_floating> mmx::GLUE_42 ( const complex< mmx_floating > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 219 of file glue_complex_floating.cpp.

                                                                 {
    return incexp2 (arg_1, arg_2);
  }
static interval<mmx_floating> mmx::GLUE_42 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 218 of file glue_interval_floating.cpp.

References round().

                                                {
    return round (arg_1);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_42 ( const tangent< complex< double >, complex< double > > &  arg_1,
const tangent< complex< double >, complex< double > > &  arg_2 
) [static]

Definition at line 219 of file glue_tangent_double.cpp.

                                                                                                                               {
    return arg_1 * arg_2;
  }
static interval<double> mmx::GLUE_42 ( const interval< double > &  arg_1) [static]

Definition at line 215 of file glue_interval_double.cpp.

References round().

                                          {
    return round (arg_1);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_42 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1,
const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 220 of file glue_tangent_floating.cpp.

                                                                                                                                                       {
    return arg_1 * arg_2;
  }
static complex<double> mmx::GLUE_42 ( const complex< double > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 218 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                                           {
    return incexp2 (arg_1, arg_2);
  }
static bool mmx::GLUE_43 ( const mmx_floating &  arg_1) [static]

Definition at line 221 of file glue_floating.cpp.

References is_infinite().

                                      {
    return is_infinite (arg_1);
  }
static bool mmx::GLUE_43 ( const interval< double > &  arg_1) [static]

Definition at line 220 of file glue_interval_double.cpp.

References is_finite().

                                          {
    return is_finite (arg_1);
  }
static bool mmx::GLUE_43 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 223 of file glue_interval_floating.cpp.

References is_finite().

                                                {
    return is_finite (arg_1);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_43 ( const tangent< complex< double >, complex< double > > &  arg_1,
const tangent< complex< double >, complex< double > > &  arg_2 
) [static]

Definition at line 224 of file glue_tangent_double.cpp.

                                                                                                                               {
    return arg_1 / arg_2;
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_43 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1,
const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 225 of file glue_tangent_floating.cpp.

                                                                                                                                                       {
    return arg_1 / arg_2;
  }
static complex<double> mmx::GLUE_43 ( const complex< double > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 223 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                                           {
    return decexp2 (arg_1, arg_2);
  }
static complex<mmx_floating> mmx::GLUE_43 ( const complex< mmx_floating > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 224 of file glue_complex_floating.cpp.

                                                                 {
    return decexp2 (arg_1, arg_2);
  }
static bool mmx::GLUE_44 ( const mmx_floating &  arg_1) [static]

Definition at line 226 of file glue_floating.cpp.

References is_nan().

                                      {
    return is_nan (arg_1);
  }
static double mmx::GLUE_44 ( const complex< double > &  arg_1) [static]

Definition at line 228 of file glue_complex_double.cpp.

References rounding_error().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return rounding_error (arg_1);
  }
static bool mmx::GLUE_44 ( const interval< double > &  arg_1) [static]

Definition at line 225 of file glue_interval_double.cpp.

References is_infinite().

                                          {
    return is_infinite (arg_1);
  }
static bool mmx::GLUE_44 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 228 of file glue_interval_floating.cpp.

References is_infinite().

                                                {
    return is_infinite (arg_1);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_44 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 229 of file glue_tangent_double.cpp.

References sqrt().

                                                                     {
    return sqrt (arg_1);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_44 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 230 of file glue_tangent_floating.cpp.

References sqrt().

                                                                                 {
    return sqrt (arg_1);
  }
static mmx_floating mmx::GLUE_44 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 229 of file glue_complex_floating.cpp.

References rounding_error().

                                               {
    return rounding_error (arg_1);
  }
static mmx_floating mmx::GLUE_45 ( const mmx_floating &  arg_1) [static]

Definition at line 231 of file glue_floating.cpp.

References times_infinity().

                                      {
    return times_infinity (arg_1);
  }
static bool mmx::GLUE_45 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 233 of file glue_interval_floating.cpp.

References is_nan().

                                                {
    return is_nan (arg_1);
  }
static bool mmx::GLUE_45 ( const interval< double > &  arg_1) [static]

Definition at line 230 of file glue_interval_double.cpp.

References is_nan().

                                          {
    return is_nan (arg_1);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_45 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 235 of file glue_tangent_floating.cpp.

References exp().

                                                                                 {
    return exp (arg_1);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_45 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 234 of file glue_tangent_double.cpp.

References exp().

                                                                     {
    return exp (arg_1);
  }
static double mmx::GLUE_45 ( const complex< double > &  arg_1) [static]

Definition at line 233 of file glue_complex_double.cpp.

References additive_error().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return additive_error (arg_1);
  }
static mmx_floating mmx::GLUE_45 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 234 of file glue_complex_floating.cpp.

References additive_error().

                                               {
    return additive_error (arg_1);
  }
static interval<mmx_floating> mmx::GLUE_46 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 238 of file glue_interval_floating.cpp.

References times_infinity().

                                                {
    return times_infinity (arg_1);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_46 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 239 of file glue_tangent_double.cpp.

References log().

                                                                     {
    return log (arg_1);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_46 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 240 of file glue_tangent_floating.cpp.

References log().

                                                                                 {
    return log (arg_1);
  }
static int mmx::GLUE_46 ( const mmx_floating &  arg_1) [static]

Definition at line 236 of file glue_floating.cpp.

References precision().

                                      {
    return precision (arg_1);
  }
static double mmx::GLUE_46 ( const complex< double > &  arg_1) [static]

Definition at line 238 of file glue_complex_double.cpp.

References multiplicative_error().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return multiplicative_error (arg_1);
  }
static mmx_floating mmx::GLUE_46 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 239 of file glue_complex_floating.cpp.

References multiplicative_error().

                                               {
    return multiplicative_error (arg_1);
  }
static interval<double> mmx::GLUE_46 ( const interval< double > &  arg_1) [static]

Definition at line 235 of file glue_interval_double.cpp.

References times_infinity().

                                          {
    return times_infinity (arg_1);
  }
static mmx_floating mmx::GLUE_47 ( const mmx_floating &  arg_1) [static]

Definition at line 241 of file glue_floating.cpp.

References next_above().

                                      {
    return next_above (arg_1);
  }
static int mmx::GLUE_47 ( const interval< double > &  arg_1) [static]

Definition at line 240 of file glue_interval_double.cpp.

References precision().

                                          {
    return precision (arg_1);
  }
static int mmx::GLUE_47 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 243 of file glue_interval_floating.cpp.

References precision().

                                                {
    return precision (arg_1);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_47 ( const tangent< complex< double >, complex< double > > &  arg_1,
const tangent< complex< double >, complex< double > > &  arg_2 
) [static]

Definition at line 244 of file glue_tangent_double.cpp.

References pow().

                                                                                                                               {
    return pow (arg_1, arg_2);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_47 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1,
const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_2 
) [static]

Definition at line 245 of file glue_tangent_floating.cpp.

References pow().

                                                                                                                                                       {
    return pow (arg_1, arg_2);
  }
static double mmx::GLUE_47 ( const complex< double > &  arg_1) [static]

Definition at line 243 of file glue_complex_double.cpp.

References elementary_error().

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return elementary_error (arg_1);
  }
static mmx_floating mmx::GLUE_47 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 244 of file glue_complex_floating.cpp.

References elementary_error().

                                               {
    return elementary_error (arg_1);
  }
static mmx_floating mmx::GLUE_48 ( const mmx_floating &  arg_1) [static]

Definition at line 246 of file glue_floating.cpp.

References next_below().

                                      {
    return next_below (arg_1);
  }
static int mmx::GLUE_48 ( const interval< double > &  arg_1) [static]

Definition at line 245 of file glue_interval_double.cpp.

References exponent().

                                          {
    return exponent (arg_1);
  }
static int mmx::GLUE_48 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 248 of file glue_interval_floating.cpp.

References exponent().

                                                {
    return exponent (arg_1);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_48 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 249 of file glue_tangent_double.cpp.

References cos().

                                                                     {
    return cos (arg_1);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_48 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 250 of file glue_tangent_floating.cpp.

References cos().

                                                                                 {
    return cos (arg_1);
  }
static complex<generic> mmx::GLUE_48 ( const complex< double > &  arg_1) [static]

Definition at line 248 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                         {
    return as<complex<generic> > (arg_1);
  }
static complex<mmx_floating> mmx::GLUE_48 ( const complex< rational > &  arg_1) [static]

Definition at line 249 of file glue_complex_floating.cpp.

                                           {
    return as<complex<mmx_floating> > (arg_1);
  }
static int mmx::GLUE_49 ( const mmx_floating &  arg_1) [static]

Definition at line 251 of file glue_floating.cpp.

References exponent().

                                      {
    return exponent (arg_1);
  }
static double mmx::GLUE_49 ( const interval< double > &  arg_1) [static]

Definition at line 250 of file glue_interval_double.cpp.

References magnitude().

                                          {
    return magnitude (arg_1);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_49 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 255 of file glue_tangent_floating.cpp.

References sin().

                                                                                 {
    return sin (arg_1);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_49 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 254 of file glue_tangent_double.cpp.

References sin().

                                                                     {
    return sin (arg_1);
  }
static double mmx::GLUE_49 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 253 of file glue_interval_floating.cpp.

References magnitude().

                                                {
    return magnitude (arg_1);
  }
static complex<double> mmx::GLUE_49 ( const complex< rational > &  arg_1) [static]

Definition at line 253 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_floating(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                           {
    return as<complex<double> > (arg_1);
  }
static complex<generic> mmx::GLUE_49 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 254 of file glue_complex_floating.cpp.

                                               {
    return as<complex<generic> > (arg_1);
  }
static rational mmx::GLUE_5 ( const complex< rational > &  arg_1) [static]

Definition at line 29 of file glue_complex_rational.cpp.

References Im().

                                          {
    return Im (arg_1);
  }
static mmx_floating mmx::GLUE_5 ( const int &  arg_1) [static]

Definition at line 31 of file glue_floating.cpp.

References mmx_floating.

                            {
    return mmx_floating (arg_1);
  }
static double mmx::GLUE_5 ( const interval< double > &  arg_1) [static]

Definition at line 30 of file glue_interval_double.cpp.

References upper().

                                         {
    return upper (arg_1);
  }
static mmx_floating mmx::GLUE_5 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 33 of file glue_interval_floating.cpp.

References upper().

                                               {
    return upper (arg_1);
  }
static rational mmx::GLUE_5 ( const integer &  arg_1,
const integer &  arg_2 
) [static]

Definition at line 28 of file glue_rational.cpp.

References rational_new.

                                                      {
    return rational_new (arg_1, arg_2);
  }
static double mmx::GLUE_5 ( const tangent< double, double > &  arg_1) [static]

Definition at line 34 of file glue_tangent_double.cpp.

References slope().

                                                {
    return slope (arg_1);
  }
static mmx_floating mmx::GLUE_5 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 35 of file glue_tangent_floating.cpp.

References slope().

                                                            {
    return slope (arg_1);
  }
static rational mmx::GLUE_5 ( const tangent< rational, rational > &  arg_1) [static]

Definition at line 30 of file glue_tangent_rational.cpp.

References slope().

                                                    {
    return slope (arg_1);
  }
static tangent<generic, generic> mmx::GLUE_5 ( const tangent< generic, generic > &  arg_1) [static]

Definition at line 27 of file glue_tangent_generic.cpp.

                                                  {
    return -arg_1;
  }
static double mmx::GLUE_5 ( const complex< double > &  arg_1) [static]

Definition at line 33 of file glue_complex_double.cpp.

References Im().

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                                        {
    return Im (arg_1);
  }
static mmx_floating mmx::GLUE_5 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 34 of file glue_complex_floating.cpp.

References Im().

                                              {
    return Im (arg_1);
  }
static complex<generic> mmx::GLUE_5 ( const complex< generic > &  arg_1) [static]

Definition at line 27 of file glue_complex_generic.cpp.

References conj().

                                         {
    return conj (arg_1);
  }
static interval<mmx_floating> mmx::GLUE_50 ( const interval< mmx_floating > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 258 of file glue_interval_floating.cpp.

                                                                  {
    return incexp2 (arg_1, arg_2);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_50 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 259 of file glue_tangent_double.cpp.

References tan().

                                                                     {
    return tan (arg_1);
  }
static double mmx::GLUE_50 ( const mmx_floating &  arg_1) [static]

Definition at line 256 of file glue_floating.cpp.

References magnitude().

Referenced by glue_floating(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                      {
    return magnitude (arg_1);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_50 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 260 of file glue_tangent_floating.cpp.

References tan().

                                                                                 {
    return tan (arg_1);
  }
static interval<double> mmx::GLUE_50 ( const interval< double > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 255 of file glue_interval_double.cpp.

                                                            {
    return incexp2 (arg_1, arg_2);
  }
static mmx_floating mmx::GLUE_51 ( const mmx_floating &  arg_1,
const int &  arg_2 
) [static]

Definition at line 261 of file glue_floating.cpp.

Referenced by glue_floating(), glue_interval_double(), glue_interval_floating(), glue_tangent_double(), and glue_tangent_floating().

                                                        {
    return incexp2 (arg_1, arg_2);
  }
static interval<double> mmx::GLUE_51 ( const interval< double > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 260 of file glue_interval_double.cpp.

                                                            {
    return decexp2 (arg_1, arg_2);
  }
static interval<mmx_floating> mmx::GLUE_51 ( const interval< mmx_floating > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 263 of file glue_interval_floating.cpp.

                                                                  {
    return decexp2 (arg_1, arg_2);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_51 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 264 of file glue_tangent_double.cpp.

References acos().

                                                                     {
    return acos (arg_1);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_51 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 265 of file glue_tangent_floating.cpp.

References acos().

                                                                                 {
    return acos (arg_1);
  }
static mmx_floating mmx::GLUE_52 ( const mmx_floating &  arg_1,
const int &  arg_2 
) [static]

Definition at line 266 of file glue_floating.cpp.

Referenced by glue_floating(), glue_tangent_double(), and glue_tangent_floating().

                                                        {
    return decexp2 (arg_1, arg_2);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_52 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 269 of file glue_tangent_double.cpp.

References asin().

                                                                     {
    return asin (arg_1);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_52 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 270 of file glue_tangent_floating.cpp.

References asin().

                                                                                 {
    return asin (arg_1);
  }
static mmx_floating mmx::GLUE_53 ( const mmx_floating &  arg_1) [static]

Definition at line 271 of file glue_floating.cpp.

References rounding_error().

Referenced by glue_floating(), glue_tangent_double(), and glue_tangent_floating().

                                      {
    return rounding_error (arg_1);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_53 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 275 of file glue_tangent_floating.cpp.

References atan().

                                                                                 {
    return atan (arg_1);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_53 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 274 of file glue_tangent_double.cpp.

References atan().

                                                                     {
    return atan (arg_1);
  }
static mmx_floating mmx::GLUE_54 ( const mmx_floating &  arg_1) [static]

Definition at line 276 of file glue_floating.cpp.

References additive_error().

Referenced by glue_floating(), glue_tangent_double(), and glue_tangent_floating().

                                      {
    return additive_error (arg_1);
  }
static bool mmx::GLUE_54 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 279 of file glue_tangent_double.cpp.

References is_finite().

                                                                     {
    return is_finite (arg_1);
  }
static bool mmx::GLUE_54 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 280 of file glue_tangent_floating.cpp.

References is_finite().

                                                                                 {
    return is_finite (arg_1);
  }
static mmx_floating mmx::GLUE_55 ( const mmx_floating &  arg_1) [static]

Definition at line 281 of file glue_floating.cpp.

References multiplicative_error().

Referenced by glue_floating(), glue_tangent_double(), and glue_tangent_floating().

                                      {
    return multiplicative_error (arg_1);
  }
static bool mmx::GLUE_55 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 284 of file glue_tangent_double.cpp.

References is_infinite().

                                                                     {
    return is_infinite (arg_1);
  }
static bool mmx::GLUE_55 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 285 of file glue_tangent_floating.cpp.

References is_infinite().

                                                                                 {
    return is_infinite (arg_1);
  }
static mmx_floating mmx::GLUE_56 ( const mmx_floating &  arg_1) [static]

Definition at line 286 of file glue_floating.cpp.

References elementary_error().

Referenced by glue_floating(), glue_tangent_double(), and glue_tangent_floating().

                                      {
    return elementary_error (arg_1);
  }
static bool mmx::GLUE_56 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 289 of file glue_tangent_double.cpp.

References is_nan().

                                                                     {
    return is_nan (arg_1);
  }
static bool mmx::GLUE_56 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 290 of file glue_tangent_floating.cpp.

References is_nan().

                                                                                 {
    return is_nan (arg_1);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_57 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 295 of file glue_tangent_floating.cpp.

References times_infinity().

                                                                                 {
    return times_infinity (arg_1);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_57 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 294 of file glue_tangent_double.cpp.

References times_infinity().

Referenced by glue_tangent_double(), and glue_tangent_floating().

                                                                     {
    return times_infinity (arg_1);
  }
static int mmx::GLUE_58 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 300 of file glue_tangent_floating.cpp.

References precision().

                                                                                 {
    return precision (arg_1);
  }
static int mmx::GLUE_58 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 299 of file glue_tangent_double.cpp.

References precision().

Referenced by glue_tangent_double(), and glue_tangent_floating().

                                                                     {
    return precision (arg_1);
  }
static int mmx::GLUE_59 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 304 of file glue_tangent_double.cpp.

References exponent().

Referenced by glue_tangent_double(), and glue_tangent_floating().

                                                                     {
    return exponent (arg_1);
  }
static int mmx::GLUE_59 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 305 of file glue_tangent_floating.cpp.

References exponent().

                                                                                 {
    return exponent (arg_1);
  }
static complex<rational> mmx::GLUE_6 ( const complex< rational > &  arg_1) [static]

Definition at line 34 of file glue_complex_rational.cpp.

References conj().

                                          {
    return conj (arg_1);
  }
static integer mmx::GLUE_6 ( const string &  arg_1) [static]

Definition at line 33 of file glue_integer.cpp.

                               {
    return integer (arg_1);
  }
static mmx_floating mmx::GLUE_6 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 38 of file glue_interval_floating.cpp.

References center().

                                               {
    return center (arg_1);
  }
static tangent<double, double> mmx::GLUE_6 ( const tangent< double, double > &  arg_1) [static]

Definition at line 39 of file glue_tangent_double.cpp.

                                                {
    return -arg_1;
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_6 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 40 of file glue_tangent_floating.cpp.

                                                            {
    return -arg_1;
  }
static tangent<rational, rational> mmx::GLUE_6 ( const tangent< rational, rational > &  arg_1) [static]

Definition at line 35 of file glue_tangent_rational.cpp.

                                                    {
    return -arg_1;
  }
static tangent<generic, generic> mmx::GLUE_6 ( const tangent< generic, generic > &  arg_1) [static]

Definition at line 32 of file glue_tangent_generic.cpp.

References square().

                                                  {
    return square (arg_1);
  }
static complex<double> mmx::GLUE_6 ( const complex< double > &  arg_1) [static]

Definition at line 38 of file glue_complex_double.cpp.

References conj().

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                                        {
    return conj (arg_1);
  }
static integer mmx::GLUE_6 ( const rational &  arg_1) [static]

Definition at line 33 of file glue_rational.cpp.

                                 {
    return numerator (arg_1);
  }
static double mmx::GLUE_6 ( const interval< double > &  arg_1) [static]

Definition at line 35 of file glue_interval_double.cpp.

References center().

                                         {
    return center (arg_1);
  }
static complex<mmx_floating> mmx::GLUE_6 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 39 of file glue_complex_floating.cpp.

References conj().

                                              {
    return conj (arg_1);
  }
static mmx_floating mmx::GLUE_6 ( const double &  arg_1) [static]

Definition at line 36 of file glue_floating.cpp.

References mmx_floating.

                               {
    return mmx_floating (arg_1);
  }
static complex<generic> mmx::GLUE_6 ( const complex< generic > &  arg_1) [static]

Definition at line 32 of file glue_complex_generic.cpp.

References times_i().

                                         {
    return times_i (arg_1);
  }
static double mmx::GLUE_60 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 309 of file glue_tangent_double.cpp.

References magnitude().

Referenced by glue_tangent_double(), and glue_tangent_floating().

                                                                     {
    return magnitude (arg_1);
  }
static double mmx::GLUE_60 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 310 of file glue_tangent_floating.cpp.

References magnitude().

                                                                                 {
    return magnitude (arg_1);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_61 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 315 of file glue_tangent_floating.cpp.

                                                                                                   {
    return incexp2 (arg_1, arg_2);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_61 ( const tangent< complex< double >, complex< double > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 314 of file glue_tangent_double.cpp.

Referenced by glue_tangent_double(), and glue_tangent_floating().

                                                                                       {
    return incexp2 (arg_1, arg_2);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_62 ( const tangent< complex< double >, complex< double > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 319 of file glue_tangent_double.cpp.

Referenced by glue_tangent_double(), and glue_tangent_floating().

                                                                                       {
    return decexp2 (arg_1, arg_2);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_62 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1,
const int &  arg_2 
) [static]

Definition at line 320 of file glue_tangent_floating.cpp.

                                                                                                   {
    return decexp2 (arg_1, arg_2);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_63 ( const tangent< double, double > &  arg_1) [static]

Definition at line 324 of file glue_tangent_double.cpp.

Referenced by glue_tangent_double(), and glue_tangent_floating().

                                                 {
    return as<tangent<complex<double> , complex<double> > > (arg_1);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_63 ( const tangent< rational, rational > &  arg_1) [static]

Definition at line 325 of file glue_tangent_floating.cpp.

                                                     {
    return as<tangent<complex<mmx_floating> , complex<mmx_floating> > > (arg_1);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_64 ( const tangent< complex< rational >, complex< rational > > &  arg_1) [static]

Definition at line 330 of file glue_tangent_floating.cpp.

                                                                         {
    return as<tangent<complex<mmx_floating> , complex<mmx_floating> > > (arg_1);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_64 ( const tangent< rational, rational > &  arg_1) [static]

Definition at line 329 of file glue_tangent_double.cpp.

Referenced by glue_tangent_double(), and glue_tangent_floating().

                                                     {
    return as<tangent<complex<double> , complex<double> > > (arg_1);
  }
static tangent<complex<mmx_floating> , complex<mmx_floating> > mmx::GLUE_65 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 335 of file glue_tangent_floating.cpp.

                                                             {
    return as<tangent<complex<mmx_floating> , complex<mmx_floating> > > (arg_1);
  }
static tangent<complex<double> , complex<double> > mmx::GLUE_65 ( const tangent< complex< rational >, complex< rational > > &  arg_1) [static]

Definition at line 334 of file glue_tangent_double.cpp.

Referenced by glue_tangent_double(), and glue_tangent_floating().

                                                                         {
    return as<tangent<complex<double> , complex<double> > > (arg_1);
  }
static tangent<generic, generic> mmx::GLUE_66 ( const tangent< complex< mmx_floating >, complex< mmx_floating > > &  arg_1) [static]

Definition at line 340 of file glue_tangent_floating.cpp.

                                                                                 {
    return as<tangent<generic, generic> > (arg_1);
  }
static tangent<generic, generic> mmx::GLUE_66 ( const tangent< complex< double >, complex< double > > &  arg_1) [static]

Definition at line 339 of file glue_tangent_double.cpp.

Referenced by glue_tangent_double(), and glue_tangent_floating().

                                                                     {
    return as<tangent<generic, generic> > (arg_1);
  }
static complex<rational> mmx::GLUE_7 ( const complex< rational > &  arg_1) [static]

Definition at line 39 of file glue_complex_rational.cpp.

References times_i().

                                          {
    return times_i (arg_1);
  }
static mmx_floating mmx::GLUE_7 ( const integer &  arg_1) [static]

Definition at line 41 of file glue_floating.cpp.

References mmx_floating.

                                {
    return mmx_floating (arg_1);
  }
static double mmx::GLUE_7 ( const interval< double > &  arg_1) [static]

Definition at line 40 of file glue_interval_double.cpp.

References radius().

                                         {
    return radius (arg_1);
  }
static mmx_floating mmx::GLUE_7 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 43 of file glue_interval_floating.cpp.

References radius().

                                               {
    return radius (arg_1);
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_7 ( const tangent< mmx_floating, mmx_floating > &  arg_1) [static]

Definition at line 45 of file glue_tangent_floating.cpp.

References square().

                                                            {
    return square (arg_1);
  }
static tangent<generic, generic> mmx::GLUE_7 ( const tangent< generic, generic > &  arg_1,
const tangent< generic, generic > &  arg_2 
) [static]

Definition at line 37 of file glue_tangent_generic.cpp.

                                                                                          {
    return arg_1 + arg_2;
  }
static integer mmx::GLUE_7 ( const rational &  arg_1) [static]

Definition at line 38 of file glue_rational.cpp.

                                 {
    return denominator (arg_1);
  }
static tangent<double, double> mmx::GLUE_7 ( const tangent< double, double > &  arg_1) [static]

Definition at line 44 of file glue_tangent_double.cpp.

References square().

                                                {
    return square (arg_1);
  }
static tangent<rational, rational> mmx::GLUE_7 ( const tangent< rational, rational > &  arg_1) [static]

Definition at line 40 of file glue_tangent_rational.cpp.

References square().

                                                    {
    return square (arg_1);
  }
static complex<double> mmx::GLUE_7 ( const complex< double > &  arg_1) [static]

Definition at line 43 of file glue_complex_double.cpp.

References times_i().

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                                        {
    return times_i (arg_1);
  }
static complex<mmx_floating> mmx::GLUE_7 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 44 of file glue_complex_floating.cpp.

References times_i().

                                              {
    return times_i (arg_1);
  }
static complex<generic> mmx::GLUE_7 ( const complex< generic > &  arg_1) [static]

Definition at line 37 of file glue_complex_generic.cpp.

References over_i().

                                         {
    return over_i (arg_1);
  }
static complex<rational> mmx::GLUE_8 ( const complex< rational > &  arg_1) [static]

Definition at line 44 of file glue_complex_rational.cpp.

References over_i().

                                          {
    return over_i (arg_1);
  }
static mmx_floating mmx::GLUE_8 ( const rational &  arg_1) [static]

Definition at line 46 of file glue_floating.cpp.

References mmx_floating.

                                 {
    return mmx_floating (arg_1);
  }
static integer mmx::GLUE_8 ( const integer &  arg_1) [static]

Definition at line 43 of file glue_integer.cpp.

                                {
    return -arg_1;
  }
static interval<double> mmx::GLUE_8 ( const interval< double > &  arg_1) [static]

Definition at line 45 of file glue_interval_double.cpp.

                                         {
    return -arg_1;
  }
static interval<mmx_floating> mmx::GLUE_8 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 48 of file glue_interval_floating.cpp.

                                               {
    return -arg_1;
  }
static tangent<double, double> mmx::GLUE_8 ( const tangent< double, double > &  arg_1,
const tangent< double, double > &  arg_2 
) [static]

Definition at line 49 of file glue_tangent_double.cpp.

                                                                                      {
    return arg_1 + arg_2;
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_8 ( const tangent< mmx_floating, mmx_floating > &  arg_1,
const tangent< mmx_floating, mmx_floating > &  arg_2 
) [static]

Definition at line 50 of file glue_tangent_floating.cpp.

                                                                                                              {
    return arg_1 + arg_2;
  }
static complex<double> mmx::GLUE_8 ( const complex< double > &  arg_1) [static]

Definition at line 48 of file glue_complex_double.cpp.

References over_i().

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                                        {
    return over_i (arg_1);
  }
static tangent<generic, generic> mmx::GLUE_8 ( const tangent< generic, generic > &  arg_1,
const tangent< generic, generic > &  arg_2 
) [static]

Definition at line 42 of file glue_tangent_generic.cpp.

                                                                                          {
    return arg_1 - arg_2;
  }
static tangent<rational, rational> mmx::GLUE_8 ( const tangent< rational, rational > &  arg_1,
const tangent< rational, rational > &  arg_2 
) [static]

Definition at line 45 of file glue_tangent_rational.cpp.

                                                                                              {
    return arg_1 + arg_2;
  }
static complex<mmx_floating> mmx::GLUE_8 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 49 of file glue_complex_floating.cpp.

References over_i().

                                              {
    return over_i (arg_1);
  }
static complex<generic> mmx::GLUE_8 ( const complex< generic > &  arg_1) [static]

Definition at line 42 of file glue_complex_generic.cpp.

                                         {
    return -arg_1;
  }
static complex<rational> mmx::GLUE_9 ( const complex< rational > &  arg_1) [static]

Definition at line 49 of file glue_complex_rational.cpp.

                                          {
    return -arg_1;
  }
static integer mmx::GLUE_9 ( const integer &  arg_1) [static]

Definition at line 48 of file glue_integer.cpp.

References square().

                                {
    return square (arg_1);
  }
static mmx_floating mmx::GLUE_9 ( const string &  arg_1) [static]

Definition at line 51 of file glue_floating.cpp.

References mmx_floating.

                               {
    return mmx_floating (arg_1);
  }
static interval<double> mmx::GLUE_9 ( const interval< double > &  arg_1) [static]

Definition at line 50 of file glue_interval_double.cpp.

References square().

                                         {
    return square (arg_1);
  }
static rational mmx::GLUE_9 ( const rational &  arg_1) [static]

Definition at line 48 of file glue_rational.cpp.

References square().

                                 {
    return square (arg_1);
  }
static tangent<double, double> mmx::GLUE_9 ( const tangent< double, double > &  arg_1,
const tangent< double, double > &  arg_2 
) [static]

Definition at line 54 of file glue_tangent_double.cpp.

                                                                                      {
    return arg_1 - arg_2;
  }
static tangent<mmx_floating, mmx_floating> mmx::GLUE_9 ( const tangent< mmx_floating, mmx_floating > &  arg_1,
const tangent< mmx_floating, mmx_floating > &  arg_2 
) [static]

Definition at line 55 of file glue_tangent_floating.cpp.

                                                                                                              {
    return arg_1 - arg_2;
  }
static tangent<rational, rational> mmx::GLUE_9 ( const tangent< rational, rational > &  arg_1,
const tangent< rational, rational > &  arg_2 
) [static]

Definition at line 50 of file glue_tangent_rational.cpp.

                                                                                              {
    return arg_1 - arg_2;
  }
static interval<mmx_floating> mmx::GLUE_9 ( const interval< mmx_floating > &  arg_1) [static]

Definition at line 53 of file glue_interval_floating.cpp.

References square().

                                               {
    return square (arg_1);
  }
static tangent<generic, generic> mmx::GLUE_9 ( const tangent< generic, generic > &  arg_1,
const tangent< generic, generic > &  arg_2 
) [static]

Definition at line 47 of file glue_tangent_generic.cpp.

                                                                                          {
    return arg_1 * arg_2;
  }
static complex<double> mmx::GLUE_9 ( const complex< double > &  arg_1) [static]

Definition at line 53 of file glue_complex_double.cpp.

Referenced by glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                                        {
    return -arg_1;
  }
static complex<mmx_floating> mmx::GLUE_9 ( const complex< mmx_floating > &  arg_1) [static]

Definition at line 54 of file glue_complex_floating.cpp.

                                              {
    return -arg_1;
  }
static complex<generic> mmx::GLUE_9 ( const complex< generic > &  arg_1) [static]

Definition at line 47 of file glue_complex_generic.cpp.

References square().

                                         {
    return square (arg_1);
  }
void glue_affine_generic ( )

Definition at line 7 of file glue_affine_generic.cpp.

Referenced by glue_numerix().

                         {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_generic"));
  }
void mmx::glue_ball_double ( )

Referenced by glue_numerix().

void mmx::glue_ball_floating ( )

Referenced by glue_numerix().

void glue_complex_double ( )

Definition at line 258 of file glue_complex_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_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_26(), GLUE_27(), GLUE_28(), GLUE_29(), GLUE_3(), GLUE_30(), GLUE_31(), GLUE_32(), GLUE_33(), GLUE_34(), GLUE_35(), GLUE_36(), GLUE_37(), GLUE_38(), GLUE_39(), GLUE_4(), GLUE_40(), GLUE_41(), GLUE_42(), GLUE_43(), GLUE_44(), GLUE_45(), GLUE_46(), GLUE_47(), GLUE_48(), GLUE_49(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_numerix().

                         {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_double"));
    call_glue (string ("glue_complex_rational"));
    define_type<complex<double> > (gen (lit ("Complex"), lit ("Double")));
    define ("complex", GLUE_1);
    define ("complex", GLUE_2);
    define_converter ("upgrade", GLUE_3, PENALTY_HOMOMORPHISM);
    define ("Re", GLUE_4);
    define ("Im", GLUE_5);
    define ("conj", GLUE_6);
    define ("times_i", GLUE_7);
    define ("over_i", GLUE_8);
    define ("-", GLUE_9);
    define ("square", GLUE_10);
    define ("+", GLUE_11);
    define ("-", GLUE_12);
    define ("*", GLUE_13);
    define ("+", GLUE_14);
    define ("+", GLUE_15);
    define ("-", GLUE_16);
    define ("-", GLUE_17);
    define ("*", GLUE_18);
    define ("*", GLUE_19);
    define ("/", GLUE_20);
    define ("/", GLUE_21);
    define ("/", GLUE_22);
    define ("abs", GLUE_23);
    define ("arg", GLUE_24);
    define ("sqrt", GLUE_25);
    define ("exp", GLUE_26);
    define ("log", GLUE_27);
    define ("^", GLUE_28);
    define ("cos", GLUE_29);
    define ("sin", GLUE_30);
    define ("tan", GLUE_31);
    define ("arccos", GLUE_32);
    define ("arcsin", GLUE_33);
    define ("arctan", GLUE_34);
    define ("finite?", GLUE_35);
    define ("infinite?", GLUE_36);
    define ("nan?", GLUE_37);
    define ("times_infinity", GLUE_38);
    define ("precision", GLUE_39);
    define ("exponent", GLUE_40);
    define ("magnitude", GLUE_41);
    define ("increase_exponent", GLUE_42);
    define ("decrease_exponent", GLUE_43);
    define ("rounding_error", GLUE_44);
    define ("additive_error", GLUE_45);
    define ("multiplicative_error", GLUE_46);
    define ("elementary_error", GLUE_47);
    define_converter (":>", GLUE_48, PENALTY_PROMOTE_GENERIC);
    define_converter (":>", GLUE_49, PENALTY_INCLUSION);
  }
void glue_complex_floating ( )

Definition at line 259 of file glue_complex_floating.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_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_26(), GLUE_27(), GLUE_28(), GLUE_29(), GLUE_3(), GLUE_30(), GLUE_31(), GLUE_32(), GLUE_33(), GLUE_34(), GLUE_35(), GLUE_36(), GLUE_37(), GLUE_38(), GLUE_39(), GLUE_4(), GLUE_40(), GLUE_41(), GLUE_42(), GLUE_43(), GLUE_44(), GLUE_45(), GLUE_46(), GLUE_47(), GLUE_48(), GLUE_49(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_numerix().

                           {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_floating"));
    call_glue (string ("glue_complex_double"));
    define_type<complex<mmx_floating> > (gen (lit ("Complex"), lit ("Floating")));
    define ("complex", GLUE_1);
    define ("complex", GLUE_2);
    define_converter ("upgrade", GLUE_3, PENALTY_HOMOMORPHISM);
    define ("Re", GLUE_4);
    define ("Im", GLUE_5);
    define ("conj", GLUE_6);
    define ("times_i", GLUE_7);
    define ("over_i", GLUE_8);
    define ("-", GLUE_9);
    define ("square", GLUE_10);
    define ("+", GLUE_11);
    define ("-", GLUE_12);
    define ("*", GLUE_13);
    define ("+", GLUE_14);
    define ("+", GLUE_15);
    define ("-", GLUE_16);
    define ("-", GLUE_17);
    define ("*", GLUE_18);
    define ("*", GLUE_19);
    define ("/", GLUE_20);
    define ("/", GLUE_21);
    define ("/", GLUE_22);
    define ("abs", GLUE_23);
    define ("arg", GLUE_24);
    define ("sqrt", GLUE_25);
    define ("exp", GLUE_26);
    define ("log", GLUE_27);
    define ("^", GLUE_28);
    define ("cos", GLUE_29);
    define ("sin", GLUE_30);
    define ("tan", GLUE_31);
    define ("arccos", GLUE_32);
    define ("arcsin", GLUE_33);
    define ("arctan", GLUE_34);
    define ("finite?", GLUE_35);
    define ("infinite?", GLUE_36);
    define ("nan?", GLUE_37);
    define ("times_infinity", GLUE_38);
    define ("precision", GLUE_39);
    define ("exponent", GLUE_40);
    define ("magnitude", GLUE_41);
    define ("increase_exponent", GLUE_42);
    define ("decrease_exponent", GLUE_43);
    define ("rounding_error", GLUE_44);
    define ("additive_error", GLUE_45);
    define ("multiplicative_error", GLUE_46);
    define ("elementary_error", GLUE_47);
    define_converter (":>", GLUE_48, PENALTY_INCLUSION);
    define_converter (":>", GLUE_49, PENALTY_PROMOTE_GENERIC);
  }
void glue_complex_generic ( )

Definition at line 132 of file glue_complex_generic.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_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_numerix().

                          {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_generic"));
    define_type<complex<generic> > (gen (lit ("Complex"), lit ("Generic")));
    define ("complex", GLUE_1);
    define ("complex", GLUE_2);
    define ("Re", GLUE_3);
    define ("Im", GLUE_4);
    define ("conj", GLUE_5);
    define ("times_i", GLUE_6);
    define ("over_i", GLUE_7);
    define ("-", GLUE_8);
    define ("square", GLUE_9);
    define ("+", GLUE_10);
    define ("-", GLUE_11);
    define ("*", GLUE_12);
    define ("/", GLUE_13);
    define ("abs", GLUE_14);
    define ("arg", GLUE_15);
    define ("sqrt", GLUE_16);
    define ("exp", GLUE_17);
    define ("log", GLUE_18);
    define ("^", GLUE_19);
    define ("cos", GLUE_20);
    define ("sin", GLUE_21);
    define ("tan", GLUE_22);
    define ("arccos", GLUE_23);
    define ("arcsin", GLUE_24);
    define ("arctan", GLUE_25);
  }
void glue_complex_rational ( )

Definition at line 124 of file glue_complex_rational.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_22(), GLUE_23(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_numerix().

                           {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_rational"));
    call_glue (string ("glue_complex_generic"));
    define_type<complex<rational> > (gen (lit ("Complex"), lit ("Rational")));
    define ("complex", GLUE_1);
    define ("complex", GLUE_2);
    define_converter ("upgrade", GLUE_3, PENALTY_HOMOMORPHISM);
    define ("Re", GLUE_4);
    define ("Im", GLUE_5);
    define ("conj", GLUE_6);
    define ("times_i", GLUE_7);
    define ("over_i", GLUE_8);
    define ("-", GLUE_9);
    define ("square", GLUE_10);
    define ("+", GLUE_11);
    define ("-", GLUE_12);
    define ("*", GLUE_13);
    define ("+", GLUE_14);
    define ("+", GLUE_15);
    define ("-", GLUE_16);
    define ("-", GLUE_17);
    define ("*", GLUE_18);
    define ("*", GLUE_19);
    define ("/", GLUE_20);
    define ("/", GLUE_21);
    define ("/", GLUE_22);
    define_converter (":>", GLUE_23, PENALTY_PROMOTE_GENERIC);
  }
void glue_floating ( )

Definition at line 291 of file glue_floating.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_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_26(), GLUE_27(), GLUE_28(), GLUE_29(), GLUE_3(), GLUE_30(), GLUE_31(), GLUE_32(), GLUE_33(), GLUE_34(), GLUE_35(), GLUE_36(), GLUE_37(), GLUE_38(), GLUE_39(), GLUE_4(), GLUE_40(), GLUE_41(), GLUE_42(), GLUE_43(), GLUE_44(), GLUE_45(), GLUE_46(), GLUE_47(), GLUE_48(), GLUE_49(), GLUE_5(), GLUE_50(), GLUE_51(), GLUE_52(), GLUE_53(), GLUE_54(), GLUE_55(), GLUE_56(), GLUE_6(), GLUE_7(), GLUE_8(), GLUE_9(), mmx_bit_precision, mmx_discrepancy, mmx_pretty_exponents, and mmx_significant_digits.

Referenced by glue_numerix().

                   {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_rational"));
    static alias<int> mmx_significant_digits_alias = global_alias (((int&) mmx_significant_digits));
    define_constant<alias<int> > ("significant_digits", mmx_significant_digits_alias);
    static alias<int> mmx_bit_precision_alias = global_alias (((int&) mmx_bit_precision));
    define_constant<alias<int> > ("bit_precision", mmx_bit_precision_alias);
    static alias<int> mmx_discrepancy_alias = global_alias (((int&) mmx_discrepancy));
    define_constant<alias<int> > ("discrepancy", mmx_discrepancy_alias);
    static alias<bool> mmx_pretty_exponents_alias = global_alias (((bool&) mmx_pretty_exponents));
    define_constant<alias<bool> > ("pretty_exponents", mmx_pretty_exponents_alias);
    define_type<mmx_floating > (lit ("Floating"));
    define ("literal_floating", GLUE_1);
    define_converter ("upgrade", GLUE_2, PENALTY_INCLUSION);
    define_converter ("upgrade", GLUE_3, PENALTY_INCLUSION);
    define_converter ("upgrade", GLUE_4, PENALTY_INCLUSION);
    define ("as_floating", GLUE_5);
    define ("as_floating", GLUE_6);
    define ("as_floating", GLUE_7);
    define ("as_floating", GLUE_8);
    define ("as_floating", GLUE_9);
    define ("as_int", GLUE_10);
    define ("as_double", GLUE_11);
    define ("as_integer", GLUE_12);
    define ("as_string", GLUE_13);
    define ("uniform_deviate", GLUE_14);
    define ("-", GLUE_15);
    define ("square", GLUE_16);
    define ("+", GLUE_17);
    define ("-", GLUE_18);
    define ("*", GLUE_19);
    define ("/", GLUE_20);
    define ("sqrt", GLUE_21);
    define ("^", GLUE_22);
    define ("exp", GLUE_23);
    define ("log", GLUE_24);
    define ("cos", GLUE_25);
    define ("sin", GLUE_26);
    define ("tan", GLUE_27);
    define ("arccos", GLUE_28);
    define ("arcsin", GLUE_29);
    define ("arctan", GLUE_30);
    define ("<", GLUE_31);
    define ("<=", GLUE_32);
    define (">", GLUE_33);
    define (">=", GLUE_34);
    define ("abs", GLUE_35);
    define ("min", GLUE_36);
    define ("max", GLUE_37);
    define ("floor", GLUE_38);
    define ("ceil", GLUE_39);
    define ("trunc", GLUE_40);
    define ("round", GLUE_41);
    define ("finite?", GLUE_42);
    define ("infinite?", GLUE_43);
    define ("nan?", GLUE_44);
    define ("times_infinity", GLUE_45);
    define ("precision", GLUE_46);
    define ("next_above", GLUE_47);
    define ("next_below", GLUE_48);
    define ("exponent", GLUE_49);
    define ("magnitude", GLUE_50);
    define ("increase_exponent", GLUE_51);
    define ("decrease_exponent", GLUE_52);
    define ("rounding_error", GLUE_53);
    define ("additive_error", GLUE_54);
    define ("multiplicative_error", GLUE_55);
    define ("elementary_error", GLUE_56);
  }
void glue_integer ( )

Definition at line 193 of file glue_integer.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_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_26(), GLUE_27(), GLUE_28(), GLUE_29(), GLUE_3(), GLUE_30(), GLUE_31(), GLUE_32(), GLUE_33(), GLUE_34(), GLUE_35(), GLUE_36(), GLUE_37(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_numerix().

                  {
    static bool done = false;
    if (done) return;
    done = true;
    define_type<integer > (lit ("Integer"));
    define ("literal_integer", GLUE_1);
    define_constructor<int > (GLUE_2);
    define ("integer", GLUE_3);
    define_converter ("upgrade", GLUE_4, PENALTY_INCLUSION);
    define_converter (":>", GLUE_5, PENALTY_CAST);
    define ("as_integer", GLUE_6);
    define ("as_string", GLUE_7);
    define ("-", GLUE_8);
    define ("square", GLUE_9);
    define ("+", GLUE_10);
    define ("-", GLUE_11);
    define ("*", GLUE_12);
    define ("div", GLUE_13);
    define ("quo", GLUE_14);
    define ("rem", GLUE_15);
    define ("divides?", GLUE_16);
    define ("gcd", GLUE_17);
    define ("lcm", GLUE_18);
    define ("<", GLUE_19);
    define ("<=", GLUE_20);
    define (">", GLUE_21);
    define (">=", GLUE_22);
    define ("abs", GLUE_23);
    define ("min", GLUE_24);
    define ("max", GLUE_25);
    define (".!", GLUE_26);
    define ("binomial", GLUE_27);
    define ("probable_prime?", GLUE_28);
    define ("probable_next_prime", GLUE_29);
    define ("/\\", GLUE_30);
    define ("\\/", GLUE_31);
    define ("xor", GLUE_32);
    define ("!", GLUE_33);
    define ("#", GLUE_34);
    define (".[]", GLUE_35);
    define ("hamming_norm", GLUE_36);
    define ("hamming_distance", GLUE_37);
  }
void glue_interval_double ( )

Definition at line 265 of file glue_interval_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_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_26(), GLUE_27(), GLUE_28(), GLUE_29(), GLUE_3(), GLUE_30(), GLUE_31(), GLUE_32(), GLUE_33(), GLUE_34(), GLUE_35(), GLUE_36(), GLUE_37(), GLUE_38(), GLUE_39(), GLUE_4(), GLUE_40(), GLUE_41(), GLUE_42(), GLUE_43(), GLUE_44(), GLUE_45(), GLUE_46(), GLUE_47(), GLUE_48(), GLUE_49(), GLUE_5(), GLUE_50(), GLUE_51(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_numerix().

                          {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_double"));
    define_type<interval<double> > (gen (lit ("Interval"), lit ("Double")));
    define ("interval", GLUE_1);
    define ("interval", GLUE_2);
    define_converter ("upgrade", GLUE_3, PENALTY_INCLUSION);
    define ("lower", GLUE_4);
    define ("upper", GLUE_5);
    define ("center", GLUE_6);
    define ("radius", GLUE_7);
    define ("-", GLUE_8);
    define ("square", GLUE_9);
    define ("+", GLUE_10);
    define ("-", GLUE_11);
    define ("*", GLUE_12);
    define ("+", GLUE_13);
    define ("+", GLUE_14);
    define ("-", GLUE_15);
    define ("-", GLUE_16);
    define ("*", GLUE_17);
    define ("*", GLUE_18);
    define ("/", GLUE_19);
    define ("/", GLUE_20);
    define ("/", GLUE_21);
    define ("sqrt", GLUE_22);
    define ("exp", GLUE_23);
    define ("log", GLUE_24);
    define ("^", GLUE_25);
    define ("cos", GLUE_26);
    define ("sin", GLUE_27);
    define ("tan", GLUE_28);
    define ("arccos", GLUE_29);
    define ("arcsin", GLUE_30);
    define ("arctan", GLUE_31);
    define ("<", GLUE_32);
    define (">", GLUE_33);
    define ("<=", GLUE_34);
    define (">=", GLUE_35);
    define ("abs", GLUE_36);
    define ("min", GLUE_37);
    define ("max", GLUE_38);
    define ("floor", GLUE_39);
    define ("ceil", GLUE_40);
    define ("trunc", GLUE_41);
    define ("round", GLUE_42);
    define ("finite?", GLUE_43);
    define ("infinite?", GLUE_44);
    define ("nan?", GLUE_45);
    define ("times_infinity", GLUE_46);
    define ("precision", GLUE_47);
    define ("exponent", GLUE_48);
    define ("magnitude", GLUE_49);
    define ("increase_exponent", GLUE_50);
    define ("decrease_exponent", GLUE_51);
  }
void glue_interval_floating ( )

Definition at line 268 of file glue_interval_floating.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_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_26(), GLUE_27(), GLUE_28(), GLUE_29(), GLUE_3(), GLUE_30(), GLUE_31(), GLUE_32(), GLUE_33(), GLUE_34(), GLUE_35(), GLUE_36(), GLUE_37(), GLUE_38(), GLUE_39(), GLUE_4(), GLUE_40(), GLUE_41(), GLUE_42(), GLUE_43(), GLUE_44(), GLUE_45(), GLUE_46(), GLUE_47(), GLUE_48(), GLUE_49(), GLUE_5(), GLUE_50(), GLUE_51(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_numerix().

                            {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_floating"));
    call_glue (string ("glue_interval_double"));
    define_type<interval<mmx_floating> > (gen (lit ("Interval"), lit ("Floating")));
    define ("interval", GLUE_1);
    define ("interval", GLUE_2);
    define_converter ("upgrade", GLUE_3, PENALTY_INCLUSION);
    define ("lower", GLUE_4);
    define ("upper", GLUE_5);
    define ("center", GLUE_6);
    define ("radius", GLUE_7);
    define ("-", GLUE_8);
    define ("square", GLUE_9);
    define ("+", GLUE_10);
    define ("-", GLUE_11);
    define ("*", GLUE_12);
    define ("+", GLUE_13);
    define ("+", GLUE_14);
    define ("-", GLUE_15);
    define ("-", GLUE_16);
    define ("*", GLUE_17);
    define ("*", GLUE_18);
    define ("/", GLUE_19);
    define ("/", GLUE_20);
    define ("/", GLUE_21);
    define ("sqrt", GLUE_22);
    define ("exp", GLUE_23);
    define ("log", GLUE_24);
    define ("^", GLUE_25);
    define ("cos", GLUE_26);
    define ("sin", GLUE_27);
    define ("tan", GLUE_28);
    define ("arccos", GLUE_29);
    define ("arcsin", GLUE_30);
    define ("arctan", GLUE_31);
    define ("<", GLUE_32);
    define (">", GLUE_33);
    define ("<=", GLUE_34);
    define (">=", GLUE_35);
    define ("abs", GLUE_36);
    define ("min", GLUE_37);
    define ("max", GLUE_38);
    define ("floor", GLUE_39);
    define ("ceil", GLUE_40);
    define ("trunc", GLUE_41);
    define ("round", GLUE_42);
    define ("finite?", GLUE_43);
    define ("infinite?", GLUE_44);
    define ("nan?", GLUE_45);
    define ("times_infinity", GLUE_46);
    define ("precision", GLUE_47);
    define ("exponent", GLUE_48);
    define ("magnitude", GLUE_49);
    define ("increase_exponent", GLUE_50);
    define ("decrease_exponent", GLUE_51);
  }
void mmx::glue_modular_int ( )

Referenced by glue_numerix().

void glue_modular_integer ( )

Definition at line 12 of file glue_modular_integer.cpp.

Referenced by glue_numerix().

                          {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_modular_int"));
  }
void mmx::glue_numerix ( )

Definition at line 26 of file glue_numerix.cpp.

References glue_affine_generic(), glue_ball_double(), glue_ball_floating(), glue_complex_double(), glue_complex_floating(), glue_complex_generic(), glue_complex_rational(), glue_floating(), glue_integer(), glue_interval_double(), glue_interval_floating(), glue_modular_int(), glue_modular_integer(), glue_rational(), glue_tangent_double(), glue_tangent_floating(), glue_tangent_generic(), and glue_tangent_rational().

                  {
    static bool done = false;
    if (done) return;
    done = true;
    register_glue (string ("glue_affine_generic"), (& (glue_affine_generic)));
    register_glue (string ("glue_ball_double"), (& (glue_ball_double)));
    register_glue (string ("glue_ball_floating"), (& (glue_ball_floating)));
    register_glue (string ("glue_complex_double"), (& (glue_complex_double)));
    register_glue (string ("glue_complex_floating"), (& (glue_complex_floating)));
    register_glue (string ("glue_complex_generic"), (& (glue_complex_generic)));
    register_glue (string ("glue_complex_rational"), (& (glue_complex_rational)));
    register_glue (string ("glue_floating"), (& (glue_floating)));
    register_glue (string ("glue_integer"), (& (glue_integer)));
    register_glue (string ("glue_interval_double"), (& (glue_interval_double)));
    register_glue (string ("glue_interval_floating"), (& (glue_interval_floating)));
    register_glue (string ("glue_modular_int"), (& (glue_modular_int)));
    register_glue (string ("glue_modular_integer"), (& (glue_modular_integer)));
    register_glue (string ("glue_rational"), (& (glue_rational)));
    register_glue (string ("glue_tangent_double"), (& (glue_tangent_double)));
    register_glue (string ("glue_tangent_floating"), (& (glue_tangent_floating)));
    register_glue (string ("glue_tangent_generic"), (& (glue_tangent_generic)));
    register_glue (string ("glue_tangent_rational"), (& (glue_tangent_rational)));
    register_glue (string ("glue_numerix"), (& (glue_numerix)));
    dl_link ("basix");
    glue_affine_generic ();
    glue_ball_double ();
    glue_ball_floating ();
    glue_complex_double ();
    glue_complex_floating ();
    glue_complex_generic ();
    glue_complex_rational ();
    glue_floating ();
    glue_integer ();
    glue_interval_double ();
    glue_interval_floating ();
    glue_modular_int ();
    glue_modular_integer ();
    glue_rational ();
    glue_tangent_double ();
    glue_tangent_floating ();
    glue_tangent_generic ();
    glue_tangent_rational ();
    include ("numerix/big_operators.mmx");
  }
void glue_rational ( )

Definition at line 158 of file glue_rational.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_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_26(), GLUE_27(), GLUE_28(), GLUE_29(), GLUE_3(), GLUE_30(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_numerix().

                   {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_integer"));
    define_type<rational > (lit ("Rational"));
    define ("rational", GLUE_1);
    define ("rational", GLUE_2);
    define_converter ("upgrade", GLUE_3, PENALTY_INCLUSION);
    define_converter ("upgrade", GLUE_4, PENALTY_INCLUSION);
    define ("/", GLUE_5);
    define ("numerator", GLUE_6);
    define ("denominator", GLUE_7);
    define ("-", GLUE_8);
    define ("square", GLUE_9);
    define ("+", GLUE_10);
    define ("-", GLUE_11);
    define ("*", GLUE_12);
    define ("/", GLUE_13);
    define ("^", GLUE_14);
    define ("^", GLUE_15);
    define ("div", GLUE_16);
    define ("divides?", GLUE_17);
    define ("gcd", GLUE_18);
    define ("lcm", GLUE_19);
    define ("<", GLUE_20);
    define ("<=", GLUE_21);
    define (">", GLUE_22);
    define (">=", GLUE_23);
    define ("abs", GLUE_24);
    define ("min", GLUE_25);
    define ("max", GLUE_26);
    define ("floor", GLUE_27);
    define ("ceil", GLUE_28);
    define ("trunc", GLUE_29);
    define ("round", GLUE_30);
  }
void glue_tangent_double ( )

Definition at line 344 of file glue_tangent_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_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_26(), GLUE_27(), GLUE_28(), GLUE_29(), GLUE_3(), GLUE_30(), GLUE_31(), GLUE_32(), GLUE_33(), GLUE_34(), GLUE_35(), GLUE_36(), GLUE_37(), GLUE_38(), GLUE_39(), GLUE_4(), GLUE_40(), GLUE_41(), GLUE_42(), GLUE_43(), GLUE_44(), GLUE_45(), GLUE_46(), GLUE_47(), GLUE_48(), GLUE_49(), GLUE_5(), GLUE_50(), GLUE_51(), GLUE_52(), GLUE_53(), GLUE_54(), GLUE_55(), GLUE_56(), GLUE_57(), GLUE_58(), GLUE_59(), GLUE_6(), GLUE_60(), GLUE_61(), GLUE_62(), GLUE_63(), GLUE_64(), GLUE_65(), GLUE_66(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_numerix().

                         {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_complex_double"));
    call_glue (string ("glue_tangent_rational"));
    define_type<tangent<double, double> > (gen (lit ("Tangent"), lit ("Double"), lit ("Double")));
    define ("tangent", GLUE_1);
    define_converter ("upgrade", GLUE_2, PENALTY_HOMOMORPHISM);
    define ("tangent", GLUE_3);
    define ("base", GLUE_4);
    define ("slope", GLUE_5);
    define ("-", GLUE_6);
    define ("square", GLUE_7);
    define ("+", GLUE_8);
    define ("-", GLUE_9);
    define ("*", GLUE_10);
    define ("/", GLUE_11);
    define ("sqrt", GLUE_12);
    define ("exp", GLUE_13);
    define ("log", GLUE_14);
    define ("^", GLUE_15);
    define ("cos", GLUE_16);
    define ("sin", GLUE_17);
    define ("tan", GLUE_18);
    define ("arccos", GLUE_19);
    define ("arcsin", GLUE_20);
    define ("arctan", GLUE_21);
    define ("finite?", GLUE_22);
    define ("infinite?", GLUE_23);
    define ("nan?", GLUE_24);
    define ("times_infinity", GLUE_25);
    define ("precision", GLUE_26);
    define ("exponent", GLUE_27);
    define ("magnitude", GLUE_28);
    define ("increase_exponent", GLUE_29);
    define ("decrease_exponent", GLUE_30);
    define_converter (":>", GLUE_31, PENALTY_PROMOTE_GENERIC);
    define_converter (":>", GLUE_32, PENALTY_INCLUSION);
    define_type<tangent<complex<double> , complex<double> > > (gen (lit ("Tangent"), gen (lit ("Complex"), lit ("Double")), gen (lit ("Complex"), lit ("Double"))));
    define ("tangent", GLUE_33);
    define_converter ("upgrade", GLUE_34, PENALTY_HOMOMORPHISM);
    define ("tangent", GLUE_35);
    define ("base", GLUE_36);
    define ("slope", GLUE_37);
    define ("-", GLUE_38);
    define ("square", GLUE_39);
    define ("+", GLUE_40);
    define ("-", GLUE_41);
    define ("*", GLUE_42);
    define ("/", GLUE_43);
    define ("sqrt", GLUE_44);
    define ("exp", GLUE_45);
    define ("log", GLUE_46);
    define ("^", GLUE_47);
    define ("cos", GLUE_48);
    define ("sin", GLUE_49);
    define ("tan", GLUE_50);
    define ("arccos", GLUE_51);
    define ("arcsin", GLUE_52);
    define ("arctan", GLUE_53);
    define ("finite?", GLUE_54);
    define ("infinite?", GLUE_55);
    define ("nan?", GLUE_56);
    define ("times_infinity", GLUE_57);
    define ("precision", GLUE_58);
    define ("exponent", GLUE_59);
    define ("magnitude", GLUE_60);
    define ("increase_exponent", GLUE_61);
    define ("decrease_exponent", GLUE_62);
    define_converter (":>", GLUE_63, PENALTY_HOMOMORPHISM);
    define_converter (":>", GLUE_64, PENALTY_HOMOMORPHISM);
    define_converter (":>", GLUE_65, PENALTY_INCLUSION);
    define_converter (":>", GLUE_66, PENALTY_PROMOTE_GENERIC);
  }
void glue_tangent_floating ( )

Definition at line 345 of file glue_tangent_floating.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_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_26(), GLUE_27(), GLUE_28(), GLUE_29(), GLUE_3(), GLUE_30(), GLUE_31(), GLUE_32(), GLUE_33(), GLUE_34(), GLUE_35(), GLUE_36(), GLUE_37(), GLUE_38(), GLUE_39(), GLUE_4(), GLUE_40(), GLUE_41(), GLUE_42(), GLUE_43(), GLUE_44(), GLUE_45(), GLUE_46(), GLUE_47(), GLUE_48(), GLUE_49(), GLUE_5(), GLUE_50(), GLUE_51(), GLUE_52(), GLUE_53(), GLUE_54(), GLUE_55(), GLUE_56(), GLUE_57(), GLUE_58(), GLUE_59(), GLUE_6(), GLUE_60(), GLUE_61(), GLUE_62(), GLUE_63(), GLUE_64(), GLUE_65(), GLUE_66(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_numerix().

                           {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_complex_double"));
    call_glue (string ("glue_complex_floating"));
    call_glue (string ("glue_tangent_double"));
    define_type<tangent<mmx_floating, mmx_floating> > (gen (lit ("Tangent"), lit ("Floating"), lit ("Floating")));
    define ("tangent", GLUE_1);
    define_converter ("upgrade", GLUE_2, PENALTY_HOMOMORPHISM);
    define ("tangent", GLUE_3);
    define ("base", GLUE_4);
    define ("slope", GLUE_5);
    define ("-", GLUE_6);
    define ("square", GLUE_7);
    define ("+", GLUE_8);
    define ("-", GLUE_9);
    define ("*", GLUE_10);
    define ("/", GLUE_11);
    define ("sqrt", GLUE_12);
    define ("exp", GLUE_13);
    define ("log", GLUE_14);
    define ("^", GLUE_15);
    define ("cos", GLUE_16);
    define ("sin", GLUE_17);
    define ("tan", GLUE_18);
    define ("arccos", GLUE_19);
    define ("arcsin", GLUE_20);
    define ("arctan", GLUE_21);
    define ("finite?", GLUE_22);
    define ("infinite?", GLUE_23);
    define ("nan?", GLUE_24);
    define ("times_infinity", GLUE_25);
    define ("precision", GLUE_26);
    define ("exponent", GLUE_27);
    define ("magnitude", GLUE_28);
    define ("increase_exponent", GLUE_29);
    define ("decrease_exponent", GLUE_30);
    define_converter (":>", GLUE_31, PENALTY_INCLUSION);
    define_converter (":>", GLUE_32, PENALTY_PROMOTE_GENERIC);
    define_type<tangent<complex<mmx_floating> , complex<mmx_floating> > > (gen (lit ("Tangent"), gen (lit ("Complex"), lit ("Floating")), gen (lit ("Complex"), lit ("Floating"))));
    define ("tangent", GLUE_33);
    define_converter ("upgrade", GLUE_34, PENALTY_HOMOMORPHISM);
    define ("tangent", GLUE_35);
    define ("base", GLUE_36);
    define ("slope", GLUE_37);
    define ("-", GLUE_38);
    define ("square", GLUE_39);
    define ("+", GLUE_40);
    define ("-", GLUE_41);
    define ("*", GLUE_42);
    define ("/", GLUE_43);
    define ("sqrt", GLUE_44);
    define ("exp", GLUE_45);
    define ("log", GLUE_46);
    define ("^", GLUE_47);
    define ("cos", GLUE_48);
    define ("sin", GLUE_49);
    define ("tan", GLUE_50);
    define ("arccos", GLUE_51);
    define ("arcsin", GLUE_52);
    define ("arctan", GLUE_53);
    define ("finite?", GLUE_54);
    define ("infinite?", GLUE_55);
    define ("nan?", GLUE_56);
    define ("times_infinity", GLUE_57);
    define ("precision", GLUE_58);
    define ("exponent", GLUE_59);
    define ("magnitude", GLUE_60);
    define ("increase_exponent", GLUE_61);
    define ("decrease_exponent", GLUE_62);
    define_converter (":>", GLUE_63, PENALTY_HOMOMORPHISM);
    define_converter (":>", GLUE_64, PENALTY_INCLUSION);
    define_converter (":>", GLUE_65, PENALTY_HOMOMORPHISM);
    define_converter (":>", GLUE_66, PENALTY_PROMOTE_GENERIC);
  }
void glue_tangent_generic ( )

Definition at line 107 of file glue_tangent_generic.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_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_numerix().

                          {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_generic"));
    define_type<tangent<generic, generic> > (gen (lit ("Tangent"), lit ("Generic"), lit ("Generic")));
    define ("tangent", GLUE_1);
    define ("tangent", GLUE_2);
    define ("base", GLUE_3);
    define ("slope", GLUE_4);
    define ("-", GLUE_5);
    define ("square", GLUE_6);
    define ("+", GLUE_7);
    define ("-", GLUE_8);
    define ("*", GLUE_9);
    define ("/", GLUE_10);
    define ("sqrt", GLUE_11);
    define ("exp", GLUE_12);
    define ("log", GLUE_13);
    define ("^", GLUE_14);
    define ("cos", GLUE_15);
    define ("sin", GLUE_16);
    define ("tan", GLUE_17);
    define ("arccos", GLUE_18);
    define ("arcsin", GLUE_19);
    define ("arctan", GLUE_20);
  }
void glue_tangent_rational ( )

Definition at line 135 of file glue_tangent_rational.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_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_numerix().

                           {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_complex_rational"));
    call_glue (string ("glue_tangent_generic"));
    define_type<tangent<rational, rational> > (gen (lit ("Tangent"), lit ("Rational"), lit ("Rational")));
    define ("tangent", GLUE_1);
    define_converter ("upgrade", GLUE_2, PENALTY_HOMOMORPHISM);
    define ("tangent", GLUE_3);
    define ("base", GLUE_4);
    define ("slope", GLUE_5);
    define ("-", GLUE_6);
    define ("square", GLUE_7);
    define ("+", GLUE_8);
    define ("-", GLUE_9);
    define ("*", GLUE_10);
    define ("/", GLUE_11);
    define_converter (":>", GLUE_12, PENALTY_PROMOTE_GENERIC);
    define_type<tangent<complex<rational> , complex<rational> > > (gen (lit ("Tangent"), gen (lit ("Complex"), lit ("Rational")), gen (lit ("Complex"), lit ("Rational"))));
    define ("tangent", GLUE_13);
    define_converter ("upgrade", GLUE_14, PENALTY_HOMOMORPHISM);
    define ("tangent", GLUE_15);
    define ("base", GLUE_16);
    define ("slope", GLUE_17);
    define ("-", GLUE_18);
    define ("square", GLUE_19);
    define ("+", GLUE_20);
    define ("-", GLUE_21);
    define ("*", GLUE_22);
    define ("/", GLUE_23);
    define_converter (":>", GLUE_24, PENALTY_HOMOMORPHISM);
    define_converter (":>", GLUE_25, PENALTY_PROMOTE_GENERIC);
  }
bool mmx::hard_eq ( const twin< C, D, V > &  x,
const twin< C, D, V > &  y 
)

Definition at line 158 of file twin.hpp.

References cdr(), and hard_eq().

                                                 {
  return hard_eq (cdr (x), cdr (y)); }
bool mmx::hard_eq ( const modular< M, modular_local > &  c1,
const modular< M, modular_local > &  c2 
)

Definition at line 406 of file modular.hpp.

References get_modulus().

Referenced by affine_limits_helper< C, VC >::common(), hard_eq(), and hard_neq().

                                                         {
  return hard_eq (*c1, *c2) && 
         hard_eq (get_modulus (c1), get_modulus (c2)); }
nat mmx::hard_hash ( const twin< C, D, V > &  x)

Definition at line 152 of file twin.hpp.

References cdr(), and hard_hash().

{ return hard_hash (cdr (x)); }
nat mmx::hard_hash ( const modular< M, modular_local > &  c)

Definition at line 395 of file modular.hpp.

References get_modulus().

Referenced by hard_hash().

                                      {
  nat h= hard_hash (*c);
  return (h<<1) ^ (h<<5) ^ (h>>29) ^ hard_hash (get_modulus (c)); }
tangent<C,D> mmx::HARD_IDENTITY_OP_SUGAR ( template< typename C, typename D >  ,
tangent< C, D >   
)
complex<C> mmx::HARD_IDENTITY_OP_SUGAR ( template< typename C >  ,
complex< C >   
)
bool mmx::hard_neq ( const modular< M, modular_local > &  c1,
const modular< M, modular_local > &  c2 
)

Definition at line 410 of file modular.hpp.

References hard_eq().

Referenced by hard_neq().

                                                          {
  return ! hard_eq (c1, c2); }
bool mmx::hard_neq ( const twin< C, D, V > &  x,
const twin< C, D, V > &  y 
)

Definition at line 160 of file twin.hpp.

References cdr(), and hard_neq().

                                                  {
  return hard_neq (cdr (x), cdr (y)); }
nat mmx::hash ( const floating< V > &  x)

Definition at line 168 of file floating.hpp.

                                  {
  mpfr_t y;
  mpfr_init2 (y, 32);
  mpfr_set (y, *x, GMP_RNDN);
  if (!mpfr_number_p (y)) return 12321;
  if (mpfr_zero_p (y)) return 1234321;
  nat m= (nat) y->_mpfr_d[0];
  nat e= (nat) y->_mpfr_exp;
  nat s= (nat) y->_mpfr_sign;
  mpfr_clear (y);
  return m ^ (m >> ((nat) 31)) ^ e ^ (e << ((nat) 3)) ^ s ^ (s << ((nat) 7));
}
int mmx::hash ( const scalar_set< C > &  R) [inline]

Definition at line 50 of file kernel.hpp.

{ return 1;}
interval<C,V> nat mmx::hash ( const interval< C, V > &  x)

Definition at line 161 of file interval.hpp.

{ return 12721; }
nat mmx::hash ( const modular< M, modular_local > &  c)

Definition at line 386 of file modular.hpp.

References get_modulus(), and hash().

                        {
  nat h= hash (*c);
  return (h<<1) ^ (h<<5) ^ (h>>29) ^ hash (get_modulus (c)); }
nat mmx::hash ( const twin< C, D, V > &  x)

Definition at line 150 of file twin.hpp.

References car(), and hash().

{ return hash (car (x)); }
nat mmx::hash ( const ball< C, R, V > &  z)

Definition at line 322 of file ball.hpp.

Referenced by hash().

                     {
  (void) z;
  // return hash (center (z));
  return 123123123;
}
interval<C,V> mmx::hypot ( const interval< C, V > &  x,
const interval< C, V > &  y 
)

Definition at line 474 of file interval.hpp.

References Interval, sqrt(), square(), and upper().

                                             {
  Interval z= square (x) + square (y);
  if (z > 0) return sqrt (z);
  else return Interval (0, Up::sqrt (upper (z)));
}
ball<C,R,V> mmx::hypot ( const ball< C, R, V > &  x,
const ball< C, R, V > &  y 
) [inline]

Definition at line 474 of file ball.hpp.

References Ball, C, Elementary_variant, and V.

Referenced by abs(), implementation< ball_complex_construct, IV, ball_complex< BV > >::gauss(), hypot(), implementation< ball_root, W, ball_rounded >::hypot(), implementation< ball_root, IV, ball_infinities< BV > >::hypot(), and sqrt().

                                     {
  typedef Elementary_variant(C,V) EV;
  typedef implementation<ball_root,EV> Impl;
  Ball d; Impl::hypot (d, x, y); return d;
}
floating<V> mmx::hypot ( const floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 403 of file floating.hpp.

References Floating, and Rnd.

                                                                    {
  Floating r (*x1, *x2); mpfr_hypot (*r, *x1, *x2, Rnd); return r; }
twin<C,D,V> mmx::hypot ( const twin< C, D, V > &  x,
const twin< C, D, V > &  y 
)

Definition at line 261 of file twin.hpp.

References car(), cdr(), hypot(), and Twin.

                                               {
  return Twin (hypot (car (x), car (y)), hypot (cdr (x), cdr (y))); }
mmx::HYPOT_SUGAR ( template< typename C, typename D >  ,
tangent< C, D >   
)
tangent<Real_type(C),Real_type(D) > mmx::Im ( const tangent< C, D > &  z) [inline]

Definition at line 401 of file tangent.hpp.

References base(), Im(), Real_tangent, and slope().

                      {
  return Real_tangent (Im (base (z)), Im (slope (z)));
}
ball< Real_type(C) ,R,V> mmx::Im ( const ball< C, R, V > &  z) [inline]

Definition at line 53 of file ball_complex.hpp.

References center(), Im(), radius(), and Real_ball.

                                                 {
  return Real_ball (Im (center (z)), radius (z)); }
affine<Real_type(C),Real_type(VC) > mmx::Im ( const affine< C, VC > &  z) [inline]

Definition at line 489 of file affine.hpp.

References base(), limits(), Real_affine, and slope().

Referenced by abs(), add(), additive_error(), arg(), ARG_HYPER_SUGAR(), binary_test(), blur(), change_precision(), conj(), copy(), cos(), implementation< ball_elementary, IV, ball_complex< BV > >::cos(), cosh(), as_helper< complex< T >, complex< F > >::cv(), fast_helper< complex< C > >::dd(), binary_helper< complex< C > >::disassemble(), div(), duplicate(), exp(), exponent(), flatten(), GLUE_4(), GLUE_5(), Im(), invert(), is_exact_zero(), is_fuzz(), is_infinite(), is_nan(), magnitude(), map(), mul(), neg(), norm(), operator*(), operator+(), operator-(), operator/(), operator<<(), operator>>(), over_i(), pow(), precision(), set_accuracy(), set_as(), set_euler(), set_fuzz(), set_imaginary(), set_infinity(), set_largest(), set_log2(), set_nan(), set_pi(), set_smallest(), sharpen(), sin(), implementation< ball_elementary, IV, ball_complex< BV > >::sin(), sinh(), sqrt(), square(), sub(), times_i(), unary_hash(), fast_helper< complex< C > >::uu(), make_ball_helper< complex< interval< C > >, complex< C >, C >::val(), and binary_helper< complex< C > >::write().

                     {
  return Real_affine (Im (base (z)), Im (slope (z)), limits (z));
}
C Im ( const complex< C > &  z) [inline]

Definition at line 107 of file complex.hpp.

{ return z.im; }
C & Im ( complex< C > &  z) [inline]

Definition at line 109 of file complex.hpp.

{ return z.im; }
static void mmx::inc_mantissa ( string &  mant,
integer &  expo 
) [static]

Definition at line 88 of file string_scnot.cpp.

References as_string().

Referenced by make_range(), and trunc_digits().

                                           {
  string mant2= as_string (integer (mant) + 1);
  if (N (mant2) > N (mant)) expo= expo + 1;
  mant= mant2;
}
bool mmx::included ( const ball< C, R, V > &  b1,
const ball< C, R, V > &  b2 
) [inline]

Definition at line 316 of file ball.hpp.

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

                                          {
  // returns true if b1 is provably included in b2
  return radius (b1 - Ball (center (b2))) <= radius (b2);
}
mmx::INDIRECT_IMPL ( rational  ,
rational_rep   
)

Definition at line 204 of file rational.hpp.

                                                      {
  static const nat id= SYMBOLIC_RATIONAL; };
mmx::INDIRECT_IMPL ( integer  ,
integer_rep   
)

Definition at line 1006 of file integer.hpp.

                                                     {
  static const nat id= SYMBOLIC_INTEGER; };
mmx::INDIRECT_IMPL_1 ( floating  ,
floating_rep  ,
typename V  ,
V   
)

Definition at line 145 of file floating.hpp.

                                                         {
  static const nat id= SYMBOLIC_FLOATING; };
bool mmx::intersect ( interval< C, V > &  r,
const interval< C, V > &  a,
const interval< C, V > &  b 
) [inline]

Definition at line 203 of file interval.hpp.

References Interval, lower(), max(), min(), and upper().

                                                              {
  if ((upper (a) < lower (b)) || (lower (a) > upper (b))) return false;
  r = Interval (max (lower (a), lower (b)), min (upper (a), upper (b)));
  return true;
}
tangent<C,D> mmx::INV_HYPER_SUGAR ( template< typename C, typename D >  ,
tangent< C, D >   
)
void mmx::inv_mod ( C &  dest,
const modulus< C, V > &  m 
) [inline]

Definition at line 166 of file modulus.hpp.

Referenced by modulus_div_naive< modulus_inv_integer_naive< modulus_mul_naive< modulus_add_integer_naive< modulus_reduction_naive< modulus_normalization_integer_naive > > > > >::div_mod(), modulus_div_int_naive< modulus_inv_int_naive< modulus_mul_int_naive< modulus_add_int_naive< modulus_reduction_int_naive< modulus_normalization_int_naive< modulus_maximum_size_int< size > > > > > > >::div_mod(), inv_mod(), and invert().

                                    {
  V::inv_mod (dest, m); }
void mmx::inv_mod ( C &  dest,
const C &  s,
const modulus< C, V > &  m 
) [inline]

Definition at line 170 of file modulus.hpp.

References inv_mod().

                                                {
  V::inv_mod (dest, s, m); }
mmx::INV_TRIGO_SUGAR ( template< typename C, typename V >  ,
interval< C, V >   
)
mmx::INV_TRIGO_SUGAR ( template< typename C, typename R, typename V >  ,
ball< C, R, V >   
)
mmx::INV_TRIGO_SUGAR ( template< typename C >  ,
complex< C >   
)
complex<C> mmx::invert ( const complex< C > &  z) [inline]

Definition at line 329 of file complex.hpp.

References C, Complex, Im(), norm(), and Re().

                          {
  C a= norm (z);
  return Complex (Re (z) / a, -Im (z) / a);
}
ball<C,R,V> mmx::invert ( const ball< C, R, V > &  z) [inline]

Definition at line 422 of file ball.hpp.

References Ball, and invert().

                       {
  typedef implementation<ball_multiplicative,V> Impl;
  Ball d; Impl::invert (d, z); return d;
}
STMPL complex<double> mmx::invert ( const complex< double > &  z) [inline]

Definition at line 25 of file complex_double.hpp.

References abs(), Im(), and Re().

                                  {
  if (abs (Re (z)) >= abs (Im (z))) {
    double f= Im (z) / Re (z);
    double c= 1.0 / (Re (z) + Im (z) * f);
    return complex<double> (c, -c * f);
  }
  else {
    double f= Re (z) / Im (z);
    double c= 1.0 / (Re (z) * f + Im (z));
    return complex<double> (c * f, -c);
  }
}
modular<M,V> mmx::invert ( const modular< M, V > &  a) [inline]

Definition at line 263 of file modular.hpp.

References get_modulus(), inv_mod(), and Modular.

                          {
  Modular c;
  inv_mod (c.rep, a.rep, Modular::get_modulus ());
  return c; }
floating<V> mmx::invert ( const floating< V > &  x) [inline]

Definition at line 310 of file floating.hpp.

References Floating, and Rnd.

                                                {
  Floating one (1); Floating r (*x); mpfr_div (*r, *one, *x, Rnd); return r; }
affine<C,VC> mmx::invert ( const affine< C, VC > &  z) [inline]

Definition at line 278 of file affine.hpp.

Referenced by acos(), asin(), atan(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::invert(), invert(), log(), operator/(), and sqrt().

                         {
  ERROR ("not yet implemented");
  //C inv= invert (base (z));
  //return Affine (inv, - square (inv) * slope (z));
}
tangent<C,D> mmx::invert ( const tangent< C, D > &  z) [inline]

Definition at line 199 of file tangent.hpp.

References base(), C, invert(), slope(), square(), and Tangent.

                          {
  C inv= invert (base (z));
  return Tangent (inv, - square (inv) * slope (z));
}
modular<M,modular_local> mmx::invert ( const modular< M, modular_local > &  a) [inline]

Definition at line 494 of file modular.hpp.

References get_modulus(), inv_mod(), and Modular.

                          {
  M mod= get_modulus (a);
  Modular c;
  inv_mod (c.rep, a.rep, mod);
  c.mod= mod;
  return c; }
bool mmx::is_exact_zero ( const interval< C, V > &  x) [inline]

Definition at line 135 of file interval.hpp.

References is_exact_zero(), lower(), and upper().

                                                   {
  return is_exact_zero (lower (x)) && is_exact_zero (upper (x)); }
bool mmx::is_exact_zero ( const ball< C, R, V > &  z) [inline]

Definition at line 149 of file ball.hpp.

References center(), and radius().

Referenced by flatten(), flatten_range(), is_exact_zero(), and modular_local::modulus_storage< M >::set_modulus().

                                               {
  return is_exact_zero (center (z)) && is_exact_zero (radius (z)); }
bool mmx::is_exact_zero ( const twin< C, D, V > &  x) [inline]

Definition at line 88 of file twin.hpp.

References car(), and is_exact_zero().

                                               {
  return is_exact_zero (car (x)); }
bool mmx::is_exact_zero ( const complex< C > &  z) [inline]

Definition at line 116 of file complex.hpp.

References Im(), is_exact_zero(), and Re().

                                                  {
  return is_exact_zero (Re (z)) && is_exact_zero (Im (z)); }
interval<C,V> V bool mmx::is_finite ( const interval< C, V > &  x) [inline]

Definition at line 595 of file interval.hpp.

References is_finite(), lower(), and upper().

                                               {
  return is_finite (lower (x)) && is_finite (upper (x)); }
bool mmx::is_finite ( const tangent< C, D > &  z) [inline]

Definition at line 351 of file tangent.hpp.

References base(), is_finite(), and slope().

                                              {
  return is_finite (base (z)) && is_finite (slope (z)); }
bool mmx::is_finite ( const twin< C, D, V > &  x) [inline]

Definition at line 268 of file twin.hpp.

References car(), and is_finite().

                                           {
  return is_finite (car (x)); }
bool mmx::is_finite ( const affine< C, VC > &  z) [inline]

Definition at line 435 of file affine.hpp.

References base(), and slope().

Referenced by implementation< ball_abs, IV, ball_infinities< BV > >::abs(), implementation< ball_additive, IV, ball_infinities< BV > >::add(), ARG_HYPER_SUGAR(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::div(), GLUE_22(), GLUE_35(), GLUE_42(), GLUE_43(), GLUE_54(), implementation< ball_root, IV, ball_infinities< BV > >::hypot(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::invert(), is_finite(), is_infinite(), is_non_zero(), is_zero(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::mul(), implementation< ball_additive, IV, ball_infinities< BV > >::neg(), implementation< ball_shift, IV, ball_infinities< BV > >::shiftl(), implementation< ball_shift, IV, ball_infinities< BV > >::shiftr(), implementation< ball_root, IV, ball_infinities< BV > >::sqrt(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::square(), and implementation< ball_additive, IV, ball_infinities< BV > >::sub().

                                             {
  return is_finite (base (z)) && is_finite (slope (z)); }
bool mmx::is_finite ( const ball< C, R, V > &  z) [inline]

Definition at line 639 of file ball.hpp.

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

                                           {
  return is_finite (center (z)) && is_finite (radius (z)); }
bool mmx::is_fuzz ( const interval< C, V > &  x) [inline]

Definition at line 599 of file interval.hpp.

References is_infinite(), lower(), and upper().

                                             {
  return is_infinite (lower (x)) && is_infinite (upper (x)) &&
    lower (x) != upper (x); }
bool mmx::is_fuzz ( const affine< C, VC > &  z) [inline]

Definition at line 441 of file affine.hpp.

References base(), is_nan(), and slope().

Referenced by implementation< ball_abs, IV, ball_infinities< BV > >::abs(), implementation< ball_additive, IV, ball_infinities< BV > >::add(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::div(), flatten(), flatten_range(), implementation< ball_root, IV, ball_infinities< BV > >::hypot(), is_fuzz(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::mul(), and implementation< ball_additive, IV, ball_infinities< BV > >::sub().

                                           {
  return !is_nan (z) && (is_fuzz (base (z)) || is_fuzz (slope (z))); }
bool mmx::is_fuzz ( const tangent< C, D > &  z) [inline]

Definition at line 357 of file tangent.hpp.

References base(), is_fuzz(), is_nan(), and slope().

                                            {
  return !is_nan (z) && (is_fuzz (base (z)) || is_fuzz (slope (z))); }
bool mmx::is_fuzz ( const ball< C, R, V > &  z) [inline]

Definition at line 643 of file ball.hpp.

References center(), is_infinite(), is_nan(), and radius().

                                         {
  return !is_nan (center (z)) && is_infinite (radius (z)); }
bool mmx::is_fuzz ( const floating< V > &  x) [inline]

Definition at line 460 of file floating.hpp.

                                             {
  (void) x; return false; }
bool mmx::is_fuzz ( const twin< C, D, V > &  x) [inline]

Definition at line 272 of file twin.hpp.

References car(), and is_fuzz().

                                         {
  return is_fuzz (car (x)); }
bool mmx::is_fuzz ( const complex< C > &  z) [inline]

Definition at line 581 of file complex.hpp.

References Im(), is_fuzz(), is_nan(), and Re().

                                            {
  return !is_nan (z) && (is_fuzz (Re (z)) || is_fuzz (Im (z))); }
bool mmx::is_infinite ( const complex< C > &  z) [inline]

Definition at line 579 of file complex.hpp.

References Im(), is_infinite(), is_nan(), and Re().

                                                {
  return !is_nan (z) && (is_infinite (Re (z)) || is_infinite (Im (z))); }
bool mmx::is_infinite ( const interval< C, V > &  x) [inline]

Definition at line 597 of file interval.hpp.

References is_infinite(), lower(), and upper().

                                                 {
  return is_infinite (lower (x)) && upper (x) == lower (x); }
bool mmx::is_infinite ( const ball< C, R, V > &  z) [inline]

Definition at line 641 of file ball.hpp.

References center(), is_finite(), is_infinite(), and radius().

                                             {
  return is_infinite (center (z)) && is_finite (radius (z)); }
bool mmx::is_infinite ( const tangent< C, D > &  z) [inline]

Definition at line 355 of file tangent.hpp.

References base(), is_infinite(), is_nan(), and slope().

                                                {
  return !is_nan (z) && (is_infinite (base (z)) || is_infinite (slope (z))); }
bool mmx::is_infinite ( const floating< V > &  x) [inline]

Definition at line 458 of file floating.hpp.

                                                 {
  return mpfr_inf_p (*x) != 0; }
bool mmx::is_infinite ( const twin< C, D, V > &  x) [inline]

Definition at line 270 of file twin.hpp.

References car(), and is_infinite().

                                             {
  return is_infinite (car (x)); }
bool mmx::is_infinite ( const affine< C, VC > &  z) [inline]

Definition at line 439 of file affine.hpp.

References base(), is_nan(), and slope().

Referenced by implementation< ball_abs, IV, ball_infinities< BV > >::abs(), implementation< ball_additive, IV, ball_infinities< BV > >::add(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::div(), flatten(), GLUE_23(), GLUE_36(), GLUE_43(), GLUE_44(), GLUE_55(), is_fuzz(), is_infinite(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::mul(), implementation< ball_additive, IV, ball_infinities< BV > >::neg(), radius(), implementation< ball_root, IV, ball_infinities< BV > >::sqrt(), implementation< ball_root, IV, ball_complex< BV > >::sqrt(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::square(), and implementation< ball_additive, IV, ball_infinities< BV > >::sub().

                                               {
  return !is_nan (z) && (is_infinite (base (z)) || is_infinite (slope (z))); }
static bool mmx::is_integer ( const string &  s) [static]

Definition at line 196 of file string_scnot.cpp.

Referenced by flatten_number().

                             {
  nat i= 0;
  if (i<N(s) && s[i] == '-') i++;
  for (; i<N(s); i++)
    if (s[i] < '0' || s[i] > '9') return false;
  return true;
}
bool mmx::is_nan ( const complex< C > &  z) [inline]

Definition at line 577 of file complex.hpp.

References Im(), is_nan(), and Re().

                                           {
  return is_nan (Re (z)) || is_nan (Im (z)); }
bool mmx::is_nan ( const ball< C, R, V > &  z) [inline]

Definition at line 645 of file ball.hpp.

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

                                        {
  return is_nan (center (z)) || is_nan (radius (z)); }
bool mmx::is_nan ( const tangent< C, D > &  z) [inline]

Definition at line 353 of file tangent.hpp.

References base(), is_nan(), and slope().

                                           {
  return is_nan (base (z)) || is_nan (slope (z)); }
bool mmx::is_nan ( const floating< V > &  x) [inline]

Definition at line 462 of file floating.hpp.

                                            {
  return mpfr_nan_p (*x) != 0; }
bool mmx::is_nan ( const twin< C, D, V > &  x) [inline]

Definition at line 274 of file twin.hpp.

References car(), and is_nan().

                                        {
  return is_nan (car (x)); }
bool mmx::is_nan ( const affine< C, VC > &  z) [inline]

Definition at line 437 of file affine.hpp.

References base(), and slope().

Referenced by abs(), implementation< ball_additive, IV, ball_infinities< BV > >::add(), cosh(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::div(), flatten(), flatten_range(), GLUE_24(), GLUE_37(), GLUE_44(), GLUE_45(), GLUE_56(), implementation< ball_root, IV, ball_infinities< BV > >::hypot(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::invert(), is_fuzz(), is_infinite(), is_nan(), is_negative(), is_negative_or_zero(), is_non_zero(), is_positive(), is_positive_or_zero(), is_zero(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::mul(), operator!=(), operator<(), operator<=(), operator==(), operator>(), operator>=(), and implementation< ball_additive, IV, ball_infinities< BV > >::sub().

                                          {
  return is_nan (base (z)) || is_nan (slope (z)); }
bool mmx::is_nan ( const interval< C, V > &  x) [inline]

Definition at line 602 of file interval.hpp.

References is_nan(), lower(), and upper().

                                            {
  return is_nan (lower (x)) || is_nan (upper (x)); }
bool mmx::is_negative ( const ball< C, R, V > &  z) [inline]

Definition at line 267 of file ball.hpp.

References bnd_up(), center(), and is_nan().

Referenced by operator<().

                            {
  return !is_nan (center (z)) && bnd_up (z) < 0;
}
bool mmx::is_negative_or_zero ( const ball< C, R, V > &  z) [inline]

Definition at line 262 of file ball.hpp.

References bnd_down(), center(), and is_nan().

Referenced by implementation< ball_elementary, W, ball_rounded >::log(), operator<=(), implementation< ball_root, W, ball_rounded >::sqrt(), and implementation< ball_root, IV, ball_infinities< BV > >::sqrt().

                                    {
  return !is_nan (center (z)) && bnd_down (z) <= 0;
}
bool mmx::is_non_zero ( const interval< C, V > &  x) [inline]

Definition at line 215 of file interval.hpp.

References is_finite(), lower(), sign(), and upper().

                                {
  return !is_finite (x) || sign (lower (x)) * sign (upper (x)) > 0;
}
bool mmx::is_non_zero ( const ball< C, R, V > &  z) [inline]

Definition at line 256 of file ball.hpp.

References abs_down(), center(), is_nan(), and radius().

                            {
  return is_nan (center (z)) || is_nan (radius (z)) ||
         abs_down (z) != 0;
}
bool mmx::is_positive ( const ball< C, R, V > &  z) [inline]

Definition at line 277 of file ball.hpp.

References bnd_down(), center(), and is_nan().

Referenced by operator>().

                            {
  return !is_nan (center (z)) && bnd_down (z) > 0;
}
bool mmx::is_positive_or_zero ( const ball< C, R, V > &  z) [inline]

Definition at line 272 of file ball.hpp.

References bnd_up(), center(), and is_nan().

Referenced by operator>=().

                                    {
  return !is_nan (center (z)) && bnd_up (z) >= 0;
}
bool mmx::is_probable_prime ( const integer &  i) [inline]

Definition at line 1148 of file integer.hpp.

Referenced by GLUE_28(), probable_next_prime(), and probable_previous_prime().

                                                 {
  int n= 5, b;
  while ((b= mpz_probab_prime_p (*i, n)) == 1 && n < 10) n++;
  return b != 0;
}
bool mmx::is_reliable ( const twin< C, D, V > &  x) [inline]

Definition at line 276 of file twin.hpp.

References car(), and is_reliable().

                                             {
  return is_reliable (car (x)); }
bool mmx::is_reliable ( const complex< C > &  z) [inline]

Definition at line 583 of file complex.hpp.

References is_reliable(), and Re().

                                                {
  return is_reliable (Re (z)); }
bool mmx::is_reliable ( const ball< C, R, V > &  z) [inline]

Definition at line 647 of file ball.hpp.

                                             {
  (void) z; return true; }
bool mmx::is_reliable ( const tangent< C, D > &  z) [inline]

Definition at line 359 of file tangent.hpp.

References base(), and is_reliable().

                                                {
  return is_reliable (base (z)); }
bool mmx::is_reliable ( const floating< V > &  x) [inline]

Definition at line 464 of file floating.hpp.

                                                 {
  (void) x; return false; }
bool mmx::is_reliable ( const interval< C, V > &  x) [inline]

Definition at line 604 of file interval.hpp.

                                                 {
  (void) x; return true; }
bool mmx::is_reliable ( const affine< C, VC > &  z) [inline]

Definition at line 443 of file affine.hpp.

References base().

Referenced by is_reliable().

                                               {
  return is_reliable (base (z)); }
bool mmx::is_zero ( const interval< C, V > &  x) [inline]

Definition at line 210 of file interval.hpp.

References is_finite(), lower(), sign(), and upper().

                            {
  return is_finite (x) && sign (lower (x)) * sign (upper (x)) <= 0;
}
bool mmx::is_zero ( const floating< V > &  x) [inline]

Definition at line 344 of file floating.hpp.

                                             {
  return mpfr_zero_p (*x) != 0; }
bool mmx::is_zero ( const ball< C, R, V > &  z) [inline]

Definition at line 250 of file ball.hpp.

References abs_down(), center(), is_nan(), and radius().

Referenced by implementation< ball_multiplicative, IV, ball_infinities< BV > >::div(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::invert(), implementation< ball_elementary, IV, ball_complex< BV > >::log(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::mul(), operator/(), and implementation< ball_root, IV, ball_complex< BV > >::sqrt().

                        {
  return !is_nan (center (z)) && !is_nan (radius (z)) &&
         abs_down (z) == 0;
}
modular<M,V> mmx::lcm ( const modular< M, V > &  a,
const modular< M, V > &  b 
) [inline]

Definition at line 278 of file modular.hpp.

Referenced by GLUE_18(), and GLUE_19().

                                         {
  return a * b; }
bool mmx::less_prec ( const rational &  q,
unsigned  prec 
) [inline]

Definition at line 162 of file kernel.hpp.

  {
    integer n;
    if(q<0)
      n=-(numerator(q)<<prec);
    else
      n=numerator(q)<<prec;
    return (n<denominator(q));
  }
integer mmx::lift ( const modular< modulus< unsigned char, V >, W > &  x) [inline]

Definition at line 1081 of file modular_int.hpp.

integer mmx::lift ( const modular< modulus< int, V >, W > &  x) [inline]

Definition at line 1086 of file modular_int.hpp.

integer mmx::lift ( const modular< modulus< unsigned short int, V >, W > &  x) [inline]

Definition at line 1083 of file modular_int.hpp.

integer mmx::lift ( const modular< modulus< long long int, V >, W > &  x) [inline]

Definition at line 1090 of file modular_int.hpp.

integer mmx::lift ( const modular< modulus< unsigned int, V >, W > &  x) [inline]

Definition at line 1085 of file modular_int.hpp.

integer mmx::lift ( const modular< modulus< long int, V >, W > &  x) [inline]

Definition at line 1088 of file modular_int.hpp.

integer mmx::lift ( const modular< modulus< signed char, V >, W > &  x) [inline]

Definition at line 1082 of file modular_int.hpp.

integer mmx::lift ( const modular< modulus< signed short int, V >, W > &  x) [inline]

Definition at line 1084 of file modular_int.hpp.

integer mmx::lift ( const modular< modulus< unsigned long int, V >, W > &  x) [inline]

Definition at line 1087 of file modular_int.hpp.

modular<M,V>::C mmx::lift ( const modular< M, V > &  x) [inline]

Definition at line 143 of file modular.hpp.

{ return *x; }
integer mmx::lift ( const modular< modulus< unsigned long long int, V >, W > &  x) [inline]

Definition at line 1089 of file modular_int.hpp.

affine_limits_helper< C, VC >::VT limits ( const affine< C, VC > &  z) [inline]

Definition at line 108 of file affine.hpp.

Referenced by abs(), additive_error(), binary_test(), blur(), change_precision(), common_limits(), copy(), binary_helper< affine< C, VC > >::disassemble(), domain(), duplicate(), flatten(), Im(), operator*(), operator+(), operator-(), operator/(), operator<<(), operator>>(), Re(), sharpen(), square(), truncate(), unary_hash(), and binary_helper< affine< C, VC > >::write().

                                        {
  return z.lim; }
twin<C,D,V> mmx::log ( const twin< C, D, V > &  x)

Definition at line 229 of file twin.hpp.

References car(), cdr(), log(), and Twin.

                              {
  return Twin (log (car (x)), log (cdr (x))); }
interval<C,V> mmx::log ( const interval< C, V > &  x)

Definition at line 486 of file interval.hpp.

References Interval, log(), lower(), and upper().

                        {
  return Interval (Down::log (lower (x)), Up::log (upper (x)));
}
ball<C,R,V> mmx::log ( const ball< C, R, V > &  z) [inline]
Examples:
ball_test.cpp, complex_ball_test.cpp, complex_test.cpp, and interval_test.cpp.

Definition at line 488 of file ball.hpp.

References Ball, C, Elementary_variant, and V.

Referenced by GLUE_13(), GLUE_14(), GLUE_18(), GLUE_24(), GLUE_27(), GLUE_46(), log(), mpfr_get_magnitude(), and pow().

                    {
  typedef Elementary_variant(C,V) EV;
  typedef implementation<ball_elementary,EV> Impl;
  Ball d; Impl::log (d, z); return d;
}
tangent<C,D> mmx::log ( const tangent< C, D > &  z) [inline]

Definition at line 242 of file tangent.hpp.

References base(), invert(), log(), slope(), and Tangent.

                       {
  return Tangent (log (base (z)), invert (base (z)) * slope (z));
}
floating<V> mmx::log ( const floating< V > &  x1) [inline]

Definition at line 409 of file floating.hpp.

References Floating, and Rnd.

                                              {
  Floating r (*x1); mpfr_log (*r, *x1, Rnd); return r; }
complex<C> mmx::log ( const complex< C > &  z) [inline]

Definition at line 471 of file complex.hpp.

References abs(), arg(), Complex, and log().

                       {
  return Complex (log (abs (z)), arg (z));
}
floating<V> mmx::log10 ( const floating< V > &  x1) [inline]

Definition at line 413 of file floating.hpp.

References Floating, and Rnd.

                                                {
  Floating r (*x1); mpfr_log10 (*r, *x1, Rnd); return r; }
floating<V> mmx::log2 ( const floating< V > &  x1) [inline]

Definition at line 411 of file floating.hpp.

References Floating, and Rnd.

                                               {
  Floating r (*x1); mpfr_log2 (*r, *x1, Rnd); return r; }
C lower ( const interval< C, V > &  z) [inline]

Definition at line 109 of file interval.hpp.

{ return x.l; }
C mmx::lower ( const ball< C, R, V > &  z) [inline]

Definition at line 109 of file ball.hpp.

References Rnd.

Referenced by abs(), abs_down(), acos(), asin(), atan(), atan2(), binary_test(), bnd_down(), ceil(), implementation< ball_ordered, W, ball_rounded >::ceil(), center(), CF(), change_precision(), copy(), cos(), cosh(), binary_helper< interval< C, V > >::disassemble(), duplicate(), exp(), exponent(), flatten(), flatten_range(), floor(), implementation< ball_ordered, W, ball_rounded >::floor(), GLUE_4(), intersect(), is_exact_zero(), is_finite(), is_fuzz(), is_infinite(), is_nan(), is_non_zero(), is_zero(), log(), magnitude(), map(), max(), min(), operator!=(), operator*(), operator+(), interval< C, V >::operator+=(), operator-(), interval< C, V >::operator-=(), operator/(), operator<(), operator<<(), operator<=(), operator==(), operator>(), operator>=(), operator>>(), precision(), radius(), round(), implementation< ball_ordered, W, ball_rounded >::round(), sin(), singleton(), sinh(), sqrt(), square(), trunc(), implementation< ball_ordered, W, ball_rounded >::trunc(), unary_hash(), and binary_helper< interval< C, V > >::write().

                                    {
  typedef implementation<ball_rounding,V> Rnd;
  return Rnd::lower (z); }
double mmx::magnitude ( const affine< C, VC > &  z) [inline]

Definition at line 457 of file affine.hpp.

References base().

Referenced by GLUE_28(), GLUE_41(), GLUE_49(), GLUE_50(), GLUE_60(), and magnitude().

                                               {
  return magnitude (base (z)); }
double mmx::magnitude ( const twin< C, D, V > &  x) [inline]

Definition at line 286 of file twin.hpp.

References car(), and magnitude().

                                             {
  return magnitude (car (x)); }
double mmx::magnitude ( const interval< C, V > &  x) [inline]

Definition at line 615 of file interval.hpp.

References lower(), magnitude(), max(), and upper().

                                                 {
  return max (magnitude (lower (x)), magnitude (upper (x))); }
double mmx::magnitude ( const ball< C, R, V > &  z) [inline]

Definition at line 663 of file ball.hpp.

References center(), magnitude(), max(), and radius().

                                             {
  return max (magnitude (center (z)), magnitude (radius (z))); }
double mmx::magnitude ( const complex< C > &  z) [inline]

Definition at line 621 of file complex.hpp.

References Im(), magnitude(), Re(), and square().

                                                {
  return magnitude (square (Re(z)) + square (Im(z))) / 2.0; }
double mmx::magnitude ( const tangent< C, D > &  z) [inline]

Definition at line 370 of file tangent.hpp.

References base(), and magnitude().

                                                {
  return magnitude (base (z)); }
double mmx::magnitude ( const floating< V > &  x) [inline]

Definition at line 492 of file floating.hpp.

References mpfr_get_magnitude().

                                                 {
  return mpfr_get_magnitude (*x); }
affine<C,VC> mmx::make_affine ( const C &  cst,
const VC &  lin,
const VC &  dom 
) [inline]

Definition at line 121 of file affine.hpp.

References Affine.

                                                                            {
  typedef affine_limits_helper<C,VC> Helper;
  return Affine (cst, Helper::get_linear (lin, dom),
                 Helper::get_limits (dom)); }
ball<C> mmx::make_mmx_ball ( const C &  c,
const R &  r 
) [inline]

Definition at line 695 of file ball.hpp.

Referenced by mmx_ball().

                                       {
  return ball<C> (c, as<Default_radius_type(C) > (r), true);
}
ball<C> mmx::make_mmx_ball ( const C &  c) [inline]

Definition at line 700 of file ball.hpp.

References abs(), and promote().

                           {
  return ball<C> (c, as<Default_radius_type(C) > (promote (0, abs (c))));
}
string make_range ( const string &  l,
const string &  r 
)

Definition at line 131 of file string_scnot.cpp.

References as_string(), decompose(), and recompose().

Referenced by flatten_range().

                                                {
  int     sign1, sign2;
  string  mant1, mant2;
  integer expo1, expo2;
  decompose (s1, sign1, mant1, expo1);
  decompose (s2, sign2, mant2, expo2);
  if (locase (mant1) == "nan" || locase (mant2) == "nan") return "NaN";
  if (locase (mant1) == "infty" || locase (mant2) == "infty") {
    if (mant1 == mant2 && sign1 == sign2)
      return recompose (sign1, mant1, expo1);
    return "Fuzz";
  }
  if (sign1 != sign2) {
    integer expo= expo1;
    if (sign1 == 0 || (sign2 != 0 && expo2 > expo1)) expo= expo2;
    return "0e" * as_string (expo+1);
  }
  if (sign1 == 0) return "0";
  if (sign1 < 0) return "-" * make_range (mant2, expo2, mant1, expo1);
  else return make_range (mant1, expo1, mant2, expo2);
}
static string mmx::make_range ( string &  mant1,
integer &  expo1,
string &  mant2,
integer &  expo2 
) [static]

Definition at line 95 of file string_scnot.cpp.

References as_string(), inc_mantissa(), min(), and recompose().

{
  if (expo2 == expo1 + 1) {
    mant1= "0" * mant1;
    expo1= expo1 + 1;
  }
  if (expo2 != expo1) return "0e" * as_string (expo2 + 1);

  nat i, n= min (N(mant1), N(mant2));
  for (i=0; i<n; i++)
    if (mant1[i] != mant2[i]) {
      if (mant2[i] == mant1[i] + 1) {
        i++;
        while (i<n && (mant1[i] == '9' && mant2[i] == '0')) i++;
        if (i >= n ||
            (mant1[i] >= '0' && mant1[i] <= '4') ||
            (mant2[i] >= '5' && mant2[i] <= '9')) i--;
      }
      break;
    }
  string mant2b= mant2 (0, i);
  if (i>0 && mant1[i-1] == mant2[i-1]) {
    if (i<N(mant1) && mant1[i] >= '5')
      inc_mantissa (mant2b, expo2);
    else if (i<N(mant2) && mant2[i] >= '5') {
      bool inc= (i != 0 && mant2[i-1] >= '5');
      mant2b= mant2b (0, N(mant2b) - 1);
      if (inc) inc_mantissa (mant2b, expo2);
    }
  }
  if (mant2b == "") return "0e" * as_string (expo2 + 1);
  else return recompose (1, mant2b, expo2);
}
scalar_set<C> mmx::make_set ( const C &  c) [inline]

Definition at line 57 of file kernel.hpp.

                                                              { 
    return scalar_set<C>(); 
  }
complex<D> mmx::map ( D(*)(const S1 &)  fun,
const complex< S1 > &  z 
)

Definition at line 136 of file complex.hpp.

References Im(), and Re().

                                                 {
  return complex<D> (fun (Re (z)), fun (Im (z)));
}
complex<D> mmx::map ( const function_1< D, Argument(S1) > &  fun,
const complex< S1 > &  z 
)

Definition at line 131 of file complex.hpp.

References Im(), and Re().

                                                                   {
  return complex<D> (fun (Re (z)), fun (Im (z)));
}
twin<CD,DD> mmx::map ( const function_1< CD, Argument(CS) > &  funC,
const function_1< DD, Argument(DS) > &  funD,
const twin< CS, DS > &  z,
const format< CD > &  fmC,
const format< DD > &  fmD 
)

Definition at line 102 of file twin.hpp.

References car(), and cdr().

                            {
  return twin<CD,DD> (funC (car (z)), funD (cdr (z)));
}
interval<D> mmx::map ( D(*)(const S1 &)  fun,
const interval< S1 > &  x 
)

Definition at line 155 of file interval.hpp.

References lower(), and upper().

                                                  {
  return interval<D> (fun (lower (x)), fun (upper (x)));
}
tangent<CD,DD> mmx::map ( const function_1< CD, Argument(CS) > &  funC,
const function_1< DD, Argument(DS) > &  funD,
const tangent< CS, DS > &  z,
const format< CD > &  fmC,
const format< DD > &  fmD 
)

Definition at line 94 of file tangent.hpp.

References base(), and slope().

                            {
  return tangent<CD,DD> (funC (base (z)), funD (slope (z)));
}
affine<CD,DD> mmx::map ( const function_1< CD, Argument(CS) > &  funC,
const function_1< DD, Argument(DS) > &  funD,
const affine< CS, DS > &  z,
const format< CD > &  fmC,
const format< DD > &  fmD 
)

Definition at line 151 of file affine.hpp.

References base(), and slope().

                            {
  return affine<CD,DD> (funC (base (z)), funD (slope (z)));
}
interval<D> mmx::map ( const function_1< D, Argument(S1) > &  fun,
const interval< S1 > &  x 
)

Definition at line 150 of file interval.hpp.

References lower(), and upper().

                                                                    {
  return interval<D> (fun (lower (x)), fun (upper (x)));
}
interval<C,V> mmx::max ( const interval< C, V > &  x1,
const interval< C, V > &  x2 
)

Definition at line 276 of file interval.hpp.

References Interval, lower(), max(), and upper().

                                             {
  return Interval (max (lower (x1), lower (x2)), max (upper (x1), upper (x2)));
}
affine<C,VC> mmx::max ( const affine< C, VC > &  z1,
const affine< C, VC > &  z2 
)
Examples:
ball_test.cpp, and interval_test.cpp.

Definition at line 424 of file affine.hpp.

Referenced by abs(), cos(), implementation< ball_elementary, W, ball_rounded >::cos(), cosh(), exponent(), GLUE_25(), GLUE_26(), GLUE_37(), GLUE_38(), intersect(), implementation< ball_multiplicative, W, ball_rough >::invert(), magnitude(), implementation< ball_rounding, W, ball_rounded >::make_interval(), max(), mpfr_to_string(), operator*(), std_floating::prec(), sin(), implementation< ball_elementary, W, ball_rounded >::sin(), square(), and make_interval_helper< ball< C, R, V >, C2 >::val().

                                         {
  if (z1 >= z2) return z1; else return z2;
}
tangent<C,D> mmx::max ( const tangent< C, D > &  z1,
const tangent< C, D > &  z2 
)

Definition at line 340 of file tangent.hpp.

                                           {
  if (z1 >= z2) return z1; else return z2;
}
floating<V> mmx::max ( const floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 379 of file floating.hpp.

                                                                  {
  return x1 >= x2? x1: x2; }
ball<C,R,V> mmx::max ( const ball< C, R, V > &  z1,
const ball< C, R, V > &  z2 
) [inline]

Definition at line 606 of file ball.hpp.

References Ball, and max().

                                     {
  typedef implementation<ball_ordered,V> Impl;
  Ball d; Impl::max (d, z1, z2); return d;
}
ball<C,R,V> mmx::min ( const ball< C, R, V > &  z1,
const ball< C, R, V > &  z2 
) [inline]

Definition at line 600 of file ball.hpp.

References Ball, and min().

                                     {
  typedef implementation<ball_ordered,V> Impl;
  Ball d; Impl::min (d, z1, z2); return d;
}
tangent<C,D> mmx::min ( const tangent< C, D > &  z1,
const tangent< C, D > &  z2 
) [inline]

Definition at line 335 of file tangent.hpp.

                                           {
  if (z1 <= z2) return z1; else return z2;
}
affine<C,VC> mmx::min ( const affine< C, VC > &  z1,
const affine< C, VC > &  z2 
) [inline]
Examples:
ball_test.cpp, and interval_test.cpp.

Definition at line 419 of file affine.hpp.

Referenced by abs(), cos(), GLUE_24(), GLUE_25(), GLUE_36(), GLUE_37(), intersect(), make_range(), min(), modulus_mul_int_preinverse< V >::mul_mod_helper< C, void, m >::op(), operator*(), std_floating::prec(), precision(), sin(), and trunc_digits().

                                         {
  if (z1 <= z2) return z1; else return z2;
}
floating<V> mmx::min ( const floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 377 of file floating.hpp.

                                                                  {
  return x1 <= x2? x1: x2; }
interval<C,V> mmx::min ( const interval< C, V > &  x1,
const interval< C, V > &  x2 
)

Definition at line 271 of file interval.hpp.

References Interval, lower(), min(), and upper().

                                             {
  return Interval (min (lower (x1), lower (x2)), min (upper (x1), upper (x2)));
}
static mmx_ball ( mmx_floating  ,
mmx_floating   
) const [static]

Definition at line 15 of file glue_ball_floating.cpp.

References make_mmx_ball().

                                     {
    return make_mmx_ball (arg_1);
  }
static mmx_ball ( double  ,
double   
) const [static]

Definition at line 14 of file glue_ball_double.cpp.

References make_mmx_ball().

                               {
    return make_mmx_ball (arg_1);
  }
static mmx::mmx_modular ( int  ) const [static]
void mpfr_binary_read ( const port &  p,
mpfr_t  dest 
)

Definition at line 102 of file mmx_mpfr.cpp.

References BITS_PER_LIMB.

Referenced by binary_helper< floating< V > >::read().

                                              {
  mpfr_prec_t pr= binary_read<mpfr_prec_t> (p);
  mpfr_sign_t si= binary_read<mpfr_sign_t> (p);
  mp_exp_t    ex= binary_read<mp_exp_t   > (p);
  mpfr_set_prec (dest, pr);
  xnat n= (pr + BITS_PER_LIMB - 1) / BITS_PER_LIMB;
  for (xnat i=0; i<n; i++)
    dest->_mpfr_d[i]= binary_read<mp_limb_t> (p);
  dest->_mpfr_prec= pr;
  dest->_mpfr_sign= si;
  dest->_mpfr_exp = ex;
}
void mpfr_binary_write ( const port &  p,
const mpfr_t  arg 
)

Definition at line 92 of file mmx_mpfr.cpp.

References BITS_PER_LIMB.

Referenced by binary_helper< floating< V > >::write().

                                                    {
  binary_write<mpfr_prec_t> (p, arg->_mpfr_prec);
  binary_write<mpfr_sign_t> (p, arg->_mpfr_sign);
  binary_write<mp_exp_t   > (p, arg->_mpfr_exp );
  xnat n= (arg->_mpfr_prec + BITS_PER_LIMB - 1) / BITS_PER_LIMB;
  for (xnat i=0; i<n; i++)
    binary_write<mp_limb_t> (p, arg->_mpfr_d[i]);
}
string mpfr_double_as_string ( double  x)

Definition at line 72 of file mmx_mpfr.cpp.

References mpfr_to_string(), and trunc_digits().

Referenced by numerix_instance::numerix_instance().

                                 {
  mpfr_t aux;
  mpfr_init2 (aux, 64);
  mpfr_set_d (aux, x, GMP_RNDN);
  string r= mpfr_to_string (aux, 50);
  mpfr_clear (aux);
  return trunc_digits (r, 14);
}
double mpfr_get_magnitude ( const mpfr_t  arg)

Definition at line 27 of file mmx_mpfr.cpp.

References log().

Referenced by magnitude().

                                      {
  if (mpfr_inf_p (arg) || !mpfr_number_p (arg))
    return (double) mpfr_get_emax ();
  if (mpfr_sgn (arg) == 0)
    return (double) mpfr_get_emin ();
  mp_exp_t expo= mpfr_get_exp (arg);
  mpfr_t aux;
  mpfr_init2 (aux, mpfr_get_prec (arg));
  mpfr_div_2si (aux, arg, expo, GMP_RNDN);
  mpfr_abs (aux, aux, GMP_RNDN);
  return ((double) expo) + log (mpfr_get_d (aux, GMP_RNDU)) / log (2.0);
  //return ((double) expo) + log2 (mpfr_get_d (aux, GMP_RNDU));
}
mp_exp_t mmx::mpfr_get_step ( const mpfr_t  arg) [inline]

Definition at line 60 of file mmx_mpfr.hpp.

                                                 {
  return mpfr_get_exp (arg) - mpfr_get_prec (arg); }
xnat mmx::mpfr_prec_round_up ( xnat  prec) [inline]

Definition at line 58 of file mmx_mpfr.hpp.

References BITS_PER_LIMB.

                                           {
  return BITS_PER_LIMB * ((prec + BITS_PER_LIMB - 1) / BITS_PER_LIMB); }
mp_exp_t mmx::mpfr_safe_get_exp ( const mpfr_t  arg) [inline]

Definition at line 65 of file mmx_mpfr.hpp.

Referenced by exponent().

                                                     {
  if (mpfr_sgn (arg) == 0) return mpfr_get_emin ();
  else return mpfr_get_exp (arg); }
mp_exp_t mmx::mpfr_safe_get_step ( const mpfr_t  arg) [inline]

Definition at line 62 of file mmx_mpfr.hpp.

                                                      {
  if (mpfr_sgn (arg) == 0) return mpfr_get_emin ();
  else return mpfr_get_exp (arg) - mpfr_get_prec (arg); }
string mpfr_to_string ( const mpz_t  x)

Definition at line 42 of file mmx_mpfr.cpp.

Referenced by as_string(), binary_helper< floating< V > >::disassemble(), and mpfr_double_as_string().

                               {
  char* s= mpz_get_str (NULL, 10, x);
  string r= s;
  mpfr_free_str (s);
  return r;
}
string mpfr_to_string ( const mpfr_t  x,
xnat  bits = 0 
)

Definition at line 50 of file mmx_mpfr.cpp.

References as_string(), exponent(), max(), and trunc_digits().

                                           {
  string r;
  if (mpfr_nan_p (x) != 0) return "NaN";
  if (mpfr_inf_p (x) != 0) {
    if (mpfr_sgn (x) < 0) return "-Infty";
    return "Infty";
  }
  if (mpfr_zero_p (x) != 0) return "0";
  xnat digs= bits==0? 0: max (((int) (0.301029995 * bits)) - 1, 2);
  mp_exp_t exponent;
  char* mantissa_s= mpfr_get_str (NULL, &exponent, 10, digs, x, GMP_RNDN);
  int first= 0;
  if (mantissa_s[0] == '-') { r << "-"; first++; }
  r << mantissa_s[first];
  r << ".";
  r << (mantissa_s + (first + 1));
  r << "e" << as_string (exponent-1);
  mpfr_free_str (mantissa_s);
  return trunc_digits (r, 0);
}
void mmx::mpq_mul_2si ( mpq_t  dest,
const mpq_t  arg,
long int  shift 
) [inline]

Definition at line 40 of file mmx_gmp.hpp.

                                                                      {
  if (shift >= 0) mpq_mul_2exp (dest, arg, shift);
  else mpq_div_2exp (dest, arg, -shift); }
void mmx::mpz_add_si ( mpz_t  dest,
const mpz_t  arg,
long int  plus 
) [inline]

Definition at line 28 of file mmx_gmp.hpp.

                                                                    {
  if (plus >= 0) mpz_add_ui (dest, arg, plus);
  else mpz_sub_ui (dest, arg, -plus); }
void mpz_binary_read ( const port &  p,
mpz_t  dest 
)

Definition at line 62 of file mmx_gmp.cpp.

Referenced by binary_helper< integer >::read().

                                            {
  int n= binary_read<int> (p);
  nat a= (nat) (n<0? -n: n);
  (void) _mpz_realloc (dest, a);
  for (nat i=0; i<a; i++)
    dest->_mp_d[i]= binary_read<mp_limb_t> (p);
  dest->_mp_size= n;
}
void mpz_binary_write ( const port &  p,
const mpz_t  arg 
)

Definition at line 53 of file mmx_gmp.cpp.

Referenced by binary_helper< integer >::write().

                                                  {
  int n= arg->_mp_size;
  nat a= (nat) (n<0? -n: n);
  binary_write<int> (p, n);
  for (nat i=0; i<a; i++)
    binary_write<mp_limb_t> (p, arg->_mp_d[i]);
}
void mmx::mpz_mul_2si ( mpz_t  dest,
const mpz_t  arg,
long int  shift 
) [inline]

Definition at line 37 of file mmx_gmp.hpp.

                                                                      {
  if (shift >= 0) mpz_mul_2exp (dest, arg, shift);
  else mpz_fdiv_q_2exp (dest, arg, -shift); }
void mmx::mpz_si_sub ( mpz_t  dest,
long int  plus,
const mpz_t  arg 
) [inline]

Definition at line 34 of file mmx_gmp.hpp.

                                                                    {
  if (plus >= 0) mpz_ui_sub (dest, plus, arg);
  else { mpz_add_ui (dest, arg, -plus); mpz_neg (dest, dest); } }
void mmx::mpz_sub_si ( mpz_t  dest,
const mpz_t  arg,
long int  plus 
) [inline]

Definition at line 31 of file mmx_gmp.hpp.

                                                                    {
  if (plus >= 0) mpz_sub_ui (dest, arg, plus);
  else mpz_add_ui (dest, arg, -plus); }
void mmx::mul ( complex< C > &  r,
const complex< C > &  z,
const C &  c 
) [inline]

Definition at line 435 of file complex.hpp.

References Im(), mul(), and Re().

                                               {
  mul (Re (r), Re (z), c);
  mul (Im (r), Im (z), c);
}
void mmx::mul ( complex< C > &  r,
const C &  c,
const complex< C > &  z 
) [inline]

Definition at line 429 of file complex.hpp.

References Im(), and Re().

Referenced by implementation< ball_elementary, W, ball_rounded >::atan2(), implementation< ball_elementary, W, ball_rounded >::cos(), implementation< ball_elementary, IV, ball_complex< BV > >::cos(), implementation< ball_elementary, W, ball_rounded >::cosh(), implementation< ball_elementary, IV, ball_complex< BV > >::cosh(), implementation< ball_elementary, W, ball_rounded >::exp(), implementation< ball_elementary, IV, ball_complex< BV > >::exp(), mul(), implementation< ball_multiplicative, W, ball_rounded >::mul(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::mul(), operator*(), implementation< ball_elementary, W, ball_rounded >::sin(), implementation< ball_elementary, IV, ball_complex< BV > >::sin(), implementation< ball_elementary, W, ball_rounded >::sinh(), implementation< ball_elementary, IV, ball_complex< BV > >::sinh(), square(), and implementation< ball_multiplicative, W, ball_rounded >::square().

                                               {
  mul (Re (r), c, Re (z));
  mul (Im (r), c, Im (z));
}
void mmx::mul ( floating< V > &  r,
const floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 331 of file floating.hpp.

References Rnd.

                                                                            {
  r.secure (); mpfr_mul (*r, *x1, *x2, Rnd); }
void mmx::mul_add ( floating< V > &  r,
const floating< V > &  x,
const floating< V > &  y 
) [inline]

Definition at line 335 of file floating.hpp.

References Rnd.

                                                                             {
  r.secure (); mpfr_fma (*r, *x, *y, *r, Rnd); }
void mmx::mul_mod ( C &  dest,
const C &  s,
const modulus< C, V > &  m,
C &  carry 
) [inline]

Definition at line 154 of file modulus.hpp.

References mul_mod().

                                                          {
  V::mul_mod (dest, s, m, carry); }
void mmx::mul_mod ( C &  dest,
const C &  s1,
const C &  s2,
const modulus< C, V > &  m 
) [inline]

Definition at line 158 of file modulus.hpp.

References mul_mod().

                                                              {
  V::mul_mod (dest, s1, s2, m); }
void mmx::mul_mod ( C &  dest,
const C &  s1,
const C &  s2,
const modulus< C, V > &  m,
C &  carry 
) [inline]

Definition at line 162 of file modulus.hpp.

References mul_mod().

                                                                        {
  V::mul_mod (dest, s1, s2, m, carry); }
void mmx::mul_mod ( C &  dest,
const C &  s,
const modulus< C, V > &  m 
) [inline]

Definition at line 150 of file modulus.hpp.

Referenced by modulus_div_naive< modulus_inv_integer_naive< modulus_mul_naive< modulus_add_integer_naive< modulus_reduction_naive< modulus_normalization_integer_naive > > > > >::div_mod(), modulus_div_int_naive< modulus_inv_int_naive< modulus_mul_int_naive< modulus_add_int_naive< modulus_reduction_int_naive< modulus_normalization_int_naive< modulus_maximum_size_int< size > > > > > > >::div_mod(), mul_mod(), operator*(), and operator*=().

                                                {
  V::mul_mod (dest, s, m); }
ball<Abs_type(C),R,Abs_type(V) > mmx::multiplicative_error ( const ball< C, R, V > &  x) [inline]

Definition at line 656 of file ball.hpp.

References Abs_ball, and center().

Referenced by implementation< ball_rounding, W, ball_rounded >::add_multiplicative_error(), add_rough_multiplicative_error(), GLUE_46(), GLUE_55(), implementation< ball_multiplicative, W, ball_rounded >::invert(), implementation< ball_multiplicative, W, ball_rough >::invert(), and radius().

                                                          {
  return Abs_ball (multiplicative_error (center (x))); }
rational mmx::nearest ( const floating<> &  x,
int  prec 
) [inline]

Definition at line 172 of file kernel.hpp.

References as_integer(), and floor().

Referenced by as_helper< rational, floating<> >::cv().

  {
    integer er = integer(1)<<prec;

    floating<> r=(x>0?x:-x), f = floor(r);
    integer a=as_integer(f);
    
    integer n0=1, n1= a, tn=a;
    integer d0=0, d1= 1, td=1;
    
    for(;d0*d1<er && r!=f;)
      {
        r=1/(r-f); f = floor(r); 
        a=as_integer(f);
        n1*=a;n1+=n0;n0=tn;tn=n1;
        d1*=a;d1+=d0;d0=td;td=d1;
      }
    return (x>0? rational(n1)/d1: rational(-n1)/d1);
  }
void mmx::neg ( floating< V > &  r) [inline]

Definition at line 323 of file floating.hpp.

References Rnd.

                                   {
  r.secure (); mpfr_neg (*r, *r, Rnd); }
void mmx::neg ( floating< V > &  r,
const floating< V > &  x1 
) [inline]

Definition at line 325 of file floating.hpp.

References Rnd.

                                                       {
  r.secure (); mpfr_neg (*r, *x1, Rnd); }
void mmx::neg ( complex< C > &  r) [inline]

Definition at line 405 of file complex.hpp.

References Im(), and Re().

Referenced by neg(), implementation< ball_additive, IV, ball_infinities< BV > >::neg(), and operator-().

                 {
  neg (Re (r));
  neg (Im (r));
}
void mmx::neg ( complex< C > &  r,
const complex< C > &  z1 
) [inline]

Definition at line 411 of file complex.hpp.

References Im(), neg(), and Re().

                                    {
  neg (Re (r), Re (z1));
  neg (Im (r), Im (z1));
}
void mmx::neg_mod ( C &  dest,
const C &  s,
const modulus< C, V > &  m 
) [inline]

Definition at line 110 of file modulus.hpp.

References neg_mod().

                                                {
  V::neg_mod (dest, s, m); }
void mmx::neg_mod ( C &  dest,
const C &  s,
const modulus< C, V > &  m,
C &  carry 
) [inline]

Definition at line 114 of file modulus.hpp.

References neg_mod().

                                                          {
  V::neg_mod (dest, s, m, carry); }
void mmx::neg_mod ( C &  dest,
const modulus< C, V > &  m,
C &  carry 
) [inline]

Definition at line 106 of file modulus.hpp.

References neg_mod().

                                              {
  V::neg_mod (dest, m, carry); }
void mmx::neg_mod ( C &  dest,
const modulus< C, V > &  m 
) [inline]

Definition at line 102 of file modulus.hpp.

Referenced by neg_mod(), and operator-().

                                    {
  V::neg_mod (dest, m); }
floating<V> mmx::next_above ( const floating< V > &  x1) [inline]

Definition at line 471 of file floating.hpp.

References Floating, and Rnd.

Referenced by GLUE_47(), set_accuracy(), and make_interval_helper< ball< C, R, V >, C2 >::val().

                                                     {
  Floating r (*x1); mpfr_set (*r, *x1, Rnd);
  mpfr_nextabove (*r); return r; }
floating<V> mmx::next_below ( const floating< V > &  x1) [inline]

Definition at line 474 of file floating.hpp.

References Floating, and Rnd.

Referenced by GLUE_48().

                                                     {
  Floating r (*x1); mpfr_set (*r, *x1, Rnd);
  mpfr_nextbelow (*r); return r; }
C mmx::norm ( const complex< C > &  z) [inline]
Examples:
complex_test.cpp.

Definition at line 221 of file complex.hpp.

References Im(), Re(), and square().

Referenced by invert(), operator/(), and complex< C >::operator/=().

                        {
  return square (Re (z)) + square (Im (z));
}
bool mmx::operator!= ( const scalar_set< X > &  r1,
const scalar_set< X > &  r2 
)

Definition at line 49 of file kernel.hpp.

{ return !(r1==r2); }
bool mmx::operator!= ( const floating< V > &  x1,
const floating< V2 > &  x2 
) [inline]

Definition at line 349 of file floating.hpp.

                                                                        {
  return mpfr_equal_p (*x1, *x2) == 0; }
bool mmx::operator!= ( const floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 362 of file floating.hpp.

                                                                      {
  return mpfr_equal_p (*x1, *x2) == 0; }
bool mmx::operator!= ( const twin< C, D, V > &  x,
const twin< C, D, V > &  y 
)

Definition at line 136 of file twin.hpp.

References car().

                                                     {
  return car (x) != car (y); }
bool mmx::operator!= ( const ball< C, R, V > &  z1,
const ball< C, R, V > &  z2 
)

Definition at line 289 of file ball.hpp.

References abs_down(), Ball, and is_nan().

                                             {
  if (is_nan (z1) || is_nan (z2)) return !(is_nan (z1) && is_nan (z2));
  Ball d= z1 - z2;
  return abs_down (d) != 0;
}
bool mmx::operator!= ( const interval< C, V > &  x1,
const interval< C, V > &  x2 
) [inline]

Definition at line 226 of file interval.hpp.

References is_nan(), lower(), and upper().

                                                     {
  if (is_nan (x1) || is_nan (x2)) return !(is_nan (x1) && is_nan (x2));
  return lower (x1) > upper (x2) || lower (x2) > upper (x1);
}
ball<C,R,V> mmx::operator* ( const ball< C, R, V > &  z1,
const ball< C, R, V > &  z2 
) [inline]

Definition at line 398 of file ball.hpp.

References Ball, and mul().

                                            {
  typedef implementation<ball_multiplicative,V> Impl;
  Ball d; Impl::mul (d, z1, z2); return d;
}
complex<C> mmx::operator* ( const complex< C > &  z1,
const complex< C > &  z2 
) [inline]

Definition at line 317 of file complex.hpp.

References Complex, Im(), and Re().

                                                  {
  return Complex (Re (z1) * Re (z2) - Im (z1) * Im (z2),
                  Re (z1) * Im (z2) + Im (z1) * Re (z2));
}
interval<C,V> mmx::operator* ( const interval< C, V > &  x1,
const interval< C, V > &  x2 
)

Definition at line 373 of file interval.hpp.

References Interval, lower(), max(), min(), mul(), and upper().

                                                    {
  if (lower (x1) >= 0)
    return Interval (lower (x2) >= 0?
                     Down::mul (lower (x1), lower (x2)):
                     Down::mul (upper (x1), lower (x2)),
                     upper (x2) >= 0?
                     Up::mul (upper (x1), upper (x2)):
                     Up::mul (lower (x1), upper (x2)));
  else if (upper (x1) <= 0)
    return Interval (upper (x2) >= 0?
                     Down::mul (lower (x1), upper (x2)):
                     Down::mul (upper (x1), upper (x2)),
                     lower (x2) >= 0?
                     Up::mul (upper (x1), lower (x2)):
                     Up::mul (lower (x1), lower (x2)));
  else if (lower (x2) >= 0)
    return Interval (Down::mul (lower (x1), upper (x2)),
                     Up::mul (upper (x1), upper (x2)));
  else if (upper (x2) <= 0)
    return Interval (Down::mul (upper (x1), lower (x2)),
                     Up::mul (lower (x1), lower (x2)));
  else
    return Interval (min (Down::mul (lower (x1), upper (x2)),
                          Down::mul (upper (x1), lower (x2))),
                     max (Up::mul (lower (x1), lower (x2)),
                          Up::mul (upper (x1), upper (x2))));
}
interval<C,V> mmx::operator* ( const interval< C, V > &  x1,
const C &  x2 
) [inline]

Definition at line 401 of file interval.hpp.

References Interval.

                                                                  {
  return x1 * Interval (x2); }
complex<C> mmx::operator* ( const C &  x,
const complex< C > &  z 
) [inline]

Definition at line 307 of file complex.hpp.

References Complex, Im(), and Re().

                                          {
  return Complex (x * Re (z), x * Im (z));
}
affine<C,VC> mmx::operator* ( const affine< C, VC > &  z1,
const affine< C, VC > &  z2 
) [inline]

Definition at line 255 of file affine.hpp.

References Affine, base(), common_limits(), slope(), truncate(), and VR.

                                                {
  VR lim= common_limits (z1, z2);
  return Affine (base (z1) * base (z2),
                 truncate (z1) * slope (z2) + slope (z1) * truncate (z2), lim);
}
ball<C,R,V> mmx::operator* ( const C &  z1,
const ball< C, R, V > &  z2 
) [inline]

Definition at line 410 of file ball.hpp.

References Ball, and mul().

                                         {
  typedef implementation<ball_multiplicative,V> Impl;
  Ball d; Impl::mul (d, z1, z2); return d;
}
modular<M,V> mmx::operator* ( const modular< M, V > &  a,
const typename M::base &  b 
) [inline]

Definition at line 241 of file modular.hpp.

References Modular.

                                                       {
  return a * Modular (b); }
modular<M,modular_local> mmx::operator* ( const modular< M, modular_local > &  a,
const modular< M, modular_local > &  b 
) [inline]

Definition at line 474 of file modular.hpp.

References get_modulus(), Modular, and mul_mod().

                                                {
  M ma= get_modulus (a), mb= get_modulus (b);
  M mod= ma == 0 ? mb : ma;
  VERIFY (ma == 0 || mb == 0 || ma == mb, "incompatible moduli");
  Modular c;
  mul_mod (c.rep, a.rep, b.rep, mod);
  c.mod= mod;
  return c; }
modular<M,V> mmx::operator* ( const modular< M, V > &  a,
const modular< M, V > &  b 
) [inline]

Definition at line 235 of file modular.hpp.

References get_modulus(), Modular, and mul_mod().

                                                {
  Modular c;
  mul_mod (c.rep, a.rep, b.rep, Modular::get_modulus ());
  return c; }
complex<C> mmx::operator* ( const complex< C > &  z,
const C &  x 
) [inline]

Definition at line 312 of file complex.hpp.

References Complex, Im(), and Re().

                                          {
  return Complex (Re (z) * x, Im (z) * x);
}
interval<C,V> mmx::operator* ( const C &  x1,
const interval< C, V > &  x2 
) [inline]

Definition at line 403 of file interval.hpp.

References Interval.

                                                                  {
  return Interval (x1) * x2; }
floating<V> mmx::operator* ( const floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 304 of file floating.hpp.

References Floating, and Rnd.

                                                                         {
  Floating r (*x1, *x2); mpfr_mul (*r, *x1, *x2, Rnd); return r; }
tangent<C,D> mmx::operator* ( const tangent< C, D > &  z1,
const tangent< C, D > &  z2 
) [inline]

Definition at line 178 of file tangent.hpp.

References base(), slope(), and Tangent.

                                                  {
  return Tangent (base (z1) * base (z2),
                  base (z1) * slope (z2) + slope (z1) * base (z2));
}
tangent<C,D> mmx::operator* ( const C &  z1,
const tangent< C, D > &  z2 
) [inline]

Definition at line 184 of file tangent.hpp.

References base(), slope(), and Tangent.

                                            {
  return Tangent (z1 * base (z2), z1 * slope (z2));
}
tangent<C,D> mmx::operator* ( const tangent< C, D > &  z1,
const C &  z2 
) [inline]

Definition at line 189 of file tangent.hpp.

References base(), slope(), and Tangent.

                                            {
  return Tangent (base (z1) * z2, slope (z1) * z2);
}
affine<C,VC> mmx::operator* ( const affine< C, VC > &  z1,
const C &  z2 
) [inline]

Definition at line 267 of file affine.hpp.

References Affine, base(), limits(), and slope().

                                           {
  return Affine (base (z1) * z2, slope (z1) * z2, limits (z1));
}
affine<C,VC> mmx::operator* ( const C &  z1,
const affine< C, VC > &  z2 
) [inline]

Definition at line 262 of file affine.hpp.

References Affine, base(), limits(), and slope().

                                           {
  return Affine (z1 * base (z2), z1 * slope (z2), limits (z2));
}
ball<C,R,V> mmx::operator* ( const ball< C, R, V > &  z1,
const C &  z2 
) [inline]

Definition at line 404 of file ball.hpp.

References Ball, and mul().

                                         {
  typedef implementation<ball_multiplicative,V> Impl;
  Ball d; Impl::mul (d, z1, z2); return d;
}
twin<C,D,V> mmx::operator* ( const twin< C, D, V > &  x1,
const twin< C, D, V > &  x2 
) [inline]

Definition at line 210 of file twin.hpp.

References car(), cdr(), and Twin.

                                            {
  return Twin (car (x1) * car (x2), cdr (x1) * cdr (x2));
}
modular<M,V> mmx::operator* ( const typename M::base &  a,
const modular< M, V > &  b 
) [inline]

Definition at line 245 of file modular.hpp.

References Modular.

                                                       {
  return Modular (a) * b; }
ball<complex<C>,R,V> mmx::operator* ( const ball< complex< C >, R, V > &  z1,
const ball< C, R, V > &  z2 
) [inline]

Definition at line 137 of file ball_complex.hpp.

References Complex_ball.

                                                                             {
  return z1 * Complex_ball (z2); }
ball<complex<C>,R,V> mmx::operator* ( const ball< C, R, V > &  z1,
const ball< complex< C >, R, V > &  z2 
) [inline]

Definition at line 139 of file ball_complex.hpp.

References Complex_ball.

                                                                             {
  return Complex_ball (z1) * z2; }
modular<M,V>& mmx::operator*= ( modular< M, V > &  dest,
const modular< M, V > &  s 
) [inline]

Definition at line 191 of file modular.hpp.

References get_modulus(), and mul_mod().

                                              {
  mul_mod (dest.rep, s.rep, Modular::get_modulus ());
  return dest; }
floating<V>& mmx::operator*= ( floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 318 of file floating.hpp.

References Rnd.

                                                                     {
  x1.secure (); mpfr_mul (*x1, *x1, *x2, Rnd); return x1; }
modular<M,modular_local>& mmx::operator*= ( modular< M, modular_local > &  dest,
const modular< M, modular_local > &  s 
) [inline]

Definition at line 430 of file modular.hpp.

References get_modulus(), and mul_mod().

                                              {
  M md= get_modulus (dest), ms= get_modulus (s);
  M mod= md == 0 ? ms : md;
  VERIFY (md == 0 || ms == 0 || md == ms, "incompatible moduli");
  mul_mod (dest.rep, s.rep, mod);
  return dest; }
interval<C,V> mmx::operator+ ( const interval< C, V > &  x1,
const interval< C, V > &  x2 
) [inline]

Definition at line 341 of file interval.hpp.

References add(), Interval, lower(), and upper().

                                                    {
  return Interval (Down::add (lower (x1), lower (x2)),
                   Up::add (upper (x1), upper (x2)));
}
interval<C,V> mmx::operator+ ( const C &  x1,
const interval< C, V > &  x2 
) [inline]

Definition at line 352 of file interval.hpp.

References add(), Interval, lower(), and upper().

                                             {
  return Interval (Down::add (x1, lower (x2)), Up::add (x1, upper (x2)));
}
interval<C,V> mmx::operator+ ( const interval< C, V > &  x1,
const C &  x2 
) [inline]

Definition at line 347 of file interval.hpp.

References add(), Interval, lower(), and upper().

                                             {
  return Interval (Down::add (lower (x1), x2), Up::add (upper (x1), x2));
}
modular<M,V> mmx::operator+ ( const modular< M, V > &  a,
const modular< M, V > &  b 
) [inline]

Definition at line 201 of file modular.hpp.

References add_mod(), get_modulus(), and Modular.

                                                {
  Modular c;
  add_mod (c.rep, a.rep, b.rep, Modular::get_modulus ());
  return c; }
ball<C,R,V> mmx::operator+ ( const ball< C, R, V > &  z1,
const C &  z2 
) [inline]

Definition at line 368 of file ball.hpp.

References add(), and Ball.

                                         {
  typedef implementation<ball_additive,V> Impl;
  Ball d; Impl::add (d, z1, z2); return d;
}
affine<C,VC> mmx::operator+ ( const affine< C, VC > &  z1,
const affine< C, VC > &  z2 
) [inline]

Definition at line 224 of file affine.hpp.

References Affine, base(), common_limits(), slope(), and VR.

                                                {
  VR lim= common_limits (z1, z2);
  return Affine (base (z1) + base (z2), slope (z1) + slope (z2), lim);
}
ball<C,R,V> mmx::operator+ ( const C &  z1,
const ball< C, R, V > &  z2 
) [inline]

Definition at line 374 of file ball.hpp.

References add(), and Ball.

                                         {
  typedef implementation<ball_additive,V> Impl;
  Ball d; Impl::add (d, z1, z2); return d;
}
modular<M,V> mmx::operator+ ( const typename M::base &  a,
const modular< M, V > &  b 
) [inline]

Definition at line 211 of file modular.hpp.

References Modular.

                                                       {
  return Modular (a) + b; }
complex<C> mmx::operator+ ( const complex< C > &  z1,
const C &  z2 
) [inline]

Definition at line 277 of file complex.hpp.

References Complex, Im(), and Re().

                                            {
  return Complex (Re (z1) + z2, Im (z1));
}
modular<M,modular_local> mmx::operator+ ( const modular< M, modular_local > &  a,
const modular< M, modular_local > &  b 
) [inline]

Definition at line 446 of file modular.hpp.

References add_mod(), get_modulus(), and Modular.

                                                {
  M ma= get_modulus (a), mb= get_modulus (b);
  M mod= ma == 0 ? mb : ma;
  VERIFY (ma == 0 || mb == 0 || ma == mb, "incompatible moduli");
  Modular c;
  add_mod (c.rep, a.rep, b.rep, mod);
  c.mod= mod;
  return c; }
affine<C,VC> mmx::operator+ ( const affine< C, VC > &  z1,
const C &  z2 
) [inline]

Definition at line 235 of file affine.hpp.

References Affine, base(), limits(), and slope().

                                           {
  return Affine (base (z1) + z2, slope (z1), limits (z1));
}
complex<C> mmx::operator+ ( const complex< C > &  z1,
const complex< C > &  z2 
) [inline]

Definition at line 272 of file complex.hpp.

References Complex, Im(), and Re().

                                                  {
  return Complex (Re (z1) + Re (z2), Im (z1) + Im (z2));
}
floating<V> mmx::operator+ ( const floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 300 of file floating.hpp.

References Floating, and Rnd.

                                                                         {
  Floating r (*x1, *x2); mpfr_add (*r, *x1, *x2, Rnd); return r; }
ball<C,R,V> mmx::operator+ ( const ball< C, R, V > &  z1,
const ball< C, R, V > &  z2 
) [inline]

Definition at line 362 of file ball.hpp.

References add(), and Ball.

                                            {
  typedef implementation<ball_additive,V> Impl;
  Ball d; Impl::add (d, z1, z2); return d;
}
tangent<C,D> mmx::operator+ ( const tangent< C, D > &  z1,
const tangent< C, D > &  z2 
) [inline]

Definition at line 168 of file tangent.hpp.

References base(), slope(), and Tangent.

                                                  {
  return Tangent (base (z1) + base (z2), slope (z1) + slope (z2));
}
affine<C,VC> mmx::operator+ ( const C &  z1,
const affine< C, VC > &  z2 
) [inline]

Definition at line 230 of file affine.hpp.

References Affine, base(), limits(), and slope().

                                           {
  return Affine (z1 + base (z2), slope (z2), limits (z2));
}
twin<C,D,V> mmx::operator+ ( const twin< C, D, V > &  x1,
const twin< C, D, V > &  x2 
) [inline]

Definition at line 195 of file twin.hpp.

References car(), cdr(), and Twin.

                                            {
  return Twin (car (x1) + car (x2), cdr (x1) + cdr (x2));
}
modular<M,V> mmx::operator+ ( const modular< M, V > &  a,
const typename M::base &  b 
) [inline]

Definition at line 207 of file modular.hpp.

References Modular.

                                                       {
  return a + Modular (b); }
ball<complex<C>,R,V> mmx::operator+ ( const ball< complex< C >, R, V > &  z1,
const ball< C, R, V > &  z2 
) [inline]

Definition at line 129 of file ball_complex.hpp.

References Complex_ball.

                                                                             {
  return z1 + Complex_ball (z2); }
ball<complex<C>,R,V> mmx::operator+ ( const ball< C, R, V > &  z1,
const ball< complex< C >, R, V > &  z2 
) [inline]

Definition at line 131 of file ball_complex.hpp.

References Complex_ball.

                                                                             {
  return Complex_ball (z1) + z2; }
complex<C> mmx::operator+ ( const C &  z1,
const complex< C > &  z2 
) [inline]

Definition at line 282 of file complex.hpp.

References Complex, Im(), and Re().

                                            {
  return Complex (z1 + Re (z2), Im (z2));
}
floating<V>& mmx::operator+= ( floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 314 of file floating.hpp.

References Rnd.

                                                                     {
  x1.secure (); mpfr_add (*x1, *x1, *x2, Rnd); return x1; }
V modular<M,V>& mmx::operator+= ( modular< M, V > &  dest,
const modular< M, V > &  s 
) [inline]

Definition at line 181 of file modular.hpp.

References add_mod(), and get_modulus().

                                              {
  add_mod (dest.rep, s.rep, Modular::get_modulus ());
  return dest; }
modular<M,modular_local>& mmx::operator+= ( modular< M, modular_local > &  dest,
const modular< M, modular_local > &  s 
) [inline]

Definition at line 414 of file modular.hpp.

References add_mod(), and get_modulus().

                                              {
  M md= get_modulus (dest), ms= get_modulus (s);
  M mod= md == 0 ? ms : md;
  VERIFY (md == 0 || ms == 0 || md == ms, "incompatible moduli");
  add_mod (dest.rep, s.rep, mod);
  return dest; }
ball<C,R,V> mmx::operator- ( const C &  z1,
const ball< C, R, V > &  z2 
) [inline]

Definition at line 392 of file ball.hpp.

References Ball, and sub().

                                         {
  typedef implementation<ball_additive,V> Impl;
  Ball d; Impl::sub (d, z1, z2); return d;
}
interval<C,V> mmx::operator- ( const interval< C, V > &  x) [inline]

Definition at line 336 of file interval.hpp.

References Interval, lower(), and upper().

                               {
  return Interval (-upper (x), -lower (x));
}
affine< C, VC > operator- ( const affine< C, VC > &  z1,
const affine< C, VC > &  z2 
) [inline]

Definition at line 240 of file affine.hpp.

References Affine, base(), and slope().

                                                {
  return Affine (base (z1) - base (z2), slope (z1) - slope (z2));
}
interval<C,V> mmx::operator- ( const interval< C, V > &  x1,
const interval< C, V > &  x2 
) [inline]

Definition at line 357 of file interval.hpp.

References Interval, lower(), sub(), and upper().

                                                    {
  return Interval (Down::sub (lower (x1), upper (x2)),
                   Up::sub (upper (x1), lower (x2)));
}
twin<C,D,V> mmx::operator- ( const twin< C, D, V > &  x1,
const twin< C, D, V > &  x2 
) [inline]

Definition at line 205 of file twin.hpp.

References car(), cdr(), and Twin.

                                            {
  return Twin (car (x1) - car (x2), cdr (x1) - cdr (x2));
}
complex<C> mmx::operator- ( const C &  z1,
const complex< C > &  z2 
) [inline]

Definition at line 302 of file complex.hpp.

References Complex, Im(), and Re().

                                            {
  return Complex (z1 - Re (z2), -Im (z2));
}
ball<C,R,V> mmx::operator- ( const ball< C, R, V > &  z) [inline]

Definition at line 356 of file ball.hpp.

References Ball, and neg().

                           {
  typedef implementation<ball_additive,V> Impl;
  Ball d; Impl::neg (d, z); return d;
}
ball<complex<C>,R,V> mmx::operator- ( const ball< C, R, V > &  z1,
const ball< complex< C >, R, V > &  z2 
) [inline]

Definition at line 135 of file ball_complex.hpp.

References Complex_ball.

                                                                             {
  return Complex_ball (z1) - z2; }
complex<C> mmx::operator- ( const complex< C > &  z) [inline]

Definition at line 287 of file complex.hpp.

References Complex, Im(), and Re().

                              {
  return Complex (-Re (z), -Im (z));
}
modular<M,V> mmx::operator- ( const modular< M, V > &  a,
const typename M::base &  b 
) [inline]

Definition at line 227 of file modular.hpp.

References Modular.

                                                       {
  return a - Modular (b); }
affine<C,VC> mmx::operator- ( const affine< C, VC > &  z) [inline]

Definition at line 219 of file affine.hpp.

References Affine, base(), limits(), and slope().

                             {
  return Affine (-base (z), -slope (z), limits (z));
}
complex<C> mmx::operator- ( const complex< C > &  z1,
const complex< C > &  z2 
) [inline]

Definition at line 292 of file complex.hpp.

References Complex, Im(), and Re().

                                                  {
  return Complex (Re (z1) - Re (z2), Im (z1) - Im (z2));
}
ball<C,R,V> mmx::operator- ( const ball< C, R, V > &  z1,
const ball< C, R, V > &  z2 
) [inline]

Definition at line 380 of file ball.hpp.

References Ball, and sub().

                                            {
  typedef implementation<ball_additive,V> Impl;
  Ball d; Impl::sub (d, z1, z2); return d;
}
modular<M,V> mmx::operator- ( const modular< M, V > &  a,
const modular< M, V > &  b 
) [inline]

Definition at line 221 of file modular.hpp.

References get_modulus(), Modular, and sub_mod().

                                                {
  Modular c;
  sub_mod (c.rep, a.rep, b.rep, Modular::get_modulus ());
  return c; }
modular<M,V> mmx::operator- ( const typename M::base &  a,
const modular< M, V > &  b 
) [inline]

Definition at line 231 of file modular.hpp.

References Modular.

                                                       {
  return Modular (a) - b; }
ball<C,R,V> mmx::operator- ( const ball< C, R, V > &  z1,
const C &  z2 
) [inline]

Definition at line 386 of file ball.hpp.

References Ball, and sub().

                                         {
  typedef implementation<ball_additive,V> Impl;
  Ball d; Impl::sub (d, z1, z2); return d;
}
modular<M,modular_local> mmx::operator- ( const modular< M, modular_local > &  a,
const modular< M, modular_local > &  b 
) [inline]

Definition at line 464 of file modular.hpp.

References get_modulus(), Modular, and sub_mod().

                                                {
  M ma= get_modulus (a), mb= get_modulus (b);
  M mod= ma == 0 ? mb : ma;
  VERIFY (ma == 0 || mb == 0 || ma == mb, "incompatible moduli");
  Modular c;
  sub_mod (c.rep, a.rep, b.rep, mod);
  c.mod= mod;
  return c; }
floating<V> mmx::operator- ( const floating< V > &  x1) [inline]

Definition at line 298 of file floating.hpp.

References Floating, and Rnd.

                                                     {
  Floating r (*x1); mpfr_neg (*r, *x1, Rnd); return r; }
floating<V> mmx::operator- ( const floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 302 of file floating.hpp.

References Floating, and Rnd.

                                                                         {
  Floating r (*x1, *x2); mpfr_sub (*r, *x1, *x2, Rnd); return r; }
modular<M,modular_local> mmx::operator- ( const modular< M, modular_local > &  a) [inline]

Definition at line 456 of file modular.hpp.

References get_modulus(), Modular, and neg_mod().

                              {
  M mod= get_modulus (a);
  Modular c;
  neg_mod (c.rep, a.rep, mod);
  c.mod= mod;
  return c; }
affine<C,VC> mmx::operator- ( const C &  z1,
const affine< C, VC > &  z2 
) [inline]

Definition at line 245 of file affine.hpp.

References Affine, base(), limits(), and slope().

                                           {
  return Affine (z1 - base (z2), slope (z2), limits (z2));
}
twin<C,D,V> mmx::operator- ( const twin< C, D, V > &  x) [inline]

Definition at line 200 of file twin.hpp.

References car(), cdr(), and Twin.

                           {
  return Twin (-car (x), -cdr (x));
}
interval<C,V> mmx::operator- ( const interval< C, V > &  x1,
const C &  x2 
) [inline]

Definition at line 363 of file interval.hpp.

References add(), Interval, lower(), and upper().

                                             {
  return Interval (Down::add (lower (x1), x2), Up::add (upper (x1), x2));
}
tangent< C, D > operator- ( const tangent< C, D > &  z1,
const tangent< C, D > &  z2 
) [inline]

Definition at line 173 of file tangent.hpp.

References base(), slope(), and Tangent.

                                                  {
  return Tangent (base (z1) - base (z2), slope (z1) - slope (z2));
}
complex<C> mmx::operator- ( const complex< C > &  z1,
const C &  z2 
) [inline]

Definition at line 297 of file complex.hpp.

References Complex, Im(), and Re().

                                            {
  return Complex (Re (z1) - z2, Im (z1));
}
modular<M,V> mmx::operator- ( const modular< M, V > &  a) [inline]

Definition at line 215 of file modular.hpp.

References get_modulus(), Modular, and neg_mod().

                              {
  Modular c;
  neg_mod (c.rep, a.rep, Modular::get_modulus ());
  return c; }
affine<C,VC> mmx::operator- ( const affine< C, VC > &  z1,
const C &  z2 
) [inline]

Definition at line 250 of file affine.hpp.

References Affine, base(), limits(), and slope().

                                           {
  return Affine (base (z1) - z2, slope (z1), limits (z1));
}
ball<complex<C>,R,V> mmx::operator- ( const ball< complex< C >, R, V > &  z1,
const ball< C, R, V > &  z2 
) [inline]

Definition at line 133 of file ball_complex.hpp.

References Complex_ball.

                                                                             {
  return z1 - Complex_ball (z2); }
tangent<C,D> mmx::operator- ( const tangent< C, D > &  z) [inline]

Definition at line 163 of file tangent.hpp.

References base(), slope(), and Tangent.

                              {
  return Tangent (-base (z), -slope (z));
}
interval<C,V> mmx::operator- ( const C &  x1,
const interval< C, V > &  x2 
) [inline]

Definition at line 368 of file interval.hpp.

References add(), Interval, lower(), and upper().

                                             {
  return Interval (Down::add (x1, upper (x2)), Up::add (x1, lower (x2)));
}
modular<M,V>& mmx::operator-= ( modular< M, V > &  dest,
const modular< M, V > &  s 
) [inline]

Definition at line 186 of file modular.hpp.

References get_modulus(), and sub_mod().

                                              {
  sub_mod (dest.rep, s.rep, Modular::get_modulus ());
  return dest; }
modular<M,modular_local>& mmx::operator-= ( modular< M, modular_local > &  dest,
const modular< M, modular_local > &  s 
) [inline]

Definition at line 422 of file modular.hpp.

References get_modulus(), and sub_mod().

                                              {
  M md= get_modulus (dest), ms= get_modulus (s);
  M mod= md == 0 ? ms : md;
  VERIFY (md == 0 || ms == 0 || md == ms, "incompatible moduli");
  sub_mod (dest.rep, s.rep, mod);
  return dest; }
floating<V>& mmx::operator-= ( floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 316 of file floating.hpp.

References Rnd.

                                                                     {
  x1.secure (); mpfr_sub (*x1, *x1, *x2, Rnd); return x1; }
interval<C,V> mmx::operator/ ( const interval< C, V > &  x1,
const interval< C, V > &  x2 
)

Definition at line 420 of file interval.hpp.

References div(), Interval, is_zero(), lower(), and upper().

                                                    {
  if (is_zero (x2)) return Nan (Interval);
  else if (lower (x2) > 0)
    return Interval (lower (x1) > 0?
                     Down::div (lower (x1), upper (x2)):
                     Down::div (lower (x1), lower (x2)),
                     upper (x1) > 0?
                     Up::div (upper (x1), lower (x2)):
                     Up::div (upper (x1), upper (x2)));
  else if (upper (x2) < 0)
    return Interval (upper (x1) > 0?
                     Down::div (upper (x1), upper (x2)):
                     Down::div (upper (x1), lower (x2)),
                     lower (x1) > 0?
                     Up::div (lower (x1), lower (x2)):
                     Up::div (lower (x1), upper (x2)));
  else return Nan (Interval);
}
complex<C> mmx::operator/ ( const complex< C > &  z,
const C &  x 
) [inline]

Definition at line 335 of file complex.hpp.

References Complex, Im(), and Re().

                                          {
  return Complex (Re (z) / x, Im (z) / x);
}
modular<M,modular_local> mmx::operator/ ( const modular< M, modular_local > &  a,
const modular< M, modular_local > &  b 
) [inline]

Definition at line 484 of file modular.hpp.

References div_mod(), get_modulus(), and Modular.

                                                {
  M ma= get_modulus (a), mb= get_modulus (b);
  M mod= ma == 0 ? mb : ma;
  VERIFY (ma == 0 || mb == 0 || ma == mb, "incompatible moduli");
  Modular c;
  div_mod (c.rep, a.rep, b.rep, mod);
  c.mod= mod;
  return c; }
complex<C> mmx::operator/ ( const C &  x,
const complex< C > &  z 
) [inline]

Definition at line 340 of file complex.hpp.

References C, Complex, Im(), norm(), and Re().

                                          {
  C a= x / norm (z);
  return Complex (a * Re (z), -a * Im (z));
}
STMPL complex<double> mmx::operator/ ( const complex< double > &  z1,
const complex< double > &  z2 
) [inline]

Definition at line 39 of file complex_double.hpp.

References abs(), Im(), and Re().

                                                                  {
  if (abs (Re (z2)) >= abs (Im (z2))) {
    double f= Im (z2) / Re (z2);
    double c= 1.0 / (Re (z2) + Im (z2) * f);
    return complex<double> (c * (Re (z1) + Im (z1) * f),
                            c * (Im (z1) - Re (z1) * f));
  }
  else {
    double f= Re (z2) / Im (z2);
    double c= 1.0 / (Re (z2) * f + Im (z2));
    return complex<double> (c * (Re (z1) * f + Im (z1)),
                            c * (Im (z1) * f - Re (z1)));
  }
}
twin<C,D,V> mmx::operator/ ( const twin< C, D, V > &  x1,
const twin< C, D, V > &  x2 
) [inline]

Definition at line 215 of file twin.hpp.

References car(), cdr(), and Twin.

                                            {
  return Twin (car (x1) / car (x2), cdr (x1) / cdr (x2));
}
ball<C,R,V> mmx::operator/ ( const ball< C, R, V > &  z1,
const ball< C, R, V > &  z2 
) [inline]

Definition at line 428 of file ball.hpp.

References Ball, and div().

                                            {
  typedef implementation<ball_multiplicative,V> Impl;
  Ball d; Impl::div (d, z1, z2); return d;
}
modular<M,V> mmx::operator/ ( const modular< M, V > &  a,
const modular< M, V > &  b 
) [inline]

Definition at line 249 of file modular.hpp.

References div_mod(), get_modulus(), and Modular.

                                                {
  Modular c;
  div_mod (c.rep, a.rep, b.rep, Modular::get_modulus ());
  return c; }
interval<C,V> mmx::operator/ ( const interval< C, V > &  x1,
const C &  x2 
) [inline]

Definition at line 439 of file interval.hpp.

References Interval.

                                                                  {
  return x1 / Interval (x2); }
ball<complex<C>,R,V> mmx::operator/ ( const ball< C, R, V > &  z1,
const ball< complex< C >, R, V > &  z2 
) [inline]

Definition at line 143 of file ball_complex.hpp.

References Complex_ball.

                                                                             {
  return Complex_ball (z1) / z2; }
complex<C> mmx::operator/ ( const complex< C > &  z1,
const complex< C > &  z2 
) [inline]

Definition at line 346 of file complex.hpp.

References C, Complex, Im(), norm(), and Re().

                                                  {
  C a= norm (z2);
  return Complex ((Re (z1) * Re (z2) + Im (z1) * Im (z2)) / a,
                  (Im (z1) * Re (z2) - Re (z1) * Im (z2)) / a);
}
modular<M,V> mmx::operator/ ( const typename M::base &  a,
const modular< M, V > &  b 
) [inline]

Definition at line 259 of file modular.hpp.

References Modular.

                                                       {
  return Modular (a) / b; }
ball<C,R,V> mmx::operator/ ( const ball< C, R, V > &  z1,
const C &  z2 
) [inline]

Definition at line 434 of file ball.hpp.

References Ball, and div().

                                         {
  typedef implementation<ball_multiplicative,V> Impl;
  Ball d; Impl::div (d, z1, z2); return d;
}
affine<C,VC> mmx::operator/ ( const affine< C, VC > &  z1,
const affine< C, VC > &  z2 
) [inline]

Definition at line 285 of file affine.hpp.

                                                {
  ERROR ("not yet implemented");
  //C inv= invert (base (z2));
  //return Affine (inv * base (z1),
  //               inv * (slope (z1) - inv * base (z1) * slope (z2)));
}
modular<M,V> mmx::operator/ ( const modular< M, V > &  a,
const typename M::base &  b 
) [inline]

Definition at line 255 of file modular.hpp.

References Modular.

                                                       {
  return a / Modular (b); }
affine<C,VC> mmx::operator/ ( const affine< C, VC > &  z1,
const C &  z2 
) [inline]

Definition at line 300 of file affine.hpp.

References Affine, base(), C, invert(), limits(), and slope().

                                           {
  C inv= invert (z2);
  return Affine (inv * base (z1), inv * slope (z1), limits (z1));
}
ball<C,R,V> mmx::operator/ ( const C &  z1,
const ball< C, R, V > &  z2 
) [inline]

Definition at line 440 of file ball.hpp.

References Ball, and div().

                                         {
  typedef implementation<ball_multiplicative,V> Impl;
  Ball d; Impl::div (d, z1, z2); return d;
}
affine<C,VC> mmx::operator/ ( const C &  z1,
const affine< C, VC > &  z2 
) [inline]

Definition at line 293 of file affine.hpp.

                                           {
  ERROR ("not yet implemented");
  //C inv= invert (base (z2));
  //return Affine (inv * z1, - square (inv) * z1 * slope (z2));
}
ball<complex<C>,R,V> mmx::operator/ ( const ball< complex< C >, R, V > &  z1,
const ball< C, R, V > &  z2 
) [inline]

Definition at line 141 of file ball_complex.hpp.

References Complex_ball.

                                                                             {
  return z1 / Complex_ball (z2); }
interval<C,V> mmx::operator/ ( const C &  x1,
const interval< C, V > &  x2 
) [inline]

Definition at line 441 of file interval.hpp.

References Interval.

                                                                  {
  return Interval (x1) / x2; }
tangent<C,D> mmx::operator/ ( const tangent< C, D > &  z1,
const tangent< C, D > &  z2 
) [inline]

Definition at line 205 of file tangent.hpp.

References base(), C, invert(), slope(), and Tangent.

                                                  {
  C inv= invert (base (z2));
  return Tangent (inv * base (z1),
                  inv * (slope (z1) - inv * base (z1) * slope (z2)));
}
floating<V> mmx::operator/ ( const floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 306 of file floating.hpp.

References Floating, and Rnd.

                                                                         {
  Floating r (*x1, *x2); mpfr_div (*r, *x1, *x2, Rnd); return r; }
tangent<C,D> mmx::operator/ ( const C &  z1,
const tangent< C, D > &  z2 
) [inline]

Definition at line 212 of file tangent.hpp.

References base(), C, invert(), slope(), square(), and Tangent.

                                            {
  C inv= invert (base (z2));
  return Tangent (inv * z1, - square (inv) * z1 * slope (z2));
}
tangent<C,D> mmx::operator/ ( const tangent< C, D > &  z1,
const C &  z2 
) [inline]

Definition at line 218 of file tangent.hpp.

References base(), C, invert(), slope(), and Tangent.

                                            {
  C inv= invert (z2);
  return Tangent (inv * base (z1), inv * slope (z1));
}
modular<M,V>& mmx::operator/= ( modular< M, V > &  dest,
const modular< M, V > &  s 
) [inline]

Definition at line 196 of file modular.hpp.

References div_mod(), and get_modulus().

                                              {
  div_mod (dest.rep, s.rep, Modular::get_modulus ());
  return dest; }
floating<V>& mmx::operator/= ( floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 320 of file floating.hpp.

References Rnd.

                                                                     {
  x1.secure (); mpfr_div (*x1, *x1, *x2, Rnd); return x1; }
modular<M,modular_local>& mmx::operator/= ( modular< M, modular_local > &  dest,
const modular< M, modular_local > &  s 
) [inline]

Definition at line 438 of file modular.hpp.

References div_mod(), and get_modulus().

                                              {
  M md= get_modulus (dest), ms= get_modulus (s);
  M mod= md == 0 ? ms : md;
  VERIFY (md == 0 || ms == 0 || md == ms, "incompatible moduli");
  div_mod (dest.rep, s.rep, mod);
  return dest; }
bool mmx::operator< ( const affine< C, VC > &  z1,
const affine< C, VC > &  z2 
) [inline]

Definition at line 404 of file affine.hpp.

References base().

                                                {
  return base (z1) < base (z2);
}
bool mmx::operator< ( const floating< V > &  x1,
const floating< V2 > &  x2 
) [inline]

Definition at line 351 of file floating.hpp.

                                                                       {
  return mpfr_less_p (*x1, *x2) != 0; }
bool mmx::operator< ( const floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 364 of file floating.hpp.

                                                                     {
  return mpfr_less_p (*x1, *x2) != 0; }
bool mmx::operator< ( const tangent< C, D > &  z1,
const tangent< C, D > &  z2 
) [inline]

Definition at line 320 of file tangent.hpp.

References base().

                                                  {
  return base (z1) < base (z2);
}
bool mmx::operator< ( const twin< C, D, V > &  x,
const twin< C, D, V > &  y 
)

Definition at line 138 of file twin.hpp.

References car().

                                                    {
  return car (x) < car (y); }
bool mmx::operator< ( const ball< C, R, V > &  z1,
const ball< C, R, V > &  z2 
) [inline]

Definition at line 301 of file ball.hpp.

References is_negative().

                                            {
  return is_negative (z1 - z2);
}
bool mmx::operator< ( const interval< C, V > &  x1,
const interval< C, V > &  x2 
) [inline]

Definition at line 238 of file interval.hpp.

References is_nan(), lower(), and upper().

                                                    {
  if (is_nan (x1) || is_nan (x2)) return false;
  return lower (x2) > upper (x1);
}
interval<C,V> mmx::operator<< ( const interval< C, V > &  x,
const xint &  shift 
) [inline]

Definition at line 617 of file interval.hpp.

References Interval, lower(), and upper().

                                                                        {
  return Interval (incexp2 (lower (x), shift), incexp2 (upper (x), shift)); }
affine<C,VC> mmx::operator<< ( const affine< C, VC > &  z,
const xint &  s 
) [inline]

Definition at line 461 of file affine.hpp.

References Affine, base(), limits(), and slope().

                                                                {
  return Affine (incexp2 (base (z), s), incexp2 (slope (z), s), limits (z)); }
ball<C,R,V> mmx::operator<< ( const ball< C, R, V > &  z,
const xint &  shift 
) [inline]

Definition at line 665 of file ball.hpp.

References Ball.

                                                                {
  typedef implementation<ball_shift,V> Impl;
  Ball d; Impl::shiftl (d, z, shift); return d; }
floating<V> mmx::operator<< ( const floating< V > &  x1,
const xint &  shift 
) [inline]

Definition at line 494 of file floating.hpp.

References Floating, and Rnd.

                                                                         {
  Floating r (*x1); mpfr_mul_2si (*r, *x1, shift, Rnd); return r; }
tangent<C,D> mmx::operator<< ( const tangent< C, D > &  z,
const xint &  shift 
) [inline]

Definition at line 374 of file tangent.hpp.

References base(), slope(), and Tangent.

                                                                      {
  return Tangent (incexp2 (base (z), shift), incexp2 (slope (z), shift)); }
twin<C,D,V> mmx::operator<< ( const twin< C, D, V > &  x,
const xint &  shift 
) [inline]

Definition at line 288 of file twin.hpp.

References car(), cdr(), and Twin.

                                                                {
  return Twin (incexp2 (car (x), shift), incexp2 (cdr (x), shift)); }
complex<C> mmx::operator<< ( const complex< C > &  z,
const xint &  shift 
) [inline]

Definition at line 623 of file complex.hpp.

References Complex, Im(), and Re().

                                                                      {
  return Complex (incexp2 (Re (z), shift), incexp2 (Im (z), shift)); }
floating<V>& mmx::operator<<= ( floating< V > &  x1,
const xint &  shift 
) [inline]

Definition at line 498 of file floating.hpp.

                                                                     {
  return x1= x1 << shift; }
bool mmx::operator<= ( const floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 368 of file floating.hpp.

                                                                      {
  return mpfr_lessequal_p (*x1, *x2) != 0; }
bool mmx::operator<= ( const ball< C, R, V > &  z1,
const ball< C, R, V > &  z2 
) [inline]

Definition at line 296 of file ball.hpp.

References is_negative_or_zero().

                                             {
  return is_negative_or_zero (z1 - z2);
}
bool mmx::operator<= ( const floating< V > &  x1,
const floating< V2 > &  x2 
) [inline]

Definition at line 355 of file floating.hpp.

                                                                        {
  return mpfr_lessequal_p (*x1, *x2) != 0; }
bool mmx::operator<= ( const affine< C, VC > &  z1,
const affine< C, VC > &  z2 
) [inline]

Definition at line 399 of file affine.hpp.

References base().

                                                 {
  return base (z1) < base (z2) || z1 == z2;
}
tangent<C,D> tangent<C,D> bool mmx::operator<= ( const tangent< C, D > &  z1,
const tangent< C, D > &  z2 
) [inline]

Definition at line 315 of file tangent.hpp.

References base().

                                                   {
  return base (z1) < base (z2) || z1 == z2;
}
bool mmx::operator<= ( const interval< C, V > &  x1,
const interval< C, V > &  x2 
) [inline]

Definition at line 232 of file interval.hpp.

References is_nan(), lower(), and upper().

                                                     {
  if (is_nan (x1) || is_nan (x2)) return false;
  return lower (x1) <= upper (x2);
}
bool mmx::operator<= ( const twin< C, D, V > &  x,
const twin< C, D, V > &  y 
)

Definition at line 140 of file twin.hpp.

References car().

                                                     {
  return car (x) <= car (y); }
bool mmx::operator== ( const ball< C, R, V > &  z1,
const ball< C, R, V > &  z2 
)

Definition at line 282 of file ball.hpp.

References abs_down(), Ball, and is_nan().

                                             {
  if (is_nan (z1) || is_nan (z2)) return is_nan (z1) && is_nan (z2);
  Ball d= z1 - z2;
  return abs_down (d) == 0;
}
bool mmx::operator== ( const floating< V > &  x1,
const floating< V2 > &  x2 
) [inline]

Definition at line 347 of file floating.hpp.

                                                                        {
  return mpfr_equal_p (*x1, *x2) != 0; }
bool mmx::operator== ( const scalar_set< X > &  r1,
const scalar_set< X > &  r2 
)

Definition at line 47 of file kernel.hpp.

{ return true; }
bool mmx::operator== ( const floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 360 of file floating.hpp.

                                                                      {
  return mpfr_equal_p (*x1, *x2) != 0; }
bool mmx::operator== ( const twin< C, D, V > &  x,
const twin< C, D, V > &  y 
)

Definition at line 134 of file twin.hpp.

References car().

                                                     {
  return car (x) == car (y); }
bool mmx::operator== ( const interval< C, V > &  x1,
const interval< C, V > &  x2 
) [inline]

Definition at line 220 of file interval.hpp.

References is_nan(), lower(), and upper().

                                                     {
  if (is_nan (x1) || is_nan (x2)) return is_nan (x1) && is_nan (x2);
  return lower (x1) <= upper (x2) && lower (x2) <= upper (x1);
}
bool mmx::operator> ( const interval< C, V > &  x1,
const interval< C, V > &  x2 
) [inline]

Definition at line 250 of file interval.hpp.

References is_nan(), lower(), and upper().

                                                    {
  if (is_nan (x1) || is_nan (x2)) return false;
  return lower (x1) > upper (x2);
}
bool mmx::operator> ( const floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 366 of file floating.hpp.

                                                                     {
  return mpfr_greater_p (*x1, *x2) != 0; }
bool mmx::operator> ( const tangent< C, D > &  z1,
const tangent< C, D > &  z2 
) [inline]

Definition at line 330 of file tangent.hpp.

References base().

                                                  {
  return base (z1) > base (z2);
}
bool mmx::operator> ( const floating< V > &  x1,
const floating< V2 > &  x2 
) [inline]

Definition at line 353 of file floating.hpp.

                                                                       {
  return mpfr_greater_p (*x1, *x2) != 0; }
bool mmx::operator> ( const affine< C, VC > &  z1,
const affine< C, VC > &  z2 
) [inline]

Definition at line 414 of file affine.hpp.

References base().

                                                {
  return base (z1) > base (z2);
}
bool mmx::operator> ( const twin< C, D, V > &  x,
const twin< C, D, V > &  y 
)

Definition at line 142 of file twin.hpp.

References car().

                                                    {
  return car (x) > car (y); }
bool mmx::operator> ( const ball< C, R, V > &  z1,
const ball< C, R, V > &  z2 
) [inline]

Definition at line 311 of file ball.hpp.

References is_positive().

                                            {
  return is_positive (z1 - z2);
}
bool mmx::operator>= ( const affine< C, VC > &  z1,
const affine< C, VC > &  z2 
) [inline]

Definition at line 409 of file affine.hpp.

References base().

                                                 {
  return base (z1) > base (z2) || z1 == z2;
}
bool mmx::operator>= ( const twin< C, D, V > &  x,
const twin< C, D, V > &  y 
)

Definition at line 144 of file twin.hpp.

References car().

                                                     {
  return car (x) >= car (y); }
bool mmx::operator>= ( const interval< C, V > &  x1,
const interval< C, V > &  x2 
) [inline]

Definition at line 244 of file interval.hpp.

References is_nan(), lower(), and upper().

                                                     {
  if (is_nan (x1) || is_nan (x2)) return false;
  return lower (x2) <= upper (x1);
}
bool mmx::operator>= ( const tangent< C, D > &  z1,
const tangent< C, D > &  z2 
) [inline]

Definition at line 325 of file tangent.hpp.

References base().

                                                   {
  return base (z1) > base (z2) || z1 == z2;
}
bool mmx::operator>= ( const floating< V > &  x1,
const floating< V2 > &  x2 
) [inline]

Definition at line 357 of file floating.hpp.

                                                                        {
  return mpfr_greaterequal_p (*x1, *x2) != 0; }
bool mmx::operator>= ( const ball< C, R, V > &  z1,
const ball< C, R, V > &  z2 
) [inline]

Definition at line 306 of file ball.hpp.

References is_positive_or_zero().

                                             {
  return is_positive_or_zero (z1 - z2);
}
bool mmx::operator>= ( const floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 370 of file floating.hpp.

                                                                      {
  return mpfr_greaterequal_p (*x1, *x2) != 0; }
floating<V> mmx::operator>> ( const floating< V > &  x1,
const xint &  shift 
) [inline]

Definition at line 496 of file floating.hpp.

References Floating, and Rnd.

                                                                         {
  Floating r (*x1); mpfr_mul_2si (*r, *x1, -shift, Rnd); return r; }
ball<C,R,V> mmx::operator>> ( const ball< C, R, V > &  z,
const xint &  shift 
) [inline]

Definition at line 668 of file ball.hpp.

References Ball.

                                                                {
  typedef implementation<ball_shift,V> Impl;
  Ball d; Impl::shiftr (d, z, shift); return d; }
affine<C,VC> mmx::operator>> ( const affine< C, VC > &  z,
const xint &  s 
) [inline]

Definition at line 463 of file affine.hpp.

References Affine, base(), limits(), and slope().

                                                                {
  return Affine (decexp2 (base (z), s), decexp2 (slope (z), s), limits (z)); }
complex<C> mmx::operator>> ( const complex< C > &  z,
const xint &  shift 
) [inline]

Definition at line 625 of file complex.hpp.

References Complex, Im(), and Re().

                                                                      {
  return Complex (decexp2 (Re (z), shift), decexp2 (Im (z), shift)); }
interval<C,V> mmx::operator>> ( const interval< C, V > &  x,
const xint &  shift 
) [inline]

Definition at line 619 of file interval.hpp.

References Interval, lower(), and upper().

                                                                        {
  return Interval (decexp2 (lower (x), shift), decexp2 (upper (x), shift)); }
tangent<C,D> mmx::operator>> ( const tangent< C, D > &  z,
const xint &  shift 
) [inline]

Definition at line 376 of file tangent.hpp.

References base(), slope(), and Tangent.

                                                                      {
  return Tangent (decexp2 (base (z), shift), decexp2 (slope (z), shift)); }
twin<C,D,V> mmx::operator>> ( const twin< C, D, V > &  x,
const xint &  shift 
) [inline]

Definition at line 290 of file twin.hpp.

References car(), cdr(), and Twin.

                                                                {
  return Twin (decexp2 (car (x), shift), decexp2 (cdr (x), shift)); }
floating<V>& mmx::operator>>= ( floating< V > &  x1,
const xint &  shift 
) [inline]

Definition at line 500 of file floating.hpp.

                                                                     {
  return x1= x1 >> shift; }
ball<C,R,V> mmx::over_i ( const ball< C, R, V > &  z) [inline]

Definition at line 61 of file ball_complex.hpp.

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

Referenced by acos(), implementation< ball_elementary, IV, ball_complex< BV > >::acos(), asin(), implementation< ball_elementary, IV, ball_complex< BV > >::asin(), atan(), implementation< ball_elementary, IV, ball_complex< BV > >::atan(), GLUE_7(), and GLUE_8().

                                                        {
  return Complex_ball (over_i (center (z)), radius (z)); }
complex<C> mmx::over_i ( const complex< C > &  z) [inline]

Definition at line 236 of file complex.hpp.

References Complex, Im(), and Re().

                          {
  return Complex (Im (z), -Re (z));
}
ball<complex<C>,R,V> mmx::polar ( const ball< C, R, V > &  r,
const ball< C, R, V > &  t 
)

Definition at line 90 of file ball_complex.hpp.

References Complex_ball.

Referenced by exp(), and pow().

                                     {
  typedef implementation<ball_complex_construct,ball_complex<V> > Impl;
  Complex_ball z; Impl::polar (z, r, t); return z;
}
complex<C> mmx::polar ( const C &  r,
const C &  t 
) [inline]

Definition at line 206 of file complex.hpp.

References Complex, cos(), and sin().

                               {
  return Complex (r * cos (t), r * sin (t));
}
ball<C,R,V> mmx::pow ( const ball< C, R, V > &  z,
const ball< C, R, V > &  y 
) [inline]
Examples:
floating_test.cpp, and integer_test.cpp.

Definition at line 495 of file ball.hpp.

References Ball, C, Elementary_variant, and V.

Referenced by flatten_number(), GLUE_14(), GLUE_15(), GLUE_19(), GLUE_22(), GLUE_25(), GLUE_28(), GLUE_47(), and pow().

                                   {
  typedef Elementary_variant(C,V) EV;
  typedef implementation<ball_elementary,EV> Impl;
  Ball d; Impl::pow (d, z, y); return d;
}
twin<C,D,V> mmx::pow ( const twin< C, D, V > &  x1,
const twin< C, D, V > &  x2 
) [inline]

Definition at line 231 of file twin.hpp.

References car(), cdr(), pow(), and Twin.

                                                      {
  return Twin (pow (car (x1), car (x2)), pow (cdr (x1), cdr (x2))); }
complex<C> mmx::pow ( const int &  z,
const complex< C > &  y 
) [inline]

Definition at line 499 of file complex.hpp.

References exp(), and log().

                                     {
  return exp (y * log (z));
}
ball<C,R,V> mmx::pow ( const ball< C, R, V > &  z,
const int &  y 
) [inline]

Definition at line 502 of file ball.hpp.

References Ball, C, Elementary_variant, pow(), and V.

                                  {
  typedef Elementary_variant(C,V) EV;
  typedef implementation<ball_elementary,EV> Impl;
  Ball d; Impl::pow (d, z, Ball (y)); return d;
}
floating<V> mmx::pow ( const floating< V > &  x1,
const int &  x2 
) [inline]

Definition at line 443 of file floating.hpp.

References Floating, and Rnd.

                                                             {
  Floating r (*x1); mpfr_pow_ui (*r, *x1, x2, Rnd); return r; }
tangent<C,D> mmx::pow ( const tangent< C, D > &  z,
const K &  y 
) [inline]

Definition at line 247 of file tangent.hpp.

References exp(), log(), and Tangent.

                                   {
  return exp (Tangent (y) * log (z));
}
ball<C,R,V> mmx::pow ( const int &  z,
const ball< C, R, V > &  y 
) [inline]

Definition at line 509 of file ball.hpp.

References Ball, C, Elementary_variant, pow(), and V.

                                  {
  typedef Elementary_variant(C,V) EV;
  typedef implementation<ball_elementary,EV> Impl;
  Ball d; Impl::pow (d, Ball (z), y); return d;
}
floating<V> mmx::pow ( const int &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 445 of file floating.hpp.

References Floating, and Rnd.

                                                             {
  Floating r (*x2); mpfr_ui_pow (*r, x1, *x2, Rnd); return r; }
complex<C> mmx::pow ( const complex< C > &  z,
const complex< C > &  y 
) [inline]

Definition at line 476 of file complex.hpp.

References abs(), arg(), C, exp(), Im(), log(), polar(), and Re().

                                         {
  C r= log (abs (z));
  C t= arg (z);
  return polar (exp (r * Re (y) - Im (y) * t),
                Im (y) * r + Re (y) * t);
}
complex<C> mmx::pow ( const complex< C > &  z,
const C &  y 
) [inline]

Definition at line 484 of file complex.hpp.

References exp(), and log().

                                   {
  return exp (y * log (z));
}
twin<C,D,V> mmx::pow ( const twin< C, D, V > &  x1,
const int &  x2 
) [inline]

Definition at line 233 of file twin.hpp.

References pow(), and Twin.

                                                     {
  return pow (x1, Twin (x2)); }
complex<C> mmx::pow ( const C &  z,
const complex< C > &  y 
) [inline]

Definition at line 489 of file complex.hpp.

References exp(), and log().

                                   {
  return exp (y * log (z));
}
complex<C> mmx::pow ( const complex< C > &  z,
const int &  y 
) [inline]

Definition at line 494 of file complex.hpp.

References exp(), and log().

                                     {
  return exp (y * log (z));
}
floating<V> mmx::pow ( const floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 441 of file floating.hpp.

References Floating, and Rnd.

                                                                  {
  Floating r (*x1, *x2); mpfr_pow (*r, *x1, *x2, Rnd); return r; }
interval<C,V> mmx::pow ( const interval< C, V > &  x,
const interval< C, V > &  y 
) [inline]

Definition at line 491 of file interval.hpp.

References exp(), and log().

                                           {
  return exp (y * log (x));
}
xnat mmx::precision ( const affine< C, VC > &  z) [inline]

Definition at line 450 of file affine.hpp.

References base().

Referenced by as_helper< rational, floating<> >::cv(), binary_helper< floating< V > >::disassemble(), flatten_range(), GLUE_26(), GLUE_39(), GLUE_46(), GLUE_47(), GLUE_58(), and precision().

                                             {
  return precision (base (z)); }
xnat mmx::precision ( const twin< C, D, V > &  x) [inline]

Definition at line 281 of file twin.hpp.

References car(), and precision().

                                           {
  return precision (car (x)); }
xnat mmx::precision ( const tangent< C, D > &  z) [inline]

Definition at line 365 of file tangent.hpp.

References base(), and precision().

                                              {
  return precision (base (z)); }
xnat mmx::precision ( const interval< C, V > &  x) [inline]

Definition at line 610 of file interval.hpp.

References lower(), min(), precision(), and upper().

                                               {
  return min (precision (lower (x)), precision (upper (x))); }
xnat mmx::precision ( const floating< V > &  x) [inline]

Definition at line 469 of file floating.hpp.

                                               {
  return (xnat) mpfr_get_prec (*x); }
xnat mmx::precision ( const complex< C > &  z) [inline]

Definition at line 589 of file complex.hpp.

References Im(), min(), precision(), and Re().

                                              {
  return min (precision (Re (z)), precision (Im (z))); }
xnat mmx::precision ( const ball< C, R, V > &  x) [inline]

Definition at line 652 of file ball.hpp.

References center(), and precision().

                                           {
  return precision (center (x)); }
void mmx::print ( OSTREAM &  os,
const rational &  x 
) [inline]

Definition at line 25 of file kernel.hpp.

References as_string().

                                        { 
    os   << as_charp(as_string(numerator(x))); 
    if (denominator(x) != 1){ 
      os <<"/";
      os << as_charp(as_string(denominator(x))); 
    }
  }
void mmx::print ( OSTREAM &  os,
const floating< V > &  x 
) [inline]

Definition at line 35 of file kernel.hpp.

References as_string().

{ os << as_charp(as_string(x)); }
void mmx::print ( OSTREAM &  os,
const integer &  x 
) [inline]

Definition at line 22 of file kernel.hpp.

References as_string().

{ os << as_charp(as_string(x)); }
integer mmx::probable_next_prime ( const integer &  i) [inline]

Definition at line 1160 of file integer.hpp.

References is_probable_prime().

Referenced by GLUE_29().

                                                      {
  integer j (i+1);
  while (! is_probable_prime (j)) j += 1;
  return j;
}
integer mmx::probable_previous_prime ( const integer &  i) [inline]

Definition at line 1154 of file integer.hpp.

References is_probable_prime().

                                                          {
  integer j (i-1);
  while (! is_probable_prime (j)) j -= 1;
  return j;
}
integer mmx::promote ( const F &  x,
const integer &   
) [inline]

Definition at line 1128 of file integer.hpp.

{ return as<integer> (x); }
floating<V> mmx::promote ( const F &  x,
const floating< V > &   
) [inline]

Definition at line 256 of file floating.hpp.

Referenced by acos(), implementation< ball_elementary, W, ball_rounded >::acos(), asin(), implementation< ball_elementary, W, ball_rounded >::asin(), atan(), implementation< ball_elementary, W, ball_rounded >::atan(), implementation< ball_elementary, W, ball_rounded >::atan2(), binpow(), complex_gaussian(), cos(), implementation< ball_elementary, W, ball_rounded >::cos(), make_mmx_ball(), scalar_tangent(), sin(), implementation< ball_elementary, W, ball_rounded >::sin(), and sqrt().

{ return as<Floating > (x); }
rational mmx::promote ( const F &  x,
const rational &   
) [inline]

Definition at line 243 of file rational.hpp.

{ return as<rational> (x); }
R & radius ( ball< C, R, V > &  z) [inline]

Definition at line 107 of file ball.hpp.

{ return z.r; }
R radius ( const ball< C, R, V > &  z) [inline]
Examples:
ball_test.cpp, complex_ball_test.cpp, and interval_test.cpp.

Definition at line 105 of file ball.hpp.

Referenced by implementation< ball_abs, W, ball_rounded >::abs(), implementation< ball_rounding, W, ball_rounded >::abs_down(), Abs_type(), implementation< ball_rounding, W, ball_rounded >::abs_up(), implementation< ball_elementary, W, ball_rounded >::acos(), implementation< ball_additive, W, ball_rounded >::add(), implementation< ball_additive, W, ball_rough >::add(), implementation< ball_rounding, W, ball_rounded >::add_additive_error(), implementation< ball_rounding, W, ball_rounded >::add_elementary_error(), implementation< ball_rounding, W, ball_rounded >::add_multiplicative_error(), add_rough_additive_error(), add_rough_multiplicative_error(), implementation< ball_rounding, W, ball_rounded >::add_rounding_error(), implementation< ball_elementary, W, ball_rounded >::asin(), implementation< ball_elementary, W, ball_rounded >::atan(), implementation< ball_elementary, W, ball_rounded >::atan2(), binary_test(), blur(), implementation< ball_rounding, W, ball_rounded >::bnd_down(), implementation< ball_rounding, W, ball_rounded >::bnd_up(), change_precision(), affine_limits_helper< C, VC >::common(), conj(), copy(), implementation< ball_elementary, W, ball_rounded >::cos(), implementation< ball_elementary, IV, ball_complex< BV > >::cos(), implementation< ball_elementary, W, ball_rounded >::cosh(), implementation< ball_elementary, IV, ball_complex< BV > >::cosh(), binary_helper< ball< C, R, V > >::disassemble(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::div(), duplicate(), implementation< ball_elementary, W, ball_rounded >::exp(), implementation< ball_elementary, IV, ball_complex< BV > >::exp(), exponent(), flatten(), implementation< ball_complex_construct, IV, ball_complex< BV > >::gauss(), affine_limits_helper< C, VC >::get_limits(), GLUE_7(), implementation< ball_root, W, ball_rounded >::hypot(), implementation< ball_root, W, ball_rough >::hypot(), Im(), included(), implementation< ball_multiplicative, W, ball_rounded >::invert(), implementation< ball_multiplicative, W, ball_rough >::invert(), is_exact_zero(), is_finite(), is_fuzz(), is_infinite(), is_nan(), is_non_zero(), is_zero(), implementation< ball_elementary, W, ball_rounded >::log(), implementation< ball_elementary, IV, ball_complex< BV > >::log(), implementation< ball_rounding, W, ball_rounded >::lower(), magnitude(), implementation< ball_rounding, W, ball_rounded >::make_interval(), implementation< ball_ordered, W, ball_rounded >::max(), implementation< ball_ordered, W, ball_rounded >::min(), implementation< ball_multiplicative, W, ball_rounded >::mul(), implementation< ball_multiplicative, W, ball_rough >::mul(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::mul(), implementation< ball_additive, W, ball_rounded >::neg(), implementation< ball_additive, W, ball_rough >::neg(), over_i(), Re(), set_as(), implementation< ball_shift, W, ball_rounded >::shiftl(), implementation< ball_shift, W, ball_rough >::shiftl(), implementation< ball_shift, W, ball_rounded >::shiftr(), implementation< ball_shift, W, ball_rough >::shiftr(), implementation< ball_elementary, W, ball_rounded >::sin(), implementation< ball_elementary, IV, ball_complex< BV > >::sin(), implementation< ball_elementary, W, ball_rounded >::sinh(), implementation< ball_elementary, IV, ball_complex< BV > >::sinh(), implementation< ball_root, W, ball_rounded >::sqrt(), implementation< ball_root, W, ball_rough >::sqrt(), implementation< ball_root, IV, ball_complex< BV > >::sqrt(), implementation< ball_multiplicative, W, ball_rounded >::square(), implementation< ball_multiplicative, W, ball_rough >::square(), implementation< ball_additive, W, ball_rounded >::sub(), implementation< ball_additive, W, ball_rough >::sub(), times_i(), unary_hash(), implementation< ball_rounding, W, ball_rounded >::upper(), and binary_helper< ball< C, R, V > >::write().

{ return z.r; }
C mmx::radius ( const interval< C, V > &  x) [inline]

Definition at line 113 of file interval.hpp.

References add(), center(), is_infinite(), lower(), multiplicative_error(), sub(), and upper().

                                         {
  if (is_infinite (x)) return 0;
  return Up::add (decexp2 (Up::sub (upper (x), lower (x))),
                  multiplicative_error (center (x))); }
integer mmx::raw_integer ( nat  limb_sz) [inline]

Definition at line 1011 of file integer.hpp.

References BITS_PER_LIMB.

                                         {
  return new integer_rep (limb_sz * BITS_PER_LIMB); }
affine<Real_type(C),Real_type(VC) > mmx::Re ( const affine< C, VC > &  z) [inline]

Definition at line 484 of file affine.hpp.

References base(), limits(), Real_affine, and slope().

Referenced by abs(), add(), additive_error(), arg(), ARG_HYPER_SUGAR(), binary_test(), blur(), CF(), change_precision(), conj(), copy(), cos(), cosh(), implementation< ball_elementary, IV, ball_complex< BV > >::cosh(), as_helper< complex< T >, complex< F > >::cv(), fast_helper< complex< C > >::dd(), binary_helper< complex< C > >::disassemble(), div(), duplicate(), exp(), implementation< ball_elementary, IV, ball_complex< BV > >::exp(), exponent(), flatten(), GLUE_3(), GLUE_4(), invert(), is_exact_zero(), is_fuzz(), is_infinite(), is_nan(), is_reliable(), magnitude(), map(), mul(), neg(), norm(), operator*(), operator+(), operator-(), operator/(), operator<<(), operator>>(), over_i(), pow(), precision(), Re(), set_accuracy(), set_as(), set_euler(), set_fuzz(), set_imaginary(), set_infinity(), set_largest(), set_log2(), set_nan(), set_pi(), set_smallest(), sharpen(), sin(), sinh(), implementation< ball_elementary, IV, ball_complex< BV > >::sinh(), sqrt(), square(), sub(), times_i(), unary_hash(), fast_helper< complex< C > >::uu(), make_ball_helper< complex< interval< C > >, complex< C >, C >::val(), and binary_helper< complex< C > >::write().

                     {
  return Real_affine (Re (base (z)), Re (slope (z)), limits (z));
}
ball< Real_type(C) ,R,V> mmx::Re ( const ball< C, R, V > &  z) [inline]

Definition at line 51 of file ball_complex.hpp.

References center(), radius(), Re(), and Real_ball.

                                                 {
  return Real_ball (Re (center (z)), radius (z)); }
tangent<Real_type(C),Real_type(D) > mmx::Re ( const tangent< C, D > &  z) [inline]

Definition at line 396 of file tangent.hpp.

References base(), Re(), Real_tangent, and slope().

                      {
  return Real_tangent (Re (base (z)), Re (slope (z)));
}
C & Re ( complex< C > &  z) [inline]

Definition at line 108 of file complex.hpp.

{ return z.re; }
C Re ( const complex< C > &  z) [inline]

Definition at line 106 of file complex.hpp.

{ return z.re; }
static string mmx::recompose ( int  sign,
const string &  mant,
const integer &  i 
) [static]

Definition at line 72 of file string_scnot.cpp.

References as_int(), and as_string().

Referenced by decompose_range(), make_range(), and trunc_digits().

                                                           {
  if (sign == 0) return "0";
  if (locase (mant) == "nan") return "NaN";
  if (mant == "0") return "0e" * as_string (i);
  if (sign < 0) return "-" * recompose (1, mant, i);
  if (locase (mant) == "infty") return "Infty";
  if (i == -1) return "0." * mant;
  if (i == -2) return "0.0" * mant;
  if (i == -3) return "0.00" * mant;
  if (N(mant) == 1) return mant * "e" * as_string (i);
  if (i >= 0 && i<6 && N(mant)>i+1)
    return mant (0, as_int (i)+1) * "." * mant (as_int (i)+1, N(mant));
  return mant (0, 1) * "." * mant (1, N(mant)) * "e" * as_string (i);
}
void mmx::reduce_mod ( C &  dest,
const modulus< C, V > &  m 
) [inline]

Definition at line 78 of file modulus.hpp.

Referenced by modulus_add_naive< modulus_reduction_naive< modulus_normalization_naive > >::add_mod(), modulus_encoding_naive< modulus_div_naive< modulus_inv_naive< modulus_mul_naive< modulus_add_naive< modulus_reduction_naive< modulus_normalization_naive > > > > > >::encode_mod(), modulus_encoding_integer_naive< modulus_div_naive< modulus_inv_integer_naive< modulus_mul_naive< modulus_add_integer_naive< modulus_reduction_naive< modulus_normalization_integer_naive > > > > > >::encode_mod(), modulus_encoding_int_naive< modulus_div_int_naive< modulus_inv_int_naive< modulus_mul_int_naive< modulus_add_int_naive< modulus_reduction_int_naive< modulus_normalization_int_naive< modulus_maximum_size_int< size > > > > > > > >::encode_mod(), modulus_mul_naive< modulus_add_naive< modulus_reduction_naive< modulus_normalization_naive > > >::mul_mod(), modulus_add_naive< modulus_reduction_naive< modulus_normalization_naive > >::neg_mod(), reduce_mod(), and modulus_add_naive< modulus_reduction_naive< modulus_normalization_naive > >::sub_mod().

                                       {
  V::reduce_mod (dest, m); }
void mmx::reduce_mod ( C &  dest,
const C &  s,
const modulus< C, V > &  m 
) [inline]

Definition at line 86 of file modulus.hpp.

References reduce_mod().

                                                   {
  V::reduce_mod (dest, s, m); }
void mmx::reduce_mod ( C &  dest,
const modulus< C, V > &  m,
C &  carry 
) [inline]

Definition at line 82 of file modulus.hpp.

References reduce_mod().

                                                 {
  V::reduce_mod (dest, m, carry); }
void mmx::reduce_mod ( C &  dest,
const C &  s,
const modulus< C, V > &  m,
C &  carry 
) [inline]

Definition at line 90 of file modulus.hpp.

References reduce_mod().

                                                             {
  V::reduce_mod (dest, s, m, carry); }
C mmx::rough_next_above ( const C &  z) [inline]

Definition at line 131 of file ball_rough.hpp.

References C.

Referenced by implementation< ball_multiplicative, W, ball_rough >::invert(), and implementation< ball_root, W, ball_rough >::sqrt().

                              {
  return (1 + Accuracy (C)) * z;
}
double mmx::rough_next_above ( const double &  z) [inline]

Definition at line 136 of file ball_rough.hpp.

                                   {
  const double alpha= 1.000000000000000223;
  return alpha * z;
}
floating<V> mmx::round ( const floating< V > &  x1) [inline]

Definition at line 388 of file floating.hpp.

References Floating.

                                                {
  Floating r (*x1); mpfr_round (*r, *x1); return r; }
interval<C,V> mmx::round ( const interval< C, V > &  x)

Definition at line 296 of file interval.hpp.

References Interval, lower(), round(), and upper().

                          {
  return Interval (Down::round (lower (x)), Up::round (upper (x)));
}
ball<C,R,V> mmx::round ( const ball< C, R, V > &  z) [inline]

Definition at line 630 of file ball.hpp.

References Ball.

Referenced by GLUE_30(), GLUE_41(), GLUE_42(), round(), and implementation< ball_ordered, W, ball_rounded >::round().

                      {
  typedef implementation<ball_ordered,V> Impl;
  Ball d; Impl::round (d, z); return d;
}
floating<V> mmx::rounding_error ( const floating< V > &  x) [inline]

Definition at line 477 of file floating.hpp.

References Floating.

Referenced by implementation< ball_rounding, W, ball_rounded >::add_rounding_error(), GLUE_44(), GLUE_53(), rounded_none_down::rounded_as(), and rounded_none_up::rounded_as().

                                                        {
  Floating r (*x);
  mpfr_abs (*r, *x, GMP_RNDN);
  mpfr_mul_2si (*r, *r, 1-mpfr_get_prec (*x), GMP_RNDN);
  mpfr_nextabove (*r);
  return r; }
void mmx::scalar_tangent ( tangent< C, D > &  r,
const C &  c 
) [inline]

Definition at line 67 of file tangent.hpp.

References promote(), slope(), and Tangent.

                                                         {
  r= Tangent (c, promote (0, slope (r))); }
void mmx::set_accuracy ( complex< C > &  z) [inline]

Definition at line 254 of file complex.hpp.

References Im(), Re(), and set_accuracy().

                                           {
  set_accuracy (Re (z)); set_zero (Im (z)); }
void mmx::set_accuracy ( floating< V > &  r) [inline]

Definition at line 283 of file floating.hpp.

References Floating, and next_above().

                                            {
  r= next_above (Floating (1)) - Floating (1); }
void mmx::set_accuracy ( interval< C, V > &  x) [inline]

Definition at line 318 of file interval.hpp.

References C, and Interval.

                                            {
  x= Interval (Accuracy (C), Accuracy (C)); }
void mmx::set_accuracy ( tangent< C, D > &  z) [inline]

Definition at line 145 of file tangent.hpp.

References base(), set_accuracy(), and slope().

                                           {
  set_accuracy (base (z)); set_zero (slope (z)); }
void mmx::set_accuracy ( affine< C, VC > &  x) [inline]

Definition at line 205 of file affine.hpp.

References Affine, and C.

Referenced by set_accuracy().

{ x= Affine (Accuracy (C), 0); }
void mmx::set_accuracy ( ball< C, R, V > &  x) [inline]

Definition at line 342 of file ball.hpp.

References Ball, and C.

{ x= Ball (Accuracy (C), 0); }
void mmx::set_accuracy ( twin< C, D, V > &  z) [inline]

Definition at line 177 of file twin.hpp.

References car(), cdr(), and set_accuracy().

                                        {
  set_accuracy (car (z)); set_accuracy (cdr (z)); }
void mmx::set_as ( complex< T > &  r,
const F &  x 
) [inline]

Definition at line 97 of file complex.hpp.

References Im(), Re(), and set_as().

                                   {
  set_as (Re(r), x);
  set_as (Im(r), 0);
}
void mmx::set_as ( ball< TC, TR, TV > &  r,
const ball< FC, FR, FV > &  z 
) [inline]

Definition at line 230 of file ball.hpp.

References add_additive_error(), center(), radius(), and Rnd.

Referenced by set_as().

                                                    {
  typedef implementation<ball_rounding,TV> Rnd;
  set_as (center (r), center (z));
  set_as (radius (r), radius (z));
  Rnd::add_additive_error (r);
}
void mmx::set_as ( complex< T > &  r,
const complex< F > &  z 
) [inline]

Definition at line 91 of file complex.hpp.

References Im(), Re(), and set_as().

                                            {
  set_as (Re(r), Re(z));
  set_as (Im(r), Im(z));
}
void mmx::set_as ( ball< TC, TR, TV > &  r,
const F &  z 
) [inline]

Definition at line 238 of file ball.hpp.

References add_additive_error(), center(), radius(), Rnd, and set_as().

                                       {
  typedef implementation<ball_rounding,TV> Rnd;
  set_as (center (r), z);
  set_as (radius (r), 0);
  Rnd::add_additive_error (r);
}
void mmx::set_catalan ( interval< C, V > &  x) [inline]

Definition at line 326 of file interval.hpp.

References Interval.

                                           {
  x= Interval (Down::template catalan<C>(), Up::template catalan<C>()); }
void mmx::set_euler ( tangent< C, D > &  z) [inline]

Definition at line 151 of file tangent.hpp.

References base(), set_euler(), and slope().

                                        {
  set_euler (base (z)); set_zero (slope (z)); }
void mmx::set_euler ( affine< C, VC > &  x) [inline]

Definition at line 208 of file affine.hpp.

References Affine, and C.

Referenced by set_euler().

{ x= Affine (Euler (C), 0); }
void mmx::set_euler ( ball< C, R, V > &  x) [inline]

Definition at line 345 of file ball.hpp.

References Ball, and C.

{ x= Ball (Euler (C), 0, true); }
void mmx::set_euler ( interval< C, V > &  x) [inline]

Definition at line 324 of file interval.hpp.

References Interval.

                                         {
  x= Interval (Down::template euler<C>(), Up::template euler<C>()); }
void mmx::set_euler ( complex< C > &  z) [inline]

Definition at line 260 of file complex.hpp.

References Im(), Re(), and set_euler().

                                        {
  set_euler (Re (z)); set_zero (Im (z)); }
void mmx::set_euler ( twin< C, D, V > &  z) [inline]

Definition at line 183 of file twin.hpp.

References car(), cdr(), and set_euler().

                                     {
  set_euler (car (z)); set_euler (cdr (z)); }
void mmx::set_euler ( floating< V > &  r) [inline]

Definition at line 289 of file floating.hpp.

References Rnd.

                                         {
  mpfr_const_euler (*r, Rnd); }
void mmx::set_fuzz ( tangent< C, D > &  z) [inline]

Definition at line 139 of file tangent.hpp.

References base(), set_fuzz(), and slope().

                                       {
  set_fuzz (base (z)); set_fuzz (slope (z)); }
void mmx::set_fuzz ( ball< C, R, V > &  x) [inline]

Definition at line 339 of file ball.hpp.

References Ball, and R.

{ x= Ball (0, Infinity (R)); }
void mmx::set_fuzz ( twin< C, D, V > &  z) [inline]

Definition at line 171 of file twin.hpp.

References car(), cdr(), and set_fuzz().

                                    {
  set_fuzz (car (z)); set_fuzz (cdr (z)); }
void mmx::set_fuzz ( interval< C, V > &  x) [inline]

Definition at line 312 of file interval.hpp.

References C, and Interval.

                                        {
  x= Interval (Minimal (C), Maximal (C)); }
void mmx::set_fuzz ( complex< C > &  z) [inline]

Definition at line 248 of file complex.hpp.

References Im(), Re(), and set_fuzz().

                                       {
  set_fuzz (Re (z)); set_fuzz (Im (z)); }
void mmx::set_fuzz ( affine< C, VC > &  x) [inline]

Definition at line 202 of file affine.hpp.

References Affine, and C.

Referenced by set_fuzz().

{ x= Affine (Fuzz (C), 0); }
void mmx::set_imaginary ( complex< C > &  z) [inline]

Definition at line 262 of file complex.hpp.

References Im(), and Re().

                                            {
  set_zero (Re (z)); set_one (Im (z)); }
void mmx::set_imaginary ( ball< C, R, V > &  x) [inline]

Definition at line 346 of file ball.hpp.

References Ball.

                                         {
  x= Ball (Real_type (Ball) (0), Real_type (Ball) (1)); }
void mmx::set_imaginary ( affine< C, VC > &  x) [inline]

Definition at line 209 of file affine.hpp.

References Affine, and C.

Referenced by set_imaginary().

{ x= Affine (Imaginary (C), 0); }
void mmx::set_imaginary ( tangent< C, D > &  z) [inline]

Definition at line 153 of file tangent.hpp.

References base(), set_imaginary(), and slope().

                                            {
  set_imaginary (base (z)); set_zero (slope (z)); }
void mmx::set_imaginary ( twin< C, D, V > &  z) [inline]

Definition at line 185 of file twin.hpp.

References car(), cdr(), and set_imaginary().

                                         {
  set_zero (car (z)); set_imaginary (cdr (z)); }
void mmx::set_infinity ( tangent< C, D > &  z) [inline]

Definition at line 137 of file tangent.hpp.

References base(), set_infinity(), and slope().

                                           {
  set_infinity (base (z)); set_zero (slope (z)); }
void mmx::set_infinity ( interval< C, V > &  x) [inline]

Definition at line 310 of file interval.hpp.

References C, and Interval.

                                            {
  x= Interval (Infinity (C), Infinity (C)); }
void mmx::set_infinity ( twin< C, D, V > &  z) [inline]

Definition at line 169 of file twin.hpp.

References car(), cdr(), and set_infinity().

                                        {
  set_infinity (car (z)); set_infinity (cdr (z)); }
void mmx::set_infinity ( complex< C > &  z) [inline]

Definition at line 246 of file complex.hpp.

References Im(), Re(), and set_infinity().

                                           {
  set_infinity (Re (z)); set_infinity (Im (z)); }
void mmx::set_infinity ( affine< C, VC > &  x) [inline]

Definition at line 201 of file affine.hpp.

References Affine, and C.

Referenced by set_infinity().

{ x= Affine (Infinity (C), 0); }
void mmx::set_infinity ( ball< C, R, V > &  x) [inline]

Definition at line 338 of file ball.hpp.

References Ball, and C.

{ x= Ball (Infinity (C), 0); }
void mmx::set_infinity ( floating< V > &  r) [inline]

Definition at line 273 of file floating.hpp.

                                            {
  mpfr_set_inf (*r, 1); }
void mmx::set_largest ( floating< V > &  r) [inline]

Definition at line 279 of file floating.hpp.

                                           {
  mpfr_set_inf (*r, 1); mpfr_nextbelow (*r); }
void mmx::set_largest ( interval< C, V > &  x) [inline]

Definition at line 316 of file interval.hpp.

References C, and Interval.

                                           {
  x= Interval (Largest (C), Largest (C)); }
void mmx::set_largest ( affine< C, VC > &  x) [inline]

Definition at line 204 of file affine.hpp.

References Affine, and C.

Referenced by set_largest().

{ x= Affine (Largest (C), 0); }
void mmx::set_largest ( twin< C, D, V > &  z) [inline]

Definition at line 175 of file twin.hpp.

References car(), cdr(), and set_largest().

                                       {
  set_largest (car (z)); set_largest (cdr (z)); }
void mmx::set_largest ( ball< C, R, V > &  x) [inline]

Definition at line 341 of file ball.hpp.

References Ball, and C.

{ x= Ball (Largest (C), 0); }
void mmx::set_largest ( tangent< C, D > &  z) [inline]

Definition at line 143 of file tangent.hpp.

References base(), set_largest(), and slope().

                                          {
  set_largest (base (z)); set_zero (slope (z)); }
void mmx::set_largest ( complex< C > &  z) [inline]

Definition at line 252 of file complex.hpp.

References Im(), Re(), and set_largest().

                                          {
  set_largest (Re (z)); set_zero (Im (z)); }
void mmx::set_log2 ( twin< C, D, V > &  z) [inline]

Definition at line 179 of file twin.hpp.

References car(), cdr(), and set_log2().

                                    {
  set_log2 (car (z)); set_log2 (cdr (z)); }
void mmx::set_log2 ( tangent< C, D > &  z) [inline]

Definition at line 147 of file tangent.hpp.

References base(), set_log2(), and slope().

                                       {
  set_log2 (base (z)); set_zero (slope (z)); }
void mmx::set_log2 ( ball< C, R, V > &  x) [inline]

Definition at line 343 of file ball.hpp.

References Ball, and C.

{ x= Ball (Log2 (C), 0, true); }
void mmx::set_log2 ( interval< C, V > &  x) [inline]

Definition at line 320 of file interval.hpp.

References Interval.

                                        {
  x= Interval (Down::template log2<C>(), Up::template log2<C>()); }
void mmx::set_log2 ( affine< C, VC > &  x) [inline]

Definition at line 206 of file affine.hpp.

References Affine, and C.

Referenced by set_log2().

{ x= Affine (Log2 (C), 0); }
void mmx::set_log2 ( floating< V > &  r) [inline]

Definition at line 285 of file floating.hpp.

References Rnd.

                                        {
  mpfr_const_log2 (*r, Rnd); }
void mmx::set_log2 ( complex< C > &  z) [inline]

Definition at line 256 of file complex.hpp.

References Im(), Re(), and set_log2().

                                       {
  set_log2 (Re (z)); set_zero (Im (z)); }
void mmx::set_maximal ( affine< C, VC > &  x) [inline]

Definition at line 199 of file affine.hpp.

References Affine, and C.

{ x= Affine (Maximal (C), 0); }
void mmx::set_maximal ( ball< C, R, V > &  x) [inline]

Definition at line 336 of file ball.hpp.

References Ball, and C.

{ x= Ball (Maximal (C), 0); }
void mmx::set_maximal ( interval< C, V > &  x) [inline]

Definition at line 306 of file interval.hpp.

References C, and Interval.

                                           {
  x= Interval (Maximal (C), Maximal (C)); }
void mmx::set_maximal ( floating< V > &  r) [inline]

Definition at line 275 of file floating.hpp.

                                           {
  mpfr_set_inf (*r, 1); }
void mmx::set_minimal ( floating< V > &  r) [inline]

Definition at line 277 of file floating.hpp.

                                           {
  mpfr_set_inf (*r, -1); }
void mmx::set_minimal ( interval< C, V > &  x) [inline]

Definition at line 308 of file interval.hpp.

References C, and Interval.

                                           {
  x= Interval (Minimal (C), Minimal (C)); }
void mmx::set_minimal ( affine< C, VC > &  x) [inline]

Definition at line 200 of file affine.hpp.

References Affine, and C.

{ x= Affine (Minimal (C), 0); }
void mmx::set_minimal ( ball< C, R, V > &  x) [inline]

Definition at line 337 of file ball.hpp.

References Ball, and C.

{ x= Ball (Minimal (C), 0); }
void mmx::set_modulus ( modular< M, modular_local > &  x,
const M &  p 
) [inline]

Definition at line 375 of file modular.hpp.

                                     {
  x.set_local_modulus (p); }
void mmx::set_modulus ( modular< M, V > &  x,
const M &  p 
) [inline]
Examples:
modular_test.cpp.

Definition at line 153 of file modular.hpp.

                                                      {
  (void) x; Modular::set_modulus (p); }
void mmx::set_nan ( ball< C, R, V > &  x) [inline]

Definition at line 335 of file ball.hpp.

References Ball, and C.

{ x= Ball (Nan (C), 0); }
void mmx::set_nan ( rational &  r) [inline]

Definition at line 251 of file rational.hpp.

{ r= 0; }
void mmx::set_nan ( tangent< C, D > &  z) [inline]

Definition at line 135 of file tangent.hpp.

References base(), set_nan(), and slope().

                                      {
  set_nan (base (z)); set_nan (slope (z)); }
void mmx::set_nan ( affine< C, VC > &  x) [inline]

Definition at line 198 of file affine.hpp.

References Affine, and C.

Referenced by set_nan().

{ x= Affine (Nan (C), 0); }
void mmx::set_nan ( complex< C > &  z) [inline]

Definition at line 244 of file complex.hpp.

References Im(), Re(), and set_nan().

                                      {
  set_nan (Re (z)); set_nan (Im (z)); }
void mmx::set_nan ( twin< C, D, V > &  z) [inline]

Definition at line 167 of file twin.hpp.

References car(), cdr(), and set_nan().

                                   {
  set_nan (car (z)); set_nan (cdr (z)); }
void mmx::set_nan ( interval< C, V > &  x) [inline]

Definition at line 304 of file interval.hpp.

References C, and Interval.

                                       {
  x= Interval (Nan (C), Nan (C)); }
void mmx::set_nan ( floating< V > &  r) [inline]

Definition at line 271 of file floating.hpp.

                                       {
  mpfr_init (*r); }
void mmx::set_pi ( twin< C, D, V > &  z) [inline]

Definition at line 181 of file twin.hpp.

References car(), cdr(), and set_pi().

                                  {
  set_pi (car (z)); set_pi (cdr (z)); }
void mmx::set_pi ( affine< C, VC > &  x) [inline]

Definition at line 207 of file affine.hpp.

References Affine, and C.

Referenced by set_pi().

{ x= Affine (Pi (C), 0); }
void mmx::set_pi ( floating< V > &  r) [inline]

Definition at line 287 of file floating.hpp.

References Rnd.

                                      {
  mpfr_const_pi (*r, Rnd); }
void mmx::set_pi ( ball< C, R, V > &  x) [inline]

Definition at line 344 of file ball.hpp.

References Ball, and C.

{ x= Ball (Pi (C), 0, true); }
void mmx::set_pi ( complex< C > &  z) [inline]

Definition at line 258 of file complex.hpp.

References Im(), Re(), and set_pi().

                                     {
  set_pi (Re (z)); set_zero (Im (z)); }
void mmx::set_pi ( tangent< C, D > &  z) [inline]

Definition at line 149 of file tangent.hpp.

References base(), set_pi(), and slope().

                                     {
  set_pi (base (z)); set_zero (slope (z)); }
void mmx::set_pi ( interval< C, V > &  x) [inline]

Definition at line 322 of file interval.hpp.

References Interval.

                                      {
  x= Interval (Down::template pi<C>(), Up::template pi<C>()); }
void mmx::set_smallest ( complex< C > &  z) [inline]

Definition at line 250 of file complex.hpp.

References Im(), Re(), and set_smallest().

                                           {
  set_smallest (Re (z)); set_zero (Im (z)); }
void mmx::set_smallest ( ball< C, R, V > &  x) [inline]

Definition at line 340 of file ball.hpp.

References Ball, and C.

{ x= Ball (Smallest (C), 0); }
void mmx::set_smallest ( twin< C, D, V > &  z) [inline]

Definition at line 173 of file twin.hpp.

References car(), cdr(), and set_smallest().

                                        {
  set_smallest (car (z)); set_smallest (cdr (z)); }
void mmx::set_smallest ( interval< C, V > &  x) [inline]

Definition at line 314 of file interval.hpp.

References C, and Interval.

                                            {
  x= Interval (Smallest (C), Smallest (C)); }
void mmx::set_smallest ( floating< V > &  r) [inline]

Definition at line 281 of file floating.hpp.

                                            {
  mpfr_set_si (*r, 0, GMP_RNDU); mpfr_nextabove (*r); }
void mmx::set_smallest ( tangent< C, D > &  z) [inline]

Definition at line 141 of file tangent.hpp.

References base(), set_smallest(), and slope().

                                           {
  set_smallest (base (z)); set_zero (slope (z)); }
void mmx::set_smallest ( affine< C, VC > &  x) [inline]

Definition at line 203 of file affine.hpp.

References Affine, and C.

Referenced by set_smallest().

{ x= Affine (Smallest (C), 0); }
tangent<C,D> mmx::sharpen ( const tangent< C, D > &  z) [inline]

Definition at line 379 of file tangent.hpp.

References base(), sharpen(), slope(), and Tangent.

                                               {
  return Tangent (sharpen (base (z)), sharpen (slope (z))); }
complex<C> mmx::sharpen ( const complex< C > &  z) [inline]

Definition at line 642 of file complex.hpp.

References Complex, Im(), Re(), and sharpen().

                                               {
  return Complex (sharpen (Re (z)), sharpen (Im (z))); }
ball<C,R,V> mmx::sharpen ( const ball< C, R, V > &  z) [inline]

Definition at line 678 of file ball.hpp.

References Ball, and center().

                                         {
  return Ball (center (z)); }
interval<C,V> mmx::sharpen ( const interval< C, V > &  x) [inline]

Definition at line 636 of file interval.hpp.

References center(), and Interval.

                                                 {
  return Interval (center (x)); }
affine<C,VC> mmx::sharpen ( const affine< C, VC > &  z) [inline]

Definition at line 466 of file affine.hpp.

References Affine, base(), limits(), and slope().

Referenced by affine_limits_helper< C, VC >::get_linear(), and sharpen().

                                             {
  return Affine (sharpen (base (z)), sharpen (slope (z)), limits (z)); }
twin<C,D,V> mmx::sharpen ( const twin< C, D, V > &  z) [inline]

Definition at line 293 of file twin.hpp.

References car(), cdr(), sharpen(), and Twin.

                                         {
  return Twin (sharpen (car (z)), sharpen (cdr (z))); }
int mmx::sign ( const floating< V > &  x1) [inline]

Definition at line 373 of file floating.hpp.

Referenced by abs(), atan2(), cos(), decompose(), decompose_range(), modulus_encoding_int_naive< modulus_div_int_naive< modulus_inv_int_naive< modulus_mul_int_naive< modulus_add_int_naive< modulus_reduction_int_naive< modulus_normalization_int_naive< modulus_maximum_size_int< size > > > > > > > >::encode_mod(), is_non_zero(), is_zero(), sin(), and trunc_digits().

                                          {
  int r= mpfr_sgn (*x1); return (r<0? -1: (r==0? 0: 1)); }
generic mmx::simple_construct_integer ( const integer &  i)

Definition at line 22 of file numerix.cpp.

References as_string().

                                            {
  return generic (as_string (i));
}
generic mmx::simple_construct_rational ( const rational &  x)

Definition at line 27 of file numerix.cpp.

References as_string().

                                              {
  if (denominator (x) == 1) return generic (as_string (numerator (x)));
  return generic (as_string (numerator (x))) /
         generic (as_string (denominator (x)));
}
complex<C> mmx::sin ( const complex< C > &  z) [inline]

Definition at line 510 of file complex.hpp.

References Complex, cos(), cosh(), Im(), Re(), sin(), and sinh().

                       {
  return Complex (sin (Re (z)) * cosh (Im (z)),
                  cos (Re (z)) * sinh (Im (z)));
}
interval<C,V> mmx::sin ( const interval< C, V > &  x)

Definition at line 517 of file interval.hpp.

References C, cos(), Interval, lower(), max(), min(), promote(), sign(), sin(), sub(), and upper().

                        {
  C pi_lo= promote (314159, lower (x)) / promote (100000, lower (x));
  if (Up::sub (upper (x), lower (x)) >= pi_lo)
    return Interval (promote (-1, lower (x)), promote (1, lower (x)));
  else {
    int s1= sign (cos (lower (x)));
    int s2= sign (cos (upper (x)));
    if (s1 >= 0 && s2 >= 0)
      return Interval (Down::sin (lower (x)), Up::sin (upper (x)));
    else if (s1 <= 0 && s2 <= 0)
      return Interval (Down::sin (upper (x)), Down::sin (lower (x)));
    else if (s1 >= 0)
      return Interval (min (Down::sin (lower (x)), Down::sin (upper (x))),
                       promote (1, lower (x)));
    else
      return Interval (promote (-1, lower (x)),
                       max (Down::sin (lower (x)), Down::sin (upper (x))));
  }
}
twin<C,D,V> mmx::sin ( const twin< C, D, V > &  x)

Definition at line 237 of file twin.hpp.

References car(), cdr(), sin(), and Twin.

                              {
  return Twin (sin (car (x)), sin (cdr (x))); }
floating<V> mmx::sin ( const floating< V > &  x1) [inline]

Definition at line 417 of file floating.hpp.

References Floating, and Rnd.

                                              {
  Floating r (*x1); mpfr_sin (*r, *x1, Rnd); return r; }
ball<C,R,V> mmx::sin ( const ball< C, R, V > &  z) [inline]
Examples:
ball_test.cpp, complex_ball_test.cpp, complex_test.cpp, and interval_test.cpp.

Definition at line 523 of file ball.hpp.

References Ball, C, Elementary_variant, and V.

Referenced by cos(), implementation< ball_elementary, W, ball_rounded >::cos(), cosh(), GLUE_16(), GLUE_17(), GLUE_21(), GLUE_26(), GLUE_27(), GLUE_30(), GLUE_49(), polar(), implementation< ball_complex_construct, IV, ball_complex< BV > >::polar(), sin(), sinh(), and tan().

                    {
  typedef Elementary_variant(C,V) EV;
  typedef implementation<ball_elementary,EV> Impl;
  Ball d; Impl::sin (d, z); return d;
}
tangent<C,D> mmx::sin ( const tangent< C, D > &  z) [inline]

Definition at line 257 of file tangent.hpp.

References base(), cos(), sin(), slope(), and Tangent.

                       {
  return Tangent (sin (base (z)), cos (base (z)) * slope (z));
}
bool mmx::singleton ( const interval< T > &  x) [inline]

Definition at line 112 of file kernel.hpp.

References lower(), and upper().

{ return lower(x) == upper(x); };
tangent<C,D> mmx::sinh ( const tangent< C, D > &  z) [inline]

Definition at line 272 of file tangent.hpp.

References base(), cosh(), sinh(), slope(), and Tangent.

                        {
  return Tangent (sinh (base (z)), cosh (base (z)) * slope (z));
}
interval<C,V> mmx::sinh ( const interval< C, V > &  x) [inline]

Definition at line 553 of file interval.hpp.

References Interval, lower(), sinh(), and upper().

                         {
  return Interval (Down::sinh (lower (x)), Up::sinh (upper (x)));
}
floating<V> mmx::sinh ( const floating< V > &  x1) [inline]

Definition at line 431 of file floating.hpp.

References Floating, and Rnd.

                                               {
  Floating r (*x1); mpfr_sinh (*r, *x1, Rnd); return r; }
complex<C> mmx::sinh ( const complex< C > &  z) [inline]

Definition at line 557 of file complex.hpp.

References Complex, cos(), cosh(), Im(), Re(), sin(), and sinh().

                        {
  return Complex (sinh (Re (z)) * cos (Im (z)),
                  cosh (Re (z)) * sin (Im (z)));
}
twin<C,D,V> mmx::sinh ( const twin< C, D, V > &  x)

Definition at line 249 of file twin.hpp.

References car(), cdr(), sinh(), and Twin.

                               {
  return Twin (sinh (car (x)), sinh (cdr (x))); }
ball<C,R,V> mmx::sinh ( const ball< C, R, V > &  z) [inline]

Definition at line 544 of file ball.hpp.

References Ball, C, Elementary_variant, and V.

Referenced by cos(), implementation< ball_elementary, IV, ball_complex< BV > >::cos(), cosh(), implementation< ball_elementary, W, ball_rounded >::cosh(), implementation< ball_elementary, IV, ball_complex< BV > >::cosh(), sin(), sinh(), and tanh().

                     {
  typedef Elementary_variant(C,V) EV;
  typedef implementation<ball_elementary,EV> Impl;
  Ball d; Impl::sinh (d, z); return d;
}
D slope ( const tangent< C, D > &  z) [inline]

Definition at line 70 of file tangent.hpp.

{ return z.d; }
VC slope ( const affine< C, VC > &  z) [inline]

Definition at line 106 of file affine.hpp.

Referenced by abs(), acos(), additive_error(), asin(), atan(), binary_test(), blur(), CF2(), change_precision(), copy(), cos(), cosh(), binary_helper< tangent< C, D > >::disassemble(), binary_helper< affine< C, VC > >::disassemble(), duplicate(), exp(), flatten(), GLUE_17(), GLUE_37(), GLUE_4(), GLUE_5(), Im(), invert(), is_finite(), is_fuzz(), is_infinite(), is_nan(), log(), map(), operator*(), operator+(), operator-(), operator/(), operator<<(), operator>>(), Re(), scalar_tangent(), set_accuracy(), set_euler(), set_fuzz(), set_imaginary(), set_infinity(), set_largest(), set_log2(), set_nan(), set_pi(), set_smallest(), sharpen(), sin(), sinh(), sqrt(), square(), truncate(), unary_hash(), binary_helper< tangent< C, D > >::write(), and binary_helper< affine< C, VC > >::write().

                                       {
  return z.lin; }
D & slope ( tangent< C, D > &  z) [inline]

Definition at line 72 of file tangent.hpp.

{ return z.d; }
V twin<C,D,V> mmx::sqrt ( const twin< C, D, V > &  x)

Definition at line 225 of file twin.hpp.

References car(), cdr(), sqrt(), and Twin.

                               {
  return Twin (sqrt (car (x)), sqrt (cdr (x))); }
floating<V> mmx::sqrt ( const floating< V > &  x1) [inline]

Definition at line 399 of file floating.hpp.

References Rnd.

                                               {
  Floating r (*x1); mpfr_sqrt (*r, *x1, Rnd); return r; }
complex<C> mmx::sqrt ( const complex< C > &  z)

Definition at line 451 of file complex.hpp.

References C, Complex, hypot(), Im(), promote(), Re(), and sqrt().

                        {
  C a= hypot (Re (z), Im (z));
  if (Re (z) > 0) {
    C r= sqrt ((a + Re (z)) / promote (2, a));
    return Complex (r, (Im (z) / r) / promote (2, a));
  }
  else if (a == 0) return promote (0, z);
  else {
    C i = sqrt ((a - Re (z)) / promote (2, a));
    if (Im (z) < 0) i= -i;
    return Complex ((Im (z) / i) / promote (2, a), i);
  }
}
interval<C,V> mmx::sqrt ( const interval< C, V > &  x)

Definition at line 469 of file interval.hpp.

References Interval, lower(), sqrt(), and upper().

                         {
  return Interval (Down::sqrt (lower (x)), Up::sqrt (upper (x)));
}
ball<C,R,V> mmx::sqrt ( const ball< C, R, V > &  z) [inline]
Examples:
ball_test.cpp, complex_ball_test.cpp, floating_test.cpp, integer_test.cpp, and interval_test.cpp.

Definition at line 467 of file ball.hpp.

References Ball, C, Elementary_variant, and V.

Referenced by acos(), implementation< ball_elementary, W, ball_rounded >::acos(), asin(), implementation< ball_elementary, W, ball_rounded >::asin(), GLUE_11(), GLUE_12(), GLUE_16(), GLUE_21(), GLUE_22(), GLUE_25(), GLUE_44(), hypot(), sqrt(), implementation< ball_root, W, ball_rounded >::sqrt(), implementation< ball_root, IV, ball_infinities< BV > >::sqrt(), and implementation< ball_root, IV, ball_complex< BV > >::sqrt().

                     {
  typedef Elementary_variant(C,V) EV;
  typedef implementation<ball_root,EV> Impl;
  Ball d; Impl::sqrt (d, z); return d;
}
tangent<C,D> mmx::sqrt ( const tangent< C, D > &  z) [inline]

Definition at line 230 of file tangent.hpp.

References base(), C, invert(), slope(), sqrt(), and Tangent.

                        {
  C s= sqrt (base (z));
  return Tangent (s, invert (s + s) * slope (z));
}
interval<C,V> mmx::square ( const interval< C, V > &  x) [inline]

Definition at line 407 of file interval.hpp.

References Interval, lower(), max(), mul(), and upper().

                           {
  if (lower (x) >= 0)
    return Interval (Down::mul (lower (x), lower (x)),
                     Up::mul (upper (x), upper (x)));
  else if (upper (x) <= 0)
    return Interval (Down::mul (upper (x), upper (x)),
                     Up::mul (lower (x), lower (x)));
  else return Interval (Down::mul (lower (x), upper (x)),
                        max (Up::mul (lower (x), lower (x)),
                             Up::mul (upper (x), upper (x))));
}
complex<C> mmx::square ( const complex< C > &  z) [inline]

Definition at line 323 of file complex.hpp.

References C, Complex, Im(), Re(), and square().

                          {
  C h= Re (z) * Im (z);
  return Complex (square (Re (z)) - square (Im (z)), h + h);
}
floating<V> mmx::square ( const floating< V > &  x) [inline]

Definition at line 308 of file floating.hpp.

References Floating, and Rnd.

                                                {
  Floating r (*x); mpfr_mul (*r, *x, *x, Rnd); return r; }
tangent<C,D> mmx::square ( const tangent< C, D > &  z) [inline]

Definition at line 194 of file tangent.hpp.

References base(), slope(), square(), and Tangent.

                          {
  return Tangent (square (base (z)), (base (z) + base (z)) * slope (z));
}
ball<C,R,V> mmx::square ( const ball< C, R, V > &  z) [inline]

Definition at line 416 of file ball.hpp.

References Ball, and square().

                       {
  typedef implementation<ball_multiplicative,V> Impl;
  Ball d; Impl::square (d, z); return d;
}
affine<C,VC> mmx::square ( const affine< C, VC > &  z) [inline]

Definition at line 272 of file affine.hpp.

References Affine, base(), limits(), slope(), and truncate().

Referenced by acos(), asin(), atan(), implementation< ball_elementary, W, ball_rounded >::atan(), binpow(), GLUE_10(), GLUE_16(), GLUE_19(), GLUE_39(), GLUE_6(), GLUE_7(), GLUE_9(), hypot(), invert(), implementation< ball_multiplicative, W, ball_rounded >::invert(), magnitude(), norm(), operator/(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::square(), and square().

                         {
  return Affine (square (base (z)),
                 (base (z) + truncate (z)) * slope (z), limits (z));
}
mmx::STYPE_TO_TYPE ( template< typename V, typename W >  ,
lift_type  ,
modular< modulus< unsigned int, V >, W >  ,
integer   
)
mmx::STYPE_TO_TYPE ( template< typename V, typename W >  ,
lift_type  ,
modular< modulus< signed short int, V >, W >  ,
integer   
)
mmx::STYPE_TO_TYPE ( template< typename V, typename W >  ,
lift_type  ,
modular< modulus< int, V >, W >  ,
integer   
)
mmx::STYPE_TO_TYPE ( template< typename V, typename W >  ,
lift_type  ,
modular< modulus< long int, V >, W >  ,
integer   
)
mmx::STYPE_TO_TYPE ( template< typename V, typename W >  ,
lift_type  ,
modular< modulus< unsigned short int, V >, W >  ,
integer   
)
mmx::STYPE_TO_TYPE ( template< typename V, typename W >  ,
lift_type  ,
modular< modulus< unsigned char, V >, W >  ,
integer   
)
mmx::STYPE_TO_TYPE ( template< typename C >  ,
default_radius_type  ,
complex< C >  ,
Default_radius_type(C)   
)
mmx::STYPE_TO_TYPE ( template< typename V >  ,
default_radius_type  ,
floating< V >  ,
floating< single_floating >   
)
mmx::STYPE_TO_TYPE ( template< typename V, typename W >  ,
lift_type  ,
modular< modulus< long long int, V >, W >  ,
integer   
)
mmx::STYPE_TO_TYPE ( template< typename V, typename W >  ,
lift_type  ,
modular< modulus< unsigned long long int, V >, W >  ,
integer   
)
mmx::STYPE_TO_TYPE ( template< typename C, typename VC >  ,
scalar_type  ,
affine< C, VC >  ,
C   
)
mmx::STYPE_TO_TYPE ( template< typename V, typename W >  ,
lift_type  ,
modular< modulus< unsigned long int, V >, W >  ,
integer   
)
mmx::STYPE_TO_TYPE ( template< typename V, typename W >  ,
lift_type  ,
modular< modulus< signed char, V >, W >  ,
integer   
)
mmx::STYPE_TO_TYPE ( template< typename C, typename D >  ,
scalar_type  ,
tangent< C, D >  ,
C   
)
mmx::STYPE_TO_TYPE ( template< typename M, typename V >  ,
lift_type  ,
modular< M, V >  ,
typename modular< M, V >::C   
)
void mmx::sub ( floating< V > &  r,
const floating< V > &  x1,
const floating< V > &  x2 
) [inline]

Definition at line 329 of file floating.hpp.

References Rnd.

                                                                            {
  r.secure (); mpfr_sub (*r, *x1, *x2, Rnd); }
void mmx::sub ( complex< C > &  r,
const complex< C > &  z1,
const complex< C > &  z2 
) [inline]

Definition at line 423 of file complex.hpp.

References Im(), and Re().

Referenced by implementation< ball_rounding, W, ball_rounded >::abs_down(), implementation< ball_rounding, W, ball_rounded >::bnd_down(), cos(), implementation< ball_rounding, W, ball_rounded >::make_interval(), operator-(), interval< C, V >::operator-=(), radius(), sin(), implementation< ball_additive, IV, ball_infinities< BV > >::sub(), and make_interval_helper< ball< C, R, V >, C2 >::val().

                                                       {
  sub (Re (r), Re (z1), Re (z2));
  sub (Im (r), Im (z1), Im (z2));
}
void mmx::sub_mod ( C &  dest,
const C &  s,
const modulus< C, V > &  m 
) [inline]

Definition at line 134 of file modulus.hpp.

Referenced by operator-(), operator-=(), and sub_mod().

                                                {
  V::sub_mod (dest, s, m); }
void mmx::sub_mod ( C &  dest,
const C &  s,
const modulus< C, V > &  m,
C &  carry 
) [inline]

Definition at line 138 of file modulus.hpp.

References sub_mod().

                                                          {
  V::sub_mod (dest, s, m, carry); }
void mmx::sub_mod ( C &  dest,
const C &  s1,
const C &  s2,
const modulus< C, V > &  m 
) [inline]

Definition at line 142 of file modulus.hpp.

References sub_mod().

                                                              {
  V::sub_mod (dest, s1, s2, m); }
void mmx::sub_mod ( C &  dest,
const C &  s1,
const C &  s2,
const modulus< C, V > &  m,
C &  carry 
) [inline]

Definition at line 146 of file modulus.hpp.

References sub_mod().

                                                                        {
  V::sub_mod (dest, s1, s2, m, carry); }
tangent<C,D> mmx::tan ( const tangent< C, D > &  z) [inline]

Definition at line 262 of file tangent.hpp.

References cos(), and sin().

                       {
  return sin (z) / cos (z);
}
twin<C,D,V> mmx::tan ( const twin< C, D, V > &  x)

Definition at line 239 of file twin.hpp.

References car(), cdr(), tan(), and Twin.

                              {
  return Twin (tan (car (x)), tan (cdr (x))); }
floating<V> mmx::tan ( const floating< V > &  x1) [inline]

Definition at line 419 of file floating.hpp.

References Floating, and Rnd.

                                              {
  Floating r (*x1); mpfr_tan (*r, *x1, Rnd); return r; }
ball<C,R,V> mmx::tan ( const ball< C, R, V > &  z) [inline]
Examples:
ball_test.cpp, complex_ball_test.cpp, and interval_test.cpp.

Definition at line 530 of file ball.hpp.

References Ball, C, Elementary_variant, and V.

Referenced by GLUE_17(), GLUE_18(), GLUE_22(), GLUE_27(), GLUE_28(), GLUE_31(), GLUE_50(), and tan().

                    {
  typedef Elementary_variant(C,V) EV;
  typedef implementation<ball_elementary,EV> Impl;
  Ball d; Impl::tan (d, z); return d;
}
interval<C,V> mmx::tan ( const interval< C, V > &  x)

Definition at line 538 of file interval.hpp.

References cos(), and sin().

                        {
  return sin (x) / cos (x);
}
complex<C> mmx::tan ( const complex< C > &  z) [inline]

Definition at line 516 of file complex.hpp.

References cos(), and sin().

                       {
  return sin (z) / cos (z);
}
interval<C,V> mmx::tanh ( const interval< C, V > &  x)

Definition at line 558 of file interval.hpp.

References cosh(), and sinh().

                         {
  return sinh (x) / cosh (x);
}
ball<C,R,V> mmx::tanh ( const ball< C, R, V > &  z) [inline]

Definition at line 551 of file ball.hpp.

References Ball, C, Elementary_variant, and V.

Referenced by tanh().

                     {
  typedef Elementary_variant(C,V) EV;
  typedef implementation<ball_elementary,EV> Impl;
  Ball d; Impl::tanh (d, z); return d;
}
complex<C> mmx::tanh ( const complex< C > &  z) [inline]

Definition at line 563 of file complex.hpp.

References cosh(), and sinh().

                        {
  return sinh (z) / cosh (z);
}
tangent<C,D> mmx::tanh ( const tangent< C, D > &  z)

Definition at line 277 of file tangent.hpp.

References cosh(), and sinh().

                        {
  return sinh (z) / cosh (z);
}
floating<V> mmx::tanh ( const floating< V > &  x1) [inline]

Definition at line 433 of file floating.hpp.

References Floating, and Rnd.

                                               {
  Floating r (*x1); mpfr_tanh (*r, *x1, Rnd); return r; }
twin<C,D,V> mmx::tanh ( const twin< C, D, V > &  x)

Definition at line 251 of file twin.hpp.

References car(), cdr(), tanh(), and Twin.

                               {
  return Twin (tanh (car (x)), tanh (cdr (x))); }
complex<C> mmx::times_i ( const complex< C > &  z) [inline]

Definition at line 231 of file complex.hpp.

References Complex, Im(), and Re().

                           {
  return Complex (-Im (z), Re (z));
}
ball<C,R,V> mmx::times_i ( const ball< C, R, V > &  z) [inline]

Definition at line 59 of file ball_complex.hpp.

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

Referenced by asin(), implementation< ball_elementary, IV, ball_complex< BV > >::asin(), atan(), implementation< ball_elementary, IV, ball_complex< BV > >::atan(), GLUE_6(), and GLUE_7().

                                                         {
  return Complex_ball (times_i (center (z)), radius (z)); }
interval<C,V> mmx::times_infinity ( const interval< C, V > &  x) [inline]

Definition at line 328 of file interval.hpp.

                                                        {
  return x * infinity_cst<Interval > (); }
floating<V> mmx::times_infinity ( const floating< V > &  x) [inline]

Definition at line 291 of file floating.hpp.

                                                        {
  return x * infinity_cst<Floating > (); }
affine<C,VC> mmx::times_infinity ( const affine< C, VC > &  x) [inline]

Definition at line 211 of file affine.hpp.

Referenced by GLUE_25(), GLUE_38(), GLUE_45(), GLUE_46(), and GLUE_57().

                                                    {
  return x * infinity_cst<Affine > (); }
ball<C,R,V> mmx::times_infinity ( const ball< C, R, V > &  x) [inline]

Definition at line 348 of file ball.hpp.

                                                {
  return x * infinity_cst<Ball > (); }
tangent<C,D> mmx::times_infinity ( const tangent< C, D > &  x) [inline]

Definition at line 155 of file tangent.hpp.

                                                      {
  return x * infinity_cst<Tangent > (); }
twin<C,D,V> mmx::times_infinity ( const twin< C, D, V > &  x) [inline]

Definition at line 187 of file twin.hpp.

                                                {
  return x * infinity_cst<Twin > (); }
complex<C> mmx::times_infinity ( const complex< C > &  z) [inline]

Definition at line 264 of file complex.hpp.

                                                      {
  return z * infinity_cst<Complex > (); }
mmx::TRUE_IDENTITY_OP_SUGAR ( template< typename C, typename VC >  ,
affine< C, VC >   
)
mmx::TRUE_IDENTITY_OP_SUGAR ( template< typename C >  ,
complex< C >   
)
mmx::TRUE_IDENTITY_OP_SUGAR ( template< typename C, typename D >  ,
tangent< C, D >   
)
mmx::TRUE_TO_EXACT_IDENTITY_SUGAR ( template< typename V >  ,
floating< V >   
)
mmx::TRUE_TO_EXACT_IDENTITY_SUGAR ( rational  )
mmx::TRUE_TO_EXACT_IDENTITY_SUGAR ( integer  )
interval<C,V> mmx::trunc ( const interval< C, V > &  x)

Definition at line 286 of file interval.hpp.

References Interval, lower(), trunc(), and upper().

                          {
  return Interval (Down::trunc (lower (x)), Up::trunc (upper (x)));
}
ball<C,R,V> mmx::trunc ( const ball< C, R, V > &  z) [inline]

Definition at line 618 of file ball.hpp.

References Ball.

Referenced by GLUE_29(), GLUE_40(), GLUE_41(), trunc(), and implementation< ball_ordered, W, ball_rounded >::trunc().

                      {
  typedef implementation<ball_ordered,V> Impl;
  Ball d; Impl::trunc (d, z); return d;
}
floating<V> mmx::trunc ( const floating< V > &  x1) [inline]

Definition at line 384 of file floating.hpp.

References Floating.

                                                {
  Floating r (*x1); mpfr_trunc (*r, *x1); return r; }
string trunc_digits ( const string &  s,
xnat  dd 
)

Definition at line 176 of file string_scnot.cpp.

References decompose(), inc_mantissa(), min(), mmx_significant_digits, recompose(), and sign().

Referenced by as_string(), flatten_range(), mpfr_double_as_string(), and mpfr_to_string().

                                        {
  if (mmx_significant_digits != 0) {
    if (dd == 0) dd= mmx_significant_digits;
    else dd= min (dd, mmx_significant_digits);
  }
  if (locase (s) == "nan") return "NaN";
  if (locase (s) == "infty") return "Infty";
  if (locase (s) == "-infty") return "-Infty";
  if (locase (s) == "fuzz") return "Fuzz";
  int     sign;
  string  mant;
  integer expo;
  decompose (s, sign, mant, expo);
  if (dd == 0 || N(mant) <= dd) return recompose (sign, mant, expo);
  string mant2= mant (0, dd);
  if (mant[dd] >= '5') inc_mantissa (mant2, expo);
  return recompose (sign, mant2, expo);
}
C mmx::truncate ( const affine< C, VC > &  z) [inline]

Definition at line 114 of file affine.hpp.

References base(), limits(), and slope().

Referenced by operator*(), and square().

                                         {
  typedef affine_limits_helper<C,VC> Helper;
  return base (z) + Helper::truncate (slope (z), limits (z)); }
nat mmx::unary_hash ( const ball< C, R, V > &  x)

Definition at line 153 of file ball.hpp.

References center(), and radius().

                           {
  nat h= Op::op (center (x));
  return (h<<3) ^ (h<<11) ^ (h>>29) ^ Op::op (radius (x));
}
nat mmx::unary_hash ( const affine< C, VC > &  x)

Definition at line 137 of file affine.hpp.

References base(), limits(), and slope().

                             {
  nat h= Op::op (base (x));
  h += (h<<3) ^ (h<<11) ^ (h>>29) ^ Op::op (slope (x));
  return (h<<3) ^ (h<<11) ^ (h>>29) ^ Op::op (limits (x));
}
nat mmx::unary_hash ( const tangent< C, D > &  x)

Definition at line 82 of file tangent.hpp.

References base(), and slope().

                              {
  nat h= Op::op (base (x));
  return (h<<3) ^ (h<<11) ^ (h>>29) ^ Op::op (slope (x));
}
nat mmx::unary_hash ( const complex< C > &  z) [inline]

Definition at line 120 of file complex.hpp.

References Im(), and Re().

                              {
  nat h= Op::op (Re (z));
  return (h<<1) ^ (h<<5) ^ (h>>29) ^ Op::op (Im (z));
}
nat mmx::unary_hash ( const twin< C, D, V > &  x)

Definition at line 92 of file twin.hpp.

References car().

                           {
  return Op::op (car (x));
}
nat mmx::unary_hash ( const interval< C, V > &  x)

Definition at line 139 of file interval.hpp.

References lower(), and upper().

                               {
  nat h= Op::op (lower (x));
  return (h<<3) ^ (h<<15) ^ (h>>29) ^ Op::op (upper (x));
}
mmx::UNARY_RETURN_TYPE ( template< typename C, typename R, typename V >  ,
radius_op  ,
ball< C, R, V >  ,
R   
)
mmx::UNARY_RETURN_TYPE ( template< typename C >  ,
abs_op  ,
complex< C >  ,
C   
)
mmx::UNARY_RETURN_TYPE ( STMPL  ,
denominator_op  ,
rational  ,
integer   
)
mmx::UNARY_RETURN_TYPE ( template< typename C, typename VC >  ,
Re_op  ,
affine< C, VC >  ,
affine< Real_type(C), Real_type(VC) >   
)
mmx::UNARY_RETURN_TYPE ( template< typename C, typename R, typename V >  ,
center_op  ,
ball< C, R, V >  ,
C   
)
mmx::UNARY_RETURN_TYPE ( template< typename C, typename D >  ,
Re_op  ,
tangent< C, D >  ,
tangent< Real_type(C), Real_type(D) >   
)
mmx::UNARY_RETURN_TYPE ( template< typename C, typename V >  ,
radius_op  ,
interval< C, V >  ,
C   
)
mmx::UNARY_RETURN_TYPE ( template< typename C >  ,
Re_op  ,
complex< C >  ,
C   
)
mmx::UNARY_RETURN_TYPE ( template< typename C >  ,
radius_op  ,
complex< C >  ,
Radius_type(C)   
)
mmx::UNARY_RETURN_TYPE ( template< typename C, typename VC >  ,
abs_op  ,
affine< C, VC >  ,
affine< Abs_type(C), Abs_type(VC) >   
)
mmx::UNARY_RETURN_TYPE ( template< typename C, typename D >  ,
abs_op  ,
tangent< C, D >  ,
tangent< Abs_type(C), Abs_type(D) >   
)
mmx::UNARY_RETURN_TYPE ( template< typename C, typename R, typename V >  ,
Re_op  ,
ball< C, R, V >  ,
ball< Real_type(C), R, V >   
)
mmx::UNARY_RETURN_TYPE ( template< typename C, typename R, typename V >  ,
abs_op  ,
ball< C, R, V >  ,
ball< Abs_type(C), R, Abs_type(V) >   
)
mmx::UNARY_RETURN_TYPE ( template< typename C >  ,
center_op  ,
complex< C >  ,
complex< Center_type(C) >   
)
mmx::UNARY_RETURN_TYPE ( STMPL  ,
numerator_op  ,
rational  ,
integer   
)
floating<V> mmx::uniform_deviate ( const floating< V > &  lo,
const floating< V > &  hi 
) [inline]

Definition at line 514 of file floating.hpp.

References Floating, and gmp_randstate.

Referenced by GLUE_14().

                                                                              {
  Floating r (*lo, *hi); mpfr_urandomb (*r, gmp_randstate);
  return lo + r * (hi - lo); }
C mmx::upper ( const ball< C, R, V > &  z) [inline]

Definition at line 112 of file ball.hpp.

References Rnd.

Referenced by abs(), abs_up(), acos(), asin(), atan(), atan2(), binary_test(), bnd_up(), ceil(), implementation< ball_ordered, W, ball_rounded >::ceil(), center(), change_precision(), copy(), cos(), cosh(), binary_helper< interval< C, V > >::disassemble(), duplicate(), exp(), exponent(), flatten(), flatten_range(), floor(), implementation< ball_ordered, W, ball_rounded >::floor(), GLUE_5(), hypot(), intersect(), is_exact_zero(), is_finite(), is_fuzz(), is_infinite(), is_nan(), is_non_zero(), is_zero(), log(), magnitude(), map(), max(), min(), operator!=(), operator*(), operator+(), interval< C, V >::operator+=(), operator-(), interval< C, V >::operator-=(), operator/(), operator<(), operator<<(), operator<=(), operator==(), operator>(), operator>=(), operator>>(), precision(), radius(), round(), implementation< ball_ordered, W, ball_rounded >::round(), sin(), singleton(), sinh(), sqrt(), square(), trunc(), implementation< ball_ordered, W, ball_rounded >::trunc(), unary_hash(), and binary_helper< interval< C, V > >::write().

                                    {
  typedef implementation<ball_rounding,V> Rnd;
  return Rnd::upper (z); }
C upper ( const interval< C, V > &  z) [inline]

Definition at line 110 of file interval.hpp.

{ return x.r; }
floating<W> mmx::view ( const floating< V > &  x) [inline]

Definition at line 169 of file rounded.hpp.

                            {
  return *((floating<W>*) ((void*) &x));
}
mmx::WRAP_PRINT_IMPL ( template< typename M, typename V >  inline,
modular< M, V >   
)
mmx::WRAP_WRAPPED_IMPL ( template< typename M, typename V >  inline,
modular< M, V >   
)
mmx::WRAP_WRAPPED_IMPL ( template< typename C, typename V >  inline,
modulus< C, V >   
)
string zero_to_string ( const mpfr_t  err)

Definition at line 82 of file mmx_mpfr.cpp.

References as_string(), and exponent().

                                  {
  string r;
  mp_exp_t exponent;
  char* mantissa_s= mpfr_get_str (NULL, &exponent, 10, 2, err, GMP_RNDN);
  r << "0.0e" << as_string (exponent-1);
  mpfr_free_str (mantissa_s);
  return r;
}
floating<V> mmx::zeta ( const floating< V > &  x1) [inline]

Definition at line 509 of file floating.hpp.

References Floating, and Rnd.

                                               {
  Floating r (*x1); mpfr_zeta (*r, *x1, Rnd); return r; }

Variable Documentation

interval<C,V> ARG_HYPER_SUGAR(template< typename C, typename V >, interval< C, V >)template< typename C

Definition at line 569 of file complex.hpp.

                                              {
  return is_finite (Re (z)) && is_finite (Im (z)); }
string(* as_string_hook)(double)

Referenced by numerix_instance::numerix_instance().

C
Examples:
complex_ball_test.cpp, and modular_test.cpp.

Definition at line 66 of file complex.hpp.

Referenced by abs(), acos(), rounded_opposite< V >::add(), implementation< ball_additive, IV, ball_infinities< BV > >::add(), asin(), atan(), atan2(), binpow(), implementation< ball_ordered, W, ball_rounded >::ceil(), cos(), cosh(), rounded_opposite< V >::div(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::div(), modulus_div_naive< modulus_inv_integer_naive< modulus_mul_naive< modulus_add_integer_naive< modulus_reduction_naive< modulus_normalization_integer_naive > > > > >::div_mod(), modulus_div_int_naive< modulus_inv_int_naive< modulus_mul_int_naive< modulus_add_int_naive< modulus_reduction_int_naive< modulus_normalization_int_naive< modulus_maximum_size_int< size > > > > > > >::div_mod(), modulus_mul_int_preinverse< modulus_add_int_naive< modulus_reduction_int_naive< modulus_normalization_int_naive< modulus_maximum_size_int< m > > > > >::dyn_r(), modulus_mul_int_preinverse< modulus_add_int_naive< modulus_reduction_int_naive< modulus_normalization_int_naive< modulus_maximum_size_int< m > > > > >::dyn_s(), modulus_mul_int_preinverse< modulus_add_int_naive< modulus_reduction_int_naive< modulus_normalization_int_naive< modulus_maximum_size_int< m > > > > >::dyn_t(), modulus_mul_int_preinverse< V >::auxiliaries_helper< C, p >::_inverse_helper< void, Dummy >::dyn_value(), modulus_encoding_int_naive< modulus_div_int_naive< modulus_inv_int_naive< modulus_mul_int_naive< modulus_add_int_naive< modulus_reduction_int_naive< modulus_normalization_int_naive< modulus_maximum_size_int< size > > > > > > > >::encode_mod(), exp(), implementation< ball_ordered, W, ball_rounded >::floor(), binary_helper< twin< C, D, V > >::full_type_name(), binary_helper< tangent< C, D > >::full_type_name(), binary_helper< interval< C, V > >::full_type_name(), binary_helper< complex< C > >::full_type_name(), binary_helper< ball< C, R, V > >::full_type_name(), binary_helper< affine< C, VC > >::full_type_name(), modulus_mul_int_naive< V >::mul_mod_helper< C, void >::half_lshift_mod(), hypot(), modulus_inv_naive< modulus_mul_naive< modulus_add_naive< modulus_reduction_naive< modulus_normalization_naive > > > >::inv_mod(), modulus_inv_int_naive< modulus_mul_int_naive< modulus_add_int_naive< modulus_reduction_int_naive< modulus_normalization_int_naive< modulus_maximum_size_int< size > > > > > >::inv_mod(), modulus_inv_int_naive< modulus_mul_int_naive< modulus_add_int_naive< modulus_reduction_int_naive< modulus_normalization_int_naive< modulus_maximum_size_int< size > > > > > >::inv_mod_unsigned(), invert(), log(), implementation< ball_rounding, W, ball_rounded >::lower(), implementation< ball_rounding, W, ball_rounded >::make_interval(), modulus< C, modulus_int_preinverse< m > >::modulus(), rounded_opposite< V >::mul(), implementation< ball_multiplicative, IV, ball_infinities< BV > >::mul(), modulus_mul_int_preinverse< V >::mul_mod_helper< C, void, m >::op(), modulus_mul_int_preinverse< V >::mul_mod_helper< C, D, m >::op(), modulus_mul_int_naive< V >::mul_mod_helper< C, void >::op(), modulus_mul_int_naive< V >::mul_mod_helper< C, D >::op(), modulus_add_int_naive< V >::add_mod_helper< C, false >::op(), complex< C >::operator*=(), operator/(), complex< C >::operator/=(), pow(), binary_helper< twin< C, D, V > >::read(), binary_helper< tangent< C, D > >::read(), binary_helper< interval< C, V > >::read(), binary_helper< complex< C > >::read(), binary_helper< ball< C, R, V > >::read(), binary_helper< affine< C, VC > >::read(), modulus_reduction_int_naive< modulus_normalization_int_naive< modulus_maximum_size_int< size > > >::reduce_mod(), rough_next_above(), implementation< ball_ordered, W, ball_rounded >::round(), rounded_local< Mode >::rounded_as(), rounded_global< Mode >::rounded_as(), rounded_none_down::rounded_as(), rounded_none_up::rounded_as(), set_accuracy(), set_euler(), set_fuzz(), set_imaginary(), set_infinity(), set_largest(), set_log2(), set_maximal(), set_minimal(), set_nan(), set_pi(), set_smallest(), binary_helper< twin< C, D, V > >::short_type_name(), binary_helper< tangent< C, D > >::short_type_name(), binary_helper< interval< C, V > >::short_type_name(), binary_helper< complex< C > >::short_type_name(), binary_helper< ball< C, R, V > >::short_type_name(), binary_helper< affine< C, VC > >::short_type_name(), sin(), sinh(), sqrt(), rounded_opposite< V >::square(), square(), rounded_opposite< V >::sub(), implementation< ball_additive, IV, ball_infinities< BV > >::sub(), modulus_add_integer_naive< modulus_reduction_naive< modulus_normalization_integer_naive > >::sub_mod_core(), modulus_add_int_naive< modulus_reduction_int_naive< modulus_normalization_int_naive< modulus_maximum_size_int< size > > > >::sub_mod_core(), tan(), tanh(), implementation< ball_ordered, W, ball_rounded >::trunc(), and implementation< ball_rounding, W, ball_rounded >::upper().

C2

Definition at line 58 of file twin.hpp.

Referenced by make_ball_helper< interval< C, V >, C2, R2 >::val(), and make_interval_helper< ball< C, R, V >, C2 >::val().

center_op

Definition at line 85 of file interval.hpp.

complex< C > complex< C >

Definition at line 66 of file complex.hpp.

tangent< C, D > D

Definition at line 103 of file tangent.hpp.

Referenced by fixed_floating< V, P, D >::disc(), modulus_mul_int_preinverse< modulus_add_int_naive< modulus_reduction_int_naive< modulus_normalization_int_naive< modulus_maximum_size_int< m > > > > >::dyn_q(), binary_helper< twin< C, D, V > >::full_type_name(), modulus_mul_int_naive< modulus_add_int_naive< modulus_reduction_int_naive< modulus_normalization_int_naive< modulus_maximum_size_int< size > > > > >::mul_mod(), modulus_mul_int_preinverse< V >::mul_mod_helper< C, D, m >::op(), modulus_mul_int_naive< V >::mul_mod_helper< C, D >::op(), binary_helper< twin< C, D, V > >::read(), binary_helper< tangent< C, D > >::read(), binary_helper< twin< C, D, V > >::short_type_name(), and binary_helper< tangent< C, D > >::short_type_name().

D1

Definition at line 58 of file twin.hpp.

D2

Definition at line 58 of file twin.hpp.

F

Definition at line 67 of file modulus.hpp.

Referenced by as_helper< T, F >::cv().

floating< V >

Definition at line 392 of file floating.hpp.

gmp_randstate_t gmp_randstate

Definition at line 17 of file numerix.cpp.

Referenced by numerix_instance::numerix_instance(), and uniform_deviate().

tangent<C,D> HARD_IDENTITY_OP_SUGAR(template< typename C, typename D >, tangent< C, D >) template< typename C
interval< C, V >

Definition at line 85 of file interval.hpp.

tangent<C,D> INV_HYPER_SUGAR(template< typename C, typename D >, tangent< C, D >) ARG_HYPER_SUGAR(template< typename C

Definition at line 450 of file floating.hpp.

                                               {
  return mpfr_number_p (*x) != 0; }
xnat mmx_bit_precision = 64
Examples:
ball_test.cpp, complex_ball_test.cpp, floating_test.cpp, and interval_test.cpp.

Definition at line 21 of file mmx_mpfr.cpp.

Referenced by binary_helper< floating< V > >::assemble(), glue_floating(), mmx_local_bit_precision::mmx_local_bit_precision(), std_floating::prec(), and mmx_local_bit_precision::~mmx_local_bit_precision().

xnat mmx_discrepancy = (BITS_PER_LIMB >> 1)

Definition at line 23 of file mmx_mpfr.cpp.

Referenced by std_floating::disc(), and glue_floating().

bool mmx_pretty_exponents = false

Definition at line 24 of file mmx_mpfr.cpp.

Referenced by flatten_number(), and glue_floating().

mpfr_rnd_t mmx_rounding_mode = GMP_RNDN

Definition at line 22 of file mmx_mpfr.cpp.

Referenced by rounding_helper< floating< V > >::get_rounding(), std_floating::rnd(), and rounding_helper< floating< V > >::set_rounding().

xnat mmx_significant_digits = 0

Definition at line 20 of file mmx_mpfr.cpp.

Referenced by flatten_range(), glue_floating(), mmx_local_significant_digits::mmx_local_significant_digits(), trunc_digits(), and mmx_local_significant_digits::~mmx_local_significant_digits().

numerix_instance numerix_inst

Definition at line 63 of file numerix.cpp.

modular<M,V> POOR_MAN_SQRT_SUGAR(template< typename M, typename V >, modular< M, V >) POOR_MAN_ELEMENTARY_SUGAR(template< typename M
ball< C, R, V > R
Examples:
ball_test.cpp.

Definition at line 165 of file ball.hpp.

Referenced by implementation< ball_rounding, W, ball_rounded >::abs_down(), implementation< ball_rounding, W, ball_rounded >::abs_up(), implementation< ball_elementary, W, ball_rounded >::acos(), implementation< ball_additive, W, ball_rounded >::add(), implementation< ball_rounding, W, ball_rounded >::add_additive_error(), implementation< ball_rounding, W, ball_rounded >::add_elementary_error(), implementation< ball_rounding, W, ball_rounded >::add_multiplicative_error(), add_rough_additive_error(), add_rough_multiplicative_error(), implementation< ball_rounding, W, ball_rounded >::add_rounding_error(), implementation< ball_elementary, W, ball_rounded >::asin(), implementation< ball_elementary, W, ball_rounded >::atan(), implementation< ball_elementary, W, ball_rounded >::atan2(), blur(), implementation< ball_rounding, W, ball_rounded >::bnd_down(), implementation< ball_rounding, W, ball_rounded >::bnd_up(), complex_gaussian(), implementation< ball_elementary, W, ball_rounded >::cos(), implementation< ball_elementary, IV, ball_complex< BV > >::cos(), implementation< ball_elementary, W, ball_rounded >::cosh(), implementation< ball_elementary, IV, ball_complex< BV > >::cosh(), implementation< ball_elementary, W, ball_rounded >::exp(), implementation< ball_elementary, IV, ball_complex< BV > >::exp(), binary_helper< ball< C, R, V > >::full_type_name(), implementation< ball_complex_construct, IV, ball_complex< BV > >::gauss(), implementation< ball_root, W, ball_rounded >::hypot(), implementation< ball_multiplicative, W, ball_rounded >::invert(), implementation< ball_multiplicative, W, ball_rough >::invert(), implementation< ball_elementary, W, ball_rounded >::log(), implementation< ball_elementary, IV, ball_complex< BV > >::log(), implementation< ball_multiplicative, W, ball_rounded >::mul(), implementation< ball_multiplicative, W, ball_rough >::mul(), binary_helper< ball< C, R, V > >::read(), rnd_floating< V, R >::rnd(), set_fuzz(), implementation< ball_shift, W, ball_rough >::shiftl(), implementation< ball_shift, W, ball_rough >::shiftr(), binary_helper< ball< C, R, V > >::short_type_name(), implementation< ball_elementary, W, ball_rounded >::sin(), implementation< ball_elementary, IV, ball_complex< BV > >::sin(), implementation< ball_elementary, W, ball_rounded >::sinh(), implementation< ball_elementary, IV, ball_complex< BV > >::sinh(), implementation< ball_root, W, ball_rounded >::sqrt(), implementation< ball_root, W, ball_rough >::sqrt(), implementation< ball_root, IV, ball_complex< BV > >::sqrt(), implementation< ball_multiplicative, W, ball_rounded >::square(), implementation< ball_multiplicative, W, ball_rough >::square(), implementation< ball_additive, W, ball_rounded >::sub(), and make_interval_helper< ball< C, R, V >, C2 >::val().

scalar_type

Definition at line 66 of file complex.hpp.

TV

Definition at line 67 of file modulus.hpp.

modular< M, V > V
Examples:
modular_test.cpp.

Definition at line 165 of file ball.hpp.

Referenced by acos(), asin(), atan(), atan2(), complex_gaussian(), cos(), cosh(), exp(), hypot(), log(), pow(), sin(), sinh(), sqrt(), tan(), and tanh().

V1

Definition at line 58 of file twin.hpp.

VC

Definition at line 160 of file affine.hpp.

Referenced by affine_limits_helper< C, VC >::get_domain(), binary_helper< affine< C, VC > >::read(), and binary_helper< affine< C, VC > >::short_type_name().

 All Classes Namespaces Files Functions Variables Typedefs Friends Defines