Up

Module Core_int63

63 or 64 bit integers.

The size of Int63 is always at least 63 bits. On a 64-bit platform it is just an int (63-bits), and on a 32-bit platform it is an int64.

Because Int63 has different sizes on 32-bit and 64-bit platforms, there are several pitfalls to be aware of:

  • Int63 will behave differently in the case of overflow.
  • marshalling Int63 will not work between 32-bit and 64-bit platforms. unmarshal will segfault.
  • bin_io will work, except that it will raise an overflow exception when you send too large of an int from a 32-bit to a 64-bit platform. This is counterintuitive because the 32-bit platform has the larger int size.

Signature

include Int_intf.S with type t = private int
type t = private int
val typerep_of_t : t Typerep_lib.Std.Typerep.t
val typename_of_t : t Typerep_lib.Std.Typename.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
include Interfaces.Floatable with type t := t
type t
val of_float : float -> t
val to_float : t -> float
include Interfaces.Intable with type t := t
type t
val of_int_exn : int -> t
val to_int_exn : t -> int
include Interfaces.Identifiable with type t := t
type t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
include Stringable.S with type t := t
type t
val of_string : string -> t
val to_string : t -> string
include Comparable.S_binable with type t := t
include Comparable_intf.S_common
include Comparable_intf.Polymorphic_compare
include 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
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 Or_error.t
include Comparator.S with type t := t
type t
type comparator_witness
include Comparable_intf.Validate with type t := t
type 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_intf.Map_and_set_binable with type t := t with type comparator_witness := comparator_witness
type t
include Comparator.S with type t := t
type t
type comparator_witness
include Hashable.S_binable with type t := t
type t
val hash : t -> int
module Table : Hashable.Hashtbl.S_binable with type key = t
module Hash_set : Hash_set.S_binable with type elt = t
module Hash_queue : Hash_queue.S with type Key.t = t
include Pretty_printer.S with type t := t
type t
val pp : Format.formatter -> t -> unit
include Comparable.With_zero with type t := t
type 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 -> Sign0.t

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

include Int_intf.Hexable with type t := t
type t
module Hex : sig .. end
include Quickcheckable.S_bounded with type t := t
include Quickcheck_intf.S
type 'a gen
type 'a obs
type 'a shr
type t
val gen : t gen
val obs : t obs
val shrinker : t shr
val gen_between : lower_bound:t Maybe_bound.t -> upper_bound:t Maybe_bound.t -> t gen

gen_between and obs_between produce generators and observers for values satisfying lower_bound and upper_bound. Both functions raise an exception if no values satisfy both lower_bound and upper_bound.

val obs_between : lower_bound:t Maybe_bound.t -> upper_bound:t Maybe_bound.t -> t obs
val to_string_hum : ?delimiter:char -> t -> string

delimiter is underscore by default

val num_bits : int

The number of bits available in this integer type. Note that the integer representations are signed

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

module O : sig .. end
A sub-module designed to be opened to make working with ints more convenient.
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 Int_intf.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.

val max_value : t

The largest representable integer

The smallest representable integer

val min_value : t

The smallest representable integer

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

shifts right, preserving the sign of the input.

val shift_right : t -> int -> t

shifts right, preserving the sign of the input.

shifts right, filling in with zeroes, which will not preserve the sign of the input

val shift_right_logical : t -> int -> t

shifts right, filling in with zeroes, which will not preserve the sign of the input

Increment and decrement functions for integer references
val decr : t Pervasives.ref -> unit
val incr : t Pervasives.ref -> unit
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
module Overflow_exn : sig .. end
Unlike the usual operations, these never overflow, preferring instead to raise.
val of_int : int -> t
val to_int : t -> int option
val random : ?state:Core_random.State.t -> t -> t

random ~state bound returns a random integer between 0 (inclusive) and bound (exclusive). bound must be greater than 0.

The default ~state is Random.State.default.