Module BatNum

`module BatNum: `sig` .. `end``

Operation on arbitrary-precision numbers.

Numbers (type `BatNum.num`) are arbitrary-precision rational numbers, plus the special elements `1/0` (infinity) and `0/0` (undefined).

• Author(s): Valerie Menissier-Morain (base module), Gabriel Scherer, David Teller

`type num = `Num.num` = `
 `|` `Int of int` `|` `Big_int of Big_int.big_int` `|` `Ratio of Ratio.ratio`

The type of numbers.

`type t = `num` `
`val zero : `num``
Usual operations
`val one : `num``
`val neg : `num -> num``
`val abs : `num -> num``
`val add : `num -> num -> num``
`val sub : `num -> num -> num``
`val mul : `num -> num -> num``
`val div : `num -> num -> num``
`val modulo : `num -> num -> num``
`val pow : `num -> num -> num``
`val compare : `num -> num -> int``
`val ord : `num -> num -> BatOrd.order``
`val equal : `num -> num -> bool``
`val of_int : `int -> num``
`val to_int : `num -> int``
`val of_float : `float -> num``
`val to_float : `num -> float``
`val of_string : `string -> num``
`val to_string : `num -> string``

Convert a number to a string, using fractional notation. Two formats are recognized: simple integer literals and a pair of integer literals separated by a '/', to indicate a rational number.

`val of_float_string : `string -> num``

Convert a simple floating point literal to a num. Plain integer literals are also accepted; numbers written with a trailing exponent are not currently accepted.

`val (+) : `num -> num -> num``
`val (-) : `num -> num -> num``
`val ( * ) : `num -> num -> num``
`val (/) : `num -> num -> num``
`val ( ** ) : `num -> num -> num``
`val max_num : `num -> num -> num``
`val min_num : `num -> num -> num``
`val quo : `num -> num -> num``

Euclidian divisiom

`val square : `num -> num``
`val succ : `num -> num``
• Raises `Invalid_argument` `"Num.succ"` for `Num.Ratio _` argument
`val pred : `num -> num``
• Raises `Invalid_argument` `"Num.pred"` for `Num.Ratio _` argument
`val is_integer : `num -> bool``

`is_integer x` returns `true` if `x` represents an integer value, `false` otherwise

`val round : `num -> num``
`val floor : `num -> num``
`val ceil : `num -> num``
`val approx : `num -> num``

`approx n` return the integer closest to `n`

`val sign : `num -> int``

Return `-1`, `0` or `1` according to the sign of the argument.

`val operations : `num BatNumber.numeric``
Comparisons between numbers
`val (=/) : `num -> num -> bool``
`val (</) : `num -> num -> bool``
`val (>/) : `num -> num -> bool``
`val (<=/) : `num -> num -> bool``
`val (>=/) : `num -> num -> bool``
`val (<>/) : `num -> num -> bool``
`val eq_num : `num -> num -> bool``
`val lt_num : `num -> num -> bool``
`val le_num : `num -> num -> bool``
`val gt_num : `num -> num -> bool``
`val ge_num : `num -> num -> bool``
Coercions with strings
`val approx_num_fix : `int -> num -> string``

See `Num.approx_num_exp`.

`val approx_num_exp : `int -> num -> string``

Approximate a number by a decimal. The first argument is the required precision. The second argument is the number to approximate. `Num.approx_num_fix` uses decimal notation; the first argument is the number of digits after the decimal point. `approx_num_exp` uses scientific (exponential) notation; the first argument is the number of digits in the mantissa.

`val nat_of_num : `num -> Nat.nat``
Coercions between numerical types
`val num_of_nat : `Nat.nat -> num``
`val num_of_big_int : `Big_int.big_int -> num``
`val big_int_of_num : `num -> Big_int.big_int``
`val ratio_of_num : `num -> Ratio.ratio``
`val num_of_ratio : `Ratio.ratio -> num``
`val float_of_num : `num -> float``
Boilerplate code
`val print : `'a BatInnerIO.output -> t -> unit``
Printing
Submodules grouping all infix operators
`module TaggedInfix: `sig` .. `end``
`module Infix: `sig` .. `end``
`module Compare: `BatNumber.Compare``  with type bat__compare_t = t``
Deprecated
`val (+/) : `num -> num -> num``
`val add_num : `num -> num -> num``
`val minus_num : `num -> num``
`val (-/) : `num -> num -> num``
`val sub_num : `num -> num -> num``
`val ( */ ) : `num -> num -> num``
`val mult_num : `num -> num -> num``
`val square_num : `num -> num``
`val (//) : `num -> num -> num``
`val div_num : `num -> num -> num``
`val quo_num : `num -> num -> num``
`val mod_num : `num -> num -> num``
`val ( **/ ) : `num -> num -> num``
`val power_num : `num -> num -> num``
`val abs_num : `num -> num``
`val succ_num : `num -> num``
`val pred_num : `num -> num``
`val incr_num : `num Stdlib.ref -> unit``
`val decr_num : `num Stdlib.ref -> unit``
`val is_integer_num : `num -> bool``
`val integer_num : `num -> num``
`val floor_num : `num -> num``
`val round_num : `num -> num``
`val ceiling_num : `num -> num``
`val sign_num : `num -> int``
`val string_of_num : `num -> string``
`val num_of_string : `string -> num``
`val int_of_num : `num -> int``
`val num_of_int : `int -> num``
`val compare_num : `num -> num -> int``