Annotation of OpenXM_contrib/gmp/mpfrxx.h, Revision 1.1
1.1 ! ohara 1: /* mpfrxx.h -- C++ class wrapper for MPFR. -*- 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: #ifndef __GMPFR_PLUSPLUS__
! 23: #define __GMPFR_PLUSPLUS__
! 24:
! 25: #include <iostream>
! 26: #include <string>
! 27: #include <gmp.h>
! 28: #include <mpfr.h>
! 29: #include "gmpxx.h"
! 30:
! 31:
! 32: class __gmpfr_value { };
! 33:
! 34: template <class T, class U>
! 35: void __gmp_set_expr(mpfr_ptr, const __gmp_expr<T, U> &);
! 36:
! 37: const int mpfr_default_base = 10;
! 38:
! 39:
! 40: /**************** Macros for in-class declarations ****************/
! 41:
! 42: #define __GMPFRR_DECLARE_COMPOUND_OPERATOR(fun) \
! 43: template <class T, class U> \
! 44: __gmp_expr<__gmpfr_value, __gmpfr_value> & fun(const __gmp_expr<T, U> &);
! 45:
! 46: #define __GMPFRN_DECLARE_COMPOUND_OPERATOR(fun) \
! 47: __gmp_expr & fun(signed char); \
! 48: __gmp_expr & fun(unsigned char); \
! 49: __gmp_expr & fun(signed int); \
! 50: __gmp_expr & fun(unsigned int); \
! 51: __gmp_expr & fun(signed short int); \
! 52: __gmp_expr & fun(unsigned short int); \
! 53: __gmp_expr & fun(signed long int); \
! 54: __gmp_expr & fun(unsigned long int); \
! 55: __gmp_expr & fun(float); \
! 56: __gmp_expr & fun(double); \
! 57: __gmp_expr & fun(long double);
! 58:
! 59: #define __GMPFR_DECLARE_COMPOUND_OPERATOR(fun) \
! 60: __GMPFRR_DECLARE_COMPOUND_OPERATOR(fun) \
! 61: __GMPFRN_DECLARE_COMPOUND_OPERATOR(fun)
! 62:
! 63: #define __GMPFR_DECLARE_COMPOUND_OPERATOR_UI(fun) \
! 64: __gmp_expr & fun(unsigned long int);
! 65:
! 66: #define __GMPFR_DECLARE_INCREMENT_OPERATOR(fun) \
! 67: inline __gmp_expr & fun(); \
! 68: inline __gmp_expr fun(int);
! 69:
! 70:
! 71: /**************** mpfr_class -- wrapper for mpfr_t ****************/
! 72:
! 73: template <>
! 74: class __gmp_expr<__gmpfr_value, __gmpfr_value>
! 75: {
! 76: private:
! 77: mpfr_t mp;
! 78: public:
! 79: // size information
! 80: unsigned long int get_prec() const { return mpfr_get_prec(mp); }
! 81:
! 82: // constructors and destructor
! 83: __gmp_expr() { mpfr_init(mp); }
! 84:
! 85: __gmp_expr(const __gmp_expr &f)
! 86: {
! 87: mpfr_init2(mp, f.get_prec());
! 88: mpfr_set(mp, f.mp, __gmp_default_rounding_mode);
! 89: }
! 90: __gmp_expr(const __gmp_expr &f, unsigned long int prec,
! 91: mp_rnd_t mode = __gmp_default_rounding_mode)
! 92: { mpfr_init2(mp, prec); mpfr_set(mp, f.mp, mode); }
! 93: template <class T, class U>
! 94: __gmp_expr(const __gmp_expr<T, U> &expr)
! 95: { mpfr_init2(mp, expr.get_prec()); __gmp_set_expr(mp, expr); }
! 96: template <class T, class U>
! 97: __gmp_expr(const __gmp_expr<T, U> &expr, unsigned long int prec)
! 98: { mpfr_init2(mp, prec); __gmp_set_expr(mp, expr); }
! 99:
! 100: __gmp_expr(signed char c)
! 101: { mpfr_init(mp); mpfr_set_si(mp, c, __gmp_default_rounding_mode); }
! 102: __gmp_expr(signed char c, unsigned long int prec,
! 103: mp_rnd_t mode = __gmp_default_rounding_mode)
! 104: { mpfr_init2(mp, prec); mpfr_set_si(mp, c, mode); }
! 105: __gmp_expr(unsigned char c)
! 106: { mpfr_init(mp); mpfr_set_ui(mp, c, __gmp_default_rounding_mode); }
! 107: __gmp_expr(unsigned char c, unsigned long int prec,
! 108: mp_rnd_t mode = __gmp_default_rounding_mode)
! 109: { mpfr_init2(mp, prec); mpfr_set_ui(mp, c, mode); }
! 110:
! 111: __gmp_expr(signed int i)
! 112: { mpfr_init(mp); mpfr_set_si(mp, i, __gmp_default_rounding_mode); }
! 113: __gmp_expr(signed int i, unsigned long int prec,
! 114: mp_rnd_t mode = __gmp_default_rounding_mode)
! 115: { mpfr_init2(mp, prec); mpfr_set_si(mp, i, mode); }
! 116: __gmp_expr(unsigned int i)
! 117: { mpfr_init(mp); mpfr_set_ui(mp, i, __gmp_default_rounding_mode); }
! 118: __gmp_expr(unsigned int i, unsigned long int prec,
! 119: mp_rnd_t mode = __gmp_default_rounding_mode)
! 120: { mpfr_init2(mp, prec); mpfr_set_ui(mp, i, mode); }
! 121:
! 122: __gmp_expr(signed short int s)
! 123: { mpfr_init(mp); mpfr_set_si(mp, s, __gmp_default_rounding_mode); }
! 124: __gmp_expr(signed short int s, unsigned long int prec,
! 125: mp_rnd_t mode = __gmp_default_rounding_mode)
! 126: { mpfr_init2(mp, prec); mpfr_set_si(mp, s, mode); }
! 127: __gmp_expr(unsigned short int s)
! 128: { mpfr_init(mp); mpfr_set_ui(mp, s, __gmp_default_rounding_mode); }
! 129: __gmp_expr(unsigned short int s, unsigned long int prec,
! 130: mp_rnd_t mode = __gmp_default_rounding_mode)
! 131: { mpfr_init2(mp, prec); mpfr_set_ui(mp, s, mode); }
! 132:
! 133: __gmp_expr(signed long int l)
! 134: { mpfr_init(mp); mpfr_set_si(mp, l, __gmp_default_rounding_mode); }
! 135: __gmp_expr(signed long int l, unsigned long int prec,
! 136: mp_rnd_t mode = __gmp_default_rounding_mode)
! 137: { mpfr_init2(mp, prec); mpfr_set_si(mp, l, mode); }
! 138: __gmp_expr(unsigned long int l)
! 139: { mpfr_init(mp); mpfr_set_ui(mp, l, __gmp_default_rounding_mode); }
! 140: __gmp_expr(unsigned long int l, unsigned long int prec,
! 141: mp_rnd_t mode = __gmp_default_rounding_mode)
! 142: { mpfr_init2(mp, prec); mpfr_set_ui(mp, l, mode); }
! 143:
! 144: __gmp_expr(float f)
! 145: { mpfr_init(mp); mpfr_set_d(mp, f, __gmp_default_rounding_mode); }
! 146: __gmp_expr(float f, unsigned long int prec,
! 147: mp_rnd_t mode = __gmp_default_rounding_mode)
! 148: { mpfr_init2(mp, prec); mpfr_set_d(mp, f, mode); }
! 149: __gmp_expr(double d)
! 150: { mpfr_init(mp); mpfr_set_d(mp, d, __gmp_default_rounding_mode); }
! 151: __gmp_expr(double d, unsigned long int prec,
! 152: mp_rnd_t mode = __gmp_default_rounding_mode)
! 153: { mpfr_init2(mp, prec); mpfr_set_d(mp, d, mode); }
! 154: /*
! 155: __gmp_expr(long double ld)
! 156: { mpfr_init(mp); mpfr_set_d(mp, ld, __gmp_default_rounding_mode); }
! 157: __gmp_expr(long double ld, unsigned long int prec,
! 158: mp_rnd_t mode = __gmp_default_rounding_mode)
! 159: { mpfr_init2(mp, prec); mpfr_set_d(mp, ld, mode); }
! 160: */
! 161:
! 162: /*
! 163: explicit __gmp_expr(const char *s)
! 164: { mpfr_init_set_str(mp, s, mpfr_default_base); }
! 165: __gmp_expr(const char *s, int base) { mpfr_init_set_str(mp, s, base); }
! 166: explicit __gmp_expr(const std::string &s)
! 167: { mpfr_init_set_str(mp, s.c_str(), mpfr_default_base); }
! 168: __gmp_expr(const std::string &s, int base)
! 169: { mpfr_init_set_str(mp, s.c_str(), base); }
! 170: */
! 171:
! 172: explicit __gmp_expr(mpfr_srcptr f)
! 173: {
! 174: mpfr_init2(mp, mpfr_get_prec(f));
! 175: mpfr_set(mp, f, __gmp_default_rounding_mode);
! 176: }
! 177: explicit __gmp_expr(mpfr_srcptr f, unsigned long int prec)
! 178: {
! 179: mpfr_init2(mp, prec);
! 180: mpfr_set(mp, f, __gmp_default_rounding_mode);
! 181: }
! 182:
! 183: ~__gmp_expr() { mpfr_clear(mp); }
! 184:
! 185: // assignment operators
! 186: __gmp_expr & operator=(const __gmp_expr &f)
! 187: { mpfr_set(mp, f.mp, __gmp_default_rounding_mode); return *this; }
! 188: template <class T, class U>
! 189: __gmp_expr<__gmpfr_value, __gmpfr_value> & operator=
! 190: (const __gmp_expr<T, U> &expr)
! 191: { __gmp_set_expr(mp, expr); return *this; }
! 192:
! 193: __gmp_expr & operator=(signed char c)
! 194: { mpfr_set_si(mp, c, __gmp_default_rounding_mode); return *this; }
! 195: __gmp_expr & operator=(unsigned char c)
! 196: { mpfr_set_ui(mp, c, __gmp_default_rounding_mode); return *this; }
! 197:
! 198: __gmp_expr & operator=(signed int i)
! 199: { mpfr_set_si(mp, i, __gmp_default_rounding_mode); return *this; }
! 200: __gmp_expr & operator=(unsigned int i)
! 201: { mpfr_set_ui(mp, i, __gmp_default_rounding_mode); return *this; }
! 202:
! 203: __gmp_expr & operator=(signed short int s)
! 204: { mpfr_set_si(mp, s, __gmp_default_rounding_mode); return *this; }
! 205: __gmp_expr & operator=(unsigned short int s)
! 206: { mpfr_set_ui(mp, s, __gmp_default_rounding_mode); return *this; }
! 207:
! 208: __gmp_expr & operator=(signed long int l)
! 209: { mpfr_set_si(mp, l, __gmp_default_rounding_mode); return *this; }
! 210: __gmp_expr & operator=(unsigned long int l)
! 211: { mpfr_set_ui(mp, l, __gmp_default_rounding_mode); return *this; }
! 212:
! 213: __gmp_expr & operator=(float f)
! 214: { mpfr_set_d(mp, f, __gmp_default_rounding_mode); return *this; }
! 215: __gmp_expr & operator=(double d)
! 216: { mpfr_set_d(mp, d, __gmp_default_rounding_mode); return *this; }
! 217: /*
! 218: __gmp_expr & operator=(long double ld)
! 219: { mpfr_set_d(mp, ld, __gmp_default_rounding_mode); return *this; }
! 220: */
! 221:
! 222: /*
! 223: __gmp_expr & operator=(const char *s)
! 224: { mpfr_set_str(mp, s, mpfr_default_base); return *this; }
! 225: __gmp_expr & operator=(const std::string &s)
! 226: { mpfr_set_str(mp, s.c_str(), mpfr_default_base); return *this; }
! 227:
! 228: // string input/output functions
! 229: int set_str(const std::string &s, int base)
! 230: { return mpfr_set_str(mp, s.c_str(), base); }
! 231: */
! 232: std::string get_str(mp_exp_t *expo, int base, size_t size,
! 233: mp_rnd_t rmode = __gmp_default_rounding_mode) const
! 234: {
! 235: __gmp_alloc_cstring temp(mpfr_get_str(0, expo, base, size, mp, rmode));
! 236: return std::string(temp.str);
! 237: }
! 238:
! 239: // conversion functions
! 240: mpfr_srcptr get_mpfr_t() const { return mp; }
! 241: mpfr_ptr get_mpfr_t() { return mp; }
! 242:
! 243: // signed long get_si() const { return mpfr_get_si(mp); }
! 244: // unsigned long get_ui() const { return mpfr_get_ui(mp); }
! 245: double get_d() const // should be long double
! 246: { return mpfr_get_d(mp, __gmp_default_rounding_mode); }
! 247:
! 248: // compound assignments
! 249: __GMPFR_DECLARE_COMPOUND_OPERATOR(operator+=)
! 250: __GMPFR_DECLARE_COMPOUND_OPERATOR(operator-=)
! 251: __GMPFR_DECLARE_COMPOUND_OPERATOR(operator*=)
! 252: __GMPFR_DECLARE_COMPOUND_OPERATOR(operator/=)
! 253:
! 254: __GMPFR_DECLARE_COMPOUND_OPERATOR_UI(operator<<=)
! 255: __GMPFR_DECLARE_COMPOUND_OPERATOR_UI(operator>>=)
! 256:
! 257: __GMPFR_DECLARE_INCREMENT_OPERATOR(operator++)
! 258: __GMPFR_DECLARE_INCREMENT_OPERATOR(operator--)
! 259: };
! 260:
! 261: typedef __gmp_expr<__gmpfr_value, __gmpfr_value> mpfr_class;
! 262:
! 263:
! 264: inline std::ostream & operator<<(std::ostream &o, const mpfr_class &f)
! 265: {
! 266: mp_exp_t expo;
! 267: int base = 10;
! 268: __gmp_alloc_cstring temp(mpfr_get_str(0, &expo, base, 0, f.get_mpfr_t(),
! 269: __gmp_default_rounding_mode));
! 270:
! 271: // cancel terminating zeros
! 272: for (size_t i=strlen(temp.str)-1; temp.str[i]=='0' && i>0; --i)
! 273: temp.str[i] = '\0';
! 274:
! 275: if (*temp.str == '-')
! 276: o << "-0." << temp.str+1;
! 277: else
! 278: o << "0." << temp.str;
! 279:
! 280: if (base <= 10)
! 281: o << "e" << expo;
! 282: else
! 283: o << "@" << expo;
! 284:
! 285: return o;
! 286: }
! 287:
! 288: template <class T>
! 289: inline std::ostream & operator<<
! 290: (std::ostream &o, const __gmp_expr<__gmpfr_value, T> &expr)
! 291: {
! 292: mpfr_class temp(expr);
! 293: return o << temp;
! 294: }
! 295:
! 296: inline std::istream & operator>>(std::istream &i, mpfr_class &f)
! 297: {
! 298: mpf_t temp;
! 299: mpf_init2(temp, f.get_prec());
! 300: i >> temp;
! 301: mpfr_set_f(f.get_mpfr_t(), temp, __gmp_default_rounding_mode);
! 302: mpf_clear(temp);
! 303: return i;
! 304: }
! 305:
! 306:
! 307: /**************** Classes for type conversion ****************/
! 308:
! 309: class __gmpfr_temp
! 310: {
! 311: private:
! 312: mpfr_srcptr mp;
! 313: bool is_temp;
! 314: mpfr_t temp;
! 315:
! 316: __gmpfr_temp();
! 317: __gmpfr_temp(const __gmpfr_temp &);
! 318: void operator=(const __gmpfr_temp &);
! 319: public:
! 320: __gmpfr_temp(const mpfr_class &f) : mp(f.get_mpfr_t()), is_temp(false) { }
! 321: __gmpfr_temp(const mpfr_class &f, unsigned long int)
! 322: : mp(f.get_mpfr_t()), is_temp(false) { }
! 323: template <class T, class U>
! 324: __gmpfr_temp(const __gmp_expr<T, U> &expr)
! 325: {
! 326: mpfr_init2(temp, expr.get_prec());
! 327: __gmp_set_expr(temp, expr);
! 328: mp = temp;
! 329: is_temp = true;
! 330: }
! 331: template <class T, class U>
! 332: __gmpfr_temp(const __gmp_expr<T, U> &expr, unsigned long int prec)
! 333: {
! 334: mpfr_init2(temp, prec);
! 335: __gmp_set_expr(temp, expr);
! 336: mp = temp;
! 337: is_temp = true;
! 338: }
! 339: ~__gmpfr_temp() { if (is_temp) mpfr_clear(temp); }
! 340:
! 341: mpfr_srcptr get_mp() const { return mp; }
! 342: };
! 343:
! 344:
! 345: template <>
! 346: struct __gmp_resolve_expr<__gmpz_value, __gmpfr_value>
! 347: {
! 348: typedef __gmpfr_value value_type;
! 349: typedef __gmpfr_temp temp_type;
! 350: };
! 351:
! 352: template <>
! 353: struct __gmp_resolve_expr<__gmpfr_value, __gmpz_value>
! 354: {
! 355: typedef __gmpfr_value value_type;
! 356: typedef __gmpfr_temp temp_type;
! 357: };
! 358:
! 359: template <>
! 360: struct __gmp_resolve_expr<__gmpq_value, __gmpfr_value>
! 361: {
! 362: typedef __gmpfr_value value_type;
! 363: typedef __gmpfr_temp temp_type;
! 364: };
! 365:
! 366: template <>
! 367: struct __gmp_resolve_expr<__gmpfr_value, __gmpq_value>
! 368: {
! 369: typedef __gmpfr_value value_type;
! 370: typedef __gmpfr_temp temp_type;
! 371: };
! 372:
! 373: template <>
! 374: struct __gmp_resolve_expr<__gmpf_value, __gmpfr_value>
! 375: {
! 376: typedef __gmpfr_value value_type;
! 377: typedef __gmpfr_temp temp_type;
! 378: };
! 379:
! 380: template <>
! 381: struct __gmp_resolve_expr<__gmpfr_value, __gmpf_value>
! 382: {
! 383: typedef __gmpfr_value value_type;
! 384: typedef __gmpfr_temp temp_type;
! 385: };
! 386:
! 387: template <>
! 388: struct __gmp_resolve_expr<__gmpfr_value, __gmpfr_value>
! 389: {
! 390: typedef __gmpfr_value value_type;
! 391: typedef __gmpfr_temp temp_type;
! 392: };
! 393:
! 394:
! 395: /*
! 396: template <class T>
! 397: inline void __gmp_set_expr(mpz_ptr z, const mpfr_class &f)
! 398: {
! 399: mpz_set_fr(z, f.get_mpfr_t());
! 400: }
! 401:
! 402: template <class T>
! 403: inline void __gmp_set_expr
! 404: (mpz_ptr z, const __gmp_expr<__gmpfr_value, T> &expr)
! 405: {
! 406: mpfr_class temp(expr);
! 407: mpz_set_fr(z, temp.get_mpfr_t());
! 408: }
! 409:
! 410: template <class T>
! 411: inline void __gmp_set_expr(mpq_ptr q, const mpfr_class &f)
! 412: {
! 413: mpq_set_fr(q, f.get_mpfr_t());
! 414: }
! 415:
! 416: template <class T>
! 417: inline void __gmp_set_expr
! 418: (mpq_ptr q, const __gmp_expr<__gmpfr_value, T> &expr)
! 419: {
! 420: mpfr_class temp(expr);
! 421: mpq_set_fr(q, temp.get_mpfr_t());
! 422: }
! 423:
! 424: template <class T>
! 425: inline void __gmp_set_expr(mpf_ptr f, const mpfr_class &g)
! 426: {
! 427: mpf_set_fr(f, g.get_mpfr_t());
! 428: }
! 429:
! 430: template <class T>
! 431: inline void __gmp_set_expr
! 432: (mpf_ptr f, const __gmp_expr<__gmpfr_value, T> &expr)
! 433: {
! 434: mpfr_class temp(expr);
! 435: mpf_set_fr(f, temp.get_mpfr_t());
! 436: }
! 437: */
! 438:
! 439: template <class T>
! 440: inline void __gmp_set_expr(mpfr_ptr f, const mpz_class &z)
! 441: {
! 442: mpfr_set_z(f, z.get_mpz_t(), __gmp_default_rounding_mode);
! 443: }
! 444:
! 445: template <class T>
! 446: inline void __gmp_set_expr(mpfr_ptr f, const mpz_classref &z)
! 447: {
! 448: mpfr_set_z(f, z.get_mpz_t(), __gmp_default_rounding_mode);
! 449: }
! 450:
! 451: template <class T>
! 452: inline void __gmp_set_expr
! 453: (mpfr_ptr f, const __gmp_expr<__gmpz_value, T> &expr)
! 454: {
! 455: mpz_class temp(expr);
! 456: mpfr_set_z(f, temp.get_mpz_t(), __gmp_default_rounding_mode);
! 457: }
! 458:
! 459: template <class T>
! 460: inline void __gmp_set_expr(mpfr_ptr f, const mpq_class &q)
! 461: {
! 462: mpfr_set_q(f, q.get_mpq_t(), __gmp_default_rounding_mode);
! 463: }
! 464:
! 465: template <class T>
! 466: inline void __gmp_set_expr
! 467: (mpfr_ptr f, const __gmp_expr<__gmpq_value, T> &expr)
! 468: {
! 469: mpq_class temp(expr);
! 470: mpfr_set_q(f, temp.get_mpq_t(), __gmp_default_rounding_mode);
! 471: }
! 472:
! 473: template <class T>
! 474: inline void __gmp_set_expr(mpfr_ptr f, const mpf_class &g)
! 475: {
! 476: mpfr_set_f(f, g.get_mpf_t(), __gmp_default_rounding_mode);
! 477: }
! 478:
! 479: template <class T>
! 480: inline void __gmp_set_expr
! 481: (mpfr_ptr f, const __gmp_expr<__gmpf_value, T> &expr)
! 482: {
! 483: mpq_class temp(expr);
! 484: mpfr_set_f(f, temp.get_mpf_t(), __gmp_default_rounding_mode);
! 485: }
! 486:
! 487: template <>
! 488: inline void __gmp_set_expr(mpfr_ptr f, const mpfr_class &g)
! 489: {
! 490: mpfr_set(f, g.get_mpfr_t(), __gmp_default_rounding_mode);
! 491: }
! 492:
! 493: template <class T>
! 494: inline void __gmp_set_expr
! 495: (mpfr_ptr f, const __gmp_expr<__gmpfr_value, T> &expr)
! 496: {
! 497: expr.eval(f, mpfr_get_prec(f));
! 498: }
! 499:
! 500:
! 501: /**************** Specializations of __gmp_expr ****************/
! 502:
! 503: // unary expressions
! 504:
! 505: template <class Op>
! 506: class __gmp_expr<__gmpfr_value, __gmp_unary_expr<mpfr_class, Op> >
! 507: {
! 508: private:
! 509: __gmp_unary_expr<mpfr_class, Op> expr;
! 510: public:
! 511: __gmp_expr(const mpfr_class &val) : expr(val) { }
! 512: void eval(mpfr_ptr f, unsigned long int) const
! 513: { Op::eval(f, expr.val.get_mpfr_t(), __gmp_default_rounding_mode); }
! 514: unsigned long int get_prec() const
! 515: { return mpfr_get_prec(expr.val.get_mpfr_t()); }
! 516: };
! 517:
! 518: template <class T, class U, class Op>
! 519: class __gmp_expr<__gmpfr_value, __gmp_unary_expr<__gmp_expr<T, U>, Op> >
! 520: {
! 521: private:
! 522: __gmp_unary_expr<__gmp_expr<T, U>, Op> expr;
! 523: public:
! 524: __gmp_expr(const __gmp_expr<T, U> &val) : expr(val) { }
! 525: void eval(mpfr_ptr f, unsigned long int prec) const
! 526: {
! 527: mpfr_class temp(expr.val, prec);
! 528: Op::eval(f, temp.get_mpfr_t(), __gmp_default_rounding_mode);
! 529: }
! 530: unsigned long int get_prec() const { return expr.val.get_prec(); }
! 531: };
! 532:
! 533:
! 534: // binary expressions
! 535:
! 536: template <class Op>
! 537: class __gmp_expr
! 538: <__gmpfr_value, __gmp_binary_expr<mpfr_class, mpfr_class, Op> >
! 539: {
! 540: private:
! 541: __gmp_binary_expr<mpfr_class, mpfr_class, Op> expr;
! 542: public:
! 543: __gmp_expr(const mpfr_class &val1, const mpfr_class &val2)
! 544: : expr(val1, val2) { }
! 545: void eval(mpfr_ptr f, unsigned long int) const
! 546: { Op::eval(f, expr.val1.get_mpfr_t(), expr.val2.get_mpfr_t(),
! 547: __gmp_default_rounding_mode); }
! 548: unsigned long int get_prec() const
! 549: {
! 550: unsigned long int prec1 = expr.val1.get_prec(),
! 551: prec2 = expr.val2.get_prec();
! 552: return (prec1 > prec2) ? prec1 : prec2;
! 553: }
! 554: };
! 555:
! 556: template <class T, class Op>
! 557: class __gmp_expr<__gmpfr_value, __gmp_binary_expr<mpfr_class, T, Op> >
! 558: {
! 559: private:
! 560: __gmp_binary_expr<mpfr_class, T, Op> expr;
! 561: public:
! 562: __gmp_expr(const mpfr_class &val1, T val2) : expr(val1, val2) { }
! 563: void eval(mpfr_ptr f, unsigned long int) const
! 564: { Op::eval(f, expr.val1.get_mpfr_t(), expr.val2,
! 565: __gmp_default_rounding_mode); }
! 566: unsigned long int get_prec() const
! 567: {
! 568: unsigned long int prec1 = expr.val1.get_prec(),
! 569: prec2 = mpf_get_default_prec();
! 570: return (prec1 > prec2) ? prec1 : prec2;
! 571: }
! 572: };
! 573:
! 574: template <class T, class Op>
! 575: class __gmp_expr<__gmpfr_value, __gmp_binary_expr<T, mpfr_class, Op> >
! 576: {
! 577: private:
! 578: __gmp_binary_expr<T, mpfr_class, Op> expr;
! 579: public:
! 580: __gmp_expr(T val1, const mpfr_class &val2) : expr(val1, val2) { }
! 581: void eval(mpfr_ptr f, unsigned long int) const
! 582: { Op::eval(f, expr.val1, expr.val2.get_mpfr_t(),
! 583: __gmp_default_rounding_mode); }
! 584: unsigned long int get_prec() const
! 585: {
! 586: unsigned long int prec1 = mpf_get_default_prec(),
! 587: prec2 = expr.val2.get_prec();
! 588: return (prec1 > prec2) ? prec1 : prec2;
! 589: }
! 590: };
! 591:
! 592: template <class T, class U, class Op>
! 593: class __gmp_expr
! 594: <__gmpfr_value, __gmp_binary_expr<mpfr_class, __gmp_expr<T, U>, Op> >
! 595: {
! 596: private:
! 597: __gmp_binary_expr<mpfr_class, __gmp_expr<T, U>, Op> expr;
! 598: public:
! 599: __gmp_expr(const mpfr_class &val1, const __gmp_expr<T, U> &val2)
! 600: : expr(val1, val2) { }
! 601: void eval(mpfr_ptr f, unsigned long int prec) const
! 602: {
! 603: mpfr_class temp(expr.val2, prec);
! 604: Op::eval(f, expr.val1.get_mpfr_t(), temp.get_mpfr_t(),
! 605: __gmp_default_rounding_mode);
! 606: }
! 607: unsigned long int get_prec() const
! 608: {
! 609: unsigned long int prec1 = expr.val1.get_prec(),
! 610: prec2 = expr.val2.get_prec();
! 611: return (prec1 > prec2) ? prec1 : prec2;
! 612: }
! 613: };
! 614:
! 615: template <class T, class U, class Op>
! 616: class __gmp_expr
! 617: <__gmpfr_value, __gmp_binary_expr<__gmp_expr<T, U>, mpfr_class, Op> >
! 618: {
! 619: private:
! 620: __gmp_binary_expr<__gmp_expr<T, U>, mpfr_class, Op> expr;
! 621: public:
! 622: __gmp_expr(const __gmp_expr<T, U> &val1, const mpfr_class &val2)
! 623: : expr(val1, val2) { }
! 624: void eval(mpfr_ptr f, unsigned long int prec) const
! 625: {
! 626: mpfr_class temp(expr.val1, prec);
! 627: Op::eval(f, temp.get_mpfr_t(), expr.val2.get_mpfr_t(),
! 628: __gmp_default_rounding_mode);
! 629: }
! 630: unsigned long int get_prec() const
! 631: {
! 632: unsigned long int prec1 = expr.val1.get_prec(),
! 633: prec2 = expr.val2.get_prec();
! 634: return (prec1 > prec2) ? prec1 : prec2;
! 635: }
! 636: };
! 637:
! 638: template <class T, class U, class V, class Op>
! 639: class __gmp_expr<__gmpfr_value, __gmp_binary_expr<__gmp_expr<T, U>, V, Op> >
! 640: {
! 641: private:
! 642: __gmp_binary_expr<__gmp_expr<T, U>, V, Op> expr;
! 643: public:
! 644: __gmp_expr(const __gmp_expr<T, U> &val1, V val2) : expr(val1, val2) { }
! 645: void eval(mpfr_ptr f, unsigned long int prec) const
! 646: {
! 647: mpfr_class temp(expr.val1, prec);
! 648: Op::eval(f, temp.get_mpfr_t(), expr.val2, __gmp_default_rounding_mode);
! 649: }
! 650: unsigned long int get_prec() const
! 651: {
! 652: unsigned long int prec1 = expr.val1.get_prec(),
! 653: prec2 = mpf_get_default_prec();
! 654: return (prec1 > prec2) ? prec1 : prec2;
! 655: }
! 656: };
! 657:
! 658: template <class T, class U, class V, class Op>
! 659: class __gmp_expr<__gmpfr_value, __gmp_binary_expr<T, __gmp_expr<U, V>, Op> >
! 660: {
! 661: private:
! 662: __gmp_binary_expr<T, __gmp_expr<U, V>, Op> expr;
! 663: public:
! 664: __gmp_expr(T val1, const __gmp_expr<U, V> &val2) : expr(val1, val2) { }
! 665: void eval(mpfr_ptr f, unsigned long int prec) const
! 666: {
! 667: mpfr_class temp(expr.val2, prec);
! 668: Op::eval(f, expr.val1, temp.get_mpfr_t(), __gmp_default_rounding_mode);
! 669: }
! 670: unsigned long int get_prec() const
! 671: {
! 672: unsigned long int prec1 = mpf_get_default_prec(),
! 673: prec2 = expr.val2.get_prec();
! 674: return (prec1 > prec2) ? prec1 : prec2;
! 675: }
! 676: };
! 677:
! 678: template <class T, class U, class V, class W, class Op>
! 679: class __gmp_expr
! 680: <__gmpfr_value, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
! 681: {
! 682: private:
! 683: __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> expr;
! 684: public:
! 685: __gmp_expr(const __gmp_expr<T, U> &val1, const __gmp_expr<V, W> &val2)
! 686: : expr(val1, val2) { }
! 687: void eval(mpfr_ptr f, unsigned long int prec) const
! 688: {
! 689: mpfr_class temp1(expr.val1, prec), temp2(expr.val2, prec);
! 690: Op::eval(f, temp1.get_mpfr_t(), temp2.get_mpfr_t(),
! 691: __gmp_default_rounding_mode);
! 692: }
! 693: unsigned long int get_prec() const
! 694: {
! 695: unsigned long int prec1 = expr.val1.get_prec(),
! 696: prec2 = expr.val2.get_prec();
! 697: return (prec1 > prec2) ? prec1 : prec2;
! 698: }
! 699: };
! 700:
! 701:
! 702: /**************** Macros for defining functions ****************/
! 703:
! 704: #define __GMPFRR_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 705: \
! 706: template <class T, class U> \
! 707: inline mpfr_class & mpfr_class::fun(const __gmp_expr<T, U> &expr) \
! 708: { \
! 709: __gmpfr_temp temp(expr, get_prec()); \
! 710: eval_fun::eval(mp, mp, temp.get_mp(), __gmp_default_rounding_mode); \
! 711: return *this; \
! 712: }
! 713:
! 714: #define __GMPFRN_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 715: \
! 716: inline mpfr_class & mpfr_class::fun(signed char c) \
! 717: { \
! 718: eval_fun::eval(mp, mp, (signed long int) c, \
! 719: __gmp_default_rounding_mode); \
! 720: return *this; \
! 721: } \
! 722: \
! 723: inline mpfr_class & mpfr_class::fun(unsigned char c) \
! 724: { \
! 725: eval_fun::eval(mp, mp, (unsigned long int) c, \
! 726: __gmp_default_rounding_mode); \
! 727: return *this; \
! 728: } \
! 729: \
! 730: inline mpfr_class & mpfr_class::fun(signed int i) \
! 731: { \
! 732: eval_fun::eval(mp, mp, (signed long int) i, \
! 733: __gmp_default_rounding_mode); \
! 734: return *this; \
! 735: } \
! 736: \
! 737: inline mpfr_class & mpfr_class::fun(unsigned int i) \
! 738: { \
! 739: eval_fun::eval(mp, mp, (unsigned long int) i, \
! 740: __gmp_default_rounding_mode); \
! 741: return *this; \
! 742: } \
! 743: \
! 744: inline mpfr_class & mpfr_class::fun(signed short int s) \
! 745: { \
! 746: eval_fun::eval(mp, mp, (signed long int) s, \
! 747: __gmp_default_rounding_mode); \
! 748: return *this; \
! 749: } \
! 750: \
! 751: inline mpfr_class & mpfr_class::fun(unsigned short int s) \
! 752: { \
! 753: eval_fun::eval(mp, mp, (unsigned long int) s, \
! 754: __gmp_default_rounding_mode); \
! 755: return *this; \
! 756: } \
! 757: \
! 758: inline mpfr_class & mpfr_class::fun(signed long int l) \
! 759: { \
! 760: eval_fun::eval(mp, mp, l, __gmp_default_rounding_mode); \
! 761: return *this; \
! 762: } \
! 763: \
! 764: inline mpfr_class & mpfr_class::fun(unsigned long int l) \
! 765: { \
! 766: eval_fun::eval(mp, mp, l, __gmp_default_rounding_mode); \
! 767: return *this; \
! 768: } \
! 769: \
! 770: inline mpfr_class & mpfr_class::fun(float f) \
! 771: { \
! 772: eval_fun::eval(mp, mp, (double) f, __gmp_default_rounding_mode); \
! 773: return *this; \
! 774: } \
! 775: \
! 776: inline mpfr_class & mpfr_class::fun(double d) \
! 777: { \
! 778: eval_fun::eval(mp, mp, d, __gmp_default_rounding_mode); \
! 779: return *this; \
! 780: } \
! 781: \
! 782: /* \
! 783: inline mpfr_class & mpfr_class::fun(long double ld) \
! 784: { \
! 785: eval_fun::eval(mp, mp, ld, __gmp_default_rounding_mode); \
! 786: return *this; \
! 787: } */
! 788:
! 789: #define __GMPFR_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 790: __GMPFRR_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
! 791: __GMPFRN_DEFINE_COMPOUND_OPERATOR(fun, eval_fun)
! 792:
! 793: #define __GMPFR_DEFINE_COMPOUND_OPERATOR_UI(fun, eval_fun) \
! 794: \
! 795: inline mpfr_class & mpfr_class::fun(unsigned long int l) \
! 796: { \
! 797: eval_fun::eval(mp, mp, l, __gmp_default_rounding_mode); \
! 798: return *this; \
! 799: }
! 800:
! 801: #define __GMPFR_DEFINE_INCREMENT_OPERATOR(fun, eval_fun) \
! 802: \
! 803: inline mpfr_class & mpfr_class::fun() \
! 804: { \
! 805: eval_fun::eval(mp, mp, __gmp_default_rounding_mode); \
! 806: return *this; \
! 807: } \
! 808: \
! 809: inline mpfr_class mpfr_class::fun(int) \
! 810: { \
! 811: mpfr_class temp(*this); \
! 812: eval_fun::eval(mp, mp, __gmp_default_rounding_mode); \
! 813: return temp; \
! 814: }
! 815:
! 816:
! 817: /**************** Arithmetic operators and functions ****************/
! 818:
! 819: __GMPFR_DEFINE_COMPOUND_OPERATOR(operator+=, __gmp_binary_plus)
! 820: __GMPFR_DEFINE_COMPOUND_OPERATOR(operator-=, __gmp_binary_minus)
! 821: __GMPFR_DEFINE_COMPOUND_OPERATOR(operator*=, __gmp_binary_multiplies)
! 822: __GMPFR_DEFINE_COMPOUND_OPERATOR(operator/=, __gmp_binary_divides)
! 823:
! 824: __GMPFR_DEFINE_COMPOUND_OPERATOR_UI(operator<<=, __gmp_binary_lshift)
! 825: __GMPFR_DEFINE_COMPOUND_OPERATOR_UI(operator>>=, __gmp_binary_rshift)
! 826:
! 827: __GMPFR_DEFINE_INCREMENT_OPERATOR(operator++, __gmp_unary_increment)
! 828: __GMPFR_DEFINE_INCREMENT_OPERATOR(operator--, __gmp_unary_decrement)
! 829:
! 830:
! 831: /**************** #undef all private macros ****************/
! 832:
! 833: #undef __GMPFRR_DECLARE_COMPOUND_OPERATOR
! 834: #undef __GMPFRN_DECLARE_COMPOUND_OPERATOR
! 835: #undef __GMPFR_DECLARE_COMPOUND_OPERATOR
! 836: #undef __GMPFR_DECLARE_COMPOUND_OPERATOR_UI
! 837: #undef __GMPFR_DECLARE_INCREMENT_OPERATOR
! 838:
! 839: #undef __GMPFRR_DEFINE_COMPOUND_OPERATOR
! 840: #undef __GMPFRN_DEFINE_COMPOUND_OPERATOR
! 841: #undef __GMPFR_DEFINE_COMPOUND_OPERATOR
! 842: #undef __GMPFR_DEFINE_COMPOUND_OPERATOR_UI
! 843: #undef __GMPFR_DEFINE_INCREMENT_OPERATOR
! 844:
! 845:
! 846: #endif /* __GMPFR_PLUSPLUS__ */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mpfrxx.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp