This is gmp.info, produced by makeinfo version 4.0 from gmp.texi.

START-INFO-DIR-ENTRY
* gmp: (gmp.info).               GNU Multiple Precision Arithmetic Library.
END-INFO-DIR-ENTRY

   This file documents GNU MP, a library for arbitrary-precision
arithmetic.

   Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
Free Software Foundation, Inc.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that
the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that this permission notice may be stated in a
translation approved by the Foundation.


File: gmp.info,  Node: Random State Initialization,  Prev: Random Number Functions,  Up: Random Number Functions

Random State Initialization
===========================

   See *Note Random Number Functions:: for a discussion on how to
choose the initial seed value passed to these functions.

 - Function: int gmp_randinit (gmp_randstate_t STATE, unsigned long int
     SIZE, gmp_randalg_t ALG) Initialize random state variable STATE.

     ALG denotes what algorithm to use for random number generation.
     Use one of
        - GMP_RAND_ALG_LC -- Linear congruential.

          A fast generator defined by X = (aX + c) mod m.

          a, c, and m are picked from a table where the modulus (m) is
          a power of 2 and the multiplier is congruent to 5 (mod 8).
          All schemes in the table have passed the spectral test, as
          defined by [D. Knuth, "The Art of Computer Programming:
          Volume 2, Seminumerical Algorithms", Third Edition, Addison
          Wesley, 1998, p.93.].  The choice is based on the SIZE
          parameter.  The maximum SIZE supported by this algorithm is
          128.  If you need bigger random numbers, use your own scheme
          and call one of the other `gmp_randinit' functions.


     If ALG is 0 or GMP_RAND_ALG_DEFAULT, the default algorithm is
     used.  The default algorithm is typically a fast algorithm like the
     linear congruential.

     SIZE is the size of the largest good quality random number to be
     generated, expressed in number of bits.  If the random generation
     functions are asked for a bigger random number than indicated by
     this parameter, two or more numbers of SIZE bits will be generated
     and concatenated, resulting in a "bad" random number.  This can be
     used to generate big random numbers relatively cheap if the
     quality of randomness isn't of great importance.

     When you're done with a STATE variable, call `gmp_randclear' to
     deallocate any memory allocated by this function.

     `gmp_randinit' may set the following bits in GMP_ERRNO:
        * GMP_ERROR_UNSUPPORTED_ARGUMENT -- ALG is unsupported

        * GMP_ERROR_INVALID_ARGUMENT -- SIZE is too big

 - Function: void gmp_randinit_lc_2exp (gmp_randstate_t STATE, mpz_t A,
     unsigned long int C, unsigned long int M2EXP)

     Initialize random state variable STATE with given linear
     congruential scheme.

     Parameters A, C, and M2EXP are the multiplier, adder, and modulus
     for the linear congruential scheme to use, respectively.  The
     modulus is expressed as a power of 2, so that M = 2^M2EXP.

     The least significant bits of a random number generated by the
     linear congruential algorithm where the modulus is a power of two
     are not very random.  Therefore, the lower half of a random number
     generated by an LC scheme initialized with this function is
     discarded.  Thus, the size of a random number is M2EXP / 2
     (rounded upwards) bits when this function has been used for
     initializing the random state.

     When you're done with a STATE variable, call `gmp_randclear' to
     deallocate any memory allocated by this function.

 - Function: void gmp_randseed (gmp_randstate_t STATE, mpz_t SEED)
 - Function: void gmp_randseed_ui (gmp_randstate_t STATE, unsigned long
          int SEED)
     Set the initial seed value.

     Parameter SEED is the initial random seed.  The function
     `gmp_randseed_ui' takes the SEED as an unsigned long int rather
     than as an mpz_t.

 - Function: void gmp_randclear (gmp_randstate_t STATE)
     Free all memory occupied by STATE.  Make sure to call this
     function for all `gmp_randstate_t' variables when you are done with
     them.


File: gmp.info,  Node: BSD Compatible Functions,  Next: Custom Allocation,  Prev: Random Number Functions,  Up: Top

Berkeley MP Compatible Functions
********************************

   These functions are intended to be fully compatible with the
Berkeley MP library which is available on many BSD derived U*ix
systems.  The `--enable-mpbsd' option must be used when building GNU MP
to make these available (*note Installing GMP::).

   The original Berkeley MP library has a usage restriction: you cannot
use the same variable as both source and destination in a single
function call.  The compatible functions in GNU MP do not share this
restriction--inputs and outputs may overlap.

   It is not recommended that new programs are written using these
functions.  Apart from the incomplete set of functions, the interface
for initializing `MINT' objects is more error prone, and the `pow'
function collides with `pow' in `libm.a'.

   Include the header `mp.h' to get the definition of the necessary
types and functions.  If you are on a BSD derived system, make sure to
include GNU `mp.h' if you are going to link the GNU `libmp.a' to your
program.  This means that you probably need to give the -I<dir> option
to the compiler, where <dir> is the directory where you have GNU `mp.h'.

 - Function: MINT * itom (signed short int INITIAL_VALUE)
     Allocate an integer consisting of a `MINT' object and dynamic limb
     space.  Initialize the integer to INITIAL_VALUE.  Return a pointer
     to the `MINT' object.

 - Function: MINT * xtom (char *INITIAL_VALUE)
     Allocate an integer consisting of a `MINT' object and dynamic limb
     space.  Initialize the integer from INITIAL_VALUE, a hexadecimal,
     '\0'-terminate C string.  Return a pointer to the `MINT' object.

 - Function: void move (MINT *SRC, MINT *DEST)
     Set DEST to SRC by copying.  Both variables must be previously
     initialized.

 - Function: void madd (MINT *SRC_1, MINT *SRC_2, MINT *DESTINATION)
     Add SRC_1 and SRC_2 and put the sum in DESTINATION.

 - Function: void msub (MINT *SRC_1, MINT *SRC_2, MINT *DESTINATION)
     Subtract SRC_2 from SRC_1 and put the difference in DESTINATION.

 - Function: void mult (MINT *SRC_1, MINT *SRC_2, MINT *DESTINATION)
     Multiply SRC_1 and SRC_2 and put the product in DESTINATION.

 - Function: void mdiv (MINT *DIVIDEND, MINT *DIVISOR, MINT *QUOTIENT,
          MINT *REMAINDER)
 - Function: void sdiv (MINT *DIVIDEND, signed short int DIVISOR, MINT
          *QUOTIENT, signed short int *REMAINDER)
     Set QUOTIENT to DIVIDEND/DIVISOR, and REMAINDER to DIVIDEND mod
     DIVISOR.  The quotient is rounded towards zero; the remainder has
     the same sign as the dividend unless it is zero.

     Some implementations of these functions work differently--or not
     at all--for negative arguments.

 - Function: void msqrt (MINT *OPERAND, MINT *ROOT, MINT *REMAINDER)
     Set ROOT to the truncated integer part of the square root of
     OPERAND.  Set REMAINDER to OPERAND-ROOT*ROOT, (i.e., zero if
     OPERAND is a perfect square).

     If ROOT and REMAINDER are the same variable, the results are
     undefined.

 - Function: void pow (MINT *BASE, MINT *EXP, MINT *MOD, MINT *DEST)
     Set DEST to (BASE raised to EXP) modulo MOD.

 - Function: void rpow (MINT *BASE, signed short int EXP, MINT *DEST)
     Set DEST to BASE raised to EXP.

 - Function: void gcd (MINT *OPERAND1, MINT *OPERAND2, MINT *RES)
     Set RES to the greatest common divisor of OPERAND1 and OPERAND2.

 - Function: int mcmp (MINT *OPERAND1, MINT *OPERAND2)
     Compare OPERAND1 and OPERAND2.  Return a positive value if
     OPERAND1 > OPERAND2, zero if OPERAND1 = OPERAND2, and a negative
     value if OPERAND1 < OPERAND2.

 - Function: void min (MINT *DEST)
     Input a decimal string from `stdin', and put the read integer in
     DEST.  SPC and TAB are allowed in the number string, and are
     ignored.

 - Function: void mout (MINT *SRC)
     Output SRC to `stdout', as a decimal string.  Also output a
     newline.

 - Function: char * mtox (MINT *OPERAND)
     Convert OPERAND to a hexadecimal string, and return a pointer to
     the string.  The returned string is allocated using the default
     memory allocation function, `malloc' by default.

 - Function: void mfree (MINT *OPERAND)
     De-allocate, the space used by OPERAND.  *This function should
     only be passed a value returned by `itom' or `xtom'.*


File: gmp.info,  Node: Custom Allocation,  Next: Contributors,  Prev: BSD Compatible Functions,  Up: Top

Custom Allocation
*****************

   By default, the GMP functions use `malloc', `realloc', and `free'
for memory allocation.  If `malloc' or `realloc' fails, the GMP library
terminates execution after printing a fatal error message to standard
error.

   For some applications, you may wish to allocate memory in other
ways, or you may not want to have a fatal error when there is no more
memory available.  To accomplish this, you can specify alternative
memory allocation functions.

 - Function: void mp_set_memory_functions (
          void *(*ALLOC_FUNC_PTR) (size_t),
          void *(*REALLOC_FUNC_PTR) (void *, size_t, size_t),
          void (*FREE_FUNC_PTR) (void *, size_t))
     Replace the current allocation functions from the arguments.  If
     an argument is NULL, the corresponding default function is
     retained.

     *Make sure to call this function in such a way that there are no
     active GMP objects that were allocated using the previously active
     allocation function!  Usually, that means that you have to call
     this function before any other GMP function.*

   The functions you supply should fit the following declarations:

 - Function: void * allocate_function (size_t ALLOC_SIZE)
     This function should return a pointer to newly allocated space
     with at least ALLOC_SIZE storage units.

 - Function: void * reallocate_function (void *PTR, size_t OLD_SIZE,
          size_t NEW_SIZE)
     This function should return a pointer to newly allocated space of
     at least NEW_SIZE storage units, after copying at least the first
     OLD_SIZE storage units from PTR.  It should also de-allocate the
     space at PTR.

     You can assume that the space at PTR was formerly returned from
     `allocate_function' or `reallocate_function', for a request for
     OLD_SIZE storage units.

 - Function: void deallocate_function (void *PTR, size_t SIZE)
     De-allocate the space pointed to by PTR.

     You can assume that the space at PTR was formerly returned from
     `allocate_function' or `reallocate_function', for a request for
     SIZE storage units.

   (A "storage unit" is the unit in which the `sizeof' operator returns
the size of an object, normally an 8 bit byte.)


File: gmp.info,  Node: Contributors,  Next: References,  Prev: Custom Allocation,  Up: Top

Contributors
************

   Torbjorn Granlund wrote the original GMP library and is still
developing and maintaining it.  Several other individuals and
organizations have contributed to GMP in various ways.  Here is a list
in chronological order:

   Gunnar Sjoedin and Hans Riesel helped with mathematical problems in
early versions of the library.

   Richard Stallman contributed to the interface design and revised the
first version of this manual.

   Brian Beuning and Doug Lea helped with testing of early versions of
the library and made creative suggestions.

   John Amanatides of York University in Canada contributed the function
`mpz_probab_prime_p'.

   Paul Zimmermann of Inria sparked the development of GMP 2, with his
comparisons between bignum packages.

   Ken Weber (Kent State University, Universidade Federal do Rio Grande
do Sul) contributed `mpz_gcd', `mpz_divexact', `mpn_gcd', and
`mpn_bdivmod', partially supported by CNPq (Brazil) grant 301314194-2.

   Per Bothner of Cygnus Support helped to set up GMP to use Cygnus'
configure.  He has also made valuable suggestions and tested numerous
intermediary releases.

   Joachim Hollman was involved in the design of the `mpf' interface,
and in the `mpz' design revisions for version 2.

   Bennet Yee contributed the functions `mpz_jacobi' and `mpz_legendre'.

   Andreas Schwab contributed the files `mpn/m68k/lshift.S' and
`mpn/m68k/rshift.S'.

   The development of floating point functions of GNU MP 2, were
supported in part by the ESPRIT-BRA (Basic Research Activities) 6846
project POSSO (POlynomial System SOlving).

   GNU MP 2 was finished and released by SWOX AB (formerly known as TMG
Datakonsult), Swedenborgsgatan 23, SE-118 27 STOCKHOLM, SWEDEN, in
cooperation with the IDA Center for Computing Sciences, USA.

   Robert Harley of Inria, France and David Seal of ARM, England,
suggested clever improvements for population count.

   Robert Harley also wrote highly optimized Karatsuba and 3-way Toom
multiplication functions for GMP 3.

   Torsten Ekedahl of the Mathematical department of Stockholm
University provided significant inspiration during several phases of
the GMP development.  His mathematical expertise helped improve several
algorithms.

   Paul Zimmermann wrote the Burnikel-Ziegler division code, the REDC
code, and the new mpz_powm code that uses Hensel lifting.  The ECMNET
project Paul is organizing has been a driving force behind many of the
optimization of GMP 3.

   Linus Nordberg wrote the new configure system based on autoconf and
implemented the new random functions.

   Kent Boortz made the Macintosh port.

   Kevin Ryde wrote a lot of very high quality x86 code, optimized for
most CPU variants.  He also made countless other valuable contributions.

   GNU MP 3 was finished and released by Torbjorn Granlund and Linus
Nordberg of SWOX AB, and volunteer Kevin Ryde.  The work was partially
funded by the IDA Center for Computing Sciences, USA.

   (This list is chronological, not ordered after significance.  If you
have contributed to GMP but are not listed above, please tell
<tege@swox.com> about the omission!)


File: gmp.info,  Node: References,  Prev: Contributors,  Up: Top

References
**********

   * Donald E. Knuth, "The Art of Computer Programming", vol 2,
     "Seminumerical Algorithms", 3rd edition, Addison-Wesley, 1988.

   * John D. Lipson, "Elements of Algebra and Algebraic Computing", The
     Benjamin Cummings Publishing Company Inc, 1981.

   * Richard M. Stallman, "Using and Porting GCC", Free Software
     Foundation, 1999, `ftp://ftp.gnu.org/pub/gnu/gcc/'.

   * Peter L. Montgomery, "Modular Multiplication Without Trial
     Division", in Mathematics of Computation, volume 44, number 170,
     April 1985.

   * Torbjorn Granlund and Peter L. Montgomery, "Division by Invariant
     Integers using Multiplication", in Proceedings of the SIGPLAN
     PLDI'94 Conference, June 1994.

   * Tudor Jebelean, "An algorithm for exact division", Journal of
     Symbolic Computation, v. 15, 1993, pp. 169-180.

   * Kenneth Weber, "The accelerated integer GCD algorithm", ACM
     Transactions on Mathematical Software, v. 21 (March), 1995, pp.
     111-122.

   * Christoph Burnikel and Joachim Ziegler, "Fast Recursive Division",
     Max-Planck-Institut fuer Informatik Research Report MPI-I-98-1-022,
     `http://www.mpi-sb.mpg.de/~ziegler/TechRep.ps.gz'.


File: gmp.info,  Node: Concept Index,  Up: Top

Concept Index
*************

* Menu:

* Arithmetic functions <1>:              Float Arithmetic.
* Arithmetic functions:                  Integer Arithmetic.
* Bit manipulation functions:            Integer Logic and Bit Fiddling.
* BSD MP compatible functions:           BSD Compatible Functions.
* Comparison functions:                  Float Comparison.
* Conditions for copying GNU MP:         Copying.
* Conversion functions <1>:              Converting Integers.
* Conversion functions:                  Converting Floats.
* Copying conditions:                    Copying.
* Float arithmetic functions:            Float Arithmetic.
* Float assignment functions:            Assigning Floats.
* Float comparisons functions:           Float Comparison.
* Float functions:                       Floating-point Functions.
* Float input and output functions:      I/O of Floats.
* Floating-point functions:              Floating-point Functions.
* Floating-point number:                 Nomenclature and Types.
* gmp.h:                                 GMP Basics.
* I/O functions <1>:                     I/O of Integers.
* I/O functions:                         I/O of Floats.
* Initialization and assignment functions <1>: Simultaneous Float Init & Assign.
* Initialization and assignment functions: Simultaneous Integer Init & Assign.
* Input functions <1>:                   I/O of Integers.
* Input functions:                       I/O of Floats.
* Installation:                          Installing GMP.
* Integer:                               Nomenclature and Types.
* Integer arithmetic functions:          Integer Arithmetic.
* Integer assignment functions:          Assigning Integers.
* Integer conversion functions:          Converting Integers.
* Integer functions:                     Integer Functions.
* Integer input and output functions:    I/O of Integers.
* Limb:                                  Nomenclature and Types.
* Logical functions:                     Integer Logic and Bit Fiddling.
* Low-level functions:                   Low-level Functions.
* Miscellaneous float functions:         Miscellaneous Float Functions.
* Miscellaneous integer functions:       Miscellaneous Integer Functions.
* mp.h:                                  BSD Compatible Functions.
* Output functions <1>:                  I/O of Floats.
* Output functions:                      I/O of Integers.
* Random Number Functions:               Random Number Functions.
* Rational number:                       Nomenclature and Types.
* Rational number functions:             Rational Number Functions.
* Reporting bugs:                        Reporting Bugs.
* User-defined precision:                Floating-point Functions.


File: gmp.info,  Node: Function Index,  Up: Top

Function and Type Index
***********************

* Menu:

* __GNU_MP_VERSION:                      Useful Macros and Constants.
* __GNU_MP_VERSION_MINOR:                Useful Macros and Constants.
* __GNU_MP_VERSION_PATCHLEVEL:           Useful Macros and Constants.
* _mpz_realloc:                          Initializing Integers.
* allocate_function:                     Custom Allocation.
* deallocate_function:                   Custom Allocation.
* gcd:                                   BSD Compatible Functions.
* gmp_randclear:                         Random State Initialization.
* gmp_randinit:                          Random State Initialization.
* gmp_randinit_lc_2exp:                  Random State Initialization.
* gmp_randseed:                          Random State Initialization.
* gmp_randseed_ui:                       Random State Initialization.
* itom:                                  BSD Compatible Functions.
* madd:                                  BSD Compatible Functions.
* mcmp:                                  BSD Compatible Functions.
* mdiv:                                  BSD Compatible Functions.
* mfree:                                 BSD Compatible Functions.
* min:                                   BSD Compatible Functions.
* mout:                                  BSD Compatible Functions.
* move:                                  BSD Compatible Functions.
* mp_limb_t:                             Nomenclature and Types.
* mp_set_memory_functions:               Custom Allocation.
* mpf_abs:                               Float Arithmetic.
* mpf_add:                               Float Arithmetic.
* mpf_add_ui:                            Float Arithmetic.
* mpf_ceil:                              Miscellaneous Float Functions.
* mpf_clear:                             Initializing Floats.
* mpf_cmp:                               Float Comparison.
* mpf_cmp_si:                            Float Comparison.
* mpf_cmp_ui:                            Float Comparison.
* mpf_div:                               Float Arithmetic.
* mpf_div_2exp:                          Float Arithmetic.
* mpf_div_ui:                            Float Arithmetic.
* mpf_eq:                                Float Comparison.
* mpf_floor:                             Miscellaneous Float Functions.
* mpf_get_d:                             Converting Floats.
* mpf_get_prec:                          Initializing Floats.
* mpf_get_str:                           Converting Floats.
* mpf_init:                              Initializing Floats.
* mpf_init2:                             Initializing Floats.
* mpf_init_set:                          Simultaneous Float Init & Assign.
* mpf_init_set_d:                        Simultaneous Float Init & Assign.
* mpf_init_set_si:                       Simultaneous Float Init & Assign.
* mpf_init_set_str:                      Simultaneous Float Init & Assign.
* mpf_init_set_ui:                       Simultaneous Float Init & Assign.
* mpf_inp_str:                           I/O of Floats.
* mpf_mul:                               Float Arithmetic.
* mpf_mul_2exp:                          Float Arithmetic.
* mpf_mul_ui:                            Float Arithmetic.
* mpf_neg:                               Float Arithmetic.
* mpf_out_str:                           I/O of Floats.
* mpf_pow_ui:                            Float Arithmetic.
* mpf_random2:                           Miscellaneous Float Functions.
* mpf_reldiff:                           Float Comparison.
* mpf_set:                               Assigning Floats.
* mpf_set_d:                             Assigning Floats.
* mpf_set_default_prec:                  Initializing Floats.
* mpf_set_prec:                          Initializing Floats.
* mpf_set_prec_raw:                      Initializing Floats.
* mpf_set_q:                             Assigning Floats.
* mpf_set_si:                            Assigning Floats.
* mpf_set_str:                           Assigning Floats.
* mpf_set_ui:                            Assigning Floats.
* mpf_set_z:                             Assigning Floats.
* mpf_sgn:                               Float Comparison.
* mpf_sqrt:                              Float Arithmetic.
* mpf_sqrt_ui:                           Float Arithmetic.
* mpf_sub:                               Float Arithmetic.
* mpf_sub_ui:                            Float Arithmetic.
* mpf_t:                                 Nomenclature and Types.
* mpf_trunc:                             Miscellaneous Float Functions.
* mpf_ui_div:                            Float Arithmetic.
* mpf_ui_sub:                            Float Arithmetic.
* mpf_urandomb:                          Miscellaneous Float Functions.
* mpn_add:                               Low-level Functions.
* mpn_add_1:                             Low-level Functions.
* mpn_add_n:                             Low-level Functions.
* mpn_addmul_1:                          Low-level Functions.
* mpn_bdivmod:                           Low-level Functions.
* mpn_cmp:                               Low-level Functions.
* mpn_divexact_by3:                      Low-level Functions.
* mpn_divmod:                            Low-level Functions.
* mpn_divmod_1:                          Low-level Functions.
* mpn_divrem:                            Low-level Functions.
* mpn_divrem_1:                          Low-level Functions.
* mpn_gcd:                               Low-level Functions.
* mpn_gcd_1:                             Low-level Functions.
* mpn_gcdext:                            Low-level Functions.
* mpn_get_str:                           Low-level Functions.
* mpn_hamdist:                           Low-level Functions.
* mpn_lshift:                            Low-level Functions.
* mpn_mod_1:                             Low-level Functions.
* mpn_mul:                               Low-level Functions.
* mpn_mul_1:                             Low-level Functions.
* mpn_mul_n:                             Low-level Functions.
* mpn_perfect_square_p:                  Low-level Functions.
* mpn_popcount:                          Low-level Functions.
* mpn_preinv_mod_1:                      Low-level Functions.
* mpn_random:                            Low-level Functions.
* mpn_random2:                           Low-level Functions.
* mpn_rshift:                            Low-level Functions.
* mpn_scan0:                             Low-level Functions.
* mpn_scan1:                             Low-level Functions.
* mpn_set_str:                           Low-level Functions.
* mpn_sqrtrem:                           Low-level Functions.
* mpn_sub:                               Low-level Functions.
* mpn_sub_1:                             Low-level Functions.
* mpn_sub_n:                             Low-level Functions.
* mpn_submul_1:                          Low-level Functions.
* mpq_add:                               Assigning Rationals.
* mpq_canonicalize:                      Rational Number Functions.
* mpq_clear:                             Initializing Rationals.
* mpq_cmp:                               Comparing Rationals.
* mpq_cmp_ui:                            Comparing Rationals.
* mpq_denref:                            Applying Integer Functions.
* mpq_div:                               Assigning Rationals.
* mpq_equal:                             Comparing Rationals.
* mpq_get_d:                             Miscellaneous Rational Functions.
* mpq_get_den:                           Miscellaneous Rational Functions.
* mpq_get_num:                           Miscellaneous Rational Functions.
* mpq_init:                              Initializing Rationals.
* mpq_inv:                               Assigning Rationals.
* mpq_mul:                               Assigning Rationals.
* mpq_neg:                               Assigning Rationals.
* mpq_numref:                            Applying Integer Functions.
* mpq_set:                               Initializing Rationals.
* mpq_set_d:                             Miscellaneous Rational Functions.
* mpq_set_den:                           Miscellaneous Rational Functions.
* mpq_set_num:                           Miscellaneous Rational Functions.
* mpq_set_si:                            Initializing Rationals.
* mpq_set_ui:                            Initializing Rationals.
* mpq_set_z:                             Initializing Rationals.
* mpq_sgn:                               Comparing Rationals.
* mpq_sub:                               Assigning Rationals.
* mpq_t:                                 Nomenclature and Types.
* mpz_abs:                               Integer Arithmetic.
* mpz_add:                               Integer Arithmetic.
* mpz_add_ui:                            Integer Arithmetic.
* mpz_addmul_ui:                         Integer Arithmetic.
* mpz_and:                               Integer Logic and Bit Fiddling.
* mpz_array_init:                        Initializing Integers.
* mpz_bin_ui:                            Integer Arithmetic.
* mpz_bin_uiui:                          Integer Arithmetic.
* mpz_cdiv_q:                            Integer Arithmetic.
* mpz_cdiv_q_ui:                         Integer Arithmetic.
* mpz_cdiv_qr:                           Integer Arithmetic.
* mpz_cdiv_qr_ui:                        Integer Arithmetic.
* mpz_cdiv_r:                            Integer Arithmetic.
* mpz_cdiv_r_ui:                         Integer Arithmetic.
* mpz_cdiv_ui:                           Integer Arithmetic.
* mpz_clear:                             Initializing Integers.
* mpz_clrbit:                            Integer Logic and Bit Fiddling.
* mpz_cmp:                               Comparison Functions.
* mpz_cmp_si:                            Comparison Functions.
* mpz_cmp_ui:                            Comparison Functions.
* mpz_cmpabs:                            Comparison Functions.
* mpz_cmpabs_ui:                         Comparison Functions.
* mpz_com:                               Integer Logic and Bit Fiddling.
* mpz_divexact:                          Integer Arithmetic.
* mpz_fac_ui:                            Integer Arithmetic.
* mpz_fdiv_q:                            Integer Arithmetic.
* mpz_fdiv_q_2exp:                       Integer Arithmetic.
* mpz_fdiv_q_ui:                         Integer Arithmetic.
* mpz_fdiv_qr:                           Integer Arithmetic.
* mpz_fdiv_qr_ui:                        Integer Arithmetic.
* mpz_fdiv_r:                            Integer Arithmetic.
* mpz_fdiv_r_2exp:                       Integer Arithmetic.
* mpz_fdiv_r_ui:                         Integer Arithmetic.
* mpz_fdiv_ui:                           Integer Arithmetic.
* mpz_fib_ui:                            Integer Arithmetic.
* mpz_fits_sint_p:                       Miscellaneous Integer Functions.
* mpz_fits_slong_p:                      Miscellaneous Integer Functions.
* mpz_fits_sshort_p:                     Miscellaneous Integer Functions.
* mpz_fits_uint_p:                       Miscellaneous Integer Functions.
* mpz_fits_ulong_p:                      Miscellaneous Integer Functions.
* mpz_fits_ushort_p:                     Miscellaneous Integer Functions.
* mpz_gcd:                               Integer Arithmetic.
* mpz_gcd_ui:                            Integer Arithmetic.
* mpz_gcdext:                            Integer Arithmetic.
* mpz_get_d:                             Converting Integers.
* mpz_get_si:                            Converting Integers.
* mpz_get_str:                           Converting Integers.
* mpz_get_ui:                            Converting Integers.
* mpz_getlimbn:                          Converting Integers.
* mpz_hamdist:                           Integer Logic and Bit Fiddling.
* mpz_init:                              Initializing Integers.
* mpz_init_set:                          Simultaneous Integer Init & Assign.
* mpz_init_set_d:                        Simultaneous Integer Init & Assign.
* mpz_init_set_si:                       Simultaneous Integer Init & Assign.
* mpz_init_set_str:                      Simultaneous Integer Init & Assign.
* mpz_init_set_ui:                       Simultaneous Integer Init & Assign.
* mpz_inp_raw:                           I/O of Integers.
* mpz_inp_str:                           I/O of Integers.
* mpz_invert:                            Integer Arithmetic.
* mpz_ior:                               Integer Logic and Bit Fiddling.
* mpz_jacobi:                            Integer Arithmetic.
* mpz_lcm:                               Integer Arithmetic.
* mpz_legendre:                          Integer Arithmetic.
* mpz_mod:                               Integer Arithmetic.
* mpz_mod_ui:                            Integer Arithmetic.
* mpz_mul:                               Integer Arithmetic.
* mpz_mul_2exp:                          Integer Arithmetic.
* mpz_mul_ui:                            Integer Arithmetic.
* mpz_neg:                               Integer Arithmetic.
* mpz_nextprime:                         Integer Arithmetic.
* mpz_out_raw:                           I/O of Integers.
* mpz_out_str:                           I/O of Integers.
* mpz_perfect_power_p:                   Integer Arithmetic.
* mpz_perfect_square_p:                  Integer Arithmetic.
* mpz_popcount:                          Integer Logic and Bit Fiddling.
* mpz_pow_ui:                            Integer Arithmetic.
* mpz_powm:                              Integer Arithmetic.
* mpz_powm_ui:                           Integer Arithmetic.
* mpz_probab_prime_p:                    Integer Arithmetic.
* mpz_random:                            Miscellaneous Integer Functions.
* mpz_random2:                           Miscellaneous Integer Functions.
* mpz_remove:                            Integer Arithmetic.
* mpz_root:                              Integer Arithmetic.
* mpz_rrandomb:                          Miscellaneous Integer Functions.
* mpz_scan0:                             Integer Logic and Bit Fiddling.
* mpz_scan1:                             Integer Logic and Bit Fiddling.
* mpz_set:                               Assigning Integers.
* mpz_set_d:                             Assigning Integers.
* mpz_set_f:                             Assigning Integers.
* mpz_set_q:                             Assigning Integers.
* mpz_set_si:                            Assigning Integers.
* mpz_set_str:                           Assigning Integers.
* mpz_set_ui:                            Assigning Integers.
* mpz_setbit:                            Integer Logic and Bit Fiddling.
* mpz_sgn:                               Comparison Functions.
* mpz_size:                              Miscellaneous Integer Functions.
* mpz_sizeinbase:                        Miscellaneous Integer Functions.
* mpz_sqrt:                              Integer Arithmetic.
* mpz_sqrtrem:                           Integer Arithmetic.
* mpz_sub:                               Integer Arithmetic.
* mpz_sub_ui:                            Integer Arithmetic.
* mpz_swap:                              Assigning Integers.
* mpz_t:                                 Nomenclature and Types.
* mpz_tdiv_q:                            Integer Arithmetic.
* mpz_tdiv_q_2exp:                       Integer Arithmetic.
* mpz_tdiv_q_ui:                         Integer Arithmetic.
* mpz_tdiv_qr:                           Integer Arithmetic.
* mpz_tdiv_qr_ui:                        Integer Arithmetic.
* mpz_tdiv_r:                            Integer Arithmetic.
* mpz_tdiv_r_2exp:                       Integer Arithmetic.
* mpz_tdiv_r_ui:                         Integer Arithmetic.
* mpz_tdiv_ui:                           Integer Arithmetic.
* mpz_tstbit:                            Integer Logic and Bit Fiddling.
* mpz_ui_pow_ui:                         Integer Arithmetic.
* mpz_urandomb:                          Miscellaneous Integer Functions.
* mpz_urandomm:                          Miscellaneous Integer Functions.
* mpz_xor:                               Integer Logic and Bit Fiddling.
* msqrt:                                 BSD Compatible Functions.
* msub:                                  BSD Compatible Functions.
* mtox:                                  BSD Compatible Functions.
* mult:                                  BSD Compatible Functions.
* pow:                                   BSD Compatible Functions.
* reallocate_function:                   Custom Allocation.
* rpow:                                  BSD Compatible Functions.
* sdiv:                                  BSD Compatible Functions.
* xtom:                                  BSD Compatible Functions.


