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 1198