Annotation of OpenXM_contrib/gmp/gmpxx.h, Revision 1.1
1.1 ! ohara 1: /* gmpxx.h -- C++ class wrapper for GMP types. -*- C++ -*-
! 2:
! 3: Copyright 2001, 2002 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 the GNU Lesser General Public License as published by
! 9: the Free Software Foundation; either version 2.1 of the License, or (at your
! 10: option) any later version.
! 11:
! 12: The GNU MP Library is distributed in the hope that it will be useful, but
! 13: WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
! 14: or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
! 15: License for more details.
! 16:
! 17: You should have received a copy of the GNU Lesser General Public License
! 18: along with the GNU MP Library; see the file COPYING.LIB. If not, write to
! 19: the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
! 20: MA 02111-1307, USA. */
! 21:
! 22: /* the C++ compiler must implement the following features:
! 23: - member templates
! 24: - partial specialization of templates
! 25: - namespace support
! 26: for g++, this means version 2.91 or higher
! 27: for other compilers, I don't know */
! 28: #ifdef __GNUC__
! 29: #if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 91)
! 30: #error gmpxx.h requires g++ version 2.91 (egcs 1.1.2) or higher
! 31: #endif
! 32: #endif
! 33:
! 34: #ifndef __GMP_PLUSPLUS__
! 35: #define __GMP_PLUSPLUS__
! 36:
! 37: #include <iosfwd>
! 38: #include <string>
! 39: #include <gmp.h>
! 40:
! 41:
! 42: /**************** Function objects ****************/
! 43: /* Any evaluation of a __gmp_expr ends up calling one of these functions
! 44: all intermediate functions being inline, the evaluation should optimize
! 45: to a direct call to the relevant function, thus yielding no overhead
! 46: over the C interface.
! 47: Functions with mpfr_t arguments are wrapped by an #ifdef test because
! 48: mpfr isn't installed by default */
! 49:
! 50: struct __gmp_unary_plus
! 51: {
! 52: static void eval(mpz_ptr z, mpz_srcptr w) { mpz_set(z, w); }
! 53: static void eval(mpq_ptr q, mpq_srcptr r) { mpq_set(q, r); }
! 54: static void eval(mpf_ptr f, mpf_srcptr g) { mpf_set(f, g); }
! 55: #ifdef __MPFR_H
! 56: static void eval(mpfr_ptr f, mpfr_srcptr g, mp_rnd_t mode)
! 57: { mpfr_set(f, g, mode); }
! 58: #endif
! 59: };
! 60:
! 61: struct __gmp_unary_minus
! 62: {
! 63: static void eval(mpz_ptr z, mpz_srcptr w) { mpz_neg(z, w); }
! 64: static void eval(mpq_ptr q, mpq_srcptr r) { mpq_neg(q, r); }
! 65: static void eval(mpf_ptr f, mpf_srcptr g) { mpf_neg(f, g); }
! 66: #ifdef __MPFR_H
! 67: static void eval(mpfr_ptr f, mpfr_srcptr g, mp_rnd_t mode)
! 68: { mpfr_neg(f, g, mode); }
! 69: #endif
! 70: };
! 71:
! 72: struct __gmp_unary_com
! 73: {
! 74: static void eval(mpz_ptr z, mpz_srcptr w) { mpz_com(z, w); }
! 75: };
! 76:
! 77: struct __gmp_binary_plus
! 78: {
! 79: static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
! 80: { mpz_add(z, w, v); }
! 81:
! 82: static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
! 83: { mpz_add_ui(z, w, l); }
! 84: static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
! 85: { mpz_add_ui(z, w, l); }
! 86: static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
! 87: {
! 88: if (l >= 0)
! 89: mpz_add_ui(z, w, l);
! 90: else
! 91: mpz_sub_ui(z, w, -l);
! 92: }
! 93: static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
! 94: {
! 95: if (l >= 0)
! 96: mpz_add_ui(z, w, l);
! 97: else
! 98: mpz_sub_ui(z, w, -l);
! 99: }
! 100: static void eval(mpz_ptr z, mpz_srcptr w, double d)
! 101: {
! 102: mpz_t temp;
! 103: mpz_init_set_d(temp, d);
! 104: mpz_add(z, w, temp);
! 105: mpz_clear(temp);
! 106: }
! 107: static void eval(mpz_ptr z, double d, mpz_srcptr w)
! 108: {
! 109: mpz_t temp;
! 110: mpz_init_set_d(temp, d);
! 111: mpz_add(z, temp, w);
! 112: mpz_clear(temp);
! 113: }
! 114:
! 115: static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
! 116: { mpq_add(q, r, s); }
! 117:
! 118: static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
! 119: {
! 120: mpq_t temp;
! 121: mpq_init(temp);
! 122: mpq_set_ui(temp, l, 1);
! 123: mpq_add(q, r, temp);
! 124: mpq_clear(temp);
! 125: }
! 126: static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
! 127: {
! 128: mpq_t temp;
! 129: mpq_init(temp);
! 130: mpq_set_ui(temp, l, 1);
! 131: mpq_add(q, temp, r);
! 132: mpq_clear(temp);
! 133: }
! 134: static void eval(mpq_ptr q, mpq_srcptr r, signed long int l)
! 135: {
! 136: mpq_t temp;
! 137: mpq_init(temp);
! 138: mpq_set_si(temp, l, 1);
! 139: mpq_add(q, r, temp);
! 140: mpq_clear(temp);
! 141: }
! 142: static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
! 143: {
! 144: mpq_t temp;
! 145: mpq_init(temp);
! 146: mpq_set_si(temp, l, 1);
! 147: mpq_add(q, temp, r);
! 148: mpq_clear(temp);
! 149: }
! 150: static void eval(mpq_ptr q, mpq_srcptr r, double d)
! 151: {
! 152: mpq_t temp;
! 153: mpq_init(temp);
! 154: mpq_set_d(temp, d);
! 155: mpq_add(q, r, temp);
! 156: mpq_clear(temp);
! 157: }
! 158: static void eval(mpq_ptr q, double d, mpq_srcptr r)
! 159: {
! 160: mpq_t temp;
! 161: mpq_init(temp);
! 162: mpq_set_d(temp, d);
! 163: mpq_add(q, temp, r);
! 164: mpq_clear(temp);
! 165: }
! 166:
! 167: static void eval(mpq_ptr q, mpq_srcptr r, mpz_srcptr z)
! 168: {
! 169: mpq_set(q, r);
! 170: mpz_addmul(mpq_numref(q), mpq_denref(q), z);
! 171: }
! 172: static void eval(mpq_ptr q, mpz_srcptr z, mpq_srcptr r)
! 173: {
! 174: mpq_set(q, r);
! 175: mpz_addmul(mpq_numref(q), mpq_denref(q), z);
! 176: }
! 177:
! 178: static void eval(mpf_ptr f, mpf_srcptr g, mpf_srcptr h)
! 179: { mpf_add(f, g, h); }
! 180:
! 181: static void eval(mpf_ptr f, mpf_srcptr g, unsigned long int l)
! 182: { mpf_add_ui(f, g, l); }
! 183: static void eval(mpf_ptr f, unsigned long int l, mpf_srcptr g)
! 184: { mpf_add_ui(f, g, l); }
! 185: static void eval(mpf_ptr f, mpf_srcptr g, signed long int l)
! 186: {
! 187: if (l >= 0)
! 188: mpf_add_ui(f, g, l);
! 189: else
! 190: mpf_sub_ui(f, g, -l);
! 191: }
! 192: static void eval(mpf_ptr f, signed long int l, mpf_srcptr g)
! 193: {
! 194: if (l >= 0)
! 195: mpf_add_ui(f, g, l);
! 196: else
! 197: mpf_sub_ui(f, g, -l);
! 198: }
! 199: static void eval(mpf_ptr f, mpf_srcptr g, double d)
! 200: {
! 201: mpf_t temp;
! 202: mpf_init2(temp, 8*sizeof(double));
! 203: mpf_set_d(temp, d);
! 204: mpf_add(f, g, temp);
! 205: mpf_clear(temp);
! 206: }
! 207: static void eval(mpf_ptr f, double d, mpf_srcptr g)
! 208: {
! 209: mpf_t temp;
! 210: mpf_init2(temp, 8*sizeof(double));
! 211: mpf_set_d(temp, d);
! 212: mpf_add(f, temp, g);
! 213: mpf_clear(temp);
! 214: }
! 215:
! 216: #ifdef __MPFR_H
! 217: static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h, mp_rnd_t mode)
! 218: { mpfr_add(f, g, h, mode); }
! 219:
! 220: static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l,
! 221: mp_rnd_t mode)
! 222: { mpfr_add_ui(f, g, l, mode); }
! 223: static void eval(mpfr_ptr f, unsigned long int l, mpfr_srcptr g,
! 224: mp_rnd_t mode)
! 225: { mpfr_add_ui(f, g, l, mode); }
! 226: static void eval(mpfr_ptr f, mpfr_srcptr g, signed long int l,
! 227: mp_rnd_t mode)
! 228: {
! 229: if (l >= 0)
! 230: mpfr_add_ui(f, g, l, mode);
! 231: else
! 232: mpfr_sub_ui(f, g, -l, mode);
! 233: }
! 234: static void eval(mpfr_ptr f, signed long int l, mpfr_srcptr g,
! 235: mp_rnd_t mode)
! 236: {
! 237: if (l >= 0)
! 238: mpfr_add_ui(f, g, l, mode);
! 239: else
! 240: mpfr_sub_ui(f, g, -l, mode);
! 241: }
! 242: static void eval(mpfr_ptr f, mpfr_srcptr g, double d, mp_rnd_t mode)
! 243: {
! 244: mpfr_t temp;
! 245: mpfr_init2(temp, 8*sizeof(double));
! 246: mpfr_set_d(temp, d, mode);
! 247: mpfr_add(f, g, temp, mode);
! 248: mpfr_clear(temp);
! 249: }
! 250: static void eval(mpfr_ptr f, double d, mpfr_srcptr g, mp_rnd_t mode)
! 251: {
! 252: mpfr_t temp;
! 253: mpfr_init2(temp, 8*sizeof(double));
! 254: mpfr_set_d(temp, d, mode);
! 255: mpfr_add(f, temp, g, mode);
! 256: mpfr_clear(temp);
! 257: }
! 258: #endif
! 259: };
! 260:
! 261: struct __gmp_binary_minus
! 262: {
! 263: static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
! 264: { mpz_sub(z, w, v); }
! 265:
! 266: static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
! 267: { mpz_sub_ui(z, w, l); }
! 268: static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
! 269: { mpz_ui_sub(z, l, w); }
! 270: static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
! 271: {
! 272: if (l >= 0)
! 273: mpz_sub_ui(z, w, l);
! 274: else
! 275: mpz_add_ui(z, w, -l);
! 276: }
! 277: static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
! 278: {
! 279: if (l >= 0)
! 280: mpz_ui_sub(z, l, w);
! 281: else
! 282: {
! 283: mpz_add_ui(z, w, -l);
! 284: mpz_neg(z, z);
! 285: }
! 286: }
! 287: static void eval(mpz_ptr z, mpz_srcptr w, double d)
! 288: {
! 289: mpz_t temp;
! 290: mpz_init_set_d(temp, d);
! 291: mpz_sub(z, w, temp);
! 292: mpz_clear(temp);
! 293: }
! 294: static void eval(mpz_ptr z, double d, mpz_srcptr w)
! 295: {
! 296: mpz_t temp;
! 297: mpz_init_set_d(temp, d);
! 298: mpz_sub(z, temp, w);
! 299: mpz_clear(temp);
! 300: }
! 301:
! 302: static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
! 303: { mpq_sub(q, r, s); }
! 304:
! 305: static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
! 306: {
! 307: mpq_t temp;
! 308: mpq_init(temp);
! 309: mpq_set_ui(temp, l, 1);
! 310: mpq_sub(q, r, temp);
! 311: mpq_clear(temp);
! 312: }
! 313: static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
! 314: {
! 315: mpq_t temp;
! 316: mpq_init(temp);
! 317: mpq_set_ui(temp, l, 1);
! 318: mpq_sub(q, temp, r);
! 319: mpq_clear(temp);
! 320: }
! 321: static void eval(mpq_ptr q, mpq_srcptr r, signed long int l)
! 322: {
! 323: mpq_t temp;
! 324: mpq_init(temp);
! 325: mpq_set_si(temp, l, 1);
! 326: mpq_sub(q, r, temp);
! 327: mpq_clear(temp);
! 328: }
! 329: static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
! 330: {
! 331: mpq_t temp;
! 332: mpq_init(temp);
! 333: mpq_set_si(temp, l, 1);
! 334: mpq_sub(q, temp, r);
! 335: mpq_clear(temp);
! 336: }
! 337: static void eval(mpq_ptr q, mpq_srcptr r, double d)
! 338: {
! 339: mpq_t temp;
! 340: mpq_init(temp);
! 341: mpq_set_d(temp, d);
! 342: mpq_sub(q, r, temp);
! 343: mpq_clear(temp);
! 344: }
! 345: static void eval(mpq_ptr q, double d, mpq_srcptr r)
! 346: {
! 347: mpq_t temp;
! 348: mpq_init(temp);
! 349: mpq_set_d(temp, d);
! 350: mpq_sub(q, temp, r);
! 351: mpq_clear(temp);
! 352: }
! 353:
! 354: static void eval(mpq_ptr q, mpq_srcptr r, mpz_srcptr z)
! 355: {
! 356: mpq_set(q, r);
! 357: mpz_submul(mpq_numref(q), mpq_denref(q), z);
! 358: }
! 359: static void eval(mpq_ptr q, mpz_srcptr z, mpq_srcptr r)
! 360: {
! 361: mpq_neg(q, r);
! 362: mpz_addmul(mpq_numref(q), mpq_denref(q), z);
! 363: }
! 364:
! 365: static void eval(mpf_ptr f, mpf_srcptr g, mpf_srcptr h)
! 366: { mpf_sub(f, g, h); }
! 367:
! 368: static void eval(mpf_ptr f, mpf_srcptr g, unsigned long int l)
! 369: { mpf_sub_ui(f, g, l); }
! 370: static void eval(mpf_ptr f, unsigned long int l, mpf_srcptr g)
! 371: { mpf_ui_sub(f, l, g); }
! 372: static void eval(mpf_ptr f, mpf_srcptr g, signed long int l)
! 373: {
! 374: if (l >= 0)
! 375: mpf_sub_ui(f, g, l);
! 376: else
! 377: mpf_add_ui(f, g, -l);
! 378: }
! 379: static void eval(mpf_ptr f, signed long int l, mpf_srcptr g)
! 380: {
! 381: if (l >= 0)
! 382: mpf_sub_ui(f, g, l);
! 383: else
! 384: mpf_add_ui(f, g, -l);
! 385: mpf_neg(f, f);
! 386: }
! 387: static void eval(mpf_ptr f, mpf_srcptr g, double d)
! 388: {
! 389: mpf_t temp;
! 390: mpf_init2(temp, 8*sizeof(double));
! 391: mpf_set_d(temp, d);
! 392: mpf_sub(f, g, temp);
! 393: mpf_clear(temp);
! 394: }
! 395: static void eval(mpf_ptr f, double d, mpf_srcptr g)
! 396: {
! 397: mpf_t temp;
! 398: mpf_init2(temp, 8*sizeof(double));
! 399: mpf_set_d(temp, d);
! 400: mpf_sub(f, temp, g);
! 401: mpf_clear(temp);
! 402: }
! 403:
! 404: #ifdef __MPFR_H
! 405: static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h, mp_rnd_t mode)
! 406: { mpfr_sub(f, g, h, mode); }
! 407:
! 408: static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l,
! 409: mp_rnd_t mode)
! 410: { mpfr_sub_ui(f, g, l, mode); }
! 411: static void eval(mpfr_ptr f, unsigned long int l, mpfr_srcptr g,
! 412: mp_rnd_t mode)
! 413: { mpfr_ui_sub(f, l, g, mode); }
! 414: static void eval(mpfr_ptr f, mpfr_srcptr g, signed long int l,
! 415: mp_rnd_t mode)
! 416: {
! 417: if (l >= 0)
! 418: mpfr_sub_ui(f, g, l, mode);
! 419: else
! 420: mpfr_add_ui(f, g, -l, mode);
! 421: }
! 422: static void eval(mpfr_ptr f, signed long int l, mpfr_srcptr g,
! 423: mp_rnd_t mode)
! 424: {
! 425: if (l >= 0)
! 426: mpfr_sub_ui(f, g, l, mode);
! 427: else
! 428: mpfr_add_ui(f, g, -l, mode);
! 429: mpfr_neg(f, f, mode);
! 430: }
! 431: static void eval(mpfr_ptr f, mpfr_srcptr g, double d, mp_rnd_t mode)
! 432: {
! 433: mpfr_t temp;
! 434: mpfr_init2(temp, 8*sizeof(double));
! 435: mpfr_set_d(temp, d, mode);
! 436: mpfr_sub(f, g, temp, mode);
! 437: mpfr_clear(temp);
! 438: }
! 439: static void eval(mpfr_ptr f, double d, mpfr_srcptr g, mp_rnd_t mode)
! 440: {
! 441: mpfr_t temp;
! 442: mpfr_init2(temp, 8*sizeof(double));
! 443: mpfr_set_d(temp, d, mode);
! 444: mpfr_sub(f, temp, g, mode);
! 445: mpfr_clear(temp);
! 446: }
! 447: #endif
! 448: };
! 449:
! 450: struct __gmp_binary_multiplies
! 451: {
! 452: static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
! 453: { mpz_mul(z, w, v); }
! 454:
! 455: static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
! 456: { mpz_mul_ui(z, w, l); }
! 457: static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
! 458: { mpz_mul_ui(z, w, l); }
! 459: static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
! 460: {
! 461: if (l >= 0)
! 462: mpz_mul_ui(z, w, l);
! 463: else
! 464: {
! 465: mpz_mul_ui(z, w, -l);
! 466: mpz_neg(z, z);
! 467: }
! 468: }
! 469: static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
! 470: {
! 471: if (l >= 0)
! 472: mpz_mul_ui(z, w, l);
! 473: else
! 474: {
! 475: mpz_mul_ui(z, w, -l);
! 476: mpz_neg(z, z);
! 477: }
! 478: }
! 479: static void eval(mpz_ptr z, mpz_srcptr w, double d)
! 480: {
! 481: mpz_t temp;
! 482: mpz_init_set_d(temp, d);
! 483: mpz_mul(z, w, temp);
! 484: mpz_clear(temp);
! 485: }
! 486: static void eval(mpz_ptr z, double d, mpz_srcptr w)
! 487: {
! 488: mpz_t temp;
! 489: mpz_init_set_d(temp, d);
! 490: mpz_mul(z, temp, w);
! 491: mpz_clear(temp);
! 492: }
! 493:
! 494: static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
! 495: { mpq_mul(q, r, s); }
! 496:
! 497: static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
! 498: {
! 499: mpq_t temp;
! 500: mpq_init(temp);
! 501: mpq_set_ui(temp, l, 1);
! 502: mpq_mul(q, r, temp);
! 503: mpq_clear(temp);
! 504: }
! 505: static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
! 506: {
! 507: mpq_t temp;
! 508: mpq_init(temp);
! 509: mpq_set_ui(temp, l, 1);
! 510: mpq_mul(q, temp, r);
! 511: mpq_clear(temp);
! 512: }
! 513: static void eval(mpq_ptr q, mpq_srcptr r, signed long int l)
! 514: {
! 515: mpq_t temp;
! 516: mpq_init(temp);
! 517: mpq_set_si(temp, l, 1);
! 518: mpq_mul(q, r, temp);
! 519: mpq_clear(temp);
! 520: }
! 521: static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
! 522: {
! 523: mpq_t temp;
! 524: mpq_init(temp);
! 525: mpq_set_si(temp, l, 1);
! 526: mpq_mul(q, temp, r);
! 527: mpq_clear(temp);
! 528: }
! 529: static void eval(mpq_ptr q, mpq_srcptr r, double d)
! 530: {
! 531: mpq_t temp;
! 532: mpq_init(temp);
! 533: mpq_set_d(temp, d);
! 534: mpq_mul(q, r, temp);
! 535: mpq_clear(temp);
! 536: }
! 537: static void eval(mpq_ptr q, double d, mpq_srcptr r)
! 538: {
! 539: mpq_t temp;
! 540: mpq_init(temp);
! 541: mpq_set_d(temp, d);
! 542: mpq_mul(q, temp, r);
! 543: mpq_clear(temp);
! 544: }
! 545:
! 546: static void eval(mpf_ptr f, mpf_srcptr g, mpf_srcptr h)
! 547: { mpf_mul(f, g, h); }
! 548:
! 549: static void eval(mpf_ptr f, mpf_srcptr g, unsigned long int l)
! 550: { mpf_mul_ui(f, g, l); }
! 551: static void eval(mpf_ptr f, unsigned long int l, mpf_srcptr g)
! 552: { mpf_mul_ui(f, g, l); }
! 553: static void eval(mpf_ptr f, mpf_srcptr g, signed long int l)
! 554: {
! 555: if (l >= 0)
! 556: mpf_mul_ui(f, g, l);
! 557: else
! 558: {
! 559: mpf_mul_ui(f, g, -l);
! 560: mpf_neg(f, f);
! 561: }
! 562: }
! 563: static void eval(mpf_ptr f, signed long int l, mpf_srcptr g)
! 564: {
! 565: if (l >= 0)
! 566: mpf_mul_ui(f, g, l);
! 567: else
! 568: {
! 569: mpf_mul_ui(f, g, -l);
! 570: mpf_neg(f, f);
! 571: }
! 572: }
! 573: static void eval(mpf_ptr f, mpf_srcptr g, double d)
! 574: {
! 575: mpf_t temp;
! 576: mpf_init2(temp, 8*sizeof(double));
! 577: mpf_set_d(temp, d);
! 578: mpf_mul(f, g, temp);
! 579: mpf_clear(temp);
! 580: }
! 581: static void eval(mpf_ptr f, double d, mpf_srcptr g)
! 582: {
! 583: mpf_t temp;
! 584: mpf_init2(temp, 8*sizeof(double));
! 585: mpf_set_d(temp, d);
! 586: mpf_mul(f, temp, g);
! 587: mpf_clear(temp);
! 588: }
! 589:
! 590: #ifdef __MPFR_H
! 591: static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h, mp_rnd_t mode)
! 592: { mpfr_mul(f, g, h, mode); }
! 593:
! 594: static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l,
! 595: mp_rnd_t mode)
! 596: { mpfr_mul_ui(f, g, l, mode); }
! 597: static void eval(mpfr_ptr f, unsigned long int l, mpfr_srcptr g,
! 598: mp_rnd_t mode)
! 599: { mpfr_mul_ui(f, g, l, mode); }
! 600: static void eval(mpfr_ptr f, mpfr_srcptr g, signed long int l,
! 601: mp_rnd_t mode)
! 602: {
! 603: if (l >= 0)
! 604: mpfr_mul_ui(f, g, l, mode);
! 605: else
! 606: {
! 607: mpfr_mul_ui(f, g, -l, mode);
! 608: mpfr_neg(f, f, mode);
! 609: }
! 610: }
! 611: static void eval(mpfr_ptr f, signed long int l, mpfr_srcptr g,
! 612: mp_rnd_t mode)
! 613: {
! 614: if (l >= 0)
! 615: mpfr_mul_ui(f, g, l, mode);
! 616: else
! 617: {
! 618: mpfr_mul_ui(f, g, -l, mode);
! 619: mpfr_neg(f, f, mode);
! 620: }
! 621: }
! 622: static void eval(mpfr_ptr f, mpfr_srcptr g, double d, mp_rnd_t mode)
! 623: {
! 624: mpfr_t temp;
! 625: mpfr_init2(temp, 8*sizeof(double));
! 626: mpfr_set_d(temp, d, mode);
! 627: mpfr_mul(f, g, temp, mode);
! 628: mpfr_clear(temp);
! 629: }
! 630: static void eval(mpfr_ptr f, double d, mpfr_srcptr g, mp_rnd_t mode)
! 631: {
! 632: mpfr_t temp;
! 633: mpfr_init2(temp, 8*sizeof(double));
! 634: mpfr_set_d(temp, d, mode);
! 635: mpfr_mul(f, temp, g, mode);
! 636: mpfr_clear(temp);
! 637: }
! 638: #endif
! 639: };
! 640:
! 641: struct __gmp_binary_divides
! 642: {
! 643: static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
! 644: { mpz_tdiv_q(z, w, v); }
! 645:
! 646: static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
! 647: { mpz_tdiv_q_ui(z, w, l); }
! 648: static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
! 649: {
! 650: if (mpz_sgn(w) >= 0)
! 651: {
! 652: if (mpz_fits_ulong_p(w))
! 653: mpz_set_ui(z, l / mpz_get_ui(w));
! 654: else
! 655: mpz_set_ui(z, 0);
! 656: }
! 657: else
! 658: {
! 659: mpz_neg(z, w);
! 660: if (mpz_fits_ulong_p(z))
! 661: {
! 662: mpz_set_ui(z, l / mpz_get_ui(z));
! 663: mpz_neg(z, z);
! 664: }
! 665: else
! 666: mpz_set_ui(z, 0);
! 667: }
! 668: }
! 669: static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
! 670: {
! 671: if (l >= 0)
! 672: mpz_tdiv_q_ui(z, w, l);
! 673: else
! 674: {
! 675: mpz_tdiv_q_ui(z, w, -l);
! 676: mpz_neg(z, z);
! 677: }
! 678: }
! 679: static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
! 680: {
! 681: if (mpz_fits_slong_p(w))
! 682: mpz_set_si(z, l / mpz_get_si(w));
! 683: else
! 684: mpz_set_si(z, 0);
! 685: }
! 686: static void eval(mpz_ptr z, mpz_srcptr w, double d)
! 687: {
! 688: mpz_t temp;
! 689: mpz_init_set_d(temp, d);
! 690: mpz_tdiv_q(z, w, temp);
! 691: mpz_clear(temp);
! 692: }
! 693: static void eval(mpz_ptr z, double d, mpz_srcptr w)
! 694: {
! 695: mpz_t temp;
! 696: mpz_init_set_d(temp, d);
! 697: mpz_tdiv_q(z, temp, w);
! 698: mpz_clear(temp);
! 699: }
! 700:
! 701: static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
! 702: { mpq_div(q, r, s); }
! 703:
! 704: static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
! 705: {
! 706: mpq_t temp;
! 707: mpq_init(temp);
! 708: mpq_set_ui(temp, l, 1);
! 709: mpq_div(q, r, temp);
! 710: mpq_clear(temp);
! 711: }
! 712: static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
! 713: {
! 714: mpq_t temp;
! 715: mpq_init(temp);
! 716: mpq_set_ui(temp, l, 1);
! 717: mpq_div(q, temp, r);
! 718: mpq_clear(temp);
! 719: }
! 720: static void eval(mpq_ptr q, mpq_srcptr r, signed long int l)
! 721: {
! 722: mpq_t temp;
! 723: mpq_init(temp);
! 724: mpq_set_si(temp, l, 1);
! 725: mpq_div(q, r, temp);
! 726: mpq_clear(temp);
! 727: }
! 728: static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
! 729: {
! 730: mpq_t temp;
! 731: mpq_init(temp);
! 732: mpq_set_si(temp, l, 1);
! 733: mpq_div(q, temp, r);
! 734: mpq_clear(temp);
! 735: }
! 736: static void eval(mpq_ptr q, mpq_srcptr r, double d)
! 737: {
! 738: mpq_t temp;
! 739: mpq_init(temp);
! 740: mpq_set_d(temp, d);
! 741: mpq_div(q, r, temp);
! 742: mpq_clear(temp);
! 743: }
! 744: static void eval(mpq_ptr q, double d, mpq_srcptr r)
! 745: {
! 746: mpq_t temp;
! 747: mpq_init(temp);
! 748: mpq_set_d(temp, d);
! 749: mpq_div(q, temp, r);
! 750: mpq_clear(temp);
! 751: }
! 752:
! 753: static void eval(mpf_ptr f, mpf_srcptr g, mpf_srcptr h)
! 754: { mpf_div(f, g, h); }
! 755:
! 756: static void eval(mpf_ptr f, mpf_srcptr g, unsigned long int l)
! 757: { mpf_div_ui(f, g, l); }
! 758: static void eval(mpf_ptr f, unsigned long int l, mpf_srcptr g)
! 759: { mpf_ui_div(f, l, g); }
! 760: static void eval(mpf_ptr f, mpf_srcptr g, signed long int l)
! 761: {
! 762: if (l >= 0)
! 763: mpf_div_ui(f, g, l);
! 764: else
! 765: {
! 766: mpf_div_ui(f, g, -l);
! 767: mpf_neg(f, f);
! 768: }
! 769: }
! 770: static void eval(mpf_ptr f, signed long int l, mpf_srcptr g)
! 771: {
! 772: if (l >= 0)
! 773: mpf_ui_div(f, l, g);
! 774: else
! 775: {
! 776: mpf_ui_div(f, -l, g);
! 777: mpf_neg(f, f);
! 778: }
! 779: }
! 780: static void eval(mpf_ptr f, mpf_srcptr g, double d)
! 781: {
! 782: mpf_t temp;
! 783: mpf_init2(temp, 8*sizeof(double));
! 784: mpf_set_d(temp, d);
! 785: mpf_div(f, g, temp);
! 786: mpf_clear(temp);
! 787: }
! 788: static void eval(mpf_ptr f, double d, mpf_srcptr g)
! 789: {
! 790: mpf_t temp;
! 791: mpf_init2(temp, 8*sizeof(double));
! 792: mpf_set_d(temp, d);
! 793: mpf_div(f, temp, g);
! 794: mpf_clear(temp);
! 795: }
! 796:
! 797: #ifdef __MPFR_H
! 798: static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h, mp_rnd_t mode)
! 799: { mpfr_div(f, g, h, mode); }
! 800:
! 801: static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l,
! 802: mp_rnd_t mode)
! 803: { mpfr_div_ui(f, g, l, mode); }
! 804: static void eval(mpfr_ptr f, unsigned long int l, mpfr_srcptr g,
! 805: mp_rnd_t mode)
! 806: { mpfr_ui_div(f, l, g, mode); }
! 807: static void eval(mpfr_ptr f, mpfr_srcptr g, signed long int l,
! 808: mp_rnd_t mode)
! 809: {
! 810: if (l >= 0)
! 811: mpfr_div_ui(f, g, l, mode);
! 812: else
! 813: {
! 814: mpfr_div_ui(f, g, -l, mode);
! 815: mpfr_neg(f, f, mode);
! 816: }
! 817: }
! 818: static void eval(mpfr_ptr f, signed long int l, mpfr_srcptr g,
! 819: mp_rnd_t mode)
! 820: {
! 821: if (l >= 0)
! 822: mpfr_ui_div(f, l, g, mode);
! 823: else
! 824: {
! 825: mpfr_ui_div(f, -l, g, mode);
! 826: mpfr_neg(f, f, mode);
! 827: }
! 828: }
! 829: static void eval(mpfr_ptr f, mpfr_srcptr g, double d, mp_rnd_t mode)
! 830: {
! 831: mpfr_t temp;
! 832: mpfr_init2(temp, 8*sizeof(double));
! 833: mpfr_set_d(temp, d, mode);
! 834: mpfr_div(f, g, temp, mode);
! 835: mpfr_clear(temp);
! 836: }
! 837: static void eval(mpfr_ptr f, double d, mpfr_srcptr g, mp_rnd_t mode)
! 838: {
! 839: mpfr_t temp;
! 840: mpfr_init2(temp, 8*sizeof(double));
! 841: mpfr_set_d(temp, d, mode);
! 842: mpfr_div(f, temp, g, mode);
! 843: mpfr_clear(temp);
! 844: }
! 845: #endif
! 846: };
! 847:
! 848: struct __gmp_binary_modulus
! 849: {
! 850: static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
! 851: { mpz_tdiv_r(z, w, v); }
! 852:
! 853: static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
! 854: { mpz_tdiv_r_ui(z, w, l); }
! 855: static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
! 856: {
! 857: if (mpz_sgn(w) >= 0)
! 858: {
! 859: if (mpz_fits_ulong_p(w))
! 860: mpz_set_ui(z, l % mpz_get_ui(w));
! 861: else
! 862: mpz_set_ui(z, l);
! 863: }
! 864: else
! 865: {
! 866: mpz_neg(z, w);
! 867: if (mpz_fits_ulong_p(z))
! 868: mpz_set_ui(z, l % mpz_get_ui(z));
! 869: else
! 870: mpz_set_ui(z, l);
! 871: }
! 872: }
! 873: static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
! 874: {
! 875: if (l >= 0)
! 876: mpz_mod_ui(z, w, l);
! 877: else
! 878: mpz_mod_ui(z, w, -l);
! 879: }
! 880: static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
! 881: {
! 882: if (mpz_fits_slong_p(w))
! 883: mpz_set_si(z, l % mpz_get_si(w));
! 884: else
! 885: mpz_set_si(z, l);
! 886: }
! 887: static void eval(mpz_ptr z, mpz_srcptr w, double d)
! 888: {
! 889: mpz_t temp;
! 890: mpz_init_set_d(temp, d);
! 891: mpz_tdiv_r(z, w, temp);
! 892: mpz_clear(temp);
! 893: }
! 894: static void eval(mpz_ptr z, double d, mpz_srcptr w)
! 895: {
! 896: mpz_t temp;
! 897: mpz_init_set_d(temp, d);
! 898: mpz_tdiv_r(z, temp, w);
! 899: mpz_clear(temp);
! 900: }
! 901: };
! 902:
! 903: struct __gmp_binary_and
! 904: {
! 905: static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
! 906: { mpz_and(z, w, v); }
! 907: };
! 908:
! 909: struct __gmp_binary_ior
! 910: {
! 911: static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
! 912: { mpz_ior(z, w, v); }
! 913: };
! 914:
! 915: struct __gmp_binary_xor
! 916: {
! 917: static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
! 918: { mpz_xor(z, w, v); }
! 919: };
! 920:
! 921: struct __gmp_binary_lshift
! 922: {
! 923: static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
! 924: { mpz_mul_2exp(z, w, l); }
! 925: static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
! 926: { mpq_mul_2exp(q, r, l); }
! 927: static void eval(mpf_ptr f, mpf_srcptr g, unsigned long int l)
! 928: { mpf_mul_2exp(f, g, l); }
! 929: #ifdef __MPFR_H
! 930: static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l,
! 931: mp_rnd_t mode)
! 932: { mpfr_mul_2exp(f, g, l, mode); }
! 933: #endif
! 934: };
! 935:
! 936: struct __gmp_binary_rshift
! 937: {
! 938: static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
! 939: { mpz_tdiv_q_2exp(z, w, l); }
! 940: static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
! 941: { mpq_div_2exp(q, r, l); }
! 942: static void eval(mpf_ptr f, mpf_srcptr g, unsigned long int l)
! 943: { mpf_div_2exp(f, g, l); }
! 944: #ifdef __MPFR_H
! 945: static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l,
! 946: mp_rnd_t mode)
! 947: { mpfr_div_2exp(f, g, l, mode); }
! 948: #endif
! 949: };
! 950:
! 951: struct __gmp_binary_equal
! 952: {
! 953: static bool eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w) == 0; }
! 954:
! 955: static bool eval(mpz_srcptr z, unsigned long int l)
! 956: { return mpz_cmp_ui(z, l) == 0; }
! 957: static bool eval(unsigned long int l, mpz_srcptr z)
! 958: { return mpz_cmp_ui(z, l) == 0; }
! 959: static bool eval(mpz_srcptr z, signed long int l)
! 960: { return mpz_cmp_si(z, l) == 0; }
! 961: static bool eval(signed long int l, mpz_srcptr z)
! 962: { return mpz_cmp_si(z, l) == 0; }
! 963: static bool eval(mpz_srcptr z, double d)
! 964: { return mpz_cmp_d(z, d) == 0; }
! 965: static bool eval(double d, mpz_srcptr z)
! 966: { return mpz_cmp_d(z, d) == 0; }
! 967:
! 968: static bool eval(mpq_srcptr q, mpq_srcptr r)
! 969: { return mpq_equal(q, r) != 0; }
! 970:
! 971: static bool eval(mpq_srcptr q, unsigned long int l)
! 972: { return mpq_cmp_ui(q, l, 1) == 0; }
! 973: static bool eval(unsigned long int l, mpq_srcptr q)
! 974: { return mpq_cmp_ui(q, l, 1) == 0; }
! 975: static bool eval(mpq_srcptr q, signed long int l)
! 976: { return mpq_cmp_si(q, l, 1) == 0; }
! 977: static bool eval(signed long int l, mpq_srcptr q)
! 978: { return mpq_cmp_si(q, l, 1) == 0; }
! 979: static bool eval(mpq_srcptr q, double d)
! 980: {
! 981: bool b;
! 982: mpq_t temp;
! 983: mpq_init(temp);
! 984: mpq_set_d(temp, d);
! 985: b = (mpq_equal(q, temp) != 0);
! 986: mpq_clear(temp);
! 987: return b;
! 988: }
! 989: static bool eval(double d, mpq_srcptr q)
! 990: {
! 991: bool b;
! 992: mpq_t temp;
! 993: mpq_init(temp);
! 994: mpq_set_d(temp, d);
! 995: b = (mpq_equal(temp, q) != 0);
! 996: mpq_clear(temp);
! 997: return b;
! 998: }
! 999:
! 1000: static bool eval(mpf_srcptr f, mpf_srcptr g) { return mpf_cmp(f, g) == 0; }
! 1001:
! 1002: static bool eval(mpf_srcptr f, unsigned long int l)
! 1003: { return mpf_cmp_ui(f, l) == 0; }
! 1004: static bool eval(unsigned long int l, mpf_srcptr f)
! 1005: { return mpf_cmp_ui(f, l) == 0; }
! 1006: static bool eval(mpf_srcptr f, signed long int l)
! 1007: { return mpf_cmp_si(f, l) == 0; }
! 1008: static bool eval(signed long int l, mpf_srcptr f)
! 1009: { return mpf_cmp_si(f, l) == 0; }
! 1010: static bool eval(mpf_srcptr f, double d)
! 1011: { return mpf_cmp_d(f, d) == 0; }
! 1012: static bool eval(double d, mpf_srcptr f)
! 1013: { return mpf_cmp_d(f, d) == 0; }
! 1014:
! 1015: #ifdef __MPFR_H
! 1016: static bool eval(mpfr_srcptr f, mpfr_srcptr g)
! 1017: { return mpfr_cmp(f, g) == 0; }
! 1018:
! 1019: static bool eval(mpfr_srcptr f, unsigned long int l)
! 1020: { return mpfr_cmp_ui(f, l) == 0; }
! 1021: static bool eval(unsigned long int l, mpfr_srcptr f)
! 1022: { return mpfr_cmp_ui(f, l) == 0; }
! 1023: static bool eval(mpfr_srcptr f, signed long int l)
! 1024: {
! 1025: if (mpfr_sgn(f) >= 0)
! 1026: {
! 1027: if (l >= 0)
! 1028: return mpfr_cmp_ui(f, l) == 0;
! 1029: else
! 1030: return false;
! 1031: }
! 1032: else
! 1033: {
! 1034: if (l >= 0)
! 1035: return false;
! 1036: else
! 1037: {
! 1038: bool b;
! 1039: mpfr_t temp;
! 1040: mpfr_init2(temp, mpfr_get_prec(f));
! 1041: mpfr_neg(temp, f, __gmp_default_rounding_mode);
! 1042: b = (mpfr_cmp_ui(temp, -l) == 0);
! 1043: mpfr_clear(temp);
! 1044: return b;
! 1045: }
! 1046: }
! 1047: }
! 1048: static bool eval(signed long int l, mpfr_srcptr f)
! 1049: {
! 1050: if (mpfr_sgn(f) >= 0)
! 1051: {
! 1052: if (l >= 0)
! 1053: return mpfr_cmp_ui(f, l) == 0;
! 1054: else
! 1055: return false;
! 1056: }
! 1057: else
! 1058: {
! 1059: if (l >= 0)
! 1060: return false;
! 1061: else
! 1062: {
! 1063: bool b;
! 1064: mpfr_t temp;
! 1065: mpfr_init2(temp, mpfr_get_prec(f));
! 1066: mpfr_neg(temp, f, __gmp_default_rounding_mode);
! 1067: b = (mpfr_cmp_ui(temp, -l) == 0);
! 1068: mpfr_clear(temp);
! 1069: return b;
! 1070: }
! 1071: }
! 1072: }
! 1073: static bool eval(mpfr_srcptr f, double d)
! 1074: {
! 1075: bool b;
! 1076: mpfr_t temp;
! 1077: mpfr_init2(temp, 8*sizeof(double));
! 1078: mpfr_set_d(temp, d, __gmp_default_rounding_mode);
! 1079: b = (mpfr_cmp(f, temp) == 0);
! 1080: mpfr_clear(temp);
! 1081: return b;
! 1082: }
! 1083: static bool eval(double d, mpfr_srcptr f)
! 1084: {
! 1085: bool b;
! 1086: mpfr_t temp;
! 1087: mpfr_init2(temp, 8*sizeof(double));
! 1088: mpfr_set_d(temp, d, __gmp_default_rounding_mode);
! 1089: b = (mpfr_cmp(temp, f) == 0);
! 1090: mpfr_clear(temp);
! 1091: return b;
! 1092: }
! 1093: #endif
! 1094: };
! 1095:
! 1096: struct __gmp_binary_not_equal
! 1097: {
! 1098: static bool eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w) != 0; }
! 1099:
! 1100: static bool eval(mpz_srcptr z, unsigned long int l)
! 1101: { return mpz_cmp_ui(z, l) != 0; }
! 1102: static bool eval(unsigned long int l, mpz_srcptr z)
! 1103: { return mpz_cmp_ui(z, l) != 0; }
! 1104: static bool eval(mpz_srcptr z, signed long int l)
! 1105: { return mpz_cmp_si(z, l) != 0; }
! 1106: static bool eval(signed long int l, mpz_srcptr z)
! 1107: { return mpz_cmp_si(z, l) != 0; }
! 1108: static bool eval(mpz_srcptr z, double d)
! 1109: { return mpz_cmp_d(z, d) != 0; }
! 1110: static bool eval(double d, mpz_srcptr z)
! 1111: { return mpz_cmp_d(z, d) != 0; }
! 1112:
! 1113: static bool eval(mpq_srcptr q, mpq_srcptr r)
! 1114: { return mpq_equal(q, r) == 0; }
! 1115:
! 1116: static bool eval(mpq_srcptr q, unsigned long int l)
! 1117: { return mpq_cmp_ui(q, l, 1) != 0; }
! 1118: static bool eval(unsigned long int l, mpq_srcptr q)
! 1119: { return mpq_cmp_ui(q, l, 1) != 0; }
! 1120: static bool eval(mpq_srcptr q, signed long int l)
! 1121: { return mpq_cmp_si(q, l, 1) != 0; }
! 1122: static bool eval(signed long int l, mpq_srcptr q)
! 1123: { return mpq_cmp_si(q, l, 1) != 0; }
! 1124: static bool eval(mpq_srcptr q, double d)
! 1125: {
! 1126: bool b;
! 1127: mpq_t temp;
! 1128: mpq_init(temp);
! 1129: mpq_set_d(temp, d);
! 1130: b = (mpq_equal(q, temp) == 0);
! 1131: mpq_clear(temp);
! 1132: return b;
! 1133: }
! 1134: static bool eval(double d, mpq_srcptr q)
! 1135: {
! 1136: bool b;
! 1137: mpq_t temp;
! 1138: mpq_init(temp);
! 1139: mpq_set_d(temp, d);
! 1140: b = (mpq_equal(temp, q) == 0);
! 1141: mpq_clear(temp);
! 1142: return b;
! 1143: }
! 1144:
! 1145: static bool eval(mpf_srcptr f, mpf_srcptr g) { return mpf_cmp(f, g) != 0; }
! 1146:
! 1147: static bool eval(mpf_srcptr f, unsigned long int l)
! 1148: { return mpf_cmp_ui(f, l) != 0; }
! 1149: static bool eval(unsigned long int l, mpf_srcptr f)
! 1150: { return mpf_cmp_ui(f, l) != 0; }
! 1151: static bool eval(mpf_srcptr f, signed long int l)
! 1152: { return mpf_cmp_si(f, l) != 0; }
! 1153: static bool eval(signed long int l, mpf_srcptr f)
! 1154: { return mpf_cmp_si(f, l) != 0; }
! 1155: static bool eval(mpf_srcptr f, double d)
! 1156: { return mpf_cmp_d(f, d) != 0; }
! 1157: static bool eval(double d, mpf_srcptr f)
! 1158: { return mpf_cmp_d(f, d) != 0; }
! 1159:
! 1160: #ifdef __MPFR_H
! 1161: static bool eval(mpfr_srcptr f, mpfr_srcptr g)
! 1162: { return mpfr_cmp(f, g) != 0; }
! 1163:
! 1164: static bool eval(mpfr_srcptr f, unsigned long int l)
! 1165: { return mpfr_cmp_ui(f, l) != 0; }
! 1166: static bool eval(unsigned long int l, mpfr_srcptr f)
! 1167: { return mpfr_cmp_ui(f, l) != 0; }
! 1168: static bool eval(mpfr_srcptr f, signed long int l)
! 1169: {
! 1170: if (mpfr_sgn(f) >= 0)
! 1171: {
! 1172: if (l >= 0)
! 1173: return mpfr_cmp_ui(f, l) != 0;
! 1174: else
! 1175: return true;
! 1176: }
! 1177: else
! 1178: {
! 1179: if (l >= 0)
! 1180: return true;
! 1181: else
! 1182: {
! 1183: bool b;
! 1184: mpfr_t temp;
! 1185: mpfr_init2(temp, mpfr_get_prec(f));
! 1186: mpfr_neg(temp, f, __gmp_default_rounding_mode);
! 1187: b = (mpfr_cmp_ui(temp, -l) != 0);
! 1188: mpfr_clear(temp);
! 1189: return b;
! 1190: }
! 1191: }
! 1192: }
! 1193: static bool eval(signed long int l, mpfr_srcptr f)
! 1194: {
! 1195: if (mpfr_sgn(f) >= 0)
! 1196: {
! 1197: if (l >= 0)
! 1198: return mpfr_cmp_ui(f, l) != 0;
! 1199: else
! 1200: return true;
! 1201: }
! 1202: else
! 1203: {
! 1204: if (l >= 0)
! 1205: return true;
! 1206: else
! 1207: {
! 1208: bool b;
! 1209: mpfr_t temp;
! 1210: mpfr_init2(temp, mpfr_get_prec(f));
! 1211: mpfr_neg(temp, f, __gmp_default_rounding_mode);
! 1212: b = (mpfr_cmp_ui(temp, -l) != 0);
! 1213: mpfr_clear(temp);
! 1214: return b;
! 1215: }
! 1216: }
! 1217: }
! 1218: static bool eval(mpfr_srcptr f, double d)
! 1219: {
! 1220: bool b;
! 1221: mpfr_t temp;
! 1222: mpfr_init2(temp, 8*sizeof(double));
! 1223: mpfr_set_d(temp, d, __gmp_default_rounding_mode);
! 1224: b = (mpfr_cmp(f, temp) != 0);
! 1225: mpfr_clear(temp);
! 1226: return b;
! 1227: }
! 1228: static bool eval(double d, mpfr_srcptr f)
! 1229: {
! 1230: bool b;
! 1231: mpfr_t temp;
! 1232: mpfr_init2(temp, 8*sizeof(double));
! 1233: mpfr_set_d(temp, d, __gmp_default_rounding_mode);
! 1234: b = (mpfr_cmp(temp, f) != 0);
! 1235: mpfr_clear(temp);
! 1236: return b;
! 1237: }
! 1238: #endif
! 1239: };
! 1240:
! 1241: struct __gmp_binary_less
! 1242: {
! 1243: static bool eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w) < 0; }
! 1244:
! 1245: static bool eval(mpz_srcptr z, unsigned long int l)
! 1246: { return mpz_cmp_ui(z, l) < 0; }
! 1247: static bool eval(unsigned long int l, mpz_srcptr z)
! 1248: { return mpz_cmp_ui(z, l) > 0; }
! 1249: static bool eval(mpz_srcptr z, signed long int l)
! 1250: { return mpz_cmp_si(z, l) < 0; }
! 1251: static bool eval(signed long int l, mpz_srcptr z)
! 1252: { return mpz_cmp_si(z, l) > 0; }
! 1253: static bool eval(mpz_srcptr z, double d)
! 1254: { return mpz_cmp_d(z, d) < 0; }
! 1255: static bool eval(double d, mpz_srcptr z)
! 1256: { return mpz_cmp_d(z, d) > 0; }
! 1257:
! 1258: static bool eval(mpq_srcptr q, mpq_srcptr r) { return mpq_cmp(q, r) < 0; }
! 1259:
! 1260: static bool eval(mpq_srcptr q, unsigned long int l)
! 1261: { return mpq_cmp_ui(q, l, 1) < 0; }
! 1262: static bool eval(unsigned long int l, mpq_srcptr q)
! 1263: { return mpq_cmp_ui(q, l, 1) > 0; }
! 1264: static bool eval(mpq_srcptr q, signed long int l)
! 1265: { return mpq_cmp_si(q, l, 1) < 0; }
! 1266: static bool eval(signed long int l, mpq_srcptr q)
! 1267: { return mpq_cmp_si(q, l, 1) > 0; }
! 1268: static bool eval(mpq_srcptr q, double d)
! 1269: {
! 1270: bool b;
! 1271: mpq_t temp;
! 1272: mpq_init(temp);
! 1273: mpq_set_d(temp, d);
! 1274: b = (mpq_cmp(q, temp) < 0);
! 1275: mpq_clear(temp);
! 1276: return b;
! 1277: }
! 1278: static bool eval(double d, mpq_srcptr q)
! 1279: {
! 1280: bool b;
! 1281: mpq_t temp;
! 1282: mpq_init(temp);
! 1283: mpq_set_d(temp, d);
! 1284: b = (mpq_cmp(temp, q) < 0);
! 1285: mpq_clear(temp);
! 1286: return b;
! 1287: }
! 1288:
! 1289: static bool eval(mpf_srcptr f, mpf_srcptr g) { return mpf_cmp(f, g) < 0; }
! 1290:
! 1291: static bool eval(mpf_srcptr f, unsigned long int l)
! 1292: { return mpf_cmp_ui(f, l) < 0; }
! 1293: static bool eval(unsigned long int l, mpf_srcptr f)
! 1294: { return mpf_cmp_ui(f, l) > 0; }
! 1295: static bool eval(mpf_srcptr f, signed long int l)
! 1296: { return mpf_cmp_si(f, l) < 0; }
! 1297: static bool eval(signed long int l, mpf_srcptr f)
! 1298: { return mpf_cmp_si(f, l) > 0; }
! 1299: static bool eval(mpf_srcptr f, double d)
! 1300: { return mpf_cmp_d(f, d) < 0; }
! 1301: static bool eval(double d, mpf_srcptr f)
! 1302: { return mpf_cmp_d(f, d) > 0; }
! 1303:
! 1304: #ifdef __MPFR_H
! 1305: static bool eval(mpfr_srcptr f, mpfr_srcptr g)
! 1306: { return mpfr_cmp(f, g) < 0; }
! 1307:
! 1308: static bool eval(mpfr_srcptr f, unsigned long int l)
! 1309: { return mpfr_cmp_ui(f, l) < 0; }
! 1310: static bool eval(unsigned long int l, mpfr_srcptr f)
! 1311: { return mpfr_cmp_ui(f, l) > 0; }
! 1312: static bool eval(mpfr_srcptr f, signed long int l)
! 1313: {
! 1314: if (mpfr_sgn(f) >= 0)
! 1315: {
! 1316: if (l >= 0)
! 1317: return mpfr_cmp_ui(f, l) < 0;
! 1318: else
! 1319: return false;
! 1320: }
! 1321: else
! 1322: {
! 1323: if (l >= 0)
! 1324: return true;
! 1325: else
! 1326: {
! 1327: bool b;
! 1328: mpfr_t temp;
! 1329: mpfr_init2(temp, mpfr_get_prec(f));
! 1330: mpfr_neg(temp, f, __gmp_default_rounding_mode);
! 1331: b = (mpfr_cmp_ui(temp, -l) > 0);
! 1332: mpfr_clear(temp);
! 1333: return b;
! 1334: }
! 1335: }
! 1336: }
! 1337: static bool eval(signed long int l, mpfr_srcptr f)
! 1338: {
! 1339: if (mpfr_sgn(f) >= 0)
! 1340: {
! 1341: if (l >= 0)
! 1342: return mpfr_cmp_ui(f, l) > 0;
! 1343: else
! 1344: return true;
! 1345: }
! 1346: else
! 1347: {
! 1348: if (l >= 0)
! 1349: return false;
! 1350: else
! 1351: {
! 1352: bool b;
! 1353: mpfr_t temp;
! 1354: mpfr_init2(temp, mpfr_get_prec(f));
! 1355: mpfr_neg(temp, f, __gmp_default_rounding_mode);
! 1356: b = (mpfr_cmp_ui(temp, -l) < 0);
! 1357: mpfr_clear(temp);
! 1358: return b;
! 1359: }
! 1360: }
! 1361: }
! 1362: static bool eval(mpfr_srcptr f, double d)
! 1363: {
! 1364: bool b;
! 1365: mpfr_t temp;
! 1366: mpfr_init2(temp, 8*sizeof(double));
! 1367: mpfr_set_d(temp, d, __gmp_default_rounding_mode);
! 1368: b = (mpfr_cmp(f, temp) < 0);
! 1369: mpfr_clear(temp);
! 1370: return b;
! 1371: }
! 1372: static bool eval(double d, mpfr_srcptr f)
! 1373: {
! 1374: bool b;
! 1375: mpfr_t temp;
! 1376: mpfr_init2(temp, 8*sizeof(double));
! 1377: mpfr_set_d(temp, d, __gmp_default_rounding_mode);
! 1378: b = (mpfr_cmp(temp, f) < 0);
! 1379: mpfr_clear(temp);
! 1380: return b;
! 1381: }
! 1382: #endif
! 1383: };
! 1384:
! 1385: struct __gmp_binary_less_equal
! 1386: {
! 1387: static bool eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w) <= 0; }
! 1388:
! 1389: static bool eval(mpz_srcptr z, unsigned long int l)
! 1390: { return mpz_cmp_ui(z, l) <= 0; }
! 1391: static bool eval(unsigned long int l, mpz_srcptr z)
! 1392: { return mpz_cmp_ui(z, l) >= 0; }
! 1393: static bool eval(mpz_srcptr z, signed long int l)
! 1394: { return mpz_cmp_si(z, l) <= 0; }
! 1395: static bool eval(signed long int l, mpz_srcptr z)
! 1396: { return mpz_cmp_si(z, l) >= 0; }
! 1397: static bool eval(mpz_srcptr z, double d)
! 1398: { return mpz_cmp_d(z, d) <= 0; }
! 1399: static bool eval(double d, mpz_srcptr z)
! 1400: { return mpz_cmp_d(z, d) >= 0; }
! 1401:
! 1402: static bool eval(mpq_srcptr q, mpq_srcptr r) { return mpq_cmp(q, r) <= 0; }
! 1403:
! 1404: static bool eval(mpq_srcptr q, unsigned long int l)
! 1405: { return mpq_cmp_ui(q, l, 1) <= 0; }
! 1406: static bool eval(unsigned long int l, mpq_srcptr q)
! 1407: { return mpq_cmp_ui(q, l, 1) >= 0; }
! 1408: static bool eval(mpq_srcptr q, signed long int l)
! 1409: { return mpq_cmp_si(q, l, 1) <= 0; }
! 1410: static bool eval(signed long int l, mpq_srcptr q)
! 1411: { return mpq_cmp_si(q, l, 1) >= 0; }
! 1412: static bool eval(mpq_srcptr q, double d)
! 1413: {
! 1414: bool b;
! 1415: mpq_t temp;
! 1416: mpq_init(temp);
! 1417: mpq_set_d(temp, d);
! 1418: b = (mpq_cmp(q, temp) <= 0);
! 1419: mpq_clear(temp);
! 1420: return b;
! 1421: }
! 1422: static bool eval(double d, mpq_srcptr q)
! 1423: {
! 1424: bool b;
! 1425: mpq_t temp;
! 1426: mpq_init(temp);
! 1427: mpq_set_d(temp, d);
! 1428: b = (mpq_cmp(temp, q) <= 0);
! 1429: mpq_clear(temp);
! 1430: return b;
! 1431: }
! 1432:
! 1433: static bool eval(mpf_srcptr f, mpf_srcptr g) { return mpf_cmp(f, g) <= 0; }
! 1434:
! 1435: static bool eval(mpf_srcptr f, unsigned long int l)
! 1436: { return mpf_cmp_ui(f, l) <= 0; }
! 1437: static bool eval(unsigned long int l, mpf_srcptr f)
! 1438: { return mpf_cmp_ui(f, l) >= 0; }
! 1439: static bool eval(mpf_srcptr f, signed long int l)
! 1440: { return mpf_cmp_si(f, l) <= 0; }
! 1441: static bool eval(signed long int l, mpf_srcptr f)
! 1442: { return mpf_cmp_si(f, l) >= 0; }
! 1443: static bool eval(mpf_srcptr f, double d)
! 1444: { return mpf_cmp_d(f, d) <= 0; }
! 1445: static bool eval(double d, mpf_srcptr f)
! 1446: { return mpf_cmp_d(f, d) >= 0; }
! 1447:
! 1448: #ifdef __MPFR_H
! 1449: static bool eval(mpfr_srcptr f, mpfr_srcptr g)
! 1450: { return mpfr_cmp(f, g) <= 0; }
! 1451:
! 1452: static bool eval(mpfr_srcptr f, unsigned long int l)
! 1453: { return mpfr_cmp_ui(f, l) <= 0; }
! 1454: static bool eval(unsigned long int l, mpfr_srcptr f)
! 1455: { return mpfr_cmp_ui(f, l) >= 0; }
! 1456: static bool eval(mpfr_srcptr f, signed long int l)
! 1457: {
! 1458: if (mpfr_sgn(f) >= 0)
! 1459: {
! 1460: if (l >= 0)
! 1461: return mpfr_cmp_ui(f, l) <= 0;
! 1462: else
! 1463: return false;
! 1464: }
! 1465: else
! 1466: {
! 1467: if (l >= 0)
! 1468: return true;
! 1469: else
! 1470: {
! 1471: bool b;
! 1472: mpfr_t temp;
! 1473: mpfr_init2(temp, mpfr_get_prec(f));
! 1474: mpfr_neg(temp, f, __gmp_default_rounding_mode);
! 1475: b = (mpfr_cmp_ui(temp, -l) >= 0);
! 1476: mpfr_clear(temp);
! 1477: return b;
! 1478: }
! 1479: }
! 1480: }
! 1481: static bool eval(signed long int l, mpfr_srcptr f)
! 1482: {
! 1483: if (mpfr_sgn(f) >= 0)
! 1484: {
! 1485: if (l >= 0)
! 1486: return mpfr_cmp_ui(f, l) >= 0;
! 1487: else
! 1488: return true;
! 1489: }
! 1490: else
! 1491: {
! 1492: if (l >= 0)
! 1493: return false;
! 1494: else
! 1495: {
! 1496: bool b;
! 1497: mpfr_t temp;
! 1498: mpfr_init2(temp, mpfr_get_prec(f));
! 1499: mpfr_neg(temp, f, __gmp_default_rounding_mode);
! 1500: b = (mpfr_cmp_ui(temp, -l) <= 0);
! 1501: mpfr_clear(temp);
! 1502: return b;
! 1503: }
! 1504: }
! 1505: }
! 1506: static bool eval(mpfr_srcptr f, double d)
! 1507: {
! 1508: bool b;
! 1509: mpfr_t temp;
! 1510: mpfr_init2(temp, 8*sizeof(double));
! 1511: mpfr_set_d(temp, d, __gmp_default_rounding_mode);
! 1512: b = (mpfr_cmp(f, temp) <= 0);
! 1513: mpfr_clear(temp);
! 1514: return b;
! 1515: }
! 1516: static bool eval(double d, mpfr_srcptr f)
! 1517: {
! 1518: bool b;
! 1519: mpfr_t temp;
! 1520: mpfr_init2(temp, 8*sizeof(double));
! 1521: mpfr_set_d(temp, d, __gmp_default_rounding_mode);
! 1522: b = (mpfr_cmp(temp, f) <= 0);
! 1523: mpfr_clear(temp);
! 1524: return b;
! 1525: }
! 1526: #endif
! 1527: };
! 1528:
! 1529: struct __gmp_binary_greater
! 1530: {
! 1531: static bool eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w) > 0; }
! 1532:
! 1533: static bool eval(mpz_srcptr z, unsigned long int l)
! 1534: { return mpz_cmp_ui(z, l) > 0; }
! 1535: static bool eval(unsigned long int l, mpz_srcptr z)
! 1536: { return mpz_cmp_ui(z, l) < 0; }
! 1537: static bool eval(mpz_srcptr z, signed long int l)
! 1538: { return mpz_cmp_si(z, l) > 0; }
! 1539: static bool eval(signed long int l, mpz_srcptr z)
! 1540: { return mpz_cmp_si(z, l) < 0; }
! 1541: static bool eval(mpz_srcptr z, double d)
! 1542: { return mpz_cmp_d(z, d) > 0; }
! 1543: static bool eval(double d, mpz_srcptr z)
! 1544: { return mpz_cmp_d(z, d) < 0; }
! 1545:
! 1546: static bool eval(mpq_srcptr q, mpq_srcptr r) { return mpq_cmp(q, r) > 0; }
! 1547:
! 1548: static bool eval(mpq_srcptr q, unsigned long int l)
! 1549: { return mpq_cmp_ui(q, l, 1) > 0; }
! 1550: static bool eval(unsigned long int l, mpq_srcptr q)
! 1551: { return mpq_cmp_ui(q, l, 1) < 0; }
! 1552: static bool eval(mpq_srcptr q, signed long int l)
! 1553: { return mpq_cmp_si(q, l, 1) > 0; }
! 1554: static bool eval(signed long int l, mpq_srcptr q)
! 1555: { return mpq_cmp_si(q, l, 1) < 0; }
! 1556: static bool eval(mpq_srcptr q, double d)
! 1557: {
! 1558: bool b;
! 1559: mpq_t temp;
! 1560: mpq_init(temp);
! 1561: mpq_set_d(temp, d);
! 1562: b = (mpq_cmp(q, temp) > 0);
! 1563: mpq_clear(temp);
! 1564: return b;
! 1565: }
! 1566: static bool eval(double d, mpq_srcptr q)
! 1567: {
! 1568: bool b;
! 1569: mpq_t temp;
! 1570: mpq_init(temp);
! 1571: mpq_set_d(temp, d);
! 1572: b = (mpq_cmp(temp, q) > 0);
! 1573: mpq_clear(temp);
! 1574: return b;
! 1575: }
! 1576:
! 1577: static bool eval(mpf_srcptr f, mpf_srcptr g) { return mpf_cmp(f, g) > 0; }
! 1578:
! 1579: static bool eval(mpf_srcptr f, unsigned long int l)
! 1580: { return mpf_cmp_ui(f, l) > 0; }
! 1581: static bool eval(unsigned long int l, mpf_srcptr f)
! 1582: { return mpf_cmp_ui(f, l) < 0; }
! 1583: static bool eval(mpf_srcptr f, signed long int l)
! 1584: { return mpf_cmp_si(f, l) > 0; }
! 1585: static bool eval(signed long int l, mpf_srcptr f)
! 1586: { return mpf_cmp_si(f, l) < 0; }
! 1587: static bool eval(mpf_srcptr f, double d)
! 1588: { return mpf_cmp_d(f, d) > 0; }
! 1589: static bool eval(double d, mpf_srcptr f)
! 1590: { return mpf_cmp_d(f, d) < 0; }
! 1591:
! 1592: #ifdef __MPFR_H
! 1593: static bool eval(mpfr_srcptr f, mpfr_srcptr g)
! 1594: { return mpfr_cmp(f, g) > 0; }
! 1595:
! 1596: static bool eval(mpfr_srcptr f, unsigned long int l)
! 1597: { return mpfr_cmp_ui(f, l) > 0; }
! 1598: static bool eval(unsigned long int l, mpfr_srcptr f)
! 1599: { return mpfr_cmp_ui(f, l) < 0; }
! 1600: static bool eval(mpfr_srcptr f, signed long int l)
! 1601: {
! 1602: if (mpfr_sgn(f) >= 0)
! 1603: {
! 1604: if (l >= 0)
! 1605: return mpfr_cmp_ui(f, l) > 0;
! 1606: else
! 1607: return true;
! 1608: }
! 1609: else
! 1610: {
! 1611: if (l >= 0)
! 1612: return false;
! 1613: else
! 1614: {
! 1615: bool b;
! 1616: mpfr_t temp;
! 1617: mpfr_init2(temp, mpfr_get_prec(f));
! 1618: mpfr_neg(temp, f, __gmp_default_rounding_mode);
! 1619: b = (mpfr_cmp_ui(temp, -l) < 0);
! 1620: mpfr_clear(temp);
! 1621: return b;
! 1622: }
! 1623: }
! 1624: }
! 1625: static bool eval(signed long int l, mpfr_srcptr f)
! 1626: {
! 1627: if (mpfr_sgn(f) >= 0)
! 1628: {
! 1629: if (l >= 0)
! 1630: return mpfr_cmp_ui(f, l) < 0;
! 1631: else
! 1632: return false;
! 1633: }
! 1634: else
! 1635: {
! 1636: if (l >= 0)
! 1637: return true;
! 1638: else
! 1639: {
! 1640: bool b;
! 1641: mpfr_t temp;
! 1642: mpfr_init2(temp, mpfr_get_prec(f));
! 1643: mpfr_neg(temp, f, __gmp_default_rounding_mode);
! 1644: b = (mpfr_cmp_ui(temp, -l) > 0);
! 1645: mpfr_clear(temp);
! 1646: return b;
! 1647: }
! 1648: }
! 1649: }
! 1650: static bool eval(mpfr_srcptr f, double d)
! 1651: {
! 1652: bool b;
! 1653: mpfr_t temp;
! 1654: mpfr_init2(temp, 8*sizeof(double));
! 1655: mpfr_set_d(temp, d, __gmp_default_rounding_mode);
! 1656: b = (mpfr_cmp(f, temp) > 0);
! 1657: mpfr_clear(temp);
! 1658: return b;
! 1659: }
! 1660: static bool eval(double d, mpfr_srcptr f)
! 1661: {
! 1662: bool b;
! 1663: mpfr_t temp;
! 1664: mpfr_init2(temp, 8*sizeof(double));
! 1665: mpfr_set_d(temp, d, __gmp_default_rounding_mode);
! 1666: b = (mpfr_cmp(temp, f) > 0);
! 1667: mpfr_clear(temp);
! 1668: return b;
! 1669: }
! 1670: #endif
! 1671: };
! 1672:
! 1673: struct __gmp_binary_greater_equal
! 1674: {
! 1675: static bool eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w) >= 0; }
! 1676:
! 1677: static bool eval(mpz_srcptr z, unsigned long int l)
! 1678: { return mpz_cmp_ui(z, l) >= 0; }
! 1679: static bool eval(unsigned long int l, mpz_srcptr z)
! 1680: { return mpz_cmp_ui(z, l) <= 0; }
! 1681: static bool eval(mpz_srcptr z, signed long int l)
! 1682: { return mpz_cmp_si(z, l) >= 0; }
! 1683: static bool eval(signed long int l, mpz_srcptr z)
! 1684: { return mpz_cmp_si(z, l) <= 0; }
! 1685: static bool eval(mpz_srcptr z, double d)
! 1686: { return mpz_cmp_d(z, d) >= 0; }
! 1687: static bool eval(double d, mpz_srcptr z)
! 1688: { return mpz_cmp_d(z, d) <= 0; }
! 1689:
! 1690: static bool eval(mpq_srcptr q, mpq_srcptr r) { return mpq_cmp(q, r) >= 0; }
! 1691:
! 1692: static bool eval(mpq_srcptr q, unsigned long int l)
! 1693: { return mpq_cmp_ui(q, l, 1) >= 0; }
! 1694: static bool eval(unsigned long int l, mpq_srcptr q)
! 1695: { return mpq_cmp_ui(q, l, 1) <= 0; }
! 1696: static bool eval(mpq_srcptr q, signed long int l)
! 1697: { return mpq_cmp_si(q, l, 1) >= 0; }
! 1698: static bool eval(signed long int l, mpq_srcptr q)
! 1699: { return mpq_cmp_si(q, l, 1) <= 0; }
! 1700: static bool eval(mpq_srcptr q, double d)
! 1701: {
! 1702: bool b;
! 1703: mpq_t temp;
! 1704: mpq_init(temp);
! 1705: mpq_set_d(temp, d);
! 1706: b = (mpq_cmp(q, temp) >= 0);
! 1707: mpq_clear(temp);
! 1708: return b;
! 1709: }
! 1710: static bool eval(double d, mpq_srcptr q)
! 1711: {
! 1712: bool b;
! 1713: mpq_t temp;
! 1714: mpq_init(temp);
! 1715: mpq_set_d(temp, d);
! 1716: b = (mpq_cmp(temp, q) >= 0);
! 1717: mpq_clear(temp);
! 1718: return b;
! 1719: }
! 1720:
! 1721: static bool eval(mpf_srcptr f, mpf_srcptr g) { return mpf_cmp(f, g) >= 0; }
! 1722:
! 1723: static bool eval(mpf_srcptr f, unsigned long int l)
! 1724: { return mpf_cmp_ui(f, l) >= 0; }
! 1725: static bool eval(unsigned long int l, mpf_srcptr f)
! 1726: { return mpf_cmp_ui(f, l) <= 0; }
! 1727: static bool eval(mpf_srcptr f, signed long int l)
! 1728: { return mpf_cmp_si(f, l) >= 0; }
! 1729: static bool eval(signed long int l, mpf_srcptr f)
! 1730: { return mpf_cmp_si(f, l) <= 0; }
! 1731: static bool eval(mpf_srcptr f, double d)
! 1732: { return mpf_cmp_d(f, d) >= 0; }
! 1733: static bool eval(double d, mpf_srcptr f)
! 1734: { return mpf_cmp_d(f, d) <= 0; }
! 1735:
! 1736: #ifdef __MPFR_H
! 1737: static bool eval(mpfr_srcptr f, mpfr_srcptr g)
! 1738: { return mpfr_cmp(f, g) >= 0; }
! 1739:
! 1740: static bool eval(mpfr_srcptr f, unsigned long int l)
! 1741: { return mpfr_cmp_ui(f, l) >= 0; }
! 1742: static bool eval(unsigned long int l, mpfr_srcptr f)
! 1743: { return mpfr_cmp_ui(f, l) <= 0; }
! 1744: static bool eval(mpfr_srcptr f, signed long int l)
! 1745: {
! 1746: if (mpfr_sgn(f) >= 0)
! 1747: {
! 1748: if (l >= 0)
! 1749: return mpfr_cmp_ui(f, l) >= 0;
! 1750: else
! 1751: return true;
! 1752: }
! 1753: else
! 1754: {
! 1755: if (l >= 0)
! 1756: return false;
! 1757: else
! 1758: {
! 1759: bool b;
! 1760: mpfr_t temp;
! 1761: mpfr_init2(temp, mpfr_get_prec(f));
! 1762: mpfr_neg(temp, f, __gmp_default_rounding_mode);
! 1763: b = (mpfr_cmp_ui(temp, -l) <= 0);
! 1764: mpfr_clear(temp);
! 1765: return b;
! 1766: }
! 1767: }
! 1768: }
! 1769: static bool eval(signed long int l, mpfr_srcptr f)
! 1770: {
! 1771: if (mpfr_sgn(f) >= 0)
! 1772: {
! 1773: if (l >= 0)
! 1774: return mpfr_cmp_ui(f, l) <= 0;
! 1775: else
! 1776: return false;
! 1777: }
! 1778: else
! 1779: {
! 1780: if (l >= 0)
! 1781: return true;
! 1782: else
! 1783: {
! 1784: bool b;
! 1785: mpfr_t temp;
! 1786: mpfr_init2(temp, mpfr_get_prec(f));
! 1787: mpfr_neg(temp, f, __gmp_default_rounding_mode);
! 1788: b = (mpfr_cmp_ui(temp, -l) >= 0);
! 1789: mpfr_clear(temp);
! 1790: return b;
! 1791: }
! 1792: }
! 1793: }
! 1794: static bool eval(mpfr_srcptr f, double d)
! 1795: {
! 1796: bool b;
! 1797: mpfr_t temp;
! 1798: mpfr_init2(temp, 8*sizeof(double));
! 1799: mpfr_set_d(temp, d, __gmp_default_rounding_mode);
! 1800: b = (mpfr_cmp(f, temp) >= 0);
! 1801: mpfr_clear(temp);
! 1802: return b;
! 1803: }
! 1804: static bool eval(double d, mpfr_srcptr f)
! 1805: {
! 1806: bool b;
! 1807: mpfr_t temp;
! 1808: mpfr_init2(temp, 8*sizeof(double));
! 1809: mpfr_set_d(temp, d, __gmp_default_rounding_mode);
! 1810: b = (mpfr_cmp(temp, f) >= 0);
! 1811: mpfr_clear(temp);
! 1812: return b;
! 1813: }
! 1814: #endif
! 1815: };
! 1816:
! 1817: struct __gmp_unary_increment
! 1818: {
! 1819: static void eval(mpz_ptr z, mpz_srcptr w) { mpz_add_ui(z, w, 1); }
! 1820: static void eval(mpq_ptr q, mpq_srcptr r)
! 1821: { mpz_add(mpq_numref(q), mpq_numref(r), mpq_denref(r)); }
! 1822: static void eval(mpf_ptr f, mpf_srcptr g) { mpf_add_ui(f, g, 1); }
! 1823: #ifdef __MPFR_H
! 1824: static void eval(mpfr_ptr f, mpfr_srcptr g, mp_rnd_t mode)
! 1825: { mpfr_add_ui(f, g, 1, mode); }
! 1826: #endif
! 1827: };
! 1828:
! 1829: struct __gmp_unary_decrement
! 1830: {
! 1831: static void eval(mpz_ptr z, mpz_srcptr w) { mpz_sub_ui(z, w, 1); }
! 1832: static void eval(mpq_ptr q, mpq_srcptr r)
! 1833: { mpz_sub(mpq_numref(q), mpq_numref(r), mpq_denref(r)); }
! 1834: static void eval(mpf_ptr f, mpf_srcptr g) { mpf_sub_ui(f, g, 1); }
! 1835: #ifdef __MPFR_H
! 1836: static void eval(mpfr_ptr f, mpfr_srcptr g, mp_rnd_t mode)
! 1837: { mpfr_sub_ui(f, g, 1, mode); }
! 1838: #endif
! 1839: };
! 1840:
! 1841: struct __gmp_abs_function
! 1842: {
! 1843: static void eval(mpz_ptr z, mpz_srcptr w) { mpz_abs(z, w); }
! 1844: static void eval(mpq_ptr q, mpq_srcptr r) { mpq_abs(q, r); }
! 1845: static void eval(mpf_ptr f, mpf_srcptr g) { mpf_abs(f, g); }
! 1846: #ifdef __MPFR_H
! 1847: static void eval(mpfr_ptr f, mpfr_srcptr g, mp_rnd_t mode)
! 1848: { mpfr_abs(f, g, mode); }
! 1849: #endif
! 1850: };
! 1851:
! 1852: struct __gmp_trunc_function
! 1853: {
! 1854: static void eval(mpf_ptr f, mpf_srcptr g) { mpf_trunc(f, g); }
! 1855: #ifdef __MPFR_H
! 1856: static void eval(mpfr_ptr f, mpfr_srcptr g, mp_rnd_t) { mpfr_trunc(f, g); }
! 1857: #endif
! 1858: };
! 1859:
! 1860: struct __gmp_floor_function
! 1861: {
! 1862: static void eval(mpf_ptr f, mpf_srcptr g) { mpf_floor(f, g); }
! 1863: #ifdef __MPFR_H
! 1864: static void eval(mpfr_ptr f, mpfr_srcptr g, mp_rnd_t) { mpfr_floor(f, g); }
! 1865: #endif
! 1866: };
! 1867:
! 1868: struct __gmp_ceil_function
! 1869: {
! 1870: static void eval(mpf_ptr f, mpf_srcptr g) { mpf_ceil(f, g); }
! 1871: #ifdef __MPFR_H
! 1872: static void eval(mpfr_ptr f, mpfr_srcptr g, mp_rnd_t) { mpfr_ceil(f, g); }
! 1873: #endif
! 1874: };
! 1875:
! 1876: struct __gmp_sqrt_function
! 1877: {
! 1878: static void eval(mpz_ptr z, mpz_srcptr w) { mpz_sqrt(z, w); }
! 1879: static void eval(mpf_ptr f, mpf_srcptr g) { mpf_sqrt(f, g); }
! 1880: #ifdef __MPFR_H
! 1881: static void eval(mpfr_ptr f, mpfr_srcptr g, mp_rnd_t mode)
! 1882: { mpfr_sqrt(f, g, mode); }
! 1883: #endif
! 1884: };
! 1885:
! 1886: struct __gmp_hypot_function
! 1887: {
! 1888: static void eval(mpf_ptr f, mpf_srcptr g, mpf_srcptr h)
! 1889: {
! 1890: mpf_t temp;
! 1891: mpf_init2(temp, mpf_get_prec(f));
! 1892: mpf_mul(temp, g, g);
! 1893: mpf_mul(f, h, h);
! 1894: mpf_add(f, f, temp);
! 1895: mpf_sqrt(f, f);
! 1896: mpf_clear(temp);
! 1897: }
! 1898:
! 1899: static void eval(mpf_ptr f, mpf_srcptr g, unsigned long int l)
! 1900: {
! 1901: mpf_t temp;
! 1902: mpf_init2(temp, mpf_get_prec(f));
! 1903: mpf_mul(temp, g, g);
! 1904: mpf_set_ui(f, l);
! 1905: mpf_mul(f, f, f);
! 1906: mpf_add(f, f, temp);
! 1907: mpf_sqrt(f, f);
! 1908: mpf_clear(temp);
! 1909: }
! 1910: static void eval(mpf_ptr f, unsigned long int l, mpf_srcptr g)
! 1911: {
! 1912: mpf_t temp;
! 1913: mpf_init2(temp, mpf_get_prec(f));
! 1914: mpf_mul(temp, g, g);
! 1915: mpf_set_ui(f, l);
! 1916: mpf_mul(f, f, f);
! 1917: mpf_add(f, f, temp);
! 1918: mpf_sqrt(f, f);
! 1919: mpf_clear(temp);
! 1920: }
! 1921: static void eval(mpf_ptr f, mpf_srcptr g, signed long int l)
! 1922: {
! 1923: mpf_t temp;
! 1924: mpf_init2(temp, mpf_get_prec(f));
! 1925: mpf_mul(temp, g, g);
! 1926: mpf_set_si(f, l);
! 1927: mpf_mul(f, f, f);
! 1928: mpf_add(f, f, temp);
! 1929: mpf_sqrt(f, f);
! 1930: mpf_clear(temp);
! 1931: }
! 1932: static void eval(mpf_ptr f, signed long int l, mpf_srcptr g)
! 1933: {
! 1934: mpf_t temp;
! 1935: mpf_init2(temp, mpf_get_prec(f));
! 1936: mpf_mul(temp, g, g);
! 1937: mpf_set_si(f, l);
! 1938: mpf_mul(f, f, f);
! 1939: mpf_add(f, f, temp);
! 1940: mpf_sqrt(f, f);
! 1941: mpf_clear(temp);
! 1942: }
! 1943: static void eval(mpf_ptr f, mpf_srcptr g, double d)
! 1944: {
! 1945: mpf_t temp;
! 1946: mpf_init2(temp, mpf_get_prec(f));
! 1947: mpf_mul(temp, g, g);
! 1948: mpf_set_d(f, d);
! 1949: mpf_mul(f, f, f);
! 1950: mpf_add(f, f, temp);
! 1951: mpf_sqrt(f, f);
! 1952: mpf_clear(temp);
! 1953: }
! 1954: static void eval(mpf_ptr f, double d, mpf_srcptr g)
! 1955: {
! 1956: mpf_t temp;
! 1957: mpf_init2(temp, mpf_get_prec(f));
! 1958: mpf_mul(temp, g, g);
! 1959: mpf_set_d(f, d);
! 1960: mpf_mul(f, f, f);
! 1961: mpf_add(f, f, temp);
! 1962: mpf_sqrt(f, f);
! 1963: mpf_clear(temp);
! 1964: }
! 1965:
! 1966: #ifdef __MPFR_H
! 1967: static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h, mp_rnd_t mode)
! 1968: {
! 1969: mpfr_t temp;
! 1970: mpfr_init2(temp, mpfr_get_prec(f));
! 1971: mpfr_mul(temp, g, g, mode);
! 1972: mpfr_mul(f, h, h, mode);
! 1973: mpfr_add(f, f, temp, mode);
! 1974: mpfr_sqrt(f, f, mode);
! 1975: mpfr_clear(temp);
! 1976: }
! 1977:
! 1978: static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l,
! 1979: mp_rnd_t mode)
! 1980: {
! 1981: mpfr_t temp;
! 1982: mpfr_init2(temp, mpfr_get_prec(f));
! 1983: mpfr_mul(temp, g, g, mode);
! 1984: mpfr_set_ui(f, l, mode);
! 1985: mpfr_mul(f, f, f, mode);
! 1986: mpfr_add(f, f, temp, mode);
! 1987: mpfr_sqrt(f, f, mode);
! 1988: mpfr_clear(temp);
! 1989: }
! 1990: static void eval(mpfr_ptr f, unsigned long int l, mpfr_srcptr g,
! 1991: mp_rnd_t mode)
! 1992: {
! 1993: mpfr_t temp;
! 1994: mpfr_init2(temp, mpfr_get_prec(f));
! 1995: mpfr_mul(temp, g, g, mode);
! 1996: mpfr_set_ui(f, l, mode);
! 1997: mpfr_mul(f, f, f, mode);
! 1998: mpfr_add(f, f, temp, mode);
! 1999: mpfr_sqrt(f, f, mode);
! 2000: mpfr_clear(temp);
! 2001: }
! 2002: static void eval(mpfr_ptr f, mpfr_srcptr g, signed long int l,
! 2003: mp_rnd_t mode)
! 2004: {
! 2005: mpfr_t temp;
! 2006: mpfr_init2(temp, mpfr_get_prec(f));
! 2007: mpfr_mul(temp, g, g, mode);
! 2008: mpfr_set_si(f, l, mode);
! 2009: mpfr_mul(f, f, f, mode);
! 2010: mpfr_add(f, f, temp, mode);
! 2011: mpfr_sqrt(f, f, mode);
! 2012: mpfr_clear(temp);
! 2013: }
! 2014: static void eval(mpfr_ptr f, signed long int l, mpfr_srcptr g,
! 2015: mp_rnd_t mode)
! 2016: {
! 2017: mpfr_t temp;
! 2018: mpfr_init2(temp, mpfr_get_prec(f));
! 2019: mpfr_mul(temp, g, g, mode);
! 2020: mpfr_set_si(f, l, mode);
! 2021: mpfr_mul(f, f, f, mode);
! 2022: mpfr_add(f, f, temp, mode);
! 2023: mpfr_sqrt(f, f, mode);
! 2024: mpfr_clear(temp);
! 2025: }
! 2026: static void eval(mpfr_ptr f, mpfr_srcptr g, double d, mp_rnd_t mode)
! 2027: {
! 2028: mpfr_t temp;
! 2029: mpfr_init2(temp, mpfr_get_prec(f));
! 2030: mpfr_mul(temp, g, g, mode);
! 2031: mpfr_set_d(f, d, mode);
! 2032: mpfr_mul(f, f, f, mode);
! 2033: mpfr_add(f, f, temp, mode);
! 2034: mpfr_sqrt(f, f, mode);
! 2035: mpfr_clear(temp);
! 2036: }
! 2037: static void eval(mpfr_ptr f, double d, mpfr_srcptr g, mp_rnd_t mode)
! 2038: {
! 2039: mpfr_t temp;
! 2040: mpfr_init2(temp, mpfr_get_prec(f));
! 2041: mpfr_mul(temp, g, g, mode);
! 2042: mpfr_set_d(f, d, mode);
! 2043: mpfr_mul(f, f, f, mode);
! 2044: mpfr_add(f, f, temp, mode);
! 2045: mpfr_sqrt(f, f, mode);
! 2046: mpfr_clear(temp);
! 2047: }
! 2048: #endif
! 2049: };
! 2050:
! 2051: struct __gmp_sgn_function
! 2052: {
! 2053: static int eval(mpz_srcptr z) { return mpz_sgn(z); }
! 2054: static int eval(mpq_srcptr q) { return mpq_sgn(q); }
! 2055: static int eval(mpf_srcptr f) { return mpf_sgn(f); }
! 2056: #ifdef __MPFR_H
! 2057: static int eval(mpfr_srcptr f) { return mpfr_cmp_ui(f, 0); }
! 2058: #endif
! 2059: };
! 2060:
! 2061: struct __gmp_cmp_function
! 2062: {
! 2063: static int eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w); }
! 2064: static int eval(mpq_srcptr q, mpq_srcptr r) { return mpq_cmp(q, r); }
! 2065: static int eval(mpf_srcptr f, mpf_srcptr g) { return mpf_cmp(f, g); }
! 2066: #ifdef __MPFR_H
! 2067: static int eval(mpfr_srcptr f, mpfr_srcptr g) { return mpfr_cmp(f, g); }
! 2068: #endif
! 2069: };
! 2070:
! 2071: struct __gmp_rand_function
! 2072: {
! 2073: static void eval(mpz_ptr z, gmp_randstate_t s, unsigned long int l)
! 2074: { mpz_urandomb(z, s, l); }
! 2075: static void eval(mpz_ptr z, gmp_randstate_t s, mpz_srcptr w)
! 2076: { mpz_urandomm(z, s, w); }
! 2077: static void eval(mpf_ptr f, gmp_randstate_t s, unsigned long int prec)
! 2078: { mpf_urandomb(f, s, prec); }
! 2079: };
! 2080:
! 2081:
! 2082: /**************** Auxiliary classes ****************/
! 2083:
! 2084: /* this is the same as gmp_allocated_string in gmp-impl.h
! 2085: since gmp-impl.h is not publicly available, I redefine it here
! 2086: I use a different name to avoid possible clashes */
! 2087: struct __gmp_alloc_cstring
! 2088: {
! 2089: char *str;
! 2090: __gmp_alloc_cstring(char *s) { str = s; }
! 2091: ~__gmp_alloc_cstring() { __gmp_free_func(str, strlen(str)+1); }
! 2092: };
! 2093:
! 2094:
! 2095: template <class T, class U>
! 2096: class __gmp_expr;
! 2097:
! 2098: template <class T>
! 2099: struct __gmp_resolve_ref
! 2100: {
! 2101: typedef T ref_type;
! 2102: };
! 2103:
! 2104: template <class T, class U>
! 2105: struct __gmp_resolve_ref<__gmp_expr<T, U> >
! 2106: {
! 2107: typedef const __gmp_expr<T, U> & ref_type;
! 2108: };
! 2109:
! 2110: template <class T, class Op>
! 2111: struct __gmp_unary_expr
! 2112: {
! 2113: typename __gmp_resolve_ref<T>::ref_type val;
! 2114: __gmp_unary_expr(const T &v) : val(v) { }
! 2115: private:
! 2116: __gmp_unary_expr();
! 2117: };
! 2118:
! 2119: template <class T, class U, class Op>
! 2120: struct __gmp_binary_expr
! 2121: {
! 2122: typename __gmp_resolve_ref<T>::ref_type val1;
! 2123: typename __gmp_resolve_ref<U>::ref_type val2;
! 2124: __gmp_binary_expr(const T &v1, const U &v2) : val1(v1), val2(v2) { }
! 2125: private:
! 2126: __gmp_binary_expr();
! 2127: };
! 2128:
! 2129:
! 2130: class __gmpz_value { };
! 2131: class __gmpzref_value { };
! 2132: class __gmpq_value { };
! 2133: class __gmpf_value { };
! 2134:
! 2135:
! 2136: template <class T, class U>
! 2137: void __gmp_set_expr(mpz_ptr, const __gmp_expr<T, U> &);
! 2138: template <class T, class U>
! 2139: void __gmp_set_expr(mpq_ptr, const __gmp_expr<T, U> &);
! 2140: template <class T, class U>
! 2141: void __gmp_set_expr(mpf_ptr, const __gmp_expr<T, U> &);
! 2142:
! 2143:
! 2144: /**************** Macros for in-class declarations ****************/
! 2145: /* This is just repetitive code that is easier to maintain if it's written
! 2146: only once */
! 2147:
! 2148: #define __GMPZZ_DECLARE_COMPOUND_OPERATOR(fun) \
! 2149: template <class T, class U> \
! 2150: __gmp_expr<__gmpz_value, __gmpz_value> & fun(const __gmp_expr<T, U> &);
! 2151:
! 2152: #define __GMPZN_DECLARE_COMPOUND_OPERATOR(fun) \
! 2153: __gmp_expr & fun(signed char); \
! 2154: __gmp_expr & fun(unsigned char); \
! 2155: __gmp_expr & fun(signed int); \
! 2156: __gmp_expr & fun(unsigned int); \
! 2157: __gmp_expr & fun(signed short int); \
! 2158: __gmp_expr & fun(unsigned short int); \
! 2159: __gmp_expr & fun(signed long int); \
! 2160: __gmp_expr & fun(unsigned long int); \
! 2161: __gmp_expr & fun(float); \
! 2162: __gmp_expr & fun(double); \
! 2163: __gmp_expr & fun(long double);
! 2164:
! 2165: #define __GMPZ_DECLARE_COMPOUND_OPERATOR(fun) \
! 2166: __GMPZZ_DECLARE_COMPOUND_OPERATOR(fun) \
! 2167: __GMPZN_DECLARE_COMPOUND_OPERATOR(fun)
! 2168:
! 2169: #define __GMPZ_DECLARE_COMPOUND_OPERATOR_UI(fun) \
! 2170: __gmp_expr & fun(unsigned long int);
! 2171:
! 2172: #define __GMPZ_DECLARE_INCREMENT_OPERATOR(fun) \
! 2173: inline __gmp_expr & fun(); \
! 2174: inline __gmp_expr fun(int);
! 2175:
! 2176: #define __GMPZRR_DECLARE_COMPOUND_OPERATOR(fun) \
! 2177: template <class T, class U> \
! 2178: __gmp_expr<__gmpz_value, __gmpzref_value> & fun(const __gmp_expr<T, U> &);
! 2179:
! 2180: #define __GMPZRN_DECLARE_COMPOUND_OPERATOR(fun) \
! 2181: __gmp_expr & fun(signed char); \
! 2182: __gmp_expr & fun(unsigned char); \
! 2183: __gmp_expr & fun(signed int); \
! 2184: __gmp_expr & fun(unsigned int); \
! 2185: __gmp_expr & fun(signed short int); \
! 2186: __gmp_expr & fun(unsigned short int); \
! 2187: __gmp_expr & fun(signed long int); \
! 2188: __gmp_expr & fun(unsigned long int); \
! 2189: __gmp_expr & fun(float); \
! 2190: __gmp_expr & fun(double); \
! 2191: __gmp_expr & fun(long double);
! 2192:
! 2193: #define __GMPZR_DECLARE_COMPOUND_OPERATOR(fun) \
! 2194: __GMPZRR_DECLARE_COMPOUND_OPERATOR(fun) \
! 2195: __GMPZRN_DECLARE_COMPOUND_OPERATOR(fun)
! 2196:
! 2197: #define __GMPZR_DECLARE_COMPOUND_OPERATOR_UI(fun) \
! 2198: __gmp_expr & fun(unsigned long int);
! 2199:
! 2200: #define __GMPZR_DECLARE_INCREMENT_OPERATOR(fun) \
! 2201: inline __gmp_expr & fun(); \
! 2202: inline mpz_class fun(int);
! 2203:
! 2204: #define __GMPQQ_DECLARE_COMPOUND_OPERATOR(fun) \
! 2205: template <class T, class U> \
! 2206: __gmp_expr<__gmpq_value, __gmpq_value> & fun(const __gmp_expr<T, U> &);
! 2207:
! 2208: #define __GMPQN_DECLARE_COMPOUND_OPERATOR(fun) \
! 2209: __gmp_expr & fun(signed char); \
! 2210: __gmp_expr & fun(unsigned char); \
! 2211: __gmp_expr & fun(signed int); \
! 2212: __gmp_expr & fun(unsigned int); \
! 2213: __gmp_expr & fun(signed short int); \
! 2214: __gmp_expr & fun(unsigned short int); \
! 2215: __gmp_expr & fun(signed long int); \
! 2216: __gmp_expr & fun(unsigned long int); \
! 2217: __gmp_expr & fun(float); \
! 2218: __gmp_expr & fun(double); \
! 2219: __gmp_expr & fun(long double);
! 2220:
! 2221: #define __GMPQ_DECLARE_COMPOUND_OPERATOR(fun) \
! 2222: __GMPQQ_DECLARE_COMPOUND_OPERATOR(fun) \
! 2223: __GMPQN_DECLARE_COMPOUND_OPERATOR(fun)
! 2224:
! 2225: #define __GMPQ_DECLARE_COMPOUND_OPERATOR_UI(fun) \
! 2226: __gmp_expr & fun(unsigned long int);
! 2227:
! 2228: #define __GMPQ_DECLARE_INCREMENT_OPERATOR(fun) \
! 2229: inline __gmp_expr & fun(); \
! 2230: inline __gmp_expr fun(int);
! 2231:
! 2232: #define __GMPFF_DECLARE_COMPOUND_OPERATOR(fun) \
! 2233: template <class T, class U> \
! 2234: __gmp_expr<__gmpf_value, __gmpf_value> & fun(const __gmp_expr<T, U> &);
! 2235:
! 2236: #define __GMPFN_DECLARE_COMPOUND_OPERATOR(fun) \
! 2237: __gmp_expr & fun(signed char); \
! 2238: __gmp_expr & fun(unsigned char); \
! 2239: __gmp_expr & fun(signed int); \
! 2240: __gmp_expr & fun(unsigned int); \
! 2241: __gmp_expr & fun(signed short int); \
! 2242: __gmp_expr & fun(unsigned short int); \
! 2243: __gmp_expr & fun(signed long int); \
! 2244: __gmp_expr & fun(unsigned long int); \
! 2245: __gmp_expr & fun(float); \
! 2246: __gmp_expr & fun(double); \
! 2247: __gmp_expr & fun(long double);
! 2248:
! 2249: #define __GMPF_DECLARE_COMPOUND_OPERATOR(fun) \
! 2250: __GMPFF_DECLARE_COMPOUND_OPERATOR(fun) \
! 2251: __GMPFN_DECLARE_COMPOUND_OPERATOR(fun)
! 2252:
! 2253: #define __GMPF_DECLARE_COMPOUND_OPERATOR_UI(fun) \
! 2254: __gmp_expr & fun(unsigned long int);
! 2255:
! 2256: #define __GMPF_DECLARE_INCREMENT_OPERATOR(fun) \
! 2257: inline __gmp_expr & fun(); \
! 2258: inline __gmp_expr fun(int);
! 2259:
! 2260:
! 2261: /**************** mpz_class -- wrapper for mpz_t ****************/
! 2262:
! 2263: template <>
! 2264: class __gmp_expr<__gmpz_value, __gmpz_value>
! 2265: {
! 2266: private:
! 2267: mpz_t mp;
! 2268: public:
! 2269: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 2270:
! 2271: // constructors and destructor
! 2272: __gmp_expr() { mpz_init(mp); }
! 2273:
! 2274: __gmp_expr(const __gmp_expr &z) { mpz_init_set(mp, z.mp); }
! 2275: template <class T, class U>
! 2276: __gmp_expr(const __gmp_expr<T, U> &expr)
! 2277: { mpz_init(mp); __gmp_set_expr(mp, expr); }
! 2278:
! 2279: __gmp_expr(signed char c) { mpz_init_set_si(mp, c); }
! 2280: __gmp_expr(unsigned char c) { mpz_init_set_ui(mp, c); }
! 2281:
! 2282: __gmp_expr(signed int i) { mpz_init_set_si(mp, i); }
! 2283: __gmp_expr(unsigned int i) { mpz_init_set_ui(mp, i); }
! 2284:
! 2285: __gmp_expr(signed short int s) { mpz_init_set_si(mp, s); }
! 2286: __gmp_expr(unsigned short int s) { mpz_init_set_ui(mp, s); }
! 2287:
! 2288: __gmp_expr(signed long int l) { mpz_init_set_si(mp, l); }
! 2289: __gmp_expr(unsigned long int l) { mpz_init_set_ui(mp, l); }
! 2290:
! 2291: __gmp_expr(float f) { mpz_init_set_d(mp, f); }
! 2292: __gmp_expr(double d) { mpz_init_set_d(mp, d); }
! 2293: // __gmp_expr(long double ld) { mpz_init_set_d(mp, ld); }
! 2294:
! 2295: explicit __gmp_expr(const char *s)
! 2296:
! 2297: { mpz_init_set_str(mp, s, 0); }
! 2298: __gmp_expr(const char *s, int base)
! 2299: { mpz_init_set_str(mp, s, base); }
! 2300: explicit __gmp_expr(const std::string &s)
! 2301: { mpz_init_set_str(mp, s.c_str(), 0); }
! 2302: __gmp_expr(const std::string &s, int base)
! 2303: { mpz_init_set_str(mp, s.c_str(), base); }
! 2304:
! 2305: explicit __gmp_expr(mpz_srcptr z) { mpz_init_set(mp, z); }
! 2306:
! 2307: ~__gmp_expr() { mpz_clear(mp); }
! 2308:
! 2309: // assignment operators
! 2310: __gmp_expr & operator=(const __gmp_expr &z)
! 2311: { mpz_set(mp, z.mp); return *this; }
! 2312: template <class T, class U>
! 2313: __gmp_expr<__gmpz_value, __gmpz_value> & operator=
! 2314: (const __gmp_expr<T, U> &expr)
! 2315: { __gmp_set_expr(mp, expr); return *this; }
! 2316:
! 2317: __gmp_expr & operator=(signed char c) { mpz_set_si(mp, c); return *this; }
! 2318: __gmp_expr & operator=(unsigned char c) { mpz_set_ui(mp, c); return *this; }
! 2319:
! 2320: __gmp_expr & operator=(signed int i) { mpz_set_si(mp, i); return *this; }
! 2321: __gmp_expr & operator=(unsigned int i) { mpz_set_ui(mp, i); return *this; }
! 2322:
! 2323: __gmp_expr & operator=(signed short int s)
! 2324: { mpz_set_si(mp, s); return *this; }
! 2325: __gmp_expr & operator=(unsigned short int s)
! 2326: { mpz_set_ui(mp, s); return *this; }
! 2327:
! 2328: __gmp_expr & operator=(signed long int l)
! 2329: { mpz_set_si(mp, l); return *this; }
! 2330: __gmp_expr & operator=(unsigned long int l)
! 2331: { mpz_set_ui(mp, l); return *this; }
! 2332:
! 2333: __gmp_expr & operator=(float f) { mpz_set_d(mp, f); return *this; }
! 2334: __gmp_expr & operator=(double d) { mpz_set_d(mp, d); return *this; }
! 2335: /*
! 2336: __gmp_expr & operator=(long double ld) { mpz_set_ld(mp, ld); return *this; }
! 2337: */
! 2338:
! 2339: __gmp_expr & operator=(const char *s)
! 2340: { mpz_set_str(mp, s, 0); return *this; }
! 2341: __gmp_expr & operator=(const std::string &s)
! 2342: { mpz_set_str(mp, s.c_str(), 0); return *this; }
! 2343:
! 2344: // string input/output functions
! 2345: int set_str(const std::string &s, int base)
! 2346: { return mpz_set_str(mp, s.c_str(), base); }
! 2347: std::string get_str(int base = 10) const
! 2348: {
! 2349: __gmp_alloc_cstring temp(mpz_get_str(0, base, mp));
! 2350: return std::string(temp.str);
! 2351: }
! 2352:
! 2353: // conversion functions
! 2354: mpz_srcptr get_mpz_t() const { return mp; }
! 2355: mpz_ptr get_mpz_t() { return mp; }
! 2356:
! 2357: signed long int get_si() const { return mpz_get_si(mp); }
! 2358: unsigned long int get_ui() const { return mpz_get_ui(mp); }
! 2359: double get_d() const { return mpz_get_d(mp); } // should be long double
! 2360:
! 2361: // bool fits_schar_p() const { return mpz_fits_schar_p(mp); }
! 2362: // bool fits_uchar_p() const { return mpz_fits_uchar_p(mp); }
! 2363: bool fits_sint_p() const { return mpz_fits_sint_p(mp); }
! 2364: bool fits_uint_p() const { return mpz_fits_uint_p(mp); }
! 2365: bool fits_sshort_p() const { return mpz_fits_sshort_p(mp); }
! 2366: bool fits_ushort_p() const { return mpz_fits_ushort_p(mp); }
! 2367: bool fits_slong_p() const { return mpz_fits_slong_p(mp); }
! 2368: bool fits_ulong_p() const { return mpz_fits_ulong_p(mp); }
! 2369: // bool fits_float_p() const { return mpz_fits_float_p(mp); }
! 2370: // bool fits_double_p() const { return mpz_fits_double_p(mp); }
! 2371: // bool fits_ldouble_p() const { return mpz_fits_ldouble_p(mp); }
! 2372:
! 2373: // member operators
! 2374: __GMPZ_DECLARE_COMPOUND_OPERATOR(operator+=)
! 2375: __GMPZ_DECLARE_COMPOUND_OPERATOR(operator-=)
! 2376: __GMPZ_DECLARE_COMPOUND_OPERATOR(operator*=)
! 2377: __GMPZ_DECLARE_COMPOUND_OPERATOR(operator/=)
! 2378: __GMPZ_DECLARE_COMPOUND_OPERATOR(operator%=)
! 2379:
! 2380: __GMPZZ_DECLARE_COMPOUND_OPERATOR(operator&=)
! 2381: __GMPZZ_DECLARE_COMPOUND_OPERATOR(operator|=)
! 2382: __GMPZZ_DECLARE_COMPOUND_OPERATOR(operator^=)
! 2383:
! 2384: __GMPZ_DECLARE_COMPOUND_OPERATOR_UI(operator<<=)
! 2385: __GMPZ_DECLARE_COMPOUND_OPERATOR_UI(operator>>=)
! 2386:
! 2387: __GMPZ_DECLARE_INCREMENT_OPERATOR(operator++)
! 2388: __GMPZ_DECLARE_INCREMENT_OPERATOR(operator--)
! 2389: };
! 2390:
! 2391: typedef __gmp_expr<__gmpz_value, __gmpz_value> mpz_class;
! 2392:
! 2393:
! 2394: inline std::ostream & operator<<(std::ostream &o, const mpz_class &z)
! 2395: {
! 2396: return o << z.get_mpz_t();
! 2397: }
! 2398:
! 2399: template <class T>
! 2400: inline std::ostream & operator<<
! 2401: (std::ostream &o, const __gmp_expr<__gmpz_value, T> &expr)
! 2402: {
! 2403: mpz_class temp(expr);
! 2404: return o << temp.get_mpz_t();
! 2405: }
! 2406:
! 2407: inline std::istream & operator>>(std::istream &i, mpz_class &z)
! 2408: {
! 2409: return i >> z.get_mpz_t();
! 2410: }
! 2411:
! 2412:
! 2413: /**************** mpz_classref -- num/den of mpq_t ****************/
! 2414:
! 2415: template <>
! 2416: class __gmp_expr<__gmpz_value, __gmpzref_value>
! 2417: {
! 2418: friend class __gmp_expr<__gmpq_value, __gmpq_value>;
! 2419: private:
! 2420: mpz_ptr ref;
! 2421:
! 2422: __gmp_expr();
! 2423: // __gmp_expr(const __gmp_expr &);
! 2424: __gmp_expr(mpz_ptr z) : ref(z) { }
! 2425: __gmp_expr(mpz_srcptr z) : ref((mpz_ptr) z) { }
! 2426: public:
! 2427: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 2428:
! 2429: // assignment operators
! 2430: __gmp_expr & operator=(const __gmp_expr &z)
! 2431: { mpz_set(ref, z.ref); return *this; }
! 2432: __gmp_expr & operator=(const mpz_class &z)
! 2433: { mpz_set(ref, z.get_mpz_t()); return *this; }
! 2434: template <class T, class U>
! 2435: __gmp_expr<__gmpz_value, __gmpzref_value> & operator=
! 2436: (const __gmp_expr<T, U> &expr)
! 2437: { __gmp_set_expr(ref, expr); return *this; }
! 2438:
! 2439: __gmp_expr & operator=(signed char c) { mpz_set_si(ref, c); return *this; }
! 2440: __gmp_expr & operator=(unsigned char c)
! 2441: { mpz_set_ui(ref, c); return *this; }
! 2442:
! 2443: __gmp_expr & operator=(signed int i) { mpz_set_si(ref, i); return *this; }
! 2444: __gmp_expr & operator=(unsigned int i) { mpz_set_ui(ref, i); return *this; }
! 2445:
! 2446: __gmp_expr & operator=(signed short int s)
! 2447: { mpz_set_si(ref, s); return *this; }
! 2448: __gmp_expr & operator=(unsigned short int s)
! 2449: { mpz_set_ui(ref, s); return *this; }
! 2450:
! 2451: __gmp_expr & operator=(signed long int l)
! 2452: { mpz_set_si(ref, l); return *this; }
! 2453: __gmp_expr & operator=(unsigned long int l)
! 2454: { mpz_set_ui(ref, l); return *this; }
! 2455:
! 2456: __gmp_expr & operator=(float f) { mpz_set_d(ref, f); return *this; }
! 2457: __gmp_expr & operator=(double d) { mpz_set_d(ref, d); return *this; }
! 2458: /*
! 2459: __gmp_expr & operator=(long double ld)
! 2460: { mpz_set_ld(ref, ld); return *this; }
! 2461: */
! 2462:
! 2463: __gmp_expr & operator=(const char *s)
! 2464: { mpz_set_str(ref, s, 0); return *this; }
! 2465: __gmp_expr & operator=(const std::string &s)
! 2466: { mpz_set_str(ref, s.c_str(), 0); return *this; }
! 2467:
! 2468: // string input/output functions
! 2469: int set_str(const std::string &s, int base)
! 2470: { return mpz_set_str(ref, s.c_str(), base); }
! 2471: std::string get_str(int base = 10) const
! 2472: {
! 2473: __gmp_alloc_cstring temp(mpz_get_str(0, base, ref));
! 2474: return std::string(temp.str);
! 2475: }
! 2476:
! 2477: // conversion functions
! 2478: mpz_srcptr get_mpz_t() const { return ref; }
! 2479: mpz_ptr get_mpz_t() { return ref; }
! 2480:
! 2481: signed long int get_si() const { return mpz_get_si(ref); }
! 2482: unsigned long int get_ui() const { return mpz_get_ui(ref); }
! 2483: double get_d() const { return mpz_get_d(ref); } // should be long double
! 2484:
! 2485: // bool fits_bool_p() const { return mpz_fits_bool_p(ref); }
! 2486: // bool fits_schar_p() const { return mpz_fits_schar_p(ref); }
! 2487: // bool fits_uchar_p() const { return mpz_fits_uchar_p(ref); }
! 2488: bool fits_sint_p() const { return mpz_fits_sint_p(ref); }
! 2489: bool fits_uint_p() const { return mpz_fits_uint_p(ref); }
! 2490: bool fits_sshort_p() const { return mpz_fits_sshort_p(ref); }
! 2491: bool fits_ushort_p() const { return mpz_fits_ushort_p(ref); }
! 2492: bool fits_slong_p() const { return mpz_fits_slong_p(ref); }
! 2493: bool fits_ulong_p() const { return mpz_fits_ulong_p(ref); }
! 2494: // bool fits_float_p() const { return mpz_fits_float_p(ref); }
! 2495: // bool fits_double_p() const { return mpz_fits_double_p(ref); }
! 2496: // bool fits_ldouble_p() const { return mpz_fits_ldouble_p(ref); }
! 2497:
! 2498: // member operators
! 2499: __GMPZR_DECLARE_COMPOUND_OPERATOR(operator+=)
! 2500: __GMPZR_DECLARE_COMPOUND_OPERATOR(operator-=)
! 2501: __GMPZR_DECLARE_COMPOUND_OPERATOR(operator*=)
! 2502: __GMPZR_DECLARE_COMPOUND_OPERATOR(operator/=)
! 2503: __GMPZR_DECLARE_COMPOUND_OPERATOR(operator%=)
! 2504:
! 2505: __GMPZRR_DECLARE_COMPOUND_OPERATOR(operator&=)
! 2506: __GMPZRR_DECLARE_COMPOUND_OPERATOR(operator|=)
! 2507: __GMPZRR_DECLARE_COMPOUND_OPERATOR(operator^=)
! 2508:
! 2509: __GMPZR_DECLARE_COMPOUND_OPERATOR_UI(operator<<=)
! 2510: __GMPZR_DECLARE_COMPOUND_OPERATOR_UI(operator>>=)
! 2511:
! 2512: __GMPZR_DECLARE_INCREMENT_OPERATOR(operator++)
! 2513: __GMPZR_DECLARE_INCREMENT_OPERATOR(operator--)
! 2514: };
! 2515:
! 2516: typedef __gmp_expr<__gmpz_value, __gmpzref_value> mpz_classref;
! 2517:
! 2518:
! 2519: inline std::ostream & operator<<(std::ostream &o, const mpz_classref &z)
! 2520: {
! 2521: return o << z.get_mpz_t();
! 2522: }
! 2523:
! 2524: inline std::istream & operator>>(std::istream &i, mpz_classref &z)
! 2525: {
! 2526: return i >> z.get_mpz_t();
! 2527: }
! 2528:
! 2529: /**************** mpq_class -- wrapper for mpq_t ****************/
! 2530:
! 2531: template <>
! 2532: class __gmp_expr<__gmpq_value, __gmpq_value>
! 2533: {
! 2534: private:
! 2535: mpq_t mp;
! 2536: public:
! 2537: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 2538: void canonicalize() { mpq_canonicalize(mp); }
! 2539:
! 2540: // constructors and destructor
! 2541: __gmp_expr() { mpq_init(mp); }
! 2542:
! 2543: __gmp_expr(const __gmp_expr &q) { mpq_init(mp); mpq_set(mp, q.mp); }
! 2544: template <class T, class U>
! 2545: __gmp_expr(const __gmp_expr<T, U> &expr)
! 2546: { mpq_init(mp); __gmp_set_expr(mp, expr); }
! 2547:
! 2548: __gmp_expr(signed char c) { mpq_init(mp); mpq_set_si(mp, c, 1); }
! 2549: __gmp_expr(unsigned char c) { mpq_init(mp); mpq_set_ui(mp, c, 1); }
! 2550:
! 2551: __gmp_expr(signed int i) { mpq_init(mp); mpq_set_si(mp, i, 1); }
! 2552: __gmp_expr(unsigned int i) { mpq_init(mp); mpq_set_ui(mp, i, 1); }
! 2553:
! 2554: __gmp_expr(signed short int s) { mpq_init(mp); mpq_set_si(mp, s, 1); }
! 2555: __gmp_expr(unsigned short int s) { mpq_init(mp); mpq_set_ui(mp, s, 1); }
! 2556:
! 2557: __gmp_expr(signed long int l) { mpq_init(mp); mpq_set_si(mp, l, 1); }
! 2558: __gmp_expr(unsigned long int l) { mpq_init(mp); mpq_set_ui(mp, l, 1); }
! 2559:
! 2560: __gmp_expr(float f) { mpq_init(mp); mpq_set_d(mp, f); }
! 2561: __gmp_expr(double d) { mpq_init(mp); mpq_set_d(mp, d); }
! 2562: // __gmp_expr(long double ld) { mpq_init(mp); mpq_set_ld(mp, ld); }
! 2563:
! 2564: explicit __gmp_expr(const char *s)
! 2565: { mpq_init(mp); mpq_set_str(mp, s, 0); }
! 2566: __gmp_expr(const char *s, unsigned long int base)
! 2567: { mpq_init(mp); mpq_set_str(mp, s, base); }
! 2568: explicit __gmp_expr(const std::string &s)
! 2569: { mpq_init(mp); mpq_set_str(mp, s.c_str(), 0); }
! 2570: __gmp_expr(const std::string &s, unsigned long int base)
! 2571: { mpq_init(mp); mpq_set_str(mp, s.c_str(), base); }
! 2572:
! 2573: explicit __gmp_expr(mpq_srcptr q) { mpq_init(mp); mpq_set(mp, q); }
! 2574:
! 2575: __gmp_expr(const mpz_class &num, const mpz_class &den)
! 2576: {
! 2577: mpq_init(mp);
! 2578: mpz_set(mpq_numref(mp), num.get_mpz_t());
! 2579: mpz_set(mpq_denref(mp), den.get_mpz_t());
! 2580: }
! 2581: // this is defined later (after __gmpz_temp)
! 2582: template <class T, class U>
! 2583: __gmp_expr(const __gmp_expr<__gmpz_value, T> &,
! 2584: const __gmp_expr<__gmpz_value, U> &);
! 2585:
! 2586: ~__gmp_expr() { mpq_clear(mp); }
! 2587:
! 2588: // assignment operators
! 2589: __gmp_expr & operator=(const __gmp_expr &q)
! 2590: { mpq_set(mp, q.mp); return *this; }
! 2591: template <class T, class U>
! 2592: __gmp_expr<__gmpq_value, __gmpq_value> & operator=
! 2593: (const __gmp_expr<T, U> &expr)
! 2594: { __gmp_set_expr(mp, expr); return *this; }
! 2595:
! 2596: __gmp_expr & operator=(signed char c)
! 2597: { mpq_set_si(mp, c, 1); return *this; }
! 2598: __gmp_expr & operator=(unsigned char c)
! 2599: { mpq_set_ui(mp, c, 1); return *this; }
! 2600:
! 2601: __gmp_expr & operator=(signed int i) { mpq_set_si(mp, i, 1); return *this; }
! 2602: __gmp_expr & operator=(unsigned int i)
! 2603: { mpq_set_ui(mp, i, 1); return *this; }
! 2604:
! 2605: __gmp_expr & operator=(signed short int s)
! 2606: { mpq_set_si(mp, s, 1); return *this; }
! 2607: __gmp_expr & operator=(unsigned short int s)
! 2608: { mpq_set_ui(mp, s, 1); return *this; }
! 2609:
! 2610: __gmp_expr & operator=(signed long int l)
! 2611: { mpq_set_si(mp, l, 1); return *this; }
! 2612: __gmp_expr & operator=(unsigned long int l)
! 2613: { mpq_set_ui(mp, l, 1); return *this; }
! 2614:
! 2615: __gmp_expr & operator=(float f) { mpq_set_d(mp, f); return *this; }
! 2616: __gmp_expr & operator=(double d) { mpq_set_d(mp, d); return *this; }
! 2617: /*
! 2618: __gmp_expr & operator=(long double ld) { mpq_set_ld(mp, ld); return *this; }
! 2619: */
! 2620:
! 2621: __gmp_expr & operator=(const char *s)
! 2622: { mpq_set_str(mp, s, 0); return *this; }
! 2623: __gmp_expr & operator=(const std::string &s)
! 2624: { mpq_set_str(mp, s.c_str(), 0); return *this; }
! 2625:
! 2626: // string input/output functions
! 2627: int set_str(const std::string &s, int base)
! 2628: { return mpq_set_str(mp, s.c_str(), base); }
! 2629: std::string get_str(int base = 10) const
! 2630: {
! 2631: __gmp_alloc_cstring temp(mpq_get_str(0, base, mp));
! 2632: return std::string(temp.str);
! 2633: }
! 2634:
! 2635: // conversion functions
! 2636:
! 2637: // casting a reference to an mpz_t to mpz_class & is a dirty hack,
! 2638: // but works because the internal representation of mpz_class is
! 2639: // exactly an mpz_t
! 2640: const mpz_class & get_num() const
! 2641: { return reinterpret_cast<const mpz_class &>(*mpq_numref(mp)); }
! 2642: mpz_class & get_num()
! 2643: { return reinterpret_cast<mpz_class &>(*mpq_numref(mp)); }
! 2644: const mpz_class & get_den() const
! 2645: { return reinterpret_cast<const mpz_class &>(*mpq_denref(mp)); }
! 2646: mpz_class & get_den()
! 2647: { return reinterpret_cast<mpz_class &>(*mpq_denref(mp)); }
! 2648:
! 2649: mpq_srcptr get_mpq_t() const { return mp; }
! 2650: mpq_ptr get_mpq_t() { return mp; }
! 2651:
! 2652: mpz_srcptr get_num_mpz_t() const { return mpq_numref(mp); }
! 2653: mpz_ptr get_num_mpz_t() { return mpq_numref(mp); }
! 2654: mpz_srcptr get_den_mpz_t() const { return mpq_denref(mp); }
! 2655: mpz_ptr get_den_mpz_t() { return mpq_denref(mp); }
! 2656:
! 2657: double get_d() const { return mpq_get_d(mp); } // should be long double
! 2658:
! 2659: // compound assignments
! 2660: __GMPQ_DECLARE_COMPOUND_OPERATOR(operator+=)
! 2661: __GMPQ_DECLARE_COMPOUND_OPERATOR(operator-=)
! 2662: __GMPQ_DECLARE_COMPOUND_OPERATOR(operator*=)
! 2663: __GMPQ_DECLARE_COMPOUND_OPERATOR(operator/=)
! 2664:
! 2665: __GMPQ_DECLARE_COMPOUND_OPERATOR_UI(operator<<=)
! 2666: __GMPQ_DECLARE_COMPOUND_OPERATOR_UI(operator>>=)
! 2667:
! 2668: __GMPQ_DECLARE_INCREMENT_OPERATOR(operator++)
! 2669: __GMPQ_DECLARE_INCREMENT_OPERATOR(operator--)
! 2670: };
! 2671:
! 2672: typedef __gmp_expr<__gmpq_value, __gmpq_value> mpq_class;
! 2673:
! 2674:
! 2675: inline std::ostream & operator<<(std::ostream &o, const mpq_class &q)
! 2676: {
! 2677: return o << q.get_mpq_t();
! 2678: }
! 2679:
! 2680: template <class T>
! 2681: inline std::ostream & operator<<
! 2682: (std::ostream &o, const __gmp_expr<__gmpq_value, T> &expr)
! 2683: {
! 2684: mpq_class temp(expr);
! 2685: return o << temp.get_mpq_t();
! 2686: }
! 2687:
! 2688: inline std::istream & operator>>(std::istream &i, mpq_class &q)
! 2689: {
! 2690: i >> q.get_mpq_t();
! 2691: // q.canonicalize();
! 2692: return i;
! 2693: }
! 2694:
! 2695:
! 2696: /**************** mpf_class -- wrapper for mpf_t ****************/
! 2697:
! 2698: template <>
! 2699: class __gmp_expr<__gmpf_value, __gmpf_value>
! 2700: {
! 2701: private:
! 2702: mpf_t mp;
! 2703: public:
! 2704: // size information
! 2705: unsigned long int get_prec() const { return mpf_get_prec(mp); }
! 2706:
! 2707: void set_prec(unsigned long int prec) { mpf_set_prec(mp, prec); }
! 2708: void set_prec_raw(unsigned long int prec) { mpf_set_prec_raw(mp, prec); }
! 2709:
! 2710: // constructors and destructor
! 2711: __gmp_expr() { mpf_init(mp); }
! 2712:
! 2713: __gmp_expr(const __gmp_expr &f)
! 2714: { mpf_init2(mp, f.get_prec()); mpf_set(mp, f.mp); }
! 2715: __gmp_expr(const __gmp_expr &f, unsigned long int prec)
! 2716: { mpf_init2(mp, prec); mpf_set(mp, f.mp); }
! 2717: template <class T, class U>
! 2718: __gmp_expr(const __gmp_expr<T, U> &expr)
! 2719: { mpf_init2(mp, expr.get_prec()); __gmp_set_expr(mp, expr); }
! 2720: template <class T, class U>
! 2721: __gmp_expr(const __gmp_expr<T, U> &expr, unsigned long int prec)
! 2722: { mpf_init2(mp, prec); __gmp_set_expr(mp, expr); }
! 2723:
! 2724: __gmp_expr(signed char c) { mpf_init_set_si(mp, c); }
! 2725: __gmp_expr(signed char c, unsigned long int prec)
! 2726: { mpf_init2(mp, prec); mpf_set_si(mp, c); }
! 2727: __gmp_expr(unsigned char c) { mpf_init_set_ui(mp, c); }
! 2728: __gmp_expr(unsigned char c, unsigned long int prec)
! 2729: { mpf_init2(mp, prec); mpf_set_ui(mp, c); }
! 2730:
! 2731: __gmp_expr(signed int i) { mpf_init_set_si(mp, i); }
! 2732: __gmp_expr(signed int i, unsigned long int prec)
! 2733: { mpf_init2(mp, prec); mpf_set_si(mp, i); }
! 2734: __gmp_expr(unsigned int i) { mpf_init_set_ui(mp, i); }
! 2735: __gmp_expr(unsigned int i, unsigned long int prec)
! 2736: { mpf_init2(mp, prec); mpf_set_ui(mp, i); }
! 2737:
! 2738: __gmp_expr(signed short int s) { mpf_init_set_si(mp, s); }
! 2739: __gmp_expr(signed short int s, unsigned long int prec)
! 2740: { mpf_init2(mp, prec); mpf_set_si(mp, s); }
! 2741: __gmp_expr(unsigned short int s) { mpf_init_set_ui(mp, s); }
! 2742: __gmp_expr(unsigned short int s, unsigned long int prec)
! 2743: { mpf_init2(mp, prec); mpf_set_ui(mp, s); }
! 2744:
! 2745: __gmp_expr(signed long int l) { mpf_init_set_si(mp, l); }
! 2746: __gmp_expr(signed long int l, unsigned long int prec)
! 2747: { mpf_init2(mp, prec); mpf_set_si(mp, l); }
! 2748: __gmp_expr(unsigned long int l) { mpf_init_set_ui(mp, l); }
! 2749: __gmp_expr(unsigned long int l, unsigned long int prec)
! 2750: { mpf_init2(mp, prec); mpf_set_ui(mp, l); }
! 2751:
! 2752: __gmp_expr(float f) { mpf_init_set_d(mp, f); }
! 2753: __gmp_expr(float f, unsigned long int prec)
! 2754: { mpf_init2(mp, prec); mpf_set_d(mp, f); }
! 2755: __gmp_expr(double d) { mpf_init_set_d(mp, d); }
! 2756: __gmp_expr(double d, unsigned long int prec)
! 2757: { mpf_init2(mp, prec); mpf_set_d(mp, d); }
! 2758: /*
! 2759: __gmp_expr(long double ld) { mpf_init_set_d(mp, ld); }
! 2760: __gmp_expr(long double ld, unsigned long int prec)
! 2761: { mpf_init2(mp, prec); mpf_set_d(mp, ld); }
! 2762: */
! 2763:
! 2764: explicit __gmp_expr(const char *s) { mpf_init_set_str(mp, s, 0); }
! 2765: __gmp_expr(const char *s, unsigned long int prec)
! 2766: { mpf_init2(mp, prec); mpf_set_str(mp, s, 0); }
! 2767: explicit __gmp_expr(const std::string &s)
! 2768: { mpf_init_set_str(mp, s.c_str(), 0); }
! 2769: __gmp_expr(const std::string &s, unsigned long int prec)
! 2770: { mpf_init2(mp, prec); mpf_set_str(mp, s.c_str(), 0); }
! 2771:
! 2772: explicit __gmp_expr(mpf_srcptr f)
! 2773: { mpf_init2(mp, mpf_get_prec(f)); mpf_set(mp, f); }
! 2774: __gmp_expr(mpf_srcptr f, unsigned long int prec)
! 2775: { mpf_init2(mp, prec); mpf_set(mp, f); }
! 2776:
! 2777: ~__gmp_expr() { mpf_clear(mp); }
! 2778:
! 2779: // assignment operators
! 2780: __gmp_expr & operator=(const __gmp_expr &f)
! 2781: { mpf_set(mp, f.mp); return *this; }
! 2782: template <class T, class U>
! 2783: __gmp_expr<__gmpf_value, __gmpf_value> & operator=
! 2784: (const __gmp_expr<T, U> &expr)
! 2785: { __gmp_set_expr(mp, expr); return *this; }
! 2786:
! 2787: __gmp_expr & operator=(signed char c) { mpf_set_si(mp, c); return *this; }
! 2788: __gmp_expr & operator=(unsigned char c) { mpf_set_ui(mp, c); return *this; }
! 2789:
! 2790: __gmp_expr & operator=(signed int i) { mpf_set_si(mp, i); return *this; }
! 2791: __gmp_expr & operator=(unsigned int i) { mpf_set_ui(mp, i); return *this; }
! 2792:
! 2793: __gmp_expr & operator=(signed short int s)
! 2794: { mpf_set_si(mp, s); return *this; }
! 2795: __gmp_expr & operator=(unsigned short int s)
! 2796: { mpf_set_ui(mp, s); return *this; }
! 2797:
! 2798: __gmp_expr & operator=(signed long int l)
! 2799: { mpf_set_si(mp, l); return *this; }
! 2800: __gmp_expr & operator=(unsigned long int l)
! 2801: { mpf_set_ui(mp, l); return *this; }
! 2802:
! 2803: __gmp_expr & operator=(float f) { mpf_set_d(mp, f); return *this; }
! 2804: __gmp_expr & operator=(double d) { mpf_set_d(mp, d); return *this; }
! 2805: /*
! 2806: __gmp_expr & operator=(long double ld) { mpf_set_ld(mp, ld); return *this; }
! 2807: */
! 2808:
! 2809: __gmp_expr & operator=(const char *s)
! 2810: { mpf_set_str(mp, s, 0); return *this; }
! 2811: __gmp_expr & operator=(const std::string &s)
! 2812: { mpf_set_str(mp, s.c_str(), 0); return *this; }
! 2813:
! 2814: // string input/output functions
! 2815: int set_str(const std::string &s, int base)
! 2816: { return mpf_set_str(mp, s.c_str(), base); }
! 2817: std::string get_str(mp_exp_t *expo, int base, size_t size) const
! 2818: {
! 2819: __gmp_alloc_cstring temp(mpf_get_str(0, expo, base, size, mp));
! 2820: return std::string(temp.str);
! 2821: }
! 2822:
! 2823: // conversion functions
! 2824: mpf_srcptr get_mpf_t() const { return mp; }
! 2825: mpf_ptr get_mpf_t() { return mp; }
! 2826:
! 2827: signed long int get_si() const { return mpf_get_si(mp); }
! 2828: unsigned long int get_ui() const { return mpf_get_ui(mp); }
! 2829: double get_d() const { return mpf_get_d(mp); } // should be long double
! 2830:
! 2831: // bool fits_schar_p() const { return mpf_fits_schar_p(mp); }
! 2832: // bool fits_uchar_p() const { return mpf_fits_uchar_p(mp); }
! 2833: bool fits_sint_p() const { return mpf_fits_sint_p(mp); }
! 2834: bool fits_uint_p() const { return mpf_fits_uint_p(mp); }
! 2835: bool fits_sshort_p() const { return mpf_fits_sshort_p(mp); }
! 2836: bool fits_ushort_p() const { return mpf_fits_ushort_p(mp); }
! 2837: bool fits_slong_p() const { return mpf_fits_slong_p(mp); }
! 2838: bool fits_ulong_p() const { return mpf_fits_ulong_p(mp); }
! 2839: // bool fits_float_p() const { return mpf_fits_float_p(mp); }
! 2840: // bool fits_double_p() const { return mpf_fits_double_p(mp); }
! 2841: // bool fits_ldouble_p() const { return mpf_fits_ldouble_p(mp); }
! 2842:
! 2843: // compound assignments
! 2844: __GMPF_DECLARE_COMPOUND_OPERATOR(operator+=)
! 2845: __GMPF_DECLARE_COMPOUND_OPERATOR(operator-=)
! 2846: __GMPF_DECLARE_COMPOUND_OPERATOR(operator*=)
! 2847: __GMPF_DECLARE_COMPOUND_OPERATOR(operator/=)
! 2848:
! 2849: __GMPF_DECLARE_COMPOUND_OPERATOR_UI(operator<<=)
! 2850: __GMPF_DECLARE_COMPOUND_OPERATOR_UI(operator>>=)
! 2851:
! 2852: __GMPF_DECLARE_INCREMENT_OPERATOR(operator++)
! 2853: __GMPF_DECLARE_INCREMENT_OPERATOR(operator--)
! 2854: };
! 2855:
! 2856: typedef __gmp_expr<__gmpf_value, __gmpf_value> mpf_class;
! 2857:
! 2858:
! 2859: inline std::ostream & operator<<(std::ostream &o, const mpf_class &f)
! 2860: {
! 2861: return o << f.get_mpf_t();
! 2862: }
! 2863:
! 2864: template <class T>
! 2865: inline std::ostream & operator<<
! 2866: (std::ostream &o, const __gmp_expr<__gmpf_value, T> &expr)
! 2867: {
! 2868: mpf_class temp(expr);
! 2869: return o << temp.get_mpf_t();
! 2870: }
! 2871:
! 2872: inline std::istream & operator>>(std::istream &i, mpf_class &f)
! 2873: {
! 2874: return i >> f.get_mpf_t();
! 2875: }
! 2876:
! 2877:
! 2878: /**************** Classes for type conversion ****************/
! 2879: /* If the expression to be converted is a plain mp[zqf]_class, a direct
! 2880: reference to its mp[zqf]_t internal yields optimal efficiency.
! 2881: If it's a compound expression, a temporary must be used */
! 2882:
! 2883: class __gmpz_temp
! 2884: {
! 2885: private:
! 2886: mpz_srcptr mp;
! 2887: bool is_temp;
! 2888: mpz_t temp;
! 2889:
! 2890: __gmpz_temp();
! 2891: __gmpz_temp(const __gmpz_temp &);
! 2892: void operator=(const __gmpz_temp &);
! 2893: public:
! 2894: __gmpz_temp(const mpz_class &z) : mp(z.get_mpz_t()), is_temp(false) { }
! 2895: __gmpz_temp(const mpz_classref &z) : mp(z.get_mpz_t()), is_temp(false) { }
! 2896: template <class T, class U>
! 2897: __gmpz_temp(const __gmp_expr<T, U> &expr)
! 2898: {
! 2899: mpz_init(temp);
! 2900: __gmp_set_expr(temp, expr);
! 2901: mp = temp;
! 2902: is_temp = true;
! 2903: }
! 2904: ~__gmpz_temp() { if (is_temp) mpz_clear(temp); }
! 2905:
! 2906: mpz_srcptr get_mp() const { return mp; }
! 2907: };
! 2908:
! 2909: class __gmpq_temp
! 2910: {
! 2911: private:
! 2912: mpq_srcptr mp;
! 2913: bool is_temp;
! 2914: mpq_t temp;
! 2915:
! 2916: __gmpq_temp();
! 2917: __gmpq_temp(const __gmpq_temp &);
! 2918: void operator=(const __gmpq_temp &);
! 2919: public:
! 2920: __gmpq_temp(const mpq_class &q) : mp(q.get_mpq_t()), is_temp(false) { }
! 2921: template <class T, class U>
! 2922: __gmpq_temp(const __gmp_expr<T, U> &expr)
! 2923: {
! 2924: mpq_init(temp);
! 2925: __gmp_set_expr(temp, expr);
! 2926: mp = temp;
! 2927: is_temp = true;
! 2928: }
! 2929: ~__gmpq_temp() { if (is_temp) mpq_clear(temp); }
! 2930:
! 2931: mpq_srcptr get_mp() const { return mp; }
! 2932: };
! 2933:
! 2934: class __gmpf_temp
! 2935: {
! 2936: private:
! 2937: mpf_srcptr mp;
! 2938: bool is_temp;
! 2939: mpf_t temp;
! 2940:
! 2941: __gmpf_temp();
! 2942: __gmpf_temp(const __gmpf_temp &);
! 2943: void operator=(const __gmpf_temp &);
! 2944: public:
! 2945: __gmpf_temp(const mpf_class &f) : mp(f.get_mpf_t()), is_temp(false) { }
! 2946: __gmpf_temp(const mpf_class &f, unsigned long int)
! 2947: : mp(f.get_mpf_t()), is_temp(false) { }
! 2948: template <class T, class U>
! 2949: __gmpf_temp(const __gmp_expr<T, U> &expr)
! 2950: {
! 2951: mpf_init2(temp, expr.get_prec());
! 2952: __gmp_set_expr(temp, expr);
! 2953: mp = temp;
! 2954: is_temp = true;
! 2955: }
! 2956: template <class T, class U>
! 2957: __gmpf_temp(const __gmp_expr<T, U> &expr, unsigned long int prec)
! 2958: {
! 2959: mpf_init2(temp, prec);
! 2960: __gmp_set_expr(temp, expr);
! 2961: mp = temp;
! 2962: is_temp = true;
! 2963: }
! 2964: ~__gmpf_temp() { if (is_temp) mpf_clear(temp); }
! 2965:
! 2966: mpf_srcptr get_mp() const { return mp; }
! 2967: };
! 2968:
! 2969:
! 2970: // this function must be defined after __gmpz_temp
! 2971: template <class T, class U>
! 2972: inline mpq_class::__gmp_expr(const __gmp_expr<__gmpz_value, T> &num,
! 2973: const __gmp_expr<__gmpz_value, U> &den)
! 2974: {
! 2975: __gmpz_temp temp1(num), temp2(den);
! 2976: mpq_init(mp);
! 2977: mpz_set(mpq_numref(mp), temp1.get_mp());
! 2978: mpz_set(mpq_denref(mp), temp2.get_mp());
! 2979: }
! 2980:
! 2981:
! 2982: // type of mixed-type expressions
! 2983: template <class T, class U>
! 2984: struct __gmp_resolve_expr;
! 2985:
! 2986: template <>
! 2987: struct __gmp_resolve_expr<__gmpz_value, __gmpz_value>
! 2988: {
! 2989: typedef __gmpz_value value_type;
! 2990: typedef __gmpz_temp temp_type;
! 2991: };
! 2992:
! 2993: template <>
! 2994: struct __gmp_resolve_expr<__gmpq_value, __gmpq_value>
! 2995: {
! 2996: typedef __gmpq_value value_type;
! 2997: typedef __gmpq_temp temp_type;
! 2998: };
! 2999:
! 3000: template <>
! 3001: struct __gmp_resolve_expr<__gmpz_value, __gmpq_value>
! 3002: {
! 3003: typedef __gmpq_value value_type;
! 3004: typedef __gmpq_temp temp_type;
! 3005: };
! 3006:
! 3007: template <>
! 3008: struct __gmp_resolve_expr<__gmpq_value, __gmpz_value>
! 3009: {
! 3010: typedef __gmpq_value value_type;
! 3011: typedef __gmpq_temp temp_type;
! 3012: };
! 3013:
! 3014: template <>
! 3015: struct __gmp_resolve_expr<__gmpf_value, __gmpf_value>
! 3016: {
! 3017: typedef __gmpf_value value_type;
! 3018: typedef __gmpf_temp temp_type;
! 3019: };
! 3020:
! 3021: template <>
! 3022: struct __gmp_resolve_expr<__gmpz_value, __gmpf_value>
! 3023: {
! 3024: typedef __gmpf_value value_type;
! 3025: typedef __gmpf_temp temp_type;
! 3026: };
! 3027:
! 3028: template <>
! 3029: struct __gmp_resolve_expr<__gmpf_value, __gmpz_value>
! 3030: {
! 3031: typedef __gmpf_value value_type;
! 3032: typedef __gmpf_temp temp_type;
! 3033: };
! 3034:
! 3035: template <>
! 3036: struct __gmp_resolve_expr<__gmpq_value, __gmpf_value>
! 3037: {
! 3038: typedef __gmpf_value value_type;
! 3039: typedef __gmpf_temp temp_type;
! 3040: };
! 3041:
! 3042: template <>
! 3043: struct __gmp_resolve_expr<__gmpf_value, __gmpq_value>
! 3044: {
! 3045: typedef __gmpf_value value_type;
! 3046: typedef __gmpf_temp temp_type;
! 3047: };
! 3048:
! 3049:
! 3050: // perform type conversions
! 3051:
! 3052: template <>
! 3053: inline void __gmp_set_expr(mpz_ptr z, const mpz_class &w)
! 3054: {
! 3055: mpz_set(z, w.get_mpz_t());
! 3056: }
! 3057:
! 3058: template <class T>
! 3059: inline void __gmp_set_expr(mpz_ptr z, const __gmp_expr<__gmpz_value, T> &expr)
! 3060: {
! 3061: expr.eval(z);
! 3062: }
! 3063:
! 3064: template <>
! 3065: inline void __gmp_set_expr(mpz_ptr z, const mpz_classref &w)
! 3066: {
! 3067: mpz_set(z, w.get_mpz_t());
! 3068: }
! 3069:
! 3070: template <>
! 3071: inline void __gmp_set_expr(mpz_ptr z, const mpq_class &q)
! 3072: {
! 3073: mpz_set_q(z, q.get_mpq_t());
! 3074: }
! 3075:
! 3076: template <class T>
! 3077: inline void __gmp_set_expr(mpz_ptr z, const __gmp_expr<__gmpq_value, T> &expr)
! 3078: {
! 3079: mpq_class temp(expr);
! 3080: mpz_set_q(z, temp.get_mpq_t());
! 3081: }
! 3082:
! 3083: template <class T>
! 3084: inline void __gmp_set_expr(mpz_ptr z, const mpf_class &f)
! 3085: {
! 3086: mpz_set_f(z, f.get_mpf_t());
! 3087: }
! 3088:
! 3089: template <class T>
! 3090: inline void __gmp_set_expr(mpz_ptr z, const __gmp_expr<__gmpf_value, T> &expr)
! 3091: {
! 3092: mpf_class temp(expr);
! 3093: mpz_set_f(z, temp.get_mpf_t());
! 3094: }
! 3095:
! 3096: template <>
! 3097: inline void __gmp_set_expr(mpq_ptr q, const mpz_class &z)
! 3098: {
! 3099: mpq_set_z(q, z.get_mpz_t());
! 3100: }
! 3101:
! 3102: template <class T>
! 3103: inline void __gmp_set_expr(mpq_ptr q, const __gmp_expr<__gmpz_value, T> &expr)
! 3104: {
! 3105: mpz_class temp(expr);
! 3106: mpq_set_z(q, temp.get_mpz_t());
! 3107: }
! 3108:
! 3109: template <>
! 3110: inline void __gmp_set_expr(mpq_ptr q, const mpz_classref &z)
! 3111: {
! 3112: mpq_set_z(q, z.get_mpz_t());
! 3113: }
! 3114:
! 3115: template <>
! 3116: inline void __gmp_set_expr(mpq_ptr q, const mpq_class &r)
! 3117: {
! 3118: mpq_set(q, r.get_mpq_t());
! 3119: }
! 3120:
! 3121: template <class T>
! 3122: inline void __gmp_set_expr(mpq_ptr q, const __gmp_expr<__gmpq_value, T> &expr)
! 3123: {
! 3124: expr.eval(q);
! 3125: }
! 3126:
! 3127: template <class T>
! 3128: inline void __gmp_set_expr(mpq_ptr q, const mpf_class &f)
! 3129: {
! 3130: mpq_set_f(q, f.get_mpf_t());
! 3131: }
! 3132:
! 3133: template <class T>
! 3134: inline void __gmp_set_expr(mpq_ptr q, const __gmp_expr<__gmpf_value, T> &expr)
! 3135: {
! 3136: mpf_class temp(expr);
! 3137: mpq_set_f(q, temp.get_mpf_t());
! 3138: }
! 3139:
! 3140: template <class T>
! 3141: inline void __gmp_set_expr(mpf_ptr f, const mpz_class &z)
! 3142: {
! 3143: mpf_set_z(f, z.get_mpz_t());
! 3144: }
! 3145:
! 3146: template <class T>
! 3147: inline void __gmp_set_expr(mpf_ptr f, const __gmp_expr<__gmpz_value, T> &expr)
! 3148: {
! 3149: mpz_class temp(expr);
! 3150: mpf_set_z(f, temp.get_mpz_t());
! 3151: }
! 3152:
! 3153: template <class T>
! 3154: inline void __gmp_set_expr(mpf_ptr f, const mpz_classref &z)
! 3155: {
! 3156: mpf_set_z(f, z.get_mpz_t());
! 3157: }
! 3158:
! 3159: template <class T>
! 3160: inline void __gmp_set_expr(mpf_ptr f, const mpq_class &q)
! 3161: {
! 3162: mpf_set_q(f, q.get_mpq_t());
! 3163: }
! 3164:
! 3165: template <class T>
! 3166: inline void __gmp_set_expr(mpf_ptr f, const __gmp_expr<__gmpq_value, T> &expr)
! 3167: {
! 3168: mpq_class temp(expr);
! 3169: mpf_set_q(f, temp.get_mpq_t());
! 3170: }
! 3171:
! 3172: template <>
! 3173: inline void __gmp_set_expr(mpf_ptr f, const mpf_class &g)
! 3174: {
! 3175: mpf_set(f, g.get_mpf_t());
! 3176: }
! 3177:
! 3178: template <class T>
! 3179: inline void __gmp_set_expr(mpf_ptr f, const __gmp_expr<__gmpf_value, T> &expr)
! 3180: {
! 3181: expr.eval(f, mpf_get_prec(f));
! 3182: }
! 3183:
! 3184:
! 3185: /**************** Specializations of __gmp_expr ****************/
! 3186: /* The eval() method of __gmp_expr<T, U> evaluates the corresponding
! 3187: expression assigning the result to its argument, which is either an
! 3188: mpz_t, mpq_t, or mpf_t -- this depends on the T argument, which is
! 3189: either __gmpz_value, __gmpq_value, or __gmpf_value, respectively.
! 3190: Compound expressions are evaluated recursively (temporaries are created
! 3191: to hold intermediate values), while for simple expressions the eval()
! 3192: method of the appropriate function object (available as the Op argument
! 3193: of either __gmp_unary_expr<T, Op> or __gmp_binary_expr<T, U, Op>) is
! 3194: called. */
! 3195:
! 3196: /**************** Unary expressions ****************/
! 3197: /* cases:
! 3198: - simple: argument is mp[zqf]_class, or mpz_classref
! 3199: - compound: argument is __gmp_expr<...> */
! 3200:
! 3201:
! 3202: // simple expressions
! 3203:
! 3204: template <class Op>
! 3205: class __gmp_expr<__gmpz_value, __gmp_unary_expr<mpz_class, Op> >
! 3206: {
! 3207: private:
! 3208: __gmp_unary_expr<mpz_class, Op> expr;
! 3209: public:
! 3210: __gmp_expr(const mpz_class &val) : expr(val) { }
! 3211: void eval(mpz_ptr z) const { Op::eval(z, expr.val.get_mpz_t()); }
! 3212: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3213: };
! 3214:
! 3215: template <class Op>
! 3216: class __gmp_expr<__gmpz_value, __gmp_unary_expr<mpz_classref, Op> >
! 3217: {
! 3218: private:
! 3219: __gmp_unary_expr<mpz_classref, Op> expr;
! 3220: public:
! 3221: __gmp_expr(const mpz_classref &val) : expr(val) { }
! 3222: void eval(mpz_ptr z) const { Op::eval(z, expr.val.get_mpz_t()); }
! 3223: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3224: };
! 3225:
! 3226: template <class Op>
! 3227: class __gmp_expr<__gmpq_value, __gmp_unary_expr<mpq_class, Op> >
! 3228: {
! 3229: private:
! 3230: __gmp_unary_expr<mpq_class, Op> expr;
! 3231: public:
! 3232: __gmp_expr(const mpq_class &val) : expr(val) { }
! 3233: void eval(mpq_ptr q) const { Op::eval(q, expr.val.get_mpq_t()); }
! 3234: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3235: };
! 3236:
! 3237: template <class Op>
! 3238: class __gmp_expr<__gmpf_value, __gmp_unary_expr<mpf_class, Op> >
! 3239: {
! 3240: private:
! 3241: __gmp_unary_expr<mpf_class, Op> expr;
! 3242: public:
! 3243: __gmp_expr(const mpf_class &val) : expr(val) { }
! 3244: void eval(mpf_ptr f, unsigned long int) const
! 3245: { Op::eval(f, expr.val.get_mpf_t()); }
! 3246: unsigned long int get_prec() const
! 3247: { return mpf_get_prec(expr.val.get_mpf_t()); }
! 3248: };
! 3249:
! 3250:
! 3251: // compound expressions
! 3252:
! 3253: template <class T, class U, class Op>
! 3254: class __gmp_expr<__gmpz_value, __gmp_unary_expr<__gmp_expr<T, U>, Op> >
! 3255: {
! 3256: private:
! 3257: __gmp_unary_expr<__gmp_expr<T, U>, Op> expr;
! 3258: public:
! 3259: __gmp_expr(const __gmp_expr<T, U> &val) : expr(val) { }
! 3260: void eval(mpz_ptr z) const
! 3261: {
! 3262: mpz_class temp(expr.val);
! 3263: Op::eval(z, temp.get_mpz_t());
! 3264: }
! 3265: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3266: };
! 3267:
! 3268: template <class T, class U, class Op>
! 3269: class __gmp_expr<__gmpq_value, __gmp_unary_expr<__gmp_expr<T, U>, Op> >
! 3270: {
! 3271: private:
! 3272: __gmp_unary_expr<__gmp_expr<T, U>, Op> expr;
! 3273: public:
! 3274: __gmp_expr(const __gmp_expr<T, U> &val) : expr(val) { }
! 3275: void eval(mpq_ptr q) const
! 3276: {
! 3277: mpq_class temp(expr.val);
! 3278: Op::eval(q, temp.get_mpq_t());
! 3279: }
! 3280: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3281: };
! 3282:
! 3283: template <class T, class U, class Op>
! 3284: class __gmp_expr<__gmpf_value, __gmp_unary_expr<__gmp_expr<T, U>, Op> >
! 3285: {
! 3286: private:
! 3287: __gmp_unary_expr<__gmp_expr<T, U>, Op> expr;
! 3288: public:
! 3289: __gmp_expr(const __gmp_expr<T, U> &val) : expr(val) { }
! 3290: void eval(mpf_ptr f, unsigned long int prec) const
! 3291: {
! 3292: mpf_class temp(expr.val, prec);
! 3293: Op::eval(f, temp.get_mpf_t());
! 3294: }
! 3295: unsigned long int get_prec() const { return expr.val.get_prec(); }
! 3296: };
! 3297:
! 3298:
! 3299: /**************** Binary expressions ****************/
! 3300: /* simple:
! 3301: - arguments are both mp[zqf]_class, or mpz_classref
! 3302: - one argument is mp[zqf]_class(ref), one is a built-in type
! 3303: compound:
! 3304: - one is mp[zqf]_class(ref), one is __gmp_expr<...>
! 3305: - one is __gmp_expr<...>, one is built-in
! 3306: - both arguments are __gmp_expr<...> */
! 3307:
! 3308:
! 3309: // simple expressions
! 3310:
! 3311: template <class Op>
! 3312: class __gmp_expr<__gmpz_value, __gmp_binary_expr<mpz_class, mpz_class, Op> >
! 3313: {
! 3314: private:
! 3315: __gmp_binary_expr<mpz_class, mpz_class, Op> expr;
! 3316: public:
! 3317: __gmp_expr(const mpz_class &val1, const mpz_class &val2)
! 3318: : expr(val1, val2) { }
! 3319: void eval(mpz_ptr z) const
! 3320: { Op::eval(z, expr.val1.get_mpz_t(), expr.val2.get_mpz_t()); }
! 3321: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3322: };
! 3323:
! 3324: template <class Op>
! 3325: class __gmp_expr
! 3326: <__gmpz_value, __gmp_binary_expr<mpz_class, mpz_classref, Op> >
! 3327: {
! 3328: private:
! 3329: __gmp_binary_expr<mpz_class, mpz_classref, Op> expr;
! 3330: public:
! 3331: __gmp_expr(const mpz_class &val1, const mpz_classref &val2)
! 3332: : expr(val1, val2) { }
! 3333: void eval(mpz_ptr z) const
! 3334: { Op::eval(z, expr.val1.get_mpz_t(), expr.val2.get_mpz_t()); }
! 3335: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3336: };
! 3337:
! 3338: template <class Op>
! 3339: class __gmp_expr
! 3340: <__gmpz_value, __gmp_binary_expr<mpz_classref, mpz_class, Op> >
! 3341: {
! 3342: private:
! 3343: __gmp_binary_expr<mpz_classref, mpz_class, Op> expr;
! 3344: public:
! 3345: __gmp_expr(const mpz_classref &val1, const mpz_class &val2)
! 3346: : expr(val1, val2) { }
! 3347: void eval(mpz_ptr z) const
! 3348: { Op::eval(z, expr.val1.get_mpz_t(), expr.val2.get_mpz_t()); }
! 3349: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3350: };
! 3351:
! 3352: template <class Op>
! 3353: class __gmp_expr
! 3354: <__gmpz_value, __gmp_binary_expr<mpz_classref, mpz_classref, Op> >
! 3355: {
! 3356: private:
! 3357: __gmp_binary_expr<mpz_classref, mpz_classref, Op> expr;
! 3358: public:
! 3359: __gmp_expr(const mpz_classref &val1, const mpz_classref &val2)
! 3360: : expr(val1, val2) { }
! 3361: void eval(mpz_ptr z) const
! 3362: { Op::eval(z, expr.val1.get_mpz_t(), expr.val2.get_mpz_t()); }
! 3363: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3364: };
! 3365:
! 3366: template <class Op>
! 3367: class __gmp_expr<__gmpq_value, __gmp_binary_expr<mpq_class, mpq_class, Op> >
! 3368: {
! 3369: private:
! 3370: __gmp_binary_expr<mpq_class, mpq_class, Op> expr;
! 3371: public:
! 3372: __gmp_expr(const mpq_class &val1, const mpq_class &val2)
! 3373: : expr(val1, val2) { }
! 3374: void eval(mpq_ptr q) const
! 3375: { Op::eval(q, expr.val1.get_mpq_t(), expr.val2.get_mpq_t()); }
! 3376: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3377: };
! 3378:
! 3379: template <class Op>
! 3380: class __gmp_expr<__gmpf_value, __gmp_binary_expr<mpf_class, mpf_class, Op> >
! 3381: {
! 3382: private:
! 3383: __gmp_binary_expr<mpf_class, mpf_class, Op> expr;
! 3384: public:
! 3385: __gmp_expr(const mpf_class &val1, const mpf_class &val2)
! 3386: : expr(val1, val2) { }
! 3387: void eval(mpf_ptr f, unsigned long int) const
! 3388: { Op::eval(f, expr.val1.get_mpf_t(), expr.val2.get_mpf_t()); }
! 3389: unsigned long int get_prec() const
! 3390: {
! 3391: unsigned long int prec1 = expr.val1.get_prec(),
! 3392: prec2 = expr.val2.get_prec();
! 3393: return (prec1 > prec2) ? prec1 : prec2;
! 3394: }
! 3395: };
! 3396:
! 3397:
! 3398: // simple expressions, T is a built-in numerical type
! 3399:
! 3400: template <class T, class Op>
! 3401: class __gmp_expr<__gmpz_value, __gmp_binary_expr<mpz_class, T, Op> >
! 3402: {
! 3403: private:
! 3404: __gmp_binary_expr<mpz_class, T, Op> expr;
! 3405: public:
! 3406: __gmp_expr(const mpz_class &val1, T val2) : expr(val1, val2) { }
! 3407: void eval(mpz_ptr z) const
! 3408: { Op::eval(z, expr.val1.get_mpz_t(), expr.val2); }
! 3409: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3410: };
! 3411:
! 3412: template <class T, class Op>
! 3413: class __gmp_expr<__gmpz_value, __gmp_binary_expr<T, mpz_class, Op> >
! 3414: {
! 3415: private:
! 3416: __gmp_binary_expr<T, mpz_class, Op> expr;
! 3417: public:
! 3418: __gmp_expr(T val1, const mpz_class &val2) : expr(val1, val2) { }
! 3419: void eval(mpz_ptr z) const
! 3420: { Op::eval(z, expr.val1, expr.val2.get_mpz_t()); }
! 3421: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3422: };
! 3423:
! 3424: template <class T, class Op>
! 3425: class __gmp_expr<__gmpz_value, __gmp_binary_expr<mpz_classref, T, Op> >
! 3426: {
! 3427: private:
! 3428: __gmp_binary_expr<mpz_classref, T, Op> expr;
! 3429: public:
! 3430: __gmp_expr(const mpz_classref &val1, T val2) : expr(val1, val2) { }
! 3431: void eval(mpz_ptr z) const
! 3432: { Op::eval(z, expr.val1.get_mpz_t(), expr.val2); }
! 3433: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3434: };
! 3435:
! 3436: template <class T, class Op>
! 3437: class __gmp_expr<__gmpz_value, __gmp_binary_expr<T, mpz_classref, Op> >
! 3438: {
! 3439: private:
! 3440: __gmp_binary_expr<T, mpz_classref, Op> expr;
! 3441: public:
! 3442: __gmp_expr(T val1, const mpz_classref &val2) : expr(val1, val2) { }
! 3443: void eval(mpz_ptr z) const
! 3444: { Op::eval(z, expr.val1, expr.val2.get_mpz_t()); }
! 3445: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3446: };
! 3447:
! 3448: template <class T, class Op>
! 3449: class __gmp_expr<__gmpq_value, __gmp_binary_expr<mpq_class, T, Op> >
! 3450: {
! 3451: private:
! 3452: __gmp_binary_expr<mpq_class, T, Op> expr;
! 3453: public:
! 3454: __gmp_expr(const mpq_class &val1, T val2) : expr(val1, val2) { }
! 3455: void eval(mpq_ptr q) const
! 3456: { Op::eval(q, expr.val1.get_mpq_t(), expr.val2); }
! 3457: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3458: };
! 3459:
! 3460: template <class T, class Op>
! 3461: class __gmp_expr<__gmpq_value, __gmp_binary_expr<T, mpq_class, Op> >
! 3462: {
! 3463: private:
! 3464: __gmp_binary_expr<T, mpq_class, Op> expr;
! 3465: public:
! 3466: __gmp_expr(T val1, const mpq_class &val2) : expr(val1, val2) { }
! 3467: void eval(mpq_ptr q) const
! 3468: { Op::eval(q, expr.val1, expr.val2.get_mpq_t()); }
! 3469: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3470: };
! 3471:
! 3472: template <class T, class Op>
! 3473: class __gmp_expr<__gmpf_value, __gmp_binary_expr<mpf_class, T, Op> >
! 3474: {
! 3475: private:
! 3476: __gmp_binary_expr<mpf_class, T, Op> expr;
! 3477: public:
! 3478: __gmp_expr(const mpf_class &val1, T val2) : expr(val1, val2) { }
! 3479: void eval(mpf_ptr f, unsigned long int) const
! 3480: { Op::eval(f, expr.val1.get_mpf_t(), expr.val2); }
! 3481: unsigned long int get_prec() const
! 3482: {
! 3483: unsigned long int prec1 = expr.val1.get_prec(),
! 3484: prec2 = mpf_get_default_prec();
! 3485: return (prec1 > prec2) ? prec1 : prec2;
! 3486: }
! 3487: };
! 3488:
! 3489: template <class T, class Op>
! 3490: class __gmp_expr<__gmpf_value, __gmp_binary_expr<T, mpf_class, Op> >
! 3491: {
! 3492: private:
! 3493: __gmp_binary_expr<T, mpf_class, Op> expr;
! 3494: public:
! 3495: __gmp_expr(T val1, const mpf_class &val2) : expr(val1, val2) { }
! 3496: void eval(mpf_ptr f, unsigned long int) const
! 3497: { Op::eval(f, expr.val1, expr.val2.get_mpf_t()); }
! 3498: unsigned long int get_prec() const
! 3499: {
! 3500: unsigned long int prec1 = mpf_get_default_prec(),
! 3501: prec2 = expr.val2.get_prec();
! 3502: return (prec1 > prec2) ? prec1 : prec2;
! 3503: }
! 3504: };
! 3505:
! 3506:
! 3507: // compound expressions, one argument is a subexpression
! 3508:
! 3509: template <class T, class U, class Op>
! 3510: class __gmp_expr
! 3511: <__gmpz_value, __gmp_binary_expr<mpz_class, __gmp_expr<T, U>, Op> >
! 3512: {
! 3513: private:
! 3514: __gmp_binary_expr<mpz_class, __gmp_expr<T, U>, Op> expr;
! 3515: public:
! 3516: __gmp_expr(const mpz_class &val1, const __gmp_expr<T, U> &val2)
! 3517: : expr(val1, val2) { }
! 3518: void eval(mpz_ptr z) const
! 3519: {
! 3520: mpz_class temp(expr.val2);
! 3521: Op::eval(z, expr.val1.get_mpz_t(), temp.get_mpz_t());
! 3522: }
! 3523: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3524: };
! 3525:
! 3526: template <class T, class U, class Op>
! 3527: class __gmp_expr
! 3528: <__gmpz_value, __gmp_binary_expr<__gmp_expr<T, U>, mpz_class, Op> >
! 3529: {
! 3530: private:
! 3531: __gmp_binary_expr<__gmp_expr<T, U>, mpz_class, Op> expr;
! 3532: public:
! 3533: __gmp_expr(const __gmp_expr<T, U> &val1, const mpz_class &val2)
! 3534: : expr(val1, val2) { }
! 3535: void eval(mpz_ptr z) const
! 3536: {
! 3537: mpz_class temp(expr.val1);
! 3538: Op::eval(z, temp.get_mpz_t(), expr.val2.get_mpz_t());
! 3539: }
! 3540: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3541: };
! 3542:
! 3543: template <class T, class U, class Op>
! 3544: class __gmp_expr
! 3545: <__gmpz_value, __gmp_binary_expr<mpz_classref, __gmp_expr<T, U>, Op> >
! 3546: {
! 3547: private:
! 3548: __gmp_binary_expr<mpz_classref, __gmp_expr<T, U>, Op> expr;
! 3549: public:
! 3550: __gmp_expr(const mpz_classref &val1, const __gmp_expr<T, U> &val2)
! 3551: : expr(val1, val2) { }
! 3552: void eval(mpz_ptr z) const
! 3553: {
! 3554: mpz_class temp(expr.val2);
! 3555: Op::eval(z, expr.val1.get_mpz_t(), temp.get_mpz_t());
! 3556: }
! 3557: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3558: };
! 3559:
! 3560: template <class T, class U, class Op>
! 3561: class __gmp_expr
! 3562: <__gmpz_value, __gmp_binary_expr<__gmp_expr<T, U>, mpz_classref, Op> >
! 3563: {
! 3564: private:
! 3565: __gmp_binary_expr<__gmp_expr<T, U>, mpz_classref, Op> expr;
! 3566: public:
! 3567: __gmp_expr(const __gmp_expr<T, U> &val1, const mpz_classref &val2)
! 3568: : expr(val1, val2) { }
! 3569: void eval(mpz_ptr z) const
! 3570: {
! 3571: mpz_class temp(expr.val1);
! 3572: Op::eval(z, temp.get_mpz_t(), expr.val2.get_mpz_t());
! 3573: }
! 3574: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3575: };
! 3576:
! 3577: template <class T, class U, class Op>
! 3578: class __gmp_expr
! 3579: <__gmpq_value, __gmp_binary_expr<mpq_class, __gmp_expr<T, U>, Op> >
! 3580: {
! 3581: private:
! 3582: __gmp_binary_expr<mpq_class, __gmp_expr<T, U>, Op> expr;
! 3583: public:
! 3584: __gmp_expr(const mpq_class &val1, const __gmp_expr<T, U> &val2)
! 3585: : expr(val1, val2) { }
! 3586: void eval(mpq_ptr q) const
! 3587: {
! 3588: mpq_class temp(expr.val2);
! 3589: Op::eval(q, expr.val1.get_mpq_t(), temp.get_mpq_t());
! 3590: }
! 3591: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3592: };
! 3593:
! 3594: template <class T, class U, class Op>
! 3595: class __gmp_expr
! 3596: <__gmpq_value, __gmp_binary_expr<__gmp_expr<T, U>, mpq_class, Op> >
! 3597: {
! 3598: private:
! 3599: __gmp_binary_expr<__gmp_expr<T, U>, mpq_class, Op> expr;
! 3600: public:
! 3601: __gmp_expr(const __gmp_expr<T, U> &val1, const mpq_class &val2)
! 3602: : expr(val1, val2) { }
! 3603: void eval(mpq_ptr q) const
! 3604: {
! 3605: mpq_class temp(expr.val1);
! 3606: Op::eval(q, temp.get_mpq_t(), expr.val2.get_mpq_t());
! 3607: }
! 3608: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3609: };
! 3610:
! 3611: template <class T, class U, class Op>
! 3612: class __gmp_expr
! 3613: <__gmpf_value, __gmp_binary_expr<mpf_class, __gmp_expr<T, U>, Op> >
! 3614: {
! 3615: private:
! 3616: __gmp_binary_expr<mpf_class, __gmp_expr<T, U>, Op> expr;
! 3617: public:
! 3618: __gmp_expr(const mpf_class &val1, const __gmp_expr<T, U> &val2)
! 3619: : expr(val1, val2) { }
! 3620: void eval(mpf_ptr f, unsigned long int prec) const
! 3621: {
! 3622: mpf_class temp(expr.val2, prec);
! 3623: Op::eval(f, expr.val1.get_mpf_t(), temp.get_mpf_t());
! 3624: }
! 3625: unsigned long int get_prec() const
! 3626: {
! 3627: unsigned long int prec1 = expr.val1.get_prec(),
! 3628: prec2 = expr.val2.get_prec();
! 3629: return (prec1 > prec2) ? prec1 : prec2;
! 3630: }
! 3631: };
! 3632:
! 3633: template <class T, class U, class Op>
! 3634: class __gmp_expr
! 3635: <__gmpf_value, __gmp_binary_expr<__gmp_expr<T, U>, mpf_class, Op> >
! 3636: {
! 3637: private:
! 3638: __gmp_binary_expr<__gmp_expr<T, U>, mpf_class, Op> expr;
! 3639: public:
! 3640: __gmp_expr(const __gmp_expr<T, U> &val1, const mpf_class &val2)
! 3641: : expr(val1, val2) { }
! 3642: void eval(mpf_ptr f, unsigned long int prec) const
! 3643: {
! 3644: mpf_class temp(expr.val1, prec);
! 3645: Op::eval(f, temp.get_mpf_t(), expr.val2.get_mpf_t());
! 3646: }
! 3647: unsigned long int get_prec() const
! 3648: {
! 3649: unsigned long int prec1 = expr.val1.get_prec(),
! 3650: prec2 = expr.val2.get_prec();
! 3651: return (prec1 > prec2) ? prec1 : prec2;
! 3652: }
! 3653: };
! 3654:
! 3655:
! 3656: // one argument is a subexpression, one is a built-in
! 3657:
! 3658: template <class T, class U, class V, class Op>
! 3659: class __gmp_expr<__gmpz_value, __gmp_binary_expr<__gmp_expr<T, U>, V, Op> >
! 3660: {
! 3661: private:
! 3662: __gmp_binary_expr<__gmp_expr<T, U>, V, Op> expr;
! 3663: public:
! 3664: __gmp_expr(const __gmp_expr<T, U> &val1, V val2) : expr(val1, val2) { }
! 3665: void eval(mpz_ptr z) const
! 3666: {
! 3667: mpz_class temp(expr.val1);
! 3668: Op::eval(z, temp.get_mpz_t(), expr.val2);
! 3669: }
! 3670: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3671: };
! 3672:
! 3673: template <class T, class U, class V, class Op>
! 3674: class __gmp_expr<__gmpz_value, __gmp_binary_expr<T, __gmp_expr<U, V>, Op> >
! 3675: {
! 3676: private:
! 3677: __gmp_binary_expr<T, __gmp_expr<U, V>, Op> expr;
! 3678: public:
! 3679: __gmp_expr(T val1, const __gmp_expr<U, V> &val2) : expr(val1, val2) { }
! 3680: void eval(mpz_ptr z) const
! 3681: {
! 3682: mpz_class temp(expr.val2);
! 3683: Op::eval(z, expr.val1, temp.get_mpz_t());
! 3684: }
! 3685: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3686: };
! 3687:
! 3688: template <class T, class U, class V, class Op>
! 3689: class __gmp_expr<__gmpq_value, __gmp_binary_expr<__gmp_expr<T, U>, V, Op> >
! 3690: {
! 3691: private:
! 3692: __gmp_binary_expr<__gmp_expr<T, U>, V, Op> expr;
! 3693: public:
! 3694: __gmp_expr(const __gmp_expr<T, U> &val1, V val2) : expr(val1, val2) { }
! 3695: void eval(mpq_ptr q) const
! 3696: {
! 3697: mpq_class temp(expr.val1);
! 3698: Op::eval(q, temp.get_mpq_t(), expr.val2);
! 3699: }
! 3700: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3701: };
! 3702:
! 3703: template <class T, class U, class V, class Op>
! 3704: class __gmp_expr<__gmpq_value, __gmp_binary_expr<T, __gmp_expr<U, V>, Op> >
! 3705: {
! 3706: private:
! 3707: __gmp_binary_expr<T, __gmp_expr<U, V>, Op> expr;
! 3708: public:
! 3709: __gmp_expr(T val1, const __gmp_expr<U, V> &val2) : expr(val1, val2) { }
! 3710: void eval(mpq_ptr q) const
! 3711: {
! 3712: mpq_class temp(expr.val2);
! 3713: Op::eval(q, expr.val1, temp.get_mpq_t());
! 3714: }
! 3715: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3716: };
! 3717:
! 3718: template <class T, class U, class V, class Op>
! 3719: class __gmp_expr<__gmpf_value, __gmp_binary_expr<__gmp_expr<T, U>, V, Op> >
! 3720: {
! 3721: private:
! 3722: __gmp_binary_expr<__gmp_expr<T, U>, V, Op> expr;
! 3723: public:
! 3724: __gmp_expr(const __gmp_expr<T, U> &val1, V val2) : expr(val1, val2) { }
! 3725: void eval(mpf_ptr f, unsigned long int prec) const
! 3726: {
! 3727: mpf_class temp(expr.val1, prec);
! 3728: Op::eval(f, temp.get_mpf_t(), expr.val2);
! 3729: }
! 3730: unsigned long int get_prec() const
! 3731: {
! 3732: unsigned long int prec1 = expr.val1.get_prec(),
! 3733: prec2 = mpf_get_default_prec();
! 3734: return (prec1 > prec2) ? prec1 : prec2;
! 3735: }
! 3736: };
! 3737:
! 3738: template <class T, class U, class V, class Op>
! 3739: class __gmp_expr<__gmpf_value, __gmp_binary_expr<T, __gmp_expr<U, V>, Op> >
! 3740: {
! 3741: private:
! 3742: __gmp_binary_expr<T, __gmp_expr<U, V>, Op> expr;
! 3743: public:
! 3744: __gmp_expr(T val1, const __gmp_expr<U, V> &val2) : expr(val1, val2) { }
! 3745: void eval(mpf_ptr f, unsigned long int prec) const
! 3746: {
! 3747: mpf_class temp(expr.val2, prec);
! 3748: Op::eval(f, expr.val1, temp.get_mpf_t());
! 3749: }
! 3750: unsigned long int get_prec() const
! 3751: {
! 3752: unsigned long int prec1 = mpf_get_default_prec(),
! 3753: prec2 = expr.val2.get_prec();
! 3754: return (prec1 > prec2) ? prec1 : prec2;
! 3755: }
! 3756: };
! 3757:
! 3758:
! 3759: // both arguments are subexpressions
! 3760:
! 3761: template <class T, class U, class V, class W, class Op>
! 3762: class __gmp_expr
! 3763: <__gmpz_value, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
! 3764: {
! 3765: private:
! 3766: __gmp_binary_expr
! 3767: <__gmp_expr<T, U>, __gmp_expr<V, W>, Op> expr;
! 3768: public:
! 3769: __gmp_expr(const __gmp_expr<T, U> &val1, const __gmp_expr<V, W> &val2)
! 3770: : expr(val1, val2) { }
! 3771: void eval(mpz_ptr z) const
! 3772: {
! 3773: mpz_class temp1(expr.val1), temp2(expr.val2);
! 3774: Op::eval(z, temp1.get_mpz_t(), temp2.get_mpz_t());
! 3775: }
! 3776: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3777: };
! 3778:
! 3779: template <class T, class U, class V, class W, class Op>
! 3780: class __gmp_expr
! 3781: <__gmpq_value, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
! 3782: {
! 3783: private:
! 3784: __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> expr;
! 3785: public:
! 3786: __gmp_expr(const __gmp_expr<T, U> &val1, const __gmp_expr<V, W> &val2)
! 3787: : expr(val1, val2) { }
! 3788: void eval(mpq_ptr q) const
! 3789: {
! 3790: mpq_class temp1(expr.val1), temp2(expr.val2);
! 3791: Op::eval(q, temp1.get_mpq_t(), temp2.get_mpq_t());
! 3792: }
! 3793: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 3794: };
! 3795:
! 3796: template <class T, class U, class V, class W, class Op>
! 3797: class __gmp_expr
! 3798: <__gmpf_value, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
! 3799: {
! 3800: private:
! 3801: __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> expr;
! 3802: public:
! 3803: __gmp_expr(const __gmp_expr<T, U> &val1, const __gmp_expr<V, W> &val2)
! 3804: : expr(val1, val2) { }
! 3805: void eval(mpf_ptr f, unsigned long int prec) const
! 3806: {
! 3807: mpf_class temp1(expr.val1, prec), temp2(expr.val2, prec);
! 3808: Op::eval(f, temp1.get_mpf_t(), temp2.get_mpf_t());
! 3809: }
! 3810: unsigned long int get_prec() const
! 3811: {
! 3812: unsigned long int prec1 = expr.val1.get_prec(),
! 3813: prec2 = expr.val2.get_prec();
! 3814: return (prec1 > prec2) ? prec1 : prec2;
! 3815: }
! 3816: };
! 3817:
! 3818:
! 3819: /**************** Special cases ****************/
! 3820: /* Some operations (i.e., add and subtract) with mixed mpz/mpq arguments
! 3821: can be done directly without first converting the mpz to mpq.
! 3822: Appropriate specializations are required. */
! 3823:
! 3824:
! 3825: #define __GMPZQ_DEFINE_EXPR(eval_fun) \
! 3826: \
! 3827: template <> \
! 3828: class __gmp_expr \
! 3829: <__gmpq_value, __gmp_binary_expr<mpz_class, mpq_class, eval_fun> > \
! 3830: { \
! 3831: private: \
! 3832: __gmp_binary_expr<mpz_class, mpq_class, eval_fun> expr; \
! 3833: public: \
! 3834: __gmp_expr(const mpz_class &val1, const mpq_class &val2) \
! 3835: : expr(val1, val2) { } \
! 3836: void eval(mpq_ptr q) const \
! 3837: { eval_fun::eval(q, expr.val1.get_mpz_t(), expr.val2.get_mpq_t()); } \
! 3838: unsigned long int get_prec() const { return mpf_get_default_prec(); } \
! 3839: }; \
! 3840: \
! 3841: template <> \
! 3842: class __gmp_expr \
! 3843: <__gmpq_value, __gmp_binary_expr<mpq_class, mpz_class, eval_fun> > \
! 3844: { \
! 3845: private: \
! 3846: __gmp_binary_expr<mpq_class, mpz_class, eval_fun> expr; \
! 3847: public: \
! 3848: __gmp_expr(const mpq_class &val1, const mpz_class &val2) \
! 3849: : expr(val1, val2) { } \
! 3850: void eval(mpq_ptr q) const \
! 3851: { eval_fun::eval(q, expr.val1.get_mpq_t(), expr.val2.get_mpz_t()); } \
! 3852: unsigned long int get_prec() const { return mpf_get_default_prec(); } \
! 3853: }; \
! 3854: \
! 3855: template <class T> \
! 3856: class __gmp_expr<__gmpq_value, \
! 3857: __gmp_binary_expr<mpz_class, __gmp_expr<__gmpq_value, T>, eval_fun> > \
! 3858: { \
! 3859: private: \
! 3860: __gmp_binary_expr<mpz_class, __gmp_expr<__gmpq_value, T>, eval_fun> expr; \
! 3861: public: \
! 3862: __gmp_expr(const mpz_class &val1, const __gmp_expr<__gmpq_value, T> &val2) \
! 3863: : expr(val1, val2) { } \
! 3864: void eval(mpq_ptr q) const \
! 3865: { \
! 3866: mpq_class temp(expr.val2); \
! 3867: eval_fun::eval(q, expr.val1.get_mpz_t(), temp.get_mpq_t()); \
! 3868: } \
! 3869: unsigned long int get_prec() const { return mpf_get_default_prec(); } \
! 3870: }; \
! 3871: \
! 3872: template <class T> \
! 3873: class __gmp_expr<__gmpq_value, \
! 3874: __gmp_binary_expr<mpq_class, __gmp_expr<__gmpz_value, T>, eval_fun> > \
! 3875: { \
! 3876: private: \
! 3877: __gmp_binary_expr<mpq_class, __gmp_expr<__gmpz_value, T>, eval_fun> expr; \
! 3878: public: \
! 3879: __gmp_expr(const mpq_class &val1, const __gmp_expr<__gmpz_value, T> &val2) \
! 3880: : expr(val1, val2) { } \
! 3881: void eval(mpq_ptr q) const \
! 3882: { \
! 3883: mpz_class temp(expr.val2); \
! 3884: eval_fun::eval(q, expr.val1.get_mpq_t(), temp.get_mpz_t()); \
! 3885: } \
! 3886: unsigned long int get_prec() const { return mpf_get_default_prec(); } \
! 3887: }; \
! 3888: \
! 3889: template <class T> \
! 3890: class __gmp_expr<__gmpq_value, \
! 3891: __gmp_binary_expr<__gmp_expr<__gmpz_value, T>, mpq_class, eval_fun> > \
! 3892: { \
! 3893: private: \
! 3894: __gmp_binary_expr<__gmp_expr<__gmpz_value, T>, mpq_class, eval_fun> expr; \
! 3895: public: \
! 3896: __gmp_expr(const __gmp_expr<__gmpz_value, T> &val1, const mpq_class &val2) \
! 3897: : expr(val1, val2) { } \
! 3898: void eval(mpq_ptr q) const \
! 3899: { \
! 3900: mpz_class temp(expr.val1); \
! 3901: eval_fun::eval(q, temp.get_mpz_t(), expr.val2.get_mpq_t()); \
! 3902: } \
! 3903: unsigned long int get_prec() const { return mpf_get_default_prec(); } \
! 3904: }; \
! 3905: \
! 3906: template <class T> \
! 3907: class __gmp_expr<__gmpq_value, \
! 3908: __gmp_binary_expr<__gmp_expr<__gmpq_value, T>, mpz_class, eval_fun> > \
! 3909: { \
! 3910: private: \
! 3911: __gmp_binary_expr<__gmp_expr<__gmpq_value, T>, mpz_class, eval_fun> expr; \
! 3912: public: \
! 3913: __gmp_expr(const __gmp_expr<__gmpq_value, T> &val1, const mpz_class &val2) \
! 3914: : expr(val1, val2) { } \
! 3915: void eval(mpq_ptr q) const \
! 3916: { \
! 3917: mpq_class temp(expr.val1); \
! 3918: eval_fun::eval(q, temp.get_mpq_t(), expr.val2.get_mpz_t()); \
! 3919: } \
! 3920: unsigned long int get_prec() const { return mpf_get_default_prec(); } \
! 3921: }; \
! 3922: \
! 3923: template <class T, class U> \
! 3924: class __gmp_expr<__gmpq_value, __gmp_binary_expr \
! 3925: <__gmp_expr<__gmpz_value, T>, __gmp_expr<__gmpq_value, U>, eval_fun> > \
! 3926: { \
! 3927: private: \
! 3928: __gmp_binary_expr \
! 3929: <__gmp_expr<__gmpz_value, T>, __gmp_expr<__gmpq_value, U>, eval_fun> expr; \
! 3930: public: \
! 3931: __gmp_expr(const __gmp_expr<__gmpz_value, T> &val1, \
! 3932: const __gmp_expr<__gmpq_value, U> &val2) \
! 3933: : expr(val1, val2) { } \
! 3934: void eval(mpq_ptr q) const \
! 3935: { \
! 3936: mpz_class temp1(expr.val1); \
! 3937: mpq_class temp2(expr.val2); \
! 3938: eval_fun::eval(q, temp1.get_mpz_t(), temp2.get_mpq_t()); \
! 3939: } \
! 3940: unsigned long int get_prec() const { return mpf_get_default_prec(); } \
! 3941: }; \
! 3942: \
! 3943: template <class T, class U> \
! 3944: class __gmp_expr<__gmpq_value, __gmp_binary_expr \
! 3945: <__gmp_expr<__gmpq_value, T>, __gmp_expr<__gmpz_value, U>, eval_fun> > \
! 3946: { \
! 3947: private: \
! 3948: __gmp_binary_expr \
! 3949: <__gmp_expr<__gmpq_value, T>, __gmp_expr<__gmpz_value, U>, eval_fun> expr; \
! 3950: public: \
! 3951: __gmp_expr(const __gmp_expr<__gmpq_value, T> &val1, \
! 3952: const __gmp_expr<__gmpz_value, U> &val2) \
! 3953: : expr(val1, val2) { } \
! 3954: void eval(mpq_ptr q) const \
! 3955: { \
! 3956: mpq_class temp1(expr.val1); \
! 3957: mpz_class temp2(expr.val2); \
! 3958: eval_fun::eval(q, temp1.get_mpq_t(), temp2.get_mpz_t()); \
! 3959: } \
! 3960: unsigned long int get_prec() const { return mpf_get_default_prec(); } \
! 3961: };
! 3962:
! 3963:
! 3964: __GMPZQ_DEFINE_EXPR(__gmp_binary_plus)
! 3965: __GMPZQ_DEFINE_EXPR(__gmp_binary_minus)
! 3966:
! 3967:
! 3968: /**************** Macros for defining functions ****************/
! 3969: /* Results of operators and functions are __gmp_expr<T, U> objects.
! 3970: T determines the numerical type of the expression: it can be either
! 3971: __gmpz_value, __gmpq_value, or __gmpf_value.
! 3972: U is either __gmp_unary_expr<V, Op> or __gmp_binary_expr<V, W, Op>,
! 3973: where V and W are the arguments' types -- they can in turn be
! 3974: expressions, thus allowing to build compound expressions to any
! 3975: degree of complexity. Op is a function object that must have an
! 3976: eval() method accepting appropriate arguments.
! 3977: When the arguments of a binary expression have different numerical
! 3978: types, __gmp_resolve_expr is used to determine the "larger" type.
! 3979: Actual evaluation of a __gmp_expr<T, U> object is done when it gets
! 3980: assigned to an mp[zqf]_class: this is done by calling its eval()
! 3981: method. */
! 3982:
! 3983: // non-member operators and functions
! 3984:
! 3985: #define __GMP_DEFINE_UNARY_FUNCTION(fun, eval_fun) \
! 3986: \
! 3987: template <class T, class U> \
! 3988: inline __gmp_expr<T, __gmp_unary_expr<__gmp_expr<T, U>, eval_fun> > \
! 3989: fun(const __gmp_expr<T, U> &expr) \
! 3990: { \
! 3991: return __gmp_expr<T, __gmp_unary_expr<__gmp_expr<T, U>, eval_fun> >(expr); \
! 3992: }
! 3993:
! 3994: #define __GMP_DEFINE_BINARY_FUNCTION(fun, eval_fun) \
! 3995: \
! 3996: template <class T, class U, class V, class W> \
! 3997: inline __gmp_expr<typename __gmp_resolve_expr<T, V>::value_type, \
! 3998: __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, eval_fun> > \
! 3999: fun(const __gmp_expr<T, U> &expr1, const __gmp_expr<V, W> &expr2) \
! 4000: { \
! 4001: return __gmp_expr<typename __gmp_resolve_expr<T, V>::value_type, \
! 4002: __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, eval_fun> > \
! 4003: (expr1, expr2); \
! 4004: } \
! 4005: \
! 4006: template <class T, class U> \
! 4007: inline __gmp_expr \
! 4008: <T, __gmp_binary_expr<__gmp_expr<T, U>, signed long int, eval_fun> > \
! 4009: fun(const __gmp_expr<T, U> &expr, signed char c) \
! 4010: { \
! 4011: return __gmp_expr<T, __gmp_binary_expr \
! 4012: <__gmp_expr<T, U>, signed long int, eval_fun> >(expr, c); \
! 4013: } \
! 4014: \
! 4015: template <class T, class U> \
! 4016: inline __gmp_expr \
! 4017: <T, __gmp_binary_expr<signed long int, __gmp_expr<T, U>, eval_fun> > \
! 4018: fun(signed char c, const __gmp_expr<T, U> &expr) \
! 4019: { \
! 4020: return __gmp_expr<T, __gmp_binary_expr \
! 4021: <signed long int, __gmp_expr<T, U>, eval_fun> >(c, expr); \
! 4022: } \
! 4023: \
! 4024: template <class T, class U> \
! 4025: inline __gmp_expr \
! 4026: <T, __gmp_binary_expr<__gmp_expr<T, U>, unsigned long int, eval_fun> > \
! 4027: fun(const __gmp_expr<T, U> &expr, unsigned char c) \
! 4028: { \
! 4029: return __gmp_expr<T, __gmp_binary_expr \
! 4030: <__gmp_expr<T, U>, unsigned long int, eval_fun> >(expr, c); \
! 4031: } \
! 4032: \
! 4033: template <class T, class U> \
! 4034: inline __gmp_expr \
! 4035: <T, __gmp_binary_expr<unsigned long int, __gmp_expr<T, U>, eval_fun> > \
! 4036: fun(unsigned char c, const __gmp_expr<T, U> &expr) \
! 4037: { \
! 4038: return __gmp_expr<T, __gmp_binary_expr \
! 4039: <unsigned long int, __gmp_expr<T, U>, eval_fun> >(c, expr); \
! 4040: } \
! 4041: \
! 4042: template <class T, class U> \
! 4043: inline __gmp_expr \
! 4044: <T, __gmp_binary_expr<__gmp_expr<T, U>, signed long int, eval_fun> > \
! 4045: fun(const __gmp_expr<T, U> &expr, signed int i) \
! 4046: { \
! 4047: return __gmp_expr<T, __gmp_binary_expr \
! 4048: <__gmp_expr<T, U>, signed long int, eval_fun> >(expr, i); \
! 4049: } \
! 4050: \
! 4051: template <class T, class U> \
! 4052: inline __gmp_expr \
! 4053: <T, __gmp_binary_expr<signed long int, __gmp_expr<T, U>, eval_fun> > \
! 4054: fun(signed int i, const __gmp_expr<T, U> &expr) \
! 4055: { \
! 4056: return __gmp_expr<T, __gmp_binary_expr \
! 4057: <signed long int, __gmp_expr<T, U>, eval_fun> >(i, expr); \
! 4058: } \
! 4059: \
! 4060: template <class T, class U> \
! 4061: inline __gmp_expr \
! 4062: <T, __gmp_binary_expr<__gmp_expr<T, U>, unsigned long int, eval_fun> > \
! 4063: fun(const __gmp_expr<T, U> &expr, unsigned int i) \
! 4064: { \
! 4065: return __gmp_expr<T, __gmp_binary_expr \
! 4066: <__gmp_expr<T, U>, unsigned long int, eval_fun> >(expr, i); \
! 4067: } \
! 4068: \
! 4069: template <class T, class U> \
! 4070: inline __gmp_expr \
! 4071: <T, __gmp_binary_expr<unsigned long int, __gmp_expr<T, U>, eval_fun> > \
! 4072: fun(unsigned int i, const __gmp_expr<T, U> &expr) \
! 4073: { \
! 4074: return __gmp_expr<T, __gmp_binary_expr \
! 4075: <unsigned long int, __gmp_expr<T, U>, eval_fun> >(i, expr); \
! 4076: } \
! 4077: \
! 4078: template <class T, class U> \
! 4079: inline __gmp_expr \
! 4080: <T, __gmp_binary_expr<__gmp_expr<T, U>, signed long int, eval_fun> > \
! 4081: fun(const __gmp_expr<T, U> &expr, signed short int s) \
! 4082: { \
! 4083: return __gmp_expr<T, __gmp_binary_expr \
! 4084: <__gmp_expr<T, U>, signed long int, eval_fun> >(expr, s); \
! 4085: } \
! 4086: \
! 4087: template <class T, class U> \
! 4088: inline __gmp_expr \
! 4089: <T, __gmp_binary_expr<signed long int, __gmp_expr<T, U>, eval_fun> > \
! 4090: fun(signed short int s, const __gmp_expr<T, U> &expr) \
! 4091: { \
! 4092: return __gmp_expr<T, __gmp_binary_expr \
! 4093: <signed long int, __gmp_expr<T, U>, eval_fun> >(s, expr); \
! 4094: } \
! 4095: \
! 4096: template <class T, class U> \
! 4097: inline __gmp_expr \
! 4098: <T, __gmp_binary_expr<__gmp_expr<T, U>, unsigned long int, eval_fun> > \
! 4099: fun(const __gmp_expr<T, U> &expr, unsigned short int s) \
! 4100: { \
! 4101: return __gmp_expr<T, __gmp_binary_expr \
! 4102: <__gmp_expr<T, U>, unsigned long int, eval_fun> >(expr, s); \
! 4103: } \
! 4104: \
! 4105: template <class T, class U> \
! 4106: inline __gmp_expr \
! 4107: <T, __gmp_binary_expr<unsigned long int, __gmp_expr<T, U>, eval_fun> > \
! 4108: fun(unsigned short int s, const __gmp_expr<T, U> &expr) \
! 4109: { \
! 4110: return __gmp_expr<T, __gmp_binary_expr \
! 4111: <unsigned long int, __gmp_expr<T, U>, eval_fun> >(s, expr); \
! 4112: } \
! 4113: \
! 4114: template <class T, class U> \
! 4115: inline __gmp_expr \
! 4116: <T, __gmp_binary_expr<__gmp_expr<T, U>, signed long int, eval_fun> > \
! 4117: fun(const __gmp_expr<T, U> &expr, signed long int l) \
! 4118: { \
! 4119: return __gmp_expr<T, __gmp_binary_expr \
! 4120: <__gmp_expr<T, U>, signed long int, eval_fun> >(expr, l); \
! 4121: } \
! 4122: \
! 4123: template <class T, class U> \
! 4124: inline __gmp_expr \
! 4125: <T, __gmp_binary_expr<signed long int, __gmp_expr<T, U>, eval_fun> > \
! 4126: fun(signed long int l, const __gmp_expr<T, U> &expr) \
! 4127: { \
! 4128: return __gmp_expr<T, __gmp_binary_expr \
! 4129: <signed long int, __gmp_expr<T, U>, eval_fun> >(l, expr); \
! 4130: } \
! 4131: \
! 4132: template <class T, class U> \
! 4133: inline __gmp_expr \
! 4134: <T, __gmp_binary_expr<__gmp_expr<T, U>, unsigned long int, eval_fun> > \
! 4135: fun(const __gmp_expr<T, U> &expr, unsigned long int l) \
! 4136: { \
! 4137: return __gmp_expr<T, __gmp_binary_expr \
! 4138: <__gmp_expr<T, U>, unsigned long int, eval_fun> >(expr, l); \
! 4139: } \
! 4140: \
! 4141: template <class T, class U> \
! 4142: inline __gmp_expr \
! 4143: <T, __gmp_binary_expr<unsigned long int, __gmp_expr<T, U>, eval_fun> > \
! 4144: fun(unsigned long int l, const __gmp_expr<T, U> &expr) \
! 4145: { \
! 4146: return __gmp_expr<T, __gmp_binary_expr \
! 4147: <unsigned long int, __gmp_expr<T, U>, eval_fun> >(l, expr); \
! 4148: } \
! 4149: \
! 4150: template <class T, class U> \
! 4151: inline __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, double, eval_fun> > \
! 4152: fun(const __gmp_expr<T, U> &expr, float f) \
! 4153: { \
! 4154: return __gmp_expr \
! 4155: <T, __gmp_binary_expr<__gmp_expr<T, U>, double, eval_fun> >(expr, f); \
! 4156: } \
! 4157: \
! 4158: template <class T, class U> \
! 4159: inline __gmp_expr<T, __gmp_binary_expr<double, __gmp_expr<T, U>, eval_fun> > \
! 4160: fun(float f, const __gmp_expr<T, U> &expr) \
! 4161: { \
! 4162: return __gmp_expr \
! 4163: <T, __gmp_binary_expr<double, __gmp_expr<T, U>, eval_fun> >(f, expr); \
! 4164: } \
! 4165: \
! 4166: template <class T, class U> \
! 4167: inline __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, double, eval_fun> > \
! 4168: fun(const __gmp_expr<T, U> &expr, double d) \
! 4169: { \
! 4170: return __gmp_expr \
! 4171: <T, __gmp_binary_expr<__gmp_expr<T, U>, double, eval_fun> >(expr, d); \
! 4172: } \
! 4173: \
! 4174: template <class T, class U> \
! 4175: inline __gmp_expr<T, __gmp_binary_expr<double, __gmp_expr<T, U>, eval_fun> > \
! 4176: fun(double d, const __gmp_expr<T, U> &expr) \
! 4177: { \
! 4178: return __gmp_expr \
! 4179: <T, __gmp_binary_expr<double, __gmp_expr<T, U>, eval_fun> >(d, expr); \
! 4180: } \
! 4181: \
! 4182: template <class T, class U> \
! 4183: inline __gmp_expr \
! 4184: <T, __gmp_binary_expr<__gmp_expr<T, U>, long double, eval_fun> > \
! 4185: fun(const __gmp_expr<T, U> &expr, long double ld) \
! 4186: { \
! 4187: return __gmp_expr<T, __gmp_binary_expr \
! 4188: <__gmp_expr<T, U>, long double, eval_fun> >(expr, ld); \
! 4189: } \
! 4190: \
! 4191: template <class T, class U> \
! 4192: inline __gmp_expr \
! 4193: <T, __gmp_binary_expr<long double, __gmp_expr<T, U>, eval_fun> > \
! 4194: fun(long double ld, const __gmp_expr<T, U> &expr) \
! 4195: { \
! 4196: return __gmp_expr<T, __gmp_binary_expr \
! 4197: <long double, __gmp_expr<T, U>, eval_fun> >(ld, expr); \
! 4198: }
! 4199:
! 4200: #define __GMP_DEFINE_BINARY_FUNCTION_UI(fun, eval_fun) \
! 4201: \
! 4202: template <class T, class U> \
! 4203: inline __gmp_expr \
! 4204: <T, __gmp_binary_expr<__gmp_expr<T, U>, unsigned long int, eval_fun> > \
! 4205: fun(const __gmp_expr<T, U> &expr, unsigned long int l) \
! 4206: { \
! 4207: return __gmp_expr<T, __gmp_binary_expr \
! 4208: <__gmp_expr<T, U>, unsigned long int, eval_fun> >(expr, l); \
! 4209: }
! 4210:
! 4211: #define __GMP_DEFINE_UNARY_TYPE_FUNCTION(type, fun, eval_fun) \
! 4212: \
! 4213: template <class T, class U> \
! 4214: inline type fun(const __gmp_expr<T, U> &expr) \
! 4215: { \
! 4216: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4217: return eval_fun::eval(temp.get_mp()); \
! 4218: }
! 4219:
! 4220: #define __GMP_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun) \
! 4221: \
! 4222: template <class T, class U, class V, class W> \
! 4223: inline type fun(const __gmp_expr<T, U> &expr1, \
! 4224: const __gmp_expr<V, W> &expr2) \
! 4225: { \
! 4226: typename __gmp_resolve_expr<T, V>::temp_type temp1(expr1), temp2(expr2); \
! 4227: return eval_fun::eval(temp1.get_mp(), temp2.get_mp()); \
! 4228: } \
! 4229: \
! 4230: template <class T, class U> \
! 4231: inline type fun(const __gmp_expr<T, U> &expr1, \
! 4232: const __gmp_expr<T, U> &expr2) \
! 4233: { \
! 4234: typename __gmp_resolve_expr<T, T>::temp_type temp1(expr1), temp2(expr2); \
! 4235: return eval_fun::eval(temp1.get_mp(), temp2.get_mp()); \
! 4236: } \
! 4237: \
! 4238: template <class T, class U> \
! 4239: inline type fun(const __gmp_expr<T, U> &expr, signed char c) \
! 4240: { \
! 4241: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4242: return eval_fun::eval(temp.get_mp(), (signed long int) c); \
! 4243: } \
! 4244: \
! 4245: template <class T, class U> \
! 4246: inline type fun(signed char c, const __gmp_expr<T, U> &expr) \
! 4247: { \
! 4248: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4249: return eval_fun::eval((signed long int) c, temp.get_mp()); \
! 4250: } \
! 4251: \
! 4252: template <class T, class U> \
! 4253: inline type fun(const __gmp_expr<T, U> &expr, unsigned char c) \
! 4254: { \
! 4255: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4256: return eval_fun::eval(temp.get_mp(), (unsigned long int) c); \
! 4257: } \
! 4258: \
! 4259: template <class T, class U> \
! 4260: inline type fun(unsigned char c, const __gmp_expr<T, U> &expr) \
! 4261: { \
! 4262: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4263: return eval_fun::eval((unsigned long int) c, temp.get_mp()); \
! 4264: } \
! 4265: \
! 4266: template <class T, class U> \
! 4267: inline type fun(const __gmp_expr<T, U> &expr, signed int i) \
! 4268: { \
! 4269: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4270: return eval_fun::eval(temp.get_mp(), (signed long int) i); \
! 4271: } \
! 4272: \
! 4273: template <class T, class U> \
! 4274: inline type fun(signed int i, const __gmp_expr<T, U> &expr) \
! 4275: { \
! 4276: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4277: return eval_fun::eval((signed long int) i, temp.get_mp()); \
! 4278: } \
! 4279: \
! 4280: template <class T, class U> \
! 4281: inline type fun(const __gmp_expr<T, U> &expr, unsigned int i) \
! 4282: { \
! 4283: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4284: return eval_fun::eval(temp.get_mp(), (unsigned long int) i); \
! 4285: } \
! 4286: \
! 4287: template <class T, class U> \
! 4288: inline type fun(unsigned int i, const __gmp_expr<T, U> &expr) \
! 4289: { \
! 4290: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4291: return eval_fun::eval((unsigned long int) i, temp.get_mp()); \
! 4292: } \
! 4293: \
! 4294: template <class T, class U> \
! 4295: inline type fun(const __gmp_expr<T, U> &expr, signed short int s) \
! 4296: { \
! 4297: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4298: return eval_fun::eval(temp.get_mp(), (signed long int) s); \
! 4299: } \
! 4300: \
! 4301: template <class T, class U> \
! 4302: inline type fun(signed short int s, const __gmp_expr<T, U> &expr) \
! 4303: { \
! 4304: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4305: return eval_fun::eval((signed long int) s, temp.get_mp()); \
! 4306: } \
! 4307: \
! 4308: template <class T, class U> \
! 4309: inline type fun(const __gmp_expr<T, U> &expr, unsigned short int s) \
! 4310: { \
! 4311: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4312: return eval_fun::eval(temp.get_mp(), (unsigned long int) s); \
! 4313: } \
! 4314: \
! 4315: template <class T, class U> \
! 4316: inline type fun(unsigned short int s, const __gmp_expr<T, U> &expr) \
! 4317: { \
! 4318: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4319: return eval_fun::eval((unsigned long int) s, temp.get_mp()); \
! 4320: } \
! 4321: \
! 4322: template <class T, class U> \
! 4323: inline type fun(const __gmp_expr<T, U> &expr, signed long int l) \
! 4324: { \
! 4325: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4326: return eval_fun::eval(temp.get_mp(), l); \
! 4327: } \
! 4328: \
! 4329: template <class T, class U> \
! 4330: inline type fun(signed long int l, const __gmp_expr<T, U> &expr) \
! 4331: { \
! 4332: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4333: return eval_fun::eval(l, temp.get_mp()); \
! 4334: } \
! 4335: \
! 4336: template <class T, class U> \
! 4337: inline type fun(const __gmp_expr<T, U> &expr, unsigned long int l) \
! 4338: { \
! 4339: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4340: return eval_fun::eval(temp.get_mp(), l); \
! 4341: } \
! 4342: \
! 4343: template <class T, class U> \
! 4344: inline type fun(unsigned long int l, const __gmp_expr<T, U> &expr) \
! 4345: { \
! 4346: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4347: return eval_fun::eval(l, temp.get_mp()); \
! 4348: } \
! 4349: \
! 4350: template <class T, class U> \
! 4351: inline type fun(const __gmp_expr<T, U> &expr, float f) \
! 4352: { \
! 4353: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4354: return eval_fun::eval(temp.get_mp(), (double) f); \
! 4355: } \
! 4356: \
! 4357: template <class T, class U> \
! 4358: inline type fun(float f, const __gmp_expr<T, U> &expr) \
! 4359: { \
! 4360: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4361: return eval_fun::eval((double) f, temp.get_mp()); \
! 4362: } \
! 4363: \
! 4364: template <class T, class U> \
! 4365: inline type fun(const __gmp_expr<T, U> &expr, double d) \
! 4366: { \
! 4367: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4368: return eval_fun::eval(temp.get_mp(), d); \
! 4369: } \
! 4370: \
! 4371: template <class T, class U> \
! 4372: inline type fun(double d, const __gmp_expr<T, U> &expr) \
! 4373: { \
! 4374: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4375: return eval_fun::eval(d, temp.get_mp()); \
! 4376: } \
! 4377: \
! 4378: template <class T, class U> \
! 4379: inline type fun(const __gmp_expr<T, U> &expr, long double ld) \
! 4380: { \
! 4381: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4382: return eval_fun::eval(temp.get_mp(), ld); \
! 4383: } \
! 4384: \
! 4385: template <class T, class U> \
! 4386: inline type fun(long double ld, const __gmp_expr<T, U> &expr) \
! 4387: { \
! 4388: typename __gmp_resolve_expr<T, T>::temp_type temp(expr); \
! 4389: return eval_fun::eval(ld, temp.get_mp()); \
! 4390: }
! 4391:
! 4392:
! 4393: // member operators for mpz_class
! 4394:
! 4395: #define __GMPZZ_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 4396: \
! 4397: template <class T, class U> \
! 4398: inline mpz_class & mpz_class::fun(const __gmp_expr<T, U> &expr) \
! 4399: { \
! 4400: __gmpz_temp temp(expr); \
! 4401: eval_fun::eval(mp, mp, temp.get_mp()); \
! 4402: return *this; \
! 4403: }
! 4404:
! 4405: #define __GMPZN_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 4406: \
! 4407: inline mpz_class & mpz_class::fun(signed char c) \
! 4408: { \
! 4409: eval_fun::eval(mp, mp, (signed long int) c); \
! 4410: return *this; \
! 4411: } \
! 4412: \
! 4413: inline mpz_class & mpz_class::fun(unsigned char c) \
! 4414: { \
! 4415: eval_fun::eval(mp, mp, (unsigned long int) c); \
! 4416: return *this; \
! 4417: } \
! 4418: \
! 4419: inline mpz_class & mpz_class::fun(signed int i) \
! 4420: { \
! 4421: eval_fun::eval(mp, mp, (signed long int) i); \
! 4422: return *this; \
! 4423: } \
! 4424: \
! 4425: inline mpz_class & mpz_class::fun(unsigned int i) \
! 4426: { \
! 4427: eval_fun::eval(mp, mp, (unsigned long int) i); \
! 4428: return *this; \
! 4429: } \
! 4430: \
! 4431: inline mpz_class & mpz_class::fun(signed short int s) \
! 4432: { \
! 4433: eval_fun::eval(mp, mp, (signed long int) s); \
! 4434: return *this; \
! 4435: } \
! 4436: \
! 4437: inline mpz_class & mpz_class::fun(unsigned short int s) \
! 4438: { \
! 4439: eval_fun::eval(mp, mp, (unsigned long int) s); \
! 4440: return *this; \
! 4441: } \
! 4442: \
! 4443: inline mpz_class & mpz_class::fun(signed long int l) \
! 4444: { \
! 4445: eval_fun::eval(mp, mp, l); \
! 4446: return *this; \
! 4447: } \
! 4448: \
! 4449: inline mpz_class & mpz_class::fun(unsigned long int l) \
! 4450: { \
! 4451: eval_fun::eval(mp, mp, l); \
! 4452: return *this; \
! 4453: } \
! 4454: \
! 4455: inline mpz_class & mpz_class::fun(float f) \
! 4456: { \
! 4457: eval_fun::eval(mp, mp, (double) f); \
! 4458: return *this; \
! 4459: } \
! 4460: \
! 4461: inline mpz_class & mpz_class::fun(double d) \
! 4462: { \
! 4463: eval_fun::eval(mp, mp, d); \
! 4464: return *this; \
! 4465: } \
! 4466: \
! 4467: /* \
! 4468: inline mpz_class & mpz_class::fun(long double ld) \
! 4469: { \
! 4470: eval_fun::eval(mp, mp, ld); \
! 4471: return *this; \
! 4472: } */
! 4473:
! 4474: #define __GMPZ_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 4475: __GMPZZ_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 4476: __GMPZN_DEFINE_COMPOUND_OPERATOR(fun, eval_fun)
! 4477:
! 4478: #define __GMPZ_DEFINE_COMPOUND_OPERATOR_UI(fun, eval_fun) \
! 4479: \
! 4480: inline mpz_class & mpz_class::fun(unsigned long int l) \
! 4481: { \
! 4482: eval_fun::eval(mp, mp, l); \
! 4483: return *this; \
! 4484: }
! 4485:
! 4486: #define __GMPZ_DEFINE_INCREMENT_OPERATOR(fun, eval_fun) \
! 4487: \
! 4488: inline mpz_class & mpz_class::fun() \
! 4489: { \
! 4490: eval_fun::eval(mp, mp); \
! 4491: return *this; \
! 4492: } \
! 4493: \
! 4494: inline mpz_class mpz_class::fun(int) \
! 4495: { \
! 4496: mpz_class temp(*this); \
! 4497: eval_fun::eval(mp, mp); \
! 4498: return temp; \
! 4499: }
! 4500:
! 4501:
! 4502: // member operators for mpz_classref
! 4503:
! 4504: #define __GMPZRR_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 4505: \
! 4506: template <class T, class U> \
! 4507: inline mpz_classref & mpz_classref::fun(const __gmp_expr<T, U> &expr) \
! 4508: { \
! 4509: __gmpz_temp temp(expr); \
! 4510: eval_fun::eval(ref, ref, temp.get_mp()); \
! 4511: return *this; \
! 4512: }
! 4513:
! 4514: #define __GMPZRN_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 4515: \
! 4516: inline mpz_classref & mpz_classref::fun(signed char c) \
! 4517: { \
! 4518: eval_fun::eval(ref, ref, (signed long int) c); \
! 4519: return *this; \
! 4520: } \
! 4521: \
! 4522: inline mpz_classref & mpz_classref::fun(unsigned char c) \
! 4523: { \
! 4524: eval_fun::eval(ref, ref, (unsigned long int) c); \
! 4525: return *this; \
! 4526: } \
! 4527: \
! 4528: inline mpz_classref & mpz_classref::fun(signed int i) \
! 4529: { \
! 4530: eval_fun::eval(ref, ref, (signed long int) i); \
! 4531: return *this; \
! 4532: } \
! 4533: \
! 4534: inline mpz_classref & mpz_classref::fun(unsigned int i) \
! 4535: { \
! 4536: eval_fun::eval(ref, ref, (unsigned long int) i); \
! 4537: return *this; \
! 4538: } \
! 4539: \
! 4540: inline mpz_classref & mpz_classref::fun(signed short int s) \
! 4541: { \
! 4542: eval_fun::eval(ref, ref, (signed long int) s); \
! 4543: return *this; \
! 4544: } \
! 4545: \
! 4546: inline mpz_classref & mpz_classref::fun(unsigned short int s) \
! 4547: { \
! 4548: eval_fun::eval(ref, ref, (unsigned long int) s); \
! 4549: return *this; \
! 4550: } \
! 4551: \
! 4552: inline mpz_classref & mpz_classref::fun(signed long int l) \
! 4553: { \
! 4554: eval_fun::eval(ref, ref, l); \
! 4555: return *this; \
! 4556: } \
! 4557: \
! 4558: inline mpz_classref & mpz_classref::fun(unsigned long int l) \
! 4559: { \
! 4560: eval_fun::eval(ref, ref, l); \
! 4561: return *this; \
! 4562: } \
! 4563: \
! 4564: inline mpz_classref & mpz_classref::fun(float f) \
! 4565: { \
! 4566: eval_fun::eval(ref, ref, (double) f); \
! 4567: return *this; \
! 4568: } \
! 4569: \
! 4570: inline mpz_classref & mpz_classref::fun(double d) \
! 4571: { \
! 4572: eval_fun::eval(ref, ref, d); \
! 4573: return *this; \
! 4574: } \
! 4575: \
! 4576: /* \
! 4577: inline mpz_classref & mpz_classref::fun(long double ld) \
! 4578: { \
! 4579: eval_fun::eval(ref, ref, ld); \
! 4580: return *this; \
! 4581: } */
! 4582:
! 4583: #define __GMPZR_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 4584: __GMPZRR_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 4585: __GMPZRN_DEFINE_COMPOUND_OPERATOR(fun, eval_fun)
! 4586:
! 4587: #define __GMPZR_DEFINE_COMPOUND_OPERATOR_UI(fun, eval_fun) \
! 4588: \
! 4589: inline mpz_classref & mpz_classref::fun(unsigned long int l) \
! 4590: { \
! 4591: eval_fun::eval(ref, ref, l); \
! 4592: return *this; \
! 4593: }
! 4594:
! 4595: #define __GMPZR_DEFINE_INCREMENT_OPERATOR(fun, eval_fun) \
! 4596: \
! 4597: inline mpz_classref & mpz_classref::fun() \
! 4598: { \
! 4599: eval_fun::eval(ref, ref); \
! 4600: return *this; \
! 4601: } \
! 4602: \
! 4603: inline mpz_class mpz_classref::fun(int) \
! 4604: { \
! 4605: mpz_class temp(*this); \
! 4606: eval_fun::eval(ref, ref); \
! 4607: return temp; \
! 4608: }
! 4609:
! 4610:
! 4611: // member operators for mpq_class
! 4612:
! 4613: #define __GMPQQ_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 4614: \
! 4615: template <class T, class U> \
! 4616: inline mpq_class & mpq_class::fun(const __gmp_expr<T, U> &expr) \
! 4617: { \
! 4618: __gmpq_temp temp(expr); \
! 4619: eval_fun::eval(mp, mp, temp.get_mp()); \
! 4620: return *this; \
! 4621: }
! 4622:
! 4623: #define __GMPQN_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 4624: \
! 4625: inline mpq_class & mpq_class::fun(signed char c) \
! 4626: { \
! 4627: eval_fun::eval(mp, mp, (signed long int) c); \
! 4628: return *this; \
! 4629: } \
! 4630: \
! 4631: inline mpq_class & mpq_class::fun(unsigned char c) \
! 4632: { \
! 4633: eval_fun::eval(mp, mp, (unsigned long int) c); \
! 4634: return *this; \
! 4635: } \
! 4636: \
! 4637: inline mpq_class & mpq_class::fun(signed int i) \
! 4638: { \
! 4639: eval_fun::eval(mp, mp, (signed long int) i); \
! 4640: return *this; \
! 4641: } \
! 4642: \
! 4643: inline mpq_class & mpq_class::fun(unsigned int i) \
! 4644: { \
! 4645: eval_fun::eval(mp, mp, (unsigned long int) i); \
! 4646: return *this; \
! 4647: } \
! 4648: \
! 4649: inline mpq_class & mpq_class::fun(signed short int s) \
! 4650: { \
! 4651: eval_fun::eval(mp, mp, (signed long int) s); \
! 4652: return *this; \
! 4653: } \
! 4654: \
! 4655: inline mpq_class & mpq_class::fun(unsigned short int s) \
! 4656: { \
! 4657: eval_fun::eval(mp, mp, (unsigned long int) s); \
! 4658: return *this; \
! 4659: } \
! 4660: \
! 4661: inline mpq_class & mpq_class::fun(signed long int l) \
! 4662: { \
! 4663: eval_fun::eval(mp, mp, l); \
! 4664: return *this; \
! 4665: } \
! 4666: \
! 4667: inline mpq_class & mpq_class::fun(unsigned long int l) \
! 4668: { \
! 4669: eval_fun::eval(mp, mp, l); \
! 4670: return *this; \
! 4671: } \
! 4672: \
! 4673: inline mpq_class & mpq_class::fun(float f) \
! 4674: { \
! 4675: eval_fun::eval(mp, mp, (double) f); \
! 4676: return *this; \
! 4677: } \
! 4678: \
! 4679: inline mpq_class & mpq_class::fun(double d) \
! 4680: { \
! 4681: eval_fun::eval(mp, mp, d); \
! 4682: return *this; \
! 4683: } \
! 4684: \
! 4685: /* \
! 4686: inline mpq_class & mpq_class::fun(long double ld) \
! 4687: { \
! 4688: eval_fun::eval(mp, mp, ld); \
! 4689: return *this; \
! 4690: } */
! 4691:
! 4692: #define __GMPQ_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 4693: __GMPQQ_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 4694: __GMPQN_DEFINE_COMPOUND_OPERATOR(fun, eval_fun)
! 4695:
! 4696: #define __GMPQ_DEFINE_COMPOUND_OPERATOR_UI(fun, eval_fun) \
! 4697: \
! 4698: inline mpq_class & mpq_class::fun(unsigned long int l) \
! 4699: { \
! 4700: eval_fun::eval(mp, mp, l); \
! 4701: return *this; \
! 4702: }
! 4703:
! 4704: #define __GMPQ_DEFINE_INCREMENT_OPERATOR(fun, eval_fun) \
! 4705: \
! 4706: inline mpq_class & mpq_class::fun() \
! 4707: { \
! 4708: eval_fun::eval(mp, mp); \
! 4709: return *this; \
! 4710: } \
! 4711: \
! 4712: inline mpq_class mpq_class::fun(int) \
! 4713: { \
! 4714: mpq_class temp(*this); \
! 4715: eval_fun::eval(mp, mp); \
! 4716: return temp; \
! 4717: }
! 4718:
! 4719:
! 4720: // member operators for mpf_class
! 4721:
! 4722: #define __GMPFF_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 4723: \
! 4724: template <class T, class U> \
! 4725: inline mpf_class & mpf_class::fun(const __gmp_expr<T, U> &expr) \
! 4726: { \
! 4727: __gmpf_temp temp(expr, get_prec()); \
! 4728: eval_fun::eval(mp, mp, temp.get_mp()); \
! 4729: return *this; \
! 4730: }
! 4731:
! 4732: #define __GMPFN_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 4733: \
! 4734: inline mpf_class & mpf_class::fun(signed char c) \
! 4735: { \
! 4736: eval_fun::eval(mp, mp, (signed long int) c); \
! 4737: return *this; \
! 4738: } \
! 4739: \
! 4740: inline mpf_class & mpf_class::fun(unsigned char c) \
! 4741: { \
! 4742: eval_fun::eval(mp, mp, (unsigned long int) c); \
! 4743: return *this; \
! 4744: } \
! 4745: \
! 4746: inline mpf_class & mpf_class::fun(signed int i) \
! 4747: { \
! 4748: eval_fun::eval(mp, mp, (signed long int) i); \
! 4749: return *this; \
! 4750: } \
! 4751: \
! 4752: inline mpf_class & mpf_class::fun(unsigned int i) \
! 4753: { \
! 4754: eval_fun::eval(mp, mp, (unsigned long int) i); \
! 4755: return *this; \
! 4756: } \
! 4757: \
! 4758: inline mpf_class & mpf_class::fun(signed short int s) \
! 4759: { \
! 4760: eval_fun::eval(mp, mp, (signed long int) s); \
! 4761: return *this; \
! 4762: } \
! 4763: \
! 4764: inline mpf_class & mpf_class::fun(unsigned short int s) \
! 4765: { \
! 4766: eval_fun::eval(mp, mp, (unsigned long int) s); \
! 4767: return *this; \
! 4768: } \
! 4769: \
! 4770: inline mpf_class & mpf_class::fun(signed long int l) \
! 4771: { \
! 4772: eval_fun::eval(mp, mp, l); \
! 4773: return *this; \
! 4774: } \
! 4775: \
! 4776: inline mpf_class & mpf_class::fun(unsigned long int l) \
! 4777: { \
! 4778: eval_fun::eval(mp, mp, l); \
! 4779: return *this; \
! 4780: } \
! 4781: \
! 4782: inline mpf_class & mpf_class::fun(float f) \
! 4783: { \
! 4784: eval_fun::eval(mp, mp, (double) f); \
! 4785: return *this; \
! 4786: } \
! 4787: \
! 4788: inline mpf_class & mpf_class::fun(double d) \
! 4789: { \
! 4790: eval_fun::eval(mp, mp, d); \
! 4791: return *this; \
! 4792: } \
! 4793: \
! 4794: /* \
! 4795: inline mpf_class & mpf_class::fun(long double ld) \
! 4796: { \
! 4797: eval_fun::eval(mp, mp, ld); \
! 4798: return *this; \
! 4799: } */
! 4800:
! 4801: #define __GMPF_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 4802: __GMPFF_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 4803: __GMPFN_DEFINE_COMPOUND_OPERATOR(fun, eval_fun)
! 4804:
! 4805: #define __GMPF_DEFINE_COMPOUND_OPERATOR_UI(fun, eval_fun) \
! 4806: \
! 4807: inline mpf_class & mpf_class::fun(unsigned long int l) \
! 4808: { \
! 4809: eval_fun::eval(mp, mp, l); \
! 4810: return *this; \
! 4811: }
! 4812:
! 4813: #define __GMPF_DEFINE_INCREMENT_OPERATOR(fun, eval_fun) \
! 4814: \
! 4815: inline mpf_class & mpf_class::fun() \
! 4816: { \
! 4817: eval_fun::eval(mp, mp); \
! 4818: return *this; \
! 4819: } \
! 4820: \
! 4821: inline mpf_class mpf_class::fun(int) \
! 4822: { \
! 4823: mpf_class temp(*this); \
! 4824: eval_fun::eval(mp, mp); \
! 4825: return temp; \
! 4826: }
! 4827:
! 4828:
! 4829: /**************** Arithmetic operators and functions ****************/
! 4830:
! 4831: // non-member operators and functions
! 4832:
! 4833: __GMP_DEFINE_UNARY_FUNCTION(operator+, __gmp_unary_plus)
! 4834: __GMP_DEFINE_UNARY_FUNCTION(operator-, __gmp_unary_minus)
! 4835: __GMP_DEFINE_UNARY_FUNCTION(operator~, __gmp_unary_com)
! 4836:
! 4837: __GMP_DEFINE_BINARY_FUNCTION(operator+, __gmp_binary_plus)
! 4838: __GMP_DEFINE_BINARY_FUNCTION(operator-, __gmp_binary_minus)
! 4839: __GMP_DEFINE_BINARY_FUNCTION(operator*, __gmp_binary_multiplies)
! 4840: __GMP_DEFINE_BINARY_FUNCTION(operator/, __gmp_binary_divides)
! 4841: __GMP_DEFINE_BINARY_FUNCTION(operator%, __gmp_binary_modulus)
! 4842: __GMP_DEFINE_BINARY_FUNCTION(operator&, __gmp_binary_and)
! 4843: __GMP_DEFINE_BINARY_FUNCTION(operator|, __gmp_binary_ior)
! 4844: __GMP_DEFINE_BINARY_FUNCTION(operator^, __gmp_binary_xor)
! 4845:
! 4846: __GMP_DEFINE_BINARY_FUNCTION_UI(operator<<, __gmp_binary_lshift)
! 4847: __GMP_DEFINE_BINARY_FUNCTION_UI(operator>>, __gmp_binary_rshift)
! 4848:
! 4849: __GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator==, __gmp_binary_equal)
! 4850: __GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator!=, __gmp_binary_not_equal)
! 4851: __GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator<, __gmp_binary_less)
! 4852: __GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator<=, __gmp_binary_less_equal)
! 4853: __GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator>, __gmp_binary_greater)
! 4854: __GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator>=, \
! 4855: __gmp_binary_greater_equal)
! 4856:
! 4857: __GMP_DEFINE_UNARY_FUNCTION(abs, __gmp_abs_function)
! 4858: __GMP_DEFINE_UNARY_FUNCTION(trunc, __gmp_trunc_function)
! 4859: __GMP_DEFINE_UNARY_FUNCTION(floor, __gmp_floor_function)
! 4860: __GMP_DEFINE_UNARY_FUNCTION(ceil, __gmp_ceil_function)
! 4861: __GMP_DEFINE_UNARY_FUNCTION(sqrt, __gmp_sqrt_function)
! 4862: __GMP_DEFINE_BINARY_FUNCTION(hypot, __gmp_hypot_function)
! 4863:
! 4864: __GMP_DEFINE_UNARY_TYPE_FUNCTION(int, sgn, __gmp_sgn_function)
! 4865: __GMP_DEFINE_BINARY_TYPE_FUNCTION(int, cmp, __gmp_cmp_function)
! 4866:
! 4867: // member operators for mpz_class
! 4868:
! 4869: __GMPZ_DEFINE_COMPOUND_OPERATOR(operator+=, __gmp_binary_plus)
! 4870: __GMPZ_DEFINE_COMPOUND_OPERATOR(operator-=, __gmp_binary_minus)
! 4871: __GMPZ_DEFINE_COMPOUND_OPERATOR(operator*=, __gmp_binary_multiplies)
! 4872: __GMPZ_DEFINE_COMPOUND_OPERATOR(operator/=, __gmp_binary_divides)
! 4873: __GMPZ_DEFINE_COMPOUND_OPERATOR(operator%=, __gmp_binary_modulus)
! 4874:
! 4875: __GMPZZ_DEFINE_COMPOUND_OPERATOR(operator&=, __gmp_binary_and)
! 4876: __GMPZZ_DEFINE_COMPOUND_OPERATOR(operator|=, __gmp_binary_ior)
! 4877: __GMPZZ_DEFINE_COMPOUND_OPERATOR(operator^=, __gmp_binary_xor)
! 4878:
! 4879: __GMPZ_DEFINE_COMPOUND_OPERATOR_UI(operator<<=, __gmp_binary_lshift)
! 4880: __GMPZ_DEFINE_COMPOUND_OPERATOR_UI(operator>>=, __gmp_binary_rshift)
! 4881:
! 4882: __GMPZ_DEFINE_INCREMENT_OPERATOR(operator++, __gmp_unary_increment)
! 4883: __GMPZ_DEFINE_INCREMENT_OPERATOR(operator--, __gmp_unary_decrement)
! 4884:
! 4885: // member operators for mpz_classref
! 4886:
! 4887: __GMPZR_DEFINE_COMPOUND_OPERATOR(operator+=, __gmp_binary_plus)
! 4888: __GMPZR_DEFINE_COMPOUND_OPERATOR(operator-=, __gmp_binary_minus)
! 4889: __GMPZR_DEFINE_COMPOUND_OPERATOR(operator*=, __gmp_binary_multiplies)
! 4890: __GMPZR_DEFINE_COMPOUND_OPERATOR(operator/=, __gmp_binary_divides)
! 4891: __GMPZR_DEFINE_COMPOUND_OPERATOR(operator%=, __gmp_binary_modulus)
! 4892:
! 4893: __GMPZRR_DEFINE_COMPOUND_OPERATOR(operator&=, __gmp_binary_and)
! 4894: __GMPZRR_DEFINE_COMPOUND_OPERATOR(operator|=, __gmp_binary_ior)
! 4895: __GMPZRR_DEFINE_COMPOUND_OPERATOR(operator^=, __gmp_binary_xor)
! 4896:
! 4897: __GMPZR_DEFINE_COMPOUND_OPERATOR_UI(operator<<=, __gmp_binary_lshift)
! 4898: __GMPZR_DEFINE_COMPOUND_OPERATOR_UI(operator>>=, __gmp_binary_rshift)
! 4899:
! 4900: __GMPZR_DEFINE_INCREMENT_OPERATOR(operator++, __gmp_unary_increment)
! 4901: __GMPZR_DEFINE_INCREMENT_OPERATOR(operator--, __gmp_unary_decrement)
! 4902:
! 4903: // member operators for mpq_class
! 4904:
! 4905: __GMPQ_DEFINE_COMPOUND_OPERATOR(operator+=, __gmp_binary_plus)
! 4906: __GMPQ_DEFINE_COMPOUND_OPERATOR(operator-=, __gmp_binary_minus)
! 4907: __GMPQ_DEFINE_COMPOUND_OPERATOR(operator*=, __gmp_binary_multiplies)
! 4908: __GMPQ_DEFINE_COMPOUND_OPERATOR(operator/=, __gmp_binary_divides)
! 4909:
! 4910: __GMPQ_DEFINE_COMPOUND_OPERATOR_UI(operator<<=, __gmp_binary_lshift)
! 4911: __GMPQ_DEFINE_COMPOUND_OPERATOR_UI(operator>>=, __gmp_binary_rshift)
! 4912:
! 4913: __GMPQ_DEFINE_INCREMENT_OPERATOR(operator++, __gmp_unary_increment)
! 4914: __GMPQ_DEFINE_INCREMENT_OPERATOR(operator--, __gmp_unary_decrement)
! 4915:
! 4916: // member operators for mpf_class
! 4917:
! 4918: __GMPF_DEFINE_COMPOUND_OPERATOR(operator+=, __gmp_binary_plus)
! 4919: __GMPF_DEFINE_COMPOUND_OPERATOR(operator-=, __gmp_binary_minus)
! 4920: __GMPF_DEFINE_COMPOUND_OPERATOR(operator*=, __gmp_binary_multiplies)
! 4921: __GMPF_DEFINE_COMPOUND_OPERATOR(operator/=, __gmp_binary_divides)
! 4922:
! 4923: __GMPF_DEFINE_COMPOUND_OPERATOR_UI(operator<<=, __gmp_binary_lshift)
! 4924: __GMPF_DEFINE_COMPOUND_OPERATOR_UI(operator>>=, __gmp_binary_rshift)
! 4925:
! 4926: __GMPF_DEFINE_INCREMENT_OPERATOR(operator++, __gmp_unary_increment)
! 4927: __GMPF_DEFINE_INCREMENT_OPERATOR(operator--, __gmp_unary_decrement)
! 4928:
! 4929:
! 4930: /**************** Class wrapper for gmp_randstate_t ****************/
! 4931:
! 4932: class __gmp_urandomb_value { };
! 4933: class __gmp_urandomm_value { };
! 4934:
! 4935: template <>
! 4936: class __gmp_expr<__gmpz_value, __gmp_urandomb_value>
! 4937: {
! 4938: private:
! 4939: __gmp_randstate_struct *state;
! 4940: unsigned long int bits;
! 4941: public:
! 4942: __gmp_expr(gmp_randstate_t s, unsigned long int l) : state(s), bits(l) { }
! 4943: void eval(mpz_ptr z) const { __gmp_rand_function::eval(z, state, bits); }
! 4944: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 4945: };
! 4946:
! 4947: template <>
! 4948: class __gmp_expr<__gmpz_value, __gmp_urandomm_value>
! 4949: {
! 4950: private:
! 4951: __gmp_randstate_struct *state;
! 4952: mpz_class range;
! 4953: public:
! 4954: __gmp_expr(gmp_randstate_t s, const mpz_class &z) : state(s), range(z) { }
! 4955: void eval(mpz_ptr z) const
! 4956: { __gmp_rand_function::eval(z, state, range.get_mpz_t()); }
! 4957: unsigned long int get_prec() const { return mpf_get_default_prec(); }
! 4958: };
! 4959:
! 4960: template <>
! 4961: class __gmp_expr<__gmpf_value, __gmp_urandomb_value>
! 4962: {
! 4963: private:
! 4964: __gmp_randstate_struct *state;
! 4965: unsigned long int bits;
! 4966: public:
! 4967: __gmp_expr(gmp_randstate_t s, unsigned long int l) : state(s), bits(l) { }
! 4968: void eval(mpf_ptr f, unsigned long int prec) const
! 4969: { __gmp_rand_function::eval(f, state, (bits>0) ? get_prec() : prec); }
! 4970: unsigned long int get_prec() const
! 4971: {
! 4972: if (bits == 0)
! 4973: return mpf_get_default_prec();
! 4974: else
! 4975: return bits;
! 4976: }
! 4977: };
! 4978:
! 4979: extern "C" {
! 4980: typedef void __gmp_randinit_default_t (gmp_randstate_t);
! 4981: typedef void __gmp_randinit_lc_2exp_t (gmp_randstate_t, mpz_srcptr, unsigned long int, unsigned long int);
! 4982: typedef int __gmp_randinit_lc_2exp_size_t (gmp_randstate_t, unsigned long int);
! 4983: }
! 4984:
! 4985: class gmp_randclass
! 4986: {
! 4987: private:
! 4988: gmp_randstate_t state;
! 4989: gmp_randclass(const gmp_randclass &); // copy constructor not allowed
! 4990: void operator=(const gmp_randclass &); // copying with assignment not allowed
! 4991: public:
! 4992: // constructors and destructor
! 4993: gmp_randclass(gmp_randalg_t alg, unsigned long int size)
! 4994: {
! 4995: switch (alg)
! 4996: {
! 4997: case GMP_RAND_ALG_LC: // no other cases for now
! 4998: default:
! 4999: gmp_randinit(state, alg, size);
! 5000: break;
! 5001: }
! 5002: }
! 5003:
! 5004: // gmp_randinit_default
! 5005: gmp_randclass(__gmp_randinit_default_t* f)
! 5006: { f(state); }
! 5007:
! 5008: // gmp_randinit_lc_2exp
! 5009: gmp_randclass(__gmp_randinit_lc_2exp_t* f,
! 5010: mpz_class z, unsigned long int l1, unsigned long int l2)
! 5011: { f(state, z.get_mpz_t(), l1, l2); }
! 5012:
! 5013: // gmp_randinit_lc_2exp_size
! 5014: gmp_randclass(__gmp_randinit_lc_2exp_size_t* f,
! 5015: unsigned long int size)
! 5016: { f(state, size); }
! 5017:
! 5018: ~gmp_randclass() { gmp_randclear(state); }
! 5019:
! 5020: // initialize
! 5021: void seed(); // choose a random seed some way (?)
! 5022: void seed(unsigned long int s) { gmp_randseed_ui(state, s); }
! 5023: void seed(const mpz_class &z) { gmp_randseed(state, z.get_mpz_t()); }
! 5024:
! 5025: // get random number
! 5026: __gmp_expr<__gmpz_value, __gmp_urandomb_value>
! 5027: get_z_bits(unsigned long int l)
! 5028: { return __gmp_expr<__gmpz_value, __gmp_urandomb_value>(state, l); }
! 5029: __gmp_expr<__gmpz_value, __gmp_urandomb_value>
! 5030: get_z_bits(const mpz_class &z)
! 5031: { return get_z_bits(z.get_ui()); }
! 5032:
! 5033: __gmp_expr<__gmpz_value, __gmp_urandomm_value>
! 5034: get_z_range(const mpz_class &z)
! 5035: { return __gmp_expr<__gmpz_value, __gmp_urandomm_value>(state, z); }
! 5036: __gmp_expr<__gmpf_value, __gmp_urandomb_value>
! 5037: get_f(unsigned long int prec = 0)
! 5038: { return __gmp_expr<__gmpf_value, __gmp_urandomb_value>(state, prec); }
! 5039: };
! 5040:
! 5041:
! 5042: /**************** #undef all private macros ****************/
! 5043:
! 5044: #undef __GMPZQ_DEFINE_EXPR
! 5045:
! 5046: #undef __GMP_DEFINE_UNARY_FUNCTION
! 5047: #undef __GMP_DEFINE_BINARY_FUNCTION
! 5048: #undef __GMP_DEFINE_BINARY_FUNCTION_UI
! 5049: #undef __GMP_DEFINE_UNARY_TYPE_FUNCTION
! 5050: #undef __GMP_DEFINE_BINARY_TYPE_FUNCTION
! 5051:
! 5052: #undef __GMPZZ_DECLARE_COMPOUND_OPERATOR
! 5053: #undef __GMPZN_DECLARE_COMPOUND_OPERATOR
! 5054: #undef __GMPZ_DECLARE_COMPOUND_OPERATOR
! 5055: #undef __GMPZ_DECLARE_COMPOUND_OPERATOR_UI
! 5056: #undef __GMPZ_DECLARE_INCREMENT_OPERATOR
! 5057:
! 5058: #undef __GMPZZ_DEFINE_COMPOUND_OPERATOR
! 5059: #undef __GMPZN_DEFINE_COMPOUND_OPERATOR
! 5060: #undef __GMPZ_DEFINE_COMPOUND_OPERATOR
! 5061: #undef __GMPZ_DEFINE_COMPOUND_OPERATOR_UI
! 5062: #undef __GMPZ_DEFINE_INCREMENT_OPERATOR
! 5063:
! 5064: #undef __GMPZRR_DECLARE_COMPOUND_OPERATOR
! 5065: #undef __GMPZRN_DECLARE_COMPOUND_OPERATOR
! 5066: #undef __GMPZR_DECLARE_COMPOUND_OPERATOR
! 5067: #undef __GMPZR_DECLARE_COMPOUND_OPERATOR_UI
! 5068: #undef __GMPZR_DECLARE_INCREMENT_OPERATOR
! 5069:
! 5070: #undef __GMPZRR_DEFINE_COMPOUND_OPERATOR
! 5071: #undef __GMPZRN_DEFINE_COMPOUND_OPERATOR
! 5072: #undef __GMPZR_DEFINE_COMPOUND_OPERATOR
! 5073: #undef __GMPZR_DEFINE_COMPOUND_OPERATOR_UI
! 5074: #undef __GMPZR_DEFINE_INCREMENT_OPERATOR
! 5075:
! 5076: #undef __GMPQQ_DECLARE_COMPOUND_OPERATOR
! 5077: #undef __GMPQN_DECLARE_COMPOUND_OPERATOR
! 5078: #undef __GMPQ_DECLARE_COMPOUND_OPERATOR
! 5079: #undef __GMPQ_DECLARE_COMPOUND_OPERATOR_UI
! 5080: #undef __GMPQ_DECLARE_INCREMENT_OPERATOR
! 5081:
! 5082: #undef __GMPQQ_DEFINE_COMPOUND_OPERATOR
! 5083: #undef __GMPQN_DEFINE_COMPOUND_OPERATOR
! 5084: #undef __GMPQ_DEFINE_COMPOUND_OPERATOR
! 5085: #undef __GMPQ_DEFINE_COMPOUND_OPERATOR_UI
! 5086: #undef __GMPQ_DEFINE_INCREMENT_OPERATOR
! 5087:
! 5088: #undef __GMPFF_DECLARE_COMPOUND_OPERATOR
! 5089: #undef __GMPFN_DECLARE_COMPOUND_OPERATOR
! 5090: #undef __GMPF_DECLARE_COMPOUND_OPERATOR
! 5091: #undef __GMPF_DECLARE_COMPOUND_OPERATOR_UI
! 5092: #undef __GMPF_DECLARE_INCREMENT_OPERATOR
! 5093:
! 5094: #undef __GMPFF_DEFINE_COMPOUND_OPERATOR
! 5095: #undef __GMPFN_DEFINE_COMPOUND_OPERATOR
! 5096: #undef __GMPF_DEFINE_COMPOUND_OPERATOR
! 5097: #undef __GMPF_DEFINE_COMPOUND_OPERATOR_UI
! 5098: #undef __GMPF_DEFINE_INCREMENT_OPERATOR
! 5099:
! 5100:
! 5101: #endif /* __GMP_PLUSPLUS__ */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to gmpxx.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp