| import unittest |
|
|
| from hdc import crystal, fractal, manifold, state |
| from hdc.entropy import entropy_bits, entropic_octave, level_histogram, max_bits |
| from hdc.hypervec import hvc, sim |
| from hdc.shader import ShaderFabric |
| from hdc.shader3d import Volume, cube_volume |
| from hdc.shader4d import Volume4D, sweep_volume |
|
|
| D = 2000 |
|
|
|
|
| def fabric(): |
| return ShaderFabric(d=D) |
|
|
|
|
| def solid(size=5, value=180): |
| return Volume.from_levels( |
| [[[value for _ in range(size)] for _ in range(size)] for _ in range(size)], fabric() |
| ) |
|
|
|
|
| class TestGeodesic(unittest.TestCase): |
| def test_distance_is_manhattan_on_a_solid(self): |
| vol = solid() |
| self.assertEqual(manifold.geodesic_distance(vol, (0, 0, 0), (4, 4, 4)), 12) |
| self.assertEqual(manifold.geodesic_distance(vol, (0, 0, 0), (0, 0, 4)), 4) |
|
|
| def test_seed_is_distance_zero(self): |
| vol = solid() |
| field = manifold.geodesic_field(vol, (2, 2, 2)) |
| self.assertEqual(field.levels()[2][2][2], 0) |
| |
| self.assertEqual(max(v for p in field.levels() for r in p for v in r), 6) |
|
|
| def test_disconnected_returns_none(self): |
| rows = [[[0] * 5 for _ in range(5)] for _ in range(5)] |
| rows[0][0][0] = 180 |
| rows[4][4][4] = 180 |
| vol = Volume.from_levels(rows, fabric()) |
| self.assertIsNone(manifold.geodesic_distance(vol, (0, 0, 0), (4, 4, 4))) |
|
|
| def test_empty_seed_is_all_unreached(self): |
| vol = Volume.from_levels([[[0] * 3 for _ in range(3)] for _ in range(3)], fabric()) |
| field = manifold.geodesic_field(vol, (1, 1, 1)) |
| self.assertEqual(set(v for p in field.levels() for r in p for v in r), {255}) |
|
|
|
|
| class TestCurvature(unittest.TestCase): |
| def test_uniform_block_is_flat(self): |
| vol = solid() |
| self.assertEqual(set(v for p in manifold.curvature(vol).levels() for r in p for v in r), {128}) |
| self.assertEqual(max(v for p in manifold.laplacian(vol).levels() for r in p for v in r), 0) |
|
|
| def test_hollow_shell_has_ridges_and_valleys(self): |
| rows = [[[180 if (x in (0, 4) or y in (0, 4) or z in (0, 4)) else 0 |
| for x in range(5)] for y in range(5)] for z in range(5)] |
| vol = Volume.from_levels(rows, fabric()) |
| codes = [v for p in manifold.curvature(vol).levels() for r in p for v in r] |
| self.assertIn(255, codes) |
| self.assertIn(0, codes) |
|
|
| def test_laplacian_detects_a_gap(self): |
| rows = [[[100] * 5 for _ in range(5)] for _ in range(5)] |
| rows[2][2][2] = 0 |
| vol = Volume.from_levels(rows, fabric()) |
| lap = manifold.laplacian(vol) |
| self.assertEqual(lap.levels()[2][2][2], 600) |
| self.assertEqual(lap.levels()[2][2][1], 100) |
|
|
| def test_manifold_shade_equals_plain_shade_when_flat(self): |
| vol = solid() |
| self.assertEqual(manifold.manifold_shade(vol).levels(), vol.shade().levels()) |
|
|
| def test_manifold_shade_differs_where_curvature_is_nonzero(self): |
| rows = [[[180] * 5 for _ in range(5)] for _ in range(5)] |
| rows[2][2][2] = 0 |
| vol = Volume.from_levels(rows, fabric()) |
| self.assertNotEqual(manifold.manifold_shade(vol).levels(), vol.shade().levels()) |
|
|
|
|
| class TestFractal(unittest.TestCase): |
| def test_sierpinski_pattern_is_exact(self): |
| img = fractal.sierpinski(3) |
| levels = img.levels() |
| self.assertEqual(len(levels), 8) |
| for y in range(8): |
| for x in range(8): |
| self.assertEqual(levels[y][x], 255 if (x & y) == 0 else 0) |
|
|
| def test_fbm_octaves_halve(self): |
| img = fractal.fbm(16, 16, 4, 4, 7, fabric()) |
| peaks = fractal.octave_peaks(img) |
| self.assertGreaterEqual(peaks[0], 200) |
| for coarser, finer in zip(peaks, peaks[1:]): |
| self.assertLessEqual(abs(finer - coarser // 2), 3, msg=str(peaks)) |
|
|
| def test_fbm_values_stay_in_range(self): |
| levels = [v for row in fractal.fbm(12, 12, 3, 4, 7, fabric()).levels() for v in row] |
| self.assertGreaterEqual(min(levels), 0) |
| self.assertLessEqual(max(levels), 255) |
|
|
| def test_fern_draws_something_inside_the_frame(self): |
| levels = [v for row in fractal.fern(800, 20, 24, fabric()).levels() for v in row] |
| self.assertGreater(sum(1 for v in levels if v), 20) |
|
|
| def test_detail_keeps_the_base_at_least_as_bright(self): |
| base = fractal.sierpinski(3, 200, fabric()) |
| out = fractal.detail(base, octaves=2, strength=1) |
| for row_base, row_out in zip(base.levels(), out.levels()): |
| for a, b in zip(row_base, row_out): |
| self.assertGreaterEqual(b, a) |
|
|
|
|
| class TestCrystal(unittest.TestCase): |
| def test_lattice_site_counts(self): |
| self.assertEqual(len(crystal.lattice_sites(4, "cubic")), 64) |
| self.assertEqual(len(crystal.lattice_sites(4, "hex")), 2 * 2 * 2 * 3) |
| with self.assertRaises(ValueError): |
| crystal.lattice_sites(4, "quasicrystal") |
|
|
| def test_crystallize_covers_every_occupied_voxel(self): |
| vol = solid(5) |
| grains = crystal.crystallize(vol, [(0, 0, 0), (4, 4, 4)]) |
| levels = [v for p in grains.levels() for r in p for v in r] |
| self.assertNotIn(255, levels) |
| self.assertEqual(set(levels), {0, 1}) |
|
|
| def test_every_voxel_is_its_own_grain_when_seeded_everywhere(self): |
| vol = solid(5) |
| grains = crystal.crystallize(vol, crystal.lattice_sites(5, "cubic")) |
| self.assertEqual(len(set(v for p in grains.levels() for r in p for v in r)), 125) |
|
|
| def test_two_seeds_split_a_bar(self): |
| rows = [[[100 if 1 <= x <= 6 else 0 for x in range(8)] for _ in range(3)] for _ in range(3)] |
| vol = Volume.from_levels(rows, fabric()) |
| grains = crystal.crystallize(vol, [(1, 1, 1), (6, 1, 1)]) |
| left = grains.levels()[1][1][1] |
| right = grains.levels()[1][1][6] |
| self.assertNotEqual(left, right) |
| walls = crystal.grain_boundaries(grains) |
| self.assertEqual(walls.levels()[1][1][3] + walls.levels()[1][1][4], 255) |
|
|
| def test_periodicity_recovers_a_two_plane_lattice(self): |
| rows = [[[180 if x % 2 == 0 and 1 <= y <= 3 and 1 <= z <= 3 else 0 |
| for x in range(8)] for y in range(5)] for z in range(5)] |
| vol = Volume.from_levels(rows, fabric()) |
| spacing, score = crystal.periodicity(vol, axis=0) |
| self.assertEqual(spacing, 2) |
| self.assertGreater(score, 0.5) |
|
|
| def test_uniform_volume_has_no_period(self): |
| self.assertEqual(crystal.periodicity(solid(5), axis=0)[0], 0) |
|
|
| def test_facet_histogram_covers_surface_codes_only(self): |
| hist = crystal.facet_histogram(solid(5)) |
| self.assertTrue(hist) |
| self.assertTrue(all(0 <= code <= 6 for code in hist)) |
|
|
|
|
| class TestEntropy(unittest.TestCase): |
| def test_flat_field_is_zero_bits(self): |
| bits, counts = entropy_bits([100] * 8, 8, 0, 255, fabric()) |
| self.assertEqual(bits, 0.0) |
| self.assertEqual(counts[3], 8) |
|
|
| def test_two_values_is_one_bit(self): |
| bits, _ = entropy_bits([0, 255] * 4, 8, 0, 255, fabric()) |
| self.assertAlmostEqual(bits, 1.0, places=6) |
|
|
| def test_uniform_eight_bins_is_three_bits(self): |
| bits, _ = entropy_bits([0, 32, 64, 96, 128, 160, 192, 255], 8, 0, 255, fabric()) |
| self.assertAlmostEqual(bits, 3.0, places=6) |
|
|
| def test_single_bucket_histogram_has_no_entropy(self): |
| self.assertEqual(level_histogram([7, 7, 7], 1, 0, 255, fabric()), [3]) |
|
|
| def test_octave_is_monotone_in_entropy(self): |
| ceiling = max_bits(8) |
| values = [entropic_octave(b, ceiling) for b in (0.0, 0.5, 1.0, 2.0, 3.0)] |
| self.assertEqual(values, sorted(values, reverse=True)) |
| self.assertEqual(values[0], 4) |
| self.assertEqual(values[-1], 0) |
|
|
|
|
| class TestVolume4D(unittest.TestCase): |
| def setUp(self): |
| self.vol = sweep_volume(step=4, size=5, value=200, fabric=fabric()) |
|
|
| def test_shape_and_slices(self): |
| self.assertEqual((self.vol.w, self.vol.h, self.vol.depth, self.vol.u), (5, 5, 5, 4)) |
| self.assertEqual(self.vol.stat()["voxels"], 500) |
|
|
| def test_slices_differ_and_drift_is_positive(self): |
| self.assertNotEqual(self.vol.levels()[0], self.vol.levels()[1]) |
| self.assertGreater(self.vol.drift(), 0.0) |
|
|
| def test_static_stack_has_zero_entropy_and_drift(self): |
| block = [[[[180] * 4 for _ in range(3)] for _ in range(3)] for _ in range(3)] |
| vol = Volume4D.from_levels(block, fabric()) |
| self.assertEqual(vol.drift(), 0.0) |
| entropy = vol.entropy_along_u(8) |
| self.assertEqual(max(v for p in entropy.levels() for r in p for v in r), 0) |
| self.assertEqual(set(v for p in vol.entropic_octaves(8).levels() for r in p for v in r), {2}) |
|
|
| def test_eight_equally_likely_values_saturate_entropy(self): |
| block = [ |
| [[[u * 32 for _ in range(2)] for _ in range(2)] for _ in range(2)] |
| for u in range(8) |
| ] |
| vol = Volume4D.from_levels(block, fabric()) |
| entropy = vol.entropy_along_u(8) |
| self.assertEqual(max(v for p in entropy.levels() for r in p for v in r), 255) |
|
|
| def test_two_alternating_values_reach_one_third(self): |
| block = [ |
| [[[0 if u % 2 else 255 for _ in range(2)] for _ in range(2)] for _ in range(2)] |
| for u in range(4) |
| ] |
| vol = Volume4D.from_levels(block, fabric()) |
| entropy = vol.entropy_along_u(8) |
| self.assertEqual(max(v for p in entropy.levels() for r in p for v in r), 85) |
|
|
| def test_projection_collapses_u(self): |
| projected = self.vol.project_u() |
| self.assertEqual((projected.w, projected.h, projected.depth), (5, 5, 5)) |
|
|
| def test_entropic_shade_is_darker_than_plain_projection(self): |
| plain = self.vol.project_u().shade() |
| entropic = self.vol.shade_entropic() |
| peak_plain = max(v for p in plain.levels() for r in p for v in r) |
| peak_entropic = max(v for p in entropic.levels() for r in p for v in r) |
| self.assertLessEqual(peak_entropic, peak_plain) |
|
|
|
|
| class TestPredictiveState(unittest.TestCase): |
| def setUp(self): |
| self.model, self.states, self.world = state.trained_model(8, D) |
|
|
| def test_learned_transition_is_exact(self): |
| for i, s in enumerate(self.states): |
| predicted, confidence = self.model.predict(s, "next") |
| self.assertEqual(predicted, self.states[(i + 1) % 8]) |
| self.assertGreater(confidence, 0.2) |
|
|
| def test_unseen_action_predicts_nothing(self): |
| self.assertEqual(self.model.predict(self.states[0], "jump"), (None, 0.0)) |
|
|
| def test_surprise_is_zero_when_the_model_is_right(self): |
| surprise = self.model.surprise(self.states[0], "next", self.states[1]) |
| self.assertAlmostEqual(surprise, 0.0, places=6) |
|
|
| def test_surprise_is_high_when_the_world_disagrees(self): |
| surprise = self.model.surprise(self.states[0], "next", self.states[5]) |
| self.assertGreater(surprise, 0.9) |
|
|
| def test_plan_finds_the_short_path(self): |
| plan = self.model.plan(self.states[0], self.states[6], ["next", "prev"], horizon=4) |
| self.assertEqual(plan["actions"], ["prev", "prev"]) |
| self.assertGreater(plan["expanded"], 0) |
|
|
| def test_plan_to_current_state_is_empty(self): |
| plan = self.model.plan(self.states[3], self.states[3], ["next", "prev"], horizon=2) |
| self.assertEqual(plan["actions"], []) |
|
|
| def test_agent_reaches_goal_and_reports_zero_loss(self): |
| agent = state.StateAgent(self.model, ["next", "prev"], goal=self.states[6]) |
| episode = agent.run(self.states[0], lambda s, a: self.world[a](s), steps=4) |
| self.assertEqual(len(episode), 2) |
| self.assertAlmostEqual(agent.loss(), 0.0, places=6) |
|
|
| def test_agent_learns_an_unmodelled_world(self): |
| model = state.PredictiveModel(d=D, alphabet=self.states) |
| agent = state.StateAgent(model, ["next"], goal=self.states[2]) |
| agent.run(self.states[0], lambda s, a: self.world[a](s), steps=3) |
| |
| self.assertGreater(agent.episode[0]["surprise"], 0.5) |
| self.assertAlmostEqual(model.surprise(self.states[0], "next", self.states[1]), 0.0, places=6) |
|
|
|
|
| class TestSignedCompare(unittest.TestCase): |
| def test_negative_is_less_than_zero(self): |
| f = fabric() |
| self.assertEqual(f.compare(f.sub(f.level(0), f.level(180)), f.level(0)), -1) |
| self.assertEqual(f.compare(f.level(0), f.sub(f.level(0), f.level(180))), 1) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
