contrib/mpfr/src/mpfr-impl.h

   1 /* Utilities for MPFR developers, not exported.
   2
   3 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc.
   4 Contributed by the AriC 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    https://sympa.inria.fr/sympa/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 /* In the following macro, p is usually a mpfr_prec_t, but this macro
 650    works with other integer types (without integer overflow). Checking
 651    that p >= 1 in debug mode is useful here because this macro can be
 652    used on a computed precision (in particular, this formula does not
 653    work for a degenerate case p = 0, and could give different results
 654    on different platforms). But let us not use an assertion checking
 655    in the MPFR_LAST_LIMB() and MPFR_LIMB_SIZE() macros below to avoid
 656    too much expansion for assertions (in practice, this should be a
 657    problem just when testing MPFR with the --enable-assert configure
 658    option and the -ansi -pedantic-errors gcc compiler flags). */
 659 #define MPFR_PREC2LIMBS(p) \
 660   (MPFR_ASSERTD ((p) >= 1), ((p) - 1) / GMP_NUMB_BITS + 1)
 661
 662 #define MPFR_PREC(x)      ((x)->_mpfr_prec)
 663 #define MPFR_EXP(x)       ((x)->_mpfr_exp)
 664 #define MPFR_MANT(x)      ((x)->_mpfr_d)
 665 #define MPFR_LAST_LIMB(x) ((MPFR_PREC (x) - 1) / GMP_NUMB_BITS)
 666 #define MPFR_LIMB_SIZE(x) (MPFR_LAST_LIMB (x) + 1)
 667
 668
 669 /******************************************************
 670  **************** exponent properties *****************
 671  ******************************************************/
 672
 673 /* Limits of the mpfr_exp_t type (NOT those of valid exponent values).
 674    These macros can be used in preprocessor directives. */
 675 #if   _MPFR_EXP_FORMAT == 1
 676 # define MPFR_EXP_MAX (SHRT_MAX)
 677 # define MPFR_EXP_MIN (SHRT_MIN)
 678 #elif _MPFR_EXP_FORMAT == 2
 679 # define MPFR_EXP_MAX (INT_MAX)
 680 # define MPFR_EXP_MIN (INT_MIN)
 681 #elif _MPFR_EXP_FORMAT == 3
 682 # define MPFR_EXP_MAX (LONG_MAX)
 683 # define MPFR_EXP_MIN (LONG_MIN)
 684 #elif _MPFR_EXP_FORMAT == 4
 685 # define MPFR_EXP_MAX (MPFR_INTMAX_MAX)
 686 # define MPFR_EXP_MIN (MPFR_INTMAX_MIN)
 687 #else
 688 # error "Invalid MPFR Exp format"
 689 #endif
 690
 691 /* Before doing a cast to mpfr_uexp_t, make sure that the value is
 692    nonnegative. */
 693 #define MPFR_UEXP(X) (MPFR_ASSERTD ((X) >= 0), (mpfr_uexp_t) (X))
 694
 695 #if MPFR_EXP_MIN >= LONG_MIN && MPFR_EXP_MAX <= LONG_MAX
 696 typedef long int mpfr_eexp_t;
 697 # define mpfr_get_exp_t(x,r) mpfr_get_si((x),(r))
 698 # define mpfr_set_exp_t(x,e,r) mpfr_set_si((x),(e),(r))
 699 # define MPFR_EXP_FSPEC "l"
 700 #elif defined (_MPFR_H_HAVE_INTMAX_T)
 701 typedef intmax_t mpfr_eexp_t;
 702 # define mpfr_get_exp_t(x,r) mpfr_get_sj((x),(r))
 703 # define mpfr_set_exp_t(x,e,r) mpfr_set_sj((x),(e),(r))
 704 # define MPFR_EXP_FSPEC "j"
 705 #else
 706 # error "Cannot define mpfr_get_exp_t and mpfr_set_exp_t"
 707 #endif
 708
 709 /* Invalid exponent value (to track bugs...) */
 710 #define MPFR_EXP_INVALID \
 711  ((mpfr_exp_t) 1 << (GMP_NUMB_BITS*sizeof(mpfr_exp_t)/sizeof(mp_limb_t)-2))
 712
 713 /* Definition of the exponent limits for MPFR numbers.
 714  * These limits are chosen so that if e is such an exponent, then 2e-1 and
 715  * 2e+1 are representable. This is useful for intermediate computations,
 716  * in particular the multiplication.
 717  */
 718 #undef MPFR_EMIN_MIN
 719 #undef MPFR_EMIN_MAX
 720 #undef MPFR_EMAX_MIN
 721 #undef MPFR_EMAX_MAX
 722 #define MPFR_EMIN_MIN (1-MPFR_EXP_INVALID)
 723 #define MPFR_EMIN_MAX (MPFR_EXP_INVALID-1)
 724 #define MPFR_EMAX_MIN (1-MPFR_EXP_INVALID)
 725 #define MPFR_EMAX_MAX (MPFR_EXP_INVALID-1)
 726
 727 /* Use MPFR_GET_EXP and MPFR_SET_EXP instead of MPFR_EXP directly,
 728    unless when the exponent may be out-of-range, for instance when
 729    setting the exponent before calling mpfr_check_range.
 730    MPFR_EXP_CHECK is defined when WANT_ASSERT is defined, but if you
 731    don't use WANT_ASSERT (for speed reasons), you can still define
 732    MPFR_EXP_CHECK by setting -DMPFR_EXP_CHECK in $CFLAGS. */
 733
 734 #ifdef MPFR_EXP_CHECK
 735 # define MPFR_GET_EXP(x)          (mpfr_get_exp) (x)
 736 # define MPFR_SET_EXP(x, exp)     MPFR_ASSERTN (!mpfr_set_exp ((x), (exp)))
 737 # define MPFR_SET_INVALID_EXP(x)  ((void) (MPFR_EXP (x) = MPFR_EXP_INVALID))
 738 #else
 739 # define MPFR_GET_EXP(x)          MPFR_EXP (x)
 740 # define MPFR_SET_EXP(x, exp)     ((void) (MPFR_EXP (x) = (exp)))
 741 # define MPFR_SET_INVALID_EXP(x)  ((void) 0)
 742 #endif
 743
 744
 745
 746 /******************************************************
 747  ********** Singular Values (NAN, INF, ZERO) **********
 748  ******************************************************/
 749
 750 /* Enum special value of exponent. */
 751 # define MPFR_EXP_ZERO (MPFR_EXP_MIN+1)
 752 # define MPFR_EXP_NAN  (MPFR_EXP_MIN+2)
 753 # define MPFR_EXP_INF  (MPFR_EXP_MIN+3)
 754
 755 #define MPFR_IS_NAN(x)   (MPFR_EXP(x) == MPFR_EXP_NAN)
 756 #define MPFR_SET_NAN(x)  (MPFR_EXP(x) =  MPFR_EXP_NAN)
 757 #define MPFR_IS_INF(x)   (MPFR_EXP(x) == MPFR_EXP_INF)
 758 #define MPFR_SET_INF(x)  (MPFR_EXP(x) =  MPFR_EXP_INF)
 759 #define MPFR_IS_ZERO(x)  (MPFR_EXP(x) == MPFR_EXP_ZERO)
 760 #define MPFR_SET_ZERO(x) (MPFR_EXP(x) =  MPFR_EXP_ZERO)
 761 #define MPFR_NOTZERO(x)  (MPFR_EXP(x) != MPFR_EXP_ZERO)
 762
 763 #define MPFR_IS_FP(x)       (!MPFR_IS_NAN(x) && !MPFR_IS_INF(x))
 764 #define MPFR_IS_SINGULAR(x) (MPFR_EXP(x) <= MPFR_EXP_INF)
 765 #define MPFR_IS_PURE_FP(x)  (!MPFR_IS_SINGULAR(x) && \
 766   (MPFR_ASSERTD ((MPFR_MANT(x)[MPFR_LAST_LIMB(x)]  \
 767                   & MPFR_LIMB_HIGHBIT) != 0), 1))
 768
 769 #define MPFR_ARE_SINGULAR(x,y) \
 770   (MPFR_UNLIKELY(MPFR_IS_SINGULAR(x)) || MPFR_UNLIKELY(MPFR_IS_SINGULAR(y)))
 771
 772 #define MPFR_IS_POWER_OF_2(x) \
 773   (mpfr_cmp_ui_2exp ((x), 1, MPFR_GET_EXP (x) - 1) == 0)
 774
 775
 776 /******************************************************
 777  ********************* Sign Macros ********************
 778  ******************************************************/
 779
 780 #define MPFR_SIGN_POS (1)
 781 #define MPFR_SIGN_NEG (-1)
 782
 783 #define MPFR_IS_STRICTPOS(x)  (MPFR_NOTZERO((x)) && MPFR_SIGN(x) > 0)
 784 #define MPFR_IS_STRICTNEG(x)  (MPFR_NOTZERO((x)) && MPFR_SIGN(x) < 0)
 785
 786 #define MPFR_IS_NEG(x) (MPFR_SIGN(x) < 0)
 787 #define MPFR_IS_POS(x) (MPFR_SIGN(x) > 0)
 788
 789 #define MPFR_SET_POS(x) (MPFR_SIGN(x) = MPFR_SIGN_POS)
 790 #define MPFR_SET_NEG(x) (MPFR_SIGN(x) = MPFR_SIGN_NEG)
 791
 792 #define MPFR_CHANGE_SIGN(x) (MPFR_SIGN(x) = -MPFR_SIGN(x))
 793 #define MPFR_SET_SAME_SIGN(x, y) (MPFR_SIGN(x) = MPFR_SIGN(y))
 794 #define MPFR_SET_OPPOSITE_SIGN(x, y) (MPFR_SIGN(x) = -MPFR_SIGN(y))
 795 #define MPFR_ASSERT_SIGN(s) \
 796  (MPFR_ASSERTD((s) == MPFR_SIGN_POS || (s) == MPFR_SIGN_NEG))
 797 #define MPFR_SET_SIGN(x, s) \
 798   (MPFR_ASSERT_SIGN(s), MPFR_SIGN(x) = s)
 799 #define MPFR_IS_POS_SIGN(s1) (s1 > 0)
 800 #define MPFR_IS_NEG_SIGN(s1) (s1 < 0)
 801 #define MPFR_MULT_SIGN(s1, s2) ((s1) * (s2))
 802 /* Transform a sign to 1 or -1 */
 803 #define MPFR_FROM_SIGN_TO_INT(s) (s)
 804 #define MPFR_INT_SIGN(x) MPFR_FROM_SIGN_TO_INT(MPFR_SIGN(x))
 805
 806
 807
 808 /******************************************************
 809  ***************** Ternary Value Macros ***************
 810  ******************************************************/
 811
 812 /* Special inexact value */
 813 #define MPFR_EVEN_INEX 2
 814
 815 /* Macros for functions returning two inexact values in an 'int' */
 816 #define INEXPOS(y) ((y) == 0 ? 0 : (((y) > 0) ? 1 : 2))
 817 #define INEX(y,z) (INEXPOS(y) | (INEXPOS(z) << 2))
 818
 819 /* When returning the ternary inexact value, ALWAYS use one of the
 820    following two macros, unless the flag comes from another function
 821    returning the ternary inexact value */
 822 #define MPFR_RET(I) return \
 823   (I) ? ((__gmpfr_flags |= MPFR_FLAGS_INEXACT), (I)) : 0
 824 #define MPFR_RET_NAN return (__gmpfr_flags |= MPFR_FLAGS_NAN), 0
 825
 826 #define MPFR_SET_ERANGE() (__gmpfr_flags |= MPFR_FLAGS_ERANGE)
 827
 828 #define SIGN(I) ((I) < 0 ? -1 : (I) > 0)
 829 #define SAME_SIGN(I1,I2) (SIGN (I1) == SIGN (I2))
 830
 831
 832
 833 /******************************************************
 834  ************** Rounding mode macros  *****************
 835  ******************************************************/
 836
 837 /* MPFR_RND_MAX gives the number of supported rounding modes by all functions.
 838  * Once faithful rounding is implemented, MPFR_RNDA should be changed
 839  * to MPFR_RNDF. But this will also require more changes in the tests.
 840  */
 841 #define MPFR_RND_MAX ((mpfr_rnd_t)((MPFR_RNDA)+1))
 842
 843 /* We want to test this :
 844  *  (rnd == MPFR_RNDU && test) || (rnd == RNDD && !test)
 845  * ie it transforms RNDU or RNDD to Away or Zero according to the sign */
 846 #define MPFR_IS_RNDUTEST_OR_RNDDNOTTEST(rnd, test) \
 847   (((rnd) + (test)) == MPFR_RNDD)
 848
 849 /* We want to test if rnd = Zero, or Away.
 850    'test' is 1 if negative, and 0 if positive. */
 851 #define MPFR_IS_LIKE_RNDZ(rnd, test) \
 852   ((rnd==MPFR_RNDZ) || MPFR_IS_RNDUTEST_OR_RNDDNOTTEST (rnd, test))
 853
 854 #define MPFR_IS_LIKE_RNDU(rnd, sign) \
 855   ((rnd==MPFR_RNDU) || (rnd==MPFR_RNDZ && sign<0) || (rnd==MPFR_RNDA && sign>0))
 856
 857 #define MPFR_IS_LIKE_RNDD(rnd, sign) \
 858   ((rnd==MPFR_RNDD) || (rnd==MPFR_RNDZ && sign>0) || (rnd==MPFR_RNDA && sign<0))
 859
 860 /* Invert a rounding mode, RNDZ and RNDA are unchanged */
 861 #define MPFR_INVERT_RND(rnd) ((rnd == MPFR_RNDU) ? MPFR_RNDD : \
 862                              ((rnd == MPFR_RNDD) ? MPFR_RNDU : rnd))
 863
 864 /* Transform RNDU and RNDD to RNDZ according to test */
 865 #define MPFR_UPDATE_RND_MODE(rnd, test)                            \
 866   do {                                                             \
 867     if (MPFR_UNLIKELY(MPFR_IS_RNDUTEST_OR_RNDDNOTTEST(rnd, test))) \
 868       rnd = MPFR_RNDZ;                                              \
 869   } while (0)
 870
 871 /* Transform RNDU and RNDD to RNDZ or RNDA according to sign,
 872    leave the other modes unchanged */
 873 #define MPFR_UPDATE2_RND_MODE(rnd, sign)        \
 874   do {                                          \
 875   if (rnd == MPFR_RNDU)                          \
 876     rnd = (sign > 0) ? MPFR_RNDA : MPFR_RNDZ;     \
 877   else if (rnd == MPFR_RNDD)                     \
 878     rnd = (sign < 0) ? MPFR_RNDA : MPFR_RNDZ;     \
 879   } while (0)
 880
 881
 882 /******************************************************
 883  ******************* Limb Macros **********************
 884  ******************************************************/
 885
 886  /* Definition of MPFR_LIMB_HIGHBIT */
 887 #if defined(GMP_LIMB_HIGHBIT)
 888 # define MPFR_LIMB_HIGHBIT GMP_LIMB_HIGHBIT
 889 #elif defined(MP_LIMB_T_HIGHBIT)
 890 # define MPFR_LIMB_HIGHBIT MP_LIMB_T_HIGHBIT
 891 #else
 892 # error "Neither GMP_LIMB_HIGHBIT nor MP_LIMB_T_HIGHBIT defined in GMP"
 893 #endif
 894
 895 /* Mask to get the Most Significant Bit of a limb */
 896 #define MPFR_LIMB_MSB(l) ((l)&MPFR_LIMB_HIGHBIT)
 897
 898 /* Definition of MPFR_LIMB_ONE & MPFR_LIMB_ZERO */
 899 #ifdef CNST_LIMB
 900 # define MPFR_LIMB_ONE  CNST_LIMB(1)
 901 # define MPFR_LIMB_ZERO CNST_LIMB(0)
 902 #else
 903 # define MPFR_LIMB_ONE  ((mp_limb_t) 1L)
 904 # define MPFR_LIMB_ZERO ((mp_limb_t) 0L)
 905 #endif
 906
 907 /* Mask for the low 's' bits of a limb */
 908 #define MPFR_LIMB_MASK(s) ((MPFR_LIMB_ONE<<(s))-MPFR_LIMB_ONE)
 909
 910
 911
 912 /******************************************************
 913  ********************** Memory ************************
 914  ******************************************************/
 915
 916 /* Heap Memory gestion */
 917 typedef union { mp_size_t s; mp_limb_t l; } mpfr_size_limb_t;
 918 #define MPFR_GET_ALLOC_SIZE(x) \
 919  ( ((mp_size_t*) MPFR_MANT(x))[-1] + 0)
 920 #define MPFR_SET_ALLOC_SIZE(x, n) \
 921  ( ((mp_size_t*) MPFR_MANT(x))[-1] = n)
 922 #define MPFR_MALLOC_SIZE(s) \
 923   ( sizeof(mpfr_size_limb_t) + BYTES_PER_MP_LIMB * ((size_t) s) )
 924 #define MPFR_SET_MANT_PTR(x,p) \
 925    (MPFR_MANT(x) = (mp_limb_t*) ((mpfr_size_limb_t*) p + 1))
 926 #define MPFR_GET_REAL_PTR(x) \
 927    ((mp_limb_t*) ((mpfr_size_limb_t*) MPFR_MANT(x) - 1))
 928
 929 /* Temporary memory gestion */
 930 #ifndef TMP_SALLOC
 931 /* GMP 4.1.x or below or internals */
 932 #define MPFR_TMP_DECL TMP_DECL
 933 #define MPFR_TMP_MARK TMP_MARK
 934 #define MPFR_TMP_ALLOC TMP_ALLOC
 935 #define MPFR_TMP_FREE TMP_FREE
 936 #else
 937 #define MPFR_TMP_DECL(x) TMP_DECL
 938 #define MPFR_TMP_MARK(x) TMP_MARK
 939 #define MPFR_TMP_ALLOC(s) TMP_ALLOC(s)
 940 #define MPFR_TMP_FREE(x) TMP_FREE
 941 #endif
 942
 943 /* This code is experimental: don't use it */
 944 #ifdef MPFR_USE_OWN_MPFR_TMP_ALLOC
 945 extern unsigned char *mpfr_stack;
 946 #undef MPFR_TMP_DECL
 947 #undef MPFR_TMP_MARK
 948 #undef MPFR_TMP_ALLOC
 949 #undef MPFR_TMP_FREE
 950 #define MPFR_TMP_DECL(_x) unsigned char *(_x)
 951 #define MPFR_TMP_MARK(_x) ((_x) = mpfr_stack)
 952 #define MPFR_TMP_ALLOC(_s) (mpfr_stack += (_s), mpfr_stack - (_s))
 953 #define MPFR_TMP_FREE(_x) (mpfr_stack = (_x))
 954 #endif
 955
 956 #define MPFR_TMP_LIMBS_ALLOC(N) \
 957   ((mp_limb_t *) MPFR_TMP_ALLOC ((size_t) (N) * BYTES_PER_MP_LIMB))
 958
 959 /* temporary allocate 1 limb at xp, and initialize mpfr variable x */
 960 /* The temporary var doesn't have any size field, but it doesn't matter
 961  * since only functions dealing with the Heap care about it */
 962 #define MPFR_TMP_INIT1(xp, x, p)                                     \
 963  ( MPFR_PREC(x) = (p),                                               \
 964    MPFR_MANT(x) = (xp),                                              \
 965    MPFR_SET_POS(x),                                                  \
 966    MPFR_SET_INVALID_EXP(x))
 967
 968 #define MPFR_TMP_INIT(xp, x, p, s)                                   \
 969   (xp = MPFR_TMP_LIMBS_ALLOC(s),                                     \
 970    MPFR_TMP_INIT1(xp, x, p))
 971
 972 #define MPFR_TMP_INIT_ABS(d, s)                                      \
 973  ( MPFR_PREC(d) = MPFR_PREC(s),                                      \
 974    MPFR_MANT(d) = MPFR_MANT(s),                                      \
 975    MPFR_SET_POS(d),                                                  \
 976    MPFR_EXP(d)  = MPFR_EXP(s))
 977
 978
 979
 980 /******************************************************
 981  *****************  Cache macros **********************
 982  ******************************************************/
 983
 984 #define mpfr_const_pi(_d,_r)    mpfr_cache(_d, __gmpfr_cache_const_pi,_r)
 985 #define mpfr_const_log2(_d,_r)  mpfr_cache(_d, __gmpfr_cache_const_log2, _r)
 986 #define mpfr_const_euler(_d,_r) mpfr_cache(_d, __gmpfr_cache_const_euler, _r)
 987 #define mpfr_const_catalan(_d,_r) mpfr_cache(_d,__gmpfr_cache_const_catalan,_r)
 988
 989 #define MPFR_DECL_INIT_CACHE(_cache,_func)                           \
 990  mpfr_cache_t MPFR_THREAD_ATTR _cache =                              \
 991     {{{{0,MPFR_SIGN_POS,0,(mp_limb_t*)0}},0,_func}}
 992
 993
 994
 995 /******************************************************
 996  *******************  Threshold ***********************
 997  ******************************************************/
 998
 999 #include "mparam.h"
1000
1001 /******************************************************
1002  *****************  Useful macros *********************
1003  ******************************************************/
1004
1005 /* Theses macros help the compiler to determine if a test is
1006    likely or unlikely. The !! is necessary in case x is larger
1007    than a long. */
1008 #if __MPFR_GNUC(3,0) || __MPFR_ICC(8,1,0)
1009 # define MPFR_LIKELY(x) (__builtin_expect(!!(x),1))
1010 # define MPFR_UNLIKELY(x) (__builtin_expect(!!(x),0))
1011 #else
1012 # define MPFR_LIKELY(x) (x)
1013 # define MPFR_UNLIKELY(x) (x)
1014 #endif
1015
1016 /* Declare that some variable is initialized before being used (without a
1017    dummy initialization) in order to avoid some compiler warnings. Use the
1018    VAR = VAR trick (see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=36296)
1019    only with gcc as this is undefined behavior, and we don't know what
1020    other compilers do (they may also be smarter). This trick could be
1021    disabled with future gcc versions. */
1022 #if defined(__GNUC__)
1023 # define INITIALIZED(VAR) VAR = VAR
1024 #else
1025 # define INITIALIZED(VAR) VAR
1026 #endif
1027
1028 /* Ceil log 2: If GCC, uses a GCC extension, otherwise calls a function */
1029 /* Warning:
1030  *   Needs to define MPFR_NEED_LONGLONG.
1031  *   Computes ceil(log2(x)) only for x integer (unsigned long)
1032  *   Undefined if x is 0 */
1033 #if __MPFR_GNUC(2,95) || __MPFR_ICC(8,1,0)
1034 # define MPFR_INT_CEIL_LOG2(x)                            \
1035     (MPFR_UNLIKELY ((x) == 1) ? 0 :                       \
1036      __extension__ ({ int _b; mp_limb_t _limb;            \
1037       MPFR_ASSERTN ((x) > 1);                             \
1038       _limb = (x) - 1;                                    \
1039       MPFR_ASSERTN (_limb == (x) - 1);                    \
1040       count_leading_zeros (_b, _limb);                    \
1041       (GMP_NUMB_BITS - _b); }))
1042 #else
1043 # define MPFR_INT_CEIL_LOG2(x) (__gmpfr_int_ceil_log2(x))
1044 #endif
1045
1046 /* Add two integers with overflow handling */
1047 /* Example: MPFR_SADD_OVERFLOW (c, a, b, long, unsigned long,
1048  *                              LONG_MIN, LONG_MAX,
1049  *                              goto overflow, goto underflow); */
1050 #define MPFR_UADD_OVERFLOW(c,a,b,ACTION_IF_OVERFLOW)                  \
1051  do {                                                                 \
1052   (c) = (a) + (b);                                                    \
1053   if ((c) < (a)) ACTION_IF_OVERFLOW;                                  \
1054  } while (0)
1055
1056 #define MPFR_SADD_OVERFLOW(c,a,b,STYPE,UTYPE,MIN,MAX,ACTION_IF_POS_OVERFLOW,ACTION_IF_NEG_OVERFLOW) \
1057   do {                                                                \
1058   if ((a) >= 0 && (b) >= 0) {                                         \
1059          UTYPE uc,ua,ub;                                              \
1060          ua = (UTYPE) (a); ub = (UTYPE) (b);                          \
1061          MPFR_UADD_OVERFLOW (uc, ua, ub, ACTION_IF_POS_OVERFLOW);     \
1062          if (uc > (UTYPE)(MAX)) ACTION_IF_POS_OVERFLOW;               \
1063          else (c) = (STYPE) uc;                                       \
1064   } else if ((a) < 0 && (b) < 0) {                                    \
1065          UTYPE uc,ua,ub;                                              \
1066          ua = -(UTYPE) (a); ub = -(UTYPE) (b);                        \
1067          MPFR_UADD_OVERFLOW (uc, ua, ub, ACTION_IF_NEG_OVERFLOW);     \
1068          if (uc >= -(UTYPE)(MIN) || uc > (UTYPE)(MAX)) {              \
1069            if (uc ==  -(UTYPE)(MIN)) (c) = (MIN);                     \
1070            else  ACTION_IF_NEG_OVERFLOW; }                            \
1071          else (c) = -(STYPE) uc;                                      \
1072   } else (c) = (a) + (b);                                             \
1073  } while (0)
1074
1075
1076 /* Set a number to 1 (Fast) - It doesn't check if 1 is in the exponent range */
1077 #define MPFR_SET_ONE(x)                                               \
1078 do {                                                                  \
1079   mp_size_t _size = MPFR_LAST_LIMB(x);                                \
1080   MPFR_SET_POS(x);                                                    \
1081   MPFR_EXP(x) = 1;                                                    \
1082   MPN_ZERO ( MPFR_MANT(x), _size);                                    \
1083   MPFR_MANT(x)[_size] = MPFR_LIMB_HIGHBIT;                            \
1084 } while (0)
1085
1086 /* Compute s = (-a) % GMP_NUMB_BITS as unsigned */
1087 #define MPFR_UNSIGNED_MINUS_MODULO(s, a)                              \
1088   do                                                                  \
1089     {                                                                 \
1090       if (IS_POW2 (GMP_NUMB_BITS))                                    \
1091         (s) = (- (unsigned int) (a)) % GMP_NUMB_BITS;                 \
1092       else                                                            \
1093         {                                                             \
1094           (s) = (a) % GMP_NUMB_BITS;                                  \
1095           if ((s) != 0)                                               \
1096             (s) = GMP_NUMB_BITS - (s);                                \
1097         }                                                             \
1098       MPFR_ASSERTD ((s) >= 0 && (s) < GMP_NUMB_BITS);                 \
1099     }                                                                 \
1100   while (0)
1101
1102 /* Use it only for debug reasons */
1103 /*   MPFR_TRACE (operation) : execute operation iff DEBUG flag is set */
1104 /*   MPFR_DUMP (x) : print x (a mpfr_t) on stdout */
1105 #ifdef DEBUG
1106 # define MPFR_TRACE(x) x
1107 #else
1108 # define MPFR_TRACE(x) (void) 0
1109 #endif
1110 #define MPFR_DUMP(x) ( printf(#x"="), mpfr_dump(x) )
1111
1112 /* Test if X (positive) is a power of 2 */
1113 #define IS_POW2(X) (((X) & ((X) - 1)) == 0)
1114 #define NOT_POW2(X) (((X) & ((X) - 1)) != 0)
1115
1116 /* Safe absolute value (to avoid possible integer overflow) */
1117 /* type is the target (unsigned) type */
1118 #define SAFE_ABS(type,x) ((x) >= 0 ? (type)(x) : -(type)(x))
1119
1120 #define mpfr_get_d1(x) mpfr_get_d(x,__gmpfr_default_rounding_mode)
1121
1122 /* Store in r the size in bits of the mpz_t z */
1123 #define MPFR_MPZ_SIZEINBASE2(r, z)              \
1124   do {                                          \
1125    int _cnt;                                    \
1126    mp_size_t _size;                             \
1127    MPFR_ASSERTD (mpz_sgn (z) != 0);             \
1128    _size = ABSIZ(z);                            \
1129    count_leading_zeros (_cnt, PTR(z)[_size-1]); \
1130    (r) = _size * GMP_NUMB_BITS - _cnt;       \
1131   } while (0)
1132
1133 /* Needs <locale.h> */
1134 #ifdef HAVE_LOCALE_H
1135 #include <locale.h>
1136 /* Warning! In case of signed char, the value of MPFR_DECIMAL_POINT may
1137    be negative (the ISO C99 does not seem to forbid negative values). */
1138 #define MPFR_DECIMAL_POINT (localeconv()->decimal_point[0])
1139 #define MPFR_THOUSANDS_SEPARATOR (localeconv()->thousands_sep[0])
1140 #else
1141 #define MPFR_DECIMAL_POINT ((char) '.')
1142 #define MPFR_THOUSANDS_SEPARATOR ('\0')
1143 #endif
1144
1145
1146 /* Set y to s*significand(x)*2^e, for example MPFR_ALIAS(y,x,1,MPFR_EXP(x))
1147    sets y to |x|, and MPFR_ALIAS(y,x,MPFR_SIGN(x),0) sets y to x*2^f such
1148    that 1/2 <= |y| < 1. Does not check y is in the valid exponent range.
1149    WARNING! x and y share the same mantissa. So, some operations are
1150    not valid if x has been provided via an argument, e.g., trying to
1151    modify the mantissa of y, even temporarily, or calling mpfr_clear on y.
1152 */
1153 #define MPFR_ALIAS(y,x,s,e)                     \
1154   do                                            \
1155     {                                           \
1156       MPFR_PREC(y) = MPFR_PREC(x);              \
1157       MPFR_SIGN(y) = (s);                       \
1158       MPFR_EXP(y) = (e);                        \
1159       MPFR_MANT(y) = MPFR_MANT(x);              \
1160     } while (0)
1161
1162
1163 /******************************************************
1164  **************  Save exponent macros  ****************
1165  ******************************************************/
1166
1167 /* See README.dev for details on how to use the macros.
1168    They are used to set the exponent range to the maximum
1169    temporarily */
1170
1171 typedef struct {
1172   unsigned int saved_flags;
1173   mpfr_exp_t saved_emin;
1174   mpfr_exp_t saved_emax;
1175 } mpfr_save_expo_t;
1176
1177 /* Minimum and maximum exponents of the extended exponent range. */
1178 #define MPFR_EXT_EMIN MPFR_EMIN_MIN
1179 #define MPFR_EXT_EMAX MPFR_EMAX_MAX
1180
1181 #define MPFR_SAVE_EXPO_DECL(x) mpfr_save_expo_t x
1182 #define MPFR_SAVE_EXPO_MARK(x)     \
1183  ((x).saved_flags = __gmpfr_flags, \
1184   (x).saved_emin = __gmpfr_emin,   \
1185   (x).saved_emax = __gmpfr_emax,   \
1186   __gmpfr_emin = MPFR_EXT_EMIN,    \
1187   __gmpfr_emax = MPFR_EXT_EMAX)
1188 #define MPFR_SAVE_EXPO_FREE(x)     \
1189  (__gmpfr_flags = (x).saved_flags, \
1190   __gmpfr_emin = (x).saved_emin,   \
1191   __gmpfr_emax = (x).saved_emax)
1192 #define MPFR_SAVE_EXPO_UPDATE_FLAGS(x, flags)  \
1193   (x).saved_flags |= (flags)
1194
1195 /* Speed up final checking */
1196 #define mpfr_check_range(x,t,r) \
1197  (MPFR_LIKELY (MPFR_EXP (x) >= __gmpfr_emin && MPFR_EXP (x) <= __gmpfr_emax) \
1198   ? ((t) ? (__gmpfr_flags |= MPFR_FLAGS_INEXACT, (t)) : 0)                   \
1199   : mpfr_check_range(x,t,r))
1200
1201
1202 /******************************************************
1203  *****************  Inline Rounding *******************
1204  ******************************************************/
1205
1206 /*
1207  * Note: due to the labels, one cannot use a macro MPFR_RNDRAW* more than
1208  * once in a function (otherwise these labels would not be unique).
1209  */
1210
1211 /*
1212  * Round mantissa (srcp, sprec) to mpfr_t dest using rounding mode rnd
1213  * assuming dest's sign is sign.
1214  * In rounding to nearest mode, execute MIDDLE_HANDLER when the value
1215  * is the middle of two consecutive numbers in dest precision.
1216  * Execute OVERFLOW_HANDLER in case of overflow when rounding.
1217  */
1218 #define MPFR_RNDRAW_GEN(inexact, dest, srcp, sprec, rnd, sign,              \
1219                         MIDDLE_HANDLER, OVERFLOW_HANDLER)                   \
1220   do {                                                                      \
1221     mp_size_t _dests, _srcs;                                                \
1222     mp_limb_t *_destp;                                                      \
1223     mpfr_prec_t _destprec, _srcprec;                                        \
1224                                                                             \
1225     /* Check Trivial Case when Dest Mantissa has more bits than source */   \
1226     _srcprec = (sprec);                                                     \
1227     _destprec = MPFR_PREC (dest);                                           \
1228     _destp = MPFR_MANT (dest);                                              \
1229     if (MPFR_UNLIKELY (_destprec >= _srcprec))                              \
1230       {                                                                     \
1231         _srcs  = MPFR_PREC2LIMBS (_srcprec);                                \
1232         _dests = MPFR_PREC2LIMBS (_destprec) - _srcs;                       \
1233         MPN_COPY (_destp + _dests, srcp, _srcs);                            \
1234         MPN_ZERO (_destp, _dests);                                          \
1235         inexact = 0;                                                        \
1236       }                                                                     \
1237     else                                                                    \
1238       {                                                                     \
1239         /* Non trivial case: rounding needed */                             \
1240         mpfr_prec_t _sh;                                                    \
1241         mp_limb_t *_sp;                                                     \
1242         mp_limb_t _rb, _sb, _ulp;                                           \
1243                                                                             \
1244         /* Compute Position and shift */                                    \
1245         _srcs  = MPFR_PREC2LIMBS (_srcprec);                                \
1246         _dests = MPFR_PREC2LIMBS (_destprec);                               \
1247         MPFR_UNSIGNED_MINUS_MODULO (_sh, _destprec);                        \
1248         _sp = (srcp) + _srcs - _dests;                                      \
1249                                                                             \
1250         /* General case when prec % GMP_NUMB_BITS != 0 */                   \
1251         if (MPFR_LIKELY (_sh != 0))                                         \
1252           {                                                                 \
1253             mp_limb_t _mask;                                                \
1254             /* Compute Rounding Bit and Sticky Bit */                       \
1255             /* Note: in directed rounding modes, if the rounding bit */     \
1256             /* is 1, the behavior does not depend on the sticky bit; */     \
1257             /* thus we will not try to compute it in this case (this */     \
1258             /* can be much faster and avoids to read uninitialized   */     \
1259             /* data in the current mpfr_mul implementation). We just */     \
1260             /* make sure that _sb is initialized.                    */     \
1261             _mask = MPFR_LIMB_ONE << (_sh - 1);                             \
1262             _rb = _sp[0] & _mask;                                           \
1263             _sb = _sp[0] & (_mask - 1);                                     \
1264             if (MPFR_UNLIKELY (_sb == 0) &&                                 \
1265                 ((rnd) == MPFR_RNDN || _rb == 0))                           \
1266               { /* TODO: Improve it */                                      \
1267                 mp_limb_t *_tmp;                                            \
1268                 mp_size_t _n;                                               \
1269                 for (_tmp = _sp, _n = _srcs - _dests ;                      \
1270                      _n != 0 && _sb == 0 ; _n--)                            \
1271                   _sb = *--_tmp;                                            \
1272               }                                                             \
1273             _ulp = 2 * _mask;                                               \
1274           }                                                                 \
1275         else /* _sh == 0 */                                                 \
1276           {                                                                 \
1277             MPFR_ASSERTD (_dests < _srcs);                                  \
1278             /* Compute Rounding Bit and Sticky Bit - see note above */      \
1279             _rb = _sp[-1] & MPFR_LIMB_HIGHBIT;                              \
1280             _sb = _sp[-1] & (MPFR_LIMB_HIGHBIT-1);                          \
1281             if (MPFR_UNLIKELY (_sb == 0) &&                                 \
1282                 ((rnd) == MPFR_RNDN || _rb == 0))                           \
1283               {                                                             \
1284                 mp_limb_t *_tmp;                                            \
1285                 mp_size_t _n;                                               \
1286                 for (_tmp = _sp - 1, _n = _srcs - _dests - 1 ;              \
1287                      _n != 0 && _sb == 0 ; _n--)                            \
1288                   _sb = *--_tmp;                                            \
1289               }                                                             \
1290             _ulp = MPFR_LIMB_ONE;                                           \
1291           }                                                                 \
1292         /* Rounding */                                                      \
1293         if (MPFR_LIKELY (rnd == MPFR_RNDN))                                 \
1294           {                                                                 \
1295             if (_rb == 0)                                                   \
1296               {                                                             \
1297               trunc:                                                        \
1298                 inexact = MPFR_LIKELY ((_sb | _rb) != 0) ? -sign : 0;       \
1299               trunc_doit:                                                   \
1300                 MPN_COPY (_destp, _sp, _dests);                             \
1301                 _destp[0] &= ~(_ulp - 1);                                   \
1302               }                                                             \
1303             else if (MPFR_UNLIKELY (_sb == 0))                              \
1304               { /* Middle of two consecutive representable numbers */       \
1305                 MIDDLE_HANDLER;                                             \
1306               }                                                             \
1307             else                                                            \
1308               {                                                             \
1309                 if (0)                                                      \
1310                   goto addoneulp_doit; /* dummy code to avoid warning */    \
1311               addoneulp:                                                    \
1312                 inexact = sign;                                             \
1313               addoneulp_doit:                                               \
1314                 if (MPFR_UNLIKELY (mpn_add_1 (_destp, _sp, _dests, _ulp)))  \
1315                   {                                                         \
1316                     _destp[_dests - 1] = MPFR_LIMB_HIGHBIT;                 \
1317                     OVERFLOW_HANDLER;                                       \
1318                   }                                                         \
1319                 _destp[0] &= ~(_ulp - 1);                                   \
1320               }                                                             \
1321           }                                                                 \
1322         else                                                                \
1323           { /* Directed rounding mode */                                    \
1324             if (MPFR_LIKELY (MPFR_IS_LIKE_RNDZ (rnd,                        \
1325                                                 MPFR_IS_NEG_SIGN (sign))))  \
1326               goto trunc;                                                   \
1327              else if (MPFR_UNLIKELY ((_sb | _rb) == 0))                     \
1328                {                                                            \
1329                  inexact = 0;                                               \
1330                  goto trunc_doit;                                           \
1331                }                                                            \
1332              else                                                           \
1333               goto addoneulp;                                               \
1334           }                                                                 \
1335       }                                                                     \
1336   } while (0)
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  */
1343 #define MPFR_RNDRAW(inexact, dest, srcp, sprec, rnd, sign, OVERFLOW_HANDLER) \
1344    MPFR_RNDRAW_GEN (inexact, dest, srcp, sprec, rnd, sign,                   \
1345      if ((_sp[0] & _ulp) == 0)                                               \
1346        {                                                                     \
1347          inexact = -sign;                                                    \
1348          goto trunc_doit;                                                    \
1349        }                                                                     \
1350      else                                                                    \
1351        goto addoneulp;                                                       \
1352      , OVERFLOW_HANDLER)
1353
1354 /*
1355  * Round mantissa (srcp, sprec) to mpfr_t dest using rounding mode rnd
1356  * assuming dest's sign is sign.
1357  * Execute OVERFLOW_HANDLER in case of overflow when rounding.
1358  * Set inexact to +/- MPFR_EVEN_INEX in case of even rounding.
1359  */
1360 #define MPFR_RNDRAW_EVEN(inexact, dest, srcp, sprec, rnd, sign, \
1361                          OVERFLOW_HANDLER)                      \
1362    MPFR_RNDRAW_GEN (inexact, dest, srcp, sprec, rnd, sign,      \
1363      if ((_sp[0] & _ulp) == 0)                                  \
1364        {                                                        \
1365          inexact = -MPFR_EVEN_INEX * sign;                      \
1366          goto trunc_doit;                                       \
1367        }                                                        \
1368      else                                                       \
1369        {                                                        \
1370          inexact = MPFR_EVEN_INEX * sign;                       \
1371          goto addoneulp_doit;                                   \
1372        }                                                        \
1373      , OVERFLOW_HANDLER)
1374
1375 /* Return TRUE if b is non singular and we can round it to precision 'prec'
1376    and determine the ternary value, with rounding mode 'rnd', and with
1377    error at most 'error' */
1378 #define MPFR_CAN_ROUND(b,err,prec,rnd)                                       \
1379  (!MPFR_IS_SINGULAR (b) && mpfr_round_p (MPFR_MANT (b), MPFR_LIMB_SIZE (b),  \
1380                                          (err), (prec) + ((rnd)==MPFR_RNDN)))
1381
1382 /* Copy the sign and the significand, and handle the exponent in exp. */
1383 #define MPFR_SETRAW(inexact,dest,src,exp,rnd)                           \
1384   if (MPFR_UNLIKELY (dest != src))                                      \
1385     {                                                                   \
1386       MPFR_SET_SIGN (dest, MPFR_SIGN (src));                            \
1387       if (MPFR_LIKELY (MPFR_PREC (dest) == MPFR_PREC (src)))            \
1388         {                                                               \
1389           MPN_COPY (MPFR_MANT (dest), MPFR_MANT (src),                  \
1390                     MPFR_LIMB_SIZE (src));                              \
1391           inexact = 0;                                                  \
1392         }                                                               \
1393       else                                                              \
1394         {                                                               \
1395           MPFR_RNDRAW (inexact, dest, MPFR_MANT (src), MPFR_PREC (src), \
1396                        rnd, MPFR_SIGN (src), exp++);                    \
1397         }                                                               \
1398     }                                                                   \
1399   else                                                                  \
1400     inexact = 0;
1401
1402 /* TODO: fix this description (see round_near_x.c). */
1403 /* Assuming that the function has a Taylor expansion which looks like:
1404     y=o(f(x)) = o(v + g(x)) with |g(x)| <= 2^(EXP(v)-err)
1405    we can quickly set y to v if x is small (ie err > prec(y)+1) in most
1406    cases. It assumes that f(x) is not representable exactly as a FP number.
1407    v must not be a singular value (NAN, INF or ZERO); usual values are
1408    v=1 or v=x.
1409
1410    y is the destination (a mpfr_t), v the value to set (a mpfr_t),
1411    err1+err2 with err2 <= 3 the error term (mpfr_exp_t's), dir (an int) is
1412    the direction of the committed error (if dir = 0, it rounds toward 0,
1413    if dir=1, it rounds away from 0), rnd the rounding mode.
1414
1415    It returns from the function a ternary value in case of success.
1416    If you want to free something, you must fill the "extra" field
1417    in consequences, otherwise put nothing in it.
1418
1419    The test is less restrictive than necessary, but the function
1420    will finish the check itself.
1421
1422    Note: err1 + err2 is allowed to overflow as mpfr_exp_t, but it must give
1423    its real value as mpfr_uexp_t.
1424 */
1425 #define MPFR_FAST_COMPUTE_IF_SMALL_INPUT(y,v,err1,err2,dir,rnd,extra)   \
1426   do {                                                                  \
1427     mpfr_ptr _y = (y);                                                  \
1428     mpfr_exp_t _err1 = (err1);                                          \
1429     mpfr_exp_t _err2 = (err2);                                          \
1430     if (_err1 > 0)                                                      \
1431       {                                                                 \
1432         mpfr_uexp_t _err = (mpfr_uexp_t) _err1 + _err2;                 \
1433         if (MPFR_UNLIKELY (_err > MPFR_PREC (_y) + 1))                  \
1434           {                                                             \
1435             int _inexact = mpfr_round_near_x (_y,(v),_err,(dir),(rnd)); \
1436             if (_inexact != 0)                                          \
1437               {                                                         \
1438                 extra;                                                  \
1439                 return _inexact;                                        \
1440               }                                                         \
1441           }                                                             \
1442       }                                                                 \
1443   } while (0)
1444
1445 /* Variant, to be called somewhere after MPFR_SAVE_EXPO_MARK. This variant
1446    is needed when there are some computations before or when some non-zero
1447    real constant is used, such as __gmpfr_one for mpfr_cos. */
1448 #define MPFR_SMALL_INPUT_AFTER_SAVE_EXPO(y,v,err1,err2,dir,rnd,expo,extra) \
1449   do {                                                                  \
1450     mpfr_ptr _y = (y);                                                  \
1451     mpfr_exp_t _err1 = (err1);                                          \
1452     mpfr_exp_t _err2 = (err2);                                          \
1453     if (_err1 > 0)                                                      \
1454       {                                                                 \
1455         mpfr_uexp_t _err = (mpfr_uexp_t) _err1 + _err2;                 \
1456         if (MPFR_UNLIKELY (_err > MPFR_PREC (_y) + 1))                  \
1457           {                                                             \
1458             int _inexact;                                               \
1459             mpfr_clear_flags ();                                        \
1460             _inexact = mpfr_round_near_x (_y,(v),_err,(dir),(rnd));     \
1461             if (_inexact != 0)                                          \
1462               {                                                         \
1463                 extra;                                                  \
1464                 MPFR_SAVE_EXPO_UPDATE_FLAGS (expo, __gmpfr_flags);      \
1465                 MPFR_SAVE_EXPO_FREE (expo);                             \
1466                 return mpfr_check_range (_y, _inexact, (rnd));          \
1467               }                                                         \
1468           }                                                             \
1469       }                                                                 \
1470   } while (0)
1471
1472 /******************************************************
1473  ***************  Ziv Loop Macro  *********************
1474  ******************************************************/
1475
1476 #ifndef MPFR_USE_LOGGING
1477
1478 #define MPFR_ZIV_DECL(_x) mpfr_prec_t _x
1479 #define MPFR_ZIV_INIT(_x, _p) (_x) = GMP_NUMB_BITS
1480 #define MPFR_ZIV_NEXT(_x, _p) ((_p) += (_x), (_x) = (_p)/2)
1481 #define MPFR_ZIV_FREE(x)
1482
1483 #else
1484
1485 /* The following test on glibc is there mainly for Darwin (Mac OS X), to
1486    obtain a better error message. The real test should have been a test
1487    concerning nested functions in gcc, which are disabled by default on
1488    Darwin; but it is not possible to do that without a configure test. */
1489 # if defined (__cplusplus) || !(__MPFR_GNUC(3,0) && __MPFR_GLIBC(2,0))
1490 #  error "Logging not supported (needs gcc >= 3.0 and GNU C Library >= 2.0)."
1491 # endif
1492
1493 /* Use LOGGING */
1494
1495 /* Note: the mpfr_log_level >= 0 below avoids to take into account
1496    Ziv loops used by the MPFR functions called by the mpfr_fprintf
1497    in LOG_PRINT. */
1498
1499 #define MPFR_ZIV_DECL(_x)                                               \
1500   mpfr_prec_t _x;                                                       \
1501   int _x ## _cpt = 1;                                                   \
1502   static unsigned long  _x ## _loop = 0, _x ## _bad = 0;                \
1503   static const char *_x ## _fname = __func__;                           \
1504   auto void __attribute__ ((destructor)) x ## _f  (void);               \
1505   void __attribute__ ((destructor)) x ## _f  (void) {                   \
1506     if (_x ## _loop != 0 && (MPFR_LOG_STAT_F & mpfr_log_type))          \
1507       fprintf (mpfr_log_file,                                           \
1508                "%s: Ziv failed %2.2f%% (%lu bad cases / %lu calls)\n",  \
1509                _x ## _fname, (double) 100.0 * _x ## _bad / _x ## _loop, \
1510                _x ## _bad, _x ## _loop ); }
1511
1512 #define MPFR_ZIV_INIT(_x, _p)                                           \
1513   do                                                                    \
1514     {                                                                   \
1515       (_x) = GMP_NUMB_BITS;                                             \
1516       if (mpfr_log_level >= 0)                                          \
1517         _x ## _loop ++;                                                 \
1518       if ((MPFR_LOG_BADCASE_F & mpfr_log_type) &&                       \
1519           (mpfr_log_current <= mpfr_log_level))                         \
1520         LOG_PRINT ("%s:ZIV 1st prec=%Pd\n",                             \
1521                    __func__, (mpfr_prec_t) (_p));                       \
1522     }                                                                   \
1523   while (0)
1524
1525 #define MPFR_ZIV_NEXT(_x, _p)                                           \
1526   do                                                                    \
1527     {                                                                   \
1528       (_p) += (_x);                                                     \
1529       (_x) = (_p) / 2;                                                  \
1530       if (mpfr_log_level >= 0)                                          \
1531         _x ## _bad += (_x ## _cpt == 1);                                \
1532       _x ## _cpt ++;                                                    \
1533       if ((MPFR_LOG_BADCASE_F & mpfr_log_type) &&                       \
1534           (mpfr_log_current <= mpfr_log_level))                         \
1535         LOG_PRINT ("%s:ZIV new prec=%Pd\n",                             \
1536                    __func__, (mpfr_prec_t) (_p));                       \
1537     }                                                                   \
1538   while (0)
1539
1540 #define MPFR_ZIV_FREE(_x)                                               \
1541   do                                                                    \
1542     {                                                                   \
1543       if ((MPFR_LOG_BADCASE_F & mpfr_log_type) && _x ## _cpt > 1 &&     \
1544           (mpfr_log_current <= mpfr_log_level))                         \
1545         fprintf (mpfr_log_file, "%s:ZIV %d loops\n",                    \
1546                  __func__, _x ## _cpt);                                 \
1547     }                                                                   \
1548   while (0)
1549
1550 #endif
1551
1552
1553 /******************************************************
1554  ***************  Logging Macros  *********************
1555  ******************************************************/
1556
1557 /* The different kind of LOG */
1558 #define MPFR_LOG_INPUT_F    1
1559 #define MPFR_LOG_OUTPUT_F   2
1560 #define MPFR_LOG_INTERNAL_F 4
1561 #define MPFR_LOG_TIME_F     8
1562 #define MPFR_LOG_BADCASE_F  16
1563 #define MPFR_LOG_MSG_F      32
1564 #define MPFR_LOG_STAT_F     64
1565
1566 #ifdef MPFR_USE_LOGGING
1567
1568 /* Check if we can support this feature */
1569 # ifdef MPFR_USE_THREAD_SAFE
1570 #  error "Enable either `Logging' or `thread-safe', not both"
1571 # endif
1572 # if !__MPFR_GNUC(3,0)
1573 #  error "Logging not supported (GCC >= 3.0)"
1574 # endif
1575
1576 #if defined (__cplusplus)
1577 extern "C" {
1578 #endif
1579
1580 __MPFR_DECLSPEC extern FILE *mpfr_log_file;
1581 __MPFR_DECLSPEC extern int   mpfr_log_type;
1582 __MPFR_DECLSPEC extern int   mpfr_log_level;
1583 __MPFR_DECLSPEC extern int   mpfr_log_current;
1584 __MPFR_DECLSPEC extern mpfr_prec_t mpfr_log_prec;
1585
1586 #if defined (__cplusplus)
1587  }
1588 #endif
1589
1590 /* LOG_PRINT calls mpfr_fprintf on mpfr_log_file with logging disabled
1591    (recursive logging is not wanted and freezes MPFR). */
1592 #define LOG_PRINT(format, ...)                                          \
1593   do                                                                    \
1594     {                                                                   \
1595       int old_level = mpfr_log_level;                                   \
1596       mpfr_log_level = -1;  /* disable logging in mpfr_fprintf */       \
1597       __gmpfr_cache_const_pi = __gmpfr_logging_pi;                      \
1598       __gmpfr_cache_const_log2 = __gmpfr_logging_log2;                  \
1599       mpfr_fprintf (mpfr_log_file, format, __VA_ARGS__);                \
1600       mpfr_log_level = old_level;                                       \
1601       __gmpfr_cache_const_pi = __gmpfr_normal_pi;                       \
1602       __gmpfr_cache_const_log2 = __gmpfr_normal_log2;                   \
1603     }                                                                   \
1604   while (0)
1605
1606 #define MPFR_LOG_VAR(x)                                                 \
1607   do                                                                    \
1608     if ((MPFR_LOG_INTERNAL_F & mpfr_log_type) &&                        \
1609         (mpfr_log_current <= mpfr_log_level))                           \
1610       LOG_PRINT ("%s.%d:%s[%#Pu]=%.*Rg\n", __func__, __LINE__,          \
1611                  #x, mpfr_get_prec (x), mpfr_log_prec, x);              \
1612   while (0)
1613
1614 #define MPFR_LOG_MSG2(format, ...)                                      \
1615   do                                                                    \
1616     if ((MPFR_LOG_MSG_F & mpfr_log_type) &&                             \
1617         (mpfr_log_current <= mpfr_log_level))                           \
1618       LOG_PRINT ("%s.%d: "format, __func__, __LINE__, __VA_ARGS__);     \
1619   while (0)
1620 #define MPFR_LOG_MSG(x) MPFR_LOG_MSG2 x
1621
1622 #define MPFR_LOG_BEGIN2(format, ...)                                    \
1623   mpfr_log_current ++;                                                  \
1624   if ((MPFR_LOG_INPUT_F & mpfr_log_type) &&                             \
1625       (mpfr_log_current <= mpfr_log_level))                             \
1626     LOG_PRINT ("%s:IN  "format"\n", __func__, __VA_ARGS__);             \
1627   if ((MPFR_LOG_TIME_F & mpfr_log_type) &&                              \
1628       (mpfr_log_current <= mpfr_log_level))                             \
1629     __gmpfr_log_time = mpfr_get_cputime ();
1630 #define MPFR_LOG_BEGIN(x)                                               \
1631   int __gmpfr_log_time = 0;                                             \
1632   MPFR_LOG_BEGIN2 x
1633
1634 #define MPFR_LOG_END2(format, ...)                                      \
1635   if ((MPFR_LOG_TIME_F & mpfr_log_type) &&                              \
1636       (mpfr_log_current <= mpfr_log_level))                             \
1637     fprintf (mpfr_log_file, "%s:TIM %dms\n", __mpfr_log_fname,          \
1638              mpfr_get_cputime () - __gmpfr_log_time);                   \
1639   if ((MPFR_LOG_OUTPUT_F & mpfr_log_type) &&                            \
1640       (mpfr_log_current <= mpfr_log_level))                             \
1641     LOG_PRINT ("%s:OUT "format"\n", __mpfr_log_fname, __VA_ARGS__);     \
1642   mpfr_log_current --;
1643 #define MPFR_LOG_END(x)                                                 \
1644   static const char *__mpfr_log_fname = __func__;                       \
1645   MPFR_LOG_END2 x
1646
1647 #define MPFR_LOG_FUNC(begin,end)                                        \
1648   static const char *__mpfr_log_fname = __func__;                       \
1649   auto void __mpfr_log_cleanup (int *time);                             \
1650   void __mpfr_log_cleanup (int *time) {                                 \
1651     int __gmpfr_log_time = *time;                                       \
1652     MPFR_LOG_END2 end; }                                                \
1653   int __gmpfr_log_time __attribute__ ((cleanup (__mpfr_log_cleanup)));  \
1654   __gmpfr_log_time = 0;                                                 \
1655   MPFR_LOG_BEGIN2 begin
1656
1657 #else /* MPFR_USE_LOGGING */
1658
1659 /* Define void macro for logging */
1660
1661 #define MPFR_LOG_VAR(x)
1662 #define MPFR_LOG_BEGIN(x)
1663 #define MPFR_LOG_END(x)
1664 #define MPFR_LOG_MSG(x)
1665 #define MPFR_LOG_FUNC(x,y)
1666
1667 #endif /* MPFR_USE_LOGGING */
1668
1669
1670 /**************************************************************
1671  ************  Group Initialize Functions Macros  *************
1672  **************************************************************/
1673
1674 #ifndef MPFR_GROUP_STATIC_SIZE
1675 # define MPFR_GROUP_STATIC_SIZE 16
1676 #endif
1677
1678 struct mpfr_group_t {
1679   size_t     alloc;
1680   mp_limb_t *mant;
1681   mp_limb_t  tab[MPFR_GROUP_STATIC_SIZE];
1682 };
1683
1684 #define MPFR_GROUP_DECL(g) struct mpfr_group_t g
1685 #define MPFR_GROUP_CLEAR(g) do {                                 \
1686  MPFR_LOG_MSG (("GROUP_CLEAR: ptr = 0x%lX, size = %lu\n",        \
1687                 (unsigned long) (g).mant,                        \
1688                 (unsigned long) (g).alloc));                     \
1689  if (MPFR_UNLIKELY ((g).alloc != 0)) {                           \
1690    MPFR_ASSERTD ((g).mant != (g).tab);                           \
1691    (*__gmp_free_func) ((g).mant, (g).alloc);                     \
1692  }} while (0)
1693
1694 #define MPFR_GROUP_INIT_TEMPLATE(g, prec, num, handler) do {            \
1695  mpfr_prec_t _prec = (prec);                                            \
1696  mp_size_t _size;                                                       \
1697  MPFR_ASSERTD (_prec >= MPFR_PREC_MIN);                                 \
1698  if (MPFR_UNLIKELY (_prec > MPFR_PREC_MAX))                             \
1699    mpfr_abort_prec_max ();                                              \
1700  _size = MPFR_PREC2LIMBS (_prec);                                       \
1701  if (MPFR_UNLIKELY (_size * (num) > MPFR_GROUP_STATIC_SIZE))            \
1702    {                                                                    \
1703      (g).alloc = (num) * _size * sizeof (mp_limb_t);                    \
1704      (g).mant = (mp_limb_t *) (*__gmp_allocate_func) ((g).alloc);       \
1705    }                                                                    \
1706  else                                                                   \
1707    {                                                                    \
1708      (g).alloc = 0;                                                     \
1709      (g).mant = (g).tab;                                                \
1710    }                                                                    \
1711  MPFR_LOG_MSG (("GROUP_INIT: ptr = 0x%lX, size = %lu\n",                \
1712                 (unsigned long) (g).mant, (unsigned long) (g).alloc));  \
1713  handler;                                                               \
1714  } while (0)
1715 #define MPFR_GROUP_TINIT(g, n, x)                       \
1716   MPFR_TMP_INIT1 ((g).mant + _size * (n), x, _prec)
1717
1718 #define MPFR_GROUP_INIT_1(g, prec, x)                            \
1719  MPFR_GROUP_INIT_TEMPLATE(g, prec, 1, MPFR_GROUP_TINIT(g, 0, x))
1720 #define MPFR_GROUP_INIT_2(g, prec, x, y)                         \
1721  MPFR_GROUP_INIT_TEMPLATE(g, prec, 2,                            \
1722    MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y))
1723 #define MPFR_GROUP_INIT_3(g, prec, x, y, z)                      \
1724  MPFR_GROUP_INIT_TEMPLATE(g, prec, 3,                            \
1725    MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y);          \
1726    MPFR_GROUP_TINIT(g, 2, z))
1727 #define MPFR_GROUP_INIT_4(g, prec, x, y, z, t)                   \
1728  MPFR_GROUP_INIT_TEMPLATE(g, prec, 4,                            \
1729    MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y);          \
1730    MPFR_GROUP_TINIT(g, 2, z);MPFR_GROUP_TINIT(g, 3, t))
1731 #define MPFR_GROUP_INIT_5(g, prec, x, y, z, t, a)                \
1732  MPFR_GROUP_INIT_TEMPLATE(g, prec, 5,                            \
1733    MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y);          \
1734    MPFR_GROUP_TINIT(g, 2, z);MPFR_GROUP_TINIT(g, 3, t);          \
1735    MPFR_GROUP_TINIT(g, 4, a))
1736 #define MPFR_GROUP_INIT_6(g, prec, x, y, z, t, a, b)             \
1737  MPFR_GROUP_INIT_TEMPLATE(g, prec, 6,                            \
1738    MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y);          \
1739    MPFR_GROUP_TINIT(g, 2, z);MPFR_GROUP_TINIT(g, 3, t);          \
1740    MPFR_GROUP_TINIT(g, 4, a);MPFR_GROUP_TINIT(g, 5, b))
1741
1742 #define MPFR_GROUP_REPREC_TEMPLATE(g, prec, num, handler) do {          \
1743  mpfr_prec_t _prec = (prec);                                            \
1744  size_t    _oalloc = (g).alloc;                                         \
1745  mp_size_t _size;                                                       \
1746  MPFR_LOG_MSG (("GROUP_REPREC: oldptr = 0x%lX, oldsize = %lu\n",        \
1747                 (unsigned long) (g).mant, (unsigned long) _oalloc));    \
1748  MPFR_ASSERTD (_prec >= MPFR_PREC_MIN);                                 \
1749  if (MPFR_UNLIKELY (_prec > MPFR_PREC_MAX))                             \
1750    mpfr_abort_prec_max ();                                              \
1751  _size = MPFR_PREC2LIMBS (_prec);                                       \
1752  (g).alloc = (num) * _size * sizeof (mp_limb_t);                        \
1753  if (MPFR_LIKELY (_oalloc == 0))                                        \
1754    (g).mant = (mp_limb_t *) (*__gmp_allocate_func) ((g).alloc);         \
1755  else                                                                   \
1756    (g).mant = (mp_limb_t *)                                             \
1757      (*__gmp_reallocate_func) ((g).mant, _oalloc, (g).alloc);           \
1758  MPFR_LOG_MSG (("GROUP_REPREC: newptr = 0x%lX, newsize = %lu\n",        \
1759                 (unsigned long) (g).mant, (unsigned long) (g).alloc));  \
1760  handler;                                                               \
1761  } while (0)
1762
1763 #define MPFR_GROUP_REPREC_1(g, prec, x)                          \
1764  MPFR_GROUP_REPREC_TEMPLATE(g, prec, 1, MPFR_GROUP_TINIT(g, 0, x))
1765 #define MPFR_GROUP_REPREC_2(g, prec, x, y)                       \
1766  MPFR_GROUP_REPREC_TEMPLATE(g, prec, 2,                          \
1767    MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y))
1768 #define MPFR_GROUP_REPREC_3(g, prec, x, y, z)                    \
1769  MPFR_GROUP_REPREC_TEMPLATE(g, prec, 3,                          \
1770    MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y);          \
1771    MPFR_GROUP_TINIT(g, 2, z))
1772 #define MPFR_GROUP_REPREC_4(g, prec, x, y, z, t)                 \
1773  MPFR_GROUP_REPREC_TEMPLATE(g, prec, 4,                          \
1774    MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y);          \
1775    MPFR_GROUP_TINIT(g, 2, z);MPFR_GROUP_TINIT(g, 3, t))
1776 #define MPFR_GROUP_REPREC_5(g, prec, x, y, z, t, a)              \
1777  MPFR_GROUP_REPREC_TEMPLATE(g, prec, 5,                          \
1778    MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y);          \
1779    MPFR_GROUP_TINIT(g, 2, z);MPFR_GROUP_TINIT(g, 3, t);          \
1780    MPFR_GROUP_TINIT(g, 4, a))
1781 #define MPFR_GROUP_REPREC_6(g, prec, x, y, z, t, a, b)           \
1782  MPFR_GROUP_REPREC_TEMPLATE(g, prec, 6,                          \
1783    MPFR_GROUP_TINIT(g, 0, x);MPFR_GROUP_TINIT(g, 1, y);          \
1784    MPFR_GROUP_TINIT(g, 2, z);MPFR_GROUP_TINIT(g, 3, t);          \
1785    MPFR_GROUP_TINIT(g, 4, a);MPFR_GROUP_TINIT(g, 5, b))
1786
1787
1788 /******************************************************
1789  ***************  Internal Functions  *****************
1790  ******************************************************/
1791
1792 #if defined (__cplusplus)
1793 extern "C" {
1794 #endif
1795
1796 __MPFR_DECLSPEC int mpfr_underflow _MPFR_PROTO ((mpfr_ptr, mpfr_rnd_t, int));
1797 __MPFR_DECLSPEC int mpfr_overflow _MPFR_PROTO ((mpfr_ptr, mpfr_rnd_t, int));
1798
1799 __MPFR_DECLSPEC int mpfr_add1 _MPFR_PROTO ((mpfr_ptr, mpfr_srcptr,
1800                                             mpfr_srcptr, mpfr_rnd_t));
1801 __MPFR_DECLSPEC int mpfr_sub1 _MPFR_PROTO ((mpfr_ptr, mpfr_srcptr,
1802                                             mpfr_srcptr, mpfr_rnd_t));
1803 __MPFR_DECLSPEC int mpfr_add1sp _MPFR_PROTO ((mpfr_ptr, mpfr_srcptr,
1804                                               mpfr_srcptr, mpfr_rnd_t));
1805 __MPFR_DECLSPEC int mpfr_sub1sp _MPFR_PROTO ((mpfr_ptr, mpfr_srcptr,
1806                                               mpfr_srcptr, mpfr_rnd_t));
1807 __MPFR_DECLSPEC int mpfr_can_round_raw _MPFR_PROTO ((const mp_limb_t *,
1808              mp_size_t, int, mpfr_exp_t, mpfr_rnd_t, mpfr_rnd_t, mpfr_prec_t));
1809
1810 __MPFR_DECLSPEC int mpfr_cmp2 _MPFR_PROTO ((mpfr_srcptr, mpfr_srcptr,
1811                                             mpfr_prec_t *));
1812
1813 __MPFR_DECLSPEC long          __gmpfr_ceil_log2     _MPFR_PROTO ((double));
1814 __MPFR_DECLSPEC long          __gmpfr_floor_log2    _MPFR_PROTO ((double));
1815 __MPFR_DECLSPEC double        __gmpfr_ceil_exp2     _MPFR_PROTO ((double));
1816 __MPFR_DECLSPEC unsigned long __gmpfr_isqrt     _MPFR_PROTO ((unsigned long));
1817 __MPFR_DECLSPEC unsigned long __gmpfr_cuberoot  _MPFR_PROTO ((unsigned long));
1818 __MPFR_DECLSPEC int       __gmpfr_int_ceil_log2 _MPFR_PROTO ((unsigned long));
1819
1820 __MPFR_DECLSPEC mpfr_exp_t mpfr_ceil_mul _MPFR_PROTO ((mpfr_exp_t, int, int));
1821
1822 __MPFR_DECLSPEC int mpfr_exp_2 _MPFR_PROTO ((mpfr_ptr, mpfr_srcptr,mpfr_rnd_t));
1823 __MPFR_DECLSPEC int mpfr_exp_3 _MPFR_PROTO ((mpfr_ptr, mpfr_srcptr,mpfr_rnd_t));
1824 __MPFR_DECLSPEC int mpfr_powerof2_raw _MPFR_PROTO ((mpfr_srcptr));
1825
1826 __MPFR_DECLSPEC int mpfr_pow_general _MPFR_PROTO ((mpfr_ptr, mpfr_srcptr,
1827                            mpfr_srcptr, mpfr_rnd_t, int, mpfr_save_expo_t *));
1828
1829 __MPFR_DECLSPEC void mpfr_setmax _MPFR_PROTO ((mpfr_ptr, mpfr_exp_t));
1830 __MPFR_DECLSPEC void mpfr_setmin _MPFR_PROTO ((mpfr_ptr, mpfr_exp_t));
1831
1832 __MPFR_DECLSPEC long mpfr_mpn_exp _MPFR_PROTO ((mp_limb_t *, mpfr_exp_t *, int,
1833                                                 mpfr_exp_t, size_t));
1834
1835 #ifdef _MPFR_H_HAVE_FILE
1836 __MPFR_DECLSPEC void mpfr_fprint_binary _MPFR_PROTO ((FILE *, mpfr_srcptr));
1837 #endif
1838 __MPFR_DECLSPEC void mpfr_print_binary _MPFR_PROTO ((mpfr_srcptr));
1839 __MPFR_DECLSPEC void mpfr_print_mant_binary _MPFR_PROTO ((const char*,
1840                                           const mp_limb_t*, mpfr_prec_t));
1841 __MPFR_DECLSPEC void mpfr_set_str_binary _MPFR_PROTO((mpfr_ptr, const char*));
1842
1843 __MPFR_DECLSPEC int mpfr_round_raw _MPFR_PROTO ((mp_limb_t *,
1844        const mp_limb_t *, mpfr_prec_t, int, mpfr_prec_t, mpfr_rnd_t, int *));
1845 __MPFR_DECLSPEC int mpfr_round_raw_2 _MPFR_PROTO ((const mp_limb_t *,
1846              mpfr_prec_t, int, mpfr_prec_t, mpfr_rnd_t));
1847 /* No longer defined (see round_prec.c).
1848    Uncomment if it needs to be defined again.
1849 __MPFR_DECLSPEC int mpfr_round_raw_3 _MPFR_PROTO ((const mp_limb_t *,
1850              mpfr_prec_t, int, mpfr_prec_t, mpfr_rnd_t, int *));
1851 */
1852 __MPFR_DECLSPEC int mpfr_round_raw_4 _MPFR_PROTO ((mp_limb_t *,
1853        const mp_limb_t *, mpfr_prec_t, int, mpfr_prec_t, mpfr_rnd_t));
1854
1855 #define mpfr_round_raw2(xp, xn, neg, r, prec) \
1856   mpfr_round_raw_2((xp),(xn)*GMP_NUMB_BITS,(neg),(prec),(r))
1857
1858 __MPFR_DECLSPEC int mpfr_check _MPFR_PROTO ((mpfr_srcptr));
1859
1860 __MPFR_DECLSPEC int mpfr_sum_sort _MPFR_PROTO ((mpfr_srcptr *const,
1861                                                 unsigned long, mpfr_srcptr *));
1862
1863 __MPFR_DECLSPEC int mpfr_get_cputime _MPFR_PROTO ((void));
1864
1865 __MPFR_DECLSPEC void mpfr_nexttozero _MPFR_PROTO ((mpfr_ptr));
1866 __MPFR_DECLSPEC void mpfr_nexttoinf _MPFR_PROTO ((mpfr_ptr));
1867
1868 __MPFR_DECLSPEC int mpfr_const_pi_internal _MPFR_PROTO ((mpfr_ptr,mpfr_rnd_t));
1869 __MPFR_DECLSPEC int mpfr_const_log2_internal _MPFR_PROTO((mpfr_ptr,mpfr_rnd_t));
1870 __MPFR_DECLSPEC int mpfr_const_euler_internal _MPFR_PROTO((mpfr_ptr, mpfr_rnd_t));
1871 __MPFR_DECLSPEC int mpfr_const_catalan_internal _MPFR_PROTO((mpfr_ptr, mpfr_rnd_t));
1872
1873 #if 0
1874 __MPFR_DECLSPEC void mpfr_init_cache _MPFR_PROTO ((mpfr_cache_t,
1875                                            int(*)(mpfr_ptr,mpfr_rnd_t)));
1876 #endif
1877 __MPFR_DECLSPEC void mpfr_clear_cache _MPFR_PROTO ((mpfr_cache_t));
1878 __MPFR_DECLSPEC int  mpfr_cache _MPFR_PROTO ((mpfr_ptr, mpfr_cache_t,
1879                                               mpfr_rnd_t));
1880
1881 __MPFR_DECLSPEC void mpfr_mulhigh_n _MPFR_PROTO ((mpfr_limb_ptr,
1882                         mpfr_limb_srcptr, mpfr_limb_srcptr, mp_size_t));
1883 __MPFR_DECLSPEC void mpfr_mullow_n  _MPFR_PROTO ((mpfr_limb_ptr,
1884                         mpfr_limb_srcptr, mpfr_limb_srcptr, mp_size_t));
1885 __MPFR_DECLSPEC void mpfr_sqrhigh_n _MPFR_PROTO ((mpfr_limb_ptr,
1886                         mpfr_limb_srcptr, mp_size_t));
1887 __MPFR_DECLSPEC mp_limb_t mpfr_divhigh_n _MPFR_PROTO ((mpfr_limb_ptr,
1888                         mpfr_limb_ptr, mpfr_limb_ptr, mp_size_t));
1889
1890 __MPFR_DECLSPEC int mpfr_round_p _MPFR_PROTO ((mp_limb_t *, mp_size_t,
1891                                                mpfr_exp_t, mpfr_prec_t));
1892
1893 __MPFR_DECLSPEC void mpfr_dump_mant _MPFR_PROTO ((const mp_limb_t *,
1894                                                   mpfr_prec_t, mpfr_prec_t,
1895                                                   mpfr_prec_t));
1896
1897 __MPFR_DECLSPEC int mpfr_round_near_x _MPFR_PROTO ((mpfr_ptr, mpfr_srcptr,
1898                                                     mpfr_uexp_t, int,
1899                                                     mpfr_rnd_t));
1900 __MPFR_DECLSPEC void mpfr_abort_prec_max _MPFR_PROTO ((void))
1901        MPFR_NORETURN_ATTR;
1902
1903 __MPFR_DECLSPEC void mpfr_rand_raw _MPFR_PROTO((mpfr_limb_ptr, gmp_randstate_t,
1904                                                 mpfr_prec_t));
1905
1906 __MPFR_DECLSPEC mpz_t* mpfr_bernoulli_internal _MPFR_PROTO((mpz_t*,
1907                                                             unsigned long));
1908
1909 __MPFR_DECLSPEC int mpfr_sincos_fast _MPFR_PROTO((mpfr_t, mpfr_t,
1910                                                   mpfr_srcptr, mpfr_rnd_t));
1911
1912 __MPFR_DECLSPEC double mpfr_scale2 _MPFR_PROTO((double, int));
1913
1914 __MPFR_DECLSPEC void mpfr_div_ui2 _MPFR_PROTO((mpfr_ptr, mpfr_srcptr,
1915                                                unsigned long int, unsigned long int,
1916                                                mpfr_rnd_t));
1917
1918 __MPFR_DECLSPEC void mpfr_gamma_one_and_two_third _MPFR_PROTO((mpfr_ptr, mpfr_ptr, mpfr_prec_t));
1919
1920 #if defined (__cplusplus)
1921 }
1922 #endif
1923
1924 #endif