Division is undefined if the divisor is zero. Passing a zero divisor to the
division or modulo functions (including the modular powering functions
`mpz_powm`

and `mpz_powm_ui`

) will cause an intentional division by
zero. This lets a program handle arithmetic exceptions in these functions the
same way as for normal C `int`

arithmetic.

- Function:
`void`

**mpz_cdiv_q**`(mpz_t`

¶`q`, const mpz_t`n`, const mpz_t`d`) - Function:
`void`

**mpz_cdiv_r**`(mpz_t`

¶`r`, const mpz_t`n`, const mpz_t`d`) - Function:
`void`

**mpz_cdiv_qr**`(mpz_t`

¶`q`, mpz_t`r`, const mpz_t`n`, const mpz_t`d`) - Function:
`unsigned long int`

**mpz_cdiv_q_ui**`(mpz_t`

¶`q`, const mpz_t`n`, unsigned long int`d`) - Function:
`unsigned long int`

**mpz_cdiv_r_ui**`(mpz_t`

¶`r`, const mpz_t`n`, unsigned long int`d`) - Function:
`unsigned long int`

**mpz_cdiv_qr_ui**`(mpz_t`

¶`q`, mpz_t`r`, const mpz_t`n`, unsigned long int`d`) - Function:
`unsigned long int`

**mpz_cdiv_ui**`(const mpz_t`

¶`n`, unsigned long int`d`) - Function:
`void`

**mpz_cdiv_q_2exp**`(mpz_t`

¶`q`, const mpz_t`n`, mp_bitcnt_t`b`) - Function:
`void`

**mpz_cdiv_r_2exp**`(mpz_t`

¶`r`, const mpz_t`n`, mp_bitcnt_t`b`)

- Function:
`void`

**mpz_fdiv_q**`(mpz_t`

¶`q`, const mpz_t`n`, const mpz_t`d`) - Function:
`void`

**mpz_fdiv_r**`(mpz_t`

¶`r`, const mpz_t`n`, const mpz_t`d`) - Function:
`void`

**mpz_fdiv_qr**`(mpz_t`

¶`q`, mpz_t`r`, const mpz_t`n`, const mpz_t`d`) - Function:
`unsigned long int`

**mpz_fdiv_q_ui**`(mpz_t`

¶`q`, const mpz_t`n`, unsigned long int`d`) - Function:
`unsigned long int`

**mpz_fdiv_r_ui**`(mpz_t`

¶`r`, const mpz_t`n`, unsigned long int`d`) - Function:
`unsigned long int`

**mpz_fdiv_qr_ui**`(mpz_t`

¶`q`, mpz_t`r`, const mpz_t`n`, unsigned long int`d`) - Function:
`unsigned long int`

**mpz_fdiv_ui**`(const mpz_t`

¶`n`, unsigned long int`d`) - Function:
`void`

**mpz_fdiv_q_2exp**`(mpz_t`

¶`q`, const mpz_t`n`, mp_bitcnt_t`b`) - Function:
`void`

**mpz_fdiv_r_2exp**`(mpz_t`

¶`r`, const mpz_t`n`, mp_bitcnt_t`b`)

- Function:
`void`

**mpz_tdiv_q**`(mpz_t`

¶`q`, const mpz_t`n`, const mpz_t`d`) - Function:
`void`

**mpz_tdiv_r**`(mpz_t`

¶`r`, const mpz_t`n`, const mpz_t`d`) - Function:
`void`

**mpz_tdiv_qr**`(mpz_t`

¶`q`, mpz_t`r`, const mpz_t`n`, const mpz_t`d`) - Function:
`unsigned long int`

**mpz_tdiv_q_ui**`(mpz_t`

¶`q`, const mpz_t`n`, unsigned long int`d`) - Function:
`unsigned long int`

**mpz_tdiv_r_ui**`(mpz_t`

¶`r`, const mpz_t`n`, unsigned long int`d`) - Function:
`unsigned long int`

**mpz_tdiv_qr_ui**`(mpz_t`

¶`q`, mpz_t`r`, const mpz_t`n`, unsigned long int`d`) - Function:
`unsigned long int`

**mpz_tdiv_ui**`(const mpz_t`

¶`n`, unsigned long int`d`) - Function:
`void`

**mpz_tdiv_q_2exp**`(mpz_t`

¶`q`, const mpz_t`n`, mp_bitcnt_t`b`) - Function:
`void`

**mpz_tdiv_r_2exp**`(mpz_t`

¶`r`, const mpz_t`n`, mp_bitcnt_t`b`) -

Divide

`n`by`d`, forming a quotient`q`and/or remainder`r`. For the`2exp`

functions,. The rounding is in three styles, each suiting different applications.`d`=2^`b``cdiv`

rounds`q`up towards*+infinity*, and`r`will have the opposite sign to`d`. The`c`

stands for “ceil”.`fdiv`

rounds`q`down towards*−infinity*, and`r`will have the same sign as`d`. The`f`

stands for “floor”.`tdiv`

rounds`q`towards zero, and`r`will have the same sign as`n`. The`t`

stands for “truncate”.

In all cases

`q`and`r`will satisfy, and`n`=`q`*`d`+`r``r`will satisfy*0<=abs(*.`r`)<abs(`d`)The

`q`

functions calculate only the quotient, the`r`

functions only the remainder, and the`qr`

functions calculate both. Note that for`qr`

the same variable cannot be passed for both`q`and`r`, or results will be unpredictable.For the

`ui`

variants the return value is the remainder, and in fact returning the remainder is all the`div_ui`

functions do. For`tdiv`

and`cdiv`

the remainder can be negative, so for those the return value is the absolute value of the remainder.For the

`2exp`

variants the divisor is*2^*. These functions are implemented as right shifts and bit masks, but of course they round the same as the other functions.`b`For positive

`n`both`mpz_fdiv_q_2exp`

and`mpz_tdiv_q_2exp`

are simple bitwise right shifts. For negative`n`,`mpz_fdiv_q_2exp`

is effectively an arithmetic right shift treating`n`as two’s complement the same as the bitwise logical functions do, whereas`mpz_tdiv_q_2exp`

effectively treats`n`as sign and magnitude.

- Function:
`void`

**mpz_mod**`(mpz_t`

¶`r`, const mpz_t`n`, const mpz_t`d`) - Function:
`unsigned long int`

**mpz_mod_ui**`(mpz_t`

¶`r`, const mpz_t`n`, unsigned long int`d`) Set

`r`to`n``mod`

`d`. The sign of the divisor is ignored; the result is always non-negative.`mpz_mod_ui`

is identical to`mpz_fdiv_r_ui`

above, returning the remainder as well as setting`r`. See`mpz_fdiv_ui`

above if only the return value is wanted.

- Function:
`void`

**mpz_divexact**`(mpz_t`

¶`q`, const mpz_t`n`, const mpz_t`d`) - Function:
`void`

**mpz_divexact_ui**`(mpz_t`

¶`q`, const mpz_t`n`, unsigned long`d`) -
Set

`q`to`n`/`d`. These functions produce correct results only when it is known in advance that`d`divides`n`.These routines are much faster than the other division functions, and are the best choice when exact division is known to occur, for example reducing a rational to lowest terms.

- Function:
`int`

**mpz_divisible_p**`(const mpz_t`

¶`n`, const mpz_t`d`) - Function:
`int`

**mpz_divisible_ui_p**`(const mpz_t`

¶`n`, unsigned long int`d`) - Function:
`int`

**mpz_divisible_2exp_p**`(const mpz_t`

¶`n`, mp_bitcnt_t`b`) -
Return non-zero if

`n`is exactly divisible by`d`, or in the case of`mpz_divisible_2exp_p`

by*2^*.`b``n`is divisible by`d`if there exists an integer`q`satisfying. Unlike the other division functions,`n`=`q`*`d`is accepted and following the rule it can be seen that only 0 is considered divisible by 0.`d`=0

- Function:
`int`

**mpz_congruent_p**`(const mpz_t`

¶`n`, const mpz_t`c`, const mpz_t`d`) - Function:
`int`

**mpz_congruent_ui_p**`(const mpz_t`

¶`n`, unsigned long int`c`, unsigned long int`d`) - Function:
`int`

**mpz_congruent_2exp_p**`(const mpz_t`

¶`n`, const mpz_t`c`, mp_bitcnt_t`b`) -
Return non-zero if

`n`is congruent to`c`modulo`d`, or in the case of`mpz_congruent_2exp_p`

modulo*2^*.`b``n`is congruent to`c`mod`d`if there exists an integer`q`satisfying. Unlike the other division functions,`n`=`c`+`q`*`d`is accepted and following the rule it can be seen that`d`=0`n`and`c`are considered congruent mod 0 only when exactly equal.