Stdlib.Int(3)

Stdlib.Int(3) 💅

okay so bestie, this is the Stdlib.Int page from the OCaml library manual, and it's basically the whole personality of OCaml integers in one place. no description in the NAME section, which is giving mysterious main character energy, but we move 🫶

---

NAME

Stdlib.Int — no description 🙈 (that's literally all it says, i'm not hiding anything from you)

✨ Module ✨

Module Stdlib.Int

📖 Documentation

Module Int : (module Stdlib__Int)

---

🔢 Integers 🔢

type t = int

The type for integer values. iconic, honestly.

---

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, bestie. 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, she's new here. 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, the other new girl. 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 . (yes that's the whole point, lowkey iconic)

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 . 😭 like genuinely, watch out for that one.

---

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 . 💀 no cap, don't do it.

---

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, the description reads exactly like that, i'm not messing with you 😭)

---

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 ⭐

---

and that's the whole page bestie, every single val accounted for, nothing skipped, we ate and left no crumbs 🔥

mwah 💋 — this page was served up by OCamldoc, dated 2026-06-22, on page Stdlib.Int(3). catch you in the next manpage 🫶