Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-std

Source of release 0.7.0

0.7.0 / tools / math_reference.py

#!/usr/bin/env python3
"""Regenerate offline math vectors with mpmath 1.3.0 (not needed by the gate).

Inputs are exact IEEE values. Evaluate at 500 and 800 decimal digits and require
identical nearest-even binary rounding; fused arithmetic uses 1100/1300 digits.
This is independent of host libm, but agreement at two precisions is evidence,
not a proof that an arbitrary-precision implementation cannot contain defects.
"""
import csv
from pathlib import Path
import random
import struct

import mpmath as mp

assert mp.__version__ == "1.3.0", "use the pinned reference generator version"
ROOT = Path(__file__).resolve().parents[1]
OPERATIONS = "floor ceil round trunc sqrt cbrt hypot mod pow exp exp2 log log2 log10 log1p expm1 fma sin cos tan asin acos atan atan2 sinh cosh tanh remainder".split()
EXACT = {"floor", "ceil", "round", "trunc", "sqrt", "mod", "remainder", "fma"}


def encode(value, width):
    return int.from_bytes(struct.pack("<f" if width == 32 else "<d", value), "little")


def decode(bits, width):
    return struct.unpack("<f" if width == 32 else "<d", bits.to_bytes(width // 8, "little"))[0]


def rounded_bits(value, width, negative_zero=False):
    precision, bias = (24, 127) if width == 32 else (53, 1023)
    sign_bit = 1 << (width - 1)
    infinity = ((bias * 2 + 1) << (precision - 1))
    if mp.isnan(value):
        return infinity | (1 << (precision - 2))
    if mp.isinf(value):
        return infinity | (sign_bit if value < 0 else 0)
    sign, mantissa, exponent, bit_count = value._mpf_
    if not mantissa:
        return sign_bit if negative_zero else 0
    encoded_sign = sign_bit if sign else 0
    top = exponent + bit_count - 1
    if top > bias:
        return encoded_sign | infinity
    quantum = max(top, 1 - bias) - (precision - 1)
    shift = quantum - exponent
    if shift > 0:
        significand, remainder = divmod(mantissa, 1 << shift)
        half = 1 << (shift - 1)
        if remainder > half or (remainder == half and significand & 1):
            significand += 1
    else:
        significand = mantissa << -shift
    if significand == 1 << precision:
        significand >>= 1
        top += 1
    if top > bias:
        return encoded_sign | infinity
    if significand < 1 << (precision - 1):
        return encoded_sign | significand
    return encoded_sign | ((max(top, 1 - bias) + bias) << (precision - 1)) | (significand - (1 << (precision - 1)))


def trunc(value):
    return mp.ceil(value) if value < 0 else mp.floor(value)


def evaluate(operation, values):
    x, y, z = values
    if operation == "trunc": return trunc(x)
    if operation == "round": return mp.sign(x) * mp.floor(abs(x) + mp.mpf("0.5"))
    if operation == "cbrt": return mp.sign(x) * mp.root(abs(x), 3)
    if operation == "hypot": return mp.sqrt(x*x + y*y)
    if operation == "mod": return x - trunc(x/y)*y
    if operation == "remainder": return x - mp.nint(x/y)*y
    if operation == "pow": return mp.power(x, y)
    if operation == "exp2": return mp.power(2, x)
    if operation == "log2": return mp.log(x, 2)
    if operation == "log10": return mp.log10(x)
    if operation == "fma": return x*y + z
    if operation == "atan2": return mp.atan2(x, y)
    return getattr(mp, operation)(x)


def reference(operation, bits, width, precision):
    with mp.workdps(precision):
        values = [mp.mpf(decode(value, width)) for value in bits]
        answer = evaluate(operation, values)
        if isinstance(answer, mp.mpc):
            assert answer.imag != 0
            answer = mp.nan
        # mpmath has one zero. Restore the IEEE signs for exact-zero results of
        # the operations whose sign is determined by their first argument.
        negative_zero = bool(bits[0] >> (width - 1)) and operation in {
            "floor", "ceil", "round", "trunc", "sqrt", "cbrt", "mod", "remainder",
            "log1p", "expm1", "sin", "tan", "asin", "atan", "sinh", "tanh"}
        return rounded_bits(answer, width, negative_zero)


rows = []
randomizer = random.Random(5601)
for width in (32, 64):
    precision, bias = (24, 127) if width == 32 else (53, 1023)
    infinity = (bias * 2 + 1) << (precision - 1)
    one = bias << (precision - 1)
    minimum_normal = 1 << (precision - 1)
    general = [0, 1, 2, 3, minimum_normal-1, minimum_normal, minimum_normal+1,
               one-1, one, one+1, infinity-1]
    general += [randomizer.randrange(1, infinity) for _ in range(35)]
    general += [value | (1 << (width - 1)) for value in general]
    ordinary = [-1000, -745, -710, -104, -88, -20, -2, -1, -0.75, -0.5, -0.1,
                -2**-24, -2**-54, 0, 2**-54, 2**-24, 0.1, 0.5, 0.75, 1, 2, 20, 88, 104, 710]
    for operation in OPERATIONS:
        candidates = [(bits, encode(1.5, width), encode(-0.5, width)) for bits in general]
        if operation in {"exp", "exp2", "expm1", "sinh", "cosh", "tanh"}:
            candidates = [(encode(value, width), 0, 0) for value in ordinary]
        elif operation in {"asin", "acos"}:
            candidates += [(encode(value, width), 0, 0) for value in ordinary if -1 <= value <= 1]
        elif operation == "log1p":
            candidates = [row for row in candidates if decode(row[0], width) >= -1]
            candidates += [(encode(value, width), 0, 0) for value in ordinary if value >= -1]
        elif operation == "pow":
            candidates = [(encode(x, width), encode(y, width), 0)
                          for x in (0.1, 0.5, 0.999, 1, 1.001, 2, 10, 100)
                          for y in (-20, -2, -0.5, 0, 0.5, 2, 20)]
            candidates += [(encode(x, width), encode(y, width), 0)
                           for x in (-10, -2, -0.5) for y in (-3, -2, 2, 3)]
        elif operation in {"hypot", "mod", "remainder", "fma", "atan2"}:
            for _ in range(50):
                a, b, c = (randomizer.choice(general) for _ in range(3))
                if decode(b, width) != 0 and (operation != "atan2" or decode(a, width) != 0):
                    candidates.append((a, b, c))
            if operation == "fma":
                candidates += [(one+1, one-1, encode(-1, width)),
                               (infinity-1, encode(2, width), (infinity-1) | (1 << (width-1)))]
            if operation == "atan2":
                candidates = [row for row in candidates if decode(row[0], width) != 0]
        for bits in sorted(set(candidates)):
            precisions = (1100, 1300) if operation in {"fma", "mod", "remainder"} else (500, 800)
            expected = reference(operation, bits, width, precisions[0])
            checked = reference(operation, bits, width, precisions[1])
            assert expected == checked, (operation, width, bits, expected, checked)
            rows.append([operation, width, *[f"{value:0{width//4}x}" for value in bits],
                         f"{expected:0{width//4}x}", 0 if operation in EXACT else 4])
output = ROOT / "tests/programs/math_accuracy/reference.csv"
with output.open("w", newline="") as target:
    writer = csv.writer(target, lineterminator="\n")
    writer.writerow(["operation", "width", "x_bits", "y_bits", "z_bits", "result_bits", "ulp_limit"])
    writer.writerows(rows)
print(f"wrote {output.relative_to(ROOT)} ({len(rows)} vectors)")