# Module Int

    module Int: sig .. end

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.

    val zero : int

`zero` is the integer `0`.

    val one : int

`one` is the integer `1`.

    val minus_one : int

`minus_one` is the integer `-1`.

    val neg : int -> int

`neg x` is `~-x`.

    val add : int -> int -> int

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

    val sub : int -> int -> int

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

    val mul : int -> int -> int

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

    val div : int -> int -> int

Rounding division. `div x y` is the real quotient `x / y` rounded towards zero to an integer. See `(/)` for details.

- Raises `Division_by_zero` if the second argument is 0.

    val rem : int -> int -> int

`rem x y` is the remainder of the rounding division `div x y`. We have `rem x y = x - div x y * y`. See `(mod)` for details.

- Raises `Division_by_zero` if the second argument is 0.

    val fdiv : int -> int -> int

Floor division. `fdiv x y` is the real quotient `x / y` rounded down to an integer. We have `fdiv x y <= div x y <= cdiv x y` and `cdiv x y - fdiv x y <= 1`.

- Since 5.5
- Raises `Division_by_zero` if the second argument is 0.

    val cdiv : int -> int -> int

Ceil division. `cdiv x y` is the real quotient `x / y` rounded up to an integer. We have `fdiv x y <= div x y <= cdiv x y` and `cdiv x y - fdiv x y <= 1`.

- Since 5.5
- Raises `Division_by_zero` if the second argument is 0.

    val ediv : int -> int -> int

Euclidean division. `ediv x y` is the real quotient `x / y` rounded down to an integer if `y > 0` and rounded up to an integer if `y < 0`. The remainder `erem x y = x - ediv x y * y` is always non-negative. Moreover, `ediv x (-y)` = `- ediv x y`.

- Since 5.5
- Raises `Division_by_zero` if the second argument is 0.

    val erem : int -> int -> int

Euclidean remainder. If `y` is not zero, we have `x = ediv x y * y + erem x y` and `0 <= erem x y <= abs y - 1`. The result of `erem x y` is always non-negative, unlike the result of `rem x y`, which has the sign of `x`.

- Since 5.5
- Raises `Division_by_zero` if the second argument is 0.

    val succ : int -> int

`succ x` is `add x 1`.

    val pred : int -> int

`pred x` is `sub x 1`.

    val 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 `Int.min_int`.

    val max_int : int

`max_int` is the greatest representable integer, `2``Sys.int_size - 1``-1`.

    val min_int : int

`min_int` is the smallest representable integer, `-2``Sys.int_size - 1`.

    val logand : int -> int -> int

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

    val logor : int -> int -> int

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

    val logxor : int -> int -> int

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

    val lognot : int -> int

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

    val 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`.

    val 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`.

    val shift_right_logical : int -> int -> int

`shift_right_logical 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

    val equal : int -> int -> bool

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

    val compare : int -> int -> int

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

    val min : int -> int -> int

Return the smaller of the two arguments.

- Since 4.13

    val max : int -> int -> int

Return the greater of the two arguments.

- Since 4.13

## Bit counting

    val popcount : t -> int

Population count, also known as Hamming weight. `popcount n` is the number of 1 bits in the binary representation of `n`. Negative `n` are represented in two's complement.

- Since 5.5

    val unsigned_bitsize : t -> int

`unsigned_bitsize n` is the minimal number of bits needed to represent `n` as an unsigned binary number. It is the smallest integer `i` between 0 and `Sys.int_size` inclusive such that `0 <= n < 2{^i}` (unsigned).

- Since 5.5

    val signed_bitsize : t -> int

`signed_bitsize n` is the minimal number of bits needed to represent `n` as a signed, two's complement binary number. It is the smallest integer `i` between 1 and `Sys.int_size` inclusive such that `-2{^i-1} <= n < 2{^i-1}` (signed).

- Since 5.5

    val leading_zeros : t -> int

`leading_zeros n` is the number of leading (most significant) 0 bits in the binary representation of `n`. It is an integer between 0 and `Sys.int_size` inclusive. If `n` is negative, `leading_zeros n = 0` since the most significant bit of `n` is 1. `leading_zeros n = {!Sys.int_size}` if and only if `n = zero`. Note that `leading_zeros n + unsigned_bitsize n = {!Sys.int_size}`.

- Since 5.5

    val leading_sign_bits : t -> int

`leading_sign_bits n` is the number of leading (most significant) sign bits in the binary representation of `n`, excluding the sign bit itself. It is an integer between 0 and `{!Sys.int_size} - 1` inclusive. For positive `n`, it is the number of leading zero bits minus one. For negative `n`, it is the number of leading one bits minus one. Note that `leading_sign_bits n + signed_bitsize n = {!Sys.int_size}`.

- Since 5.5

    val trailing_zeros : t -> int

`trailing_zeros n` is the number of trailing (least significant) 0 bits in the binary representation of `n`. It is an integer between 0 and `Sys.int_size` inclusive. It is the largest integer `i <= {!Sys.int_size}` such that `2{^i}` divides `n` evenly. For example, `trailing_zeros n = 0` if and only if `n` is odd, and `trailing_zeros n = {!Sys.int_size}` if and only if `n = zero`.

- Since 5.5

## Converting

    val to_float : int -> float

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

    val 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.

    val to_string : int -> string

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

    val 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

    val 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