---
name: "Int"
section: "3o"
platform: "linux"
package: "ocaml"
version: "5.5.0-1"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/Int"
---

# Int(3o)

Integer values.

## NAME

Int - Integer values.

## Module

Module   Int

## Documentation

Module **Int**\
  :  **sig end**

Integer values.

Integers are  **Sys.int\_size** bits wide and use two's complement representation. All operations are taken modulo 2^ **Sys.int\_size** . They do not fail on overflow.

**Since** 4.08

### Integers

*type t* =  **int**

The type for integer values.

*val zero* :  **int**

**zero** is the integer  **0** .

*val one* :  **int**

**one** is the integer  **1** .

*val minus\_one* :  **int**

**minus\_one** is the integer  **-1** .

*val neg* :  **int -\> int**

**neg x** is  **~-x** .

*val add* :  **int -\> int -\> int**

**add x y** is the addition  **x + y** .

*val sub* :  **int -\> int -\> int**

**sub x y** is the subtraction  **x - y** .

*val mul* :  **int -\> int -\> int**

**mul x y** is the multiplication  **x \* y** .

*val div* :  **int -\> int -\> int**

Rounding division. **div x y** is the real quotient  **x / y** rounded towards zero to an integer. See  **(/)** for details.

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

*val rem* :  **int -\> int -\> int**

**rem x y** is the remainder of the rounding division  **div x y** . We have  **rem x y = x - div x y \* y** . See  **(mod)** for details.

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

*val fdiv* :  **int -\> int -\> int**

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* :  **int -\> int -\> int**

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* :  **int -\> int -\> int**

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* :  **int -\> int -\> int**

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* :  **int -\> int**

**succ x** is  **add x 1** .

*val pred* :  **int -\> int**

**pred x** is  **sub x 1** .

*val abs* :  **int -\> int**

**abs x** is the absolute value of  **x** . That is  **x** if  **x** is positive and  **neg x** if  **x** is negative. Warning. This may be negative if the argument is  **Int.min\_int** .

*val max\_int* :  **int**

**max\_int** is the greatest representable integer, **2** ^ **Sys.int\_size - 1** **-1** .

*val min\_int* :  **int**

**min\_int** is the smallest representable integer, **-2** ^ **Sys.int\_size - 1** .

*val logand* :  **int -\> int -\> int**

**logand x y** is the bitwise logical and of  **x** and  **y** .

*val logor* :  **int -\> int -\> int**

**logor x y** is the bitwise logical or of  **x** and  **y** .

*val logxor* :  **int -\> int -\> int**

**logxor x y** is the bitwise logical exclusive or of  **x** and  **y** .

*val lognot* :  **int -\> int**

**lognot x** is the bitwise logical negation of  **x** .

*val shift\_left* :  **int -\> int -\> int**

**shift\_left x n** shifts  **x** to the left by  **n** bits. The result is unspecified if  **n \< 0** or  **n \>**  **Sys.int\_size** .

*val shift\_right* :  **int -\> int -\> int**

**shift\_right x n** shifts  **x** to the right by  **n** bits. This is an arithmetic shift: the sign bit of  **x** is replicated and inserted in the vacated bits. The result is unspecified if  **n \< 0** or **n \>**  **Sys.int\_size** .

*val shift\_right\_logical* :  **int -\> int -\> int**

**shift\_right\_logical x n** shifts  **x** to the right by  **n** bits. This is a logical shift: zeroes are inserted in the vacated bits regardless of the sign of  **x** . The result is unspecified if  **n \< 0** or  **n \>**  **Sys.int\_size** .

### Predicates and comparisons

*val equal* :  **int -\> int -\> bool**

**equal x y** is  **true** if and only if  **x = y** .

*val compare* :  **int -\> int -\> int**

**compare x y** is  **compare** **x y** but more efficient.

*val min* :  **int -\> int -\> int**

Return the smaller of the two arguments.

**Since** 4.13

*val max* :  **int -\> int -\> int**

Return the greater of the two arguments.

**Since** 4.13

### Bit counting

*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  **Sys.int\_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  **Sys.int\_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  **Sys.int\_size** inclusive. If  **n** is negative,  **leading\_zeros n = 0** since the most significant bit of  **n** is 1. **leading\_zeros n = {!Sys.int\_size}** if and only if  **n = zero** . Note that  **leading\_zeros n + unsigned\_bitsize n = {!Sys.int\_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  **{!Sys.int\_size} - 1** 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 = {!Sys.int\_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  **Sys.int\_size** inclusive. It is the largest integer  **i \<= {!Sys.int\_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 = {!Sys.int\_size}** if and only if  **n = zero** .

**Since** 5.5

### Converting

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

**to\_float x** is  **x** as a floating point number.

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

**of\_float x** truncates  **x** to an integer. The result is unspecified if the argument is  **nan** or falls outside the range of representable integers.

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

**to\_string x** is the written representation of  **x** in decimal.

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

A seeded hash function for 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* :  **int -\> int**

An unseeded hash function for 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