# Multiple-precision Integers¶

The gmpy2 *mpz* type supports arbitrary precision integers. It should be a
drop-in replacement for Python’s *long* type. Depending on the platform and the
specific operation, an *mpz* will be faster than Python’s *long* once the
precision exceeds 20 to 50 digits. All the special integer functions in GMP are
supported.

## Examples¶

```
>>> import gmpy2
>>> from gmpy2 import mpz
>>> mpz('123') + 1
mpz(124)
>>> 10 - mpz(1)
mpz(9)
>>> gmpy2.is_prime(17)
True
```

Note

The use of `from gmpy2 import *`

is not recommended. The names in gmpy2
have been chosen to avoid conflict with Python’s builtin names but gmpy2
does use names that may conflict with other modules or variable names.

## mpz Methods¶

**bit_clear(...)**- x.bit_clear(n) returns a copy of
*x*with bit*n*set to 0. **bit_flip(...)**- x.bit_flip(n) returns a copy of
*x*with bit*n*inverted. **bit_length(...)**- x.bit_length() returns the number of significant bits in the radix-2
representation of
*x*. For compatibility with Python, mpz(0).bit_length() returns 0. **bit_scan0(...)**- x.bit_scan0(n) returns the index of the first 0-bit of
*x*with index >=*n*. If there are no more 0-bits in*x*at or above index*n*(which can only happen for*x*< 0, assuming an infinitely long 2’s complement format), then None is returned.*n*must be >= 0. **bit_scan1(...)**- x.bit_scan1(n) returns the index of the first 1-bit of
*x*with index >=*n*. If there are no more 1-bits in*x*at or above index*n*(which can only happen for*x*>= 0, assuming an infinitely long 2’s complement format), then None is returned.*n*must be >= 0. **bit_set(...)**- x.bit_set(n) returns a copy of
*x*with bit*n*set to 1. **bit_test(...)**- x.bit_test(n) returns True if bit
*n*of*x*is set, and False if it is not set. **denominator(...)**- x.denominator() returns mpz(1).
**digits(...)**- x.digits([base=10]) returns a string representing
*x*in radix*base*. **numerator(...)**- x.numerator() returns a copy of x.
**num_digits(...)**- x.num_digits([base=10]) returns the length of the string representing
the absolute value of
*x*in radix*base*. The result is correct if base is a power of 2. For other other bases, the result is usually correct but may be 1 too large.*base*can range between 2 and 62, inclusive.

## mpz Functions¶

**add(...)**- add(x, y) returns
*x*+*y*. The result type depends on the input types. **bincoef(...)**- bincoef(x, n) returns the binomial coefficient.
*n*must be >= 0. **bit_clear(...)**- bit_clear(x, n) returns a copy of
*x*with bit*n*set to 0. **bit_flip(...)**- bit_flip(x, n) returns a copy of
*x*with bit*n*inverted. **bit_length(...)**- bit_length(x) returns the number of significant bits in the radix-2
representation of
*x*. For compatibility with Python, mpz(0).bit_length() returns 0 while mpz(0).num_digits(2) returns 1. **bit_mask(...)**- bit_mask(n) returns an
*mpz*object exactly*n*bits in length with all bits set. **bit_scan0(...)**- bit_scan0(x, n) returns the index of the first 0-bit of
*x*with index >=*n*. If there are no more 0-bits in*x*at or above index*n*(which can only happen for*x*< 0, assuming an infinitely long 2’s complement format), then None is returned.*n*must be >= 0. **bit_scan1(...)**- bit_scan1(x, n) returns the index of the first 1-bit of
*x*with index >=*n*. If there are no more 1-bits in*x*at or above index*n*(which can only happen for*x*>= 0, assuming an infinitely long 2’s complement format), then None is returned.*n*must be >= 0. **bit_set(...)**- bit_set(x, n) returns a copy of
*x*with bit*n*set to 1. **bit_test(...)**- bit_test(x, n) returns True if bit
*n*of*x*is set, and False if it is not set. **c_div(...)**- c_div(x, y) returns the quotient of
*x*divided by*y*. The quotient is rounded towards +Inf (ceiling rounding).*x*and*y*must be integers. **c_div_2exp(...)**- c_div_2exp(x, n) returns the quotient of
*x*divided by 2**n. The quotient is rounded towards +Inf (ceiling rounding).*x*must be an integer and*n*must be > 0. **c_divmod(...)**- c_divmod(x, y) returns the quotient and remainder of
*x*divided by*y*. The quotient is rounded towards +Inf (ceiling rounding) and the remainder will have the opposite sign of*y*.*x*and*y*must be integers. **c_divmod_2exp(...)**- c_divmod_2exp(x ,n) returns the quotient and remainder of
*x*divided by 2**n. The quotient is rounded towards +Inf (ceiling rounding) and the remainder will be negative or zero.*x*must be an integer and*n*must be > 0. **c_mod(...)**- c_mod(x, y) returns the remainder of
*x*divided by*y*. The remainder will have the opposite sign of*y*.*x*and*y*must be integers. **c_mod_2exp(...)**- c_mod_2exp(x, n) returns the remainder of
*x*divided by 2**n. The remainder will be negative.*x*must be an integer and*n*must be > 0. **comb(...)**- comb(x, n) returns the number of combinations of
*x*things, taking*n*at a time.*n*must be >= 0. **digits(...)**- digits(x[, base=10]) returns a string representing
*x*in radix*base*. **div(...)**- div(x, y) returns
*x*/*y*. The result type depends on the input types. **divexact(...)**- divexact(x, y) returns the quotient of
*x*divided by*y*. Faster than standard division but requires the remainder is zero! **divm(...)**- divm(a, b, m) returns
*x*such that*b***x*==*a*modulo*m*. Raises a ZeroDivisionError exception if no such value*x*exists. **f_div(...)**- f_div(x, y) returns the quotient of
*x*divided by*y*. The quotient is rounded towards -Inf (floor rounding).*x*and*y*must be integers. **f_div_2exp(...)**- f_div_2exp(x, n) returns the quotient of
*x*divided by 2**n. The quotient is rounded towards -Inf (floor rounding).*x*must be an integer and*n*must be > 0. **f_divmod(...)**- f_divmod(x, y) returns the quotient and remainder of
*x*divided by*y*. The quotient is rounded towards -Inf (floor rounding) and the remainder will have the same sign as*y*.*x*and*y*must be integers. **f_divmod_2exp(...)**- f_divmod_2exp(x, n) returns quotient and remainder after dividing
*x*by 2**n. The quotient is rounded towards -Inf (floor rounding) and the remainder will be positive.*x*must be an integer and*n*must be > 0. **f_mod(...)**- f_mod(x, y) returns the remainder of
*x*divided by*y*. The remainder will have the same sign as*y*.*x*and*y*must be integers. **f_mod_2exp(...)**- f_mod_2exp(x, n) returns remainder of
*x*divided by 2**n. The remainder will be positive.*x*must be an integer and*n*must be > 0. **fac(...)**- fac(n) returns the exact factorial of
*n*. Use factorial() to get the floating-point approximation. **fib(...)**- fib(n) returns the
*n*-th Fibonacci number. **fib2(...)**- fib2(n) returns a 2-tuple with the (
*n*-1)-th and*n*-th Fibonacci numbers. **gcd(...)**- gcd(a, b) returns the greatest common divisor of integers
*a*and*b*. **gcdext(...)**gcdext(a, b) returns a 3-element tuple (

*g*,*s*,*t*) such that*g*== gcd(*a*,*b*) and*g*==*a***s*+*b***t***hamdist(...)**- hamdist(x, y) returns the Hamming distance (number of bit-positions
where the bits differ) between integers
*x*and*y*. **invert(...)**- invert(x, m) returns
*y*such that*x***y*== 1 modulo*m*, or 0 if no such*y*exists. **iroot(...)**- iroot(x,n) returns a 2-element tuple (
*y*,*b*) such that*y*is the integer*n*-th root of*x*and*b*is True if the root is exact.*x*must be >= 0 and*n*must be > 0. **iroot_rem(...)**- iroot_rem(x,n) returns a 2-element tuple (
*y*,*r*) such that*y*is the integer*n*-th root of*x*and*x*= y**n +*r*.*x*must be >= 0 and*n*must be > 0. **is_even(...)**- is_even(x) returns True if
*x*is even, False otherwise. **is_odd(...)**- is_odd(x) returns True if
*x*is odd, False otherwise. **is_power(...)**- is_power(x) returns True if
*x*is a perfect power, False otherwise. **is_prime(...)**- is_prime(x[, n=25]) returns True if
*x*is**probably**prime. False is returned if*x*is definitely composite.*x*is checked for small divisors and up to*n*Miller-Rabin tests are performed. The actual tests performed may vary based on version of GMP or MPIR used. **is_square(...)**- is_square(x) returns True if
*x*is a perfect square, False otherwise. **isqrt(...)**- isqrt(x) returns the integer square root of an integer
*x*.*x*must be >= 0. **isqrt_rem(...)**- isqrt_rem(x) returns a 2-tuple (
*s*,*t*) such that*s*= isqrt(*x*) and*t*=*x*-*s***s*.*x*must be >= 0. **jacobi(...)**- jacobi(x, y) returns the Jacobi symbol (
*x*|*y*).*y*must be odd and > 0. **kronecker(...)**- kronecker(x, y) returns the Kronecker-Jacobi symbol (
*x*|*y*). **lcm(...)**- lcm(a, b) returns the lowest common multiple of integers
*a*and*b*. **legendre(...)**- legendre(x, y) returns the Legendre symbol (
*x*|*y*).*y*is assumed to be an odd prime. **lucas(...)**- lucas(n) returns the
*n*-th Lucas number. **lucas2(...)**- lucas2(n) returns a 2-tuple with the (
*n*-1)-th and*n*-th Lucas numbers. **mpz(...)**mpz() returns a new

*mpz*object set to 0.mpz(n) returns a new

*mpz*object from a numeric value*n*. If*n*is not an integer, it will be truncated to an integer.mpz(s[, base=0]) returns a new

*mpz*object from a string*s*made of digits in the given base. If base = 0, thn binary, octal, or hex Python strings are recognized by leading 0b, 0o, or 0x characters. Otherwise the string is assumed to be decimal. Values for base can range between 2 and 62.**mpz_random(...)**- mpz_random(random_state, n) returns a uniformly distributed random
integer between 0 and
*n*-1. The parameter*random_state*must be created by random_state() first. **mpz_rrandomb(...)**- mpz_rrandomb(random_state, b) returns a random integer between 0 and
2**b - 1 with long sequences of zeros and one in its binary representation.
The parameter
*random_state*must be created by random_state() first. **mpz_urandomb(...)**- mpz_urandomb(random_state, b) returns a uniformly distributed random
integer between 0 and 2**b - 1. The parameter
*random_state*must be created by random_state() first. **mul(...)**- mul(x, y) returns
*x***y*. The result type depends on the input types. **next_prime(...)**- next_prime(x) returns the next
**probable**prime number >*x*. **num_digits(...)**- num_digits(x[, base=10]) returns the length of the string representing
the absolute value of
*x*in radix*base*. The result is correct if base is a power of 2. For other other bases, the result is usually correct but may be 1 too large.*base*can range between 2 and 62, inclusive. **popcount(...)**- popcount(x) returns the number of bits with value 1 in
*x*. If*x*< 0, the number of bits with value 1 is infinite so -1 is returned in that case. **powmod(...)**- powmod(x, y, m) returns (
*x****y*) mod*m*. The exponenent*y*can be negative, and the correct result will be returned if the inverse of*x*mod*m*exists. Otherwise, a ValueError is raised. **remove(...)**- remove(x, f) will remove the factor
*f*from*x*as many times as possible and return a 2-tuple (*y*,*m*) where*y*=*x*// (*f****m*).*f*does not divide*y*.*m*is the multiplicity of the factor*f*in*x*.*f*must be > 1. **sub(...)**- sub(x, y) returns
*x*-*y*. The result type depends on the input types. **t_div(...)**- t_div(x, y) returns the quotient of
*x*divided by*y*. The quotient is rounded towards zero (truncation).*x*and*y*must be integers. **t_div_2exp(...)**- t_div_2exp(x, n) returns the quotient of
*x*divided by 2**n. The quotient is rounded towards zero (truncation).*n*must be > 0. **t_divmod(...)**- t_divmod(x, y) returns the quotient and remainder of
*x*divided by*y*. The quotient is rounded towards zero (truncation) and the remainder will have the same sign as*x*.*x*and*y*must be integers. **t_divmod_2exp(...)**- t_divmod_2exp(x, n) returns the quotient and remainder of
*x*divided by 2**n. The quotient is rounded towards zero (truncation) and the remainder will have the same sign as*x*.*x*must be an integer and*n*must be > 0. **t_mod(...)**- t_mod(x, y) returns the remainder of
*x*divided by*y*. The remainder will have the same sign as*x*.*x*and*y*must be integers. **t_mod_2exp(...)**- t_mod_2exp(x, n) returns the remainder of
*x*divided by 2**n. The remainder will have the same sign as*x*.*x*must be an integer and*n*must be > 0.