jon.recoil.org

Module Std.Big_int

include module type of struct include Big_int end
type big_int = Big_int.big_int

The type of big integers.

The big integer 0.

The big integer 1.

Arithmetic operations

Addition of a small integer to a big integer.

Predecessor (subtract 1).

Multiplication of two big integers.

Multiplication of a big integer by a small 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. Raise 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|. Raise Division_by_zero if the divisor is zero.

Euclidean quotient of two big integers. This is the first result q of quomod_big_int (see above).

Euclidean modulus of two big integers. This is the second result r of quomod_big_int (see above).

Greatest common divisor of two big integers.

val power_int_positive_int : int -> int -> Sexplib_num.Std.Big_int.big_int
val power_big_int_positive_int : Sexplib_num.Std.Big_int.big_int -> int -> Sexplib_num.Std.Big_int.big_int
val power_int_positive_big_int : int -> Sexplib_num.Std.Big_int.big_int -> Sexplib_num.Std.Big_int.big_int

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. Raise Invalid_argument if b is negative.

Comparisons and tests
val sign_big_int : Sexplib_num.Std.Big_int.big_int -> int

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.

val num_digits_big_int : Sexplib_num.Std.Big_int.big_int -> int

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

val num_bits_big_int : Sexplib_num.Std.Big_int.big_int -> int

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 4.03.0
Conversions to and from strings
val string_of_big_int : Sexplib_num.Std.Big_int.big_int -> string

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

val big_int_of_string : string -> Sexplib_num.Std.Big_int.big_int

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

val big_int_of_string_opt : string -> Sexplib_num.Std.Big_int.big_int option

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 4.05
Conversions to and from other numerical types
val big_int_of_int : int -> Sexplib_num.Std.Big_int.big_int

Convert a small integer to a big integer.

val is_int_big_int : Sexplib_num.Std.Big_int.big_int -> bool

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 230 and 230-1. On a 64-bit platform, is_int_big_int a returns true if and only if a is between -262 and 262-1.

val int_of_big_int : Sexplib_num.Std.Big_int.big_int -> int

Convert a big integer to a small integer (type int). Raises Failure "int_of_big_int" if the big integer is not representable as a small integer.

val int_of_big_int_opt : Sexplib_num.Std.Big_int.big_int -> int option

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

  • since 4.05
val big_int_of_int32 : int32 -> Sexplib_num.Std.Big_int.big_int

Convert a 32-bit integer to a big integer.

val big_int_of_nativeint : nativeint -> Sexplib_num.Std.Big_int.big_int

Convert a native integer to a big integer.

val big_int_of_int64 : int64 -> Sexplib_num.Std.Big_int.big_int

Convert a 64-bit integer to a big integer.

val int32_of_big_int : Sexplib_num.Std.Big_int.big_int -> int32

Convert a big integer to a 32-bit integer. Raises Failure if the big integer is outside the range [-231, 231-1].

val int32_of_big_int_opt : Sexplib_num.Std.Big_int.big_int -> int32 option

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

  • since 4.05
val nativeint_of_big_int : Sexplib_num.Std.Big_int.big_int -> nativeint

Convert a big integer to a native integer. Raises Failure if the big integer is outside the range [Nativeint.min_int, Nativeint.max_int].

val nativeint_of_big_int_opt : Sexplib_num.Std.Big_int.big_int -> nativeint option

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 4.05
val int64_of_big_int : Sexplib_num.Std.Big_int.big_int -> int64

Convert a big integer to a 64-bit integer. Raises Failure if the big integer is outside the range [-263, 263-1].

val int64_of_big_int_opt : Sexplib_num.Std.Big_int.big_int -> int64 option

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

  • since 4.05
val float_of_big_int : Sexplib_num.Std.Big_int.big_int -> float

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

Bit-oriented operations

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.

val shift_right_towards_zero_big_int : Sexplib_num.Std.Big_int.big_int -> int -> Sexplib_num.Std.Big_int.big_int

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.

val sexp_of_big_int : Big_int.big_int -> Sexplib.Sexp.t
val big_int_of_sexp : Sexplib.Sexp.t -> Big_int.big_int