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

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

`Division_by_zero`

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

.```
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 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 2^{31} - 1 on a 32-bit platform,
or 2^{63} - 1 on a 64-bit platform.

```
let min_int: nativeint;
```

The greatest representable native integer,
either -2^{31} on a 32-bit platform,
or -2^{63} 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 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 ^{32},
i.e. the top 32 bits are lost. On 32-bit platforms,
the conversion is exact.

`int32`

). On 64-bit platforms,
the 64-bit native integer is taken modulo 2```
let of_string: string => nativeint;
```

Convert the given string to a native integer.
The string is read in decimal (by default) or in hexadecimal,
octal or binary if the string begins with

`0x`

, `0o`

or `0b`

respectively.
Raise `Failure "int_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`

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

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

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

.```
let format: (string, nativeint) => string;
```

`Nativeint.format fmt n`

return the string representation of the
native integer `n`

in the format specified by `fmt`

.
`fmt`

is a `Printf`

-style format consisting of exactly
one `%d`

, `%i`

, `%u`

, `%x`

, `%X`

or `%o`

conversion specification.
This function is deprecated; use `Printf.sprintf`

with a `%nx`

format
instead.