1 /* Utilities for MPFR developers, not exported. 2 3 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. 4 Contributed by the Arenaire and Caramel projects, INRIA. 5 6 This file is part of the GNU MPFR Library. 7 8 The GNU MPFR Library is free software; you can redistribute it and/or modify 9 it under the terms of the GNU Lesser General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or (at your 11 option) any later version. 12 13 The GNU MPFR Library is distributed in the hope that it will be useful, but 14 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 16 License for more details. 17 18 You should have received a copy of the GNU Lesser General Public License 19 along with the GNU MPFR Library; see the file COPYING.LESSER. If not, see 20 http://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc., 21 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. */ 22 23 #ifndef __MPFR_IMPL_H__ 24 #define __MPFR_IMPL_H__ 25 26 /* Let's include some standard headers unconditionally as they are 27 already needed by several source files or when some options are 28 enabled/disabled, and it is easy to forget them (some configure 29 options may hide the error). 30 Note: If some source file must not have such a header included 31 (which is very unlikely and probably means something broken in 32 this source file), we should do that with some macro (that would 33 also force to disable incompatible features). */ 34 #if defined (__cplusplus) 35 #include <cstdio> 36 #include <cstring> 37 #else 38 #include <stdio.h> 39 #include <string.h> 40 #endif 41 #include <limits.h> 42 43 #if _MPFR_EXP_FORMAT == 4 44 /* mpfr_exp_t will be defined as intmax_t */ 45 # include "mpfr-intmax.h" 46 #endif 47 48 /* Check if we are inside a build of MPFR or inside the test suite. 49 This is needed in mpfr.h to export or import the functions. 50 It matters only for Windows DLL */ 51 #ifndef __MPFR_TEST_H__ 52 # define __MPFR_WITHIN_MPFR 1 53 #endif 54 55 /****************************************************** 56 ****************** Include files ********************* 57 ******************************************************/ 58 59 /* Include 'config.h' before using ANY configure macros if needed 60 NOTE: It isn't MPFR 'config.h', but GMP's one! */ 61 #ifdef HAVE_CONFIG_H 62 # include "config.h" 63 #endif 64 65 #ifdef MPFR_HAVE_GMP_IMPL /* Build with gmp internals*/ 66 67 # ifndef __GMP_H__ 68 # include "gmp.h" 69 # endif 70 # ifndef __GMP_IMPL_H__ 71 # include "gmp-impl.h" 72 # endif 73 # ifdef MPFR_NEED_LONGLONG_H 74 # include "longlong.h" 75 # endif 76 # ifndef __MPFR_H 77 # include "mpfr.h" 78 # endif 79 80 #else /* Build without gmp internals */ 81 82 # ifndef __GMP_H__ 83 # include "gmp.h" 84 # endif 85 # ifndef __MPFR_H 86 # include "mpfr.h" 87 # endif 88 # ifndef __GMPFR_GMP_H__ 89 # include "mpfr-gmp.h" 90 # endif 91 # ifdef MPFR_NEED_LONGLONG_H 92 # define LONGLONG_STANDALONE 93 # include "mpfr-longlong.h" 94 # endif 95 96 #endif 97 #undef MPFR_NEED_LONGLONG_H 98 99 /* If a mpn_sqr_n macro is not defined, use mpn_mul. GMP 4.x defines a 100 mpn_sqr_n macro in gmp-impl.h (and this macro disappeared in GMP 5), 101 so that GMP's macro can only be used when MPFR has been configured 102 with --with-gmp-build (and only with GMP 4.x). */ 103 #ifndef mpn_sqr_n 104 # define mpn_sqr_n(dst,src,n) mpn_mul((dst),(src),(n),(src),(n)) 105 #endif 106 107 /* For the definition of MPFR_THREAD_ATTR. GCC/ICC detection macros are 108 no longer used, as they sometimes gave incorrect information about 109 the support of thread-local variables. A configure check is now done. 110 If the use of detection macros is needed in the future, this could be 111 moved below (after the detection macros are defined). */ 112 #include "mpfr-thread.h" 113 114 115 /****************************************************** 116 ***************** Detection macros ******************* 117 ******************************************************/ 118 119 /* Macros to detect STDC, GCC, GLIBC, GMP and ICC version */ 120 #if defined(__STDC_VERSION__) 121 # define __MPFR_STDC(version) (__STDC_VERSION__>=(version)) 122 #elif defined(__STDC__) 123 # define __MPFR_STDC(version) (0 == (version)) 124 #else 125 # define __MPFR_STDC(version) 0 126 #endif 127 128 #if defined(_WIN32) 129 /* Under MS Windows (e.g. with VS2008 or VS2010), Intel's compiler doesn't 130 support/enable extensions like the ones seen under GNU/Linux. 131 http://websympa.loria.fr/wwsympa/arc/mpfr/2011-02/msg00032.html */ 132 # define __MPFR_ICC(a,b,c) 0 133 #elif defined(__ICC) 134 # define __MPFR_ICC(a,b,c) (__ICC >= (a)*100+(b)*10+(c)) 135 #elif defined(__INTEL_COMPILER) 136 # define __MPFR_ICC(a,b,c) (__INTEL_COMPILER >= (a)*100+(b)*10+(c)) 137 #else 138 # define __MPFR_ICC(a,b,c) 0 139 #endif 140 141 #if defined(__GNUC__) && defined(__GNUC_MINOR__) && ! __MPFR_ICC(0,0,0) 142 # define __MPFR_GNUC(a,i) \ 143 (MPFR_VERSION_NUM(__GNUC__,__GNUC_MINOR__,0) >= MPFR_VERSION_NUM(a,i,0)) 144 #else 145 # define __MPFR_GNUC(a,i) 0 146 #endif 147 148 #if defined(__GLIBC__) && defined(__GLIBC_MINOR__) 149 # define __MPFR_GLIBC(a,i) \ 150 (MPFR_VERSION_NUM(__GLIBC__,__GLIBC_MINOR__,0) >= MPFR_VERSION_NUM(a,i,0)) 151 #else 152 # define __MPFR_GLIBC(a,i) 0 153 #endif 154 155 #if defined(__GNU_MP_VERSION) && \ 156 defined(__GNU_MP_VERSION_MINOR) && \ 157 defined(__GNU_MP_VERSION_PATCHLEVEL) 158 # define __MPFR_GMP(a,b,c) \ 159 (MPFR_VERSION_NUM(__GNU_MP_VERSION,__GNU_MP_VERSION_MINOR,__GNU_MP_VERSION_PATCHLEVEL) >= MPFR_VERSION_NUM(a,b,c)) 160 #else 161 # define __MPFR_GMP(a,b,c) 0 162 #endif 163 164 165 166 /****************************************************** 167 ************* GMP Basic Pointer Types **************** 168 ******************************************************/ 169 170 typedef mp_limb_t *mpfr_limb_ptr; 171 typedef __gmp_const mp_limb_t *mpfr_limb_srcptr; 172 173 174 175 /****************************************************** 176 ****************** (U)INTMAX_MAX ********************* 177 ******************************************************/ 178 179 /* Let's try to fix UINTMAX_MAX and INTMAX_MAX if these macros don't work 180 (e.g. with gcc -ansi -pedantic-errors in 32-bit mode under GNU/Linux), 181 see <http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=582698>. */ 182 #ifdef _MPFR_H_HAVE_INTMAX_T 183 # ifdef MPFR_HAVE_INTMAX_MAX 184 # define MPFR_UINTMAX_MAX UINTMAX_MAX 185 # define MPFR_INTMAX_MAX INTMAX_MAX 186 # define MPFR_INTMAX_MIN INTMAX_MIN 187 # else 188 # define MPFR_UINTMAX_MAX ((uintmax_t) -1) 189 # define MPFR_INTMAX_MAX ((intmax_t) (MPFR_UINTMAX_MAX >> 1)) 190 # define MPFR_INTMAX_MIN (INT_MIN + INT_MAX - MPFR_INTMAX_MAX) 191 # endif 192 #endif 193 194 195 196 /****************************************************** 197 ******************** Check GMP *********************** 198 ******************************************************/ 199 200 #if !__MPFR_GMP(4,1,0) 201 # error "GMP 4.1.0 or newer needed" 202 #endif 203 204 #if GMP_NAIL_BITS != 0 205 # error "MPFR doesn't support nonzero values of GMP_NAIL_BITS" 206 #endif 207 208 #if (GMP_NUMB_BITS<32) || (GMP_NUMB_BITS & (GMP_NUMB_BITS - 1)) 209 # error "GMP_NUMB_BITS must be a power of 2, and >= 32" 210 #endif 211 212 #if GMP_NUMB_BITS == 16 213 # define MPFR_LOG2_GMP_NUMB_BITS 4 214 #elif GMP_NUMB_BITS == 32 215 # define MPFR_LOG2_GMP_NUMB_BITS 5 216 #elif GMP_NUMB_BITS == 64 217 # define MPFR_LOG2_GMP_NUMB_BITS 6 218 #elif GMP_NUMB_BITS == 128 219 # define MPFR_LOG2_GMP_NUMB_BITS 7 220 #elif GMP_NUMB_BITS == 256 221 # define MPFR_LOG2_GMP_NUMB_BITS 8 222 #else 223 # error "Can't compute log2(GMP_NUMB_BITS)" 224 #endif 225 226 #if __MPFR_GNUC(3,0) || __MPFR_ICC(8,1,0) 227 /* For the future: N1478: Supporting the 'noreturn' property in C1x 228 http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1478.htm */ 229 # define MPFR_NORETURN_ATTR __attribute__ ((noreturn)) 230 # define MPFR_CONST_ATTR __attribute__ ((const)) 231 #else 232 # define MPFR_NORETURN_ATTR 233 # define MPFR_CONST_ATTR 234 #endif 235 236 /****************************************************** 237 ************* Global Internal Variables ************** 238 ******************************************************/ 239 240 /* Cache struct */ 241 struct __gmpfr_cache_s { 242 mpfr_t x; 243 int inexact; 244 int (*func)(mpfr_ptr, mpfr_rnd_t); 245 }; 246 typedef struct __gmpfr_cache_s mpfr_cache_t[1]; 247 typedef struct __gmpfr_cache_s *mpfr_cache_ptr; 248 249 #if defined (__cplusplus) 250 extern "C" { 251 #endif 252 253 __MPFR_DECLSPEC extern MPFR_THREAD_ATTR unsigned int __gmpfr_flags; 254 __MPFR_DECLSPEC extern MPFR_THREAD_ATTR mpfr_exp_t __gmpfr_emin; 255 __MPFR_DECLSPEC extern MPFR_THREAD_ATTR mpfr_exp_t __gmpfr_emax; 256 __MPFR_DECLSPEC extern MPFR_THREAD_ATTR mpfr_prec_t __gmpfr_default_fp_bit_precision; 257 __MPFR_DECLSPEC extern MPFR_THREAD_ATTR mpfr_rnd_t __gmpfr_default_rounding_mode; 258 __MPFR_DECLSPEC extern MPFR_THREAD_ATTR mpfr_cache_t __gmpfr_cache_const_euler; 259 __MPFR_DECLSPEC extern MPFR_THREAD_ATTR mpfr_cache_t __gmpfr_cache_const_catalan; 260 261 #ifndef MPFR_USE_LOGGING 262 __MPFR_DECLSPEC extern MPFR_THREAD_ATTR mpfr_cache_t __gmpfr_cache_const_pi; 263 __MPFR_DECLSPEC extern MPFR_THREAD_ATTR mpfr_cache_t __gmpfr_cache_const_log2; 264 #else 265 /* Two constants are used by the logging functions (via mpfr_fprintf, 266 then mpfr_log, for the base conversion): pi and log(2). Since the 267 mpfr_cache function isn't re-entrant when working on the same cache, 268 we need to define two caches for each constant. */ 269 __MPFR_DECLSPEC extern MPFR_THREAD_ATTR mpfr_cache_t __gmpfr_normal_pi; 270 __MPFR_DECLSPEC extern MPFR_THREAD_ATTR mpfr_cache_t __gmpfr_normal_log2; 271 __MPFR_DECLSPEC extern MPFR_THREAD_ATTR mpfr_cache_t __gmpfr_logging_pi; 272 __MPFR_DECLSPEC extern MPFR_THREAD_ATTR mpfr_cache_t __gmpfr_logging_log2; 273 __MPFR_DECLSPEC extern MPFR_THREAD_ATTR mpfr_cache_ptr __gmpfr_cache_const_pi; 274 __MPFR_DECLSPEC extern MPFR_THREAD_ATTR mpfr_cache_ptr __gmpfr_cache_const_log2; 275 #endif 276 277 #define BASE_MAX 62 278 __MPFR_DECLSPEC extern const __mpfr_struct __gmpfr_l2b[BASE_MAX-1][2]; 279 280 /* Note: do not use the following values when they can be outside the 281 current exponent range, e.g. when the exponent range has not been 282 extended yet; under such a condition, they can be used only in 283 mpfr_cmpabs. */ 284 __MPFR_DECLSPEC extern const mpfr_t __gmpfr_one; 285 __MPFR_DECLSPEC extern const mpfr_t __gmpfr_two; 286 __MPFR_DECLSPEC extern const mpfr_t __gmpfr_four; 287 288 289 #if defined (__cplusplus) 290 } 291 #endif 292 293 /* Flags of __gmpfr_flags */ 294 #define MPFR_FLAGS_UNDERFLOW 1 295 #define MPFR_FLAGS_OVERFLOW 2 296 #define MPFR_FLAGS_NAN 4 297 #define MPFR_FLAGS_INEXACT 8 298 #define MPFR_FLAGS_ERANGE 16 299 #define MPFR_FLAGS_DIVBY0 32 300 #define MPFR_FLAGS_ALL 63 301 302 /* Replace some common functions for direct access to the global vars */ 303 #define mpfr_get_emin() (__gmpfr_emin + 0) 304 #define mpfr_get_emax() (__gmpfr_emax + 0) 305 #define mpfr_get_default_rounding_mode() (__gmpfr_default_rounding_mode + 0) 306 #define mpfr_get_default_prec() (__gmpfr_default_fp_bit_precision + 0) 307 308 #define mpfr_clear_flags() \ 309 ((void) (__gmpfr_flags = 0)) 310 #define mpfr_clear_underflow() \ 311 ((void) (__gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_UNDERFLOW)) 312 #define mpfr_clear_overflow() \ 313 ((void) (__gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_OVERFLOW)) 314 #define mpfr_clear_nanflag() \ 315 ((void) (__gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_NAN)) 316 #define mpfr_clear_inexflag() \ 317 ((void) (__gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_INEXACT)) 318 #define mpfr_clear_erangeflag() \ 319 ((void) (__gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_ERANGE)) 320 #define mpfr_clear_divby0() \ 321 ((void) (__gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_DIVBY0)) 322 #define mpfr_underflow_p() \ 323 ((int) (__gmpfr_flags & MPFR_FLAGS_UNDERFLOW)) 324 #define mpfr_overflow_p() \ 325 ((int) (__gmpfr_flags & MPFR_FLAGS_OVERFLOW)) 326 #define mpfr_nanflag_p() \ 327 ((int) (__gmpfr_flags & MPFR_FLAGS_NAN)) 328 #define mpfr_inexflag_p() \ 329 ((int) (__gmpfr_flags & MPFR_FLAGS_INEXACT)) 330 #define mpfr_erangeflag_p() \ 331 ((int) (__gmpfr_flags & MPFR_FLAGS_ERANGE)) 332 #define mpfr_divby0_p() \ 333 ((int) (__gmpfr_flags & MPFR_FLAGS_DIVBY0)) 334 335 /* Testing an exception flag correctly is tricky. There are mainly two 336 pitfalls: First, one needs to remember to clear the corresponding 337 flag, in case it was set before the function call or during some 338 intermediate computations (in practice, one can clear all the flags). 339 Secondly, one needs to test the flag early enough, i.e. before it 340 can be modified by another function. Moreover, it is quite difficult 341 (if not impossible) to reliably check problems with "make check". To 342 avoid these pitfalls, it is recommended to use the following macros. 343 Other use of the exception-flag predicate functions/macros will be 344 detected by mpfrlint. 345 Note: _op can be either a statement or an expression. 346 MPFR_BLOCK_EXCEP should be used only inside a block; it is useful to 347 detect some exception in order to exit the block as soon as possible. */ 348 #define MPFR_BLOCK_DECL(_flags) unsigned int _flags 349 /* The (void) (_flags) makes sure that _flags is read at least once (it 350 makes sense to use MPFR_BLOCK while _flags will never be read in the 351 source, so that we wish to avoid the corresponding warning). */ 352 #define MPFR_BLOCK(_flags,_op) \ 353 do \ 354 { \ 355 mpfr_clear_flags (); \ 356 _op; \ 357 (_flags) = __gmpfr_flags; \ 358 (void) (_flags); \ 359 } \ 360 while (0) 361 #define MPFR_BLOCK_TEST(_flags,_f) MPFR_UNLIKELY ((_flags) & (_f)) 362 #define MPFR_BLOCK_EXCEP (__gmpfr_flags & (MPFR_FLAGS_UNDERFLOW | \ 363 MPFR_FLAGS_OVERFLOW | \ 364 MPFR_FLAGS_DIVBY0 | \ 365 MPFR_FLAGS_NAN)) 366 /* Let's use a MPFR_ prefix, because e.g. OVERFLOW is defined by glibc's 367 math.h, though this is not a reserved identifier! */ 368 #define MPFR_UNDERFLOW(_flags) MPFR_BLOCK_TEST (_flags, MPFR_FLAGS_UNDERFLOW) 369 #define MPFR_OVERFLOW(_flags) MPFR_BLOCK_TEST (_flags, MPFR_FLAGS_OVERFLOW) 370 #define MPFR_NANFLAG(_flags) MPFR_BLOCK_TEST (_flags, MPFR_FLAGS_NAN) 371 #define MPFR_INEXFLAG(_flags) MPFR_BLOCK_TEST (_flags, MPFR_FLAGS_INEXACT) 372 #define MPFR_ERANGEFLAG(_flags) MPFR_BLOCK_TEST (_flags, MPFR_FLAGS_ERANGE) 373 #define MPFR_DIVBY0(_flags) MPFR_BLOCK_TEST (_flags, MPFR_FLAGS_DIVBY0) 374 375 376 /****************************************************** 377 ******************** Assertions ********************** 378 ******************************************************/ 379 380 /* Compile with -DWANT_ASSERT to check all assert statements */ 381 382 /* Note: do not use GMP macros ASSERT_ALWAYS and ASSERT as they are not 383 expressions, and as a consequence, they cannot be used in a for(), 384 with a comma operator and so on. */ 385 386 /* MPFR_ASSERTN(expr): assertions that should always be checked */ 387 #define MPFR_ASSERTN(expr) \ 388 ((void) ((MPFR_UNLIKELY(expr)) || MPFR_UNLIKELY( (ASSERT_FAIL(expr),0) ))) 389 390 /* MPFR_ASSERTD(expr): assertions that should be checked when testing */ 391 #ifdef WANT_ASSERT 392 # define MPFR_EXP_CHECK 1 393 # define MPFR_ASSERTD(expr) MPFR_ASSERTN (expr) 394 #else 395 # define MPFR_ASSERTD(expr) ((void) 0) 396 #endif 397 398 /* Code to deal with impossible 399 WARNING: It doesn't use do { } while (0) for Insure++*/ 400 #define MPFR_RET_NEVER_GO_HERE() {MPFR_ASSERTN(0); return 0;} 401 402 403 /****************************************************** 404 ******************** Warnings ************************ 405 ******************************************************/ 406 407 /* MPFR_WARNING is no longer useful, but let's keep the macro in case 408 it needs to be used again in the future. */ 409 410 #ifdef MPFR_USE_WARNINGS 411 # include <stdlib.h> 412 # define MPFR_WARNING(W) \ 413 do \ 414 { \ 415 char *q = getenv ("MPFR_QUIET"); \ 416 if (q == NULL || *q == 0) \ 417 fprintf (stderr, "MPFR: %s\n", W); \ 418 } \ 419 while (0) 420 #else 421 # define MPFR_WARNING(W) ((void) 0) 422 #endif 423 424 425 /****************************************************** 426 ****************** double macros ********************* 427 ******************************************************/ 428 429 /* Precision used for lower precision computations */ 430 #define MPFR_SMALL_PRECISION 32 431 432 /* Definition of constants */ 433 #define LOG2 0.69314718055994528622 /* log(2) rounded to zero on 53 bits */ 434 #define ALPHA 4.3191365662914471407 /* a+2 = a*log(a), rounded to +infinity */ 435 #define EXPM1 0.36787944117144227851 /* exp(-1), rounded to zero */ 436 437 /* MPFR_DOUBLE_SPEC = 1 if the C type 'double' corresponds to IEEE-754 438 double precision, 0 if it doesn't, and undefined if one doesn't know. 439 On all the tested machines, MPFR_DOUBLE_SPEC = 1. To have this macro 440 defined here, #include <float.h> is needed. If need be, other values 441 could be defined for other specs (once they are known). */ 442 #if !defined(MPFR_DOUBLE_SPEC) && defined(FLT_RADIX) && \ 443 defined(DBL_MANT_DIG) && defined(DBL_MIN_EXP) && defined(DBL_MAX_EXP) 444 # if FLT_RADIX == 2 && DBL_MANT_DIG == 53 && \ 445 DBL_MIN_EXP == -1021 && DBL_MAX_EXP == 1024 446 # define MPFR_DOUBLE_SPEC 1 447 # else 448 # define MPFR_DOUBLE_SPEC 0 449 # endif 450 #endif 451 452 /* Debug non IEEE floats */ 453 #ifdef XDEBUG 454 # undef _GMP_IEEE_FLOATS 455 #endif 456 #ifndef _GMP_IEEE_FLOATS 457 # define _GMP_IEEE_FLOATS 0 458 #endif 459 460 #ifndef IEEE_DBL_MANT_DIG 461 #define IEEE_DBL_MANT_DIG 53 462 #endif 463 #define MPFR_LIMBS_PER_DOUBLE ((IEEE_DBL_MANT_DIG-1)/GMP_NUMB_BITS+1) 464 465 #ifndef IEEE_FLT_MANT_DIG 466 #define IEEE_FLT_MANT_DIG 24 467 #endif 468 #define MPFR_LIMBS_PER_FLT ((IEEE_FLT_MANT_DIG-1)/GMP_NUMB_BITS+1) 469 470 /* Visual C++ doesn't support +1.0/0.0, -1.0/0.0 and 0.0/0.0 471 at compile time. */ 472 #if defined(_MSC_VER) && defined(_WIN32) && (_MSC_VER >= 1200) 473 static double double_zero = 0.0; 474 # define DBL_NAN (double_zero/double_zero) 475 # define DBL_POS_INF ((double) 1.0/double_zero) 476 # define DBL_NEG_INF ((double)-1.0/double_zero) 477 # define DBL_NEG_ZERO (-double_zero) 478 #else 479 # define DBL_POS_INF ((double) 1.0/0.0) 480 # define DBL_NEG_INF ((double)-1.0/0.0) 481 # define DBL_NAN ((double) 0.0/0.0) 482 # define DBL_NEG_ZERO (-0.0) 483 #endif 484 485 /* Note: In the past, there was specific code for _GMP_IEEE_FLOATS, which 486 was based on NaN and Inf memory representations. This code was breaking 487 the aliasing rules (see ISO C99, 6.5#6 and 6.5#7 on the effective type) 488 and for this reason it did not behave correctly with GCC 4.5.0 20091119. 489 The code needed a memory transfer and was probably not better than the 490 macros below with a good compiler (a fix based on the NaN / Inf memory 491 representation would be even worse due to C limitations), and this code 492 could be selected only when MPFR was built with --with-gmp-build, thus 493 introducing a difference (bad for maintaining/testing MPFR); therefore 494 it has been removed. The old code required that the argument x be an 495 lvalue of type double. We still require that, in case one would need 496 to change the macros below, e.g. for some broken compiler. But the 497 LVALUE(x) condition could be removed if really necessary. */ 498 /* Below, the &(x) == &(x) || &(x) != &(x) allows to make sure that x 499 is a lvalue without (probably) any warning from the compiler. The 500 &(x) != &(x) is needed to avoid a failure under Mac OS X 10.4.11 501 (with Xcode 2.4.1, i.e. the latest one). */ 502 #define LVALUE(x) (&(x) == &(x) || &(x) != &(x)) 503 #define DOUBLE_ISINF(x) (LVALUE(x) && ((x) > DBL_MAX || (x) < -DBL_MAX)) 504 #ifdef MPFR_NANISNAN 505 /* Avoid MIPSpro / IRIX64 / gcc -ffast-math (incorrect) optimizations. 506 The + must not be replaced by a ||. With gcc -ffast-math, NaN is 507 regarded as a positive number or something like that; the second 508 test catches this case. */ 509 # define DOUBLE_ISNAN(x) \ 510 (LVALUE(x) && !((((x) >= 0.0) + ((x) <= 0.0)) && -(x)*(x) <= 0.0)) 511 #else 512 # define DOUBLE_ISNAN(x) (LVALUE(x) && (x) != (x)) 513 #endif 514 515 /****************************************************** 516 *************** Long double macros ******************* 517 ******************************************************/ 518 519 /* We try to get the exact value of the precision of long double 520 (provided by the implementation) in order to provide correct 521 rounding in this case (not guaranteed if the C implementation 522 does not have an adequate long double arithmetic). Note that 523 it may be lower than the precision of some numbers that can 524 be represented in a long double; e.g. on FreeBSD/x86, it is 525 53 because the processor is configured to round in double 526 precision (even when using the long double type -- this is a 527 limitation of the x87 arithmetic), and on Mac OS X, it is 106 528 because the implementation is a double-double arithmetic. 529 Otherwise (e.g. in base 10), we get an upper bound of the 530 precision, and correct rounding isn't currently provided. 531 */ 532 #if defined(LDBL_MANT_DIG) && FLT_RADIX == 2 533 # define MPFR_LDBL_MANT_DIG LDBL_MANT_DIG 534 #else 535 # define MPFR_LDBL_MANT_DIG \ 536 (sizeof(long double)*GMP_NUMB_BITS/sizeof(mp_limb_t)) 537 #endif 538 #define MPFR_LIMBS_PER_LONG_DOUBLE \ 539 ((sizeof(long double)-1)/sizeof(mp_limb_t)+1) 540 541 /* LONGDOUBLE_NAN_ACTION executes the code "action" if x is a NaN. */ 542 543 /* On hppa2.0n-hp-hpux10 with the unbundled HP cc, the test x!=x on a NaN 544 has been seen false, meaning NaNs are not detected. This seemed to 545 happen only after other comparisons, not sure what's really going on. In 546 any case we can pick apart the bytes to identify a NaN. */ 547 #ifdef HAVE_LDOUBLE_IEEE_QUAD_BIG 548 # define LONGDOUBLE_NAN_ACTION(x, action) \ 549 do { \ 550 union { \ 551 long double ld; \ 552 struct { \ 553 unsigned int sign : 1; \ 554 unsigned int exp : 15; \ 555 unsigned int man3 : 16; \ 556 unsigned int man2 : 32; \ 557 unsigned int man1 : 32; \ 558 unsigned int man0 : 32; \ 559 } s; \ 560 } u; \ 561 u.ld = (x); \ 562 if (u.s.exp == 0x7FFFL \ 563 && (u.s.man0 | u.s.man1 | u.s.man2 | u.s.man3) != 0) \ 564 { action; } \ 565 } while (0) 566 #endif 567 568 #ifdef HAVE_LDOUBLE_IEEE_QUAD_LITTLE 569 # define LONGDOUBLE_NAN_ACTION(x, action) \ 570 do { \ 571 union { \ 572 long double ld; \ 573 struct { \ 574 unsigned int man0 : 32; \ 575 unsigned int man1 : 32; \ 576 unsigned int man2 : 32; \ 577 unsigned int man3 : 16; \ 578 unsigned int exp : 15; \ 579 unsigned int sign : 1; \ 580 } s; \ 581 } u; \ 582 u.ld = (x); \ 583 if (u.s.exp == 0x7FFFL \ 584 && (u.s.man0 | u.s.man1 | u.s.man2 | u.s.man3) != 0) \ 585 { action; } \ 586 } while (0) 587 #endif 588 589 /* Under IEEE rules, NaN is not equal to anything, including itself. 590 "volatile" here stops "cc" on mips64-sgi-irix6.5 from optimizing away 591 x!=x. */ 592 #ifndef LONGDOUBLE_NAN_ACTION 593 # define LONGDOUBLE_NAN_ACTION(x, action) \ 594 do { \ 595 volatile long double __x = LONGDOUBLE_VOLATILE (x); \ 596 if ((x) != __x) \ 597 { action; } \ 598 } while (0) 599 # define WANT_LONGDOUBLE_VOLATILE 1 600 #endif 601 602 /* If we don't have a proper "volatile" then volatile is #defined to empty, 603 in this case call through an external function to stop the compiler 604 optimizing anything. */ 605 #ifdef WANT_LONGDOUBLE_VOLATILE 606 # ifdef volatile 607 __MPFR_DECLSPEC long double __gmpfr_longdouble_volatile _MPFR_PROTO ((long double)) MPFR_CONST_ATTR; 608 # define LONGDOUBLE_VOLATILE(x) (__gmpfr_longdouble_volatile (x)) 609 # define WANT_GMPFR_LONGDOUBLE_VOLATILE 1 610 # else 611 # define LONGDOUBLE_VOLATILE(x) (x) 612 # endif 613 #endif 614 615 /* Some special case for IEEE_EXT Litle Endian */ 616 #if HAVE_LDOUBLE_IEEE_EXT_LITTLE 617 618 typedef union { 619 long double ld; 620 struct { 621 unsigned int manl : 32; 622 unsigned int manh : 32; 623 unsigned int expl : 8 ; 624 unsigned int exph : 7; 625 unsigned int sign : 1; 626 } s; 627 } mpfr_long_double_t; 628 629 /* #undef MPFR_LDBL_MANT_DIG */ 630 #undef MPFR_LIMBS_PER_LONG_DOUBLE 631 /* #define MPFR_LDBL_MANT_DIG 64 */ 632 #define MPFR_LIMBS_PER_LONG_DOUBLE ((64-1)/GMP_NUMB_BITS+1) 633 634 #endif 635 636 /****************************************************** 637 *************** _Decimal64 support ******************* 638 ******************************************************/ 639 640 #ifdef MPFR_WANT_DECIMAL_FLOATS 641 /* to cast between binary64 and decimal64 */ 642 union ieee_double_decimal64 { double d; _Decimal64 d64; }; 643 #endif 644 645 /****************************************************** 646 **************** mpfr_t properties ******************* 647 ******************************************************/ 648 649 #define MPFR_PREC(x) ((x)->_mpfr_prec) 650 #define MPFR_EXP(x) ((x)->_mpfr_exp) 651 #define MPFR_MANT(x) ((x)->_mpfr_d) 652 #define MPFR_LIMB_SIZE(x) ((MPFR_PREC((x))-1)/GMP_NUMB_BITS+1) 653 654 655 /****************************************************** 656 **************** exponent properties ***************** 657 ******************************************************/ 658 659 /* Limits of the mpfr_exp_t type (NOT those of valid exponent values). 660 These macros can be used in preprocessor directives. */ 661 #if _MPFR_EXP_FORMAT == 1 662 # define MPFR_EXP_MAX (SHRT_MAX) 663 # define MPFR_EXP_MIN (SHRT_MIN) 664 #elif _MPFR_EXP_FORMAT == 2 665 # define MPFR_EXP_MAX (INT_MAX) 666 # define MPFR_EXP_MIN (INT_MIN) 667 #elif _MPFR_EXP_FORMAT == 3 668 # define MPFR_EXP_MAX (LONG_MAX) 669 # define MPFR_EXP_MIN (LONG_MIN) 670 #elif _MPFR_EXP_FORMAT == 4 671 # define MPFR_EXP_MAX (MPFR_INTMAX_MAX) 672 # define MPFR_EXP_MIN (MPFR_INTMAX_MIN) 673 #else 674 # error "Invalid MPFR Exp format" 675 #endif 676 677 /* Before doing a cast to mpfr_uexp_t, make sure that the value is 678 nonnegative. */ 679 #define MPFR_UEXP(X) (MPFR_ASSERTD ((X) >= 0), (mpfr_uexp_t) (X)) 680 681 #if MPFR_EXP_MIN >= LONG_MIN && MPFR_EXP_MAX <= LONG_MAX 682 typedef long int mpfr_eexp_t; 683 # define mpfr_get_exp_t(x,r) mpfr_get_si((x),(r)) 684 # define mpfr_set_exp_t(x,e,r) mpfr_set_si((x),(e),(r)) 685 # define MPFR_EXP_FSPEC "l" 686 #elif defined (_MPFR_H_HAVE_INTMAX_T) 687 typedef intmax_t mpfr_eexp_t; 688 # define mpfr_get_exp_t(x,r) mpfr_get_sj((x),(r)) 689 # define mpfr_set_exp_t(x,e,r) mpfr_set_sj((x),(e),(r)) 690 # define MPFR_EXP_FSPEC "j" 691 #else 692 # error "Cannot define mpfr_get_exp_t and mpfr_set_exp_t" 693 #endif 694 695 /* Invalid exponent value (to track bugs...) */ 696 #define MPFR_EXP_INVALID \ 697 ((mpfr_exp_t) 1 << (GMP_NUMB_BITS*sizeof(mpfr_exp_t)/sizeof(mp_limb_t)-2)) 698 699 /* Definition of the exponent limits for MPFR numbers. 700 * These limits are chosen so that if e is such an exponent, then 2e-1 and 701 * 2e+1 are representable. This is useful for intermediate computations, 702 * in particular the multiplication. 703 */ 704 #undef MPFR_EMIN_MIN 705 #undef MPFR_EMIN_MAX 706 #undef MPFR_EMAX_MIN 707 #undef MPFR_EMAX_MAX 708 #define MPFR_EMIN_MIN (1-MPFR_EXP_INVALID) 709 #define MPFR_EMIN_MAX (MPFR_EXP_INVALID-1) 710 #define MPFR_EMAX_MIN (1-MPFR_EXP_INVALID) 711 #define MPFR_EMAX_MAX (MPFR_EXP_INVALID-1) 712 713 /* Use MPFR_GET_EXP and MPFR_SET_EXP instead of MPFR_EXP directly, 714 unless when the exponent may be out-of-range, for instance when 715 setting the exponent before calling mpfr_check_range. 716 MPFR_EXP_CHECK is defined when WANT_ASSERT is defined, but if you 717 don't use WANT_ASSERT (for speed reasons), you can still define 718 MPFR_EXP_CHECK by setting -DMPFR_EXP_CHECK in $CFLAGS. */ 719 720 #ifdef MPFR_EXP_CHECK 721 # define MPFR_GET_EXP(x) (mpfr_get_exp) (x) 722 # define MPFR_SET_EXP(x, exp) MPFR_ASSERTN (!mpfr_set_exp ((x), (exp))) 723 # define MPFR_SET_INVALID_EXP(x) ((void) (MPFR_EXP (x) = MPFR_EXP_INVALID)) 724 #else 725 # define MPFR_GET_EXP(x) MPFR_EXP (x) 726 # define MPFR_SET_EXP(x, exp) ((void) (MPFR_EXP (x) = (exp))) 727 # define MPFR_SET_INVALID_EXP(x) ((void) 0) 728 #endif 729 730 731 732 /****************************************************** 733 ********** Singular Values (NAN, INF, ZERO) ********** 734 ******************************************************/ 735 736 /* Enum special value of exponent. */ 737 # define MPFR_EXP_ZERO (MPFR_EXP_MIN+1) 738 # define MPFR_EXP_NAN (MPFR_EXP_MIN+2) 739 # define MPFR_EXP_INF (MPFR_EXP_MIN+3) 740 741 #define MPFR_IS_NAN(x) (MPFR_EXP(x) == MPFR_EXP_NAN) 742 #define MPFR_SET_NAN(x) (MPFR_EXP(x) = MPFR_EXP_NAN) 743 #define MPFR_IS_INF(x) (MPFR_EXP(x) == MPFR_EXP_INF) 744 #define MPFR_SET_INF(x) (MPFR_EXP(x) = MPFR_EXP_INF) 745 #define MPFR_IS_ZERO(x) (MPFR_EXP(x) == MPFR_EXP_ZERO) 746 #define MPFR_SET_ZERO(x) (MPFR_EXP(x) = MPFR_EXP_ZERO) 747 #define MPFR_NOTZERO(x) (MPFR_EXP(x) != MPFR_EXP_ZERO) 748 749 #define MPFR_IS_FP(x) (!MPFR_IS_NAN(x) && !MPFR_IS_INF(x)) 750 #define MPFR_IS_SINGULAR(x) (MPFR_EXP(x) <= MPFR_EXP_INF) 751 #define MPFR_IS_PURE_FP(x) (!MPFR_IS_SINGULAR(x) && \ 752 (MPFR_ASSERTD (MPFR_MANT(x)[MPFR_LIMB_SIZE(x)-1] & MPFR_LIMB_HIGHBIT), 1)) 753 754 #define MPFR_ARE_SINGULAR(x,y) \ 755 (MPFR_UNLIKELY(MPFR_IS_SINGULAR(x)) || MPFR_UNLIKELY(MPFR_IS_SINGULAR(y))) 756 757 #define MPFR_IS_POWER_OF_2(x) \ 758 (mpfr_cmp_ui_2exp ((x), 1, MPFR_GET_EXP (x) - 1) == 0) 759 760 761 /****************************************************** 762 ********************* Sign Macros ******************** 763 ******************************************************/ 764 765 #define MPFR_SIGN_POS (1) 766 #define MPFR_SIGN_NEG (-1) 767 768 #define MPFR_IS_STRICTPOS(x) (MPFR_NOTZERO((x)) && MPFR_SIGN(x) > 0) 769 #define MPFR_IS_STRICTNEG(x) (MPFR_NOTZERO((x)) && MPFR_SIGN(x) < 0) 770 771 #define MPFR_IS_NEG(x) (MPFR_SIGN(x) < 0) 772 #define MPFR_IS_POS(x) (MPFR_SIGN(x) > 0) 773 774 #define MPFR_SET_POS(x) (MPFR_SIGN(x) = MPFR_SIGN_POS) 775 #define MPFR_SET_NEG(x) (MPFR_SIGN(x) = MPFR_SIGN_NEG) 776 777 #define MPFR_CHANGE_SIGN(x) (MPFR_SIGN(x) = -MPFR_SIGN(x)) 778 #define MPFR_SET_SAME_SIGN(x, y) (MPFR_SIGN(x) = MPFR_SIGN(y)) 779 #define MPFR_SET_OPPOSITE_SIGN(x, y) (MPFR_SIGN(x) = -MPFR_SIGN(y)) 780 #define MPFR_ASSERT_SIGN(s) \ 781 (MPFR_ASSERTD((s) == MPFR_SIGN_POS || (s) == MPFR_SIGN_NEG)) 782 #define MPFR_SET_SIGN(x, s) \ 783 (MPFR_ASSERT_SIGN(s), MPFR_SIGN(x) = s) 784 #define MPFR_IS_POS_SIGN(s1) (s1 > 0) 785 #define MPFR_IS_NEG_SIGN(s1) (s1 < 0) 786 #define MPFR_MULT_SIGN(s1, s2) ((s1) * (s2)) 787 /* Transform a sign to 1 or -1 */ 788 #define MPFR_FROM_SIGN_TO_INT(s) (s) 789 #define MPFR_INT_SIGN(x) MPFR_FROM_SIGN_TO_INT(MPFR_SIGN(x)) 790 791 792 793 /****************************************************** 794 ***************** Ternary Value Macros *************** 795 ******************************************************/ 796 797 /* Special inexact value */ 798 #define MPFR_EVEN_INEX 2 799 800 /* Macros for functions returning two inexact values in an 'int' */ 801 #define INEXPOS(y) ((y) == 0 ? 0 : (((y) > 0) ? 1 : 2)) 802 #define INEX(y,z) (INEXPOS(y) | (INEXPOS(z) << 2)) 803 804 /* When returning the ternary inexact value, ALWAYS use one of the 805 following two macros, unless the flag comes from another function 806 returning the ternary inexact value */ 807 #define MPFR_RET(I) return \ 808 (I) ? ((__gmpfr_flags |= MPFR_FLAGS_INEXACT), (I)) : 0 809 #define MPFR_RET_NAN return (__gmpfr_flags |= MPFR_FLAGS_NAN), 0 810 811 #define MPFR_SET_ERANGE() (__gmpfr_flags |= MPFR_FLAGS_ERANGE) 812 813 #define SIGN(I) ((I) < 0 ? -1 : (I) > 0) 814 #define SAME_SIGN(I1,I2) (SIGN (I1) == SIGN (I2)) 815 816 817 818 /****************************************************** 819 ************** Rounding mode macros ***************** 820 ******************************************************/ 821 822 /* MPFR_RND_MAX gives the number of supported rounding modes by all functions. 823 * Once faithful rounding is implemented, MPFR_RNDA should be changed 824 * to MPFR_RNDF. But this will also require more changes in the tests. 825 */ 826 #define MPFR_RND_MAX ((mpfr_rnd_t)((MPFR_RNDA)+1)) 827 828 /* We want to test this : 829 * (rnd == MPFR_RNDU && test) || (rnd == RNDD && !test) 830 * ie it transforms RNDU or RNDD to Away or Zero according to the sign */ 831 #define MPFR_IS_RNDUTEST_OR_RNDDNOTTEST(rnd, test) \ 832 (((rnd) + (test)) == MPFR_RNDD) 833 834 /* We want to test if rnd = Zero, or Away. 835 'test' is 1 if negative, and 0 if positive. */ 836 #define MPFR_IS_LIKE_RNDZ(rnd, test) \ 837 ((rnd==MPFR_RNDZ) || MPFR_IS_RNDUTEST_OR_RNDDNOTTEST (rnd, test)) 838 839 #define MPFR_IS_LIKE_RNDU(rnd, sign) \ 840 ((rnd==MPFR_RNDU) || (rnd==MPFR_RNDZ && sign<0) || (rnd==MPFR_RNDA && sign>0)) 841 842 #define MPFR_IS_LIKE_RNDD(rnd, sign) \ 843 ((rnd==MPFR_RNDD) || (rnd==MPFR_RNDZ && sign>0) || (rnd==MPFR_RNDA && sign<0)) 844 845 /* Invert a rounding mode, RNDZ and RNDA are unchanged */ 846 #define MPFR_INVERT_RND(rnd) ((rnd == MPFR_RNDU) ? MPFR_RNDD : \ 847 ((rnd == MPFR_RNDD) ? MPFR_RNDU : rnd)) 848 849 /* Transform RNDU and RNDD to RNDZ according to test */ 850 #define MPFR_UPDATE_RND_MODE(rnd, test) \ 851 do { \ 852 if (MPFR_UNLIKELY(MPFR_IS_RNDUTEST_OR_RNDDNOTTEST(rnd, test))) \ 853 rnd = MPFR_RNDZ; \ 854 } while (0) 855 856 /* Transform RNDU and RNDD to RNDZ or RNDA according to sign, 857 leave the other modes unchanged */ 858 #define MPFR_UPDATE2_RND_MODE(rnd, sign) \ 859 do { \ 860 if (rnd == MPFR_RNDU) \ 861 rnd = (sign > 0) ? MPFR_RNDA : MPFR_RNDZ; \ 862 else if (rnd == MPFR_RNDD) \ 863 rnd = (sign < 0) ? MPFR_RNDA : MPFR_RNDZ; \ 864 } while (0) 865 866 867 /****************************************************** 868 ******************* Limb Macros ********************** 869 ******************************************************/ 870 871 /* Definition of MPFR_LIMB_HIGHBIT */ 872 #if defined(GMP_LIMB_HIGHBIT) 873 # define MPFR_LIMB_HIGHBIT GMP_LIMB_HIGHBIT 874 #elif defined(MP_LIMB_T_HIGHBIT) 875 # define MPFR_LIMB_HIGHBIT MP_LIMB_T_HIGHBIT 876 #else 877 # error "Neither GMP_LIMB_HIGHBIT nor MP_LIMB_T_HIGHBIT defined in GMP" 878 #endif 879 880 /* Mask to get the Most Significant Bit of a limb */ 881 #define MPFR_LIMB_MSB(l) ((l)&MPFR_LIMB_HIGHBIT) 882 883 /* Definition of MPFR_LIMB_ONE & MPFR_LIMB_ZERO */ 884 #ifdef CNST_LIMB 885 # define MPFR_LIMB_ONE CNST_LIMB(1) 886 # define MPFR_LIMB_ZERO CNST_LIMB(0) 887 #else 888 # define MPFR_LIMB_ONE ((mp_limb_t) 1L) 889 # define MPFR_LIMB_ZERO ((mp_limb_t) 0L) 890 #endif 891 892 /* Mask for the low 's' bits of a limb */ 893 #define MPFR_LIMB_MASK(s) ((MPFR_LIMB_ONE<<(s))-MPFR_LIMB_ONE) 894 895 896 897 /****************************************************** 898 ********************** Memory ************************ 899 ******************************************************/ 900 901 /* Heap Memory gestion */ 902 typedef union { mp_size_t s; mp_limb_t l; } mpfr_size_limb_t; 903 #define MPFR_GET_ALLOC_SIZE(x) \ 904 ( ((mp_size_t*) MPFR_MANT(x))[-1] + 0) 905 #define MPFR_SET_ALLOC_SIZE(x, n) \ 906 ( ((mp_size_t*) MPFR_MANT(x))[-1] = n) 907 #define MPFR_MALLOC_SIZE(s) \ 908 ( sizeof(mpfr_size_limb_t) + BYTES_PER_MP_LIMB * ((size_t) s) ) 909 #define MPFR_SET_MANT_PTR(x,p) \ 910 (MPFR_MANT(x) = (mp_limb_t*) ((mpfr_size_limb_t*) p + 1)) 911 #define MPFR_GET_REAL_PTR(x) \ 912 ((mp_limb_t*) ((mpfr_size_limb_t*) MPFR_MANT(x) - 1)) 913 914 /* Temporary memory gestion */ 915 #ifndef TMP_SALLOC 916 /* GMP 4.1.x or below or internals */ 917 #define MPFR_TMP_DECL TMP_DECL 918 #define MPFR_TMP_MARK TMP_MARK 919 #define MPFR_TMP_ALLOC TMP_ALLOC 920 #define MPFR_TMP_FREE TMP_FREE 921 #else 922 #define MPFR_TMP_DECL(x) TMP_DECL 923 #define MPFR_TMP_MARK(x) TMP_MARK 924 #define MPFR_TMP_ALLOC(s) TMP_ALLOC(s) 925 #define MPFR_TMP_FREE(x) TMP_FREE 926 #endif 927 928 /* This code is experimental: don't use it */ 929 #ifdef MPFR_USE_OWN_MPFR_TMP_ALLOC 930 extern unsigned char *mpfr_stack; 931 #undef MPFR_TMP_DECL 932 #undef MPFR_TMP_MARK 933 #undef MPFR_TMP_ALLOC 934 #undef MPFR_TMP_FREE 935 #define MPFR_TMP_DECL(_x) unsigned char *(_x) 936 #define MPFR_TMP_MARK(_x) ((_x) = mpfr_stack) 937 #define MPFR_TMP_ALLOC(_s) (mpfr_stack += (_s), mpfr_stack - (_s)) 938 #define MPFR_TMP_FREE(_x) (mpfr_stack = (_x)) 939 #endif 940 941 #define MPFR_TMP_LIMBS_ALLOC(N) \ 942 ((mp_limb_t *) MPFR_TMP_ALLOC ((size_t) (N) * BYTES_PER_MP_LIMB)) 943 944 /* temporary allocate 1 limb at xp, and initialize mpfr variable x */ 945 /* The temporary var doesn't have any size field, but it doesn't matter 946 * since only functions dealing with the Heap care about it */ 947 #define MPFR_TMP_INIT1(xp, x, p) \ 948 ( MPFR_PREC(x) = (p), \ 949 MPFR_MANT(x) = (xp), \ 950 MPFR_SET_POS(x), \ 951 MPFR_SET_INVALID_EXP(x)) 952 953 #define MPFR_TMP_INIT(xp, x, p, s) \ 954 (xp = MPFR_TMP_LIMBS_ALLOC(s), \ 955 MPFR_TMP_INIT1(xp, x, p)) 956 957 #define MPFR_TMP_INIT_ABS(d, s) \ 958 ( MPFR_PREC(d) = MPFR_PREC(s), \ 959 MPFR_MANT(d) = MPFR_MANT(s), \ 960 MPFR_SET_POS(d), \ 961 MPFR_EXP(d) = MPFR_EXP(s)) 962 963 964 965 /****************************************************** 966 ***************** Cache macros ********************** 967 ******************************************************/ 968 969 #define mpfr_const_pi(_d,_r) mpfr_cache(_d, __gmpfr_cache_const_pi,_r) 970 #define mpfr_const_log2(_d,_r) mpfr_cache(_d, __gmpfr_cache_const_log2, _r) 971 #define mpfr_const_euler(_d,_r) mpfr_cache(_d, __gmpfr_cache_const_euler, _r) 972 #define mpfr_const_catalan(_d,_r) mpfr_cache(_d,__gmpfr_cache_const_catalan,_r) 973 974 #define MPFR_DECL_INIT_CACHE(_cache,_func) \ 975 mpfr_cache_t MPFR_THREAD_ATTR _cache = \ 976 {{{{0,MPFR_SIGN_POS,0,(mp_limb_t*)0}},0,_func}} 977 978 979 980 /****************************************************** 981 ******************* Threshold *********************** 982 ******************************************************/ 983 984 #include "mparam.h" 985 986 /****************************************************** 987 ***************** Useful macros ********************* 988 ******************************************************/ 989 990 /* Theses macros help the compiler to determine if a test is 991 * likely or unlikely. */ 992 #if __MPFR_GNUC(3,0) || __MPFR_ICC(8,1,0) 993 # define MPFR_LIKELY(x) (__builtin_expect(!!(x),1)) 994 # define MPFR_UNLIKELY(x) (__builtin_expect((x),0)) 995 #else 996 # define MPFR_LIKELY(x) (x) 997 # define MPFR_UNLIKELY(x) (x) 998 #endif 999 1000 /* Declare that some variable is initialized before being used (without a 1001 dummy initialization) in order to avoid some compiler warnings. Use the 1002 VAR = VAR trick (see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=36296) 1003 only with gcc as this is undefined behavior, and we don't know what 1004 other compilers do (they may also be smarter). This trick could be 1005 disabled with future gcc versions. */ 1006 #if defined(__GNUC__) 1007 # define INITIALIZED(VAR) VAR = VAR 1008 #else 1009 # define INITIALIZED(VAR) VAR 1010 #endif 1011 1012 /* Ceil log 2: If GCC, uses a GCC extension, otherwise calls a function */ 1013 /* Warning: 1014 * Needs to define MPFR_NEED_LONGLONG. 1015 * Computes ceil(log2(x)) only for x integer (unsigned long) 1016 * Undefined if x is 0 */ 1017 #if __MPFR_GNUC(2,95) || __MPFR_ICC(8,1,0) 1018 # define MPFR_INT_CEIL_LOG2(x) \ 1019 (MPFR_UNLIKELY ((x) == 1) ? 0 : \ 1020 __extension__ ({ int _b; mp_limb_t _limb; \ 1021 MPFR_ASSERTN ((x) > 1); \ 1022 _limb = (x) - 1; \ 1023 MPFR_ASSERTN (_limb == (x) - 1); \ 1024 count_leading_zeros (_b, _limb); \ 1025 (GMP_NUMB_BITS - _b); })) 1026 #else 1027 # define MPFR_INT_CEIL_LOG2(x) (__gmpfr_int_ceil_log2(x)) 1028 #endif 1029 1030 /* Add two integers with overflow handling */ 1031 /* Example: MPFR_SADD_OVERFLOW (c, a, b, long, unsigned long, 1032 * LONG_MIN, LONG_MAX, 1033 * goto overflow, goto underflow); */ 1034 #define MPFR_UADD_OVERFLOW(c,a,b,ACTION_IF_OVERFLOW) \ 1035 do { \ 1036 (c) = (a) + (b); \ 1037 if ((c) < (a)) ACTION_IF_OVERFLOW; \ 1038 } while (0) 1039 1040 #define MPFR_SADD_OVERFLOW(c,a,b,STYPE,UTYPE,MIN,MAX,ACTION_IF_POS_OVERFLOW,ACTION_IF_NEG_OVERFLOW) \ 1041 do { \ 1042 if ((a) >= 0 && (b) >= 0) { \ 1043 UTYPE uc,ua,ub; \ 1044 ua = (UTYPE) (a); ub = (UTYPE) (b); \ 1045 MPFR_UADD_OVERFLOW (uc, ua, ub, ACTION_IF_POS_OVERFLOW); \ 1046 if (uc > (UTYPE)(MAX)) ACTION_IF_POS_OVERFLOW; \ 1047 else (c) = (STYPE) uc; \ 1048 } else if ((a) < 0 && (b) < 0) { \ 1049 UTYPE uc,ua,ub; \ 1050 ua = -(UTYPE) (a); ub = -(UTYPE) (b); \ 1051 MPFR_UADD_OVERFLOW (uc, ua, ub, ACTION_IF_NEG_OVERFLOW); \ 1052 if (uc >= -(UTYPE)(MIN) || uc > (UTYPE)(MAX)) { \ 1053 if (uc == -(UTYPE)(MIN)) (c) = (MIN); \ 1054 else ACTION_IF_NEG_OVERFLOW; } \ 1055 else (c) = -(STYPE) uc; \ 1056 } else (c) = (a) + (b); \ 1057 } while (0) 1058 1059 1060 /* Set a number to 1 (Fast) - It doesn't check if 1 is in the exponent range */ 1061 #define MPFR_SET_ONE(x) \ 1062 do { \ 1063 mp_size_t _size = MPFR_LIMB_SIZE(x) - 1; \ 1064 MPFR_SET_POS(x); \ 1065 MPFR_EXP(x) = 1; \ 1066 MPN_ZERO ( MPFR_MANT(x), _size); \ 1067 MPFR_MANT(x)[_size] = MPFR_LIMB_HIGHBIT; \ 1068 } while (0) 1069 1070 /* Compute s = (-a) % GMP_NUMB_BITS as unsigned */ 1071 #define MPFR_UNSIGNED_MINUS_MODULO(s, a) \ 1072 do \ 1073 { \ 1074 if (IS_POW2 (GMP_NUMB_BITS)) \ 1075 (s) = (- (unsigned int) (a)) % GMP_NUMB_BITS; \ 1076 else \ 1077 { \ 1078 (s) = (a) % GMP_NUMB_BITS; \ 1079 if ((s) != 0) \ 1080 (s) = GMP_NUMB_BITS - (s); \ 1081 } \ 1082 MPFR_ASSERTD ((s) >= 0 && (s) < GMP_NUMB_BITS); \ 1083 } \ 1084 while (0) 1085 1086 /* Use it only for debug reasons */ 1087 /* MPFR_TRACE (operation) : execute operation iff DEBUG flag is set */ 1088 /* MPFR_DUMP (x) : print x (a mpfr_t) on stdout */ 1089 #ifdef DEBUG 1090 # define MPFR_TRACE(x) x 1091 #else 1092 # define MPFR_TRACE(x) (void) 0 1093 #endif 1094 #define MPFR_DUMP(x) ( printf(#x"="), mpfr_dump(x) ) 1095 1096 /* Test if X (positive) is a power of 2 */ 1097 #define IS_POW2(X) (((X) & ((X) - 1)) == 0) 1098 #define NOT_POW2(X) (((X) & ((X) - 1)) != 0) 1099 1100 /* Safe absolute value (to avoid possible integer overflow) */ 1101 /* type is the target (unsigned) type */ 1102 #define SAFE_ABS(type,x) ((x) >= 0 ? (type)(x) : -(type)(x)) 1103 1104 #define mpfr_get_d1(x) mpfr_get_d(x,__gmpfr_default_rounding_mode) 1105 1106 /* Store in r the size in bits of the mpz_t z */ 1107 #define MPFR_MPZ_SIZEINBASE2(r, z) \ 1108 do { \ 1109 int _cnt; \ 1110 mp_size_t _size; \ 1111 MPFR_ASSERTD (mpz_sgn (z) != 0); \ 1112 _size = ABSIZ(z); \ 1113 count_leading_zeros (_cnt, PTR(z)[_size-1]); \ 1114 (r) = _size * GMP_NUMB_BITS - _cnt; \ 1115 } while (0) 1116 1117 /* Needs <locale.h> */ 1118 #ifdef HAVE_LOCALE_H 1119 #include <locale.h> 1120 /* Warning! In case of signed char, the value of MPFR_DECIMAL_POINT may 1121 be negative (the ISO C99 does not seem to forbid negative values). */ 1122 #define MPFR_DECIMAL_POINT (localeconv()->decimal_point[0]) 1123 #define MPFR_THOUSANDS_SEPARATOR (localeconv()->thousands_sep[0]) 1124 #else 1125 #define MPFR_DECIMAL_POINT ((char) '.') 1126 #define MPFR_THOUSANDS_SEPARATOR ('\0') 1127 #endif 1128 1129 1130 /* Set y to s*significand(x)*2^e, for example MPFR_ALIAS(y,x,1,MPFR_EXP(x)) 1131 sets y to |x|, and MPFR_ALIAS(y,x,MPFR_SIGN(x),0) sets y to x*2^f such 1132 that 1/2 <= |y| < 1. Does not check y is in the valid exponent range. 1133 WARNING! x and y share the same mantissa. So, some operations are 1134 not valid if x has been provided via an argument, e.g., trying to 1135 modify the mantissa of y, even temporarily, or calling mpfr_clear on y. 1136 */ 1137 #define MPFR_ALIAS(y,x,s,e) \ 1138 do \ 1139 { \ 1140 MPFR_PREC(y) = MPFR_PREC(x); \ 1141 MPFR_SIGN(y) = (s); \ 1142 MPFR_EXP(y) = (e); \ 1143 MPFR_MANT(y) = MPFR_MANT(x); \ 1144 } while (0) 1145 1146 1147 /****************************************************** 1148 ************** Save exponent macros **************** 1149 ******************************************************/ 1150 1151 /* See README.dev for details on how to use the macros. 1152 They are used to set the exponent range to the maximum 1153 temporarily */ 1154 1155 typedef struct { 1156 unsigned int saved_flags; 1157 mpfr_exp_t saved_emin; 1158 mpfr_exp_t saved_emax; 1159 } mpfr_save_expo_t; 1160 1161 /* Minimum and maximum exponents of the extended exponent range. */ 1162 #define MPFR_EXT_EMIN MPFR_EMIN_MIN 1163 #define MPFR_EXT_EMAX MPFR_EMAX_MAX 1164 1165 #define MPFR_SAVE_EXPO_DECL(x) mpfr_save_expo_t x 1166 #define MPFR_SAVE_EXPO_MARK(x) \ 1167 ((x).saved_flags = __gmpfr_flags, \ 1168 (x).saved_emin = __gmpfr_emin, \ 1169 (x).saved_emax = __gmpfr_emax, \ 1170 __gmpfr_emin = MPFR_EXT_EMIN, \ 1171 __gmpfr_emax = MPFR_EXT_EMAX) 1172 #define MPFR_SAVE_EXPO_FREE(x) \ 1173 (__gmpfr_flags = (x).saved_flags, \ 1174 __gmpfr_emin = (x).saved_emin, \ 1175 __gmpfr_emax = (x).saved_emax) 1176 #define MPFR_SAVE_EXPO_UPDATE_FLAGS(x, flags) \ 1177 (x).saved_flags |= (flags) 1178 1179 /* Speed up final checking */ 1180 #define mpfr_check_range(x,t,r) \ 1181 (MPFR_LIKELY (MPFR_EXP (x) >= __gmpfr_emin && MPFR_EXP (x) <= __gmpfr_emax) \ 1182 ? ((t) ? (__gmpfr_flags |= MPFR_FLAGS_INEXACT, (t)) : 0) \ 1183 : mpfr_check_range(x,t,r)) 1184 1185 1186 /****************************************************** 1187 ***************** Inline Rounding ******************* 1188 ******************************************************/ 1189 1190 /* 1191 * Note: due to the labels, one cannot use a macro MPFR_RNDRAW* more than 1192 * once in a function (otherwise these labels would not be unique). 1193 */ 1194 1195 /* 1196 * Round mantissa (srcp, sprec) to mpfr_t dest using rounding mode rnd 1197 * assuming dest's sign is sign. 1198 * In rounding to nearest mode, execute MIDDLE_HANDLER when the value 1199 * is the middle of two consecutive numbers in dest precision. 1200 * Execute OVERFLOW_HANDLER in case of overflow when rounding. 1201 */ 1202 #define MPFR_RNDRAW_GEN(inexact, dest, srcp, sprec, rnd, sign, \ 1203 MIDDLE_HANDLER, OVERFLOW_HANDLER) \ 1204 do { \ 1205 mp_size_t _dests, _srcs; \ 1206 mp_limb_t *_destp; \ 1207 mpfr_prec_t _destprec, _srcprec; \ 1208 \ 1209 /* Check Trivial Case when Dest Mantissa has more bits than source */ \ 1210 _srcprec = (sprec); \ 1211 _destprec = MPFR_PREC (dest); \ 1212 _destp = MPFR_MANT (dest); \ 1213 if (MPFR_UNLIKELY (_destprec >= _srcprec)) \ 1214 { \ 1215 _srcs = (_srcprec + GMP_NUMB_BITS-1)/GMP_NUMB_BITS; \ 1216 _dests = (_destprec + GMP_NUMB_BITS-1)/GMP_NUMB_BITS - _srcs; \ 1217 MPN_COPY (_destp + _dests, srcp, _srcs); \ 1218 MPN_ZERO (_destp, _dests); \ 1219 inexact = 0; \ 1220 } \ 1221 else \ 1222 { \ 1223 /* Non trivial case: rounding needed */ \ 1224 mpfr_prec_t _sh; \ 1225 mp_limb_t *_sp; \ 1226 mp_limb_t _rb, _sb, _ulp; \ 1227 \ 1228 /* Compute Position and shift */ \ 1229 _srcs = (_srcprec + GMP_NUMB_BITS-1)/GMP_NUMB_BITS; \ 1230 _dests = (_destprec + GMP_NUMB_BITS-1)/GMP_NUMB_BITS; \ 1231 MPFR_UNSIGNED_MINUS_MODULO (_sh, _destprec); \ 1232 _sp = (srcp) + _srcs - _dests; \ 1233 \ 1234 /* General case when prec % GMP_NUMB_BITS != 0 */ \ 1235 if (MPFR_LIKELY (_sh != 0)) \ 1236 { \ 1237 mp_limb_t _mask; \ 1238 /* Compute Rounding Bit and Sticky Bit */ \ 1239 /* Note: in directed rounding modes, if the rounding bit */ \ 1240 /* is 1, the behavior does not depend on the sticky bit; */ \ 1241 /* thus we will not try to compute it in this case (this */ \ 1242 /* can be much faster and avoids to read uninitialized */ \ 1243 /* data in the current mpfr_mul implementation). We just */ \ 1244 /* make sure that _sb is initialized. */ \ 1245 _mask = MPFR_LIMB_ONE << (_sh - 1); \ 1246 _rb = _sp[0] & _mask; \ 1247 _sb = _sp[0] & (_mask - 1); \ 1248 if (MPFR_UNLIKELY (_sb == 0) && \ 1249 ((rnd) == MPFR_RNDN || _rb == 0)) \ 1250 { /* TODO: Improve it */ \ 1251 mp_limb_t *_tmp; \ 1252 mp_size_t _n; \ 1253 for (_tmp = _sp, _n = _srcs - _dests ; \ 1254 _n != 0 && _sb == 0 ; _n--) \ 1255 _sb = *--_tmp; \ 1256 } \ 1257 _ulp = 2 * _mask; \ 1258 } \ 1259 else /* _sh == 0 */ \ 1260 { \ 1261 MPFR_ASSERTD (_dests < _srcs); \ 1262 /* Compute Rounding Bit and Sticky Bit - see note above */ \ 1263 _rb = _sp[-1] & MPFR_LIMB_HIGHBIT; \ 1264 _sb = _sp[-1] & (MPFR_LIMB_HIGHBIT-1); \ 1265 if (MPFR_UNLIKELY (_sb == 0) && \ 1266 ((rnd) == MPFR_RNDN || _rb == 0)) \ 1267 { \ 1268 mp_limb_t *_tmp; \ 1269 mp_size_t _n; \ 1270 for (_tmp = _sp - 1, _n = _srcs - _dests - 1 ; \ 1271 _n != 0 && _sb == 0 ; _n--) \ 1272 _sb = *--_tmp; \ 1273 } \ 1274 _ulp = MPFR_LIMB_ONE; \ 1275 } \ 1276 /* Rounding */ \ 1277 if (MPFR_LIKELY (rnd == MPFR_RNDN)) \ 1278 { \ 1279 if (_rb == 0) \ 1280 { \ 1281 trunc: \ 1282 inexact = MPFR_LIKELY ((_sb | _rb) != 0) ? -sign : 0; \ 1283 trunc_doit: \ 1284 MPN_COPY (_destp, _sp, _dests); \ 1285 _destp[0] &= ~(_ulp - 1); \ 1286 } \ 1287 else if (MPFR_UNLIKELY (_sb == 0)) \ 1288 { /* Middle of two consecutive representable numbers */ \ 1289 MIDDLE_HANDLER; \ 1290 } \ 1291 else \ 1292 { \ 1293 if (0) \ 1294 goto addoneulp_doit; /* dummy code to avoid warning */ \ 1295 addoneulp: \ 1296 inexact = sign; \ 1297 addoneulp_doit: \ 1298 if (MPFR_UNLIKELY (mpn_add_1 (_destp, _sp, _dests, _ulp))) \ 1299 { \ 1300 _destp[_dests - 1] = MPFR_LIMB_HIGHBIT; \ 1301 OVERFLOW_HANDLER; \ 1302 } \ 1303 _destp[0] &= ~(_ulp - 1); \ 1304 } \ 1305 } \ 1306 else \ 1307 { /* Directed rounding mode */ \ 1308 if (MPFR_LIKELY (MPFR_IS_LIKE_RNDZ (rnd, \ 1309 MPFR_IS_NEG_SIGN (sign)))) \ 1310 goto trunc; \ 1311 else if (MPFR_UNLIKELY ((_sb | _rb) == 0)) \ 1312 { \ 1313 inexact = 0; \ 1314 goto trunc_doit; \ 1315 } \ 1316 else \ 1317 goto addoneulp; \ 1318 } \ 1319 } \ 1320 } while (0) 1321 1322 /* 1323 * Round mantissa (srcp, sprec) to mpfr_t dest using rounding mode rnd 1324 * assuming dest's sign is sign. 1325 * Execute OVERFLOW_HANDLER in case of overflow when rounding. 1326 */ 1327 #define MPFR_RNDRAW(inexact, dest, srcp, sprec, rnd, sign, OVERFLOW_HANDLER) \ 1328 MPFR_RNDRAW_GEN (inexact, dest, srcp, sprec, rnd, sign, \ 1329 if ((_sp[0] & _ulp) == 0) \ 1330 { \ 1331 inexact = -sign; \ 1332 goto trunc_doit; \ 1333 } \ 1334 else \ 1335 goto addoneulp; \ 1336 , OVERFLOW_HANDLER) 1337 1338 /* 1339 * Round mantissa (srcp, sprec) to mpfr_t dest using rounding mode rnd 1340 * assuming dest's sign is sign. 1341 * Execute OVERFLOW_HANDLER in case of overflow when rounding. 1342 * Set inexact to +/- MPFR_EVEN_INEX in case of even rounding. 1343 */ 1344 #define MPFR_RNDRAW_EVEN(inexact, dest, srcp, sprec, rnd, sign, \ 1345 OVERFLOW_HANDLER) \ 1346 MPFR_RNDRAW_GEN (inexact, dest, srcp, sprec, rnd, sign, \ 1347 if ((_sp[0] & _ulp) == 0) \ 1348 { \ 1349 inexact = -MPFR_EVEN_INEX * sign; \ 1350 goto trunc_doit; \ 1351 } \ 1352 else \ 1353 { \ 1354 inexact = MPFR_EVEN_INEX * sign; \ 1355 goto addoneulp_doit; \ 1356 } \ 1357 , OVERFLOW_HANDLER) 1358 1359 /* Return TRUE if b is non singular and we can round it to precision 'prec' 1360 and determine the ternary value, with rounding mode 'rnd', and with 1361 error at most 'error' */ 1362 #define MPFR_CAN_ROUND(b,err,prec,rnd) \ 1363 (!MPFR_IS_SINGULAR (b) && mpfr_round_p (MPFR_MANT (b), MPFR_LIMB_SIZE (b), \ 1364 (err), (prec) + ((rnd)==MPFR_RNDN))) 1365 1366 /* Copy the sign and the significand, and handle the exponent in exp. */ 1367 #define MPFR_SETRAW(inexact,dest,src,exp,rnd) \ 1368 if (MPFR_UNLIKELY (dest != src)) \ 1369 { \ 1370 MPFR_SET_SIGN (dest, MPFR_SIGN (src)); \ 1371 if (MPFR_LIKELY (MPFR_PREC (dest) == MPFR_PREC (src))) \ 1372 { \ 1373 MPN_COPY (MPFR_MANT (dest), MPFR_MANT (src), \ 1374 (MPFR_PREC (src) + GMP_NUMB_BITS-1)/GMP_NUMB_BITS); \ 1375 inexact = 0; \ 1376 } \ 1377 else \ 1378 { \ 1379 MPFR_RNDRAW (inexact, dest, MPFR_MANT (src), MPFR_PREC (src), \ 1380 rnd, MPFR_SIGN (src), exp++); \ 1381 } \ 1382 } \ 1383 else \ 1384 inexact = 0; 1385 1386 /* TODO: fix this description (see round_near_x.c). */ 1387 /* Assuming that the function has a Taylor expansion which looks like: 1388 y=o(f(x)) = o(v + g(x)) with |g(x)| <= 2^(EXP(v)-err) 1389 we can quickly set y to v if x is small (ie err > prec(y)+1) in most 1390 cases. It assumes that f(x) is not representable exactly as a FP number. 1391 v must not be a singular value (NAN, INF or ZERO); usual values are 1392 v=1 or v=x. 1393 1394 y is the destination (a mpfr_t), v the value to set (a mpfr_t), 1395 err1+err2 with err2 <= 3 the error term (mpfr_exp_t's), dir (an int) is 1396 the direction of the committed error (if dir = 0, it rounds toward 0, 1397 if dir=1, it rounds away from 0), rnd the rounding mode. 1398 1399 It returns from the function a ternary value in case of success. 1400 If you want to free something, you must fill the "extra" field 1401 in consequences, otherwise put nothing in it. 1402 1403 The test is less restrictive than necessary, but the function 1404 will finish the check itself. 1405 1406 Note: err1 + err2 is allowed to overflow as mpfr_exp_t, but it must give 1407 its real value as mpfr_uexp_t. 1408 */ 1409 #define MPFR_FAST_COMPUTE_IF_SMALL_INPUT(y,v,err1,err2,dir,rnd,extra) \ 1410 do { \ 1411 mpfr_ptr _y = (y); \ 1412 mpfr_exp_t _err1 = (err1); \ 1413 mpfr_exp_t _err2 = (err2); \ 1414 if (_err1 > 0) \ 1415 { \ 1416 mpfr_uexp_t _err = (mpfr_uexp_t) _err1 + _err2; \ 1417 if (MPFR_UNLIKELY (_err > MPFR_PREC (_y) + 1)) \ 1418 { \ 1419 int _inexact = mpfr_round_near_x (_y,(v),_err,(dir),(rnd)); \ 1420 if (_inexact != 0) \ 1421 { \ 1422 extra; \ 1423 return _inexact; \ 1424 } \ 1425 } \ 1426 } \ 1427 } while (0) 1428 1429 /* Variant, to be called somewhere after MPFR_SAVE_EXPO_MARK. This variant 1430 is needed when there are some computations before or when some non-zero 1431 real constant is used, such as __gmpfr_one for mpfr_cos. */ 1432 #define MPFR_SMALL_INPUT_AFTER_SAVE_EXPO(y,v,err1,err2,dir,rnd,expo,extra) \ 1433 do { \ 1434 mpfr_ptr _y = (y); \ 1435 mpfr_exp_t _err1 = (err1); \ 1436 mpfr_exp_t _err2 = (err2); \ 1437 if (_err1 > 0) \ 1438 { \ 1439 mpfr_uexp_t _err = (mpfr_uexp_t) _err1 + _err2; \ 1440 if (MPFR_UNLIKELY (_err > MPFR_PREC (_y) + 1)) \ 1441 { \ 1442 int _inexact; \ 1443 mpfr_clear_flags (); \ 1444 _inexact = mpfr_round_near_x (_y,(v),_err,(dir),(rnd)); \ 1445 if (_inexact != 0) \ 1446 { \ 1447 extra; \ 1448 MPFR_SAVE_EXPO_UPDATE_FLAGS (expo, __gmpfr_flags); \ 1449 MPFR_SAVE_EXPO_FREE (expo); \ 1450 return mpfr_check_range (_y, _inexact, (rnd)); \ 1451 } \ 1452 } \ 1453 } \ 1454 } while (0) 1455 1456 /****************************************************** 1457 *************** Ziv Loop Macro ********************* 1458 ******************************************************/ 1459 1460 #ifndef MPFR_USE_LOGGING 1461 1462 #define MPFR_ZIV_DECL(_x) mpfr_prec_t _x 1463 #define MPFR_ZIV_INIT(_x, _p) (_x) = GMP_NUMB_BITS 1464 #define MPFR_ZIV_NEXT(_x, _p) ((_p) += (_x), (_x) = (_p)/2) 1465 #define MPFR_ZIV_FREE(x) 1466 1467 #else 1468 1469 /* The following test on glibc is there mainly for Darwin (Mac OS X), to 1470 obtain a better error message. The real test should have been a test 1471 concerning nested functions in gcc, which are disabled by default on 1472 Darwin; but it is not possible to do that without a configure test. */ 1473 # if defined (__cplusplus) || !(__MPFR_GNUC(3,0) && __MPFR_GLIBC(2,0)) 1474 # error "Logging not supported (needs gcc >= 3.0 and GNU C Library >= 2.0)." 1475 # endif 1476 1477 /* Use LOGGING */ 1478 1479 /* Note: the mpfr_log_level >= 0 below avoids to take into account 1480 Ziv loops used by the MPFR functions called by the mpfr_fprintf 1481 in LOG_PRINT. */ 1482 1483 #define MPFR_ZIV_DECL(_x) \ 1484 mpfr_prec_t _x; \ 1485 int _x ## _cpt = 1; \ 1486 static unsigned long _x ## _loop = 0, _x ## _bad = 0; \ 1487 static const char *_x ## _fname = __func__; \ 1488 auto void __attribute__ ((destructor)) x ## _f (void); \ 1489 void __attribute__ ((destructor)) x ## _f (void) { \ 1490 if (_x ## _loop != 0 && (MPFR_LOG_STAT_F & mpfr_log_type)) \ 1491 fprintf (mpfr_log_file, \ 1492 "%s: Ziv failed %2.2f%% (%lu bad cases / %lu calls)\n", \ 1493 _x ## _fname, (double) 100.0 * _x ## _bad / _x ## _loop, \ 1494 _x ## _bad, _x ## _loop ); } 1495 1496 #define MPFR_ZIV_INIT(_x, _p) \ 1497 do \ 1498 { \ 1499 (_x) = GMP_NUMB_BITS; \ 1500 if (mpfr_log_level >= 0) \ 1501 _x ## _loop ++; \ 1502 if ((MPFR_LOG_BADCASE_F & mpfr_log_type) && \ 1503 (mpfr_log_current <= mpfr_log_level)) \ 1504 LOG_PRINT ("%s:ZIV 1st prec=%Pd\n", \ 1505 __func__, (mpfr_prec_t) (_p)); \ 1506 } \ 1507 while (0) 1508 1509 #define MPFR_ZIV_NEXT(_x, _p) \ 1510 do \ 1511 { \ 1512 (_p) += (_x); \ 1513 (_x) = (_p) / 2; \ 1514 if (mpfr_log_level >= 0) \ 1515 _x ## _bad += (_x ## _cpt == 1); \ 1516 _x ## _cpt ++; \ 1517 if ((MPFR_LOG_BADCASE_F & mpfr_log_type) && \ 1518 (mpfr_log_current <= mpfr_log_level)) \ 1519 LOG_PRINT ("%s:ZIV new prec=%Pd\n", \ 1520 __func__, (mpfr_prec_t) (_p)); \ 1521 } \ 1522 while (0) 1523 1524 #define MPFR_ZIV_FREE(_x) \ 1525 do \ 1526 { \ 1527 if ((MPFR_LOG_BADCASE_F & mpfr_log_type) && _x ## _cpt > 1 && \ 1528 (mpfr_log_current <= mpfr_log_level)) \ 1529 fprintf (mpfr_log_file, "%s:ZIV %d loops\n", \ 1530 __func__, _x ## _cpt); \ 1531 } \ 1532 while (0) 1533 1534 #endif 1535 1536 1537 /****************************************************** 1538 *************** Logging Macros ********************* 1539 ******************************************************/ 1540 1541 /* The different kind of LOG */ 1542 #define MPFR_LOG_INPUT_F 1 1543 #define MPFR_LOG_OUTPUT_F 2 1544 #define MPFR_LOG_INTERNAL_F 4 1545 #define MPFR_LOG_TIME_F 8 1546 #define MPFR_LOG_BADCASE_F 16 1547 #define MPFR_LOG_MSG_F 32 1548 #define MPFR_LOG_STAT_F 64 1549 1550 #ifdef MPFR_USE_LOGGING 1551 1552 /* Check if we can support this feature */ 1553 # ifdef MPFR_USE_THREAD_SAFE 1554 # error "Enable either `Logging' or `thread-safe', not both" 1555 # endif 1556 # if !__MPFR_GNUC(3,0) 1557 # error "Logging not supported (GCC >= 3.0)" 1558 # endif 1559 1560 #if defined (__cplusplus) 1561 extern "C" { 1562 #endif 1563 1564 __MPFR_DECLSPEC extern FILE *mpfr_log_file; 1565 __MPFR_DECLSPEC extern int mpfr_log_type; 1566 __MPFR_DECLSPEC extern int mpfr_log_level; 1567 __MPFR_DECLSPEC extern int mpfr_log_current; 1568 __MPFR_DECLSPEC extern mpfr_prec_t mpfr_log_prec; 1569 1570 #if defined (__cplusplus) 1571 } 1572 #endif 1573 1574 /* LOG_PRINT calls mpfr_fprintf on mpfr_log_file with logging disabled 1575 (recursive logging is not wanted and freezes MPFR). */ 1576 #define LOG_PRINT(format, ...) \ 1577 do \ 1578 { \ 1579 int old_level = mpfr_log_level; \ 1580 mpfr_log_level = -1; /* disable logging in mpfr_fprintf */ \ 1581 __gmpfr_cache_const_pi = __gmpfr_logging_pi; \ 1582 __gmpfr_cache_const_log2 = __gmpfr_logging_log2; \ 1583 mpfr_fprintf (mpfr_log_file, format, __VA_ARGS__); \ 1584 mpfr_log_level = old_level; \ 1585 __gmpfr_cache_const_pi = __gmpfr_normal_pi; \ 1586 __gmpfr_cache_const_log2 = __gmpfr_normal_log2; \ 1587 } \ 1588 while (0) 1589 1590 #define MPFR_LOG_VAR(x) \ 1591 do \ 1592 if ((MPFR_LOG_INTERNAL_F & mpfr_log_type) && \ 1593 (mpfr_log_current <= mpfr_log_level)) \ 1594 LOG_PRINT ("%s.%d:%s[%#Pu]=%.*Rf\n", __func__, __LINE__, \ 1595 #x, mpfr_get_prec (x), mpfr_log_prec, x); \ 1596 while (0) 1597 1598 #define MPFR_LOG_MSG2(format, ...) \ 1599 do \ 1600 if ((MPFR_LOG_MSG_F & mpfr_log_type) && \ 1601 (mpfr_log_current <= mpfr_log_level)) \ 1602 LOG_PRINT ("%s.%d: "format, __func__, __LINE__, __VA_ARGS__); \ 1603 while (0) 1604 #define MPFR_LOG_MSG(x) MPFR_LOG_MSG2 x 1605 1606 #define MPFR_LOG_BEGIN2(format, ...) \ 1607 mpfr_log_current ++; \ 1608 if ((MPFR_LOG_INPUT_F & mpfr_log_type) && \ 1609 (mpfr_log_current <= mpfr_log_level)) \ 1610 LOG_PRINT ("%s:IN "format"\n", __func__, __VA_ARGS__); \ 1611 if ((MPFR_LOG_TIME_F & mpfr_log_type) && \ 1612 (mpfr_log_current <= mpfr_log_level)) \ 1613 __gmpfr_log_time = mpfr_get_cputime (); 1614 #define MPFR_LOG_BEGIN(x) \ 1615 int __gmpfr_log_time = 0; \ 1616 MPFR_LOG_BEGIN2 x 1617 1618 #define MPFR_LOG_END2(format, ...) \ 1619 if ((MPFR_LOG_TIME_F & mpfr_log_type) && \ 1620 (mpfr_log_current <= mpfr_log_level)) \ 1621 fprintf (mpfr_log_file, "%s:TIM %dms\n", __mpfr_log_fname, \ 1622 mpfr_get_cputime () - __gmpfr_log_time); \ 1623 if ((MPFR_LOG_OUTPUT_F & mpfr_log_type) && \ 1624 (mpfr_log_current <= mpfr_log_level)) \ 1625 LOG_PRINT ("%s:OUT "format"\n", __mpfr_log_fname, __VA_ARGS__); \ 1626 mpfr_log_current --; 1627 #define MPFR_LOG_END(x) \ 1628 static const char *__mpfr_log_fname = __func__; \ 1629 MPFR_LOG_END2 x 1630 1631 #define MPFR_LOG_FUNC(begin,end) \ 1632 static const char *__mpfr_log_fname = __func__; \ 1633 auto void __mpfr_log_cleanup (int *time); \ 1634 void __mpfr_log_cleanup (int *time) { \ 1635 int __gmpfr_log_time = *time; \ 1636 MPFR_LOG_END2 end; } \ 1637 int __gmpfr_log_time __attribute__ ((cleanup (__mpfr_log_cleanup))); \ 1638 __gmpfr_log_time = 0; \ 1639 MPFR_LOG_BEGIN2 begin 1640 1641 #else /* MPFR_USE_LOGGING */ 1642 1643 /* Define void macro for logging */ 1644 1645 #define MPFR_LOG_VAR(x) 1646 #define MPFR_LOG_BEGIN(x) 1647 #define MPFR_LOG_END(x) 1648 #define MPFR_LOG_MSG(x) 1649 #define MPFR_LOG_FUNC(x,y) 1650 1651 #endif /* MPFR_USE_LOGGING */ 1652 1653 1654 /************************************************************** 1655 ************ Group Initialize Functions Macros ************* 1656 **************************************************************/ 1657 1658 #ifndef MPFR_GROUP_STATIC_SIZE 1659 # define MPFR_GROUP_STATIC_SIZE 16 1660 #endif 1661 1662 struct mpfr_group_t { 1663 size_t alloc; 1664 mp_limb_t *mant; 1665 mp_limb_t tab[MPFR_GROUP_STATIC_SIZE]; 1666 }; 1667 1668 #define MPFR_GROUP_DECL(g) struct mpfr_group_t g 1669 #define MPFR_GROUP_CLEAR(g) do { \ 1670 MPFR_LOG_MSG (("GROUP_CLEAR: ptr = 0x%lX, size = %lu\n", \ 1671 (unsigned long) (g).mant, \ 1672 (unsigned long) (g).alloc)); \ 1673 if (MPFR_UNLIKELY ((g).alloc != 0)) { \ 1674 MPFR_ASSERTD ((g).mant != (g).tab); \ 1675 (*__gmp_free_func) ((g).mant, (g).alloc); \ 1676 }} while (0) 1677 1678 #define MPFR_GROUP_INIT_TEMPLATE(g, prec, num, handler) do { \ 1679 mpfr_prec_t _prec = (prec); \ 1680 mp_size_t _size; \ 1681 MPFR_ASSERTD (_prec >= MPFR_PREC_MIN); \ 1682 if (MPFR_UNLIKELY (_prec > MPFR_PREC_MAX)) \ 1683 mpfr_abort_prec_max (); \ 1684 _size = (mpfr_prec_t) (_prec + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS; \ 1685 if (MPFR_UNLIKELY (_size * (num) > MPFR_GROUP_STATIC_SIZE)) \ 1686 { \ 1687 (g).alloc = (num) * _size * sizeof (mp_limb_t); \ 1688 (g).mant = (mp_limb_t *) (*__gmp_allocate_func) ((g).alloc); \ 1689 } \ 1690 else \ 1691 { \ 1692 (g).alloc = 0; \ 1693 (g).mant = (g).tab; \ 1694 } \ 1695 MPFR_LOG_MSG (("GROUP_INIT: ptr = 0x%lX, size = %lu\n", \ 1696 (unsigned long) (g).mant, (unsigned long) (g).alloc)); \ 1697 handler; \ 1698 } while (0) 1699 #define MPFR_GROUP_TINIT(g, n, x) \ 1700 MPFR_TMP_INIT1 ((g).mant + _size * (n), x, _prec) 1701 1702 #define MPFR_GROUP_INIT_1(g, prec, x) \ 1703 MPFR_GROUP_INIT_TEMPLATE(g, prec, 1, MPFR_GROUP_TINIT(g, 0, x)) 1704 #define MPFR_GROUP_INIT_2(g, prec, x, y) \ 1705 MPFR_GROUP_INIT_TEMPLATE(g, prec, 2, \ 1706 MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y)) 1707 #define MPFR_GROUP_INIT_3(g, prec, x, y, z) \ 1708 MPFR_GROUP_INIT_TEMPLATE(g, prec, 3, \ 1709 MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y); \ 1710 MPFR_GROUP_TINIT(g, 2, z)) 1711 #define MPFR_GROUP_INIT_4(g, prec, x, y, z, t) \ 1712 MPFR_GROUP_INIT_TEMPLATE(g, prec, 4, \ 1713 MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y); \ 1714 MPFR_GROUP_TINIT(g, 2, z);MPFR_GROUP_TINIT(g, 3, t)) 1715 #define MPFR_GROUP_INIT_5(g, prec, x, y, z, t, a) \ 1716 MPFR_GROUP_INIT_TEMPLATE(g, prec, 5, \ 1717 MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y); \ 1718 MPFR_GROUP_TINIT(g, 2, z);MPFR_GROUP_TINIT(g, 3, t); \ 1719 MPFR_GROUP_TINIT(g, 4, a)) 1720 #define MPFR_GROUP_INIT_6(g, prec, x, y, z, t, a, b) \ 1721 MPFR_GROUP_INIT_TEMPLATE(g, prec, 6, \ 1722 MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y); \ 1723 MPFR_GROUP_TINIT(g, 2, z);MPFR_GROUP_TINIT(g, 3, t); \ 1724 MPFR_GROUP_TINIT(g, 4, a);MPFR_GROUP_TINIT(g, 5, b)) 1725 1726 #define MPFR_GROUP_REPREC_TEMPLATE(g, prec, num, handler) do { \ 1727 mpfr_prec_t _prec = (prec); \ 1728 size_t _oalloc = (g).alloc; \ 1729 mp_size_t _size; \ 1730 MPFR_LOG_MSG (("GROUP_REPREC: oldptr = 0x%lX, oldsize = %lu\n", \ 1731 (unsigned long) (g).mant, (unsigned long) _oalloc)); \ 1732 MPFR_ASSERTD (_prec >= MPFR_PREC_MIN); \ 1733 if (MPFR_UNLIKELY (_prec > MPFR_PREC_MAX)) \ 1734 mpfr_abort_prec_max (); \ 1735 _size = (mpfr_prec_t) (_prec + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS; \ 1736 (g).alloc = (num) * _size * sizeof (mp_limb_t); \ 1737 if (MPFR_LIKELY (_oalloc == 0)) \ 1738 (g).mant = (mp_limb_t *) (*__gmp_allocate_func) ((g).alloc); \ 1739 else \ 1740 (g).mant = (mp_limb_t *) \ 1741 (*__gmp_reallocate_func) ((g).mant, _oalloc, (g).alloc); \ 1742 MPFR_LOG_MSG (("GROUP_REPREC: newptr = 0x%lX, newsize = %lu\n", \ 1743 (unsigned long) (g).mant, (unsigned long) (g).alloc)); \ 1744 handler; \ 1745 } while (0) 1746 1747 #define MPFR_GROUP_REPREC_1(g, prec, x) \ 1748 MPFR_GROUP_REPREC_TEMPLATE(g, prec, 1, MPFR_GROUP_TINIT(g, 0, x)) 1749 #define MPFR_GROUP_REPREC_2(g, prec, x, y) \ 1750 MPFR_GROUP_REPREC_TEMPLATE(g, prec, 2, \ 1751 MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y)) 1752 #define MPFR_GROUP_REPREC_3(g, prec, x, y, z) \ 1753 MPFR_GROUP_REPREC_TEMPLATE(g, prec, 3, \ 1754 MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y); \ 1755 MPFR_GROUP_TINIT(g, 2, z)) 1756 #define MPFR_GROUP_REPREC_4(g, prec, x, y, z, t) \ 1757 MPFR_GROUP_REPREC_TEMPLATE(g, prec, 4, \ 1758 MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y); \ 1759 MPFR_GROUP_TINIT(g, 2, z);MPFR_GROUP_TINIT(g, 3, t)) 1760 #define MPFR_GROUP_REPREC_5(g, prec, x, y, z, t, a) \ 1761 MPFR_GROUP_REPREC_TEMPLATE(g, prec, 5, \ 1762 MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y); \ 1763 MPFR_GROUP_TINIT(g, 2, z);MPFR_GROUP_TINIT(g, 3, t); \ 1764 MPFR_GROUP_TINIT(g, 4, a)) 1765 #define MPFR_GROUP_REPREC_6(g, prec, x, y, z, t, a, b) \ 1766 MPFR_GROUP_REPREC_TEMPLATE(g, prec, 6, \ 1767 MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y); \ 1768 MPFR_GROUP_TINIT(g, 2, z);MPFR_GROUP_TINIT(g, 3, t); \ 1769 MPFR_GROUP_TINIT(g, 4, a);MPFR_GROUP_TINIT(g, 5, b)) 1770 1771 1772 /****************************************************** 1773 *************** Internal Functions ***************** 1774 ******************************************************/ 1775 1776 #if defined (__cplusplus) 1777 extern "C" { 1778 #endif 1779 1780 __MPFR_DECLSPEC int mpfr_underflow _MPFR_PROTO ((mpfr_ptr, mpfr_rnd_t, int)); 1781 __MPFR_DECLSPEC int mpfr_overflow _MPFR_PROTO ((mpfr_ptr, mpfr_rnd_t, int)); 1782 1783 __MPFR_DECLSPEC int mpfr_add1 _MPFR_PROTO ((mpfr_ptr, mpfr_srcptr, 1784 mpfr_srcptr, mpfr_rnd_t)); 1785 __MPFR_DECLSPEC int mpfr_sub1 _MPFR_PROTO ((mpfr_ptr, mpfr_srcptr, 1786 mpfr_srcptr, mpfr_rnd_t)); 1787 __MPFR_DECLSPEC int mpfr_add1sp _MPFR_PROTO ((mpfr_ptr, mpfr_srcptr, 1788 mpfr_srcptr, mpfr_rnd_t)); 1789 __MPFR_DECLSPEC int mpfr_sub1sp _MPFR_PROTO ((mpfr_ptr, mpfr_srcptr, 1790 mpfr_srcptr, mpfr_rnd_t)); 1791 __MPFR_DECLSPEC int mpfr_can_round_raw _MPFR_PROTO ((const mp_limb_t *, 1792 mp_size_t, int, mpfr_exp_t, mpfr_rnd_t, mpfr_rnd_t, mpfr_prec_t)); 1793 1794 __MPFR_DECLSPEC int mpfr_cmp2 _MPFR_PROTO ((mpfr_srcptr, mpfr_srcptr, 1795 mpfr_prec_t *)); 1796 1797 __MPFR_DECLSPEC long __gmpfr_ceil_log2 _MPFR_PROTO ((double)); 1798 __MPFR_DECLSPEC long __gmpfr_floor_log2 _MPFR_PROTO ((double)); 1799 __MPFR_DECLSPEC double __gmpfr_ceil_exp2 _MPFR_PROTO ((double)); 1800 __MPFR_DECLSPEC unsigned long __gmpfr_isqrt _MPFR_PROTO ((unsigned long)); 1801 __MPFR_DECLSPEC unsigned long __gmpfr_cuberoot _MPFR_PROTO ((unsigned long)); 1802 __MPFR_DECLSPEC int __gmpfr_int_ceil_log2 _MPFR_PROTO ((unsigned long)); 1803 1804 __MPFR_DECLSPEC mpfr_exp_t mpfr_ceil_mul _MPFR_PROTO ((mpfr_exp_t, int, int)); 1805 1806 __MPFR_DECLSPEC int mpfr_exp_2 _MPFR_PROTO ((mpfr_ptr, mpfr_srcptr,mpfr_rnd_t)); 1807 __MPFR_DECLSPEC int mpfr_exp_3 _MPFR_PROTO ((mpfr_ptr, mpfr_srcptr,mpfr_rnd_t)); 1808 __MPFR_DECLSPEC int mpfr_powerof2_raw _MPFR_PROTO ((mpfr_srcptr)); 1809 1810 __MPFR_DECLSPEC int mpfr_pow_general _MPFR_PROTO ((mpfr_ptr, mpfr_srcptr, 1811 mpfr_srcptr, mpfr_rnd_t, int, mpfr_save_expo_t *)); 1812 1813 __MPFR_DECLSPEC void mpfr_setmax _MPFR_PROTO ((mpfr_ptr, mpfr_exp_t)); 1814 __MPFR_DECLSPEC void mpfr_setmin _MPFR_PROTO ((mpfr_ptr, mpfr_exp_t)); 1815 1816 __MPFR_DECLSPEC long mpfr_mpn_exp _MPFR_PROTO ((mp_limb_t *, mpfr_exp_t *, int, 1817 mpfr_exp_t, size_t)); 1818 1819 #ifdef _MPFR_H_HAVE_FILE 1820 __MPFR_DECLSPEC void mpfr_fprint_binary _MPFR_PROTO ((FILE *, mpfr_srcptr)); 1821 #endif 1822 __MPFR_DECLSPEC void mpfr_print_binary _MPFR_PROTO ((mpfr_srcptr)); 1823 __MPFR_DECLSPEC void mpfr_print_mant_binary _MPFR_PROTO ((const char*, 1824 const mp_limb_t*, mpfr_prec_t)); 1825 __MPFR_DECLSPEC void mpfr_set_str_binary _MPFR_PROTO((mpfr_ptr, const char*)); 1826 1827 __MPFR_DECLSPEC int mpfr_round_raw _MPFR_PROTO ((mp_limb_t *, 1828 const mp_limb_t *, mpfr_prec_t, int, mpfr_prec_t, mpfr_rnd_t, int *)); 1829 __MPFR_DECLSPEC int mpfr_round_raw_2 _MPFR_PROTO ((const mp_limb_t *, 1830 mpfr_prec_t, int, mpfr_prec_t, mpfr_rnd_t)); 1831 /* No longer defined (see round_prec.c). 1832 Uncomment if it needs to be defined again. 1833 __MPFR_DECLSPEC int mpfr_round_raw_3 _MPFR_PROTO ((const mp_limb_t *, 1834 mpfr_prec_t, int, mpfr_prec_t, mpfr_rnd_t, int *)); 1835 */ 1836 __MPFR_DECLSPEC int mpfr_round_raw_4 _MPFR_PROTO ((mp_limb_t *, 1837 const mp_limb_t *, mpfr_prec_t, int, mpfr_prec_t, mpfr_rnd_t)); 1838 1839 #define mpfr_round_raw2(xp, xn, neg, r, prec) \ 1840 mpfr_round_raw_2((xp),(xn)*GMP_NUMB_BITS,(neg),(prec),(r)) 1841 1842 __MPFR_DECLSPEC int mpfr_check _MPFR_PROTO ((mpfr_srcptr)); 1843 1844 __MPFR_DECLSPEC int mpfr_sum_sort _MPFR_PROTO ((mpfr_srcptr *const, 1845 unsigned long, mpfr_srcptr *)); 1846 1847 __MPFR_DECLSPEC int mpfr_get_cputime _MPFR_PROTO ((void)); 1848 1849 __MPFR_DECLSPEC void mpfr_nexttozero _MPFR_PROTO ((mpfr_ptr)); 1850 __MPFR_DECLSPEC void mpfr_nexttoinf _MPFR_PROTO ((mpfr_ptr)); 1851 1852 __MPFR_DECLSPEC int mpfr_const_pi_internal _MPFR_PROTO ((mpfr_ptr,mpfr_rnd_t)); 1853 __MPFR_DECLSPEC int mpfr_const_log2_internal _MPFR_PROTO((mpfr_ptr,mpfr_rnd_t)); 1854 __MPFR_DECLSPEC int mpfr_const_euler_internal _MPFR_PROTO((mpfr_ptr, mpfr_rnd_t)); 1855 __MPFR_DECLSPEC int mpfr_const_catalan_internal _MPFR_PROTO((mpfr_ptr, mpfr_rnd_t)); 1856 1857 #if 0 1858 __MPFR_DECLSPEC void mpfr_init_cache _MPFR_PROTO ((mpfr_cache_t, 1859 int(*)(mpfr_ptr,mpfr_rnd_t))); 1860 #endif 1861 __MPFR_DECLSPEC void mpfr_clear_cache _MPFR_PROTO ((mpfr_cache_t)); 1862 __MPFR_DECLSPEC int mpfr_cache _MPFR_PROTO ((mpfr_ptr, mpfr_cache_t, 1863 mpfr_rnd_t)); 1864 1865 __MPFR_DECLSPEC void mpfr_mulhigh_n _MPFR_PROTO ((mpfr_limb_ptr, 1866 mpfr_limb_srcptr, mpfr_limb_srcptr, mp_size_t)); 1867 __MPFR_DECLSPEC void mpfr_mullow_n _MPFR_PROTO ((mpfr_limb_ptr, 1868 mpfr_limb_srcptr, mpfr_limb_srcptr, mp_size_t)); 1869 __MPFR_DECLSPEC void mpfr_sqrhigh_n _MPFR_PROTO ((mpfr_limb_ptr, 1870 mpfr_limb_srcptr, mp_size_t)); 1871 __MPFR_DECLSPEC mp_limb_t mpfr_divhigh_n _MPFR_PROTO ((mpfr_limb_ptr, 1872 mpfr_limb_ptr, mpfr_limb_ptr, mp_size_t)); 1873 1874 __MPFR_DECLSPEC int mpfr_round_p _MPFR_PROTO ((mp_limb_t *, mp_size_t, 1875 mpfr_exp_t, mpfr_prec_t)); 1876 1877 __MPFR_DECLSPEC void mpfr_dump_mant _MPFR_PROTO ((const mp_limb_t *, 1878 mpfr_prec_t, mpfr_prec_t, 1879 mpfr_prec_t)); 1880 1881 __MPFR_DECLSPEC int mpfr_round_near_x _MPFR_PROTO ((mpfr_ptr, mpfr_srcptr, 1882 mpfr_uexp_t, int, 1883 mpfr_rnd_t)); 1884 __MPFR_DECLSPEC void mpfr_abort_prec_max _MPFR_PROTO ((void)) 1885 MPFR_NORETURN_ATTR; 1886 1887 __MPFR_DECLSPEC void mpfr_rand_raw _MPFR_PROTO((mpfr_limb_ptr, gmp_randstate_t, 1888 unsigned long)); 1889 1890 __MPFR_DECLSPEC mpz_t* mpfr_bernoulli_internal _MPFR_PROTO((mpz_t*, 1891 unsigned long)); 1892 1893 __MPFR_DECLSPEC int mpfr_sincos_fast _MPFR_PROTO((mpfr_t, mpfr_t, 1894 mpfr_srcptr, mpfr_rnd_t)); 1895 1896 __MPFR_DECLSPEC double mpfr_scale2 _MPFR_PROTO((double, int)); 1897 1898 __MPFR_DECLSPEC void mpfr_div_ui2 _MPFR_PROTO((mpfr_ptr, mpfr_srcptr, 1899 unsigned long int, unsigned long int, 1900 mpfr_rnd_t)); 1901 1902 __MPFR_DECLSPEC void mpfr_gamma_one_and_two_third _MPFR_PROTO((mpfr_ptr, mpfr_ptr, mpfr_prec_t)); 1903 1904 #if defined (__cplusplus) 1905 } 1906 #endif 1907 1908 #endif 1909