# Module `Stdlib.Int`

Integer values.

Integers are `Sys.int_size` bits wide and use two's complement representation. All operations are taken modulo 2`Sys.int_size`. They do not fail on overflow.

• since 4.08

## Integers

`type t = int;`

The type for integer values.

`let zero: int;`

`zero` is the integer `0`.

`let one: int;`

`one` is the integer `1`.

`let minus_one: int;`

`minus_one` is the integer `-1`.

`let neg: int => int;`

`neg x` is `~-x`.

`let add: int => int => int;`

`add x y` is the addition `x + y`.

`let sub: int => int => int;`

`sub x y` is the subtraction `x - y`.

`let mul: int => int => int;`

`mul x y` is the multiplication `x * y`.

`let div: int => int => int;`

`div x y` is the division `x / y`. See `Stdlib.(/)` for details.

`let rem: int => int => int;`

`rem x y` is the remainder `x mod y`. See `Stdlib.(mod)` for details.

`let succ: int => int;`

`succ x` is `add x 1`.

`let pred: int => int;`

`pred x` is `sub x 1`.

`let abs: int => int;`

`abs x` is the absolute value of `x`. That is `x` if `x` is positive and `neg x` if `x` is negative. Warning. This may be negative if the argument is `min_int`.

`let max_int: int;`

`max_int` is the greatest representable integer, `2{^[Sys.int_size - 1]} - 1`.

`let min_int: int;`

`min_int` is the smallest representable integer, `-2{^[Sys.int_size - 1]}`.

`let logand: int => int => int;`

`logand x y` is the bitwise logical and of `x` and `y`.

`let logor: int => int => int;`

`logor x y` is the bitwise logical or of `x` and `y`.

`let logxor: int => int => int;`

`logxor x y` is the bitwise logical exclusive or of `x` and `y`.

`let lognot: int => int;`

`lognot x` is the bitwise logical negation of `x`.

`let shift_left: int => int => int;`

`shift_left x n` shifts `x` to the left by `n` bits. The result is unspecified if `n < 0` or `n > ``Sys.int_size`.

`let shift_right: int => int => int;`

`shift_right x n` shifts `x` to the right by `n` bits. This is an arithmetic shift: the sign bit of `x` is replicated and inserted in the vacated bits. The result is unspecified if `n < 0` or `n > ``Sys.int_size`.

`let shift_right_logical: int => int => int;`

`shift_right x n` shifts `x` to the right by `n` bits. This is a logical shift: zeroes are inserted in the vacated bits regardless of the sign of `x`. The result is unspecified if `n < 0` or `n > ``Sys.int_size`.

## Predicates and comparisons

`let equal: int => int => bool;`

`equal x y` is `true` if and only if `x = y`.

`let compare: int => int => int;`

`compare x y` is `Stdlib.compare`` x y` but more efficient.

`let min: int => int => int;`

Return the smaller of the two arguments.

• since 4.13
`let max: int => int => int;`

Return the greater of the two arguments.

• since 4.13

## Converting

`let to_float: int => float;`

`to_float x` is `x` as a floating point number.

`let of_float: float => int;`

`of_float x` truncates `x` to an integer. The result is unspecified if the argument is `nan` or falls outside the range of representable integers.

`let to_string: int => string;`

`to_string x` is the written representation of `x` in decimal.

`let seeded_hash: int => int => int;`

A seeded hash function for ints, with the same output value as `Hashtbl.seeded_hash`. This function allows this module to be passed as argument to the functor `Hashtbl.MakeSeeded`.

• since 5.1
`let hash: int => int;`

An unseeded hash function for ints, with the same output value as `Hashtbl.hash`. This function allows this module to be passed as argument to the functor `Hashtbl.Make`.

• since 5.1