BatBig_int

# Module BatBig_int

    module BatBig_int: sig .. end

Operations on arbitrary-precision integers.

Big integers (type `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 extends Stdlib's Big_int module, go there for documentation on the rest of the functions and types.
Author(s): Valerie Menissier-Morain (base module), Gabriel Scherer, David Teller

    type t = Big_int.big_int

    val zero : Big_int.big_int

    val one : Big_int.big_int

    val neg : Big_int.big_int -> Big_int.big_int

    val succ : Big_int.big_int -> Big_int.big_int

    val pred : Big_int.big_int -> Big_int.big_int

    val abs : Big_int.big_int -> Big_int.big_int

    val add : Big_int.big_int -> Big_int.big_int -> Big_int.big_int

    val sub : Big_int.big_int -> Big_int.big_int -> Big_int.big_int

    val mul : Big_int.big_int -> Big_int.big_int -> Big_int.big_int

    val div : Big_int.big_int -> Big_int.big_int -> Big_int.big_int

    val modulo : Big_int.big_int -> Big_int.big_int -> Big_int.big_int

    val pow : Big_int.big_int -> Big_int.big_int -> Big_int.big_int

    val to_string : Big_int.big_int -> string

    val of_string : string -> Big_int.big_int

    val to_int : Big_int.big_int -> int

    val of_int : int -> Big_int.big_int

    val of_float : float -> Big_int.big_int

    val to_float : Big_int.big_int -> float

    val compare : Big_int.big_int -> Big_int.big_int -> int

    val (--) : Big_int.big_int -> Big_int.big_int -> Big_int.big_int BatEnum.t

    val (---) : Big_int.big_int -> Big_int.big_int -> Big_int.big_int BatEnum.t

    val (+) : t -> t -> t

    val (-) : t -> t -> t

    val ( * ) : t -> t -> t

    val (/) : t -> t -> t

    val ( ** ) : t -> t -> t

    val (<>) : t -> t -> bool

    val (>=) : t -> t -> bool

    val (<=) : t -> t -> bool

    val (>) : t -> t -> bool

    val (<) : t -> t -> bool

    val (=) : t -> t -> bool

    val operations : t BatNumber.numeric

###### Arithmetic operations

    val add_int_big_int : int -> Big_int.big_int -> Big_int.big_int

Addition of a small integer to a big integer.

    val square_big_int : Big_int.big_int -> Big_int.big_int

Return the square of the given big integer

    val sqrt_big_int : Big_int.big_int -> Big_int.big_int

`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.

    val quomod_big_int : Big_int.big_int -> Big_int.big_int -> Big_int.big_int * Big_int.big_int

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.

    val power_int_positive_int : int -> int -> Big_int.big_int

    val power_big_int_positive_int : Big_int.big_int -> int -> Big_int.big_int

    val power_int_positive_big_int : int -> Big_int.big_int -> Big_int.big_int

    val power_big_int_positive_big_int : Big_int.big_int -> Big_int.big_int -> 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 : 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.

    val compare_big_int : Big_int.big_int -> Big_int.big_int -> int

`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`.

    val eq_big_int : Big_int.big_int -> Big_int.big_int -> bool

    val le_big_int : Big_int.big_int -> Big_int.big_int -> bool

    val ge_big_int : Big_int.big_int -> Big_int.big_int -> bool

    val lt_big_int : Big_int.big_int -> Big_int.big_int -> bool

    val gt_big_int : Big_int.big_int -> Big_int.big_int -> bool

Usual boolean comparisons between two big integers.

    val max_big_int : Big_int.big_int -> Big_int.big_int -> Big_int.big_int

Return the greater of its two arguments.

    val min_big_int : Big_int.big_int -> Big_int.big_int -> Big_int.big_int

Return the smaller of its two arguments.

    val num_digits_big_int : Big_int.big_int -> int

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

###### Conversions to and from strings

    val string_of_big_int : Big_int.big_int -> string

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

    val big_int_of_string : string -> 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.

###### Conversions to and from other numerical types

    val big_int_of_int : int -> Big_int.big_int

Convert a small integer to a big integer.

    val is_int_big_int : 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 : 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 float_of_big_int : Big_int.big_int -> float

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

###### Submodules grouping all infix operators

    module Infix: BatNumber.Infix  with type bat__infix_t = t

    module Compare: BatNumber.Compare  with type bat__compare_t = t

###### Boilerplate code

Printing

    val print : 'a BatIO.output -> t -> unit