Nativeint(3) OCaml library Nativeint(3)

# [NAME](#NAME)

Nativeint - Processor-native integers.

# [Module](#Module)

Module Nativeint

# [Documentation](#Documentation)

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.

Literals for native integers are suffixed by n:

```


     let zero: nativeint = 0n


     let one: nativeint = 1n


     let m_one: nativeint = -1n


    
```

*val zero* : **nativeint**

The native integer 0.

*val one* : **nativeint**

The native integer 1.

*val minus\_one* : **nativeint**

The native integer -1.

*val neg* : **nativeint -> nativeint**

Unary negation.

*val add* : **nativeint -> nativeint -> nativeint**

Addition.

*val sub* : **nativeint -> nativeint -> nativeint**

Subtraction.

*val mul* : **nativeint -> nativeint -> nativeint**

Multiplication.

*val div* : **nativeint -> nativeint -> nativeint**

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

**Raises Division\_by\_zero** if the second argument is zero.

*val unsigned\_div* : **nativeint -> nativeint -> nativeint**

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

**Since** 4.08

*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 **Nativeint.rem** , except that arguments and result are interpreted as unsigned native integers.

**Since** 4.08

*val fdiv* : **nativeint -> nativeint -> nativeint**

Floor division. **fdiv x y** is the real quotient **x / y** rounded down to an integer. We have **fdiv x y <= div x y <= cdiv x y** and **cdiv x y - fdiv x y <= 1** .

**Since** 5.5

**Raises Division\_by\_zero** if the second argument is 0.

*val cdiv* : **nativeint -> nativeint -> nativeint**

Ceil division. **cdiv x y** is the real quotient **x / y** rounded up to an integer. We have **fdiv x y <= div x y <= cdiv x y** and **cdiv x y - fdiv x y <= 1** .

**Since** 5.5

**Raises Division\_by\_zero** if the second argument is 0.

*val ediv* : **nativeint -> nativeint -> nativeint**

Euclidean division. **ediv x y** is the real quotient **x / y** rounded down to an integer if **y > 0** and rounded up to an integer if **y < 0** . The remainder **erem x y = x - ediv x y * y** is always non-negative. Moreover, **ediv x (-y)** = **- ediv x y** .

**Since** 5.5

**Raises Division\_by\_zero** if the second argument is 0.

*val erem* : **nativeint -> nativeint -> nativeint**

Euclidean remainder. If **y** is not zero, we have **x = ediv x y * y + erem x y** and **0 <= erem x y <= abs y - 1** . The result of **erem x y** is always non-negative, unlike the result of **rem x y** , which has the sign of **x** .

**Since** 5.5

**Raises Division\_by\_zero** if the second argument is 0.

*val succ* : **nativeint -> nativeint**

Successor. **Nativeint.succ x** is **Nativeint.add x Nativeint.one** .

*val pred* : **nativeint -> nativeint**

Predecessor. **Nativeint.pred x** is **Nativeint.sub x Nativeint.one** .

*val abs* : **nativeint -> nativeint**

**abs x** is the absolute value of **x** . On **min\_int** this is **min\_int** itself and thus remains negative.

*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 logand* : **nativeint -> nativeint -> nativeint**

Bitwise logical and.

*val logor* : **nativeint -> nativeint -> nativeint**

Bitwise logical or.

*val logxor* : **nativeint -> nativeint -> nativeint**

Bitwise logical exclusive or.

*val lognot* : **nativeint -> nativeint**

Bitwise logical negation.

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

**Since** 4.08

*val of\_float* : **float -> nativeint**

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.

*val to\_float* : **nativeint -> float**

Convert the given native integer to a floating-point number.

*val of\_int32* : **int32 -> nativeint**

Convert the given 32-bit integer (type **int32** ) to a native integer.

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

**Raises 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** .

*val of\_string\_opt* : **string -> nativeint option**

Same as **of\_string** , but return **None** instead of raising.

**Since** 4.05

*val to\_string* : **nativeint -> string**

Return the string representation of its argument, in decimal.

*type t* = **nativeint**

An alias for the type of native integers.

*val compare* : **t -> t -> int**

The comparison function for native integers, with the same specification as **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** .

*val unsigned\_compare* : **t -> t -> int**

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

**Since** 4.08

*val equal* : **t -> t -> bool**

The equal function for native ints.

**Since** 4.03

*val min* : **t -> t -> t**

Return the smaller of the two arguments.

**Since** 4.13

*val max* : **t -> t -> t**

Return the greater of the two arguments.

**Since** 4.13

*val popcount* : **t -> int**

Population count, also known as Hamming weight. **popcount n** is the number of 1 bits in the binary representation of **n** . Negative **n** are represented in two's complement.

**Since** 5.5

*val unsigned\_bitsize* : **t -> int**

**unsigned\_bitsize n** is the minimal number of bits needed to represent **n** as an unsigned binary number. It is the smallest integer **i** between 0 and **size** inclusive such that **0 <= n < 2{^i}** (unsigned).

**Since** 5.5

*val signed\_bitsize* : **t -> int**

**signed\_bitsize n** is the minimal number of bits needed to represent **n** as a signed, two's complement binary number. It is the smallest integer **i** between 1 and **size** inclusive such that **-2{^i-1} <= n < 2{^i-1}** (signed).

**Since** 5.5

*val leading\_zeros* : **t -> int**

**leading\_zeros n** is the number of leading (most significant) 0 bits in the binary representation of **n** . It is an integer between 0 and 64 inclusive. If **n** is negative, **leading\_zeros n = 0** since the most significant bit of **n** is 1. **leading\_zeros n = size** if and only if **n = zero** . Note that **leading\_zeros n + unsigned\_bitsize n = size** .

**Since** 5.5

*val leading\_sign\_bits* : **t -> int**

**leading\_sign\_bits n** is the number of leading (most significant) sign bits in the binary representation of **n** , excluding the sign bit itself. It is an integer between 0 and 63 inclusive. For positive **n** , it is the number of leading zero bits minus one. For negative **n** , it is the number of leading one bits minus one. Note that **leading\_sign\_bits n + signed\_bitsize n = size** .

**Since** 5.5

*val trailing\_zeros* : **t -> int**

**trailing\_zeros n** is the number of trailing (least significant) 0 bits in the binary representation of **n** . It is an integer between 0 and **size** inclusive. It is the largest integer **i <= size** such that **2{^i}** divides **n** evenly. For example, **trailing\_zeros n = 0** if and only if **n** is odd, and **trailing\_zeros n = size** if and only if **n = zero** .

**Since** 5.5

*val seeded\_hash* : **int -> t -> int**

A seeded hash function for native ints, with the same output value as **Hashtbl.seeded\_hash** . This function allows this module to be passed as argument to the functor **Hashtbl.MakeSeeded** .

**Since** 5.1

*val hash* : **t -> int**

An unseeded hash function for native ints, with the same output value as **Hashtbl.hash** . This function allows this module to be passed as argument to the functor **Hashtbl.Make** .

**Since** 5.1

2026-09-04 OCamldoc

---

Document: Nativeint(3o) from ocaml 5.5.1-r0 (Chainguard OS)
Source: https://github.com/ocaml/ocaml