# Int64

Provides utility functions on 64-bit signed integers.

Note that most operations are available as built-in operators (e.g. `1 + 1`

).

Import from the base library to use this module.

`import Int64 "mo:base/Int64";`

## Type `Int64`

`type Int64 = Prim.Types.Int64`

64-bit signed integers.

## Value `minimumValue`

`let minimumValue : Int64`

Minimum 64-bit integer value, `-2 ** 63`

.

Example:

`Int64.minimumValue // => -9_223_372_036_854_775_808`

## Value `maximumValue`

`let maximumValue : Int64`

Maximum 64-bit integer value, `+2 ** 63 - 1`

.

Example:

`Int64.maximumValue // => +9_223_372_036_854_775_807`

## Value `toInt`

`let toInt : Int64 -> Int`

Converts a 64-bit signed integer to a signed integer with infinite precision.

Example:

`Int64.toInt(123_456) // => 123_456 : Int`

## Value `fromInt`

`let fromInt : Int -> Int64`

Converts a signed integer with infinite precision to a 64-bit signed integer.

Traps on overflow/underflow.

Example:

`Int64.fromInt(123_456) // => +123_456 : Int64`

## Value `fromInt32`

`let fromInt32 : Int32 -> Int64`

Converts a 32-bit signed integer to a 64-bit signed integer.

Traps on overflow/underflow.

Example:

`Int64.fromInt32(-123_456) // => -123_456 : Int64`

## Value `toInt32`

`let toInt32 : Int64 -> Int32`

Converts a 64-bit signed integer to a 32-bit signed integer.

Wraps on overflow/underflow.

Example:

`Int64.toInt32(-123_456) // => -123_456 : Int32`

## Value `fromIntWrap`

`let fromIntWrap : Int -> Int64`

Converts a signed integer with infinite precision to a 64-bit signed integer.

Wraps on overflow/underflow.

Example:

`Int64.fromIntWrap(-123_456) // => -123_456 : Int64`

## Value `fromNat64`

`let fromNat64 : Nat64 -> Int64`

Converts an unsigned 64-bit integer to a signed 64-bit integer.

Wraps on overflow/underflow.

Example:

`Int64.fromNat64(123_456) // => +123_456 : Int64`

## Value `toNat64`

`let toNat64 : Int64 -> Nat64`

Converts a signed 64-bit integer to an unsigned 64-bit integer.

Wraps on overflow/underflow.

Example:

`Int64.toNat64(-1) // => 18_446_744_073_709_551_615 : Nat64 // underflow`

## Function `toText`

`func toText(x : Int64) : Text`

Returns the Text representation of `x`

. Textual representation *do not*
contain underscores to represent commas.

Example:

`Int64.toText(-123456) // => "-123456"`

## Function `abs`

`func abs(x : Int64) : Int64`

Returns the absolute value of `x`

.

Traps when `x == -2 ** 63`

(the minimum `Int64`

value).

Example:

`Int64.abs(-123456) // => +123_456`

## Function `min`

`func min(x : Int64, y : Int64) : Int64`

Returns the minimum of `x`

and `y`

.

Example:

`Int64.min(+2, -3) // => -3`

## Function `max`

`func max(x : Int64, y : Int64) : Int64`

Returns the maximum of `x`

and `y`

.

Example:

`Int64.max(+2, -3) // => +2`

## Function `equal`

`func equal(x : Int64, y : Int64) : Bool`

Equality function for Int64 types.
This is equivalent to `x == y`

.

Example:

`Int64.equal(-1, -1); // => true`

Note: The reason why this function is defined in this library (in addition
to the existing `==`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `==`

as a function value at the moment.

Example:

`import Buffer "mo:base/Buffer";`

let buffer1 = Buffer.Buffer<Int64>(1);

buffer1.add(-3);

let buffer2 = Buffer.Buffer<Int64>(1);

buffer2.add(-3);

Buffer.equal(buffer1, buffer2, Int64.equal) // => true

## Function `notEqual`

`func notEqual(x : Int64, y : Int64) : Bool`

Inequality function for Int64 types.
This is equivalent to `x != y`

.

Example:

`Int64.notEqual(-1, -2); // => true`

Note: The reason why this function is defined in this library (in addition
to the existing `!=`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `!=`

as a function value at the moment.

## Function `less`

`func less(x : Int64, y : Int64) : Bool`

"Less than" function for Int64 types.
This is equivalent to `x < y`

.

Example:

`Int64.less(-2, 1); // => true`

Note: The reason why this function is defined in this library (in addition
to the existing `<`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `<`

as a function value at the moment.

## Function `lessOrEqual`

`func lessOrEqual(x : Int64, y : Int64) : Bool`

"Less than or equal" function for Int64 types.
This is equivalent to `x <= y`

.

Example:

`Int64.lessOrEqual(-2, -2); // => true`

Note: The reason why this function is defined in this library (in addition
to the existing `<=`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `<=`

as a function value at the moment.

## Function `greater`

`func greater(x : Int64, y : Int64) : Bool`

"Greater than" function for Int64 types.
This is equivalent to `x > y`

.

Example:

`Int64.greater(-2, -3); // => true`

Note: The reason why this function is defined in this library (in addition
to the existing `>`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `>`

as a function value at the moment.

## Function `greaterOrEqual`

`func greaterOrEqual(x : Int64, y : Int64) : Bool`

"Greater than or equal" function for Int64 types.
This is equivalent to `x >= y`

.

Example:

`Int64.greaterOrEqual(-2, -2); // => true`

Note: The reason why this function is defined in this library (in addition
to the existing `>=`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `>=`

as a function value at the moment.

## Function `compare`

`func compare(x : Int64, y : Int64) : {#less; #equal; #greater}`

General-purpose comparison function for `Int64`

. Returns the `Order`

(
either `#less`

, `#equal`

, or `#greater`

) of comparing `x`

with `y`

.

Example:

`Int64.compare(-3, 2) // => #less`

This function can be used as value for a high order function, such as a sort function.

Example:

`import Array "mo:base/Array";`

Array.sort([1, -2, -3] : [Int64], Int64.compare) // => [-3, -2, 1]

## Function `neg`

`func neg(x : Int64) : Int64`

Returns the negation of `x`

, `-x`

.

Traps on overflow, i.e. for `neg(-2 ** 63)`

.

Example:

`Int64.neg(123) // => -123`

Note: The reason why this function is defined in this library (in addition
to the existing `-`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `-`

as a function value at the moment.

## Function `add`

`func add(x : Int64, y : Int64) : Int64`

Returns the sum of `x`

and `y`

, `x + y`

.

Traps on overflow/underflow.

Example:

`Int64.add(1234, 123) // => +1_357`

Note: The reason why this function is defined in this library (in addition
to the existing `+`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `+`

as a function value at the moment.

Example:

`import Array "mo:base/Array";`

Array.foldLeft<Int64, Int64>([1, -2, -3], 0, Int64.add) // => -4

## Function `sub`

`func sub(x : Int64, y : Int64) : Int64`

Returns the difference of `x`

and `y`

, `x - y`

.

Traps on overflow/underflow.

Example:

`Int64.sub(123, 100) // => +23`

Note: The reason why this function is defined in this library (in addition
to the existing `-`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `-`

as a function value at the moment.

Example:

`import Array "mo:base/Array";`

Array.foldLeft<Int64, Int64>([1, -2, -3], 0, Int64.sub) // => 4

## Function `mul`

`func mul(x : Int64, y : Int64) : Int64`

Returns the product of `x`

and `y`

, `x * y`

.

Traps on overflow/underflow.

Example:

`Int64.mul(123, 10) // => +1_230`

Note: The reason why this function is defined in this library (in addition
to the existing `*`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `*`

as a function value at the moment.

Example:

`import Array "mo:base/Array";`

Array.foldLeft<Int64, Int64>([1, -2, -3], 1, Int64.mul) // => 6

## Function `div`

`func div(x : Int64, y : Int64) : Int64`

Returns the signed integer division of `x`

by `y`

, `x / y`

.
Rounds the quotient towards zero, which is the same as truncating the decimal places of the quotient.

Traps when `y`

is zero.

Example:

`Int64.div(123, 10) // => +12`

Note: The reason why this function is defined in this library (in addition
to the existing `/`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `/`

as a function value at the moment.

## Function `rem`

`func rem(x : Int64, y : Int64) : Int64`

Returns the remainder of the signed integer division of `x`

by `y`

, `x % y`

,
which is defined as `x - x / y * y`

.

Traps when `y`

is zero.

Example:

`Int64.rem(123, 10) // => +3`

Note: The reason why this function is defined in this library (in addition
to the existing `%`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `%`

as a function value at the moment.

## Function `pow`

`func pow(x : Int64, y : Int64) : Int64`

Returns `x`

to the power of `y`

, `x ** y`

.

Traps on overflow/underflow and when `y < 0 or y >= 64`

.

Example:

`Int64.pow(2, 10) // => +1_024`

Note: The reason why this function is defined in this library (in addition
to the existing `**`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `**`

as a function value at the moment.

## Function `bitnot`

`func bitnot(x : Int64) : Int64`

Returns the bitwise negation of `x`

, `^x`

.

Example:

`Int64.bitnot(-256 /* 0xffff_ffff_ffff_ff00 */) // => +255 // 0xff`

Note: The reason why this function is defined in this library (in addition
to the existing `^`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `^`

as a function value at the moment.

## Function `bitand`

`func bitand(x : Int64, y : Int64) : Int64`

Returns the bitwise "and" of `x`

and `y`

, `x & y`

.

Example:

`Int64.bitand(0xffff, 0x00f0) // => +240 // 0xf0`

Note: The reason why this function is defined in this library (in addition
to the existing `&`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `&`

as a function value at the moment.

## Function `bitor`

`func bitor(x : Int64, y : Int64) : Int64`

Returns the bitwise "or" of `x`

and `y`

, `x | y`

.

Example:

`Int64.bitor(0xffff, 0x00f0) // => +65_535 // 0xffff`

Note: The reason why this function is defined in this library (in addition
to the existing `|`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `|`

as a function value at the moment.

## Function `bitxor`

`func bitxor(x : Int64, y : Int64) : Int64`

Returns the bitwise "exclusive or" of `x`

and `y`

, `x ^ y`

.

Example:

`Int64.bitxor(0xffff, 0x00f0) // => +65_295 // 0xff0f`

Note: The reason why this function is defined in this library (in addition
to the existing `^`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `^`

as a function value at the moment.

## Function `bitshiftLeft`

`func bitshiftLeft(x : Int64, y : Int64) : Int64`

Returns the bitwise left shift of `x`

by `y`

, `x << y`

.
The right bits of the shift filled with zeros.
Left-overflowing bits, including the sign bit, are discarded.

For `y >= 64`

, the semantics is the same as for `bitshiftLeft(x, y % 64)`

.
For `y < 0`

, the semantics is the same as for `bitshiftLeft(x, y + y % 64)`

.

Example:

`Int64.bitshiftLeft(1, 8) // => +256 // 0x100 equivalent to `2 ** 8`.`

Note: The reason why this function is defined in this library (in addition
to the existing `<<`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `<<`

as a function value at the moment.

## Function `bitshiftRight`

`func bitshiftRight(x : Int64, y : Int64) : Int64`

Returns the signed bitwise right shift of `x`

by `y`

, `x >> y`

.
The sign bit is retained and the left side is filled with the sign bit.
Right-underflowing bits are discarded, i.e. not rotated to the left side.

For `y >= 64`

, the semantics is the same as for `bitshiftRight(x, y % 64)`

.
For `y < 0`

, the semantics is the same as for `bitshiftRight (x, y + y % 64)`

.

Example:

`Int64.bitshiftRight(1024, 8) // => +4 // equivalent to `1024 / (2 ** 8)``

Note: The reason why this function is defined in this library (in addition
to the existing `>>`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `>>`

as a function value at the moment.

## Function `bitrotLeft`

`func bitrotLeft(x : Int64, y : Int64) : Int64`

Returns the bitwise left rotatation of `x`

by `y`

, `x <<> y`

.
Each left-overflowing bit is inserted again on the right side.
The sign bit is rotated like other bits, i.e. the rotation interprets the number as unsigned.

Changes the direction of rotation for negative `y`

.
For `y >= 64`

, the semantics is the same as for `bitrotLeft(x, y % 64)`

.

Example:

Int64.bitrotLeft(0x2000_0000_0000_0001, 4) // => +18 // 0x12.

Note: The reason why this function is defined in this library (in addition
to the existing `<<>`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `<<>`

as a function value at the moment.

## Function `bitrotRight`

`func bitrotRight(x : Int64, y : Int64) : Int64`

Returns the bitwise right rotation of `x`

by `y`

, `x <>> y`

.
Each right-underflowing bit is inserted again on the right side.
The sign bit is rotated like other bits, i.e. the rotation interprets the number as unsigned.

Changes the direction of rotation for negative `y`

.
For `y >= 64`

, the semantics is the same as for `bitrotRight(x, y % 64)`

.

Example:

`Int64.bitrotRight(0x0002_0000_0000_0001, 48) // => +65538 // 0x1_0002.`

Note: The reason why this function is defined in this library (in addition
to the existing `<>>`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `<>>`

as a function value at the moment.

## Function `bittest`

`func bittest(x : Int64, p : Nat) : Bool`

Returns the value of bit `p`

in `x`

, `x & 2**p == 2**p`

.
If `p >= 64`

, the semantics is the same as for `bittest(x, p % 64)`

.
This is equivalent to checking if the `p`

-th bit is set in `x`

, using 0 indexing.

Example:

`Int64.bittest(128, 7) // => true`

## Function `bitset`

`func bitset(x : Int64, p : Nat) : Int64`

Returns the value of setting bit `p`

in `x`

to `1`

.
If `p >= 64`

, the semantics is the same as for `bitset(x, p % 64)`

.

Example:

`Int64.bitset(0, 7) // => +128`

## Function `bitclear`

`func bitclear(x : Int64, p : Nat) : Int64`

Returns the value of clearing bit `p`

in `x`

to `0`

.
If `p >= 64`

, the semantics is the same as for `bitclear(x, p % 64)`

.

Example:

`Int64.bitclear(-1, 7) // => -129`

## Function `bitflip`

`func bitflip(x : Int64, p : Nat) : Int64`

Returns the value of flipping bit `p`

in `x`

.
If `p >= 64`

, the semantics is the same as for `bitclear(x, p % 64)`

.

Example:

`Int64.bitflip(255, 7) // => +127`

## Value `bitcountNonZero`

`let bitcountNonZero : (x : Int64) -> Int64`

Returns the count of non-zero bits in `x`

.

Example:

`Int64.bitcountNonZero(0xffff) // => +16`

## Value `bitcountLeadingZero`

`let bitcountLeadingZero : (x : Int64) -> Int64`

Returns the count of leading zero bits in `x`

.

Example:

`Int64.bitcountLeadingZero(0x8000_0000) // => +32`

## Value `bitcountTrailingZero`

`let bitcountTrailingZero : (x : Int64) -> Int64`

Returns the count of trailing zero bits in `x`

.

Example:

`Int64.bitcountTrailingZero(0x0201_0000) // => +16`

## Function `addWrap`

`func addWrap(x : Int64, y : Int64) : Int64`

Returns the sum of `x`

and `y`

, `x +% y`

.

Wraps on overflow/underflow.

Example:

`Int64.addWrap(2 ** 62, 2 ** 62) // => -9_223_372_036_854_775_808 // overflow`

Note: The reason why this function is defined in this library (in addition
to the existing `+%`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `+%`

as a function value at the moment.

## Function `subWrap`

`func subWrap(x : Int64, y : Int64) : Int64`

Returns the difference of `x`

and `y`

, `x -% y`

.

Wraps on overflow/underflow.

Example:

`Int64.subWrap(-2 ** 63, 1) // => +9_223_372_036_854_775_807 // underflow`

Note: The reason why this function is defined in this library (in addition
to the existing `-%`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `-%`

as a function value at the moment.

## Function `mulWrap`

`func mulWrap(x : Int64, y : Int64) : Int64`

Returns the product of `x`

and `y`

, `x *% y`

. Wraps on overflow.

Wraps on overflow/underflow.

Example:

`Int64.mulWrap(2 ** 32, 2 ** 32) // => 0 // overflow`

Note: The reason why this function is defined in this library (in addition
to the existing `*%`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `*%`

as a function value at the moment.

## Function `powWrap`

`func powWrap(x : Int64, y : Int64) : Int64`

Returns `x`

to the power of `y`

, `x **% y`

.

Wraps on overflow/underflow.
Traps if `y < 0 or y >= 64`

.

Example:

`Int64.powWrap(2, 63) // => -9_223_372_036_854_775_808 // overflow`

Note: The reason why this function is defined in this library (in addition
to the existing `**%`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `**%`

as a function value at the moment.