Legend:
Library
Module
Module type
Parameter
Class
Class type
An int of exactly 32 bits, regardless of the machine.
Side note: There's not much reason to want an int of at least 32 bits (i.e. 32 on 32-bit machines and 63 on 64-bit machines) because Int63 is basically just as efficient.
Overflow issues are _not_ generally considered and explicitly handled. This may be more of an issue for 32-bit ints than 64-bit ints.
Int32.t is boxed on both 32-bit and 64-bit machines.
ascending is identical to compare. descending x y = ascending y x. These are intended to be mnemonic when used like List.sort ~cmp:ascending and List.sort
~cmp:descending, since they cause the list to be sorted in ascending or descending order, respectively.
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.
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:
of_float_unchecked truncates the given floating point number to an integer, rounding towards zero. The result is unspecified if the argument is nan or falls outside the range of representable integers.
val num_bits : int
The number of bits available in this integer type. Note that the integer representations are signed
Round a regular 64-bit OCaml float to a 32-bit IEEE-754 'single' float, and return its bit representation. We make no promises about the exact rounding behavior, or what happens in case of over- or underflow.