Int(3)

💖 Int — Integer values 💖

okay so this is the Int page from the OCaml library manual (that's Int(3), bestie, iykyk) 💅

---

🌸 Module 🌸

Module Int

Module Int
 : sig end

Integer values, periodt. ✨

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 — she just wraps around and keeps going, main character energy fr fr. 🌀

Since 4.08 🎀

---

🧚 Integers 🧚

type t = int

The type for integer values. iconic.

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. flip the sign bestie

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. next pls ➡️

val pred : int -> int

pred x is sub x 1. previous pls ⬅️

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 😭 — like, genuinely, that's undefined-ish chaos, don't be surprised.

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. ⚠️ like, bestie, don't.

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. yes, that's literally what it says, and honestly? slay. ⚡

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. ⚠️ no cap, watch out

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 ✨

---

💖 and that's the whole page bestie, go forth and modulo 💖

this gem was brought to you by OCamldoc, dated 2026-06-22 — see you in the next man page, mwah 🫶🎀🦋