MPN_CMP(result, xp, yp, size) - compare {xp, size} with {yp, size} and set
result to -1, 0, 1, size may be zero
MPN_COPY_INCR(dst, src, size) - copy size limbs from src to dst incrementing
memory locations throughout copy (i.e. src must come after dst if they overlap)
size == 0 is allowed
MPN_COPY_DECR(dst, src, size) - as for MPN_COPY_INCR except ptrs are decremented
(i.e. src must come before dst if they overlap)
MPN_COPY(dst, src, size) - copy size limbs from src to dst which must be same
or separate
MPN_REVERSE(dst, src, size) - set {dst, size} to the limbs of {src, size} in
reverse order
MPN_ZERO(dst, n) - set n limbs at dst to zero
mpn_com_n(dst, src, size) - set {dst, size} to the complement of {src, size}
mpn_and_n(dst, src1, src2, n) - set {dst, n} to {src1, n} & {src2, n}
mpn_andn_n(dst, src1, src2, n) - set {dst, n} to {src1, n} & ~{src2, n}
mpn_nand_n(dst, src1, src2, n) - set {dst, n} to {src1, n} nand {src2, n}
mpn_ior_n(dst, src1, src2, n) - set {dst, n} to {src1, n} | {src2, n}
mpn_iorn_n(dst, src1, src2, n) - set {dst, n} to {src1, n} | ~{src2, n}
mpn_nior_n(dst, src1, src2, n) - set {dst, n} to {src1, n} nor {src2, n}
mpn_xor_n(dst, src1, src2, n) - set {dst, n} to {src1, n} xor {src2, n}
mpn_xnor_n(dst, src1, src2, n) - set {dst, n} to {src1, n} xnor {src2, n}
MPN_NORMALIZE(dst, nlimbs) - normalise the mpn at dst, i.e. set nlimbs to number
of non-zero limbs
MPN_NORMALIZE_NOT_ZERO(dst, nlimbs) - normalise the mpn at dst, i.e. set
nlimbs to number of non-zero limbs, assuming it isn't zero
MPN_STRIP_LOW_ZEROS_NOT_ZERO(ptr, size, low) - strip least sig zero limbs from
{ptr, size} by incr ptr and decr size, low should be ptr[0] and will be set
to new ptr[0] upon return, function assumes {ptr, size} is not zero
MPN_OVERLAP_P(xp, xsize, yp, ysize) - nonzero if the given mpns overlap
MPN_SAME_OR_INCR2_P(dst, dsize, src, ssize) - nonzero if ok for incr algorithm
MPN_SAME_OR_INCR_P(dst, src, size) - as for INCR2 variant, but same sizes
MPN_SAME_OR_DECR2_P(dst, dsize, src, ssize) - nonzero if ok for decr algorithm
MPN_SAME_OR_DECR_P(dst, src, size) - as for DECR2 variant, but same sizes
MPN_LOGOPS_N_INLINE(dst, src1, src2, n, operation) - do n operations involving
any of src1, src2, dst
MPN_INCR_U(ptr, size, incr) - {ptr, size} += n expect no carry
MPN_DECR_U(ptr, size, incr) - {ptr, size} -= n expect no carry
mpn_incr_u(ptr, incr) - {ptr, size} += n carry possible
mpn_decr_u(ptr, incr) - {ptr, size} -= n carry possible
MPN_SIZEINBASE(result, ptr, size, base) - set result to number of numerals
{ptr, size} has, in the given base. For power of 2 bases it is exact, otherwise
it may sometimes be one too big - this is done for efficiency so not all limbs
have to be checked
MPN_SIZEINBASE_16(result, ptr, size, base) - special optimisation for base 16
MPN_SET_UI(zp, zn, u) - set {zp, zn} to the given ui, where zn must be big enough
to accomodate a ulong
MPN_DIVREM_OR_PREINV_DIVREM_1(qp,xsize,ap,size,d,dinv,shift) - set {qp, xsize} to
{ap, size} divided by d with dinv an inverse of d and shift the number of bits
d has to be shifted, only uses the preinv if this will be better on this arch
MPN_MOD_OR_PREINV_MOD_1(ap,size,d,dinv) - return {ap, size} mod d with d an
inverse of d - using preinv only if better on this arch
MPN_DIVREM_OR_DIVEXACT_1(dst, src, size, divisor) - divide {src, size} by divisor assuming no remainder if this will be faster
MPN_DIVREM_OR_DIVEXACT_1(dst, src, size, divisor) - mpn_modexact_1_odd or
mpn_mod_1 depending on which is faster on this arch
MPN_BSWAP(dst, src, size) - byte swap limbs from {src,size} and store
at {dst,size}
MPN_BSWAP_REVERSE(dst, src, size) - byte swap limbs from {dst,size} and
store in reverse order at {src,size}
ADDC_LIMB(cout, w, x, y) - w = x + y with cout set to 1 for carry from add
ADDC_LIMB(cout, w, x, y) - w = x - y with cout set to 1 for borrow from sub
BITS_TO_LIMBS(n) - number of limbs required to store the given number of bits
LIMB_HIGHBIT_TO_MASK(n) - platform independently set a mask to 0 or 0xFF..FF
depending on whether high bit of n is 0 or 1
LOW_ZEROS_MASK(n) - bit mask of all the least significant zero bits of n
ULONG_PARITY(p, n) - sets p to 1 if the number of 1 bits in n is odd
NEG_MOD(r, a, d) - r = -a mod d (a >= d is allowed) may return r > d (all limbs)
BSWAP_LIMB(dst, src) - reverse bytes in a limb
BSWAP_LIMB_FETCH(dst, src) - set dst to the reverse of the bytes in the limb
pointed to by src
BSWAP_LIMB_STORE(dst, src) - set limb pointed to by dst to the reverse of the bytes in src
popc_limb(result, input) - population count of a limb (fast!!)
POW2_P(n) - return 1 if n is a power of 2 (or 0)
CNST_LIMB(C) - platform independent way of writing e.g. 1L if C was 1 say
MEM_OVERLAP_P(xp, xsize, yp, ysize) - nonzero if given arrays of bytes overlap
invert_limb(invxl, xl) - set invxl to the "inverse" of the limb xl for functions
that take a precomputed "inverse" limb
technically this isn't an inverse, but it sets invxl to the largest limb
not larger than (2^(2*BITS_PER_MP_LIMB))/xl - (2^BITS_PER_MP_LIMB) and all
1's if this would give an overflow
udiv_qrnnd_preinv1(q, r, nh, nl, d, di) - nh, nl divided by d with di an "inverse"
of d. The most significant bit of d has to be set
udiv_qrnnd_preinv2(q, r, nh, nl, d, di) - as for preinv1 but branch free
udiv_qrnnd_preinv2gen(q, r, nh, nl, d, di, dnorm, lgup) - as for preinv2 but for
any d. dnorm is d shifted left so its msb is set, lgup is ceil_log2(d)
modlimb_invert(inv, n) - true limb invert, i.e. inv*n == 1 mod 2^GMP_NUMB_BITS
MODLIMB_INVERSE_3 - special case of modlimb_invert for n == 3
MPZ_TMP_INIT(X, NLIMBS) - Allocates a temporary mpz_t with space for NLIMBS, space
will automatically be cleared out upon calling function's return
MPZ_REALLOC(z, n) - reallocate mpz_t to n limbs if it doesn't have enough
MPZ_EQUAL_1_P(z) - returns 1 if z is 1, otherwise 0
MPZ_FAKE_UI(z, zp, u) - creates a fake mpz_t z from an ui. zp must have space for
an unsigned long
ABOVE_THRESHOLD(size, thresh) - decide whether to use algorithm A or B depending whether size >= thresh. thresh == MP_SIZE_T_MAX means only ever use A,
thresh == 0 means only ever use B
BELOW_THRESHOLD(size, thresh) - !ABOVE_THRESHOLD
Macro constants defined in gmp_impl.h
===========================================
BYTES_PER_MP_LIMB - bytes per limb
BITS_PER_MP_LIMB - bits per limb
BITS_PER_ULONG - bits in an unsigned long
LIMBS_PER_ULONG - number of limbs per unsigned long
ULONG_MAX - unsigned long ~0
UINT_MAX - unsigned in ~0
USHRT_MAX - unsigned short ~0
MP_LIMB_T_MAX - mp_limb_t ~0
ULONG_HIGHBIT - unsigned long high bit set
UINT_HIGHBIT - unsigned int high bit set
USHRT_HIGHBIT - unsigned short high bit set
GMP_LIMB_HIGHBIT - mp_limb_t high bit set
LONG_MIN - smallest negative long
LONG_MAX - largest positive long
LONG_HIGHBIT - LONG_MIN
INT_MIN - smallest negative int
INT_MAX - largest positive int
INT_HIGHBIT - INT_MIN
SHRT_MIN - smallest negative short
SHRT_MAX - largest positive short
SHRT_HIGHBIT - SHRT_MIN
MP_SIZE_T_MIN - smallest negative mp_size_t
MP_SIZE_T_MAX - largest positive mp_size_t
MP_EXP_T_MIN - smallest negative mp_exp_t
MP_EXP_T_MAX - largest positive mp_exp_t
GMP_NUMB_HIGHBIT - highest bit of a limb (not including nail bits)
GMP_NUMB_CEIL_MAX_DIV3 - ceil(GMP_NUMB_MAX/3)
GMP_NUMB_CEIL_2MAX_DIV3 - ceil(2*GMP_NUMB_MAX/3)
PP - product of odd primes that will fit in a limb 3x5x...
PP_FIRST_OMITTED - first odd prime omitted
PP_INVERTED - inverse of PP
Exception macros
===========================================
GMP_ERROR(code) - raise exception with given code
DIVIDE_BY_ZERO - raise divide by zero exception
SQRT_OF_NEGATIVE - raise square root of negative exception
Some types defined in gmp_impl.h
===========================================
gmp_uint_least32_t - unsigned integer type with at least 32 bits
Macros used in prototypes
===========================================
ATTRIBUTE_CONST - function examines its arguments and returns a value but no
memory is read or written to and function has no side effects
ATTRIBUTE_NORETURN - signifies a function that won't ever return (supresses
"code unreachable" compile time errors)
ATTRIBUTE_MALLOC - function returns a pointer that can't alias anything,
just as malloc does
REGPARM_2_1(a,b,x) - reorder parameters to x,a,b so that x can be put in a reg
REGPARM_3_1(a,b,c,x) - reorder parameters to x,a,b,c so that x can be put in a reg
REGPARM_ATTR(n) - make parameter a register parameter
Stack based memory manager
==========================
Usage: TMP_DECL;
TMP_MARK;
ptr = TMP_ALLOC(bytes);
TMP_FREE;
This pushes handling of the stack allocation onto the calling function, which is
what Pari does. It is faster than malloc and other stack based methods (!) A
reentrant version is available by doing #define WANT_TMP_REENTRANT 1
Variants: TMP_SDECL, TMP_SMARK, TMP_SALLOC, TMP_SFREE - for small allocations
(uses alloca if available)
TMP_SDECL, TMP_SMARK, TMP_SALLOC, TMP_SFREE - for large allocations
Note: TEMP_ALLOC calls TMP_SALLOC if bytes < 65536, otherwise TMP_BALLOC
TMP_B/S/ALLOC_TYPE(n, type) - alloc space for n variables of the given type
TMP_B/S/ALLOC_LIMBS(n) - alloc space for n limbs
TMP_B/S/ALLOC_MP_PTRS(n) - alloc space for n mp_ptr's
TMP_ALLOC_LIMBS_2(xp, xsize, yp, ysize) - makes two allocations at once (faster)
Memory manager
==========================
alloca(size) - allocate size bytes of space in the stack frame of the calling
function. Space is automatically freed when the calling function returns
__gmp_default_allocate(bytes) - alloc bytes using GMP default memory manager
__gmp_default_reallocate(ptr,bytes) - realloc bytes using default memory manager
__gmp_default_free(ptr, size) - free the size bytes allocated at ptr
__GMP_ALLOCATE_FUNC_TYPE(n, type) - allocate space for n vars of given type using
user defined memory management function
__GMP_ALLOCATE_FUNC_LIMBS(n) - allocate n limbs, user defined mem man
__GMP_REALLOCATE_FUNC_TYPE(p, old, new, type) - reallocate from old to new size
user defined memory management function
__GMP_REALLOCATE_FUNC_LIMBS(p, old, new) - realloc from old to new limbs,
user defined mem man
__GMP_FREE_FUNC_TYPE(n, type) - free space for n vars of given type using
user defined memory management function
__GMP_FREE_FUNC_LIMBS(n) - free n limbs, user defined mem man
__GMP_REALLOCATE_FUNC_MAYBE(p, old, new) - reallocate, oldsize can equal newsize,
