This manual documents how to install and use the Multiple Precision +Floating-Point Reliable Library, version 2.3.2. + +
Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. + +
Permission is granted to copy, distribute and/or modify this document under +the terms of the GNU Free Documentation License, Version 1.2 or any later +version published by the Free Software Foundation; with no Invariant Sections, +with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the +license is included in GNU Free Documentation License. +
+ ++ + + + + + + + + + + + + + + + + + + + + + + + + + +
+This library is free; this means that everyone is free to use it and +free to redistribute it on a free basis. The library is not in the public +domain; it is copyrighted and there are restrictions on its distribution, but +these restrictions are designed to permit everything that a good cooperating +citizen would want to do. What is not allowed is to try to prevent others +from further sharing any version of this library that they might get from +you. + +
Specifically, we want to make sure that you have the right to give away copies +of the library, that you receive source code or else can get it if you want +it, that you can change this library or use pieces of it in new free programs, +and that you know you can do these things. + +
To make sure that everyone has such rights, we have to forbid you to deprive +anyone else of these rights. For example, if you distribute copies of the +MPFR library, you must give the recipients all the rights that you have. You +must make sure that they, too, receive or can get the source code. And you +must tell them their rights. + +
Also, for our own protection, we must make certain that everyone finds out +that there is no warranty for the MPFR library. If it is modified by +someone else and passed on, we want their recipients to know that what they +have is not what we distributed, so that any problems introduced by others +will not reflect on our reputation. + +
The precise conditions of the license for the MPFR library are found in the +Lesser General Public License that accompanies the source code. +See the file COPYING.LIB. + +
+ + +MPFR is a portable library written in C for arbitrary precision arithmetic
+on floating-point numbers. It is based on the GNU MP library.
+It aims to extend the class of floating-point numbers provided by the
+GNU MP library by a precise semantics. The main differences
+with the mpf class from GNU MP are:
+
+
mp_bits_per_limb (32 or 64 on most machines);
+In particular, with a precision of 53 bits, MPFR should be able to
+exactly reproduce all computations with double-precision machine
+floating-point numbers (e.g., double type in C, with a C
+implementation that rigorously follows Annex F of the ISO C99 standard
+and FP_CONTRACT pragma set to OFF) on the four arithmetic
+operations and the square root, except the default exponent range is much
+wider and subnormal numbers are not implemented (but can be emulated).
+
+
This version of MPFR is released under the GNU Lesser General Public +License, Version 2.1 or any later version. +It is permitted to link MPFR to most non-free programs, as long as when +distributing them the MPFR source code and a means to re-link with a +modified MPFR library is provided. + +
Everyone should read MPFR Basics. If you need to install the library +yourself, you need to read Installing MPFR, too. + +
The rest of the manual can be used for later reference, although it is +probably a good idea to glance through it. + +
+ + +Here are the steps needed to install the library on Unix systems +(more details are provided in the INSTALL file): + +
This will prepare the build and setup the options according to your system. +If you get error messages, you might check that you use the same compiler +and compile options as for GNU MP (see the INSTALL file). + +
This will compile MPFR, and create a library archive file libmpfr.a. +A dynamic library may be produced too (see configure). + +
This will make sure MPFR was built correctly. +If you get error messages, please +report this to ‘mpfr@loria.fr’. (See Reporting Bugs, for +information on what to include in useful bug reports.) + +
This will copy the files mpfr.h and mpf2mpfr.h to the directory +/usr/local/include, the file libmpfr.a to the directory +/usr/local/lib, and the file mpfr.info to the directory +/usr/local/share/info (or if you passed the ‘--prefix’ option to + configure, using the prefix directory given as argument to +‘--prefix’ instead of /usr/local). +
There are some other useful make targets: + +
Create an info version of the manual, in mpfr.info. + +
Create a PDF version of the manual, in mpfr.pdf. + +
Create a DVI version of the manual, in mpfr.dvi. + +
Create a Postscript version of the manual, in mpfr.ps. + +
Create a HTML version of the manual, in several pages in the directory +mpfr.html; if you want only one output HTML file, then type +‘makeinfo --html --no-split mpfr.texi’ instead. + +
Delete all object files and archive files, but not the configuration files. + +
Delete all files not included in the distribution. + +
Delete all files copied by ‘make install’. +
In case of problem, please read the INSTALL file carefully +before reporting a bug, in particular section “In case of problem”. +Some problems are due to bad configuration on the user side (not +specific to MPFR). Problems are also mentioned in the FAQ +http://www.mpfr.org/faq.html. + + + +
Please report problems to ‘mpfr@loria.fr’. +See Reporting Bugs. +Some bug fixes are available on the +MPFR 2.3.2 web page http://www.mpfr.org/mpfr-2.3.2/. + +
The latest version of MPFR is available from http://www.mpfr.org/. + +
+ + ++ + +If you think you have found a bug in the MPFR library, first have a look +on the MPFR 2.3.2 web page http://www.mpfr.org/mpfr-2.3.2/ and the +FAQ http://www.mpfr.org/faq.html: +perhaps this bug is already known, in which case you may find there +a workaround for it. Otherwise, please investigate and report it. +We have made this library available to you, and it is not to ask too +much from you, to ask you to report the bugs that you find. + +
There are a few things you should think about when you put your bug report +together. + +
You have to send us a test case that makes it possible for us to reproduce the +bug. Include instructions on how to run the test case. + +
You also have to explain what is wrong; if you get a crash, or if the results +printed are incorrect and in that case, in what way. + +
Please include compiler version information in your bug report. This can +be extracted using ‘cc -V’ on some machines, or, if you're using gcc, +‘gcc -v’. Also, include the output from ‘uname -a’ and the MPFR +version (the GMP version may be useful too). + +
If your bug report is good, we will do our best to help you to get a corrected +version of the library; if the bug report is poor, we won't do anything about +it (aside of chiding you to send better bug reports). + +
Send your bug report to: ‘mpfr@loria.fr’. + +
If you think something in this manual is unclear, or downright incorrect, or if +the language needs to be improved, please send a note to the same address. + +
+ + +All declarations needed to use MPFR are collected in the include file +mpfr.h. It is designed to work with both C and C++ compilers. +You should include that file in any program using the MPFR library: + +
#include <mpfr.h> ++
Note however that prototypes for MPFR functions with FILE * parameters
+are provided only if <stdio.h> is included too (before mpfr.h).
+
+
#include <stdio.h> + #include <mpfr.h> ++
You can avoid the use of MPFR macros encapsulating functions by defining +the ‘MPFR_USE_NO_MACRO’ macro before mpfr.h is included. In +general this should not be necessary, but this can be useful when debugging +user code: with some macros, the compiler may emit spurious warnings with +some warning options, and macros can prevent some prototype checking. + +
All programs using MPFR must link against both libmpfr and +libgmp libraries. On a typical Unix-like system this can be +done with ‘-lmpfr -lgmp’ (in that order), for example + +
gcc myprogram.c -lmpfr -lgmp ++
MPFR is built using Libtool and an application can use that to link if +desired, see GNU Libtool. + + + + + +
If MPFR has been installed to a non-standard location, then it may be +necessary to set up environment variables such as ‘C_INCLUDE_PATH’ +and ‘LIBRARY_PATH’, or use ‘-I’ and ‘-L’ compiler options, +in order to point to the right directories. For a shared library, it may +also be necessary to set up some sort of run-time library path (e.g., +‘LD_LIBRARY_PATH’) on some systems. Please read the INSTALL +file for additional information. + +
A floating-point number or float for short, is an arbitrary
+precision significand (also called mantissa) with a limited precision
+exponent. The C data type
+for such objects is mpfr_t (internally defined as a one-element
+array of a structure, and mpfr_ptr is the C data type representing
+a pointer to this structure). A floating-point number can have
+three special values: Not-a-Number (NaN) or plus or minus Infinity. NaN
+represents an uninitialized object, the result of an invalid operation
+(like 0 divided by 0), or a value that cannot be determined (like
++Infinity minus +Infinity). Moreover, like in the IEEE 754-1985 standard,
+zero is signed, i.e. there are both +0 and −0; the behavior
+is the same as in the IEEE 754-1985 standard and it is generalized to
+the other functions supported by MPFR.
+
+
The precision is the number of bits used to represent the significand
+of a floating-point number;
+the corresponding C data type is mp_prec_t.
+The precision can be any integer between MPFR_PREC_MIN and
+MPFR_PREC_MAX. In the current implementation, MPFR_PREC_MIN
+is equal to 2.
+
+
Warning! MPFR needs to increase the precision internally, in order to
+provide accurate results (and in particular, correct rounding). Do not
+attempt to set the precision to any value near MPFR_PREC_MAX,
+otherwise MPFR will abort due to an assertion failure. Moreover, you
+may reach some memory limit on your platform, in which case the program
+may abort, crash or have undefined behavior (depending on your C
+implementation).
+
+
The rounding mode specifies the way to round the result of a
+floating-point operation, in case the exact result can not be represented
+exactly in the destination significand;
+the corresponding C data type is mp_rnd_t.
+
+
+A limb means the part of a multi-precision number that fits in a single
+word. (We chose this word because a limb of the human body is analogous to a
+digit, only larger, and containing several digits.) Normally a limb contains
+32 or 64 bits. The C data type for a limb is mp_limb_t.
+
+
There is only one class of functions in the MPFR library: + +
mpfr_. The associated type is mpfr_t.
+ As a general rule, all MPFR functions expect output arguments before input +arguments. This notation is based on an analogy with the assignment operator. + +
MPFR allows you to use the same variable for both input and output in the same
+expression. For example, the main function for floating-point multiplication,
+mpfr_mul, can be used like this: mpfr_mul (x, x, x, rnd_mode).
+This
+computes the square of x with rounding mode rnd_mode
+and puts the result back in x.
+
+
Before you can assign to an MPFR variable, you need to initialize it by calling +one of the special initialization functions. When you're done with a +variable, you need to clear it out, using one of the functions for that +purpose. + +
A variable should only be initialized once, or at least cleared out between +each initialization. After a variable has been initialized, it may be +assigned to any number of times. + +
For efficiency reasons, avoid to initialize and clear out a variable in loops. +Instead, initialize it before entering the loop, and clear it out after the +loop has exited. + +
You don't need to be concerned about allocating additional space for MPFR +variables, since any variable has a significand of fixed size. +Hence unless you change its precision, or clear and reinitialize it, +a floating-point variable will have the same allocated space during all its +life. + +
The following four rounding modes are supported: + +
GMP_RNDN: round to nearest
+GMP_RNDZ: round toward zero
+GMP_RNDU: round toward plus infinity
+GMP_RNDD: round toward minus infinity
+The ‘round to nearest’ mode works as in the IEEE 754-1985 standard: in +case the number to be rounded lies exactly in the middle of two representable +numbers, it is rounded to the one with the least significant bit set to zero. +For example, the number 5/2, which is represented by (10.1) in binary, is +rounded to (10.0)=2 with a precision of two bits, and not to (11.0)=3. +This rule avoids the drift phenomenon mentioned by Knuth in volume 2 +of The Art of Computer Programming (Section 4.2.2). + +
Most MPFR functions take as first argument the destination variable, as
+second and following arguments the input variables, as last argument a
+rounding mode, and have a return value of type int, called the
+ternary value. The value stored in the destination variable is
+correctly rounded, i.e. MPFR behaves as if it computed the result with
+an infinite precision, then rounded it to the precision of this variable.
+The input variables are regarded as exact (in particular, their precision
+does not affect the result).
+
+
As a consequence, in case of a non-zero real rounded result, the error +on the result is less or equal to 1/2 ulp (unit in the last place) of +the target in the rounding to nearest mode, and less than 1 ulp of the +target in the directed rounding modes (a ulp is the weight of the least +significant represented bit of the target after rounding). + + + +
Unless documented otherwise, functions returning an int return
+a ternary value.
+If the ternary value is zero, it means that the value stored in the
+destination variable is the exact result of the corresponding mathematical
+function. If the ternary value is positive (resp. negative), it means
+the value stored in the destination variable is greater (resp. lower)
+than the exact result. For example with the GMP_RNDU rounding mode,
+the ternary value is usually positive, except when the result is exact, in
+which case it is zero. In the case of an infinite result, it is considered
+as inexact when it was obtained by overflow, and exact otherwise. A NaN
+result (Not-a-Number) always corresponds to an exact return value.
+The opposite of a returned ternary value is guaranteed to be representable
+in an int.
+
+
Unless documented otherwise, functions returning a 1
+(or any other value specified in this manual)
+for special cases (like acos(0)) should return an overflow or
+an underflow if 1 is not representable in the current exponent range.
+
+
This section specifies the floating-point values (of type mpfr_t)
+returned by MPFR functions. For functions returning several values (like
+mpfr_sin_cos), the rules apply to each result separately.
+
+
Functions can have one or several input arguments. An input point is +a mapping from these input arguments to the set of the MPFR numbers. +When none of its components are NaN, an input point can also be seen +as a tuple in the extended real numbers (the set of the real numbers +with both infinities). + +
When the input point is in the domain of the mathematical function, the +result is rounded as described in Section “Rounding Modes” (but see +below for the specification of the sign of an exact zero). Otherwise +the general rules from this section apply unless stated otherwise in +the description of the MPFR function (MPFR Interface). + +
When the input point is not in the domain of the mathematical function
+but is in its closure in the extended real numbers and the function can
+be extended by continuity, the result is the obtained limit.
+Examples: mpfr_hypot on (+Inf,0) gives +Inf. But mpfr_pow
+cannot be defined on (1,+Inf) using this rule, as one can find
+sequences (x_n,y_n) such that
+x_n goes to 1, y_n goes to +Inf
+and x_n to the y_n goes to any
+positive value when n goes to the infinity.
+
+
When the input point is in the closure of the domain of the mathematical
+function and an input argument is +0 (resp. −0), one considers
+the limit when the corresponding argument approaches 0 from above
+(resp. below). If the limit is not defined (e.g., mpfr_log on
+−0), the behavior must be specified in the description of the
+MPFR function.
+
+
When the result is equal to 0, its sign is determined by considering the
+limit as if the input point were not in the domain: If one approaches 0
+from above (resp. below), the result is +0 (resp. −0). In the
+other cases, the sign must be specified in the description of the MPFR
+function. Example: mpfr_sin on +0 gives +0.
+
+
When the input point is not in the closure of the domain of the function,
+the result is NaN. Example: mpfr_sqrt on −17 gives NaN.
+
+
When an input argument is NaN, the result is NaN, possibly except when
+a partial function is constant on the finite floating-point numbers;
+such a case is always explicitly specified in MPFR Interface.
+
+
+
+
+Example: mpfr_hypot on (NaN,0) gives NaN, but mpfr_hypot
+on (NaN,+Inf) gives +Inf (as specified in Special Functions),
+since for any finite input x, mpfr_hypot on (x,+Inf)
+gives +Inf.
+
+
MPFR supports 5 exception types: + +
Note: This is not the single definition of the underflow. MPFR chooses +to consider the underflow after rounding. The underflow before rounding +can also be defined. For instance, consider a function that has the +exact result 7 multiplied by two to the power +e−4, where e is the smallest exponent (for a +significand between 1/2 and 1) in the current +range, with a 2-bit target precision and rounding toward plus infinity. +The exact result has the exponent e−1. With the underflow +before rounding, such a function call would yield an underflow, as +e−1 is outside the current exponent range. However, MPFR +first considers the rounded result assuming an unbounded exponent range. +The exact result cannot be represented exactly in precision 2, and here, +it is rounded to 0.5 times 2 to e, which is +representable in the current exponent range. As a consequence, this will +not yield an underflow in MPFR. + +
mpfr_cmp or in a
+conversion to an integer).
+
+ MPFR has a global flag for each exception, which can be cleared, set +or tested by functions described in Exception Related Functions. + +
Differences with the ISO C99 standard: + +
MPFR functions may create caches, e.g. when computing constants such
+as Pi, either because the user has called a function like
+mpfr_const_pi directly or because such a function was called
+internally by the MPFR library itself to compute some other function.
+
+
At any time, the user can free the various caches with
+mpfr_free_cache. It is strongly advised to do that before
+terminating a thread, or before exiting when using tools like
+‘valgrind’ (to avoid memory leaks being reported).
+
+
MPFR internal data such as flags, the exponent range, the default +precision and rounding mode, and caches (i.e., data that are not +accessed via parameters) are either global (if MPFR has not been +compiled as thread safe) or per-thread (thread local storage). + +
+ + +
+The floating-point functions expect arguments of type mpfr_t.
+
+
The MPFR floating-point functions have an interface that is similar to the
+GNU MP
+integer functions. The function prefix for floating-point operations is
+mpfr_.
+
+
There is one significant characteristic of floating-point numbers that has +motivated a difference between this function class and other GNU MP function +classes: the inherent inexactness of floating-point arithmetic. The user has +to specify the precision for each variable. A computation that assigns a +variable will take place with the precision of the assigned variable; the +cost of that computation should not depend from the +precision of variables used as input (on average). + +
The semantics of a calculation in MPFR is specified as follows: Compute the +requested operation exactly (with “infinite accuracy”), and round the result +to the precision of the destination variable, with the given rounding mode. +The MPFR floating-point functions are intended to be a smooth extension +of the IEEE 754-1985 arithmetic. The results obtained on one computer should +not differ from the results obtained on a computer with a different word size. + +
MPFR does not keep track of the accuracy of a computation. This is left +to the user or to a higher layer. +As a consequence, if two variables are used to store +only a few significant bits, and their product is stored in a variable with large +precision, then MPFR will still compute the result with full precision. + +
The value of the standard C macro errno may be set to non-zero by
+any MPFR function or macro, whether or not there is an error.
+
+
An mpfr_t object must be initialized before storing the first value in
+it. The functions mpfr_init and mpfr_init2 are used for that
+purpose.
+
+
Initialize x, set its precision to be exactly +prec bits and its value to NaN. (Warning: the corresponding +
mpffunctions initialize to zero instead.) + +Normally, a variable should be initialized once only or at +least be cleared, using
mpfr_clear, between initializations. +To change the precision of a variable which has already been initialized, +usempfr_set_prec. +The precision prec must be an integer betweenMPFR_PREC_MINand +MPFR_PREC_MAX(otherwise the behavior is undefined). +
Free the space occupied by x. Make sure to call this function for all +
mpfr_tvariables when you are done with them. +
Initialize x and set its value to NaN. + +
Normally, a variable should be initialized once only +or at least be cleared, using
mpfr_clear, between initializations. The +precision of x is the default precision, which can be changed +by a call tompfr_set_default_prec. +
Set the default precision to be exactly prec bits. The +precision of a variable means the number of bits used to store its significand. +All +subsequent calls to
mpfr_initwill use this precision, but previously +initialized variables are unaffected. +This default precision is set to 53 bits initially. +The precision can be any integer betweenMPFR_PREC_MINand +MPFR_PREC_MAX. +
Here is an example on how to initialize floating-point variables: + +
{
+ mpfr_t x, y;
+ mpfr_init (x); /* use default precision */
+ mpfr_init2 (y, 256); /* precision exactly 256 bits */
+ ...
+ /* When the program is about to exit, do ... */
+ mpfr_clear (x);
+ mpfr_clear (y);
+ mpfr_free_cache ();
+ }
+
+ The following functions are useful for changing the precision during a +calculation. A typical use would be for adjusting the precision gradually in +iterative algorithms like Newton-Raphson, making the computation precision +closely match the actual accurate part of the numbers. + +
Reset the precision of x to be exactly prec bits, +and set its value to NaN. +The previous value stored in x is lost. It is equivalent to +a call to
mpfr_clear(x)followed by a call to +mpfr_init2(x, prec), but more efficient as no allocation is done in +case the current allocated space for the significand of x is enough. +The precision prec can be any integer betweenMPFR_PREC_MINand +MPFR_PREC_MAX. + +In case you want to keep the previous value stored in x, +use
mpfr_prec_roundinstead. +
Return the precision actually used for assignments of x, i.e. the +number of bits used to store its significand. +
These functions assign new values to already initialized floats
+(see Initialization Functions). When using any functions using
+intmax_t, you must include <stdint.h> or <inttypes.h>
+before mpfr.h, to allow mpfr.h to define prototypes for
+these functions.
+
+
Set the value of rop from op, rounded +toward the given direction rnd. +Note that the input 0 is converted to +0 by
mpfr_set_ui, +mpfr_set_si,mpfr_set_sj,mpfr_set_uj, +mpfr_set_z,mpfr_set_qand +mpfr_set_f, regardless of the rounding mode. +If the system doesn't support the IEEE-754 standard,mpfr_set_d, +mpfr_set_ldand +mpfr_set_decimal64might not preserve the signed zeros. +Thempfr_set_decimal64function is built only with the configure +option ‘--enable-decimal-float’, which also requires +‘--with-gmp-build’, and when the compiler or +system provides the ‘_Decimal64’ data type +(GCC version 4.2.0 is known to support this data type, +but only when configured with ‘--enable-decimal-float’ too). +mpfr_set_qmight not be able to work if the numerator (or the +denominator) can not be representable as ampfr_t. + +Note: If you want to store a floating-point constant to a
mpfr_t, +you should usempfr_set_str(or one of the MPFR constant functions, +such asmpfr_const_pifor Pi) instead ofmpfr_set_d, +mpfr_set_ldormpfr_set_decimal64. +Otherwise the floating-point constant will be first +converted into a reduced-precision (e.g., 53-bit) binary number before +MPFR can work with it. +
Set the value of rop from op multiplied by +two to the power e, rounded toward the given direction rnd. +Note that the input 0 is converted to +0. +
Set rop to the value of the whole string s in base base, +rounded in the direction rnd. +See the documentation of
mpfr_strtofrfor a detailed description +of the valid string formats. + + + + +This function returns 0 if the entire string up to the final null character +is a valid number in base base; otherwise it returns −1, and +rop may have changed. +
+Read a floating-point number from a string nptr in base base, +rounded in the direction rnd; base must be either 0 (to +detect the base, as described below) or a number from 2 to 36 (otherwise +the behavior is undefined). If nptr starts with valid data, the +result is stored in rop and
*endptr points to the +character just after the valid data (if endptr is not a null pointer); +otherwise rop is set to zero and the value of nptr is stored +in the location referenced by endptr (if endptr is not a null +pointer). The usual ternary value is returned. + +Parsing follows the standard C
strtodfunction with some extensions. +Case is ignored. After optional leading whitespace, one has a subject +sequence consisting of an optional sign (+or-), and either +numeric data or special data. The subject sequence is defined as the +longest initial subsequence of the input string, starting with the first +non-whitespace character, that is of the expected form. + +The form of numeric data is a non-empty sequence of significand digits +with an optional decimal point, and an optional exponent consisting of +an exponent prefix followed by an optional sign and a non-empty sequence +of decimal digits. A significand digit is either a decimal digit or a +Latin letter (62 possible characters), with
a= 10,b= 11, +...,z= 36; its value must be strictly less than the base. +The decimal point can be either the one defined by the current locale or +the period (the first one is accepted for consistency with the C standard +and the practice, the second one is accepted to allow the programmer to +provide MPFR numbers from strings in a way that does not depend on the +current locale). +The exponent prefix can beeorEfor bases up to 10, or +@in any base; it indicates a multiplication by a power of the +base. In bases 2 and 16, the exponent prefix can also bepor +P, in which case it introduces a binary exponent: it indicates a +multiplication by a power of 2 (there is a difference only for base 16). +The value of an exponent is always written in base 10. +In base 2, the significand can start with0bor0B, and +in base 16, it can start with0xor0X. + +If the argument base is 0, then the base is automatically detected +as follows. If the significand starts with
0bor0B, base 2 +is assumed. If the significand starts with0xor0X, base 16 +is assumed. Otherwise base 10 is assumed. + +Note: The exponent must contain at least a digit. Otherwise the possible +exponent prefix and sign are not part of the number (which ends with the +significand). Similarly, if
0b,0B,0xor0X+is not followed by a binary/hexadecimal digit, then the subject sequence +stops at the character0. + +Special data (for infinities and NaN) can be
@inf@or +@nan@(n-char-sequence), and if base <= 16, +it can also beinfinity,inf,nanor +nan(n-char-sequence), all case insensitive. +An-char-sequenceis a non-empty string containing only digits, +Latin letters and the underscore (0, 1, 2, ..., 9, a, b, ..., z, +A, B, ..., Z, _). Note: one has an optional sign for all data, even +NaN. + +
Set the variable x to infinity or NaN (Not-a-Number) respectively. +In
mpfr_set_inf, x is set to plus infinity iff sign is +nonnegative. +
Swap the values x and y efficiently. Warning: the +precisions are exchanged too; in case the precisions are different, +
mpfr_swapis thus not equivalent to threempfr_setcalls +using a third auxiliary variable. +
Initialize rop and set its value from op, rounded in the direction +rnd. +The precision of rop will be taken from the active default precision, +as set by
mpfr_set_default_prec. +
Initialize x and set its value from +the string s in base base, +rounded in the direction rnd. +See
mpfr_set_str. +
Convert op to a
double(respectively_Decimal64or +long double), using the rounding mode rnd. +If op is NaN, some fixed NaN (either quiet or signaling) or the result +of 0.0/0.0 is returned. If op is ±Inf, an infinity of the same +sign or the result of ±1.0/0.0 is returned. If op is zero, these +functions return a zero, trying to preserve its sign, if possible. +Thempfr_get_decimal64function is built only under some conditions: +see the documentation ofmpfr_set_decimal64. +
Return d and set exp such that 0.5<=abs(d)<1 +and d times 2 raised to exp equals +op rounded to double (resp. long double) +precision, using the given rounding mode. + +If op is zero, then a zero of the same sign (or an unsigned zero, +if the implementation does not have signed zeros) is returned, and +exp is set to 0. +If op is NaN or an infinity, then the corresponding double precision +(resp. long-double precision) +value is returned, and exp is undefined. +
Convert op to a
long, anunsigned long, +anintmax_tor anuintmax_t(respectively) after rounding +it with respect to rnd. +If op is NaN, the result is undefined. +If op is too big for the return type, it returns the maximum +or the minimum of the corresponding C type, depending on the direction +of the overflow. The flag erange is set too. +See alsompfr_fits_slong_p,mpfr_fits_ulong_p, +mpfr_fits_intmax_pandmpfr_fits_uintmax_p. +
Put the scaled significand of op (regarded as an integer, with the +precision of op) into rop, and return the exponent exp +(which may be outside the current exponent range) such that op +exactly equals +rop multiplied by two exponent exp. +If the exponent is not representable in the
mp_exp_ttype, the +behavior is undefined. +
Convert op to a
mpz_t, after rounding it with respect to +rnd. If op is NaN or Inf, the result is undefined. +
Convert op to a
mpf_t, after rounding it with respect to +rnd. Return zero iff no error occurred, +in particular a non-zero value is returned if +op is NaN or Inf, which do not exist inmpf. +
Convert op to a string of digits in base b, with rounding in +the direction rnd, where n is either zero (see below) or the +number of significant digits; in the latter case, n must be greater +or equal to 2. The base may vary from 2 to 36. + +
The generated string is a fraction, with an implicit radix point immediately +to the left of the first digit. For example, the number −3.1416 would +be returned as "−31416" in the string and 1 written at expptr. +If rnd is to nearest, and op is exactly in the middle of two +possible outputs, the one with an even last digit is chosen +(for an odd base, this may not correspond to an even significand). + +
If n is zero, the number of digits of the significand is chosen +large enough so that re-reading the printed value with the same precision, +assuming both output and input use rounding to nearest, will recover +the original value of op. +More precisely, in most cases, the chosen precision of str is +the minimal precision depending on n and b only that +satisfies the above property, i.e., +m = 1 + ceil(n*log(2)/log(b)), +but in some very rare cases, it might be m+1. + +
If str is a null pointer, space for the significand is allocated using +the current allocation function, and a pointer to the string is returned. +To free the returned string, you must use
mpfr_free_str. + +If str is not a null pointer, it should point to a block of storage +large enough for the significand, i.e., at least
max(n+ 2, 7). +The extra two bytes are for a possible minus sign, and for the terminating null +character. + +If the input number is an ordinary number, the exponent is written through +the pointer expptr (the current minimal exponent for 0). + +
A pointer to the string is returned, unless there is an error, in which +case a null pointer is returned. +
Free a string allocated by
mpfr_get_strusing the current unallocation +function (preliminary interface). +The block is assumed to bestrlen(str)+1bytes. +For more information about how it is done: +see section “Custom Allocation” in GNU MP. +
Return non-zero if op would fit in the respective C data type, when +rounded to an integer in the direction rnd. +
Set rop to op1 + op2 rounded in the direction +rnd. For types having no signed zero, it is considered unsigned +(i.e. (+0) + 0 = (+0) and (−0) + 0 = (−0)). +
Set rop to op1 - op2 rounded in the direction +rnd. For types having no signed zero, it is considered unsigned +(i.e. (+0) − 0 = (+0), (−0) − 0 = (−0), +0 − (+0) = (−0) and 0 − (−0) = (+0)). +
Set rop to op1 times op2 rounded in the +direction rnd. +When a result is zero, its sign is the product of the signs of the operands +(for types having no signed zero, it is considered positive). +
Set rop to the square of op +rounded in the direction rnd. +
Set rop to op1/op2 rounded in the direction rnd. +When a result is zero, its sign is the product of the signs of the operands +(for types having no signed zero, it is considered positive). +
Set rop to the square root of op +rounded in the direction rnd. Return −0 if op is +−0 (to be consistent with the IEEE 754-1985 standard). +Set rop to NaN if op is negative. +
Set rop to the cubic root (resp. the kth root) +of op rounded in the direction rnd. +An odd (resp. even) root of a negative number (including −Inf) +returns a negative number (resp. NaN). +The kth root of −0 is defined to be −0, +whatever the parity of k. +
Set rop to op1 raised to op2, +rounded in the direction rnd. +Special values are currently handled as described in the ISO C99 standard +for the
powfunction (note this may change in future versions): ++
+pow(±0,y)returns plus or minus infinity for y a negative odd integer. +pow(±0,y)returns plus infinity for y negative and not an odd integer. +pow(±0,y)returns plus or minus zero for y a positive odd integer. +pow(±0,y)returns plus zero for y positive and not an odd integer. +pow(-1, ±Inf)returns 1. +pow(+1,y)returns 1 for any y, even a NaN. +pow(x, ±0)returns 1 for any x, even a NaN. +pow(x,y)returns NaN for finite negative x and finite non-integer y. +pow(x, -Inf)returns plus infinity for 0 < abs(x) < 1, and plus zero for abs(x) > 1. +pow(x, +Inf)returns plus zero for 0 < abs(x) < 1, and plus infinity for abs(x) > 1. +pow(-Inf,y)returns minus zero for y a negative odd integer. +pow(-Inf,y)returns plus zero for y negative and not an odd integer. +pow(-Inf,y)returns minus infinity for y a positive odd integer. +pow(-Inf,y)returns plus infinity for y positive and not an odd integer. +pow(+Inf,y)returns plus zero for y negative, and plus infinity for y positive. +
Set rop to -op rounded in the direction rnd. +Just changes the sign if rop and op are the same variable. +
Set rop to the absolute value of op, +rounded in the direction rnd. +Just changes the sign if rop and op are the same variable. +
Set rop to the positive difference of op1 and op2, i.e., +op1 - op2 rounded in the direction rnd +if op1 > op2, and +0 otherwise. +Returns NaN when op1 or op2 is NaN. +
Set rop to op1 times 2 raised +to op2 +rounded in the direction rnd. Just increases the exponent by op2 +when rop and op1 are identical. +
Set rop to op1 divided by 2 raised +to op2 +rounded in the direction rnd. Just decreases the exponent by op2 +when rop and op1 are identical. +
Compare op1 and op2. Return a positive value if op1 > +op2, zero if op1 = op2, and a negative value if +op1 < op2. +Both op1 and op2 are considered to their full own precision, +which may differ. +If one of the operands is NaN, set the erange flag and return zero. + +
Note: These functions may be useful to distinguish the three possible cases. +If you need to distinguish two cases only, it is recommended to use the +predicate functions (e.g.,
mpfr_equal_pfor the equality) described +below; they behave like the IEEE-754 comparisons, in particular when one +or both arguments are NaN. But only floating-point numbers can be compared +(you may need to do a conversion first). +
Compare op1 and op2 multiplied by two to +the power e. Similar as above. +
Compare |op1| and |op2|. Return a positive value if +|op1| > |op2|, zero if |op1| = |op2|, and +a negative value if |op1| < |op2|. +If one of the operands is NaN, set the erange flag and return zero. +
Return non-zero if op is respectively NaN, an infinity, an ordinary +number (i.e. neither NaN nor an infinity) or zero. Return zero otherwise. +
Return a positive value if op > 0, zero if op = 0, +and a negative value if op < 0. +If the operand is NaN, set the erange flag and return zero. +
Return non-zero if op1 > op2, zero otherwise. +
Return non-zero if op1 >= op2, zero otherwise. +
Return non-zero if op1 < op2, zero otherwise. +
Return non-zero if op1 <= op2, zero otherwise. +
Return non-zero if op1 < op2 or +op1 > op2 (i.e. neither op1, nor op2 is +NaN, and op1 <> op2), zero otherwise (i.e. op1 +and/or op2 are NaN, or op1 = op2). +
Return non-zero if op1 = op2, zero otherwise +(i.e. op1 and/or op2 are NaN, or +op1 <> op2). +
Return non-zero if op1 or op2 is a NaN (i.e. they cannot be +compared), zero otherwise. +
All those functions, except explicitly stated, return zero for an +exact return value, a positive value for a return value larger than the +exact result, and a negative value otherwise. + +
Important note: in some domains, computing special functions (either with +correct or incorrect rounding) is expensive, even for small precision, +for example the trigonometric and Bessel functions for large argument. + +
Set rop to the natural logarithm of op, +log2(op) or +log10(op), respectively, +rounded in the direction rnd. +Return −Inf if op is −0 (i.e. the sign of the zero +has no influence on the result). +
Set rop to the exponential of op, + to 2 power of op +or to 10 power of op, respectively, +rounded in the direction rnd. +
Set rop to the cosine of op, sine of op, +tangent of op, rounded in the direction rnd. +
Set rop to the secant of op, cosecant of op, +cotangent of op, rounded in the direction rnd. +
Set simultaneously sop to the sine of op and + cop to the cosine of op, +rounded in the direction rnd with the corresponding precisions of +sop and cop, which must be different variables. +Return 0 iff both results are exact. +
Set rop to the arc-cosine, arc-sine or arc-tangent of op, +rounded in the direction rnd. +Note that since
acos(-1)returns the floating-point number closest to +Pi according to the given rounding mode, this number might not be +in the output range 0 <= rop < \pi +of the arc-cosine function; +still, the result lies in the image of the output range +by the rounding function. +The same holds forasin(-1),asin(1),atan(-Inf), +atan(+Inf). +
Set rop to the arc-tangent2 of y and x, +rounded in the direction rnd: +if
x > 0,atan2(y, x) = atan (y/x); +ifx < 0,atan2(y, x) = sign(y)*(Pi - atan (abs(y/x))). +As foratan, in case the exact mathematical result is +Pi or +-Pi, its rounded result might be outside the function output range. + +
atan2(y, 0)does not raise any floating-point exception. +Special values are currently handled as described in the ISO C99 standard +for theatan2function (note this may change in future versions): ++
+atan2(+0, -0)returns +Pi. +atan2(-0, -0)returns -Pi. +atan2(+0, +0)returns +0. +atan2(-0, +0)returns −0. +atan2(+0, x)returns +Pi for x < 0. +atan2(-0, x)returns -Pi for x < 0. +atan2(+0, x)returns +0 for x > 0. +atan2(-0, x)returns −0 for x > 0. +atan2(y, 0)returns -Pi/2 for y < 0. +atan2(y, 0)returns +Pi/2 for y > 0. +atan2(+Inf, -Inf)returns +3*Pi/4. +atan2(-Inf, -Inf)returns -3*Pi/4. +atan2(+Inf, +Inf)returns +Pi/4. +atan2(-Inf, +Inf)returns -Pi/4. +atan2(+Inf, x)returns +Pi/2 for finite x. +atan2(-Inf, x)returns -Pi/2 for finite x. +atan2(y, -Inf)returns +Pi for finite y > 0. +atan2(y, -Inf)returns -Pi for finite y < 0. +atan2(y, +Inf)returns +0 for finite y > 0. +atan2(y, +Inf)returns −0 for finite y < 0. +
Set rop to the hyperbolic cosine, sine or tangent of op, +rounded in the direction rnd. +
Set rop to the hyperbolic secant of op, cosecant of op, +cotangent of op, rounded in the direction rnd. +
Set rop to the inverse hyperbolic cosine, sine or tangent of op, +rounded in the direction rnd. +
Set rop to the factorial of the
unsigned long intop, +rounded in the direction rnd. +
Set rop to the logarithm of one plus op, +rounded in the direction rnd. +
Set rop to the exponential of op minus one, +rounded in the direction rnd. +
Set y to the exponential integral of x, +rounded in the direction rnd. +For positive x, +the exponential integral is the sum of Euler's constant, of the logarithm +of x, and of the sum for k from 1 to infinity of +x to the power k, divided by k and factorial(k). +For negative x, the returned value is NaN. +
Set rop to the value of the Gamma function on op, rounded in the +direction rnd. When op is a negative integer, NaN is returned. +
Set rop to the value of the logarithm of the Gamma function on op, +rounded in the direction rnd. +When −2k−1 <= x <= −2k, +k being a non-negative integer, NaN is returned. +See also
mpfr_lgamma. +
Set rop to the value of the logarithm of the absolute value of the +Gamma function on op, rounded in the direction rnd. The sign +(1 or −1) of Gamma(op) is returned in the object pointed to +by signp. When op is an infinity or a non-positive integer, ++Inf is returned. When op is NaN, −Inf or a negative integer, +*signp is undefined, and when op is ±0, *signp is +the sign of the zero. +
Set rop to the value of the Riemann Zeta function on op, +rounded in the direction rnd. +
Set rop to the value of the error function on op, +rounded in the direction rnd. +
Set rop to the value of the complementary error function on op, +rounded in the direction rnd. +
Set rop to the value of the first order Bessel function of order 0, 1 +and n on op, rounded in the direction rnd. When op is +NaN, rop is always set to NaN. When op is plus or minus Infinity, +rop is set to +0. When op is zero, and n is not zero, +rop is +0 or −0 depending on the parity and sign of n, +and the sign of op. +
Set rop to the value of the second order Bessel function of order 0, 1 +and n on op, rounded in the direction rnd. When op is +NaN or negative, +rop is always set to NaN. When op is +Inf, +rop is +0. When op is zero, +rop is +Inf or −Inf depending on the parity and sign of n. +
Set rop to (op1 times op2) + op3, +rounded in the direction rnd. +
Set rop to (op1 times op2) - op3, +rounded in the direction rnd. +
Set rop to the arithmetic-geometric mean of op1 and op2, +rounded in the direction rnd. +The arithmetic-geometric mean is the common limit of the sequences +u[n] and v[n], where u[0]=op1, v[0]=op2, u[n+1] is the +arithmetic mean of u[n] and v[n], and v[n+1] is the geometric mean of +u[n] and v[n]. +If any operand is negative, the return value is NaN. +
Set rop to the Euclidean norm of x and y, +i.e. the square root of the sum of the squares of x and y, +rounded in the direction rnd. +Special values are currently handled as described in Section F.9.4.3 of +the ISO C99 standard, for the
hypotfunction (note this may change +in future versions): If x or y is an infinity, then plus +infinity is returned in rop, even if the other number is NaN. +
Set rop to the logarithm of 2, the value of Pi, +of Euler's constant 0.577..., of Catalan's constant 0.915..., +respectively, rounded in the direction +rnd. These functions cache the computed values to avoid other +calculations if a lower or equal precision is requested. To free these caches, +use
mpfr_free_cache. +
Free various caches used by MPFR internally, in particular the +caches used by the functions computing constants (currently +
mpfr_const_log2,mpfr_const_pi, +mpfr_const_eulerandmpfr_const_catalan). +You should call this function before terminating a thread, even if you did +not call these functions directly (they could have been called internally). +
Set ret to the sum of all elements of tab whose size is n, +rounded in the direction rnd. Warning, tab is a table of pointers +to mpfr_t, not a table of mpfr_t (preliminary interface). The returned +
intvalue is zero when the computed value is the exact value, +and non-zero when this cannot be guaranteed, without giving the +direction of the error as the other functions do. +
This section describes functions that perform input from an input/output
+stream, and functions that output to an input/output stream.
+Passing a null pointer for a stream argument to any of
+these functions will make them read from stdin and write to
+stdout, respectively.
+
+
When using any of these functions, you must include the <stdio.h>
+standard header before mpfr.h, to allow mpfr.h to define
+prototypes for these functions.
+
+
Output op on stream stream, as a string of digits in +base base, rounded in the direction rnd. +The base may vary from 2 to 36. Print n significant digits exactly, +or if n is 0, enough digits so that op can be read back +exactly (see
mpfr_get_str). + +In addition to the significant digits, a decimal point (defined by the +current locale) at the right of the +first digit and a trailing exponent in base 10, in the form ‘eNNN’, +are printed. If base is greater than 10, ‘@’ will be used +instead of ‘e’ as exponent delimiter. + +
Return the number of bytes written, or if an error occurred, return 0. +
Input a string in base base from stream stream, +rounded in the direction rnd, and put the +read float in rop. + + + + + + + + + +
This function reads a word (defined as a sequence of characters between +whitespace) and parses it using
mpfr_set_str(it may change). +See the documentation ofmpfr_strtofrfor a detailed description +of the valid string formats. + + + + + + +Return the number of bytes read, or if an error occurred, return 0. +
Set rop to op rounded to an integer. +
mpfr_rintrounds to the nearest representable integer in the +given rounding mode,mpfr_ceilrounds +to the next higher or equal representable integer,mpfr_floorto +the next lower or equal representable integer,mpfr_roundto the +nearest representable integer, rounding halfway cases away from zero, +andmpfr_truncto the next representable integer toward zero. + +The returned value is zero when the result is exact, positive when it is +greater than the original value of op, and negative when it is smaller. +More precisely, the returned value is 0 when op is an integer +representable in rop, 1 or −1 when op is an integer +that is not representable in rop, 2 or −2 when op is +not an integer. + +
Note that
mpfr_roundis different frommpfr_rintcalled with +the rounding to nearest mode (where halfway cases are rounded to an even +integer or significand). Note also that no double rounding is performed; for +instance, 4.5 (100.1 in binary) is rounded bympfr_roundto 4 (100 +in binary) in 2-bit precision, thoughround(4.5)is equal to 5 and +5 (101 in binary) is rounded to 6 (110 in binary) in 2-bit precision. +
Set rop to op rounded to an integer. +
mpfr_rint_ceilrounds to the next higher or equal integer, +mpfr_rint_floorto the next lower or equal integer, +mpfr_rint_roundto the nearest integer, rounding halfway cases away +from zero, andmpfr_rint_truncto the next integer toward zero. +If the result is not representable, it is rounded in the direction rnd. +The returned value is the ternary value associated with the considered +round-to-integer function (regarded in the same way as any other +mathematical function). +
Set rop to the fractional part of op, having the same sign as +op, rounded in the direction rnd (unlike in
mpfr_rint, +rnd affects only how the exact fractional part is rounded, not how +the fractional part is generated). +
Set r to the remainder of the division of x by y, with +quotient rounded to the nearest integer (ties rounded to even), and +r rounded according to the direction rnd. +If r is zero, it has the sign of x. +The return value is the ternary value corresponding to r. +Additionally,
mpfr_remquostores +the low significant bits from the quotient in *q +(more precisely the number of bits in alongminus one), +with the sign of x divided by y +(except if those low bits are all zero, in which case zero is returned). +Note that x may be so large in magnitude relative to y that an +exact representation of the quotient is not practical. +These functions are useful for additive argument reduction. +
If x or y is NaN, set x to NaN. Otherwise, if x +is different from y, replace x by the next floating-point +number (with the precision of x and the current exponent range) +in the direction of y, if there is one +(the infinite values are seen as the smallest and largest floating-point +numbers). If the result is zero, it keeps the same sign. No underflow or +overflow is generated. +
Equivalent to
mpfr_nexttowardwhere y is plus infinity. +
Equivalent to
mpfr_nexttowardwhere y is minus infinity. +
Set rop to the minimum of op1 and op2. If op1 +and op2 are both NaN, then rop is set to NaN. If op1 +or op2 is NaN, then rop is set to the numeric value. If +op1 and op2 are zeros of different signs, then rop +is set to −0. +
Set rop to the maximum of op1 and op2. If op1 +and op2 are both NaN, then rop is set to NaN. If op1 +or op2 is NaN, then rop is set to the numeric value. If +op1 and op2 are zeros of different signs, then rop +is set to +0. +
Generate a uniformly distributed random float in the interval +0 <= rop < 1. +Return 0, unless the exponent is not in the current exponent range, in +which case rop is set to NaN and a non-zero value is returned. The +second argument is a
gmp_randstate_tstructure which should be +created using the GMPgmp_randinitfunction, see the GMP manual. +
Generate a uniformly distributed random float in the interval +0 <= rop < 1. +This function is deprecated;
mpfr_urandombshould be used instead. +
Generate a random float of at most size limbs, with long strings of +zeros and ones in the binary representation. The exponent of the number is in +the interval −exp to exp. +This function is useful for +testing functions and algorithms, since this kind of random numbers have +proven to be more likely to trigger corner-case bugs. +Negative random numbers are generated when size is negative. +Put +0 in rop when size if zero. The internal state of the default +pseudorandom number generator is modified by a call to this function (the +same one as GMP if MPFR was built using ‘--with-gmp-build’). +
Get the exponent of x, assuming that x is a non-zero ordinary +number and the significand is chosen in [1/2,1). The behavior for NaN, +infinity or zero is undefined. +
Set the exponent of x if e is in the current exponent range, +and return 0 (even if x is not a non-zero ordinary number); +otherwise, return a non-zero value. +The significand is assumed to be in [1/2,1). +
Return a non-zero value iff op has its sign bit set (i.e. if it is +negative, −0, or a NaN whose representation has its sign bit set). +
Set the value of rop from op, rounded toward the given +direction rnd, then set (resp. clear) its sign bit if s +is non-zero (resp. zero), even when op is a NaN. +
Set the value of rop from op1, rounded toward the given +direction rnd, then set its sign bit to that of op2 (even +when op1 or op2 is a NaN). This function is equivalent to +
mpfr_setsign (rop,op1, mpfr_signbit (op2),rnd). +
Return the MPFR version, as a null-terminated string. +
MPFR_VERSIONis the version of MPFR as a preprocessing constant. +MPFR_VERSION_MAJOR,MPFR_VERSION_MINORand +MPFR_VERSION_PATCHLEVELare respectively the major, minor and patch +level of MPFR version, as preprocessing constants. +MPFR_VERSION_STRINGis the version (with an optional suffix, used +in development and pre-release versions) as a string constant, which can +be compared to the result ofmpfr_get_versionto check at run time +the header file and library used match: +if (strcmp (mpfr_get_version (), MPFR_VERSION_STRING)) + fprintf (stderr, "Warning: header and library do not match\n"); ++Note: Obtaining different strings is not necessarily an error, as +in general, a program compiled with some old MPFR version can be +dynamically linked with a newer MPFR library version (if allowed +by the library versioning system). +
Create an integer in the same format as used by
MPFR_VERSIONfrom the +given major, minor and patchlevel. +Here is an example of how to check the MPFR version at compile time: +#if (!defined(MPFR_VERSION) || (MPFR_VERSION<MPFR_VERSION_NUM(2,1,0))) + # error "Wrong MPFR version." + #endif ++
Return a null-terminated string containing the ids of the patches applied to +the MPFR library (contents of the PATCHES file), separated by spaces. +Note: If the program has been compiled with an older MPFR version and is +dynamically linked with a new MPFR library version, the ids of the patches +applied to the old (compile-time) MPFR version are not available (however +this information should not have much interest in general). +
Set the default rounding mode to rnd. +The default rounding mode is to nearest initially. +
Round x according to rnd with precision prec, which +must be an integer between
MPFR_PREC_MINandMPFR_PREC_MAX+(otherwise the behavior is undefined). +If prec is greater or equal to the precision of x, then new +space is allocated for the significand, and it is filled with zeros. +Otherwise, the significand is rounded to precision prec with the given +direction. In both cases, the precision of x is changed to prec. +
[This function is obsolete. Please use
mpfr_prec_roundinstead.] +
Return the input string (GMP_RNDD, GMP_RNDU, GMP_RNDN, GMP_RNDZ) +corresponding to the rounding mode rnd or a null pointer if +rnd is an invalid rounding mode. +
Return the (current) smallest and largest exponents allowed for a +floating-point variable. The smallest positive value of a floating-point +variable is one half times 2 raised to the +smallest exponent and the largest value has the form (1 - epsilon) times 2 raised to the largest exponent. +
Set the smallest and largest exponents allowed for a floating-point variable. +Return a non-zero value when exp is not in the range accepted by the +implementation (in that case the smallest or largest exponent is not changed), +and zero otherwise. +If the user changes the exponent range, it is her/his responsibility to check +that all current floating-point variables are in the new allowed range +(for example using
mpfr_check_range), otherwise the subsequent +behavior will be undefined, in the sense of the ISO C standard. + +
Return the minimum and maximum of the smallest and largest exponents +allowed for
mpfr_set_eminandmpfr_set_emax. These values +are implementation dependent; it is possible to create a non +portable program by writingmpfr_set_emax(mpfr_get_emax_max())+andmpfr_set_emin(mpfr_get_emin_min())since the values +of the smallest and largest exponents become implementation dependent. +
This function forces x to be in the current range of acceptable +values, t being the current ternary value: negative if x +is smaller than the exact value, positive if x is larger than +the exact value and zero if x is exact (before the call). It +generates an underflow or an overflow if the exponent of x is +outside the current allowed range; the value of t may be used +to avoid a double rounding. This function returns zero if the rounded +result is equal to the exact one, a positive value if the rounded +result is larger than the exact one, a negative value if the rounded +result is smaller than the exact one. Note that unlike most functions, +the result is compared to the exact one, not the input value x, +i.e. the ternary value is propagated. + +
Note: If x is an infinity and t is different from zero (i.e., +if the rounded result is an inexact infinity), then the overflow flag is +set. This is useful because
mpfr_check_rangeis typically called +(at least in MPFR functions) after restoring the flags that could have +been set due to internal computations. +
This function rounds x emulating subnormal number arithmetic: +if x is outside the subnormal exponent range, it just propagates the +ternary value t; otherwise, it rounds x to precision +
EXP(x)-emin+1according to rounding mode rnd and previous +ternary value t, avoiding double rounding problems. +More precisely in the subnormal domain, denoting by e the value of +emin, x is rounded in fixed-point +arithmetic to an integer multiple of two to the power +e−1; as a consequence, 1.5 multiplied by two to the power e−1 when t is zero +is rounded to two to the power e with rounding to nearest. + +
PREC(x)is not modified by this function. +rnd and t must be the used rounding mode for computing x +and the returned ternary value when computing x. +The subnormal exponent range is fromemintoemin+PREC(x)-1. +If the result cannot be represented in the current exponent range +(due to a too smallemax), the behavior is undefined. +Note that unlike most functions, the result is compared to the exact one, +not the input value x, i.e. the ternary value is propagated. +This is a preliminary interface. +
This is an example of how to emulate double IEEE-754 arithmetic +using MPFR: + +
{
+ mpfr_t xa, xb;
+ int i;
+ volatile double a, b;
+
+ mpfr_set_default_prec (53);
+ mpfr_set_emin (-1073);
+ mpfr_set_emax (1024);
+
+ mpfr_init (xa); mpfr_init (xb);
+
+ b = 34.3; mpfr_set_d (xb, b, GMP_RNDN);
+ a = 0x1.1235P-1021; mpfr_set_d (xa, a, GMP_RNDN);
+
+ a /= b;
+ i = mpfr_div (xa, xa, xb, GMP_RNDN);
+ i = mpfr_subnormalize (xa, i, GMP_RNDN);
+
+ mpfr_clear (xa); mpfr_clear (xb);
+ }
+
+ Warning: this emulates a double IEEE-754 arithmetic with correct rounding +in the subnormal range, which may not be the case for your hardware. + +
Clear the underflow, overflow, invalid, inexact and erange flags. +
Set the underflow, overflow, invalid, inexact and erange flags. +
Clear all global flags (underflow, overflow, inexact, invalid, erange). +
Return the corresponding (underflow, overflow, invalid, inexact, erange) +flag, which is non-zero iff the flag is set. +
All the given interfaces are preliminary. They might change incompatibly in +future revisions. + +
This macro declares name as an automatic variable of type
mpfr_t, +initializes it and sets its precision to be exactly prec bits +and its value to NaN. name must be a valid identifier. +You must use this macro in the declaration section. +This macro is much faster than usingmpfr_init2but has some +drawbacks: + ++
+- You must not call
mpfr_clearwith variables +created with this macro (The storage is allocated at the point of declaration +and deallocated when the brace-level is exited.). +- You can not change their precision. +
- You should not create variables with huge precision with this macro. +
- Your compiler must support ‘Non-Constant Initializers’ (standard +in C++ and ISO C99) and ‘Token Pasting’ +(standard in ISO C89). If prec is not a compiler constant, your compiler +must support ‘Variable-length automatic arrays’ (standard in ISO C99). +‘GCC 2.95.3’ supports all these features. If you compile your program +with gcc in c89 mode and with ‘-pedantic’, you may want to define the +
MPFR_USE_EXTENSIONmacro to avoid warnings due to the +MPFR_DECL_INITimplementation. +
Initialize all the
mpfr_tvariables of the givenva_list, +set their precision to be the default precision and their value to NaN. +Seempfr_initfor more details. +Theva_listis assumed to be composed only of typempfr_t+(or equivalentlympfr_ptr). +It begins from x. It ends when it encounters a null pointer (whose +type must also bempfr_ptr). +
Initialize all the
mpfr_tvariables of the givenva_list, +set their precision to be exactly +prec bits and their value to NaN. +Seempfr_init2for more details. +Theva_listis assumed to be composed only of typempfr_t+(or equivalentlympfr_ptr). +It begins from x. It ends when it encounters a null pointer (whose +type must also bempfr_ptr). +
Free the space occupied by all the
mpfr_tvariables of the given +va_list. Seempfr_clearfor more details. +Theva_listis assumed to be composed only of typempfr_t+(or equivalentlympfr_ptr). +It begins from x. It ends when it encounters a null pointer (whose +type must also bempfr_ptr). +
Here is an example of how to use multiple initialization functions: + +
{
+ mpfr_t x, y, z, t;
+ mpfr_inits2 (256, x, y, z, t, (mpfr_ptr) 0);
+ ...
+ mpfr_clears (x, y, z, t, (mpfr_ptr) 0);
+ }
+
+
+
+ A header file mpf2mpfr.h is included in the distribution of MPFR for
+compatibility with the GNU MP class MPF.
+After inserting the following two lines after the #include <gmp.h>
+line,
+
+#include <mpfr.h> +#include <mpf2mpfr.h> ++any program written for +MPF can be compiled directly with MPFR without any changes. +All operations are then performed with the default MPFR rounding mode, +which can be reset with
mpfr_set_default_rounding_mode.
+
+ Warning: the mpf_init and mpf_init2 functions initialize
+to zero, whereas the corresponding MPFR functions initialize to NaN:
+this is useful to detect uninitialized values, but is slightly incompatible
+with mpf.
+
+
Reset the precision of x to be exactly prec bits. +The only difference with
mpfr_set_precis that prec is assumed to +be small enough so that the significand fits into the current allocated memory +space for x. Otherwise the behavior is undefined. +
Return non-zero if op1 and op2 are both non-zero ordinary +numbers with the same exponent and the same first op3 bits, both +zero, or both infinities of the same sign. Return zero otherwise. This +function is defined for compatibility with
mpf. Do not use it if +you want to know whether two numbers are close to each other; for instance, +1.011111 and 1.100000 are regarded as different for any value of op3 +larger than 1. +
Compute the relative difference between op1 and op2 +and store the result in rop. +This function does not guarantee the correct rounding on the relative +difference; it just computes |op1-op2|/op1, using the +rounding mode rnd for all operations and the precision of rop. +
See
mpfr_mul_2uiandmpfr_div_2ui. These functions are only kept +for compatibility with MPF. +
Some applications use a stack to handle the memory and their objects. +However, the MPFR memory design is not well suited for such a thing. So that +such applications are able to use MPFR, an auxiliary memory interface has +been created: the Custom Interface. + +
The following interface allows them to use MPFR in two ways: +
mpfr_t
+on the stack.
+mpfr_t each time it is needed.
+Each function in this interface is also implemented as a macro for
+efficiency reasons: for example mpfr_custom_init (s, p)
+uses the macro, while (mpfr_custom_init) (s, p) uses the function.
+
+
Note 1: MPFR functions may still initialize temporary FP numbers +using standard mpfr_init. See Custom Allocation (GNU MP). + +
Note 2: MPFR functions may use the cached functions (mpfr_const_pi for
+example), even if they are not explicitly called. You have to call
+mpfr_free_cache each time you garbage the memory iff mpfr_init, through
+GMP Custom Allocation, allocates its memory on the application stack.
+
+
Note 3: This interface is preliminary. + +
Return the needed size in bytes to store the significand of a FP number +of precision prec. +
Initialize a significand of precision prec. +significand must be an area of
mpfr_custom_get_size (prec)bytes +at least and be suitably aligned for an array ofmp_limb_t. +
Perform a dummy initialization of a
mpfr_tand set it to: ++
+ In all cases, it uses significand directly for further computing +involving x. It will not allocate anything. +A FP number initialized with this function cannot be resized using +- if
ABS(kind) == MPFR_NAN_KIND, x is set to NaN; +- if
ABS(kind) == MPFR_INF_KIND, x is set to the infinity +of signsign(kind); +- if
ABS(kind) == MPFR_ZERO_KIND, x is set to the zero of +signsign(kind); +- if
ABS(kind) == MPFR_REGULAR_KIND, x is set to a regular +number:x = sign(kind)*significand*2^exp+mpfr_set_prec, or cleared usingmpfr_clear! +significand must have been initialized withmpfr_custom_init+using the same precision prec. +
Return the current kind of a
mpfr_tas used by +mpfr_custom_init_set. +The behavior of this function for anympfr_tnot initialized +withmpfr_custom_init_setis undefined. +
Return a pointer to the significand used by a
mpfr_tinitialized with +mpfr_custom_init_set. +The behavior of this function for anympfr_tnot initialized +withmpfr_custom_init_setis undefined. +
Return the exponent of x, assuming that x is a non-zero ordinary +number. The return value for NaN, Infinity or Zero is unspecified but doesn't +produce any trap. +The behavior of this function for any
mpfr_tnot initialized +withmpfr_custom_init_setis undefined. +
Inform MPFR that the significand has moved due to a garbage collect +and update its new position to
new_position. +However the application has to move the significand and thempfr_t+itself. +The behavior of this function for anympfr_tnot initialized +withmpfr_custom_init_setis undefined. +
See the test suite for examples. + +
+ +The following types and +functions were mainly designed for the implementation of MPFR, +but may be useful for users too. +However no upward compatibility is guaranteed. +You may need to include mpfr-impl.h to use them. + +
The mpfr_t type consists of four fields.
+
+
_mpfr_prec field is used to store the precision of
+the variable (in bits); this is not less than MPFR_PREC_MIN.
+
+ _mpfr_sign field is used to store the sign of the variable.
+
+ _mpfr_exp field stores the exponent.
+An exponent of 0 means a radix point just above the most significant
+limb. Non-zero values n are a multiplier 2^n relative to that
+point.
+A NaN, an infinity and a zero are indicated by a special value of the exponent.
+
+ _mpfr_d is a pointer to the limbs, least
+significant limbs stored first.
+The number of limbs in use is controlled by _mpfr_prec, namely
+ceil(_mpfr_prec/mp_bits_per_limb).
+Non-singular values always have the most significant bit of the most
+significant limb set to 1. When the precision does not correspond to a
+whole number of limbs, the excess bits at the low end of the data are zero.
+
+ Assuming b is an approximation of an unknown number +x in the direction rnd1 with error at most two to the power +E(b)-err where E(b) is the exponent of b, return a non-zero +value if one is able to round correctly x to precision +prec with the direction rnd2, +and 0 otherwise (including for NaN and Inf). +This function does not modify its arguments. + +
Note: if one wants to also determine the correct ternary value when rounding +b to precision prec, a useful trick is the following: +
+ if (mpfr_can_round (b, err, rnd1, GMP_RNDZ, prec + (rnd2 == GMP_RNDN))) + ... ++Indeed, if rnd2 isGMP_RNDN, this will check if one can +round to prec+1 bits with a directed rounding: +if so, one can surely round to nearest to prec bits, +and in addition one can determine the correct ternary value, which would not +be the case when b is near from a value exactly representable on +prec bits. +
Convert op to a
double, using the default MPFR rounding mode +(see functionmpfr_set_default_rounding_mode). This function is +obsolete. +
The main developers of MPFR are Guillaume Hanrot, Vincent Lefèvre, +Patrick Pélissier, Philippe Théveny and Paul Zimmermann. + +
Sylvie Boldo from ENS-Lyon, France,
+contributed the functions mpfr_agm and mpfr_log.
+Emmanuel Jeandel, from ENS-Lyon too,
+contributed the generic hypergeometric code in
+generic.c, as well as the mpfr_exp3,
+a first implementation of the sine and cosine,
+and improved versions of
+mpfr_const_log2 and mpfr_const_pi.
+Mathieu Dutour contributed the functions mpfr_atan and mpfr_asin,
+and a previous version of mpfr_gamma;
+David Daney contributed the hyperbolic and inverse hyperbolic functions,
+the base-2 exponential, and the factorial function. Fabrice Rouillier
+contributed the original version of mul_ui.c, the gmp_op.c
+file, and helped to the Microsoft Windows porting.
+Jean-Luc Rémy contributed the mpfr_zeta code.
+Ludovic Meunier helped in the design of the mpfr_erf code.
+Damien Stehlé contributed the mpfr_get_ld_2exp function.
+
+
We would like to thank Jean-Michel Muller and Joris van der Hoeven for very +fruitful discussions at the beginning of that project, Torbjörn Granlund +and Kevin Ryde for their help about design issues, +and Nathalie Revol for her careful reading of a previous version of +this documentation. +Kevin Ryde did a tremendous job for the portability of MPFR in 2002-2004. + +
The development of the MPFR library would not have been possible without +the continuous support of INRIA, and of the LORIA (Nancy, France) and LIP +(Lyon, France) laboratories. In particular the main authors were or are +members of the PolKA, Spaces, Cacao project-teams at LORIA and of the +Arenaire project-team at LIP. +This project was started during the Fiable (reliable in French) action +supported by INRIA, and continued during the AOC action. +The development of MPFR was also supported by a grant +(202F0659 00 MPN 121) from the Conseil Régional de Lorraine in 2002, +and from INRIA by an "associate engineer" grant (2003-2005) +and an "opération de développement logiciel" grant (2007-2009). + +
+ + +Copyright © 2000,2001,2002 Free Software Foundation, Inc. + 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. ++
The purpose of this License is to make a manual, textbook, or other +functional and useful document free in the sense of freedom: to +assure everyone the effective freedom to copy and redistribute it, +with or without modifying it, either commercially or noncommercially. +Secondarily, this License preserves for the author and publisher a way +to get credit for their work, while not being considered responsible +for modifications made by others. + +
This License is a kind of “copyleft”, which means that derivative +works of the document must themselves be free in the same sense. It +complements the GNU General Public License, which is a copyleft +license designed for free software. + +
We have designed this License in order to use it for manuals for free +software, because free software needs free documentation: a free +program should come with manuals providing the same freedoms that the +software does. But this License is not limited to software manuals; +it can be used for any textual work, regardless of subject matter or +whether it is published as a printed book. We recommend this License +principally for works whose purpose is instruction or reference. + +
This License applies to any manual or other work, in any medium, that +contains a notice placed by the copyright holder saying it can be +distributed under the terms of this License. Such a notice grants a +world-wide, royalty-free license, unlimited in duration, to use that +work under the conditions stated herein. The “Document”, below, +refers to any such manual or work. Any member of the public is a +licensee, and is addressed as “you”. You accept the license if you +copy, modify or distribute the work in a way requiring permission +under copyright law. + +
A “Modified Version” of the Document means any work containing the +Document or a portion of it, either copied verbatim, or with +modifications and/or translated into another language. + +
A “Secondary Section” is a named appendix or a front-matter section +of the Document that deals exclusively with the relationship of the +publishers or authors of the Document to the Document's overall +subject (or to related matters) and contains nothing that could fall +directly within that overall subject. (Thus, if the Document is in +part a textbook of mathematics, a Secondary Section may not explain +any mathematics.) The relationship could be a matter of historical +connection with the subject or with related matters, or of legal, +commercial, philosophical, ethical or political position regarding +them. + +
The “Invariant Sections” are certain Secondary Sections whose titles +are designated, as being those of Invariant Sections, in the notice +that says that the Document is released under this License. If a +section does not fit the above definition of Secondary then it is not +allowed to be designated as Invariant. The Document may contain zero +Invariant Sections. If the Document does not identify any Invariant +Sections then there are none. + +
The “Cover Texts” are certain short passages of text that are listed, +as Front-Cover Texts or Back-Cover Texts, in the notice that says that +the Document is released under this License. A Front-Cover Text may +be at most 5 words, and a Back-Cover Text may be at most 25 words. + +
A “Transparent” copy of the Document means a machine-readable copy, +represented in a format whose specification is available to the +general public, that is suitable for revising the document +straightforwardly with generic text editors or (for images composed of +pixels) generic paint programs or (for drawings) some widely available +drawing editor, and that is suitable for input to text formatters or +for automatic translation to a variety of formats suitable for input +to text formatters. A copy made in an otherwise Transparent file +format whose markup, or absence of markup, has been arranged to thwart +or discourage subsequent modification by readers is not Transparent. +An image format is not Transparent if used for any substantial amount +of text. A copy that is not “Transparent” is called “Opaque”. + +
Examples of suitable formats for Transparent copies include plain +ascii without markup, Texinfo input format, LaTeX input +format, SGML or XML using a publicly available +DTD, and standard-conforming simple HTML, +PostScript or PDF designed for human modification. Examples +of transparent image formats include PNG, XCF and +JPG. Opaque formats include proprietary formats that can be +read and edited only by proprietary word processors, SGML or +XML for which the DTD and/or processing tools are +not generally available, and the machine-generated HTML, +PostScript or PDF produced by some word processors for +output purposes only. + +
The “Title Page” means, for a printed book, the title page itself, +plus such following pages as are needed to hold, legibly, the material +this License requires to appear in the title page. For works in +formats which do not have any title page as such, “Title Page” means +the text near the most prominent appearance of the work's title, +preceding the beginning of the body of the text. + +
A section “Entitled XYZ” means a named subunit of the Document whose +title either is precisely XYZ or contains XYZ in parentheses following +text that translates XYZ in another language. (Here XYZ stands for a +specific section name mentioned below, such as “Acknowledgements”, +“Dedications”, “Endorsements”, or “History”.) To “Preserve the Title” +of such a section when you modify the Document means that it remains a +section “Entitled XYZ” according to this definition. + +
The Document may include Warranty Disclaimers next to the notice which +states that this License applies to the Document. These Warranty +Disclaimers are considered to be included by reference in this +License, but only as regards disclaiming warranties: any other +implication that these Warranty Disclaimers may have is void and has +no effect on the meaning of this License. + +
You may copy and distribute the Document in any medium, either +commercially or noncommercially, provided that this License, the +copyright notices, and the license notice saying this License applies +to the Document are reproduced in all copies, and that you add no other +conditions whatsoever to those of this License. You may not use +technical measures to obstruct or control the reading or further +copying of the copies you make or distribute. However, you may accept +compensation in exchange for copies. If you distribute a large enough +number of copies you must also follow the conditions in section 3. + +
You may also lend copies, under the same conditions stated above, and +you may publicly display copies. + +
If you publish printed copies (or copies in media that commonly have +printed covers) of the Document, numbering more than 100, and the +Document's license notice requires Cover Texts, you must enclose the +copies in covers that carry, clearly and legibly, all these Cover +Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on +the back cover. Both covers must also clearly and legibly identify +you as the publisher of these copies. The front cover must present +the full title with all words of the title equally prominent and +visible. You may add other material on the covers in addition. +Copying with changes limited to the covers, as long as they preserve +the title of the Document and satisfy these conditions, can be treated +as verbatim copying in other respects. + +
If the required texts for either cover are too voluminous to fit +legibly, you should put the first ones listed (as many as fit +reasonably) on the actual cover, and continue the rest onto adjacent +pages. + +
If you publish or distribute Opaque copies of the Document numbering +more than 100, you must either include a machine-readable Transparent +copy along with each Opaque copy, or state in or with each Opaque copy +a computer-network location from which the general network-using +public has access to download using public-standard network protocols +a complete Transparent copy of the Document, free of added material. +If you use the latter option, you must take reasonably prudent steps, +when you begin distribution of Opaque copies in quantity, to ensure +that this Transparent copy will remain thus accessible at the stated +location until at least one year after the last time you distribute an +Opaque copy (directly or through your agents or retailers) of that +edition to the public. + +
It is requested, but not required, that you contact the authors of the +Document well before redistributing any large number of copies, to give +them a chance to provide you with an updated version of the Document. + +
You may copy and distribute a Modified Version of the Document under +the conditions of sections 2 and 3 above, provided that you release +the Modified Version under precisely this License, with the Modified +Version filling the role of the Document, thus licensing distribution +and modification of the Modified Version to whoever possesses a copy +of it. In addition, you must do these things in the Modified Version: + +
If the Modified Version includes new front-matter sections or +appendices that qualify as Secondary Sections and contain no material +copied from the Document, you may at your option designate some or all +of these sections as invariant. To do this, add their titles to the +list of Invariant Sections in the Modified Version's license notice. +These titles must be distinct from any other section titles. + +
You may add a section Entitled “Endorsements”, provided it contains +nothing but endorsements of your Modified Version by various +parties—for example, statements of peer review or that the text has +been approved by an organization as the authoritative definition of a +standard. + +
You may add a passage of up to five words as a Front-Cover Text, and a +passage of up to 25 words as a Back-Cover Text, to the end of the list +of Cover Texts in the Modified Version. Only one passage of +Front-Cover Text and one of Back-Cover Text may be added by (or +through arrangements made by) any one entity. If the Document already +includes a cover text for the same cover, previously added by you or +by arrangement made by the same entity you are acting on behalf of, +you may not add another; but you may replace the old one, on explicit +permission from the previous publisher that added the old one. + +
The author(s) and publisher(s) of the Document do not by this License +give permission to use their names for publicity for or to assert or +imply endorsement of any Modified Version. + +
You may combine the Document with other documents released under this +License, under the terms defined in section 4 above for modified +versions, provided that you include in the combination all of the +Invariant Sections of all of the original documents, unmodified, and +list them all as Invariant Sections of your combined work in its +license notice, and that you preserve all their Warranty Disclaimers. + +
The combined work need only contain one copy of this License, and +multiple identical Invariant Sections may be replaced with a single +copy. If there are multiple Invariant Sections with the same name but +different contents, make the title of each such section unique by +adding at the end of it, in parentheses, the name of the original +author or publisher of that section if known, or else a unique number. +Make the same adjustment to the section titles in the list of +Invariant Sections in the license notice of the combined work. + +
In the combination, you must combine any sections Entitled “History” +in the various original documents, forming one section Entitled +“History”; likewise combine any sections Entitled “Acknowledgements”, +and any sections Entitled “Dedications”. You must delete all +sections Entitled “Endorsements.” + +
You may make a collection consisting of the Document and other documents +released under this License, and replace the individual copies of this +License in the various documents with a single copy that is included in +the collection, provided that you follow the rules of this License for +verbatim copying of each of the documents in all other respects. + +
You may extract a single document from such a collection, and distribute +it individually under this License, provided you insert a copy of this +License into the extracted document, and follow this License in all +other respects regarding verbatim copying of that document. + +
A compilation of the Document or its derivatives with other separate +and independent documents or works, in or on a volume of a storage or +distribution medium, is called an “aggregate” if the copyright +resulting from the compilation is not used to limit the legal rights +of the compilation's users beyond what the individual works permit. +When the Document is included in an aggregate, this License does not +apply to the other works in the aggregate which are not themselves +derivative works of the Document. + +
If the Cover Text requirement of section 3 is applicable to these +copies of the Document, then if the Document is less than one half of +the entire aggregate, the Document's Cover Texts may be placed on +covers that bracket the Document within the aggregate, or the +electronic equivalent of covers if the Document is in electronic form. +Otherwise they must appear on printed covers that bracket the whole +aggregate. + +
Translation is considered a kind of modification, so you may +distribute translations of the Document under the terms of section 4. +Replacing Invariant Sections with translations requires special +permission from their copyright holders, but you may include +translations of some or all Invariant Sections in addition to the +original versions of these Invariant Sections. You may include a +translation of this License, and all the license notices in the +Document, and any Warranty Disclaimers, provided that you also include +the original English version of this License and the original versions +of those notices and disclaimers. In case of a disagreement between +the translation and the original version of this License or a notice +or disclaimer, the original version will prevail. + +
If a section in the Document is Entitled “Acknowledgements”, +“Dedications”, or “History”, the requirement (section 4) to Preserve +its Title (section 1) will typically require changing the actual +title. + +
You may not copy, modify, sublicense, or distribute the Document except +as expressly provided for under this License. Any other attempt to +copy, modify, sublicense or distribute the Document is void, and will +automatically terminate your rights under this License. However, +parties who have received copies, or rights, from you under this +License will not have their licenses terminated so long as such +parties remain in full compliance. + +
The Free Software Foundation may publish new, revised versions +of the GNU Free Documentation License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. See +http://www.gnu.org/copyleft/. + +
Each version of the License is given a distinguishing version number. +If the Document specifies that a particular numbered version of this +License “or any later version” applies to it, you have the option of +following the terms and conditions either of that specified version or +of any later version that has been published (not as a draft) by the +Free Software Foundation. If the Document does not specify a version +number of this License, you may choose any version ever published (not +as a draft) by the Free Software Foundation. +
To use this License in a document you have written, include a copy of +the License in the document and put the following copyright and +license notices just after the title page: + +
Copyright (C) year your name. + Permission is granted to copy, distribute and/or modify this document + under the terms of the GNU Free Documentation License, Version 1.2 + or any later version published by the Free Software Foundation; + with no Invariant Sections, no Front-Cover Texts, and no Back-Cover + Texts. A copy of the license is included in the section entitled ``GNU + Free Documentation License''. ++
If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, +replace the “with...Texts.” line with this: + +
with the Invariant Sections being list their titles, with + the Front-Cover Texts being list, and with the Back-Cover Texts + being list. ++
If you have Invariant Sections without Cover Texts, or some other +combination of the three, merge those two alternatives to suit the +situation. + +
If your document contains nontrivial examples of program code, we +recommend releasing these examples in parallel under your choice of +free software license, such as the GNU General Public License, +to permit their use in free software. + + + + +
+ + +libmpfr: MPFR Basicsstdio.h: MPFR Basicsmp_prec_t: MPFR Basicsmp_rnd_t: MPFR Basicsmpfr_abs: Basic Arithmetic Functionsmpfr_acos: Special Functionsmpfr_acosh: Special Functionsmpfr_add: Basic Arithmetic Functionsmpfr_add_q: Basic Arithmetic Functionsmpfr_add_si: Basic Arithmetic Functionsmpfr_add_ui: Basic Arithmetic Functionsmpfr_add_z: Basic Arithmetic Functionsmpfr_agm: Special Functionsmpfr_asin: Special Functionsmpfr_asinh: Special Functionsmpfr_atan: Special Functionsmpfr_atan2: Special Functionsmpfr_atanh: Special Functionsmpfr_can_round: Internalsmpfr_cbrt: Basic Arithmetic Functionsmpfr_ceil: Integer Related Functionsmpfr_check_range: Exception Related Functionsmpfr_clear: Initialization Functionsmpfr_clear_erangeflag: Exception Related Functionsmpfr_clear_flags: Exception Related Functionsmpfr_clear_inexflag: Exception Related Functionsmpfr_clear_nanflag: Exception Related Functionsmpfr_clear_overflow: Exception Related Functionsmpfr_clear_underflow: Exception Related Functionsmpfr_clears: Advanced Functionsmpfr_cmp: Comparison Functionsmpfr_cmp_d: Comparison Functionsmpfr_cmp_f: Comparison Functionsmpfr_cmp_ld: Comparison Functionsmpfr_cmp_q: Comparison Functionsmpfr_cmp_si: Comparison Functionsmpfr_cmp_si_2exp: Comparison Functionsmpfr_cmp_ui: Comparison Functionsmpfr_cmp_ui_2exp: Comparison Functionsmpfr_cmp_z: Comparison Functionsmpfr_cmpabs: Comparison Functionsmpfr_const_catalan: Special Functionsmpfr_const_euler: Special Functionsmpfr_const_log2: Special Functionsmpfr_const_pi: Special Functionsmpfr_copysign: Miscellaneous Functionsmpfr_cos: Special Functionsmpfr_cosh: Special Functionsmpfr_cot: Special Functionsmpfr_coth: Special Functionsmpfr_csc: Special Functionsmpfr_csch: Special Functionsmpfr_custom_get_exp: Custom Interfacempfr_custom_get_kind: Custom Interfacempfr_custom_get_mantissa: Custom Interfacempfr_custom_get_size: Custom Interfacempfr_custom_init: Custom Interfacempfr_custom_init_set: Custom Interfacempfr_custom_move: Custom InterfaceMPFR_DECL_INIT: Advanced Functionsmpfr_dim: Basic Arithmetic Functionsmpfr_div: Basic Arithmetic Functionsmpfr_div_2exp: Compatibility with MPFmpfr_div_2si: Basic Arithmetic Functionsmpfr_div_2ui: Basic Arithmetic Functionsmpfr_div_q: Basic Arithmetic Functionsmpfr_div_si: Basic Arithmetic Functionsmpfr_div_ui: Basic Arithmetic Functionsmpfr_div_z: Basic Arithmetic Functionsmpfr_eint: Special Functionsmpfr_eq: Compatibility with MPFmpfr_equal_p: Comparison Functionsmpfr_erangeflag_p: Exception Related Functionsmpfr_erf: Special Functionsmpfr_erfc: Special Functionsmpfr_exp: Special Functionsmpfr_exp10: Special Functionsmpfr_exp2: Special Functionsmpfr_expm1: Special Functionsmpfr_fac_ui: Special Functionsmpfr_fits_intmax_p: Conversion Functionsmpfr_fits_sint_p: Conversion Functionsmpfr_fits_slong_p: Conversion Functionsmpfr_fits_sshort_p: Conversion Functionsmpfr_fits_uint_p: Conversion Functionsmpfr_fits_uintmax_p: Conversion Functionsmpfr_fits_ulong_p: Conversion Functionsmpfr_fits_ushort_p: Conversion Functionsmpfr_floor: Integer Related Functionsmpfr_fma: Special Functionsmpfr_fms: Special Functionsmpfr_frac: Integer Related Functionsmpfr_free_cache: Special Functionsmpfr_free_str: Conversion Functionsmpfr_gamma: Special Functionsmpfr_get_d: Conversion Functionsmpfr_get_d1: Internalsmpfr_get_d_2exp: Conversion Functionsmpfr_get_decimal64: Conversion Functionsmpfr_get_default_prec: Initialization Functionsmpfr_get_default_rounding_mode: Rounding Mode Related Functionsmpfr_get_emax: Exception Related Functionsmpfr_get_emax_max: Exception Related Functionsmpfr_get_emax_min: Exception Related Functionsmpfr_get_emin: Exception Related Functionsmpfr_get_emin_max: Exception Related Functionsmpfr_get_emin_min: Exception Related Functionsmpfr_get_exp: Miscellaneous Functionsmpfr_get_f: Conversion Functionsmpfr_get_ld: Conversion Functionsmpfr_get_ld_2exp: Conversion Functionsmpfr_get_patches: Miscellaneous Functionsmpfr_get_prec: Initialization Functionsmpfr_get_si: Conversion Functionsmpfr_get_sj: Conversion Functionsmpfr_get_str: Conversion Functionsmpfr_get_ui: Conversion Functionsmpfr_get_uj: Conversion Functionsmpfr_get_version: Miscellaneous Functionsmpfr_get_z: Conversion Functionsmpfr_get_z_exp: Conversion Functionsmpfr_greater_p: Comparison Functionsmpfr_greaterequal_p: Comparison Functionsmpfr_hypot: Special Functionsmpfr_inexflag_p: Exception Related Functionsmpfr_inf_p: Comparison Functionsmpfr_init: Initialization Functionsmpfr_init2: Initialization Functionsmpfr_init_set: Combined Initialization and Assignment Functionsmpfr_init_set_d: Combined Initialization and Assignment Functionsmpfr_init_set_f: Combined Initialization and Assignment Functionsmpfr_init_set_ld: Combined Initialization and Assignment Functionsmpfr_init_set_q: Combined Initialization and Assignment Functionsmpfr_init_set_si: Combined Initialization and Assignment Functionsmpfr_init_set_str: Combined Initialization and Assignment Functionsmpfr_init_set_ui: Combined Initialization and Assignment Functionsmpfr_init_set_z: Combined Initialization and Assignment Functionsmpfr_inits: Advanced Functionsmpfr_inits2: Advanced Functionsmpfr_inp_str: Input and Output Functionsmpfr_integer_p: Integer Related Functionsmpfr_j0: Special Functionsmpfr_j1: Special Functionsmpfr_jn: Special Functionsmpfr_less_p: Comparison Functionsmpfr_lessequal_p: Comparison Functionsmpfr_lessgreater_p: Comparison Functionsmpfr_lgamma: Special Functionsmpfr_lngamma: Special Functionsmpfr_log: Special Functionsmpfr_log10: Special Functionsmpfr_log1p: Special Functionsmpfr_log2: Special Functionsmpfr_max: Miscellaneous Functionsmpfr_min: Miscellaneous Functionsmpfr_mul: Basic Arithmetic Functionsmpfr_mul_2exp: Compatibility with MPFmpfr_mul_2si: Basic Arithmetic Functionsmpfr_mul_2ui: Basic Arithmetic Functionsmpfr_mul_q: Basic Arithmetic Functionsmpfr_mul_si: Basic Arithmetic Functionsmpfr_mul_ui: Basic Arithmetic Functionsmpfr_mul_z: Basic Arithmetic Functionsmpfr_nan_p: Comparison Functionsmpfr_nanflag_p: Exception Related Functionsmpfr_neg: Basic Arithmetic Functionsmpfr_nextabove: Miscellaneous Functionsmpfr_nextbelow: Miscellaneous Functionsmpfr_nexttoward: Miscellaneous Functionsmpfr_number_p: Comparison Functionsmpfr_out_str: Input and Output Functionsmpfr_overflow_p: Exception Related Functionsmpfr_pow: Basic Arithmetic Functionsmpfr_pow_si: Basic Arithmetic Functionsmpfr_pow_ui: Basic Arithmetic Functionsmpfr_pow_z: Basic Arithmetic Functionsmpfr_prec_round: Rounding Mode Related Functionsmpfr_print_rnd_mode: Rounding Mode Related Functionsmpfr_random: Miscellaneous Functionsmpfr_random2: Miscellaneous Functionsmpfr_reldiff: Compatibility with MPFmpfr_remainder: Integer Related Functionsmpfr_remquo: Integer Related Functionsmpfr_rint: Integer Related Functionsmpfr_rint_ceil: Integer Related Functionsmpfr_rint_floor: Integer Related Functionsmpfr_rint_round: Integer Related Functionsmpfr_rint_trunc: Integer Related Functionsmpfr_root: Basic Arithmetic Functionsmpfr_round: Integer Related Functionsmpfr_round_prec: Rounding Mode Related Functionsmpfr_sec: Special Functionsmpfr_sech: Special Functionsmpfr_set: Assignment Functionsmpfr_set_d: Assignment Functionsmpfr_set_decimal64: Assignment Functionsmpfr_set_default_prec: Initialization Functionsmpfr_set_default_rounding_mode: Rounding Mode Related Functionsmpfr_set_emax: Exception Related Functionsmpfr_set_emin: Exception Related Functionsmpfr_set_erangeflag: Exception Related Functionsmpfr_set_exp: Miscellaneous Functionsmpfr_set_f: Assignment Functionsmpfr_set_inexflag: Exception Related Functionsmpfr_set_inf: Assignment Functionsmpfr_set_ld: Assignment Functionsmpfr_set_nan: Assignment Functionsmpfr_set_nanflag: Exception Related Functionsmpfr_set_overflow: Exception Related Functionsmpfr_set_prec: Initialization Functionsmpfr_set_prec_raw: Compatibility with MPFmpfr_set_q: Assignment Functionsmpfr_set_si: Assignment Functionsmpfr_set_si_2exp: Assignment Functionsmpfr_set_sj: Assignment Functionsmpfr_set_sj_2exp: Assignment Functionsmpfr_set_str: Assignment Functionsmpfr_set_ui: Assignment Functionsmpfr_set_ui_2exp: Assignment Functionsmpfr_set_uj: Assignment Functionsmpfr_set_uj_2exp: Assignment Functionsmpfr_set_underflow: Exception Related Functionsmpfr_set_z: Assignment Functionsmpfr_setsign: Miscellaneous Functionsmpfr_sgn: Comparison Functionsmpfr_si_div: Basic Arithmetic Functionsmpfr_si_sub: Basic Arithmetic Functionsmpfr_signbit: Miscellaneous Functionsmpfr_sin: Special Functionsmpfr_sin_cos: Special Functionsmpfr_sinh: Special Functionsmpfr_sqr: Basic Arithmetic Functionsmpfr_sqrt: Basic Arithmetic Functionsmpfr_sqrt_ui: Basic Arithmetic Functionsmpfr_strtofr: Assignment Functionsmpfr_sub: Basic Arithmetic Functionsmpfr_sub_q: Basic Arithmetic Functionsmpfr_sub_si: Basic Arithmetic Functionsmpfr_sub_ui: Basic Arithmetic Functionsmpfr_sub_z: Basic Arithmetic Functionsmpfr_subnormalize: Exception Related Functionsmpfr_sum: Special Functionsmpfr_swap: Assignment Functionsmpfr_t: MPFR Basicsmpfr_tan: Special Functionsmpfr_tanh: Special Functionsmpfr_trunc: Integer Related Functionsmpfr_ui_div: Basic Arithmetic Functionsmpfr_ui_pow: Basic Arithmetic Functionsmpfr_ui_pow_ui: Basic Arithmetic Functionsmpfr_ui_sub: Basic Arithmetic Functionsmpfr_underflow_p: Exception Related Functionsmpfr_unordered_p: Comparison Functionsmpfr_urandomb: Miscellaneous FunctionsMPFR_VERSION: Miscellaneous FunctionsMPFR_VERSION_MAJOR: Miscellaneous FunctionsMPFR_VERSION_MINOR: Miscellaneous FunctionsMPFR_VERSION_NUM: Miscellaneous FunctionsMPFR_VERSION_PATCHLEVEL: Miscellaneous FunctionsMPFR_VERSION_STRING: Miscellaneous Functionsmpfr_y0: Special Functionsmpfr_y1: Special Functionsmpfr_yn: Special Functionsmpfr_zero_p: Comparison Functionsmpfr_zeta: Special Functionsmpfr_zeta_ui: Special Functions