module BatBig_int:sig..end
Big integers (type BatBig_int.big_int or equivalently Big_int.t) are
signed integers of arbitrary size. This module lets you compute
with huge numbers, whose size is limited only by the amount of
memory given to OCaml. The downside is speed, as big integers
are much slower than any other type of integer known to OCaml.
This module replaces Stdlib's
Big_int
module.
Author(s): Valerie Menissier-Morain (base module), Gabriel Scherer, David Teller
typebig_int =Big_int.big_int
val zero : big_intval zero_big_int : big_int0.val one : big_intval unit_big_int : big_int1.val neg : big_int -> big_intval succ : big_int -> big_intval pred : big_int -> big_intval abs : big_int -> big_intval add : big_int -> big_int -> big_intval sub : big_int -> big_int -> big_intval mul : big_int -> big_int -> big_intval div : big_int -> big_int -> big_intval modulo : big_int -> big_int -> big_intval pow : big_int -> big_int -> big_inttypet =big_int
val (+) : t -> t -> tval (-) : t -> t -> tval ( * ) : t -> t -> tval (/) : t -> t -> tval ( ** ) : t -> t -> tval minus_big_int : big_int -> big_intval abs_big_int : big_int -> big_intval add_big_int : big_int -> big_int -> big_intval succ_big_int : big_int -> big_intval add_int_big_int : int -> big_int -> big_intval sub_big_int : big_int -> big_int -> big_intval pred_big_int : big_int -> big_intval mult_big_int : big_int -> big_int -> big_intval mult_int_big_int : int -> big_int -> big_intval square_big_int : big_int -> big_intval sqrt_big_int : big_int -> big_intsqrt_big_int a returns the integer square root of a,
that is, the largest big integer r such that r * r <= a.Invalid_argument if a is negative.val quomod_big_int : big_int ->
big_int -> big_int * big_int(q,r) = quomod_big_int a b, we have
a = q * b + r and 0 <= r < |b|.Division_by_zero if the divisor is zero.val div_big_int : big_int -> big_int -> big_intq of quomod_big_int (see above).val mod_big_int : big_int -> big_int -> big_intr of quomod_big_int (see above).val gcd_big_int : big_int -> big_int -> big_intval power_int_positive_int : int -> int -> big_intval power_big_int_positive_int : big_int -> int -> big_intval power_int_positive_big_int : int -> big_int -> big_intval power_big_int_positive_big_int : big_int -> big_int -> big_inta raised to the power b
(the second argument). Depending
on the function, a and b can be either small integers
or big integers.Invalid_argument if b is negative.val operations : t BatNumber.numericval (--) : big_int -> big_int -> big_int BatEnum.tval (---) : big_int -> big_int -> big_int BatEnum.tval compare : big_int -> big_int -> intval ord : big_int -> big_int -> BatOrd.orderval equal : big_int -> big_int -> boolval sign_big_int : big_int -> int0 if the given big integer is zero,
1 if it is positive, and -1 if it is negative.val compare_big_int : big_int -> big_int -> intcompare_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.val eq_big_int : big_int -> big_int -> boolval le_big_int : big_int -> big_int -> boolval ge_big_int : big_int -> big_int -> boolval lt_big_int : big_int -> big_int -> boolval gt_big_int : big_int -> big_int -> boolval max_big_int : big_int -> big_int -> big_intval min_big_int : big_int -> big_int -> big_intval num_digits_big_int : big_int -> intval to_string : big_int -> stringval string_of_big_int : big_int -> stringval of_string : string -> big_intval big_int_of_string : string -> big_int- or + sign,
followed by one or several decimal digits.val to_string_in_binary : big_int -> stringstring_of_big_int, but in base 2val to_string_in_octal : big_int -> stringstring_of_big_int, but in base 8val to_string_in_hexa : big_int -> stringstring_of_big_int, but in base 16val to_string_in_base : int -> big_int -> stringto_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.Invalid_argument if b is not in
2 .. 36.val to_string_in_custom_base : string -> int -> big_int -> stringsymbols, 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.Invalid_argument if b is incorrect.val big_int_base_default_symbols : stringto_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.val of_int : int -> big_intval big_int_of_int : int -> big_intval is_int_big_int : big_int -> boolint)
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 to_int : big_int -> intval int_of_big_int : big_int -> intint).Failure if the big integer
is not representable as a small integer.val big_int_of_int32 : int32 -> big_intval big_int_of_nativeint : nativeint -> big_intval big_int_of_int64 : int64 -> big_intval int32_of_big_int : big_int -> int32Failure if the big integer is outside the
range [-2{^31}, 2{^31}-1].val nativeint_of_big_int : big_int -> nativeintFailure if the big integer is outside the
range [Nativeint.min_int, Nativeint.max_int].val int64_of_big_int : big_int -> int64Failure if the big integer is outside the
range [-2{^63}, 2{^63}-1].val float_of_big_int : big_int -> floatval of_float : float -> big_intInvalid_argument when given NaN or +/-infinityval to_float : big_int -> floatval and_big_int : big_int -> big_int -> big_intval or_big_int : big_int -> big_int -> big_intval xor_big_int : big_int -> big_int -> big_intval shift_left_big_int : big_int -> int -> big_intshift_left_big_int b n returns b shifted left by n bits.
Equivalent to multiplication by 2^n.val shift_right_big_int : big_int -> int -> big_intshift_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 : big_int -> int -> big_intshift_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.val extract_big_int : big_int -> int -> int -> big_intextract_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.module Infix:BatNumber.Infixwith type bat__infix_t = t
module Compare:BatNumber.Comparewith type bat__compare_t = t
val print : 'a BatIO.output -> t -> unit