module Int32: sig .. end
32-bit integers.
This module provides operations on the type int32
of signed 32-bit integers. Unlike the built-in int
type,
the type int32
is guaranteed to be exactly 32-bit wide on all
platforms. All arithmetic operations over int32
are taken
modulo 232.
Performance notice: values of type int32
occupy more memory
space than values of type int
, and arithmetic operations on
int32
are generally slower than those on int
. Use int32
only when the application requires exact 32-bit arithmetic.
Literals for 32-bit integers are suffixed by l:
let zero: int32 = 0l let one: int32 = 1l let m_one: int32 = -1l
let zero: int32;
The 32-bit integer 0.
let one: int32;
The 32-bit integer 1.
let minus_one: int32;
The 32-bit integer -1.
let neg: int32 => int32;
Unary negation.
let add: (int32, int32) => int32;
Addition.
let sub: (int32, int32) => int32;
Subtraction.
let mul: (int32, int32) => int32;
Multiplication.
let div: (int32, int32) => int32;
Integer division. This division rounds the real quotient of
its arguments towards zero, as specified for (/)
.
Division_by_zero
if the second
argument is zero.let unsigned_div: (int32, int32) => int32;
Same as Int32.div
, except that arguments and result are interpreted as unsigned 32-bit integers.
let rem: (int32, int32) => int32;
Integer remainder. If y
is not zero, the result
of Int32.rem x y
satisfies the following property:
x = Int32.add (Int32.mul (Int32.div x y) y) (Int32.rem x y)
.
If y = 0
, Int32.rem x y
raises Division_by_zero
.
let unsigned_rem: (int32, int32) => int32;
Same as Int32.rem
, except that arguments and result are interpreted as unsigned 32-bit integers.
let succ: int32 => int32;
Successor. Int32.succ x
is Int32.add x Int32.one
.
let pred: int32 => int32;
Predecessor. Int32.pred x
is Int32.sub x Int32.one
.
let abs: int32 => int32;
Return the absolute value of its argument.
let max_int: int32;
The greatest representable 32-bit integer, 231 - 1.
let min_int: int32;
The smallest representable 32-bit integer, -231.
let logand: (int32, int32) => int32;
Bitwise logical and.
let logor: (int32, int32) => int32;
Bitwise logical or.
let logxor: (int32, int32) => int32;
Bitwise logical exclusive or.
let lognot: int32 => int32;
Bitwise logical negation.
let shift_left: (int32, int) => int32;
Int32.shift_left x y
shifts x
to the left by y
bits.
The result is unspecified if y < 0
or y >= 32
.
let shift_right: (int32, int) => int32;
Int32.shift_right x y
shifts x
to the right by y
bits.
This is an arithmetic shift: the sign bit of x
is replicated
and inserted in the vacated bits.
The result is unspecified if y < 0
or y >= 32
.
let shift_right_logical: (int32, int) => int32;
Int32.shift_right_logical x y
shifts x
to the right by y
bits.
This is a logical shift: zeroes are inserted in the vacated bits
regardless of the sign of x
.
The result is unspecified if y < 0
or y >= 32
.
let of_int: int => int32;
Convert the given integer (type int
) to a 32-bit integer
(type int32
). On 64-bit platforms, the argument is taken
modulo 232.
let to_int: int32 => int;
Convert the given 32-bit integer (type int32
) to an
integer (type int
). On 32-bit platforms, the 32-bit integer
is taken modulo 231, i.e. the high-order bit is lost
during the conversion. On 64-bit platforms, the conversion
is exact.
let unsigned_to_int: int32 => option(int);
Same as Int32.to_int
, but interprets the argument as an unsigned integer.
Returns None
if the unsigned value of the argument cannot fit into an
int
.
let of_float: float => int32;
Convert the given floating-point number to a 32-bit integer,
discarding the fractional part (truncate towards 0).
The result of the conversion is undefined if, after truncation,
the number is outside the range [Int32.min_int
, Int32.max_int
].
let to_float: int32 => float;
Convert the given 32-bit integer to a floating-point number.
let of_string: string => int32;
Convert the given string to a 32-bit integer.
The string is read in decimal (by default, or if the string
begins with 0u
) or in hexadecimal, octal or binary if the
string begins with 0x
, 0o
or 0b
respectively.
The 0u
prefix reads the input as an unsigned integer in the range
[0, 2*Int32.max_int+1]
. If the input exceeds Int32.max_int
it is converted to the signed integer
Int32.min_int + input - Int32.max_int - 1
.
The _
(underscore) character can appear anywhere in the string
and is ignored.
Failure
if the given string is not
a valid representation of an integer, or if the integer represented
exceeds the range of integers representable in type int32
.let of_string_opt: string => option(int32);
Same as of_string
, but return None
instead of raising.
let to_string: int32 => string;
Return the string representation of its argument, in signed decimal.
let bits_of_float: float => int32;
Return the internal representation of the given float according to the IEEE 754 floating-point 'single format' bit layout. Bit 31 of the result represents the sign of the float; bits 30 to 23 represent the (biased) exponent; bits 22 to 0 represent the mantissa.
let float_of_bits: int32 => float;
Return the floating-point number whose internal representation,
according to the IEEE 754 floating-point 'single format' bit layout,
is the given int32
.
type t = int32;
An alias for the type of 32-bit integers.
let compare: (t, t) => int;
let unsigned_compare: (t, t) => int;
Same as Int32.compare
, except that arguments are interpreted as unsigned
32-bit integers.
let equal: (t, t) => bool;
The equal function for int32s.