Stdlib.Int64(3) OCaml library Stdlib.Int64(3) # [NAME](#NAME) Stdlib.Int64 - no description # [Module](#Module) Module Stdlib.Int64 # [Documentation](#Documentation) Module **Int64** : **(module Stdlib\_\_Int64)** *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 2026-10-23 OCamldoc --- Document: Stdlib.Int64(3o) from ocaml 5.5.2-r0 (Chainguard OS) Source: https://github.com/ocaml/ocaml