Module Core.IntSource

This module extends Base.Int.

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.

Other common functions

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. If the result overflows (too far positive or too far negative), round returns an incorrect result.

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

Successor and predecessor functions

Exponentiation

Bit-wise logical operations

Bit-shifting operations

The results are unspecified for negative shifts and shifts >= num_bits.

Increment and decrement functions for integer references

Conversion functions to related integer types

Conversion functions

Truncating conversions

These functions return the least-significant bits of the input. In cases where optional conversions return Some x, truncating conversions return x.

Byte swap operations

Byte swap operations reverse the order of bytes in an integer. For example, Int32.bswap32 reorders the bottom 32 bits (or 4 bytes), turning 0x1122_3344 to 0x4433_2211. Byte swap functions exposed by Base use OCaml primitives to generate assembly instructions to perform the relevant byte swaps.

For a more extensive list of byteswap functions, see Int32 and Int64.

Note that int is already stable by itself, since as a primitive type it is an integral part of the sexp / bin_io protocol. Int.Stable exists only to introduce Int.Stable.Set and Int.Stable.Map, and provide interface uniformity with other stable types.