Batteries user guide : Batteries.Num

# Module Batteries.Num

    module Num: BatNum

    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

###### Additional operations

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 Pervasives.ref -> unit

    val decr_num : num Pervasives.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