Download source/tests/test_compact.py from PureOne/Qyxo-Zhaenivoth-Guard: direct link, hf CLI and curl.
- Browser
- Download file 12.7 kB
-
https://huggingface.co/datasets/PureOne/Qyxo-Zhaenivoth-Guard/resolve/main/source/tests/test_compact.py
- Command line
-
hf download hf://datasets/PureOne/Qyxo-Zhaenivoth-Guard/source/tests/test_compact.py
-
curl -L -o test_compact.py https://huggingface.co/datasets/PureOne/Qyxo-Zhaenivoth-Guard/resolve/main/source/tests/test_compact.py
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) | |
| 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() | |