| 1 |
/* mpfr.h -- Include file for mpfr. |
| 2 |
|
| 3 |
Copyright 1999-2020 Free Software Foundation, Inc. |
| 4 |
Contributed by the AriC and Caramba 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 |
https://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_H |
| 24 |
#define __MPFR_H |
| 25 |
|
| 26 |
/* Define MPFR version number */ |
| 27 |
#define MPFR_VERSION_MAJOR 4 |
| 28 |
#define MPFR_VERSION_MINOR 1 |
| 29 |
#define MPFR_VERSION_PATCHLEVEL 0 |
| 30 |
#define MPFR_VERSION_STRING "4.1.0-p13" |
| 31 |
|
| 32 |
/* User macros: |
| 33 |
MPFR_USE_FILE: Define it to make MPFR define functions dealing |
| 34 |
with FILE* (auto-detect). |
| 35 |
MPFR_USE_INTMAX_T: Define it to make MPFR define functions dealing |
| 36 |
with intmax_t (auto-detect). |
| 37 |
MPFR_USE_VA_LIST: Define it to make MPFR define functions dealing |
| 38 |
with va_list (auto-detect). |
| 39 |
MPFR_USE_C99_FEATURE: Define it to 1 to make MPFR support C99-feature |
| 40 |
(auto-detect), to 0 to bypass the detection. |
| 41 |
MPFR_USE_EXTENSION: Define it to make MPFR use GCC extension to |
| 42 |
reduce warnings. |
| 43 |
MPFR_USE_NO_MACRO: Define it to make MPFR remove any overriding |
| 44 |
function macro. |
| 45 |
*/ |
| 46 |
|
| 47 |
/* Macros dealing with MPFR VERSION */ |
| 48 |
#define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c)) |
| 49 |
#define MPFR_VERSION \ |
| 50 |
MPFR_VERSION_NUM(MPFR_VERSION_MAJOR,MPFR_VERSION_MINOR,MPFR_VERSION_PATCHLEVEL) |
| 51 |
|
| 52 |
#ifndef MPFR_USE_MINI_GMP |
| 53 |
#include <gmp.h> |
| 54 |
#else |
| 55 |
#include <mini-gmp.h> |
| 56 |
#endif |
| 57 |
|
| 58 |
/* Avoid some problems with macro expansion if the user defines macros |
| 59 |
with the same name as keywords. By convention, identifiers and macro |
| 60 |
names starting with mpfr_ are reserved by MPFR. */ |
| 61 |
typedef void mpfr_void; |
| 62 |
typedef int mpfr_int; |
| 63 |
typedef unsigned int mpfr_uint; |
| 64 |
typedef long mpfr_long; |
| 65 |
typedef unsigned long mpfr_ulong; |
| 66 |
typedef size_t mpfr_size_t; |
| 67 |
|
| 68 |
/* Global (possibly TLS) flags. Might also be used in an mpfr_t in the |
| 69 |
future (there would be room as mpfr_sign_t just needs 1 byte). |
| 70 |
TODO: The tests currently assume that the flags fits in an unsigned int; |
| 71 |
this should be cleaned up, e.g. by defining a function that outputs the |
| 72 |
flags as a string or by using the flags_out function (from tests/tests.c |
| 73 |
directly). */ |
| 74 |
typedef unsigned int mpfr_flags_t; |
| 75 |
|
| 76 |
/* Flags macros (in the public API) */ |
| 77 |
#define MPFR_FLAGS_UNDERFLOW 1 |
| 78 |
#define MPFR_FLAGS_OVERFLOW 2 |
| 79 |
#define MPFR_FLAGS_NAN 4 |
| 80 |
#define MPFR_FLAGS_INEXACT 8 |
| 81 |
#define MPFR_FLAGS_ERANGE 16 |
| 82 |
#define MPFR_FLAGS_DIVBY0 32 |
| 83 |
#define MPFR_FLAGS_ALL (MPFR_FLAGS_UNDERFLOW | \ |
| 84 |
MPFR_FLAGS_OVERFLOW | \ |
| 85 |
MPFR_FLAGS_NAN | \ |
| 86 |
MPFR_FLAGS_INEXACT | \ |
| 87 |
MPFR_FLAGS_ERANGE | \ |
| 88 |
MPFR_FLAGS_DIVBY0) |
| 89 |
|
| 90 |
/* Definition of rounding modes (DON'T USE MPFR_RNDNA!). |
| 91 |
Warning! Changing the contents of this enum should be seen as an |
| 92 |
interface change since the old and the new types are not compatible |
| 93 |
(the integer type compatible with the enumerated type can even change, |
| 94 |
see ISO C99, 6.7.2.2#4), and in Makefile.am, AGE should be set to 0. |
| 95 |
|
| 96 |
MPFR_RNDU must appear just before MPFR_RNDD (see |
| 97 |
MPFR_IS_RNDUTEST_OR_RNDDNOTTEST in mpfr-impl.h). |
| 98 |
|
| 99 |
If you change the order of the rounding modes, please update the routines |
| 100 |
in texceptions.c which assume 0=RNDN, 1=RNDZ, 2=RNDU, 3=RNDD, 4=RNDA. |
| 101 |
*/ |
| 102 |
typedef enum { |
| 103 |
MPFR_RNDN=0, /* round to nearest, with ties to even */ |
| 104 |
MPFR_RNDZ, /* round toward zero */ |
| 105 |
MPFR_RNDU, /* round toward +Inf */ |
| 106 |
MPFR_RNDD, /* round toward -Inf */ |
| 107 |
MPFR_RNDA, /* round away from zero */ |
| 108 |
MPFR_RNDF, /* faithful rounding */ |
| 109 |
MPFR_RNDNA=-1 /* round to nearest, with ties away from zero (mpfr_round) */ |
| 110 |
} mpfr_rnd_t; |
| 111 |
|
| 112 |
/* kept for compatibility with MPFR 2.4.x and before */ |
| 113 |
#define GMP_RNDN MPFR_RNDN |
| 114 |
#define GMP_RNDZ MPFR_RNDZ |
| 115 |
#define GMP_RNDU MPFR_RNDU |
| 116 |
#define GMP_RNDD MPFR_RNDD |
| 117 |
|
| 118 |
/* The _MPFR_PREC_FORMAT and _MPFR_EXP_FORMAT values are automatically |
| 119 |
defined below. You MUST NOT force a value (this will break the ABI), |
| 120 |
possibly except for a very particular use, in which case you also need |
| 121 |
to rebuild the MPFR library with the chosen values; do not install this |
| 122 |
rebuilt library in a path that is searched by default, otherwise this |
| 123 |
will break applications that are dynamically linked with MPFR. |
| 124 |
|
| 125 |
Using non-default values is not guaranteed to work. |
| 126 |
|
| 127 |
Note: With the following default choices for _MPFR_PREC_FORMAT and |
| 128 |
_MPFR_EXP_FORMAT, mpfr_exp_t will be the same as [mp_exp_t] (at least |
| 129 |
up to GMP 6). */ |
| 130 |
|
| 131 |
/* Define precision: 1 (short), 2 (int) or 3 (long). |
| 132 |
DON'T FORCE A VALUE (see above). */ |
| 133 |
#ifndef _MPFR_PREC_FORMAT |
| 134 |
# if __GMP_MP_SIZE_T_INT |
| 135 |
# define _MPFR_PREC_FORMAT 2 |
| 136 |
# else |
| 137 |
# define _MPFR_PREC_FORMAT 3 |
| 138 |
# endif |
| 139 |
#endif |
| 140 |
|
| 141 |
/* Define exponent: 1 (short), 2 (int), 3 (long) or 4 (intmax_t). |
| 142 |
DON'T FORCE A VALUE (see above). */ |
| 143 |
#ifndef _MPFR_EXP_FORMAT |
| 144 |
# define _MPFR_EXP_FORMAT _MPFR_PREC_FORMAT |
| 145 |
#endif |
| 146 |
|
| 147 |
#if _MPFR_PREC_FORMAT > _MPFR_EXP_FORMAT |
| 148 |
# error "mpfr_prec_t must not be larger than mpfr_exp_t" |
| 149 |
#endif |
| 150 |
|
| 151 |
/* Let's make mpfr_prec_t signed in order to avoid problems due to the |
| 152 |
usual arithmetic conversions when mixing mpfr_prec_t and mpfr_exp_t |
| 153 |
in an expression (for error analysis) if casts are forgotten. |
| 154 |
Note: mpfr_prec_t is currently limited to "long". This means that |
| 155 |
under MS Windows, the precisions are limited to about 2^31; however, |
| 156 |
these are already huge precisions, probably sufficient in practice |
| 157 |
on this platform. */ |
| 158 |
#if _MPFR_PREC_FORMAT == 1 |
| 159 |
typedef short mpfr_prec_t; |
| 160 |
typedef unsigned short mpfr_uprec_t; |
| 161 |
#elif _MPFR_PREC_FORMAT == 2 |
| 162 |
typedef int mpfr_prec_t; |
| 163 |
typedef unsigned int mpfr_uprec_t; |
| 164 |
#elif _MPFR_PREC_FORMAT == 3 |
| 165 |
/* we could use "long long" under Windows 64 here, which can be tested |
| 166 |
with the macro _WIN64 according to |
| 167 |
https://sourceforge.net/p/predef/wiki/OperatingSystems/ */ |
| 168 |
typedef long mpfr_prec_t; |
| 169 |
typedef unsigned long mpfr_uprec_t; |
| 170 |
#else |
| 171 |
# error "Invalid MPFR Prec format" |
| 172 |
#endif |
| 173 |
|
| 174 |
/* Definition of precision limits without needing <limits.h> */ |
| 175 |
/* Note: The casts allows the expression to yield the wanted behavior |
| 176 |
for _MPFR_PREC_FORMAT == 1 (due to integer promotion rules). We |
| 177 |
also make sure that MPFR_PREC_MIN and MPFR_PREC_MAX have a signed |
| 178 |
integer type. The "- 256" allows more security, avoiding some |
| 179 |
integer overflows in extreme cases; ideally it should be useless. */ |
| 180 |
#define MPFR_PREC_MIN 1 |
| 181 |
#define MPFR_PREC_MAX ((mpfr_prec_t) ((((mpfr_uprec_t) -1) >> 1) - 256)) |
| 182 |
|
| 183 |
/* Definition of sign */ |
| 184 |
typedef int mpfr_sign_t; |
| 185 |
|
| 186 |
/* Definition of the exponent. _MPFR_EXP_FORMAT must be large enough |
| 187 |
so that mpfr_exp_t has at least 32 bits. */ |
| 188 |
#if _MPFR_EXP_FORMAT == 1 |
| 189 |
typedef short mpfr_exp_t; |
| 190 |
typedef unsigned short mpfr_uexp_t; |
| 191 |
#elif _MPFR_EXP_FORMAT == 2 |
| 192 |
typedef int mpfr_exp_t; |
| 193 |
typedef unsigned int mpfr_uexp_t; |
| 194 |
#elif _MPFR_EXP_FORMAT == 3 |
| 195 |
typedef long mpfr_exp_t; |
| 196 |
typedef unsigned long mpfr_uexp_t; |
| 197 |
#elif _MPFR_EXP_FORMAT == 4 |
| 198 |
/* Note: in this case, intmax_t and uintmax_t must be defined before |
| 199 |
the inclusion of mpfr.h (we do not include <stdint.h> here because |
| 200 |
of some non-ISO C99 implementations that support these types). */ |
| 201 |
typedef intmax_t mpfr_exp_t; |
| 202 |
typedef uintmax_t mpfr_uexp_t; |
| 203 |
#else |
| 204 |
# error "Invalid MPFR Exp format" |
| 205 |
#endif |
| 206 |
|
| 207 |
/* Definition of the standard exponent limits */ |
| 208 |
#define MPFR_EMAX_DEFAULT ((mpfr_exp_t) (((mpfr_ulong) 1 << 30) - 1)) |
| 209 |
#define MPFR_EMIN_DEFAULT (-(MPFR_EMAX_DEFAULT)) |
| 210 |
|
| 211 |
/* DON'T USE THIS! (For MPFR-public macros only, see below.) |
| 212 |
The mpfr_sgn macro uses the fact that __MPFR_EXP_NAN and __MPFR_EXP_ZERO |
| 213 |
are the smallest values. For a n-bit type, EXP_MAX is 2^(n-1)-1, |
| 214 |
EXP_ZERO is 1-2^(n-1), EXP_NAN is 2-2^(n-1), EXP_INF is 3-2^(n-1). |
| 215 |
This may change in the future. MPFR code should not be based on these |
| 216 |
representations (but if this is absolutely needed, protect the code |
| 217 |
with a static assertion). */ |
| 218 |
#define __MPFR_EXP_MAX ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1)) |
| 219 |
#define __MPFR_EXP_NAN (1 - __MPFR_EXP_MAX) |
| 220 |
#define __MPFR_EXP_ZERO (0 - __MPFR_EXP_MAX) |
| 221 |
#define __MPFR_EXP_INF (2 - __MPFR_EXP_MAX) |
| 222 |
|
| 223 |
/* Definition of the main structure */ |
| 224 |
typedef struct { |
| 225 |
mpfr_prec_t _mpfr_prec; |
| 226 |
mpfr_sign_t _mpfr_sign; |
| 227 |
mpfr_exp_t _mpfr_exp; |
| 228 |
mp_limb_t *_mpfr_d; |
| 229 |
} __mpfr_struct; |
| 230 |
|
| 231 |
/* Compatibility with previous types of MPFR */ |
| 232 |
#ifndef mp_rnd_t |
| 233 |
# define mp_rnd_t mpfr_rnd_t |
| 234 |
#endif |
| 235 |
#ifndef mp_prec_t |
| 236 |
# define mp_prec_t mpfr_prec_t |
| 237 |
#endif |
| 238 |
|
| 239 |
/* |
| 240 |
The represented number is |
| 241 |
_sign*(_d[k-1]/B+_d[k-2]/B^2+...+_d[0]/B^k)*2^_exp |
| 242 |
where k=ceil(_mp_prec/GMP_NUMB_BITS) and B=2^GMP_NUMB_BITS. |
| 243 |
|
| 244 |
For the msb (most significant bit) normalized representation, we must have |
| 245 |
_d[k-1]>=B/2, unless the number is singular. |
| 246 |
|
| 247 |
We must also have the last k*GMP_NUMB_BITS-_prec bits set to zero. |
| 248 |
*/ |
| 249 |
|
| 250 |
typedef __mpfr_struct mpfr_t[1]; |
| 251 |
typedef __mpfr_struct *mpfr_ptr; |
| 252 |
typedef const __mpfr_struct *mpfr_srcptr; |
| 253 |
|
| 254 |
/* For those who need a direct and fast access to the sign field. |
| 255 |
However it is not in the API, thus use it at your own risk: it might |
| 256 |
not be supported, or change name, in further versions! |
| 257 |
Unfortunately, it must be defined here (instead of MPFR's internal |
| 258 |
header file mpfr-impl.h) because it is used by some macros below. |
| 259 |
*/ |
| 260 |
#define MPFR_SIGN(x) ((x)->_mpfr_sign) |
| 261 |
|
| 262 |
/* Stack interface */ |
| 263 |
typedef enum { |
| 264 |
MPFR_NAN_KIND = 0, |
| 265 |
MPFR_INF_KIND = 1, |
| 266 |
MPFR_ZERO_KIND = 2, |
| 267 |
MPFR_REGULAR_KIND = 3 |
| 268 |
} mpfr_kind_t; |
| 269 |
|
| 270 |
/* Free cache policy */ |
| 271 |
typedef enum { |
| 272 |
MPFR_FREE_LOCAL_CACHE = 1, /* 1 << 0 */ |
| 273 |
MPFR_FREE_GLOBAL_CACHE = 2 /* 1 << 1 */ |
| 274 |
} mpfr_free_cache_t; |
| 275 |
|
| 276 |
/* GMP defines: |
| 277 |
+ size_t: Standard size_t |
| 278 |
+ __GMP_NOTHROW For C++: can't throw . |
| 279 |
+ __GMP_EXTERN_INLINE Attribute for inline function. |
| 280 |
+ __GMP_DECLSPEC_EXPORT compiling to go into a DLL |
| 281 |
+ __GMP_DECLSPEC_IMPORT compiling to go into a application |
| 282 |
*/ |
| 283 |
/* Extra MPFR defines */ |
| 284 |
#define __MPFR_SENTINEL_ATTR |
| 285 |
#if defined (__GNUC__) |
| 286 |
# if __GNUC__ >= 4 |
| 287 |
# undef __MPFR_SENTINEL_ATTR |
| 288 |
# define __MPFR_SENTINEL_ATTR __attribute__ ((__sentinel__)) |
| 289 |
# endif |
| 290 |
#endif |
| 291 |
|
| 292 |
/* If the user hasn't requested his/her preference |
| 293 |
and if the intention of support by the compiler is C99 |
| 294 |
and if the compiler is known to support the C99 feature |
| 295 |
then we can auto-detect the C99 support as OK. |
| 296 |
__GNUC__ is used to detect GNU-C, ICC & CLANG compilers. |
| 297 |
Currently we need only variadic macros, and they are present |
| 298 |
since GCC >= 3. We don't test library version since we don't |
| 299 |
use any feature present in the library too (except intmax_t, |
| 300 |
but they use another detection).*/ |
| 301 |
#ifndef MPFR_USE_C99_FEATURE |
| 302 |
# if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) |
| 303 |
# if defined (__GNUC__) |
| 304 |
# if __GNUC__ >= 3 |
| 305 |
# define MPFR_USE_C99_FEATURE 1 |
| 306 |
# endif |
| 307 |
# endif |
| 308 |
# endif |
| 309 |
# ifndef MPFR_USE_C99_FEATURE |
| 310 |
# define MPFR_USE_C99_FEATURE 0 |
| 311 |
# endif |
| 312 |
#endif |
| 313 |
|
| 314 |
/* Support for WINDOWS Dll: |
| 315 |
Check if we are inside a MPFR build, and if so export the functions. |
| 316 |
Otherwise does the same thing as GMP */ |
| 317 |
#if defined(__MPFR_WITHIN_MPFR) && __GMP_LIBGMP_DLL |
| 318 |
# define __MPFR_DECLSPEC __GMP_DECLSPEC_EXPORT |
| 319 |
#else |
| 320 |
# ifndef __GMP_DECLSPEC |
| 321 |
# define __GMP_DECLSPEC |
| 322 |
# endif |
| 323 |
# define __MPFR_DECLSPEC __GMP_DECLSPEC |
| 324 |
#endif |
| 325 |
|
| 326 |
/* Use MPFR_DEPRECATED to mark MPFR functions, types or variables as |
| 327 |
deprecated. Code inspired by Apache Subversion's svn_types.h file. |
| 328 |
For compatibility with MSVC, MPFR_DEPRECATED must be put before |
| 329 |
__MPFR_DECLSPEC (not at the end of the function declaration as |
| 330 |
documented in the GCC manual); GCC does not seem to care. |
| 331 |
Moreover, in order to avoid a warning when testing such functions, |
| 332 |
do something like: |
| 333 |
+------------------------------------------ |
| 334 |
|#ifndef _MPFR_NO_DEPRECATED_funcname |
| 335 |
|MPFR_DEPRECATED |
| 336 |
|#endif |
| 337 |
|__MPFR_DECLSPEC int mpfr_funcname (...); |
| 338 |
+------------------------------------------ |
| 339 |
and in the corresponding test program: |
| 340 |
+------------------------------------------ |
| 341 |
|#define _MPFR_NO_DEPRECATED_funcname |
| 342 |
|#include "mpfr-test.h" |
| 343 |
+------------------------------------------ |
| 344 |
*/ |
| 345 |
#if defined(__GNUC__) && \ |
| 346 |
(__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)) |
| 347 |
# define MPFR_DEPRECATED __attribute__ ((__deprecated__)) |
| 348 |
#elif defined(_MSC_VER) && _MSC_VER >= 1300 |
| 349 |
# define MPFR_DEPRECATED __declspec(deprecated) |
| 350 |
#else |
| 351 |
# define MPFR_DEPRECATED |
| 352 |
#endif |
| 353 |
/* TODO: Also define MPFR_EXPERIMENTAL for experimental functions? |
| 354 |
See SVN_EXPERIMENTAL in Subversion 1.9+ as an example: |
| 355 |
__attribute__((__warning__("..."))) can be used with GCC 4.3.1+ but |
| 356 |
not __llvm__, and __declspec(deprecated("...")) can be used with |
| 357 |
MSC as above. */ |
| 358 |
|
| 359 |
#if defined(__GNUC__) && \ |
| 360 |
(__GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9)) |
| 361 |
# define MPFR_RETURNS_NONNULL __attribute__ ((__returns_nonnull__)) |
| 362 |
#else |
| 363 |
# define MPFR_RETURNS_NONNULL |
| 364 |
#endif |
| 365 |
|
| 366 |
/* Note: In order to be declared, some functions need a specific |
| 367 |
system header to be included *before* "mpfr.h". If the user |
| 368 |
forgets to include the header, the MPFR function prototype in |
| 369 |
the user object file is not correct. To avoid wrong results, |
| 370 |
we raise a linker error in that case by changing their internal |
| 371 |
name in the library (prefixed by __gmpfr instead of mpfr). See |
| 372 |
the lines of the form "#define mpfr_xxx __gmpfr_xxx" below. */ |
| 373 |
|
| 374 |
#if defined (__cplusplus) |
| 375 |
extern "C" { |
| 376 |
#endif |
| 377 |
|
| 378 |
__MPFR_DECLSPEC MPFR_RETURNS_NONNULL const char * mpfr_get_version (void); |
| 379 |
__MPFR_DECLSPEC MPFR_RETURNS_NONNULL const char * mpfr_get_patches (void); |
| 380 |
|
| 381 |
__MPFR_DECLSPEC int mpfr_buildopt_tls_p (void); |
| 382 |
__MPFR_DECLSPEC int mpfr_buildopt_float128_p (void); |
| 383 |
__MPFR_DECLSPEC int mpfr_buildopt_decimal_p (void); |
| 384 |
__MPFR_DECLSPEC int mpfr_buildopt_gmpinternals_p (void); |
| 385 |
__MPFR_DECLSPEC int mpfr_buildopt_sharedcache_p (void); |
| 386 |
__MPFR_DECLSPEC MPFR_RETURNS_NONNULL const char * |
| 387 |
mpfr_buildopt_tune_case (void); |
| 388 |
|
| 389 |
__MPFR_DECLSPEC mpfr_exp_t mpfr_get_emin (void); |
| 390 |
__MPFR_DECLSPEC int mpfr_set_emin (mpfr_exp_t); |
| 391 |
__MPFR_DECLSPEC mpfr_exp_t mpfr_get_emin_min (void); |
| 392 |
__MPFR_DECLSPEC mpfr_exp_t mpfr_get_emin_max (void); |
| 393 |
__MPFR_DECLSPEC mpfr_exp_t mpfr_get_emax (void); |
| 394 |
__MPFR_DECLSPEC int mpfr_set_emax (mpfr_exp_t); |
| 395 |
__MPFR_DECLSPEC mpfr_exp_t mpfr_get_emax_min (void); |
| 396 |
__MPFR_DECLSPEC mpfr_exp_t mpfr_get_emax_max (void); |
| 397 |
|
| 398 |
__MPFR_DECLSPEC void mpfr_set_default_rounding_mode (mpfr_rnd_t); |
| 399 |
__MPFR_DECLSPEC mpfr_rnd_t mpfr_get_default_rounding_mode (void); |
| 400 |
__MPFR_DECLSPEC const char * mpfr_print_rnd_mode (mpfr_rnd_t); |
| 401 |
|
| 402 |
__MPFR_DECLSPEC void mpfr_clear_flags (void); |
| 403 |
__MPFR_DECLSPEC void mpfr_clear_underflow (void); |
| 404 |
__MPFR_DECLSPEC void mpfr_clear_overflow (void); |
| 405 |
__MPFR_DECLSPEC void mpfr_clear_divby0 (void); |
| 406 |
__MPFR_DECLSPEC void mpfr_clear_nanflag (void); |
| 407 |
__MPFR_DECLSPEC void mpfr_clear_inexflag (void); |
| 408 |
__MPFR_DECLSPEC void mpfr_clear_erangeflag (void); |
| 409 |
|
| 410 |
__MPFR_DECLSPEC void mpfr_set_underflow (void); |
| 411 |
__MPFR_DECLSPEC void mpfr_set_overflow (void); |
| 412 |
__MPFR_DECLSPEC void mpfr_set_divby0 (void); |
| 413 |
__MPFR_DECLSPEC void mpfr_set_nanflag (void); |
| 414 |
__MPFR_DECLSPEC void mpfr_set_inexflag (void); |
| 415 |
__MPFR_DECLSPEC void mpfr_set_erangeflag (void); |
| 416 |
|
| 417 |
__MPFR_DECLSPEC int mpfr_underflow_p (void); |
| 418 |
__MPFR_DECLSPEC int mpfr_overflow_p (void); |
| 419 |
__MPFR_DECLSPEC int mpfr_divby0_p (void); |
| 420 |
__MPFR_DECLSPEC int mpfr_nanflag_p (void); |
| 421 |
__MPFR_DECLSPEC int mpfr_inexflag_p (void); |
| 422 |
__MPFR_DECLSPEC int mpfr_erangeflag_p (void); |
| 423 |
|
| 424 |
__MPFR_DECLSPEC void mpfr_flags_clear (mpfr_flags_t); |
| 425 |
__MPFR_DECLSPEC void mpfr_flags_set (mpfr_flags_t); |
| 426 |
__MPFR_DECLSPEC mpfr_flags_t mpfr_flags_test (mpfr_flags_t); |
| 427 |
__MPFR_DECLSPEC mpfr_flags_t mpfr_flags_save (void); |
| 428 |
__MPFR_DECLSPEC void mpfr_flags_restore (mpfr_flags_t, |
| 429 |
mpfr_flags_t); |
| 430 |
|
| 431 |
__MPFR_DECLSPEC int mpfr_check_range (mpfr_ptr, int, mpfr_rnd_t); |
| 432 |
|
| 433 |
__MPFR_DECLSPEC void mpfr_init2 (mpfr_ptr, mpfr_prec_t); |
| 434 |
__MPFR_DECLSPEC void mpfr_init (mpfr_ptr); |
| 435 |
__MPFR_DECLSPEC void mpfr_clear (mpfr_ptr); |
| 436 |
|
| 437 |
__MPFR_DECLSPEC void |
| 438 |
mpfr_inits2 (mpfr_prec_t, mpfr_ptr, ...) __MPFR_SENTINEL_ATTR; |
| 439 |
__MPFR_DECLSPEC void |
| 440 |
mpfr_inits (mpfr_ptr, ...) __MPFR_SENTINEL_ATTR; |
| 441 |
__MPFR_DECLSPEC void |
| 442 |
mpfr_clears (mpfr_ptr, ...) __MPFR_SENTINEL_ATTR; |
| 443 |
|
| 444 |
__MPFR_DECLSPEC int mpfr_prec_round (mpfr_ptr, mpfr_prec_t, mpfr_rnd_t); |
| 445 |
__MPFR_DECLSPEC int mpfr_can_round (mpfr_srcptr, mpfr_exp_t, mpfr_rnd_t, |
| 446 |
mpfr_rnd_t, mpfr_prec_t); |
| 447 |
__MPFR_DECLSPEC mpfr_prec_t mpfr_min_prec (mpfr_srcptr); |
| 448 |
|
| 449 |
__MPFR_DECLSPEC mpfr_exp_t mpfr_get_exp (mpfr_srcptr); |
| 450 |
__MPFR_DECLSPEC int mpfr_set_exp (mpfr_ptr, mpfr_exp_t); |
| 451 |
__MPFR_DECLSPEC mpfr_prec_t mpfr_get_prec (mpfr_srcptr); |
| 452 |
__MPFR_DECLSPEC void mpfr_set_prec (mpfr_ptr, mpfr_prec_t); |
| 453 |
__MPFR_DECLSPEC void mpfr_set_prec_raw (mpfr_ptr, mpfr_prec_t); |
| 454 |
__MPFR_DECLSPEC void mpfr_set_default_prec (mpfr_prec_t); |
| 455 |
__MPFR_DECLSPEC mpfr_prec_t mpfr_get_default_prec (void); |
| 456 |
|
| 457 |
__MPFR_DECLSPEC int mpfr_set_d (mpfr_ptr, double, mpfr_rnd_t); |
| 458 |
__MPFR_DECLSPEC int mpfr_set_flt (mpfr_ptr, float, mpfr_rnd_t); |
| 459 |
#ifdef MPFR_WANT_DECIMAL_FLOATS |
| 460 |
/* _Decimal64 is not defined in C++, |
| 461 |
cf https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51364 */ |
| 462 |
__MPFR_DECLSPEC int mpfr_set_decimal64 (mpfr_ptr, _Decimal64, mpfr_rnd_t); |
| 463 |
__MPFR_DECLSPEC int mpfr_set_decimal128 (mpfr_ptr, _Decimal128, mpfr_rnd_t); |
| 464 |
#endif |
| 465 |
__MPFR_DECLSPEC int mpfr_set_ld (mpfr_ptr, long double, mpfr_rnd_t); |
| 466 |
#ifdef MPFR_WANT_FLOAT128 |
| 467 |
__MPFR_DECLSPEC int mpfr_set_float128 (mpfr_ptr, _Float128, mpfr_rnd_t); |
| 468 |
__MPFR_DECLSPEC _Float128 mpfr_get_float128 (mpfr_srcptr, mpfr_rnd_t); |
| 469 |
#endif |
| 470 |
__MPFR_DECLSPEC int mpfr_set_z (mpfr_ptr, mpz_srcptr, mpfr_rnd_t); |
| 471 |
__MPFR_DECLSPEC int mpfr_set_z_2exp (mpfr_ptr, mpz_srcptr, mpfr_exp_t, |
| 472 |
mpfr_rnd_t); |
| 473 |
__MPFR_DECLSPEC void mpfr_set_nan (mpfr_ptr); |
| 474 |
__MPFR_DECLSPEC void mpfr_set_inf (mpfr_ptr, int); |
| 475 |
__MPFR_DECLSPEC void mpfr_set_zero (mpfr_ptr, int); |
| 476 |
|
| 477 |
#ifndef MPFR_USE_MINI_GMP |
| 478 |
/* mini-gmp does not provide mpf_t, we disable the following functions */ |
| 479 |
__MPFR_DECLSPEC int mpfr_set_f (mpfr_ptr, mpf_srcptr, mpfr_rnd_t); |
| 480 |
__MPFR_DECLSPEC int mpfr_cmp_f (mpfr_srcptr, mpf_srcptr); |
| 481 |
__MPFR_DECLSPEC int mpfr_get_f (mpf_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 482 |
#endif |
| 483 |
__MPFR_DECLSPEC int mpfr_set_si (mpfr_ptr, long, mpfr_rnd_t); |
| 484 |
__MPFR_DECLSPEC int mpfr_set_ui (mpfr_ptr, unsigned long, mpfr_rnd_t); |
| 485 |
__MPFR_DECLSPEC int mpfr_set_si_2exp (mpfr_ptr, long, mpfr_exp_t, mpfr_rnd_t); |
| 486 |
__MPFR_DECLSPEC int mpfr_set_ui_2exp (mpfr_ptr, unsigned long, mpfr_exp_t, |
| 487 |
mpfr_rnd_t); |
| 488 |
#ifndef MPFR_USE_MINI_GMP |
| 489 |
/* mini-gmp does not provide mpq_t, we disable the following functions */ |
| 490 |
__MPFR_DECLSPEC int mpfr_set_q (mpfr_ptr, mpq_srcptr, mpfr_rnd_t); |
| 491 |
__MPFR_DECLSPEC int mpfr_mul_q (mpfr_ptr, mpfr_srcptr, mpq_srcptr, mpfr_rnd_t); |
| 492 |
__MPFR_DECLSPEC int mpfr_div_q (mpfr_ptr, mpfr_srcptr, mpq_srcptr, mpfr_rnd_t); |
| 493 |
__MPFR_DECLSPEC int mpfr_add_q (mpfr_ptr, mpfr_srcptr, mpq_srcptr, mpfr_rnd_t); |
| 494 |
__MPFR_DECLSPEC int mpfr_sub_q (mpfr_ptr, mpfr_srcptr, mpq_srcptr, mpfr_rnd_t); |
| 495 |
__MPFR_DECLSPEC int mpfr_cmp_q (mpfr_srcptr, mpq_srcptr); |
| 496 |
__MPFR_DECLSPEC void mpfr_get_q (mpq_ptr q, mpfr_srcptr f); |
| 497 |
#endif |
| 498 |
__MPFR_DECLSPEC int mpfr_set_str (mpfr_ptr, const char *, int, mpfr_rnd_t); |
| 499 |
__MPFR_DECLSPEC int mpfr_init_set_str (mpfr_ptr, const char *, int, |
| 500 |
mpfr_rnd_t); |
| 501 |
__MPFR_DECLSPEC int mpfr_set4 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t, int); |
| 502 |
__MPFR_DECLSPEC int mpfr_abs (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 503 |
__MPFR_DECLSPEC int mpfr_set (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 504 |
__MPFR_DECLSPEC int mpfr_neg (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 505 |
__MPFR_DECLSPEC int mpfr_signbit (mpfr_srcptr); |
| 506 |
__MPFR_DECLSPEC int mpfr_setsign (mpfr_ptr, mpfr_srcptr, int, mpfr_rnd_t); |
| 507 |
__MPFR_DECLSPEC int mpfr_copysign (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, |
| 508 |
mpfr_rnd_t); |
| 509 |
|
| 510 |
__MPFR_DECLSPEC mpfr_exp_t mpfr_get_z_2exp (mpz_ptr, mpfr_srcptr); |
| 511 |
__MPFR_DECLSPEC float mpfr_get_flt (mpfr_srcptr, mpfr_rnd_t); |
| 512 |
__MPFR_DECLSPEC double mpfr_get_d (mpfr_srcptr, mpfr_rnd_t); |
| 513 |
#ifdef MPFR_WANT_DECIMAL_FLOATS |
| 514 |
__MPFR_DECLSPEC _Decimal64 mpfr_get_decimal64 (mpfr_srcptr, mpfr_rnd_t); |
| 515 |
__MPFR_DECLSPEC _Decimal128 mpfr_get_decimal128 (mpfr_srcptr, mpfr_rnd_t); |
| 516 |
#endif |
| 517 |
__MPFR_DECLSPEC long double mpfr_get_ld (mpfr_srcptr, mpfr_rnd_t); |
| 518 |
__MPFR_DECLSPEC double mpfr_get_d1 (mpfr_srcptr); |
| 519 |
__MPFR_DECLSPEC double mpfr_get_d_2exp (long*, mpfr_srcptr, mpfr_rnd_t); |
| 520 |
__MPFR_DECLSPEC long double mpfr_get_ld_2exp (long*, mpfr_srcptr, mpfr_rnd_t); |
| 521 |
__MPFR_DECLSPEC int mpfr_frexp (mpfr_exp_t*, mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 522 |
__MPFR_DECLSPEC long mpfr_get_si (mpfr_srcptr, mpfr_rnd_t); |
| 523 |
__MPFR_DECLSPEC unsigned long mpfr_get_ui (mpfr_srcptr, mpfr_rnd_t); |
| 524 |
__MPFR_DECLSPEC size_t mpfr_get_str_ndigits (int, mpfr_prec_t); |
| 525 |
__MPFR_DECLSPEC char * mpfr_get_str (char*, mpfr_exp_t*, int, size_t, |
| 526 |
mpfr_srcptr, mpfr_rnd_t); |
| 527 |
__MPFR_DECLSPEC int mpfr_get_z (mpz_ptr z, mpfr_srcptr f, mpfr_rnd_t); |
| 528 |
|
| 529 |
__MPFR_DECLSPEC void mpfr_free_str (char *); |
| 530 |
|
| 531 |
__MPFR_DECLSPEC int mpfr_urandom (mpfr_ptr, gmp_randstate_t, mpfr_rnd_t); |
| 532 |
#ifndef _MPFR_NO_DEPRECATED_GRANDOM /* for the test of this function */ |
| 533 |
MPFR_DEPRECATED |
| 534 |
#endif |
| 535 |
__MPFR_DECLSPEC int mpfr_grandom (mpfr_ptr, mpfr_ptr, gmp_randstate_t, |
| 536 |
mpfr_rnd_t); |
| 537 |
__MPFR_DECLSPEC int mpfr_nrandom (mpfr_ptr, gmp_randstate_t, mpfr_rnd_t); |
| 538 |
__MPFR_DECLSPEC int mpfr_erandom (mpfr_ptr, gmp_randstate_t, mpfr_rnd_t); |
| 539 |
__MPFR_DECLSPEC int mpfr_urandomb (mpfr_ptr, gmp_randstate_t); |
| 540 |
|
| 541 |
__MPFR_DECLSPEC void mpfr_nextabove (mpfr_ptr); |
| 542 |
__MPFR_DECLSPEC void mpfr_nextbelow (mpfr_ptr); |
| 543 |
__MPFR_DECLSPEC void mpfr_nexttoward (mpfr_ptr, mpfr_srcptr); |
| 544 |
|
| 545 |
#ifndef MPFR_USE_MINI_GMP |
| 546 |
__MPFR_DECLSPEC int mpfr_printf (const char*, ...); |
| 547 |
__MPFR_DECLSPEC int mpfr_asprintf (char**, const char*, ...); |
| 548 |
__MPFR_DECLSPEC int mpfr_sprintf (char*, const char*, ...); |
| 549 |
__MPFR_DECLSPEC int mpfr_snprintf (char*, size_t, const char*, ...); |
| 550 |
#endif |
| 551 |
|
| 552 |
__MPFR_DECLSPEC int mpfr_pow (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t); |
| 553 |
__MPFR_DECLSPEC int mpfr_pow_si (mpfr_ptr, mpfr_srcptr, long, mpfr_rnd_t); |
| 554 |
__MPFR_DECLSPEC int mpfr_pow_ui (mpfr_ptr, mpfr_srcptr, unsigned long, |
| 555 |
mpfr_rnd_t); |
| 556 |
__MPFR_DECLSPEC int mpfr_ui_pow_ui (mpfr_ptr, unsigned long, unsigned long, |
| 557 |
mpfr_rnd_t); |
| 558 |
__MPFR_DECLSPEC int mpfr_ui_pow (mpfr_ptr, unsigned long, mpfr_srcptr, |
| 559 |
mpfr_rnd_t); |
| 560 |
__MPFR_DECLSPEC int mpfr_pow_z (mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t); |
| 561 |
|
| 562 |
__MPFR_DECLSPEC int mpfr_sqrt (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 563 |
__MPFR_DECLSPEC int mpfr_sqrt_ui (mpfr_ptr, unsigned long, mpfr_rnd_t); |
| 564 |
__MPFR_DECLSPEC int mpfr_rec_sqrt (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 565 |
|
| 566 |
__MPFR_DECLSPEC int mpfr_add (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t); |
| 567 |
__MPFR_DECLSPEC int mpfr_sub (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t); |
| 568 |
__MPFR_DECLSPEC int mpfr_mul (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t); |
| 569 |
__MPFR_DECLSPEC int mpfr_div (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t); |
| 570 |
|
| 571 |
__MPFR_DECLSPEC int mpfr_add_ui (mpfr_ptr, mpfr_srcptr, unsigned long, |
| 572 |
mpfr_rnd_t); |
| 573 |
__MPFR_DECLSPEC int mpfr_sub_ui (mpfr_ptr, mpfr_srcptr, unsigned long, |
| 574 |
mpfr_rnd_t); |
| 575 |
__MPFR_DECLSPEC int mpfr_ui_sub (mpfr_ptr, unsigned long, mpfr_srcptr, |
| 576 |
mpfr_rnd_t); |
| 577 |
__MPFR_DECLSPEC int mpfr_mul_ui (mpfr_ptr, mpfr_srcptr, unsigned long, |
| 578 |
mpfr_rnd_t); |
| 579 |
__MPFR_DECLSPEC int mpfr_div_ui (mpfr_ptr, mpfr_srcptr, unsigned long, |
| 580 |
mpfr_rnd_t); |
| 581 |
__MPFR_DECLSPEC int mpfr_ui_div (mpfr_ptr, unsigned long, mpfr_srcptr, |
| 582 |
mpfr_rnd_t); |
| 583 |
|
| 584 |
__MPFR_DECLSPEC int mpfr_add_si (mpfr_ptr, mpfr_srcptr, long, mpfr_rnd_t); |
| 585 |
__MPFR_DECLSPEC int mpfr_sub_si (mpfr_ptr, mpfr_srcptr, long, mpfr_rnd_t); |
| 586 |
__MPFR_DECLSPEC int mpfr_si_sub (mpfr_ptr, long, mpfr_srcptr, mpfr_rnd_t); |
| 587 |
__MPFR_DECLSPEC int mpfr_mul_si (mpfr_ptr, mpfr_srcptr, long, mpfr_rnd_t); |
| 588 |
__MPFR_DECLSPEC int mpfr_div_si (mpfr_ptr, mpfr_srcptr, long, mpfr_rnd_t); |
| 589 |
__MPFR_DECLSPEC int mpfr_si_div (mpfr_ptr, long, mpfr_srcptr, mpfr_rnd_t); |
| 590 |
|
| 591 |
__MPFR_DECLSPEC int mpfr_add_d (mpfr_ptr, mpfr_srcptr, double, mpfr_rnd_t); |
| 592 |
__MPFR_DECLSPEC int mpfr_sub_d (mpfr_ptr, mpfr_srcptr, double, mpfr_rnd_t); |
| 593 |
__MPFR_DECLSPEC int mpfr_d_sub (mpfr_ptr, double, mpfr_srcptr, mpfr_rnd_t); |
| 594 |
__MPFR_DECLSPEC int mpfr_mul_d (mpfr_ptr, mpfr_srcptr, double, mpfr_rnd_t); |
| 595 |
__MPFR_DECLSPEC int mpfr_div_d (mpfr_ptr, mpfr_srcptr, double, mpfr_rnd_t); |
| 596 |
__MPFR_DECLSPEC int mpfr_d_div (mpfr_ptr, double, mpfr_srcptr, mpfr_rnd_t); |
| 597 |
|
| 598 |
__MPFR_DECLSPEC int mpfr_sqr (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 599 |
|
| 600 |
__MPFR_DECLSPEC int mpfr_const_pi (mpfr_ptr, mpfr_rnd_t); |
| 601 |
__MPFR_DECLSPEC int mpfr_const_log2 (mpfr_ptr, mpfr_rnd_t); |
| 602 |
__MPFR_DECLSPEC int mpfr_const_euler (mpfr_ptr, mpfr_rnd_t); |
| 603 |
__MPFR_DECLSPEC int mpfr_const_catalan (mpfr_ptr, mpfr_rnd_t); |
| 604 |
|
| 605 |
__MPFR_DECLSPEC int mpfr_agm (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t); |
| 606 |
|
| 607 |
__MPFR_DECLSPEC int mpfr_log (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 608 |
__MPFR_DECLSPEC int mpfr_log2 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 609 |
__MPFR_DECLSPEC int mpfr_log10 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 610 |
__MPFR_DECLSPEC int mpfr_log1p (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 611 |
__MPFR_DECLSPEC int mpfr_log_ui (mpfr_ptr, unsigned long, mpfr_rnd_t); |
| 612 |
|
| 613 |
__MPFR_DECLSPEC int mpfr_exp (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 614 |
__MPFR_DECLSPEC int mpfr_exp2 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 615 |
__MPFR_DECLSPEC int mpfr_exp10 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 616 |
__MPFR_DECLSPEC int mpfr_expm1 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 617 |
__MPFR_DECLSPEC int mpfr_eint (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 618 |
__MPFR_DECLSPEC int mpfr_li2 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 619 |
|
| 620 |
__MPFR_DECLSPEC int mpfr_cmp (mpfr_srcptr, mpfr_srcptr); |
| 621 |
__MPFR_DECLSPEC int mpfr_cmp3 (mpfr_srcptr, mpfr_srcptr, int); |
| 622 |
__MPFR_DECLSPEC int mpfr_cmp_d (mpfr_srcptr, double); |
| 623 |
__MPFR_DECLSPEC int mpfr_cmp_ld (mpfr_srcptr, long double); |
| 624 |
__MPFR_DECLSPEC int mpfr_cmp_ui (mpfr_srcptr, unsigned long); |
| 625 |
__MPFR_DECLSPEC int mpfr_cmp_si (mpfr_srcptr, long); |
| 626 |
__MPFR_DECLSPEC int mpfr_cmp_ui_2exp (mpfr_srcptr, unsigned long, mpfr_exp_t); |
| 627 |
__MPFR_DECLSPEC int mpfr_cmp_si_2exp (mpfr_srcptr, long, mpfr_exp_t); |
| 628 |
__MPFR_DECLSPEC int mpfr_cmpabs (mpfr_srcptr, mpfr_srcptr); |
| 629 |
__MPFR_DECLSPEC int mpfr_cmpabs_ui (mpfr_srcptr, unsigned long); |
| 630 |
__MPFR_DECLSPEC void mpfr_reldiff (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, |
| 631 |
mpfr_rnd_t); |
| 632 |
__MPFR_DECLSPEC int mpfr_eq (mpfr_srcptr, mpfr_srcptr, unsigned long); |
| 633 |
__MPFR_DECLSPEC int mpfr_sgn (mpfr_srcptr); |
| 634 |
|
| 635 |
__MPFR_DECLSPEC int mpfr_mul_2exp (mpfr_ptr, mpfr_srcptr, unsigned long, |
| 636 |
mpfr_rnd_t); |
| 637 |
__MPFR_DECLSPEC int mpfr_div_2exp (mpfr_ptr, mpfr_srcptr, unsigned long, |
| 638 |
mpfr_rnd_t); |
| 639 |
__MPFR_DECLSPEC int mpfr_mul_2ui (mpfr_ptr, mpfr_srcptr, unsigned long, |
| 640 |
mpfr_rnd_t); |
| 641 |
__MPFR_DECLSPEC int mpfr_div_2ui (mpfr_ptr, mpfr_srcptr, unsigned long, |
| 642 |
mpfr_rnd_t); |
| 643 |
__MPFR_DECLSPEC int mpfr_mul_2si (mpfr_ptr, mpfr_srcptr, long, mpfr_rnd_t); |
| 644 |
__MPFR_DECLSPEC int mpfr_div_2si (mpfr_ptr, mpfr_srcptr, long, mpfr_rnd_t); |
| 645 |
|
| 646 |
__MPFR_DECLSPEC int mpfr_rint (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 647 |
__MPFR_DECLSPEC int mpfr_roundeven (mpfr_ptr, mpfr_srcptr); |
| 648 |
__MPFR_DECLSPEC int mpfr_round (mpfr_ptr, mpfr_srcptr); |
| 649 |
__MPFR_DECLSPEC int mpfr_trunc (mpfr_ptr, mpfr_srcptr); |
| 650 |
__MPFR_DECLSPEC int mpfr_ceil (mpfr_ptr, mpfr_srcptr); |
| 651 |
__MPFR_DECLSPEC int mpfr_floor (mpfr_ptr, mpfr_srcptr); |
| 652 |
__MPFR_DECLSPEC int mpfr_rint_roundeven (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 653 |
__MPFR_DECLSPEC int mpfr_rint_round (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 654 |
__MPFR_DECLSPEC int mpfr_rint_trunc (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 655 |
__MPFR_DECLSPEC int mpfr_rint_ceil (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 656 |
__MPFR_DECLSPEC int mpfr_rint_floor (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 657 |
__MPFR_DECLSPEC int mpfr_frac (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 658 |
__MPFR_DECLSPEC int mpfr_modf (mpfr_ptr, mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 659 |
__MPFR_DECLSPEC int mpfr_remquo (mpfr_ptr, long*, mpfr_srcptr, mpfr_srcptr, |
| 660 |
mpfr_rnd_t); |
| 661 |
__MPFR_DECLSPEC int mpfr_remainder (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, |
| 662 |
mpfr_rnd_t); |
| 663 |
__MPFR_DECLSPEC int mpfr_fmod (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t); |
| 664 |
__MPFR_DECLSPEC int mpfr_fmodquo (mpfr_ptr, long*, mpfr_srcptr, mpfr_srcptr, |
| 665 |
mpfr_rnd_t); |
| 666 |
|
| 667 |
__MPFR_DECLSPEC int mpfr_fits_ulong_p (mpfr_srcptr, mpfr_rnd_t); |
| 668 |
__MPFR_DECLSPEC int mpfr_fits_slong_p (mpfr_srcptr, mpfr_rnd_t); |
| 669 |
__MPFR_DECLSPEC int mpfr_fits_uint_p (mpfr_srcptr, mpfr_rnd_t); |
| 670 |
__MPFR_DECLSPEC int mpfr_fits_sint_p (mpfr_srcptr, mpfr_rnd_t); |
| 671 |
__MPFR_DECLSPEC int mpfr_fits_ushort_p (mpfr_srcptr, mpfr_rnd_t); |
| 672 |
__MPFR_DECLSPEC int mpfr_fits_sshort_p (mpfr_srcptr, mpfr_rnd_t); |
| 673 |
__MPFR_DECLSPEC int mpfr_fits_uintmax_p (mpfr_srcptr, mpfr_rnd_t); |
| 674 |
__MPFR_DECLSPEC int mpfr_fits_intmax_p (mpfr_srcptr, mpfr_rnd_t); |
| 675 |
|
| 676 |
__MPFR_DECLSPEC void mpfr_extract (mpz_ptr, mpfr_srcptr, unsigned int); |
| 677 |
__MPFR_DECLSPEC void mpfr_swap (mpfr_ptr, mpfr_ptr); |
| 678 |
__MPFR_DECLSPEC void mpfr_dump (mpfr_srcptr); |
| 679 |
|
| 680 |
__MPFR_DECLSPEC int mpfr_nan_p (mpfr_srcptr); |
| 681 |
__MPFR_DECLSPEC int mpfr_inf_p (mpfr_srcptr); |
| 682 |
__MPFR_DECLSPEC int mpfr_number_p (mpfr_srcptr); |
| 683 |
__MPFR_DECLSPEC int mpfr_integer_p (mpfr_srcptr); |
| 684 |
__MPFR_DECLSPEC int mpfr_zero_p (mpfr_srcptr); |
| 685 |
__MPFR_DECLSPEC int mpfr_regular_p (mpfr_srcptr); |
| 686 |
|
| 687 |
__MPFR_DECLSPEC int mpfr_greater_p (mpfr_srcptr, mpfr_srcptr); |
| 688 |
__MPFR_DECLSPEC int mpfr_greaterequal_p (mpfr_srcptr, mpfr_srcptr); |
| 689 |
__MPFR_DECLSPEC int mpfr_less_p (mpfr_srcptr, mpfr_srcptr); |
| 690 |
__MPFR_DECLSPEC int mpfr_lessequal_p (mpfr_srcptr, mpfr_srcptr); |
| 691 |
__MPFR_DECLSPEC int mpfr_lessgreater_p (mpfr_srcptr, mpfr_srcptr); |
| 692 |
__MPFR_DECLSPEC int mpfr_equal_p (mpfr_srcptr, mpfr_srcptr); |
| 693 |
__MPFR_DECLSPEC int mpfr_unordered_p (mpfr_srcptr, mpfr_srcptr); |
| 694 |
|
| 695 |
__MPFR_DECLSPEC int mpfr_atanh (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 696 |
__MPFR_DECLSPEC int mpfr_acosh (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 697 |
__MPFR_DECLSPEC int mpfr_asinh (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 698 |
__MPFR_DECLSPEC int mpfr_cosh (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 699 |
__MPFR_DECLSPEC int mpfr_sinh (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 700 |
__MPFR_DECLSPEC int mpfr_tanh (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 701 |
__MPFR_DECLSPEC int mpfr_sinh_cosh (mpfr_ptr, mpfr_ptr, mpfr_srcptr, |
| 702 |
mpfr_rnd_t); |
| 703 |
|
| 704 |
__MPFR_DECLSPEC int mpfr_sech (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 705 |
__MPFR_DECLSPEC int mpfr_csch (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 706 |
__MPFR_DECLSPEC int mpfr_coth (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 707 |
|
| 708 |
__MPFR_DECLSPEC int mpfr_acos (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 709 |
__MPFR_DECLSPEC int mpfr_asin (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 710 |
__MPFR_DECLSPEC int mpfr_atan (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 711 |
__MPFR_DECLSPEC int mpfr_sin (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 712 |
__MPFR_DECLSPEC int mpfr_sin_cos (mpfr_ptr, mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 713 |
__MPFR_DECLSPEC int mpfr_cos (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 714 |
__MPFR_DECLSPEC int mpfr_tan (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 715 |
__MPFR_DECLSPEC int mpfr_atan2 (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t); |
| 716 |
__MPFR_DECLSPEC int mpfr_sec (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 717 |
__MPFR_DECLSPEC int mpfr_csc (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 718 |
__MPFR_DECLSPEC int mpfr_cot (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 719 |
|
| 720 |
__MPFR_DECLSPEC int mpfr_hypot (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t); |
| 721 |
__MPFR_DECLSPEC int mpfr_erf (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 722 |
__MPFR_DECLSPEC int mpfr_erfc (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 723 |
__MPFR_DECLSPEC int mpfr_cbrt (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 724 |
#ifndef _MPFR_NO_DEPRECATED_ROOT /* for the test of this function */ |
| 725 |
MPFR_DEPRECATED |
| 726 |
#endif |
| 727 |
__MPFR_DECLSPEC int mpfr_root (mpfr_ptr, mpfr_srcptr, unsigned long, |
| 728 |
mpfr_rnd_t); |
| 729 |
__MPFR_DECLSPEC int mpfr_rootn_ui (mpfr_ptr, mpfr_srcptr, unsigned long, |
| 730 |
mpfr_rnd_t); |
| 731 |
__MPFR_DECLSPEC int mpfr_gamma (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 732 |
__MPFR_DECLSPEC int mpfr_gamma_inc (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, |
| 733 |
mpfr_rnd_t); |
| 734 |
__MPFR_DECLSPEC int mpfr_beta (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t); |
| 735 |
__MPFR_DECLSPEC int mpfr_lngamma (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 736 |
__MPFR_DECLSPEC int mpfr_lgamma (mpfr_ptr, int *, mpfr_srcptr, mpfr_rnd_t); |
| 737 |
__MPFR_DECLSPEC int mpfr_digamma (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 738 |
__MPFR_DECLSPEC int mpfr_zeta (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 739 |
__MPFR_DECLSPEC int mpfr_zeta_ui (mpfr_ptr, unsigned long, mpfr_rnd_t); |
| 740 |
__MPFR_DECLSPEC int mpfr_fac_ui (mpfr_ptr, unsigned long, mpfr_rnd_t); |
| 741 |
__MPFR_DECLSPEC int mpfr_j0 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 742 |
__MPFR_DECLSPEC int mpfr_j1 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 743 |
__MPFR_DECLSPEC int mpfr_jn (mpfr_ptr, long, mpfr_srcptr, mpfr_rnd_t); |
| 744 |
__MPFR_DECLSPEC int mpfr_y0 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 745 |
__MPFR_DECLSPEC int mpfr_y1 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 746 |
__MPFR_DECLSPEC int mpfr_yn (mpfr_ptr, long, mpfr_srcptr, mpfr_rnd_t); |
| 747 |
|
| 748 |
__MPFR_DECLSPEC int mpfr_ai (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t); |
| 749 |
|
| 750 |
__MPFR_DECLSPEC int mpfr_min (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t); |
| 751 |
__MPFR_DECLSPEC int mpfr_max (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t); |
| 752 |
__MPFR_DECLSPEC int mpfr_dim (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t); |
| 753 |
|
| 754 |
__MPFR_DECLSPEC int mpfr_mul_z (mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t); |
| 755 |
__MPFR_DECLSPEC int mpfr_div_z (mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t); |
| 756 |
__MPFR_DECLSPEC int mpfr_add_z (mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t); |
| 757 |
__MPFR_DECLSPEC int mpfr_sub_z (mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t); |
| 758 |
__MPFR_DECLSPEC int mpfr_z_sub (mpfr_ptr, mpz_srcptr, mpfr_srcptr, mpfr_rnd_t); |
| 759 |
__MPFR_DECLSPEC int mpfr_cmp_z (mpfr_srcptr, mpz_srcptr); |
| 760 |
|
| 761 |
__MPFR_DECLSPEC int mpfr_fma (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, |
| 762 |
mpfr_rnd_t); |
| 763 |
__MPFR_DECLSPEC int mpfr_fms (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, |
| 764 |
mpfr_rnd_t); |
| 765 |
__MPFR_DECLSPEC int mpfr_fmma (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, |
| 766 |
mpfr_srcptr, mpfr_rnd_t); |
| 767 |
__MPFR_DECLSPEC int mpfr_fmms (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, |
| 768 |
mpfr_srcptr, mpfr_rnd_t); |
| 769 |
__MPFR_DECLSPEC int mpfr_sum (mpfr_ptr, const mpfr_ptr *, unsigned long, |
| 770 |
mpfr_rnd_t); |
| 771 |
__MPFR_DECLSPEC int mpfr_dot (mpfr_ptr, const mpfr_ptr *, const mpfr_ptr *, |
| 772 |
unsigned long, mpfr_rnd_t); |
| 773 |
|
| 774 |
__MPFR_DECLSPEC void mpfr_free_cache (void); |
| 775 |
__MPFR_DECLSPEC void mpfr_free_cache2 (mpfr_free_cache_t); |
| 776 |
__MPFR_DECLSPEC void mpfr_free_pool (void); |
| 777 |
__MPFR_DECLSPEC int mpfr_mp_memory_cleanup (void); |
| 778 |
|
| 779 |
__MPFR_DECLSPEC int mpfr_subnormalize (mpfr_ptr, int, mpfr_rnd_t); |
| 780 |
|
| 781 |
__MPFR_DECLSPEC int mpfr_strtofr (mpfr_ptr, const char *, char **, int, |
| 782 |
mpfr_rnd_t); |
| 783 |
|
| 784 |
__MPFR_DECLSPEC void mpfr_round_nearest_away_begin (mpfr_ptr); |
| 785 |
__MPFR_DECLSPEC int mpfr_round_nearest_away_end (mpfr_ptr, int); |
| 786 |
|
| 787 |
__MPFR_DECLSPEC size_t mpfr_custom_get_size (mpfr_prec_t); |
| 788 |
__MPFR_DECLSPEC void mpfr_custom_init (void *, mpfr_prec_t); |
| 789 |
__MPFR_DECLSPEC MPFR_RETURNS_NONNULL void * |
| 790 |
mpfr_custom_get_significand (mpfr_srcptr); |
| 791 |
__MPFR_DECLSPEC mpfr_exp_t mpfr_custom_get_exp (mpfr_srcptr); |
| 792 |
__MPFR_DECLSPEC void mpfr_custom_move (mpfr_ptr, void *); |
| 793 |
__MPFR_DECLSPEC void mpfr_custom_init_set (mpfr_ptr, int, mpfr_exp_t, |
| 794 |
mpfr_prec_t, void *); |
| 795 |
__MPFR_DECLSPEC int mpfr_custom_get_kind (mpfr_srcptr); |
| 796 |
|
| 797 |
__MPFR_DECLSPEC int mpfr_total_order_p (mpfr_srcptr, mpfr_srcptr); |
| 798 |
|
| 799 |
#if defined (__cplusplus) |
| 800 |
} |
| 801 |
#endif |
| 802 |
|
| 803 |
/* Define MPFR_USE_EXTENSION to avoid "gcc -pedantic" warnings. */ |
| 804 |
#ifndef MPFR_EXTENSION |
| 805 |
# if defined(MPFR_USE_EXTENSION) |
| 806 |
# define MPFR_EXTENSION __extension__ |
| 807 |
# else |
| 808 |
# define MPFR_EXTENSION |
| 809 |
# endif |
| 810 |
#endif |
| 811 |
|
| 812 |
/* Warning! This macro doesn't work with K&R C (e.g., compare the "gcc -E" |
| 813 |
output with and without -traditional) and shouldn't be used internally. |
| 814 |
For public use only, but see the MPFR manual. */ |
| 815 |
#define MPFR_DECL_INIT(_x, _p) \ |
| 816 |
MPFR_EXTENSION mp_limb_t __gmpfr_local_tab_##_x[((_p)-1)/GMP_NUMB_BITS+1]; \ |
| 817 |
MPFR_EXTENSION mpfr_t _x = {{(_p),1,__MPFR_EXP_NAN,__gmpfr_local_tab_##_x}} |
| 818 |
|
| 819 |
#if MPFR_USE_C99_FEATURE |
| 820 |
/* C99 & C11 version: functions with multiple inputs supported */ |
| 821 |
#define mpfr_round_nearest_away(func, rop, ...) \ |
| 822 |
(mpfr_round_nearest_away_begin(rop), \ |
| 823 |
mpfr_round_nearest_away_end((rop), func((rop), __VA_ARGS__, MPFR_RNDN))) |
| 824 |
#else |
| 825 |
/* C89 version: function with one input supported */ |
| 826 |
#define mpfr_round_nearest_away(func, rop, op) \ |
| 827 |
(mpfr_round_nearest_away_begin(rop), \ |
| 828 |
mpfr_round_nearest_away_end((rop), func((rop), (op), MPFR_RNDN))) |
| 829 |
#endif |
| 830 |
|
| 831 |
/* Fast access macros to replace function interface. |
| 832 |
If the USER don't want to use the macro interface, let him make happy |
| 833 |
even if it produces faster and smaller code. */ |
| 834 |
#ifndef MPFR_USE_NO_MACRO |
| 835 |
|
| 836 |
/* In the implementation of these macros, we need to make sure that the |
| 837 |
arguments are evaluated one time exactly and that type conversion is |
| 838 |
done as it would be with a function. Tests should be added to ensure |
| 839 |
that. |
| 840 |
Note that the macros for the custom interface are not concerned; the |
| 841 |
MPFR manual has been clarified. */ |
| 842 |
|
| 843 |
/* Prevent x from being used as an lvalue. |
| 844 |
Thanks to Wojtek Lerch and Tim Rentsch for the idea. */ |
| 845 |
#define MPFR_VALUE_OF(x) (0 ? (x) : (x)) |
| 846 |
|
| 847 |
/* The following macro converts the argument to mpfr_srcptr, as in type |
| 848 |
conversion for function parameters. But it will detect disallowed |
| 849 |
implicit conversions, e.g. when the argument has an integer type. */ |
| 850 |
#define MPFR_SRCPTR(x) ((mpfr_srcptr) (0 ? (x) : (mpfr_srcptr) (x))) |
| 851 |
#define MPFR_GET_SIGN(_x) MPFR_VALUE_OF(MPFR_SIGN(MPFR_SRCPTR(_x))) |
| 852 |
|
| 853 |
#define mpfr_nan_p(_x) (MPFR_SRCPTR(_x)->_mpfr_exp == __MPFR_EXP_NAN) |
| 854 |
#define mpfr_inf_p(_x) (MPFR_SRCPTR(_x)->_mpfr_exp == __MPFR_EXP_INF) |
| 855 |
#define mpfr_zero_p(_x) (MPFR_SRCPTR(_x)->_mpfr_exp == __MPFR_EXP_ZERO) |
| 856 |
#define mpfr_regular_p(_x) (MPFR_SRCPTR(_x)->_mpfr_exp > __MPFR_EXP_INF) |
| 857 |
|
| 858 |
/* mpfr_sgn is documented as a macro, thus the following code is fine. |
| 859 |
But it would be safer to regard it as a function in some future |
| 860 |
MPFR version. */ |
| 861 |
#define mpfr_sgn(_x) \ |
| 862 |
((_x)->_mpfr_exp < __MPFR_EXP_INF ? \ |
| 863 |
(mpfr_nan_p (_x) ? mpfr_set_erangeflag () : (mpfr_void) 0), 0 : \ |
| 864 |
MPFR_SIGN (_x)) |
| 865 |
|
| 866 |
#define mpfr_get_prec(_x) MPFR_VALUE_OF(MPFR_SRCPTR(_x)->_mpfr_prec) |
| 867 |
#define mpfr_get_exp(_x) MPFR_VALUE_OF(MPFR_SRCPTR(_x)->_mpfr_exp) |
| 868 |
/* Note: Defining mpfr_get_exp() as a macro has the effect to disable |
| 869 |
the check that the argument is a pure FP number (done in the function); |
| 870 |
this increases the risk of undetected error and makes debugging more |
| 871 |
complex. Is it really worth in practice? (Potential FIXME) */ |
| 872 |
|
| 873 |
#define mpfr_round(a,b) mpfr_rint((a), (b), MPFR_RNDNA) |
| 874 |
#define mpfr_trunc(a,b) mpfr_rint((a), (b), MPFR_RNDZ) |
| 875 |
#define mpfr_ceil(a,b) mpfr_rint((a), (b), MPFR_RNDU) |
| 876 |
#define mpfr_floor(a,b) mpfr_rint((a), (b), MPFR_RNDD) |
| 877 |
|
| 878 |
#define mpfr_cmp_ui(b,i) mpfr_cmp_ui_2exp((b),(i),0) |
| 879 |
#define mpfr_cmp_si(b,i) mpfr_cmp_si_2exp((b),(i),0) |
| 880 |
#if __GNUC__ > 2 || __GNUC_MINOR__ >= 95 |
| 881 |
#define mpfr_set(a,b,r) \ |
| 882 |
__extension__ ({ \ |
| 883 |
mpfr_srcptr _p = (b); \ |
| 884 |
mpfr_set4(a,_p,r,MPFR_SIGN(_p)); \ |
| 885 |
}) |
| 886 |
#endif |
| 887 |
#define mpfr_abs(a,b,r) mpfr_set4(a,b,r,1) |
| 888 |
#define mpfr_copysign(a,b,c,r) mpfr_set4(a,b,r,MPFR_GET_SIGN(c)) |
| 889 |
#define mpfr_setsign(a,b,s,r) mpfr_set4(a,b,r,(s) ? -1 : 1) |
| 890 |
#define mpfr_signbit(x) (MPFR_GET_SIGN(x) < 0) |
| 891 |
#define mpfr_cmp(b, c) mpfr_cmp3(b, c, 1) |
| 892 |
#define mpfr_mul_2exp(y,x,n,r) mpfr_mul_2ui((y),(x),(n),(r)) |
| 893 |
#define mpfr_div_2exp(y,x,n,r) mpfr_div_2ui((y),(x),(n),(r)) |
| 894 |
|
| 895 |
|
| 896 |
/* When using GCC or ICC, optimize certain common comparisons and affectations. |
| 897 |
Added casts to improve robustness in case of undefined behavior and |
| 898 |
compiler extensions based on UB (in particular -fwrapv). MPFR doesn't |
| 899 |
use such extensions, but these macros will be used by 3rd-party code, |
| 900 |
where such extensions may be required. |
| 901 |
Moreover casts to unsigned long have been added to avoid warnings in |
| 902 |
programs that use MPFR and are compiled with -Wconversion; such casts |
| 903 |
are OK since if X is a constant expression, then (unsigned long) X is |
| 904 |
also a constant expression, so that the optimizations still work. The |
| 905 |
warnings are probably related to the following two bugs: |
| 906 |
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=4210 |
| 907 |
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=38470 (possibly a variant) |
| 908 |
and the casts could be removed once these bugs are fixed. |
| 909 |
Casts shouldn't be used on the generic calls (to the ..._2exp functions), |
| 910 |
where implicit conversions are performed. Indeed, having at least one |
| 911 |
implicit conversion in the macro allows the compiler to emit diagnostics |
| 912 |
when normally expected, for instance in the following call: |
| 913 |
mpfr_set_ui (x, "foo", MPFR_RNDN); |
| 914 |
If this is not possible (for future macros), one of the tricks described |
| 915 |
on http://groups.google.com/group/comp.std.c/msg/e92abd24bf9eaf7b could |
| 916 |
be used. */ |
| 917 |
#if defined (__GNUC__) && !defined(__cplusplus) |
| 918 |
#if (__GNUC__ >= 2) |
| 919 |
|
| 920 |
#undef mpfr_cmp_ui |
| 921 |
/* We use the fact that mpfr_sgn on NaN sets the erange flag and returns 0. |
| 922 |
But warning! mpfr_sgn is specified as a macro in the API, thus the macro |
| 923 |
mustn't be used if side effects are possible, like here. */ |
| 924 |
#define mpfr_cmp_ui(_f,_u) \ |
| 925 |
(__builtin_constant_p (_u) && (mpfr_ulong) (_u) == 0 ? \ |
| 926 |
(mpfr_sgn) (_f) : \ |
| 927 |
mpfr_cmp_ui_2exp ((_f), (_u), 0)) |
| 928 |
|
| 929 |
#undef mpfr_cmp_si |
| 930 |
#define mpfr_cmp_si(_f,_s) \ |
| 931 |
(__builtin_constant_p (_s) && (mpfr_long) (_s) >= 0 ? \ |
| 932 |
mpfr_cmp_ui ((_f), (mpfr_ulong) (mpfr_long) (_s)) : \ |
| 933 |
mpfr_cmp_si_2exp ((_f), (_s), 0)) |
| 934 |
|
| 935 |
#if __GNUC__ > 2 || __GNUC_MINOR__ >= 95 |
| 936 |
#undef mpfr_set_ui |
| 937 |
#define mpfr_set_ui(_f,_u,_r) \ |
| 938 |
(__builtin_constant_p (_u) && (mpfr_ulong) (_u) == 0 ? \ |
| 939 |
__extension__ ({ \ |
| 940 |
mpfr_ptr _p = (_f); \ |
| 941 |
_p->_mpfr_sign = 1; \ |
| 942 |
_p->_mpfr_exp = __MPFR_EXP_ZERO; \ |
| 943 |
(mpfr_void) (_r); 0; }) : \ |
| 944 |
mpfr_set_ui_2exp ((_f), (_u), 0, (_r))) |
| 945 |
#endif |
| 946 |
|
| 947 |
#undef mpfr_set_si |
| 948 |
#define mpfr_set_si(_f,_s,_r) \ |
| 949 |
(__builtin_constant_p (_s) && (mpfr_long) (_s) >= 0 ? \ |
| 950 |
mpfr_set_ui ((_f), (mpfr_ulong) (mpfr_long) (_s), (_r)) : \ |
| 951 |
mpfr_set_si_2exp ((_f), (_s), 0, (_r))) |
| 952 |
|
| 953 |
#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) |
| 954 |
/* If the source is a constant number that is a power of 2, |
| 955 |
optimize the call */ |
| 956 |
#undef mpfr_mul_ui |
| 957 |
#define mpfr_mul_ui(_f, _g, _u,_r) \ |
| 958 |
(__builtin_constant_p (_u) && (mpfr_ulong) (_u) >= 1 && \ |
| 959 |
((mpfr_ulong) (_u) & ((mpfr_ulong) (_u) - 1)) == 0 ? \ |
| 960 |
mpfr_mul_2si((_f), (_g), __builtin_ctzl (_u), (_r)) : \ |
| 961 |
mpfr_mul_ui ((_f), (_g), (_u), (_r))) |
| 962 |
#undef mpfr_div_ui |
| 963 |
#define mpfr_div_ui(_f, _g, _u,_r) \ |
| 964 |
(__builtin_constant_p (_u) && (mpfr_ulong) (_u) >= 1 && \ |
| 965 |
((mpfr_ulong) (_u) & ((mpfr_ulong) (_u) - 1)) == 0 ? \ |
| 966 |
mpfr_mul_2si((_f), (_g), - __builtin_ctzl (_u), (_r)) : \ |
| 967 |
mpfr_div_ui ((_f), (_g), (_u), (_r))) |
| 968 |
#endif |
| 969 |
|
| 970 |
/* If the source is a constant number that is non-negative, |
| 971 |
optimize the call */ |
| 972 |
#undef mpfr_mul_si |
| 973 |
#define mpfr_mul_si(_f, _g, _s,_r) \ |
| 974 |
(__builtin_constant_p (_s) && (mpfr_long) (_s) >= 0 ? \ |
| 975 |
mpfr_mul_ui ((_f), (_g), (mpfr_ulong) (mpfr_long) (_s), (_r)) : \ |
| 976 |
mpfr_mul_si ((_f), (_g), (_s), (_r))) |
| 977 |
#undef mpfr_div_si |
| 978 |
#define mpfr_div_si(_f, _g, _s,_r) \ |
| 979 |
(__builtin_constant_p (_s) && (mpfr_long) (_s) >= 0 ? \ |
| 980 |
mpfr_div_ui ((_f), (_g), (mpfr_ulong) (mpfr_long) (_s), (_r)) : \ |
| 981 |
mpfr_div_si ((_f), (_g), (_s), (_r))) |
| 982 |
|
| 983 |
#endif |
| 984 |
#endif |
| 985 |
|
| 986 |
/* Macro version of mpfr_stack interface for fast access */ |
| 987 |
#define mpfr_custom_get_size(p) ((mpfr_size_t) \ |
| 988 |
(((p)+GMP_NUMB_BITS-1)/GMP_NUMB_BITS*sizeof (mp_limb_t))) |
| 989 |
#define mpfr_custom_init(m,p) do {} while (0) |
| 990 |
#define mpfr_custom_get_significand(x) ((mpfr_void*)((x)->_mpfr_d)) |
| 991 |
#define mpfr_custom_get_exp(x) ((x)->_mpfr_exp) |
| 992 |
#define mpfr_custom_move(x,m) do { ((x)->_mpfr_d = (mp_limb_t*)(m)); } while (0) |
| 993 |
#define mpfr_custom_init_set(x,k,e,p,m) do { \ |
| 994 |
mpfr_ptr _x = (x); \ |
| 995 |
mpfr_exp_t _e; \ |
| 996 |
mpfr_kind_t _t; \ |
| 997 |
mpfr_int _s, _k; \ |
| 998 |
_k = (k); \ |
| 999 |
if (_k >= 0) { \ |
| 1000 |
_t = (mpfr_kind_t) _k; \ |
| 1001 |
_s = 1; \ |
| 1002 |
} else { \ |
| 1003 |
_t = (mpfr_kind_t) - _k; \ |
| 1004 |
_s = -1; \ |
| 1005 |
} \ |
| 1006 |
_e = _t == MPFR_REGULAR_KIND ? (e) : \ |
| 1007 |
_t == MPFR_NAN_KIND ? __MPFR_EXP_NAN : \ |
| 1008 |
_t == MPFR_INF_KIND ? __MPFR_EXP_INF : __MPFR_EXP_ZERO; \ |
| 1009 |
_x->_mpfr_prec = (p); \ |
| 1010 |
_x->_mpfr_sign = _s; \ |
| 1011 |
_x->_mpfr_exp = _e; \ |
| 1012 |
_x->_mpfr_d = (mp_limb_t*) (m); \ |
| 1013 |
} while (0) |
| 1014 |
#define mpfr_custom_get_kind(x) \ |
| 1015 |
( (x)->_mpfr_exp > __MPFR_EXP_INF ? \ |
| 1016 |
(mpfr_int) MPFR_REGULAR_KIND * MPFR_SIGN (x) \ |
| 1017 |
: (x)->_mpfr_exp == __MPFR_EXP_INF ? \ |
| 1018 |
(mpfr_int) MPFR_INF_KIND * MPFR_SIGN (x) \ |
| 1019 |
: (x)->_mpfr_exp == __MPFR_EXP_NAN ? (mpfr_int) MPFR_NAN_KIND \ |
| 1020 |
: (mpfr_int) MPFR_ZERO_KIND * MPFR_SIGN (x) ) |
| 1021 |
|
| 1022 |
|
| 1023 |
#endif /* MPFR_USE_NO_MACRO */ |
| 1024 |
|
| 1025 |
/* These are defined to be macros */ |
| 1026 |
#define mpfr_init_set_si(x, i, rnd) \ |
| 1027 |
( mpfr_init(x), mpfr_set_si((x), (i), (rnd)) ) |
| 1028 |
#define mpfr_init_set_ui(x, i, rnd) \ |
| 1029 |
( mpfr_init(x), mpfr_set_ui((x), (i), (rnd)) ) |
| 1030 |
#define mpfr_init_set_d(x, d, rnd) \ |
| 1031 |
( mpfr_init(x), mpfr_set_d((x), (d), (rnd)) ) |
| 1032 |
#define mpfr_init_set_ld(x, d, rnd) \ |
| 1033 |
( mpfr_init(x), mpfr_set_ld((x), (d), (rnd)) ) |
| 1034 |
#define mpfr_init_set_z(x, i, rnd) \ |
| 1035 |
( mpfr_init(x), mpfr_set_z((x), (i), (rnd)) ) |
| 1036 |
#ifndef MPFR_USE_MINI_GMP |
| 1037 |
#define mpfr_init_set_q(x, i, rnd) \ |
| 1038 |
( mpfr_init(x), mpfr_set_q((x), (i), (rnd)) ) |
| 1039 |
#define mpfr_init_set_f(x, y, rnd) \ |
| 1040 |
( mpfr_init(x), mpfr_set_f((x), (y), (rnd)) ) |
| 1041 |
#endif |
| 1042 |
#define mpfr_init_set(x, y, rnd) \ |
| 1043 |
( mpfr_init(x), mpfr_set((x), (y), (rnd)) ) |
| 1044 |
|
| 1045 |
/* Compatibility layer -- obsolete functions and macros */ |
| 1046 |
/* Note: it is not possible to output warnings, unless one defines |
| 1047 |
* a deprecated variable and uses it, e.g. |
| 1048 |
* MPFR_DEPRECATED extern int mpfr_deprecated_feature; |
| 1049 |
* #define MPFR_EMIN_MIN ((void)mpfr_deprecated_feature,mpfr_get_emin_min()) |
| 1050 |
* (the cast to void avoids a warning because the left-hand operand |
| 1051 |
* has no effect). |
| 1052 |
*/ |
| 1053 |
#define mpfr_cmp_abs mpfr_cmpabs |
| 1054 |
#define mpfr_round_prec(x,r,p) mpfr_prec_round(x,p,r) |
| 1055 |
#define __gmp_default_rounding_mode (mpfr_get_default_rounding_mode()) |
| 1056 |
#define __mpfr_emin (mpfr_get_emin()) |
| 1057 |
#define __mpfr_emax (mpfr_get_emax()) |
| 1058 |
#define __mpfr_default_fp_bit_precision (mpfr_get_default_fp_bit_precision()) |
| 1059 |
#define MPFR_EMIN_MIN mpfr_get_emin_min() |
| 1060 |
#define MPFR_EMIN_MAX mpfr_get_emin_max() |
| 1061 |
#define MPFR_EMAX_MIN mpfr_get_emax_min() |
| 1062 |
#define MPFR_EMAX_MAX mpfr_get_emax_max() |
| 1063 |
#define mpfr_version (mpfr_get_version()) |
| 1064 |
#ifndef mpz_set_fr |
| 1065 |
# define mpz_set_fr mpfr_get_z |
| 1066 |
#endif |
| 1067 |
#define mpfr_get_z_exp mpfr_get_z_2exp |
| 1068 |
#define mpfr_custom_get_mantissa mpfr_custom_get_significand |
| 1069 |
|
| 1070 |
#endif /* __MPFR_H */ |
| 1071 |
|
| 1072 |
|
| 1073 |
/* Check if <stdint.h> / <inttypes.h> is included or if the user |
| 1074 |
explicitly wants intmax_t. Automatic detection is done by |
| 1075 |
checking: |
| 1076 |
- INTMAX_C and UINTMAX_C, but not if the compiler is a C++ one |
| 1077 |
(as suggested by Patrick Pelissier) because the test does not |
| 1078 |
work well in this case. See: |
| 1079 |
https://sympa.inria.fr/sympa/arc/mpfr/2010-02/msg00025.html |
| 1080 |
We do not check INTMAX_MAX and UINTMAX_MAX because under Solaris, |
| 1081 |
these macros are always defined by <limits.h> (i.e. even when |
| 1082 |
<stdint.h> and <inttypes.h> are not included). |
| 1083 |
- _STDINT_H (defined by the glibc), _STDINT_H_ (defined under |
| 1084 |
Mac OS X) and _STDINT (defined under MS Visual Studio), but |
| 1085 |
this test may not work with all implementations. |
| 1086 |
Portable software should not rely on these tests. |
| 1087 |
*/ |
| 1088 |
#if (defined (INTMAX_C) && defined (UINTMAX_C) && !defined(__cplusplus)) || \ |
| 1089 |
defined (MPFR_USE_INTMAX_T) || \ |
| 1090 |
defined (_STDINT_H) || defined (_STDINT_H_) || defined (_STDINT) || \ |
| 1091 |
defined (_SYS_STDINT_H_) /* needed for FreeBSD */ |
| 1092 |
# ifndef _MPFR_H_HAVE_INTMAX_T |
| 1093 |
# define _MPFR_H_HAVE_INTMAX_T 1 |
| 1094 |
|
| 1095 |
#if defined (__cplusplus) |
| 1096 |
extern "C" { |
| 1097 |
#endif |
| 1098 |
|
| 1099 |
#define mpfr_set_sj __gmpfr_set_sj |
| 1100 |
#define mpfr_set_sj_2exp __gmpfr_set_sj_2exp |
| 1101 |
#define mpfr_set_uj __gmpfr_set_uj |
| 1102 |
#define mpfr_set_uj_2exp __gmpfr_set_uj_2exp |
| 1103 |
#define mpfr_get_sj __gmpfr_mpfr_get_sj |
| 1104 |
#define mpfr_get_uj __gmpfr_mpfr_get_uj |
| 1105 |
__MPFR_DECLSPEC int mpfr_set_sj (mpfr_ptr, intmax_t, mpfr_rnd_t); |
| 1106 |
__MPFR_DECLSPEC int mpfr_set_sj_2exp (mpfr_ptr, intmax_t, intmax_t, |
| 1107 |
mpfr_rnd_t); |
| 1108 |
__MPFR_DECLSPEC int mpfr_set_uj (mpfr_ptr, uintmax_t, mpfr_rnd_t); |
| 1109 |
__MPFR_DECLSPEC int mpfr_set_uj_2exp (mpfr_ptr, uintmax_t, intmax_t, |
| 1110 |
mpfr_rnd_t); |
| 1111 |
__MPFR_DECLSPEC intmax_t mpfr_get_sj (mpfr_srcptr, mpfr_rnd_t); |
| 1112 |
__MPFR_DECLSPEC uintmax_t mpfr_get_uj (mpfr_srcptr, mpfr_rnd_t); |
| 1113 |
|
| 1114 |
#if defined (__cplusplus) |
| 1115 |
} |
| 1116 |
#endif |
| 1117 |
|
| 1118 |
# endif /* _MPFR_H_HAVE_INTMAX_T */ |
| 1119 |
#endif |
| 1120 |
|
| 1121 |
|
| 1122 |
/* Check if <stdio.h> has been included or if the user wants FILE */ |
| 1123 |
#if defined (_GMP_H_HAVE_FILE) || defined (MPFR_USE_FILE) |
| 1124 |
# ifndef _MPFR_H_HAVE_FILE |
| 1125 |
# define _MPFR_H_HAVE_FILE 1 |
| 1126 |
|
| 1127 |
#if defined (__cplusplus) |
| 1128 |
extern "C" { |
| 1129 |
#endif |
| 1130 |
|
| 1131 |
#define mpfr_inp_str __gmpfr_inp_str |
| 1132 |
#define mpfr_out_str __gmpfr_out_str |
| 1133 |
__MPFR_DECLSPEC size_t mpfr_inp_str (mpfr_ptr, FILE*, int, mpfr_rnd_t); |
| 1134 |
__MPFR_DECLSPEC size_t mpfr_out_str (FILE*, int, size_t, mpfr_srcptr, |
| 1135 |
mpfr_rnd_t); |
| 1136 |
#ifndef MPFR_USE_MINI_GMP |
| 1137 |
#define mpfr_fprintf __gmpfr_fprintf |
| 1138 |
__MPFR_DECLSPEC int mpfr_fprintf (FILE*, const char*, ...); |
| 1139 |
#endif |
| 1140 |
#define mpfr_fpif_export __gmpfr_fpif_export |
| 1141 |
#define mpfr_fpif_import __gmpfr_fpif_import |
| 1142 |
__MPFR_DECLSPEC int mpfr_fpif_export (FILE*, mpfr_ptr); |
| 1143 |
__MPFR_DECLSPEC int mpfr_fpif_import (mpfr_ptr, FILE*); |
| 1144 |
|
| 1145 |
#if defined (__cplusplus) |
| 1146 |
} |
| 1147 |
#endif |
| 1148 |
|
| 1149 |
# endif /* _MPFR_H_HAVE_FILE */ |
| 1150 |
#endif |
| 1151 |
|
| 1152 |
|
| 1153 |
/* check if <stdarg.h> has been included or if the user wants va_list */ |
| 1154 |
#if defined (_GMP_H_HAVE_VA_LIST) || defined (MPFR_USE_VA_LIST) |
| 1155 |
# ifndef _MPFR_H_HAVE_VA_LIST |
| 1156 |
# define _MPFR_H_HAVE_VA_LIST 1 |
| 1157 |
|
| 1158 |
#if defined (__cplusplus) |
| 1159 |
extern "C" { |
| 1160 |
#endif |
| 1161 |
|
| 1162 |
#define mpfr_vprintf __gmpfr_vprintf |
| 1163 |
#define mpfr_vasprintf __gmpfr_vasprintf |
| 1164 |
#define mpfr_vsprintf __gmpfr_vsprintf |
| 1165 |
#define mpfr_vsnprintf __gmpfr_vsnprintf |
| 1166 |
__MPFR_DECLSPEC int mpfr_vprintf (const char*, va_list); |
| 1167 |
__MPFR_DECLSPEC int mpfr_vasprintf (char**, const char*, va_list); |
| 1168 |
__MPFR_DECLSPEC int mpfr_vsprintf (char*, const char*, va_list); |
| 1169 |
__MPFR_DECLSPEC int mpfr_vsnprintf (char*, size_t, const char*, va_list); |
| 1170 |
|
| 1171 |
#if defined (__cplusplus) |
| 1172 |
} |
| 1173 |
#endif |
| 1174 |
|
| 1175 |
# endif /* _MPFR_H_HAVE_VA_LIST */ |
| 1176 |
#endif |
| 1177 |
|
| 1178 |
|
| 1179 |
/* check if <stdarg.h> has been included and if FILE is available |
| 1180 |
(see above) */ |
| 1181 |
#if defined (_MPFR_H_HAVE_VA_LIST) && defined (_MPFR_H_HAVE_FILE) |
| 1182 |
# ifndef _MPFR_H_HAVE_VA_LIST_FILE |
| 1183 |
# define _MPFR_H_HAVE_VA_LIST_FILE 1 |
| 1184 |
|
| 1185 |
#if defined (__cplusplus) |
| 1186 |
extern "C" { |
| 1187 |
#endif |
| 1188 |
|
| 1189 |
#define mpfr_vfprintf __gmpfr_vfprintf |
| 1190 |
__MPFR_DECLSPEC int mpfr_vfprintf (FILE*, const char*, va_list); |
| 1191 |
|
| 1192 |
#if defined (__cplusplus) |
| 1193 |
} |
| 1194 |
#endif |
| 1195 |
|
| 1196 |
# endif /* _MPFR_H_HAVE_VA_LIST_FILE */ |
| 1197 |
#endif |
