Int32(3) OCaml library Int32(3) # [NAME](#NAME) Int32 - 32-bit integers. # [Module](#Module) Module Int32 # [Documentation](#Documentation) Module **Int32** : **sig end** 32-bit integers. This module provides operations on the type **int32** of signed 32-bit integers. Unlike the built-in **int** type, the type **int32** is guaranteed to be exactly 32-bit wide on all platforms. All arithmetic operations over **int32** are taken modulo 2^32. Performance notice: values of type **int32** occupy more memory space than values of type **int** , and arithmetic operations on **int32** are generally slower than those on **int** . Use **int32** only when the application requires exact 32-bit arithmetic. Literals for 32-bit integers are suffixed by l: ``` let zero: int32 = 0l let one: int32 = 1l let m_one: int32 = -1l ``` *val zero* : **int32** The 32-bit integer 0. *val one* : **int32** The 32-bit integer 1. *val minus\_one* : **int32** The 32-bit integer -1. *val neg* : **int32 -> int32** Unary negation. *val add* : **int32 -> int32 -> int32** Addition. *val sub* : **int32 -> int32 -> int32** Subtraction. *val mul* : **int32 -> int32 -> int32** Multiplication. *val div* : **int32 -> int32 -> int32** 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* : **int32 -> int32 -> int32** Same as **Int32.div** , except that arguments and result are interpreted as unsigned 32-bit integers. **Since** 4.08.0 *val rem* : **int32 -> int32 -> int32** Integer remainder. If **y** is not zero, the result of **Int32.rem x y** satisfies the following property: **x = Int32.add (Int32.mul (Int32.div x y) y) (Int32.rem x y)** . If **y = 0** , **Int32.rem x y** raises **Division\_by\_zero** . *val unsigned\_rem* : **int32 -> int32 -> int32** Same as **Int32.rem** , except that arguments and result are interpreted as unsigned 32-bit integers. **Since** 4.08.0 *val succ* : **int32 -> int32** Successor. **Int32.succ x** is **Int32.add x Int32.one** . *val pred* : **int32 -> int32** Predecessor. **Int32.pred x** is **Int32.sub x Int32.one** . *val abs* : **int32 -> int32** Return the absolute value of its argument. *val max\_int* : **int32** The greatest representable 32-bit integer, 2^31 - 1. *val min\_int* : **int32** The smallest representable 32-bit integer, -2^31. *val logand* : **int32 -> int32 -> int32** Bitwise logical and. *val logor* : **int32 -> int32 -> int32** Bitwise logical or. *val logxor* : **int32 -> int32 -> int32** Bitwise logical exclusive or. *val lognot* : **int32 -> int32** Bitwise logical negation. *val shift\_left* : **int32 -> int -> int32** **Int32.shift\_left x y** shifts **x** to the left by **y** bits. The result is unspecified if **y < 0** or **y >= 32** . *val shift\_right* : **int32 -> int -> int32** **Int32.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 >= 32** . *val shift\_right\_logical* : **int32 -> int -> int32** **Int32.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 >= 32** . *val of\_int* : **int -> int32** Convert the given integer (type **int** ) to a 32-bit integer (type **int32** ). On 64-bit platforms, the argument is taken modulo 2^32. *val to\_int* : **int32 -> int** Convert the given 32-bit integer (type **int32** ) to an integer (type **int** ). On 32-bit platforms, the 32-bit integer is taken modulo 2^31, i.e. the high-order bit is lost during the conversion. On 64-bit platforms, the conversion is exact. *val unsigned\_to\_int* : **int32 -> int option** Same as **Int32.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.0 *val of\_float* : **float -> int32** Convert the given floating-point number to a 32-bit integer, discarding the fractional part (truncate towards 0). If the truncated floating-point number is outside the range \[ **Int32.min\_int** , **Int32.max\_int** ], no exception is raised, and an unspecified, platform-dependent integer is returned. *val to\_float* : **int32 -> float** Convert the given 32-bit integer to a floating-point number. *val of\_string* : **string -> int32** Convert the given string to a 32-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\*Int32.max\_int+1]** . If the input exceeds **Int32.max\_int** it is converted to the signed integer **Int32.min\_int + input - Int32.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 **int32** . *val of\_string\_opt* : **string -> int32 option** Same as **of\_string** , but return **None** instead of raising. **Since** 4.05 *val to\_string* : **int32 -> string** Return the string representation of its argument, in signed decimal. *val bits\_of\_float* : **float -> int32** Return the internal representation of the given float according to the IEEE 754 floating-point 'single format' bit layout. Bit 31 of the result represents the sign of the float; bits 30 to 23 represent the (biased) exponent; bits 22 to 0 represent the mantissa. *val float\_of\_bits* : **int32 -> float** Return the floating-point number whose internal representation, according to the IEEE 754 floating-point 'single format' bit layout, is the given **int32** . *type t* = **int32** An alias for the type of 32-bit integers. *val compare* : **t -> t -> int** The comparison function for 32-bit integers, with the same specification as **compare** . Along with the type **t** , this function **compare** allows the module **Int32** to be passed as argument to the functors **Set.Make** and **Map.Make** . *val unsigned\_compare* : **t -> t -> int** Same as **Int32.compare** , except that arguments are interpreted as unsigned 32-bit integers. **Since** 4.08.0 *val equal* : **t -> t -> bool** The equal function for int32s. **Since** 4.03.0 *val min* : **t -> t -> t** Return the smaller of the two arguments. **Since** 4.13.0 *val max* : **t -> t -> t** Return the greater of the two arguments. **Since** 4.13.0 2026-09-15 OCamldoc --- Document: Int32(3o) from ocaml-4 4.14.4-r3 (Chainguard OS) Source: https://github.com/ocaml/ocaml