\input texinfo    @c -*-texinfo-*-
@comment %**start of header
@setfilename gmp.info
@settitle GNU MP 1.3.2
@synindex tp fn
@c footnotestyle separate
@c paragraphindent 2
@comment %**end of header

@c smallbook

@iftex
@finalout
@end iftex

@c Note: the edition number is listed in *three* places; please update
@c all three.  Also, update the month and year where appropriate.

@c ==> Update edition number for settitle and subtitle, and in the
@c ==> following paragraph; update date, too.

@ifinfo
This file documents GNU MP, a library for arbitrary-precision integer
and rational number arithmetic.

This is a draft edition of the documentation, last updated May 20 1993.

Copyright (C) 1991, 1993 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.

@ignore
Permission is granted to process this file through TeX and print the
results, provided the printed document carries copying permission
notice identical to this one except for the removal of this paragraph
(this paragraph not being relevant to the printed manual).

@end ignore
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.
@end ifinfo

@setchapternewpage odd
@titlepage
@c  use the new format for titles

@title GNU MP
@subtitle The GNU Multiple Precision Arithmetic Library
@subtitle Edition 1.3.2
@subtitle May 1993

@author by Torbj@"orn Granlund

@comment   Include the Distribution inside the titlepage so
@c that headings are turned off.

@page
@vskip 0pt plus 1filll
Copyright @copyright{} 1991, 1993 Free Software Foundation, Inc.

@sp 2

Published by the Free Software Foundation @*
675 Massachusetts Avenue, @*
Cambridge, MA 02139 USA @*

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.
@end titlepage

@ifinfo
@node Top, Copying, (dir), (dir)
@end ifinfo

@menu
* Copying::                  GMP Copying Conditions.
* Intro::                    Introduction to GMP.
* Nomenclature::             Terminology and basic data types.
* Initialization::           Initialization of multi-precision number objects.
* Integer Functions::        Functions for arithmetic on signed integers.
* Rational Number Functions:: Functions for arithmetic on rational numbers.
* Low-level Functions::      Fast functions for natural numbers.
* BSD Compatible Functions:: All functions found in BSD MP (somewhat faster).
* Miscellaneous Functions::  Functions that do particular things.
* Custom Allocation::        How to customize the internal allocation.
* Reporting Bugs::           Help us to improve this library.

* References::
* Concept Index::
* Function Index::
@end menu

@node Copying, Intro, Top, Top
@comment  node-name, next, previous,  up
@unnumbered GNU MP Copying Conditions
@cindex Copying conditions
@cindex Conditions for copying GNU MP

This library is @dfn{free}; this means that everyone is free to use it
and free to redistribute it on a free basis.  The library is not in the
public domain; it is copyrighted and there are restrictions on its
distribution, but these restrictions are designed to permit everything
that a good cooperating citizen would want to do.  What is not allowed
is to try to prevent others from further sharing any version of this
library that they might get from you.@refill

  Specifically, we want to make sure that you have the right to give
away copies of the library, that you receive source code or else can get
it if you want it, that you can change this library or use pieces of it
in new free programs, and that you know you can do these things.@refill

  To make sure that everyone has such rights, we have to forbid you to
deprive anyone else of these rights.  For example, if you distribute
copies of the GMP library, you must give the recipients all the rights
that you have.  You must make sure that they, too, receive or can get
the source code.  And you must tell them their rights.@refill

  Also, for our own protection, we must make certain that everyone finds
out that there is no warranty for the GMP library.  If it is modified by
someone else and passed on, we want their recipients to know that what
they have is not what we distributed, so that any problems introduced by
others will not reflect on our reputation.@refill

  The precise conditions of the license for the GMP library are found in
the General Public License that accompany the source code.@refill

@node Intro, Initialization, Copying, Top
@comment  node-name,  next,  previous,  up
@chapter Introduction to MP
@cindex Introduction
@cindex Overview

GNU MP is a portable library for arbitrary precision integer and
rational number arithmetic.@footnote{The limit of the precision is set by the
available memory in your computer.}  It aims to provide the fastest
possible arithmetic for all applications that need more than two words
of integer precision.

Most often, applications tend to use just a few words of precision;
but some applications may need thousands of words.  GNU MP is designed
to give good performance for both kinds of applications, by choosing
algorithms based on the sizes of the operands.

There are five groups of functions in the MP library:

@enumerate
@item
Functions for signed integer arithmetic, with names
beginning with @code{mpz_}.

@item
Functions for rational number arithmetic, with names beginning with
@code{mpq_}.

@item
Functions compatible with Berkeley MP, such as @code{itom}, @code{madd},
and @code{mult}.

@item
Fast low-level functions that operate on natural numbers.  These are
used by the functions in the preceding groups, and you can also call
them directly from very time-critical user programs.  These functions'
names begin with @code{mpn_}.

@item
Miscellaneous functions.
@end enumerate

As a general rule, all MP functions expect output arguments before input
arguments.  This notation is based on an analogy with the assignment
operator.  (The BSD MP compatibility functions disobey this rule, having
the output argument(s) last.)  Multi-precision numbers, whether
output or input, are always passed as addresses to the declared type.

@menu
* Nomenclature::
* Thanks::
@end menu

@node Nomenclature, Thanks, Intro, Intro
@comment  node-name,  next,  previous,  up
@section Nomenclature and Data Types
@cindex nomenclature

@cindex integer
@tindex @code{MP_INT}
In this manual, @dfn{integer} means a multiple precision integer, as
used in the MP package.  The C data type for such integers is
@code{MP_INT}.  For example:

@example
MP_INT sum;

struct foo @{ MP_INT x, y; @};

MP_INT vec[20];
@end example

@cindex rational number
@tindex @code{MP_RAT}
@dfn{Rational number} means a multiple precision fraction.  The C data
type for these fractions is @code{MP_RAT}.  For example:

@example
MP_RAT quotient;
@end example

@cindex limb
A @dfn{limb} means the part of a multi-precision number that fits in a
single word.  (We chose this word because a limb of the human body is
analogous to a digit, only larger, and containing several digits.)
Normally a limb contains 32 bits.

@node Thanks,, Nomenclature, Intro
@comment  node-name,  next,  previous,  up
@section Thanks

I would like to thank Gunnar Sjoedin and Hans Riesel for their help with
mathematical problems, Richard Stallman for his help with design issues
and for revising this manual, Brian Beuning and Doug Lea for their
testing of various versions of the library, and Joachim Hollman for
his many valuable suggestions.

Special thanks to Brian Beuning, he has shaked out many bugs from early
versions of the code!

John Amanatides of York University in Canada contributed the function
@code{mpz_probab_prime_p}.

@node Initialization, Integer Functions, Intro, Top
@comment  node-name,  next,  previous,  up
@chapter Initialization

Before you can use a variable or object of type @code{MP_INT} or
@code{MP_RAT}, you must initialize it.  This fills in the components
that point to dynamically allocated space for the limbs of the number.

When you are finished using the object, you should clear out the object.
This frees the dynamic space that it points to, so the space can be used
again.

Once you have initialized the object, you need not be concerned about
allocating additional space.  The functions in the MP package
automatically allocate additional space when the object does not already
have enough space.  They do not, however, reduce the space in use when a
smaller number is stored in the object.  Most of the time, this policy
is best, since it avoids frequent re-allocation.  If you want to reduce
the space in an object to the minimum needed, you can do
@code{_mpz_realloc (&@var{object}, mpz_size (&@var{object}))}.

The functions to initialize numbers are @code{mpz_init} (for @code{MP_INT}) and
@code{mpq_init} (for @code{MP_RAT}).

@code{mpz_init} allocates space for the limbs, and stores a pointer
to that space in the @code{MP_INT} object.  It also stores the value 0
in the object.

In the same manner, @code{mpq_init} allocates space for the numerator
and denominator limbs, and stores pointers to these spaces in the @code{MP_RAT}
object.

To clear out a number object, use @code{mpz_clear} and @code{mpq_clear},
respectively.

Here is an example of use:

@example
@{
  MP_INT temp;
  mpz_init (&temp);

  @dots{} @r{store and read values in @code{temp} zero or more times} @dots{}

  mpz_clear (&temp):
@}
@end example

You might be tempted to copy an integer from one object to another like
this:

@example
MP_INT x, y;

x = y;
@end example

Although valid C, @strong{this is an error.} Rather than copying the
integer value from @code{y} to @code{x} it will make the two variables
share storage.  Subsequent assignments to one variable would change the
other mysteriously.  And if you were to clear out both variables
subsequently, you would confuse @code{malloc} and cause your program to
crash.

To copy the value properly, you must use the function @code{mpz_set}.
(@pxref{Assigning Integers})

@node Integer Functions, Rational Number Functions, Initialization, Top
@comment  node-name,  next,  previous,  up
@chapter Integer Functions
@cindex Integer functions

This chapter describes the MP functions for performing integer arithmetic.

The integer functions use arguments and values of type
pointer-to-@code{MP_INT} (@pxref{Nomenclature}).  The type @code{MP_INT}
is a structure, but applications should not refer directly to its
components.  Include the header @file{gmp.h} to get the definition of
@code{MP_INT}.

@menu
* Initializing Integers::
* Assigning Integers::
* Simultaneous Integer Init & Assign::
* Converting Integers::
* Integer Arithmetic::
* Logic on Integers::
* I/O of Integers::
@end menu

@node Initializing Integers, Assigning Integers, , Integer Functions
@comment  node-name,  next,  previous,  up
@section Initializing Integer Objects

Most of the functions for integer arithmetic assume that the output is
stored in an object already initialized.  For example, @code{mpz_add}
stores the result of addition (@pxref{Integer Arithmetic}).  Thus, you
must initialize the object before storing the first value in it.  You
can do this separately by calling the function @code{mpz_init}.

@deftypefun void mpz_init (MP_INT *@var{integer})
Initialize @var{integer} with limb space and set the initial numeric
value to 0.  Each variable should normally only be initialized once,
or at least cleared out (using @code{mpz_clear}) between each initialization.
@end deftypefun

Here is an example of using @code{mpz_init}:

@example
@{
  MP_INT integ;
  mpz_init (&integ);
  @dots{}
  mpz_add (&integ, @dots{});
  @dots{}
  mpz_sub (&integ, @dots{});

  /* Unless you are now exiting the program, do ... */
  mpz_clear (&integ);
@}
@end example

@noindent
As you can see, you can store new values any number of times, once an
object is initialized.

@deftypefun void mpz_clear (MP_INT *@var{integer})
Free the limb space occupied by @var{integer}.  Make sure to call this
function for all @code{MP_INT} variables when you are done with them.
@end deftypefun

@deftypefun {void *} _mpz_realloc (MP_INT *@var{integer}, mp_size @var{new_alloc})
Change the limb space allocation to @var{new_alloc} limbs.  This
function is not normally called from user code, but it can be used to
give memory back to the heap, or to increase the space of a variable to
avoid repeated automatic re-allocation.
@end deftypefun

@deftypefun void mpz_array_init (MP_INT @var{integer_array}[], size_t @var{array_size}, mp_size @var{fixed_num_limbs})
Allocate @strong{fixed} limb space for all @var{array_size} integers in
@var{integer_array}.  The fixed allocation for each integer in the array
is @var{fixed_num_limbs}.  This function is useful for decreasing the
working set for some algorithms that use large integer arrays.  If the
fixed space will be insufficient for storing the result of a subsequent
calculation, the result is unpredictable.

There is no way to de-allocate the storage allocated by this function.  Don't
call @code{mpz_clear}!
@end deftypefun


@node Assigning Integers, Simultaneous Integer Init & Assign, Initializing Integers, Integer Functions
@comment  node-name,  next,  previous,  up
@subsection Integer Assignment Functions
@cindex Integer assignment functions

These functions assign new values to already initialized integers
(@pxref{Initializing Integers}).

@deftypefun void mpz_set (MP_INT *@var{dest_integer}, MP_INT *@var{src_integer})
Assign @var{dest_integer} from @var{src_integer}.
@end deftypefun

@deftypefun void mpz_set_ui (MP_INT *@var{integer}, unsigned long int @var{initial_value})
Set the value of @var{integer} from @var{initial_value}.
@end deftypefun

@deftypefun void mpz_set_si (MP_INT *@var{integer}, signed long int @var{initial_value})
Set the value of @var{integer} from @var{initial_value}.
@end deftypefun

@deftypefun int mpz_set_str (MP_INT *@var{integer}, char *@var{initial_value}, int @var{base})
Set the value of @var{integer} from @var{initial_value},
a '\0'-terminated C string in base @var{base}.  White space is allowed in
the string, and is simply ignored.  The base may vary from 2 to 36.  If
@var{base} is 0, the actual base is determined from the leading characters: if
the first two characters are `0x' or `0X', hexadecimal is assumed,
otherwise if the first character is `0', octal is assumed, otherwise
decimal is assumed.

This function returns 0 if the entire string up to the '\0' is a valid
number in base @var{base}.  Otherwise it returns @minus{}1.
@end deftypefun


@node Simultaneous Integer Init & Assign, Converting Integers, Assigning Integers, Integer Functions
@comment  node-name,  next,  previous,  up
@subsection Combined Initialization and Assignment Functions
@cindex Initialization and assignment functions, combined

For your convenience, MP provides a parallel series of
initialize-and-set arithmetic functions which initialize the output and
then store the value there.  These functions' names have the form
@code{mpz_init_set@dots{}}.

Here is an example of using one:

@example
@{
  MP_INT integ;
  mpz_init_set_str (&integ, "3141592653589793238462643383279502884", 10);
  @dots{}
  mpz_sub (&integ, @dots{});

  mpz_clear (&integ);
@}
@end example

Once the integer has been initialized by any of the
@code{mpz_init_set@dots{}} functions, it can be used as the source or
destination operand for the ordinary integer functions.  Don't use an
initialize-and-set function on a variable already initialized!

@deftypefun void mpz_init_set (MP_INT *@var{dest_integer}, MP_INT *@var{src_integer})
Initialize @var{dest_integer} with limb space and set the initial numeric
value from @var{src_integer}.
@end deftypefun

@deftypefun void mpz_init_set_ui (MP_INT *@var{dest_integer}, unsigned long int @var{src_ulong})
Initialize @var{dest_integer} with limb space and set the initial numeric
value from @var{src_ulong}.
@end deftypefun

@deftypefun void mpz_init_set_si (MP_INT *@var{dest_integer}, signed long int @var{src_slong})
Initialize @var{dest_integer} with limb space and set the initial numeric
value from @var{src_slong}.
@end deftypefun

@deftypefun int mpz_init_set_str (MP_INT *@var{dest_integer}, char *@var{src_cstring}, int @var{base})
Initialize @var{dest_integer} with limb space and set the initial
numeric value from @var{src_cstring}, a '\0'-terminated C string in base
@var{base}.  The base may vary from 2 to 36.  There may be white space
in the string.

If the string is a correct base @var{base} number, the function returns
0; if an error occurs it returns @minus{}1.  @var{dest_integer} is
initialized even if an error occurs.  (I.e., you have to call mpz_clear
for it.)
@end deftypefun


@node Converting Integers,  Integer Arithmetic, Simultaneous Integer Init & Assign, Integer Functions
@comment  node-name,  next,  previous,  up
@section Conversion Functions
@cindex Conversion functions

@deftypefun {unsigned long int} mpz_get_ui (MP_INT *@var{src_integer})
Return the least significant limb from @var{src_integer}.  This
function together with @*
@code{mpz_div_2exp(@dots{}, @var{src_integer}, CHAR_BIT*sizeof(unsigned
long int))} can be used to extract the limbs of an integer efficiently.
@end deftypefun

@deftypefun {signed long int} mpz_get_si (MP_INT *@var{src_integer})
If @var{src_integer} fits into a @code{signed long int} return the value
of @var{src_integer}.  Otherwise return the least significant bits of
@var{src_integer}, with the same sign as @var{src_integer}.
@end deftypefun

@deftypefun {char *} mpz_get_str (char *@var{string}, int @var{base}, MP_INT *@var{integer})
Convert @var{integer} to a '\0'-terminated C string in @var{string},
using base @var{base}.  The base may vary from 2 to 36.  If @var{string}
is NULL, space for the string is allocated using the default allocation
function.

If @var{string} is not NULL, it should point to a block of storage
enough large for the result.  To find out the right amount of space to
provide for @var{string}, use @code{mpz_sizeinbase (@var{integer},
@var{base}) + 2}.  The "+ 2" is for a possible minus sign, and for the
terminating null character.  (@pxref{Miscellaneous Functions}).

This function returns a pointer to the result string.
@end deftypefun


@node     Integer Arithmetic, Logic on Integers, Converting Integers, Integer Functions
@comment  node-name,  next,  previous,  up
@section Integer Arithmetic Functions
@cindex Integer arithmetic functions
@cindex Arithmetic functions

@deftypefun void mpz_add (MP_INT *@var{sum}, MP_INT *@var{addend1}, MP_INT *@var{addend2})
@end deftypefun
@deftypefun void mpz_add_ui (MP_INT *@var{sum}, MP_INT *@var{addend1}, unsigned long int @var{addend2})
Set @var{sum} to @var{addend1} + @var{addend2}.
@end deftypefun

@deftypefun void mpz_sub (MP_INT *@var{difference}, MP_INT *@var{minuend}, MP_INT *@var{subtrahend})
@end deftypefun
@deftypefun void mpz_sub_ui (MP_INT *@var{difference}, MP_INT *@var{minuend}, unsigned long int @var{subtrahend})
Set @var{difference} to @var{minuend} @minus{} @var{subtrahend}.
@end deftypefun

@deftypefun void mpz_mul (MP_INT *@var{product}, MP_INT *@var{multiplicator}, MP_INT *@var{multiplicand})
@end deftypefun
@deftypefun void mpz_mul_ui (MP_INT *@var{product}, MP_INT *@var{multiplicator}, unsigned long int @var{multiplicand})
Set @var{product} to @var{multiplicator} times @var{multiplicand}.
@end deftypefun

Division is undefined if the divisor is zero, and passing a zero divisor
to the divide or modulo functions, as well passing a zero mod argument
to the powm functions, will make these functions intentionally divide by
zero.  This gives the user the possibility to handle arithmetic
exceptions in these functions in the same manner as other arithmetic
exceptions.

@deftypefun void mpz_div (MP_INT *@var{quotient}, MP_INT *@var{dividend}, MP_INT *@var{divisor})
@end deftypefun
@deftypefun void mpz_div_ui (MP_INT *@var{quotient}, MP_INT *@var{dividend}, unsigned long int @var{divisor})
Set @var{quotient} to @var{dividend} / @var{divisor}.  The quotient is
rounded towards 0.
@end deftypefun

@deftypefun void mpz_mod (MP_INT *@var{remainder}, MP_INT *@var{divdend}, MP_INT *@var{divisor})
@end deftypefun
@deftypefun void mpz_mod_ui (MP_INT *@var{remainder}, MP_INT *@var{divdend}, unsigned long int @var{divisor})
Divide @var{dividend} and @var{divisor} and put the remainder in
@var{remainder}.  The remainder has the same sign as the dividend, and
its absolute value is less than the absolute value of the divisor.
@end deftypefun

@deftypefun void mpz_divmod (MP_INT *@var{quotient}, MP_INT *@var{remainder}, MP_INT *@var{dividend}, MP_INT *@var{divisor})
@end deftypefun
@deftypefun void mpz_divmod_ui (MP_INT *@var{quotient}, MP_INT *@var{remainder}, MP_INT *@var{dividend}, unsigned long int @var{divisor})
Divide @var{dividend} and @var{divisor} and put the quotient in
@var{quotient} and the remainder in @var{remainder}.  The quotient is
rounded towards 0.  The remainder has the same sign as the dividend,
and its absolute value is less than the absolute value of the divisor.

If @var{quotient} and @var{remainder} are the same variable, the results
are not defined.
@end deftypefun

@deftypefun void mpz_mdiv (MP_INT *@var{quotient}, MP_INT *@var{dividend}, MP_INT *@var{divisor})
@end deftypefun
@deftypefun void mpz_mdiv_ui (MP_INT *@var{quotient}, MP_INT *@var{dividend}, unsigned long int @var{divisor})
Set @var{quotient} to @var{dividend} / @var{divisor}.  The quotient is
rounded towards @minus{}infinity.
@end deftypefun

@deftypefun void mpz_mmod (MP_INT *@var{remainder}, MP_INT *@var{divdend}, MP_INT *@var{divisor})
@end deftypefun
@deftypefun {unsigned long int} mpz_mmod_ui (MP_INT *@var{remainder}, MP_INT *@var{divdend}, unsigned long int @var{divisor})
Divide @var{dividend} and @var{divisor} and put the remainder in
@var{remainder}.  The remainder is always positive, and its value is
less than the value of the divisor.

For @code{mpz_mmod_ui} the remainder is returned, and if @var{remainder} is
not NULL, also stored there.
@end deftypefun

@deftypefun void mpz_mdivmod (MP_INT *@var{quotient}, MP_INT *@var{remainder}, MP_INT *@var{dividend}, MP_INT *@var{divisor})
@end deftypefun
@deftypefun {unsigned long int} mpz_mdivmod_ui (MP_INT *@var{quotient}, MP_INT *@var{remainder}, MP_INT *@var{dividend}, unsigned long int @var{divisor})
Divide @var{dividend} and @var{divisor} and put the quotient in
@var{quotient} and the remainder in @var{remainder}.  The quotient is
rounded towards @minus{}infinity.  The remainder is always positive, and its
value is less than the value of the divisor.

For @code{mpz_mdivmod_ui} the remainder is small enough to fit in an
@code{unsigned long int}, and is therefore returned.  If @var{remainder}
is not NULL, the remainder is also stored there.

If @var{quotient} and @var{remainder} are the same variable, the results
are not defined.
@end deftypefun

@deftypefun void mpz_sqrt (MP_INT *@var{root}, MP_INT *@var{operand})
Set @var{root} to the square root of @var{operand}.  The result is
rounded towards zero.
@end deftypefun

@deftypefun void mpz_sqrtrem (MP_INT *@var{root}, MP_INT *@var{remainder}, MP_INT *@var{operand})
Set @var{root} to the square root of @var{operand}, as with
@code{mpz_sqrt}.  Set @var{remainder} to
@ifinfo
@var{operand}@minus{}@var{root}*@var{root},
@end ifinfo
@iftex
@tex
$operand - root^2$,
@end tex
@end iftex
(i.e@. zero if @var{operand} is a perfect square).

If @var{root} and @var{remainder} are the same variable, the results are
not defined.
@end deftypefun

@deftypefun int mpz_perfect_square_p (MP_INT *@var{square})
Return non-zero if @var{square} is perfect, i.e@. if the square root of
@var{square} is integral.  Return zero otherwise.
@end deftypefun

@deftypefun int mpz_probab_prime_p (MP_INT *@var{n}, int @var{reps})
An implementation of the probabilistic primality test found in Knuth's
Seminumerical Algorithms book.  If the function
@code{mpz_probab_prime_p(@var{n}, @var{reps})} returns 0 then @var{n} is
not prime.  If it returns 1, then @var{n} is `probably' prime.  The
probability of a false positive is (1/4)**@var{reps}, where @var{reps}
is the number of internal passes of the probabilistic algorithm.  Knuth
indicates that 25 passes are reasonable.
@end deftypefun

@deftypefun void mpz_powm (MP_INT *@var{res}, MP_INT *@var{base}, MP_INT *@var{exp}, MP_INT *@var{mod})
@end deftypefun
@deftypefun void mpz_powm_ui (MP_INT *@var{res}, MP_INT *@var{base}, unsigned long int @var{exp}, MP_INT *@var{mod})
Set @var{res} to (@var{base} raised to @var{exp}) modulo @var{mod}.
If @var{exp} is negative, the result is undefined.
@end deftypefun

@deftypefun void mpz_pow_ui (MP_INT *@var{res}, MP_INT *@var{base}, unsigned long int @var{exp})
Set @var{res} to @var{base} raised to @var{exp}.
@end deftypefun

@deftypefun void mpz_fac_ui (MP_INT *@var{res}, unsigned long int @var{n})
Set @var{res} @var{n}!, the factorial of n.
@end deftypefun

@deftypefun void mpz_gcd (MP_INT *@var{res}, MP_INT *@var{operand1}, MP_INT *@var{operand2})
Set @var{res} to the greatest common divisor of @var{operand1} and
@var{operand2}.
@end deftypefun

@deftypefun void mpz_gcdext (MP_INT *@var{g}, MP_INT *@var{s}, MP_INT *@var{t}, MP_INT *@var{a}, MP_INT *@var{b})
Compute @var{g}, @var{s}, and @var{t}, such that @var{a}@var{s} +
@var{b}@var{t} = @var{g} = @code{gcd} (@var{a}, @var{b}).  If @var{t} is
NULL, that argument is not computed.
@end deftypefun

@deftypefun void mpz_neg (MP_INT *@var{negated_operand}, MP_INT *@var{operand})
Set @var{negated_operand} to @minus{}@var{operand}.
@end deftypefun

@deftypefun void mpz_abs (MP_INT *@var{positive_operand}, MP_INT *@var{signed_operand})
Set @var{positive_operand} to the absolute value of @var{signed_operand}.
@end deftypefun

@deftypefun int mpz_cmp (MP_INT *@var{operand1}, MP_INT *@var{operand2})
@end deftypefun
@deftypefun int mpz_cmp_ui (MP_INT *@var{operand1}, unsigned long int @var{operand2})
@end deftypefun
@deftypefun int mpz_cmp_si (MP_INT *@var{operand1}, signed long int @var{operand2})
Compare @var{operand1} and @var{operand2}.  Return a positive value if
@var{operand1} > @var{operand2}, zero if @var{operand1} = @var{operand2},
and a negative value if @var{operand1} < @var{operand2}.
@end deftypefun

@deftypefun void mpz_mul_2exp (MP_INT *@var{product}, MP_INT *@var{multiplicator}, unsigned long int @var{exponent_of_2})
Set @var{product} to @var{multiplicator} times 2 raised to
@var{exponent_of_2}.  This operation can also be defined as a left shift,
@var{exponent_of_2} steps.
@end deftypefun

@deftypefun void mpz_div_2exp (MP_INT *@var{quotient}, MP_INT *@var{dividend}, unsigned long int @var{exponent_of_2})
Set @var{quotient} to @var{dividend} divided by 2 raised to
@var{exponent_of_2}.  This operation can also be defined as a right
shift, @var{exponent_of_2} steps, but unlike the >> operator in
C, the result is rounded towards 0.
@end deftypefun

@deftypefun void mpz_mod_2exp (MP_INT *@var{remainder}, MP_INT *@var{dividend}, unsigned long int @var{exponent_of_2})
Set @var{remainder} to @var{dividend} mod (2 raised to
@var{exponent_of_2}).  The sign of @var{remainder} will have the same sign
as @var{dividend}.

This operation can also be defined as a masking of the
@var{exponent_of_2} least significant bits.
@end deftypefun

@node Logic on Integers, I/O of Integers, Integer Arithmetic, Integer Functions
@comment  node-name,  next,  previous,  up
@section Logical Functions
@cindex Logical functions

@deftypefun void mpz_and (MP_INT *@var{conjunction}, MP_INT *@var{operand1}, MP_INT *@var{operand2})
Set @var{conjunction} to @var{operand1} logical-and @var{operand2}.
@end deftypefun

@deftypefun void mpz_ior (MP_INT *@var{disjunction}, MP_INT *@var{operand1}, MP_INT *@var{operand2})
Set @var{disjunction} to @var{operand1} inclusive-or @var{operand2}.
@end deftypefun

@deftypefun void mpz_xor (MP_INT *@var{disjunction}, MP_INT *@var{operand1}, MP_INT *@var{operand2})
Set @var{disjunction} to @var{operand1} exclusive-or @var{operand2}.

This function is missing in the current release.
@end deftypefun

@deftypefun void mpz_com (MP_INT *@var{complemented_operand}, MP_INT *@var{operand})
Set @var{complemented_operand} to the one's complement of @var{operand}.
@end deftypefun

@node I/O of Integers,, Logic on Integers, Integer Functions
@comment  node-name,  next,  previous,  up
@section Input and Output Functions
@cindex Input and output functions
@cindex Output functions
@cindex I/O functions

Functions that perform input from a standard I/O stream, and functions for
output conversion.

@deftypefun void mpz_inp_raw (MP_INT *@var{integer}, FILE *@var{stream})
Input from standard I/O stream @var{stream} in the format written by
@code{mpz_out_raw}, and put the result in @var{integer}.
@end deftypefun

@deftypefun void mpz_inp_str (MP_INT *@var{integer}, FILE *@var{stream}, int @var{base})
Input a string in base @var{base} from standard I/O stream @var{stream},
and put the read integer in @var{integer}.  The base may vary from 2 to
36.  If @var{base} is 0, the actual base is determined from the leading
characters: if the first two characters are `0x' or `0X', hexadecimal is
assumed, otherwise if the first character is `0', octal is assumed,
otherwise decimal is assumed.
@end deftypefun


@deftypefun void mpz_out_raw (FILE *@var{stream}, MP_INT *@var{integer})
Output @var{integer} on standard I/O stream @var{stream}, in raw binary
format.  The integer is written in a portable format, with 4 bytes of
size information, and that many bytes of limbs.  Both the size and the
limbs are written in decreasing significance order.
@end deftypefun

@deftypefun void mpz_out_str (FILE *@var{stream}, int @var{base}, MP_INT *@var{integer})
Output @var{integer} on standard I/O stream @var{stream}, as a string of
digits in base @var{base}.  The base may vary from 2 to 36.
@end deftypefun


@node Rational Number Functions, Low-level Functions, Integer Functions, Top
@comment  node-name,  next,  previous,  up
@chapter Rational Number Functions
@cindex Rational number functions

All rational arithmetic functions canonicalize the result, so that the
denominator and the numerator have no common factors.  Zero has the
unique representation 0/1.

The set of functions is quite small.  Maybe it will be extended in a
future release.

@deftypefun void mpq_init (MP_RAT *@var{dest_rational})
Initialize @var{dest_rational} with limb space and set the initial
numeric value to 0/1.  Each variable should normally only be initialized
once, or at least cleared out (using the function @code{mpq_clear})
between each initialization.
@end deftypefun

@deftypefun void mpq_clear (MP_RAT *@var{rational_number})
Free the limb space occupied by @var{rational_number}.  Make sure to
call this function for all @code{MP_RAT} variables when you are done
with them.
@end deftypefun

@deftypefun void mpq_set (MP_RAT *@var{dest_rational}, MP_RAT *@var{src_rational})
Assign @var{dest_rational} from @var{src_rational}.
@end deftypefun

@deftypefun void mpq_set_ui (MP_RAT *@var{rational_number}, unsigned long int @var{numerator}, unsigned long int @var{denominator})
Set the value of @var{rational_number} to
@var{numerator}/@var{denominator}.  If @var{numerator} and
@var{denominator} have common factors, they are divided out before
@var{rational_number} is assigned.
@end deftypefun

@deftypefun void mpq_set_si (MP_RAT *@var{rational_number}, signed long int @var{numerator}, unsigned long int @var{denominator})
Like @code{mpq_set_ui}, but @var{numerator} is signed.
@end deftypefun

@deftypefun void mpq_add (MP_RAT *@var{sum}, MP_RAT *@var{addend1}, MP_RAT *@var{addend2})
Set @var{sum} to @var{addend1} + @var{addend2}.
@end deftypefun

@deftypefun void mpq_sub (MP_RAT *@var{difference}, MP_RAT *@var{minuend}, MP_RAT *@var{subtrahend})
Set @var{difference} to @var{minuend} @minus{} @var{subtrahend}.
@end deftypefun

@deftypefun void mpq_mul (MP_RAT *@var{product}, MP_RAT *@var{multiplicator}, MP_RAT *@var{multiplicand})
Set @var{product} to @var{multiplicator} * @var{multiplicand}
@end deftypefun

@deftypefun void mpq_div (MP_RAT *@var{quotient}, MP_RAT *@var{dividend}, MP_RAT *@var{divisor})
Set @var{quotient} to @var{dividend} / @var{divisor}.
@end deftypefun

@deftypefun void mpq_neg (MP_RAT *@var{negated_operand}, MP_RAT *@var{operand})
Set @var{negated_operand} to @minus{}@var{operand}.
@end deftypefun

@deftypefun int mpq_cmp (MP_RAT *@var{operand1}, MP_RAT *@var{operand2})
Compare @var{operand1} and @var{operand2}.  Return a positive value if
@var{operand1} > @var{operand2}, zero if @var{operand1} = @var{operand2},
and a negative value if @var{operand1} < @var{operand2}.
@end deftypefun

@deftypefun void mpq_inv (MP_RAT *@var{inverted_number}, MP_RAT *@var{number})
Invert @var{number} by swapping the numerator and denominator.  If the
new denominator becomes zero, this routine will divide by zero.
@end deftypefun

@deftypefun void mpq_set_num (MP_RAT *@var{rational_number}, MP_INT *@var{numerator})
Make @var{numerator} become the numerator of @var{rational_number} by
copying.
@end deftypefun

@deftypefun void mpq_set_den (MP_RAT *@var{rational_number}, MP_INT *@var{denominator})
Make @var{denominator} become the denominator of @var{rational_number}
by copying.  If @var{denominator} < 0 the denominator of
@var{rational_number} is set to the absolute value of @var{denominator},
and the sign of the numerator of @var{rational_number} is changed.
@end deftypefun

@deftypefun void mpq_get_num (MP_INT *@var{numerator}, MP_RAT *@var{rational_number})
Copy the numerator of @var{rational_number} to the integer
@var{numerator}, to prepare for integer operations on the numerator.
@end deftypefun

@deftypefun void mpq_get_den (MP_INT *@var{denominator}, MP_RAT *@var{rational_number})
Copy the denominator of @var{rational_number} to the integer
@var{denominator}, to prepare for integer operations on the denominator.
@end deftypefun


@node Low-level Functions, BSD Compatible Functions, Rational Number Functions, Top
@comment  node-name,  next,  previous,  up
@chapter Low-level Functions
@cindex Low-level functions

@c 1. Some of these function clobber input operands.
@c 

@strong{The next release of the GNU MP library (2.0) will include
changes to some mpn functions.  Programs that use these functions
according to the descriptions below will therefore not work with the
next release.}

The low-level function layer is designed to be as fast as possible,
@strong{not} to provide a coherent calling interface.  The different
functions have similar interfaces, but there are variations that might
be confusing.  These functions do as little as possible apart from the
real multiple precision computation, so that no time is spent on things
that not all callers need.

A source operand is specified by a pointer to the least significant limb
and a limb count.  A destination operand is specified by just a pointer.
It is the responsability of the caller to ensure that the destination
has enough space for storing the result.

With this way of specifying source operands, it is possible to perform
computations on subranges of an argument, and store the result into a
subrange of a destination.

All these functions require that the operands are normalized in the
sense that the most significant limb must be non-zero.  (A future release
of might drop this requirement.)

The low-level layer is the base for the implementation of the
@code{mpz_} and @code{mpq_} layers.

The code below adds the number beginning at @var{src1_ptr} and the
number beginning at @var{src2_ptr} and writes the sum at @var{dest_ptr}.
A constraint for @code{mpn_add} is that @var{src1_size} must not be
smaller that @var{src2_size}.

@example
mpn_add (dest_ptr, src1_ptr, src1_size, src2_ptr, src2_size)
@end example

In the description below, a source operand is identified by the pointer
to the least significant limb, and the limb count in braces.

@deftypefun mp_size mpn_add (mp_ptr @var{dest_ptr}, mp_srcptr @var{src1_ptr}, mp_size @var{src1_size}, mp_srcptr @var{src2_ptr}, mp_size @var{src2_size})
Add @{@var{src1_ptr}, @var{src1_size}@} and @{@var{src2_ptr},
@var{src2_size}@}, and write the @var{src1_size} least significant limbs
of the result to @var{dest_ptr}.  Carry-out, either 0 or 1, is returned.

This function requires that @var{src1_size} is greater than or equal to
@var{src2_size}.
@end deftypefun

@deftypefun mp_size mpn_sub (mp_ptr @var{dest_ptr}, mp_srcptr @var{src1_ptr}, mp_size @var{src1_size}, mp_srcptr @var{src2_ptr}, mp_size @var{src2_size})
Subtarct @{@var{src2_ptr}, @var{src2_size}@} from @{@var{src1_ptr},
@var{src1_size}@}, and write the result to @var{dest_ptr}.

Return 1 if the minuend < the subtrahend.  Otherwise, return the
negative difference between the number of words in the result and the
minuend.  I.e@. return 0 if the result has @var{src1_size} words, @minus{}1 if
it has @var{src1_size} @minus{} 1 words, etc.

This function requires that @var{src1_size} is greater than or equal to
@var{src2_size}.
@end deftypefun

@deftypefun mp_size mpn_mul (mp_ptr @var{dest_ptr}, mp_srcptr @var{src1_ptr}, mp_size @var{src1_size}, mp_srcptr @var{src2_ptr}, mp_size @var{src2_size})
Multiply @{@var{src1_ptr}, @var{src1_size}@} and @{@var{src2_ptr},
@var{src2_size}@}, and write the result to @var{dest_ptr}.  The exact
size of the result is returned.

The destination has to have space for @var{src1_size} + @var{src1_size}
limbs, even if the result might be one limb smaller.

This function requires that @var{src1_size} is greater than or equal to
@var{src2_size}.  The destination must be distinct from either input
operands.
@end deftypefun

@deftypefun mp_size mpn_div (mp_ptr @var{dest_ptr}, mp_ptr @var{src1_ptr}, mp_size @var{src1_size}, mp_srcptr @var{src2_ptr}, mp_size @var{src2_size})
Divide @{@var{src1_ptr}, @var{src1_size}@} by @{@var{src2_ptr},
@var{src2_size}@}, and write the quotient to @var{dest_ptr}, and the
remainder to @var{src1_ptr}.

Return 0 if the quotient size is at most (@var{src1_size} @minus{}
@var{src2_size}), and 1 if the quotient size is at most (@var{src1_size}
@minus{} @var{src2_size} + 1).  The caller has to check the most significant limb
to find out the exact size.

The most significant bit of the most significant limb of the divisor
has to be set.

This function requires that @var{src1_size} is greater than or equal to
@var{src2_size}.  The quotient, pointed to by @var{dest_ptr}, must be
distinct from either input operands.
@end deftypefun

@deftypefun mp_limb mpn_lshift (mp_ptr @var{dest_ptr}, mp_srcptr @var{src_ptr}, mp_size @var{src_size}, unsigned long int @var{count})
Shift @{@var{src_ptr}, @var{src_size}@} @var{count} bits to the left, and
write the @var{src_size} least significant limbs of the result to
@var{dest_ptr}.  @var{count} might be in the range 1 to n @minus{} 1, on an n-bit
machine. The limb shifted out is returned.

Overlapping of the destination space and the source space is allowed in this
function, provdied @var{dest_ptr} >= @var{src_ptr}.
@end deftypefun

@deftypefun mp_size mpn_rshift (mp_ptr @var{dest_ptr}, mp_srcptr @var{src_ptr}, mp_size @var{src_size}, unsigned long int @var{count})
Shift @{@var{src_ptr}, @var{src_size}@} @var{count} bits to the right, and
write the @var{src_size} least significant limbs of the result to
@var{dest_ptr}.  @var{count} might be in the range 1 to n @minus{} 1, on an n-bit
machine. The size of the result is returned.

Overlaping of the destination space and the source space is allowed in this
function, provdied @var{dest_ptr} <= @var{src_ptr}.
@end deftypefun

@deftypefun mp_size mpn_rshiftci (mp_ptr @var{dest_ptr}, mp_srcptr @var{src_ptr}, mp_size @var{src_size}, unsigned long int @var{count}, mp_limb @var{inlimb})
Like mpn_rshift, but use @var{inlimb} to feed the least significant end
of the destination.
@end deftypefun

@deftypefun int mpn_cmp (mp_srcptr @var{src1_ptr}, mp_srcptr @var{src2_ptr}, mp_size @var{size})
Compare @{@var{src1_ptr}, @var{size}@} and @{@var{src2_ptr}, @var{size}@}
and return a positive value if src1 > src2, 0 of they are equal,
and a negative value if src1 < src2.
@end deftypefun


@node BSD Compatible Functions, Miscellaneous Functions, Low-level Functions, Top
@comment  node-name,  next,  previous,  up
@chapter Berkeley MP Compatible Functions
@cindex BSD 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 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 @code{MINT} objects is more error prone, and the
@code{pow} function collides with @code{pow} in @file{libm.a}.

Include the header @file{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 @file{mp.h} if you are going to link the GNU @file{libmp.a}
to you 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
@file{mp.h}.

@deftypefun {MINT *} itom (signed short int @var{initial_value})
Allocate an integer consisting of a @code{MINT} object and dynamic limb
space.  Initialize the integer to @var{initial_value}.  Return a pointer
to the @code{MINT} object.
@end deftypefun

@deftypefun {MINT *} xtom (char *@var{initial_value})
Allocate an integer consisting of a @code{MINT} object and dynamic limb
space.  Initialize the integer from @var{initial_value}, a hexadecimal,
'\0'-terminate C string.  Return a pointer to the @code{MINT} object.
@end deftypefun

@deftypefun void move (MINT *@var{src}, MINT *@var{dest})
Set @var{dest} to @var{src} by copying.  Both variables must be
previously initialized.
@end deftypefun

@deftypefun void madd (MINT *@var{src_1}, MINT *@var{src_2}, MINT *@var{destination})
Add @var{src_1} and @var{src_2} and put the sum in @var{destination}.
@end deftypefun

@deftypefun void msub (MINT *@var{src_1}, MINT *@var{src_2}, MINT *@var{destination})
Subtract @var{src_2} from @var{src_1} and put the difference in
@var{destination}.
@end deftypefun

@deftypefun void mult (MINT *@var{src_1}, MINT *@var{src_2}, MINT *@var{destination})
Multiply @var{src_1} and @var{src_2} and put the product in
@var{destination}.
@end deftypefun

@deftypefun void mdiv (MINT *@var{dividend}, MINT *@var{divisor}, MINT *@var{quotient}, MINT *@var{remainder})
@end deftypefun
@deftypefun void sdiv (MINT *@var{dividend}, signed short int @var{divisor}, MINT *@var{quotient}, signed short int *@var{remainder})
Set @var{quotient} to @var{dividend} / @var{divisor}, and
@var{remainder} to @var{dividend} mod @var{divisor}.  The quotient is
rounded towards zero; the remainder has the same sign as the dividend.

Some implementations of this function return a remainder whose sign is
inverted if the divisor is negative.  Such a definition makes little
sense from a mathematical point of view.  GNU MP might be considered
incompatible with the traditional MP in this respect.
@end deftypefun

@deftypefun void msqrt (MINT *@var{operand}, MINT *@var{root}, MINT *@var{remainder})
Set @var{root} to the square root of @var{operand}, as with
@code{mpz_sqrt}.  Set @var{remainder} to
@ifinfo
@var{operand}-@var{root}*@var{root},
@end ifinfo
@iftex
@tex
$operand - root^2$,
@end tex
@end iftex
(i.e@. zero if @var{operand} is a perfect square).
@end deftypefun

@deftypefun void pow (MINT *@var{base}, MINT *@var{exp}, MINT *@var{mod}, MINT *@var{dest})
Set @var{dest} to (@var{base} raised to @var{exp}) modulo @var{mod}.
@end deftypefun

@deftypefun void rpow (MINT *@var{base}, signed short int @var{exp}, MINT *@var{dest})
Set @var{dest} to @var{base} raised to @var{exp}.
@end deftypefun

@deftypefun void gcd (MINT *@var{operand1}, MINT *@var{operand2}, MINT *@var{res})
Set @var{res} to the greatest common divisor of @var{operand1} and
@var{operand2}.
@end deftypefun

@deftypefun int mcmp (MINT *@var{operand1}, MINT *@var{operand2})
Compare @var{operand1} and @var{operand2}.  Return a positive value if
@var{operand1} > @var{operand2}, zero if @var{operand1} =
@var{operand2}, and a negative value if @var{operand1} < @var{operand2}.
@end deftypefun

@deftypefun void min (MINT *@var{dest})
Input a decimal string from stdin, and put the read integer in
@var{dest}.  SPC and TAB are allowed in the number string, and are
ignored.
@end deftypefun

@deftypefun void mout (MINT *@var{src})
Output @var{src} to stdout, as a decimal string.  Also output a newline.
@end deftypefun

@deftypefun {char *} mtox (MINT *@var{operand})
Convert @var{operand} to a hexadecimal string, and return a pointer to
the string.  The returned string is allocated using the default memory
allocation function, @code{malloc} by default. (@xref{Initialization},
for an explanation of the memory allocation in MP).
@end deftypefun

@deftypefun void mfree (MINT *@var{operand})
De-allocate, the space used by @var{operand}.  @strong{This function
should only be passed a value returned by @code{itom} or @code{xtom}.}
@end deftypefun

@node Miscellaneous Functions, Custom Allocation, BSD Compatible Functions, Top
@comment  node-name,  next,  previous,  up
@chapter Miscellaneous Functions
@cindex Miscellaneous functions

@deftypefun void mpz_random (MP_INT *@var{random_integer}, mp_size @var{max_size})
Generate a random integer of at most @var{max_size} limbs.  The generated
random number doesn't satisfy any particular requirements of randomness.
@end deftypefun

@deftypefun void mpz_random2 (MP_INT *@var{random_integer}, mp_size @var{max_size})
Generate a random integer of at most @var{max_size} limbs, with long
strings of zeros and ones in the binary representation.  Useful for
testing functions and algorithms, since this kind of random numbers have
proven to be more likely to trigger bugs.
@end deftypefun

@deftypefun size_t mpz_size (MP_INT *@var{integer})
Return the size of @var{integer} measured in number of limbs.  If
@var{integer} is zero, the returned value will be zero, if @var{integer}
has one limb, the returned value will be one, etc.
(@xref{Nomenclature}, for an explanation of the concept @dfn{limb}.)
@end deftypefun

@deftypefun size_t mpz_sizeinbase (MP_INT *@var{integer}, int @var{base})
Return the size of @var{integer} measured in number of digits in base
@var{base}.  The base may vary from 2 to 36.  The returned value will be
exact or 1 too big.  If @var{base} is a power of 2, the returned value
will always be exact.

This function is useful in order to allocate the right amount of space
before converting @var{integer} to a string.  The right amount of
allocation is normally two more than the value returned by
@code{mpz_sizeinbase} (one extra for a minus sign and one for the
terminating '\0').
@end deftypefun

@node Custom Allocation, Reporting Bugs, Miscellaneous Functions, Top
@comment  node-name,  next,  previous,  up
@section Custom Allocation

By default, the initialization functions use @code{malloc},
@code{realloc}, and @code{free} to do their work.  If @code{malloc} or
@code{realloc} fails, the MP package terminates execution after a
printing fatal error message on standard error.

In 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 functions
for allocating and de-allocating memory.  Use
@code{mp_set_memory_functions} to do this.

@findex mp_set_memory_functions
@code{mp_set_memory_functions} has three arguments,
@var{allocate_function}, @var{reallocate_function}, and
@var{deallocate_function}, in that order.  If an argument is NULL,
the corresponding default function is retained.

The functions you supply should fit the following declarations:

@table @code
@item void * @var{allocate_function} (size_t @var{alloc_size})
This function should return a pointer to newly allocated space with at
least @var{alloc_size} storage units.

@item void * @var{reallocate_function} (void *@var{ptr}, size_t @var{old_size}, size_t @var{new_size})
This function should return a pointer to newly allocated space of at
least @var{new_size} storage units, after copying the first
@var{old_size} storage units from @var{ptr}.  It should also de-allocate the
space at @var{ptr}.

You can assume that the space at @var{ptr} was formely returned from
@var{allocate_function} or @var{reallocate_function}, for a
request for @var{old_size} storage units.

@item void @var{deallocate_function} (void *@var{ptr}, size_t @var{size})
De-allocate the space pointed to by @var{ptr}.

You can assume that the space at @var{ptr} was formely returned from
@var{allocate_function} or @var{reallocate_function}, for a
request for @var{size} storage units.
@end table

(A @dfn{storage unit} is the unit in which the @code{sizeof} operator
returns the size of an object, normally an 8 bit byte.)

@strong{NOTE: call @code{mp_set_memory_functions} only before calling
any other MP functions.} Otherwise, the user-defined allocation
functions may be asked to re-allocate or de-allocate something
previously allocated by the default allocation functions.

@node Reporting Bugs, , Custom Allocation, Top
@comment  node-name,  next,  previous,  up
@chapter Reporting Bugs
@cindex Reporting bugs

If you think you have found a bug in the GNU MP library, please
investigate it and report it.  We have made this library available to
you, and it is not to ask too much from you, to ask you to report the
bugs that you find.

Please make sure that the bug is really in the GNU MP library.

You have to send us a test case that makes it possible for us to
reproduce the bug.

You also have to explain what is wrong; if you get a crash, or if the
results printed are not good and in that case, in what way.

Make sure that the bug report includes all information you would
need to fix this kind of bug for someone else.  Think twice.

If your bug report is good, we will do our best to help you to get a
corrected version of the library; if the bug report is poor, we won't do
anything about it (aside of chiding you to send better bug reports).

Send your bug report to: tege@@gnu.ai.mit.edu.

If you think something in this manual is unclear, or downright
incorrect, or if the language needs to be improved, please send a note
to the same address.


@node References, , , Top
@comment  node-name,  next,  previous,  up
@unnumbered References

@itemize @bullet

@item
Donald E@. Knuth, "The Art of Computer Programming", vol 2,
"Seminumerical Algorithms", 2nd edition, Addison-Wesley, 1981.

@item
John D@. Lipson, "Elements of Algebra and Algebraic Computing",
The Benjamin Cummins Publishing Company Inc, 1981.

@item
Richard M@. Stallman, "Using and Porting GCC", Free Software Foundation,
1993.

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

@end itemize

@node Concept Index, , , Top
@comment  node-name,  next,  previous,  up
@unnumbered Concept Index
@printindex cp

@node Function Index, , , Top
@comment  node-name,  next,  previous,  up
@unnumbered Function and Type Index
@printindex fn


@contents
@bye