219N/A<
title>MPFR 2.3.2</
title>
219N/A<
meta http-
equiv="Content-Type" content="text/html; charset=iso-8859-1">
219N/A<
meta name="description" content="How to install and use MPFR, a library for reliable multiple precision floating-point arithmetic, version 2.3.2.">
219N/A<
meta name="generator" content="makeinfo 4.11">
219N/A<
link title="Top" rel="top" href="#Top">
219N/AThis manual documents how to install and use the Multiple Precision 219N/AFloating-Point Reliable Library, version 2.3.2. 219N/ACopyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. 219N/APermission is granted to copy, distribute and/or modify this document under 219N/Athe terms of the GNU Free Documentation License, Version 1.2 or any later 219N/Aversion published by the Free Software Foundation; with no Invariant Sections, 219N/Awith no Front-Cover Texts, and with no Back-Cover Texts. A copy of the 219N/Alicense is included in *note GNU Free Documentation License::.--> 219N/ANext: <
a rel="next" accesskey="n" href="#Copying">Copying</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#dir">(dir)</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#dir">(dir)</
a>
219N/A<
h2 class="unnumbered">MPFR</
h2>
219N/A <
p>This manual documents how to install and use the Multiple Precision
219N/AFloating-Point Reliable Library, version 2.3.2.
219N/A <
p>Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
219N/A <
p>Permission is granted to copy, distribute
and/
or modify this document under
219N/Athe terms of the GNU Free Documentation License, Version 1.2 or any later
219N/Aversion published by the Free Software Foundation; with no Invariant Sections,
219N/Awith no Front-Cover Texts, and with no Back-Cover Texts. A copy of the
219N/Alicense is included in <
a href="#GNU-Free-Documentation-License">GNU Free Documentation License</
a>.
219N/A<!-- Don't bother with contents for html, the menus seem adequate. --> 219N/A<
li><
a accesskey="1" href="#Copying">Copying</
a>: MPFR Copying Conditions (LGPL).
219N/A<
li><
a accesskey="2" href="#Introduction-to-MPFR">Introduction to MPFR</
a>: Brief introduction to MPFR.
219N/A<
li><
a accesskey="3" href="#Installing-MPFR">Installing MPFR</
a>: How to configure and compile the MPFR library.
219N/A<
li><
a accesskey="4" href="#Reporting-Bugs">Reporting Bugs</
a>: How to usefully report bugs.
219N/A<
li><
a accesskey="5" href="#MPFR-Basics">MPFR Basics</
a>: What every MPFR user should now.
219N/A<
li><
a accesskey="6" href="#MPFR-Interface">MPFR Interface</
a>: MPFR functions and macros.
219N/A<
li><
a accesskey="7" href="#Contributors">Contributors</
a>
219N/A<
li><
a accesskey="8" href="#References">References</
a>
219N/A<
li><
a accesskey="9" href="#GNU-Free-Documentation-License">GNU Free Documentation License</
a>
219N/A<
li><
a href="#Concept-Index">Concept Index</
a>
219N/A<
li><
a href="#Function-Index">Function Index</
a>
219N/A<!-- @m{T,N} is $T$ in tex or @math{N} otherwise. This is an easy way to give --> 219N/A<!-- different forms for math in tex and info. Commas in N or T don't work, --> 219N/A<!-- but @C{} can be used instead. \, works in info but not in tex. --> 219N/A<!-- Usage: @GMPabs{x} --> 219N/A<!-- Give either |x| in tex, or abs(x) in info or html. --> 219N/A<!-- Usage: @GMPtimes{} --> 219N/A<!-- Give either \times or the word "times". --> 219N/A<!-- New math operators. --> 219N/A<!-- @abs{} can be used in both tex and info, or just \abs in tex. --> 219N/A<!-- @times{} made available as a "*" in info and html (already works in tex). --> 219N/A<!-- Math operators already available in tex, made available in info too. --> 219N/A<!-- For example @log{} can be used in both tex and info. --> 219N/A<!-- @pom{} definition --> 219N/A<!-- Usage: @MPFRpxreftop{info,title} --> 219N/A<!-- Like @pxref{}, but designed for a reference to the top of a document, not --> 219N/A<!-- a particular section. --> 219N/A<!-- The texinfo manual recommends putting a likely section name in references --> 219N/A<!-- like this, eg. "Introduction", but it seems better to just give the title. --> 219N/ANext: <
a rel="next" accesskey="n" href="#Introduction-to-MPFR">Introduction to MPFR</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Top">Top</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#Top">Top</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A<
h2 class="unnumbered">MPFR Copying Conditions</
h2>
219N/A<
p><
a name="index-Copying-conditions-1"></
a><
a name="index-Conditions-for-copying-MPFR-2"></
a>
219N/AThis library is <
dfn>free</
dfn>; this means that everyone is free to use it and
219N/Afree to redistribute it on a free basis. The library is not in the public
219N/Adomain; it is copyrighted and there are restrictions on its distribution, but
219N/Athese restrictions are designed to permit everything that a good cooperating
219N/Acitizen would want to do. What is not allowed is to try to prevent others
219N/Afrom further sharing any version of this library that they might get from
219N/A <
p>Specifically, we want to make sure that you have the right to give away copies
219N/Aof the library, that you receive source code or else can get it if you want
219N/Ait, that you can change this library or use pieces of it in new free programs,
219N/Aand that you know you can do these things.
219N/A <
p>To make sure that everyone has such rights, we have to forbid you to deprive
219N/Aanyone else of these rights. For example, if you distribute copies of the
219N/AMPFR library, you must give the recipients all the rights that you have. You
219N/Amust make sure that they, too, receive or can get the source code. And you
219N/Amust tell them their rights.
219N/A <
p>Also, for our own protection, we must make certain that everyone finds out
219N/Athat there is no warranty for the MPFR library. If it is modified by
219N/Asomeone else and passed on, we want their recipients to know that what they
219N/Ahave is not what we distributed, so that any problems introduced by others
219N/Awill not reflect on our reputation.
219N/A <
p>The precise conditions of the license for the MPFR library are found in the
219N/ALesser General Public License that accompanies the source code.
219N/A<
a name="Introduction-to-MPFR"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Installing-MPFR">Installing MPFR</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Copying">Copying</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#Top">Top</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A<
h2 class="chapter">1 Introduction to MPFR</
h2>
219N/A<
p>MPFR is a portable library written in C for arbitrary precision arithmetic
219N/Aon floating-point numbers. It is based on the GNU MP library.
219N/AIt aims to extend the class of floating-point numbers provided by the
219N/AGNU MP library by a precise semantics. The main differences
219N/Awith the <
code>mpf</
code> class from GNU MP are:
219N/A<
li>the MPFR code is portable,
i.e. the result of any operation
219N/Adoes not depend (or should not) on the machine word size
219N/A<
code>mp_bits_per_limb</
code> (32 or 64 on most machines);
219N/A<
li>the precision in bits can be set exactly to any valid value
219N/Afor each variable (including very small precision);
219N/A<
li>MPFR provides the four rounding modes from the IEEE 754-1985
219N/A <
p>In particular, with a precision of 53 bits, MPFR should be able to
219N/Aexactly reproduce all computations with double-precision machine
219N/Afloating-point numbers (
e.g., <
code>double</
code> type in C, with a C
219N/Aimplementation that rigorously follows Annex F of the ISO C99 standard
219N/Aand <
code>FP_CONTRACT</
code> pragma set to <
code>OFF</
code>) on the four arithmetic
219N/Aoperations and the square root, except the default exponent range is much
219N/Awider and subnormal numbers are not implemented (but can be emulated).
219N/A <
p>This version of MPFR is released under the GNU Lesser General Public
219N/ALicense, Version 2.1 or any later version.
219N/AIt is permitted to link MPFR to most non-free programs, as long as when
219N/Adistributing them the MPFR source code and a means to re-link with a
219N/Amodified MPFR library is provided.
219N/A<
h3 class="section">1.1 How to Use This Manual</
h3>
219N/A<
p>Everyone should read <
a href="#MPFR-Basics">MPFR Basics</
a>. If you need to install the library
219N/Ayourself, you need to read <
a href="#Installing-MPFR">Installing MPFR</
a>, too.
219N/A <
p>The rest of the manual can be used for later reference, although it is
219N/Aprobably a good idea to glance through it.
219N/A<
a name="Installing-MPFR"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Reporting-Bugs">Reporting Bugs</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Introduction-to-MPFR">Introduction to MPFR</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#Top">Top</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A<
h2 class="chapter">2 Installing MPFR</
h2>
219N/A<
p><
a name="index-Installation-3"></
a>
219N/A<
h3 class="section">2.1 How to Install</
h3>
219N/A<
p>Here are the steps needed to install the library on Unix systems
219N/A(more details are provided in the <
samp><
span class="file">INSTALL</
span></
samp> file):
219N/A<
li>To build MPFR, you first have to install GNU MP
219N/A(version 4.1 or higher) on your computer.
219N/AYou need a C compiler, preferably GCC, but any reasonable compiler should
219N/Awork. And you need a standard Unix ‘<
samp><
span class="samp">make</
span></
samp>’ program, plus some other
219N/Astandard Unix utility programs.
219N/A <
li>In the MPFR build directory, type
219N/A <
p>This will prepare the build and setup the options according to your system.
219N/AIf you get error messages, you might check that you use the same compiler
219N/Aand compile options as for GNU MP (see the <
samp><
span class="file">INSTALL</
span></
samp> file).
219N/A <
li>‘<
samp><
span class="samp">make</
span></
samp>’
219N/A <
p>This will compile MPFR, and create a library archive file <
samp><
span class="file">
libmpfr.a</
span></
samp>.
219N/AA dynamic library may be produced too (see configure).
219N/A <
li>‘<
samp><
span class="samp">make check</
span></
samp>’
219N/A <
p>This will make sure MPFR was built correctly.
219N/AIf you get error messages, please
219N/Areport this to ‘<
samp><
span class="samp">mpfr@loria.fr</
span></
samp>’. (See <
a href="#Reporting-Bugs">Reporting Bugs</
a>, for
219N/Ainformation on what to include in useful bug reports.)
219N/A <
li>‘<
samp><
span class="samp">make install</
span></
samp>’
219N/A <
p>This will copy the files <
samp><
span class="file">
mpfr.h</
span></
samp> and <
samp><
span class="file">
mpf2mpfr.h</
span></
samp> to the directory
219N/A<
samp><
span class="file">/
usr/
local/
lib</
span></
samp>, and the file <
samp><
span class="file">
mpfr.info</
span></
samp> to the directory
219N/A<
samp><
span class="file">/
usr/
local/
share/
info</
span></
samp> (or if you passed the ‘<
samp><
span class="samp">--prefix</
span></
samp>’ option to
219N/A <
samp><
span class="file">configure</
span></
samp>, using the prefix directory given as argument to
219N/A‘<
samp><
span class="samp">--prefix</
span></
samp>’ instead of <
samp><
span class="file">/
usr/
local</
span></
samp>).
219N/A<
h3 class="section">2.2 Other `make' Targets</
h3>
219N/A<
p>There are some other useful make targets:
219N/A<
li>‘<
samp><
span class="samp">
mpfr.info</
span></
samp>’ or ‘<
samp><
span class="samp">info</
span></
samp>’
219N/A <
p>Create an info version of the manual, in <
samp><
span class="file">
mpfr.info</
span></
samp>.
219N/A <
li>‘<
samp><
span class="samp">
mpfr.pdf</
span></
samp>’ or ‘<
samp><
span class="samp">pdf</
span></
samp>’
219N/A <
p>Create a PDF version of the manual, in <
samp><
span class="file">
mpfr.pdf</
span></
samp>.
219N/A <
li>‘<
samp><
span class="samp">
mpfr.dvi</
span></
samp>’ or ‘<
samp><
span class="samp">dvi</
span></
samp>’
219N/A <
p>Create a DVI version of the manual, in <
samp><
span class="file">
mpfr.dvi</
span></
samp>.
219N/A <
li>‘<
samp><
span class="samp">
mpfr.ps</
span></
samp>’ or ‘<
samp><
span class="samp">ps</
span></
samp>’
219N/A <
p>Create a Postscript version of the manual, in <
samp><
span class="file">
mpfr.ps</
span></
samp>.
219N/A <
li>‘<
samp><
span class="samp">
mpfr.html</
span></
samp>’ or ‘<
samp><
span class="samp">html</
span></
samp>’
219N/A <
p>Create a HTML version of the manual, in several pages in the directory
219N/A<
samp><
span class="file">
mpfr.html</
span></
samp>; if you want only one output HTML file, then type
219N/A‘<
samp><
span class="samp">makeinfo --html --no-split
mpfr.texi</
span></
samp>’ instead.
219N/A <
li>‘<
samp><
span class="samp">clean</
span></
samp>’
219N/A <
p>Delete all object files and archive files, but not the configuration files.
219N/A <
li>‘<
samp><
span class="samp">distclean</
span></
samp>’
219N/A <
p>Delete all files not included in the distribution.
219N/A <
li>‘<
samp><
span class="samp">uninstall</
span></
samp>’
219N/A <
p>Delete all files copied by ‘<
samp><
span class="samp">make install</
span></
samp>’.
219N/A<
h3 class="section">2.3 Build Problems</
h3>
219N/A<
p>In case of problem, please read the <
samp><
span class="file">INSTALL</
span></
samp> file carefully
219N/Abefore reporting a bug, in particular section “In case of problem”.
219N/ASome problems are due to bad configuration on the user side (not
219N/Aspecific to MPFR). Problems are also mentioned in the FAQ
219N/A<!-- Warning! Do not split "MPFR ... @url{...}" across several lines --> 219N/A<!-- as this needs to be updated with update-version. --> 219N/A <
p>Please report problems to ‘<
samp><
span class="samp">mpfr@loria.fr</
span></
samp>’.
219N/ASee <
a href="#Reporting-Bugs">Reporting Bugs</
a>.
219N/ASome bug fixes are available on the
219N/A<
h3 class="section">2.4 Getting the Latest Version of MPFR</
h3>
219N/A<
a name="Reporting-Bugs"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#MPFR-Basics">MPFR Basics</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Installing-MPFR">Installing MPFR</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#Top">Top</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A<
h2 class="chapter">3 Reporting Bugs</
h2>
219N/A<
p><
a name="index-Reporting-bugs-4"></
a>
219N/A<!-- Warning! Do not split "MPFR ... @url{...}" across several lines --> 219N/A<!-- as this needs to be updated with update-version. --> 219N/AIf you think you have found a bug in the MPFR library, first have a look
219N/Aperhaps this bug is already known, in which case you may find there
219N/Aa workaround for it. Otherwise, please investigate and report it.
219N/AWe have made this library available to you, and it is not to ask too
219N/Amuch from you, to ask you to report the bugs that you find.
219N/A <
p>There are a few things you should think about when you put your bug report
219N/A <
p>You have to send us a test case that makes it possible for us to reproduce the
219N/Abug. Include instructions on how to run the test case.
219N/A <
p>You also have to explain what is wrong; if you get a crash, or if the results
219N/Aprinted are incorrect and in that case, in what way.
219N/A <
p>Please include compiler version information in your bug report. This can
219N/Abe extracted using ‘<
samp><
span class="samp">cc -V</
span></
samp>’ on some machines, or, if you're using gcc,
219N/A‘<
samp><
span class="samp">gcc -v</
span></
samp>’. Also, include the output from ‘<
samp><
span class="samp">uname -a</
span></
samp>’ and the MPFR
219N/Aversion (the GMP version may be useful too).
219N/A <
p>If your bug report is good, we will do our best to help you to get a corrected
219N/Aversion of the library; if the bug report is poor, we won't do anything about
219N/Ait (aside of chiding you to send better bug reports).
219N/A <
p>Send your bug report to: ‘<
samp><
span class="samp">mpfr@loria.fr</
span></
samp>’.
219N/A <
p>If you think something in this manual is unclear, or downright incorrect, or if
219N/Athe language needs to be improved, please send a note to the same address.
219N/A<
a name="MPFR-Basics"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#MPFR-Interface">MPFR Interface</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Reporting-Bugs">Reporting Bugs</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#Top">Top</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A<
h2 class="chapter">4 MPFR Basics</
h2>
219N/A<
h3 class="section">4.1 Headers and Libraries</
h3>
219N/A<
p><
a name="index-g_t_0040file_007bmpfr_002eh_007d-5"></
a>All declarations needed to use MPFR are collected in the include file
219N/A<
samp><
span class="file">
mpfr.h</
span></
samp>. It is designed to work with both C and C++ compilers.
219N/AYou should include that file in any program using the MPFR library:
219N/A <
p><
a name="index-g_t_0040code_007bstdio_002eh_007d-6"></
a>Note however that prototypes for MPFR functions with <
code>FILE *</
code> parameters
219N/Aare provided only if <
code><
stdio.h></
code> is included too (before <
samp><
span class="file">
mpfr.h</
span></
samp>).
219N/A <
p>You can avoid the use of MPFR macros encapsulating functions by defining
219N/Athe ‘<
samp><
span class="samp">MPFR_USE_NO_MACRO</
span></
samp>’ macro before <
samp><
span class="file">
mpfr.h</
span></
samp> is included. In
219N/Ageneral this should not be necessary, but this can be useful when debugging
219N/Auser code: with some macros, the compiler may emit spurious warnings with
219N/Asome warning options, and macros can prevent some prototype checking.
219N/A <
p><
a name="index-Libraries-7"></
a><
a name="index-Linking-8"></
a><
a name="index-g_t_0040code_007blibmpfr_007d-9"></
a>All programs using MPFR must link against both <
samp><
span class="file">libmpfr</
span></
samp> and
219N/A<
samp><
span class="file">libgmp</
span></
samp> libraries. On a typical Unix-like system this can be
219N/Adone with ‘<
samp><
span class="samp">-lmpfr -lgmp</
span></
samp>’ (in that order), for example
219N/A <
p><
a name="index-Libtool-10"></
a>MPFR is built using Libtool and an application can use that to link if
219N/Adesired, see <
cite>GNU Libtool</
cite>.
219N/A<!-- Note: Do not try the above cross reference without moving mpfr.info --> 219N/A<!-- into some "safe" place first. Due to a poor design, "info" will not --> 219N/A<!-- find the correct libtool info file because of the "libtool" script --> 219N/A<!-- in MPFR's directory! --> 219N/A <
p>If MPFR has been installed to a non-standard location, then it may be
219N/Anecessary to set up environment variables such as ‘<
samp><
span class="samp">C_INCLUDE_PATH</
span></
samp>’
219N/Aand ‘<
samp><
span class="samp">LIBRARY_PATH</
span></
samp>’, or use ‘<
samp><
span class="samp">-I</
span></
samp>’ and ‘<
samp><
span class="samp">-L</
span></
samp>’ compiler options,
219N/Ain order to point to the right directories. For a shared library, it may
219N/Aalso be necessary to set up some sort of run-time library path (
e.g.,
219N/A‘<
samp><
span class="samp">LD_LIBRARY_PATH</
span></
samp>’) on some systems. Please read the <
samp><
span class="file">INSTALL</
span></
samp>
219N/Afile for additional information.
219N/A<
h3 class="section">4.2 Nomenclature and Types</
h3>
219N/A<
p><
a name="index-Floating_002dpoint-number-11"></
a><
a name="index-g_t_0040code_007bmpfr_005ft_007d-12"></
a>A <
dfn>floating-point number</
dfn> or <
dfn>float</
dfn> for short, is an arbitrary
219N/Aprecision significand (also called mantissa) with a limited precision
219N/Aexponent. The C data type
219N/Afor such objects is <
code>mpfr_t</
code> (internally defined as a one-element
219N/Aarray of a structure, and <
code>mpfr_ptr</
code> is the C data type representing
219N/Aa pointer to this structure). A floating-point number can have
219N/Athree special values: Not-a-Number (NaN) or plus or minus Infinity. NaN
219N/Arepresents an uninitialized object, the result of an invalid operation
219N/A(like 0 divided by 0), or a value that cannot be determined (like
219N/A+Infinity minus +Infinity). Moreover, like in the IEEE 754-1985 standard,
219N/Azero is signed,
i.e. there are both +0 and −0; the behavior
219N/Ais the same as in the IEEE 754-1985 standard and it is generalized to
219N/Athe other functions supported by MPFR.
219N/A <
p><
a name="index-Precision-13"></
a><
a name="index-g_t_0040code_007bmp_005fprec_005ft_007d-14"></
a>The <
dfn>precision</
dfn> is the number of bits used to represent the significand
219N/Aof a floating-point number;
219N/Athe corresponding C data type is <
code>mp_prec_t</
code>.
219N/AThe precision can be any integer between <
code>MPFR_PREC_MIN</
code> and
219N/A<
code>MPFR_PREC_MAX</
code>. In the current implementation, <
code>MPFR_PREC_MIN</
code>
219N/A <
p>Warning! MPFR needs to increase the precision internally, in order to
219N/Aprovide accurate results (and in particular, correct rounding). Do not
219N/Aattempt to set the precision to any value near <
code>MPFR_PREC_MAX</
code>,
219N/Aotherwise MPFR will abort due to an assertion failure. Moreover, you
219N/Amay reach some memory limit on your platform, in which case the program
219N/Amay abort, crash or have undefined behavior (depending on your C
219N/A <
p><
a name="index-Rounding-Modes-15"></
a><
a name="index-g_t_0040code_007bmp_005frnd_005ft_007d-16"></
a>The <
dfn>rounding mode</
dfn> specifies the way to round the result of a
219N/Afloating-point operation, in case the exact result can not be represented
219N/Aexactly in the destination significand;
219N/Athe corresponding C data type is <
code>mp_rnd_t</
code>.
219N/A <
p><
a name="index-Limb-17"></
a>
<!-- @tindex @code{mp_limb_t} --> 219N/AA <
dfn>limb</
dfn> means the part of a multi-precision number that fits in a single
219N/Aword. (We chose this word because a limb of the human body is analogous to a
219N/Adigit, only larger, and containing several digits.) Normally a limb contains
219N/A32 or 64 bits. The C data type for a limb is <
code>mp_limb_t</
code>.
219N/A<
h3 class="section">4.3 Function Classes</
h3>
219N/A<
p>There is only one class of functions in the MPFR library:
219N/A<
li>Functions for floating-point arithmetic, with names beginning with
219N/A<
code>mpfr_</
code>. The associated type is <
code>mpfr_t</
code>.
219N/A<
h3 class="section">4.4 MPFR Variable Conventions</
h3>
219N/A<
p>As a general rule, all MPFR functions expect output arguments before input
219N/Aarguments. This notation is based on an analogy with the assignment operator.
219N/A <
p>MPFR allows you to use the same variable for both input and output in the same
219N/Aexpression. For example, the main function for floating-point multiplication,
219N/A<
code>mpfr_mul</
code>, can be used like this: <
code>mpfr_mul (x, x, x, rnd_mode)</
code>.
219N/Acomputes the square of <
var>x</
var> with rounding mode <
code>rnd_mode</
code>
219N/Aand puts the result back in <
var>x</
var>.
219N/A <
p>Before you can assign to an MPFR variable, you need to initialize it by calling
219N/Aone of the special initialization functions. When you're done with a
219N/Avariable, you need to clear it out, using one of the functions for that
219N/A <
p>A variable should only be initialized once, or at least cleared out between
219N/Aeach initialization. After a variable has been initialized, it may be
219N/Aassigned to any number of times.
219N/A <
p>For efficiency reasons, avoid to initialize and clear out a variable in loops.
219N/AInstead, initialize it before entering the loop, and clear it out after the
219N/A <
p>You don't need to be concerned about allocating additional space for MPFR
219N/Avariables, since any variable has a significand of fixed size.
219N/AHence unless you change its precision, or clear and reinitialize it,
219N/Aa floating-point variable will have the same allocated space during all its
219N/A<
h3 class="section">4.5 Rounding Modes</
h3>
219N/A<
p>The following four rounding modes are supported:
219N/A<
li><
code>GMP_RNDN</
code>: round to nearest
219N/A<
li><
code>GMP_RNDZ</
code>: round toward zero
219N/A<
li><
code>GMP_RNDU</
code>: round toward plus infinity
219N/A<
li><
code>GMP_RNDD</
code>: round toward minus infinity
219N/A <
p>The ‘<
samp><
span class="samp">round to nearest</
span></
samp>’ mode works as in the IEEE 754-1985 standard: in
219N/Acase the number to be rounded lies exactly in the middle of two representable
219N/Anumbers, it is rounded to the one with the least significant bit set to zero.
219N/AFor example, the number 5/2, which is represented by (10.1) in binary, is
219N/Arounded to (10.0)=2 with a precision of two bits, and not to (11.0)=3.
219N/AThis rule avoids the <
dfn>drift</
dfn> phenomenon mentioned by Knuth in volume 2
219N/Aof The Art of Computer Programming (Section 4.2.2).
219N/A <
p>Most MPFR functions take as first argument the destination variable, as
219N/Asecond and following arguments the input variables, as last argument a
219N/Arounding mode, and have a return value of type <
code>int</
code>, called the
219N/A<
dfn>ternary value</
dfn>. The value stored in the destination variable is
219N/Acorrectly rounded,
i.e. MPFR behaves as if it computed the result with
219N/Aan infinite precision, then rounded it to the precision of this variable.
219N/AThe input variables are regarded as exact (in particular, their precision
219N/Adoes not affect the result).
219N/A <
p>As a consequence, in case of a non-zero real rounded result, the error
219N/Aon the result is less or equal to 1/2 ulp (unit in the last place) of
219N/Athe target in the rounding to nearest mode, and less than 1 ulp of the
219N/Atarget in the directed rounding modes (a ulp is the weight of the least
219N/Asignificant represented bit of the target after rounding).
219N/A<!-- Since subnormals are not supported, we must take into account the ulp of --> 219N/A<!-- the rounded result, not the one of the exact result, for full generality. --> 219N/A <
p>Unless documented otherwise, functions returning an <
code>int</
code> return
219N/AIf the ternary value is zero, it means that the value stored in the
219N/Adestination variable is the exact result of the corresponding mathematical
219N/Afunction. If the ternary value is positive (resp. negative), it means
219N/Athe value stored in the destination variable is greater (resp. lower)
219N/Athan the exact result. For example with the <
code>GMP_RNDU</
code> rounding mode,
219N/Athe ternary value is usually positive, except when the result is exact, in
219N/Awhich case it is zero. In the case of an infinite result, it is considered
219N/Aas inexact when it was obtained by overflow, and exact otherwise. A NaN
219N/Aresult (Not-a-Number) always corresponds to an exact return value.
219N/AThe opposite of a returned ternary value is guaranteed to be representable
219N/A <
p>Unless documented otherwise, functions returning a <
code>1</
code>
219N/A(or any other value specified in this manual)
219N/Afor special cases (like <
code>acos(0)</
code>) should return an overflow or
219N/Aan underflow if <
code>1</
code> is not representable in the current exponent range.
219N/A<
h3 class="section">4.6 Floating-Point Values on Special Numbers</
h3>
219N/A<
p>This section specifies the floating-point values (of type <
code>mpfr_t</
code>)
219N/Areturned by MPFR functions. For functions returning several values (like
219N/A<
code>mpfr_sin_cos</
code>), the rules apply to each result separately.
219N/A <
p>Functions can have one or several input arguments. An input point is
219N/Aa mapping from these input arguments to the set of the MPFR numbers.
219N/AWhen none of its components are NaN, an input point can also be seen
219N/Aas a tuple in the extended real numbers (the set of the real numbers
219N/A <
p>When the input point is in the domain of the mathematical function, the
219N/Aresult is rounded as described in Section “Rounding Modes” (but see
219N/Abelow for the specification of the sign of an exact zero). Otherwise
219N/Athe general rules from this section apply unless stated otherwise in
219N/Athe description of the MPFR function (<
a href="#MPFR-Interface">MPFR Interface</
a>).
219N/A <
p>When the input point is not in the domain of the mathematical function
219N/Abut is in its closure in the extended real numbers and the function can
219N/Abe extended by continuity, the result is the obtained limit.
219N/AExamples: <
code>mpfr_hypot</
code> on (+Inf,0) gives +Inf. But <
code>mpfr_pow</
code>
219N/Acannot be defined on (1,+Inf) using this rule, as one can find
219N/Asequences (<
var>x</
var>_<
var>n</
var>,<
var>y</
var>_<
var>n</
var>) such that
219N/A<
var>x</
var>_<
var>n</
var> goes to 1, <
var>y</
var>_<
var>n</
var> goes to +Inf
219N/Aand <
var>x</
var>_<
var>n</
var> to the <
var>y</
var>_<
var>n</
var> goes to any
219N/Apositive value when <
var>n</
var> goes to the infinity.
219N/A <
p>When the input point is in the closure of the domain of the mathematical
219N/Afunction and an input argument is +0 (resp. −0), one considers
219N/Athe limit when the corresponding argument approaches 0 from above
219N/A(resp. below). If the limit is not defined (
e.g., <
code>mpfr_log</
code> on
219N/A−0), the behavior must be specified in the description of the
219N/A <
p>When the result is equal to 0, its sign is determined by considering the
219N/Alimit as if the input point were not in the domain: If one approaches 0
219N/Afrom above (resp. below), the result is +0 (resp. −0). In the
219N/Aother cases, the sign must be specified in the description of the MPFR
219N/Afunction. Example: <
code>mpfr_sin</
code> on +0 gives +0.
219N/A <
p>When the input point is not in the closure of the domain of the function,
219N/Athe result is NaN. Example: <
code>mpfr_sqrt</
code> on −17 gives NaN.
219N/A <
p>When an input argument is NaN, the result is NaN, possibly except when
219N/Aa partial function is constant on the finite floating-point numbers;
219N/Asuch a case is always explicitly specified in <
a href="#MPFR-Interface">MPFR Interface</
a>.
219N/A<!-- Said otherwise, if such a case is not specified, this is a bug, thus --> 219N/A<!-- we may change the returned value after documenting it without having --> 219N/A<!-- to change the libtool interface number (this would have more drawbacks --> 219N/A<!-- that advantages in practice), like for any bug fix. --> 219N/AExample: <
code>mpfr_hypot</
code> on (NaN,0) gives NaN, but <
code>mpfr_hypot</
code>
219N/Aon (NaN,+Inf) gives +Inf (as specified in <
a href="#Special-Functions">Special Functions</
a>),
219N/Asince for any finite input <
var>x</
var>, <
code>mpfr_hypot</
code> on (<
var>x</
var>,+Inf)
219N/A<
h3 class="section">4.7 Exceptions</
h3>
219N/A<
p>MPFR supports 5 exception types:
219N/AAn underflow occurs when the exact result of a function is a non-zero
219N/Areal number and the result obtained after the rounding, assuming an
219N/Aunbounded exponent range (for the rounding), has an exponent smaller
219N/Athan the minimum exponent of the current range. In the round-to-nearest
219N/Amode, the halfway case is rounded toward zero.
219N/A <
p>Note: This is not the single definition of the underflow. MPFR chooses
219N/Ato consider the underflow after rounding. The underflow before rounding
219N/Acan also be defined. For instance, consider a function that has the
219N/Aexact result 7 multiplied by two to the power
219N/A<
var>e</
var>−4, where <
var>e</
var> is the smallest exponent (for a
219N/Asignificand between 1/2 and 1) in the current
219N/Arange, with a 2-bit target precision and rounding toward plus infinity.
219N/AThe exact result has the exponent <
var>e</
var>−1. With the underflow
219N/Abefore rounding, such a function call would yield an underflow, as
219N/A<
var>e</
var>−1 is outside the current exponent range. However, MPFR
219N/Afirst considers the rounded result assuming an unbounded exponent range.
219N/AThe exact result cannot be represented exactly in precision 2, and here,
219N/Ait is rounded to 0.5 times 2 to <
var>e</
var>, which is
219N/Arepresentable in the current exponent range. As a consequence, this will
219N/Anot yield an underflow in MPFR.
219N/AAn overflow occurs when the exact result of a function is a non-zero
219N/Areal number and the result obtained after the rounding, assuming an
219N/Aunbounded exponent range (for the rounding), has an exponent larger
219N/Athan the maximum exponent of the current range. In the round-to-nearest
219N/Amode, the result is infinite.
219N/AA NaN exception occurs when the result of a function is a NaN.
219N/A<!-- NaN is defined above. So, we don't say anything more. --> 219N/AAn inexact exception occurs when the result of a function cannot be
219N/Arepresented exactly and must be rounded.
219N/AA range exception occurs when a function that does not return a MPFR
219N/Anumber (such as comparisons and conversions to an integer) has an
219N/Ainvalid result (
e.g. an argument is NaN in <
code>mpfr_cmp</
code> or in a
219N/Aconversion to an integer).
219N/A <
p>MPFR has a global flag for each exception, which can be cleared, set
219N/Aor tested by functions described in <
a href="#Exception-Related-Functions">Exception Related Functions</
a>.
219N/A <
p>Differences with the ISO C99 standard:
219N/A<
li>In C, only quiet NaNs are specified, and a NaN propagation does not
219N/Araise an invalid exception. Unless explicitly stated otherwise, MPFR sets
219N/Athe NaN flag whenever a NaN is generated, even when a NaN is propagated
219N/A(
e.g. in NaN + NaN), as if all NaNs were signaling.
219N/A <
li>An invalid exception in C corresponds to either a NaN exception or
219N/A<
h3 class="section">4.8 Memory Handling</
h3>
219N/A<
p>MPFR functions may create caches,
e.g. when computing constants such
219N/Aas Pi, either because the user has called a function like
219N/A<
code>mpfr_const_pi</
code> directly or because such a function was called
219N/Ainternally by the MPFR library itself to compute some other function.
219N/A <
p>At any time, the user can free the various caches with
219N/A<
code>mpfr_free_cache</
code>. It is strongly advised to do that before
219N/Aterminating a thread, or before exiting when using tools like
219N/A‘<
samp><
span class="samp">valgrind</
span></
samp>’ (to avoid memory leaks being reported).
219N/A <
p>MPFR internal data such as flags, the exponent range, the default
219N/Aprecision and rounding mode, and caches (
i.e., data that are not
219N/Aaccessed via parameters) are either global (if MPFR has not been
219N/Acompiled as thread safe) or per-thread (thread local storage).
219N/A<
a name="MPFR-Interface"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Contributors">Contributors</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#MPFR-Basics">MPFR Basics</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#Top">Top</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A<
h2 class="chapter">5 MPFR Interface</
h2>
219N/A<
p><
a name="index-Floating_002dpoint-functions-18"></
a><
a name="index-Float-functions-19"></
a>
219N/AThe floating-point functions expect arguments of type <
code>mpfr_t</
code>.
219N/A <
p>The MPFR floating-point functions have an interface that is similar to the
219N/Ainteger functions. The function prefix for floating-point operations is
219N/A <
p>There is one significant characteristic of floating-point numbers that has
219N/Amotivated a difference between this function class and other GNU MP function
219N/Aclasses: the inherent inexactness of floating-point arithmetic. The user has
219N/Ato specify the precision for each variable. A computation that assigns a
219N/Avariable will take place with the precision of the assigned variable; the
219N/Acost of that computation should not depend from the
219N/Aprecision of variables used as input (on average).
219N/A <
p><
a name="index-Precision-20"></
a>The semantics of a calculation in MPFR is specified as follows: Compute the
219N/Arequested operation exactly (with “infinite accuracy”), and round the result
219N/Ato the precision of the destination variable, with the given rounding mode.
219N/AThe MPFR floating-point functions are intended to be a smooth extension
219N/Aof the IEEE 754-1985 arithmetic. The results obtained on one computer should
219N/Anot differ from the results obtained on a computer with a different word size.
219N/A <
p><
a name="index-Accuracy-21"></
a>MPFR does not keep track of the accuracy of a computation. This is left
219N/Ato the user or to a higher layer.
219N/AAs a consequence, if two variables are used to store
219N/Aonly a few significant bits, and their product is stored in a variable with large
219N/Aprecision, then MPFR will still compute the result with full precision.
219N/A <
p>The value of the standard C macro <
code>errno</
code> may be set to non-zero by
219N/Aany MPFR function or macro, whether or not there is an error.
219N/A<
li><
a accesskey="1" href="#Initialization-Functions">Initialization Functions</
a>
219N/A<
li><
a accesskey="2" href="#Assignment-Functions">Assignment Functions</
a>
219N/A<
li><
a accesskey="3" href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</
a>
219N/A<
li><
a accesskey="4" href="#Conversion-Functions">Conversion Functions</
a>
219N/A<
li><
a accesskey="5" href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a>
219N/A<
li><
a accesskey="6" href="#Comparison-Functions">Comparison Functions</
a>
219N/A<
li><
a accesskey="7" href="#Special-Functions">Special Functions</
a>
219N/A<
li><
a accesskey="8" href="#Input-and-Output-Functions">Input and Output Functions</
a>
219N/A<
li><
a accesskey="9" href="#Integer-Related-Functions">Integer Related Functions</
a>
219N/A<
li><
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a>
219N/A<
li><
a href="#Rounding-Mode-Related-Functions">Rounding Mode Related Functions</
a>
219N/A<
li><
a href="#Exception-Related-Functions">Exception Related Functions</
a>
219N/A<
li><
a href="#Advanced-Functions">Advanced Functions</
a>
219N/A<
li><
a href="#Compatibility-with-MPF">Compatibility with MPF</
a>
219N/A<
li><
a href="#Custom-Interface">Custom Interface</
a>
219N/A<
li><
a href="#Internals">Internals</
a>
219N/A<
a name="Initialization-Functions"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Assignment-Functions">Assignment Functions</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#MPFR-Interface">MPFR Interface</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A <
p><
a name="index-Initialization-functions-22"></
a>
219N/A<
h3 class="section">5.1 Initialization Functions</
h3>
219N/A<
p>An <
code>mpfr_t</
code> object must be initialized before storing the first value in
219N/Ait. The functions <
code>mpfr_init</
code> and <
code>mpfr_init2</
code> are used for that
219N/A— Function: void <
b>mpfr_init2</
b> (<
var>mpfr_t x, mp_prec_t prec</
var>)<
var><
a name="index-mpfr_005finit2-23"></
a></
var><
br>
219N/A<
blockquote><
p>Initialize <
var>x</
var>, set its precision to be <
strong>exactly</
strong>
219N/A<
var>prec</
var> bits and its value to NaN. (Warning: the corresponding
219N/A<
code>mpf</
code> functions initialize to zero instead.)
219N/A <
p>Normally, a variable should be initialized once only or at
219N/Aleast be cleared, using <
code>mpfr_clear</
code>, between initializations.
219N/ATo change the precision of a variable which has already been initialized,
219N/Ause <
code>mpfr_set_prec</
code>.
219N/AThe precision <
var>prec</
var> must be an integer between <
code>MPFR_PREC_MIN</
code> and
219N/A<
code>MPFR_PREC_MAX</
code> (otherwise the behavior is undefined).
219N/A— Function: void <
b>mpfr_clear</
b> (<
var>mpfr_t x</
var>)<
var><
a name="index-mpfr_005fclear-24"></
a></
var><
br>
219N/A<
blockquote><
p>Free the space occupied by <
var>x</
var>. Make sure to call this function for all
219N/A<
code>mpfr_t</
code> variables when you are done with them.
219N/A— Function: void <
b>mpfr_init</
b> (<
var>mpfr_t x</
var>)<
var><
a name="index-mpfr_005finit-25"></
a></
var><
br>
219N/A<
blockquote><
p>Initialize <
var>x</
var> and set its value to NaN.
219N/A <
p>Normally, a variable should be initialized once only
219N/Aor at least be cleared, using <
code>mpfr_clear</
code>, between initializations. The
219N/Aprecision of <
var>x</
var> is the default precision, which can be changed
219N/Aby a call to <
code>mpfr_set_default_prec</
code>.
219N/A— Function: void <
b>mpfr_set_default_prec</
b> (<
var>mp_prec_t prec</
var>)<
var><
a name="index-mpfr_005fset_005fdefault_005fprec-26"></
a></
var><
br>
219N/A<
blockquote><
p>Set the default precision to be <
strong>exactly</
strong> <
var>prec</
var> bits. The
219N/Aprecision of a variable means the number of bits used to store its significand.
219N/Asubsequent calls to <
code>mpfr_init</
code> will use this precision, but previously
219N/Ainitialized variables are unaffected.
219N/AThis default precision is set to 53 bits initially.
219N/AThe precision can be any integer between <
code>MPFR_PREC_MIN</
code> and
219N/A<
code>MPFR_PREC_MAX</
code>.
219N/A— Function: mp_prec_t <
b>mpfr_get_default_prec</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fget_005fdefault_005fprec-27"></
a></
var><
br>
219N/A<
blockquote><
p>Return the default MPFR precision in bits.
219N/A <
p>Here is an example on how to initialize floating-point variables:
219N/A mpfr_init (x); /* use default precision */
219N/A mpfr_init2 (y, 256); /* precision <
em>exactly</
em> 256 bits */
219N/A /* When the program is about to exit, do ... */
219N/A <
p>The following functions are useful for changing the precision during a
219N/Acalculation. A typical use would be for adjusting the precision gradually in
219N/Aiterative algorithms like Newton-Raphson, making the computation precision
219N/Aclosely match the actual accurate part of the numbers.
219N/A— Function: void <
b>mpfr_set_prec</
b> (<
var>mpfr_t x, mp_prec_t prec</
var>)<
var><
a name="index-mpfr_005fset_005fprec-28"></
a></
var><
br>
219N/A<
blockquote><
p>Reset the precision of <
var>x</
var> to be <
strong>exactly</
strong> <
var>prec</
var> bits,
219N/Aand set its value to NaN.
219N/AThe previous value stored in <
var>x</
var> is lost. It is equivalent to
219N/Aa call to <
code>mpfr_clear(x)</
code> followed by a call to
219N/A<
code>mpfr_init2(x, prec)</
code>, but more efficient as no allocation is done in
219N/Acase the current allocated space for the significand of <
var>x</
var> is enough.
219N/AThe precision <
var>prec</
var> can be any integer between <
code>MPFR_PREC_MIN</
code> and
219N/A<
code>MPFR_PREC_MAX</
code>.
219N/A <
p>In case you want to keep the previous value stored in <
var>x</
var>,
219N/Ause <
code>mpfr_prec_round</
code> instead.
219N/A— Function: mp_prec_t <
b>mpfr_get_prec</
b> (<
var>mpfr_t x</
var>)<
var><
a name="index-mpfr_005fget_005fprec-29"></
a></
var><
br>
219N/A<
blockquote><
p>Return the precision actually used for assignments of <
var>x</
var>,
i.e. the
219N/Anumber of bits used to store its significand.
219N/A<
a name="Assignment-Functions"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Initialization-Functions">Initialization Functions</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A <
p><
a name="index-Assignment-functions-30"></
a>
219N/A<
h3 class="section">5.2 Assignment Functions</
h3>
219N/A<
p>These functions assign new values to already initialized floats
219N/A(see <
a href="#Initialization-Functions">Initialization Functions</
a>). When using any functions using
219N/Abefore <
samp><
span class="file">
mpfr.h</
span></
samp>, to allow <
samp><
span class="file">
mpfr.h</
span></
samp> to define prototypes for
219N/A— Function: int <
b>mpfr_set</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fset-31"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_set_ui</
b> (<
var>mpfr_t rop, unsigned long int op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fset_005fui-32"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_set_si</
b> (<
var>mpfr_t rop, long int op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fset_005fsi-33"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_set_uj</
b> (<
var>mpfr_t rop, uintmax_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fset_005fuj-34"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_set_sj</
b> (<
var>mpfr_t rop, intmax_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fset_005fsj-35"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_set_d</
b> (<
var>mpfr_t rop, double op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fset_005fd-36"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_set_ld</
b> (<
var>mpfr_t rop, long double op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fset_005fld-37"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_set_decimal64</
b> (<
var>mpfr_t rop, _Decimal64 op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fset_005fdecimal64-38"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_set_z</
b> (<
var>mpfr_t rop, mpz_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fset_005fz-39"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_set_q</
b> (<
var>mpfr_t rop, mpq_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fset_005fq-40"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_set_f</
b> (<
var>mpfr_t rop, mpf_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fset_005ff-41"></
a></
var><
br>
219N/A<
blockquote><
p>Set the value of <
var>rop</
var> from <
var>op</
var>, rounded
219N/Atoward the given direction <
var>rnd</
var>.
219N/ANote that the input 0 is converted to +0 by <
code>mpfr_set_ui</
code>,
219N/A<
code>mpfr_set_si</
code>, <
code>mpfr_set_sj</
code>, <
code>mpfr_set_uj</
code>,
219N/A<
code>mpfr_set_z</
code>, <
code>mpfr_set_q</
code> and
219N/A<
code>mpfr_set_f</
code>, regardless of the rounding mode.
219N/AIf the system doesn't support the IEEE-754 standard, <
code>mpfr_set_d</
code>,
219N/A<
code>mpfr_set_ld</
code> and
219N/A<
code>mpfr_set_decimal64</
code> might not preserve the signed zeros.
219N/AThe <
code>mpfr_set_decimal64</
code> function is built only with the configure
219N/Aoption ‘<
samp><
span class="samp">--enable-decimal-float</
span></
samp>’, which also requires
219N/A‘<
samp><
span class="samp">--with-gmp-build</
span></
samp>’, and when the compiler or
219N/Asystem provides the ‘<
samp><
span class="samp">_Decimal64</
span></
samp>’ data type
219N/A(GCC version 4.2.0 is known to support this data type,
219N/Abut only when configured with ‘<
samp><
span class="samp">--enable-decimal-float</
span></
samp>’ too).
219N/A<
code>mpfr_set_q</
code> might not be able to work if the numerator (or the
219N/Adenominator) can not be representable as a <
code>mpfr_t</
code>.
219N/A <
p>Note: If you want to store a floating-point constant to a <
code>mpfr_t</
code>,
219N/Ayou should use <
code>mpfr_set_str</
code> (or one of the MPFR constant functions,
219N/Asuch as <
code>mpfr_const_pi</
code> for Pi) instead of <
code>mpfr_set_d</
code>,
219N/A<
code>mpfr_set_ld</
code> or <
code>mpfr_set_decimal64</
code>.
219N/AOtherwise the floating-point constant will be first
219N/Aconverted into a reduced-precision (
e.g., 53-bit) binary number before
219N/A— Function: int <
b>mpfr_set_ui_2exp</
b> (<
var>mpfr_t rop, unsigned long int op, mp_exp_t e, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fset_005fui_005f2exp-42"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_set_si_2exp</
b> (<
var>mpfr_t rop, long int op, mp_exp_t e, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fset_005fsi_005f2exp-43"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_set_uj_2exp</
b> (<
var>mpfr_t rop, uintmax_t op, intmax_t e, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fset_005fuj_005f2exp-44"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_set_sj_2exp</
b> (<
var>mpfr_t rop, intmax_t op, intmax_t e, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fset_005fsj_005f2exp-45"></
a></
var><
br>
219N/A<
blockquote><
p>Set the value of <
var>rop</
var> from <
var>op</
var> multiplied by
219N/Atwo to the power <
var>e</
var>, rounded toward the given direction <
var>rnd</
var>.
219N/ANote that the input 0 is converted to +0.
219N/A— Function: int <
b>mpfr_set_str</
b> (<
var>mpfr_t rop, const char *s, int base, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fset_005fstr-46"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the value of the whole string <
var>s</
var> in base <
var>base</
var>,
219N/Arounded in the direction <
var>rnd</
var>.
219N/ASee the documentation of <
code>mpfr_strtofr</
code> for a detailed description
219N/Aof the valid string formats.
219N/A<!-- Additionally, special values --> 219N/A<!-- @code{@@NaN@@}, @code{@@Inf@@}, @code{+@@Inf@@} and @code{-@@Inf@@}, --> 219N/A<!-- all case insensitive, without leading whitespace and possibly followed by --> 219N/A<!-- other characters, are accepted too (it may change). --> 219N/AThis function returns 0 if the entire string up to the final null character
219N/Ais a valid number in base <
var>base</
var>; otherwise it returns −1, and
219N/A<
var>rop</
var> may have changed.
219N/A— Function: int <
b>mpfr_strtofr</
b> (<
var>mpfr_t rop, const char *nptr, char **endptr, int base, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fstrtofr-47"></
a></
var><
br>
219N/A <
p>Read a floating-point number from a string <
var>nptr</
var> in base <
var>base</
var>,
219N/Arounded in the direction <
var>rnd</
var>; <
var>base</
var> must be either 0 (to
219N/Adetect the base, as described below) or a number from 2 to 36 (otherwise
219N/Athe behavior is undefined). If <
var>nptr</
var> starts with valid data, the
219N/Aresult is stored in <
var>rop</
var> and <
code>*</
code><
var>endptr</
var> points to the
219N/Acharacter just after the valid data (if <
var>endptr</
var> is not a null pointer);
219N/Aotherwise <
var>rop</
var> is set to zero and the value of <
var>nptr</
var> is stored
219N/Ain the location referenced by <
var>endptr</
var> (if <
var>endptr</
var> is not a null
219N/Apointer). The usual ternary value is returned.
219N/A <
p>Parsing follows the standard C <
code>strtod</
code> function with some extensions.
219N/ACase is ignored. After optional leading whitespace, one has a subject
219N/Asequence consisting of an optional sign (<
code>+</
code> or <
code>-</
code>), and either
219N/Anumeric data or special data. The subject sequence is defined as the
219N/Alongest initial subsequence of the input string, starting with the first
219N/Anon-whitespace character, that is of the expected form.
219N/A <
p>The form of numeric data is a non-empty sequence of significand digits
219N/Awith an optional decimal point, and an optional exponent consisting of
219N/Aan exponent prefix followed by an optional sign and a non-empty sequence
219N/Aof decimal digits. A significand digit is either a decimal digit or a
219N/ALatin letter (62 possible characters), with <
code>a</
code> = 10, <
code>b</
code> = 11,
219N/A<
small class="dots">...</
small>, <
code>z</
code> = 36; its value must be strictly less than the base.
219N/AThe decimal point can be either the one defined by the current locale or
219N/Athe period (the first one is accepted for consistency with the C standard
219N/Aand the practice, the second one is accepted to allow the programmer to
219N/Aprovide MPFR numbers from strings in a way that does not depend on the
219N/AThe exponent prefix can be <
code>e</
code> or <
code>E</
code> for bases up to 10, or
219N/A<
code>@</
code> in any base; it indicates a multiplication by a power of the
219N/Abase. In bases 2 and 16, the exponent prefix can also be <
code>p</
code> or
219N/A<
code>P</
code>, in which case it introduces a binary exponent: it indicates a
219N/Amultiplication by a power of 2 (there is a difference only for base 16).
219N/AThe value of an exponent is always written in base 10.
219N/AIn base 2, the significand can start with <
code>0b</
code> or <
code>0B</
code>, and
219N/Ain base 16, it can start with <
code>0x</
code> or <
code>0X</
code>.
219N/A <
p>If the argument <
var>base</
var> is 0, then the base is automatically detected
219N/Aas follows. If the significand starts with <
code>0b</
code> or <
code>0B</
code>, base 2
219N/Ais assumed. If the significand starts with <
code>0x</
code> or <
code>0X</
code>, base 16
219N/Ais assumed. Otherwise base 10 is assumed.
219N/A <
p>Note: The exponent must contain at least a digit. Otherwise the possible
219N/Aexponent prefix and sign are not part of the number (which ends with the
219N/Asignificand). Similarly, if <
code>0b</
code>, <
code>0B</
code>, <
code>0x</
code> or <
code>0X</
code>
219N/Astops at the character <
code>0</
code>.
219N/A <
p>Special data (for infinities and NaN) can be <
code>@inf@</
code> or
219N/A<
code>@nan@(n-char-sequence)</
code>, and if <
var>base</
var> <= 16,
219N/Ait can also be <
code>infinity</
code>, <
code>inf</
code>, <
code>nan</
code> or
219N/A<
code>nan(n-char-sequence)</
code>, all case insensitive.
219N/AA <
code>n-char-sequence</
code> is a non-empty string containing only digits,
219N/ALatin letters and the underscore (0, 1, 2, <
small class="dots">...</
small>, 9, a, b, <
small class="dots">...</
small>, z,
219N/AA, B, <
small class="dots">...</
small>, Z, _). Note: one has an optional sign for all data, even
219N/A— Function: void <
b>mpfr_set_inf</
b> (<
var>mpfr_t x, int sign</
var>)<
var><
a name="index-mpfr_005fset_005finf-48"></
a></
var><
br>
219N/A— Function: void <
b>mpfr_set_nan</
b> (<
var>mpfr_t x</
var>)<
var><
a name="index-mpfr_005fset_005fnan-49"></
a></
var><
br>
219N/A<
blockquote><
p>Set the variable <
var>x</
var> to infinity or NaN (Not-a-Number) respectively.
219N/AIn <
code>mpfr_set_inf</
code>, <
var>x</
var> is set to plus infinity iff <
var>sign</
var> is
219N/A— Function: void <
b>mpfr_swap</
b> (<
var>mpfr_t x, mpfr_t y</
var>)<
var><
a name="index-mpfr_005fswap-50"></
a></
var><
br>
219N/A<
blockquote><
p>Swap the values <
var>x</
var> and <
var>y</
var> efficiently. Warning: the
219N/Aprecisions are exchanged too; in case the precisions are different,
219N/A<
code>mpfr_swap</
code> is thus not equivalent to three <
code>mpfr_set</
code> calls
219N/Ausing a third auxiliary variable.
219N/A<
a name="Combined-Initialization-and-Assignment-Functions"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Conversion-Functions">Conversion Functions</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Assignment-Functions">Assignment Functions</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A <
p><
a name="index-Combined-initialization-and-assignment-functions-51"></
a>
219N/A<
h3 class="section">5.3 Combined Initialization and Assignment Functions</
h3>
219N/A— Macro: int <
b>mpfr_init_set</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005finit_005fset-52"></
a></
var><
br>
219N/A— Macro: int <
b>mpfr_init_set_ui</
b> (<
var>mpfr_t rop, unsigned long int op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005finit_005fset_005fui-53"></
a></
var><
br>
219N/A— Macro: int <
b>mpfr_init_set_si</
b> (<
var>mpfr_t rop, signed long int op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005finit_005fset_005fsi-54"></
a></
var><
br>
219N/A— Macro: int <
b>mpfr_init_set_d</
b> (<
var>mpfr_t rop, double op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005finit_005fset_005fd-55"></
a></
var><
br>
219N/A— Macro: int <
b>mpfr_init_set_ld</
b> (<
var>mpfr_t rop, long double op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005finit_005fset_005fld-56"></
a></
var><
br>
219N/A— Macro: int <
b>mpfr_init_set_z</
b> (<
var>mpfr_t rop, mpz_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005finit_005fset_005fz-57"></
a></
var><
br>
219N/A— Macro: int <
b>mpfr_init_set_q</
b> (<
var>mpfr_t rop, mpq_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005finit_005fset_005fq-58"></
a></
var><
br>
219N/A— Macro: int <
b>mpfr_init_set_f</
b> (<
var>mpfr_t rop, mpf_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005finit_005fset_005ff-59"></
a></
var><
br>
219N/A<
blockquote><
p>Initialize <
var>rop</
var> and set its value from <
var>op</
var>, rounded in the direction
219N/AThe precision of <
var>rop</
var> will be taken from the active default precision,
219N/Aas set by <
code>mpfr_set_default_prec</
code>.
219N/A— Function: int <
b>mpfr_init_set_str</
b> (<
var>mpfr_t x, const char *s, int base, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005finit_005fset_005fstr-60"></
a></
var><
br>
219N/A<
blockquote><
p>Initialize <
var>x</
var> and set its value from
219N/Athe string <
var>s</
var> in base <
var>base</
var>,
219N/Arounded in the direction <
var>rnd</
var>.
219N/ASee <
code>mpfr_set_str</
code>.
219N/A<
a name="Conversion-Functions"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A <
p><
a name="index-Conversion-functions-61"></
a>
219N/A<
h3 class="section">5.4 Conversion Functions</
h3>
219N/A— Function: double <
b>mpfr_get_d</
b> (<
var>mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fget_005fd-62"></
a></
var><
br>
219N/A— Function: long double <
b>mpfr_get_ld</
b> (<
var>mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fget_005fld-63"></
a></
var><
br>
219N/A— Function: _Decimal64 <
b>mpfr_get_decimal64</
b> (<
var>mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fget_005fdecimal64-64"></
a></
var><
br>
219N/A<
blockquote><
p>Convert <
var>op</
var> to a <
code>double</
code> (respectively <
code>_Decimal64</
code> or
219N/A<
code>long double</
code>), using the rounding mode <
var>rnd</
var>.
219N/AIf <
var>op</
var> is NaN, some fixed NaN (either quiet or signaling) or the result
219N/Aof
0.0/
0.0 is returned. If <
var>op</
var> is �Inf, an infinity of the same
219N/Asign or the result of �
1.0/
0.0 is returned. If <
var>op</
var> is zero, these
219N/Afunctions return a zero, trying to preserve its sign, if possible.
219N/AThe <
code>mpfr_get_decimal64</
code> function is built only under some conditions:
219N/Asee the documentation of <
code>mpfr_set_decimal64</
code>.
219N/A— Function: double <
b>mpfr_get_d_2exp</
b> (<
var>long *exp, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fget_005fd_005f2exp-65"></
a></
var><
br>
219N/A— Function: long double <
b>mpfr_get_ld_2exp</
b> (<
var>long *exp, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fget_005fld_005f2exp-66"></
a></
var><
br>
219N/A<
blockquote><
p>Return <
var>d</
var> and set <
var>exp</
var> such that 0.5<=abs(<
var>d</
var>)<1
219N/Aand <
var>d</
var> times 2 raised to <
var>exp</
var> equals
219N/A<
var>op</
var> rounded to double (resp. long double)
219N/Aprecision, using the given rounding mode.
219N/A<!-- See ISO C standard, frexp function. --> 219N/AIf <
var>op</
var> is zero, then a zero of the same sign (or an unsigned zero,
219N/Aif the implementation does not have signed zeros) is returned, and
219N/A<
var>exp</
var> is set to 0.
219N/AIf <
var>op</
var> is NaN or an infinity, then the corresponding double precision
219N/A(resp. long-double precision)
219N/Avalue is returned, and <
var>exp</
var> is undefined.
219N/A— Function: long <
b>mpfr_get_si</
b> (<
var>mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fget_005fsi-67"></
a></
var><
br>
219N/A— Function: unsigned long <
b>mpfr_get_ui</
b> (<
var>mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fget_005fui-68"></
a></
var><
br>
219N/A— Function: intmax_t <
b>mpfr_get_sj</
b> (<
var>mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fget_005fsj-69"></
a></
var><
br>
219N/A— Function: uintmax_t <
b>mpfr_get_uj</
b> (<
var>mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fget_005fuj-70"></
a></
var><
br>
219N/A<
blockquote><
p>Convert <
var>op</
var> to a <
code>long</
code>, an <
code>unsigned long</
code>,
219N/Aan <
code>intmax_t</
code> or an <
code>uintmax_t</
code> (respectively) after rounding
219N/Ait with respect to <
var>rnd</
var>.
219N/AIf <
var>op</
var> is NaN, the result is undefined.
219N/AIf <
var>op</
var> is too big for the return type, it returns the maximum
219N/Aor the minimum of the corresponding C type, depending on the direction
219N/Aof the overflow. The flag erange is set too.
219N/ASee also <
code>mpfr_fits_slong_p</
code>, <
code>mpfr_fits_ulong_p</
code>,
219N/A<
code>mpfr_fits_intmax_p</
code> and <
code>mpfr_fits_uintmax_p</
code>.
219N/A— Function: mp_exp_t <
b>mpfr_get_z_exp</
b> (<
var>mpz_t rop, mpfr_t op</
var>)<
var><
a name="index-mpfr_005fget_005fz_005fexp-71"></
a></
var><
br>
219N/A<
blockquote><
p>Put the scaled significand of <
var>op</
var> (regarded as an integer, with the
219N/Aprecision of <
var>op</
var>) into <
var>rop</
var>, and return the exponent <
var>exp</
var>
219N/A(which may be outside the current exponent range) such that <
var>op</
var>
219N/A<
var>rop</
var> multiplied by two exponent <
var>exp</
var>.
219N/AIf the exponent is not representable in the <
code>mp_exp_t</
code> type, the
219N/A— Function: void <
b>mpfr_get_z</
b> (<
var>mpz_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fget_005fz-72"></
a></
var><
br>
219N/A<
blockquote><
p>Convert <
var>op</
var> to a <
code>mpz_t</
code>, after rounding it with respect to
219N/A<
var>rnd</
var>. If <
var>op</
var> is NaN or Inf, the result is undefined.
219N/A— Function: int <
b>mpfr_get_f</
b> (<
var>mpf_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fget_005ff-73"></
a></
var><
br>
219N/A<
blockquote><
p>Convert <
var>op</
var> to a <
code>mpf_t</
code>, after rounding it with respect to
219N/A<
var>rnd</
var>. Return zero iff no error occurred,
219N/Ain particular a non-zero value is returned if
219N/A<
var>op</
var> is NaN or Inf, which do not exist in <
code>mpf</
code>.
219N/A— Function: char * <
b>mpfr_get_str</
b> (<
var>char *str, mp_exp_t *expptr, int b, size_t n, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fget_005fstr-74"></
a></
var><
br>
219N/A<
blockquote><
p>Convert <
var>op</
var> to a string of digits in base <
var>b</
var>, with rounding in
219N/Athe direction <
var>rnd</
var>, where <
var>n</
var> is either zero (see below) or the
219N/Anumber of significant digits; in the latter case, <
var>n</
var> must be greater
219N/Aor equal to 2. The base may vary from 2 to 36.
219N/A <
p>The generated string is a fraction, with an implicit radix point immediately
219N/Ato the left of the first digit. For example, the number −3.1416 would
219N/Abe returned as "−31416" in the string and 1 written at <
var>expptr</
var>.
219N/AIf <
var>rnd</
var> is to nearest, and <
var>op</
var> is exactly in the middle of two
219N/Apossible outputs, the one with an even last digit is chosen
219N/A(for an odd base, this may not correspond to an even significand).
219N/A <
p>If <
var>n</
var> is zero, the number of digits of the significand is chosen
219N/Alarge enough so that re-reading the printed value with the same precision,
219N/Aassuming both output and input use rounding to nearest, will recover
219N/Athe original value of <
var>op</
var>.
219N/AMore precisely, in most cases, the chosen precision of <
var>str</
var> is
219N/Athe minimal precision depending on <
var>n</
var> and <
var>b</
var> only that
219N/Am = 1 + ceil(<
var>n</
var>*log(2)/log(<
var>b</
var>)),
219N/Abut in some very rare cases, it might be m+1.
219N/A <
p>If <
var>str</
var> is a null pointer, space for the significand is allocated using
219N/Athe current allocation function, and a pointer to the string is returned.
219N/ATo free the returned string, you must use <
code>mpfr_free_str</
code>.
219N/A <
p>If <
var>str</
var> is not a null pointer, it should point to a block of storage
219N/Alarge enough for the significand,
i.e., at least <
code>max(</
code><
var>n</
var><
code> + 2, 7)</
code>.
219N/AThe extra two bytes are for a possible minus sign, and for the terminating null
219N/A <
p>If the input number is an ordinary number, the exponent is written through
219N/Athe pointer <
var>expptr</
var> (the current minimal exponent for 0).
219N/A <
p>A pointer to the string is returned, unless there is an error, in which
219N/Acase a null pointer is returned.
219N/A— Function: void <
b>mpfr_free_str</
b> (<
var>char *str</
var>)<
var><
a name="index-mpfr_005ffree_005fstr-75"></
a></
var><
br>
219N/A<
blockquote><
p>Free a string allocated by <
code>mpfr_get_str</
code> using the current unallocation
219N/Afunction (preliminary interface).
219N/AThe block is assumed to be <
code>strlen(</
code><
var>str</
var><
code>)+1</
code> bytes.
219N/AFor more information about how it is done:
219N/Asee section “Custom Allocation” in <
cite>GNU MP</
cite>.
219N/A— Function: int <
b>mpfr_fits_ulong_p</
b> (<
var>mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005ffits_005fulong_005fp-76"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_fits_slong_p</
b> (<
var>mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005ffits_005fslong_005fp-77"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_fits_uint_p</
b> (<
var>mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005ffits_005fuint_005fp-78"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_fits_sint_p</
b> (<
var>mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005ffits_005fsint_005fp-79"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_fits_ushort_p</
b> (<
var>mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005ffits_005fushort_005fp-80"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_fits_sshort_p</
b> (<
var>mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005ffits_005fsshort_005fp-81"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_fits_intmax_p</
b> (<
var>mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005ffits_005fintmax_005fp-82"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_fits_uintmax_p</
b> (<
var>mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005ffits_005fuintmax_005fp-83"></
a></
var><
br>
219N/A<
blockquote><
p>Return non-zero if <
var>op</
var> would fit in the respective C data type, when
219N/Arounded to an integer in the direction <
var>rnd</
var>.
219N/A<
a name="Basic-Arithmetic-Functions"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Comparison-Functions">Comparison Functions</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Conversion-Functions">Conversion Functions</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A <
p><
a name="index-Basic-arithmetic-functions-84"></
a><
a name="index-Float-arithmetic-functions-85"></
a><
a name="index-Arithmetic-functions-86"></
a>
219N/A<
h3 class="section">5.5 Basic Arithmetic Functions</
h3>
219N/A— Function: int <
b>mpfr_add</
b> (<
var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fadd-87"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_add_ui</
b> (<
var>mpfr_t rop, mpfr_t op1, unsigned long int op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fadd_005fui-88"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_add_si</
b> (<
var>mpfr_t rop, mpfr_t op1, long int op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fadd_005fsi-89"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_add_z</
b> (<
var>mpfr_t rop, mpfr_t op1, mpz_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fadd_005fz-90"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_add_q</
b> (<
var>mpfr_t rop, mpfr_t op1, mpq_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fadd_005fq-91"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to <
var>op1</
var> + <
var>op2</
var> rounded in the direction
219N/A<
var>rnd</
var>. For types having no signed zero, it is considered unsigned
219N/A(
i.e. (+0) + 0 = (+0) and (−0) + 0 = (−0)).
219N/A— Function: int <
b>mpfr_sub</
b> (<
var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fsub-92"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_ui_sub</
b> (<
var>mpfr_t rop, unsigned long int op1, mpfr_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fui_005fsub-93"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_sub_ui</
b> (<
var>mpfr_t rop, mpfr_t op1, unsigned long int op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fsub_005fui-94"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_si_sub</
b> (<
var>mpfr_t rop, long int op1, mpfr_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fsi_005fsub-95"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_sub_si</
b> (<
var>mpfr_t rop, mpfr_t op1, long int op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fsub_005fsi-96"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_sub_z</
b> (<
var>mpfr_t rop, mpfr_t op1, mpz_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fsub_005fz-97"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_sub_q</
b> (<
var>mpfr_t rop, mpfr_t op1, mpq_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fsub_005fq-98"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to <
var>op1</
var> - <
var>op2</
var> rounded in the direction
219N/A<
var>rnd</
var>. For types having no signed zero, it is considered unsigned
219N/A(
i.e. (+0) − 0 = (+0), (−0) − 0 = (−0),
219N/A0 − (+0) = (−0) and 0 − (−0) = (+0)).
219N/A— Function: int <
b>mpfr_mul</
b> (<
var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fmul-99"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_mul_ui</
b> (<
var>mpfr_t rop, mpfr_t op1, unsigned long int op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fmul_005fui-100"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_mul_si</
b> (<
var>mpfr_t rop, mpfr_t op1, long int op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fmul_005fsi-101"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_mul_z</
b> (<
var>mpfr_t rop, mpfr_t op1, mpz_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fmul_005fz-102"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_mul_q</
b> (<
var>mpfr_t rop, mpfr_t op1, mpq_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fmul_005fq-103"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to <
var>op1</
var> times <
var>op2</
var> rounded in the
219N/Adirection <
var>rnd</
var>.
219N/AWhen a result is zero, its sign is the product of the signs of the operands
219N/A(for types having no signed zero, it is considered positive).
219N/A— Function: int <
b>mpfr_sqr</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fsqr-104"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the square of <
var>op</
var>
219N/Arounded in the direction <
var>rnd</
var>.
219N/A— Function: int <
b>mpfr_div</
b> (<
var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fdiv-105"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_ui_div</
b> (<
var>mpfr_t rop, unsigned long int op1, mpfr_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fui_005fdiv-106"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_div_ui</
b> (<
var>mpfr_t rop, mpfr_t op1, unsigned long int op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fdiv_005fui-107"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_si_div</
b> (<
var>mpfr_t rop, long int op1, mpfr_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fsi_005fdiv-108"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_div_si</
b> (<
var>mpfr_t rop, mpfr_t op1, long int op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fdiv_005fsi-109"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_div_z</
b> (<
var>mpfr_t rop, mpfr_t op1, mpz_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fdiv_005fz-110"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_div_q</
b> (<
var>mpfr_t rop, mpfr_t op1, mpq_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fdiv_005fq-111"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to <
var>op1</
var>/<
var>op2</
var> rounded in the direction <
var>rnd</
var>.
219N/AWhen a result is zero, its sign is the product of the signs of the operands
219N/A(for types having no signed zero, it is considered positive).
219N/A— Function: int <
b>mpfr_sqrt</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fsqrt-112"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_sqrt_ui</
b> (<
var>mpfr_t rop, unsigned long int op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fsqrt_005fui-113"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the square root of <
var>op</
var>
219N/Arounded in the direction <
var>rnd</
var>. Return −0 if <
var>op</
var> is
219N/A−0 (to be consistent with the IEEE 754-1985 standard).
219N/ASet <
var>rop</
var> to NaN if <
var>op</
var> is negative.
219N/A— Function: int <
b>mpfr_cbrt</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fcbrt-114"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_root</
b> (<
var>mpfr_t rop, mpfr_t op, unsigned long int k, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005froot-115"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the cubic root (resp. the <
var>k</
var>th root)
219N/Aof <
var>op</
var> rounded in the direction <
var>rnd</
var>.
219N/AAn odd (resp. even) root of a negative number (including −Inf)
219N/Areturns a negative number (resp. NaN).
219N/AThe <
var>k</
var>th root of −0 is defined to be −0,
219N/Awhatever the parity of <
var>k</
var>.
219N/A— Function: int <
b>mpfr_pow</
b> (<
var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fpow-116"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_pow_ui</
b> (<
var>mpfr_t rop, mpfr_t op1, unsigned long int op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fpow_005fui-117"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_pow_si</
b> (<
var>mpfr_t rop, mpfr_t op1, long int op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fpow_005fsi-118"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_pow_z</
b> (<
var>mpfr_t rop, mpfr_t op1, mpz_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fpow_005fz-119"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_ui_pow_ui</
b> (<
var>mpfr_t rop, unsigned long int op1, unsigned long int op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fui_005fpow_005fui-120"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_ui_pow</
b> (<
var>mpfr_t rop, unsigned long int op1, mpfr_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fui_005fpow-121"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to <
var>op1</
var> raised to <
var>op2</
var>,
219N/Arounded in the direction <
var>rnd</
var>.
219N/ASpecial values are currently handled as described in the ISO C99 standard
219N/Afor the <
code>pow</
code> function (note this may change in future versions):
219N/A<
li><
code>pow(�0, </
code><
var>y</
var><
code>)</
code> returns plus or minus infinity for <
var>y</
var> a negative odd integer.
219N/A<
li><
code>pow(�0, </
code><
var>y</
var><
code>)</
code> returns plus infinity for <
var>y</
var> negative and not an odd integer.
219N/A<
li><
code>pow(�0, </
code><
var>y</
var><
code>)</
code> returns plus or minus zero for <
var>y</
var> a positive odd integer.
219N/A<
li><
code>pow(�0, </
code><
var>y</
var><
code>)</
code> returns plus zero for <
var>y</
var> positive and not an odd integer.
219N/A<
li><
code>pow(-1, �Inf)</
code> returns 1.
219N/A<
li><
code>pow(+1, </
code><
var>y</
var><
code>)</
code> returns 1 for any <
var>y</
var>, even a NaN.
219N/A<
li><
code>pow(</
code><
var>x</
var><
code>, �0)</
code> returns 1 for any <
var>x</
var>, even a NaN.
219N/A<
li><
code>pow(</
code><
var>x</
var><
code>, </
code><
var>y</
var><
code>)</
code> returns NaN for finite negative <
var>x</
var> and finite non-integer <
var>y</
var>.
219N/A<
li><
code>pow(</
code><
var>x</
var><
code>, -Inf)</
code> returns plus infinity for 0 < abs(x) < 1, and plus zero for abs(x) > 1.
219N/A<
li><
code>pow(</
code><
var>x</
var><
code>, +Inf)</
code> returns plus zero for 0 < abs(x) < 1, and plus infinity for abs(x) > 1.
219N/A<
li><
code>pow(-Inf, </
code><
var>y</
var><
code>)</
code> returns minus zero for <
var>y</
var> a negative odd integer.
219N/A<
li><
code>pow(-Inf, </
code><
var>y</
var><
code>)</
code> returns plus zero for <
var>y</
var> negative and not an odd integer.
219N/A<
li><
code>pow(-Inf, </
code><
var>y</
var><
code>)</
code> returns minus infinity for <
var>y</
var> a positive odd integer.
219N/A<
li><
code>pow(-Inf, </
code><
var>y</
var><
code>)</
code> returns plus infinity for <
var>y</
var> positive and not an odd integer.
219N/A<
li><
code>pow(+Inf, </
code><
var>y</
var><
code>)</
code> returns plus zero for <
var>y</
var> negative, and plus infinity for <
var>y</
var> positive.
219N/A </
p></
blockquote></
div>
219N/A— Function: int <
b>mpfr_neg</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fneg-122"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to -<
var>op</
var> rounded in the direction <
var>rnd</
var>.
219N/AJust changes the sign if <
var>rop</
var> and <
var>op</
var> are the same variable.
219N/A— Function: int <
b>mpfr_abs</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fabs-123"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the absolute value of <
var>op</
var>,
219N/Arounded in the direction <
var>rnd</
var>.
219N/AJust changes the sign if <
var>rop</
var> and <
var>op</
var> are the same variable.
219N/A— Function: int <
b>mpfr_dim</
b> (<
var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fdim-124"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the positive difference of <
var>op1</
var> and <
var>op2</
var>,
i.e.,
219N/A<
var>op1</
var> - <
var>op2</
var> rounded in the direction <
var>rnd</
var>
219N/Aif <
var>op1</
var> > <
var>op2</
var>, and +0 otherwise.
219N/AReturns NaN when <
var>op1</
var> or <
var>op2</
var> is NaN.
219N/A— Function: int <
b>mpfr_mul_2ui</
b> (<
var>mpfr_t rop, mpfr_t op1, unsigned long int op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fmul_005f2ui-125"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_mul_2si</
b> (<
var>mpfr_t rop, mpfr_t op1, long int op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fmul_005f2si-126"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to <
var>op1</
var> times 2 raised
219N/Arounded in the direction <
var>rnd</
var>. Just increases the exponent by <
var>op2</
var>
219N/Awhen <
var>rop</
var> and <
var>op1</
var> are identical.
219N/A— Function: int <
b>mpfr_div_2ui</
b> (<
var>mpfr_t rop, mpfr_t op1, unsigned long int op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fdiv_005f2ui-127"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_div_2si</
b> (<
var>mpfr_t rop, mpfr_t op1, long int op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fdiv_005f2si-128"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to <
var>op1</
var> divided by 2 raised
219N/Arounded in the direction <
var>rnd</
var>. Just decreases the exponent by <
var>op2</
var>
219N/Awhen <
var>rop</
var> and <
var>op1</
var> are identical.
219N/A<
a name="Comparison-Functions"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Special-Functions">Special Functions</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A <
p><
a name="index-Float-comparisons-functions-129"></
a><
a name="index-Comparison-functions-130"></
a>
219N/A<
h3 class="section">5.6 Comparison Functions</
h3>
219N/A— Function: int <
b>mpfr_cmp</
b> (<
var>mpfr_t op1, mpfr_t op2</
var>)<
var><
a name="index-mpfr_005fcmp-131"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_cmp_ui</
b> (<
var>mpfr_t op1, unsigned long int op2</
var>)<
var><
a name="index-mpfr_005fcmp_005fui-132"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_cmp_si</
b> (<
var>mpfr_t op1, signed long int op2</
var>)<
var><
a name="index-mpfr_005fcmp_005fsi-133"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_cmp_d</
b> (<
var>mpfr_t op1, double op2</
var>)<
var><
a name="index-mpfr_005fcmp_005fd-134"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_cmp_ld</
b> (<
var>mpfr_t op1, long double op2</
var>)<
var><
a name="index-mpfr_005fcmp_005fld-135"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_cmp_z</
b> (<
var>mpfr_t op1, mpz_t op2</
var>)<
var><
a name="index-mpfr_005fcmp_005fz-136"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_cmp_q</
b> (<
var>mpfr_t op1, mpq_t op2</
var>)<
var><
a name="index-mpfr_005fcmp_005fq-137"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_cmp_f</
b> (<
var>mpfr_t op1, mpf_t op2</
var>)<
var><
a name="index-mpfr_005fcmp_005ff-138"></
a></
var><
br>
219N/A<
blockquote><
p>Compare <
var>op1</
var> and <
var>op2</
var>. Return a positive value if <
var>op1</
var> >
219N/A<
var>op2</
var>, zero if <
var>op1</
var> = <
var>op2</
var>, and a negative value if
219N/A<
var>op1</
var> < <
var>op2</
var>.
219N/ABoth <
var>op1</
var> and <
var>op2</
var> are considered to their full own precision,
219N/AIf one of the operands is NaN, set the erange flag and return zero.
219N/A <
p>Note: These functions may be useful to distinguish the three possible cases.
219N/AIf you need to distinguish two cases only, it is recommended to use the
219N/Apredicate functions (
e.g., <
code>mpfr_equal_p</
code> for the equality) described
219N/Abelow; they behave like the IEEE-754 comparisons, in particular when one
219N/Aor both arguments are NaN. But only floating-point numbers can be compared
219N/A(you may need to do a conversion first).
219N/A— Function: int <
b>mpfr_cmp_ui_2exp</
b> (<
var>mpfr_t op1, unsigned long int op2, mp_exp_t e</
var>)<
var><
a name="index-mpfr_005fcmp_005fui_005f2exp-139"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_cmp_si_2exp</
b> (<
var>mpfr_t op1, long int op2, mp_exp_t e</
var>)<
var><
a name="index-mpfr_005fcmp_005fsi_005f2exp-140"></
a></
var><
br>
219N/A<
blockquote><
p>Compare <
var>op1</
var> and <
var>op2</
var> multiplied by two to
219N/Athe power <
var>e</
var>. Similar as above.
219N/A— Function: int <
b>mpfr_cmpabs</
b> (<
var>mpfr_t op1, mpfr_t op2</
var>)<
var><
a name="index-mpfr_005fcmpabs-141"></
a></
var><
br>
219N/A<
blockquote><
p>Compare |<
var>op1</
var>| and |<
var>op2</
var>|. Return a positive value if
219N/A|<
var>op1</
var>| > |<
var>op2</
var>|, zero if |<
var>op1</
var>| = |<
var>op2</
var>|, and
219N/Aa negative value if |<
var>op1</
var>| < |<
var>op2</
var>|.
219N/AIf one of the operands is NaN, set the erange flag and return zero.
219N/A— Function: int <
b>mpfr_nan_p</
b> (<
var>mpfr_t op</
var>)<
var><
a name="index-mpfr_005fnan_005fp-142"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_inf_p</
b> (<
var>mpfr_t op</
var>)<
var><
a name="index-mpfr_005finf_005fp-143"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_number_p</
b> (<
var>mpfr_t op</
var>)<
var><
a name="index-mpfr_005fnumber_005fp-144"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_zero_p</
b> (<
var>mpfr_t op</
var>)<
var><
a name="index-mpfr_005fzero_005fp-145"></
a></
var><
br>
219N/A<
blockquote><
p>Return non-zero if <
var>op</
var> is respectively NaN, an infinity, an ordinary
219N/Anumber (
i.e. neither NaN nor an infinity) or zero. Return zero otherwise.
219N/A— Macro: int <
b>mpfr_sgn</
b> (<
var>mpfr_t op</
var>)<
var><
a name="index-mpfr_005fsgn-146"></
a></
var><
br>
219N/A<
blockquote><
p>Return a positive value if <
var>op</
var> > 0, zero if <
var>op</
var> = 0,
219N/Aand a negative value if <
var>op</
var> < 0.
219N/AIf the operand is NaN, set the erange flag and return zero.
219N/A— Function: int <
b>mpfr_greater_p</
b> (<
var>mpfr_t op1, mpfr_t op2</
var>)<
var><
a name="index-mpfr_005fgreater_005fp-147"></
a></
var><
br>
219N/A<
blockquote><
p>Return non-zero if <
var>op1</
var> > <
var>op2</
var>, zero otherwise.
219N/A— Function: int <
b>mpfr_greaterequal_p</
b> (<
var>mpfr_t op1, mpfr_t op2</
var>)<
var><
a name="index-mpfr_005fgreaterequal_005fp-148"></
a></
var><
br>
219N/A<
blockquote><
p>Return non-zero if <
var>op1</
var> >= <
var>op2</
var>, zero otherwise.
219N/A— Function: int <
b>mpfr_less_p</
b> (<
var>mpfr_t op1, mpfr_t op2</
var>)<
var><
a name="index-mpfr_005fless_005fp-149"></
a></
var><
br>
219N/A<
blockquote><
p>Return non-zero if <
var>op1</
var> < <
var>op2</
var>, zero otherwise.
219N/A— Function: int <
b>mpfr_lessequal_p</
b> (<
var>mpfr_t op1, mpfr_t op2</
var>)<
var><
a name="index-mpfr_005flessequal_005fp-150"></
a></
var><
br>
219N/A<
blockquote><
p>Return non-zero if <
var>op1</
var> <= <
var>op2</
var>, zero otherwise.
219N/A— Function: int <
b>mpfr_lessgreater_p</
b> (<
var>mpfr_t op1, mpfr_t op2</
var>)<
var><
a name="index-mpfr_005flessgreater_005fp-151"></
a></
var><
br>
219N/A<
blockquote><
p>Return non-zero if <
var>op1</
var> < <
var>op2</
var> or
219N/A<
var>op1</
var> > <
var>op2</
var> (
i.e. neither <
var>op1</
var>, nor <
var>op2</
var> is
219N/ANaN, and <
var>op1</
var> <> <
var>op2</
var>), zero otherwise (
i.e. <
var>op1</
var>
219N/Aand/
or <
var>op2</
var> are NaN, or <
var>op1</
var> = <
var>op2</
var>).
219N/A— Function: int <
b>mpfr_equal_p</
b> (<
var>mpfr_t op1, mpfr_t op2</
var>)<
var><
a name="index-mpfr_005fequal_005fp-152"></
a></
var><
br>
219N/A<
blockquote><
p>Return non-zero if <
var>op1</
var> = <
var>op2</
var>, zero otherwise
219N/A<
var>op1</
var> <> <
var>op2</
var>).
219N/A— Function: int <
b>mpfr_unordered_p</
b> (<
var>mpfr_t op1, mpfr_t op2</
var>)<
var><
a name="index-mpfr_005funordered_005fp-153"></
a></
var><
br>
219N/A<
blockquote><
p>Return non-zero if <
var>op1</
var> or <
var>op2</
var> is a NaN (
i.e. they cannot be
219N/Acompared), zero otherwise.
219N/A<
a name="Special-Functions"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Input-and-Output-Functions">Input and Output Functions</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Comparison-Functions">Comparison Functions</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</
a>
219N/A <
p><
a name="index-Special-functions-154"></
a>
219N/A<
h3 class="section">5.7 Special Functions</
h3>
219N/A<
p>All those functions, except explicitly stated, return zero for an
219N/Aexact return value, a positive value for a return value larger than the
219N/Aexact result, and a negative value otherwise.
219N/A <
p>Important note: in some domains, computing special functions (either with
219N/Acorrect or incorrect rounding) is expensive, even for small precision,
219N/Afor example the trigonometric and Bessel functions for large argument.
219N/A— Function: int <
b>mpfr_log</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005flog-155"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_log2</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005flog2-156"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_log10</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005flog10-157"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the natural logarithm of <
var>op</
var>,
219N/Alog10(<
var>op</
var>), respectively,
219N/Arounded in the direction <
var>rnd</
var>.
219N/AReturn −Inf if <
var>op</
var> is −0 (
i.e. the sign of the zero
219N/Ahas no influence on the result).
219N/A— Function: int <
b>mpfr_exp</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fexp-158"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_exp2</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fexp2-159"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_exp10</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fexp10-160"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the exponential of <
var>op</
var>,
219N/A to 2 power of <
var>op</
var>
219N/Aor to 10 power of <
var>op</
var>, respectively,
219N/Arounded in the direction <
var>rnd</
var>.
219N/A— Function: int <
b>mpfr_cos</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fcos-161"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_sin</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fsin-162"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_tan</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005ftan-163"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the cosine of <
var>op</
var>, sine of <
var>op</
var>,
219N/Atangent of <
var>op</
var>, rounded in the direction <
var>rnd</
var>.
219N/A— Function: int <
b>mpfr_sec</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fsec-164"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_csc</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fcsc-165"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_cot</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fcot-166"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the secant of <
var>op</
var>, cosecant of <
var>op</
var>,
219N/Acotangent of <
var>op</
var>, rounded in the direction <
var>rnd</
var>.
219N/A— Function: int <
b>mpfr_sin_cos</
b> (<
var>mpfr_t sop, mpfr_t cop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fsin_005fcos-167"></
a></
var><
br>
219N/A<
blockquote><
p>Set simultaneously <
var>sop</
var> to the sine of <
var>op</
var> and
219N/A <
var>cop</
var> to the cosine of <
var>op</
var>,
219N/Arounded in the direction <
var>rnd</
var> with the corresponding precisions of
219N/A<
var>sop</
var> and <
var>cop</
var>, which must be different variables.
219N/AReturn 0 iff both results are exact.
219N/A— Function: int <
b>mpfr_acos</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005facos-168"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_asin</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fasin-169"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_atan</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fatan-170"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the arc-cosine, arc-sine or arc-tangent of <
var>op</
var>,
219N/Arounded in the direction <
var>rnd</
var>.
219N/ANote that since <
code>acos(-1)</
code> returns the floating-point number closest to
219N/APi according to the given rounding mode, this number might not be
219N/Ain the output range 0 <= <
var>rop</
var> < \pi
219N/Aof the arc-cosine function;
219N/Astill, the result lies in the image of the output range
219N/Aby the rounding function.
219N/AThe same holds for <
code>asin(-1)</
code>, <
code>asin(1)</
code>, <
code>atan(-Inf)</
code>,
219N/A<
code>atan(+Inf)</
code>.
219N/A— Function: int <
b>mpfr_atan2</
b> (<
var>mpfr_t rop, mpfr_t y, mpfr_t x, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fatan2-171"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the arc-tangent2 of <
var>y</
var> and <
var>x</
var>,
219N/Arounded in the direction <
var>rnd</
var>:
219N/Aif <
code>x > 0</
code>, <
code>atan2(y, x) = atan (y/x)</
code>;
219N/Aif <
code>x < 0</
code>, <
code>atan2(y, x) = sign(y)*(Pi - atan (abs(y/x)))</
code>.
219N/AAs for <
code>atan</
code>, in case the exact mathematical result is +Pi or
219N/A-Pi, its rounded result might be outside the function output range.
219N/A <
p><
code>atan2(y, 0)</
code> does not raise any floating-point exception.
219N/ASpecial values are currently handled as described in the ISO C99 standard
219N/Afor the <
code>atan2</
code> function (note this may change in future versions):
219N/A<
li><
code>atan2(+0, -0)</
code> returns +Pi.
219N/A<
li><
code>atan2(-0, -0)</
code> returns -Pi.
219N/A<
li><
code>atan2(+0, +0)</
code> returns +0.
219N/A<
li><
code>atan2(-0, +0)</
code> returns −0.
219N/A<
li><
code>atan2(+0, x)</
code> returns +Pi for x < 0.
219N/A<
li><
code>atan2(-0, x)</
code> returns -Pi for x < 0.
219N/A<
li><
code>atan2(+0, x)</
code> returns +0 for x > 0.
219N/A<
li><
code>atan2(-0, x)</
code> returns −0 for x > 0.
219N/A<
li><
code>atan2(y, 0)</
code> returns -Pi/2 for y < 0.
219N/A<
li><
code>atan2(y, 0)</
code> returns +Pi/2 for y > 0.
219N/A<
li><
code>atan2(+Inf, -Inf)</
code> returns +3*Pi/4.
219N/A<
li><
code>atan2(-Inf, -Inf)</
code> returns -3*Pi/4.
219N/A<
li><
code>atan2(+Inf, +Inf)</
code> returns +Pi/4.
219N/A<
li><
code>atan2(-Inf, +Inf)</
code> returns -Pi/4.
219N/A<
li><
code>atan2(+Inf, x)</
code> returns +Pi/2 for finite x.
219N/A<
li><
code>atan2(-Inf, x)</
code> returns -Pi/2 for finite x.
219N/A<
li><
code>atan2(y, -Inf)</
code> returns +Pi for finite y > 0.
219N/A<
li><
code>atan2(y, -Inf)</
code> returns -Pi for finite y < 0.
219N/A<
li><
code>atan2(y, +Inf)</
code> returns +0 for finite y > 0.
219N/A<
li><
code>atan2(y, +Inf)</
code> returns −0 for finite y < 0.
219N/A </
p></
blockquote></
div>
219N/A— Function: int <
b>mpfr_cosh</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fcosh-172"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_sinh</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fsinh-173"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_tanh</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005ftanh-174"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the hyperbolic cosine, sine or tangent of <
var>op</
var>,
219N/Arounded in the direction <
var>rnd</
var>.
219N/A— Function: int <
b>mpfr_sech</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fsech-175"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_csch</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fcsch-176"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_coth</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fcoth-177"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the hyperbolic secant of <
var>op</
var>, cosecant of <
var>op</
var>,
219N/Acotangent of <
var>op</
var>, rounded in the direction <
var>rnd</
var>.
219N/A— Function: int <
b>mpfr_acosh</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005facosh-178"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_asinh</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fasinh-179"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_atanh</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fatanh-180"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the inverse hyperbolic cosine, sine or tangent of <
var>op</
var>,
219N/Arounded in the direction <
var>rnd</
var>.
219N/A— Function: int <
b>mpfr_fac_ui</
b> (<
var>mpfr_t rop, unsigned long int op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005ffac_005fui-181"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the factorial of the <
code>unsigned long int</
code> <
var>op</
var>,
219N/Arounded in the direction <
var>rnd</
var>.
219N/A— Function: int <
b>mpfr_log1p</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005flog1p-182"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the logarithm of one plus <
var>op</
var>,
219N/Arounded in the direction <
var>rnd</
var>.
219N/A— Function: int <
b>mpfr_expm1</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fexpm1-183"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the exponential of <
var>op</
var> minus one,
219N/Arounded in the direction <
var>rnd</
var>.
219N/A— Function: int <
b>mpfr_eint</
b> (<
var>mpfr_t y, mpfr_t x, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005feint-184"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>y</
var> to the exponential integral of <
var>x</
var>,
219N/Arounded in the direction <
var>rnd</
var>.
219N/AFor positive <
var>x</
var>,
219N/Athe exponential integral is the sum of Euler's constant, of the logarithm
219N/Aof <
var>x</
var>, and of the sum for k from 1 to infinity of
219N/A<
var>x</
var> to the power k, divided by k and factorial(k).
219N/AFor negative <
var>x</
var>, the returned value is NaN.
219N/A— Function: int <
b>mpfr_gamma</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fgamma-185"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the value of the Gamma function on <
var>op</
var>, rounded in the
219N/Adirection <
var>rnd</
var>. When <
var>op</
var> is a negative integer, NaN is returned.
219N/A— Function: int <
b>mpfr_lngamma</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005flngamma-186"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the value of the logarithm of the Gamma function on <
var>op</
var>,
219N/Arounded in the direction <
var>rnd</
var>.
219N/AWhen −2<
var>k</
var>−1 <= <
var>x</
var> <= −2<
var>k</
var>,
219N/A<
var>k</
var> being a non-negative integer, NaN is returned.
219N/ASee also <
code>mpfr_lgamma</
code>.
219N/A— Function: int <
b>mpfr_lgamma</
b> (<
var>mpfr_t rop, int *signp, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005flgamma-187"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the value of the logarithm of the absolute value of the
219N/AGamma function on <
var>op</
var>, rounded in the direction <
var>rnd</
var>. The sign
219N/A(1 or −1) of Gamma(<
var>op</
var>) is returned in the object pointed to
219N/Aby <
var>signp</
var>. When <
var>op</
var> is an infinity or a non-positive integer,
219N/A+Inf is returned. When <
var>op</
var> is NaN, −Inf or a negative integer,
219N/A*<
var>signp</
var> is undefined, and when <
var>op</
var> is �0, *<
var>signp</
var> is
219N/A— Function: int <
b>mpfr_zeta</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fzeta-188"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_zeta_ui</
b> (<
var>mpfr_t rop, unsigned long op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fzeta_005fui-189"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the value of the Riemann Zeta function on <
var>op</
var>,
219N/Arounded in the direction <
var>rnd</
var>.
219N/A— Function: int <
b>mpfr_erf</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005ferf-190"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the value of the error function on <
var>op</
var>,
219N/Arounded in the direction <
var>rnd</
var>.
219N/A— Function: int <
b>mpfr_erfc</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005ferfc-191"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the value of the complementary error function on <
var>op</
var>,
219N/Arounded in the direction <
var>rnd</
var>.
219N/A— Function: int <
b>mpfr_j0</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fj0-192"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_j1</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fj1-193"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_jn</
b> (<
var>mpfr_t rop, long n, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fjn-194"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the value of the first order Bessel function of order 0, 1
219N/Aand <
var>n</
var> on <
var>op</
var>, rounded in the direction <
var>rnd</
var>. When <
var>op</
var> is
219N/ANaN, <
var>rop</
var> is always set to NaN. When <
var>op</
var> is plus or minus Infinity,
219N/A<
var>rop</
var> is set to +0. When <
var>op</
var> is zero, and <
var>n</
var> is not zero,
219N/A<
var>rop</
var> is +0 or −0 depending on the parity and sign of <
var>n</
var>,
219N/Aand the sign of <
var>op</
var>.
219N/A— Function: int <
b>mpfr_y0</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fy0-195"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_y1</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fy1-196"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_yn</
b> (<
var>mpfr_t rop, long n, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fyn-197"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the value of the second order Bessel function of order 0, 1
219N/Aand <
var>n</
var> on <
var>op</
var>, rounded in the direction <
var>rnd</
var>. When <
var>op</
var> is
219N/A<
var>rop</
var> is always set to NaN. When <
var>op</
var> is +Inf,
219N/A<
var>rop</
var> is +0. When <
var>op</
var> is zero,
219N/A<
var>rop</
var> is +Inf or −Inf depending on the parity and sign of <
var>n</
var>.
219N/A— Function: int <
b>mpfr_fma</
b> (<
var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mpfr_t op3, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005ffma-198"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to (<
var>op1</
var> times <
var>op2</
var>) + <
var>op3</
var>,
219N/Arounded in the direction <
var>rnd</
var>.
219N/A— Function: int <
b>mpfr_fms</
b> (<
var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mpfr_t op3, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005ffms-199"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to (<
var>op1</
var> times <
var>op2</
var>) - <
var>op3</
var>,
219N/Arounded in the direction <
var>rnd</
var>.
219N/A— Function: int <
b>mpfr_agm</
b> (<
var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fagm-200"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the arithmetic-geometric mean of <
var>op1</
var> and <
var>op2</
var>,
219N/Arounded in the direction <
var>rnd</
var>.
219N/AThe arithmetic-geometric mean is the common limit of the sequences
219N/Au[n] and v[n], where u[0]=<
var>op1</
var>, v[0]=<
var>op2</
var>, u[n+1] is the
219N/Aarithmetic mean of u[n] and v[n], and v[n+1] is the geometric mean of
219N/AIf any operand is negative, the return value is NaN.
219N/A— Function: int <
b>mpfr_hypot</
b> (<
var>mpfr_t rop, mpfr_t x, mpfr_t y, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fhypot-201"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the Euclidean norm of <
var>x</
var> and <
var>y</
var>,
219N/Ai.e. the square root of the sum of the squares of <
var>x</
var> and <
var>y</
var>,
219N/Arounded in the direction <
var>rnd</
var>.
219N/ASpecial values are currently handled as described in Section F.9.4.3 of
219N/Athe ISO C99 standard, for the <
code>hypot</
code> function (note this may change
219N/Ain future versions): If <
var>x</
var> or <
var>y</
var> is an infinity, then plus
219N/Ainfinity is returned in <
var>rop</
var>, even if the other number is NaN.
219N/A— Function: int <
b>mpfr_const_log2</
b> (<
var>mpfr_t rop, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fconst_005flog2-202"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_const_pi</
b> (<
var>mpfr_t rop, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fconst_005fpi-203"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_const_euler</
b> (<
var>mpfr_t rop, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fconst_005feuler-204"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_const_catalan</
b> (<
var>mpfr_t rop, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fconst_005fcatalan-205"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the logarithm of 2, the value of Pi,
219N/Aof Euler's constant 0.577<
small class="dots">...</
small>, of Catalan's constant 0.915<
small class="dots">...</
small>,
219N/Arespectively, rounded in the direction
219N/A<
var>rnd</
var>. These functions cache the computed values to avoid other
219N/Acalculations if a lower or equal precision is requested. To free these caches,
219N/Ause <
code>mpfr_free_cache</
code>.
219N/A— Function: void <
b>mpfr_free_cache</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005ffree_005fcache-206"></
a></
var><
br>
219N/A<
blockquote><
p>Free various caches used by MPFR internally, in particular the
219N/Acaches used by the functions computing constants (currently
219N/A<
code>mpfr_const_log2</
code>, <
code>mpfr_const_pi</
code>,
219N/A<
code>mpfr_const_euler</
code> and <
code>mpfr_const_catalan</
code>).
219N/AYou should call this function before terminating a thread, even if you did
219N/Anot call these functions directly (they could have been called internally).
219N/A— Function: int <
b>mpfr_sum</
b> (<
var>mpfr_t rop, mpfr_ptr const tab</
var>[]<
var>, unsigned long n, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fsum-207"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>ret</
var> to the sum of all elements of <
var>tab</
var> whose size is <
var>n</
var>,
219N/Arounded in the direction <
var>rnd</
var>. Warning, <
var>tab</
var> is a table of pointers
219N/Ato mpfr_t, not a table of mpfr_t (preliminary interface). The returned
219N/A<
code>int</
code> value is zero when the computed value is the exact value,
219N/Aand non-zero when this cannot be guaranteed, without giving the
219N/Adirection of the error as the other functions do.
219N/A<
a name="Input-and-Output-Functions"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Integer-Related-Functions">Integer Related Functions</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Special-Functions">Special Functions</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A <
p><
a name="index-Float-input-and-output-functions-208"></
a><
a name="index-Input-functions-209"></
a><
a name="index-Output-functions-210"></
a><
a name="index-I_002fO-functions-211"></
a>
219N/A<
h3 class="section">5.8 Input and Output Functions</
h3>
219N/APassing a null pointer for a <
var>stream</
var> argument to any of
219N/Athese functions will make them read from <
code>stdin</
code> and write to
219N/A<
code>stdout</
code>, respectively.
219N/A <
p>When using any of these functions, you must include the <
code><
stdio.h></
code>
219N/Astandard header before <
samp><
span class="file">
mpfr.h</
span></
samp>, to allow <
samp><
span class="file">
mpfr.h</
span></
samp> to define
219N/Aprototypes for these functions.
219N/A— Function: size_t <
b>mpfr_out_str</
b> (<
var>FILE *stream, int base, size_t n, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fout_005fstr-212"></
a></
var><
br>
219N/A<
blockquote><
p>Output <
var>op</
var> on stream <
var>stream</
var>, as a string of digits in
219N/Abase <
var>base</
var>, rounded in the direction <
var>rnd</
var>.
219N/AThe base may vary from 2 to 36. Print <
var>n</
var> significant digits exactly,
219N/Aor if <
var>n</
var> is 0, enough digits so that <
var>op</
var> can be read back
219N/Aexactly (see <
code>mpfr_get_str</
code>).
219N/A <
p>In addition to the significant digits, a decimal point (defined by the
219N/Acurrent locale) at the right of the
219N/Afirst digit and a trailing exponent in base 10, in the form ‘<
samp><
span class="samp">eNNN</
span></
samp>’,
219N/Aare printed. If <
var>base</
var> is greater than 10, ‘<
samp><
span class="samp">@</
span></
samp>’ will be used
219N/Ainstead of ‘<
samp><
span class="samp">e</
span></
samp>’ as exponent delimiter.
219N/A <
p>Return the number of bytes written, or if an error occurred, return 0.
219N/A— Function: size_t <
b>mpfr_inp_str</
b> (<
var>mpfr_t rop, FILE *stream, int base, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005finp_005fstr-213"></
a></
var><
br>
219N/A<
blockquote><
p>Input a string in base <
var>base</
var> from stream <
var>stream</
var>,
219N/Arounded in the direction <
var>rnd</
var>, and put the
219N/Aread float in <
var>rop</
var>.
219N/A<!-- The argument @var{base} must be in the range 2 to 36. --> 219N/A <!-- The string is of the form @samp{M@@N} or, if the --> 219N/A <!-- base is 10 or less, alternatively @samp{MeN} or @samp{MEN}, or, if the base --> 219N/A <!-- is 16, alternatively @samp{MpB} or @samp{MPB}. --> 219N/A <!-- @samp{M} is the significand in the specified base, @samp{N} is the exponent --> 219N/A <!-- written in decimal for the specified base, and in base 16, @samp{B} is the --> 219N/A <!-- binary exponent written in decimal (i.e.@: it indicates the power of 2 by --> 219N/A <!-- which the significand is to be scaled). --> 219N/A <
p>This function reads a word (defined as a sequence of characters between
219N/Awhitespace) and parses it using <
code>mpfr_set_str</
code> (it may change).
219N/ASee the documentation of <
code>mpfr_strtofr</
code> for a detailed description
219N/Aof the valid string formats.
219N/A<!-- Special values can be read as follows (the case does not matter): --> 219N/A<!-- @code{@@NaN@@}, @code{@@Inf@@}, @code{+@@Inf@@} and @code{-@@Inf@@}, --> 219N/A<!-- possibly followed by other characters; if the base is smaller or equal --> 219N/A<!-- to 16, the following strings are accepted too: @code{NaN}, @code{Inf}, --> 219N/A<!-- @code{+Inf} and @code{-Inf}. --> 219N/A <
p>Return the number of bytes read, or if an error occurred, return 0.
219N/A<!-- @deftypefun void mpfr_inp_raw (mpfr_t @var{float}, FILE *@var{stream}) --> 219N/A<!-- Input from stdio stream @var{stream} in the format written by --> 219N/A<!-- @code{mpfr_out_raw}, and put the result in @var{float}. --> 219N/A<!-- @end deftypefun --> 219N/A<
a name="Integer-Related-Functions"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Miscellaneous-Functions">Miscellaneous Functions</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Input-and-Output-Functions">Input and Output Functions</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A <
p><
a name="index-Integer-related-functions-214"></
a>
219N/A<
h3 class="section">5.9 Integer Related Functions</
h3>
219N/A— Function: int <
b>mpfr_rint</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005frint-215"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_ceil</
b> (<
var>mpfr_t rop, mpfr_t op</
var>)<
var><
a name="index-mpfr_005fceil-216"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_floor</
b> (<
var>mpfr_t rop, mpfr_t op</
var>)<
var><
a name="index-mpfr_005ffloor-217"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_round</
b> (<
var>mpfr_t rop, mpfr_t op</
var>)<
var><
a name="index-mpfr_005fround-218"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_trunc</
b> (<
var>mpfr_t rop, mpfr_t op</
var>)<
var><
a name="index-mpfr_005ftrunc-219"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to <
var>op</
var> rounded to an integer.
219N/A<
code>mpfr_rint</
code> rounds to the nearest representable integer in the
219N/Agiven rounding mode, <
code>mpfr_ceil</
code> rounds
219N/Ato the next higher or equal representable integer, <
code>mpfr_floor</
code> to
219N/Athe next lower or equal representable integer, <
code>mpfr_round</
code> to the
219N/Anearest representable integer, rounding halfway cases away from zero,
219N/Aand <
code>mpfr_trunc</
code> to the next representable integer toward zero.
219N/A <
p>The returned value is zero when the result is exact, positive when it is
219N/Agreater than the original value of <
var>op</
var>, and negative when it is smaller.
219N/AMore precisely, the returned value is 0 when <
var>op</
var> is an integer
219N/Arepresentable in <
var>rop</
var>, 1 or −1 when <
var>op</
var> is an integer
219N/Athat is not representable in <
var>rop</
var>, 2 or −2 when <
var>op</
var> is
219N/A <
p>Note that <
code>mpfr_round</
code> is different from <
code>mpfr_rint</
code> called with
219N/Athe rounding to nearest mode (where halfway cases are rounded to an even
219N/Ainteger or significand). Note also that no double rounding is performed; for
219N/Ainstance, 4.5 (100.1 in binary) is rounded by <
code>mpfr_round</
code> to 4 (100
219N/Ain binary) in 2-bit precision, though <
code>round(4.5)</
code> is equal to 5 and
219N/A5 (101 in binary) is rounded to 6 (110 in binary) in 2-bit precision.
219N/A— Function: int <
b>mpfr_rint_ceil</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005frint_005fceil-220"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_rint_floor</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005frint_005ffloor-221"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_rint_round</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005frint_005fround-222"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_rint_trunc</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005frint_005ftrunc-223"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to <
var>op</
var> rounded to an integer.
219N/A<
code>mpfr_rint_ceil</
code> rounds to the next higher or equal integer,
219N/A<
code>mpfr_rint_floor</
code> to the next lower or equal integer,
219N/A<
code>mpfr_rint_round</
code> to the nearest integer, rounding halfway cases away
219N/Afrom zero, and <
code>mpfr_rint_trunc</
code> to the next integer toward zero.
219N/AIf the result is not representable, it is rounded in the direction <
var>rnd</
var>.
219N/AThe returned value is the ternary value associated with the considered
219N/Around-to-integer function (regarded in the same way as any other
219N/A— Function: int <
b>mpfr_frac</
b> (<
var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005ffrac-224"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the fractional part of <
var>op</
var>, having the same sign as
219N/A<
var>op</
var>, rounded in the direction <
var>rnd</
var> (unlike in <
code>mpfr_rint</
code>,
219N/A<
var>rnd</
var> affects only how the exact fractional part is rounded, not how
219N/Athe fractional part is generated).
219N/A— Function: int <
b>mpfr_remainder</
b> (<
var>mpfr_t r, mpfr_t x, mpfr_t y, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fremainder-225"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_remquo</
b> (<
var>mpfr_t r, long* q, mpfr_t x, mpfr_t y, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fremquo-226"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>r</
var> to the remainder of the division of <
var>x</
var> by <
var>y</
var>, with
219N/Aquotient rounded to the nearest integer (ties rounded to even), and
219N/A<
var>r</
var> rounded according to the direction <
var>rnd</
var>.
219N/AIf <
var>r</
var> is zero, it has the sign of <
var>x</
var>.
219N/AThe return value is the ternary value corresponding to <
var>r</
var>.
219N/AAdditionally, <
code>mpfr_remquo</
code> stores
219N/Athe low significant bits from the quotient in <
var>*q</
var>
219N/A(more precisely the number of bits in a <
code>long</
code> minus one),
219N/Awith the sign of <
var>x</
var> divided by <
var>y</
var>
219N/A(except if those low bits are all zero, in which case zero is returned).
219N/ANote that <
var>x</
var> may be so large in magnitude relative to <
var>y</
var> that an
219N/Aexact representation of the quotient is not practical.
219N/AThese functions are useful for additive argument reduction.
219N/A— Function: int <
b>mpfr_integer_p</
b> (<
var>mpfr_t op</
var>)<
var><
a name="index-mpfr_005finteger_005fp-227"></
a></
var><
br>
219N/A<
blockquote><
p>Return non-zero iff <
var>op</
var> is an integer.
219N/A<
a name="Miscellaneous-Functions"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Rounding-Mode-Related-Functions">Rounding Mode Related Functions</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Integer-Related-Functions">Integer Related Functions</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A <
p><
a name="index-Miscellaneous-float-functions-228"></
a>
219N/A<
h3 class="section">5.10 Miscellaneous Functions</
h3>
219N/A— Function: void <
b>mpfr_nexttoward</
b> (<
var>mpfr_t x, mpfr_t y</
var>)<
var><
a name="index-mpfr_005fnexttoward-229"></
a></
var><
br>
219N/A<
blockquote><
p>If <
var>x</
var> or <
var>y</
var> is NaN, set <
var>x</
var> to NaN. Otherwise, if <
var>x</
var>
219N/Ais different from <
var>y</
var>, replace <
var>x</
var> by the next floating-point
219N/Anumber (with the precision of <
var>x</
var> and the current exponent range)
219N/Ain the direction of <
var>y</
var>, if there is one
219N/A(the infinite values are seen as the smallest and largest floating-point
219N/Anumbers). If the result is zero, it keeps the same sign. No underflow or
219N/A— Function: void <
b>mpfr_nextabove</
b> (<
var>mpfr_t x</
var>)<
var><
a name="index-mpfr_005fnextabove-230"></
a></
var><
br>
219N/A<
blockquote><
p>Equivalent to <
code>mpfr_nexttoward</
code> where <
var>y</
var> is plus infinity.
219N/A— Function: void <
b>mpfr_nextbelow</
b> (<
var>mpfr_t x</
var>)<
var><
a name="index-mpfr_005fnextbelow-231"></
a></
var><
br>
219N/A<
blockquote><
p>Equivalent to <
code>mpfr_nexttoward</
code> where <
var>y</
var> is minus infinity.
219N/A— Function: int <
b>mpfr_min</
b> (<
var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fmin-232"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the minimum of <
var>op1</
var> and <
var>op2</
var>. If <
var>op1</
var>
219N/Aand <
var>op2</
var> are both NaN, then <
var>rop</
var> is set to NaN. If <
var>op1</
var>
219N/Aor <
var>op2</
var> is NaN, then <
var>rop</
var> is set to the numeric value. If
219N/A<
var>op1</
var> and <
var>op2</
var> are zeros of different signs, then <
var>rop</
var>
219N/A— Function: int <
b>mpfr_max</
b> (<
var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fmax-233"></
a></
var><
br>
219N/A<
blockquote><
p>Set <
var>rop</
var> to the maximum of <
var>op1</
var> and <
var>op2</
var>. If <
var>op1</
var>
219N/Aand <
var>op2</
var> are both NaN, then <
var>rop</
var> is set to NaN. If <
var>op1</
var>
219N/Aor <
var>op2</
var> is NaN, then <
var>rop</
var> is set to the numeric value. If
219N/A<
var>op1</
var> and <
var>op2</
var> are zeros of different signs, then <
var>rop</
var>
219N/A— Function: int <
b>mpfr_urandomb</
b> (<
var>mpfr_t rop, gmp_randstate_t state</
var>)<
var><
a name="index-mpfr_005furandomb-234"></
a></
var><
br>
219N/A<
blockquote><
p>Generate a uniformly distributed random float in the interval
219N/A0 <= <
var>rop</
var> < 1.
219N/AReturn 0, unless the exponent is not in the current exponent range, in
219N/Awhich case <
var>rop</
var> is set to NaN and a non-zero value is returned. The
219N/Asecond argument is a <
code>gmp_randstate_t</
code> structure which should be
219N/Acreated using the GMP <
code>gmp_randinit</
code> function, see the GMP manual.
219N/A— Function: void <
b>mpfr_random</
b> (<
var>mpfr_t rop</
var>)<
var><
a name="index-mpfr_005frandom-235"></
a></
var><
br>
219N/A<
blockquote><
p>Generate a uniformly distributed random float in the interval
219N/A0 <= <
var>rop</
var> < 1.
219N/AThis function is deprecated; <
code>mpfr_urandomb</
code> should be used instead.
219N/A— Function: void <
b>mpfr_random2</
b> (<
var>mpfr_t rop, mp_size_t size, mp_exp_t exp</
var>)<
var><
a name="index-mpfr_005frandom2-236"></
a></
var><
br>
219N/A<
blockquote><
p>Generate a random float of at most <
var>size</
var> limbs, with long strings of
219N/Azeros and ones in the binary representation. The exponent of the number is in
219N/Athe interval −<
var>exp</
var> to <
var>exp</
var>.
219N/AThis function is useful for
219N/Atesting functions and algorithms, since this kind of random numbers have
219N/Aproven to be more likely to trigger corner-case bugs.
219N/ANegative random numbers are generated when <
var>size</
var> is negative.
219N/APut +0 in <
var>rop</
var> when size if zero. The internal state of the default
219N/Apseudorandom number generator is modified by a call to this function (the
219N/Asame one as GMP if MPFR was built using ‘<
samp><
span class="samp">--with-gmp-build</
span></
samp>’).
219N/A— Function: mp_exp_t <
b>mpfr_get_exp</
b> (<
var>mpfr_t x</
var>)<
var><
a name="index-mpfr_005fget_005fexp-237"></
a></
var><
br>
219N/A<
blockquote><
p>Get the exponent of <
var>x</
var>, assuming that <
var>x</
var> is a non-zero ordinary
219N/Anumber and the significand is chosen in [1/2,1). The behavior for NaN,
219N/Ainfinity or zero is undefined.
219N/A— Function: int <
b>mpfr_set_exp</
b> (<
var>mpfr_t x, mp_exp_t e</
var>)<
var><
a name="index-mpfr_005fset_005fexp-238"></
a></
var><
br>
219N/A<
blockquote><
p>Set the exponent of <
var>x</
var> if <
var>e</
var> is in the current exponent range,
219N/Aand return 0 (even if <
var>x</
var> is not a non-zero ordinary number);
219N/Aotherwise, return a non-zero value.
219N/AThe significand is assumed to be in [1/2,1).
219N/A— Function: int <
b>mpfr_signbit</
b> (<
var>mpfr_t op</
var>)<
var><
a name="index-mpfr_005fsignbit-239"></
a></
var><
br>
219N/A<
blockquote><
p>Return a non-zero value iff <
var>op</
var> has its sign bit set (
i.e. if it is
219N/Anegative, −0, or a NaN whose representation has its sign bit set).
219N/A— Function: int <
b>mpfr_setsign</
b> (<
var>mpfr_t rop, mpfr_t op, int s, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fsetsign-240"></
a></
var><
br>
219N/A<
blockquote><
p>Set the value of <
var>rop</
var> from <
var>op</
var>, rounded toward the given
219N/Adirection <
var>rnd</
var>, then set (resp. clear) its sign bit if <
var>s</
var>
219N/Ais non-zero (resp. zero), even when <
var>op</
var> is a NaN.
219N/A— Function: int <
b>mpfr_copysign</
b> (<
var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fcopysign-241"></
a></
var><
br>
219N/A<
blockquote><
p>Set the value of <
var>rop</
var> from <
var>op1</
var>, rounded toward the given
219N/Adirection <
var>rnd</
var>, then set its sign bit to that of <
var>op2</
var> (even
219N/Awhen <
var>op1</
var> or <
var>op2</
var> is a NaN). This function is equivalent to
219N/A<
code>mpfr_setsign (</
code><
var>rop</
var><
code>, </
code><
var>op1</
var><
code>, mpfr_signbit (</
code><
var>op2</
var><
code>), </
code><
var>rnd</
var><
code>)</
code>.
219N/A<!-- By definition, a C string is always null-terminated, so that we --> 219N/A<!-- could just say "string" or "null-terminated character array", --> 219N/A<!-- but "null-terminated string" is not an error and probably better --> 219N/A<!-- for most users. --> 219N/A— Function: const char * <
b>mpfr_get_version</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fget_005fversion-242"></
a></
var><
br>
219N/A<
blockquote><
p>Return the MPFR version, as a null-terminated string.
219N/A— Macro: <
b>MPFR_VERSION</
b><
var><
a name="index-MPFR_005fVERSION-243"></
a></
var><
br>
219N/A— Macro: <
b>MPFR_VERSION_MAJOR</
b><
var><
a name="index-MPFR_005fVERSION_005fMAJOR-244"></
a></
var><
br>
219N/A— Macro: <
b>MPFR_VERSION_MINOR</
b><
var><
a name="index-MPFR_005fVERSION_005fMINOR-245"></
a></
var><
br>
219N/A— Macro: <
b>MPFR_VERSION_PATCHLEVEL</
b><
var><
a name="index-MPFR_005fVERSION_005fPATCHLEVEL-246"></
a></
var><
br>
219N/A— Macro: <
b>MPFR_VERSION_STRING</
b><
var><
a name="index-MPFR_005fVERSION_005fSTRING-247"></
a></
var><
br>
219N/A<
blockquote><
p><
code>MPFR_VERSION</
code> is the version of MPFR as a preprocessing constant.
219N/A<
code>MPFR_VERSION_MAJOR</
code>, <
code>MPFR_VERSION_MINOR</
code> and
219N/A<
code>MPFR_VERSION_PATCHLEVEL</
code> are respectively the major, minor and patch
219N/Alevel of MPFR version, as preprocessing constants.
219N/A<
code>MPFR_VERSION_STRING</
code> is the version (with an optional suffix, used
219N/Ain development and pre-release versions) as a string constant, which can
219N/Abe compared to the result of <
code>mpfr_get_version</
code> to check at run time
219N/Athe header file and library used match:
219N/A <
pre class="example"> if (strcmp (mpfr_get_version (), MPFR_VERSION_STRING))
219N/A fprintf (stderr, "Warning: header and library do not match\n");
219N/A <
p>Note: Obtaining different strings is not necessarily an error, as
219N/Ain general, a program compiled with some old MPFR version can be
219N/Adynamically linked with a newer MPFR library version (if allowed
219N/Aby the library versioning system).
219N/A— Macro: long <
b>MPFR_VERSION_NUM</
b> (<
var>major, minor, patchlevel</
var>)<
var><
a name="index-MPFR_005fVERSION_005fNUM-248"></
a></
var><
br>
219N/A<
blockquote><
p>Create an integer in the same format as used by <
code>MPFR_VERSION</
code> from the
219N/Agiven <
var>major</
var>, <
var>minor</
var> and <
var>patchlevel</
var>.
219N/AHere is an example of how to check the MPFR version at compile time:
219N/A <
pre class="example"> #if (!defined(MPFR_VERSION) || (MPFR_VERSION<MPFR_VERSION_NUM(2,1,0)))
219N/A # error "Wrong MPFR version."
219N/A— Function: const char * <
b>mpfr_get_patches</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fget_005fpatches-249"></
a></
var><
br>
219N/A<
blockquote><
p>Return a null-terminated string containing the ids of the patches applied to
219N/Athe MPFR library (contents of the <
samp><
span class="file">PATCHES</
span></
samp> file), separated by spaces.
219N/ANote: If the program has been compiled with an older MPFR version and is
219N/Adynamically linked with a new MPFR library version, the ids of the patches
219N/Aapplied to the old (compile-time) MPFR version are not available (however
219N/Athis information should not have much interest in general).
219N/A<
a name="Rounding-Mode-Related-Functions"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Exception-Related-Functions">Exception Related Functions</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Miscellaneous-Functions">Miscellaneous Functions</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</
a>
219N/A <
p><
a name="index-Rounding-mode-related-functions-250"></
a>
219N/A<
h3 class="section">5.11 Rounding Mode Related Functions</
h3>
219N/A— Function: void <
b>mpfr_set_default_rounding_mode</
b> (<
var>mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fset_005fdefault_005frounding_005fmode-251"></
a></
var><
br>
219N/A<
blockquote><
p>Set the default rounding mode to <
var>rnd</
var>.
219N/AThe default rounding mode is to nearest initially.
219N/A— Function: mp_rnd_t <
b>mpfr_get_default_rounding_mode</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fget_005fdefault_005frounding_005fmode-252"></
a></
var><
br>
219N/A<
blockquote><
p>Get the default rounding mode.
219N/A— Function: int <
b>mpfr_prec_round</
b> (<
var>mpfr_t x, mp_prec_t prec, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fprec_005fround-253"></
a></
var><
br>
219N/A<
blockquote><
p>Round <
var>x</
var> according to <
var>rnd</
var> with precision <
var>prec</
var>, which
219N/Amust be an integer between <
code>MPFR_PREC_MIN</
code> and <
code>MPFR_PREC_MAX</
code>
219N/A(otherwise the behavior is undefined).
219N/AIf <
var>prec</
var> is greater or equal to the precision of <
var>x</
var>, then new
219N/Aspace is allocated for the significand, and it is filled with zeros.
219N/AOtherwise, the significand is rounded to precision <
var>prec</
var> with the given
219N/Adirection. In both cases, the precision of <
var>x</
var> is changed to <
var>prec</
var>.
219N/A— Function: int <
b>mpfr_round_prec</
b> (<
var>mpfr_t x, mp_rnd_t rnd, mp_prec_t prec</
var>)<
var><
a name="index-mpfr_005fround_005fprec-254"></
a></
var><
br>
219N/A<
blockquote><
p>[This function is obsolete. Please use <
code>mpfr_prec_round</
code> instead.]
219N/A— Function: const char * <
b>mpfr_print_rnd_mode</
b> (<
var>mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fprint_005frnd_005fmode-255"></
a></
var><
br>
219N/A<
blockquote><
p>Return the input string (GMP_RNDD, GMP_RNDU, GMP_RNDN, GMP_RNDZ)
219N/Acorresponding to the rounding mode <
var>rnd</
var> or a null pointer if
219N/A<
var>rnd</
var> is an invalid rounding mode.
219N/A<
a name="Exception-Related-Functions"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Advanced-Functions">Advanced Functions</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Rounding-Mode-Related-Functions">Rounding Mode Related Functions</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A <
p><
a name="index-Exception-related-functions-256"></
a>
219N/A<
h3 class="section">5.12 Exception Related Functions</
h3>
219N/A— Function: mp_exp_t <
b>mpfr_get_emin</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fget_005femin-257"></
a></
var><
br>
219N/A— Function: mp_exp_t <
b>mpfr_get_emax</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fget_005femax-258"></
a></
var><
br>
219N/A<
blockquote><
p>Return the (current) smallest and largest exponents allowed for a
219N/Afloating-point variable. The smallest positive value of a floating-point
219N/Avariable is one half times 2 raised to the
219N/Asmallest exponent and the largest value has the form (1 - epsilon) times 2 raised to the largest exponent.
219N/A— Function: int <
b>mpfr_set_emin</
b> (<
var>mp_exp_t exp</
var>)<
var><
a name="index-mpfr_005fset_005femin-259"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_set_emax</
b> (<
var>mp_exp_t exp</
var>)<
var><
a name="index-mpfr_005fset_005femax-260"></
a></
var><
br>
219N/A<
blockquote><
p>Set the smallest and largest exponents allowed for a floating-point variable.
219N/AReturn a non-zero value when <
var>exp</
var> is not in the range accepted by the
219N/Aimplementation (in that case the smallest or largest exponent is not changed),
219N/AIf the user changes the exponent range, it is
her/
his responsibility to check
219N/Athat all current floating-point variables are in the new allowed range
219N/A(for example using <
code>mpfr_check_range</
code>), otherwise the subsequent
219N/Abehavior will be undefined, in the sense of the ISO C standard.
219N/A<!-- It is also her/his responsibility to check that @m {emin <= emax}. --> 219N/A— Function: mp_exp_t <
b>mpfr_get_emin_min</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fget_005femin_005fmin-261"></
a></
var><
br>
219N/A— Function: mp_exp_t <
b>mpfr_get_emin_max</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fget_005femin_005fmax-262"></
a></
var><
br>
219N/A— Function: mp_exp_t <
b>mpfr_get_emax_min</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fget_005femax_005fmin-263"></
a></
var><
br>
219N/A— Function: mp_exp_t <
b>mpfr_get_emax_max</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fget_005femax_005fmax-264"></
a></
var><
br>
219N/A<
blockquote><
p>Return the minimum and maximum of the smallest and largest exponents
219N/Aallowed for <
code>mpfr_set_emin</
code> and <
code>mpfr_set_emax</
code>. These values
219N/Aare implementation dependent; it is possible to create a non
219N/Aportable program by writing <
code>mpfr_set_emax(mpfr_get_emax_max())</
code>
219N/Aand <
code>mpfr_set_emin(mpfr_get_emin_min())</
code> since the values
219N/Aof the smallest and largest exponents become implementation dependent.
219N/A— Function: int <
b>mpfr_check_range</
b> (<
var>mpfr_t x, int t, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fcheck_005frange-265"></
a></
var><
br>
219N/A<
blockquote><
p>This function forces <
var>x</
var> to be in the current range of acceptable
219N/Avalues, <
var>t</
var> being the current ternary value: negative if <
var>x</
var>
219N/Ais smaller than the exact value, positive if <
var>x</
var> is larger than
219N/Athe exact value and zero if <
var>x</
var> is exact (before the call). It
219N/Agenerates an underflow or an overflow if the exponent of <
var>x</
var> is
219N/Aoutside the current allowed range; the value of <
var>t</
var> may be used
219N/Ato avoid a double rounding. This function returns zero if the rounded
219N/Aresult is equal to the exact one, a positive value if the rounded
219N/Aresult is larger than the exact one, a negative value if the rounded
219N/Aresult is smaller than the exact one. Note that unlike most functions,
219N/Athe result is compared to the exact one, not the input value <
var>x</
var>,
219N/A <
p>Note: If <
var>x</
var> is an infinity and <
var>t</
var> is different from zero (
i.e.,
219N/Aif the rounded result is an inexact infinity), then the overflow flag is
219N/Aset. This is useful because <
code>mpfr_check_range</
code> is typically called
219N/A(at least in MPFR functions) after restoring the flags that could have
219N/Abeen set due to internal computations.
219N/A— Function: int <
b>mpfr_subnormalize</
b> (<
var>mpfr_t x, int t, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fsubnormalize-266"></
a></
var><
br>
219N/A<
blockquote><
p>This function rounds <
var>x</
var> emulating subnormal number arithmetic:
219N/Aif <
var>x</
var> is outside the subnormal exponent range, it just propagates the
219N/Aternary value <
var>t</
var>; otherwise, it rounds <
var>x</
var> to precision
219N/A<
code>EXP(x)-emin+1</
code> according to rounding mode <
var>rnd</
var> and previous
219N/Aternary value <
var>t</
var>, avoiding double rounding problems.
219N/AMore precisely in the subnormal domain, denoting by <
var>e</
var> the value of
219N/A<
code>emin</
code>, <
var>x</
var> is rounded in fixed-point
219N/Aarithmetic to an integer multiple of two to the power
219N/A<
var>e</
var>−1; as a consequence, 1.5 multiplied by two to the power <
var>e</
var>−1 when <
var>t</
var> is zero
219N/Ais rounded to two to the power <
var>e</
var> with rounding to nearest.
219N/A <
p><
code>PREC(x)</
code> is not modified by this function.
219N/A<
var>rnd</
var> and <
var>t</
var> must be the used rounding mode for computing <
var>x</
var>
219N/Aand the returned ternary value when computing <
var>x</
var>.
219N/AThe subnormal exponent range is from <
code>emin</
code> to <
code>emin+PREC(x)-1</
code>.
219N/AIf the result cannot be represented in the current exponent range
219N/A(due to a too small <
code>emax</
code>), the behavior is undefined.
219N/ANote that unlike most functions, the result is compared to the exact one,
219N/Anot the input value <
var>x</
var>,
i.e. the ternary value is propagated.
219N/AThis is a preliminary interface.
219N/A <
p>This is an example of how to emulate double IEEE-754 arithmetic
219N/A mpfr_set_default_prec (53);
219N/A mpfr_init (xa); mpfr_init (xb);
219N/A b = 34.3; mpfr_set_d (xb, b, GMP_RNDN);
219N/A a = 0x1.1235P-1021; mpfr_set_d (xa, a, GMP_RNDN);
219N/A i = mpfr_div (xa, xa, xb, GMP_RNDN);
219N/A i = mpfr_subnormalize (xa, i, GMP_RNDN);
219N/A mpfr_clear (xa); mpfr_clear (xb);
219N/A <
p>Warning: this emulates a double IEEE-754 arithmetic with correct rounding
219N/Ain the subnormal range, which may not be the case for your hardware.
219N/A— Function: void <
b>mpfr_clear_underflow</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fclear_005funderflow-267"></
a></
var><
br>
219N/A— Function: void <
b>mpfr_clear_overflow</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fclear_005foverflow-268"></
a></
var><
br>
219N/A— Function: void <
b>mpfr_clear_nanflag</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fclear_005fnanflag-269"></
a></
var><
br>
219N/A— Function: void <
b>mpfr_clear_inexflag</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fclear_005finexflag-270"></
a></
var><
br>
219N/A— Function: void <
b>mpfr_clear_erangeflag</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fclear_005ferangeflag-271"></
a></
var><
br>
219N/A<
blockquote><
p>Clear the underflow, overflow, invalid, inexact and erange flags.
219N/A— Function: void <
b>mpfr_set_underflow</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fset_005funderflow-272"></
a></
var><
br>
219N/A— Function: void <
b>mpfr_set_overflow</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fset_005foverflow-273"></
a></
var><
br>
219N/A— Function: void <
b>mpfr_set_nanflag</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fset_005fnanflag-274"></
a></
var><
br>
219N/A— Function: void <
b>mpfr_set_inexflag</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fset_005finexflag-275"></
a></
var><
br>
219N/A— Function: void <
b>mpfr_set_erangeflag</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fset_005ferangeflag-276"></
a></
var><
br>
219N/A<
blockquote><
p>Set the underflow, overflow, invalid, inexact and erange flags.
219N/A— Function: void <
b>mpfr_clear_flags</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fclear_005fflags-277"></
a></
var><
br>
219N/A<
blockquote><
p>Clear all global flags (underflow, overflow, inexact, invalid, erange).
219N/A— Function: int <
b>mpfr_underflow_p</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005funderflow_005fp-278"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_overflow_p</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005foverflow_005fp-279"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_nanflag_p</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005fnanflag_005fp-280"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_inexflag_p</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005finexflag_005fp-281"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_erangeflag_p</
b> (<
var>void</
var>)<
var><
a name="index-mpfr_005ferangeflag_005fp-282"></
a></
var><
br>
219N/A<
blockquote><
p>Return the corresponding (underflow, overflow, invalid, inexact, erange)
219N/Aflag, which is non-zero iff the flag is set.
219N/A<
a name="Advanced-Functions"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Compatibility-with-MPF">Compatibility with MPF</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Exception-Related-Functions">Exception Related Functions</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A <
p><
a name="index-Advanced-functions-283"></
a>
219N/A<
h3 class="section">5.13 Advanced Functions</
h3>
219N/A<
p>All the given interfaces are preliminary. They might change incompatibly in
219N/A— Macro: <
b>MPFR_DECL_INIT</
b> (<
var>name, prec</
var>)<
var><
a name="index-MPFR_005fDECL_005fINIT-284"></
a></
var><
br>
219N/A<
blockquote><
p>This macro declares <
var>name</
var> as an automatic variable of type <
code>mpfr_t</
code>,
219N/Ainitializes it and sets its precision to be <
strong>exactly</
strong> <
var>prec</
var> bits
219N/Aand its value to NaN. <
var>name</
var> must be a valid identifier.
219N/AYou must use this macro in the declaration section.
219N/AThis macro is much faster than using <
code>mpfr_init2</
code> but has some
219N/A<
li>You <
strong>must not</
strong> call <
code>mpfr_clear</
code> with variables
219N/Acreated with this macro (The storage is allocated at the point of declaration
219N/Aand deallocated when the brace-level is exited.).
219N/A<
li>You <
strong>can not</
strong> change their precision.
219N/A<
li>You <
strong>should not</
strong> create variables with huge precision with this macro.
219N/A<
li>Your compiler must support ‘<
samp><
span class="samp">Non-Constant Initializers</
span></
samp>’ (standard
219N/Ain C++ and ISO C99) and ‘<
samp><
span class="samp">Token Pasting</
span></
samp>’
219N/A(standard in ISO C89). If <
var>prec</
var> is not a compiler constant, your compiler
219N/Amust support ‘<
samp><
span class="samp">Variable-length automatic arrays</
span></
samp>’ (standard in ISO C99).
219N/A‘<
samp><
span class="samp">GCC 2.95.3</
span></
samp>’ supports all these features. If you compile your program
219N/Awith gcc in c89 mode and with ‘<
samp><
span class="samp">-pedantic</
span></
samp>’, you may want to define the
219N/A<
code>MPFR_USE_EXTENSION</
code> macro to avoid warnings due to the
219N/A<
code>MPFR_DECL_INIT</
code> implementation.
219N/A </
p></
blockquote></
div>
219N/A— Function: void <
b>mpfr_inits</
b> (<
var>mpfr_t x, ...</
var>)<
var><
a name="index-mpfr_005finits-285"></
a></
var><
br>
219N/A<
blockquote><
p>Initialize all the <
code>mpfr_t</
code> variables of the given <
code>va_list</
code>,
219N/Aset their precision to be the default precision and their value to NaN.
219N/ASee <
code>mpfr_init</
code> for more details.
219N/AThe <
code>va_list</
code> is assumed to be composed only of type <
code>mpfr_t</
code>
219N/A(or equivalently <
code>mpfr_ptr</
code>).
219N/AIt begins from <
var>x</
var>. It ends when it encounters a null pointer (whose
219N/Atype must also be <
code>mpfr_ptr</
code>).
219N/A— Function: void <
b>mpfr_inits2</
b> (<
var>mp_prec_t prec, mpfr_t x, ...</
var>)<
var><
a name="index-mpfr_005finits2-286"></
a></
var><
br>
219N/A<
blockquote><
p>Initialize all the <
code>mpfr_t</
code> variables of the given <
code>va_list</
code>,
219N/Aset their precision to be <
strong>exactly</
strong>
219N/A<
var>prec</
var> bits and their value to NaN.
219N/ASee <
code>mpfr_init2</
code> for more details.
219N/AThe <
code>va_list</
code> is assumed to be composed only of type <
code>mpfr_t</
code>
219N/A(or equivalently <
code>mpfr_ptr</
code>).
219N/AIt begins from <
var>x</
var>. It ends when it encounters a null pointer (whose
219N/Atype must also be <
code>mpfr_ptr</
code>).
219N/A— Function: void <
b>mpfr_clears</
b> (<
var>mpfr_t x, ...</
var>)<
var><
a name="index-mpfr_005fclears-287"></
a></
var><
br>
219N/A<
blockquote><
p>Free the space occupied by all the <
code>mpfr_t</
code> variables of the given
219N/A<
code>va_list</
code>. See <
code>mpfr_clear</
code> for more details.
219N/AThe <
code>va_list</
code> is assumed to be composed only of type <
code>mpfr_t</
code>
219N/A(or equivalently <
code>mpfr_ptr</
code>).
219N/AIt begins from <
var>x</
var>. It ends when it encounters a null pointer (whose
219N/Atype must also be <
code>mpfr_ptr</
code>).
219N/A <
p>Here is an example of how to use multiple initialization functions:
219N/A mpfr_inits2 (256, x, y, z, t, (mpfr_ptr) 0);
219N/A mpfr_clears (x, y, z, t, (mpfr_ptr) 0);
219N/A<
a name="Compatibility-with-MPF"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Custom-Interface">Custom Interface</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Advanced-Functions">Advanced Functions</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</
a>
219N/A <
p><
a name="index-Compatibility-with-MPF-288"></
a>
219N/A<
h3 class="section">5.14 Compatibility With MPF</
h3>
219N/A<
p>A header file <
samp><
span class="file">
mpf2mpfr.h</
span></
samp> is included in the distribution of MPFR for
219N/Acompatibility with the GNU MP class MPF.
219N/AAfter inserting the following two lines after the <
code>#include <
gmp.h></
code>
219N/AMPF can be compiled directly with MPFR without any changes.
219N/AAll operations are then performed with the default MPFR rounding mode,
219N/Awhich can be reset with <
code>mpfr_set_default_rounding_mode</
code>.
219N/A <
p>Warning: the <
code>mpf_init</
code> and <
code>mpf_init2</
code> functions initialize
219N/Ato zero, whereas the corresponding MPFR functions initialize to NaN:
219N/Athis is useful to detect uninitialized values, but is slightly incompatible
219N/A— Function: void <
b>mpfr_set_prec_raw</
b> (<
var>mpfr_t x, mp_prec_t prec</
var>)<
var><
a name="index-mpfr_005fset_005fprec_005fraw-289"></
a></
var><
br>
219N/A<
blockquote><
p>Reset the precision of <
var>x</
var> to be <
strong>exactly</
strong> <
var>prec</
var> bits.
219N/AThe only difference with <
code>mpfr_set_prec</
code> is that <
var>prec</
var> is assumed to
219N/Abe small enough so that the significand fits into the current allocated memory
219N/Aspace for <
var>x</
var>. Otherwise the behavior is undefined.
219N/A— Function: int <
b>mpfr_eq</
b> (<
var>mpfr_t op1, mpfr_t op2, unsigned long int op3</
var>)<
var><
a name="index-mpfr_005feq-290"></
a></
var><
br>
219N/A<
blockquote><
p>Return non-zero if <
var>op1</
var> and <
var>op2</
var> are both non-zero ordinary
219N/Anumbers with the same exponent and the same first <
var>op3</
var> bits, both
219N/Azero, or both infinities of the same sign. Return zero otherwise. This
219N/Afunction is defined for compatibility with <
code>mpf</
code>. Do not use it if
219N/Ayou want to know whether two numbers are close to each other; for instance,
219N/A1.011111 and 1.100000 are regarded as different for any value of <
var>op3</
var>
219N/A— Function: void <
b>mpfr_reldiff</
b> (<
var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005freldiff-291"></
a></
var><
br>
219N/A<
blockquote><
p>Compute the relative difference between <
var>op1</
var> and <
var>op2</
var>
219N/Aand store the result in <
var>rop</
var>.
219N/AThis function does not guarantee the correct rounding on the relative
219N/Adifference; it just computes |<
var>op1</
var>-<
var>op2</
var>|/<
var>op1</
var>, using the
219N/Arounding mode <
var>rnd</
var> for all operations and the precision of <
var>rop</
var>.
219N/A— Function: int <
b>mpfr_mul_2exp</
b> (<
var>mpfr_t rop, mpfr_t op1, unsigned long int op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fmul_005f2exp-292"></
a></
var><
br>
219N/A— Function: int <
b>mpfr_div_2exp</
b> (<
var>mpfr_t rop, mpfr_t op1, unsigned long int op2, mp_rnd_t rnd</
var>)<
var><
a name="index-mpfr_005fdiv_005f2exp-293"></
a></
var><
br>
219N/A<
blockquote><
p>See <
code>mpfr_mul_2ui</
code> and <
code>mpfr_div_2ui</
code>. These functions are only kept
219N/Afor compatibility with MPF.
219N/A<
a name="Custom-Interface"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Internals">Internals</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Compatibility-with-MPF">Compatibility with MPF</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</
a>
219N/A <
p><
a name="index-Custom-interface-294"></
a>
219N/A<
h3 class="section">5.15 Custom Interface</
h3>
219N/A<
p>Some applications use a stack to handle the memory and their objects.
219N/AHowever, the MPFR memory design is not well suited for such a thing. So that
219N/Asuch applications are able to use MPFR, an auxiliary memory interface has
219N/Abeen created: the Custom Interface.
219N/A <
p>The following interface allows them to use MPFR in two ways:
219N/A<
li>Either they directly store the MPFR FP number as a <
code>mpfr_t</
code>
219N/A<
li>Either they store their own representation of a FP number on the
219N/Astack and construct a new temporary <
code>mpfr_t</
code> each time it is needed.
219N/A Nothing has to be done to destroy the FP numbers except garbaging the used
219N/Amemory: all the memory stuff (allocating, destroying, garbaging) is kept to
219N/A <
p>Each function in this interface is also implemented as a macro for
219N/Aefficiency reasons: for example <
code>mpfr_custom_init (s, p)</
code>
219N/Auses the macro, while <
code>(mpfr_custom_init) (s, p)</
code> uses the function.
219N/A <
p>Note 1: MPFR functions may still initialize temporary FP numbers
219N/Ausing standard mpfr_init. See Custom Allocation (GNU MP).
219N/A <
p>Note 2: MPFR functions may use the cached functions (mpfr_const_pi for
219N/Aexample), even if they are not explicitly called. You have to call
219N/A<
code>mpfr_free_cache</
code> each time you garbage the memory iff mpfr_init, through
219N/AGMP Custom Allocation, allocates its memory on the application stack.
219N/A <
p>Note 3: This interface is preliminary.
219N/A— Function: size_t <
b>mpfr_custom_get_size</
b> (<
var>mp_prec_t prec</
var>)<
var><
a name="index-mpfr_005fcustom_005fget_005fsize-295"></
a></
var><
br>
219N/A<
blockquote><
p>Return the needed size in bytes to store the significand of a FP number
219N/Aof precision <
var>prec</
var>.
219N/A— Function: void <
b>mpfr_custom_init</
b> (<
var>void *significand, mp_prec_t prec</
var>)<
var><
a name="index-mpfr_005fcustom_005finit-296"></
a></
var><
br>
219N/A<
blockquote><
p>Initialize a significand of precision <
var>prec</
var>.
219N/A<
var>significand</
var> must be an area of <
code>mpfr_custom_get_size (prec)</
code> bytes
219N/Aat least and be suitably aligned for an array of <
code>mp_limb_t</
code>.
219N/A— Function: void <
b>mpfr_custom_init_set</
b> (<
var>mpfr_t x, int kind, mp_exp_t exp, mp_prec_t prec, void *significand</
var>)<
var><
a name="index-mpfr_005fcustom_005finit_005fset-297"></
a></
var><
br>
219N/A<
blockquote><
p>Perform a dummy initialization of a <
code>mpfr_t</
code> and set it to:
219N/A<
li>if <
code>ABS(kind) == MPFR_NAN_KIND</
code>, <
var>x</
var> is set to NaN;
219N/A<
li>if <
code>ABS(kind) == MPFR_INF_KIND</
code>, <
var>x</
var> is set to the infinity
219N/Aof sign <
code>sign(kind)</
code>;
219N/A<
li>if <
code>ABS(kind) == MPFR_ZERO_KIND</
code>, <
var>x</
var> is set to the zero of
219N/Asign <
code>sign(kind)</
code>;
219N/A<
li>if <
code>ABS(kind) == MPFR_REGULAR_KIND</
code>, <
var>x</
var> is set to a regular
219N/Anumber: <
code>x = sign(kind)*significand*2^exp</
code>
219N/A In all cases, it uses <
var>significand</
var> directly for further computing
219N/Ainvolving <
var>x</
var>. It will not allocate anything.
219N/AA FP number initialized with this function cannot be resized using
219N/A<
code>mpfr_set_prec</
code>, or cleared using <
code>mpfr_clear</
code>!
219N/A<
var>significand</
var> must have been initialized with <
code>mpfr_custom_init</
code>
219N/Ausing the same precision <
var>prec</
var>.
219N/A— Function: int <
b>mpfr_custom_get_kind</
b> (<
var>mpfr_t x</
var>)<
var><
a name="index-mpfr_005fcustom_005fget_005fkind-298"></
a></
var><
br>
219N/A<
blockquote><
p>Return the current kind of a <
code>mpfr_t</
code> as used by
219N/A<
code>mpfr_custom_init_set</
code>.
219N/AThe behavior of this function for any <
code>mpfr_t</
code> not initialized
219N/Awith <
code>mpfr_custom_init_set</
code> is undefined.
219N/A— Function: void * <
b>mpfr_custom_get_mantissa</
b> (<
var>mpfr_t x</
var>)<
var><
a name="index-mpfr_005fcustom_005fget_005fmantissa-299"></
a></
var><
br>
219N/A<
blockquote><
p>Return a pointer to the significand used by a <
code>mpfr_t</
code> initialized with
219N/A<
code>mpfr_custom_init_set</
code>.
219N/AThe behavior of this function for any <
code>mpfr_t</
code> not initialized
219N/Awith <
code>mpfr_custom_init_set</
code> is undefined.
219N/A— Function: mp_exp_t <
b>mpfr_custom_get_exp</
b> (<
var>mpfr_t x</
var>)<
var><
a name="index-mpfr_005fcustom_005fget_005fexp-300"></
a></
var><
br>
219N/A<
blockquote><
p>Return the exponent of <
var>x</
var>, assuming that <
var>x</
var> is a non-zero ordinary
219N/Anumber. The return value for NaN, Infinity or Zero is unspecified but doesn't
219N/AThe behavior of this function for any <
code>mpfr_t</
code> not initialized
219N/Awith <
code>mpfr_custom_init_set</
code> is undefined.
219N/A— Function: void <
b>mpfr_custom_move</
b> (<
var>mpfr_t x, void *new_position</
var>)<
var><
a name="index-mpfr_005fcustom_005fmove-301"></
a></
var><
br>
219N/A<
blockquote><
p>Inform MPFR that the significand has moved due to a garbage collect
219N/Aand update its new position to <
code>new_position</
code>.
219N/AHowever the application has to move the significand and the <
code>mpfr_t</
code>
219N/AThe behavior of this function for any <
code>mpfr_t</
code> not initialized
219N/Awith <
code>mpfr_custom_init_set</
code> is undefined.
219N/A <
p>See the test suite for examples.
219N/A<
a name="Internals"></
a>
219N/APrevious: <
a rel="previous" accesskey="p" href="#Custom-Interface">Custom Interface</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</
a>
219N/A <
p><
a name="index-Internals-302"></
a>
219N/A<
h3 class="section">5.16 Internals</
h3>
219N/A<
p>The following types and
219N/Afunctions were mainly designed for the implementation of MPFR,
219N/Abut may be useful for users too.
219N/AHowever no upward compatibility is guaranteed.
219N/AYou may need to include <
samp><
span class="file">
mpfr-impl.h</
span></
samp> to use them.
219N/A <
p>The <
code>mpfr_t</
code> type consists of four fields.
219N/A<
li>The <
code>_mpfr_prec</
code> field is used to store the precision of
219N/Athe variable (in bits); this is not less than <
code>MPFR_PREC_MIN</
code>.
219N/A <
li>The <
code>_mpfr_sign</
code> field is used to store the sign of the variable.
219N/A <
li>The <
code>_mpfr_exp</
code> field stores the exponent.
219N/AAn exponent of 0 means a radix point just above the most significant
219N/Alimb. Non-zero values n are a multiplier 2^n relative to that
219N/AA NaN, an infinity and a zero are indicated by a special value of the exponent.
219N/A <
li>Finally, the <
code>_mpfr_d</
code> is a pointer to the limbs, least
219N/Asignificant limbs stored first.
219N/AThe number of limbs in use is controlled by <
code>_mpfr_prec</
code>, namely
219N/Aceil(<
code>_mpfr_prec</
code>/<
code>mp_bits_per_limb</
code>).
219N/ANon-singular values always have the most significant bit of the most
219N/Asignificant limb set to 1. When the precision does not correspond to a
219N/Awhole number of limbs, the excess bits at the low end of the data are zero.
219N/A<!-- @deftypefun int mpfr_add_one_ulp (mpfr_t @var{x}, mp_rnd_t @var{rnd}) --> 219N/A<!-- Add one unit in last place (ulp) to @var{x} if @var{x} is finite --> 219N/A<!-- and positive, subtract one ulp if @var{x} is finite and negative; --> 219N/A<!-- otherwise, @var{x} is not changed. --> 219N/A<!-- The return value is zero unless an overflow occurs, in which case the --> 219N/A<!-- @code{mpfr_add_one_ulp} function behaves like a conventional addition. --> 219N/A<!-- @end deftypefun --> 219N/A<!-- @deftypefun int mpfr_sub_one_ulp (mpfr_t @var{x}, mp_rnd_t @var{rnd}) --> 219N/A<!-- Subtract one ulp to @var{x} if @var{x} is finite and positive, add one --> 219N/A<!-- ulp if @var{x} is finite and negative; otherwise, @var{x} is not changed. --> 219N/A<!-- The return value is zero unless an underflow occurs, in which case the --> 219N/A<!-- @code{mpfr_sub_one_ulp} function behaves like a conventional subtraction. --> 219N/A<!-- @end deftypefun --> 219N/A— Function: int <
b>mpfr_can_round</
b> (<
var>mpfr_t b, mp_exp_t err, mp_rnd_t rnd1, mp_rnd_t rnd2, mp_prec_t prec</
var>)<
var><
a name="index-mpfr_005fcan_005fround-303"></
a></
var><
br>
219N/A<
blockquote><
p>Assuming <
var>b</
var> is an approximation of an unknown number
219N/A<
var>x</
var> in the direction <
var>rnd1</
var> with error at most two to the power
219N/AE(b)-<
var>err</
var> where E(b) is the exponent of <
var>b</
var>, return a non-zero
219N/Avalue if one is able to round correctly <
var>x</
var> to precision
219N/A<
var>prec</
var> with the direction <
var>rnd2</
var>,
219N/Aand 0 otherwise (including for NaN and Inf).
219N/AThis function <
strong>does not modify</
strong> its arguments.
219N/A <
p>Note: if one wants to also determine the correct ternary value when rounding
219N/A<
var>b</
var> to precision <
var>prec</
var>, a useful trick is the following:
219N/A if (mpfr_can_round (b, err, rnd1, GMP_RNDZ, prec + (rnd2 == GMP_RNDN)))
219N/AIndeed, if <
var>rnd2</
var> is <
code>GMP_RNDN</
code>, this will check if one can
219N/Around to <
var>prec</
var>+1 bits with a directed rounding:
219N/Aif so, one can surely round to nearest to <
var>prec</
var> bits,
219N/Aand in addition one can determine the correct ternary value, which would not
219N/Abe the case when <
var>b</
var> is near from a value exactly representable on
219N/A— Function: double <
b>mpfr_get_d1</
b> (<
var>mpfr_t op</
var>)<
var><
a name="index-mpfr_005fget_005fd1-304"></
a></
var><
br>
219N/A<
blockquote><
p>Convert <
var>op</
var> to a <
code>double</
code>, using the default MPFR rounding mode
219N/A(see function <
code>mpfr_set_default_rounding_mode</
code>). This function is
219N/A<!-- @deftypefun void mpfr_set_str_binary (mpfr_t @var{x}, const char *@var{s}) --> 219N/A<!-- Set @var{x} to the value of the binary number in string @var{s}, which has to --> 219N/A<!-- as the power of two to be multiplied by the significand. --> 219N/A<!-- The significand length of @var{s} has to be less or equal to the precision --> 219N/A<!-- of @var{x}, otherwise an error occurs. --> 219N/A<!-- If @var{s} starts with @code{N}, it is interpreted as NaN (Not-a-Number); --> 219N/A<!-- if it starts with @code{I} after the sign, it is interpreted as infinity, --> 219N/A<!-- with the corresponding sign. --> 219N/A<!-- @end deftypefun --> 219N/A<!-- @deftypefun void mpfr_print_binary (mpfr_t @var{float}) --> 219N/A<!-- Output @var{float} on stdout --> 219N/A<!-- in raw binary format (the exponent is written in decimal, yet). --> 219N/A<!-- @end deftypefun --> 219N/A<
a name="Contributors"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#References">References</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#MPFR-Interface">MPFR Interface</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#Top">Top</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A<
h2 class="unnumbered">Contributors</
h2>
219N/A<
p>The main developers of MPFR are Guillaume Hanrot, Vincent Lefèvre,
219N/APatrick Pélissier, Philippe Théveny and Paul Zimmermann.
219N/A <
p>Sylvie Boldo from ENS-Lyon, France,
219N/Acontributed the functions <
code>mpfr_agm</
code> and <
code>mpfr_log</
code>.
219N/AEmmanuel Jeandel, from ENS-Lyon too,
219N/Acontributed the generic hypergeometric code in
219N/Aa first implementation of the sine and cosine,
219N/Aand improved versions of
219N/A<
code>mpfr_const_log2</
code> and <
code>mpfr_const_pi</
code>.
219N/AMathieu Dutour contributed the functions <
code>mpfr_atan</
code> and <
code>mpfr_asin</
code>,
219N/Aand a previous version of <
code>mpfr_gamma</
code>;
219N/ADavid Daney contributed the hyperbolic and inverse hyperbolic functions,
219N/Athe base-2 exponential, and the factorial function. Fabrice Rouillier
219N/Acontributed the original version of <
samp><
span class="file">
mul_ui.c</
span></
samp>, the <
samp><
span class="file">
gmp_op.c</
span></
samp>
219N/Afile, and helped to the Microsoft Windows porting.
219N/AJean-Luc Rémy contributed the <
code>mpfr_zeta</
code> code.
219N/ALudovic Meunier helped in the design of the <
code>mpfr_erf</
code> code.
219N/ADamien Stehlé contributed the <
code>mpfr_get_ld_2exp</
code> function.
219N/A <
p>We would like to thank Jean-Michel Muller and Joris van der Hoeven for very
219N/Afruitful discussions at the beginning of that project, Torbjörn Granlund
219N/Aand Kevin Ryde for their help about design issues,
219N/Aand Nathalie Revol for her careful reading of a previous version of
219N/AKevin Ryde did a tremendous job for the portability of MPFR in 2002-2004.
219N/A <
p>The development of the MPFR library would not have been possible without
219N/Athe continuous support of INRIA, and of the LORIA (Nancy, France) and LIP
219N/A(Lyon, France) laboratories. In particular the main authors were or are
219N/Amembers of the PolKA, Spaces, Cacao project-teams at LORIA and of the
219N/AArenaire project-team at LIP.
219N/AThis project was started during the Fiable (reliable in French) action
219N/Asupported by INRIA, and continued during the AOC action.
219N/AThe development of MPFR was also supported by a grant
219N/A(202F0659 00 MPN 121) from the Conseil Régional de Lorraine in 2002,
219N/Aand from INRIA by an "associate engineer" grant (2003-2005)
219N/Aand an "opération de développement logiciel" grant (2007-2009).
219N/A<
a name="References"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#GNU-Free-Documentation-License">GNU Free Documentation License</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#Contributors">Contributors</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#Top">Top</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A<
h2 class="unnumbered">References</
h2>
219N/A<
li>Laurent Fousse, Guillaume Hanrot, Vincent Lefèvre,
219N/APatrick Pélissier and Paul Zimmermann,
219N/A"MPFR: A Multiple-Precision Binary Floating-Point Library With Correct Rounding",
219N/AACM Transactions on Mathematical Software,
219N/Avolume 33, issue 2, article 13, 15 pages, 2007,
219N/A <
li>Torbjörn Granlund, "GNU MP: The GNU Multiple Precision Arithmetic Library",
219N/A <
li>IEEE standard for binary floating-point arithmetic, Technical Report
219N/AANSI-IEEE Standard 754-1985, New York, 1985.
219N/AApproved March 21, 1985: IEEE Standards Board; approved July 26,
219N/A 1985: American National Standards Institute, 18 pages.
219N/A <
li>Donald E. Knuth, "The Art of Computer Programming", vol 2,
219N/A"Seminumerical Algorithms", 2nd edition, Addison-Wesley, 1981.
219N/A <
li>Jean-Michel Muller, "Elementary Functions, Algorithms and Implementation",
219N/ABirkhauser, Boston, 2nd edition, 2006.
219N/A<
a name="GNU-Free-Documentation-License"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Concept-Index">Concept Index</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#References">References</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#Top">Top</
a>
219N/A<
h2 class="appendix">Appendix A GNU Free Documentation License</
h2>
219N/A<
p><
a name="index-GNU-Free-Documentation-License-305"></
a>
219N/A<!-- @node GNU Free Documentation License --> 219N/A<!-- @appendixsec GNU Free Documentation License --> 219N/A <
p><
a name="index-FDL_002c-GNU-Free-Documentation-License-306"></
a><
div align="center">Version 1.2, November 2002</
div>
219N/A<
pre class="display"> Copyright © 2000,2001,2002 Free Software Foundation, Inc.
219N/A 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
219N/A Everyone is permitted to copy and distribute verbatim copies
219N/A of this license document, but changing it is not allowed.
219N/A <
p>The purpose of this License is to make a manual, textbook, or other
219N/Afunctional and useful document <
dfn>free</
dfn> in the sense of freedom: to
219N/Aassure everyone the effective freedom to copy and redistribute it,
219N/Awith or without modifying it, either commercially or noncommercially.
219N/ASecondarily, this License preserves for the author and publisher a way
219N/Ato get credit for their work, while not being considered responsible
219N/Afor modifications made by others.
219N/A <
p>This License is a kind of “copyleft”, which means that derivative
219N/Aworks of the document must themselves be free in the same sense. It
219N/Acomplements the GNU General Public License, which is a copyleft
219N/Alicense designed for free software.
219N/A <
p>We have designed this License in order to use it for manuals for free
219N/Asoftware, because free software needs free documentation: a free
219N/Aprogram should come with manuals providing the same freedoms that the
219N/Asoftware does. But this License is not limited to software manuals;
219N/Ait can be used for any textual work, regardless of subject matter or
219N/Awhether it is published as a printed book. We recommend this License
219N/Aprincipally for works whose purpose is instruction or reference.
219N/A <
li>APPLICABILITY AND DEFINITIONS
219N/A <
p>This License applies to any manual or other work, in any medium, that
219N/Acontains a notice placed by the copyright holder saying it can be
219N/Adistributed under the terms of this License. Such a notice grants a
219N/Aworld-wide, royalty-free license, unlimited in duration, to use that
219N/Awork under the conditions stated herein. The “Document”, below,
219N/Arefers to any such manual or work. Any member of the public is a
219N/Alicensee, and is addressed as “you”. You accept the license if you
219N/Acopy, modify or distribute the work in a way requiring permission
219N/A <
p>A “Modified Version” of the Document means any work containing the
219N/ADocument or a portion of it, either copied verbatim, or with
219N/Amodifications
and/
or translated into another language.
219N/A <
p>A “Secondary Section” is a named appendix or a front-matter section
219N/Aof the Document that deals exclusively with the relationship of the
219N/Apublishers or authors of the Document to the Document's overall
219N/Asubject (or to related matters) and contains nothing that could fall
219N/Adirectly within that overall subject. (Thus, if the Document is in
219N/Apart a textbook of mathematics, a Secondary Section may not explain
219N/Aany mathematics.) The relationship could be a matter of historical
219N/Aconnection with the subject or with related matters, or of legal,
219N/Acommercial, philosophical, ethical or political position regarding
219N/A <
p>The “Invariant Sections” are certain Secondary Sections whose titles
219N/Aare designated, as being those of Invariant Sections, in the notice
219N/Athat says that the Document is released under this License. If a
219N/Asection does not fit the above definition of Secondary then it is not
219N/Aallowed to be designated as Invariant. The Document may contain zero
219N/AInvariant Sections. If the Document does not identify any Invariant
219N/ASections then there are none.
219N/A <
p>The “Cover Texts” are certain short passages of text that are listed,
219N/Aas Front-Cover Texts or Back-Cover Texts, in the notice that says that
219N/Athe Document is released under this License. A Front-Cover Text may
219N/Abe at most 5 words, and a Back-Cover Text may be at most 25 words.
219N/A <
p>A “Transparent” copy of the Document means a machine-readable copy,
219N/Arepresented in a format whose specification is available to the
219N/Ageneral public, that is suitable for revising the document
219N/Astraightforwardly with generic text editors or (for images composed of
219N/Apixels) generic paint programs or (for drawings) some widely available
219N/Adrawing editor, and that is suitable for input to text formatters or
219N/Afor automatic translation to a variety of formats suitable for input
219N/Ato text formatters. A copy made in an otherwise Transparent file
219N/Aformat whose markup, or absence of markup, has been arranged to thwart
219N/Aor discourage subsequent modification by readers is not Transparent.
219N/AAn image format is not Transparent if used for any substantial amount
219N/Aof text. A copy that is not “Transparent” is called “Opaque”.
219N/A <
p>Examples of suitable formats for Transparent copies include plain
219N/A<
span class="sc">ascii</
span> without markup, Texinfo input format, LaTeX input
219N/Aformat, <
acronym>SGML</
acronym> or <
acronym>XML</
acronym> using a publicly available
219N/A<
acronym>DTD</
acronym>, and standard-conforming simple <
acronym>HTML</
acronym>,
219N/APostScript or <
acronym>PDF</
acronym> designed for human modification. Examples
219N/Aof transparent image formats include <
acronym>PNG</
acronym>, <
acronym>XCF</
acronym> and
219N/A<
acronym>JPG</
acronym>. Opaque formats include proprietary formats that can be
219N/Aread and edited only by proprietary word processors, <
acronym>SGML</
acronym> or
219N/A<
acronym>XML</
acronym> for which the <
acronym>DTD</
acronym>
and/
or processing tools are
219N/Anot generally available, and the machine-generated <
acronym>HTML</
acronym>,
219N/APostScript or <
acronym>PDF</
acronym> produced by some word processors for
219N/A <
p>The “Title Page” means, for a printed book, the title page itself,
219N/Aplus such following pages as are needed to hold, legibly, the material
219N/Athis License requires to appear in the title page. For works in
219N/Aformats which do not have any title page as such, “Title Page” means
219N/Athe text near the most prominent appearance of the work's title,
219N/Apreceding the beginning of the body of the text.
219N/A <
p>A section “Entitled XYZ” means a named subunit of the Document whose
219N/Atitle either is precisely XYZ or contains XYZ in parentheses following
219N/Atext that translates XYZ in another language. (Here XYZ stands for a
219N/Aspecific section name mentioned below, such as “Acknowledgements”,
219N/A“Dedications”, “Endorsements”, or “History”.) To “Preserve the Title”
219N/Aof such a section when you modify the Document means that it remains a
219N/Asection “Entitled XYZ” according to this definition.
219N/A <
p>The Document may include Warranty Disclaimers next to the notice which
219N/Astates that this License applies to the Document. These Warranty
219N/ADisclaimers are considered to be included by reference in this
219N/ALicense, but only as regards disclaiming warranties: any other
219N/Aimplication that these Warranty Disclaimers may have is void and has
219N/Ano effect on the meaning of this License.
219N/A <
p>You may copy and distribute the Document in any medium, either
219N/Acommercially or noncommercially, provided that this License, the
219N/Acopyright notices, and the license notice saying this License applies
219N/Ato the Document are reproduced in all copies, and that you add no other
219N/Aconditions whatsoever to those of this License. You may not use
219N/Atechnical measures to obstruct or control the reading or further
219N/Acopying of the copies you make or distribute. However, you may accept
219N/Acompensation in exchange for copies. If you distribute a large enough
219N/Anumber of copies you must also follow the conditions in section 3.
219N/A <
p>You may also lend copies, under the same conditions stated above, and
219N/Ayou may publicly display copies.
219N/A <
li>COPYING IN QUANTITY
219N/A <
p>If you publish printed copies (or copies in media that commonly have
219N/Aprinted covers) of the Document, numbering more than 100, and the
219N/ADocument's license notice requires Cover Texts, you must enclose the
219N/Acopies in covers that carry, clearly and legibly, all these Cover
219N/ATexts: Front-Cover Texts on the front cover, and Back-Cover Texts on
219N/Athe back cover. Both covers must also clearly and legibly identify
219N/Ayou as the publisher of these copies. The front cover must present
219N/Athe full title with all words of the title equally prominent and
219N/Avisible. You may add other material on the covers in addition.
219N/ACopying with changes limited to the covers, as long as they preserve
219N/Athe title of the Document and satisfy these conditions, can be treated
219N/Aas verbatim copying in other respects.
219N/A <
p>If the required texts for either cover are too voluminous to fit
219N/Alegibly, you should put the first ones listed (as many as fit
219N/Areasonably) on the actual cover, and continue the rest onto adjacent
219N/A <
p>If you publish or distribute Opaque copies of the Document numbering
219N/Amore than 100, you must either include a machine-readable Transparent
219N/Acopy along with each Opaque copy, or state in or with each Opaque copy
219N/Aa computer-network location from which the general network-using
219N/Apublic has access to download using public-standard network protocols
219N/Aa complete Transparent copy of the Document, free of added material.
219N/AIf you use the latter option, you must take reasonably prudent steps,
219N/Awhen you begin distribution of Opaque copies in quantity, to ensure
219N/Athat this Transparent copy will remain thus accessible at the stated
219N/Alocation until at least one year after the last time you distribute an
219N/AOpaque copy (directly or through your agents or retailers) of that
219N/A <
p>It is requested, but not required, that you contact the authors of the
219N/ADocument well before redistributing any large number of copies, to give
219N/Athem a chance to provide you with an updated version of the Document.
219N/A <
p>You may copy and distribute a Modified Version of the Document under
219N/Athe conditions of sections 2 and 3 above, provided that you release
219N/Athe Modified Version under precisely this License, with the Modified
219N/AVersion filling the role of the Document, thus licensing distribution
219N/Aand modification of the Modified Version to whoever possesses a copy
219N/Aof it. In addition, you must do these things in the Modified Version:
219N/A<
li>Use in the Title Page (and on the covers, if any) a title distinct
219N/Afrom that of the Document, and from those of previous versions
219N/A(which should, if there were any, be listed in the History section
219N/Aof the Document). You may use the same title as a previous version
219N/Aif the original publisher of that version gives permission.
219N/A <
li>List on the Title Page, as authors, one or more persons or entities
219N/Aresponsible for authorship of the modifications in the Modified
219N/AVersion, together with at least five of the principal authors of the
219N/ADocument (all of its principal authors, if it has fewer than five),
219N/Aunless they release you from this requirement.
219N/A <
li>State on the Title page the name of the publisher of the
219N/AModified Version, as the publisher.
219N/A <
li>Preserve all the copyright notices of the Document.
219N/A <
li>Add an appropriate copyright notice for your modifications
219N/Aadjacent to the other copyright notices.
219N/A <
li>Include, immediately after the copyright notices, a license notice
219N/Agiving the public permission to use the Modified Version under the
219N/Aterms of this License, in the form shown in the Addendum below.
219N/A <
li>Preserve in that license notice the full lists of Invariant Sections
219N/Aand required Cover Texts given in the Document's license notice.
219N/A <
li>Include an unaltered copy of this License.
219N/A <
li>Preserve the section Entitled “History”, Preserve its Title, and add
219N/Ato it an item stating at least the title, year, new authors, and
219N/Apublisher of the Modified Version as given on the Title Page. If
219N/Athere is no section Entitled “History” in the Document, create one
219N/Astating the title, year, authors, and publisher of the Document as
219N/Agiven on its Title Page, then add an item describing the Modified
219N/AVersion as stated in the previous sentence.
219N/A <
li>Preserve the network location, if any, given in the Document for
219N/Apublic access to a Transparent copy of the Document, and likewise
219N/Athe network locations given in the Document for previous versions
219N/Ait was based on. These may be placed in the “History” section.
219N/AYou may omit a network location for a work that was published at
219N/Aleast four years before the Document itself, or if the original
219N/Apublisher of the version it refers to gives permission.
219N/A <
li>For any section Entitled “Acknowledgements” or “Dedications”, Preserve
219N/Athe Title of the section, and preserve in the section all the
219N/Asubstance and tone of each of the contributor acknowledgements
and/
or 219N/Adedications given therein.
219N/A <
li>Preserve all the Invariant Sections of the Document,
219N/Aunaltered in their text and in their titles. Section numbers
219N/Aor the equivalent are not considered part of the section titles.
219N/A <
li>Delete any section Entitled “Endorsements”. Such a section
219N/Amay not be included in the Modified Version.
219N/A <
li>Do not retitle any existing section to be Entitled “Endorsements” or
219N/Ato conflict in title with any Invariant Section.
219N/A <
li>Preserve any Warranty Disclaimers.
219N/A <
p>If the Modified Version includes new front-matter sections or
219N/Aappendices that qualify as Secondary Sections and contain no material
219N/Acopied from the Document, you may at your option designate some or all
219N/Aof these sections as invariant. To do this, add their titles to the
219N/Alist of Invariant Sections in the Modified Version's license notice.
219N/AThese titles must be distinct from any other section titles.
219N/A <
p>You may add a section Entitled “Endorsements”, provided it contains
219N/Anothing but endorsements of your Modified Version by various
219N/Aparties—for example, statements of peer review or that the text has
219N/Abeen approved by an organization as the authoritative definition of a
219N/A <
p>You may add a passage of up to five words as a Front-Cover Text, and a
219N/Apassage of up to 25 words as a Back-Cover Text, to the end of the list
219N/Aof Cover Texts in the Modified Version. Only one passage of
219N/AFront-Cover Text and one of Back-Cover Text may be added by (or
219N/Athrough arrangements made by) any one entity. If the Document already
219N/Aincludes a cover text for the same cover, previously added by you or
219N/Aby arrangement made by the same entity you are acting on behalf of,
219N/Ayou may not add another; but you may replace the old one, on explicit
219N/Apermission from the previous publisher that added the old one.
219N/A <
p>The author(s) and publisher(s) of the Document do not by this License
219N/Agive permission to use their names for publicity for or to assert or
219N/Aimply endorsement of any Modified Version.
219N/A <
li>COMBINING DOCUMENTS
219N/A <
p>You may combine the Document with other documents released under this
219N/ALicense, under the terms defined in section 4 above for modified
219N/Aversions, provided that you include in the combination all of the
219N/AInvariant Sections of all of the original documents, unmodified, and
219N/Alist them all as Invariant Sections of your combined work in its
219N/Alicense notice, and that you preserve all their Warranty Disclaimers.
219N/A <
p>The combined work need only contain one copy of this License, and
219N/Amultiple identical Invariant Sections may be replaced with a single
219N/Acopy. If there are multiple Invariant Sections with the same name but
219N/Adifferent contents, make the title of each such section unique by
219N/Aadding at the end of it, in parentheses, the name of the original
219N/Aauthor or publisher of that section if known, or else a unique number.
219N/AMake the same adjustment to the section titles in the list of
219N/AInvariant Sections in the license notice of the combined work.
219N/A <
p>In the combination, you must combine any sections Entitled “History”
219N/Ain the various original documents, forming one section Entitled
219N/A“History”; likewise combine any sections Entitled “Acknowledgements”,
219N/Aand any sections Entitled “Dedications”. You must delete all
219N/Asections Entitled “Endorsements.”
219N/A <
li>COLLECTIONS OF DOCUMENTS
219N/A <
p>You may make a collection consisting of the Document and other documents
219N/Areleased under this License, and replace the individual copies of this
219N/ALicense in the various documents with a single copy that is included in
219N/Athe collection, provided that you follow the rules of this License for
219N/Averbatim copying of each of the documents in all other respects.
219N/A <
p>You may extract a single document from such a collection, and distribute
219N/Ait individually under this License, provided you insert a copy of this
219N/ALicense into the extracted document, and follow this License in all
219N/Aother respects regarding verbatim copying of that document.
219N/A <
li>AGGREGATION WITH INDEPENDENT WORKS
219N/A <
p>A compilation of the Document or its derivatives with other separate
219N/Aand independent documents or works, in or on a volume of a storage or
219N/Adistribution medium, is called an “aggregate” if the copyright
219N/Aresulting from the compilation is not used to limit the legal rights
219N/Aof the compilation's users beyond what the individual works permit.
219N/AWhen the Document is included in an aggregate, this License does not
219N/Aapply to the other works in the aggregate which are not themselves
219N/Aderivative works of the Document.
219N/A <
p>If the Cover Text requirement of section 3 is applicable to these
219N/Acopies of the Document, then if the Document is less than one half of
219N/Athe entire aggregate, the Document's Cover Texts may be placed on
219N/Acovers that bracket the Document within the aggregate, or the
219N/Aelectronic equivalent of covers if the Document is in electronic form.
219N/AOtherwise they must appear on printed covers that bracket the whole
219N/A <
p>Translation is considered a kind of modification, so you may
219N/Adistribute translations of the Document under the terms of section 4.
219N/AReplacing Invariant Sections with translations requires special
219N/Apermission from their copyright holders, but you may include
219N/Atranslations of some or all Invariant Sections in addition to the
219N/Aoriginal versions of these Invariant Sections. You may include a
219N/Atranslation of this License, and all the license notices in the
219N/ADocument, and any Warranty Disclaimers, provided that you also include
219N/Athe original English version of this License and the original versions
219N/Aof those notices and disclaimers. In case of a disagreement between
219N/Athe translation and the original version of this License or a notice
219N/Aor disclaimer, the original version will prevail.
219N/A <
p>If a section in the Document is Entitled “Acknowledgements”,
219N/A“Dedications”, or “History”, the requirement (section 4) to Preserve
219N/Aits Title (section 1) will typically require changing the actual
219N/A <
p>You may not copy, modify, sublicense, or distribute the Document except
219N/Aas expressly provided for under this License. Any other attempt to
219N/Acopy, modify, sublicense or distribute the Document is void, and will
219N/Aautomatically terminate your rights under this License. However,
219N/Aparties who have received copies, or rights, from you under this
219N/ALicense will not have their licenses terminated so long as such
219N/Aparties remain in full compliance.
219N/A <
li>FUTURE REVISIONS OF THIS LICENSE
219N/A <
p>The Free Software Foundation may publish new, revised versions
219N/Aof the GNU Free Documentation License from time to time. Such new
219N/Aversions will be similar in spirit to the present version, but may
219N/Adiffer in detail to address new problems or concerns. See
219N/A <
p>Each version of the License is given a distinguishing version number.
219N/AIf the Document specifies that a particular numbered version of this
219N/ALicense “or any later version” applies to it, you have the option of
219N/Afollowing the terms and conditions either of that specified version or
219N/Aof any later version that has been published (not as a draft) by the
219N/AFree Software Foundation. If the Document does not specify a version
219N/Anumber of this License, you may choose any version ever published (not
219N/Aas a draft) by the Free Software Foundation.
219N/A<!-- MPFR tweak: Use @appendixsec --> 219N/A<!-- @appendixsubsec ADDENDUM: How to use this License for your documents --> 219N/A<
h3 class="appendixsec">A.1 ADDENDUM: How to use this License for your documents</
h3>
219N/A<
p>To use this License in a document you have written, include a copy of
219N/Athe License in the document and put the following copyright and
219N/Alicense notices just after the title page:
219N/A<
pre class="smallexample"> Copyright (C) <
var>year</
var> <
var>your name</
var>.
219N/A Permission is granted to copy, distribute
and/
or modify this document
219N/A under the terms of the GNU Free Documentation License, Version 1.2
219N/A or any later version published by the Free Software Foundation;
219N/A with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
219N/A Texts. A copy of the license is included in the section entitled ``GNU
219N/A Free Documentation License''.
219N/A <
p>If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,
219N/A<
pre class="smallexample"> with the Invariant Sections being <
var>list their titles</
var>, with
219N/A the Front-Cover Texts being <
var>list</
var>, and with the Back-Cover Texts
219N/A <
p>If you have Invariant Sections without Cover Texts, or some other
219N/Acombination of the three, merge those two alternatives to suit the
219N/A <
p>If your document contains nontrivial examples of program code, we
219N/Arecommend releasing these examples in parallel under your choice of
219N/Afree software license, such as the GNU General Public License,
219N/Ato permit their use in free software.
219N/A<!-- Local Variables: --> 219N/A<!-- ispell-local-pdict: "ispell-dict" --> 219N/A<
a name="Concept-Index"></
a>
219N/ANext: <
a rel="next" accesskey="n" href="#Function-Index">Function Index</
a>,
219N/APrevious: <
a rel="previous" accesskey="p" href="#GNU-Free-Documentation-License">GNU Free Documentation License</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#Top">Top</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A<
h2 class="unnumbered">Concept Index</
h2>
219N/A<
ul class="index-cp" compact>
219N/A<
li><
a href="#index-Accuracy-21">Accuracy</
a>: <
a href="#MPFR-Interface">MPFR Interface</
a></
li>
219N/A<
li><
a href="#index-Advanced-functions-283">Advanced functions</
a>: <
a href="#Advanced-Functions">Advanced Functions</
a></
li>
219N/A<
li><
a href="#index-Arithmetic-functions-86">Arithmetic functions</
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-Assignment-functions-30">Assignment functions</
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-Basic-arithmetic-functions-84">Basic arithmetic functions</
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-Combined-initialization-and-assignment-functions-51">Combined initialization and assignment functions</
a>: <
a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-Comparison-functions-130">Comparison functions</
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-Compatibility-with-MPF-288">Compatibility with MPF</
a>: <
a href="#Compatibility-with-MPF">Compatibility with MPF</
a></
li>
219N/A<
li><
a href="#index-Conditions-for-copying-MPFR-2">Conditions for copying MPFR</
a>: <
a href="#Copying">Copying</
a></
li>
219N/A<
li><
a href="#index-Conversion-functions-61">Conversion functions</
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-Copying-conditions-1">Copying conditions</
a>: <
a href="#Copying">Copying</
a></
li>
219N/A<
li><
a href="#index-Custom-interface-294">Custom interface</
a>: <
a href="#Custom-Interface">Custom Interface</
a></
li>
219N/A<
li><
a href="#index-Exception-related-functions-256">Exception related functions</
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-FDL_002c-GNU-Free-Documentation-License-306">FDL, GNU Free Documentation License</
a>: <
a href="#GNU-Free-Documentation-License">GNU Free Documentation License</
a></
li>
219N/A<
li><
a href="#index-Float-arithmetic-functions-85">Float arithmetic functions</
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-Float-comparisons-functions-129">Float comparisons functions</
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-Float-functions-19">Float functions</
a>: <
a href="#MPFR-Interface">MPFR Interface</
a></
li>
219N/A<
li><
a href="#index-Float-input-and-output-functions-208">Float input and output functions</
a>: <
a href="#Input-and-Output-Functions">Input and Output Functions</
a></
li>
219N/A<
li><
a href="#index-Floating_002dpoint-functions-18">Floating-point functions</
a>: <
a href="#MPFR-Interface">MPFR Interface</
a></
li>
219N/A<
li><
a href="#index-Floating_002dpoint-number-11">Floating-point number</
a>: <
a href="#MPFR-Basics">MPFR Basics</
a></
li>
219N/A<
li><
a href="#index-GNU-Free-Documentation-License-305">GNU Free Documentation License</
a>: <
a href="#GNU-Free-Documentation-License">GNU Free Documentation License</
a></
li>
219N/A<
li><
a href="#index-I_002fO-functions-211">I/O functions</
a>: <
a href="#Input-and-Output-Functions">Input and Output Functions</
a></
li>
219N/A<
li><
a href="#index-Initialization-functions-22">Initialization functions</
a>: <
a href="#Initialization-Functions">Initialization Functions</
a></
li>
219N/A<
li><
a href="#index-Input-functions-209">Input functions</
a>: <
a href="#Input-and-Output-Functions">Input and Output Functions</
a></
li>
219N/A<
li><
a href="#index-Installation-3">Installation</
a>: <
a href="#Installing-MPFR">Installing MPFR</
a></
li>
219N/A<
li><
a href="#index-Integer-related-functions-214">Integer related functions</
a>: <
a href="#Integer-Related-Functions">Integer Related Functions</
a></
li>
219N/A<
li><
a href="#index-Internals-302">Internals</
a>: <
a href="#Internals">Internals</
a></
li>
219N/A<
li><
a href="#index-g_t_0040code_007blibmpfr_007d-9"><
code>libmpfr</
code></
a>: <
a href="#MPFR-Basics">MPFR Basics</
a></
li>
219N/A<
li><
a href="#index-Libraries-7">Libraries</
a>: <
a href="#MPFR-Basics">MPFR Basics</
a></
li>
219N/A<
li><
a href="#index-Libtool-10">Libtool</
a>: <
a href="#MPFR-Basics">MPFR Basics</
a></
li>
219N/A<
li><
a href="#index-Limb-17">Limb</
a>: <
a href="#MPFR-Basics">MPFR Basics</
a></
li>
219N/A<
li><
a href="#index-Linking-8">Linking</
a>: <
a href="#MPFR-Basics">MPFR Basics</
a></
li>
219N/A<
li><
a href="#index-Miscellaneous-float-functions-228">Miscellaneous float functions</
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-g_t_0040file_007bmpfr_002eh_007d-5"><
samp><
span class="file">
mpfr.h</
span></
samp></
a>: <
a href="#MPFR-Basics">MPFR Basics</
a></
li>
219N/A<
li><
a href="#index-Output-functions-210">Output functions</
a>: <
a href="#Input-and-Output-Functions">Input and Output Functions</
a></
li>
219N/A<
li><
a href="#index-Precision-20">Precision</
a>: <
a href="#MPFR-Interface">MPFR Interface</
a></
li>
219N/A<
li><
a href="#index-Precision-13">Precision</
a>: <
a href="#MPFR-Basics">MPFR Basics</
a></
li>
219N/A<
li><
a href="#index-Reporting-bugs-4">Reporting bugs</
a>: <
a href="#Reporting-Bugs">Reporting Bugs</
a></
li>
219N/A<
li><
a href="#index-Rounding-mode-related-functions-250">Rounding mode related functions</
a>: <
a href="#Rounding-Mode-Related-Functions">Rounding Mode Related Functions</
a></
li>
219N/A<
li><
a href="#index-Rounding-Modes-15">Rounding Modes</
a>: <
a href="#MPFR-Basics">MPFR Basics</
a></
li>
219N/A<
li><
a href="#index-Special-functions-154">Special functions</
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-g_t_0040code_007bstdio_002eh_007d-6"><
code>
stdio.h</
code></
a>: <
a href="#MPFR-Basics">MPFR Basics</
a></
li>
219N/A<
a name="Function-Index"></
a>
219N/APrevious: <
a rel="previous" accesskey="p" href="#Concept-Index">Concept Index</
a>,
219N/AUp: <
a rel="up" accesskey="u" href="#Top">Top</
a>
219N/A<!-- node-name, next, previous, up --> 219N/A<
h2 class="unnumbered">Function and Type Index</
h2>
219N/A<
ul class="index-fn" compact>
219N/A<
li><
a href="#index-g_t_0040code_007bmp_005fprec_005ft_007d-14"><
code>mp_prec_t</
code></
a>: <
a href="#MPFR-Basics">MPFR Basics</
a></
li>
219N/A<
li><
a href="#index-g_t_0040code_007bmp_005frnd_005ft_007d-16"><
code>mp_rnd_t</
code></
a>: <
a href="#MPFR-Basics">MPFR Basics</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fabs-123"><
code>mpfr_abs</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005facos-168"><
code>mpfr_acos</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005facosh-178"><
code>mpfr_acosh</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fadd-87"><
code>mpfr_add</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fadd_005fq-91"><
code>mpfr_add_q</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fadd_005fsi-89"><
code>mpfr_add_si</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fadd_005fui-88"><
code>mpfr_add_ui</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fadd_005fz-90"><
code>mpfr_add_z</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fagm-200"><
code>mpfr_agm</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fasin-169"><
code>mpfr_asin</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fasinh-179"><
code>mpfr_asinh</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fatan-170"><
code>mpfr_atan</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fatan2-171"><
code>mpfr_atan2</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fatanh-180"><
code>mpfr_atanh</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcan_005fround-303"><
code>mpfr_can_round</
code></
a>: <
a href="#Internals">Internals</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcbrt-114"><
code>mpfr_cbrt</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fceil-216"><
code>mpfr_ceil</
code></
a>: <
a href="#Integer-Related-Functions">Integer Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcheck_005frange-265"><
code>mpfr_check_range</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fclear-24"><
code>mpfr_clear</
code></
a>: <
a href="#Initialization-Functions">Initialization Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fclear_005ferangeflag-271"><
code>mpfr_clear_erangeflag</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fclear_005fflags-277"><
code>mpfr_clear_flags</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fclear_005finexflag-270"><
code>mpfr_clear_inexflag</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fclear_005fnanflag-269"><
code>mpfr_clear_nanflag</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fclear_005foverflow-268"><
code>mpfr_clear_overflow</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fclear_005funderflow-267"><
code>mpfr_clear_underflow</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fclears-287"><
code>mpfr_clears</
code></
a>: <
a href="#Advanced-Functions">Advanced Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcmp-131"><
code>mpfr_cmp</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcmp_005fd-134"><
code>mpfr_cmp_d</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcmp_005ff-138"><
code>mpfr_cmp_f</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcmp_005fld-135"><
code>mpfr_cmp_ld</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcmp_005fq-137"><
code>mpfr_cmp_q</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcmp_005fsi-133"><
code>mpfr_cmp_si</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcmp_005fsi_005f2exp-140"><
code>mpfr_cmp_si_2exp</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcmp_005fui-132"><
code>mpfr_cmp_ui</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcmp_005fui_005f2exp-139"><
code>mpfr_cmp_ui_2exp</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcmp_005fz-136"><
code>mpfr_cmp_z</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcmpabs-141"><
code>mpfr_cmpabs</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fconst_005fcatalan-205"><
code>mpfr_const_catalan</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fconst_005feuler-204"><
code>mpfr_const_euler</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fconst_005flog2-202"><
code>mpfr_const_log2</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fconst_005fpi-203"><
code>mpfr_const_pi</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcopysign-241"><
code>mpfr_copysign</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcos-161"><
code>mpfr_cos</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcosh-172"><
code>mpfr_cosh</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcot-166"><
code>mpfr_cot</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcoth-177"><
code>mpfr_coth</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcsc-165"><
code>mpfr_csc</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcsch-176"><
code>mpfr_csch</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcustom_005fget_005fexp-300"><
code>mpfr_custom_get_exp</
code></
a>: <
a href="#Custom-Interface">Custom Interface</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcustom_005fget_005fkind-298"><
code>mpfr_custom_get_kind</
code></
a>: <
a href="#Custom-Interface">Custom Interface</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcustom_005fget_005fmantissa-299"><
code>mpfr_custom_get_mantissa</
code></
a>: <
a href="#Custom-Interface">Custom Interface</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcustom_005fget_005fsize-295"><
code>mpfr_custom_get_size</
code></
a>: <
a href="#Custom-Interface">Custom Interface</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcustom_005finit-296"><
code>mpfr_custom_init</
code></
a>: <
a href="#Custom-Interface">Custom Interface</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcustom_005finit_005fset-297"><
code>mpfr_custom_init_set</
code></
a>: <
a href="#Custom-Interface">Custom Interface</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fcustom_005fmove-301"><
code>mpfr_custom_move</
code></
a>: <
a href="#Custom-Interface">Custom Interface</
a></
li>
219N/A<
li><
a href="#index-MPFR_005fDECL_005fINIT-284"><
code>MPFR_DECL_INIT</
code></
a>: <
a href="#Advanced-Functions">Advanced Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fdim-124"><
code>mpfr_dim</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fdiv-105"><
code>mpfr_div</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fdiv_005f2exp-293"><
code>mpfr_div_2exp</
code></
a>: <
a href="#Compatibility-with-MPF">Compatibility with MPF</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fdiv_005f2si-128"><
code>mpfr_div_2si</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fdiv_005f2ui-127"><
code>mpfr_div_2ui</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fdiv_005fq-111"><
code>mpfr_div_q</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fdiv_005fsi-109"><
code>mpfr_div_si</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fdiv_005fui-107"><
code>mpfr_div_ui</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fdiv_005fz-110"><
code>mpfr_div_z</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005feint-184"><
code>mpfr_eint</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005feq-290"><
code>mpfr_eq</
code></
a>: <
a href="#Compatibility-with-MPF">Compatibility with MPF</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fequal_005fp-152"><
code>mpfr_equal_p</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ferangeflag_005fp-282"><
code>mpfr_erangeflag_p</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ferf-190"><
code>mpfr_erf</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ferfc-191"><
code>mpfr_erfc</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fexp-158"><
code>mpfr_exp</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fexp10-160"><
code>mpfr_exp10</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fexp2-159"><
code>mpfr_exp2</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fexpm1-183"><
code>mpfr_expm1</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ffac_005fui-181"><
code>mpfr_fac_ui</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ffits_005fintmax_005fp-82"><
code>mpfr_fits_intmax_p</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ffits_005fsint_005fp-79"><
code>mpfr_fits_sint_p</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ffits_005fslong_005fp-77"><
code>mpfr_fits_slong_p</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ffits_005fsshort_005fp-81"><
code>mpfr_fits_sshort_p</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ffits_005fuint_005fp-78"><
code>mpfr_fits_uint_p</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ffits_005fuintmax_005fp-83"><
code>mpfr_fits_uintmax_p</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ffits_005fulong_005fp-76"><
code>mpfr_fits_ulong_p</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ffits_005fushort_005fp-80"><
code>mpfr_fits_ushort_p</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ffloor-217"><
code>mpfr_floor</
code></
a>: <
a href="#Integer-Related-Functions">Integer Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ffma-198"><
code>mpfr_fma</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ffms-199"><
code>mpfr_fms</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ffrac-224"><
code>mpfr_frac</
code></
a>: <
a href="#Integer-Related-Functions">Integer Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ffree_005fcache-206"><
code>mpfr_free_cache</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ffree_005fstr-75"><
code>mpfr_free_str</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fgamma-185"><
code>mpfr_gamma</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fd-62"><
code>mpfr_get_d</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fd1-304"><
code>mpfr_get_d1</
code></
a>: <
a href="#Internals">Internals</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fd_005f2exp-65"><
code>mpfr_get_d_2exp</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fdecimal64-64"><
code>mpfr_get_decimal64</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fdefault_005fprec-27"><
code>mpfr_get_default_prec</
code></
a>: <
a href="#Initialization-Functions">Initialization Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fdefault_005frounding_005fmode-252"><
code>mpfr_get_default_rounding_mode</
code></
a>: <
a href="#Rounding-Mode-Related-Functions">Rounding Mode Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005femax-258"><
code>mpfr_get_emax</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005femax_005fmax-264"><
code>mpfr_get_emax_max</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005femax_005fmin-263"><
code>mpfr_get_emax_min</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005femin-257"><
code>mpfr_get_emin</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005femin_005fmax-262"><
code>mpfr_get_emin_max</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005femin_005fmin-261"><
code>mpfr_get_emin_min</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fexp-237"><
code>mpfr_get_exp</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005ff-73"><
code>mpfr_get_f</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fld-63"><
code>mpfr_get_ld</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fld_005f2exp-66"><
code>mpfr_get_ld_2exp</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fpatches-249"><
code>mpfr_get_patches</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fprec-29"><
code>mpfr_get_prec</
code></
a>: <
a href="#Initialization-Functions">Initialization Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fsi-67"><
code>mpfr_get_si</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fsj-69"><
code>mpfr_get_sj</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fstr-74"><
code>mpfr_get_str</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fui-68"><
code>mpfr_get_ui</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fuj-70"><
code>mpfr_get_uj</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fversion-242"><
code>mpfr_get_version</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fz-72"><
code>mpfr_get_z</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fget_005fz_005fexp-71"><
code>mpfr_get_z_exp</
code></
a>: <
a href="#Conversion-Functions">Conversion Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fgreater_005fp-147"><
code>mpfr_greater_p</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fgreaterequal_005fp-148"><
code>mpfr_greaterequal_p</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fhypot-201"><
code>mpfr_hypot</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005finexflag_005fp-281"><
code>mpfr_inexflag_p</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005finf_005fp-143"><
code>mpfr_inf_p</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005finit-25"><
code>mpfr_init</
code></
a>: <
a href="#Initialization-Functions">Initialization Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005finit2-23"><
code>mpfr_init2</
code></
a>: <
a href="#Initialization-Functions">Initialization Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005finit_005fset-52"><
code>mpfr_init_set</
code></
a>: <
a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005finit_005fset_005fd-55"><
code>mpfr_init_set_d</
code></
a>: <
a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005finit_005fset_005ff-59"><
code>mpfr_init_set_f</
code></
a>: <
a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005finit_005fset_005fld-56"><
code>mpfr_init_set_ld</
code></
a>: <
a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005finit_005fset_005fq-58"><
code>mpfr_init_set_q</
code></
a>: <
a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005finit_005fset_005fsi-54"><
code>mpfr_init_set_si</
code></
a>: <
a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005finit_005fset_005fstr-60"><
code>mpfr_init_set_str</
code></
a>: <
a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005finit_005fset_005fui-53"><
code>mpfr_init_set_ui</
code></
a>: <
a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005finit_005fset_005fz-57"><
code>mpfr_init_set_z</
code></
a>: <
a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005finits-285"><
code>mpfr_inits</
code></
a>: <
a href="#Advanced-Functions">Advanced Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005finits2-286"><
code>mpfr_inits2</
code></
a>: <
a href="#Advanced-Functions">Advanced Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005finp_005fstr-213"><
code>mpfr_inp_str</
code></
a>: <
a href="#Input-and-Output-Functions">Input and Output Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005finteger_005fp-227"><
code>mpfr_integer_p</
code></
a>: <
a href="#Integer-Related-Functions">Integer Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fj0-192"><
code>mpfr_j0</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fj1-193"><
code>mpfr_j1</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fjn-194"><
code>mpfr_jn</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fless_005fp-149"><
code>mpfr_less_p</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005flessequal_005fp-150"><
code>mpfr_lessequal_p</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005flessgreater_005fp-151"><
code>mpfr_lessgreater_p</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005flgamma-187"><
code>mpfr_lgamma</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005flngamma-186"><
code>mpfr_lngamma</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005flog-155"><
code>mpfr_log</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005flog10-157"><
code>mpfr_log10</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005flog1p-182"><
code>mpfr_log1p</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005flog2-156"><
code>mpfr_log2</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fmax-233"><
code>mpfr_max</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fmin-232"><
code>mpfr_min</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fmul-99"><
code>mpfr_mul</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fmul_005f2exp-292"><
code>mpfr_mul_2exp</
code></
a>: <
a href="#Compatibility-with-MPF">Compatibility with MPF</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fmul_005f2si-126"><
code>mpfr_mul_2si</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fmul_005f2ui-125"><
code>mpfr_mul_2ui</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fmul_005fq-103"><
code>mpfr_mul_q</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fmul_005fsi-101"><
code>mpfr_mul_si</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fmul_005fui-100"><
code>mpfr_mul_ui</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fmul_005fz-102"><
code>mpfr_mul_z</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fnan_005fp-142"><
code>mpfr_nan_p</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fnanflag_005fp-280"><
code>mpfr_nanflag_p</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fneg-122"><
code>mpfr_neg</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fnextabove-230"><
code>mpfr_nextabove</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fnextbelow-231"><
code>mpfr_nextbelow</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fnexttoward-229"><
code>mpfr_nexttoward</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fnumber_005fp-144"><
code>mpfr_number_p</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fout_005fstr-212"><
code>mpfr_out_str</
code></
a>: <
a href="#Input-and-Output-Functions">Input and Output Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005foverflow_005fp-279"><
code>mpfr_overflow_p</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fpow-116"><
code>mpfr_pow</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fpow_005fsi-118"><
code>mpfr_pow_si</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fpow_005fui-117"><
code>mpfr_pow_ui</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fpow_005fz-119"><
code>mpfr_pow_z</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fprec_005fround-253"><
code>mpfr_prec_round</
code></
a>: <
a href="#Rounding-Mode-Related-Functions">Rounding Mode Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fprint_005frnd_005fmode-255"><
code>mpfr_print_rnd_mode</
code></
a>: <
a href="#Rounding-Mode-Related-Functions">Rounding Mode Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005frandom-235"><
code>mpfr_random</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005frandom2-236"><
code>mpfr_random2</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005freldiff-291"><
code>mpfr_reldiff</
code></
a>: <
a href="#Compatibility-with-MPF">Compatibility with MPF</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fremainder-225"><
code>mpfr_remainder</
code></
a>: <
a href="#Integer-Related-Functions">Integer Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fremquo-226"><
code>mpfr_remquo</
code></
a>: <
a href="#Integer-Related-Functions">Integer Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005frint-215"><
code>mpfr_rint</
code></
a>: <
a href="#Integer-Related-Functions">Integer Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005frint_005fceil-220"><
code>mpfr_rint_ceil</
code></
a>: <
a href="#Integer-Related-Functions">Integer Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005frint_005ffloor-221"><
code>mpfr_rint_floor</
code></
a>: <
a href="#Integer-Related-Functions">Integer Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005frint_005fround-222"><
code>mpfr_rint_round</
code></
a>: <
a href="#Integer-Related-Functions">Integer Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005frint_005ftrunc-223"><
code>mpfr_rint_trunc</
code></
a>: <
a href="#Integer-Related-Functions">Integer Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005froot-115"><
code>mpfr_root</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fround-218"><
code>mpfr_round</
code></
a>: <
a href="#Integer-Related-Functions">Integer Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fround_005fprec-254"><
code>mpfr_round_prec</
code></
a>: <
a href="#Rounding-Mode-Related-Functions">Rounding Mode Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsec-164"><
code>mpfr_sec</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsech-175"><
code>mpfr_sech</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset-31"><
code>mpfr_set</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fd-36"><
code>mpfr_set_d</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fdecimal64-38"><
code>mpfr_set_decimal64</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fdefault_005fprec-26"><
code>mpfr_set_default_prec</
code></
a>: <
a href="#Initialization-Functions">Initialization Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fdefault_005frounding_005fmode-251"><
code>mpfr_set_default_rounding_mode</
code></
a>: <
a href="#Rounding-Mode-Related-Functions">Rounding Mode Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005femax-260"><
code>mpfr_set_emax</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005femin-259"><
code>mpfr_set_emin</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005ferangeflag-276"><
code>mpfr_set_erangeflag</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fexp-238"><
code>mpfr_set_exp</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005ff-41"><
code>mpfr_set_f</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005finexflag-275"><
code>mpfr_set_inexflag</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005finf-48"><
code>mpfr_set_inf</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fld-37"><
code>mpfr_set_ld</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fnan-49"><
code>mpfr_set_nan</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fnanflag-274"><
code>mpfr_set_nanflag</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005foverflow-273"><
code>mpfr_set_overflow</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fprec-28"><
code>mpfr_set_prec</
code></
a>: <
a href="#Initialization-Functions">Initialization Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fprec_005fraw-289"><
code>mpfr_set_prec_raw</
code></
a>: <
a href="#Compatibility-with-MPF">Compatibility with MPF</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fq-40"><
code>mpfr_set_q</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fsi-33"><
code>mpfr_set_si</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fsi_005f2exp-43"><
code>mpfr_set_si_2exp</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fsj-35"><
code>mpfr_set_sj</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fsj_005f2exp-45"><
code>mpfr_set_sj_2exp</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fstr-46"><
code>mpfr_set_str</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fui-32"><
code>mpfr_set_ui</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fui_005f2exp-42"><
code>mpfr_set_ui_2exp</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fuj-34"><
code>mpfr_set_uj</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fuj_005f2exp-44"><
code>mpfr_set_uj_2exp</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005funderflow-272"><
code>mpfr_set_underflow</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fset_005fz-39"><
code>mpfr_set_z</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsetsign-240"><
code>mpfr_setsign</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsgn-146"><
code>mpfr_sgn</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsi_005fdiv-108"><
code>mpfr_si_div</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsi_005fsub-95"><
code>mpfr_si_sub</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsignbit-239"><
code>mpfr_signbit</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsin-162"><
code>mpfr_sin</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsin_005fcos-167"><
code>mpfr_sin_cos</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsinh-173"><
code>mpfr_sinh</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsqr-104"><
code>mpfr_sqr</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsqrt-112"><
code>mpfr_sqrt</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsqrt_005fui-113"><
code>mpfr_sqrt_ui</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fstrtofr-47"><
code>mpfr_strtofr</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsub-92"><
code>mpfr_sub</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsub_005fq-98"><
code>mpfr_sub_q</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsub_005fsi-96"><
code>mpfr_sub_si</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsub_005fui-94"><
code>mpfr_sub_ui</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsub_005fz-97"><
code>mpfr_sub_z</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsubnormalize-266"><
code>mpfr_subnormalize</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fsum-207"><
code>mpfr_sum</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fswap-50"><
code>mpfr_swap</
code></
a>: <
a href="#Assignment-Functions">Assignment Functions</
a></
li>
219N/A<
li><
a href="#index-g_t_0040code_007bmpfr_005ft_007d-12"><
code>mpfr_t</
code></
a>: <
a href="#MPFR-Basics">MPFR Basics</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ftan-163"><
code>mpfr_tan</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ftanh-174"><
code>mpfr_tanh</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005ftrunc-219"><
code>mpfr_trunc</
code></
a>: <
a href="#Integer-Related-Functions">Integer Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fui_005fdiv-106"><
code>mpfr_ui_div</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fui_005fpow-121"><
code>mpfr_ui_pow</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fui_005fpow_005fui-120"><
code>mpfr_ui_pow_ui</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fui_005fsub-93"><
code>mpfr_ui_sub</
code></
a>: <
a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005funderflow_005fp-278"><
code>mpfr_underflow_p</
code></
a>: <
a href="#Exception-Related-Functions">Exception Related Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005funordered_005fp-153"><
code>mpfr_unordered_p</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005furandomb-234"><
code>mpfr_urandomb</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-MPFR_005fVERSION-243"><
code>MPFR_VERSION</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-MPFR_005fVERSION_005fMAJOR-244"><
code>MPFR_VERSION_MAJOR</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-MPFR_005fVERSION_005fMINOR-245"><
code>MPFR_VERSION_MINOR</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-MPFR_005fVERSION_005fNUM-248"><
code>MPFR_VERSION_NUM</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-MPFR_005fVERSION_005fPATCHLEVEL-246"><
code>MPFR_VERSION_PATCHLEVEL</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-MPFR_005fVERSION_005fSTRING-247"><
code>MPFR_VERSION_STRING</
code></
a>: <
a href="#Miscellaneous-Functions">Miscellaneous Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fy0-195"><
code>mpfr_y0</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fy1-196"><
code>mpfr_y1</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fyn-197"><
code>mpfr_yn</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fzero_005fp-145"><
code>mpfr_zero_p</
code></
a>: <
a href="#Comparison-Functions">Comparison Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fzeta-188"><
code>mpfr_zeta</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>
219N/A<
li><
a href="#index-mpfr_005fzeta_005fui-189"><
code>mpfr_zeta_ui</
code></
a>: <
a href="#Special-Functions">Special Functions</
a></
li>