Safe_int (batteries.BatInt.Safe

type t = int

An alias for the type of integers.

val zero : t

The integer 0.

val one : t

The integer 1.

val minus_one : t

The integer -1.

val neg : t -> t

Unary negation.

val add : t -> t -> t

Addition.

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

Addition.

val sub : t -> t -> t

Subtraction.

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

Subtraction.

val mul : t -> t -> t

Multiplication.

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

Multiplication.

val div : t -> t -> t

Integer division. This division rounds the real quotient of its arguments towards zero, as specified for Pervasives.(/).

raises Division_by_zero
if the second argument is zero.

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

Integer division. This division rounds the real quotient of its arguments towards zero, as specified for Pervasives.(/).

raises Division_by_zero
if the second argument is zero.

val rem : t -> t -> t

Integer remainder. If y is not zero, the result of Int.rem x y satisfies the following property: x = Int.add (Int.mul (Int.div x y) y) (Int.rem x y).

raises Division_by_zero
if the second argument is zero.

val modulo : t -> t -> t

modulo a b computes the remainder of the integer division of a by b. This is defined only if b <> 0.

The result of modulo a b is a number m between 0 and abs ( b - 1 ) if a >= 0 or between ~- ( abs ( b - 1 ) ) if a < 0 and such that a * k + (abs b) = m, for some k.

val pow : t -> t -> t

pow a b computes a^b.

raises Invalid_argument
when b is negative.

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

a ** b computes a^b

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

Comparison: a <> b is true if and only if a and b have different values.

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

Comparison: a > b is true if and only if a is strictly greater than b.

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

Comparison: a < b is true if and only if a is strictly smaller than b.

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

Comparison: a >= b is true if and only if a is greater or equal to b.

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

Comparison: a <= b is true if and only if a is smaller or equalto b.

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

Comparison: a = b if and only if a and b have the same value.

val max_num : t

The greatest representable integer, which is either 2³⁰-1 or 2⁶²-1.

val min_num : t

The smallest representable integer, -2³⁰ or 2⁶².

val succ : t -> t

Successor. succ x is add x one.

val pred : t -> t

Predecessor. pred x is sub x one.

val abs : t -> t

Return the absolute value of its argument.

val of_float : float -> t

Convert the given floating-point number to integer, discarding the fractional part (truncate towards 0). The result of the conversion is undefined if, after truncation, the number is outside the range [Int.min_int, Int.max_int].

val to_float : t -> float

Convert the given integer to a floating-point number.

val of_string : string -> t

Convert the given string to an integer The string is read in decimal (by default) or in hexadecimal, octal or binary if the string begins with 0x, 0o or 0b respectively.

raises Failure
if the given string is not a valid representation of an integer, or if the integer represented exceeds the range of integers representable in type int.

val to_string : t -> string

Return the string representation of its argument, in signed decimal.

val operations : t BatNumber.numeric

val of_int : int -> t

val to_int : t -> int

Submodules regrouping all infix operations on safe integers

module Infix : BatNumber.Infix with type bat__infix_t = t

module Compare : BatNumber.Compare with type bat__compare_t = t

Boilerplate code

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

val compare : t -> t -> int

The comparison function for integers, with the same specification as Pervasives.compare. Along with the type t, this function compare allows the module Int to be passed as argument to the functors Set.Make and Map.Make.

val equal : t -> t -> bool

Equality function for integers, useful for HashedType.

val ord : t -> t -> BatOrd.order