`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 2^{64}

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.

```
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. Raise

`Division_by_zero`

if the second
argument is zero. This division rounds the real quotient of
its arguments towards zero, as specified for `Pervasives.(/)`

.```
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 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, 2^{63} - 1.

```
let min_int: int64;
```

The smallest representable 64-bit integer, -2^{63}.

```
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 ^{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.

`int64`

) to an
integer (type `int`

). On 64-bit platforms, the 64-bit integer
is taken modulo 2```
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 ^{32}, i.e. the top 32 bits are lost
during the conversion.

`int64`

) to a
32-bit integer (type `int32`

). The 64-bit integer
is taken modulo 2```
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 ^{32}. On 64-bit platforms,
the conversion is exact.

`int64`

) to a
native integer. On 32-bit platforms, the 64-bit integer
is taken modulo 2```
let of_string: string => int64;
```

Convert the given string to a 64-bit integer.
The string is read in decimal (by default) or in hexadecimal,
octal or binary if the string begins with

`0x`

, `0o`

or `0b`

respectively.
Raise `Failure "int_of_string"`

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 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;
```

The comparison function for 64-bit integers, with the same specification as

`Pervasives.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`

.```
let format: (string, int64) => string;
```