[BACK]Return to mpfr.info CVS log [TXT][DIR] Up to [local] / OpenXM_contrib / gmp / mpfr

Annotation of OpenXM_contrib/gmp/mpfr/mpfr.info, Revision 1.1

1.1     ! ohara       1: This is mpfr.info, produced by makeinfo version 4.2 from mpfr.texi.
        !             2:
        !             3: START-INFO-DIR-ENTRY
        !             4: * mpfr: (mpfr.info).               Multiple Precision Floating-Point Reliable Library.
        !             5: END-INFO-DIR-ENTRY
        !             6:
        !             7:    This file documents MPFR, a library for reliable multiple precision
        !             8: floating-point arithmetic
        !             9:
        !            10:    Copyright (C) 1999-2002, Free Software Foundation.
        !            11:
        !            12:    Permission is granted to make and distribute verbatim copies of this
        !            13: manual provided the copyright notice and this permission notice are
        !            14: preserved on all copies.
        !            15:
        !            16:    Permission is granted to copy and distribute modified versions of
        !            17: this manual under the conditions for verbatim copying, provided that
        !            18: the entire resulting derived work is distributed under the terms of a
        !            19: permission notice identical to this one.
        !            20:
        !            21:    Permission is granted to copy and distribute translations of this
        !            22: manual into another language, under the above conditions for modified
        !            23: versions, except that this permission notice may be stated in a
        !            24: translation approved by the Foundation.
        !            25:
        !            26: 
        !            27: File: mpfr.info,  Node: Top,  Next: Copying,  Prev: (dir),  Up: (dir)
        !            28:
        !            29: MPFR
        !            30: ****
        !            31:
        !            32:    This manual documents how to install and use the Multiple Precision
        !            33: Floating-Point Reliable Library, version 2.0.1
        !            34:
        !            35: * Menu:
        !            36:
        !            37: * Copying::                   GMP Copying Conditions (LGPL).
        !            38: * Introduction to MPFR::      Brief introduction to MPFR.
        !            39: * Installing MPFR::           How to configure and compile the MPFR library.
        !            40: * MPFR Basics::               What every MPFR user should now.
        !            41: * Reporting Bugs::            How to usefully report bugs.
        !            42: * Floating-point Functions::  Functions for arithmetic on floats.
        !            43:
        !            44: * Contributors::
        !            45: * References::
        !            46: * Concept Index::
        !            47: * Function Index::
        !            48:
        !            49: 
        !            50: File: mpfr.info,  Node: Copying,  Next: Introduction to MPFR,  Prev: Top,  Up: Top
        !            51:
        !            52: MPFR Copying Conditions
        !            53: ***********************
        !            54:
        !            55:    This library is "free"; this means that everyone is free to use it
        !            56: and free to redistribute it on a free basis.  The library is not in the
        !            57: public domain; it is copyrighted and there are restrictions on its
        !            58: distribution, but these restrictions are designed to permit everything
        !            59: that a good cooperating citizen would want to do.  What is not allowed
        !            60: is to try to prevent others from further sharing any version of this
        !            61: library that they might get from you.
        !            62:
        !            63:    Specifically, we want to make sure that you have the right to give
        !            64: away copies of the library, that you receive source code or else can
        !            65: get it if you want it, that you can change this library or use pieces
        !            66: of it in new free programs, and that you know you can do these things.
        !            67:
        !            68:    To make sure that everyone has such rights, we have to forbid you to
        !            69: deprive anyone else of these rights.  For example, if you distribute
        !            70: copies of the MPFR library, you must give the recipients all the rights
        !            71: that you have.  You must make sure that they, too, receive or can get
        !            72: the source code.  And you must tell them their rights.
        !            73:
        !            74:    Also, for our own protection, we must make certain that everyone
        !            75: finds out that there is no warranty for the MPFR library.  If it is
        !            76: modified by someone else and passed on, we want their recipients to
        !            77: know that what they have is not what we distributed, so that any
        !            78: problems introduced by others will not reflect on our reputation.
        !            79:
        !            80:    The precise conditions of the license for the MPFR library are found
        !            81: in the Lesser General Public License that accompanies the source code.
        !            82: See the file COPYING.LIB.
        !            83:
        !            84: 
        !            85: File: mpfr.info,  Node: Introduction to MPFR,  Next: Installing MPFR,  Prev: Copying,  Up: Top
        !            86:
        !            87: Introduction to MPFR
        !            88: ********************
        !            89:
        !            90:    MPFR is a portable library written in C for arbitrary precision
        !            91: arithmetic on reliable floating-point numbers. It is based on the GNU
        !            92: MP library.  It aims to extend the class of floating-point numbers
        !            93: provided by the GNU MP library by "reliable" floating-point numbers. It
        !            94: may replace the GNU MP floating-point numbers in a future release. The
        !            95: main differences with the `mpf' class are:
        !            96:
        !            97:    * the `mpfr' code is portable, i.e. the result of any operation does
        !            98:      not depend (or should not) on the machine word size
        !            99:      `mp_bits_per_limb' (32 or 64 on most machines);
        !           100:
        !           101:    * the precision in bits can be set exactly to any valid value for
        !           102:      each variable (including very small precision);
        !           103:
        !           104:    * `mpfr' provides the four rounding modes from the IEEE 754 standard.
        !           105:
        !           106:    In particular, with a precision of 53 bits, `mpfr' should be able to
        !           107: exactly reproduce all computations with double-precision machine
        !           108: floating-point numbers (`double' type in C), except the default
        !           109: exponent range is much wider and subnormal numbers are not implemented.
        !           110:
        !           111:    This version of MPFR is released under the GNU Lesser General Public
        !           112: License.  It is permitted to link MPFR to non-free programs, as long as
        !           113: when distributing them the MPFR source code and a means to re-link with
        !           114: a modified MPFR is provided.
        !           115:
        !           116: How to use this Manual
        !           117: ======================
        !           118:
        !           119:    Everyone should read *Note MPFR Basics::.  If you need to install
        !           120: the library yourself, you need to read *Note Installing MPFR::, too.
        !           121:
        !           122:    The rest of the manual can be used for later reference, although it
        !           123: is probably a good idea to glance through it.
        !           124:
        !           125: 
        !           126: File: mpfr.info,  Node: Installing MPFR,  Next: Reporting Bugs,  Prev: Introduction to MPFR,  Up: Top
        !           127:
        !           128: Installing MPFR
        !           129: ***************
        !           130:
        !           131:    To build MPFR, you first have to install GNU MP (version 4.0.1 or
        !           132: higher) on your computer.  You need a C compiler, preferably GCC, but
        !           133: any reasonable compiler should work.  And you need a standard Unix
        !           134: `make' program, plus some other standard Unix utility programs.
        !           135:
        !           136:    Here are the steps needed to install the library on Unix systems
        !           137: (more details are provided in the `INSTALL' file):
        !           138:
        !           139:   1. In most cases, `./configure --with-gmp=/usr/local/gmp' should work,
        !           140:      where the directory `/usr/local/gmp' is where you have installed
        !           141:      GNU MP.  When you install GNU MP, you have to copy the files
        !           142:      `config.h', `gmp-impl.h', `gmp-mparam.h' and `longlong.h' from the
        !           143:      GNU MP source directory to `/usr/local/gmp/include'; these
        !           144:      additional files are needed by MPFR.  If you get error messages,
        !           145:      you might check that you use the same compiler and compile options
        !           146:      as for GNU MP (see the `INSTALL' file).
        !           147:
        !           148:   2. `make'
        !           149:
        !           150:      This will compile MPFR, and create a library archive file
        !           151:      `libmpfr.a' in the working directory.
        !           152:
        !           153:   3. `make check'
        !           154:
        !           155:      This will make sure MPFR was built correctly.  If you get error
        !           156:      messages, please report this to `mpfr@loria.fr'.  (*Note Reporting
        !           157:      Bugs::, for information on what to include in useful bug reports.)
        !           158:
        !           159:   4. `make install'
        !           160:
        !           161:      This will copy the files `mpfr.h' and `mpf2mpfr.h', and
        !           162:      `libmpfr.a', to the directories `/usr/local/include' and
        !           163:      `/usr/local/lib' respectively (or if you passed the `--prefix'
        !           164:      option to `configure', to the directory given as argument to
        !           165:      `--prefix').  This will also install `mpfr.info' in
        !           166:      `/usr/local/info'.
        !           167:
        !           168:    There are some other useful make targets:
        !           169:
        !           170:    * `mpfr.dvi' or `dvi'
        !           171:
        !           172:      Create a DVI version of the manual, in `mpfr.dvi'.
        !           173:
        !           174:    * `mpfr.ps'
        !           175:
        !           176:      Create a Postscript version of the manual, in `mpfr.ps'.
        !           177:
        !           178:    * `clean'
        !           179:
        !           180:      Delete all object files and archive files, but not the
        !           181:      configuration files.
        !           182:
        !           183:    * `distclean'
        !           184:
        !           185:      Delete all files not included in the distribution.
        !           186:
        !           187:    * `uninstall' Delete all files copied by `make install'.
        !           188:
        !           189: Known Build Problems
        !           190: ====================
        !           191:
        !           192:    MPFR suffers from all bugs from the GNU MP library, plus many many
        !           193: more.
        !           194:
        !           195:    Please report other problems to `mpfr@loria.fr'.  *Note Reporting
        !           196: Bugs::.  Some bug fixes are available on the MPFR web page
        !           197: `http://www.loria.fr/projets/mpfr/' or `http://www.mpfr.org/'.
        !           198:
        !           199: 
        !           200: File: mpfr.info,  Node: Reporting Bugs,  Next: MPFR Basics,  Prev: Installing MPFR,  Up: Top
        !           201:
        !           202: Reporting Bugs
        !           203: **************
        !           204:
        !           205:    If you think you have found a bug in the MPFR library, first have a
        !           206: look on the MPFR web page `http://www.loria.fr/projets/mpfr/' or
        !           207: `http://www.mpfr.org/': perhaps this bug is already known, in which
        !           208: case you will find a workaround for it.  Otherwise, please investigate
        !           209: and report it. We have made this library available to you, and it is
        !           210: not to ask too much from you, to ask you to report the bugs that you
        !           211: find.
        !           212:
        !           213:    There are a few things you should think about when you put your bug
        !           214: report together.
        !           215:
        !           216:    You have to send us a test case that makes it possible for us to
        !           217: reproduce the bug.  Include instructions on how to run the test case.
        !           218:
        !           219:    You also have to explain what is wrong; if you get a crash, or if
        !           220: the results printed are incorrect and in that case, in what way.
        !           221:
        !           222:    Please include compiler version information in your bug report.
        !           223: This can be extracted using `cc -V' on some machines, or, if you're
        !           224: using gcc, `gcc -v'.  Also, include the output from `uname -a'.
        !           225:
        !           226:    If your bug report is good, we will do our best to help you to get a
        !           227: corrected version of the library; if the bug report is poor, we won't
        !           228: do anything about it (aside of chiding you to send better bug reports).
        !           229:
        !           230:    Send your bug report to: `mpfr@loria.fr'.
        !           231:
        !           232:    If you think something in this manual is unclear, or downright
        !           233: incorrect, or if the language needs to be improved, please send a note
        !           234: to the same address.
        !           235:
        !           236: 
        !           237: File: mpfr.info,  Node: MPFR Basics,  Next: Floating-point Functions,  Prev: Reporting Bugs,  Up: Top
        !           238:
        !           239: MPFR Basics
        !           240: ***********
        !           241:
        !           242:    All declarations needed to use MPFR are collected in the include file
        !           243: `mpfr.h'.  It is designed to work with both C and C++ compilers.  You
        !           244: should include that file in any program using the MPFR library:
        !           245:
        !           246:    `#include "mpfr.h"'
        !           247:
        !           248: Nomenclature and Types
        !           249: ======================
        !           250:
        !           251: "Floating-point number" or "Float" for short, is an arbitrary precision
        !           252: mantissa with a limited precision exponent.  The C data type for such
        !           253: objects is `mpfr_t'.  A floating-point number can have three special
        !           254: values: Not-a-Number (NaN) or plus or minus Infinity. NaN represents a
        !           255: value which cannot be represented in the floating-point format, like 0
        !           256: divided by 0, or Infinity minus Infinity.
        !           257:
        !           258: The "Precision" is the number of bits used to represent the mantissa of
        !           259: a floating-point number; the corresponding C data type is `mp_prec_t'.
        !           260: The precision can be any integer between `MPFR_PREC_MIN' and
        !           261: `MPFR_PREC_MAX'. In the current implementation, `MPFR_PREC_MIN' is
        !           262: equal to 2 and `MPFR_PREC_MAX' is equal to `ULONG_MAX'.
        !           263:
        !           264: The "rounding mode" specifies the way to round the result of a
        !           265: floating-point operation, in case the exact result can not be
        !           266: represented exactly in the destination mantissa; the corresponding C
        !           267: data type is `mp_rnd_t'.
        !           268:
        !           269: A "limb" means the part of a multi-precision number that fits in a
        !           270: single word.  (We chose this word because a limb of the human body is
        !           271: analogous to a digit, only larger, and containing several digits.)
        !           272: Normally a limb contains 32 or 64 bits.  The C data type for a limb is
        !           273: `mp_limb_t'.
        !           274:
        !           275: Function Classes
        !           276: ================
        !           277:
        !           278:    There is only one class of functions in the MPFR library:
        !           279:
        !           280:   1. Functions for floating-point arithmetic, with names beginning with
        !           281:      `mpfr_'.  The associated type is `mpfr_t'.
        !           282:
        !           283: MPFR Variable Conventions
        !           284: =========================
        !           285:
        !           286:    As a general rule, all MPFR functions expect output arguments before
        !           287: input arguments.  This notation is based on an analogy with the
        !           288: assignment operator.
        !           289:
        !           290:    MPFR allows you to use the same variable for both input and output
        !           291: in the same expression.  For example, the main function for
        !           292: floating-point multiplication, `mpfr_mul', can be used like this:
        !           293: `mpfr_mul (x, x, x, rnd_mode)'.  This computes the square of X with
        !           294: rounding mode `rnd_mode' and puts the result back in X.
        !           295:
        !           296:    Before you can assign to an MPFR variable, you need to initialize it
        !           297: by calling one of the special initialization functions.  When you're
        !           298: done with a variable, you need to clear it out, using one of the
        !           299: functions for that purpose.
        !           300:
        !           301:    A variable should only be initialized once, or at least cleared out
        !           302: between each initialization.  After a variable has been initialized, it
        !           303: may be assigned to any number of times.
        !           304:
        !           305:    For efficiency reasons, avoid to initialize and clear out a variable
        !           306: in loops.  Instead, initialize it before entering the loop, and clear
        !           307: it out after the loop has exited.
        !           308:
        !           309:    You don't need to be concerned about allocating additional space for
        !           310: MPFR variables, since any variable has a mantissa of fixed size.  Hence
        !           311: unless you change its precision, or clear and reinitialize it, a
        !           312: floating-point variable will have the same allocated space during all
        !           313: its life.
        !           314:
        !           315: Compatibility with MPF
        !           316: ======================
        !           317:
        !           318:    A header file `mpf2mpfr.h' is included in the distribution of MPFR
        !           319: for compatibility with the GNU MP class MPF.  After inserting the
        !           320: following two lines after the `#include "gmp.h"' line,
        !           321:
        !           322:    `#include "mpfr.h"'
        !           323:
        !           324:    `#include "mpf2mpfr.h"'
        !           325:
        !           326:    any program written for MPF can be linked directly with MPFR without
        !           327: any changes.  All operations are then performed with the default MPFR
        !           328: rounding mode, which can be reset with `mpfr_set_default_rounding_mode'.
        !           329:
        !           330:  - Global Variable: mp_rnd_t __gmp_default_rounding_mode
        !           331:      The default rounding mode (to nearest initially).
        !           332:
        !           333: Getting the Latest Version of MPFR
        !           334: ==================================
        !           335:
        !           336:    The latest version of MPFR is available from
        !           337: `http://www.loria.fr/projets/mpfr/' or `http://www.mpfr.org/'.
        !           338:
        !           339: 
        !           340: File: mpfr.info,  Node: Floating-point Functions,  Next: Contributors,  Prev: MPFR Basics,  Up: Top
        !           341:
        !           342: Floating-point Functions
        !           343: ************************
        !           344:
        !           345:    The floating-point functions expect arguments of type `mpfr_t'.
        !           346:
        !           347:    The MPFR floating-point functions have an interface that is similar
        !           348: to the GNU MP integer functions.  The function prefix for
        !           349: floating-point operations is `mpfr_'.
        !           350:
        !           351:    There is one significant characteristic of floating-point numbers
        !           352: that has motivated a difference between this function class and other
        !           353: MPFR function classes: the inherent inexactness of floating-point
        !           354: arithmetic.  The user has to specify the precision of each variable.  A
        !           355: computation that assigns a variable will take place with the precision
        !           356: of the assigned variable; the cost of that computation should not
        !           357: depend from the precision of variables used as input on average.
        !           358:
        !           359:    The precision of a calculation is defined as follows: Compute the
        !           360: requested operation exactly (with "infinite precision"), and round the
        !           361: result to the destination variable precision with the given rounding
        !           362: mode.  Even if the user has asked for a very high precision, MP will
        !           363: not calculate with superfluous digits.  For example, if two
        !           364: low-precision numbers of nearly equal magnitude are added, the
        !           365: precision of the result will be limited to what is required to
        !           366: represent the result accurately.
        !           367:
        !           368:    The MPFR floating-point functions are intended to be a smooth
        !           369: extension of the IEEE P754 arithmetic. The results obtained on one
        !           370: computer should not differ from the results obtained on a computer with
        !           371: a different word size.
        !           372:
        !           373: * Menu:
        !           374:
        !           375: * Rounding Modes::
        !           376: * Exceptions::
        !           377: * Initializing Floats::
        !           378: * Assigning Floats::
        !           379: * Simultaneous Float Init & Assign::
        !           380: * Converting Floats::
        !           381: * Float Arithmetic::
        !           382: * Float Comparison::
        !           383: * I/O of Floats::
        !           384: * Miscellaneous Float Functions::
        !           385:
        !           386: 
        !           387: File: mpfr.info,  Node: Rounding Modes,  Next: Exceptions,  Prev: Floating-point Functions,  Up: Floating-point Functions
        !           388:
        !           389: Rounding Modes
        !           390: ==============
        !           391:
        !           392:    The following four rounding modes are supported:
        !           393:    * `GMP_RNDN': round to nearest
        !           394:
        !           395:    * `GMP_RNDZ': round towards zero
        !           396:
        !           397:    * `GMP_RNDU': round towards plus infinity
        !           398:
        !           399:    * `GMP_RNDD': round towards minus infinity
        !           400:    The `round to nearest' mode works as in the IEEE P754 standard: in
        !           401: case the number to be rounded lies exactly in the middle of two
        !           402: representable numbers, it is rounded to the one with the least
        !           403: significant bit set to zero.  For example, the number 5, which is
        !           404: represented by (101) in binary, is rounded to (100)=4 with a precision
        !           405: of two bits, and not to (110)=6.  This rule avoids the "drift"
        !           406: phenomenon mentioned by Knuth in volume 2 of The Art of Computer
        !           407: Programming (section 4.2.2, pages 221-222).
        !           408:
        !           409:    Most MPFR functions take as first argument the destination variable,
        !           410: as second and following arguments the input variables, as last argument
        !           411: a rounding mode, and have a return value of type `int'. If this value
        !           412: is zero, it means that the value stored in the destination variable is
        !           413: the exact result of the corresponding mathematical function. If the
        !           414: returned value is positive (resp. negative), it means the value stored
        !           415: in the destination variable is greater (resp. lower) than the exact
        !           416: result.  For example with the `GMP_RNDU' rounding mode, the returned
        !           417: value is usually positive, except when the result is exact, in which
        !           418: case it is zero.  In the case of an infinite result, it is considered
        !           419: as inexact when it was obtained by overflow, and exact otherwise.  A
        !           420: NaN result (Not-a-Number) always corresponds to an inexact return value.
        !           421:
        !           422:  - Function: void mpfr_set_default_rounding_mode (mp_rnd_t RND)
        !           423:      Sets the default rounding mode to RND.  The default rounding mode
        !           424:      is to nearest initially.
        !           425:
        !           426:  - Function: int mpfr_round_prec (mpfr_t X, mp_rnd_t RND, mp_prec_t
        !           427:           PREC)
        !           428:      Rounds X according to RND with precision PREC, which may be
        !           429:      different from that of X.  If PREC is greater or equal to the
        !           430:      precision of X, then new space is allocated for the mantissa, and
        !           431:      it is filled with zeroes.  Otherwise, the mantissa is rounded to
        !           432:      precision PREC with the given direction. In both cases, the
        !           433:      precision of X is changed to PREC.  The returned value is zero
        !           434:      when the result is exact, positive when it is greater than the
        !           435:      original value of X, and negative when it is smaller.  The
        !           436:      precision PREC can be any integer between `MPFR_PREC_MIN' and
        !           437:      `MPFR_PREC_MAX'.
        !           438:
        !           439:  - Function: void mpfr_set_machine_rnd_mode (mp_rnd_t RND)
        !           440:      Set the machine rounding mode to RND.  This function is provided
        !           441:      only when the operating system supports the ISOC9X standard
        !           442:      interface for setting rounding modes (i.e. through the header file
        !           443:      <fenv.h>).
        !           444:
        !           445:  - Function: char * mpfr_print_rnd_mode (mp_rnd_t RND)
        !           446:      Returns the input string (GMP_RNDD, GMP_RNDU, GMP_RNDN, GMP_RNDZ)
        !           447:      corresponding to the rounding mode RND or a null pointer if RND is
        !           448:      an invalid rounding mode.
        !           449:
        !           450: 
        !           451: File: mpfr.info,  Node: Exceptions,  Next: Initializing Floats,  Prev: Rounding Modes,  Up: Floating-point Functions
        !           452:
        !           453: Exceptions
        !           454: ==========
        !           455:
        !           456:    Note: Overflow handling is still experimental and currently
        !           457: implemented very partially. If an overflow occurs internally at the
        !           458: wrong place, anything can happen (crash, wrong results, etc).
        !           459:
        !           460:  - Function: mp_exp_t mpfr_get_emin (void)
        !           461:  - Function: mp_exp_t mpfr_get_emax (void)
        !           462:      Return the (current) smallest and largest exponents allowed for a
        !           463:      floating-point variable.
        !           464:
        !           465:  - Function: int mpfr_set_emin (mp_exp_t EXP)
        !           466:  - Function: int mpfr_set_emax (mp_exp_t EXP)
        !           467:      Set the smallest and largest exponents allowed for a
        !           468:      floating-point variable.  Return a non-zero value when EXP is not
        !           469:      in the range accepted by the implementation (in that case the
        !           470:      smallest or largest exponent is not changed), and zero otherwise.
        !           471:      If the user changes the exponent range, it is her/his
        !           472:      responsibility to check that all current floating-point variables
        !           473:      are in the new allowed range (for example using `mpfr_check_range',
        !           474:      otherwise the subsequent behaviour will be undefined, in the sense
        !           475:      of the ISO C standard.
        !           476:
        !           477:  - Function: int mpfr_check_range (mpfr_t X, mp_rnd_t RND)
        !           478:      Return zero if the exponent of X is in the current allowed range
        !           479:      (see `mpfr_get_emin' and `mpfr_get_emax'), otherwise reset X
        !           480:      according to the current floating-point system and the rounding
        !           481:      mode RND, and return a positive value if the rounded result is
        !           482:      larger than the original one, a negative value otherwise (the
        !           483:      result cannot be exact in that case).
        !           484:
        !           485:  - Function: void mpfr_clear_underflow (void)
        !           486:  - Function: void mpfr_clear_overflow (void)
        !           487:  - Function: void mpfr_clear_nanflag (void)
        !           488:  - Function: void mpfr_clear_inexflag (void)
        !           489:      Clear the underflow, overflow, invalid, and inexact flags.
        !           490:
        !           491:  - Function: void mpfr_clear_flags (void)
        !           492:      Clear all global flags (underflow, overflow, inexact, invalid).
        !           493:
        !           494:  - Function: int mpfr_underflow_p (void)
        !           495:  - Function: int mpfr_overflow_p (void)
        !           496:  - Function: int mpfr_nanflag_p (void)
        !           497:  - Function: int mpfr_inexflag_p (void)
        !           498:      Return the corresponding (underflow, overflow, invalid, inexact)
        !           499:      flag, which is non-zero iff the flag is set.
        !           500:
        !           501: 
        !           502: File: mpfr.info,  Node: Initializing Floats,  Next: Assigning Floats,  Prev: Exceptions,  Up: Floating-point Functions
        !           503:
        !           504: Initialization and Assignment Functions
        !           505: =======================================
        !           506:
        !           507:  - Function: void mpfr_set_default_prec (mp_prec_t PREC)
        !           508:      Set the default precision to be *exactly* PREC bits.  The
        !           509:      precision of a variable means the number of bits used to store its
        !           510:      mantissa.  All subsequent calls to `mpfr_init' will use this
        !           511:      precision, but previously initialized variables are unaffected.
        !           512:      This default precision is set to 53 bits initially.  The precision
        !           513:      can be any integer between `MPFR_PREC_MIN' and `MPFR_PREC_MAX'.
        !           514:
        !           515:  - Function: mp_prec_t mpfr_get_default_prec ()
        !           516:      Returns the default MPFR precision in bits.
        !           517:
        !           518:    An `mpfr_t' object must be initialized before storing the first
        !           519: value in it.  The functions `mpfr_init' and `mpfr_init2' are used for
        !           520: that purpose.
        !           521:
        !           522:  - Function: void mpfr_init (mpfr_t X)
        !           523:      Initialize X, and set its value to NaN.  Normally, a variable
        !           524:      should be initialized once only or at least be cleared, using
        !           525:      `mpfr_clear', between initializations.  The precision of X is the
        !           526:      default precision, which can be changed by a call to
        !           527:      `mpfr_set_default_prec'.
        !           528:
        !           529:  - Function: void mpfr_init2 (mpfr_t X, mp_prec_t PREC)
        !           530:      Initialize X, set its precision to be *exactly* PREC bits, and set
        !           531:      its value to NaN.  Normally, a variable should be initialized once
        !           532:      only or at least be cleared, using `mpfr_clear', between
        !           533:      initializations.  To change the precision of a variable which has
        !           534:      already been initialized, use `mpfr_set_prec' instead.  The
        !           535:      precision PREC can be any integer between `MPFR_PREC_MIN' and
        !           536:      `MPFR_PREC_MAX'.
        !           537:
        !           538:  - Function: void mpfr_clear (mpfr_t X)
        !           539:      Free the space occupied by X.  Make sure to call this function for
        !           540:      all `mpfr_t' variables when you are done with them.
        !           541:
        !           542:    Here is an example on how to initialize floating-point variables:
        !           543:      {
        !           544:        mpfr_t x, y;
        !           545:        mpfr_init (x);                  /* use default precision */
        !           546:        mpfr_init2 (y, 256);            /* precision _exactly_ 256 bits */
        !           547:        ...
        !           548:        /* Unless the program is about to exit, do ... */
        !           549:        mpfr_clear (x);
        !           550:        mpfr_clear (y);
        !           551:      }
        !           552:
        !           553:    The following two functions are useful for changing the precision
        !           554: during a calculation.  A typical use would be for adjusting the
        !           555: precision gradually in iterative algorithms like Newton-Raphson, making
        !           556: the computation precision closely match the actual accurate part of the
        !           557: numbers.
        !           558:
        !           559:  - Function: int mpfr_set_prec (mpfr_t X, mp_prec_t PREC)
        !           560:      Reset the precision of X to be *exactly* PREC bits.  The previous
        !           561:      value stored in X is lost. It is equivalent to a call to
        !           562:      `mpfr_clear(x)' followed by a call to `mpfr_init2(x, prec)', but
        !           563:      more efficient as no allocation is done in case the current
        !           564:      allocated space for the mantissa of X is enough.  The precision
        !           565:      PREC can be any integer between `MPFR_PREC_MIN' and
        !           566:      `MPFR_PREC_MAX'.  It returns a non-zero value iff the memory
        !           567:      allocation failed.
        !           568:
        !           569:      In case you want to keep the previous value stored in X, use
        !           570:      `mpfr_round_prec' instead.
        !           571:
        !           572:  - Function: mp_prec_t mpfr_get_prec (mpfr_t X)
        !           573:      Return the precision actually used for assignments of X, i.e.  the
        !           574:      number of bits used to store its mantissa.
        !           575:
        !           576:  - Function: void mpfr_set_prec_raw (mpfr_t X, unsigned long int P)
        !           577:      Reset the precision of X to be *exactly* PREC bits.  The only
        !           578:      difference with `mpfr_set_prec' is that P is assumed to be small
        !           579:      enough so that the mantissa fits into the current allocated memory
        !           580:      space for X. Otherwise an error will occur.
        !           581:
        !           582: 
        !           583: File: mpfr.info,  Node: Assigning Floats,  Next: Simultaneous Float Init & Assign,  Prev: Initializing Floats,  Up: Floating-point Functions
        !           584:
        !           585: Assignment Functions
        !           586: ====================
        !           587:
        !           588:    These functions assign new values to already initialized floats
        !           589: (*note Initializing Floats::).
        !           590:
        !           591:  - Function: int mpfr_set (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !           592:  - Function: int mpfr_set_ui (mpfr_t ROP, unsigned long int OP,
        !           593:           mp_rnd_t RND)
        !           594:  - Function: int mpfr_set_si (mpfr_t ROP, long int OP, mp_rnd_t RND
        !           595:  - Function: int mpfr_set_d (mpfr_t ROP, double OP, mp_rnd_t RND)
        !           596:  - Function: int mpfr_set_z (mpfr_t ROP, mpz_t OP, mp_rnd_t RND)
        !           597:  - Function: int mpfr_set_q (mpfr_t ROP, mpq_t OP, mp_rnd_t RND)
        !           598:      Set the value of ROP from OP, rounded to the precision of ROP
        !           599:      towards the given direction RND.  Please note that even a `long
        !           600:      int' may have to be rounded, if the destination precision is less
        !           601:      than the machine word width.  The return value is zero when
        !           602:      ROP=OP, positive when ROP>OP, and negative when ROP<OP.  For
        !           603:      `mpfr_set_d', be careful that the input number OP may not be
        !           604:      exactly representable as a double-precision number (this happens
        !           605:      for 0.1 for instance), in which case it is first rounded by the C
        !           606:      compiler to a double-precision number, and then only to a mpfr
        !           607:      floating-point number.
        !           608:
        !           609:  - Function: int mpfr_set_str (mpfr_t X, char *S, int BASE, mp_rnd_t
        !           610:           RND)
        !           611:      Set X to the value of the string S in base BASE (between 2 and
        !           612:      36), rounded in direction RND to the precision of X.  The exponent
        !           613:      is read in decimal.  This function returns -1 if an internal
        !           614:      overflow occurred (for instance, because the exponent is too
        !           615:      large). Otherwise it returns 0 if the base is valid and if the
        !           616:      entire string up to the final '\0' is a valid number in base BASE,
        !           617:      and 1 if the input is incorrect.
        !           618:
        !           619:  - Function: void mpfr_set_str_raw (mpfr_t X, char *S)
        !           620:      Set X to the value of the binary number in string S, which has to
        !           621:      be of the form +/-xxxx.xxxxxxEyy. The exponent is read in decimal,
        !           622:      but is interpreted as the power of two to be multiplied by the
        !           623:      mantissa.  The mantissa length of S has to be less or equal to the
        !           624:      precision of X, otherwise an error occurs.  If S starts with `N',
        !           625:      it is interpreted as NaN (Not-a-Number); if it starts with `I'
        !           626:      after the sign, it is interpreted as infinity, with the
        !           627:      corresponding sign.
        !           628:
        !           629:  - Function: int mpfr_set_f (mpfr_t X, mpf_t Y, mp_rnd_t RND)
        !           630:      Set X to the GNU MP floating-point number Y, rounded with the RND
        !           631:      mode and the precision of X.  The returned value is zero when X=Y,
        !           632:      positive when X>Y, and negative when X<Y.
        !           633:
        !           634:  - Function: void mpfr_set_inf (mpfr_t X, int SIGN)
        !           635:  - Function: void mpfr_set_nan (mpfr_t X)
        !           636:      Set the variable X to infinity or NaN (Not-a-Number) respectively.
        !           637:      In `mpfr_set_inf', X is set to plus infinity iff SIGN is positive.
        !           638:
        !           639:  - Function: void mpfr_swap (mpfr_t X, mpfr_t Y)
        !           640:      Swap the values X and Y efficiently. Warning: the precisions are
        !           641:      exchanged too; in case the precisions are different, `mpfr_swap'
        !           642:      is thus not equivalent to three `mpfr_set' calls using a third
        !           643:      auxiliary variable.
        !           644:
        !           645: 
        !           646: File: mpfr.info,  Node: Simultaneous Float Init & Assign,  Next: Converting Floats,  Prev: Assigning Floats,  Up: Floating-point Functions
        !           647:
        !           648: Combined Initialization and Assignment Functions
        !           649: ================================================
        !           650:
        !           651:  - Macro: int mpfr_init_set (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !           652:  - Macro: int mpfr_init_set_ui (mpfr_t ROP, unsigned long int OP,
        !           653:           mp_rnd_t RND)
        !           654:  - Macro: int mpfr_init_set_si (mpfr_t ROP, signed long int OP,
        !           655:           mp_rnd_t RND)
        !           656:  - Macro: int mpfr_init_set_d (mpfr_t ROP, double OP, mp_rnd_t RND)
        !           657:  - Macro: int mpfr_init_set_f (mpfr_t ROP, mpf_t OP, mp_rnd_t RND)
        !           658:  - Macro: int mpfr_init_set_z (mpfr_t ROP, mpz_t OP, mp_rnd_t RND)
        !           659:  - Macro: int mpfr_init_set_q (mpfr_t ROP, mpq_t OP, mp_rnd_t RND)
        !           660:      Initialize ROP and set its value from OP, rounded to direction RND.
        !           661:      The precision of ROP will be taken from the active default
        !           662:      precision, as set by `mpfr_set_default_prec'.  The return value if
        !           663:      zero if ROP=OP, positive if ROP>OP, and negative when ROP<OP.
        !           664:
        !           665:  - Function: int mpfr_init_set_str (mpfr_t X, char *S, int BASE,
        !           666:           mp_rnd_t RND)
        !           667:      Initialize X and set its value from the string S in base BASE,
        !           668:      rounded to direction RND.  See `mpfr_set_str'.
        !           669:
        !           670: 
        !           671: File: mpfr.info,  Node: Converting Floats,  Next: Float Arithmetic,  Prev: Simultaneous Float Init & Assign,  Up: Floating-point Functions
        !           672:
        !           673: Conversion Functions
        !           674: ====================
        !           675:
        !           676:  - Function: double mpfr_get_d (mpfr_t OP, mp_rnd_t RND)
        !           677:      Convert OP to a double, using the rounding mode RND.
        !           678:
        !           679:  - Function: double mpfr_get_d1 (mpfr_t OP)
        !           680:      Convert OP to a double, using the default MPFR rounding mode (see
        !           681:      function `mpfr_set_default_rounding_mode').
        !           682:
        !           683:  - Function: mp_exp_t mpfr_get_z_exp (mpz_t Z, mpfr_t OP)
        !           684:      Puts the mantissa of OP into Z, and returns the exponent EXP such
        !           685:      that OP equals Z multiplied by two exponent EXP.
        !           686:
        !           687:  - Function: char * mpfr_get_str (char *STR, mp_exp_t *EXPPTR, int
        !           688:           BASE, size_t N_DIGITS, mpfr_t OP, mp_rnd_t RND)
        !           689:      Convert OP to a string of digits in base BASE, with rounding in
        !           690:      direction RND. The base may vary from 2 to 36.  Generate exactly
        !           691:      N_DIGITS significant digits.
        !           692:
        !           693:      If N_DIGITS is 0, it writes the maximum possible number of digits
        !           694:      giving an exact rounding in the given base BASE with the direction
        !           695:      RND. In other words, if OP was the exact rounding of a real number
        !           696:      in direction RND, then the written value is also an exact rounding
        !           697:      in base BASE of that real number with the same precision. An error
        !           698:      occurs when one is unable to determine the leading digit, which
        !           699:      can happen especially if the precision of OP is small.
        !           700:
        !           701:      If STR is a null pointer, space for the mantissa is allocated using
        !           702:      the default allocation function, and a pointer to the string is
        !           703:      returned.  In that case, the user should her/himself free the
        !           704:      corresponding memory with `(*_mp_free_func)(s, strlen(s) + 1)'.
        !           705:
        !           706:      If STR is not a null pointer, it should point to a block of storage
        !           707:      large enough for the mantissa, i.e., N_DIGITS + 2 or more. The
        !           708:      extra two bytes are for a possible minus sign, and for the
        !           709:      terminating null character.
        !           710:
        !           711:      If the input number is a real number, the exponent is written
        !           712:      through the pointer EXPPTR (the current minimal exponent for 0).
        !           713:
        !           714:      If N_DIGITS is 0, note that the space requirements for STR in this
        !           715:      case will be impossible for the user to predetermine. Therefore,
        !           716:      one needs to pass a null pointer for the string argument whenever
        !           717:      N_DIGITS is 0.
        !           718:
        !           719:      The generated string is a fraction, with an implicit radix point
        !           720:      immediately to the left of the first digit.  For example, the
        !           721:      number 3.1416 would be returned as "31416" in the string and 1
        !           722:      written at EXPPTR.
        !           723:
        !           724:      A pointer to the string is returned, unless there is an error, in
        !           725:      which case a null pointer is returned.
        !           726:
        !           727: 
        !           728: File: mpfr.info,  Node: Float Arithmetic,  Next: Float Comparison,  Prev: Converting Floats,  Up: Floating-point Functions
        !           729:
        !           730: Basic Arithmetic Functions
        !           731: ==========================
        !           732:
        !           733:  - Function: int mpfr_add (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2, mp_rnd_t
        !           734:           RND)
        !           735:  - Function: int mpfr_add_ui (mpfr_t ROP, mpfr_t OP1, unsigned long int
        !           736:           OP2, mp_rnd_t RND)
        !           737:  - Function: int mpfr_add_z (mpfr_t ROP, mpfr_t OP1, mpz_t OP2,
        !           738:           mp_rnd_t RND)
        !           739:  - Function: int mpfr_add_q (mpfr_t ROP, mpfr_t OP1, mpq_t OP2,
        !           740:           mp_rnd_t RND)
        !           741:      Set ROP to OP1 + OP2 rounded in the direction RND.  The return
        !           742:      value is zero if ROP is exactly OP1 + OP2, positive if ROP is
        !           743:      larger than OP1 + OP2, and negative if ROP is smaller than OP1 +
        !           744:      OP2.
        !           745:
        !           746:  - Function: int mpfr_sub (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2, mp_rnd_t
        !           747:           RND)
        !           748:  - Function: int mpfr_ui_sub (mpfr_t ROP, unsigned long int OP1, mpfr_t
        !           749:           OP2, mp_rnd_t RND)
        !           750:  - Function: int mpfr_sub_ui (mpfr_t ROP, mpfr_t OP1, unsigned long int
        !           751:           OP2, mp_rnd_t RND)
        !           752:  - Function: int mpfr_sub_z (mpfr_t ROP, mpfr_t OP1, mpz_t OP2,
        !           753:           mp_rnd_t RND)
        !           754:  - Function: int mpfr_sub_q (mpfr_t ROP, mpfr_t OP1, mpq_t OP2,
        !           755:           mp_rnd_t RND)
        !           756:      Set ROP to OP1 - OP2 rounded in the direction RND.  The return
        !           757:      value is zero if ROP is exactly OP1 - OP2, positive if ROP is
        !           758:      larger than OP1 - OP2, and negative if ROP is smaller than OP1 -
        !           759:      OP2.
        !           760:
        !           761:  - Function: int mpfr_mul (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2, mp_rnd_t
        !           762:           RND)
        !           763:  - Function: int mpfr_mul_ui (mpfr_t ROP, mpfr_t OP1, unsigned long int
        !           764:           OP2, mp_rnd_t RND)
        !           765:  - Function: int mpfr_mul_z (mpfr_t ROP, mpfr_t OP1, mpz_t OP2,
        !           766:           mp_rnd_t RND)
        !           767:  - Function: int mpfr_mul_q (mpfr_t ROP, mpfr_t OP1, mpq_t OP2,
        !           768:           mp_rnd_t RND)
        !           769:      Set ROP to OP1 times OP2 rounded in the direction RND.  Return 0
        !           770:      if the result is exact, a positive value if ROP>OP1*OP2, a
        !           771:      negative value otherwise.
        !           772:
        !           773:  - Function: int mpfr_div (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2, mp_rnd_t
        !           774:           RND)
        !           775:  - Function: int mpfr_ui_div (mpfr_t ROP, unsigned long int OP1, mpfr_t
        !           776:           OP2, mp_rnd_t RND)
        !           777:  - Function: int mpfr_div_ui (mpfr_t ROP, mpfr_t OP1, unsigned long int
        !           778:           OP2, mp_rnd_t RND)
        !           779:  - Function: int mpfr_div_z (mpfr_t ROP, mpfr_t OP1, mpz_t OP2,
        !           780:           mp_rnd_t RND)
        !           781:  - Function: int mpfr_div_q (mpfr_t ROP, mpfr_t OP1, mpq_t OP2,
        !           782:           mp_rnd_t RND)
        !           783:      Set ROP to OP1/OP2 rounded in the direction RND.  These functions
        !           784:      return 0 if the division is exact, a positive value when ROP is
        !           785:      larger than OP1 divided by OP2, and a negative value otherwise.
        !           786:
        !           787:  - Function: int mpfr_sqrt (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !           788:  - Function: int mpfr_sqrt_ui (mpfr_t ROP, unsigned long int OP,
        !           789:           mp_rnd_t RND)
        !           790:      Set ROP to the square root of OP rounded in the direction RND.
        !           791:      Set ROP to NaN if OP is negative.  Return 0 if the operation is
        !           792:      exact, a non-zero value otherwise.
        !           793:
        !           794:  - Function: int mpfr_pow_ui (mpfr_t ROP, mpfr_t OP1, unsigned long int
        !           795:           OP2, mp_rnd_t RND)
        !           796:  - Function: int mpfr_ui_pow_ui (mpfr_t ROP, unsigned long int OP1,
        !           797:           unsigned long int OP2, mp_rnd_t RND)
        !           798:      Set ROP to OP1 raised to OP2. The computation is done by binary
        !           799:      exponentiation.  Return 0 if the result is exact, a non-zero value
        !           800:      otherwise (but the sign of the return value has no meaning).
        !           801:
        !           802:  - Function: int mpfr_ui_pow (mpfr_t ROP, unsigned long int OP1, mpfr_t
        !           803:           OP2, mp_rnd_t RND)
        !           804:      Set ROP to OP1 raised to OP2, rounded to the direction RND with
        !           805:      the precision of ROP.  Return zero iff the result is exact, a
        !           806:      positive value when the result is greater than OP1 to the power
        !           807:      OP2, and a negative value when it is smaller.
        !           808:
        !           809:  - Function: int mpfr_pow_si (mpfr_t ROP, mpfr_t OP1, long int OP2,
        !           810:           mp_rnd_t RND)
        !           811:      Set ROP to OP1 raised to the power OP2, rounded to the direction
        !           812:      RND with the precision of ROP.  Return zero iff the result is
        !           813:      exact.
        !           814:
        !           815:  - Function: int mpfr_pow (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2, mp_rnd_t
        !           816:           RND)
        !           817:      Set ROP to OP1 raised to the power OP2, rounded to the direction
        !           818:      RND with the precision of ROP.  If OP1 is negative then ROP is set
        !           819:      to NaN, even if OP2 is an integer.  Return zero iff the result is
        !           820:      exact.
        !           821:
        !           822:  - Function: int mpfr_neg (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !           823:      Set ROP to -OP rounded in the direction RND.  Just changes the sign
        !           824:      if ROP and OP are the same variable.
        !           825:
        !           826:  - Function: int mpfr_abs (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !           827:      Set ROP to the absolute value of OP, rounded in the direction RND.
        !           828:      Return 0 if the result is exact, a positive value if ROP is larger
        !           829:      than the absolute value of OP, and a negative value otherwise.
        !           830:
        !           831:  - Function: int mpfr_mul_2exp (mpfr_t ROP, mpfr_t OP1, unsigned long
        !           832:           int OP2, mp_rnd_t RND)
        !           833:  - Function: int mpfr_mul_2ui (mpfr_t ROP, mpfr_t OP1, unsigned long
        !           834:           int OP2, mp_rnd_t RND)
        !           835:  - Function: int mpfr_mul_2si (mpfr_t ROP, mpfr_t OP1, long int OP2,
        !           836:           mp_rnd_t RND)
        !           837:      Set ROP to OP1 times 2 raised to OP2 rounded to the direction RND.
        !           838:      Just increases the exponent by OP2 when ROP and OP1 are identical.
        !           839:      Return zero when ROP=OP1, a positive value when ROP>OP1, and a
        !           840:      negative value when ROP<OP1.  Note: The `mpfr_mul_2exp' function
        !           841:      is defined for compatibility reasons; you should use
        !           842:      `mpfr_mul_2ui' (or `mpfr_mul_2si') instead.
        !           843:
        !           844:  - Function: int mpfr_div_2exp (mpfr_t ROP, mpfr_t OP1, unsigned long
        !           845:           int OP2, mp_rnd_t RND)
        !           846:  - Function: int mpfr_div_2ui (mpfr_t ROP, mpfr_t OP1, unsigned long
        !           847:           int OP2, mp_rnd_t RND)
        !           848:  - Function: int mpfr_div_2si (mpfr_t ROP, mpfr_t OP1, long int OP2,
        !           849:           mp_rnd_t RND)
        !           850:      Set ROP to OP1 divided by 2 raised to OP2 rounded to the direction
        !           851:      RND. Just decreases the exponent by OP2 when ROP and OP1 are
        !           852:      identical.  Return zero when ROP=OP1, a positive value when
        !           853:      ROP>OP1, and a negative value when ROP<OP1.  Note: The
        !           854:      `mpfr_div_2exp' function is defined for compatibility reasons; you
        !           855:      should use `mpfr_div_2ui' (or `mpfr_div_2si') instead.
        !           856:
        !           857: 
        !           858: File: mpfr.info,  Node: Float Comparison,  Next: I/O of Floats,  Prev: Float Arithmetic,  Up: Floating-point Functions
        !           859:
        !           860: Comparison Functions
        !           861: ====================
        !           862:
        !           863:  - Function: int mpfr_cmp (mpfr_t OP1, mpfr_t OP2)
        !           864:  - Function: int mpfr_cmp_ui (mpfr_t OP1, unsigned long int OP2)
        !           865:  - Function: int mpfr_cmp_si (mpfr_t OP1, signed long int OP2)
        !           866:      Compare OP1 and OP2.  Return a positive value if OP1 > OP2, zero
        !           867:      if OP1 = OP2, and a negative value if OP1 < OP2.  Both OP1 and OP2
        !           868:      are considered to their full own precision, which may differ. In
        !           869:      case OP1 and OP2 are of same sign but different, the absolute
        !           870:      value returned is one plus the absolute difference of their
        !           871:      exponents.  It is not allowed that one of the operands is NaN
        !           872:      (Not-a-Number).
        !           873:
        !           874:  - Function: int mpfr_cmp_ui_2exp (mpfr_t OP1, unsigned long int OP2,
        !           875:           int E)
        !           876:  - Function: int mpfr_cmp_si_2exp (mpfr_t OP1, long int OP2, int E)
        !           877:      Compare OP1 and OP2 multiplied by two to the power E.
        !           878:
        !           879:  - Function: int mpfr_eq (mpfr_t OP1, mpfr_t OP2, unsigned long int op3)
        !           880:      Return non-zero if the first OP3 bits of OP1 and OP2 are equal,
        !           881:      zero otherwise.  I.e., tests if OP1 and OP2 are approximately
        !           882:      equal.
        !           883:
        !           884:  - Function: int mpfr_nan_p (mpfr_t OP)
        !           885:      Return non-zero if OP is Not-a-Number (NaN), zero otherwise.
        !           886:
        !           887:  - Function: int mpfr_inf_p (mpfr_t OP)
        !           888:      Return non-zero if OP is plus or minus infinity, zero otherwise.
        !           889:
        !           890:  - Function: int mpfr_number_p (mpfr_t OP)
        !           891:      Return non-zero if OP is an ordinary number, i.e. neither
        !           892:      Not-a-Number nor plus or minus infinity.
        !           893:
        !           894:  - Function: void mpfr_reldiff (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2,
        !           895:           mp_rnd_t RND)
        !           896:      Compute the relative difference between OP1 and OP2 and store the
        !           897:      result in ROP.  This function does not guarantee the exact
        !           898:      rounding on the relative difference; it just computes
        !           899:      abs(OP1-OP2)/OP1, using the rounding mode RND for all operations.
        !           900:
        !           901:  - Function: int mpfr_sgn (mpfr_t OP)
        !           902:      Return a positive value if OP > 0, zero if OP = 0, and a negative
        !           903:      value if OP < 0.  Its result is not specified when OP is NaN
        !           904:      (Not-a-Number).
        !           905:
        !           906: Special Functions
        !           907: =================
        !           908:
        !           909:  - Function: int mpfr_log (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !           910:      Set ROP to the natural logarithm of OP, rounded to the direction
        !           911:      RND with the precision of ROP.  Return zero when the result is
        !           912:      exact (this occurs in fact only when OP is 0, 1, or +infinity) and
        !           913:      a non-zero value otherwise (except for rounding to nearest, the
        !           914:      sign of the return value is that of ROP-log(OP).
        !           915:
        !           916:  - Function: int mpfr_exp (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !           917:      Set ROP to the exponential of OP, rounded to the direction RND
        !           918:      with the precision of ROP.  Return zero when the result is exact
        !           919:      (this occurs in fact only when OP is -infinity, 0, or +infinity),
        !           920:      a positive value when the result is greater than the exponential
        !           921:      of OP, and a negative value when it is smaller.
        !           922:
        !           923:  - Function: int mpfr_exp2 (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !           924:      Set ROP to 2 power of OP, rounded to the direction RND with the
        !           925:      precision of ROP.  Return zero iff the result is exact (this
        !           926:      occurs in fact only when OP is -infinity, 0, or +infinity), a
        !           927:      positive value when the result is greater than the exponential of
        !           928:      OP, and a negative value when it is smaller.
        !           929:
        !           930:  - Function: int mpfr_cos (mpfr_t COP, mpfr_t OP, mp_rnd_t RND)
        !           931:  - Function: int mpfr_sin (mpfr_t SOP, mpfr_t OP, mp_rnd_t RND)
        !           932:  - Function: int mpfr_tan (mpfr_t TOP, mpfr_t OP, mp_rnd_t RND)
        !           933:      Set COP to the cosine of OP, SOP to the sine of OP, TOP to the
        !           934:      tangent of OP, rounded to the direction RND with the precision of
        !           935:      ROP. Return 0 iff the result is exact (this occurs in fact only
        !           936:      when OP is 0 i.e. the sine is 0, the cosine is 1, and the tangent
        !           937:      is 0).
        !           938:
        !           939:  - Function: int mpfr_sin_cos (mpfr_t SOP, mpfr_t COP, mpfr_t OP,
        !           940:           mp_rnd_t RND)
        !           941:      Set simultaneously SOP to the sine of OP and
        !           942:      COP to the cosine of OP, rounded to the direction RND with their
        !           943:      corresponding precisions.  Return 0 iff both results are exact.
        !           944:
        !           945:  - Function: int mpfr_acos (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !           946:  - Function: int mpfr_asin (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !           947:  - Function: int mpfr_atan (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !           948:      Set ROP to the arc-cosine, arc-sine or arc-tangent of OP, rounded
        !           949:      to the direction RND with the precision of ROP.  Return 0 iff the
        !           950:      result is exact.
        !           951:
        !           952:  - Function: int mpfr_cosh (mpfr_t COP, mpfr_t OP, mp_rnd_t RND)
        !           953:  - Function: int mpfr_sinh (mpfr_t SOP, mpfr_t OP, mp_rnd_t RND)
        !           954:  - Function: int mpfr_tanh (mpfr_t TOP, mpfr_t OP, mp_rnd_t RND)
        !           955:      Set COP to the hyperbolic cosine of OP,     SOP to the hyperbolic
        !           956:      sine of OP,     TOP to the hyperbolic tangent of OP, rounded to
        !           957:      the direction RND with the precision of ROP.  Return 0 iff the
        !           958:      result is exact (this occurs in fact only when OP is 0 i.e. the
        !           959:      result is 1).
        !           960:
        !           961:  - Function: int mpfr_acosh (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !           962:  - Function: int mpfr_asinh (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !           963:  - Function: int mpfr_atanh (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !           964:      Set ROP to the inverse hyperbolic cosine, sine or tangent of OP,
        !           965:      rounded to the direction RND with the precision of ROP.  Return 0
        !           966:      iff the result is exact.
        !           967:
        !           968:  - Function: int mpfr_fac_ui (mpfr_t ROP, unsigned long int OP,
        !           969:           mp_rnd_t RND)
        !           970:      Set ROP to the factorial of the unsigned long int OP, rounded to
        !           971:      the direction RND with the precision of ROP.  Return 0 iff the
        !           972:      result is exact.
        !           973:
        !           974:  - Function: int mpfr_log1p (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !           975:      Set ROP to the logarithm of one plus OP, rounded to the direction
        !           976:      RND with the precision of ROP.  Return 0 iff the result is exact
        !           977:      (this occurs in fact only when OP is 0 i.e. the result is 0).
        !           978:
        !           979:  - Function: int mpfr_expm1 (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !           980:      Set ROP to the exponential of OP minus one, rounded to the
        !           981:      direction RND with the precision of ROP.  Return 0 iff the result
        !           982:      is exact (this occurs in fact only when OP is 0 i.e. the result is
        !           983:      0).
        !           984:
        !           985:  - Function: int mpfr_log2 (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !           986:  - Function: int mpfr_log10 (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !           987:      Set ROP to the log[t] (t=2 or 10)(log x / log t) of OP, rounded to
        !           988:      the direction RND with the precision of ROP. Return 0 iff the
        !           989:      result is exact (this occurs in fact only when OP is 1 i.e. the
        !           990:      result is 0).
        !           991:
        !           992:  - Function: int mpfr_fma (mpfr_t ROP, mpfr_t OPX,mpfr_t OPY,mpfr_t
        !           993:           OPZ, mp_rnd_t RND)
        !           994:      Set ROP to OPX * OPY + OPZ, rounded to the direction RND with the
        !           995:      precision of ROP. Return 0 iff the result is exact, a positive
        !           996:      value if ROP is larger than OPX * OPY + OPZ, and a negative value
        !           997:      otherwise.
        !           998:
        !           999:  - Function: void mpfr_agm (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2,
        !          1000:           mp_rnd_t RND)
        !          1001:      Set ROP to the arithmetic-geometric mean of OP1 and OP2, rounded
        !          1002:      to the direction RND with the precision of ROP.
        !          1003:
        !          1004:  - Function: void mpfr_const_log2 (mpfr_t ROP, mp_rnd_t RND)
        !          1005:      Set ROP to the logarithm of 2 rounded to the direction RND with
        !          1006:      the precision of ROP. This function stores the computed value to
        !          1007:      avoid another calculation if a lower or equal precision is
        !          1008:      requested.
        !          1009:
        !          1010:  - Function: void mpfr_const_pi (mpfr_t ROP, mp_rnd_t RND)
        !          1011:      Set ROP to the value of Pi rounded to the direction RND with the
        !          1012:      precision of ROP. This function uses the Borwein, Borwein, Plouffe
        !          1013:      formula which directly gives the expansion of Pi in base 16.
        !          1014:
        !          1015:  - Function: void mpfr_const_euler (mpfr_t ROP, mp_rnd_t RND)
        !          1016:      Set ROP to the value of Euler's constant 0.577...  rounded to the
        !          1017:      direction RND with the precision of ROP.
        !          1018:
        !          1019: 
        !          1020: File: mpfr.info,  Node: I/O of Floats,  Next: Miscellaneous Float Functions,  Prev: Float Comparison,  Up: Floating-point Functions
        !          1021:
        !          1022: Input and Output Functions
        !          1023: ==========================
        !          1024:
        !          1025:    Functions that perform input from a standard input/output stream,
        !          1026: and functions that output to a standard input/output stream.  Passing a
        !          1027: null pointer for a STREAM argument to any of these functions will make
        !          1028: them read from `stdin' and write to `stdout', respectively.
        !          1029:
        !          1030:    When using any of these functions, it is a good idea to include
        !          1031: `stdio.h' before `mpfr.h', since that will allow `mpfr.h' to define
        !          1032: prototypes for these functions.
        !          1033:
        !          1034:  - Function: size_t mpfr_out_str (FILE *STREAM, int BASE, size_t
        !          1035:           N_DIGITS, mpfr_t OP, mp_rnd_t RND)
        !          1036:      Output OP on stdio stream STREAM, as a string of digits in base
        !          1037:      BASE, rounded to direction RND.  The base may vary from 2 to 36.
        !          1038:      Print at most N_DIGITS significant digits, or if N_DIGITS is 0,
        !          1039:      the maximum number of digits accurately representable by OP.
        !          1040:
        !          1041:      In addition to the significant digits, a decimal point at the
        !          1042:      right of the first digit and a trailing exponent, in the form
        !          1043:      `eNNN', are printed.  If BASE is greater than 10, `@' will be used
        !          1044:      instead of `e' as exponent delimiter.
        !          1045:
        !          1046:      Return the number of bytes written, or if an error occurred,
        !          1047:      return 0.
        !          1048:
        !          1049:  - Function: size_t mpfr_inp_str (mpfr_t ROP, FILE *STREAM, int BASE,
        !          1050:           mp_rnd_t RND)
        !          1051:      Input a string in base BASE from stdio stream STREAM, rounded in
        !          1052:      direction RND, and put the read float in ROP.  The string is of
        !          1053:      the form `M@N' or, if the base is 10 or less, alternatively `MeN'
        !          1054:      or `MEN'.  `M' is the mantissa and `N' is the exponent.  The
        !          1055:      mantissa is always in the specified base.  The exponent is in
        !          1056:      decimal.
        !          1057:
        !          1058:      The argument BASE may be in the range 2 to 36.
        !          1059:
        !          1060:      Unlike the corresponding `mpz' function, the base will not be
        !          1061:      determined from the leading characters of the string if BASE is 0.
        !          1062:      This is so that numbers like `0.23' are not interpreted as octal.
        !          1063:
        !          1064:      Return the number of bytes read, or if an error occurred, return 0.
        !          1065:
        !          1066:  - Function: void mpfr_print_binary (mpfr_t FLOAT)
        !          1067:      Output FLOAT on stdout in raw binary format (the exponent is in
        !          1068:      decimal, yet).  The last bits from the least significant limb
        !          1069:      which do not belong to the mantissa are printed between square
        !          1070:      brackets; they should always be zero.
        !          1071:
        !          1072: 
        !          1073: File: mpfr.info,  Node: Miscellaneous Float Functions,  Prev: I/O of Floats,  Up: Floating-point Functions
        !          1074:
        !          1075: Miscellaneous Functions
        !          1076: =======================
        !          1077:
        !          1078:  - Function: int mpfr_rint (mpfr_t ROP, mpfr_t OP, mp_rnd_t RND)
        !          1079:  - Function: int mpfr_ceil (mpfr_t ROP, mpfr_t OP)
        !          1080:  - Function: int mpfr_floor (mpfr_t ROP, mpfr_t OP)
        !          1081:  - Function: int mpfr_round (mpfr_t ROP, mpfr_t OP)
        !          1082:  - Function: int mpfr_trunc (mpfr_t ROP, mpfr_t OP)
        !          1083:      Set ROP to OP rounded to an integer. `mpfr_ceil' rounds to the
        !          1084:      next higher representable integer, `mpfr_floor' to the next lower,
        !          1085:      `mpfr_round' to the nearest representable integer, rounding
        !          1086:      halfway cases away from zero, and `mpfr_trunc' to the
        !          1087:      representable integer towards zero. `mpfr_rint' behaves like one
        !          1088:      of these four functions, depending on the rounding mode.  The
        !          1089:      returned value is zero when the result is exact, positive when it
        !          1090:      is greater than the original value of OP, and negative when it is
        !          1091:      smaller.  More precisely, the returned value is 0 when OP is an
        !          1092:      integer representable in ROP, 1 or -1 when OP is an integer that
        !          1093:      is not representable in ROP, 2 or -2 when OP is not an integer.
        !          1094:
        !          1095:  - Function: void mpfr_urandomb (mpfr_t ROP, gmp_randstate_t STATE)
        !          1096:      Generate a uniformly distributed random float in the interval 0 <=
        !          1097:      X < 1.
        !          1098:
        !          1099:  - Function: void mpfr_random (mpfr_t ROP)
        !          1100:      Generate a uniformly distributed random float in the interval 0 <=
        !          1101:      X < 1.
        !          1102:
        !          1103:  - Function: void mpfr_random2 (mpfr_t ROP, mp_size_t MAX_SIZE,
        !          1104:           mp_exp_t MAX_EXP)
        !          1105:      Generate a random float of at most MAX_SIZE limbs, with long
        !          1106:      strings of zeros and ones in the binary representation. The
        !          1107:      exponent of the number is in the interval -EXP to EXP.  This
        !          1108:      function is useful for testing functions and algorithms, since
        !          1109:      this kind of random numbers have proven to be more likely to
        !          1110:      trigger corner-case bugs.  Negative random numbers are generated
        !          1111:      when MAX_SIZE is negative.
        !          1112:
        !          1113: Internals
        !          1114: =========
        !          1115:
        !          1116:    These types and functions were mainly designed for the
        !          1117: implementation of `mpfr', but may be useful for users too.  However no
        !          1118: upward compatibility is guaranteed.  You need to include `mpfr-impl.h'
        !          1119: to use them.
        !          1120:
        !          1121:    The `mpfr_t' type consists of four fields.  The `_mpfr_prec' field
        !          1122: is used to store the precision of the variable (in bits); this is not
        !          1123: less than 2.
        !          1124:
        !          1125:    The `_mpfr_size' field is used to store the number of allocated
        !          1126: limbs, with the high bits reserved to store the sign (bit 31), the NaN
        !          1127: flag (bit 30), and the Infinity flag (bit 29); thus bits 0 to 28 remain
        !          1128: for the number of allocated limbs, with a maximal value of 536870911.
        !          1129: A NaN is indicated by the NaN flag set, and no other fields are
        !          1130: relevant.  An Infinity is indicated by the NaN flag clear and the Inf
        !          1131: flag set; the sign bit of an Infinity indicates the sign, the limb data
        !          1132: and the exponent are not relevant.
        !          1133:
        !          1134:    The `_mpfr_exp' field stores the exponent.  An exponent of 0 means a
        !          1135: radix point just above the most significant limb.  Non-zero values are
        !          1136: a multiplier 2^n relative to that point.
        !          1137:
        !          1138:    Finally, the `_mpfr_d' is a pointer to the limbs, least significant
        !          1139: limbs stored first.  The number zero is represented with its most
        !          1140: significant limb set to zero, i.e. `_mpfr_d[n-1]' where
        !          1141: n=ceil(`_mpfr_prec'/`BITS_PER_MP_LIMB').  The number of limbs in use is
        !          1142: controlled by `_mpfr_prec', namely
        !          1143: ceil(`_mpfr_prec'/`BITS_PER_MP_LIMB').  Zero is represented by the most
        !          1144: significant limb being zero, other limb data and the exponent are not
        !          1145: relevant ("not relevant" implies that the corresponding objects may
        !          1146: contain invalid values, thus should not be evaluated even if they are
        !          1147: not taken into account).  Non-zero values always have the most
        !          1148: significant bit of the most significant limb set to 1.  When the
        !          1149: precision is not a whole number of limbs, the excess bits at the low
        !          1150: end of the data are zero.  When the precision has been lowered by
        !          1151: `mpfr_set_prec', the space allocated at `_mpfr_d' remains as given by
        !          1152: `_mpfr_size', but `_mpfr_prec' indicates how much of that space is
        !          1153: actually used.
        !          1154:
        !          1155:  - Function: int mpfr_add_one_ulp (mpfr_t X, mp_rnd_t RND)
        !          1156:      Add one unit in last place (ulp) to X if X is finite and positive,
        !          1157:      subtract one ulp if X is finite and negative; otherwise, X is not
        !          1158:      changed.  The return value is zero unless an overflow occurs, in
        !          1159:      which case the `mpfr_add_one_ulp' function behaves like a
        !          1160:      conventional addition.
        !          1161:
        !          1162:  - Function: int mpfr_sub_one_ulp (mpfr_t X, mp_rnd_t RND)
        !          1163:      Subtract one ulp to X if X is finite and positive, add one ulp if
        !          1164:      X is finite and negative; otherwise, X is not changed.  The return
        !          1165:      value is zero unless an underflow occurs, in which case the
        !          1166:      `mpfr_sub_one_ulp' function behaves like a conventional
        !          1167:      subtraction.
        !          1168:
        !          1169:  - Function: int mpfr_can_round (mpfr_t B, mp_exp_t ERR, mp_rnd_t RND1,
        !          1170:           mp_rnd_t RND2, mp_prec_t PREC)
        !          1171:      Assuming B is an approximation of an unknown number X in direction
        !          1172:      RND1 with error at most two to the power E(b)-ERR where E(b) is
        !          1173:      the exponent of B, returns 1 if one is able to round exactly X to
        !          1174:      precision PREC with direction RND2,    and 0 otherwise. This
        !          1175:      function *does not modify* its arguments.
        !          1176:
        !          1177: 
        !          1178: File: mpfr.info,  Node: Contributors,  Next: References,  Prev: Floating-point Functions,  Up: Top
        !          1179:
        !          1180: Contributors
        !          1181: ************
        !          1182:
        !          1183:    The main developers consist of Guillaume Hanrot, Vincent Lefèvre and
        !          1184: Paul Zimmermann.
        !          1185:
        !          1186:    We would like to thank Jean-Michel Muller and Joris van der Hoeven
        !          1187: for very fruitful discussions at the beginning of that project,
        !          1188: Torbjorn Granlund and Kevin Ryde for their help about design issues and
        !          1189: their suggestions for an easy integration into GNU MP, and Nathalie
        !          1190: Revol for her careful reading of this documentation.
        !          1191:
        !          1192:    Sylvie Boldo from ENS-Lyon, France, contributed the functions
        !          1193: `mpfr_agm' and `mpfr_log'.  Emmanuel Jeandel, from ENS-Lyon too,
        !          1194: contributed the generic hypergeometric code in `generic.c', as well as
        !          1195: the `mpfr_exp3', a first implementation of the sine and cosine, and
        !          1196: improved versions of `mpfr_const_log2' and `mpfr_const_pi'.  Mathieu
        !          1197: Dutour contributed the functions `mpfr_atan' and `mpfr_asin', David
        !          1198: Daney contributed the hyperbolic and inverse hyperbolic functions, the
        !          1199: base-2 exponential, and the factorial function. Fabrice Rouillier
        !          1200: contributed the original version of `mul_ui.c', the `gmp_op.c' file,
        !          1201: and helped to the Windows porting.
        !          1202:
        !          1203: 
        !          1204: File: mpfr.info,  Node: References,  Next: Concept Index,  Prev: Contributors,  Up: Top
        !          1205:
        !          1206: References
        !          1207: **********
        !          1208:
        !          1209:    * Torbjorn Granlund, "GNU MP: The GNU Multiple Precision Arithmetic
        !          1210:      Library",   version 4.0.1, 2001.
        !          1211:
        !          1212:    * IEEE standard for binary floating-point arithmetic, Technical
        !          1213:      Report ANSI-IEEE Standard 754-1985, New York, 1985.  Approved
        !          1214:      March 21, 1985: IEEE Standards Board; approved July 26,   1985:
        !          1215:      American National Standards Institute, 18 pages.
        !          1216:
        !          1217:    * Donald E. Knuth, "The Art of Computer Programming", vol 2,
        !          1218:      "Seminumerical Algorithms", 2nd edition, Addison-Wesley, 1981.
        !          1219:
        !          1220:
        !          1221: 
        !          1222: File: mpfr.info,  Node: Concept Index,  Next: Function Index,  Prev: References,  Up: Top
        !          1223:
        !          1224: Concept Index
        !          1225: *************
        !          1226:
        !          1227: * Menu:
        !          1228:
        !          1229: * Arithmetic functions:                  Float Arithmetic.
        !          1230: * Comparison functions:                  Float Comparison.
        !          1231: * Conditions for copying MPFR:           Copying.
        !          1232: * Conversion functions:                  Converting Floats.
        !          1233: * Copying conditions:                    Copying.
        !          1234: * Float arithmetic functions:            Float Arithmetic.
        !          1235: * Float assignment functions:            Assigning Floats.
        !          1236: * Float comparisons functions:           Float Comparison.
        !          1237: * Float functions:                       Floating-point Functions.
        !          1238: * Float input and output functions:      I/O of Floats.
        !          1239: * Floating-point functions:              Floating-point Functions.
        !          1240: * Floating-point number:                 MPFR Basics.
        !          1241: * I/O functions:                         I/O of Floats.
        !          1242: * Initialization and assignment functions: Simultaneous Float Init & Assign.
        !          1243: * Input functions:                       I/O of Floats.
        !          1244: * Installation:                          Installing MPFR.
        !          1245: * Limb:                                  MPFR Basics.
        !          1246: * Miscellaneous float functions:         Miscellaneous Float Functions.
        !          1247: * mpfr.h:                                MPFR Basics.
        !          1248: * Output functions:                      I/O of Floats.
        !          1249: * Precision:                             MPFR Basics.
        !          1250: * Reporting bugs:                        Reporting Bugs.
        !          1251: * Rounding Mode:                         MPFR Basics.
        !          1252: * Rounding modes:                        Rounding Modes.
        !          1253: * Special functions:                     Float Comparison.
        !          1254: * User-defined precision:                Floating-point Functions.
        !          1255:
        !          1256: 
        !          1257: File: mpfr.info,  Node: Function Index,  Prev: Concept Index,  Up: Top
        !          1258:
        !          1259: Function and Type Index
        !          1260: ***********************
        !          1261:
        !          1262: * Menu:
        !          1263:
        !          1264: * mp_prec_t:                             MPFR Basics.
        !          1265: * mp_rnd_t:                              MPFR Basics.
        !          1266: * mpfr_abs:                              Float Arithmetic.
        !          1267: * mpfr_acos:                             Float Comparison.
        !          1268: * mpfr_acosh:                            Float Comparison.
        !          1269: * mpfr_add:                              Float Arithmetic.
        !          1270: * mpfr_add_one_ulp:                      Miscellaneous Float Functions.
        !          1271: * mpfr_add_q:                            Float Arithmetic.
        !          1272: * mpfr_add_ui:                           Float Arithmetic.
        !          1273: * mpfr_add_z:                            Float Arithmetic.
        !          1274: * mpfr_agm:                              Float Comparison.
        !          1275: * mpfr_asin:                             Float Comparison.
        !          1276: * mpfr_asinh:                            Float Comparison.
        !          1277: * mpfr_atan:                             Float Comparison.
        !          1278: * mpfr_atanh:                            Float Comparison.
        !          1279: * mpfr_can_round:                        Miscellaneous Float Functions.
        !          1280: * mpfr_ceil:                             Miscellaneous Float Functions.
        !          1281: * mpfr_check_range:                      Exceptions.
        !          1282: * mpfr_clear:                            Initializing Floats.
        !          1283: * mpfr_clear_flags:                      Exceptions.
        !          1284: * mpfr_clear_inexflag:                   Exceptions.
        !          1285: * mpfr_clear_nanflag:                    Exceptions.
        !          1286: * mpfr_clear_overflow:                   Exceptions.
        !          1287: * mpfr_clear_underflow:                  Exceptions.
        !          1288: * mpfr_cmp:                              Float Comparison.
        !          1289: * mpfr_cmp_si:                           Float Comparison.
        !          1290: * mpfr_cmp_si_2exp:                      Float Comparison.
        !          1291: * mpfr_cmp_ui:                           Float Comparison.
        !          1292: * mpfr_cmp_ui_2exp:                      Float Comparison.
        !          1293: * mpfr_const_euler:                      Float Comparison.
        !          1294: * mpfr_const_log2:                       Float Comparison.
        !          1295: * mpfr_const_pi:                         Float Comparison.
        !          1296: * mpfr_cos:                              Float Comparison.
        !          1297: * mpfr_cosh:                             Float Comparison.
        !          1298: * mpfr_div:                              Float Arithmetic.
        !          1299: * mpfr_div_2exp:                         Float Arithmetic.
        !          1300: * mpfr_div_2si:                          Float Arithmetic.
        !          1301: * mpfr_div_2ui:                          Float Arithmetic.
        !          1302: * mpfr_div_q:                            Float Arithmetic.
        !          1303: * mpfr_div_ui:                           Float Arithmetic.
        !          1304: * mpfr_div_z:                            Float Arithmetic.
        !          1305: * mpfr_eq:                               Float Comparison.
        !          1306: * mpfr_exp:                              Float Comparison.
        !          1307: * mpfr_exp2:                             Float Comparison.
        !          1308: * mpfr_expm1:                            Float Comparison.
        !          1309: * mpfr_fac_ui:                           Float Comparison.
        !          1310: * mpfr_floor:                            Miscellaneous Float Functions.
        !          1311: * mpfr_fma:                              Float Comparison.
        !          1312: * mpfr_get_d:                            Converting Floats.
        !          1313: * mpfr_get_d1:                           Converting Floats.
        !          1314: * mpfr_get_default_prec:                 Initializing Floats.
        !          1315: * mpfr_get_emax:                         Exceptions.
        !          1316: * mpfr_get_emin:                         Exceptions.
        !          1317: * mpfr_get_prec:                         Initializing Floats.
        !          1318: * mpfr_get_str:                          Converting Floats.
        !          1319: * mpfr_get_z_exp:                        Converting Floats.
        !          1320: * mpfr_inexflag_p:                       Exceptions.
        !          1321: * mpfr_inf_p:                            Float Comparison.
        !          1322: * mpfr_init:                             Initializing Floats.
        !          1323: * mpfr_init2:                            Initializing Floats.
        !          1324: * mpfr_init_set:                         Simultaneous Float Init & Assign.
        !          1325: * mpfr_init_set_d:                       Simultaneous Float Init & Assign.
        !          1326: * mpfr_init_set_f:                       Simultaneous Float Init & Assign.
        !          1327: * mpfr_init_set_q:                       Simultaneous Float Init & Assign.
        !          1328: * mpfr_init_set_si:                      Simultaneous Float Init & Assign.
        !          1329: * mpfr_init_set_str:                     Simultaneous Float Init & Assign.
        !          1330: * mpfr_init_set_ui:                      Simultaneous Float Init & Assign.
        !          1331: * mpfr_init_set_z:                       Simultaneous Float Init & Assign.
        !          1332: * mpfr_inp_str:                          I/O of Floats.
        !          1333: * mpfr_log:                              Float Comparison.
        !          1334: * mpfr_log10:                            Float Comparison.
        !          1335: * mpfr_log1p:                            Float Comparison.
        !          1336: * mpfr_log2:                             Float Comparison.
        !          1337: * mpfr_mul:                              Float Arithmetic.
        !          1338: * mpfr_mul_2exp:                         Float Arithmetic.
        !          1339: * mpfr_mul_2si:                          Float Arithmetic.
        !          1340: * mpfr_mul_2ui:                          Float Arithmetic.
        !          1341: * mpfr_mul_q:                            Float Arithmetic.
        !          1342: * mpfr_mul_ui:                           Float Arithmetic.
        !          1343: * mpfr_mul_z:                            Float Arithmetic.
        !          1344: * mpfr_nan_p:                            Float Comparison.
        !          1345: * mpfr_nanflag_p:                        Exceptions.
        !          1346: * mpfr_neg:                              Float Arithmetic.
        !          1347: * mpfr_number_p:                         Float Comparison.
        !          1348: * mpfr_out_str:                          I/O of Floats.
        !          1349: * mpfr_overflow_p:                       Exceptions.
        !          1350: * mpfr_pow:                              Float Arithmetic.
        !          1351: * mpfr_pow_si:                           Float Arithmetic.
        !          1352: * mpfr_pow_ui:                           Float Arithmetic.
        !          1353: * mpfr_print_binary:                     I/O of Floats.
        !          1354: * mpfr_print_rnd_mode:                   Rounding Modes.
        !          1355: * mpfr_random:                           Miscellaneous Float Functions.
        !          1356: * mpfr_random2:                          Miscellaneous Float Functions.
        !          1357: * mpfr_reldiff:                          Float Comparison.
        !          1358: * mpfr_rint:                             Miscellaneous Float Functions.
        !          1359: * mpfr_round:                            Miscellaneous Float Functions.
        !          1360: * mpfr_round_prec:                       Rounding Modes.
        !          1361: * mpfr_set:                              Assigning Floats.
        !          1362: * mpfr_set_d:                            Assigning Floats.
        !          1363: * mpfr_set_default_prec:                 Initializing Floats.
        !          1364: * mpfr_set_default_rounding_mode:        Rounding Modes.
        !          1365: * mpfr_set_emax:                         Exceptions.
        !          1366: * mpfr_set_emin:                         Exceptions.
        !          1367: * mpfr_set_f:                            Assigning Floats.
        !          1368: * mpfr_set_inf:                          Assigning Floats.
        !          1369: * mpfr_set_machine_rnd_mode:             Rounding Modes.
        !          1370: * mpfr_set_nan:                          Assigning Floats.
        !          1371: * mpfr_set_prec:                         Initializing Floats.
        !          1372: * mpfr_set_prec_raw:                     Initializing Floats.
        !          1373: * mpfr_set_q:                            Assigning Floats.
        !          1374: * mpfr_set_si:                           Assigning Floats.
        !          1375: * mpfr_set_str:                          Assigning Floats.
        !          1376: * mpfr_set_str_raw:                      Assigning Floats.
        !          1377: * mpfr_set_ui:                           Assigning Floats.
        !          1378: * mpfr_set_z:                            Assigning Floats.
        !          1379: * mpfr_sgn:                              Float Comparison.
        !          1380: * mpfr_sin:                              Float Comparison.
        !          1381: * mpfr_sin_cos:                          Float Comparison.
        !          1382: * mpfr_sinh:                             Float Comparison.
        !          1383: * mpfr_sqrt:                             Float Arithmetic.
        !          1384: * mpfr_sqrt_ui:                          Float Arithmetic.
        !          1385: * mpfr_sub:                              Float Arithmetic.
        !          1386: * mpfr_sub_one_ulp:                      Miscellaneous Float Functions.
        !          1387: * mpfr_sub_q:                            Float Arithmetic.
        !          1388: * mpfr_sub_ui:                           Float Arithmetic.
        !          1389: * mpfr_sub_z:                            Float Arithmetic.
        !          1390: * mpfr_swap:                             Assigning Floats.
        !          1391: * mpfr_t:                                MPFR Basics.
        !          1392: * mpfr_tan:                              Float Comparison.
        !          1393: * mpfr_tanh:                             Float Comparison.
        !          1394: * mpfr_trunc:                            Miscellaneous Float Functions.
        !          1395: * mpfr_ui_div:                           Float Arithmetic.
        !          1396: * mpfr_ui_pow:                           Float Arithmetic.
        !          1397: * mpfr_ui_pow_ui:                        Float Arithmetic.
        !          1398: * mpfr_ui_sub:                           Float Arithmetic.
        !          1399: * mpfr_underflow_p:                      Exceptions.
        !          1400: * mpfr_urandomb:                         Miscellaneous Float Functions.
        !          1401:
        !          1402:
        !          1403: 
        !          1404: Tag Table:
        !          1405: Node: Top1010
        !          1406: Node: Copying1677
        !          1407: Node: Introduction to MPFR3397
        !          1408: Node: Installing MPFR5133
        !          1409: Node: Reporting Bugs7665
        !          1410: Node: MPFR Basics9195
        !          1411: Node: Floating-point Functions13276
        !          1412: Node: Rounding Modes15114
        !          1413: Node: Exceptions18227
        !          1414: Node: Initializing Floats20496
        !          1415: Node: Assigning Floats24168
        !          1416: Node: Simultaneous Float Init & Assign27386
        !          1417: Node: Converting Floats28627
        !          1418: Node: Float Arithmetic31301
        !          1419: Node: Float Comparison37456
        !          1420: Node: I/O of Floats45234
        !          1421: Node: Miscellaneous Float Functions47671
        !          1422: Node: Contributors52903
        !          1423: Node: References54098
        !          1424: Node: Concept Index54714
        !          1425: Node: Function Index56376
        !          1426: 
        !          1427: End Tag Table

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>