# Module Std_kernel.Int_intf

    module Int_intf: Int_intf

    module type Round = sig .. end

    module type Hexable = sig .. end

    module type S = sig .. end

`round` rounds an int to a multiple of a given `to_multiple_of` argument, according to a direction `dir`, with default `dir` being ``Nearest`. `round` will raise if `to_multiple_of <= 0`.

           | `Down    | rounds toward Int.neg_infinity                          |
           | `Up      | rounds toward Int.infinity                              |
           | `Nearest | rounds to the nearest multiple, or `Up in case of a tie |
           | `Zero    | rounds toward zero                                      |

Here are some examples for `round ~to_multiple_of:10` for each direction:

           | `Down    | {10 .. 19} --> 10 | { 0 ... 9} --> 0 | {-10 ... -1} --> -10 |
           | `Up      | { 1 .. 10} --> 10 | {-9 ... 0} --> 0 | {-19 .. -10} --> -10 |
           | `Zero    | {10 .. 19} --> 10 | {-9 ... 9} --> 0 | {-19 .. -10} --> -10 |
           | `Nearest | { 5 .. 14} --> 10 | {-5 ... 4} --> 0 | {-15 ... -6} --> -10 |

For convenience and performance, there are variants of `round` with `dir` hard-coded. If you are writing performance-critical code you should use these.
`delimiter` is underscore by default
The number of bits available in this integer type. Note that the integer representations are signed

Infix operators and constants
Negation
There are two pairs of integer division and remainder functions, `/%` and `%`, and `/` and `rem`. They both satisfy the same equation relating the quotient and the remainder:

            x = (x /% y) * y + (x % y);
            x = (x /  y) * y + (rem x y);

The functions return the same values if `x` and `y` are positive. They all raise if `y = 0`.

The functions differ if `x < 0` or `y < 0`.

If `y < 0`, then `%` and `/%` raise, whereas `/` and `rem` do not.

`x % y` always returns a value between 0 and `y - 1`, even when `x < 0`. On the other hand, `rem x y` returns a negative value if and only if `x < 0`; that value satisfies `abs (rem x y) <= abs y - 1`.
float division of integers
A sub-module designed to be opened to make working with ints more convenient.

Successor and predecessor functions
Returns the absolute value of the argument. May be negative if the input is `min_value`
`pow base exponent` returns `base` raised to the power of `exponent`. It is OK if `base <= 0`. `pow` raises if `exponent < 0`, or an integer overflow would occur.
The largest representable integer
The smallest representable integer
Bit-wise logical operations
Bit-shifting operations

The results are unspecified for negative shifts and shifts `>= num_bits`
shifts left, filling in with zeroes
shifts right, preserving the sign of the input.
shifts right, filling in with zeroes, which will not preserve the sign of the input

Increment and decrement functions for integer references
Conversion functions to related integer types
this functor's type-correctness ensures that every value in `S.O` is also in `S`.