module Nativeint: sig .. end
Processor-native integers.
This module provides operations on the type nativeint
of
signed 32-bit integers (on 32-bit platforms) or
signed 64-bit integers (on 64-bit platforms).
This integer type has exactly the same width as that of a
pointer type in the C compiler. All arithmetic operations over
nativeint
are taken modulo 232 or 264 depending
on the word size of the architecture.
Performance notice: values of type nativeint
occupy more memory
space than values of type int
, and arithmetic operations on
nativeint
are generally slower than those on int
. Use nativeint
only when the application requires the extra bit of precision
over the int
type.
Literals for native integers are suffixed by n:
let zero: nativeint = 0n let one: nativeint = 1n let m_one: nativeint = -1n
let zero: nativeint;
The native integer 0.
let one: nativeint;
The native integer 1.
let minus_one: nativeint;
The native integer -1.
let neg: nativeint => nativeint;
Unary negation.
let add: (nativeint, nativeint) => nativeint;
Addition.
let sub: (nativeint, nativeint) => nativeint;
Subtraction.
let mul: (nativeint, nativeint) => nativeint;
Multiplication.
let div: (nativeint, nativeint) => nativeint;
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: (nativeint, nativeint) => nativeint;
Same as Nativeint.div
, except that arguments and result are interpreted as unsigned native integers.
let rem: (nativeint, nativeint) => nativeint;
Integer remainder. If y
is not zero, the result
of Nativeint.rem x y
satisfies the following properties:
Nativeint.zero <= Nativeint.rem x y < Nativeint.abs y
and
x = Nativeint.add (Nativeint.mul (Nativeint.div x y) y)
(Nativeint.rem x y)
.
If y = 0
, Nativeint.rem x y
raises Division_by_zero
.
let unsigned_rem: (nativeint, nativeint) => nativeint;
Same as Nativeint.rem
, except that arguments and result are interpreted as unsigned native integers.
let succ: nativeint => nativeint;
Successor.
Nativeint.succ x
is Nativeint.add x Nativeint.one
.
let pred: nativeint => nativeint;
Predecessor.
Nativeint.pred x
is Nativeint.sub x Nativeint.one
.
let abs: nativeint => nativeint;
Return the absolute value of its argument.
let size: int;
The size in bits of a native integer. This is equal to 32
on a 32-bit platform and to 64
on a 64-bit platform.
let max_int: nativeint;
The greatest representable native integer, either 231 - 1 on a 32-bit platform, or 263 - 1 on a 64-bit platform.
let min_int: nativeint;
The smallest representable native integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform.
let logand: (nativeint, nativeint) => nativeint;
Bitwise logical and.
let logor: (nativeint, nativeint) => nativeint;
Bitwise logical or.
let logxor: (nativeint, nativeint) => nativeint;
Bitwise logical exclusive or.
let lognot: nativeint => nativeint;
Bitwise logical negation.
let shift_left: (nativeint, int) => nativeint;
Nativeint.shift_left x y
shifts x
to the left by y
bits.
The result is unspecified if y < 0
or y >= bitsize
,
where bitsize
is 32
on a 32-bit platform and
64
on a 64-bit platform.
let shift_right: (nativeint, int) => nativeint;
Nativeint.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 >= bitsize
.
let shift_right_logical: (nativeint, int) => nativeint;
Nativeint.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 >= bitsize
.
let of_int: int => nativeint;
Convert the given integer (type int
) to a native integer
(type nativeint
).
let to_int: nativeint => int;
Convert the given native integer (type nativeint
) to an
integer (type int
). The high-order bit is lost during
the conversion.
let unsigned_to_int: nativeint => option(int);
Same as Nativeint.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 => nativeint;
Convert the given floating-point number to a native integer,
discarding the fractional part (truncate towards 0).
The result of the conversion is undefined if, after truncation,
the number is outside the range
[Nativeint.min_int
, Nativeint.max_int
].
let to_float: nativeint => float;
Convert the given native integer to a floating-point number.
let of_int32: int32 => nativeint;
Convert the given 32-bit integer (type int32
)
to a native integer.
let to_int32: nativeint => int32;
Convert the given native integer to a
32-bit integer (type int32
). On 64-bit platforms,
the 64-bit native integer is taken modulo 232,
i.e. the top 32 bits are lost. On 32-bit platforms,
the conversion is exact.
let of_string: string => nativeint;
Convert the given string to a native 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*Nativeint.max_int+1]
. If the input exceeds Nativeint.max_int
it is converted to the signed integer
Int64.min_int + input - Nativeint.max_int - 1
.
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 nativeint
.let of_string_opt: string => option(nativeint);
Same as of_string
, but return None
instead of raising.
let to_string: nativeint => string;
Return the string representation of its argument, in decimal.
type t = nativeint;
An alias for the type of native integers.
let compare: (t, t) => int;
let unsigned_compare: (t, t) => int;
Same as Nativeint.compare
, except that arguments are interpreted as unsigned
native integers.
let equal: (t, t) => bool;
The equal function for native ints.