`Stdlib.Nativeint`

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 2^{32} or 2^{64} 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
```

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

.

Same as `div`

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

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`

.

Same as `rem`

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

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.

The greatest representable native integer, either 2^{31} - 1 on a 32-bit platform, or 2^{63} - 1 on a 64-bit platform.

The smallest representable native integer, either -2^{31} on a 32-bit platform, or -2^{63} on a 64-bit platform.

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

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

.

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

.

Convert the given integer (type `int`

) to a native integer (type `nativeint`

).

Convert the given native integer (type `nativeint`

) to an integer (type `int`

). The high-order bit is lost during the conversion.

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`

.

Convert the given floating-point number to a native integer, discarding the fractional part (truncate towards 0). If the truncated floating-point number is outside the range [`Nativeint.min_int`

, `Nativeint.max_int`

], no exception is raised, and an unspecified, platform-dependent integer is returned.

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.

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`

.

Same as `of_string`

, but return `None`

instead of raising.

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`

.

Same as `compare`

, except that arguments are interpreted as *unsigned* native integers.