include Floatable.S with type t := t
val of_float : float -> t
val to_float : t -> float
include Intable.S with type t := t
val of_int_exn : int -> t
val to_int_exn : t -> int
include Identifiable.S with type t := t
include Stringable.S with type t := t
val of_string : string -> t
val to_string : t -> string
include Comparable.S with type t := t
include Comparisons.S with type t := t
val equal : t -> t -> bool
val compare : t -> t -> int
compare t1 t2
returns 0 if t1
is equal to t2
, a negative integer if t1
is less than t2
, and a positive integer if t1
is greater than t2
.
val ascending : t -> t -> int
ascending
is identical to compare
. descending x y = ascending y x
. These are intended to be mnemonic when used like List.sort ~compare:ascending
and List.sort
~cmp:descending
, since they cause the list to be sorted in ascending or descending order, respectively.
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
between t ~low ~high
means low <= t <= high
val clamp_exn : t -> min:t -> max:t -> t
clamp_exn t ~min ~max
returns t'
, the closest value to t
such that between t' ~low:min ~high:max
is true.
Raises if not (min <= max)
.
include Comparable.With_zero with type t := t
val is_positive : t -> bool
val is_non_negative : t -> bool
val is_negative : t -> bool
val is_non_positive : t -> bool
Returns Neg
, Zero
, or Pos
in a way consistent with the above functions.
val to_string_hum : ?delimiter:char -> t -> string
delimiter
is an underscore by default.
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
.
val (//) : t -> t -> float
Float division of integers.
val (lsl) : t -> int -> t
val (asr) : t -> int -> t
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.
val round :
?dir:[ `Zero | `Nearest | `Up | `Down ] ->
t ->
to_multiple_of:t ->
t
val round_towards_zero : t -> to_multiple_of:t -> t
val round_down : t -> to_multiple_of:t -> t
val round_up : t -> to_multiple_of:t -> t
val round_nearest : t -> to_multiple_of:t -> t
Returns the absolute value of the argument. May be negative if the input is min_value
.
Successor and predecessor functions
Exponentiation
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.
Bit-wise logical operations
val bit_and : t -> t -> t
These are identical to land
, lor
, etc. except they're not infix and have different names.
val bit_xor : t -> t -> t
Returns the number of 1 bits in the binary representation of the input.
Bit-shifting operations
The results are unspecified for negative shifts and shifts >= num_bits
.
val shift_left : t -> int -> t
Shifts left, filling in with zeroes.
val shift_right : t -> int -> t
Shifts right, preserving the sign of the input.
Increment and decrement functions for integer references
val of_int32_exn : int32 -> t
val to_int32_exn : t -> int32
val of_int64_exn : int64 -> t
val to_int64 : t -> int64
val of_nativeint_exn : nativeint -> t
val to_nativeint_exn : t -> nativeint
val of_float_unchecked : float -> t
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.
A sub-module designed to be opened to make working with ints more convenient.