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>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mpfr.info CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp / mpfr