1292 lines
51 KiB
Plaintext
1292 lines
51 KiB
Plaintext
\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 arbitraryprecision 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 multiprecision number objects.


* Integer Functions:: Functions for arithmetic on signed integers.


* Rational Number Functions:: Functions for arithmetic on rational numbers.


* Lowlevel 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 nodename, 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 nodename, 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 lowlevel 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 timecritical 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.) Multiprecision 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 nodename, 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 multiprecision 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 nodename, 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 nodename, 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 reallocation. 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 nodename, 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


pointerto@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 nodename, 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 reallocation.


@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 deallocate 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 nodename, 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 nodename, next, previous, up


@subsection Combined Initialization and Assignment Functions


@cindex Initialization and assignment functions, combined




For your convenience, MP provides a parallel series of


initializeandset 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


initializeandset 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 nodename, 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 nodename, 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 nonzero 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 nodename, 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} logicaland @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} inclusiveor @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} exclusiveor @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 nodename, 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, Lowlevel Functions, Integer Functions, Top


@comment nodename, 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 Lowlevel Functions, BSD Compatible Functions, Rational Number Functions, Top


@comment nodename, next, previous, up


@chapter Lowlevel Functions


@cindex Lowlevel 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 lowlevel 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 nonzero. (A future release


of might drop this requirement.)




The lowlevel 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}. Carryout, 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 nbit


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 nbit


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, Lowlevel Functions, Top


@comment nodename, 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


restrictioninputs 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})


Deallocate, 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 nodename, 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 nodename, 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 deallocating 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 deallocate 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})


Deallocate 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 userdefined allocation


functions may be asked to reallocate or deallocate something


previously allocated by the default allocation functions.




@node Reporting Bugs, , Custom Allocation, Top


@comment nodename, 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 nodename, next, previous, up


@unnumbered References




@itemize @bullet




@item


Donald E@. Knuth, "The Art of Computer Programming", vol 2,


"Seminumerical Algorithms", 2nd edition, AddisonWesley, 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 nodename, next, previous, up


@unnumbered Concept Index


@printindex cp




@node Function Index, , , Top


@comment nodename, next, previous, up


@unnumbered Function and Type Index


@printindex fn






@contents


@bye
