Module Stdlib.Int

Integer values.

Integers are Sys.int_size bits wide and use two's complement representation. All operations are taken modulo 2Sys.int_size. They do not fail on overflow.

since 4.08

Integers

type t = int

type t = int;

The type for integer values.

val zero : int

let zero: int;

zero is the integer 0.

val one : int

let one: int;

one is the integer 1.

val minus_one : int

let minus_one: int;

minus_one is the integer -1.

val neg : int -> int

let neg: int => int;

neg x is ~-x.

val add : int -> int -> int

let add: int => int => int;

add x y is the addition x + y.

val sub : int -> int -> int

let sub: int => int => int;

sub x y is the subtraction x - y.

val mul : int -> int -> int

let mul: int => int => int;

mul x y is the multiplication x * y(x, y).

val div : int -> int -> int

let div: int => int => int;

div x y is the division x / y. See Stdlib.(/) for details.

val rem : int -> int -> int

let rem: int => int => int;

rem x y is the remainder x mod y. See Stdlib.(mod) for details.

val succ : int -> int

let succ: int => int;

succ x is add x 1.

val pred : int -> int

let pred: int => int;

pred x is sub x 1.

val abs : int -> int

let abs: int => int;

abs x is the absolute value of x. That is x if x is positive and neg x if x is negative. Warning. This may be negative if the argument is min_int.

val max_int : int

let max_int: int;

max_int is the greatest representable integer, 2``Sys.int_size - 1``-1.

val min_int : int

let min_int: int;

min_int is the smallest representable integer, -2``Sys.int_size - 1.

val logand : int -> int -> int

let logand: int => int => int;

logand x y is the bitwise logical and of x and y.

val logor : int -> int -> int

let logor: int => int => int;

logor x y is the bitwise logical or of x and y.

val logxor : int -> int -> int

let logxor: int => int => int;

logxor x y is the bitwise logical exclusive or of x and y.

val lognot : int -> int

let lognot: int => int;

lognot x is the bitwise logical negation of x.

val shift_left : int -> int -> int

let shift_left: int => int => int;

shift_left x n shifts x to the left by n bits. The result is unspecified if n < 0 or n > Sys.int_size.

val shift_right : int -> int -> int

let shift_right: int => int => int;

shift_right x n shifts x to the right by n bits. This is an arithmetic shift: the sign bit of x is replicated and inserted in the vacated bits. The result is unspecified if n < 0 or n > Sys.int_size.

val shift_right_logical : int -> int -> int

let shift_right_logical: int => int => int;

shift_right x n shifts x to the right by n bits. This is a logical shift: zeroes are inserted in the vacated bits regardless of the sign of x. The result is unspecified if n < 0 or n > Sys.int_size.

Predicates and comparisons

val equal : int -> int -> bool

let equal: int => int => bool;

equal x y is true if and only if x = y.

val compare : int -> int -> int

let compare: int => int => int;

compare x y is Stdlib.compare x y but more efficient.

val min : int -> int -> int

let min: int => int => int;

Return the smaller of the two arguments.

since 4.13

val max : int -> int -> int

let max: int => int => int;

Return the greater of the two arguments.

since 4.13

Converting

val to_float : int -> float

let to_float: int => float;

to_float x is x as a floating point number.

val of_float : float -> int

let of_float: float => int;

of_float x truncates x to an integer. The result is unspecified if the argument is nan or falls outside the range of representable integers.

val to_string : int -> string

let to_string: int => string;

to_string x is the written representation of x in decimal.

val seeded_hash : int -> int -> int

let seeded_hash: int => int => int;

A seeded hash function for ints, with the same output value as Hashtbl.seeded_hash. This function allows this module to be passed as argument to the functor Hashtbl.MakeSeeded.

since 5.1

val hash : int -> int

let hash: int => int;

An unseeded hash function for ints, with the same output value as Hashtbl.hash. This function allows this module to be passed as argument to the functor Hashtbl.Make.

since 5.1