pocketpy/tests/930_deterministic_float.py

import math
import pkpy

config = pkpy.configmacros
if config["PK_ENABLE_DETERMINISM"] == 0:
    exit(0)
    
def assertEqual(a, b):
    if a == b:
        return
    print(f'{a} != {b} ({a-b})')
    raise AssertionError

# test constants
assertEqual(math.pi, 3.14159265358979323846)
assertEqual(math.e, 2.7182818284590452354)
assert math.inf, math.inf
assert math.nan != math.nan

# test ceil
assert math.ceil(math.pi) == 4
assert math.ceil(-math.e) == -2

# test floor
assert math.floor(math.pi) == 3
assert math.floor(-math.e) == -3

# test trunc
assert math.trunc(-math.e) == -2
assert math.trunc(3.999) == 3

# test fabs
assertEqual(math.fabs(math.pi), 3.14159265358979323846)
assertEqual(math.fabs(-math.pi), 3.14159265358979323846)

# test gcd
assertEqual(math.gcd(10, 5), 5)
assertEqual(math.gcd(10, 6), 2)
assertEqual(math.gcd(10, 7), 1)
assertEqual(math.gcd(10, 10), 10)
assertEqual(math.gcd(-10, 10), 10)

# test isfinite, isinf, isnan
assertEqual(math.isfinite(math.pi), True)
assertEqual(math.isfinite(math.inf), False)
assertEqual(math.isfinite(math.nan), False)
assertEqual(math.isinf(math.pi), False)
assertEqual(math.isinf(math.inf), True)
assertEqual(math.isinf(math.nan), False)
assertEqual(math.isnan(math.pi), False)
assertEqual(math.isnan(math.inf), False)
assertEqual(math.isnan(math.nan), True)

# test exp
assertEqual(math.exp(0), 1.0)
assertEqual(math.exp(1), math.e)
assertEqual(math.exp(1.5), 4.48168907033806362960604019463)
assertEqual(math.exp(3), 20.0855369231876608182574273087)
assertEqual(math.exp(-3), 0.04978706836786396527916309651)
assertEqual(math.exp(-2.253647), 0.1050155336754953 - 1.387778780781446e-17)
assertEqual(math.exp(4.729036), 113.186398052200445363268954679)

# test log series
assertEqual(math.log(0), -math.inf)
assertEqual(math.log(1), 0.0)
assertEqual(math.log(2), 0.69314718055994530942)
assertEqual(math.log(math.e), 1.0)
assertEqual(math.log(10), 2.30258509299404545700440394284)
assertEqual(math.log(28.897124), 3.363742074595449)
assertEqual(math.log2(math.e), 1.4426950408889634074)
assertEqual(math.log2(78.781291), 6.299781153677818)
assertEqual(math.log10(math.e), 0.43429448190325182765)
assertEqual(math.log10(56.907822), 1.755171964426069 + 4.440892098500626e-16)

# test pow
assertEqual(math.pow(2,2), 4.0)
assertEqual(math.pow(1.41421356237309504880, 2), 2.0 + 4.440892098500626e-16)
assertEqual(math.pow(0.70710678118654752440, 2), 0.5000000000000001)
assertEqual(math.pow(-1.255782,-3), -0.5049603042167915)
assertEqual(math.pow(6.127042, 4.071529), 1604.40754645674428502388764172)

# test sqrt
# these match CPython bit-for-bit (hardware sqrt is correctly rounded, see dmath_sqrt)
assertEqual(math.sqrt(2), 1.4142135623730951)
assertEqual(math.sqrt(math.pi), 1.7724538509055159)
assertEqual(math.sqrt(125.872509), 11.21929182257062)
assertEqual(math.sqrt(1225.296280), 35.00423231553579)
assertEqual(math.sqrt(0.1), 0.31622776601683794)
assertEqual(math.sqrt(1e300), 1e150)
assertEqual(math.sqrt(1.7976931348623157e308), 1.3407807929942596e154)
# subnormal inputs
assertEqual(math.sqrt(1e-320), 9.99994433575849e-161)
assertEqual(math.sqrt(5e-324), 2.2227587494850775e-162)
# perfect squares must be exact, the old exp/log based sqrt gave sqrt(9) == 2.9999999999999996
for i in range(2000):
    assertEqual(math.sqrt(i * i), float(i))
# special values
assertEqual(math.sqrt(math.inf), math.inf)
assertEqual(math.copysign(1.0, math.sqrt(0.0)), 1.0)
assertEqual(math.copysign(1.0, math.sqrt(-0.0)), -1.0)
assert math.isnan(math.sqrt(-1))
assert math.isnan(math.sqrt(-math.inf))
assert math.isnan(math.sqrt(math.nan))

# test cbrt
# cbrt is not required by IEEE 754 to be correctly rounded, so unlike sqrt there is
# no hardware instruction to lean on; these come from the musl port in dmath_zig.c.
# The cases marked below differ from CPython's math.cbrt by 1 ulp on Windows, where
# it is the musl port that is correctly rounded and the platform CRT that is not.
assertEqual(math.cbrt(2), 1.2599210498948732)  # CPython/msvc gives 1.259921049894873
assertEqual(math.cbrt(3), 1.4422495703074083)
assertEqual(math.cbrt(10), 2.154434690031884)
assertEqual(math.cbrt(0.1), 0.4641588833612779)  # CPython/msvc gives 0.464158883361278
assertEqual(math.cbrt(125.872509), 5.011606490362725)
assertEqual(math.cbrt(1225.296280), 10.700737364388822)
assertEqual(math.cbrt(1e300), 1e100)
assertEqual(math.cbrt(1.7976931348623157e308), 5.643803094122362e102)
# negative inputs, which the old dmath_pow based cbrt returned nan for
assertEqual(math.cbrt(-8.0), -2.0)
assertEqual(math.cbrt(-0.5), -0.7937005259840998)  # CPython/msvc gives -0.7937005259840997
assertEqual(math.cbrt(-1000.0), -10.0)
assertEqual(math.cbrt(-1e300), -1e100)
# subnormal inputs, which the old cbrt got wrong by orders of magnitude
# because dmath_log2 does not normalize them: cbrt(5e-324) came out as 2.2323972485981933e-103
assertEqual(math.cbrt(5e-324), 1.7031839360032603e-108)
assertEqual(math.cbrt(-5e-324), -1.7031839360032603e-108)
assertEqual(math.cbrt(1e-320), 2.1544266950262728e-107)  # CPython/msvc gives 2.154426695026273e-107
assertEqual(math.cbrt(2.2250738585072014e-308), 2.812644285236262e-103)  # CPython/msvc gives 2.8126442852362615e-103
# perfect cubes must be exact; the old cbrt got 1800 of these 2000 wrong,
# e.g. cbrt(27) == 2.9999999999999996 and cbrt(8) == 1.9999999999999998
for i in range(2000):
    assertEqual(math.cbrt(i * i * i), float(i))
    assertEqual(math.cbrt(-(i * i * i)), -float(i))
# special values
assertEqual(math.cbrt(math.inf), math.inf)
assertEqual(math.cbrt(-math.inf), -math.inf)
assertEqual(math.copysign(1.0, math.cbrt(0.0)), 1.0)
assertEqual(math.copysign(1.0, math.cbrt(-0.0)), -1.0)
assert math.isnan(math.cbrt(math.nan))

# test cos, sin, tan
assertEqual(math.cos(0), 1.0)
assertEqual(math.cos(math.pi/2), 6.123233995736766e-17)
assertEqual(math.cos(math.pi), -1.0)
assertEqual(math.cos(-11.352808), 0.3496839289707818 - 5.551115123125783e-17)
assertEqual(math.cos(7.294708), 0.530570640518482)
assertEqual(math.sin(0), 0.0)
assertEqual(math.sin(math.pi/2), 1.0)
assertEqual(math.sin(math.pi), 1.224646799147353e-16 + 2.465190328815662e-32)
assertEqual(math.sin(-2.837592), -0.2993398018896187)
assertEqual(math.sin(9.294782), 0.1296301374714747)
assertEqual(math.tan(0), 0.0)
assertEqual(math.tan(math.pi/2), 1.633123935319537e+16)
assertEqual(math.tan(math.pi), -1.224646799147353e-16 - 2.465190328815662e-32)
assertEqual(math.tan(-4.812975), 9.908188146466314)
assertEqual(math.tan(1.875814), -3.176189742032396 - 4.440892098500626e-16)

# test acos, asin, atan
# these match CPython bit-for-bit (ported from Zig, see src/common/dmath_zig.c)
assertEqual(math.acos(0), 1.5707963267948966)
assertEqual(math.acos(1), 0.0)
assertEqual(math.acos(-0.758293), 2.4314869951218965)
assertEqual(math.acos(0.024758), 1.546035796825635)
assertEqual(math.asin(0), 0.0)
assertEqual(math.asin(1), 1.5707963267948966)
assertEqual(math.asin(-0.225895), -0.22786168657739128)
assertEqual(math.asin(0.955658), 1.2718861958194234)
assertEqual(math.atan(0), 0.0)
assertEqual(math.atan(1), 0.7853981633974483)
assertEqual(math.atan(-3.758927), -1.3107852846106174)
assertEqual(math.atan(35.789293), 1.542862277280122)

# test atan2
assertEqual(math.atan2(math.pi/4, math.pi/4), 0.7853981633974483)
assertEqual(math.atan2(-math.pi/4, math.pi/4), -0.7853981633974483)
assertEqual(math.atan2(-math.pi/4, -math.pi/4), -2.356194490192345)
assertEqual(math.atan2(math.pi/4, -math.pi/4), 2.356194490192345)
assertEqual(math.atan2(1.573823, 0.685329), 1.160103682924653)
assertEqual(math.atan2(-0.899663, 0.668972), -0.9314162757114095)
assertEqual(math.atan2(-0.762894, -0.126497), -1.7351133471732965)
assertEqual(math.atan2(0.468463, -0.992734), 2.7006834106923736)

# near-vertical vectors used to hit a NaN in the old atan (ratio >= 2^26),
# which silently turned into direction index 0 for callers
assertEqual(math.atan2(1.0, 1e-8), 1.5707963167948966)
assertEqual(math.atan2(1.0, 1e-12), 1.5707963267938967)
assertEqual(math.atan2(-3.5, 1e-15), -1.5707963267948963)

# test fsum, sum
fsum_sin = math.fsum([math.sin(i) for i in range(5000)])
fsum_cos = math.fsum([math.cos(i) for i in range(5000, 9999)])
assertEqual(fsum_sin, 1.267667771014267 + 2.220446049250313e-16)
assertEqual(fsum_cos, 1.949547793618193 - 4.440892098500626e-16)
assertEqual(fsum_sin + fsum_cos, 3.21721556463246)
sum_sin = sum([math.sin(i) for i in range(5000)])
sum_cos = sum([math.cos(i) for i in range(5000, 9999)])
assertEqual(sum_sin, 1.267667771014264 - 2.220446049250313e-16)
assertEqual(sum_cos, 1.949547793618197 - 4.440892098500626e-16)
assertEqual(sum_sin + sum_cos, 3.21721556463246 + 4.440892098500626e-16)

# test fmod
assertEqual(math.fmod(-2.0, 3.0), -2.0)
assertEqual(math.fmod(2.0, 3.0), 2.0)
assertEqual(math.fmod(4.0, 3.0), 1.0)
assertEqual(math.fmod(-4.0, 3.0), -1.0)

# test modf
x, y = math.modf(math.pi)
assertEqual(x, 0.14159265358979323846 - 1.110223024625157e-16)
assertEqual(y, 3.0)

x, y = math.modf(-math.e)
assertEqual(x, -0.7182818284590451)
assertEqual(y, -2.0)

# test factorial
assertEqual(math.factorial(0), 1)
assertEqual(math.factorial(1), 1)
assertEqual(math.factorial(2), 2)
assertEqual(math.factorial(3), 6)
assertEqual(math.factorial(4), 24)
assertEqual(math.factorial(5), 120)