Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-std

Source of release 0.7.4

0.7.4 / tests / math_contracts / main.lucb

## Math special values and all four host rounding directions (reference.c sets them), and
## mod and remainder against the reference rows under each.
import c
from luce_std import files, math, math32
import memory
import os
import remainders
import strings

extern func math_environment_begin()
extern func math_environment_round(mode: i32)
extern func math_environment_check()
extern func math_exceptions_clear()
extern func math_invalid_raised() -> i32
extern func math_environment_end()

## Representation checks include signaling NaNs without arithmetic on them.
func check64(mode: i32):
    let positive_zero = f64.bits(0)
    let negative_zero = f64.bits(9223372036854775808)
    let positive_infinity = f64.bits(9218868437227405312)
    let negative_infinity = f64.bits(18442240474082181120)
    let signaling_nan = f64.bits(9218868437227405313)
    math_exceptions_clear()
    assert(math.is_nan(signaling_nan))
    assert(not math.is_finite(signaling_nan) and not math.is_infinite(signaling_nan))
    assert(math.abs(signaling_nan).bits() == 9218868437227405313)
    assert(math.copysign(signaling_nan, negative_zero).bits() == 18442240474082181121)
    assert(math_invalid_raised() == 0)
    assert(math.signbit(negative_zero) and not math.signbit(positive_zero))
    assert(math.min(positive_zero, negative_zero).bits() == 9223372036854775808)
    assert(math.max(negative_zero, positive_zero).bits() == 0)
    assert(math.is_nan(math.min(math.nan, (f64)1)))
    assert(math.is_nan(math.max((f64)1, math.nan)))
    assert(math.hypot(positive_infinity, math.nan) == positive_infinity)
    assert(math.pow(math.nan, (f64)0) == (f64)1)
    assert(math.pow((f64)1, math.nan) == (f64)1)
    assert(math.is_nan(math.pow((f64)-1, (f64)0.5)))
    assert(math.is_nan(math.sqrt((f64)-1)))
    assert(math.sqrt(negative_zero).bits() == 9223372036854775808)
    assert(math.cbrt(negative_infinity) == negative_infinity)
    assert(math.exp(negative_infinity).bits() == 0)
    assert(math.exp2(negative_infinity).bits() == 0)
    assert(math.expm1(negative_infinity) == (f64)-1)
    assert(math.log(positive_zero) == negative_infinity)
    assert(math.log2(negative_zero) == negative_infinity)
    assert(math.log10(positive_infinity) == positive_infinity)
    assert(math.log1p((f64)-1) == negative_infinity)
    assert(math.is_nan(math.log1p((f64)-2)))
    assert(math.is_nan(math.sin(positive_infinity)))
    assert(math.is_nan(math.cos(negative_infinity)))
    assert(math.is_nan(math.tan(positive_infinity)))
    assert(math.is_nan(math.asin((f64)2)))
    assert(math.is_nan(math.acos((f64)-2)))
    assert(math.tanh(positive_infinity) == (f64)1)
    assert(math.tanh(negative_infinity) == (f64)-1)
    assert(math.atan2(negative_zero, (f64)1).bits() == 9223372036854775808)
    # Pi is irrational; directed rounding may choose its adjacent value.
    let positive_angle = math.atan2(positive_zero, (f64)-1)
    let negative_angle = math.atan2(negative_zero, (f64)-1)
    assert(not math.signbit(positive_angle) and math.signbit(negative_angle))
    for bits in [math.abs(positive_angle).bits(), math.abs(negative_angle).bits()]:
        let expected = math.pi.bits()
        let distance = bits - expected if bits >= expected else expected - bits
        assert(distance <= 1)
    assert(math.remainder((f64)5, (f64)2) == (f64)1)
    assert(math.remainder((f64)7, (f64)2) == (f64)-1)
    assert(math.remainder((f64)-4, (f64)2).bits() == 9223372036854775808)
    assert(math.is_nan(math.mod((f64)1, positive_zero)))
    assert(math.is_nan(math.remainder(positive_infinity, (f64)1)))
    assert(math.next_up(negative_zero).bits() == 1)
    assert(math.next_down(positive_zero).bits() == 9223372036854775809)
    assert(math.next_up(f64.bits(9218868437227405311)) == positive_infinity)
    assert(math.next_down(positive_infinity).bits() == 9218868437227405311)
    assert(math.nextafter(positive_zero, negative_zero).bits() == 9223372036854775808)
    let decomposed = math.frexp(negative_zero)
    assert(decomposed.0.bits() == 9223372036854775808 and decomposed.1 == 0)
    let infinite_parts = math.modf(negative_infinity)
    assert(infinite_parts.0.bits() == 9223372036854775808 and infinite_parts.1 == negative_infinity)
    let nan_parts = math.modf(math.nan)
    assert(math.is_nan(nan_parts.0) and math.is_nan(nan_parts.1))
    let parts = math.modf((f64)-1.75)
    assert(parts.0 == (f64)-0.75 and parts.1 == (f64)-1)
    let samples: u64[6] = [1, 4503599627370496, 4607182418800017409, 9218868437227405311, 9223372036854775809, 13830554455654793216]
    for bits in samples:
        let value = f64.bits(bits)
        let pair = math.frexp(value)
        assert(math.abs(pair.0) >= (f64)0.5 and math.abs(pair.0) < (f64)1)
        assert(math.scalbn(pair.0, pair.1).bits() == bits)
    assert(math.floor((f64)-2.5) == (f64)-3)
    assert(math.ceil((f64)-2.5) == (f64)-2)
    assert(math.round((f64)-2.5) == (f64)-3)
    assert(math.trunc((f64)-2.5) == (f64)-2)
    assert(math.floor(negative_zero).bits() == 9223372036854775808)
    assert(math.ceil(negative_zero).bits() == 9223372036854775808)
    assert(math.round(negative_zero).bits() == 9223372036854775808)
    assert(math.trunc(negative_zero).bits() == 9223372036854775808)
    # Halfway addition and underflow distinguish every directed rounding mode.
    let fused = math.fma((f64)1, (f64)1, f64.bits(4368491638549381120))
    assert(fused.bits() == (4607182418800017409 if mode == 2 else 4607182418800017408))
    let negative_fused = math.fma((f64)-1, (f64)1, f64.bits(13591863675404156928))
    assert(negative_fused.bits() == (13830554455654793217 if mode == 1 else 13830554455654793216))
    assert(math.scalbn(f64.bits(1), -1).bits() == (1 if mode == 2 else 0))
    assert(math.scalbn(f64.bits(9223372036854775809), -1).bits() == (9223372036854775809 if mode == 1 else 9223372036854775808))
    let square_root = math.sqrt((f64)2)
    assert(square_root.bits() == (4609047870845172685 if mode == 0 else 4609047870845172685 if mode == 2 else 4609047870845172684))
    math_environment_check()

## Representation checks include signaling NaNs without arithmetic on them.
func check32(mode: i32):
    let positive_zero = f32.bits(0)
    let negative_zero = f32.bits(2147483648)
    let positive_infinity = f32.bits(2139095040)
    let negative_infinity = f32.bits(4286578688)
    let signaling_nan = f32.bits(2139095041)
    math_exceptions_clear()
    assert(math32.is_nan(signaling_nan))
    assert(not math32.is_finite(signaling_nan) and not math32.is_infinite(signaling_nan))
    assert(math32.abs(signaling_nan).bits() == 2139095041)
    assert(math32.copysign(signaling_nan, negative_zero).bits() == 4286578689)
    assert(math_invalid_raised() == 0)
    assert(math32.signbit(negative_zero) and not math32.signbit(positive_zero))
    assert(math32.min(positive_zero, negative_zero).bits() == 2147483648)
    assert(math32.max(negative_zero, positive_zero).bits() == 0)
    assert(math32.is_nan(math32.min(math32.nan, (f32)1)))
    assert(math32.is_nan(math32.max((f32)1, math32.nan)))
    assert(math32.hypot(positive_infinity, math32.nan) == positive_infinity)
    assert(math32.pow(math32.nan, (f32)0) == (f32)1)
    assert(math32.pow((f32)1, math32.nan) == (f32)1)
    assert(math32.is_nan(math32.pow((f32)-1, (f32)0.5)))
    assert(math32.is_nan(math32.sqrt((f32)-1)))
    assert(math32.sqrt(negative_zero).bits() == 2147483648)
    assert(math32.cbrt(negative_infinity) == negative_infinity)
    assert(math32.exp(negative_infinity).bits() == 0)
    assert(math32.exp2(negative_infinity).bits() == 0)
    assert(math32.expm1(negative_infinity) == (f32)-1)
    assert(math32.log(positive_zero) == negative_infinity)
    assert(math32.log2(negative_zero) == negative_infinity)
    assert(math32.log10(positive_infinity) == positive_infinity)
    assert(math32.log1p((f32)-1) == negative_infinity)
    assert(math32.is_nan(math32.log1p((f32)-2)))
    assert(math32.is_nan(math32.sin(positive_infinity)))
    assert(math32.is_nan(math32.cos(negative_infinity)))
    assert(math32.is_nan(math32.tan(positive_infinity)))
    assert(math32.is_nan(math32.asin((f32)2)))
    assert(math32.is_nan(math32.acos((f32)-2)))
    assert(math32.tanh(positive_infinity) == (f32)1)
    assert(math32.tanh(negative_infinity) == (f32)-1)
    assert(math32.atan2(negative_zero, (f32)1).bits() == 2147483648)
    # Pi is irrational; directed rounding may choose its adjacent value.
    let positive_angle = math32.atan2(positive_zero, (f32)-1)
    let negative_angle = math32.atan2(negative_zero, (f32)-1)
    assert(not math32.signbit(positive_angle) and math32.signbit(negative_angle))
    for bits in [math32.abs(positive_angle).bits(), math32.abs(negative_angle).bits()]:
        let expected = math32.pi.bits()
        let distance = bits - expected if bits >= expected else expected - bits
        assert(distance <= 1)
    assert(math32.remainder((f32)5, (f32)2) == (f32)1)
    assert(math32.remainder((f32)7, (f32)2) == (f32)-1)
    assert(math32.remainder((f32)-4, (f32)2).bits() == 2147483648)
    assert(math32.is_nan(math32.mod((f32)1, positive_zero)))
    assert(math32.is_nan(math32.remainder(positive_infinity, (f32)1)))
    assert(math32.next_up(negative_zero).bits() == 1)
    assert(math32.next_down(positive_zero).bits() == 2147483649)
    assert(math32.next_up(f32.bits(2139095039)) == positive_infinity)
    assert(math32.next_down(positive_infinity).bits() == 2139095039)
    assert(math32.nextafter(positive_zero, negative_zero).bits() == 2147483648)
    let decomposed = math32.frexp(negative_zero)
    assert(decomposed.0.bits() == 2147483648 and decomposed.1 == 0)
    let infinite_parts = math32.modf(negative_infinity)
    assert(infinite_parts.0.bits() == 2147483648 and infinite_parts.1 == negative_infinity)
    let nan_parts = math32.modf(math32.nan)
    assert(math32.is_nan(nan_parts.0) and math32.is_nan(nan_parts.1))
    let parts = math32.modf((f32)-1.75)
    assert(parts.0 == (f32)-0.75 and parts.1 == (f32)-1)
    let samples: u32[6] = [1, 8388608, 1065353217, 2139095039, 2147483649, 3212836864]
    for bits in samples:
        let value = f32.bits(bits)
        let pair = math32.frexp(value)
        assert(math32.abs(pair.0) >= (f32)0.5 and math32.abs(pair.0) < (f32)1)
        assert(math32.scalbn(pair.0, pair.1).bits() == bits)
    assert(math32.floor((f32)-2.5) == (f32)-3)
    assert(math32.ceil((f32)-2.5) == (f32)-2)
    assert(math32.round((f32)-2.5) == (f32)-3)
    assert(math32.trunc((f32)-2.5) == (f32)-2)
    assert(math32.floor(negative_zero).bits() == 2147483648)
    assert(math32.ceil(negative_zero).bits() == 2147483648)
    assert(math32.round(negative_zero).bits() == 2147483648)
    assert(math32.trunc(negative_zero).bits() == 2147483648)
    # Halfway addition and underflow distinguish every directed rounding mode.
    let fused = math32.fma((f32)1, (f32)1, f32.bits(864026624))
    assert(fused.bits() == (1065353217 if mode == 2 else 1065353216))
    let negative_fused = math32.fma((f32)-1, (f32)1, f32.bits(3011510272))
    assert(negative_fused.bits() == (3212836865 if mode == 1 else 3212836864))
    assert(math32.scalbn(f32.bits(1), -1).bits() == (1 if mode == 2 else 0))
    assert(math32.scalbn(f32.bits(2147483649), -1).bits() == (2147483649 if mode == 1 else 2147483648))
    let square_root = math32.sqrt((f32)2)
    assert(square_root.bits() == (1068827891 if mode == 0 else 1068827892 if mode == 2 else 1068827891))
    math_environment_check()

func check_remainders(corpus: const u8[], mode: i32):
    var position: usize = 0
    assert(corpus.length % 32 == 0)
    while position < corpus.length:
        let operation = memory.read[u32](corpus.data + position)
        let width = memory.read[u32](corpus.data + position + 4)
        let x = memory.read[u64](corpus.data + position + 8)
        let y = memory.read[u64](corpus.data + position + 16)
        let expected = memory.read[u64](corpus.data + position + 24)
        var actual: u64 = 0
        if width == 32:
            let left = f32.bits((u32)x)
            let right = f32.bits((u32)y)
            actual = (u64)(math32.mod(left, right).bits() if operation == 1 else math32.remainder(left, right).bits())
        else:
            assert(width == 64)
            let left = f64.bits(x)
            let right = f64.bits(y)
            actual = math.mod(left, right).bits() if operation == 1 else math.remainder(left, right).bits()
        if actual != expected:
            print(f"remainder reference row {position // 32}, mode {mode}, actual {actual}, expected {expected}")
            trap("a remainder changed under directed rounding")
        position += 32

pub func main(arguments: c.str[]) -> i32!:
    _ = arguments
    # the reference rows are math_accuracy's, beside this program's directory
    let here = os.env("LUC_TEST_DIR") else "tests/math_contracts"
    let csv = try strings.join([here, "/../math_accuracy/reference.csv"], "")
    defer strings.release(csv)
    let text = try files.read((c.str)csv)
    defer text.release()
    let corpus = try remainders.corpus((str)text.value)
    defer free(corpus) in memory.heap
    math_environment_begin()
    defer math_environment_end()
    for mode in 0..<4:
        math_environment_round((i32)mode)
        check64((i32)mode)
        check32((i32)mode)
        check_remainders(corpus, (i32)mode)
    print("ok math exceptional values and rounding directions")
    return 0