module Int: sig .. end
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.
type t = int;
The type for integer values.
let zero: int;
zero
is the integer 0
.
let one: int;
one
is the integer 1
.
let minus_one: int;
minus_one
is the integer -1
.
let neg: int => int;
neg x
is ~-x
.
let add: (int, int) => int;
add x y
is the addition x + y
.
let sub: (int, int) => int;
sub x y
is the subtraction x - y
.
let mul: (int, int) => int;
mul x y
is the multiplication x * y
.
let div: (int, int) => int;
div x y
is the division x / y
. See (/)
for details.
let rem: (int, int) => int;
rem x y
is the remainder x mod y
. See (mod)
for details.
let succ: int => int;
succ x
is add x 1
.
let pred: int => int;
pred x
is sub x 1
.
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 Int.min_int
.
let max_int: int;
max_int
is the greatest representable integer,
2{^[Sys.int_size - 1]} - 1
.
let min_int: int;
min_int
is the smallest representable integer,
-2{^[Sys.int_size - 1]}
.
let logand: (int, int) => int;
logand x y
is the bitwise logical and of x
and y
.
let logor: (int, int) => int;
logor x y
is the bitwise logical or of x
and y
.
let logxor: (int, int) => int;
logxor x y
is the bitwise logical exclusive or of x
and y
.
let lognot: int => int;
lognot x
is the bitwise logical negation of x
.
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
.
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
.
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
.
let equal: (int, int) => bool;
equal x y
is true
if and only if x = y
.
let compare: (int, int) => int;
compare x y
is compare
x y
but more efficient.
let to_float: int => float;
to_float x
is x
as a floating point number.
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.
let to_string: int => string;
to_string x
is the written representation of x
in decimal.