The functions in this section are for various special purposes. Most applications will not need them.
void mpz_array_init (mpz_t integer_array, mp_size_t array_size, mp_size_t fixed_num_bits) ¶This is an obsolete function. Do not use it.
void * _mpz_realloc (mpz_t integer, mp_size_t new_alloc) ¶Change the space for integer to new_alloc limbs. The value in integer is preserved if it fits, or is set to 0 if not. The return value is not useful to applications and should be ignored.
mpz_realloc2 is the preferred way to accomplish allocation changes like
this. mpz_realloc2 and _mpz_realloc are the same except that
_mpz_realloc takes its size in limbs.
mp_limb_t mpz_getlimbn (const mpz_t op, mp_size_t n) ¶Return limb number n from op. The sign of op is ignored, just the absolute value is used. The least significant limb is number 0.
mpz_size can be used to find how many limbs make up op.
mpz_getlimbn returns zero if n is outside the range 0 to
mpz_size(op)-1.
size_t mpz_size (const mpz_t op) ¶Return the size of op measured in number of limbs. If op is zero, the returned value will be zero.
const mp_limb_t * mpz_limbs_read (const mpz_t x) ¶Return a pointer to the limb array representing the absolute value of x.
The size of the array is mpz_size(x). Intended for read access
only.
mp_limb_t * mpz_limbs_write (mpz_t x, mp_size_t n) ¶mp_limb_t * mpz_limbs_modify (mpz_t x, mp_size_t n) ¶Return a pointer to the limb array, intended for write access. The array is
reallocated as needed, to make room for n limbs. Requires n
> 0. The mpz_limbs_modify function returns an array that holds the old
absolute value of x, while mpz_limbs_write may destroy the old
value and return an array with unspecified contents.
void mpz_limbs_finish (mpz_t x, mp_size_t s) ¶Updates the internal size field of x. Used after writing to the limb
array pointer returned by mpz_limbs_write or mpz_limbs_modify is
completed. The array should contain abs(s) valid limbs,
representing the new absolute value for x, and the sign of x is
taken from the sign of s. This function never reallocates x, so
the limb pointer remains valid.
void foo (mpz_t x)
{
mp_size_t n, i;
mp_limb_t *xp;
n = mpz_size (x);
xp = mpz_limbs_modify (x, 2*n);
for (i = 0; i < n; i++)
xp[n+i] = xp[n-1-i];
mpz_limbs_finish (x, mpz_sgn (x) < 0 ? - 2*n : 2*n);
}
mpz_srcptr mpz_roinit_n (mpz_t x, const mp_limb_t *xp, mp_size_t xs) ¶Special initialization of x, using the given limb array and size. x should be treated as read-only: it can be passed safely as input to any mpz function, but not as an output. The array xp must point to at least a readable limb, its size is abs(xs), and the sign of x is the sign of xs. For convenience, the function returns x, but cast to a const pointer type.
void foo (mpz_t x)
{
static const mp_limb_t y[3] = { 0x1, 0x2, 0x3 };
mpz_t tmp;
mpz_add (x, x, mpz_roinit_n (tmp, y, 3));
}
mpz_t MPZ_ROINIT_N (mp_limb_t *xp, mp_size_t xs) ¶This macro expands to an initializer which can be assigned to an mpz_t
variable. The limb array xp must point to at least a readable limb,
moreover, unlike the mpz_roinit_n function, the array must be
normalized: if xs is non-zero, then
xp[abs(xs)-1] must be non-zero. Intended
primarily for constant values. Using it for non-constant values requires a C
compiler supporting C99.
void foo (mpz_t x)
{
static const mp_limb_t ya[3] = { 0x1, 0x2, 0x3 };
static const mpz_t y = MPZ_ROINIT_N ((mp_limb_t *) ya, 3);
mpz_add (x, x, y);
}