Go to the previous, next section.

**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,
**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
`mpz_`

and `mpq_`

layers.

The code below adds the number beginning at `src1_ptr` and the
number beginning at `src2_ptr` and writes the sum at `dest_ptr`.
A constraint for `mpn_add`

is that `src1_size` must not be
smaller that `src2_size`.

mpn_add (dest_ptr, src1_ptr, src1_size, src2_ptr, src2_size)

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

__Function:__ mp_size **mpn_add** *(mp_ptr dest_ptr, mp_srcptr src1_ptr, mp_size src1_size, mp_srcptr src2_ptr, mp_size src2_size)*

Add {`src1_ptr`, `src1_size`} and {`src2_ptr`,
`src2_size`}, and write the `src1_size` least significant limbs
of the result to `dest_ptr`. Carry-out, either 0 or 1, is returned.

This function requires that `src1_size` is greater than or equal to
`src2_size`.

__Function:__ mp_size **mpn_sub** *(mp_ptr dest_ptr, mp_srcptr src1_ptr, mp_size src1_size, mp_srcptr src2_ptr, mp_size src2_size)*

Subtarct {`src2_ptr`, `src2_size`} from {`src1_ptr`,
`src1_size`}, and write the result to `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 `src1_size` words, -1 if
it has `src1_size` - 1 words, etc.

This function requires that `src1_size` is greater than or equal to
`src2_size`.

__Function:__ mp_size **mpn_mul** *(mp_ptr dest_ptr, mp_srcptr src1_ptr, mp_size src1_size, mp_srcptr src2_ptr, mp_size src2_size)*

Multiply {`src1_ptr`, `src1_size`} and {`src2_ptr`,
`src2_size`}, and write the result to `dest_ptr`. The exact
size of the result is returned.

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

This function requires that `src1_size` is greater than or equal to
`src2_size`. The destination must be distinct from either input
operands.

__Function:__ mp_size **mpn_div** *(mp_ptr dest_ptr, mp_ptr src1_ptr, mp_size src1_size, mp_srcptr src2_ptr, mp_size src2_size)*

Divide {`src1_ptr`, `src1_size`} by {`src2_ptr`,
`src2_size`}, and write the quotient to `dest_ptr`, and the
remainder to `src1_ptr`.

Return 0 if the quotient size is at most (`src1_size` -
`src2_size`), and 1 if the quotient size is at most (`src1_size`
- `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 `src1_size` is greater than or equal to
`src2_size`. The quotient, pointed to by `dest_ptr`, must be
distinct from either input operands.

__Function:__ mp_limb **mpn_lshift** *(mp_ptr dest_ptr, mp_srcptr src_ptr, mp_size src_size, unsigned long int count)*

Shift {`src_ptr`, `src_size`} `count` bits to the left, and
write the `src_size` least significant limbs of the result to
`dest_ptr`. `count` might be in the range 1 to n - 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 `dest_ptr` >= `src_ptr`.

__Function:__ mp_size **mpn_rshift** *(mp_ptr dest_ptr, mp_srcptr src_ptr, mp_size src_size, unsigned long int count)*

Shift {`src_ptr`, `src_size`} `count` bits to the right, and
write the `src_size` least significant limbs of the result to
`dest_ptr`. `count` might be in the range 1 to n - 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 `dest_ptr` <= `src_ptr`.

__Function:__ mp_size **mpn_rshiftci** *(mp_ptr dest_ptr, mp_srcptr src_ptr, mp_size src_size, unsigned long int count, mp_limb inlimb)*

Like mpn_rshift, but use `inlimb` to feed the least significant end
of the destination.

__Function:__ int **mpn_cmp** *(mp_srcptr src1_ptr, mp_srcptr src2_ptr, mp_size size)*

Compare {`src1_ptr`, `size`} and {`src2_ptr`, `size`}
and return a positive value if src1 > src2, 0 of they are equal,
and a negative value if src1 < src2.

Go to the previous, next section.