#MoonBit Float Package Documentation

• self : A floating-point number.

test {
  inspect((1.5 : Float).abs(), content="1.5")
  inspect((-1.5 : Float).abs(), content="1.5")
  inspect((0.0 : Float).abs(), content="0")
  inspect((-0.0 : Float).abs(), content="0")
  inspect(@float.not_a_number.abs().is_nan(), content="true")
}

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

test {
  inspect((1.5 : Float).ceil(), content="2")
  inspect((1.0 : Float).ceil(), content="1")
  inspect((-1.5 : Float).ceil(), content="-1")
}

• self : The value to clamp.
• min : The lower bound of the range.
• max : The upper bound of the range.

test {
  inspect((0.5 : Float).clamp(min=0.0, max=1.0), content="0.5")
  inspect((-1.0 : Float).clamp(min=0.0, max=1.0), content="0")
  inspect((2.0 : Float).clamp(min=0.0, max=1.0), content="1")
}

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

test {
  inspect((1.7 : Float).floor(), content="1")
  inspect((-1.7 : Float).floor(), content="-2")
  inspect((2.0 : Float).floor(), content="2")
}

• byte : The byte value to be converted to a float.

test {
  let b = b'\xFF' // 255 in decimal
  let f = Float::from_byte(b)
  // `Float` implements `Show`, so `f` could also be inspected directly
  inspect(f.to_double(), content="255")
}

• value : The double-precision floating-point number to be converted.

test {
  let d = 3.14159265359
  inspect(Float::from_double(d).to_double(), content="3.1415927410125732") // Note the loss of precision
}

• number : The integer value to be converted to a floating-point number.

test {
  let n = 42
  let f = Float::from_int(n)
  // `Float` implements `Show`, so `f` could also be inspected directly
  inspect(f.to_double(), content="42")
}

• self : The 64-bit integer value to be converted.

test {
  let n = 42L
  let f = Float::from_int64(n)
  // `Float` implements `Show`, so `f` could also be inspected directly
  inspect(f.to_double(), content="42")
}

• self : The unsigned 32-bit integer to be converted.

test {
  let n = 42U
  inspect(Float::from_uint(n).to_double(), content="42")
  let big = 16777216U // 2^24
  inspect(Float::from_uint(big).to_double(), content="16777216") // Last precisely representable integer
}

• self : The unsigned 64-bit integer to be converted.

test {
  let n = 42UL
  inspect(Float::from_uint64(n).to_double(), content="42")
  let big = 18446744073709551615UL // UInt64::max_value
  inspect(Float::from_uint64(big).to_double(), content="18446744073709552000")
}

• self : The first floating-point number to compare.
• other : The second floating-point number to compare.
• relative_tolerance : The relative tolerance for the comparison. Must be non-negative. Defaults to 1e-9.
• absolute_tolerance : The absolute tolerance for the comparison. Must be non-negative. Defaults to 0.0.

test {
  let x = 1.0
  let y = 1.000000001
  inspect(x.is_close(y), content="false")
  inspect(x.is_close(y, relative_tolerance=1.0e-10), content="false")
  inspect(@float.infinity.is_close(@float.infinity), content="true")
}

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

test {
  inspect(@float.infinity.is_inf(), content="true")
  inspect(@float.neg_infinity.is_inf(), content="true")
  inspect((1.0 : Float).is_inf(), content="false")
}

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

test {
  inspect(@float.not_a_number.is_nan(), content="true")
  inspect((1.0 : Float).is_nan(), content="false")
  inspect(@float.infinity.is_nan(), content="false")
}

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

test {
  inspect(@float.neg_infinity.is_neg_inf(), content="true")
  inspect((1.0 : Float).is_neg_inf(), content="false")
  inspect(@float.infinity.is_neg_inf(), content="false")
}

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

test {
  inspect(@float.infinity.is_pos_inf(), content="true")
  inspect((1.0 : Float).is_pos_inf(), content="false")
  inspect(@float.neg_infinity.is_pos_inf(), content="false")
}

• self : The start value.
• target : The end value.
• t : The interpolation factor.

test {
  inspect((0.0 : Float).lerp(target=10.0, t=0.25), content="2.5")
  inspect((5.0 : Float).lerp(target=15.0, t=0.0), content="5")
  inspect((5.0 : Float).lerp(target=15.0, t=1.0), content="15")
}

• base : The base number to be raised to a power.
• exponent : The power to which the base number is raised.

test {
  inspect(@math.powf(2.0, 3.0), content="8")
  inspect(@math.powf(4.0, 0.5), content="2")
  inspect(@math.powf(1.0, -1.0), content="1")
}

• self : The 32-bit floating-point number whose bits are to be reinterpreted.

test {
  let f = Float::from_double(1.0)
  // IEEE 754 representation of 1.0 is 0x3F800000
  inspect(f.reinterpret_as_int(), content="1065353216")
}

• float : The 32-bit floating-point number whose bits are to be reinterpreted.

test {
  let x : Float = 1.0
  inspect(x.reinterpret_as_uint(), content="1065353216") // Decimal representation of 0x3F800000
}

• self : The 32-bit integer whose bits are to be reinterpreted as a single-precision floating-point number.

test {
  // 0x3F800000 represents 1.0 in IEEE 754 single-precision format
  let n = 1065353216 // 0x3F800000
  inspect(Float::reinterpret_from_int(n), content="1")
}

• self : The unsigned 32-bit integer whose bits are to be reinterpreted as a single-precision floating-point number.

test {
  let n = 0x3F800000U // Bit pattern for 1.0f
  inspect(Float::reinterpret_from_uint(n), content="1")
}

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

test {
  inspect((2.3 : Float).round(), content="2")
  inspect((2.5 : Float).round(), content="3")
  inspect((-2.5 : Float).round(), content="-2")
}

• If the float is positive, returns 1.0.
• If the float is negative, returns -1.0.
• Otherwise, returns the float itself (0.0, -0.0 and NaN).

• self : The floating-point number whose square root is to be calculated.

• For a positive number, returns its principal square root
• For zero (positive or negative), returns zero with the same sign
• For NaN or negative numbers, returns NaN

test {
  let x = Float::from_double(16.0)
  let root = x.sqrt()
  inspect(root.to_double(), content="4")
  let neg = Float::from_double(-4.0)
  let neg_root = neg.sqrt()
  inspect(neg_root.to_double(), content="NaN")
}

• float : The floating-point number to be converted.

test {
  let x : Float = 1.0
  inspect(
    x.to_be_bytes(),
    content=(
      #|b"?\x80\x00\x00"
    ),
  )
}

• self : The 32-bit floating-point number to be converted.

test {
  let f = Float::from_double(3.14)
  inspect(f.to_double(), content="3.140000104904175")
}

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

• 0 for @float.not_a_number (NaN),
• @int.MAX_VALUE (2147483647) for values greater than @int.MAX_VALUE,
• @int.MIN_VALUE (-2147483648) for values less than @int.MIN_VALUE.
• truncated (towards zero) integer value for other cases.

test {
  inspect((1.5 : Float).to_int(), content="1")
  inspect((-1.5 : Float).to_int(), content="-1")
  inspect(@float.not_a_number.to_int(), content="0")
  inspect(@float.infinity.to_int(), content="2147483647")
  inspect(@float.neg_infinity.to_int(), content="-2147483648")
}

• float : The floating-point number to be converted.

test {
  let f : Float = 1.0
  let bytes = f.to_le_bytes()
  inspect(bytes.length(), content="4")
}

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

• Returns 0.0 (with the same sign as input) for values between -1.0 and 1.0
• Returns the input unchanged for integer values or values too large to have fractional parts
• Returns the integer part for other values

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

Arguments

• self - The starting value of the range (inclusive).
• end - The ending value of the range (exclusive by default).
• step - The step size of the range (default 1.0).
• inclusive - Whether the ending value is inclusive (default false).

Returns