The type of big integers.

Addition of a small integer to a big integer.

Return the square of the given big integer

sqrt_big_int a returns the integer square root of a, that is, the largest big integer r such that r * r <= a.

• raises Invalid_argument

  if a is negative.

Euclidean division of two big integers. The first part of the result is the quotient, the second part is the remainder. Writing (q,r) = quomod_big_int a b, we have a = q * b + r and 0 <= r < |b|.

• raises Division_by_zero

  if the divisor is zero.

Exponentiation functions. Return the big integer representing the first argument a raised to the power b (the second argument). Depending on the function, a and b can be either small integers or big integers.

• raises Invalid_argument

  if b is negative.

Return 0 if the given big integer is zero, 1 if it is positive, and -1 if it is negative.

compare_big_int a b returns 0 if a and b are equal, 1 if a is greater than b, and -1 if a is smaller than b.

Usual boolean comparisons between two big integers.

Return the greater of its two arguments.

Return the smaller of its two arguments.

Return the number of machine words used to store the given big integer.

Return the number of significant bits in the absolute value of the given big integer. num_bits_big_int a returns 0 if a is 0; otherwise it returns a positive integer n such that 2^(n-1) <= |a| < 2^n.

• since 2.5.0 and OCaml 4.03

Return the string representation of the given big integer, in decimal (base 10).

Convert a string to a big integer, in decimal. The string consists of an optional - or + sign, followed by one or several decimal digits.

Convert a string to a big integer, in decimal. The string consists of an optional - or + sign, followed by one or several decimal digits. Other the function returns None.

• since 2.7.0

as string_of_big_int, but in base 2

as string_of_big_int, but in base 8

as string_of_big_int, but in base 16

to_string_in_base b n returns the string representation in base b of the given big integer n. Should you have advanced needs (arbitrarily large bases, or custom digits instead of the usual 0,1,...9,a,b,...,z), use to_string_in_custom_base instead.

• raises Invalid_argument

  if b is not in 2 .. 36.

First argument, called symbols, is the vector of the symbols used to represent the digits in base b. to_string_in_base is almost equivalent to to_string_in_custom_base big_int_base_default_symbols, the difference being that to_string_in_custom_base allows the base to be arbitrarily large, provided that symbols can accommodate it. Concretely, the base b must be at least 2, and symbols must be of size at least b. The default value of big_int_base_default_symbols contains 62 symbols, as it uses lowercase and uppercase letters both. See below for more information.

• raises Invalid_argument

  if b is incorrect.

Default vector of symbols used by to_string_in_base and its fixed-base derivatives to_string_in_binary, to_string_in_octal and to_string_in_hexa to represent digits. The symbol at position p encodes the value p. The original value of this vector is, schematically, ['0'..'9' 'a' 'b'..'z' 'A' 'B'..'Z'], which is sufficient for bases up to and including 62. The basic to_string_in_base function is capped to base 36 to avoid unexpected behaviours do to the case-sensitivity of the output in bases 37 to 62. You technically can mutate the vector, for instance if you prefer to exchange lower- and upper-case symbols program-wide. As usual where mutability is concerned, discretion is advised. Most of the time, it is better to build custom functions using to_string_in_custom_base.

Convert a small integer to a big integer.

Test whether the given big integer is small enough to be representable as a small integer (type int) without loss of precision. On a 32-bit platform, is_int_big_int a returns true if and only if a is between -2³⁰ and 2³⁰-1. On a 64-bit platform, is_int_big_int a returns true if and only if a is between -2⁶² and 2⁶²-1.

Convert a big integer to a small integer (type int).

• raises Failure

  if the big integer is not representable as a small integer.

Convert a big integer to a small integer (type int). Return None if the big integer is not representable as a small integer.

• since 2.7.0

Convert a 32-bit integer to a big integer.

Convert a native integer to a big integer.

Convert a 64-bit integer to a big integer.

Convert a big integer to a 32-bit integer.

• raises Failure

  if the big integer is outside the range [-2{^31}, 2{^31}-1].

Convert a big integer to a 32-bit integer. Return None if the big integer is outside the range [-2³¹, 2³¹-1].

• since 2.7.0

Convert a big integer to a native integer.

• raises Failure

  if the big integer is outside the range [Nativeint.min_int, Nativeint.max_int].

Convert a big integer to a native integer. Return None if the big integer is outside the range [Nativeint.min_int, Nativeint.max_int];

• since 2.7.0

Convert a big integer to a 64-bit integer.

• raises Failure

  if the big integer is outside the range [-2{^63}, 2{^63}-1].

Convert a big integer to a 64-bit integer. Return None if the big integer is outside the range [-2⁶³, 2⁶³-1].

• since 2.7.0

Returns a floating-point number approximating the given big integer.

rounds to the nearest integer

• raises Invalid_argument

  when given NaN or +/-infinity

Bitwise logical ``and''. The arguments must be positive or zero.

Bitwise logical ``or''. The arguments must be positive or zero.

Bitwise logical ``exclusive or''. The arguments must be positive or zero.

shift_left_big_int b n returns b shifted left by n bits. Equivalent to multiplication by 2^n.

shift_right_big_int b n returns b shifted right by n bits. Equivalent to division by 2^n with the result being rounded towards minus infinity.

shift_right_towards_zero_big_int b n returns b shifted right by n bits. The shift is performed on the absolute value of b, and the result has the same sign as b. Equivalent to division by 2^n with the result being rounded towards zero.

extract_big_int bi ofs n returns a nonnegative number corresponding to bits ofs to ofs + n - 1 of the binary representation of bi. If bi is negative, a two's complement representation is used.