🥮 mooncakes.io

    #double

    This package provides the double-precision floating-point constants (infinity, NaN and the value limits) together with the rounding helpers floor, ceil, round and trunc. Trigonometric, exponential and logarithmic functions live in @math.

    #Constants and Special Values

    The package provides several important constants and special floating-point values:

    ///|
    test "special values" {
      // Special values
      inspect(@double.infinity, content="Infinity")
      inspect(@double.neg_infinity, content="-Infinity")
      inspect(@double.not_a_number, content="NaN")

      // Limits
      inspect(@double.max_value, content="1.7976931348623157e+308")
      inspect(@double.min_value, content="-1.7976931348623157e+308")
      inspect(@double.min_positive, content="2.2250738585072014e-308")
    }

    #Basic Operations

    Basic mathematical operations and rounding functions:

    ///|
    test "basic operations" {
      // Absolute value
      inspect(Double::abs(-3.14), content="3.14")

      // Rounding functions
      inspect(Double::floor(3.7), content="3")
      inspect(Double::ceil(3.2), content="4")
      inspect(Double::round(3.5), content="4")
      inspect(Double::trunc(3.7), content="3")

      // Sign
      inspect(Double::signum(-3.14), content="-1")
      inspect(Double::signum(2.0), content="1")

      // Type conversion
      inspect(Double::from_int(42), content="42")
    }

    #Special Value Testing

    Functions for testing special floating-point values and comparing numbers:

    ///|
    test "special value testing" {
      // Testing for special values
      inspect(@double.not_a_number.is_nan(), content="true")
      inspect(@double.infinity.is_inf(), content="true")
      inspect(@double.infinity.is_pos_inf(), content="true")
      inspect(@double.neg_infinity.is_neg_inf(), content="true")

      // Approximate equality
      let relative_tolerance = 1.e-9
      inspect(Double::is_close(0.1 + 0.2, 0.3, relative_tolerance~), content="true")
    }

    #Binary Representation

    To convert doubles to their binary representation, use @buffer instead:

    ///|
    test "binary representation" {
      let num = 1.0

      // Convert to big-endian and little-endian bytes
      // Different byte orders should produce different results
      let buffer = Buffer()
      buffer.write_double_be(num)
      inspect(
        buffer.to_bytes(),
        content=(
          #|b"?\xf0\x00\x00\x00\x00\x00\x00"
        ),
      )
      buffer.reset()
      buffer.write_double_le(num)
      inspect(
        buffer.to_bytes(),
        content=(
          #|b"\x00\x00\x00\x00\x00\x00\xf0?"
        ),
      )
    }

    Note: The rounding helpers can be called either as a method (d.round()) or as a package function (@double.round(d)).

    Double

    Note

    Double is a built-in type. The documentation may not be complete here. You can find all methods and implementations in the core/builtin and core/double package.

    Double::inf

    source
    #deprecated("Use `@double.infinity` and `@double.neg_infinity` instead")
    fn Double::inf(sign : Int) -> Double

    Returns positive infinity if sign >= 0, negative infinity if sign < 0.

    Double::min_normal

    source
    #deprecated("Use `@double.min_positive` instead")
    fn Double::min_normal() -> Double

    Returns the smallest positive normal value of a double-precision floating-point number.

    Returns a Double value that represents the smallest positive normal number that can be represented by a double-precision floating-point number (approximately 2.2250738585072014e-308).

    Example:

    test {
      inspect(@double.min_positive, content="2.2250738585072014e-308")
    }

    Double::nan

    source
    #deprecated("Use `@double.not_a_number` instead")
    fn Double::nan() -> Double

    [DEPRECATED] Returns a "not-a-number" (NaN) value.

    This function is deprecated. Use @double.not_a_number instead.

    Returns a double-precision floating-point NaN value.

    Example:

    test {
      let nan = @double.not_a_number
      inspect(nan.is_nan(), content="true")
    }

    abs

    source
    #deprecated("Use `x.abs()` instead")
    fn abs(x : Double) -> Double

    Return absolute value.

    ceil

    source
    fn ceil(d : Double) -> Double

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

    Parameters:

    • self : The floating point number to find the ceiling of.

    Returns the ceiling value of the input number.

    Example:

    test {
      inspect(3.7.ceil(), content="4")
      inspect((-3.7).ceil(), content="-3")
      inspect(42.0.ceil(), content="42")
    }

    floor

    source
    fn floor(d : Double) -> Double

    Returns the largest integer less than or equal to the given number.

    Parameters:

    • number : A floating-point number to be rounded down.

    Returns a double-precision floating-point number representing the largest integer less than or equal to the input.

    Example:

    test {
      inspect(3.7.floor(), content="3")
      inspect((-3.7).floor(), content="-4")
      inspect(0.0.floor(), content="0")
    }

    from_int

    source
    #deprecated("Use `Double::from_int` instead")
    fn from_int(i : Int) -> Double

    Create from int.

    infinity

    source
    let infinity : Double

    Numeric constant infinity.

    is_close

    source
    #deprecated("Use `Double::is_close` instead")
    fn is_close(d : Double, other : Double, relative_tolerance? : Double, absolute_tolerance? : Double) -> Bool

    Return whether the value close.

    max_value

    source
    let max_value : Double

    Max value constant for this type.

    min_positive

    source
    let min_positive : Double

    Numeric constant min_positive.

    min_value

    source
    let min_value : Double

    Min value constant for this type.

    neg_infinity

    source
    let neg_infinity : Double

    Numeric constant neg_infinity.

    not_a_number

    source
    let not_a_number : Double

    Numeric constant not_a_number.

    pow

    source
    #deprecated("Use `@math.pow` instead")
    fn pow(m : Double, n : Double) -> Double

    Function pow.

    round

    source
    fn round(d : Double) -> Double

    Rounds a floating-point number to the nearest integer using "round half up" rule. In this rule, when a number is halfway between two integers (like 3.5), it is rounded up to the next integer.

    Parameters:

    • value : The floating-point number to be rounded.

    Returns the rounded value as a double-precision floating-point number.

    Example:

    test {
      inspect(3.7.round(), content="4")
      inspect(3.2.round(), content="3")
      inspect(3.5.round(), content="4")
      inspect((-3.5).round(), content="-3")
    }

    trunc

    source
    fn trunc(d : Double) -> Double

    Returns an integer value by discarding the decimal part of the floating-point number (truncation toward zero).

    Parameters:

    • self : The floating-point number to be truncated.

    Returns a floating-point number representing the integer part of the input.

    Example:

    test {
      inspect(3.7.trunc(), content="3")
      inspect((-3.7).trunc(), content="-3")
      inspect(0.0.trunc(), content="0")
    }

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io