@grain/stdlib 0.5.13 → 0.6.0

package/uint64.gr

@@ -0,0 +1,471 @@
+/**
+ * Utilities for working with the Uint64 type.
+ * @example from "uint64" include Uint64
+ *
+ * @since v0.6.0
+ */
+module Uint64
+
+from "runtime/unsafe/wasmi32" include WasmI32
+from "runtime/unsafe/wasmi64" include WasmI64
+use WasmI64.{ (==), (!=), (&), (|), (^), (+), (-), (*), (<<), (>>>) }
+from "runtime/unsafe/memory" include Memory
+from "runtime/exception" include Exception
+from "runtime/numbers" include Numbers
+use Numbers.{ reducedUnsignedInteger, coerceNumberToUnsignedWasmI64 }
+from "runtime/dataStructures" include DataStructures
+use DataStructures.{ newUint64 }
+
+// First 8 bytes of 64-bit unsigned int are heap tag and 32 bits of padding
+@unsafe
+let _VALUE_OFFSET = 8n
+
+/**
+ * Converts a Number to a Uint64.
+ *
+ * @param number: The value to convert
+ * @returns The Number represented as a Uint64
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let fromNumber = (number: Number) => {
+  let result = newUint64(coerceNumberToUnsignedWasmI64(number))
+  WasmI32.toGrain(result): Uint64
+}
+
+/**
+ * Converts a Uint64 to a Number.
+ *
+ * @param value: The value to convert
+ * @returns The Uint64 represented as a Number
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let toNumber = (value: Uint64) => {
+  WasmI32.toGrain(
+    reducedUnsignedInteger(
+      WasmI64.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
+    )
+  ): Number
+}
+
+/**
+ * Converts an Int64 to a Uint64.
+ *
+ * @param number: The value to convert
+ * @returns The Int64 represented as a Uint64
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let fromInt64 = (number: Int64) => {
+  let x = WasmI64.load(WasmI32.fromGrain(number), 8n)
+  let result = newUint64(x)
+  WasmI32.toGrain(result): Uint64
+}
+
+/**
+ * Increments the value by one.
+ *
+ * @param value: The value to increment
+ * @returns The incremented value
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let incr = (value: Uint64) => {
+  let value = WasmI32.fromGrain(value)
+  let ptr = newUint64(WasmI64.load(value, _VALUE_OFFSET) + 1N)
+  WasmI32.toGrain(ptr): Uint64
+}
+
+/**
+ * Decrements the value by one.
+ *
+ * @param value: The value to decrement
+ * @returns The decremented value
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let decr = (value: Uint64) => {
+  let value = WasmI32.fromGrain(value)
+  let ptr = newUint64(WasmI64.load(value, _VALUE_OFFSET) - 1N)
+  WasmI32.toGrain(ptr): Uint64
+}
+
+/**
+ * Computes the sum of its operands.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns The sum of the two operands
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let (+) = (x: Uint64, y: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  let ptr = newUint64(xv + yv)
+  WasmI32.toGrain(ptr): Uint64
+}
+
+/**
+ * Computes the difference of its operands.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns The difference of the two operands
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let (-) = (x: Uint64, y: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  let ptr = newUint64(xv - yv)
+  WasmI32.toGrain(ptr): Uint64
+}
+
+/**
+ * Computes the product of its operands.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns The product of the two operands
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let (*) = (x: Uint64, y: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  let ptr = newUint64(xv * yv)
+  WasmI32.toGrain(ptr): Uint64
+}
+
+/**
+ * Computes the quotient of its operands.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns The quotient of its operands
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let (/) = (x: Uint64, y: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  let ptr = newUint64(WasmI64.divU(xv, yv))
+  WasmI32.toGrain(ptr): Uint64
+}
+
+/**
+ * Computes the remainder of the division of its operands.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns The remainder of its operands
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let rem = (x: Uint64, y: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  let ptr = newUint64(WasmI64.remU(xv, yv))
+  WasmI32.toGrain(ptr): Uint64
+}
+
+/**
+ * Rotates the bits of the value left by the given number of bits.
+ *
+ * @param value: The value to rotate
+ * @param amount: The number of bits to rotate by
+ * @returns The rotated value
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let rotl = (value: Uint64, amount: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
+  let yv = WasmI64.load(WasmI32.fromGrain(amount), _VALUE_OFFSET)
+  let ptr = newUint64(WasmI64.rotl(xv, yv))
+  WasmI32.toGrain(ptr): Uint64
+}
+
+/**
+ * Rotates the bits of the value right by the given number of bits.
+ *
+ * @param value: The value to rotate
+ * @param amount: The number of bits to rotate by
+ * @returns The rotated value
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let rotr = (value: Uint64, amount: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
+  let yv = WasmI64.load(WasmI32.fromGrain(amount), _VALUE_OFFSET)
+  let ptr = newUint64(WasmI64.rotr(xv, yv))
+  WasmI32.toGrain(ptr): Uint64
+}
+
+/**
+ * Shifts the bits of the value left by the given number of bits.
+ *
+ * @param value: The value to shift
+ * @param amount: The number of bits to shift by
+ * @returns The shifted value
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let (<<) = (value: Uint64, amount: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
+  let yv = WasmI64.load(WasmI32.fromGrain(amount), _VALUE_OFFSET)
+  let ptr = newUint64(xv << yv)
+  WasmI32.toGrain(ptr): Uint64
+}
+
+/**
+ * Shifts the bits of the value right by the given number of bits.
+ *
+ * @param value: The value to shift
+ * @param amount: The amount to shift by
+ * @returns The shifted value
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let (>>>) = (value: Uint64, amount: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
+  let yv = WasmI64.load(WasmI32.fromGrain(amount), _VALUE_OFFSET)
+  let ptr = newUint64(xv >>> yv)
+  WasmI32.toGrain(ptr): Uint64
+}
+
+/**
+ * Checks if the first value is equal to the second value.
+ *
+ * @param x: The first value
+ * @param y: The second value
+ * @returns `true` if the first value is equal to the second value or `false` otherwise
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let (==) = (x: Uint64, y: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  xv == yv
+}
+
+/**
+ * Checks if the first value is not equal to the second value.
+ *
+ * @param x: The first value
+ * @param y: The second value
+ * @returns `true` if the first value is not equal to the second value or `false` otherwise
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let (!=) = (x: Uint64, y: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  xv != yv
+}
+
+/**
+ * Checks if the given value is equal to zero.
+ *
+ * @param value: The value to inspect
+ * @returns `true` if the first value is equal to zero or `false` otherwise
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let eqz = (value: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
+  WasmI64.eqz(xv)
+}
+
+/**
+ * Checks if the first value is less than the second value.
+ *
+ * @param x: The first value
+ * @param y: The second value
+ * @returns `true` if the first value is less than the second value or `false` otherwise
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let (<) = (x: Uint64, y: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  WasmI64.ltU(xv, yv)
+}
+
+/**
+ * Checks if the first value is greater than the second value.
+ *
+ * @param x: The first value
+ * @param y: The second value
+ * @returns `true` if the first value is greater than the second value or `false` otherwise
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let (>) = (x: Uint64, y: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  WasmI64.gtU(xv, yv)
+}
+
+/**
+ * Checks if the first value is less than or equal to the second value.
+ *
+ * @param x: The first value
+ * @param y: The second value
+ * @returns `true` if the first value is less than or equal to the second value or `false` otherwise
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let (<=) = (x: Uint64, y: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  WasmI64.leU(xv, yv)
+}
+
+/**
+ * Checks if the first value is greater than or equal to the second value.
+ *
+ * @param x: The first value
+ * @param y: The second value
+ * @returns `true` if the first value is greater than or equal to the second value or `false` otherwise
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let (>=) = (x: Uint64, y: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  WasmI64.geU(xv, yv)
+}
+
+/**
+ * Computes the bitwise NOT of the given value.
+ *
+ * @param value: The given value
+ * @returns Containing the inverted bits of the given value
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let lnot = (value: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
+  let ptr = newUint64(xv ^ 0xffffffffffffffffN)
+  WasmI32.toGrain(ptr): Uint64
+}
+
+/**
+ * Computes the bitwise AND (`&`) on the given operands.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns Containing a `1` in each bit position for which the corresponding bits of both operands are `1`
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let (&) = (x: Uint64, y: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  let ptr = newUint64(xv & yv)
+  WasmI32.toGrain(ptr): Uint64
+}
+
+/**
+ * Computes the bitwise OR (`|`) on the given operands.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns Containing a `1` in each bit position for which the corresponding bits of either or both operands are `1`
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let (|) = (x: Uint64, y: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  let ptr = newUint64(xv | yv)
+  WasmI32.toGrain(ptr): Uint64
+}
+
+/**
+ * Computes the bitwise XOR (`^`) on the given operands.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns Containing a `1` in each bit position for which the corresponding bits of either but not both operands are `1`
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let (^) = (x: Uint64, y: Uint64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  let ptr = newUint64(xv ^ yv)
+  WasmI32.toGrain(ptr): Uint64
+}
+
+/**
+ * Counts the number of leading zero bits in the value.
+ *
+ * @param value: The value to inspect
+ * @returns The amount of leading zeros
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let clz = (value: Uint64) => {
+  let nv = WasmI64.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
+  let ptr = newUint64(WasmI64.clz(nv))
+  WasmI32.toGrain(ptr): Uint64
+}
+
+/**
+ * Counts the number of trailing zero bits in the value.
+ *
+ * @param value: The value to inspect
+ * @returns The amount of trailing zeros
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let ctz = (value: Uint64) => {
+  let nv = WasmI64.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
+  let ptr = newUint64(WasmI64.ctz(nv))
+  WasmI32.toGrain(ptr): Uint64
+}
+
+/**
+ * Counts the number of bits set to `1` in the value, also known as a population count.
+ *
+ * @param value: The value to inspect
+ * @returns The amount of 1-bits in its operand
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let popcnt = (value: Uint64) => {
+  let nv = WasmI64.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
+  let ptr = newUint64(WasmI64.popcnt(nv))
+  WasmI32.toGrain(ptr): Uint64
+}