dymokomi/luce-std
Source of release 0.7.0
0.7.0 / tests / programs / math_contracts / main.lucb
import c
import files
import math
import math32
import memory
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!:
let corpus_file = try files.read(arguments[1])
defer corpus_file.release()
let corpus = corpus_file.value
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