rational.gr

/**
 * Utilities for working with the Rational type.
 * @example from "rational" include Rational
 *
 * @example 1/2r
 * @example 3/4r
 *
 * @since v0.6.0
 */
module Rational

from "runtime/unsafe/wasmi32" include WasmI32
from "runtime/exception" include Exception
from "runtime/numbers" include Numbers
use Numbers.{
  coerceNumberToRational as fromNumber,
  coerceRationalToNumber as toNumber,
  rationalNumerator as numerator,
  rationalDenominator as denominator,
  addSubRational,
  timesDivideRational,
  rationalsEqual,
  cmpRationals,
  isInteger,
}

provide { fromNumber, toNumber, numerator, denominator }

/**
 * Gets the numerator and denominator of the rational.
 *
 * @param x: The rational to split
 * @returns The numerator and denominator of the rational
 *
 * @example Rational.toIntegerRatio(1/2r) == (1, 2)
 * @example Rational.toIntegerRatio(2/8r) == (1, 4)
 *
 * @since v0.6.0
 */
provide let toIntegerRatio = x => {
  (numerator(x), denominator(x))
}

/**
 * Creates a rational from a numerator and denominator.
 *
 * @param numerator: The numerator
 * @param denominator: The denominator
 * @returns The reduced rational
 *
 * @throws InvalidArgument(String): If the numerator is not an integer
 * @throws InvalidArgument(String): If the denominator is not an integer
 *
 * @example Rational.fromIntegerRatio(1, 2) == 1/2r
 * @example Rational.fromIntegerRatio(2, 8) == 1/4r
 *
 * @since v0.6.0
 */
@unsafe
provide let fromIntegerRatio = (numerator: Number, denominator: Number) => {
  let numeratorptr = WasmI32.fromGrain(numerator)
  let denominatorptr = WasmI32.fromGrain(denominator)
  if (!isInteger(numeratorptr)) {
    throw Exception.InvalidArgument("Numerator must be an integer")
  }
  if (!isInteger(denominatorptr)) {
    throw Exception.InvalidArgument("Denominator must be an integer")
  }
  fromNumber(numerator / denominator)
}

/**
 * Computes the sum of its operands.
 *
 * @param x: The first operand
 * @param y: The second operand
 * @returns The sum of the two operands
 *
 * @example
 * use Rational.{ (+) }
 * assert 1/2r + 1/4r == 3/4r
 *
 * @since v0.6.0
 */
@unsafe
provide let (+) = (x: Rational, y: Rational) => {
  let xptr = WasmI32.fromGrain(x)
  let yptr = WasmI32.fromGrain(y)
  let ptr = addSubRational(xptr, yptr, false, true)
  WasmI32.toGrain(ptr): Rational
}

/**
 * Computes the difference of its operands.
 *
 * @param x: The first operand
 * @param y: The second operand
 * @returns The difference of the two operands
 *
 * @example
 * use Rational.{ (-) }
 * assert 1/2r - 1/4r == 1/4r
 *
 * @since v0.6.0
 */
@unsafe
provide let (-) = (x: Rational, y: Rational) => {
  let xptr = WasmI32.fromGrain(x)
  let yptr = WasmI32.fromGrain(y)
  let ptr = addSubRational(xptr, yptr, true, true)
  WasmI32.toGrain(ptr): Rational
}

/**
 * Computes the product of its operands.
 *
 * @param x: The first operand
 * @param y: The second operand
 * @returns The product of the two operands
 *
 * @example
 * use Rational.{ (*) }
 * assert 1/2r * 1/4r == 1/8r
 *
 * @since v0.6.0
 */
@unsafe
provide let (*) = (x: Rational, y: Rational) => {
  let xptr = WasmI32.fromGrain(x)
  let yptr = WasmI32.fromGrain(y)
  let ptr = timesDivideRational(xptr, yptr, false, true)
  WasmI32.toGrain(ptr): Rational
}

/**
 * Computes the quotient of its operands.
 *
 * @param x: The first operand
 * @param y: The second operand
 * @returns The quotient of the two operands
 *
 * @example
 * use Rational.{ (/) }
 * assert 1/2r / 1/4r == 2/1r
 *
 * @since v0.6.0
 */
@unsafe
provide let (/) = (x: Rational, y: Rational) => {
  let xptr = WasmI32.fromGrain(x)
  let yptr = WasmI32.fromGrain(y)
  let ptr = timesDivideRational(xptr, yptr, true, true)
  WasmI32.toGrain(ptr): Rational
}

/**
 * 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
 *
 * @example
 * use Rational.{ (==) }
 * assert 1/2r == 1/2r
 *
 * @since v0.6.0
 */
@unsafe
provide let (==) = (x: Rational, y: Rational) => {
  let x = WasmI32.fromGrain(x)
  let y = WasmI32.fromGrain(y)
  rationalsEqual(x, y)
}

/**
 * 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
 *
 * @example
 * use Rational.{ (!=) }
 * assert 1/2r != 1/4r
 *
 * @since v0.6.0
 */
@unsafe
provide let (!=) = (x: Rational, y: Rational) => {
  let x = WasmI32.fromGrain(x)
  let y = WasmI32.fromGrain(y)
  !rationalsEqual(x, y)
}

/**
 * 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
 *
 * @example
 * use Rational.{ (<) }
 * assert 1/4r < 1/2r
 *
 * @since v0.6.0
 */
@unsafe
provide let (<) = (x: Rational, y: Rational) => {
  use WasmI32.{ (<) }
  let x = WasmI32.fromGrain(x)
  let y = WasmI32.fromGrain(y)
  cmpRationals(x, y) < 0n
}

/**
 * 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
 *
 * @example
 * use Rational.{ (>) }
 * assert 1/2r > 1/4r
 *
 * @since v0.6.0
 */
@unsafe
provide let (>) = (x: Rational, y: Rational) => {
  use WasmI32.{ (>) }
  let x = WasmI32.fromGrain(x)
  let y = WasmI32.fromGrain(y)
  cmpRationals(x, y) > 0n
}

/**
 * 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
 *
 * @example
 * use Rational.{ (<=) }
 * assert 1/4r <= 1/2r
 * @example
 * use Rational.{ (<=) }
 * assert 1/2r <= 1/2r
 *
 * @since v0.6.0
 */
@unsafe
provide let (<=) = (x: Rational, y: Rational) => {
  use WasmI32.{ (<=) }
  let x = WasmI32.fromGrain(x)
  let y = WasmI32.fromGrain(y)
  cmpRationals(x, y) <= 0n
}

/**
 * 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
 *
 * @example
 * use Rational.{ (>=) }
 * assert 1/2r >= 1/4r
 * @example
 * use Rational.{ (>=) }
 * assert 1/2r >= 1/2r
 *
 * @since v0.6.0
 */
@unsafe
provide let (>=) = (x: Rational, y: Rational) => {
  use WasmI32.{ (>=) }
  let x = WasmI32.fromGrain(x)
  let y = WasmI32.fromGrain(y)
  cmpRationals(x, y) >= 0n
}