"""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()