#Rational

The Rational type represents a rational number, which is a number that can be expressed as a fraction a/b where a and b are integers and b is not zero.

#Usage

#Arithmetic Operations

The Rational type supports the following arithmetic operations:

///|
test {
  let a = @rational.new(1L, 2L).unwrap()
  let b = @rational.new(1L, 3L).unwrap()
  assert_eq(a + b, @rational.new(5L, 6L).unwrap())
  assert_eq(a - b, @rational.new(1L, 6L).unwrap())
  assert_eq(a * b, @rational.new(1L, 6L).unwrap())
  assert_eq(a / b, @rational.new(3L, 2L).unwrap())
  assert_eq(-a, @rational.new(-1L, 2L).unwrap())
  assert_eq(a.reciprocal(), @rational.new(2L, 1L).unwrap())
  assert_eq(a.abs(), @rational.new(1L, 2L).unwrap())
}

#Comparison Operations

The Rational type supports the following comparison operations:

///|
test {
  let a = @rational.new(1L, 2L).unwrap()
  let b = @rational.new(1L, 3L).unwrap()
  assert_eq(a == b, false)
  assert_eq(a != b, true)
  assert_eq(a < b, false)
  assert_eq(a <= b, false)
  assert_eq(a > b, true)
  assert_eq(a >= b, true)
  assert_eq(Compare::compare(a, b), 1)
}

#Integer Operations

The Rational type supports the following integer operations:

///|
test {
  let a = @rational.new(1L, 2L).unwrap()
  assert_eq(a.floor(), 0)
  assert_eq(a.ceil(), 1)
  assert_eq(Show::to_string(a.fract()), "1/2")
  assert_eq(a.trunc(), 0)
  assert_eq(a.is_integer(), false)
}

#Double Operations

The Rational type supports the following double operations:

///|
test {
  let a = @rational.new(1L, 2L).unwrap()
  assert_eq(a.to_double(), 0.5)
  assert_eq(Show::to_string(@rational.from_double(0.5)), "1/2")
}

#String Operations

The Rational type supports the following string operations:

///|
test {
  let a = @rational.new(1L, 2L).unwrap()
  assert_eq(Show::to_string(a), "1/2")
}

BigRational

source

type BigRational = Rational[@moonbitlang/core/bigint.BigInt
BigInt]

Rational number type.

Invariants:

The denominator is always positive.
The numerator and denominator are always coprime.

Rational32

source

type Rational32 = Rational[Int]

Rational number type.

Invariants:

The denominator is always positive.
The numerator and denominator are always coprime.

Rational64

source

type Rational64 = Rational[Int64]

Rational number type.

Invariants:

The denominator is always positive.
The numerator and denominator are always coprime.

Integral

source

trait Integral

impl Integral for Int

fn abs(self : Int) -> Int

source

fn compare_fraction(numerator1 : Int, denominator1 : Int, numerator2 : Int, denominator2 : Int) -> Int

source

Compares two Int fractions after losslessly widening their products.

MoonBit Int is 32-bit, so every product of two Int values fits in Int64 and needs neither overflow detection nor arbitrary precision.

fn from_bigint(b : @moonbitlang/core/bigint.BigInt
BigInt) -> Int?

source

fn from_int(i : Int) -> Int

source

fn signum(self : Int) -> Int

source

fn to_bigint(self : Int) -> @moonbitlang/core/bigint.BigInt
BigInt

source

impl Integral for Int64

fn abs(self : Int64) -> Int64

source

fn compare_fraction(numerator1 : Int64, denominator1 : Int64, numerator2 : Int64, denominator2 : Int64) -> Int

source

Compares two Int64 fractions using the cheapest exact available path.

The generic comparison has already established positive denominators and equal numerator signs. Safe cross-products stay in Int64; otherwise the unsigned magnitudes use continued fractions. Comparing two negative values reverses the magnitude ordering.

fn from_bigint(b : @moonbitlang/core/bigint.BigInt
BigInt) -> Int64?

source

fn from_int(i : Int) -> Int64

source

fn signum(self : Int64) -> Int

source

fn to_bigint(self : Int64) -> @moonbitlang/core/bigint.BigInt
BigInt

source

impl Integral for BigInt

fn abs(self : @moonbitlang/core/bigint.BigInt
BigInt) -> @moonbitlang/core/bigint.BigInt
BigInt

source

fn compare_fraction(numerator1 : @moonbitlang/core/bigint.BigInt
BigInt, denominator1 : @moonbitlang/core/bigint.BigInt
BigInt, numerator2 : @moonbitlang/core/bigint.BigInt
BigInt, denominator2 : @moonbitlang/core/bigint.BigInt
BigInt) -> Int

source

Compares two BigInt fractions by exact cross-multiplication.

BigInt products do not overflow, so no fixed-width fast path or continued fraction fallback is necessary.

fn from_bigint(b : @moonbitlang/core/bigint.BigInt
BigInt) -> @moonbitlang/core/bigint.BigInt
BigInt?

source

fn from_int(i : Int) -> @moonbitlang/core/bigint.BigInt
BigInt

source

fn signum(self : @moonbitlang/core/bigint.BigInt
BigInt) -> Int

source

fn to_bigint(self : @moonbitlang/core/bigint.BigInt
BigInt) -> @moonbitlang/core/bigint.BigInt
BigInt

source

RationalError

source

pub(all) suberror RationalError {
  RationalError(String)
} derive(ToJson, @moonbitlang/core/debug.Debug
Debug)

Error type for rational number operations.

Constructor:

RationalError(String) : Error with a descriptive message.

Example:

test {
  let error = RationalError::RationalError("division by zero")
  debug_inspect(
    error,
    content=(
      #|RationalError("division by zero")
    ),
  )
}

impl Eq for RationalError

fn equal(self : RationalError, other : RationalError) -> Bool

source

Compares two RationalError values for equality.

Parameters:

self : The first RationalError to compare.
other : The second RationalError to compare.

Returns true if both RationalError values contain the same error message, false otherwise.

Example:

test {
  let error1 = @rational.RationalError("division by zero")
  let error2 = @rational.RationalError("division by zero")
  let error3 = @rational.RationalError("overflow")
  inspect(error1 == error2, content="true")
  inspect(error1 == error3, content="false")
}

RationalError::equal

source

#deprecated("`RationalError::equal` is deprecated, use `Eq::equal` instead.")
fn RationalError::equal(self : RationalError, other : RationalError) -> Bool

RationalError::not_equal

source

#deprecated("`RationalError::not_equal` is deprecated, use `Eq::not_equal` instead.")
fn RationalError::not_equal(x : RationalError, y : RationalError) -> Bool

RationalError::to_json

source

#deprecated("`RationalError::to_json` is deprecated, use `ToJson::to_json` instead.")
fn RationalError::to_json(RationalError) -> Json

RationalError::to_repr

source

#deprecated("`RationalError::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn RationalError::to_repr(RationalError) -> @moonbitlang/core/debug.Repr
Repr

Rational

source

type Rational[T] derive(Eq)

Rational number type.

Invariants:

The denominator is always positive.
The numerator and denominator are always coprime.

impl Add for Rational[T]

fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] add(self : Rational[T], other : Rational[T]) -> Rational[T]

source

NOTE: we don't check overflow here, to align with the op_add of Int64. TODO: add a checked_add method.

impl Compare for Rational[T]

fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] compare(self : Rational[T], other : Rational[T]) -> Int

source

Compares two rational numbers and returns their ordering.

Parameters:

self : The first rational number to compare.
other : The second rational number to compare.

Returns an integer indicating the relative order: negative if self is less than other, zero if they are equal, and positive if self is greater than other.

Example:

test {
  let a = @rational.new(1L, 2L).unwrap() // 1/2
  let b = @rational.new(2L, 3L).unwrap() // 2/3
  inspect(Compare::compare(a, b), content="-1") // 1/2 < 2/3
  let c = @rational.new(3L, 4L).unwrap() // 3/4
  let d = @rational.new(3L, 4L).unwrap() // 3/4
  inspect(Compare::compare(c, d), content="0") // 3/4 == 3/4
  let e = @rational.new(5L, 6L).unwrap() // 5/6
  let f = @rational.new(1L, 2L).unwrap() // 1/2
  inspect(Compare::compare(e, f), content="1") // 5/6 > 1/2
}

impl Div for Rational[T]

fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] div(self : Rational[T], other : Rational[T]) -> Rational[T]

source

Divides one rational number by another.

Parameters:

self : The dividend rational number.
other : The divisor rational number.

Returns the quotient of the division as a rational number.

Example:

test {
  let a = @rational.new(1L, 2L) // 1/2
  let b = @rational.new(2L, 3L) // 2/3
  match (a, b) {
    (Some(x), Some(y)) => {
      let result = x / y // 3/4
      inspect(result, content="3/4")
    }
    _ => ()
  }
}

impl Mul for Rational[T]

fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] mul(self : Rational[T], other : Rational[T]) -> Rational[T]

source

Multiplies two rational numbers.

Parameters:

self : The first rational number.
other : The second rational number to multiply with.

Returns the product of the two rational numbers.

Example:

test {
  let a = @rational.new(1L, 2L).unwrap() // 1/2
  let b = @rational.new(2L, 3L).unwrap() // 2/3
  let c = a * b // 1/3
  inspect(c, content="1/3")
}

impl Neg for Rational[T]

fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] neg(self : Rational[T]) -> Rational[T]

source

Returns the negation of a rational number.

Parameters:

self : The rational number to negate.

Returns a new rational number with the opposite sign.

Example:

test {
  let positive = @rational.new(3L, 4L).unwrap()
  let negative = -positive
  inspect(Show::to_string(negative), content="-3/4")
  let negative_original = @rational.new(-5L, 2L).unwrap()
  let positive_result = -negative_original
  inspect(Show::to_string(positive_result), content="5/2")
}

impl Show for Rational[T]

fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] output(self : Rational[T], logger : &Logger) -> Unit

source

Converts a rational number to its string representation.

Parameters:

self : The rational number to convert.
logger : The output logger to write the string representation to.

The string representation follows these rules:

If the numerator is zero, outputs "0"
If the denominator is 1 (i.e., the rational is an integer), outputs just the numerator
Otherwise, outputs in the format "numerator/denominator"

Example:

test {
  let zero = @rational.new(0L, 1).unwrap()
  inspect(zero, content="0")
  let integer = @rational.new(5L, 1).unwrap()
  inspect(integer, content="5")
  let fraction = @rational.new(3L, 4).unwrap()
  inspect(fraction, content="3/4")
  let negative = @rational.new(-7L, 3).unwrap()
  inspect(negative, content="-7/3")
}

impl Sub for Rational[T]

fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] sub(self : Rational[T], other : Rational[T]) -> Rational[T]

source

Subtracts one rational number from another.

Parameters:

self : The minuend (rational number to subtract from).
other : The subtrahend (rational number to subtract).

Returns the difference of the two rational numbers.

Example:

test {
  let a = @rational.new(1L, 2L).unwrap() // 1/2
  let b = @rational.new(1L, 3L).unwrap() // 1/3
  inspect(a - b, content="1/6") // 1/2 - 1/3 = 1/6
}

impl Debug for Rational[T]

impl Arbitrary for Rational[T]

fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] arbitrary(size : Int, rs : @moonbitlang/core/quickcheck/splitmix.RandomState
RandomState) -> Rational[T]

source

Rational::abs

source

#as_free_fn
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::abs(self : Rational[T]) -> Rational[T]

Returns the absolute value of a rational number.

Parameters:

self : The rational number to get the absolute value of.

Returns a new rational number representing the absolute value of the input.

Example:

test {
  let positive = @rational.new(3L, 4L).unwrap()
  let negative = @rational.new(-3L, 4L).unwrap()
  inspect(positive.abs(), content="3/4")
  inspect(negative.abs(), content="3/4")
}

Rational::add

source

#deprecated("`Rational::add` is deprecated, use `Add::add` instead.")
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::add(self : Rational[T], other : Rational[T]) -> Rational[T]

Rational::arbitrary

source

#deprecated("`Rational::arbitrary` is deprecated, use `@moonbitlang/core/quickcheck.Arbitrary::arbitrary` instead.")
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::arbitrary(size : Int, rs : @moonbitlang/core/quickcheck/splitmix.RandomState
RandomState) -> Rational[T]

Rational::ceil

source

#as_free_fn
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::ceil(self : Rational[T]) -> T

Returns the smallest integer greater than or equal to the rational number.

Parameters:

self : The rational number to ceiling.

Returns the ceiling of the rational number as a value of type T.

Example:

test {
  let r1 = @rational.new(3L, 2L).unwrap() // 3/2 = 1.5
  inspect(r1.ceil(), content="2")
  let r2 = @rational.new(-3L, 2L).unwrap() // -3/2 = -1.5
  inspect(r2.ceil(), content="-1")
  let r3 = @rational.new(4L, 2L).unwrap() // 4/2 = 2.0
  inspect(r3.ceil(), content="2")
}

Rational::compare

source

#deprecated("`Rational::compare` is deprecated, use `Compare::compare` instead.")
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::compare(self : Rational[T], other : Rational[T]) -> Int

Rational::denominator

source

fn[T] Rational::denominator(self : Rational[T]) -> T

Returns the denominator of this rational number.

Rational::div

source

#deprecated("`Rational::div` is deprecated, use `Div::div` instead.")
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::div(self : Rational[T], other : Rational[T]) -> Rational[T]

Rational::div_checked

source

#as_free_fn
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::div_checked(self : Rational[T], other : Rational[T]) -> Rational[T] raise RationalError

Divides one rational number by another, raising an error when the divisor is zero.

Parameters:

self : The dividend rational number.
other : The divisor rational number.

Returns the quotient of the division as a rational number.

Raises RationalError("division by zero") if other is zero.

Example:

test {
  let a = @rational.new(1L, 2L)
  let b = @rational.new(2L, 3L)
  match (a, b) {
    (Some(x), Some(y)) => {
      let result = x.div_checked(y)
      inspect(result, content="3/4")
    }
    _ => ()
  }
}

Rational::equal

source

#deprecated("`Rational::equal` is deprecated, use `Eq::equal` instead.")
fn[T : Eq] Rational::equal(Rational[T], Rational[T]) -> Bool

Rational::floor

source

#as_free_fn
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::floor(self : Rational[T]) -> T

Computes the largest integer that is less than or equal to the rational number.

Parameters:

self : The rational number to floor.

Returns the largest value of type T that is less than or equal to self.

Example:

test {
  let r1 = @rational.new(7L, 3L).unwrap() // 7/3 ≈ 2.33
  inspect(r1.floor(), content="2")
  let r2 = @rational.new(-7L, 3L).unwrap() // -7/3 ≈ -2.33
  inspect(r2.floor(), content="-3")
  let r3 = @rational.new(6L, 3L).unwrap() // 6/3 = 2.0
  inspect(r3.floor(), content="2")
}

Rational::fract

source

#as_free_fn
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::fract(self : Rational[T]) -> Rational[T]

Returns the fractional part of a rational number, which is the remainder after removing the integer part.

Parameters:

self : The rational number to get the fractional part from.

Returns a new rational number representing the fractional part of self. This is equivalent to self - self.trunc().

Example:

test {
  let r1 = @rational.new(7L, 2L).unwrap() // 7/2 = 3.5
  inspect(r1.fract(), content="1/2") // fractional part is 0.5 = 1/2
  let r2 = @rational.new(-7L, 2L).unwrap() // -7/2 = -3.5  
  inspect(r2.fract(), content="-1/2") // fractional part is -0.5 = -1/2
  let r3 = @rational.new(5L, 1L).unwrap() // 5/1 = 5
  inspect(r3.fract(), content="0") // fractional part is 0
}

Rational::is_integer

source

#as_free_fn
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::is_integer(self : Rational[T]) -> Bool

Checks whether the rational number represents an integer value.

Parameters:

self : The rational number to check.

Returns true if the rational number is an integer (has a denominator of 1), false otherwise.

Examples:

test {
  let half = @rational.new(1L, 2L).unwrap()
  inspect(half.is_integer(), content="false")
  let whole = @rational.new(5L, 1L).unwrap()
  inspect(whole.is_integer(), content="true")
  let zero = @rational.new(0L, 1L).unwrap()
  inspect(zero.is_integer(), content="true")
}

Rational::mul

source

#deprecated("`Rational::mul` is deprecated, use `Mul::mul` instead.")
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::mul(self : Rational[T], other : Rational[T]) -> Rational[T]

Rational::neg

source

#deprecated("`Rational::neg` is deprecated, use `Neg::neg` instead.")
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::neg(self : Rational[T]) -> Rational[T]

Rational::not_equal

source

#deprecated("`Rational::not_equal` is deprecated, use `Eq::not_equal` instead.")
fn[T : Eq] Rational::not_equal(x : Rational[T], y : Rational[T]) -> Bool

Rational::numerator

source

fn[T] Rational::numerator(self : Rational[T]) -> T

Returns the numerator of this rational number.

Rational::op_ge

source

#deprecated("`Rational::op_ge` is deprecated, use `Compare::op_ge` instead.")
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::op_ge(x : Rational[T], y : Rational[T]) -> Bool

Rational::op_gt

source

#deprecated("`Rational::op_gt` is deprecated, use `Compare::op_gt` instead.")
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::op_gt(x : Rational[T], y : Rational[T]) -> Bool

Rational::op_le

source

#deprecated("`Rational::op_le` is deprecated, use `Compare::op_le` instead.")
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::op_le(x : Rational[T], y : Rational[T]) -> Bool

Rational::op_lt

source

#deprecated("`Rational::op_lt` is deprecated, use `Compare::op_lt` instead.")
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::op_lt(x : Rational[T], y : Rational[T]) -> Bool

Rational::output

source

#deprecated("`Rational::output` is deprecated, use `Show::output` instead.")
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::output(self : Rational[T], logger : &Logger) -> Unit

Rational::reciprocal

source

#as_free_fn
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::reciprocal(self : Rational[T]) -> Rational[T]

Returns the multiplicative inverse of a rational number.

Parameters:

self : The rational number to find the reciprocal of.

Returns a new rational number that is the reciprocal of the input.

Example:

test {
  let half = @rational.new(1L, 2L).unwrap()
  let two = half.reciprocal()
  inspect(two, content="2")
  let negative_third = @rational.new(-1L, 3L).unwrap()
  let negative_three = negative_third.reciprocal()
  inspect(negative_three, content="-3")
}

Rational::reciprocal_checked

source

#as_free_fn
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::reciprocal_checked(self : Rational[T]) -> Rational[T] raise RationalError

Returns the multiplicative inverse of a rational number, raising an error when the rational number is zero.

Parameters:

self : The rational number to find the reciprocal of.

Returns a new rational number that is the reciprocal of the input.

Raises RationalError("reciprocal of zero") if self is zero.

Example:

test {
  let half = @rational.new(1L, 2L).unwrap()
  let two = half.reciprocal_checked()
  inspect(two, content="2")
}

Rational::sub

source

#deprecated("`Rational::sub` is deprecated, use `Sub::sub` instead.")
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::sub(self : Rational[T], other : Rational[T]) -> Rational[T]

Rational::to_double

source

fn Rational::to_double(self : Rational[Int64]) -> Double

Converts the rational number to its approximate double-precision floating-point representation.

Parameters:

self : The rational number to convert.

Returns the double-precision floating-point approximation of the rational number.

Example:

test {
  let rational = @rational.new(1L, 2L).unwrap()
  inspect(rational.to_double(), content="0.5")
  let negative = @rational.new(-3L, 4L).unwrap()
  inspect(negative.to_double(), content="-0.75")
}

Rational::to_repr

source

#deprecated("`Rational::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::to_repr(self : Rational[T]) -> @moonbitlang/core/debug.Repr
Repr

Rational::to_string

source

#deprecated("`Rational::to_string` is deprecated, use `Show::to_string` instead.")
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::to_string(self : Rational[T]) -> String

Rational::trunc

source

#as_free_fn
fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] Rational::trunc(self : Rational[T]) -> T

Truncates a rational number towards zero, returning the integer part.

Parameters:

self : The rational number to truncate.

Returns the integer part of the rational number as a value of type T.

Example:

test {
  let a = @rational.new(7L, 3L).unwrap() // 7/3 = 2.333...
  inspect(a.trunc(), content="2")
  let b = @rational.new(-7L, 3L).unwrap() // -7/3 = -2.333...
  inspect(b.trunc(), content="-2")
  let c = @rational.new(5L, 2L).unwrap() // 5/2 = 2.5
  inspect(c.trunc(), content="2")
  let d = @rational.new(-5L, 2L).unwrap() // -5/2 = -2.5
  inspect(d.trunc(), content="-2")
}

from_double

source

fn from_double(value : Double) -> Rational[Int64] raise RationalError

Converts a floating-point number to its rational representation using a continued fraction algorithm.

Parameters:

value : The double-precision floating-point number to convert to a rational.

Returns a rational number that approximates the input value.

Throws an error of type RationalError if the input is NaN or if the conversion would result in integer overflow.

Example:

test {
  // Convert 0.5 to rational 1/2
  let half = @rational.from_double(0.5)
  inspect(half, content="1/2")

  // Convert 0.333... to a close rational approximation
  let third = @rational.from_double(1.0 / 3.0)
  inspect(third, content="1/3")
}

new

source

fn[T : Integral + Add + Sub + Mul + Div + Neg + Mod + Show + Eq + Compare + @moonbitlang/core/quickcheck.Arbitrary
Arbitrary] new(numerator : T, denominator : T) -> Rational[T]?

Creates a rational number from the given numerator and denominator.

Parameters:

numerator : The numerator of the rational number.
denominator : The denominator of the rational number.

Returns Some(rational) if the denominator is non-zero and the reduced form fits in T, where the rational number is automatically reduced to its simplest form with a positive denominator. Returns None if the denominator is zero, or if the reduced form cannot be represented in T (e.g. its denominator is 2^63 for Rational[Int64]).

Example:

test {
  // Create 3/4
  let r1 = @rational.new(3L, 4L).unwrap()
  inspect(r1, content="3/4")

  // Create -1/2 (negative numerator)
  let r2 = @rational.new(-1L, 2L).unwrap()
  inspect(r2, content="-1/2")

  // Create -1/2 (negative denominator gets normalized)
  let r3 = @rational.new(1L, -2L).unwrap()
  inspect(r3, content="-1/2")

  // Create 1/2 (double negatives cancel out)
  let r4 = @rational.new(-1L, -2L).unwrap()
  inspect(r4, content="1/2")

  // Automatic reduction to simplest form
  let r5 = @rational.new(6L, 9L).unwrap()
  inspect(r5, content="2/3")

  // Division by zero returns None
  let r6 = @rational.new(1L, 0L)
  assert_true(r6 is None)
}

Source Files

Site source Report issue Packages Build queue Skills Statistics

#Rational

#Usage

#Arithmetic Operations

#Comparison Operations

#Integer Operations

#Double Operations

#String Operations

#BigRational

#Rational32

#Rational64

#Integral

#RationalError

#RationalError::equal

#RationalError::not_equal

#RationalError::to_json

#RationalError::to_repr

#Rational

#Rational::abs

#Rational::add

#Rational::arbitrary

#Rational::ceil

#Rational::compare

#Rational::denominator

#Rational::div

#Rational::div_checked

#Rational::equal

#Rational::floor

#Rational::fract

#Rational::is_integer

#Rational::mul

#Rational::neg

#Rational::not_equal

#Rational::numerator

#Rational::op_ge

#Rational::op_gt

#Rational::op_le

#Rational::op_lt

#Rational::output

#Rational::reciprocal

#Rational::reciprocal_checked

#Rational::sub

#Rational::to_double

#Rational::to_repr

#Rational::to_string

#Rational::trunc

#from_double

#new

Source Files

BigRational

Rational32

Rational64

Integral

RationalError

RationalError::equal

RationalError::not_equal

RationalError::to_json

RationalError::to_repr

Rational

Rational::abs

Rational::add

Rational::arbitrary

Rational::ceil

Rational::compare

Rational::denominator

Rational::div

Rational::div_checked

Rational::equal

Rational::floor

Rational::fract

Rational::is_integer

Rational::mul

Rational::neg

Rational::not_equal

Rational::numerator

Rational::op_ge

Rational::op_gt

Rational::op_le

Rational::op_lt

Rational::output

Rational::reciprocal

Rational::reciprocal_checked

Rational::sub

Rational::to_double

Rational::to_repr

Rational::to_string

Rational::trunc

from_double

new