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 264
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
let zero: int64;
The 64-bit integer 0.
let one: int64;
The 64-bit integer 1.
let minus_one: int64;
The 64-bit integer -1.
let neg: int64 => int64;
Unary negation.
let add: (int64, int64) => int64;
Addition.
let sub: (int64, int64) => int64;
Subtraction.
let mul: (int64, int64) => int64;
Multiplication.
let div: (int64, int64) => int64;
Integer division.
Division_by_zero
if the second
argument is zero. This division rounds the real quotient of
its arguments towards zero, as specified for (/)
.let unsigned_div: (int64, int64) => int64;
Same as Int64.div
, except that arguments and result are interpreted as unsigned 64-bit integers.
let 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
.
let unsigned_rem: (int64, int64) => int64;
Same as Int64.rem
, except that arguments and result are interpreted as unsigned 64-bit integers.
let succ: int64 => int64;
Successor. Int64.succ x
is Int64.add x Int64.one
.
let pred: int64 => int64;
Predecessor. Int64.pred x
is Int64.sub x Int64.one
.
let abs: int64 => int64;
Return the absolute value of its argument.
let max_int: int64;
The greatest representable 64-bit integer, 263 - 1.
let min_int: int64;
The smallest representable 64-bit integer, -263.
let logand: (int64, int64) => int64;
Bitwise logical and.
let logor: (int64, int64) => int64;
Bitwise logical or.
let logxor: (int64, int64) => int64;
Bitwise logical exclusive or.
let lognot: int64 => int64;
Bitwise logical negation.
let 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
.
let 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
.
let 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
.
let of_int: int => int64;
Convert the given integer (type int
) to a 64-bit integer
(type int64
).
let 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 263, i.e. the high-order bit is lost
during the conversion. On 32-bit platforms, the 64-bit integer
is taken modulo 231, i.e. the top 33 bits are lost
during the conversion.
let unsigned_to_int: int64 => option(int);
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
.
let of_float: float => int64;
Convert the given floating-point number to a 64-bit integer,
discarding the fractional part (truncate towards 0).
The result of the conversion is undefined if, after truncation,
the number is outside the range [Int64.min_int
, Int64.max_int
].
let to_float: int64 => float;
Convert the given 64-bit integer to a floating-point number.
let of_int32: int32 => int64;
Convert the given 32-bit integer (type int32
)
to a 64-bit integer (type int64
).
let 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 232, i.e. the top 32 bits are lost
during the conversion.
let of_nativeint: nativeint => int64;
Convert the given native integer (type nativeint
)
to a 64-bit integer (type int64
).
let 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 232. On 64-bit platforms,
the conversion is exact.
let 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.
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
.let of_string_opt: string => option(int64);
Same as of_string
, but return None
instead of raising.
let to_string: int64 => string;
Return the string representation of its argument, in decimal.
let 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.
let 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.
let compare: (t, t) => int;
let unsigned_compare: (t, t) => int;
Same as Int64.compare
, except that arguments are interpreted as unsigned
64-bit integers.
let equal: (t, t) => bool;
The equal function for int64s.