Module type Base__.Int_intf.S_common

type t
include sig ... end
val t_of_sexp : Base__.Sexplib.Sexp.t ‑> t
val sexp_of_t : t ‑> Base__.Sexplib.Sexp.t
include Base.Floatable.S with type t := t
type t
val of_float : float ‑> t
val to_float : t ‑> float
include Base.Intable.S with type t := t
type t
val of_int_exn : int ‑> t
val to_int_exn : t ‑> int
include Base.Identifiable.S with type t := t
type t
include sig ... end
val t_of_sexp : Base__.Sexplib.Sexp.t ‑> t
val sexp_of_t : t ‑> Base__.Sexplib.Sexp.t
include Base.Stringable.S with type t := t
type t
val of_string : string ‑> t
val to_string : t ‑> string
include Base.Comparable.S with type t := t
include Base.Comparable_intf.Polymorphic_compare
include Base.Polymorphic_compare_intf.Infix
type 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

-1 means "less than", 0 means "equal", 1 means "greater than", and other values should not be returned

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 ~cmp: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
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 Base.Or_error.t
include Base.Comparator.S with type t := t
type t
type comparator_witness
include Base.Comparable_intf.Validate with type t := t
type t
val validate_lbound : min:t Base.Maybe_bound.t ‑> t Base.Validate.check
val validate_ubound : max:t Base.Maybe_bound.t ‑> t Base.Validate.check
val validate_bound : min:t Base.Maybe_bound.t ‑> max:t Base.Maybe_bound.t ‑> t Base.Validate.check
include Base.Pretty_printer.S with type t := t
type t
val pp : Caml.Format.formatter ‑> t ‑> unit
include Base.Comparable.With_zero with type t := t
type t
val validate_positive : t Base.Validate.check
val validate_non_negative : t Base.Validate.check
val validate_negative : t Base.Validate.check
val validate_non_positive : t Base.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.

include Hexable with type t := t
type t
module Hex : sig ... end
val to_string_hum : ?delimiter:char ‑> t ‑> string

delimiter is 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 neg : t ‑> t

Negation

val (~-) : t ‑> t
val (/%) : t ‑> 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 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

Successor and predecessor functions
val succ : t ‑> t
val pred : t ‑> t
val abs : t ‑> t

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

include Round with type t := t
type 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.

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 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
val bit_or : t ‑> t ‑> t
val bit_xor : t ‑> t ‑> t
val bit_not : t ‑> t
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 Base__.Import.ref ‑> unit
val incr : t Base__.Import.ref ‑> unit
Population count
val popcount : t ‑> int

returns the number of 1 bits in the binary representation of the input

Conversion functions to related integer types
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.