source/libs/gmp/gmp-src/gmpxx.h

   1 /* gmpxx.h -- C++ class wrapper for GMP types.  -*- C++ -*-
   2
   3 Copyright 2001-2003, 2006, 2008, 2011, 2012 Free Software Foundation, Inc.
   4
   5 This file is part of the GNU MP Library.
   6
   7 The GNU MP Library is free software; you can redistribute it and/or modify
   8 it under the terms of either:
   9
  10   * the GNU Lesser General Public License as published by the Free
  11     Software Foundation; either version 3 of the License, or (at your
  12     option) any later version.
  13
  14 or
  15
  16   * the GNU General Public License as published by the Free Software
  17     Foundation; either version 2 of the License, or (at your option) any
  18     later version.
  19
  20 or both in parallel, as here.
  21
  22 The GNU MP Library is distributed in the hope that it will be useful, but
  23 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  24 or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  25 for more details.
  26
  27 You should have received copies of the GNU General Public License and the
  28 GNU Lesser General Public License along with the GNU MP Library.  If not,
  29 see https://www.gnu.org/licenses/.  */
  30
  31 #ifndef __GMP_PLUSPLUS__
  32 #define __GMP_PLUSPLUS__
  33
  34 #include <iosfwd>
  35
  36 #include <cstring>  /* for strlen */
  37 #include <limits>  /* numeric_limits */
  38 #include <utility>
  39 #include <algorithm>  /* swap */
  40 #include <string>
  41 #include <stdexcept>
  42 #include <cfloat>
  43 #include <gmp.h>
  44
  45 // wrapper for gcc's __builtin_constant_p
  46 // __builtin_constant_p has been in gcc since forever,
  47 // but g++-3.4 miscompiles it.
  48 #if __GMP_GNUC_PREREQ(4, 2)
  49 #define __GMPXX_CONSTANT(X) __builtin_constant_p(X)
  50 #else
  51 #define __GMPXX_CONSTANT(X) false
  52 #endif
  53 #define __GMPXX_CONSTANT_TRUE(X) (__GMPXX_CONSTANT(X) && (X))
  54
  55 // Use C++11 features
  56 #ifndef __GMPXX_USE_CXX11
  57 #if __cplusplus >= 201103L
  58 #define __GMPXX_USE_CXX11 1
  59 #else
  60 #define __GMPXX_USE_CXX11 0
  61 #endif
  62 #endif
  63
  64 #if __GMPXX_USE_CXX11
  65 #define __GMPXX_NOEXCEPT noexcept
  66 #include <type_traits> // for common_type
  67 #else
  68 #define __GMPXX_NOEXCEPT
  69 #endif
  70
  71 // Max allocations for plain types when converted to GMP types
  72 #if GMP_NAIL_BITS != 0 && ! defined _LONG_LONG_LIMB
  73 #define __GMPZ_ULI_LIMBS 2
  74 #else
  75 #define __GMPZ_ULI_LIMBS 1
  76 #endif
  77
  78 #define __GMPXX_BITS_TO_LIMBS(n)  (((n) + (GMP_NUMB_BITS - 1)) / GMP_NUMB_BITS)
  79 #define __GMPZ_DBL_LIMBS __GMPXX_BITS_TO_LIMBS(DBL_MAX_EXP)+1
  80 #define __GMPQ_NUM_DBL_LIMBS __GMPZ_DBL_LIMBS
  81 #define __GMPQ_DEN_DBL_LIMBS __GMPXX_BITS_TO_LIMBS(DBL_MANT_DIG+1-DBL_MIN_EXP)+1
  82 // The final +1s are a security margin. The current implementation of
  83 // mpq_set_d seems to need it for the denominator.
  84
  85 inline void __mpz_set_ui_safe(mpz_ptr p, unsigned long l)
  86 {
  87   p->_mp_size = (l != 0);
  88   p->_mp_d[0] = l & GMP_NUMB_MASK;
  89 #if __GMPZ_ULI_LIMBS > 1
  90   l >>= GMP_NUMB_BITS;
  91   p->_mp_d[1] = l;
  92   p->_mp_size += (l != 0);
  93 #endif
  94 }
  95
  96 inline void __mpz_set_si_safe(mpz_ptr p, long l)
  97 {
  98   if(l < 0)
  99   {
 100     __mpz_set_ui_safe(p, -static_cast<unsigned long>(l));
 101     mpz_neg(p, p);
 102   }
 103   else
 104     __mpz_set_ui_safe(p, l);
 105     // Note: we know the high bit of l is 0 so we could do slightly better
 106 }
 107
 108 // Fake temporary variables
 109 #define __GMPXX_TMPZ_UI                                                 \
 110   mpz_t temp;                                                           \
 111   mp_limb_t limbs[__GMPZ_ULI_LIMBS];                                    \
 112   temp->_mp_d = limbs;                                                  \
 113   __mpz_set_ui_safe (temp, l)
 114 #define __GMPXX_TMPZ_SI                                                 \
 115   mpz_t temp;                                                           \
 116   mp_limb_t limbs[__GMPZ_ULI_LIMBS];                                    \
 117   temp->_mp_d = limbs;                                                  \
 118   __mpz_set_si_safe (temp, l)
 119 #define __GMPXX_TMPZ_D                                                  \
 120   mpz_t temp;                                                           \
 121   mp_limb_t limbs[__GMPZ_DBL_LIMBS];                                    \
 122   temp->_mp_d = limbs;                                                  \
 123   temp->_mp_alloc = __GMPZ_DBL_LIMBS;                                   \
 124   mpz_set_d (temp, d)
 125
 126 #define __GMPXX_TMPQ_UI                                                 \
 127   mpq_t temp;                                                           \
 128   mp_limb_t limbs[__GMPZ_ULI_LIMBS+1];                                  \
 129   mpq_numref(temp)->_mp_d = limbs;                                      \
 130   __mpz_set_ui_safe (mpq_numref(temp), l);                              \
 131   mpq_denref(temp)->_mp_d = limbs + __GMPZ_ULI_LIMBS;                   \
 132   mpq_denref(temp)->_mp_size = 1;                                       \
 133   mpq_denref(temp)->_mp_d[0] = 1
 134 #define __GMPXX_TMPQ_SI                                                 \
 135   mpq_t temp;                                                           \
 136   mp_limb_t limbs[__GMPZ_ULI_LIMBS+1];                                  \
 137   mpq_numref(temp)->_mp_d = limbs;                                      \
 138   __mpz_set_si_safe (mpq_numref(temp), l);                              \
 139   mpq_denref(temp)->_mp_d = limbs + __GMPZ_ULI_LIMBS;                   \
 140   mpq_denref(temp)->_mp_size = 1;                                       \
 141   mpq_denref(temp)->_mp_d[0] = 1
 142 #define __GMPXX_TMPQ_D                                                  \
 143   mpq_t temp;                                                           \
 144   mp_limb_t limbs[__GMPQ_NUM_DBL_LIMBS + __GMPQ_DEN_DBL_LIMBS];         \
 145   mpq_numref(temp)->_mp_d = limbs;                                      \
 146   mpq_numref(temp)->_mp_alloc = __GMPQ_NUM_DBL_LIMBS;                   \
 147   mpq_denref(temp)->_mp_d = limbs + __GMPQ_NUM_DBL_LIMBS;               \
 148   mpq_denref(temp)->_mp_alloc = __GMPQ_DEN_DBL_LIMBS;                   \
 149   mpq_set_d (temp, d)
 150
 151 inline unsigned long __gmpxx_abs_ui (signed long l)
 152 {
 153   return l >= 0 ? static_cast<unsigned long>(l)
 154           : -static_cast<unsigned long>(l);
 155 }
 156
 157 /**************** Function objects ****************/
 158 /* Any evaluation of a __gmp_expr ends up calling one of these functions
 159    all intermediate functions being inline, the evaluation should optimize
 160    to a direct call to the relevant function, thus yielding no overhead
 161    over the C interface. */
 162
 163 struct __gmp_unary_plus
 164 {
 165   static void eval(mpz_ptr z, mpz_srcptr w) { mpz_set(z, w); }
 166   static void eval(mpq_ptr q, mpq_srcptr r) { mpq_set(q, r); }
 167   static void eval(mpf_ptr f, mpf_srcptr g) { mpf_set(f, g); }
 168 };
 169
 170 struct __gmp_unary_minus
 171 {
 172   static void eval(mpz_ptr z, mpz_srcptr w) { mpz_neg(z, w); }
 173   static void eval(mpq_ptr q, mpq_srcptr r) { mpq_neg(q, r); }
 174   static void eval(mpf_ptr f, mpf_srcptr g) { mpf_neg(f, g); }
 175 };
 176
 177 struct __gmp_unary_com
 178 {
 179   static void eval(mpz_ptr z, mpz_srcptr w) { mpz_com(z, w); }
 180 };
 181
 182 struct __gmp_binary_plus
 183 {
 184   static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
 185   { mpz_add(z, w, v); }
 186
 187   static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
 188   {
 189     // Ideally, those checks should happen earlier so that the tree
 190     // generated for a+0+b would just be sum(a,b).
 191     if (__GMPXX_CONSTANT(l) && l == 0)
 192     {
 193       if (z != w) mpz_set(z, w);
 194     }
 195     else
 196       mpz_add_ui(z, w, l);
 197   }
 198   static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
 199   { eval(z, w, l); }
 200   static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
 201   {
 202     if (l >= 0)
 203       eval(z, w, static_cast<unsigned long>(l));
 204     else
 205       mpz_sub_ui(z, w, -static_cast<unsigned long>(l));
 206   }
 207   static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
 208   { eval(z, w, l); }
 209   static void eval(mpz_ptr z, mpz_srcptr w, double d)
 210   {  __GMPXX_TMPZ_D;    mpz_add (z, w, temp); }
 211   static void eval(mpz_ptr z, double d, mpz_srcptr w)
 212   { eval(z, w, d); }
 213
 214   static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
 215   { mpq_add(q, r, s); }
 216
 217   static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
 218   {
 219     if (__GMPXX_CONSTANT(l) && l == 0)
 220     {
 221       if (q != r) mpq_set(q, r);
 222     }
 223     else
 224     {
 225       if (q == r)
 226         mpz_addmul_ui(mpq_numref(q), mpq_denref(q), l);
 227       else
 228       {
 229         mpz_mul_ui(mpq_numref(q), mpq_denref(r), l);
 230         mpz_add(mpq_numref(q), mpq_numref(q), mpq_numref(r));
 231         mpz_set(mpq_denref(q), mpq_denref(r));
 232       }
 233     }
 234   }
 235   static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
 236   { eval(q, r, l); }
 237   static inline void eval(mpq_ptr q, mpq_srcptr r, signed long int l);
 238   // defined after __gmp_binary_minus
 239   static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
 240   { eval(q, r, l); }
 241   static void eval(mpq_ptr q, mpq_srcptr r, double d)
 242   {  __GMPXX_TMPQ_D;    mpq_add (q, r, temp); }
 243   static void eval(mpq_ptr q, double d, mpq_srcptr r)
 244   { eval(q, r, d); }
 245
 246   static void eval(mpq_ptr q, mpq_srcptr r, mpz_srcptr z)
 247   {
 248     if (q == r)
 249       mpz_addmul(mpq_numref(q), mpq_denref(q), z);
 250     else
 251     {
 252       mpz_mul(mpq_numref(q), mpq_denref(r), z);
 253       mpz_add(mpq_numref(q), mpq_numref(q), mpq_numref(r));
 254       mpz_set(mpq_denref(q), mpq_denref(r));
 255     }
 256   }
 257   static void eval(mpq_ptr q, mpz_srcptr z, mpq_srcptr r)
 258   { eval(q, r, z); }
 259
 260   static void eval(mpf_ptr f, mpf_srcptr g, mpf_srcptr h)
 261   { mpf_add(f, g, h); }
 262
 263   static void eval(mpf_ptr f, mpf_srcptr g, unsigned long int l)
 264   { mpf_add_ui(f, g, l); }
 265   static void eval(mpf_ptr f, unsigned long int l, mpf_srcptr g)
 266   { mpf_add_ui(f, g, l); }
 267   static void eval(mpf_ptr f, mpf_srcptr g, signed long int l)
 268   {
 269     if (l >= 0)
 270       mpf_add_ui(f, g, l);
 271     else
 272       mpf_sub_ui(f, g, -static_cast<unsigned long>(l));
 273   }
 274   static void eval(mpf_ptr f, signed long int l, mpf_srcptr g)
 275   { eval(f, g, l); }
 276   static void eval(mpf_ptr f, mpf_srcptr g, double d)
 277   {
 278     mpf_t temp;
 279     mpf_init2(temp, 8*sizeof(double));
 280     mpf_set_d(temp, d);
 281     mpf_add(f, g, temp);
 282     mpf_clear(temp);
 283   }
 284   static void eval(mpf_ptr f, double d, mpf_srcptr g)
 285   { eval(f, g, d); }
 286 };
 287
 288 struct __gmp_binary_minus
 289 {
 290   static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
 291   { mpz_sub(z, w, v); }
 292
 293   static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
 294   {
 295     if (__GMPXX_CONSTANT(l) && l == 0)
 296     {
 297       if (z != w) mpz_set(z, w);
 298     }
 299     else
 300       mpz_sub_ui(z, w, l);
 301   }
 302   static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
 303   {
 304     if (__GMPXX_CONSTANT(l) && l == 0)
 305     {
 306       mpz_neg(z, w);
 307     }
 308     else
 309       mpz_ui_sub(z, l, w);
 310   }
 311   static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
 312   {
 313     if (l >= 0)
 314       eval(z, w, static_cast<unsigned long>(l));
 315     else
 316       mpz_add_ui(z, w, -static_cast<unsigned long>(l));
 317   }
 318   static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
 319   {
 320     if (l >= 0)
 321       eval(z, static_cast<unsigned long>(l), w);
 322     else
 323       {
 324         mpz_add_ui(z, w, -static_cast<unsigned long>(l));
 325         mpz_neg(z, z);
 326       }
 327   }
 328   static void eval(mpz_ptr z, mpz_srcptr w, double d)
 329   {  __GMPXX_TMPZ_D;    mpz_sub (z, w, temp); }
 330   static void eval(mpz_ptr z, double d, mpz_srcptr w)
 331   {  __GMPXX_TMPZ_D;    mpz_sub (z, temp, w); }
 332
 333   static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
 334   { mpq_sub(q, r, s); }
 335
 336   static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
 337   {
 338     if (__GMPXX_CONSTANT(l) && l == 0)
 339     {
 340       if (q != r) mpq_set(q, r);
 341     }
 342     else
 343     {
 344       if (q == r)
 345         mpz_submul_ui(mpq_numref(q), mpq_denref(q), l);
 346       else
 347       {
 348         mpz_mul_ui(mpq_numref(q), mpq_denref(r), l);
 349         mpz_sub(mpq_numref(q), mpq_numref(r), mpq_numref(q));
 350         mpz_set(mpq_denref(q), mpq_denref(r));
 351       }
 352     }
 353   }
 354   static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
 355   { eval(q, r, l); mpq_neg(q, q); }
 356   static void eval(mpq_ptr q, mpq_srcptr r, signed long int l)
 357   {
 358     if (l >= 0)
 359       eval(q, r, static_cast<unsigned long>(l));
 360     else
 361       __gmp_binary_plus::eval(q, r, -static_cast<unsigned long>(l));
 362   }
 363   static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
 364   { eval(q, r, l); mpq_neg(q, q); }
 365   static void eval(mpq_ptr q, mpq_srcptr r, double d)
 366   {  __GMPXX_TMPQ_D;    mpq_sub (q, r, temp); }
 367   static void eval(mpq_ptr q, double d, mpq_srcptr r)
 368   {  __GMPXX_TMPQ_D;    mpq_sub (q, temp, r); }
 369
 370   static void eval(mpq_ptr q, mpq_srcptr r, mpz_srcptr z)
 371   {
 372     if (q == r)
 373       mpz_submul(mpq_numref(q), mpq_denref(q), z);
 374     else
 375     {
 376       mpz_mul(mpq_numref(q), mpq_denref(r), z);
 377       mpz_sub(mpq_numref(q), mpq_numref(r), mpq_numref(q));
 378       mpz_set(mpq_denref(q), mpq_denref(r));
 379     }
 380   }
 381   static void eval(mpq_ptr q, mpz_srcptr z, mpq_srcptr r)
 382   { eval(q, r, z); mpq_neg(q, q); }
 383
 384   static void eval(mpf_ptr f, mpf_srcptr g, mpf_srcptr h)
 385   { mpf_sub(f, g, h); }
 386
 387   static void eval(mpf_ptr f, mpf_srcptr g, unsigned long int l)
 388   { mpf_sub_ui(f, g, l); }
 389   static void eval(mpf_ptr f, unsigned long int l, mpf_srcptr g)
 390   { mpf_ui_sub(f, l, g); }
 391   static void eval(mpf_ptr f, mpf_srcptr g, signed long int l)
 392   {
 393     if (l >= 0)
 394       mpf_sub_ui(f, g, l);
 395     else
 396       mpf_add_ui(f, g, -static_cast<unsigned long>(l));
 397   }
 398   static void eval(mpf_ptr f, signed long int l, mpf_srcptr g)
 399   {
 400     if (l >= 0)
 401       mpf_sub_ui(f, g, l);
 402     else
 403       mpf_add_ui(f, g, -static_cast<unsigned long>(l));
 404     mpf_neg(f, f);
 405   }
 406   static void eval(mpf_ptr f, mpf_srcptr g, double d)
 407   {
 408     mpf_t temp;
 409     mpf_init2(temp, 8*sizeof(double));
 410     mpf_set_d(temp, d);
 411     mpf_sub(f, g, temp);
 412     mpf_clear(temp);
 413   }
 414   static void eval(mpf_ptr f, double d, mpf_srcptr g)
 415   {
 416     mpf_t temp;
 417     mpf_init2(temp, 8*sizeof(double));
 418     mpf_set_d(temp, d);
 419     mpf_sub(f, temp, g);
 420     mpf_clear(temp);
 421   }
 422 };
 423
 424 // defined here so it can reference __gmp_binary_minus
 425 inline void
 426 __gmp_binary_plus::eval(mpq_ptr q, mpq_srcptr r, signed long int l)
 427 {
 428   if (l >= 0)
 429     eval(q, r, static_cast<unsigned long>(l));
 430   else
 431     __gmp_binary_minus::eval(q, r, -static_cast<unsigned long>(l));
 432 }
 433
 434 struct __gmp_binary_lshift
 435 {
 436   static void eval(mpz_ptr z, mpz_srcptr w, mp_bitcnt_t l)
 437   {
 438     if (__GMPXX_CONSTANT(l) && (l == 0))
 439     {
 440       if (z != w) mpz_set(z, w);
 441     }
 442     else
 443       mpz_mul_2exp(z, w, l);
 444   }
 445   static void eval(mpq_ptr q, mpq_srcptr r, mp_bitcnt_t l)
 446   {
 447     if (__GMPXX_CONSTANT(l) && (l == 0))
 448     {
 449       if (q != r) mpq_set(q, r);
 450     }
 451     else
 452       mpq_mul_2exp(q, r, l);
 453   }
 454   static void eval(mpf_ptr f, mpf_srcptr g, mp_bitcnt_t l)
 455   { mpf_mul_2exp(f, g, l); }
 456 };
 457
 458 struct __gmp_binary_rshift
 459 {
 460   static void eval(mpz_ptr z, mpz_srcptr w, mp_bitcnt_t l)
 461   {
 462     if (__GMPXX_CONSTANT(l) && (l == 0))
 463     {
 464       if (z != w) mpz_set(z, w);
 465     }
 466     else
 467       mpz_fdiv_q_2exp(z, w, l);
 468   }
 469   static void eval(mpq_ptr q, mpq_srcptr r, mp_bitcnt_t l)
 470   {
 471     if (__GMPXX_CONSTANT(l) && (l == 0))
 472     {
 473       if (q != r) mpq_set(q, r);
 474     }
 475     else
 476       mpq_div_2exp(q, r, l);
 477   }
 478   static void eval(mpf_ptr f, mpf_srcptr g, mp_bitcnt_t l)
 479   { mpf_div_2exp(f, g, l); }
 480 };
 481
 482 struct __gmp_binary_multiplies
 483 {
 484   static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
 485   { mpz_mul(z, w, v); }
 486
 487   static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
 488   {
 489 // gcc-3.3 doesn't have __builtin_ctzl. Don't bother optimizing for old gcc.
 490 #if __GMP_GNUC_PREREQ(3, 4)
 491     if (__GMPXX_CONSTANT(l) && (l & (l-1)) == 0)
 492     {
 493       if (l == 0)
 494       {
 495         z->_mp_size = 0;
 496       }
 497       else
 498       {
 499         __gmp_binary_lshift::eval(z, w, __builtin_ctzl(l));
 500       }
 501     }
 502     else
 503 #endif
 504       mpz_mul_ui(z, w, l);
 505   }
 506   static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
 507   { eval(z, w, l); }
 508   static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
 509   {
 510     if (__GMPXX_CONSTANT_TRUE(l >= 0))
 511       eval(z, w, static_cast<unsigned long>(l));
 512     else if (__GMPXX_CONSTANT_TRUE(l <= 0))
 513       {
 514         eval(z, w, -static_cast<unsigned long>(l));
 515         mpz_neg(z, z);
 516       }
 517     else
 518       mpz_mul_si (z, w, l);
 519   }
 520   static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
 521   { eval(z, w, l); }
 522   static void eval(mpz_ptr z, mpz_srcptr w, double d)
 523   {  __GMPXX_TMPZ_D;    mpz_mul (z, w, temp); }
 524   static void eval(mpz_ptr z, double d, mpz_srcptr w)
 525   { eval(z, w, d); }
 526
 527   static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
 528   { mpq_mul(q, r, s); }
 529
 530   static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
 531   {
 532 #if __GMP_GNUC_PREREQ(3, 4)
 533     if (__GMPXX_CONSTANT(l) && (l & (l-1)) == 0)
 534     {
 535       if (l == 0)
 536       {
 537         mpq_set_ui(q, 0, 1);
 538       }
 539       else
 540       {
 541         __gmp_binary_lshift::eval(q, r, __builtin_ctzl(l));
 542       }
 543     }
 544     else
 545 #endif
 546     {
 547       __GMPXX_TMPQ_UI;
 548       mpq_mul (q, r, temp);
 549     }
 550   }
 551   static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
 552   { eval(q, r, l); }
 553   static void eval(mpq_ptr q, mpq_srcptr r, signed long int l)
 554   {
 555     if (__GMPXX_CONSTANT_TRUE(l >= 0))
 556       eval(q, r, static_cast<unsigned long>(l));
 557     else if (__GMPXX_CONSTANT_TRUE(l <= 0))
 558       {
 559         eval(q, r, -static_cast<unsigned long>(l));
 560         mpq_neg(q, q);
 561       }
 562     else
 563       {
 564         __GMPXX_TMPQ_SI;
 565         mpq_mul (q, r, temp);
 566       }
 567   }
 568   static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
 569   { eval(q, r, l); }
 570   static void eval(mpq_ptr q, mpq_srcptr r, double d)
 571   {  __GMPXX_TMPQ_D;    mpq_mul (q, r, temp); }
 572   static void eval(mpq_ptr q, double d, mpq_srcptr r)
 573   { eval(q, r, d); }
 574
 575   static void eval(mpf_ptr f, mpf_srcptr g, mpf_srcptr h)
 576   { mpf_mul(f, g, h); }
 577
 578   static void eval(mpf_ptr f, mpf_srcptr g, unsigned long int l)
 579   { mpf_mul_ui(f, g, l); }
 580   static void eval(mpf_ptr f, unsigned long int l, mpf_srcptr g)
 581   { mpf_mul_ui(f, g, l); }
 582   static void eval(mpf_ptr f, mpf_srcptr g, signed long int l)
 583   {
 584     if (l >= 0)
 585       mpf_mul_ui(f, g, l);
 586     else
 587       {
 588         mpf_mul_ui(f, g, -static_cast<unsigned long>(l));
 589         mpf_neg(f, f);
 590       }
 591   }
 592   static void eval(mpf_ptr f, signed long int l, mpf_srcptr g)
 593   { eval(f, g, l); }
 594   static void eval(mpf_ptr f, mpf_srcptr g, double d)
 595   {
 596     mpf_t temp;
 597     mpf_init2(temp, 8*sizeof(double));
 598     mpf_set_d(temp, d);
 599     mpf_mul(f, g, temp);
 600     mpf_clear(temp);
 601   }
 602   static void eval(mpf_ptr f, double d, mpf_srcptr g)
 603   { eval(f, g, d); }
 604 };
 605
 606 struct __gmp_binary_divides
 607 {
 608   static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
 609   { mpz_tdiv_q(z, w, v); }
 610
 611   static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
 612   {
 613 #if __GMP_GNUC_PREREQ(3, 4)
 614     // Don't optimize division by 0...
 615     if (__GMPXX_CONSTANT(l) && (l & (l-1)) == 0 && l != 0)
 616     {
 617       if (l == 1)
 618       {
 619         if (z != w) mpz_set(z, w);
 620       }
 621       else
 622         mpz_tdiv_q_2exp(z, w, __builtin_ctzl(l));
 623         // warning: do not use rshift (fdiv)
 624     }
 625     else
 626 #endif
 627       mpz_tdiv_q_ui(z, w, l);
 628   }
 629   static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
 630   {
 631     if (mpz_sgn(w) >= 0)
 632       {
 633         if (mpz_fits_ulong_p(w))
 634           mpz_set_ui(z, l / mpz_get_ui(w));
 635         else
 636           mpz_set_ui(z, 0);
 637       }
 638     else
 639       {
 640         mpz_neg(z, w);
 641         if (mpz_fits_ulong_p(z))
 642           {
 643             mpz_set_ui(z, l / mpz_get_ui(z));
 644             mpz_neg(z, z);
 645           }
 646         else
 647           mpz_set_ui(z, 0);
 648       }
 649   }
 650   static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
 651   {
 652     if (l >= 0)
 653       eval(z, w, static_cast<unsigned long>(l));
 654     else
 655       {
 656         eval(z, w, -static_cast<unsigned long>(l));
 657         mpz_neg(z, z);
 658       }
 659   }
 660   static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
 661   {
 662     if (mpz_fits_slong_p(w))
 663       mpz_set_si(z, l / mpz_get_si(w));
 664     else
 665       {
 666         /* if w is bigger than a long then the quotient must be zero, unless
 667            l==LONG_MIN and w==-LONG_MIN in which case the quotient is -1 */
 668         mpz_set_si (z, (mpz_cmpabs_ui (w, __gmpxx_abs_ui(l)) == 0 ? -1 : 0));
 669       }
 670   }
 671   static void eval(mpz_ptr z, mpz_srcptr w, double d)
 672   {  __GMPXX_TMPZ_D;    mpz_tdiv_q (z, w, temp); }
 673   static void eval(mpz_ptr z, double d, mpz_srcptr w)
 674   {  __GMPXX_TMPZ_D;    mpz_tdiv_q (z, temp, w); }
 675
 676   static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
 677   { mpq_div(q, r, s); }
 678
 679   static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
 680   {
 681 #if __GMP_GNUC_PREREQ(3, 4)
 682     if (__GMPXX_CONSTANT(l) && (l & (l-1)) == 0 && l != 0)
 683       __gmp_binary_rshift::eval(q, r, __builtin_ctzl(l));
 684     else
 685 #endif
 686     {
 687       __GMPXX_TMPQ_UI;
 688       mpq_div (q, r, temp);
 689     }
 690   }
 691   static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
 692   {  __GMPXX_TMPQ_UI;   mpq_div (q, temp, r); }
 693   static void eval(mpq_ptr q, mpq_srcptr r, signed long int l)
 694   {
 695     if (__GMPXX_CONSTANT_TRUE(l >= 0))
 696       eval(q, r, static_cast<unsigned long>(l));
 697     else if (__GMPXX_CONSTANT_TRUE(l <= 0))
 698       {
 699         eval(q, r, -static_cast<unsigned long>(l));
 700         mpq_neg(q, q);
 701       }
 702     else
 703       {
 704         __GMPXX_TMPQ_SI;
 705         mpq_div (q, r, temp);
 706       }
 707   }
 708   static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
 709   {  __GMPXX_TMPQ_SI;   mpq_div (q, temp, r); }
 710   static void eval(mpq_ptr q, mpq_srcptr r, double d)
 711   {  __GMPXX_TMPQ_D;    mpq_div (q, r, temp); }
 712   static void eval(mpq_ptr q, double d, mpq_srcptr r)
 713   {  __GMPXX_TMPQ_D;    mpq_div (q, temp, r); }
 714
 715   static void eval(mpf_ptr f, mpf_srcptr g, mpf_srcptr h)
 716   { mpf_div(f, g, h); }
 717
 718   static void eval(mpf_ptr f, mpf_srcptr g, unsigned long int l)
 719   { mpf_div_ui(f, g, l); }
 720   static void eval(mpf_ptr f, unsigned long int l, mpf_srcptr g)
 721   { mpf_ui_div(f, l, g); }
 722   static void eval(mpf_ptr f, mpf_srcptr g, signed long int l)
 723   {
 724     if (l >= 0)
 725       mpf_div_ui(f, g, l);
 726     else
 727       {
 728         mpf_div_ui(f, g, -static_cast<unsigned long>(l));
 729         mpf_neg(f, f);
 730       }
 731   }
 732   static void eval(mpf_ptr f, signed long int l, mpf_srcptr g)
 733   {
 734     if (l >= 0)
 735       mpf_ui_div(f, l, g);
 736     else
 737       {
 738         mpf_ui_div(f, -static_cast<unsigned long>(l), g);
 739         mpf_neg(f, f);
 740       }
 741   }
 742   static void eval(mpf_ptr f, mpf_srcptr g, double d)
 743   {
 744     mpf_t temp;
 745     mpf_init2(temp, 8*sizeof(double));
 746     mpf_set_d(temp, d);
 747     mpf_div(f, g, temp);
 748     mpf_clear(temp);
 749   }
 750   static void eval(mpf_ptr f, double d, mpf_srcptr g)
 751   {
 752     mpf_t temp;
 753     mpf_init2(temp, 8*sizeof(double));
 754     mpf_set_d(temp, d);
 755     mpf_div(f, temp, g);
 756     mpf_clear(temp);
 757   }
 758 };
 759
 760 struct __gmp_binary_modulus
 761 {
 762   static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
 763   { mpz_tdiv_r(z, w, v); }
 764
 765   static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
 766   { mpz_tdiv_r_ui(z, w, l); }
 767   static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
 768   {
 769     if (mpz_sgn(w) >= 0)
 770       {
 771         if (mpz_fits_ulong_p(w))
 772           mpz_set_ui(z, l % mpz_get_ui(w));
 773         else
 774           mpz_set_ui(z, l);
 775       }
 776     else
 777       {
 778         mpz_neg(z, w);
 779         if (mpz_fits_ulong_p(z))
 780           mpz_set_ui(z, l % mpz_get_ui(z));
 781         else
 782           mpz_set_ui(z, l);
 783       }
 784   }
 785   static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
 786   {
 787     mpz_tdiv_r_ui (z, w, __gmpxx_abs_ui(l));
 788   }
 789   static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
 790   {
 791     if (mpz_fits_slong_p(w))
 792       mpz_set_si(z, l % mpz_get_si(w));
 793     else
 794       {
 795         /* if w is bigger than a long then the remainder is l unchanged,
 796            unless l==LONG_MIN and w==-LONG_MIN in which case it's 0 */
 797         mpz_set_si (z, mpz_cmpabs_ui (w, __gmpxx_abs_ui(l)) == 0 ? 0 : l);
 798       }
 799   }
 800   static void eval(mpz_ptr z, mpz_srcptr w, double d)
 801   {  __GMPXX_TMPZ_D;    mpz_tdiv_r (z, w, temp); }
 802   static void eval(mpz_ptr z, double d, mpz_srcptr w)
 803   {  __GMPXX_TMPZ_D;    mpz_tdiv_r (z, temp, w); }
 804 };
 805
 806 struct __gmp_binary_and
 807 {
 808   static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
 809   { mpz_and(z, w, v); }
 810
 811   static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
 812   {  __GMPXX_TMPZ_UI;   mpz_and (z, w, temp);  }
 813   static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
 814   { eval(z, w, l);  }
 815   static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
 816   {  __GMPXX_TMPZ_SI;   mpz_and (z, w, temp);  }
 817   static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
 818   { eval(z, w, l);  }
 819   static void eval(mpz_ptr z, mpz_srcptr w, double d)
 820   {  __GMPXX_TMPZ_D;    mpz_and (z, w, temp); }
 821   static void eval(mpz_ptr z, double d, mpz_srcptr w)
 822   { eval(z, w, d);  }
 823 };
 824
 825 struct __gmp_binary_ior
 826 {
 827   static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
 828   { mpz_ior(z, w, v); }
 829   static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
 830   {  __GMPXX_TMPZ_UI;   mpz_ior (z, w, temp);  }
 831   static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
 832   { eval(z, w, l);  }
 833   static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
 834   {  __GMPXX_TMPZ_SI;   mpz_ior (z, w, temp);  }
 835   static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
 836   { eval(z, w, l);  }
 837   static void eval(mpz_ptr z, mpz_srcptr w, double d)
 838   {  __GMPXX_TMPZ_D;    mpz_ior (z, w, temp); }
 839   static void eval(mpz_ptr z, double d, mpz_srcptr w)
 840   { eval(z, w, d);  }
 841 };
 842
 843 struct __gmp_binary_xor
 844 {
 845   static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
 846   { mpz_xor(z, w, v); }
 847   static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
 848   {  __GMPXX_TMPZ_UI;   mpz_xor (z, w, temp);  }
 849   static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
 850   { eval(z, w, l);  }
 851   static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
 852   {  __GMPXX_TMPZ_SI;   mpz_xor (z, w, temp);  }
 853   static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
 854   { eval(z, w, l);  }
 855   static void eval(mpz_ptr z, mpz_srcptr w, double d)
 856   {  __GMPXX_TMPZ_D;    mpz_xor (z, w, temp); }
 857   static void eval(mpz_ptr z, double d, mpz_srcptr w)
 858   { eval(z, w, d);  }
 859 };
 860
 861 struct __gmp_cmp_function
 862 {
 863   static int eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w); }
 864
 865   static int eval(mpz_srcptr z, unsigned long int l)
 866   { return mpz_cmp_ui(z, l); }
 867   static int eval(unsigned long int l, mpz_srcptr z)
 868   { return -mpz_cmp_ui(z, l); }
 869   static int eval(mpz_srcptr z, signed long int l)
 870   { return mpz_cmp_si(z, l); }
 871   static int eval(signed long int l, mpz_srcptr z)
 872   { return -mpz_cmp_si(z, l); }
 873   static int eval(mpz_srcptr z, double d)
 874   { return mpz_cmp_d(z, d); }
 875   static int eval(double d, mpz_srcptr z)
 876   { return -mpz_cmp_d(z, d); }
 877
 878   static int eval(mpq_srcptr q, mpq_srcptr r) { return mpq_cmp(q, r); }
 879
 880   static int eval(mpq_srcptr q, unsigned long int l)
 881   { return mpq_cmp_ui(q, l, 1); }
 882   static int eval(unsigned long int l, mpq_srcptr q)
 883   { return -mpq_cmp_ui(q, l, 1); }
 884   static int eval(mpq_srcptr q, signed long int l)
 885   { return mpq_cmp_si(q, l, 1); }
 886   static int eval(signed long int l, mpq_srcptr q)
 887   { return -mpq_cmp_si(q, l, 1); }
 888   static int eval(mpq_srcptr q, double d)
 889   {  __GMPXX_TMPQ_D;    return mpq_cmp (q, temp); }
 890   static int eval(double d, mpq_srcptr q)
 891   {  __GMPXX_TMPQ_D;    return mpq_cmp (temp, q); }
 892   static int eval(mpq_srcptr q, mpz_srcptr z)
 893   { return mpq_cmp_z(q, z); }
 894   static int eval(mpz_srcptr z, mpq_srcptr q)
 895   { return -mpq_cmp_z(q, z); }
 896
 897   static int eval(mpf_srcptr f, mpf_srcptr g) { return mpf_cmp(f, g); }
 898
 899   static int eval(mpf_srcptr f, unsigned long int l)
 900   { return mpf_cmp_ui(f, l); }
 901   static int eval(unsigned long int l, mpf_srcptr f)
 902   { return -mpf_cmp_ui(f, l); }
 903   static int eval(mpf_srcptr f, signed long int l)
 904   { return mpf_cmp_si(f, l); }
 905   static int eval(signed long int l, mpf_srcptr f)
 906   { return -mpf_cmp_si(f, l); }
 907   static int eval(mpf_srcptr f, double d)
 908   { return mpf_cmp_d(f, d); }
 909   static int eval(double d, mpf_srcptr f)
 910   { return -mpf_cmp_d(f, d); }
 911   static int eval(mpf_srcptr f, mpz_srcptr z)
 912   { return mpf_cmp_z(f, z); }
 913   static int eval(mpz_srcptr z, mpf_srcptr f)
 914   { return -mpf_cmp_z(f, z); }
 915   static int eval(mpf_srcptr f, mpq_srcptr q)
 916   {
 917     mpf_t qf;
 918     mpf_init(qf); /* Should we use the precision of f?  */
 919     mpf_set_q(qf, q);
 920     int ret = eval(f, qf);
 921     mpf_clear(qf);
 922     return ret;
 923   }
 924   static int eval(mpq_srcptr q, mpf_srcptr f)
 925   { return -eval(f, q); }
 926 };
 927
 928 struct __gmp_binary_equal
 929 {
 930   static bool eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w) == 0; }
 931
 932   static bool eval(mpz_srcptr z, unsigned long int l)
 933   { return mpz_cmp_ui(z, l) == 0; }
 934   static bool eval(unsigned long int l, mpz_srcptr z)
 935   { return eval(z, l); }
 936   static bool eval(mpz_srcptr z, signed long int l)
 937   { return mpz_cmp_si(z, l) == 0; }
 938   static bool eval(signed long int l, mpz_srcptr z)
 939   { return eval(z, l); }
 940   static bool eval(mpz_srcptr z, double d)
 941   { return mpz_cmp_d(z, d) == 0; }
 942   static bool eval(double d, mpz_srcptr z)
 943   { return eval(z, d); }
 944
 945   static bool eval(mpq_srcptr q, mpq_srcptr r)
 946   { return mpq_equal(q, r) != 0; }
 947
 948   static bool eval(mpq_srcptr q, unsigned long int l)
 949   { return mpq_cmp_ui(q, l, 1) == 0; }
 950   static bool eval(unsigned long int l, mpq_srcptr q)
 951   { return eval(q, l); }
 952   static bool eval(mpq_srcptr q, signed long int l)
 953   { return mpq_cmp_si(q, l, 1) == 0; }
 954   static bool eval(signed long int l, mpq_srcptr q)
 955   { return eval(q, l); }
 956   static bool eval(mpq_srcptr q, double d)
 957   {  __GMPXX_TMPQ_D;    return mpq_equal (q, temp) != 0; }
 958   static bool eval(double d, mpq_srcptr q)
 959   { return eval(q, d); }
 960   static bool eval(mpq_srcptr q, mpz_srcptr z)
 961   { return mpq_cmp_z(q, z) == 0; }
 962   static bool eval(mpz_srcptr z, mpq_srcptr q)
 963   { return eval(q, z); }
 964
 965   static bool eval(mpf_srcptr f, mpf_srcptr g) { return mpf_cmp(f, g) == 0; }
 966
 967   static bool eval(mpf_srcptr f, unsigned long int l)
 968   { return mpf_cmp_ui(f, l) == 0; }
 969   static bool eval(unsigned long int l, mpf_srcptr f)
 970   { return eval(f, l); }
 971   static bool eval(mpf_srcptr f, signed long int l)
 972   { return mpf_cmp_si(f, l) == 0; }
 973   static bool eval(signed long int l, mpf_srcptr f)
 974   { return eval(f, l); }
 975   static bool eval(mpf_srcptr f, double d)
 976   { return mpf_cmp_d(f, d) == 0; }
 977   static bool eval(double d, mpf_srcptr f)
 978   { return eval(f, d); }
 979   static bool eval(mpf_srcptr f, mpz_srcptr z)
 980   { return mpf_cmp_z(f, z) == 0; }
 981   static bool eval(mpz_srcptr z, mpf_srcptr f)
 982   { return eval(f, z); }
 983   static bool eval(mpf_srcptr f, mpq_srcptr q)
 984   { return __gmp_cmp_function::eval(f, q) == 0; }
 985   static bool eval(mpq_srcptr q, mpf_srcptr f)
 986   { return eval(f, q); }
 987 };
 988
 989 struct __gmp_binary_less
 990 {
 991   static bool eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w) < 0; }
 992
 993   static bool eval(mpz_srcptr z, unsigned long int l)
 994   { return mpz_cmp_ui(z, l) < 0; }
 995   static bool eval(unsigned long int l, mpz_srcptr z)
 996   { return mpz_cmp_ui(z, l) > 0; }
 997   static bool eval(mpz_srcptr z, signed long int l)
 998   { return mpz_cmp_si(z, l) < 0; }
 999   static bool eval(signed long int l, mpz_srcptr z)
1000   { return mpz_cmp_si(z, l) > 0; }
1001   static bool eval(mpz_srcptr z, double d)
1002   { return mpz_cmp_d(z, d) < 0; }
1003   static bool eval(double d, mpz_srcptr z)
1004   { return mpz_cmp_d(z, d) > 0; }
1005
1006   static bool eval(mpq_srcptr q, mpq_srcptr r) { return mpq_cmp(q, r) < 0; }
1007
1008   static bool eval(mpq_srcptr q, unsigned long int l)
1009   { return mpq_cmp_ui(q, l, 1) < 0; }
1010   static bool eval(unsigned long int l, mpq_srcptr q)
1011   { return mpq_cmp_ui(q, l, 1) > 0; }
1012   static bool eval(mpq_srcptr q, signed long int l)
1013   { return mpq_cmp_si(q, l, 1) < 0; }
1014   static bool eval(signed long int l, mpq_srcptr q)
1015   { return mpq_cmp_si(q, l, 1) > 0; }
1016   static bool eval(mpq_srcptr q, double d)
1017   {  __GMPXX_TMPQ_D;    return mpq_cmp (q, temp) < 0; }
1018   static bool eval(double d, mpq_srcptr q)
1019   {  __GMPXX_TMPQ_D;    return mpq_cmp (temp, q) < 0; }
1020   static bool eval(mpq_srcptr q, mpz_srcptr z)
1021   { return mpq_cmp_z(q, z) < 0; }
1022   static bool eval(mpz_srcptr z, mpq_srcptr q)
1023   { return mpq_cmp_z(q, z) > 0; }
1024
1025   static bool eval(mpf_srcptr f, mpf_srcptr g) { return mpf_cmp(f, g) < 0; }
1026
1027   static bool eval(mpf_srcptr f, unsigned long int l)
1028   { return mpf_cmp_ui(f, l) < 0; }
1029   static bool eval(unsigned long int l, mpf_srcptr f)
1030   { return mpf_cmp_ui(f, l) > 0; }
1031   static bool eval(mpf_srcptr f, signed long int l)
1032   { return mpf_cmp_si(f, l) < 0; }
1033   static bool eval(signed long int l, mpf_srcptr f)
1034   { return mpf_cmp_si(f, l) > 0; }
1035   static bool eval(mpf_srcptr f, double d)
1036   { return mpf_cmp_d(f, d) < 0; }
1037   static bool eval(double d, mpf_srcptr f)
1038   { return mpf_cmp_d(f, d) > 0; }
1039   static bool eval(mpf_srcptr f, mpz_srcptr z)
1040   { return mpf_cmp_z(f, z) < 0; }
1041   static bool eval(mpz_srcptr z, mpf_srcptr f)
1042   { return mpf_cmp_z(f, z) > 0; }
1043   static bool eval(mpf_srcptr f, mpq_srcptr q)
1044   { return __gmp_cmp_function::eval(f, q) < 0; }
1045   static bool eval(mpq_srcptr q, mpf_srcptr f)
1046   { return __gmp_cmp_function::eval(q, f) < 0; }
1047 };
1048
1049 struct __gmp_binary_greater
1050 {
1051   template <class T, class U>
1052   static inline bool eval(T t, U u) { return __gmp_binary_less::eval(u, t); }
1053 };
1054
1055 struct __gmp_unary_increment
1056 {
1057   static void eval(mpz_ptr z) { mpz_add_ui(z, z, 1); }
1058   static void eval(mpq_ptr q)
1059   { mpz_add(mpq_numref(q), mpq_numref(q), mpq_denref(q)); }
1060   static void eval(mpf_ptr f) { mpf_add_ui(f, f, 1); }
1061 };
1062
1063 struct __gmp_unary_decrement
1064 {
1065   static void eval(mpz_ptr z) { mpz_sub_ui(z, z, 1); }
1066   static void eval(mpq_ptr q)
1067   { mpz_sub(mpq_numref(q), mpq_numref(q), mpq_denref(q)); }
1068   static void eval(mpf_ptr f) { mpf_sub_ui(f, f, 1); }
1069 };
1070
1071 struct __gmp_abs_function
1072 {
1073   static void eval(mpz_ptr z, mpz_srcptr w) { mpz_abs(z, w); }
1074   static void eval(mpq_ptr q, mpq_srcptr r) { mpq_abs(q, r); }
1075   static void eval(mpf_ptr f, mpf_srcptr g) { mpf_abs(f, g); }
1076 };
1077
1078 struct __gmp_trunc_function
1079 {
1080   static void eval(mpf_ptr f, mpf_srcptr g) { mpf_trunc(f, g); }
1081 };
1082
1083 struct __gmp_floor_function
1084 {
1085   static void eval(mpf_ptr f, mpf_srcptr g) { mpf_floor(f, g); }
1086 };
1087
1088 struct __gmp_ceil_function
1089 {
1090   static void eval(mpf_ptr f, mpf_srcptr g) { mpf_ceil(f, g); }
1091 };
1092
1093 struct __gmp_sqrt_function
1094 {
1095   static void eval(mpz_ptr z, mpz_srcptr w) { mpz_sqrt(z, w); }
1096   static void eval(mpf_ptr f, mpf_srcptr g) { mpf_sqrt(f, g); }
1097 };
1098
1099 struct __gmp_hypot_function
1100 {
1101   static void eval(mpf_ptr f, mpf_srcptr g, mpf_srcptr h)
1102   {
1103     mpf_t temp;
1104     mpf_init2(temp, mpf_get_prec(f));
1105     mpf_mul(temp, g, g);
1106     mpf_mul(f, h, h);
1107     mpf_add(f, f, temp);
1108     mpf_sqrt(f, f);
1109     mpf_clear(temp);
1110   }
1111
1112   static void eval(mpf_ptr f, mpf_srcptr g, unsigned long int l)
1113   {
1114     mpf_t temp;
1115     mpf_init2(temp, mpf_get_prec(f));
1116     mpf_mul(temp, g, g);
1117     mpf_set_ui(f, l);
1118     mpf_mul_ui(f, f, l);
1119     mpf_add(f, f, temp);
1120     mpf_clear(temp);
1121     mpf_sqrt(f, f);
1122   }
1123   static void eval(mpf_ptr f, unsigned long int l, mpf_srcptr g)
1124   { eval(f, g, l); }
1125   static void eval(mpf_ptr f, mpf_srcptr g, signed long int l)
1126   { eval(f, g, __gmpxx_abs_ui(l)); }
1127   static void eval(mpf_ptr f, signed long int l, mpf_srcptr g)
1128   { eval(f, g, l); }
1129   static void eval(mpf_ptr f, mpf_srcptr g, double d)
1130   {
1131     mpf_t temp;
1132     mpf_init2(temp, mpf_get_prec(f));
1133     mpf_mul(temp, g, g);
1134     mpf_set_d(f, d);
1135     mpf_mul(f, f, f);
1136     mpf_add(f, f, temp);
1137     mpf_sqrt(f, f);
1138     mpf_clear(temp);
1139   }
1140   static void eval(mpf_ptr f, double d, mpf_srcptr g)
1141   { eval(f, g, d); }
1142 };
1143
1144 struct __gmp_sgn_function
1145 {
1146   static int eval(mpz_srcptr z) { return mpz_sgn(z); }
1147   static int eval(mpq_srcptr q) { return mpq_sgn(q); }
1148   static int eval(mpf_srcptr f) { return mpf_sgn(f); }
1149 };
1150
1151 struct __gmp_gcd_function
1152 {
1153   static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
1154   { mpz_gcd(z, w, v); }
1155   static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
1156   { mpz_gcd_ui(z, w, l); }
1157   static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
1158   { eval(z, w, l); }
1159   static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
1160   { eval(z, w, __gmpxx_abs_ui(l)); }
1161   static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
1162   { eval(z, w, l); }
1163   static void eval(mpz_ptr z, mpz_srcptr w, double d)
1164   {  __GMPXX_TMPZ_D;    mpz_gcd (z, w, temp); }
1165   static void eval(mpz_ptr z, double d, mpz_srcptr w)
1166   { eval(z, w, d); }
1167 };
1168
1169 struct __gmp_lcm_function
1170 {
1171   static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
1172   { mpz_lcm(z, w, v); }
1173   static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
1174   { mpz_lcm_ui(z, w, l); }
1175   static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
1176   { eval(z, w, l); }
1177   static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
1178   { eval(z, w, __gmpxx_abs_ui(l)); }
1179   static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
1180   { eval(z, w, l); }
1181   static void eval(mpz_ptr z, mpz_srcptr w, double d)
1182   {  __GMPXX_TMPZ_D;    mpz_lcm (z, w, temp); }
1183   static void eval(mpz_ptr z, double d, mpz_srcptr w)
1184   { eval(z, w, d); }
1185 };
1186
1187 struct __gmp_rand_function
1188 {
1189   static void eval(mpz_ptr z, gmp_randstate_t s, mp_bitcnt_t l)
1190   { mpz_urandomb(z, s, l); }
1191   static void eval(mpz_ptr z, gmp_randstate_t s, mpz_srcptr w)
1192   { mpz_urandomm(z, s, w); }
1193   static void eval(mpf_ptr f, gmp_randstate_t s, mp_bitcnt_t prec)
1194   { mpf_urandomb(f, s, prec); }
1195 };
1196
1197
1198 /**************** Auxiliary classes ****************/
1199
1200 /* this is much the same as gmp_allocated_string in gmp-impl.h
1201    since gmp-impl.h is not publicly available, I redefine it here
1202    I use a different name to avoid possible clashes */
1203
1204 extern "C" {
1205   typedef void (*__gmp_freefunc_t) (void *, size_t);
1206 }
1207 struct __gmp_alloc_cstring
1208 {
1209   char *str;
1210   __gmp_alloc_cstring(char *s) { str = s; }
1211   ~__gmp_alloc_cstring()
1212   {
1213     __gmp_freefunc_t freefunc;
1214     mp_get_memory_functions (NULL, NULL, &freefunc);
1215     (*freefunc) (str, std::strlen(str)+1);
1216   }
1217 };
1218
1219
1220 // general expression template class
1221 template <class T, class U>
1222 class __gmp_expr;
1223
1224
1225 // templates for resolving expression types
1226 template <class T>
1227 struct __gmp_resolve_ref
1228 {
1229   typedef T ref_type;
1230 };
1231
1232 template <class T, class U>
1233 struct __gmp_resolve_ref<__gmp_expr<T, U> >
1234 {
1235   typedef const __gmp_expr<T, U> & ref_type;
1236 };
1237
1238
1239 template <class T, class U = T>
1240 struct __gmp_resolve_expr;
1241
1242 template <>
1243 struct __gmp_resolve_expr<mpz_t>
1244 {
1245   typedef mpz_t value_type;
1246   typedef mpz_ptr ptr_type;
1247   typedef mpz_srcptr srcptr_type;
1248 };
1249
1250 template <>
1251 struct __gmp_resolve_expr<mpq_t>
1252 {
1253   typedef mpq_t value_type;
1254   typedef mpq_ptr ptr_type;
1255   typedef mpq_srcptr srcptr_type;
1256 };
1257
1258 template <>
1259 struct __gmp_resolve_expr<mpf_t>
1260 {
1261   typedef mpf_t value_type;
1262   typedef mpf_ptr ptr_type;
1263   typedef mpf_srcptr srcptr_type;
1264 };
1265
1266 template <>
1267 struct __gmp_resolve_expr<mpz_t, mpq_t>
1268 {
1269   typedef mpq_t value_type;
1270 };
1271
1272 template <>
1273 struct __gmp_resolve_expr<mpq_t, mpz_t>
1274 {
1275   typedef mpq_t value_type;
1276 };
1277
1278 template <>
1279 struct __gmp_resolve_expr<mpz_t, mpf_t>
1280 {
1281   typedef mpf_t value_type;
1282 };
1283
1284 template <>
1285 struct __gmp_resolve_expr<mpf_t, mpz_t>
1286 {
1287   typedef mpf_t value_type;
1288 };
1289
1290 template <>
1291 struct __gmp_resolve_expr<mpq_t, mpf_t>
1292 {
1293   typedef mpf_t value_type;
1294 };
1295
1296 template <>
1297 struct __gmp_resolve_expr<mpf_t, mpq_t>
1298 {
1299   typedef mpf_t value_type;
1300 };
1301
1302 #if __GMPXX_USE_CXX11
1303 namespace std {
1304   template <class T, class U, class V, class W>
1305   struct common_type <__gmp_expr<T, U>, __gmp_expr<V, W> >
1306   {
1307   private:
1308     typedef typename __gmp_resolve_expr<T, V>::value_type X;
1309   public:
1310     typedef __gmp_expr<X, X> type;
1311   };
1312
1313   template <class T, class U>
1314   struct common_type <__gmp_expr<T, U> >
1315   {
1316     typedef __gmp_expr<T, T> type;
1317   };
1318
1319 #define __GMPXX_DECLARE_COMMON_TYPE(typ)        \
1320   template <class T, class U>                   \
1321   struct common_type <__gmp_expr<T, U>, typ >   \
1322   {                                             \
1323     typedef __gmp_expr<T, T> type;              \
1324   };                                            \
1325                                                 \
1326   template <class T, class U>                   \
1327   struct common_type <typ, __gmp_expr<T, U> >   \
1328   {                                             \
1329     typedef __gmp_expr<T, T> type;              \
1330   }
1331
1332   __GMPXX_DECLARE_COMMON_TYPE(signed char);
1333   __GMPXX_DECLARE_COMMON_TYPE(unsigned char);
1334   __GMPXX_DECLARE_COMMON_TYPE(signed int);
1335   __GMPXX_DECLARE_COMMON_TYPE(unsigned int);
1336   __GMPXX_DECLARE_COMMON_TYPE(signed short int);
1337   __GMPXX_DECLARE_COMMON_TYPE(unsigned short int);
1338   __GMPXX_DECLARE_COMMON_TYPE(signed long int);
1339   __GMPXX_DECLARE_COMMON_TYPE(unsigned long int);
1340   __GMPXX_DECLARE_COMMON_TYPE(float);
1341   __GMPXX_DECLARE_COMMON_TYPE(double);
1342 #undef __GMPXX_DECLARE_COMMON_TYPE
1343 }
1344 #endif
1345
1346 // classes for evaluating unary and binary expressions
1347 template <class T, class Op>
1348 struct __gmp_unary_expr
1349 {
1350   typename __gmp_resolve_ref<T>::ref_type val;
1351
1352   __gmp_unary_expr(const T &v) : val(v) { }
1353 private:
1354   __gmp_unary_expr();
1355 };
1356
1357 template <class T, class U, class Op>
1358 struct __gmp_binary_expr
1359 {
1360   typename __gmp_resolve_ref<T>::ref_type val1;
1361   typename __gmp_resolve_ref<U>::ref_type val2;
1362
1363   __gmp_binary_expr(const T &v1, const U &v2) : val1(v1), val2(v2) { }
1364 private:
1365   __gmp_binary_expr();
1366 };
1367
1368
1369
1370 /**************** Macros for in-class declarations ****************/
1371 /* This is just repetitive code that is easier to maintain if it's written
1372    only once */
1373
1374 #define __GMPP_DECLARE_COMPOUND_OPERATOR(fun)                         \
1375   template <class T, class U>                                         \
1376   __gmp_expr<value_type, value_type> & fun(const __gmp_expr<T, U> &);
1377
1378 #define __GMPN_DECLARE_COMPOUND_OPERATOR(fun) \
1379   __gmp_expr & fun(signed char);              \
1380   __gmp_expr & fun(unsigned char);            \
1381   __gmp_expr & fun(signed int);               \
1382   __gmp_expr & fun(unsigned int);             \
1383   __gmp_expr & fun(signed short int);         \
1384   __gmp_expr & fun(unsigned short int);       \
1385   __gmp_expr & fun(signed long int);          \
1386   __gmp_expr & fun(unsigned long int);        \
1387   __gmp_expr & fun(float);                    \
1388   __gmp_expr & fun(double);                   \
1389   /* __gmp_expr & fun(long double); */
1390
1391 #define __GMP_DECLARE_COMPOUND_OPERATOR(fun) \
1392 __GMPP_DECLARE_COMPOUND_OPERATOR(fun)        \
1393 __GMPN_DECLARE_COMPOUND_OPERATOR(fun)
1394
1395 #define __GMP_DECLARE_COMPOUND_OPERATOR_UI(fun) \
1396   __gmp_expr & fun(mp_bitcnt_t);
1397
1398 #define __GMP_DECLARE_INCREMENT_OPERATOR(fun) \
1399   inline __gmp_expr & fun();                  \
1400   inline __gmp_expr fun(int);
1401
1402 #define __GMPXX_DEFINE_ARITHMETIC_CONSTRUCTORS          \
1403   __gmp_expr(signed char c) { init_si(c); }             \
1404   __gmp_expr(unsigned char c) { init_ui(c); }           \
1405   __gmp_expr(signed int i) { init_si(i); }              \
1406   __gmp_expr(unsigned int i) { init_ui(i); }            \
1407   __gmp_expr(signed short int s) { init_si(s); }        \
1408   __gmp_expr(unsigned short int s) { init_ui(s); }      \
1409   __gmp_expr(signed long int l) { init_si(l); }         \
1410   __gmp_expr(unsigned long int l) { init_ui(l); }       \
1411   __gmp_expr(float f) { init_d(f); }                    \
1412   __gmp_expr(double d) { init_d(d); }
1413
1414 #define __GMPXX_DEFINE_ARITHMETIC_ASSIGNMENTS           \
1415   __gmp_expr & operator=(signed char c) { assign_si(c); return *this; } \
1416   __gmp_expr & operator=(unsigned char c) { assign_ui(c); return *this; } \
1417   __gmp_expr & operator=(signed int i) { assign_si(i); return *this; } \
1418   __gmp_expr & operator=(unsigned int i) { assign_ui(i); return *this; } \
1419   __gmp_expr & operator=(signed short int s) { assign_si(s); return *this; } \
1420   __gmp_expr & operator=(unsigned short int s) { assign_ui(s); return *this; } \
1421   __gmp_expr & operator=(signed long int l) { assign_si(l); return *this; } \
1422   __gmp_expr & operator=(unsigned long int l) { assign_ui(l); return *this; } \
1423   __gmp_expr & operator=(float f) { assign_d(f); return *this; } \
1424   __gmp_expr & operator=(double d) { assign_d(d); return *this; }
1425
1426 /**************** mpz_class -- wrapper for mpz_t ****************/
1427
1428 template <>
1429 class __gmp_expr<mpz_t, mpz_t>
1430 {
1431 private:
1432   typedef mpz_t value_type;
1433   value_type mp;
1434
1435   // Helper functions used for all arithmetic types
1436   void assign_ui(unsigned long l)
1437   {
1438     if (__GMPXX_CONSTANT_TRUE(l == 0))
1439       mp->_mp_size = 0;
1440     else
1441       mpz_set_ui(mp, l);
1442   }
1443   void assign_si(signed long l)
1444   {
1445     if (__GMPXX_CONSTANT_TRUE(l >= 0))
1446       assign_ui(l);
1447     else if (__GMPXX_CONSTANT_TRUE(l <= 0))
1448       {
1449         assign_ui(-static_cast<unsigned long>(l));
1450         mpz_neg(mp, mp);
1451       }
1452     else
1453       mpz_set_si(mp, l);
1454   }
1455   void assign_d (double d)
1456   {
1457     mpz_set_d (mp, d);
1458   }
1459
1460   void init_ui(unsigned long l)
1461   {
1462     if (__GMPXX_CONSTANT_TRUE(l == 0))
1463       mpz_init(mp);
1464     else
1465       mpz_init_set_ui(mp, l);
1466   }
1467   void init_si(signed long l)
1468   {
1469     if (__GMPXX_CONSTANT_TRUE(l >= 0))
1470       init_ui(l);
1471     else if (__GMPXX_CONSTANT_TRUE(l <= 0))
1472       {
1473         init_ui(-static_cast<unsigned long>(l));
1474         mpz_neg(mp, mp);
1475       }
1476     else
1477       mpz_init_set_si(mp, l);
1478   }
1479   void init_d (double d)
1480   {
1481     mpz_init_set_d (mp, d);
1482   }
1483
1484 public:
1485   mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); }
1486
1487   // constructors and destructor
1488   __gmp_expr() { mpz_init(mp); }
1489
1490   __gmp_expr(const __gmp_expr &z) { mpz_init_set(mp, z.mp); }
1491 #if __GMPXX_USE_CXX11
1492   __gmp_expr(__gmp_expr &&z)
1493   { *mp = *z.mp; mpz_init(z.mp); }
1494 #endif
1495   template <class T>
1496   __gmp_expr(const __gmp_expr<mpz_t, T> &expr)
1497   { mpz_init(mp); __gmp_set_expr(mp, expr); }
1498   template <class T, class U>
1499   explicit __gmp_expr(const __gmp_expr<T, U> &expr)
1500   { mpz_init(mp); __gmp_set_expr(mp, expr); }
1501
1502   __GMPXX_DEFINE_ARITHMETIC_CONSTRUCTORS
1503
1504   explicit __gmp_expr(const char *s, int base = 0)
1505   {
1506     if (mpz_init_set_str (mp, s, base) != 0)
1507       {
1508         mpz_clear (mp);
1509         throw std::invalid_argument ("mpz_set_str");
1510       }
1511   }
1512   explicit __gmp_expr(const std::string &s, int base = 0)
1513   {
1514     if (mpz_init_set_str(mp, s.c_str(), base) != 0)
1515       {
1516         mpz_clear (mp);
1517         throw std::invalid_argument ("mpz_set_str");
1518       }
1519   }
1520
1521   explicit __gmp_expr(mpz_srcptr z) { mpz_init_set(mp, z); }
1522
1523   ~__gmp_expr() { mpz_clear(mp); }
1524
1525   void swap(__gmp_expr& z) __GMPXX_NOEXCEPT { std::swap(*mp, *z.mp); }
1526
1527   // assignment operators
1528   __gmp_expr & operator=(const __gmp_expr &z)
1529   { mpz_set(mp, z.mp); return *this; }
1530 #if __GMPXX_USE_CXX11
1531   __gmp_expr & operator=(__gmp_expr &&z) noexcept
1532   { swap(z); return *this; }
1533 #endif
1534   template <class T, class U>
1535   __gmp_expr<value_type, value_type> & operator=(const __gmp_expr<T, U> &expr)
1536   { __gmp_set_expr(mp, expr); return *this; }
1537
1538   __GMPXX_DEFINE_ARITHMETIC_ASSIGNMENTS
1539
1540   __gmp_expr & operator=(const char *s)
1541   {
1542     if (mpz_set_str (mp, s, 0) != 0)
1543       throw std::invalid_argument ("mpz_set_str");
1544     return *this;
1545   }
1546   __gmp_expr & operator=(const std::string &s)
1547   {
1548     if (mpz_set_str(mp, s.c_str(), 0) != 0)
1549       throw std::invalid_argument ("mpz_set_str");
1550     return *this;
1551   }
1552
1553   // string input/output functions
1554   int set_str(const char *s, int base)
1555   { return mpz_set_str(mp, s, base); }
1556   int set_str(const std::string &s, int base)
1557   { return mpz_set_str(mp, s.c_str(), base); }
1558   std::string get_str(int base = 10) const
1559   {
1560     __gmp_alloc_cstring temp(mpz_get_str(0, base, mp));
1561     return std::string(temp.str);
1562   }
1563
1564   // conversion functions
1565   mpz_srcptr __get_mp() const { return mp; }
1566   mpz_ptr __get_mp() { return mp; }
1567   mpz_srcptr get_mpz_t() const { return mp; }
1568   mpz_ptr get_mpz_t() { return mp; }
1569
1570   signed long int get_si() const { return mpz_get_si(mp); }
1571   unsigned long int get_ui() const { return mpz_get_ui(mp); }
1572   double get_d() const { return mpz_get_d(mp); }
1573
1574   // bool fits_schar_p() const { return mpz_fits_schar_p(mp); }
1575   // bool fits_uchar_p() const { return mpz_fits_uchar_p(mp); }
1576   bool fits_sint_p() const { return mpz_fits_sint_p(mp); }
1577   bool fits_uint_p() const { return mpz_fits_uint_p(mp); }
1578   bool fits_sshort_p() const { return mpz_fits_sshort_p(mp); }
1579   bool fits_ushort_p() const { return mpz_fits_ushort_p(mp); }
1580   bool fits_slong_p() const { return mpz_fits_slong_p(mp); }
1581   bool fits_ulong_p() const { return mpz_fits_ulong_p(mp); }
1582   // bool fits_float_p() const { return mpz_fits_float_p(mp); }
1583   // bool fits_double_p() const { return mpz_fits_double_p(mp); }
1584   // bool fits_ldouble_p() const { return mpz_fits_ldouble_p(mp); }
1585
1586 #if __GMPXX_USE_CXX11
1587   explicit operator bool() const { return mp->_mp_size != 0; }
1588 #endif
1589
1590   // member operators
1591   __GMP_DECLARE_COMPOUND_OPERATOR(operator+=)
1592   __GMP_DECLARE_COMPOUND_OPERATOR(operator-=)
1593   __GMP_DECLARE_COMPOUND_OPERATOR(operator*=)
1594   __GMP_DECLARE_COMPOUND_OPERATOR(operator/=)
1595   __GMP_DECLARE_COMPOUND_OPERATOR(operator%=)
1596
1597   __GMP_DECLARE_COMPOUND_OPERATOR(operator&=)
1598   __GMP_DECLARE_COMPOUND_OPERATOR(operator|=)
1599   __GMP_DECLARE_COMPOUND_OPERATOR(operator^=)
1600
1601   __GMP_DECLARE_COMPOUND_OPERATOR_UI(operator<<=)
1602   __GMP_DECLARE_COMPOUND_OPERATOR_UI(operator>>=)
1603
1604   __GMP_DECLARE_INCREMENT_OPERATOR(operator++)
1605   __GMP_DECLARE_INCREMENT_OPERATOR(operator--)
1606 };
1607
1608 typedef __gmp_expr<mpz_t, mpz_t> mpz_class;
1609
1610
1611 /**************** mpq_class -- wrapper for mpq_t ****************/
1612
1613 template <>
1614 class __gmp_expr<mpq_t, mpq_t>
1615 {
1616 private:
1617   typedef mpq_t value_type;
1618   value_type mp;
1619
1620   // Helper functions used for all arithmetic types
1621   void assign_ui(unsigned long l) { mpq_set_ui(mp, l, 1); }
1622   void assign_si(signed long l)
1623   {
1624     if (__GMPXX_CONSTANT_TRUE(l >= 0))
1625       assign_ui(l);
1626     else
1627       mpq_set_si(mp, l, 1);
1628   }
1629   void assign_d (double d)        { mpq_set_d (mp, d); }
1630
1631   void init_ui(unsigned long l) { mpq_init(mp); get_num() = l; }
1632   void init_si(signed long l)   { mpq_init(mp); get_num() = l; }
1633   void init_d (double d)        { mpq_init(mp); assign_d (d); }
1634
1635 public:
1636   mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); }
1637   void canonicalize() { mpq_canonicalize(mp); }
1638
1639   // constructors and destructor
1640   __gmp_expr() { mpq_init(mp); }
1641
1642   __gmp_expr(const __gmp_expr &q)
1643   {
1644     mpz_init_set(mpq_numref(mp), mpq_numref(q.mp));
1645     mpz_init_set(mpq_denref(mp), mpq_denref(q.mp));
1646   }
1647 #if __GMPXX_USE_CXX11
1648   __gmp_expr(__gmp_expr &&q)
1649   { *mp = *q.mp; mpq_init(q.mp); }
1650 #endif
1651   template <class T>
1652   __gmp_expr(const __gmp_expr<mpz_t, T> &expr)
1653   { mpq_init(mp); __gmp_set_expr(mp, expr); }
1654   template <class T>
1655   __gmp_expr(const __gmp_expr<mpq_t, T> &expr)
1656   { mpq_init(mp); __gmp_set_expr(mp, expr); }
1657   template <class T, class U>
1658   explicit __gmp_expr(const __gmp_expr<T, U> &expr)
1659   { mpq_init(mp); __gmp_set_expr(mp, expr); }
1660
1661   __GMPXX_DEFINE_ARITHMETIC_CONSTRUCTORS
1662
1663   explicit __gmp_expr(const char *s, int base = 0)
1664   {
1665     mpq_init (mp);
1666     // If s is the literal 0, we meant to call another constructor.
1667     // If s just happens to evaluate to 0, we would crash, so whatever.
1668     if (s == 0)
1669       {
1670         // Don't turn mpq_class(0,0) into 0
1671         mpz_set_si(mpq_denref(mp), base);
1672       }
1673     else if (mpq_set_str(mp, s, base) != 0)
1674       {
1675         mpq_clear (mp);
1676         throw std::invalid_argument ("mpq_set_str");
1677       }
1678   }
1679   explicit __gmp_expr(const std::string &s, int base = 0)
1680   {
1681     mpq_init(mp);
1682     if (mpq_set_str (mp, s.c_str(), base) != 0)
1683       {
1684         mpq_clear (mp);
1685         throw std::invalid_argument ("mpq_set_str");
1686       }
1687   }
1688   explicit __gmp_expr(mpq_srcptr q)
1689   {
1690     mpz_init_set(mpq_numref(mp), mpq_numref(q));
1691     mpz_init_set(mpq_denref(mp), mpq_denref(q));
1692   }
1693
1694   __gmp_expr(const mpz_class &num, const mpz_class &den)
1695   {
1696     mpz_init_set(mpq_numref(mp), num.get_mpz_t());
1697     mpz_init_set(mpq_denref(mp), den.get_mpz_t());
1698   }
1699
1700   ~__gmp_expr() { mpq_clear(mp); }
1701
1702   void swap(__gmp_expr& q) __GMPXX_NOEXCEPT { std::swap(*mp, *q.mp); }
1703
1704   // assignment operators
1705   __gmp_expr & operator=(const __gmp_expr &q)
1706   { mpq_set(mp, q.mp); return *this; }
1707 #if __GMPXX_USE_CXX11
1708   __gmp_expr & operator=(__gmp_expr &&q) noexcept
1709   { swap(q); return *this; }
1710   __gmp_expr & operator=(mpz_class &&z) noexcept
1711   { get_num() = std::move(z); get_den() = 1u; return *this; }
1712 #endif
1713   template <class T, class U>
1714   __gmp_expr<value_type, value_type> & operator=(const __gmp_expr<T, U> &expr)
1715   { __gmp_set_expr(mp, expr); return *this; }
1716
1717   __GMPXX_DEFINE_ARITHMETIC_ASSIGNMENTS
1718
1719   __gmp_expr & operator=(const char *s)
1720   {
1721     if (mpq_set_str (mp, s, 0) != 0)
1722       throw std::invalid_argument ("mpq_set_str");
1723     return *this;
1724   }
1725   __gmp_expr & operator=(const std::string &s)
1726   {
1727     if (mpq_set_str(mp, s.c_str(), 0) != 0)
1728       throw std::invalid_argument ("mpq_set_str");
1729     return *this;
1730   }
1731
1732   // string input/output functions
1733   int set_str(const char *s, int base)
1734   { return mpq_set_str(mp, s, base); }
1735   int set_str(const std::string &s, int base)
1736   { return mpq_set_str(mp, s.c_str(), base); }
1737   std::string get_str(int base = 10) const
1738   {
1739     __gmp_alloc_cstring temp(mpq_get_str(0, base, mp));
1740     return std::string(temp.str);
1741   }
1742
1743   // conversion functions
1744
1745   // casting a reference to an mpz_t to mpz_class & is a dirty hack,
1746   // but works because the internal representation of mpz_class is
1747   // exactly an mpz_t
1748   const mpz_class & get_num() const
1749   { return reinterpret_cast<const mpz_class &>(*mpq_numref(mp)); }
1750   mpz_class & get_num()
1751   { return reinterpret_cast<mpz_class &>(*mpq_numref(mp)); }
1752   const mpz_class & get_den() const
1753   { return reinterpret_cast<const mpz_class &>(*mpq_denref(mp)); }
1754   mpz_class & get_den()
1755   { return reinterpret_cast<mpz_class &>(*mpq_denref(mp)); }
1756
1757   mpq_srcptr __get_mp() const { return mp; }
1758   mpq_ptr __get_mp() { return mp; }
1759   mpq_srcptr get_mpq_t() const { return mp; }
1760   mpq_ptr get_mpq_t() { return mp; }
1761
1762   mpz_srcptr get_num_mpz_t() const { return mpq_numref(mp); }
1763   mpz_ptr get_num_mpz_t() { return mpq_numref(mp); }
1764   mpz_srcptr get_den_mpz_t() const { return mpq_denref(mp); }
1765   mpz_ptr get_den_mpz_t() { return mpq_denref(mp); }
1766
1767   double get_d() const { return mpq_get_d(mp); }
1768
1769 #if __GMPXX_USE_CXX11
1770   explicit operator bool() const { return mpq_numref(mp)->_mp_size != 0; }
1771 #endif
1772
1773   // compound assignments
1774   __GMP_DECLARE_COMPOUND_OPERATOR(operator+=)
1775   __GMP_DECLARE_COMPOUND_OPERATOR(operator-=)
1776   __GMP_DECLARE_COMPOUND_OPERATOR(operator*=)
1777   __GMP_DECLARE_COMPOUND_OPERATOR(operator/=)
1778
1779   __GMP_DECLARE_COMPOUND_OPERATOR_UI(operator<<=)
1780   __GMP_DECLARE_COMPOUND_OPERATOR_UI(operator>>=)
1781
1782   __GMP_DECLARE_INCREMENT_OPERATOR(operator++)
1783   __GMP_DECLARE_INCREMENT_OPERATOR(operator--)
1784 };
1785
1786 typedef __gmp_expr<mpq_t, mpq_t> mpq_class;
1787
1788
1789 /**************** mpf_class -- wrapper for mpf_t ****************/
1790
1791 template <>
1792 class __gmp_expr<mpf_t, mpf_t>
1793 {
1794 private:
1795   typedef mpf_t value_type;
1796   value_type mp;
1797
1798   // Helper functions used for all arithmetic types
1799   void assign_ui(unsigned long l) { mpf_set_ui(mp, l); }
1800   void assign_si(signed long l)
1801   {
1802     if (__GMPXX_CONSTANT_TRUE(l >= 0))
1803       assign_ui(l);
1804     else
1805       mpf_set_si(mp, l);
1806   }
1807   void assign_d (double d)        { mpf_set_d (mp, d); }
1808
1809   void init_ui(unsigned long l)
1810   {
1811     if (__GMPXX_CONSTANT_TRUE(l == 0))
1812       mpf_init(mp);
1813     else
1814       mpf_init_set_ui(mp, l);
1815   }
1816   void init_si(signed long l)
1817   {
1818     if (__GMPXX_CONSTANT_TRUE(l >= 0))
1819       init_ui(l);
1820     else
1821       mpf_init_set_si(mp, l);
1822   }
1823   void init_d (double d)        { mpf_init_set_d (mp, d); }
1824
1825 public:
1826   mp_bitcnt_t get_prec() const { return mpf_get_prec(mp); }
1827
1828   void set_prec(mp_bitcnt_t prec) { mpf_set_prec(mp, prec); }
1829   void set_prec_raw(mp_bitcnt_t prec) { mpf_set_prec_raw(mp, prec); }
1830
1831   // constructors and destructor
1832   __gmp_expr() { mpf_init(mp); }
1833
1834   __gmp_expr(const __gmp_expr &f)
1835   { mpf_init2(mp, f.get_prec()); mpf_set(mp, f.mp); }
1836 #if __GMPXX_USE_CXX11
1837   __gmp_expr(__gmp_expr &&f)
1838   { *mp = *f.mp; mpf_init2(f.mp, get_prec()); }
1839 #endif
1840   __gmp_expr(const __gmp_expr &f, mp_bitcnt_t prec)
1841   { mpf_init2(mp, prec); mpf_set(mp, f.mp); }
1842   template <class T, class U>
1843   __gmp_expr(const __gmp_expr<T, U> &expr)
1844   { mpf_init2(mp, expr.get_prec()); __gmp_set_expr(mp, expr); }
1845   template <class T, class U>
1846   __gmp_expr(const __gmp_expr<T, U> &expr, mp_bitcnt_t prec)
1847   { mpf_init2(mp, prec); __gmp_set_expr(mp, expr); }
1848
1849   __GMPXX_DEFINE_ARITHMETIC_CONSTRUCTORS
1850
1851   __gmp_expr(signed char c, mp_bitcnt_t prec)
1852   { mpf_init2(mp, prec); mpf_set_si(mp, c); }
1853   __gmp_expr(unsigned char c, mp_bitcnt_t prec)
1854   { mpf_init2(mp, prec); mpf_set_ui(mp, c); }
1855
1856   __gmp_expr(signed int i, mp_bitcnt_t prec)
1857   { mpf_init2(mp, prec); mpf_set_si(mp, i); }
1858   __gmp_expr(unsigned int i, mp_bitcnt_t prec)
1859   { mpf_init2(mp, prec); mpf_set_ui(mp, i); }
1860
1861   __gmp_expr(signed short int s, mp_bitcnt_t prec)
1862   { mpf_init2(mp, prec); mpf_set_si(mp, s); }
1863   __gmp_expr(unsigned short int s, mp_bitcnt_t prec)
1864   { mpf_init2(mp, prec); mpf_set_ui(mp, s); }
1865
1866   __gmp_expr(signed long int l, mp_bitcnt_t prec)
1867   { mpf_init2(mp, prec); mpf_set_si(mp, l); }
1868   __gmp_expr(unsigned long int l, mp_bitcnt_t prec)
1869   { mpf_init2(mp, prec); mpf_set_ui(mp, l); }
1870
1871   __gmp_expr(float f, mp_bitcnt_t prec)
1872   { mpf_init2(mp, prec); mpf_set_d(mp, f); }
1873   __gmp_expr(double d, mp_bitcnt_t prec)
1874   { mpf_init2(mp, prec); mpf_set_d(mp, d); }
1875   // __gmp_expr(long double ld) { mpf_init_set_d(mp, ld); }
1876   // __gmp_expr(long double ld, mp_bitcnt_t prec)
1877   // { mpf_init2(mp, prec); mpf_set_d(mp, ld); }
1878
1879   explicit __gmp_expr(const char *s)
1880   {
1881     if (mpf_init_set_str (mp, s, 0) != 0)
1882       {
1883         mpf_clear (mp);
1884         throw std::invalid_argument ("mpf_set_str");
1885       }
1886   }
1887   __gmp_expr(const char *s, mp_bitcnt_t prec, int base = 0)
1888   {
1889     mpf_init2(mp, prec);
1890     if (mpf_set_str(mp, s, base) != 0)
1891       {
1892         mpf_clear (mp);
1893         throw std::invalid_argument ("mpf_set_str");
1894       }
1895   }
1896   explicit __gmp_expr(const std::string &s)
1897   {
1898     if (mpf_init_set_str(mp, s.c_str(), 0) != 0)
1899       {
1900         mpf_clear (mp);
1901         throw std::invalid_argument ("mpf_set_str");
1902       }
1903   }
1904   __gmp_expr(const std::string &s, mp_bitcnt_t prec, int base = 0)
1905   {
1906     mpf_init2(mp, prec);
1907     if (mpf_set_str(mp, s.c_str(), base) != 0)
1908       {
1909         mpf_clear (mp);
1910         throw std::invalid_argument ("mpf_set_str");
1911       }
1912   }
1913
1914   explicit __gmp_expr(mpf_srcptr f)
1915   { mpf_init2(mp, mpf_get_prec(f)); mpf_set(mp, f); }
1916   __gmp_expr(mpf_srcptr f, mp_bitcnt_t prec)
1917   { mpf_init2(mp, prec); mpf_set(mp, f); }
1918
1919   ~__gmp_expr() { mpf_clear(mp); }
1920
1921   void swap(__gmp_expr& f) __GMPXX_NOEXCEPT { std::swap(*mp, *f.mp); }
1922
1923   // assignment operators
1924   __gmp_expr & operator=(const __gmp_expr &f)
1925   { mpf_set(mp, f.mp); return *this; }
1926 #if __GMPXX_USE_CXX11
1927   __gmp_expr & operator=(__gmp_expr &&f) noexcept
1928   { swap(f); return *this; }
1929 #endif
1930   template <class T, class U>
1931   __gmp_expr<value_type, value_type> & operator=(const __gmp_expr<T, U> &expr)
1932   { __gmp_set_expr(mp, expr); return *this; }
1933
1934   __GMPXX_DEFINE_ARITHMETIC_ASSIGNMENTS
1935
1936   __gmp_expr & operator=(const char *s)
1937   {
1938     if (mpf_set_str (mp, s, 0) != 0)
1939       throw std::invalid_argument ("mpf_set_str");
1940     return *this;
1941   }
1942   __gmp_expr & operator=(const std::string &s)
1943   {
1944     if (mpf_set_str(mp, s.c_str(), 0) != 0)
1945       throw std::invalid_argument ("mpf_set_str");
1946     return *this;
1947   }
1948
1949   // string input/output functions
1950   int set_str(const char *s, int base)
1951   { return mpf_set_str(mp, s, base); }
1952   int set_str(const std::string &s, int base)
1953   { return mpf_set_str(mp, s.c_str(), base); }
1954   std::string get_str(mp_exp_t &expo, int base = 10, size_t size = 0) const
1955   {
1956     __gmp_alloc_cstring temp(mpf_get_str(0, &expo, base, size, mp));
1957     return std::string(temp.str);
1958   }
1959
1960   // conversion functions
1961   mpf_srcptr __get_mp() const { return mp; }
1962   mpf_ptr __get_mp() { return mp; }
1963   mpf_srcptr get_mpf_t() const { return mp; }
1964   mpf_ptr get_mpf_t() { return mp; }
1965
1966   signed long int get_si() const { return mpf_get_si(mp); }
1967   unsigned long int get_ui() const { return mpf_get_ui(mp); }
1968   double get_d() const { return mpf_get_d(mp); }
1969
1970   // bool fits_schar_p() const { return mpf_fits_schar_p(mp); }
1971   // bool fits_uchar_p() const { return mpf_fits_uchar_p(mp); }
1972   bool fits_sint_p() const { return mpf_fits_sint_p(mp); }
1973   bool fits_uint_p() const { return mpf_fits_uint_p(mp); }
1974   bool fits_sshort_p() const { return mpf_fits_sshort_p(mp); }
1975   bool fits_ushort_p() const { return mpf_fits_ushort_p(mp); }
1976   bool fits_slong_p() const { return mpf_fits_slong_p(mp); }
1977   bool fits_ulong_p() const { return mpf_fits_ulong_p(mp); }
1978   // bool fits_float_p() const { return mpf_fits_float_p(mp); }
1979   // bool fits_double_p() const { return mpf_fits_double_p(mp); }
1980   // bool fits_ldouble_p() const { return mpf_fits_ldouble_p(mp); }
1981
1982 #if __GMPXX_USE_CXX11
1983   explicit operator bool() const { return mp->_mp_size != 0; }
1984 #endif
1985
1986   // compound assignments
1987   __GMP_DECLARE_COMPOUND_OPERATOR(operator+=)
1988   __GMP_DECLARE_COMPOUND_OPERATOR(operator-=)
1989   __GMP_DECLARE_COMPOUND_OPERATOR(operator*=)
1990   __GMP_DECLARE_COMPOUND_OPERATOR(operator/=)
1991
1992   __GMP_DECLARE_COMPOUND_OPERATOR_UI(operator<<=)
1993   __GMP_DECLARE_COMPOUND_OPERATOR_UI(operator>>=)
1994
1995   __GMP_DECLARE_INCREMENT_OPERATOR(operator++)
1996   __GMP_DECLARE_INCREMENT_OPERATOR(operator--)
1997 };
1998
1999 typedef __gmp_expr<mpf_t, mpf_t> mpf_class;
2000
2001
2002
2003 /**************** User-defined literals ****************/
2004
2005 #if __GMPXX_USE_CXX11
2006 inline mpz_class operator"" _mpz(const char* s)
2007 {
2008   return mpz_class(s);
2009 }
2010
2011 inline mpq_class operator"" _mpq(const char* s)
2012 {
2013   mpq_class q;
2014   q.get_num() = s;
2015   return q;
2016 }
2017
2018 inline mpf_class operator"" _mpf(const char* s)
2019 {
2020   return mpf_class(s);
2021 }
2022 #endif
2023
2024 /**************** I/O operators ****************/
2025
2026 // these should (and will) be provided separately
2027
2028 template <class T, class U>
2029 inline std::ostream & operator<<
2030 (std::ostream &o, const __gmp_expr<T, U> &expr)
2031 {
2032   __gmp_expr<T, T> const& temp(expr);
2033   return o << temp.__get_mp();
2034 }
2035
2036 template <class T>
2037 inline std::istream & operator>>(std::istream &i, __gmp_expr<T, T> &expr)
2038 {
2039   return i >> expr.__get_mp();
2040 }
2041
2042 /*
2043 // you might want to uncomment this
2044 inline std::istream & operator>>(std::istream &i, mpq_class &q)
2045 {
2046   i >> q.get_mpq_t();
2047   q.canonicalize();
2048   return i;
2049 }
2050 */
2051
2052
2053 /**************** Functions for type conversion ****************/
2054
2055 inline void __gmp_set_expr(mpz_ptr z, const mpz_class &w)
2056 {
2057   mpz_set(z, w.get_mpz_t());
2058 }
2059
2060 template <class T>
2061 inline void __gmp_set_expr(mpz_ptr z, const __gmp_expr<mpz_t, T> &expr)
2062 {
2063   expr.eval(z);
2064 }
2065
2066 template <class T>
2067 inline void __gmp_set_expr(mpz_ptr z, const __gmp_expr<mpq_t, T> &expr)
2068 {
2069   mpq_class const& temp(expr);
2070   mpz_set_q(z, temp.get_mpq_t());
2071 }
2072
2073 template <class T>
2074 inline void __gmp_set_expr(mpz_ptr z, const __gmp_expr<mpf_t, T> &expr)
2075 {
2076   mpf_class const& temp(expr);
2077   mpz_set_f(z, temp.get_mpf_t());
2078 }
2079
2080 inline void __gmp_set_expr(mpq_ptr q, const mpz_class &z)
2081 {
2082   mpq_set_z(q, z.get_mpz_t());
2083 }
2084
2085 template <class T>
2086 inline void __gmp_set_expr(mpq_ptr q, const __gmp_expr<mpz_t, T> &expr)
2087 {
2088   __gmp_set_expr(mpq_numref(q), expr);
2089   mpz_set_ui(mpq_denref(q), 1);
2090 }
2091
2092 inline void __gmp_set_expr(mpq_ptr q, const mpq_class &r)
2093 {
2094   mpq_set(q, r.get_mpq_t());
2095 }
2096
2097 template <class T>
2098 inline void __gmp_set_expr(mpq_ptr q, const __gmp_expr<mpq_t, T> &expr)
2099 {
2100   expr.eval(q);
2101 }
2102
2103 template <class T>
2104 inline void __gmp_set_expr(mpq_ptr q, const __gmp_expr<mpf_t, T> &expr)
2105 {
2106   mpf_class const& temp(expr);
2107   mpq_set_f(q, temp.get_mpf_t());
2108 }
2109
2110 template <class T>
2111 inline void __gmp_set_expr(mpf_ptr f, const __gmp_expr<mpz_t, T> &expr)
2112 {
2113   mpz_class const& temp(expr);
2114   mpf_set_z(f, temp.get_mpz_t());
2115 }
2116
2117 template <class T>
2118 inline void __gmp_set_expr(mpf_ptr f, const __gmp_expr<mpq_t, T> &expr)
2119 {
2120   mpq_class const& temp(expr);
2121   mpf_set_q(f, temp.get_mpq_t());
2122 }
2123
2124 inline void __gmp_set_expr(mpf_ptr f, const mpf_class &g)
2125 {
2126   mpf_set(f, g.get_mpf_t());
2127 }
2128
2129 template <class T>
2130 inline void __gmp_set_expr(mpf_ptr f, const __gmp_expr<mpf_t, T> &expr)
2131 {
2132   expr.eval(f);
2133 }
2134
2135
2136 /* Temporary objects */
2137
2138 template <class T>
2139 class __gmp_temp
2140 {
2141   __gmp_expr<T, T> val;
2142   public:
2143   template<class U, class V>
2144   __gmp_temp(U const& u, V) : val (u) {}
2145   typename __gmp_resolve_expr<T>::srcptr_type
2146   __get_mp() const { return val.__get_mp(); }
2147 };
2148
2149 template <>
2150 class __gmp_temp <mpf_t>
2151 {
2152   mpf_class val;
2153   public:
2154   template<class U>
2155   __gmp_temp(U const& u, mpf_ptr res) : val (u, mpf_get_prec(res)) {}
2156   mpf_srcptr __get_mp() const { return val.__get_mp(); }
2157 };
2158
2159 /**************** Specializations of __gmp_expr ****************/
2160 /* The eval() method of __gmp_expr<T, U> evaluates the corresponding
2161    expression and assigns the result to its argument, which is either an
2162    mpz_t, mpq_t, or mpf_t as specified by the T argument.
2163    Compound expressions are evaluated recursively (temporaries are created
2164    to hold intermediate values), while for simple expressions the eval()
2165    method of the appropriate function object (available as the Op argument
2166    of either __gmp_unary_expr<T, Op> or __gmp_binary_expr<T, U, Op>) is
2167    called. */
2168
2169
2170 /**************** Unary expressions ****************/
2171 /* cases:
2172    - simple:   argument is mp*_class, that is, __gmp_expr<T, T>
2173    - compound: argument is __gmp_expr<T, U> (with U not equal to T) */
2174
2175
2176 // simple expressions
2177
2178 template <class T, class Op>
2179 class __gmp_expr<T, __gmp_unary_expr<__gmp_expr<T, T>, Op> >
2180 {
2181 private:
2182   typedef __gmp_expr<T, T> val_type;
2183
2184   __gmp_unary_expr<val_type, Op> expr;
2185 public:
2186   explicit __gmp_expr(const val_type &val) : expr(val) { }
2187   void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2188   { Op::eval(p, expr.val.__get_mp()); }
2189   const val_type & get_val() const { return expr.val; }
2190   mp_bitcnt_t get_prec() const { return expr.val.get_prec(); }
2191 };
2192
2193
2194 // simple expressions, U is a built-in numerical type
2195
2196 template <class T, class U, class Op>
2197 class __gmp_expr<T, __gmp_unary_expr<U, Op> >
2198 {
2199 private:
2200   typedef U val_type;
2201
2202   __gmp_unary_expr<val_type, Op> expr;
2203 public:
2204   explicit __gmp_expr(const val_type &val) : expr(val) { }
2205   void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2206   { Op::eval(p, expr.val); }
2207   const val_type & get_val() const { return expr.val; }
2208   mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); }
2209 };
2210
2211
2212 // compound expressions
2213
2214 template <class T, class U, class Op>
2215 class __gmp_expr<T, __gmp_unary_expr<__gmp_expr<T, U>, Op> >
2216 {
2217 private:
2218   typedef __gmp_expr<T, U> val_type;
2219
2220   __gmp_unary_expr<val_type, Op> expr;
2221 public:
2222   explicit __gmp_expr(const val_type &val) : expr(val) { }
2223   void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2224   { expr.val.eval(p); Op::eval(p, p); }
2225   const val_type & get_val() const { return expr.val; }
2226   mp_bitcnt_t get_prec() const { return expr.val.get_prec(); }
2227 };
2228
2229
2230 /**************** Binary expressions ****************/
2231 /* simple:
2232    - arguments are both mp*_class
2233    - one argument is mp*_class, one is a built-in type
2234    compound:
2235    - one is mp*_class, one is __gmp_expr<T, U>
2236    - one is __gmp_expr<T, U>, one is built-in
2237    - both arguments are __gmp_expr<...> */
2238
2239
2240 // simple expressions
2241
2242 template <class T, class Op>
2243 class __gmp_expr
2244 <T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, T>, Op> >
2245 {
2246 private:
2247   typedef __gmp_expr<T, T> val1_type;
2248   typedef __gmp_expr<T, T> val2_type;
2249
2250   __gmp_binary_expr<val1_type, val2_type, Op> expr;
2251 public:
2252   __gmp_expr(const val1_type &val1, const val2_type &val2)
2253     : expr(val1, val2) { }
2254   void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2255   { Op::eval(p, expr.val1.__get_mp(), expr.val2.__get_mp()); }
2256   const val1_type & get_val1() const { return expr.val1; }
2257   const val2_type & get_val2() const { return expr.val2; }
2258   mp_bitcnt_t get_prec() const
2259   {
2260     mp_bitcnt_t prec1 = expr.val1.get_prec(),
2261       prec2 = expr.val2.get_prec();
2262     return (prec1 > prec2) ? prec1 : prec2;
2263   }
2264 };
2265
2266
2267 // simple expressions, U is a built-in numerical type
2268
2269 template <class T, class U, class Op>
2270 class __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, U, Op> >
2271 {
2272 private:
2273   typedef __gmp_expr<T, T> val1_type;
2274   typedef U val2_type;
2275
2276   __gmp_binary_expr<val1_type, val2_type, Op> expr;
2277 public:
2278   __gmp_expr(const val1_type &val1, const val2_type &val2)
2279     : expr(val1, val2) { }
2280   void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2281   { Op::eval(p, expr.val1.__get_mp(), expr.val2); }
2282   const val1_type & get_val1() const { return expr.val1; }
2283   const val2_type & get_val2() const { return expr.val2; }
2284   mp_bitcnt_t get_prec() const { return expr.val1.get_prec(); }
2285 };
2286
2287 template <class T, class U, class Op>
2288 class __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, T>, Op> >
2289 {
2290 private:
2291   typedef U val1_type;
2292   typedef __gmp_expr<T, T> val2_type;
2293
2294   __gmp_binary_expr<val1_type, val2_type, Op> expr;
2295 public:
2296   __gmp_expr(const val1_type &val1, const val2_type &val2)
2297     : expr(val1, val2) { }
2298   void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2299   { Op::eval(p, expr.val1, expr.val2.__get_mp()); }
2300   const val1_type & get_val1() const { return expr.val1; }
2301   const val2_type & get_val2() const { return expr.val2; }
2302   mp_bitcnt_t get_prec() const { return expr.val2.get_prec(); }
2303 };
2304
2305
2306 // compound expressions, one argument is a subexpression
2307
2308 template <class T, class U, class V, class Op>
2309 class __gmp_expr
2310 <T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<U, V>, Op> >
2311 {
2312 private:
2313   typedef __gmp_expr<T, T> val1_type;
2314   typedef __gmp_expr<U, V> val2_type;
2315
2316   __gmp_binary_expr<val1_type, val2_type, Op> expr;
2317 public:
2318   __gmp_expr(const val1_type &val1, const val2_type &val2)
2319     : expr(val1, val2) { }
2320   void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2321   {
2322     if(p != expr.val1.__get_mp())
2323     {
2324       __gmp_set_expr(p, expr.val2);
2325       Op::eval(p, expr.val1.__get_mp(), p);
2326     }
2327     else
2328     {
2329       __gmp_temp<T> temp(expr.val2, p);
2330       Op::eval(p, expr.val1.__get_mp(), temp.__get_mp());
2331     }
2332   }
2333   const val1_type & get_val1() const { return expr.val1; }
2334   const val2_type & get_val2() const { return expr.val2; }
2335   mp_bitcnt_t get_prec() const
2336   {
2337     mp_bitcnt_t prec1 = expr.val1.get_prec(),
2338       prec2 = expr.val2.get_prec();
2339     return (prec1 > prec2) ? prec1 : prec2;
2340   }
2341 };
2342
2343 template <class T, class U, class V, class Op>
2344 class __gmp_expr
2345 <T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, T>, Op> >
2346 {
2347 private:
2348   typedef __gmp_expr<U, V> val1_type;
2349   typedef __gmp_expr<T, T> val2_type;
2350
2351   __gmp_binary_expr<val1_type, val2_type, Op> expr;
2352 public:
2353   __gmp_expr(const val1_type &val1, const val2_type &val2)
2354     : expr(val1, val2) { }
2355   void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2356   {
2357     if(p != expr.val2.__get_mp())
2358     {
2359       __gmp_set_expr(p, expr.val1);
2360       Op::eval(p, p, expr.val2.__get_mp());
2361     }
2362     else
2363     {
2364       __gmp_temp<T> temp(expr.val1, p);
2365       Op::eval(p, temp.__get_mp(), expr.val2.__get_mp());
2366     }
2367   }
2368   const val1_type & get_val1() const { return expr.val1; }
2369   const val2_type & get_val2() const { return expr.val2; }
2370   mp_bitcnt_t get_prec() const
2371   {
2372     mp_bitcnt_t prec1 = expr.val1.get_prec(),
2373       prec2 = expr.val2.get_prec();
2374     return (prec1 > prec2) ? prec1 : prec2;
2375   }
2376 };
2377
2378 template <class T, class U, class Op>
2379 class __gmp_expr
2380 <T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, U>, Op> >
2381 {
2382 private:
2383   typedef __gmp_expr<T, T> val1_type;
2384   typedef __gmp_expr<T, U> val2_type;
2385
2386   __gmp_binary_expr<val1_type, val2_type, Op> expr;
2387 public:
2388   __gmp_expr(const val1_type &val1, const val2_type &val2)
2389     : expr(val1, val2) { }
2390   void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2391   {
2392     if(p != expr.val1.__get_mp())
2393     {
2394       __gmp_set_expr(p, expr.val2);
2395       Op::eval(p, expr.val1.__get_mp(), p);
2396     }
2397     else
2398     {
2399       __gmp_temp<T> temp(expr.val2, p);
2400       Op::eval(p, expr.val1.__get_mp(), temp.__get_mp());
2401     }
2402   }
2403   const val1_type & get_val1() const { return expr.val1; }
2404   const val2_type & get_val2() const { return expr.val2; }
2405   mp_bitcnt_t get_prec() const
2406   {
2407     mp_bitcnt_t prec1 = expr.val1.get_prec(),
2408       prec2 = expr.val2.get_prec();
2409     return (prec1 > prec2) ? prec1 : prec2;
2410   }
2411 };
2412
2413 template <class T, class U, class Op>
2414 class __gmp_expr
2415 <T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, T>, Op> >
2416 {
2417 private:
2418   typedef __gmp_expr<T, U> val1_type;
2419   typedef __gmp_expr<T, T> val2_type;
2420
2421   __gmp_binary_expr<val1_type, val2_type, Op> expr;
2422 public:
2423   __gmp_expr(const val1_type &val1, const val2_type &val2)
2424     : expr(val1, val2) { }
2425   void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2426   {
2427     if(p != expr.val2.__get_mp())
2428     {
2429       __gmp_set_expr(p, expr.val1);
2430       Op::eval(p, p, expr.val2.__get_mp());
2431     }
2432     else
2433     {
2434       __gmp_temp<T> temp(expr.val1, p);
2435       Op::eval(p, temp.__get_mp(), expr.val2.__get_mp());
2436     }
2437   }
2438   const val1_type & get_val1() const { return expr.val1; }
2439   const val2_type & get_val2() const { return expr.val2; }
2440   mp_bitcnt_t get_prec() const
2441   {
2442     mp_bitcnt_t prec1 = expr.val1.get_prec(),
2443       prec2 = expr.val2.get_prec();
2444     return (prec1 > prec2) ? prec1 : prec2;
2445   }
2446 };
2447
2448
2449 // one argument is a subexpression, one is a built-in
2450
2451 template <class T, class U, class V, class Op>
2452 class __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, V, Op> >
2453 {
2454 private:
2455   typedef __gmp_expr<T, U> val1_type;
2456   typedef V val2_type;
2457
2458   __gmp_binary_expr<val1_type, val2_type, Op> expr;
2459 public:
2460   __gmp_expr(const val1_type &val1, const val2_type &val2)
2461     : expr(val1, val2) { }
2462   void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2463   {
2464     expr.val1.eval(p);
2465     Op::eval(p, p, expr.val2);
2466   }
2467   const val1_type & get_val1() const { return expr.val1; }
2468   const val2_type & get_val2() const { return expr.val2; }
2469   mp_bitcnt_t get_prec() const { return expr.val1.get_prec(); }
2470 };
2471
2472 template <class T, class U, class V, class Op>
2473 class __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, V>, Op> >
2474 {
2475 private:
2476   typedef U val1_type;
2477   typedef __gmp_expr<T, V> val2_type;
2478
2479   __gmp_binary_expr<val1_type, val2_type, Op> expr;
2480 public:
2481   __gmp_expr(const val1_type &val1, const val2_type &val2)
2482     : expr(val1, val2) { }
2483   void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2484   {
2485     expr.val2.eval(p);
2486     Op::eval(p, expr.val1, p);
2487   }
2488   const val1_type & get_val1() const { return expr.val1; }
2489   const val2_type & get_val2() const { return expr.val2; }
2490   mp_bitcnt_t get_prec() const { return expr.val2.get_prec(); }
2491 };
2492
2493
2494 // both arguments are subexpressions
2495
2496 template <class T, class U, class V, class W, class Op>
2497 class __gmp_expr
2498 <T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
2499 {
2500 private:
2501   typedef __gmp_expr<T, U> val1_type;
2502   typedef __gmp_expr<V, W> val2_type;
2503
2504   __gmp_binary_expr<val1_type, val2_type, Op> expr;
2505 public:
2506   __gmp_expr(const val1_type &val1, const val2_type &val2)
2507     : expr(val1, val2) { }
2508   void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2509   {
2510     __gmp_temp<T> temp2(expr.val2, p);
2511     expr.val1.eval(p);
2512     Op::eval(p, p, temp2.__get_mp());
2513   }
2514   const val1_type & get_val1() const { return expr.val1; }
2515   const val2_type & get_val2() const { return expr.val2; }
2516   mp_bitcnt_t get_prec() const
2517   {
2518     mp_bitcnt_t prec1 = expr.val1.get_prec(),
2519       prec2 = expr.val2.get_prec();
2520     return (prec1 > prec2) ? prec1 : prec2;
2521   }
2522 };
2523
2524 template <class T, class U, class V, class W, class Op>
2525 class __gmp_expr
2526 <T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, W>, Op> >
2527 {
2528 private:
2529   typedef __gmp_expr<U, V> val1_type;
2530   typedef __gmp_expr<T, W> val2_type;
2531
2532   __gmp_binary_expr<val1_type, val2_type, Op> expr;
2533 public:
2534   __gmp_expr(const val1_type &val1, const val2_type &val2)
2535     : expr(val1, val2) { }
2536   void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2537   {
2538     __gmp_temp<T> temp1(expr.val1, p);
2539     expr.val2.eval(p);
2540     Op::eval(p, temp1.__get_mp(), p);
2541   }
2542   const val1_type & get_val1() const { return expr.val1; }
2543   const val2_type & get_val2() const { return expr.val2; }
2544   mp_bitcnt_t get_prec() const
2545   {
2546     mp_bitcnt_t prec1 = expr.val1.get_prec(),
2547       prec2 = expr.val2.get_prec();
2548     return (prec1 > prec2) ? prec1 : prec2;
2549   }
2550 };
2551
2552 template <class T, class U, class V, class Op>
2553 class __gmp_expr
2554 <T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, V>, Op> >
2555 {
2556 private:
2557   typedef __gmp_expr<T, U> val1_type;
2558   typedef __gmp_expr<T, V> val2_type;
2559
2560   __gmp_binary_expr<val1_type, val2_type, Op> expr;
2561 public:
2562   __gmp_expr(const val1_type &val1, const val2_type &val2)
2563     : expr(val1, val2) { }
2564   void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2565   {
2566     __gmp_temp<T> temp2(expr.val2, p);
2567     expr.val1.eval(p);
2568     Op::eval(p, p, temp2.__get_mp());
2569   }
2570   const val1_type & get_val1() const { return expr.val1; }
2571   const val2_type & get_val2() const { return expr.val2; }
2572   mp_bitcnt_t get_prec() const
2573   {
2574     mp_bitcnt_t prec1 = expr.val1.get_prec(),
2575       prec2 = expr.val2.get_prec();
2576     return (prec1 > prec2) ? prec1 : prec2;
2577   }
2578 };
2579
2580
2581 /**************** Special cases ****************/
2582
2583 /* Some operations (i.e., add and subtract) with mixed mpz/mpq arguments
2584    can be done directly without first converting the mpz to mpq.
2585    Appropriate specializations of __gmp_expr are required. */
2586
2587
2588 #define __GMPZQ_DEFINE_EXPR(eval_fun)                                       \
2589                                                                             \
2590 template <>                                                                 \
2591 class __gmp_expr<mpq_t, __gmp_binary_expr<mpz_class, mpq_class, eval_fun> > \
2592 {                                                                           \
2593 private:                                                                    \
2594   typedef mpz_class val1_type;                                              \
2595   typedef mpq_class val2_type;                                              \
2596                                                                             \
2597   __gmp_binary_expr<val1_type, val2_type, eval_fun> expr;                   \
2598 public:                                                                     \
2599   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
2600     : expr(val1, val2) { }                                                  \
2601   void eval(mpq_ptr q) const                                                \
2602   { eval_fun::eval(q, expr.val1.get_mpz_t(), expr.val2.get_mpq_t()); }      \
2603   const val1_type & get_val1() const { return expr.val1; }                  \
2604   const val2_type & get_val2() const { return expr.val2; }                  \
2605   mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); }           \
2606 };                                                                          \
2607                                                                             \
2608 template <>                                                                 \
2609 class __gmp_expr<mpq_t, __gmp_binary_expr<mpq_class, mpz_class, eval_fun> > \
2610 {                                                                           \
2611 private:                                                                    \
2612   typedef mpq_class val1_type;                                              \
2613   typedef mpz_class val2_type;                                              \
2614                                                                             \
2615   __gmp_binary_expr<val1_type, val2_type, eval_fun> expr;                   \
2616 public:                                                                     \
2617   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
2618     : expr(val1, val2) { }                                                  \
2619   void eval(mpq_ptr q) const                                                \
2620   { eval_fun::eval(q, expr.val1.get_mpq_t(), expr.val2.get_mpz_t()); }      \
2621   const val1_type & get_val1() const { return expr.val1; }                  \
2622   const val2_type & get_val2() const { return expr.val2; }                  \
2623   mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); }           \
2624 };                                                                          \
2625                                                                             \
2626 template <class T>                                                          \
2627 class __gmp_expr                                                            \
2628 <mpq_t, __gmp_binary_expr<mpz_class, __gmp_expr<mpq_t, T>, eval_fun> >      \
2629 {                                                                           \
2630 private:                                                                    \
2631   typedef mpz_class val1_type;                                              \
2632   typedef __gmp_expr<mpq_t, T> val2_type;                                   \
2633                                                                             \
2634   __gmp_binary_expr<val1_type, val2_type, eval_fun> expr;                   \
2635 public:                                                                     \
2636   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
2637     : expr(val1, val2) { }                                                  \
2638   void eval(mpq_ptr q) const                                                \
2639   {                                                                         \
2640     mpq_class temp(expr.val2);                                              \
2641     eval_fun::eval(q, expr.val1.get_mpz_t(), temp.get_mpq_t());             \
2642   }                                                                         \
2643   const val1_type & get_val1() const { return expr.val1; }                  \
2644   const val2_type & get_val2() const { return expr.val2; }                  \
2645   mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); }           \
2646 };                                                                          \
2647                                                                             \
2648 template <class T>                                                          \
2649 class __gmp_expr                                                            \
2650 <mpq_t, __gmp_binary_expr<mpq_class, __gmp_expr<mpz_t, T>, eval_fun> >      \
2651 {                                                                           \
2652 private:                                                                    \
2653   typedef mpq_class val1_type;                                              \
2654   typedef __gmp_expr<mpz_t, T> val2_type;                                   \
2655                                                                             \
2656   __gmp_binary_expr<val1_type, val2_type, eval_fun> expr;                   \
2657 public:                                                                     \
2658   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
2659     : expr(val1, val2) { }                                                  \
2660   void eval(mpq_ptr q) const                                                \
2661   {                                                                         \
2662     mpz_class temp(expr.val2);                                              \
2663     eval_fun::eval(q, expr.val1.get_mpq_t(), temp.get_mpz_t());             \
2664   }                                                                         \
2665   const val1_type & get_val1() const { return expr.val1; }                  \
2666   const val2_type & get_val2() const { return expr.val2; }                  \
2667   mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); }           \
2668 };                                                                          \
2669                                                                             \
2670 template <class T>                                                          \
2671 class __gmp_expr                                                            \
2672 <mpq_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, mpq_class, eval_fun> >      \
2673 {                                                                           \
2674 private:                                                                    \
2675   typedef __gmp_expr<mpz_t, T> val1_type;                                   \
2676   typedef mpq_class val2_type;                                              \
2677                                                                             \
2678   __gmp_binary_expr<val1_type, val2_type, eval_fun> expr;                   \
2679 public:                                                                     \
2680   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
2681     : expr(val1, val2) { }                                                  \
2682   void eval(mpq_ptr q) const                                                \
2683   {                                                                         \
2684     mpz_class temp(expr.val1);                                              \
2685     eval_fun::eval(q, temp.get_mpz_t(), expr.val2.get_mpq_t());             \
2686   }                                                                         \
2687   const val1_type & get_val1() const { return expr.val1; }                  \
2688   const val2_type & get_val2() const { return expr.val2; }                  \
2689   mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); }           \
2690 };                                                                          \
2691                                                                             \
2692 template <class T>                                                          \
2693 class __gmp_expr                                                            \
2694 <mpq_t, __gmp_binary_expr<__gmp_expr<mpq_t, T>, mpz_class, eval_fun> >      \
2695 {                                                                           \
2696 private:                                                                    \
2697   typedef __gmp_expr<mpq_t, T> val1_type;                                   \
2698   typedef mpz_class val2_type;                                              \
2699                                                                             \
2700   __gmp_binary_expr<val1_type, val2_type, eval_fun> expr;                   \
2701 public:                                                                     \
2702   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
2703     : expr(val1, val2) { }                                                  \
2704   void eval(mpq_ptr q) const                                                \
2705   {                                                                         \
2706     mpq_class temp(expr.val1);                                              \
2707     eval_fun::eval(q, temp.get_mpq_t(), expr.val2.get_mpz_t());             \
2708   }                                                                         \
2709   const val1_type & get_val1() const { return expr.val1; }                  \
2710   const val2_type & get_val2() const { return expr.val2; }                  \
2711   mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); }           \
2712 };                                                                          \
2713                                                                             \
2714 template <class T, class U>                                                 \
2715 class __gmp_expr<mpq_t, __gmp_binary_expr                                   \
2716 <__gmp_expr<mpz_t, T>, __gmp_expr<mpq_t, U>, eval_fun> >                    \
2717 {                                                                           \
2718 private:                                                                    \
2719   typedef __gmp_expr<mpz_t, T> val1_type;                                   \
2720   typedef __gmp_expr<mpq_t, U> val2_type;                                   \
2721                                                                             \
2722   __gmp_binary_expr<val1_type, val2_type, eval_fun> expr;                   \
2723 public:                                                                     \
2724   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
2725     : expr(val1, val2) { }                                                  \
2726   void eval(mpq_ptr q) const                                                \
2727   {                                                                         \
2728     mpz_class temp1(expr.val1);                                             \
2729     expr.val2.eval(q);                                                      \
2730     eval_fun::eval(q, temp1.get_mpz_t(), q);                                \
2731   }                                                                         \
2732   const val1_type & get_val1() const { return expr.val1; }                  \
2733   const val2_type & get_val2() const { return expr.val2; }                  \
2734   mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); }           \
2735 };                                                                          \
2736                                                                             \
2737 template <class T, class U>                                                 \
2738 class __gmp_expr<mpq_t, __gmp_binary_expr                                   \
2739 <__gmp_expr<mpq_t, T>, __gmp_expr<mpz_t, U>, eval_fun> >                    \
2740 {                                                                           \
2741 private:                                                                    \
2742   typedef __gmp_expr<mpq_t, T> val1_type;                                   \
2743   typedef __gmp_expr<mpz_t, U> val2_type;                                   \
2744                                                                             \
2745   __gmp_binary_expr<val1_type, val2_type, eval_fun> expr;                   \
2746 public:                                                                     \
2747   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
2748     : expr(val1, val2) { }                                                  \
2749   void eval(mpq_ptr q) const                                                \
2750   {                                                                         \
2751     mpz_class temp2(expr.val2);                                             \
2752     expr.val1.eval(q);                                             \
2753     eval_fun::eval(q, q, temp2.get_mpz_t());                \
2754   }                                                                         \
2755   const val1_type & get_val1() const { return expr.val1; }                  \
2756   const val2_type & get_val2() const { return expr.val2; }                  \
2757   mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); }           \
2758 };
2759
2760
2761 __GMPZQ_DEFINE_EXPR(__gmp_binary_plus)
2762 __GMPZQ_DEFINE_EXPR(__gmp_binary_minus)
2763
2764
2765
2766 /**************** Macros for defining functions ****************/
2767 /* Results of operators and functions are instances of __gmp_expr<T, U>.
2768    T determines the numerical type of the expression: it can be either
2769    mpz_t, mpq_t, or mpf_t.  When the arguments of a binary
2770    expression have different numerical types, __gmp_resolve_expr is used
2771    to determine the "larger" type.
2772    U is either __gmp_unary_expr<V, Op> or __gmp_binary_expr<V, W, Op>,
2773    where V and W are the arguments' types -- they can in turn be
2774    expressions, thus allowing to build compound expressions to any
2775    degree of complexity.
2776    Op is a function object that must have an eval() method accepting
2777    appropriate arguments.
2778    Actual evaluation of a __gmp_expr<T, U> object is done when it gets
2779    assigned to an mp*_class ("lazy" evaluation): this is done by calling
2780    its eval() method. */
2781
2782
2783 // non-member unary operators and functions
2784
2785 #define __GMP_DEFINE_UNARY_FUNCTION(fun, eval_fun)                           \
2786                                                                              \
2787 template <class T, class U>                                                  \
2788 inline __gmp_expr<T, __gmp_unary_expr<__gmp_expr<T, U>, eval_fun> >          \
2789 fun(const __gmp_expr<T, U> &expr)                                            \
2790 {                                                                            \
2791   return __gmp_expr<T, __gmp_unary_expr<__gmp_expr<T, U>, eval_fun> >(expr); \
2792 }
2793
2794 #define __GMP_DEFINE_UNARY_TYPE_FUNCTION(type, fun, eval_fun) \
2795                                                               \
2796 template <class T, class U>                                   \
2797 inline type fun(const __gmp_expr<T, U> &expr)                 \
2798 {                                                             \
2799   __gmp_expr<T, T> const& temp(expr); \
2800   return eval_fun::eval(temp.__get_mp());                     \
2801 }
2802
2803
2804 // non-member binary operators and functions
2805
2806 #define __GMPP_DEFINE_BINARY_FUNCTION(fun, eval_fun)                   \
2807                                                                        \
2808 template <class T, class U, class V, class W>                          \
2809 inline __gmp_expr<typename __gmp_resolve_expr<T, V>::value_type,       \
2810 __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, eval_fun> >      \
2811 fun(const __gmp_expr<T, U> &expr1, const __gmp_expr<V, W> &expr2)      \
2812 {                                                                      \
2813   return __gmp_expr<typename __gmp_resolve_expr<T, V>::value_type,     \
2814      __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, eval_fun> > \
2815     (expr1, expr2);                                                    \
2816 }
2817
2818 #define __GMPNN_DEFINE_BINARY_FUNCTION(fun, eval_fun, type, bigtype)       \
2819                                                                            \
2820 template <class T, class U>                                                \
2821 inline __gmp_expr                                                          \
2822 <T, __gmp_binary_expr<__gmp_expr<T, U>, bigtype, eval_fun> >               \
2823 fun(const __gmp_expr<T, U> &expr, type t)                                  \
2824 {                                                                          \
2825   return __gmp_expr                                                        \
2826     <T, __gmp_binary_expr<__gmp_expr<T, U>, bigtype, eval_fun> >(expr, t); \
2827 }                                                                          \
2828                                                                            \
2829 template <class T, class U>                                                \
2830 inline __gmp_expr                                                          \
2831 <T, __gmp_binary_expr<bigtype, __gmp_expr<T, U>, eval_fun> >               \
2832 fun(type t, const __gmp_expr<T, U> &expr)                                  \
2833 {                                                                          \
2834   return __gmp_expr                                                        \
2835     <T, __gmp_binary_expr<bigtype, __gmp_expr<T, U>, eval_fun> >(t, expr); \
2836 }
2837
2838 #define __GMPNS_DEFINE_BINARY_FUNCTION(fun, eval_fun, type)          \
2839 __GMPNN_DEFINE_BINARY_FUNCTION(fun, eval_fun, type, signed long int)
2840
2841 #define __GMPNU_DEFINE_BINARY_FUNCTION(fun, eval_fun, type)            \
2842 __GMPNN_DEFINE_BINARY_FUNCTION(fun, eval_fun, type, unsigned long int)
2843
2844 #define __GMPND_DEFINE_BINARY_FUNCTION(fun, eval_fun, type) \
2845 __GMPNN_DEFINE_BINARY_FUNCTION(fun, eval_fun, type, double)
2846
2847 #define __GMPNLD_DEFINE_BINARY_FUNCTION(fun, eval_fun, type)     \
2848 __GMPNN_DEFINE_BINARY_FUNCTION(fun, eval_fun, type, long double)
2849
2850 #define __GMPN_DEFINE_BINARY_FUNCTION(fun, eval_fun)              \
2851 __GMPNS_DEFINE_BINARY_FUNCTION(fun, eval_fun, signed char)        \
2852 __GMPNU_DEFINE_BINARY_FUNCTION(fun, eval_fun, unsigned char)      \
2853 __GMPNS_DEFINE_BINARY_FUNCTION(fun, eval_fun, signed int)         \
2854 __GMPNU_DEFINE_BINARY_FUNCTION(fun, eval_fun, unsigned int)       \
2855 __GMPNS_DEFINE_BINARY_FUNCTION(fun, eval_fun, signed short int)   \
2856 __GMPNU_DEFINE_BINARY_FUNCTION(fun, eval_fun, unsigned short int) \
2857 __GMPNS_DEFINE_BINARY_FUNCTION(fun, eval_fun, signed long int)    \
2858 __GMPNU_DEFINE_BINARY_FUNCTION(fun, eval_fun, unsigned long int)  \
2859 __GMPND_DEFINE_BINARY_FUNCTION(fun, eval_fun, float)              \
2860 __GMPND_DEFINE_BINARY_FUNCTION(fun, eval_fun, double)             \
2861 /* __GMPNLD_DEFINE_BINARY_FUNCTION(fun, eval_fun, long double) */
2862
2863 #define __GMP_DEFINE_BINARY_FUNCTION(fun, eval_fun) \
2864 __GMPP_DEFINE_BINARY_FUNCTION(fun, eval_fun)        \
2865 __GMPN_DEFINE_BINARY_FUNCTION(fun, eval_fun)
2866
2867
2868 #define __GMP_DEFINE_BINARY_FUNCTION_UI(fun, eval_fun)                 \
2869                                                                        \
2870 template <class T, class U>                                            \
2871 inline __gmp_expr                                                      \
2872 <T, __gmp_binary_expr<__gmp_expr<T, U>, mp_bitcnt_t, eval_fun> > \
2873 fun(const __gmp_expr<T, U> &expr, mp_bitcnt_t l)                 \
2874 {                                                                      \
2875   return __gmp_expr<T, __gmp_binary_expr                               \
2876     <__gmp_expr<T, U>, mp_bitcnt_t, eval_fun> >(expr, l);        \
2877 }
2878
2879
2880 #define __GMPP_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun)         \
2881                                                                         \
2882 template <class T, class U, class V, class W>                           \
2883 inline type fun(const __gmp_expr<T, U> &expr1,                          \
2884                 const __gmp_expr<V, W> &expr2)                          \
2885 {                                                                       \
2886   __gmp_expr<T, T> const& temp1(expr1);                                 \
2887   __gmp_expr<V, V> const& temp2(expr2);                                 \
2888   return eval_fun::eval(temp1.__get_mp(), temp2.__get_mp());            \
2889 }
2890
2891 #define __GMPNN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun,   \
2892                                             type2, bigtype)        \
2893                                                                    \
2894 template <class T, class U>                                        \
2895 inline type fun(const __gmp_expr<T, U> &expr, type2 t)             \
2896 {                                                                  \
2897   __gmp_expr<T, T> const& temp(expr);      \
2898   return eval_fun::eval(temp.__get_mp(), static_cast<bigtype>(t)); \
2899 }                                                                  \
2900                                                                    \
2901 template <class T, class U>                                        \
2902 inline type fun(type2 t, const __gmp_expr<T, U> &expr)             \
2903 {                                                                  \
2904   __gmp_expr<T, T> const& temp(expr);      \
2905   return eval_fun::eval(static_cast<bigtype>(t), temp.__get_mp()); \
2906 }
2907
2908 #define __GMPNS_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, type2) \
2909 __GMPNN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun,                \
2910                                     type2, signed long int)
2911
2912 #define __GMPNU_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, type2) \
2913 __GMPNN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun,                \
2914                                     type2, unsigned long int)
2915
2916 #define __GMPND_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, type2) \
2917 __GMPNN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, type2, double)
2918
2919 #define __GMPNLD_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, type2)     \
2920 __GMPNN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, type2, long double)
2921
2922 #define __GMPN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun)              \
2923 __GMPNS_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, signed char)        \
2924 __GMPNU_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, unsigned char)      \
2925 __GMPNS_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, signed int)         \
2926 __GMPNU_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, unsigned int)       \
2927 __GMPNS_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, signed short int)   \
2928 __GMPNU_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, unsigned short int) \
2929 __GMPNS_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, signed long int)    \
2930 __GMPNU_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, unsigned long int)  \
2931 __GMPND_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, float)              \
2932 __GMPND_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, double)             \
2933 /* __GMPNLD_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, long double) */
2934
2935 #define __GMP_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun) \
2936 __GMPP_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun)        \
2937 __GMPN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun)
2938
2939
2940 // member operators
2941
2942 #define __GMPP_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun)                 \
2943                                                                              \
2944 template <class T, class U>                                                  \
2945 inline type##_class & type##_class::fun(const __gmp_expr<T, U> &expr)        \
2946 {                                                                            \
2947   __gmp_set_expr(mp, __gmp_expr<type##_t, __gmp_binary_expr                  \
2948                  <type##_class, __gmp_expr<T, U>, eval_fun> >(*this, expr)); \
2949   return *this;                                                              \
2950 }
2951
2952 #define __GMPNN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun,    \
2953                                          type2, bigtype)         \
2954                                                                  \
2955 inline type##_class & type##_class::fun(type2 t)                 \
2956 {                                                                \
2957   __gmp_set_expr(mp, __gmp_expr<type##_t, __gmp_binary_expr      \
2958                  <type##_class, bigtype, eval_fun> >(*this, t)); \
2959   return *this;                                                  \
2960 }
2961
2962 #define __GMPNS_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, type2) \
2963 __GMPNN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun,                \
2964                                  type2, signed long int)
2965
2966 #define __GMPNU_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, type2) \
2967 __GMPNN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun,                \
2968                                  type2, unsigned long int)
2969
2970 #define __GMPND_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, type2) \
2971 __GMPNN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, type2, double)
2972
2973 #define __GMPNLD_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, type2)     \
2974 __GMPNN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, type2, long double)
2975
2976 #define __GMPN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun)              \
2977 __GMPNS_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, signed char)        \
2978 __GMPNU_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, unsigned char)      \
2979 __GMPNS_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, signed int)         \
2980 __GMPNU_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, unsigned int)       \
2981 __GMPNS_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, signed short int)   \
2982 __GMPNU_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, unsigned short int) \
2983 __GMPNS_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, signed long int)    \
2984 __GMPNU_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, unsigned long int)  \
2985 __GMPND_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, float)              \
2986 __GMPND_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, double)             \
2987 /* __GMPNLD_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, long double) */
2988
2989 #define __GMP_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun) \
2990 __GMPP_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun)        \
2991 __GMPN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun)
2992
2993 #define __GMPZ_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
2994 __GMP_DEFINE_COMPOUND_OPERATOR(mpz, fun, eval_fun)
2995
2996 #define __GMPQ_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
2997 __GMP_DEFINE_COMPOUND_OPERATOR(mpq, fun, eval_fun)
2998
2999 #define __GMPF_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
3000 __GMP_DEFINE_COMPOUND_OPERATOR(mpf, fun, eval_fun)
3001
3002
3003
3004 #define __GMP_DEFINE_COMPOUND_OPERATOR_UI(type, fun, eval_fun)  \
3005                                                                 \
3006 inline type##_class & type##_class::fun(mp_bitcnt_t l)    \
3007 {                                                               \
3008   __gmp_set_expr(mp, __gmp_expr<type##_t, __gmp_binary_expr     \
3009     <type##_class, mp_bitcnt_t, eval_fun> >(*this, l));   \
3010   return *this;                                                 \
3011 }
3012
3013 #define __GMPZ_DEFINE_COMPOUND_OPERATOR_UI(fun, eval_fun) \
3014 __GMP_DEFINE_COMPOUND_OPERATOR_UI(mpz, fun, eval_fun)
3015
3016 #define __GMPQ_DEFINE_COMPOUND_OPERATOR_UI(fun, eval_fun) \
3017 __GMP_DEFINE_COMPOUND_OPERATOR_UI(mpq, fun, eval_fun)
3018
3019 #define __GMPF_DEFINE_COMPOUND_OPERATOR_UI(fun, eval_fun) \
3020 __GMP_DEFINE_COMPOUND_OPERATOR_UI(mpf, fun, eval_fun)
3021
3022
3023
3024 #define __GMP_DEFINE_INCREMENT_OPERATOR(type, fun, eval_fun) \
3025                                                              \
3026 inline type##_class & type##_class::fun()                    \
3027 {                                                            \
3028   eval_fun::eval(mp);                                        \
3029   return *this;                                              \
3030 }                                                            \
3031                                                              \
3032 inline type##_class type##_class::fun(int)                   \
3033 {                                                            \
3034   type##_class temp(*this);                                  \
3035   eval_fun::eval(mp);                                        \
3036   return temp;                                               \
3037 }
3038
3039 #define __GMPZ_DEFINE_INCREMENT_OPERATOR(fun, eval_fun) \
3040 __GMP_DEFINE_INCREMENT_OPERATOR(mpz, fun, eval_fun)
3041
3042 #define __GMPQ_DEFINE_INCREMENT_OPERATOR(fun, eval_fun) \
3043 __GMP_DEFINE_INCREMENT_OPERATOR(mpq, fun, eval_fun)
3044
3045 #define __GMPF_DEFINE_INCREMENT_OPERATOR(fun, eval_fun) \
3046 __GMP_DEFINE_INCREMENT_OPERATOR(mpf, fun, eval_fun)
3047
3048
3049
3050 /**************** Arithmetic operators and functions ****************/
3051
3052 // non-member operators and functions
3053
3054 __GMP_DEFINE_UNARY_FUNCTION(operator+, __gmp_unary_plus)
3055 __GMP_DEFINE_UNARY_FUNCTION(operator-, __gmp_unary_minus)
3056 __GMP_DEFINE_UNARY_FUNCTION(operator~, __gmp_unary_com)
3057
3058 __GMP_DEFINE_BINARY_FUNCTION(operator+, __gmp_binary_plus)
3059 __GMP_DEFINE_BINARY_FUNCTION(operator-, __gmp_binary_minus)
3060 __GMP_DEFINE_BINARY_FUNCTION(operator*, __gmp_binary_multiplies)
3061 __GMP_DEFINE_BINARY_FUNCTION(operator/, __gmp_binary_divides)
3062 __GMP_DEFINE_BINARY_FUNCTION(operator%, __gmp_binary_modulus)
3063 __GMP_DEFINE_BINARY_FUNCTION(operator&, __gmp_binary_and)
3064 __GMP_DEFINE_BINARY_FUNCTION(operator|, __gmp_binary_ior)
3065 __GMP_DEFINE_BINARY_FUNCTION(operator^, __gmp_binary_xor)
3066
3067 __GMP_DEFINE_BINARY_FUNCTION_UI(operator<<, __gmp_binary_lshift)
3068 __GMP_DEFINE_BINARY_FUNCTION_UI(operator>>, __gmp_binary_rshift)
3069
3070 __GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator==, __gmp_binary_equal)
3071 __GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator!=, ! __gmp_binary_equal)
3072 __GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator<, __gmp_binary_less)
3073 __GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator<=, ! __gmp_binary_greater)
3074 __GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator>, __gmp_binary_greater)
3075 __GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator>=, ! __gmp_binary_less)
3076
3077 __GMP_DEFINE_UNARY_FUNCTION(abs, __gmp_abs_function)
3078 __GMP_DEFINE_UNARY_FUNCTION(trunc, __gmp_trunc_function)
3079 __GMP_DEFINE_UNARY_FUNCTION(floor, __gmp_floor_function)
3080 __GMP_DEFINE_UNARY_FUNCTION(ceil, __gmp_ceil_function)
3081 __GMP_DEFINE_UNARY_FUNCTION(sqrt, __gmp_sqrt_function)
3082 __GMP_DEFINE_BINARY_FUNCTION(hypot, __gmp_hypot_function)
3083 __GMP_DEFINE_BINARY_FUNCTION(gcd, __gmp_gcd_function)
3084 __GMP_DEFINE_BINARY_FUNCTION(lcm, __gmp_lcm_function)
3085
3086 __GMP_DEFINE_UNARY_TYPE_FUNCTION(int, sgn, __gmp_sgn_function)
3087 __GMP_DEFINE_BINARY_TYPE_FUNCTION(int, cmp, __gmp_cmp_function)
3088
3089 template <class T>
3090 void swap(__gmp_expr<T, T>& x, __gmp_expr<T, T>& y) __GMPXX_NOEXCEPT
3091 { x.swap(y); }
3092
3093 // member operators for mpz_class
3094
3095 __GMPZ_DEFINE_COMPOUND_OPERATOR(operator+=, __gmp_binary_plus)
3096 __GMPZ_DEFINE_COMPOUND_OPERATOR(operator-=, __gmp_binary_minus)
3097 __GMPZ_DEFINE_COMPOUND_OPERATOR(operator*=, __gmp_binary_multiplies)
3098 __GMPZ_DEFINE_COMPOUND_OPERATOR(operator/=, __gmp_binary_divides)
3099 __GMPZ_DEFINE_COMPOUND_OPERATOR(operator%=, __gmp_binary_modulus)
3100
3101 __GMPZ_DEFINE_COMPOUND_OPERATOR(operator&=, __gmp_binary_and)
3102 __GMPZ_DEFINE_COMPOUND_OPERATOR(operator|=, __gmp_binary_ior)
3103 __GMPZ_DEFINE_COMPOUND_OPERATOR(operator^=, __gmp_binary_xor)
3104
3105 __GMPZ_DEFINE_COMPOUND_OPERATOR_UI(operator<<=, __gmp_binary_lshift)
3106 __GMPZ_DEFINE_COMPOUND_OPERATOR_UI(operator>>=, __gmp_binary_rshift)
3107
3108 __GMPZ_DEFINE_INCREMENT_OPERATOR(operator++, __gmp_unary_increment)
3109 __GMPZ_DEFINE_INCREMENT_OPERATOR(operator--, __gmp_unary_decrement)
3110
3111 // member operators for mpq_class
3112
3113 __GMPQ_DEFINE_COMPOUND_OPERATOR(operator+=, __gmp_binary_plus)
3114 __GMPQ_DEFINE_COMPOUND_OPERATOR(operator-=, __gmp_binary_minus)
3115 __GMPQ_DEFINE_COMPOUND_OPERATOR(operator*=, __gmp_binary_multiplies)
3116 __GMPQ_DEFINE_COMPOUND_OPERATOR(operator/=, __gmp_binary_divides)
3117
3118 __GMPQ_DEFINE_COMPOUND_OPERATOR_UI(operator<<=, __gmp_binary_lshift)
3119 __GMPQ_DEFINE_COMPOUND_OPERATOR_UI(operator>>=, __gmp_binary_rshift)
3120
3121 __GMPQ_DEFINE_INCREMENT_OPERATOR(operator++, __gmp_unary_increment)
3122 __GMPQ_DEFINE_INCREMENT_OPERATOR(operator--, __gmp_unary_decrement)
3123
3124 // member operators for mpf_class
3125
3126 __GMPF_DEFINE_COMPOUND_OPERATOR(operator+=, __gmp_binary_plus)
3127 __GMPF_DEFINE_COMPOUND_OPERATOR(operator-=, __gmp_binary_minus)
3128 __GMPF_DEFINE_COMPOUND_OPERATOR(operator*=, __gmp_binary_multiplies)
3129 __GMPF_DEFINE_COMPOUND_OPERATOR(operator/=, __gmp_binary_divides)
3130
3131 __GMPF_DEFINE_COMPOUND_OPERATOR_UI(operator<<=, __gmp_binary_lshift)
3132 __GMPF_DEFINE_COMPOUND_OPERATOR_UI(operator>>=, __gmp_binary_rshift)
3133
3134 __GMPF_DEFINE_INCREMENT_OPERATOR(operator++, __gmp_unary_increment)
3135 __GMPF_DEFINE_INCREMENT_OPERATOR(operator--, __gmp_unary_decrement)
3136
3137
3138
3139 /**************** Class wrapper for gmp_randstate_t ****************/
3140
3141 class __gmp_urandomb_value { };
3142 class __gmp_urandomm_value { };
3143
3144 template <>
3145 class __gmp_expr<mpz_t, __gmp_urandomb_value>
3146 {
3147 private:
3148   __gmp_randstate_struct *state;
3149   mp_bitcnt_t bits;
3150 public:
3151   __gmp_expr(gmp_randstate_t s, mp_bitcnt_t l) : state(s), bits(l) { }
3152   void eval(mpz_ptr z) const { __gmp_rand_function::eval(z, state, bits); }
3153   mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); }
3154 };
3155
3156 template <>
3157 class __gmp_expr<mpz_t, __gmp_urandomm_value>
3158 {
3159 private:
3160   __gmp_randstate_struct *state;
3161   mpz_class range;
3162 public:
3163   __gmp_expr(gmp_randstate_t s, const mpz_class &z) : state(s), range(z) { }
3164   void eval(mpz_ptr z) const
3165   { __gmp_rand_function::eval(z, state, range.get_mpz_t()); }
3166   mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); }
3167 };
3168
3169 template <>
3170 class __gmp_expr<mpf_t, __gmp_urandomb_value>
3171 {
3172 private:
3173   __gmp_randstate_struct *state;
3174   mp_bitcnt_t bits;
3175 public:
3176   __gmp_expr(gmp_randstate_t s, mp_bitcnt_t l) : state(s), bits(l) { }
3177   void eval(mpf_ptr f) const
3178   {
3179     __gmp_rand_function::eval(f, state,
3180         (bits>0) ? bits : mpf_get_prec(f));
3181   }
3182   mp_bitcnt_t get_prec() const
3183   {
3184     if (bits == 0)
3185       return mpf_get_default_prec();
3186     else
3187       return bits;
3188   }
3189 };
3190
3191 extern "C" {
3192   typedef void __gmp_randinit_default_t (gmp_randstate_t);
3193   typedef void __gmp_randinit_lc_2exp_t (gmp_randstate_t, mpz_srcptr, unsigned long int, mp_bitcnt_t);
3194   typedef int __gmp_randinit_lc_2exp_size_t (gmp_randstate_t, mp_bitcnt_t);
3195 }
3196
3197 class gmp_randclass
3198 {
3199 private:
3200   gmp_randstate_t state;
3201
3202   // copy construction and assignment not allowed
3203   gmp_randclass(const gmp_randclass &);
3204   void operator=(const gmp_randclass &);
3205 public:
3206   // constructors and destructor
3207   gmp_randclass(gmp_randalg_t alg, unsigned long int size)
3208   {
3209     switch (alg)
3210       {
3211       case GMP_RAND_ALG_LC: // no other cases for now
3212       default:
3213         gmp_randinit(state, alg, size);
3214         break;
3215       }
3216   }
3217
3218   // gmp_randinit_default
3219   gmp_randclass(__gmp_randinit_default_t* f) { f(state); }
3220
3221   // gmp_randinit_lc_2exp
3222   gmp_randclass(__gmp_randinit_lc_2exp_t* f,
3223                 mpz_class z, unsigned long int l1, mp_bitcnt_t l2)
3224   { f(state, z.get_mpz_t(), l1, l2); }
3225
3226   // gmp_randinit_lc_2exp_size
3227   gmp_randclass(__gmp_randinit_lc_2exp_size_t* f,
3228                 mp_bitcnt_t size)
3229   {
3230     if (f (state, size) == 0)
3231       throw std::length_error ("gmp_randinit_lc_2exp_size");
3232   }
3233
3234   ~gmp_randclass() { gmp_randclear(state); }
3235
3236   // initialize
3237   void seed(); // choose a random seed some way (?)
3238   void seed(unsigned long int s) { gmp_randseed_ui(state, s); }
3239   void seed(const mpz_class &z) { gmp_randseed(state, z.get_mpz_t()); }
3240
3241   // get random number
3242   __gmp_expr<mpz_t, __gmp_urandomb_value> get_z_bits(mp_bitcnt_t l)
3243   { return __gmp_expr<mpz_t, __gmp_urandomb_value>(state, l); }
3244   __gmp_expr<mpz_t, __gmp_urandomb_value> get_z_bits(const mpz_class &z)
3245   { return get_z_bits(z.get_ui()); }
3246   // FIXME: z.get_bitcnt_t() ?
3247
3248   __gmp_expr<mpz_t, __gmp_urandomm_value> get_z_range(const mpz_class &z)
3249   { return __gmp_expr<mpz_t, __gmp_urandomm_value>(state, z); }
3250
3251   __gmp_expr<mpf_t, __gmp_urandomb_value> get_f(mp_bitcnt_t prec = 0)
3252   { return __gmp_expr<mpf_t, __gmp_urandomb_value>(state, prec); }
3253 };
3254
3255
3256 /**************** Specialize std::numeric_limits ****************/
3257
3258 namespace std {
3259   template <> class numeric_limits<mpz_class>
3260   {
3261   public:
3262     static const bool is_specialized = true;
3263     static mpz_class min() { return mpz_class(); }
3264     static mpz_class max() { return mpz_class(); }
3265     static mpz_class lowest() { return mpz_class(); }
3266     static const int digits = 0;
3267     static const int digits10 = 0;
3268     static const int max_digits10 = 0;
3269     static const bool is_signed = true;
3270     static const bool is_integer = true;
3271     static const bool is_exact = true;
3272     static const int radix = 2;
3273     static mpz_class epsilon() { return mpz_class(); }
3274     static mpz_class round_error() { return mpz_class(); }
3275     static const int min_exponent = 0;
3276     static const int min_exponent10 = 0;
3277     static const int max_exponent = 0;
3278     static const int max_exponent10 = 0;
3279     static const bool has_infinity = false;
3280     static const bool has_quiet_NaN = false;
3281     static const bool has_signaling_NaN = false;
3282     static const float_denorm_style has_denorm = denorm_absent;
3283     static const bool has_denorm_loss = false;
3284     static mpz_class infinity() { return mpz_class(); }
3285     static mpz_class quiet_NaN() { return mpz_class(); }
3286     static mpz_class signaling_NaN() { return mpz_class(); }
3287     static mpz_class denorm_min() { return mpz_class(); }
3288     static const bool is_iec559 = false;
3289     static const bool is_bounded = false;
3290     static const bool is_modulo = false;
3291     static const bool traps = false;
3292     static const bool tinyness_before = false;
3293     static const float_round_style round_style = round_toward_zero;
3294   };
3295
3296   template <> class numeric_limits<mpq_class>
3297   {
3298   public:
3299     static const bool is_specialized = true;
3300     static mpq_class min() { return mpq_class(); }
3301     static mpq_class max() { return mpq_class(); }
3302     static mpq_class lowest() { return mpq_class(); }
3303     static const int digits = 0;
3304     static const int digits10 = 0;
3305     static const int max_digits10 = 0;
3306     static const bool is_signed = true;
3307     static const bool is_integer = false;
3308     static const bool is_exact = true;
3309     static const int radix = 2;
3310     static mpq_class epsilon() { return mpq_class(); }
3311     static mpq_class round_error() { return mpq_class(); }
3312     static const int min_exponent = 0;
3313     static const int min_exponent10 = 0;
3314     static const int max_exponent = 0;
3315     static const int max_exponent10 = 0;
3316     static const bool has_infinity = false;
3317     static const bool has_quiet_NaN = false;
3318     static const bool has_signaling_NaN = false;
3319     static const float_denorm_style has_denorm = denorm_absent;
3320     static const bool has_denorm_loss = false;
3321     static mpq_class infinity() { return mpq_class(); }
3322     static mpq_class quiet_NaN() { return mpq_class(); }
3323     static mpq_class signaling_NaN() { return mpq_class(); }
3324     static mpq_class denorm_min() { return mpq_class(); }
3325     static const bool is_iec559 = false;
3326     static const bool is_bounded = false;
3327     static const bool is_modulo = false;
3328     static const bool traps = false;
3329     static const bool tinyness_before = false;
3330     static const float_round_style round_style = round_toward_zero;
3331   };
3332
3333   template <> class numeric_limits<mpf_class>
3334   {
3335   public:
3336     static const bool is_specialized = true;
3337     static mpf_class min() { return mpf_class(); }
3338     static mpf_class max() { return mpf_class(); }
3339     static mpf_class lowest() { return mpf_class(); }
3340     static const int digits = 0;
3341     static const int digits10 = 0;
3342     static const int max_digits10 = 0;
3343     static const bool is_signed = true;
3344     static const bool is_integer = false;
3345     static const bool is_exact = false;
3346     static const int radix = 2;
3347     static mpf_class epsilon() { return mpf_class(); }
3348     static mpf_class round_error() { return mpf_class(); }
3349     static const int min_exponent = 0;
3350     static const int min_exponent10 = 0;
3351     static const int max_exponent = 0;
3352     static const int max_exponent10 = 0;
3353     static const bool has_infinity = false;
3354     static const bool has_quiet_NaN = false;
3355     static const bool has_signaling_NaN = false;
3356     static const float_denorm_style has_denorm = denorm_absent;
3357     static const bool has_denorm_loss = false;
3358     static mpf_class infinity() { return mpf_class(); }
3359     static mpf_class quiet_NaN() { return mpf_class(); }
3360     static mpf_class signaling_NaN() { return mpf_class(); }
3361     static mpf_class denorm_min() { return mpf_class(); }
3362     static const bool is_iec559 = false;
3363     static const bool is_bounded = false;
3364     static const bool is_modulo = false;
3365     static const bool traps = false;
3366     static const bool tinyness_before = false;
3367     static const float_round_style round_style = round_indeterminate;
3368   };
3369 }
3370
3371
3372 /**************** #undef all private macros ****************/
3373
3374 #undef __GMPP_DECLARE_COMPOUND_OPERATOR
3375 #undef __GMPN_DECLARE_COMPOUND_OPERATOR
3376 #undef __GMP_DECLARE_COMPOUND_OPERATOR
3377 #undef __GMP_DECLARE_COMPOUND_OPERATOR_UI
3378 #undef __GMP_DECLARE_INCREMENT_OPERATOR
3379 #undef __GMPXX_DEFINE_ARITHMETIC_CONSTRUCTORS
3380 #undef __GMPXX_DEFINE_ARITHMETIC_ASSIGNMENTS
3381
3382 #undef __GMPZQ_DEFINE_EXPR
3383
3384 #undef __GMP_DEFINE_UNARY_FUNCTION
3385 #undef __GMP_DEFINE_UNARY_TYPE_FUNCTION
3386
3387 #undef __GMPP_DEFINE_BINARY_FUNCTION
3388 #undef __GMPNN_DEFINE_BINARY_FUNCTION
3389 #undef __GMPNS_DEFINE_BINARY_FUNCTION
3390 #undef __GMPNU_DEFINE_BINARY_FUNCTION
3391 #undef __GMPND_DEFINE_BINARY_FUNCTION
3392 #undef __GMPNLD_DEFINE_BINARY_FUNCTION
3393 #undef __GMPN_DEFINE_BINARY_FUNCTION
3394 #undef __GMP_DEFINE_BINARY_FUNCTION
3395
3396 #undef __GMP_DEFINE_BINARY_FUNCTION_UI
3397
3398 #undef __GMPP_DEFINE_BINARY_TYPE_FUNCTION
3399 #undef __GMPNN_DEFINE_BINARY_TYPE_FUNCTION
3400 #undef __GMPNS_DEFINE_BINARY_TYPE_FUNCTION
3401 #undef __GMPNU_DEFINE_BINARY_TYPE_FUNCTION
3402 #undef __GMPND_DEFINE_BINARY_TYPE_FUNCTION
3403 #undef __GMPNLD_DEFINE_BINARY_TYPE_FUNCTION
3404 #undef __GMPN_DEFINE_BINARY_TYPE_FUNCTION
3405 #undef __GMP_DEFINE_BINARY_TYPE_FUNCTION
3406
3407 #undef __GMPZ_DEFINE_COMPOUND_OPERATOR
3408
3409 #undef __GMPP_DEFINE_COMPOUND_OPERATOR
3410 #undef __GMPNN_DEFINE_COMPOUND_OPERATOR
3411 #undef __GMPNS_DEFINE_COMPOUND_OPERATOR
3412 #undef __GMPNU_DEFINE_COMPOUND_OPERATOR
3413 #undef __GMPND_DEFINE_COMPOUND_OPERATOR
3414 #undef __GMPNLD_DEFINE_COMPOUND_OPERATOR
3415 #undef __GMPN_DEFINE_COMPOUND_OPERATOR
3416 #undef __GMP_DEFINE_COMPOUND_OPERATOR
3417
3418 #undef __GMPQ_DEFINE_COMPOUND_OPERATOR
3419 #undef __GMPF_DEFINE_COMPOUND_OPERATOR
3420
3421 #undef __GMP_DEFINE_COMPOUND_OPERATOR_UI
3422 #undef __GMPZ_DEFINE_COMPOUND_OPERATOR_UI
3423 #undef __GMPQ_DEFINE_COMPOUND_OPERATOR_UI
3424 #undef __GMPF_DEFINE_COMPOUND_OPERATOR_UI
3425
3426 #undef __GMP_DEFINE_INCREMENT_OPERATOR
3427 #undef __GMPZ_DEFINE_INCREMENT_OPERATOR
3428 #undef __GMPQ_DEFINE_INCREMENT_OPERATOR
3429 #undef __GMPF_DEFINE_INCREMENT_OPERATOR
3430
3431 #undef __GMPXX_CONSTANT_TRUE
3432 #undef __GMPXX_CONSTANT
3433
3434 #endif /* __GMP_PLUSPLUS__ */