--- /dev/null
+This is ../mpfr.info, produced by makeinfo version 4.12 from
+../mpfr.texi.
+
+This manual documents how to install and use the Multiple Precision
+Floating-Point Reliable Library, version 2.4.1.
+
+ Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
+2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 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 *note GNU Free
+Documentation License::.
+
+INFO-DIR-SECTION Software libraries
+START-INFO-DIR-ENTRY
+* mpfr: (mpfr). Multiple Precision Floating-Point Reliable Library.
+END-INFO-DIR-ENTRY
+
+\1f
+File: mpfr.info, Node: Top, Next: Copying, Prev: (dir), Up: (dir)
+
+GNU MPFR
+********
+
+ This manual documents how to install and use the Multiple Precision
+Floating-Point Reliable Library, version 2.4.1.
+
+ Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
+2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 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 *note GNU Free
+Documentation License::.
+
+
+* Menu:
+
+* Copying:: MPFR Copying Conditions (LGPL).
+* Introduction to MPFR:: Brief introduction to GNU MPFR.
+* Installing MPFR:: How to configure and compile the MPFR library.
+* Reporting Bugs:: How to usefully report bugs.
+* MPFR Basics:: What every MPFR user should now.
+* MPFR Interface:: MPFR functions and macros.
+* Contributors::
+* References::
+* GNU Free Documentation License::
+* Concept Index::
+* Function Index::
+
+\1f
+File: mpfr.info, Node: Copying, Next: Introduction to MPFR, Prev: Top, Up: Top
+
+MPFR Copying Conditions
+***********************
+
+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 GNU 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 GNU 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 GNU MPFR library are
+found in the Lesser General Public License that accompanies the source
+code. See the file COPYING.LIB.
+
+\1f
+File: mpfr.info, Node: Introduction to MPFR, Next: Installing MPFR, Prev: Copying, Up: Top
+
+1 Introduction to MPFR
+**********************
+
+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:
+
+ * the MPFR code is portable, i.e. the result of any operation does
+ not depend (or should not) on the machine word size
+ `mp_bits_per_limb' (32 or 64 on most machines);
+
+ * the precision in bits can be set exactly to any valid value for
+ each variable (including very small precision);
+
+ * MPFR provides the four rounding modes from the IEEE 754-1985
+ standard.
+
+ 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.
+
+1.1 How to Use This Manual
+==========================
+
+Everyone should read *note MPFR Basics::. If you need to install the
+library yourself, you need to read *note 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.
+
+\1f
+File: mpfr.info, Node: Installing MPFR, Next: Reporting Bugs, Prev: Introduction to MPFR, Up: Top
+
+2 Installing MPFR
+*****************
+
+2.1 How to Install
+==================
+
+Here are the steps needed to install the library on Unix systems (more
+details are provided in the `INSTALL' file):
+
+ 1. To build MPFR, you first have to install GNU MP (version 4.1 or
+ higher) on your computer. You need a C compiler, preferably GCC,
+ but any reasonable compiler should work. And you need a standard
+ Unix `make' program, plus some other standard Unix utility
+ programs.
+
+ 2. In the MPFR build directory, type `./configure'
+
+ 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).
+
+ 3. `make'
+
+ This will compile MPFR, and create a library archive file
+ `libmpfr.a'. A dynamic library may be produced too (see
+ configure).
+
+ 4. `make check'
+
+ This will make sure MPFR was built correctly. If you get error
+ messages, please report this to `mpfr@loria.fr'. (*Note Reporting
+ Bugs::, for information on what to include in useful bug reports.)
+
+ 5. `make install'
+
+ 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').
+
+2.2 Other `make' Targets
+========================
+
+There are some other useful make targets:
+
+ * `mpfr.info' or `info'
+
+ Create an info version of the manual, in `mpfr.info'.
+
+ * `mpfr.pdf' or `pdf'
+
+ Create a PDF version of the manual, in `mpfr.pdf'.
+
+ * `mpfr.dvi' or `dvi'
+
+ Create a DVI version of the manual, in `mpfr.dvi'.
+
+ * `mpfr.ps' or `ps'
+
+ Create a Postscript version of the manual, in `mpfr.ps'.
+
+ * `mpfr.html' or `html'
+
+ 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.
+
+ * `clean'
+
+ Delete all object files and archive files, but not the
+ configuration files.
+
+ * `distclean'
+
+ Delete all files not included in the distribution.
+
+ * `uninstall'
+
+ Delete all files copied by `make install'.
+
+2.3 Build Problems
+==================
+
+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'. *Note Reporting Bugs::.
+Some bug fixes are available on the MPFR 2.4.1 web page
+`http://www.mpfr.org/mpfr-2.4.1/'.
+
+2.4 Getting the Latest Version of MPFR
+======================================
+
+The latest version of MPFR is available from
+`ftp://ftp.gnu.org/gnu/mpfr/' or `http://www.mpfr.org/'.
+
+\1f
+File: mpfr.info, Node: Reporting Bugs, Next: MPFR Basics, Prev: Installing MPFR, Up: Top
+
+3 Reporting Bugs
+****************
+
+If you think you have found a bug in the MPFR library, first have a look
+on the MPFR 2.4.1 web page `http://www.mpfr.org/mpfr-2.4.1/' 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 will
+not 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.
+
+\1f
+File: mpfr.info, Node: MPFR Basics, Next: MPFR Interface, Prev: Reporting Bugs, Up: Top
+
+4 MPFR Basics
+*************
+
+4.1 Headers and Libraries
+=========================
+
+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>
+
+ Likewise `<stdarg.h>' (or `<varargs.h>') is required for prototypes
+with `va_list' parameters, such as `mpfr_vprintf'.
+
+ 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, *note GNU Libtool: (libtool.info)Top.
+
+ 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.
+
+4.2 Nomenclature and Types
+==========================
+
+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'.
+
+4.3 Function Classes
+====================
+
+There is only one class of functions in the MPFR library:
+
+ 1. Functions for floating-point arithmetic, with names beginning with
+ `mpfr_'. The associated type is `mpfr_t'.
+
+4.4 MPFR Variable Conventions
+=============================
+
+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 do not 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.
+
+4.5 Rounding Modes
+==================
+
+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.
+
+4.6 Floating-Point Values on Special Numbers
+============================================
+
+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 (*note 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 *note MPFR
+Interface::. Example: `mpfr_hypot' on (NaN,0) gives NaN, but
+`mpfr_hypot' on (NaN,+Inf) gives +Inf (as specified in *note Special
+Functions::), since for any finite input X, `mpfr_hypot' on (X,+Inf)
+gives +Inf.
+
+4.7 Exceptions
+==============
+
+MPFR supports 5 exception types:
+
+ * Underflow: An underflow occurs when the exact result of a function
+ is a non-zero real number and the result obtained after the
+ rounding, assuming an unbounded exponent range (for the rounding),
+ has an exponent smaller than the minimum exponent of the current
+ range. In the round-to-nearest mode, the halfway case is rounded
+ toward zero.
+
+ 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.
+
+ * Overflow: An overflow occurs when the exact result of a function
+ is a non-zero real number and the result obtained after the
+ rounding, assuming an unbounded exponent range (for the rounding),
+ has an exponent larger than the maximum exponent of the current
+ range. In the round-to-nearest mode, the result is infinite.
+
+ * NaN: A NaN exception occurs when the result of a function is a NaN.
+
+ * Inexact: An inexact exception occurs when the result of a function
+ cannot be represented exactly and must be rounded.
+
+ * Range error: A range exception occurs when a function that does
+ not return a MPFR number (such as comparisons and conversions to
+ an integer) has an invalid result (e.g. an argument is NaN in
+ `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 *note Exception Related Functions::.
+
+ Differences with the ISO C99 standard:
+
+ * In C, only quiet NaNs are specified, and a NaN propagation does not
+ raise an invalid exception. Unless explicitly stated otherwise,
+ MPFR sets the NaN flag whenever a NaN is generated, even when a
+ NaN is propagated (e.g. in NaN + NaN), as if all NaNs were
+ signaling.
+
+ * An invalid exception in C corresponds to either a NaN exception or
+ a range error in MPFR.
+
+
+4.8 Memory Handling
+===================
+
+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).
+
+\1f
+File: mpfr.info, Node: MPFR Interface, Next: Contributors, Prev: MPFR Basics, Up: Top
+
+5 MPFR Interface
+****************
+
+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.
+
+* Menu:
+
+* Initialization Functions::
+* Assignment Functions::
+* Combined Initialization and Assignment Functions::
+* Conversion Functions::
+* Basic Arithmetic Functions::
+* Comparison Functions::
+* Special Functions::
+* Input and Output Functions::
+* Formatted Output Functions::
+* Integer Related Functions::
+* Rounding Related Functions::
+* Miscellaneous Functions::
+* Exception Related Functions::
+* Compatibility with MPF::
+* Custom Interface::
+* Internals::
+
+\1f
+File: mpfr.info, Node: Initialization Functions, Next: Assignment Functions, Prev: MPFR Interface, Up: MPFR Interface
+
+5.1 Initialization Functions
+============================
+
+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.
+
+ -- Function: void mpfr_init2 (mpfr_t X, mp_prec_t PREC)
+ Initialize X, set its precision to be *exactly* PREC bits and its
+ value to NaN. (Warning: the corresponding `mpf' functions
+ 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, use `mpfr_set_prec'. The precision PREC must be an
+ integer between `MPFR_PREC_MIN' and `MPFR_PREC_MAX' (otherwise the
+ behavior is undefined).
+
+ -- Function: void mpfr_inits2 (mp_prec_t PREC, mpfr_t X, ...)
+ Initialize all the `mpfr_t' variables of the given `va_list', set
+ their precision to be *exactly* PREC bits and their value to NaN.
+ See `mpfr_init2' for more details. The `va_list' is assumed to be
+ composed only of type `mpfr_t' (or equivalently `mpfr_ptr'). It
+ begins from X. It ends when it encounters a null pointer (whose
+ type must also be `mpfr_ptr').
+
+ -- Function: void mpfr_clear (mpfr_t X)
+ Free the space occupied by X. Make sure to call this function for
+ all `mpfr_t' variables when you are done with them.
+
+ -- Function: void mpfr_clears (mpfr_t X, ...)
+ Free the space occupied by all the `mpfr_t' variables of the given
+ `va_list'. See `mpfr_clear' for more details. The `va_list' is
+ assumed to be composed only of type `mpfr_t' (or equivalently
+ `mpfr_ptr'). It begins from X. It ends when it encounters a null
+ pointer (whose type must also be `mpfr_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);
+ }
+
+ -- Function: void mpfr_init (mpfr_t X)
+ 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 to `mpfr_set_default_prec'.
+
+ Warning! In a given program, some other libraries might change the
+ default precision and not restore it. Thus it is safer to use
+ `mpfr_init2'.
+
+ -- Function: void mpfr_inits (mpfr_t X, ...)
+ Initialize all the `mpfr_t' variables of the given `va_list', set
+ their precision to be the default precision and their value to NaN.
+ See `mpfr_init' for more details. The `va_list' is assumed to be
+ composed only of type `mpfr_t' (or equivalently `mpfr_ptr'). It
+ begins from X. It ends when it encounters a null pointer (whose
+ type must also be `mpfr_ptr').
+
+ Warning! In a given program, some other libraries might change the
+ default precision and not restore it. Thus it is safer to use
+ `mpfr_inits2'.
+
+ -- Macro: MPFR_DECL_INIT (NAME, PREC)
+ 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 using `mpfr_init2' but has some drawbacks:
+
+ * You *must not* call `mpfr_clear' with variables created with
+ this macro (the storage is allocated at the point of
+ declaration and deallocated when the brace-level is exited).
+
+ * You *cannot* 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 constant expression, your
+ compiler must support `variable-length automatic arrays'
+ (standard in ISO C99). `GCC 2.95.3' and above 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_EXTENSION' macro to avoid warnings due to the
+ `MPFR_DECL_INIT' implementation.
+
+ -- Function: void mpfr_set_default_prec (mp_prec_t 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_init' will use this
+ precision, but previously initialized variables are unaffected.
+ This default precision is set to 53 bits initially. The precision
+ can be any integer between `MPFR_PREC_MIN' and `MPFR_PREC_MAX'.
+
+ -- Function: mp_prec_t mpfr_get_default_prec (void)
+ Return the default MPFR precision in bits.
+
+ 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.
+
+ -- Function: void mpfr_set_prec (mpfr_t X, mp_prec_t PREC)
+ 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 between
+ `MPFR_PREC_MIN' and `MPFR_PREC_MAX'.
+
+ In case you want to keep the previous value stored in X, use
+ `mpfr_prec_round' instead.
+
+ -- Function: mp_prec_t mpfr_get_prec (mpfr_t X)
+ Return the precision actually used for assignments of X, i.e. the
+ number of bits used to store its significand.
+
+\1f
+File: mpfr.info, Node: Assignment Functions, Next: Combined Initialization and Assignment Functions, Prev: Initialization Functions, Up: MPFR Interface
+
+5.2 Assignment Functions
+========================
+
+These functions assign new values to already initialized floats (*note
+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.
+
+ -- Function: int mpfr_set (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_set_ui (mpfr_t ROP, unsigned long int OP,
+ mp_rnd_t RND)
+ -- Function: int mpfr_set_si (mpfr_t ROP, long int OP, mp_rnd_t RND)
+ -- Function: int mpfr_set_uj (mpfr_t ROP, uintmax_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_set_sj (mpfr_t ROP, intmax_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_set_d (mpfr_t ROP, double OP, mp_rnd_t RND)
+ -- Function: int mpfr_set_ld (mpfr_t ROP, long double OP, mp_rnd_t RND)
+ -- Function: int mpfr_set_decimal64 (mpfr_t ROP, _Decimal64 OP,
+ mp_rnd_t RND)
+ -- Function: int mpfr_set_z (mpfr_t ROP, mpz_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_set_q (mpfr_t ROP, mpq_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_set_f (mpfr_t ROP, mpf_t OP, mp_rnd_t RND)
+ 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_q' and `mpfr_set_f', regardless of the rounding mode.
+ If the system does not support the IEEE-754 standard, `mpfr_set_d',
+ `mpfr_set_ld' and `mpfr_set_decimal64' might not preserve the
+ signed zeros. The `mpfr_set_decimal64' function 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_q' might not be able to
+ work if the numerator (or the denominator) can not be
+ representable as a `mpfr_t'.
+
+ Note: If you want to store a floating-point constant to a `mpfr_t',
+ you should use `mpfr_set_str' (or one of the MPFR constant
+ functions, such as `mpfr_const_pi' for Pi) instead of `mpfr_set_d',
+ `mpfr_set_ld' or `mpfr_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.
+
+ -- Function: int mpfr_set_ui_2exp (mpfr_t ROP, unsigned long int OP,
+ mp_exp_t E, mp_rnd_t RND)
+ -- Function: int mpfr_set_si_2exp (mpfr_t ROP, long int OP, mp_exp_t
+ E, mp_rnd_t RND)
+ -- Function: int mpfr_set_uj_2exp (mpfr_t ROP, uintmax_t OP, intmax_t
+ E, mp_rnd_t RND)
+ -- Function: int mpfr_set_sj_2exp (mpfr_t ROP, intmax_t OP, intmax_t
+ E, mp_rnd_t RND)
+ 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.
+
+ -- Function: int mpfr_set_str (mpfr_t ROP, const char *S, int BASE,
+ mp_rnd_t RND)
+ Set ROP to the value of the string S in base BASE, rounded in the
+ direction RND. See the documentation of `mpfr_strtofr' for a
+ detailed description of the valid string formats. Contrary to
+ `mpfr_strtofr', `mpfr_set_str' requires the _whole_ string to
+ represent a valid floating-point number. 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.
+
+ -- Function: int mpfr_strtofr (mpfr_t ROP, const char *NPTR, char
+ **ENDPTR, int BASE, mp_rnd_t RND)
+ 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 `strtod' function 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' = 35; 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 be `e' or `E' for 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 be
+ `p' or `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 with `0b' or `0B',
+ and in base 16, it can start with `0x' or `0X'.
+
+ If the argument BASE is 0, then the base is automatically detected
+ as follows. If the significand starts with `0b' or `0B', base 2 is
+ assumed. If the significand starts with `0x' or `0X', 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', `0x'
+ or `0X' is not followed by a binary/hexadecimal digit, then the
+ subject sequence stops at the character `0'.
+
+ Special data (for infinities and NaN) can be `@inf@' or
+ `@nan@(n-char-sequence)', and if BASE <= 16, it can also be
+ `infinity', `inf', `nan' or `nan(n-char-sequence)', all case
+ insensitive. A `n-char-sequence' is 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.
+
+
+ -- Function: void mpfr_set_inf (mpfr_t X, int SIGN)
+ -- Function: void mpfr_set_nan (mpfr_t X)
+ 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.
+
+ -- Function: void mpfr_swap (mpfr_t X, mpfr_t Y)
+ Swap the values X and Y efficiently. Warning: the precisions are
+ exchanged too; in case the precisions are different, `mpfr_swap'
+ is thus not equivalent to three `mpfr_set' calls using a third
+ auxiliary variable.
+
+\1f
+File: mpfr.info, Node: Combined Initialization and Assignment Functions, Next: Conversion Functions, Prev: Assignment Functions, Up: MPFR Interface
+
+5.3 Combined Initialization and Assignment Functions
+====================================================
+
+ -- Macro: int mpfr_init_set (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Macro: int mpfr_init_set_ui (mpfr_t ROP, unsigned long int OP,
+ mp_rnd_t RND)
+ -- Macro: int mpfr_init_set_si (mpfr_t ROP, signed long int OP,
+ mp_rnd_t RND)
+ -- Macro: int mpfr_init_set_d (mpfr_t ROP, double OP, mp_rnd_t RND)
+ -- Macro: int mpfr_init_set_ld (mpfr_t ROP, long double OP, mp_rnd_t
+ RND)
+ -- Macro: int mpfr_init_set_z (mpfr_t ROP, mpz_t OP, mp_rnd_t RND)
+ -- Macro: int mpfr_init_set_q (mpfr_t ROP, mpq_t OP, mp_rnd_t RND)
+ -- Macro: int mpfr_init_set_f (mpfr_t ROP, mpf_t OP, mp_rnd_t RND)
+ 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'.
+
+ -- Function: int mpfr_init_set_str (mpfr_t X, const char *S, int BASE,
+ mp_rnd_t RND)
+ Initialize X and set its value from the string S in base BASE,
+ rounded in the direction RND. See `mpfr_set_str'.
+
+\1f
+File: mpfr.info, Node: Conversion Functions, Next: Basic Arithmetic Functions, Prev: Combined Initialization and Assignment Functions, Up: MPFR Interface
+
+5.4 Conversion Functions
+========================
+
+ -- Function: double mpfr_get_d (mpfr_t OP, mp_rnd_t RND)
+ -- Function: long double mpfr_get_ld (mpfr_t OP, mp_rnd_t RND)
+ -- Function: _Decimal64 mpfr_get_decimal64 (mpfr_t OP, mp_rnd_t RND)
+ Convert OP to a `double' (respectively `_Decimal64' or `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. The
+ `mpfr_get_decimal64' function is built only under some conditions:
+ see the documentation of `mpfr_set_decimal64'.
+
+ -- Function: double mpfr_get_d_2exp (long *EXP, mpfr_t OP, mp_rnd_t
+ RND)
+ -- Function: long double mpfr_get_ld_2exp (long *EXP, mpfr_t OP,
+ mp_rnd_t RND)
+ 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.
+
+ -- Function: long mpfr_get_si (mpfr_t OP, mp_rnd_t RND)
+ -- Function: unsigned long mpfr_get_ui (mpfr_t OP, mp_rnd_t RND)
+ -- Function: intmax_t mpfr_get_sj (mpfr_t OP, mp_rnd_t RND)
+ -- Function: uintmax_t mpfr_get_uj (mpfr_t OP, mp_rnd_t RND)
+ Convert OP to a `long', an `unsigned long', an `intmax_t' or an
+ `uintmax_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 _erange_ flag is set too. See also `mpfr_fits_slong_p',
+ `mpfr_fits_ulong_p', `mpfr_fits_intmax_p' and
+ `mpfr_fits_uintmax_p'.
+
+ -- Function: mp_exp_t mpfr_get_z_exp (mpz_t ROP, mpfr_t OP)
+ 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_t' type, the behavior is undefined.
+
+ -- Function: void mpfr_get_z (mpz_t ROP, mpfr_t OP, mp_rnd_t RND)
+ Convert OP to a `mpz_t', after rounding it with respect to RND. If
+ OP is NaN or Inf, the result is undefined.
+
+ -- Function: int mpfr_get_f (mpf_t ROP, mpfr_t OP, mp_rnd_t RND)
+ 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 in `mpf'.
+
+ -- Function: char * mpfr_get_str (char *STR, mp_exp_t *EXPPTR, int B,
+ size_t N, mpfr_t OP, mp_rnd_t RND)
+ 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.
+
+ -- Function: void mpfr_free_str (char *STR)
+ Free a string allocated by `mpfr_get_str' using the current
+ unallocation function (preliminary interface). The block is
+ assumed to be `strlen(STR)+1' bytes. For more information about
+ how it is done: *note Custom Allocation: (gmp.info)Custom
+ Allocation.
+
+ -- Function: int mpfr_fits_ulong_p (mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_fits_slong_p (mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_fits_uint_p (mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_fits_sint_p (mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_fits_ushort_p (mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_fits_sshort_p (mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_fits_intmax_p (mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_fits_uintmax_p (mpfr_t OP, mp_rnd_t RND)
+ Return non-zero if OP would fit in the respective C data type, when
+ rounded to an integer in the direction RND.
+
+\1f
+File: mpfr.info, Node: Basic Arithmetic Functions, Next: Comparison Functions, Prev: Conversion Functions, Up: MPFR Interface
+
+5.5 Basic Arithmetic Functions
+==============================
+
+ -- Function: int mpfr_add (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_add_ui (mpfr_t ROP, mpfr_t OP1, unsigned long
+ int OP2, mp_rnd_t RND)
+ -- Function: int mpfr_add_si (mpfr_t ROP, mpfr_t OP1, long int OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_add_d (mpfr_t ROP, mpfr_t OP1, double OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_add_z (mpfr_t ROP, mpfr_t OP1, mpz_t OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_add_q (mpfr_t ROP, mpfr_t OP1, mpq_t OP2,
+ mp_rnd_t 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)). The `mpfr_add_d' function assumes that
+ the radix of the `double' type is a power of 2, with a precision
+ at most that declared by the C implementation (macro
+ `IEEE_DBL_MANT_DIG', and if not defined 53 bits).
+
+ -- Function: int mpfr_sub (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_ui_sub (mpfr_t ROP, unsigned long int OP1,
+ mpfr_t OP2, mp_rnd_t RND)
+ -- Function: int mpfr_sub_ui (mpfr_t ROP, mpfr_t OP1, unsigned long
+ int OP2, mp_rnd_t RND)
+ -- Function: int mpfr_si_sub (mpfr_t ROP, long int OP1, mpfr_t OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_sub_si (mpfr_t ROP, mpfr_t OP1, long int OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_d_sub (mpfr_t ROP, double OP1, mpfr_t OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_sub_d (mpfr_t ROP, mpfr_t OP1, double OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_sub_z (mpfr_t ROP, mpfr_t OP1, mpz_t OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_sub_q (mpfr_t ROP, mpfr_t OP1, mpq_t OP2,
+ mp_rnd_t 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), (-0) - 0 = (-0), 0 - (+0) = (-0) and 0 - (-0) = (+0)). The
+ same restrictions than for `mpfr_add_d' apply to `mpfr_d_sub' and
+ `mpfr_sub_d'.
+
+ -- Function: int mpfr_mul (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_mul_ui (mpfr_t ROP, mpfr_t OP1, unsigned long
+ int OP2, mp_rnd_t RND)
+ -- Function: int mpfr_mul_si (mpfr_t ROP, mpfr_t OP1, long int OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_mul_d (mpfr_t ROP, mpfr_t OP1, double OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_mul_z (mpfr_t ROP, mpfr_t OP1, mpz_t OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_mul_q (mpfr_t ROP, mpfr_t OP1, mpq_t OP2,
+ mp_rnd_t RND)
+ 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). The same restrictions than for `mpfr_add_d' apply to
+ `mpfr_mul_d'.
+
+ -- Function: int mpfr_sqr (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ Set ROP to the square of OP rounded in the direction RND.
+
+ -- Function: int mpfr_div (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_ui_div (mpfr_t ROP, unsigned long int OP1,
+ mpfr_t OP2, mp_rnd_t RND)
+ -- Function: int mpfr_div_ui (mpfr_t ROP, mpfr_t OP1, unsigned long
+ int OP2, mp_rnd_t RND)
+ -- Function: int mpfr_si_div (mpfr_t ROP, long int OP1, mpfr_t OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_div_si (mpfr_t ROP, mpfr_t OP1, long int OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_d_div (mpfr_t ROP, double OP1, mpfr_t OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_div_d (mpfr_t ROP, mpfr_t OP1, double OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_div_z (mpfr_t ROP, mpfr_t OP1, mpz_t OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_div_q (mpfr_t ROP, mpfr_t OP1, mpq_t OP2,
+ mp_rnd_t 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). The same
+ restrictions than for `mpfr_add_d' apply to `mpfr_d_div' and
+ `mpfr_div_d'.
+
+ -- Function: int mpfr_sqrt (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_sqrt_ui (mpfr_t ROP, unsigned long int OP,
+ mp_rnd_t RND)
+ 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.
+
+ -- Function: int mpfr_rec_sqrt (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ Set ROP to the reciprocal square root of OP rounded in the
+ direction RND. Return +Inf if OP is ±0, and +0 if OP is +Inf. Set
+ ROP to NaN if OP is negative.
+
+ -- Function: int mpfr_cbrt (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_root (mpfr_t ROP, mpfr_t OP, unsigned long int
+ K, mp_rnd_t RND)
+ 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.
+
+ -- Function: int mpfr_pow (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_pow_ui (mpfr_t ROP, mpfr_t OP1, unsigned long
+ int OP2, mp_rnd_t RND)
+ -- Function: int mpfr_pow_si (mpfr_t ROP, mpfr_t OP1, long int OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_pow_z (mpfr_t ROP, mpfr_t OP1, mpz_t OP2,
+ mp_rnd_t RND)
+ -- Function: int mpfr_ui_pow_ui (mpfr_t ROP, unsigned long int OP1,
+ unsigned long int OP2, mp_rnd_t RND)
+ -- Function: int mpfr_ui_pow (mpfr_t ROP, unsigned long int OP1,
+ mpfr_t OP2, mp_rnd_t RND)
+ 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 `pow' function (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.
+
+ -- Function: int mpfr_neg (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ Set ROP to -OP rounded in the direction RND. Just changes the
+ sign if ROP and OP are the same variable.
+
+ -- Function: int mpfr_abs (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ 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.
+
+ -- Function: int mpfr_dim (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2,
+ mp_rnd_t RND)
+ 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.
+
+ -- Function: int mpfr_mul_2ui (mpfr_t ROP, mpfr_t OP1, unsigned long
+ int OP2, mp_rnd_t RND)
+ -- Function: int mpfr_mul_2si (mpfr_t ROP, mpfr_t OP1, long int OP2,
+ mp_rnd_t RND)
+ 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.
+
+ -- Function: int mpfr_div_2ui (mpfr_t ROP, mpfr_t OP1, unsigned long
+ int OP2, mp_rnd_t RND)
+ -- Function: int mpfr_div_2si (mpfr_t ROP, mpfr_t OP1, long int OP2,
+ mp_rnd_t RND)
+ 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.
+
+\1f
+File: mpfr.info, Node: Comparison Functions, Next: Special Functions, Prev: Basic Arithmetic Functions, Up: MPFR Interface
+
+5.6 Comparison Functions
+========================
+
+ -- Function: int mpfr_cmp (mpfr_t OP1, mpfr_t OP2)
+ -- Function: int mpfr_cmp_ui (mpfr_t OP1, unsigned long int OP2)
+ -- Function: int mpfr_cmp_si (mpfr_t OP1, signed long int OP2)
+ -- Function: int mpfr_cmp_d (mpfr_t OP1, double OP2)
+ -- Function: int mpfr_cmp_ld (mpfr_t OP1, long double OP2)
+ -- Function: int mpfr_cmp_z (mpfr_t OP1, mpz_t OP2)
+ -- Function: int mpfr_cmp_q (mpfr_t OP1, mpq_t OP2)
+ -- Function: int mpfr_cmp_f (mpfr_t OP1, mpf_t OP2)
+ 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_p'
+ for 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).
+
+ -- Function: int mpfr_cmp_ui_2exp (mpfr_t OP1, unsigned long int OP2,
+ mp_exp_t E)
+ -- Function: int mpfr_cmp_si_2exp (mpfr_t OP1, long int OP2, mp_exp_t
+ E)
+ Compare OP1 and OP2 multiplied by two to the power E. Similar as
+ above.
+
+ -- Function: int mpfr_cmpabs (mpfr_t OP1, mpfr_t OP2)
+ 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.
+
+ -- Function: int mpfr_nan_p (mpfr_t OP)
+ -- Function: int mpfr_inf_p (mpfr_t OP)
+ -- Function: int mpfr_number_p (mpfr_t OP)
+ -- Function: int mpfr_zero_p (mpfr_t OP)
+ 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.
+
+ -- Macro: int mpfr_sgn (mpfr_t OP)
+ 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.
+
+ -- Function: int mpfr_greater_p (mpfr_t OP1, mpfr_t OP2)
+ Return non-zero if OP1 > OP2, zero otherwise.
+
+ -- Function: int mpfr_greaterequal_p (mpfr_t OP1, mpfr_t OP2)
+ Return non-zero if OP1 >= OP2, zero otherwise.
+
+ -- Function: int mpfr_less_p (mpfr_t OP1, mpfr_t OP2)
+ Return non-zero if OP1 < OP2, zero otherwise.
+
+ -- Function: int mpfr_lessequal_p (mpfr_t OP1, mpfr_t OP2)
+ Return non-zero if OP1 <= OP2, zero otherwise.
+
+ -- Function: int mpfr_lessgreater_p (mpfr_t OP1, mpfr_t OP2)
+ 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).
+
+ -- Function: int mpfr_equal_p (mpfr_t OP1, mpfr_t OP2)
+ Return non-zero if OP1 = OP2, zero otherwise (i.e. OP1 and/or OP2
+ are NaN, or OP1 <> OP2).
+
+ -- Function: int mpfr_unordered_p (mpfr_t OP1, mpfr_t OP2)
+ Return non-zero if OP1 or OP2 is a NaN (i.e. they cannot be
+ compared), zero otherwise.
+
+\1f
+File: mpfr.info, Node: Special Functions, Next: Input and Output Functions, Prev: Comparison Functions, Up: MPFR Interface
+
+5.7 Special Functions
+=====================
+
+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.
+
+ -- Function: int mpfr_log (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_log2 (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_log10 (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ 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).
+
+ -- Function: int mpfr_exp (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_exp2 (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_exp10 (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ Set ROP to the exponential of OP, to 2 power of OP or to 10 power
+ of OP, respectively, rounded in the direction RND.
+
+ -- Function: int mpfr_cos (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_sin (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_tan (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ Set ROP to the cosine of OP, sine of OP, tangent of OP, rounded in
+ the direction RND.
+
+ -- Function: int mpfr_sec (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_csc (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_cot (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ Set ROP to the secant of OP, cosecant of OP, cotangent of OP,
+ rounded in the direction RND.
+
+ -- Function: int mpfr_sin_cos (mpfr_t SOP, mpfr_t COP, mpfr_t OP,
+ mp_rnd_t 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.
+
+ -- Function: int mpfr_acos (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_asin (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_atan (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ 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 for `asin(-1)', `asin(1)', `atan(-Inf)', `atan(+Inf)'.
+
+ -- Function: int mpfr_atan2 (mpfr_t ROP, mpfr_t Y, mpfr_t X, mp_rnd_t
+ RND)
+ Set ROP to the arc-tangent2 of Y and X, rounded in the direction
+ RND: if `x > 0', `atan2(y, x) = atan (y/x)'; if `x < 0', `atan2(y,
+ x) = sign(y)*(Pi - atan (abs(y/x)))'. As for `atan', 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 the `atan2' function (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.
+
+ -- Function: int mpfr_cosh (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_sinh (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_tanh (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ Set ROP to the hyperbolic cosine, sine or tangent of OP, rounded
+ in the direction RND.
+
+ -- Function: int mpfr_sinh_cosh (mpfr_t SOP, mpfr_t COP, mpfr_t OP,
+ mp_rnd_t RND)
+ Set simultaneously SOP to the hyperbolic sine of OP and
+ COP to the hyperbolic cosine of OP, rounded in the
+ direction RND with the corresponding precision of SOP and COP
+ which must be different variables. Return 0 iff both results are
+ exact.
+
+ -- Function: int mpfr_sech (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_csch (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_coth (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ Set ROP to the hyperbolic secant of OP, cosecant of OP, cotangent
+ of OP, rounded in the direction RND.
+
+ -- Function: int mpfr_acosh (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_asinh (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_atanh (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ Set ROP to the inverse hyperbolic cosine, sine or tangent of OP,
+ rounded in the direction RND.
+
+ -- Function: int mpfr_fac_ui (mpfr_t ROP, unsigned long int OP,
+ mp_rnd_t RND)
+ Set ROP to the factorial of the `unsigned long int' OP, rounded in
+ the direction RND.
+
+ -- Function: int mpfr_log1p (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ Set ROP to the logarithm of one plus OP, rounded in the direction
+ RND.
+
+ -- Function: int mpfr_expm1 (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ Set ROP to the exponential of OP minus one, rounded in the
+ direction RND.
+
+ -- Function: int mpfr_eint (mpfr_t Y, mpfr_t X, mp_rnd_t 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.
+
+ -- Function: int mpfr_li2 (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND_MODE)
+ Set ROP to real part of the dilogarithm of OP, rounded in the
+ direction RND_MODE. The dilogarithm function is defined here as
+ the integral of -log(1-t)/t from 0 to x.
+
+ -- Function: int mpfr_gamma (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ 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.
+
+ -- Function: int mpfr_lngamma (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ 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'.
+
+ -- Function: int mpfr_lgamma (mpfr_t ROP, int *SIGNP, mpfr_t OP,
+ mp_rnd_t RND)
+ 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.
+
+ -- Function: int mpfr_zeta (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_zeta_ui (mpfr_t ROP, unsigned long OP, mp_rnd_t
+ RND)
+ Set ROP to the value of the Riemann Zeta function on OP, rounded
+ in the direction RND.
+
+ -- Function: int mpfr_erf (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ Set ROP to the value of the error function on OP, rounded in the
+ direction RND.
+
+ -- Function: int mpfr_erfc (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ Set ROP to the value of the complementary error function on OP,
+ rounded in the direction RND.
+
+ -- Function: int mpfr_j0 (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_j1 (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_jn (mpfr_t ROP, long N, mpfr_t OP, mp_rnd_t RND)
+ Set ROP to the value of the first kind 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.
+
+ -- Function: int mpfr_y0 (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_y1 (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_yn (mpfr_t ROP, long N, mpfr_t OP, mp_rnd_t RND)
+ Set ROP to the value of the second kind 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.
+
+ -- Function: int mpfr_fma (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2, mpfr_t
+ OP3, mp_rnd_t RND)
+ Set ROP to (OP1 times OP2) + OP3, rounded in the direction RND.
+
+ -- Function: int mpfr_fms (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2, mpfr_t
+ OP3, mp_rnd_t RND)
+ Set ROP to (OP1 times OP2) - OP3, rounded in the direction RND.
+
+ -- Function: int mpfr_agm (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2,
+ mp_rnd_t 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.
+
+ -- Function: int mpfr_hypot (mpfr_t ROP, mpfr_t X, mpfr_t Y, mp_rnd_t
+ RND)
+ 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 `hypot' function (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.
+
+ -- Function: int mpfr_const_log2 (mpfr_t ROP, mp_rnd_t RND)
+ -- Function: int mpfr_const_pi (mpfr_t ROP, mp_rnd_t RND)
+ -- Function: int mpfr_const_euler (mpfr_t ROP, mp_rnd_t RND)
+ -- Function: int mpfr_const_catalan (mpfr_t ROP, mp_rnd_t RND)
+ 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'.
+
+ -- Function: void mpfr_free_cache (void)
+ 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_euler' and
+ `mpfr_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).
+
+ -- Function: int mpfr_sum (mpfr_t ROP, mpfr_ptr const TAB[], unsigned
+ long N, mp_rnd_t RND)
+ 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
+ `int' value 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.
+
+\1f
+File: mpfr.info, Node: Input and Output Functions, Next: Formatted Output Functions, Prev: Special Functions, Up: MPFR Interface
+
+5.8 Input and Output Functions
+==============================
+
+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' 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.
+
+ -- Function: size_t mpfr_out_str (FILE *STREAM, int BASE, size_t N,
+ mpfr_t OP, mp_rnd_t RND)
+ 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.
+
+ -- Function: size_t mpfr_inp_str (mpfr_t ROP, FILE *STREAM, int BASE,
+ mp_rnd_t RND)
+ 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 of `mpfr_strtofr' for a detailed
+ description of the valid string formats.
+
+ Return the number of bytes read, or if an error occurred, return 0.
+
+\1f
+File: mpfr.info, Node: Formatted Output Functions, Next: Integer Related Functions, Prev: Input and Output Functions, Up: MPFR Interface
+
+5.9 Formatted Output Functions
+==============================
+
+5.9.1 Requirements
+------------------
+
+The class of `mpfr_printf' functions provides formatted output in a
+similar manner as the standard C `printf'. These functions are defined
+only if your system supports ISO C variadic functions and the
+corresponding argument access macros.
+
+ 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.
+
+5.9.2 Format String
+-------------------
+
+The format specification accepted by `mpfr_printf' is an extension of
+the `printf' one. The conversion specification is of the form:
+ % [flags] [width] [.[precision]] [type] [rounding] conv
+ `flags', `width', and `precision' have the same meaning as for the
+standard C function `printf' (in particular, notice that the precision
+is related to the number of digits displayed in the base chosen by
+`conv' and not related to the internal precision of the `mpfr_t'
+variable). `mpfr_printf' accepts the same `type' specifiers as `gmp'
+(except the non-standard and deprecated `q', use `ll' instead), plus
+`R' and `P':
+
+ `h' `short'
+ `hh' `char'
+ `j' `intmax_t' or `uintmax_t'
+ `l' `long' or `wchar_t'
+ `ll' `long long'
+ `L' `long double'
+ `t' `ptrdiff_t'
+ `z' `size_t'
+ `F' `mpf_t', float conversions
+ `Q' `mpq_t', integer conversions
+ `M' `mp_limb_t', integer conversions
+ `N' `mp_limb_t' array, integer conversions
+ `Z' `mpz_t', integer conversions
+ `R' `mpfr_t' input, float conversions
+ `P' `mpfr_prec_t' input, integer conversions
+
+ The `type' specifiers have the same restrictions as those mentioned
+in the GMP documentation: *note Formatted Output Strings:
+(gmp.info)Formatted Output Strings. More precisely, except for `R' and
+`P' (which are defined by MPFR), the `type' specifiers are supported
+only if they are supported by `gmp_printf' in your GMP build; this
+implies that the standard specifiers, such as `t', must _also_ be
+supported by your C library if you want to use them.
+
+ The `rounding' specifier is specific to `mpfr_t' parameter and shall
+not be used with other types. `mpfr_printf' accepts the same conversion
+specifier character `conv' as `gmp_printf' plus `b'.
+
+ The `P' type outputs the precision of an `mpfr_t' variable. It is
+needed because the `mpfr_prec_t' type does not necessarily correspond
+to an `unsigned int' or any fixed standard type. For example:
+ mpfr_t x;
+ mpfr_prec_t p;
+ mpfr_init (x);
+ ...
+ p = mpfr_get_prec (x);
+ mpfr_printf ("variable x with %Pu bits", p);
+
+ The `R' type is used for a `mpfr_t' output and can be followed by a
+rounding specifier denoted by one of the following characters:
+
+ `U' round toward plus infinity
+ `D' round toward minus infinity
+ `Z' round toward zero
+ `N' round to nearest
+ `*' rounding mode (as a `mpfr_rnd_t')
+ indicated by the argument just before
+ the corresponding `mpfr_t' variable.
+
+ If the precision field is not empty, the `mpfr_t' number is rounded
+to the given precision in the direction specified by the rounding mode.
+If the precision field is empty (as in `%.Rf'), the number is displayed
+with enough digits so that it can be read back exactly (assuming
+rounding to nearest, see `mpfr_get_str'). If no rounding is specified,
+the `mpfr_t' argument is rounded to nearest. The following three
+examples are equivalent:
+ mpfr_t x;
+ mpfr_init (x);
+ ...
+ mpfr_printf ("%.128Rf", x);
+ mpfr_printf ("%.128RNf", x);
+ mpfr_printf ("%.128R*f", GMP_RNDN, x);
+
+ `mpfr_printf' also adds a new conversion specifier `b' which
+displays the `mpfr_t' parameter in binary, the behavior is undefined
+with other parameter type. The `conv' specifiers allowed with `mpfr_t'
+parameter are:
+
+ `a' `A' hex float, C99 style
+ `b' binary output
+ `e' `E' scientific format float
+ `f' fixed point float
+ `g' `G' fixed or scientific float
+
+ In case of non-decimal output, only the significand is written in the
+specified base, the exponent is always displayed in decimal. Special
+values are always displayed as `nan', `-inf', and `inf' for `a', `b',
+`e', `f', and `g' specifiers and `NAN', `-INF', and `INF' for `A', `E',
+`F', and `G' specifiers. In binary output, the precision is silently
+increased up to 2 if it equals 1.
+
+5.9.3 Functions
+---------------
+
+ -- Function: int mpfr_fprintf (FILE *STREAM, const char *TEMPLATE, ...)
+ -- Function: int mpfr_vfprintf (FILE *STREAM, const char *TEMPLATE,
+ va_list AP)
+ Print to the stream STREAM the optional arguments under the
+ control of the template string TEMPLATE.
+
+ Return the number of characters written or a negative value if an
+ error occurred. If the number of characters which ought to be
+ written appears to exceed the maximum limit for an `int', nothing
+ is written in the stream, the function returns -1, sets the
+ _erange_ flag, and (in POSIX system only) `errno' is set to
+ `EOVERFLOW'.
+
+ -- Function: int mpfr_printf (const char *TEMPLATE, ...)
+ -- Function: int mpfr_vprintf (const char *TEMPLATE, va_list AP)
+ Print to STDOUT the optional arguments under the control of the
+ template string TEMPLATE.
+
+ Return the number of characters written or a negative value if an
+ error occurred. If the number of characters which ought to be
+ written appears to exceed the maximum limit for an `int', nothing
+ is written in `stdout', the function returns -1, sets the _erange_
+ flag, and (in POSIX system only) `errno' is set to `EOVERFLOW'.
+
+ -- Function: int mpfr_sprintf (char *BUF, const char *TEMPLATE, ...)
+ -- Function: int mpfr_vsprintf (char *BUF, const char *TEMPLATE,
+ va_list AP)
+ Form a null-terminated string in BUF. No overlap is permitted
+ between BUF and the other arguments.
+
+ Return the number of characters written in the array BUF not
+ counting the terminating null character or a negative value if an
+ error occurred. If the number of characters which ought to be
+ written appears to exceed the maximum limit for an `int', nothing
+ is written in BUF, the function returns -1, sets the _erange_
+ flag, and (in POSIX system only) `errno' is set to `EOVERFLOW'.
+
+ -- Function: int mpfr_snprintf (char *BUF, size_t N, const char
+ *TEMPLATE, ...)
+ -- Function: int mpfr_vsnprintf (char *BUF, size_t N, const char
+ *TEMPLATE, va_list AP)
+ Form a null-terminated string in BUF. If N is zero, nothing is
+ written and BUF may be a null pointer, otherwise, the `n-1' first
+ characters are written in BUF and the N-th is a null character.
+
+ Return the number of characters that would have been written had N
+ be sufficiently large, not counting the terminating null character
+ or a negative value if an error occurred. If the number of
+ characters produced by the optional arguments under the control of
+ the template string TEMPLATE appears to exceed the maximum limit
+ for an `int', nothing is written in BUF, the function returns -1,
+ sets the _erange_ flag, and (in POSIX system only) `errno' is set
+ to `EOVERFLOW'.
+
+ -- Function: int mpfr_asprintf (char **STR, const char *TEMPLATE, ...)
+ -- Function: int mpfr_vasprintf (char **STR, const char *TEMPLATE,
+ va_list AP)
+ Write their output as a null terminated string in a block of
+ memory allocated using the current allocation function. A pointer
+ to the block is stored in STR. The block of memory must be freed
+ using `mpfr_free_str'.
+
+ The return value is the number of characters written in the
+ string, excluding the null-terminator or a negative value if an
+ error occurred. If the number of characters produced by the
+ optional arguments under the control of the template string
+ TEMPLATE appears to exceed the maximum limit for an `int', STR is
+ a null pointer, the function returns -1, sets the _erange_ flag,
+ and (in POSIX system only) `errno' is set to `EOVERFLOW'.
+
+\1f
+File: mpfr.info, Node: Integer Related Functions, Next: Rounding Related Functions, Prev: Formatted Output Functions, Up: MPFR Interface
+
+5.10 Integer and Remainder Related Functions
+============================================
+
+ -- Function: int mpfr_rint (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_ceil (mpfr_t ROP, mpfr_t OP)
+ -- Function: int mpfr_floor (mpfr_t ROP, mpfr_t OP)
+ -- Function: int mpfr_round (mpfr_t ROP, mpfr_t OP)
+ -- Function: int mpfr_trunc (mpfr_t ROP, mpfr_t OP)
+ Set ROP to OP rounded to an integer. `mpfr_rint' rounds to the
+ nearest representable integer in the given rounding mode,
+ `mpfr_ceil' rounds to the next higher or equal representable
+ integer, `mpfr_floor' to the next lower or equal representable
+ integer, `mpfr_round' to the nearest representable integer,
+ rounding halfway cases away from zero, and `mpfr_trunc' to 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_round' is different from `mpfr_rint' called 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 by
+ `mpfr_round' to 4 (100 in binary) in 2-bit precision, though
+ `round(4.5)' is equal to 5 and 5 (101 in binary) is rounded to 6
+ (110 in binary) in 2-bit precision.
+
+ -- Function: int mpfr_rint_ceil (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_rint_floor (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_rint_round (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ -- Function: int mpfr_rint_trunc (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ Set ROP to OP rounded to an integer. `mpfr_rint_ceil' rounds to
+ the next higher or equal integer, `mpfr_rint_floor' to the next
+ lower or equal integer, `mpfr_rint_round' to the nearest integer,
+ rounding halfway cases away from zero, and `mpfr_rint_trunc' to
+ 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).
+
+ -- Function: int mpfr_frac (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
+ 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).
+
+ -- Function: int mpfr_modf (mpfr_t IOP, mpfr_t FOP, mpfr_t OP,
+ mp_rnd_t RND)
+ Set simultaneously IOP to the integral part of OP and FOP to the
+ fractional part of OP, rounded in the direction RND with the
+ corresponding precision of IOP and FOP (equivalent to
+ `mpfr_trunc(IOP, OP, RND)' and `mpfr_frac(FOP, OP, RND)'). The
+ variables IOP and FOP must be different. Return 0 iff both results
+ are exact.
+
+ -- Function: int mpfr_fmod (mpfr_t R, mpfr_t X, mpfr_t Y, mp_rnd_t RND)
+ -- Function: int mpfr_remainder (mpfr_t R, mpfr_t X, mpfr_t Y,
+ mp_rnd_t RND)
+ -- Function: int mpfr_remquo (mpfr_t R, long* Q, mpfr_t X, mpfr_t Y,
+ mp_rnd_t RND)
+ Set R to the value of x - n y, rounded according to the direction
+ RND, where n is the integer quotient of X divided by Y, defined as
+ follows: n is rounded toward zero for `mpfr_fmod', and to the
+ nearest integer (ties rounded to even) for `mpfr_remainder' and
+ `mpfr_remquo'.
+
+ Special values are handled as described in Section F.9.7.1 of the
+ ISO C99 standard: If X is infinite or Y is zero, R is NaN. If Y
+ is infinite and X is finite, R is X rounded to the precision of R.
+ If R is zero, it has the sign of X. The return value is the
+ ternary value corresponding to R.
+
+ Additionally, `mpfr_remquo' stores the low significant bits from
+ the quotient in *Q (more precisely the number of bits in a `long'
+ minus 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. `mpfr_remainder'
+ and `mpfr_remquo' functions are useful for additive argument
+ reduction.
+
+ -- Function: int mpfr_integer_p (mpfr_t OP)
+ Return non-zero iff OP is an integer.
+
+\1f
+File: mpfr.info, Node: Rounding Related Functions, Next: Miscellaneous Functions, Prev: Integer Related Functions, Up: MPFR Interface
+
+5.11 Rounding Related Functions
+===============================
+
+ -- Function: void mpfr_set_default_rounding_mode (mp_rnd_t RND)
+ Set the default rounding mode to RND. The default rounding mode
+ is to nearest initially.
+
+ -- Function: mp_rnd_t mpfr_get_default_rounding_mode (void)
+ Get the default rounding mode.
+
+ -- Function: int mpfr_prec_round (mpfr_t X, mp_prec_t PREC, mp_rnd_t
+ RND)
+ Round X according to RND with precision PREC, which must be an
+ integer between `MPFR_PREC_MIN' and `MPFR_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.
+
+ -- Function: int mpfr_round_prec (mpfr_t X, mp_rnd_t RND, mp_prec_t
+ PREC)
+ [This function is obsolete. Please use `mpfr_prec_round' instead.]
+
+ -- Function: int mpfr_can_round (mpfr_t B, mp_exp_t ERR, mp_rnd_t
+ RND1, mp_rnd_t RND2, mp_prec_t PREC)
+ 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 is `GMP_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.
+
+ -- Function: const char * mpfr_print_rnd_mode (mp_rnd_t RND)
+ 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.
+
+\1f
+File: mpfr.info, Node: Miscellaneous Functions, Next: Exception Related Functions, Prev: Rounding Related Functions, Up: MPFR Interface
+
+5.12 Miscellaneous Functions
+============================
+
+ -- Function: void mpfr_nexttoward (mpfr_t X, mpfr_t Y)
+ 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.
+
+ -- Function: void mpfr_nextabove (mpfr_t X)
+ Equivalent to `mpfr_nexttoward' where Y is plus infinity.
+
+ -- Function: void mpfr_nextbelow (mpfr_t X)
+ Equivalent to `mpfr_nexttoward' where Y is minus infinity.
+
+ -- Function: int mpfr_min (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2,
+ mp_rnd_t RND)
+ 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.
+
+ -- Function: int mpfr_max (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2,
+ mp_rnd_t RND)
+ 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.
+
+ -- Function: int mpfr_urandomb (mpfr_t ROP, gmp_randstate_t STATE)
+ Generate a uniformly distributed random float in the interval 0 <=
+ ROP < 1. More precisely, the number can be seen as a float with a
+ random non-normalized significand and exponent 0, which is then
+ normalized (thus if E denotes the exponent after normalization,
+ then the least -E significant bits of the significand are always
+ 0). 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 (this should never happen in practice, except in very
+ specific cases). The second argument is a `gmp_randstate_t'
+ structure which should be created using the GMP `gmp_randinit'
+ function, see the GMP manual.
+
+ -- Function: void mpfr_random (mpfr_t ROP)
+ Generate a uniformly distributed random float in the interval 0 <=
+ ROP < 1.
+
+ This function is deprecated and will be suppressed in the next
+ release; `mpfr_urandomb' should be used instead.
+
+ -- Function: void mpfr_random2 (mpfr_t ROP, mp_size_t SIZE, mp_exp_t
+ EXP)
+ 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').
+
+ This function is deprecated and will be suppressed in the next
+ release.
+
+ -- Function: mp_exp_t mpfr_get_exp (mpfr_t X)
+ 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.
+
+ -- Function: int mpfr_set_exp (mpfr_t X, mp_exp_t E)
+ 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).
+
+ -- Function: int mpfr_signbit (mpfr_t OP)
+ 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).
+
+ -- Function: int mpfr_setsign (mpfr_t ROP, mpfr_t OP, int S, mp_rnd_t
+ RND)
+ 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.
+
+ -- Function: int mpfr_copysign (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2,
+ mp_rnd_t RND)
+ 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)'.
+
+ -- Function: const char * mpfr_get_version (void)
+ Return the MPFR version, as a null-terminated string.
+
+ -- Macro: MPFR_VERSION
+ -- Macro: MPFR_VERSION_MAJOR
+ -- Macro: MPFR_VERSION_MINOR
+ -- Macro: MPFR_VERSION_PATCHLEVEL
+ -- Macro: MPFR_VERSION_STRING
+ `MPFR_VERSION' is the version of MPFR as a preprocessing constant.
+ `MPFR_VERSION_MAJOR', `MPFR_VERSION_MINOR' and
+ `MPFR_VERSION_PATCHLEVEL' are respectively the major, minor and
+ patch level of MPFR version, as preprocessing constants.
+ `MPFR_VERSION_STRING' is the version (with an optional suffix, used
+ in development and pre-release versions) as a string constant,
+ which can be compared to the result of `mpfr_get_version' to 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).
+
+ -- Macro: long MPFR_VERSION_NUM (MAJOR, MINOR, PATCHLEVEL)
+ Create an integer in the same format as used by `MPFR_VERSION'
+ from 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
+
+ -- Function: const char * mpfr_get_patches (void)
+ 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).
+
+\1f
+File: mpfr.info, Node: Exception Related Functions, Next: Compatibility with MPF, Prev: Miscellaneous Functions, Up: MPFR Interface
+
+5.13 Exception Related Functions
+================================
+
+ -- Function: mp_exp_t mpfr_get_emin (void)
+ -- Function: mp_exp_t mpfr_get_emax (void)
+ 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.
+
+ -- Function: int mpfr_set_emin (mp_exp_t EXP)
+ -- Function: int mpfr_set_emax (mp_exp_t EXP)
+ 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.
+
+ -- Function: mp_exp_t mpfr_get_emin_min (void)
+ -- Function: mp_exp_t mpfr_get_emin_max (void)
+ -- Function: mp_exp_t mpfr_get_emax_min (void)
+ -- Function: mp_exp_t mpfr_get_emax_max (void)
+ Return the minimum and maximum of the smallest and largest
+ exponents allowed for `mpfr_set_emin' and `mpfr_set_emax'. These
+ values are implementation dependent; it is possible to create a non
+ portable program by writing `mpfr_set_emax(mpfr_get_emax_max())'
+ and `mpfr_set_emin(mpfr_get_emin_min())' since the values of the
+ smallest and largest exponents become implementation dependent.
+
+ -- Function: int mpfr_check_range (mpfr_t X, int T, mp_rnd_t RND)
+ 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_range' is typically
+ called (at least in MPFR functions) after restoring the flags that
+ could have been set due to internal computations.
+
+ -- Function: int mpfr_subnormalize (mpfr_t X, int T, mp_rnd_t RND)
+ 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+1' according 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 from `emin' to
+ `emin+PREC(x)-1'. If the result cannot be represented in the
+ current exponent range (due to a too small `emax'), 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.
+
+ -- Function: void mpfr_clear_underflow (void)
+ -- Function: void mpfr_clear_overflow (void)
+ -- Function: void mpfr_clear_nanflag (void)
+ -- Function: void mpfr_clear_inexflag (void)
+ -- Function: void mpfr_clear_erangeflag (void)
+ Clear the underflow, overflow, invalid, inexact and _erange_ flags.
+
+ -- Function: void mpfr_set_underflow (void)
+ -- Function: void mpfr_set_overflow (void)
+ -- Function: void mpfr_set_nanflag (void)
+ -- Function: void mpfr_set_inexflag (void)
+ -- Function: void mpfr_set_erangeflag (void)
+ Set the underflow, overflow, invalid, inexact and _erange_ flags.
+
+ -- Function: void mpfr_clear_flags (void)
+ Clear all global flags (underflow, overflow, inexact, invalid,
+ _erange_).
+
+ -- Function: int mpfr_underflow_p (void)
+ -- Function: int mpfr_overflow_p (void)
+ -- Function: int mpfr_nanflag_p (void)
+ -- Function: int mpfr_inexflag_p (void)
+ -- Function: int mpfr_erangeflag_p (void)
+ Return the corresponding (underflow, overflow, invalid, inexact,
+ _erange_) flag, which is non-zero iff the flag is set.
+
+\1f
+File: mpfr.info, Node: Compatibility with MPF, Next: Custom Interface, Prev: Exception Related Functions, Up: MPFR Interface
+
+5.14 Compatibility With MPF
+===========================
+
+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'.
+
+ -- Function: void mpfr_set_prec_raw (mpfr_t X, mp_prec_t PREC)
+ Reset the precision of X to be *exactly* PREC bits. The only
+ difference with `mpfr_set_prec' is 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.
+
+ -- Function: int mpfr_eq (mpfr_t OP1, mpfr_t OP2, unsigned long int
+ OP3)
+ 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 currently regarded as
+ different for any value of OP3 larger than 1 (but this may change
+ in the next release).
+
+ -- Function: void mpfr_reldiff (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2,
+ mp_rnd_t RND)
+ 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.
+
+ -- Function: int mpfr_mul_2exp (mpfr_t ROP, mpfr_t OP1, unsigned long
+ int OP2, mp_rnd_t RND)
+ -- Function: int mpfr_div_2exp (mpfr_t ROP, mpfr_t OP1, unsigned long
+ int OP2, mp_rnd_t RND)
+ See `mpfr_mul_2ui' and `mpfr_div_2ui'. These functions are only
+ kept for compatibility with MPF.
+
+\1f
+File: mpfr.info, Node: Custom Interface, Next: Internals, Prev: Compatibility with MPF, Up: MPFR Interface
+
+5.15 Custom Interface
+=====================
+
+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:
+ * Either they directly store the MPFR FP number as a `mpfr_t' on the
+ stack.
+
+ * Either they store their own representation of a FP number on the
+ stack and construct a new temporary `mpfr_t' each time it is
+ needed.
+ Nothing has to be done to destroy the FP numbers except garbaging
+the used memory: all the memory stuff (allocating, destroying,
+garbaging) is kept to the application.
+
+ 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.
+
+ -- Function: size_t mpfr_custom_get_size (mp_prec_t PREC)
+ Return the needed size in bytes to store the significand of a FP
+ number of precision PREC.
+
+ -- Function: void mpfr_custom_init (void *SIGNIFICAND, mp_prec_t 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 of `mp_limb_t'.
+
+ -- Function: void mpfr_custom_init_set (mpfr_t X, int KIND, mp_exp_t
+ EXP, mp_prec_t PREC, void *SIGNIFICAND)
+ Perform a dummy initialization of a `mpfr_t' and set it to:
+ * if `ABS(kind) == MPFR_NAN_KIND', X is set to NaN;
+
+ * if `ABS(kind) == MPFR_INF_KIND', X is set to the infinity of
+ sign `sign(kind)';
+
+ * if `ABS(kind) == MPFR_ZERO_KIND', X is set to the zero of
+ sign `sign(kind)';
+
+ * if `ABS(kind) == MPFR_REGULAR_KIND', X is set to a regular
+ number: `x = sign(kind)*significand*2^exp'
+ 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
+ `mpfr_set_prec', or cleared using `mpfr_clear'! SIGNIFICAND must
+ have been initialized with `mpfr_custom_init' using the same
+ precision PREC.
+
+ -- Function: int mpfr_custom_get_kind (mpfr_t X)
+ Return the current kind of a `mpfr_t' as used by
+ `mpfr_custom_init_set'. The behavior of this function for any
+ `mpfr_t' not initialized with `mpfr_custom_init_set' is undefined.
+
+ -- Function: void * mpfr_custom_get_mantissa (mpfr_t X)
+ Return a pointer to the significand used by a `mpfr_t' initialized
+ with `mpfr_custom_init_set'. The behavior of this function for
+ any `mpfr_t' not initialized with `mpfr_custom_init_set' is
+ undefined.
+
+ -- Function: mp_exp_t mpfr_custom_get_exp (mpfr_t X)
+ 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 does not produce any trap. The behavior of this function for
+ any `mpfr_t' not initialized with `mpfr_custom_init_set' is
+ undefined.
+
+ -- Function: void mpfr_custom_move (mpfr_t X, void *NEW_POSITION)
+ 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 the `mpfr_t' itself.
+ The behavior of this function for any `mpfr_t' not initialized
+ with `mpfr_custom_init_set' is undefined.
+
+ See the test suite for examples.
+
+\1f
+File: mpfr.info, Node: Internals, Prev: Custom Interface, Up: MPFR Interface
+
+5.16 Internals
+==============
+
+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.
+
+ * The `_mpfr_prec' field is used to store the precision of the
+ variable (in bits); this is not less than `MPFR_PREC_MIN'.
+
+ * The `_mpfr_sign' field is used to store the sign of the variable.
+
+ * The `_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.
+
+ * Finally, the `_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.
+
+
+\1f
+File: mpfr.info, Node: Contributors, Next: References, Prev: MPFR Interface, Up: Top
+
+Contributors
+************
+
+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, 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).
+
+\1f
+File: mpfr.info, Node: References, Next: GNU Free Documentation License, Prev: Contributors, Up: Top
+
+References
+**********
+
+ * Laurent Fousse, Guillaume Hanrot, Vincent Lefèvre, Patrick
+ Pélissier and Paul Zimmermann, "MPFR: A Multiple-Precision Binary
+ Floating-Point Library With Correct Rounding", ACM Transactions on
+ Mathematical Software, volume 33, issue 2, article 13, 15 pages,
+ 2007, `http://doi.acm.org/10.1145/1236463.1236468'.
+
+ * Torbjörn Granlund, "GNU MP: The GNU Multiple Precision Arithmetic
+ Library", version 4.2.2, 2007, `http://gmplib.org'.
+
+ * IEEE standard for binary floating-point arithmetic, Technical
+ Report ANSI-IEEE Standard 754-1985, New York, 1985. Approved
+ March 21, 1985: IEEE Standards Board; approved July 26, 1985:
+ American National Standards Institute, 18 pages.
+
+ * Donald E. Knuth, "The Art of Computer Programming", vol 2,
+ "Seminumerical Algorithms", 2nd edition, Addison-Wesley, 1981.
+
+ * Jean-Michel Muller, "Elementary Functions, Algorithms and
+ Implementation", Birkhauser, Boston, 2nd edition, 2006.
+
+
+\1f
+File: mpfr.info, Node: GNU Free Documentation License, Next: Concept Index, Prev: References, Up: Top
+
+Appendix A GNU Free Documentation License
+*****************************************
+
+ Version 1.2, November 2002
+
+ Copyright (C) 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.
+
+ 0. PREAMBLE
+
+ 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.
+
+ 1. APPLICABILITY AND DEFINITIONS
+
+ 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.
+
+ 2. VERBATIM COPYING
+
+ 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.
+
+ 3. COPYING IN QUANTITY
+
+ 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.
+
+ 4. MODIFICATIONS
+
+ 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:
+
+ A. Use in the Title Page (and on the covers, if any) a title
+ distinct from that of the Document, and from those of
+ previous versions (which should, if there were any, be listed
+ in the History section of the Document). You may use the
+ same title as a previous version if the original publisher of
+ that version gives permission.
+
+ B. List on the Title Page, as authors, one or more persons or
+ entities responsible for authorship of the modifications in
+ the Modified Version, together with at least five of the
+ principal authors of the Document (all of its principal
+ authors, if it has fewer than five), unless they release you
+ from this requirement.
+
+ C. State on the Title page the name of the publisher of the
+ Modified Version, as the publisher.
+
+ D. Preserve all the copyright notices of the Document.
+
+ E. Add an appropriate copyright notice for your modifications
+ adjacent to the other copyright notices.
+
+ F. Include, immediately after the copyright notices, a license
+ notice giving the public permission to use the Modified
+ Version under the terms of this License, in the form shown in
+ the Addendum below.
+
+ G. Preserve in that license notice the full lists of Invariant
+ Sections and required Cover Texts given in the Document's
+ license notice.
+
+ H. Include an unaltered copy of this License.
+
+ I. Preserve the section Entitled "History", Preserve its Title,
+ and add to it an item stating at least the title, year, new
+ authors, and publisher of the Modified Version as given on
+ the Title Page. If there is no section Entitled "History" in
+ the Document, create one stating the title, year, authors,
+ and publisher of the Document as given on its Title Page,
+ then add an item describing the Modified Version as stated in
+ the previous sentence.
+
+ J. Preserve the network location, if any, given in the Document
+ for public access to a Transparent copy of the Document, and
+ likewise the network locations given in the Document for
+ previous versions it was based on. These may be placed in
+ the "History" section. You may omit a network location for a
+ work that was published at least four years before the
+ Document itself, or if the original publisher of the version
+ it refers to gives permission.
+
+ K. For any section Entitled "Acknowledgements" or "Dedications",
+ Preserve the Title of the section, and preserve in the
+ section all the substance and tone of each of the contributor
+ acknowledgements and/or dedications given therein.
+
+ L. Preserve all the Invariant Sections of the Document,
+ unaltered in their text and in their titles. Section numbers
+ or the equivalent are not considered part of the section
+ titles.
+
+ M. Delete any section Entitled "Endorsements". Such a section
+ may not be included in the Modified Version.
+
+ N. Do not retitle any existing section to be Entitled
+ "Endorsements" or to conflict in title with any Invariant
+ Section.
+
+ O. Preserve any Warranty Disclaimers.
+
+ 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.
+
+ 5. COMBINING DOCUMENTS
+
+ 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."
+
+ 6. COLLECTIONS OF DOCUMENTS
+
+ 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.
+
+ 7. AGGREGATION WITH INDEPENDENT WORKS
+
+ 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.
+
+ 8. TRANSLATION
+
+ 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.
+
+ 9. TERMINATION
+
+ 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.
+
+ 10. FUTURE REVISIONS OF THIS LICENSE
+
+ 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.
+
+A.1 ADDENDUM: How to use this License for your documents
+========================================================
+
+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.
+
+\1f
+File: mpfr.info, Node: Concept Index, Next: Function Index, Prev: GNU Free Documentation License, Up: Top
+
+Concept Index
+*************
+
+\0\b[index\0\b]
+* Menu:
+
+* Accuracy: MPFR Interface. (line 28)
+* Arithmetic functions: Basic Arithmetic Functions.
+ (line 3)
+* Assignment functions: Assignment Functions. (line 3)
+* Basic arithmetic functions: Basic Arithmetic Functions.
+ (line 3)
+* Combined initialization and assignment functions: Combined Initialization and Assignment Functions.
+ (line 3)
+* Comparison functions: Comparison Functions. (line 3)
+* Compatibility with MPF: Compatibility with MPF.
+ (line 3)
+* Conditions for copying MPFR: Copying. (line 6)
+* Conversion functions: Conversion Functions. (line 3)
+* Copying conditions: Copying. (line 6)
+* Custom interface: Custom Interface. (line 3)
+* Exception related functions: Exception Related Functions.
+ (line 3)
+* FDL, GNU Free Documentation License: GNU Free Documentation License.
+ (line 6)
+* Float arithmetic functions: Basic Arithmetic Functions.
+ (line 3)
+* Float comparisons functions: Comparison Functions. (line 3)
+* Float functions: MPFR Interface. (line 6)
+* Float input and output functions: Input and Output Functions.
+ (line 3)
+* Float output functions: Formatted Output Functions.
+ (line 3)
+* Floating-point functions: MPFR Interface. (line 6)
+* Floating-point number: MPFR Basics. (line 52)
+* GNU Free Documentation License: GNU Free Documentation License.
+ (line 6)
+* I/O functions <1>: Formatted Output Functions.
+ (line 3)
+* I/O functions: Input and Output Functions.
+ (line 3)
+* Initialization functions: Initialization Functions.
+ (line 3)
+* Input functions: Input and Output Functions.
+ (line 3)
+* Installation: Installing MPFR. (line 6)
+* Integer related functions: Integer Related Functions.
+ (line 3)
+* Internals: Internals. (line 3)
+* libmpfr: MPFR Basics. (line 32)
+* Libraries: MPFR Basics. (line 32)
+* Libtool: MPFR Basics. (line 38)
+* Limb: MPFR Basics. (line 84)
+* Linking: MPFR Basics. (line 32)
+* Miscellaneous float functions: Miscellaneous Functions.
+ (line 3)
+* mpfr.h: MPFR Basics. (line 9)
+* Output functions <1>: Formatted Output Functions.
+ (line 3)
+* Output functions: Input and Output Functions.
+ (line 3)
+* Precision <1>: MPFR Interface. (line 20)
+* Precision: MPFR Basics. (line 65)
+* Reporting bugs: Reporting Bugs. (line 6)
+* Rounding mode related functions: Rounding Related Functions.
+ (line 3)
+* Rounding Modes: MPFR Basics. (line 79)
+* Special functions: Special Functions. (line 3)
+* stdarg.h: MPFR Basics. (line 22)
+* stdio.h: MPFR Basics. (line 15)
+
+\1f
+File: mpfr.info, Node: Function Index, Prev: Concept Index, Up: Top
+
+Function and Type Index
+***********************
+
+\0\b[index\0\b]
+* Menu:
+
+* mp_prec_t: MPFR Basics. (line 65)
+* mp_rnd_t: MPFR Basics. (line 79)
+* mpfr_abs: Basic Arithmetic Functions.
+ (line 177)
+* mpfr_acos: Special Functions. (line 48)
+* mpfr_acosh: Special Functions. (line 131)
+* mpfr_add: Basic Arithmetic Functions.
+ (line 8)
+* mpfr_add_d: Basic Arithmetic Functions.
+ (line 14)
+* mpfr_add_q: Basic Arithmetic Functions.
+ (line 18)
+* mpfr_add_si: Basic Arithmetic Functions.
+ (line 12)
+* mpfr_add_ui: Basic Arithmetic Functions.
+ (line 10)
+* mpfr_add_z: Basic Arithmetic Functions.
+ (line 16)
+* mpfr_agm: Special Functions. (line 221)
+* mpfr_asin: Special Functions. (line 49)
+* mpfr_asinh: Special Functions. (line 132)
+* mpfr_asprintf: Formatted Output Functions.
+ (line 171)
+* mpfr_atan: Special Functions. (line 50)
+* mpfr_atan2: Special Functions. (line 60)
+* mpfr_atanh: Special Functions. (line 133)
+* mpfr_can_round: Rounding Related Functions.
+ (line 29)
+* mpfr_cbrt: Basic Arithmetic Functions.
+ (line 107)
+* mpfr_ceil: Integer Related Functions.
+ (line 8)
+* mpfr_check_range: Exception Related Functions.
+ (line 38)
+* mpfr_clear: Initialization Functions.
+ (line 31)
+* mpfr_clear_erangeflag: Exception Related Functions.
+ (line 111)
+* mpfr_clear_flags: Exception Related Functions.
+ (line 121)
+* mpfr_clear_inexflag: Exception Related Functions.
+ (line 110)
+* mpfr_clear_nanflag: Exception Related Functions.
+ (line 109)
+* mpfr_clear_overflow: Exception Related Functions.
+ (line 108)
+* mpfr_clear_underflow: Exception Related Functions.
+ (line 107)
+* mpfr_clears: Initialization Functions.
+ (line 35)
+* mpfr_cmp: Comparison Functions.
+ (line 7)
+* mpfr_cmp_d: Comparison Functions.
+ (line 10)
+* mpfr_cmp_f: Comparison Functions.
+ (line 14)
+* mpfr_cmp_ld: Comparison Functions.
+ (line 11)
+* mpfr_cmp_q: Comparison Functions.
+ (line 13)
+* mpfr_cmp_si: Comparison Functions.
+ (line 9)
+* mpfr_cmp_si_2exp: Comparison Functions.
+ (line 31)
+* mpfr_cmp_ui: Comparison Functions.
+ (line 8)
+* mpfr_cmp_ui_2exp: Comparison Functions.
+ (line 29)
+* mpfr_cmp_z: Comparison Functions.
+ (line 12)
+* mpfr_cmpabs: Comparison Functions.
+ (line 35)
+* mpfr_const_catalan: Special Functions. (line 242)
+* mpfr_const_euler: Special Functions. (line 241)
+* mpfr_const_log2: Special Functions. (line 239)
+* mpfr_const_pi: Special Functions. (line 240)
+* mpfr_copysign: Miscellaneous Functions.
+ (line 93)
+* mpfr_cos: Special Functions. (line 29)
+* mpfr_cosh: Special Functions. (line 111)
+* mpfr_cot: Special Functions. (line 37)
+* mpfr_coth: Special Functions. (line 127)
+* mpfr_csc: Special Functions. (line 36)
+* mpfr_csch: Special Functions. (line 126)
+* mpfr_custom_get_exp: Custom Interface. (line 78)
+* mpfr_custom_get_kind: Custom Interface. (line 67)
+* mpfr_custom_get_mantissa: Custom Interface. (line 72)
+* mpfr_custom_get_size: Custom Interface. (line 38)
+* mpfr_custom_init: Custom Interface. (line 42)
+* mpfr_custom_init_set: Custom Interface. (line 48)
+* mpfr_custom_move: Custom Interface. (line 85)
+* mpfr_d_div: Basic Arithmetic Functions.
+ (line 82)
+* mpfr_d_sub: Basic Arithmetic Functions.
+ (line 37)
+* MPFR_DECL_INIT: Initialization Functions.
+ (line 75)
+* mpfr_dim: Basic Arithmetic Functions.
+ (line 182)
+* mpfr_div: Basic Arithmetic Functions.
+ (line 72)
+* mpfr_div_2exp: Compatibility with MPF.
+ (line 49)
+* mpfr_div_2si: Basic Arithmetic Functions.
+ (line 197)
+* mpfr_div_2ui: Basic Arithmetic Functions.
+ (line 195)
+* mpfr_div_d: Basic Arithmetic Functions.
+ (line 84)
+* mpfr_div_q: Basic Arithmetic Functions.
+ (line 88)
+* mpfr_div_si: Basic Arithmetic Functions.
+ (line 80)
+* mpfr_div_ui: Basic Arithmetic Functions.
+ (line 76)
+* mpfr_div_z: Basic Arithmetic Functions.
+ (line 86)
+* mpfr_eint: Special Functions. (line 150)
+* mpfr_eq: Compatibility with MPF.
+ (line 28)
+* mpfr_equal_p: Comparison Functions.
+ (line 71)
+* mpfr_erangeflag_p: Exception Related Functions.
+ (line 129)
+* mpfr_erf: Special Functions. (line 186)
+* mpfr_erfc: Special Functions. (line 190)
+* mpfr_exp: Special Functions. (line 23)
+* mpfr_exp10: Special Functions. (line 25)
+* mpfr_exp2: Special Functions. (line 24)
+* mpfr_expm1: Special Functions. (line 146)
+* mpfr_fac_ui: Special Functions. (line 138)
+* mpfr_fits_intmax_p: Conversion Functions.
+ (line 113)
+* mpfr_fits_sint_p: Conversion Functions.
+ (line 110)
+* mpfr_fits_slong_p: Conversion Functions.
+ (line 108)
+* mpfr_fits_sshort_p: Conversion Functions.
+ (line 112)
+* mpfr_fits_uint_p: Conversion Functions.
+ (line 109)
+* mpfr_fits_uintmax_p: Conversion Functions.
+ (line 114)
+* mpfr_fits_ulong_p: Conversion Functions.
+ (line 107)
+* mpfr_fits_ushort_p: Conversion Functions.
+ (line 111)
+* mpfr_floor: Integer Related Functions.
+ (line 9)
+* mpfr_fma: Special Functions. (line 213)
+* mpfr_fmod: Integer Related Functions.
+ (line 63)
+* mpfr_fms: Special Functions. (line 217)
+* mpfr_fprintf: Formatted Output Functions.
+ (line 117)
+* mpfr_frac: Integer Related Functions.
+ (line 48)
+* mpfr_free_cache: Special Functions. (line 249)
+* mpfr_free_str: Conversion Functions.
+ (line 100)
+* mpfr_gamma: Special Functions. (line 162)
+* mpfr_get_d: Conversion Functions.
+ (line 7)
+* mpfr_get_d_2exp: Conversion Functions.
+ (line 20)
+* mpfr_get_decimal64: Conversion Functions.
+ (line 9)
+* mpfr_get_default_prec: Initialization Functions.
+ (line 109)
+* mpfr_get_default_rounding_mode: Rounding Related Functions.
+ (line 11)
+* mpfr_get_emax: Exception Related Functions.
+ (line 8)
+* mpfr_get_emax_max: Exception Related Functions.
+ (line 30)
+* mpfr_get_emax_min: Exception Related Functions.
+ (line 29)
+* mpfr_get_emin: Exception Related Functions.
+ (line 7)
+* mpfr_get_emin_max: Exception Related Functions.
+ (line 28)
+* mpfr_get_emin_min: Exception Related Functions.
+ (line 27)
+* mpfr_get_exp: Miscellaneous Functions.
+ (line 71)
+* mpfr_get_f: Conversion Functions.
+ (line 55)
+* mpfr_get_ld: Conversion Functions.
+ (line 8)
+* mpfr_get_ld_2exp: Conversion Functions.
+ (line 22)
+* mpfr_get_patches: Miscellaneous Functions.
+ (line 130)
+* mpfr_get_prec: Initialization Functions.
+ (line 143)
+* mpfr_get_si: Conversion Functions.
+ (line 31)
+* mpfr_get_sj: Conversion Functions.
+ (line 33)
+* mpfr_get_str: Conversion Functions.
+ (line 61)
+* mpfr_get_ui: Conversion Functions.
+ (line 32)
+* mpfr_get_uj: Conversion Functions.
+ (line 34)
+* mpfr_get_version: Miscellaneous Functions.
+ (line 99)
+* mpfr_get_z: Conversion Functions.
+ (line 51)
+* mpfr_get_z_exp: Conversion Functions.
+ (line 44)
+* mpfr_greater_p: Comparison Functions.
+ (line 54)
+* mpfr_greaterequal_p: Comparison Functions.
+ (line 57)
+* mpfr_hypot: Special Functions. (line 230)
+* mpfr_inexflag_p: Exception Related Functions.
+ (line 128)
+* mpfr_inf_p: Comparison Functions.
+ (line 42)
+* mpfr_init: Initialization Functions.
+ (line 51)
+* mpfr_init2: Initialization Functions.
+ (line 11)
+* mpfr_init_set: Combined Initialization and Assignment Functions.
+ (line 7)
+* mpfr_init_set_d: Combined Initialization and Assignment Functions.
+ (line 12)
+* mpfr_init_set_f: Combined Initialization and Assignment Functions.
+ (line 17)
+* mpfr_init_set_ld: Combined Initialization and Assignment Functions.
+ (line 14)
+* mpfr_init_set_q: Combined Initialization and Assignment Functions.
+ (line 16)
+* mpfr_init_set_si: Combined Initialization and Assignment Functions.
+ (line 11)
+* mpfr_init_set_str: Combined Initialization and Assignment Functions.
+ (line 23)
+* mpfr_init_set_ui: Combined Initialization and Assignment Functions.
+ (line 9)
+* mpfr_init_set_z: Combined Initialization and Assignment Functions.
+ (line 15)
+* mpfr_inits: Initialization Functions.
+ (line 63)
+* mpfr_inits2: Initialization Functions.
+ (line 23)
+* mpfr_inp_str: Input and Output Functions.
+ (line 33)
+* mpfr_integer_p: Integer Related Functions.
+ (line 89)
+* mpfr_j0: Special Functions. (line 194)
+* mpfr_j1: Special Functions. (line 195)
+* mpfr_jn: Special Functions. (line 196)
+* mpfr_less_p: Comparison Functions.
+ (line 60)
+* mpfr_lessequal_p: Comparison Functions.
+ (line 63)
+* mpfr_lessgreater_p: Comparison Functions.
+ (line 66)
+* mpfr_lgamma: Special Functions. (line 172)
+* mpfr_li2: Special Functions. (line 157)
+* mpfr_lngamma: Special Functions. (line 166)
+* mpfr_log: Special Functions. (line 16)
+* mpfr_log10: Special Functions. (line 18)
+* mpfr_log1p: Special Functions. (line 142)
+* mpfr_log2: Special Functions. (line 17)
+* mpfr_max: Miscellaneous Functions.
+ (line 29)
+* mpfr_min: Miscellaneous Functions.
+ (line 22)
+* mpfr_modf: Integer Related Functions.
+ (line 55)
+* mpfr_mul: Basic Arithmetic Functions.
+ (line 51)
+* mpfr_mul_2exp: Compatibility with MPF.
+ (line 47)
+* mpfr_mul_2si: Basic Arithmetic Functions.
+ (line 190)
+* mpfr_mul_2ui: Basic Arithmetic Functions.
+ (line 188)
+* mpfr_mul_d: Basic Arithmetic Functions.
+ (line 57)
+* mpfr_mul_q: Basic Arithmetic Functions.
+ (line 61)
+* mpfr_mul_si: Basic Arithmetic Functions.
+ (line 55)
+* mpfr_mul_ui: Basic Arithmetic Functions.
+ (line 53)
+* mpfr_mul_z: Basic Arithmetic Functions.
+ (line 59)
+* mpfr_nan_p: Comparison Functions.
+ (line 41)
+* mpfr_nanflag_p: Exception Related Functions.
+ (line 127)
+* mpfr_neg: Basic Arithmetic Functions.
+ (line 173)
+* mpfr_nextabove: Miscellaneous Functions.
+ (line 15)
+* mpfr_nextbelow: Miscellaneous Functions.
+ (line 18)
+* mpfr_nexttoward: Miscellaneous Functions.
+ (line 7)
+* mpfr_number_p: Comparison Functions.
+ (line 43)
+* mpfr_out_str: Input and Output Functions.
+ (line 17)
+* mpfr_overflow_p: Exception Related Functions.
+ (line 126)
+* mpfr_pow: Basic Arithmetic Functions.
+ (line 116)
+* mpfr_pow_si: Basic Arithmetic Functions.
+ (line 120)
+* mpfr_pow_ui: Basic Arithmetic Functions.
+ (line 118)
+* mpfr_pow_z: Basic Arithmetic Functions.
+ (line 122)
+* mpfr_prec_round: Rounding Related Functions.
+ (line 15)
+* mpfr_print_rnd_mode: Rounding Related Functions.
+ (line 46)
+* mpfr_printf: Formatted Output Functions.
+ (line 130)
+* mpfr_random: Miscellaneous Functions.
+ (line 48)
+* mpfr_random2: Miscellaneous Functions.
+ (line 56)
+* mpfr_rec_sqrt: Basic Arithmetic Functions.
+ (line 102)
+* mpfr_reldiff: Compatibility with MPF.
+ (line 39)
+* mpfr_remainder: Integer Related Functions.
+ (line 65)
+* mpfr_remquo: Integer Related Functions.
+ (line 67)
+* mpfr_rint: Integer Related Functions.
+ (line 7)
+* mpfr_rint_ceil: Integer Related Functions.
+ (line 34)
+* mpfr_rint_floor: Integer Related Functions.
+ (line 35)
+* mpfr_rint_round: Integer Related Functions.
+ (line 36)
+* mpfr_rint_trunc: Integer Related Functions.
+ (line 37)
+* mpfr_root: Basic Arithmetic Functions.
+ (line 109)
+* mpfr_round: Integer Related Functions.
+ (line 10)
+* mpfr_round_prec: Rounding Related Functions.
+ (line 25)
+* mpfr_sec: Special Functions. (line 35)
+* mpfr_sech: Special Functions. (line 125)
+* mpfr_set: Assignment Functions.
+ (line 12)
+* mpfr_set_d: Assignment Functions.
+ (line 18)
+* mpfr_set_decimal64: Assignment Functions.
+ (line 21)
+* mpfr_set_default_prec: Initialization Functions.
+ (line 101)
+* mpfr_set_default_rounding_mode: Rounding Related Functions.
+ (line 7)
+* mpfr_set_emax: Exception Related Functions.
+ (line 16)
+* mpfr_set_emin: Exception Related Functions.
+ (line 15)
+* mpfr_set_erangeflag: Exception Related Functions.
+ (line 118)
+* mpfr_set_exp: Miscellaneous Functions.
+ (line 76)
+* mpfr_set_f: Assignment Functions.
+ (line 24)
+* mpfr_set_inexflag: Exception Related Functions.
+ (line 117)
+* mpfr_set_inf: Assignment Functions.
+ (line 131)
+* mpfr_set_ld: Assignment Functions.
+ (line 19)
+* mpfr_set_nan: Assignment Functions.
+ (line 132)
+* mpfr_set_nanflag: Exception Related Functions.
+ (line 116)
+* mpfr_set_overflow: Exception Related Functions.
+ (line 115)
+* mpfr_set_prec: Initialization Functions.
+ (line 131)
+* mpfr_set_prec_raw: Compatibility with MPF.
+ (line 21)
+* mpfr_set_q: Assignment Functions.
+ (line 23)
+* mpfr_set_si: Assignment Functions.
+ (line 15)
+* mpfr_set_si_2exp: Assignment Functions.
+ (line 51)
+* mpfr_set_sj: Assignment Functions.
+ (line 17)
+* mpfr_set_sj_2exp: Assignment Functions.
+ (line 55)
+* mpfr_set_str: Assignment Functions.
+ (line 61)
+* mpfr_set_ui: Assignment Functions.
+ (line 14)
+* mpfr_set_ui_2exp: Assignment Functions.
+ (line 49)
+* mpfr_set_uj: Assignment Functions.
+ (line 16)
+* mpfr_set_uj_2exp: Assignment Functions.
+ (line 53)
+* mpfr_set_underflow: Exception Related Functions.
+ (line 114)
+* mpfr_set_z: Assignment Functions.
+ (line 22)
+* mpfr_setsign: Miscellaneous Functions.
+ (line 87)
+* mpfr_sgn: Comparison Functions.
+ (line 49)
+* mpfr_si_div: Basic Arithmetic Functions.
+ (line 78)
+* mpfr_si_sub: Basic Arithmetic Functions.
+ (line 33)
+* mpfr_signbit: Miscellaneous Functions.
+ (line 82)
+* mpfr_sin: Special Functions. (line 30)
+* mpfr_sin_cos: Special Functions. (line 42)
+* mpfr_sinh: Special Functions. (line 112)
+* mpfr_sinh_cosh: Special Functions. (line 118)
+* mpfr_snprintf: Formatted Output Functions.
+ (line 155)
+* mpfr_sprintf: Formatted Output Functions.
+ (line 141)
+* mpfr_sqr: Basic Arithmetic Functions.
+ (line 68)
+* mpfr_sqrt: Basic Arithmetic Functions.
+ (line 95)
+* mpfr_sqrt_ui: Basic Arithmetic Functions.
+ (line 97)
+* mpfr_strtofr: Assignment Functions.
+ (line 72)
+* mpfr_sub: Basic Arithmetic Functions.
+ (line 27)
+* mpfr_sub_d: Basic Arithmetic Functions.
+ (line 39)
+* mpfr_sub_q: Basic Arithmetic Functions.
+ (line 43)
+* mpfr_sub_si: Basic Arithmetic Functions.
+ (line 35)
+* mpfr_sub_ui: Basic Arithmetic Functions.
+ (line 31)
+* mpfr_sub_z: Basic Arithmetic Functions.
+ (line 41)
+* mpfr_subnormalize: Exception Related Functions.
+ (line 58)
+* mpfr_sum: Special Functions. (line 258)
+* mpfr_swap: Assignment Functions.
+ (line 137)
+* mpfr_t: MPFR Basics. (line 52)
+* mpfr_tan: Special Functions. (line 31)
+* mpfr_tanh: Special Functions. (line 113)
+* mpfr_trunc: Integer Related Functions.
+ (line 11)
+* mpfr_ui_div: Basic Arithmetic Functions.
+ (line 74)
+* mpfr_ui_pow: Basic Arithmetic Functions.
+ (line 126)
+* mpfr_ui_pow_ui: Basic Arithmetic Functions.
+ (line 124)
+* mpfr_ui_sub: Basic Arithmetic Functions.
+ (line 29)
+* mpfr_underflow_p: Exception Related Functions.
+ (line 125)
+* mpfr_unordered_p: Comparison Functions.
+ (line 75)
+* mpfr_urandomb: Miscellaneous Functions.
+ (line 35)
+* mpfr_vasprintf: Formatted Output Functions.
+ (line 173)
+* MPFR_VERSION: Miscellaneous Functions.
+ (line 102)
+* MPFR_VERSION_MAJOR: Miscellaneous Functions.
+ (line 103)
+* MPFR_VERSION_MINOR: Miscellaneous Functions.
+ (line 104)
+* MPFR_VERSION_NUM: Miscellaneous Functions.
+ (line 122)
+* MPFR_VERSION_PATCHLEVEL: Miscellaneous Functions.
+ (line 105)
+* MPFR_VERSION_STRING: Miscellaneous Functions.
+ (line 106)
+* mpfr_vfprintf: Formatted Output Functions.
+ (line 119)
+* mpfr_vprintf: Formatted Output Functions.
+ (line 131)
+* mpfr_vsnprintf: Formatted Output Functions.
+ (line 157)
+* mpfr_vsprintf: Formatted Output Functions.
+ (line 143)
+* mpfr_y0: Special Functions. (line 203)
+* mpfr_y1: Special Functions. (line 204)
+* mpfr_yn: Special Functions. (line 205)
+* mpfr_zero_p: Comparison Functions.
+ (line 44)
+* mpfr_zeta: Special Functions. (line 180)
+* mpfr_zeta_ui: Special Functions. (line 182)
+
+
+\1f
+Tag Table:
+Node: Top\7f874
+Node: Copying\7f2113
+Node: Introduction to MPFR\7f3843
+Node: Installing MPFR\7f5755
+Node: Reporting Bugs\7f8997
+Node: MPFR Basics\7f10613
+Node: MPFR Interface\7f25127
+Node: Initialization Functions\7f27351
+Node: Assignment Functions\7f33919
+Node: Combined Initialization and Assignment Functions\7f41669
+Node: Conversion Functions\7f42951
+Node: Basic Arithmetic Functions\7f49151
+Node: Comparison Functions\7f58008
+Node: Special Functions\7f61430
+Node: Input and Output Functions\7f73827
+Node: Formatted Output Functions\7f75757
+Node: Integer Related Functions\7f84168
+Node: Rounding Related Functions\7f89004
+Node: Miscellaneous Functions\7f91474
+Node: Exception Related Functions\7f98260
+Node: Compatibility with MPF\7f104378
+Node: Custom Interface\7f106870
+Node: Internals\7f111053
+Node: Contributors\7f112376
+Node: References\7f114541
+Node: GNU Free Documentation License\7f115655
+Node: Concept Index\7f138098
+Node: Function Index\7f142890
+\1f
+End Tag Table
+
+\1f
+Local Variables:
+coding: iso-8859-1
+End:
projects / msp430-gcc.git / blobdiff