# Module Batteries.Number

    module Number: BatNumber

    exception Overflow

Arithmetic overflow.

This kind of exception is raised by "safe" numeric modules whenever the number which should be returned is too large to be represented.

Non-"safe" numeric modules will return a result which depends on the internal representation. For instance, with module `Int`, `max_num + 1` returns `min_num`. By opposition, with module `Safe_int`, `max_num + 1` raises `Overflow`.

    exception NaN

Not a Number

This kind of exception is raised by "safe" modules whenever the number which should be returned is not a number.

For instance, with module `Safe_float`, `0.0 / 0.0` raises `NaN`. By opposition, with module `Float`, `0.0 / 0.0` does not interrupt computation and returns a special value `nan`.

    type 'a numeric = {

`` | `zero : `'a`;`
`` | `one : `'a`;`
`` | `neg : `'a -> 'a`;`
`` | `succ : `'a -> 'a`;`
`` | `pred : `'a -> 'a`;`
`` | `abs : `'a -> 'a`;`
`` | `add : `'a -> 'a -> 'a`;`
`` | `sub : `'a -> 'a -> 'a`;`
`` | `mul : `'a -> 'a -> 'a`;`
`` | `div : `'a -> 'a -> 'a`;`
`` | `modulo : `'a -> 'a -> 'a`;`
`` | `pow : `'a -> 'a -> 'a`;`
`` | `compare : `'a -> 'a -> int`;`
`` | `of_int : `int -> 'a`;`
`` | `to_int : `'a -> int`;`
`` | `of_string : `string -> 'a`;`
`` | `to_string : `'a -> string`;`
`` | `of_float : `float -> 'a`;`
`` | `to_float : `'a -> float`;`

}
The smallest set of operations supported by every set of numbers.

This is presented as record to permit lightweight typeclass-style computation.

    module type Infix = sig .. end

The infix operators available with any type of numbers

    module type Compare = sig .. end

And if you are ready to drop generic comparison operators, then you can open this one as well

    module type RefOps = sig .. end

Reference operators ala C.

    module type Numeric = sig .. end

The full set of operations of a type of numbers

    module type Bounded = sig .. end

    module type Discrete = sig .. end