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

# Int64(3o)

64-bit integers.

## NAME

Int64 - 64-bit integers.

## Module

Module   Int64

## Documentation

Module **Int64**\
  :  **sig end**

64-bit integers.

This module provides operations on the type  **int64** of signed 64-bit integers.  Unlike the built-in  **int** type, the type  **int64** is guaranteed to be exactly 64-bit wide on all platforms.  All arithmetic operations over  **int64** are taken modulo 2^64

Performance notice: values of type  **int64** occupy more memory space than values of type  **int** , and arithmetic operations on **int64** are generally slower than those on  **int** .  Use  **int64** only when the application requires exact 64-bit arithmetic.

Literals for 64-bit integers are suffixed by L:

```
      let zero: int64 = 0L
      let one: int64 = 1L
      let m_one: int64 = -1L

```

*val zero* :  **int64**

The 64-bit integer 0.

*val one* :  **int64**

The 64-bit integer 1.

*val minus\_one* :  **int64**

The 64-bit integer -1.

*val neg* :  **int64 -\> int64**

Unary negation.

*val add* :  **int64 -\> int64 -\> int64**

Addition.

*val sub* :  **int64 -\> int64 -\> int64**

Subtraction.

*val mul* :  **int64 -\> int64 -\> int64**

Multiplication.

*val div* :  **int64 -\> int64 -\> int64**

Integer division.

**Raises Division\_by\_zero** if the second argument is zero.  This division rounds the real quotient of its arguments towards zero, as specified for  **(/)** .

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

Same as  **Int64.div** , except that arguments and result are interpreted as     unsigned 64-bit integers.

**Since** 4.08

*val rem* :  **int64 -\> int64 -\> int64**

Integer remainder.  If  **y** is not zero, the result of  **Int64.rem x y** satisfies the following property: **x = Int64.add (Int64.mul (Int64.div x y) y) (Int64.rem x y)** . If  **y = 0** ,  **Int64.rem x y** raises  **Division\_by\_zero** .

*val unsigned\_rem* :  **int64 -\> int64 -\> int64**

Same as  **Int64.rem** , except that arguments and result are interpreted as     unsigned 64-bit integers.

**Since** 4.08

*val fdiv* :  **int64 -\> int64 -\> int64**

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

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

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

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

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

*val pred* :  **int64 -\> int64**

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

*val abs* :  **int64 -\> int64**

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

*val max\_int* :  **int64**

The greatest representable 64-bit integer, 2^63 - 1.

*val min\_int* :  **int64**

The smallest representable 64-bit integer, -2^63.

*val logand* :  **int64 -\> int64 -\> int64**

Bitwise logical and.

*val logor* :  **int64 -\> int64 -\> int64**

Bitwise logical or.

*val logxor* :  **int64 -\> int64 -\> int64**

Bitwise logical exclusive or.

*val lognot* :  **int64 -\> int64**

Bitwise logical negation.

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

**Int64.shift\_left x y** shifts  **x** to the left by  **y** bits. The result is unspecified if  **y \< 0** or  **y \>= 64** .

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

**Int64.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 \>= 64** .

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

**Int64.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 \>= 64** .

*val of\_int* :  **int -\> int64**

Convert the given integer (type  **int** ) to a 64-bit integer (type  **int64** ).

*val to\_int* :  **int64 -\> int**

Convert the given 64-bit integer (type  **int64** ) to an integer (type  **int** ).  On 64-bit platforms, the 64-bit integer is taken modulo 2^63, i.e. the high-order bit is lost during the conversion.  On 32-bit platforms, the 64-bit integer is taken modulo 2^31, i.e. the top 33 bits are lost during the conversion.

*val unsigned\_to\_int* :  **int64 -\> int option**

Same as  **Int64.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 -\> int64**

Convert the given floating-point number to a 64-bit integer, discarding the fractional part (truncate towards 0). If the truncated floating-point number is outside the range \[ **Int64.min\_int** ,  **Int64.max\_int** \], no exception is raised, and an unspecified, platform-dependent integer is returned.

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

Convert the given 64-bit integer to a floating-point number.

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

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

*val to\_int32* :  **int64 -\> int32**

Convert the given 64-bit integer (type  **int64** ) to a 32-bit integer (type  **int32** ). The 64-bit integer is taken modulo 2^32, i.e. the top 32 bits are lost during the conversion.

*val of\_nativeint* :  **nativeint -\> int64**

Convert the given native integer (type  **nativeint** ) to a 64-bit integer (type  **int64** ).

*val to\_nativeint* :  **int64 -\> nativeint**

Convert the given 64-bit integer (type  **int64** ) to a native integer.  On 32-bit platforms, the 64-bit integer is taken modulo 2^32.  On 64-bit platforms, the conversion is exact.

*val of\_string* :  **string -\> int64**

Convert the given string to a 64-bit 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\*Int64.max\_int+1\]** .  If the input exceeds  **Int64.max\_int** it is converted to the signed integer **Int64.min\_int + input - Int64.max\_int - 1** .

The  **\_** (underscore) character can appear anywhere in the string and is ignored.

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

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

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

**Since** 4.05

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

Return the string representation of its argument, in decimal.

*val bits\_of\_float* :  **float -\> int64**

Return the internal representation of the given float according to the IEEE 754 floating-point 'double format' bit layout. Bit 63 of the result represents the sign of the float; bits 62 to 52 represent the (biased) exponent; bits 51 to 0 represent the mantissa.

*val float\_of\_bits* :  **int64 -\> float**

Return the floating-point number whose internal representation, according to the IEEE 754 floating-point 'double format' bit layout, is the given  **int64** .

*type t* =  **int64**

An alias for the type of 64-bit integers.

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

The comparison function for 64-bit integers, with the same specification as **compare** .  Along with the type  **t** , this function  **compare** allows the module  **Int64** to be passed as argument to the functors **Set.Make** and  **Map.Make** .

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

Same as  **Int64.compare** , except that arguments are interpreted as unsigned 64-bit integers.

**Since** 4.08

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

The equal function for int64s.

**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 64 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 64 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 = 64** if and only if  **n = zero** . Note that  **leading\_zeros n + unsigned\_bitsize n = 64** .

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

**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 64 inclusive. It is the largest integer  **i \<= 64** such that  **2{^i}** divides  **n** evenly. For example,  **trailing\_zeros n = 0** if and only if  **n** is odd, and  **trailing\_zeros n = 64** if and only if  **n = zero** .

**Since** 5.5

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

A seeded hash function for 64-bit 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 64-bit 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