include sig ... end
val t_of_sexp : Base__.Sexplib.Sexp.t ‑> t
val sexp_of_t : t ‑> Base__.Sexplib.Sexp.t
val hash_fold_t : Base__.Ppx_hash_lib.Std.Hash.state ‑> t ‑> Base__.Ppx_hash_lib.Std.Hash.state
val hash : t ‑> Base__.Ppx_hash_lib.Std.Hash.hash_value
include Identifiable.S with type t := t
include sig ... end
val t_of_sexp : Base__.Sexplib.Sexp.t ‑> t
val sexp_of_t : t ‑> Base__.Sexplib.Sexp.t
val hash_fold_t : Base__.Ppx_hash_lib.Std.Hash.state ‑> t ‑> Base__.Ppx_hash_lib.Std.Hash.state
val hash : t ‑> Base__.Ppx_hash_lib.Std.Hash.hash_value
include Comparable.S with type t := t
include Comparable_intf.Polymorphic_compare
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.
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)
.
val clamp : t ‑> min:t ‑> max:t ‑> t Or_error.t
include Comparator.S with type t := t
val comparator : (t, comparator_witness) Comparator.comparator
include Comparable_intf.Validate with type t := t
val validate_lbound : min:t Maybe_bound.t ‑> t Validate.check
val validate_ubound : max:t Maybe_bound.t ‑> t Validate.check
val validate_bound : min:t Maybe_bound.t ‑> max:t Maybe_bound.t ‑> t Validate.check
include Comparable.With_zero with type t := t
val validate_positive : t Validate.check
val validate_non_negative : t Validate.check
val validate_negative : t Validate.check
val validate_non_positive : t Validate.check
val is_positive : t ‑> bool
val is_non_negative : t ‑> bool
val is_negative : t ‑> bool
val is_non_positive : t ‑> bool
val sign : t ‑> Base__.Sign0.t
Returns Neg
, Zero
, or Pos
in a way consistent with the above functions.
val zero : t
val one : t
val minus_one : t
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
.
include Round with type t := t
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.
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 results are unspecified for negative shifts and shifts >= num_bits
val decr : t Base__.Import.ref ‑> unit
val incr : t Base__.Import.ref ‑> unit
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.