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) # every voxel of a 5-cube is within 6 steps of the centre 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) # six 100s, centre zero self.assertEqual(lap.levels()[2][2][1], 100) # one missing neighbour 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) # nothing left ungrown self.assertEqual(set(levels), {0, 1}) # every voxel took one of the two seeds 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) # every step is a surprise the first time, then the model knows it 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()