package base

  1. Overview
  2. Docs
Legend:
Library
Module
Module type
Parameter
Class
Class type
type t
include Sexplib0.Sexpable.S with type t := t
val t_sexp_grammar : t Sexplib0.Sexp_grammar.t
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
val hash_fold_t : Hash.state -> t -> Hash.state
val hash : t -> Hash.hash_value
include Sexplib0.Sexpable.S with type t := t
val t_of_sexp : Sexplib0.Sexp.t -> t
val sexp_of_t : t -> Sexplib0.Sexp.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
include Comparisons.Infix with type t := t
val (>=) : t -> t -> bool
val (<=) : t -> t -> bool
val (=) : t -> t -> bool
val (>) : t -> t -> bool
val (<) : t -> t -> bool
val (<>) : t -> t -> bool
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 min : t -> t -> t
val max : t -> t -> t
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).

val clamp : t -> min:t -> max:t -> t Or_error.t
include Comparator.S with type t := t
type comparator_witness
include Pretty_printer.S with type t := t
val pp : Formatter.t -> t -> unit
val hashable : t Hashable.t
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
val sign : t -> Sign.t

Returns Neg, Zero, or Pos in a way consistent with the above functions.

include Invariant.S with type t := t
val invariant : t -> unit
module Hex : sig ... end
val to_string_hum : ?delimiter:char -> t -> string

delimiter is an underscore by default.

Infix operators and constants

val zero : t
val one : t
val minus_one : t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (**) : t -> t -> t

Integer exponentiation

Negation

val neg : t -> t
val (~-) : t -> 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.

val (/%) : t -> t -> t
val (%) : t -> t -> t
val (/) : t -> t -> t
val rem : t -> t -> t
val (//) : t -> t -> float

Float division of integers.

val (land) : t -> t -> t

Same as bit_and.

val (lor) : t -> t -> t

Same as bit_or.

val (lxor) : t -> t -> t

Same as bit_xor.

val lnot : t -> t

Same as bit_not.

val (lsl) : t -> int -> t

Same as shift_left.

val (asr) : t -> int -> t

Same as shift_right.

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
val abs : t -> t

Returns the absolute value of the argument. May be negative if the input is min_value.

Successor and predecessor functions

val succ : t -> t
val pred : t -> t

Exponentiation

val pow : t -> t -> t

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_or : t -> t -> t
val bit_xor : t -> t -> t
val bit_not : t -> t
val popcount : t -> int

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 decr : t Caml.ref -> unit
val incr : t Caml.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.