# Module `Stdlib.Nativeint`

`val div : nativeint -> nativeint -> nativeint`

Integer division. Raise

`Division_by_zero`

if the second argument is zero. This division rounds the real quotient of its arguments towards zero, as specified for`Stdlib.(/)`

.

`val unsigned_div : nativeint -> nativeint -> nativeint`

Same as

`div`

, except that arguments and result are interpreted as*unsigned*native integers.- since
- 4.08.0

`val 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`

.

`val unsigned_rem : nativeint -> nativeint -> nativeint`

Same as

`rem`

, except that arguments and result are interpreted as*unsigned*native integers.- since
- 4.08.0

`val 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.

`val max_int : nativeint`

The greatest representable native integer, either 2

^{31}- 1 on a 32-bit platform, or 2^{63}- 1 on a 64-bit platform.

`val min_int : nativeint`

The smallest representable native integer, either -2

^{31}on a 32-bit platform, or -2^{63}on a 64-bit platform.

`val 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.

`val 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`

.

`val 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`

.

`val of_int : int -> nativeint`

Convert the given integer (type

`int`

) to a native integer (type`nativeint`

).

`val 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.

`val unsigned_to_int : nativeint -> int option`

Same as

`to_int`

, but interprets the argument as an*unsigned*integer. Returns`None`

if the unsigned value of the argument cannot fit into an`int`

.- since
- 4.08.0

`val 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`

].

`val 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 2^{32}, i.e. the top 32 bits are lost. On 32-bit platforms, the conversion is exact.

`val 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`

.Raise

`Failure "Nativeint.of_string"`

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`

.

`val of_string_opt : string -> nativeint option`

Same as

`of_string`

, but return`None`

instead of raising.- since
- 4.05

`val compare : t -> t -> int`

The comparison function for native integers, with the same specification as

`Stdlib.compare`

. Along with the type`t`

, this function`compare`

allows the module`Nativeint`

to be passed as argument to the functors`Set.Make`

and`Map.Make`

.