Qyxo-Zhaenivoth-Guard / source /tests /test_compact.py
PureOne's picture
Publish Qyxo-Zhaenivoth Guard v1.0.0 research release
25c6e75 verified
Raw History Blame Contribute Delete
12.7 kB
"""Independent precision-locality and strict-array tests for CompactDynamicBank."""
from fractions import Fraction
import importlib.util
from itertools import product
import math
import unittest
from qzguard import CompactDynamicBank
DynamicBank = CompactDynamicBank
def rat(value):
return Fraction.from_float(float(value))
def dyad(integer, exponent):
return Fraction(integer << exponent) if exponent >= 0 else Fraction(integer, 1 << -exponent)
def ratio_vertices(lower, upper, values, base_n=0, base_d=0):
for choices in product((0, 1), repeat=len(values)):
weights = [rat((lower, upper)[bit][i]) for i, bit in enumerate(choices)]
numerator = rat(base_n)+sum((w*rat(v) for w, v in zip(weights, values)), Fraction(0))
denominator = rat(base_d)+sum(weights, Fraction(0))
if denominator <= 0:
raise AssertionError("nonpositive oracle denominator")
yield numerator/denominator, numerator, denominator
def tree_state(tree):
return tuple(tree.mass), tuple(tree.moment), tuple(tree.node_exponent)
def unique_trees(bank):
return tuple({id(tree): tree for tree in bank._lowtrees+bank._hightrees}.values())
class AdaptiveDyadicHostileTests(unittest.TestCase):
def compare_vertices(self, bank, lower, upper, values, base_n=0, base_d=0):
points = tuple(ratio_vertices(lower, upper, values, base_n, base_d))
bounds = bank.enclose()
self.assertEqual(bounds.lower, (min(x[0] for x in points),))
self.assertEqual(bounds.upper, (max(x[0] for x in points),))
for threshold in (0, -1, .5, math.nextafter(0., math.inf)):
t = rat(threshold)
for relation in ("<=", ">="):
result = bank.query(threshold, relation=relation)
expected = all(ratio <= t if relation == "<=" else ratio >= t
for ratio, _, _ in points)
supports = tuple(n-t*d for _, n, d in points)
support = max(supports) if relation == "<=" else min(supports)
self.assertEqual(result.guaranteed, (expected,))
self.assertEqual(result.support, (support,))
def test_new_subnormal_exponent_touches_only_update_path_and_recovers_nodes(self):
rows = 16
values = list(range(rows))
lower, upper = [1]*rows, [2]*rows
bank = DynamicBank(values, lower, upper)
self.assertEqual(bank.mass_exponent, 0)
tree = bank._lowtrees[0]
before = tree_state(tree)
tiny = math.nextafter(0., math.inf)
row = 0
path = []
i = tree.positions[row]+1
while i <= rows:
path.append(i)
i += i & -i
before_nodes = bank.cumulative_stats.update_nodes
bank.update([row], [0], [tiny])
self.assertEqual(bank.mass_exponent, -1074)
self.assertEqual(bank.cumulative_stats.update_nodes-before_nodes, len(path))
for j in range(1, rows+1):
if j not in path:
self.assertEqual((tree.mass[j], tree.moment[j], tree.node_exponent[j]),
(before[0][j], before[1][j], before[2][j]))
self.assertEqual((tree.mass[1], tree.moment[1], tree.node_exponent[1]),
(1, 0, -1074))
lower[row], upper[row] = 0, tiny
expected = sum(rat(l)*rat(v) for l, v in zip(lower, values))
expected += sum((rat(u)-rat(l))*max(rat(v), Fraction(0))
for l, u, v in zip(lower, upper, values))
self.assertEqual(bank.query(0).support, (expected,))
# Reads align temporary values; they must not rewrite off-path storage.
after_patch = tree_state(tree)
bank.query(.25)
bank.enclose()
self.assertEqual(tree_state(tree), after_patch)
bank.update([row], [tiny], [tiny])
self.assertEqual((tree.mass[1], tree.moment[1], tree.node_exponent[1]),
(0, 0, 0))
bank.update([row], [1], [2])
self.assertEqual(bank.mass_exponent, -1074) # historical global scale
self.assertEqual(tree_state(tree), before) # local compactness recovers
def test_unchanged_spread_patch_shifts_only_baselines_and_totals(self):
values = [[-1, 2], [3, -1], [0, 4]]
bank = DynamicBank(values, [1, 1, 1], [2, 2, 2],
base_numerator=[-2, 1], base_denominator=1)
trees = unique_trees(bank)
before_states = tuple(tree_state(tree) for tree in trees)
before_nodes = bank.cumulative_stats.update_nodes
bank.update([0], [.5], [1.5]) # U-L remains exactly one
self.assertEqual(bank.mass_exponent, -1)
self.assertEqual(bank.cumulative_stats.update_nodes, before_nodes)
self.assertEqual(tuple(tree_state(tree) for tree in trees), before_states)
for c, base_n in enumerate((-2, 1)):
points = tuple(ratio_vertices([.5, 1, 1], [1.5, 2, 2],
[row[c] for row in values], base_n, 1))
result = bank.query([.25, -.25])
t = rat((.25, -.25)[c])
self.assertEqual(result.support[c], max(n-t*d for _, n, d in points))
def test_arrivals_removals_and_maximum_products_match_vertex_oracle(self):
import sys
tiny, huge = math.nextafter(0., math.inf), sys.float_info.max
values = [tiny, huge, -huge]
lower, upper = [1, 1, 1], [1, 1, 1]
bank = DynamicBank(values, lower, upper, base_numerator=1,
base_denominator=1)
self.compare_vertices(bank, lower, upper, values, 1, 1)
sequence = [([0], [tiny], [tiny]),
([1, 2], [huge, huge], [huge, huge]),
([0], [1], [1]),
([1, 2], [1, 1], [1, 1])]
for indices, lows, highs in sequence:
retained = bank.query(0)
old = retained.support, retained.guaranteed
bank.update(indices, lows, highs)
for i, lo, hi in zip(indices, lows, highs):
lower[i], upper[i] = lo, hi
self.compare_vertices(bank, lower, upper, values, 1, 1)
self.assertEqual((retained.support, retained.guaranteed), old)
def test_invalid_lower_exponent_patch_preserves_every_representation(self):
tiny = math.nextafter(0., math.inf)
bank = DynamicBank([0, 1], [1, 1], [2, 2])
def state():
return (bank.mass_exponent, bank.revision, bank.mass_lower,
bank.mass_upper, bank._sumL, bank._sumU, bank._Di,
tuple(bank._Alo), tuple(bank._Ahi),
tuple((tree.exponent, tree.total_mass, tree.total_moment,
tree_state(tree)) for tree in unique_trees(bank)))
before = state()
for indices, lo, hi in (([0, 1], [tiny, -1], [tiny, 2]),
([0, 1], [0, 0], [tiny, 2]),
([0, 0], [tiny, 1], [tiny, 2])):
with self.assertRaises(ValueError):
bank.update(indices, lo, hi)
self.assertEqual(state(), before)
with self.assertRaises(ValueError):
bank.query(0, total_mass=tiny)
self.assertEqual(state(), before)
def test_finer_fixed_total_query_is_temporary_even_after_actual_scale_change(self):
tiny = math.nextafter(0., math.inf)
bank = DynamicBank([-2, 5], [0, 0], [1, 1], base_denominator=1)
before_e = bank.mass_exponent
before_nodes = tuple(tree_state(tree) for tree in unique_trees(bank))
for total in (tiny, .25, 1.5, 2):
minimum_weight = max(Fraction(0), rat(total)-1)
maximum_weight = min(Fraction(1), rat(total))
denominator = 1+rat(total)
expected_lower = (-2*maximum_weight+5*(rat(total)-maximum_weight))/denominator
expected_upper = (-2*minimum_weight+5*(rat(total)-minimum_weight))/denominator
bounds = bank.enclose(total_mass=total)
self.assertEqual(bounds.lower, (expected_lower,))
self.assertEqual(bounds.upper, (expected_upper,))
self.assertEqual(bank.query(0, total_mass=total).support,
(expected_upper*denominator,))
self.assertEqual(bank.mass_exponent, before_e)
self.assertEqual(tuple(tree_state(tree) for tree in unique_trees(bank)),
before_nodes)
bank.update([0], [0], [2*tiny])
self.assertEqual(bank.mass_exponent, -1073)
before_nodes = tuple(tree_state(tree) for tree in unique_trees(bank))
bounds = bank.enclose(total_mass=tiny)
self.assertEqual(bounds.lower, (-2*rat(tiny)/(1+rat(tiny)),))
self.assertEqual(bounds.upper, (5*rat(tiny)/(1+rat(tiny)),))
self.assertEqual(bank.mass_exponent, -1073)
self.assertEqual(tuple(tree_state(tree) for tree in unique_trees(bank)),
before_nodes)
def test_tiny_signed_base_is_representable_at_initial_ordinary_mass_scale(self):
tiny = math.nextafter(0., math.inf)
for base_n in (tiny, -tiny):
bank = DynamicBank([1], [1], [2], base_numerator=base_n,
base_denominator=1)
self.assertEqual(bank.mass_exponent, 0)
self.compare_vertices(bank, [1], [2], [1], base_n, 1)
def test_canonical_fast_branches_cover_sign_cancellation_zero_and_large_exponents(self):
from array import array
tiny = math.nextafter(0., math.inf)
bank = DynamicBank([-2, 2], [0, 0], [1, 1], base_denominator=1)
tree = bank._lowtrees[0]
original = tree_state(tree)
self.assertIsInstance(tree.node_exponent, array)
self.assertEqual(tree.node_exponent.typecode, "h")
self.assertEqual((tree.mass[2], tree.moment[2], tree.node_exponent[2]),
(1, 0, 1))
bank.update([0], [0], [2])
self.compare_vertices(bank, [0, 0], [2, 1], [-2, 2], 0, 1)
bank.update([0], [0], [1])
self.assertEqual(tree_state(tree), original)
bank.update([0], [0], [0])
self.assertEqual((tree.mass[1], tree.moment[1], tree.node_exponent[1]),
(0, 0, 0))
bank.update([0], [0], [tiny])
self.assertEqual((tree.mass[1], tree.moment[1], tree.node_exponent[1]),
(1, -2, -1074))
self.compare_vertices(bank, [0, 0], [tiny, 1], [-2, 2], 0, 1)
bank.update([0], [0], [0])
self.assertEqual((tree.mass[1], tree.moment[1], tree.node_exponent[1]),
(0, 0, 0))
bank.update([0], [0], [1])
self.assertEqual(tree_state(tree), original)
huge_power = math.ldexp(1., 1023)
wide = DynamicBank([0]*16, [0]*16, [huge_power]*16,
base_denominator=1)
widest = wide._lowtrees[0]
self.assertEqual(widest.node_exponent[16], 1027)
self.assertEqual(wide.query(0).support, (Fraction(0),))
wide.update([15], [0], [0])
self.assertEqual(wide.enclose().lower, (Fraction(0),))
wide.update([15], [0], [huge_power])
self.assertEqual(widest.node_exponent[16], 1027)
@unittest.skipUnless(importlib.util.find_spec("numpy") is not None,
"optional NumPy backend is not installed")
class AdaptiveNumpyBoundaryTests(unittest.TestCase):
def test_zero_dimensional_boolean_string_and_object_wrappers_are_rejected(self):
import numpy as np
for wrapped in (np.array(True), np.array("1"),
np.array(True, dtype=object), np.array("1", dtype=object)):
with self.subTest(dtype=str(wrapped.dtype)):
with self.assertRaises(ValueError):
DynamicBank([wrapped], [1], [2])
bank = DynamicBank([[0, 1]], [1], [2])
with self.assertRaises(ValueError):
bank.query(wrapped)
with self.assertRaises(ValueError):
bank.update([0], [wrapped], [2])
with self.assertRaises(ValueError):
bank.query(0, total_mass=wrapped)
def test_one_element_array_is_a_vector_and_zero_dimensional_real_is_scalar(self):
import numpy as np
bank = DynamicBank([[0, 1]], [1], [2])
with self.assertRaises(ValueError):
bank.query(np.array([.5]))
scalar = bank.query(np.array(.5))
vector = bank.query(np.array([.5, .5]))
self.assertEqual(scalar.support, vector.support)
self.assertEqual(scalar.guaranteed, vector.guaranteed)
if __name__ == "__main__":
unittest.main()