Add barrel shifter and priority encoder tests

- Barrel shifter: 40 tests (left shift by 0-7 positions)
- Priority encoder: 13 tests (find highest set bit)
- Tests: 6,116 -> 6,169
- Fitness: 1.000000

README.md

@@ -479,7 +479,7 @@ The interface generalizes to **all** 65,536 8-bit additions once trained—no me
 |------|-------------|
 | `neural_computer.safetensors` | 11,581 tensors, 8,290,134 parameters |
 | `threshold_cpu.py` | CPU state, reference cycle, threshold runtime |
-| `eval.py` | Unified evaluation suite (6,116 tests, GPU-batched) |
+| `eval.py` | Unified evaluation suite (6,169 tests, GPU-batched) |
 | `build.py` | Build tools for memory, ALU, and .inputs tensors |
 | `prune_weights.py` | Weight magnitude pruning |
 

eval.py

@@ -1096,6 +1096,156 @@ class BatchedFitnessEvaluator:
         scores += s
         total += t
 
+        s, t = self._test_barrel_shifter(pop, debug)
+        scores += s
+        total += t
+
+        s, t = self._test_priority_encoder(pop, debug)
+        scores += s
+        total += t
+
+        return scores, total
+
+    def _test_barrel_shifter(self, pop: Dict, debug: bool) -> Tuple[torch.Tensor, int]:
+        """Test barrel shifter (shift by 0-7 positions)."""
+        pop_size = next(iter(pop.values())).shape[0]
+        scores = torch.zeros(pop_size, device=self.device)
+        total = 0
+
+        if debug:
+            print("\n=== BARREL SHIFTER ===")
+
+        try:
+            # Test all shift amounts 0-7 with various input patterns
+            test_vals = [0b10000001, 0b11110000, 0b00001111, 0b10101010, 0xFF]
+
+            for val in test_vals:
+                for shift in range(8):
+                    expected_val = (val << shift) & 0xFF  # Left shift
+                    val_bits = [float((val >> (7 - i)) & 1) for i in range(8)]
+                    shift_bits = [float((shift >> (2 - i)) & 1) for i in range(3)]
+
+                    # Process through 3 layers
+                    layer_in = val_bits[:]
+                    for layer in range(3):
+                        shift_amount = 1 << (2 - layer)  # 4, 2, 1
+                        sel = shift_bits[layer]
+                        layer_out = []
+
+                        for bit in range(8):
+                            prefix = f'combinational.barrelshifter.layer{layer}.bit{bit}'
+
+                            # NOT sel
+                            w_not = pop[f'{prefix}.not_sel.weight'].view(pop_size)
+                            b_not = pop[f'{prefix}.not_sel.bias'].view(pop_size)
+                            not_sel = heaviside(sel * w_not + b_not)
+
+                            # Source for shifted value
+                            shifted_src = bit + shift_amount
+                            if shifted_src < 8:
+                                shifted_val = layer_in[shifted_src]
+                            else:
+                                shifted_val = 0.0
+
+                            # AND a: original AND NOT sel
+                            w_and_a = pop[f'{prefix}.and_a.weight'].view(pop_size, 2)
+                            b_and_a = pop[f'{prefix}.and_a.bias'].view(pop_size)
+                            inp_a = torch.tensor([layer_in[bit], not_sel[0].item()], device=self.device)
+                            and_a = heaviside((inp_a * w_and_a).sum(-1) + b_and_a)
+
+                            # AND b: shifted AND sel
+                            w_and_b = pop[f'{prefix}.and_b.weight'].view(pop_size, 2)
+                            b_and_b = pop[f'{prefix}.and_b.bias'].view(pop_size)
+                            inp_b = torch.tensor([shifted_val, sel], device=self.device)
+                            and_b = heaviside((inp_b * w_and_b).sum(-1) + b_and_b)
+
+                            # OR
+                            w_or = pop[f'{prefix}.or.weight'].view(pop_size, 2)
+                            b_or = pop[f'{prefix}.or.bias'].view(pop_size)
+                            inp_or = torch.tensor([and_a[0].item(), and_b[0].item()], device=self.device)
+                            out = heaviside((inp_or * w_or).sum(-1) + b_or)
+                            layer_out.append(out[0].item())
+
+                        layer_in = layer_out
+
+                    # Check result
+                    result = sum(int(layer_in[i]) << (7 - i) for i in range(8))
+                    if result == expected_val:
+                        scores += 1
+                    total += 1
+
+            self._record('combinational.barrelshifter', int(scores[0].item()), total, [])
+            if debug:
+                r = self.results[-1]
+                print(f"  {r.name}: {r.passed}/{r.total} {'PASS' if r.success else 'FAIL'}")
+        except (KeyError, RuntimeError) as e:
+            if debug:
+                print(f"  combinational.barrelshifter: SKIP ({e})")
+
+        return scores, total
+
+    def _test_priority_encoder(self, pop: Dict, debug: bool) -> Tuple[torch.Tensor, int]:
+        """Test priority encoder (find highest set bit)."""
+        pop_size = next(iter(pop.values())).shape[0]
+        scores = torch.zeros(pop_size, device=self.device)
+        total = 0
+
+        if debug:
+            print("\n=== PRIORITY ENCODER ===")
+
+        try:
+            # Test cases: input -> (valid, index of highest bit)
+            test_cases = [
+                (0b00000000, 0, 0),  # No bits set, valid=0
+                (0b00000001, 1, 7),  # Bit 7 (LSB)
+                (0b00000010, 1, 6),
+                (0b00000100, 1, 5),
+                (0b00001000, 1, 4),
+                (0b00010000, 1, 3),
+                (0b00100000, 1, 2),
+                (0b01000000, 1, 1),
+                (0b10000000, 1, 0),  # Bit 0 (MSB)
+                (0b10000001, 1, 0),  # Multiple bits, highest wins
+                (0b01010101, 1, 1),
+                (0b00001111, 1, 4),
+                (0b11111111, 1, 0),
+            ]
+
+            for val, expected_valid, expected_idx in test_cases:
+                val_bits = torch.tensor([float((val >> (7 - i)) & 1) for i in range(8)],
+                                       device=self.device, dtype=torch.float32)
+
+                # Valid output: OR of all input bits
+                w_valid = pop['combinational.priorityencoder.valid.weight'].view(pop_size, 8)
+                b_valid = pop['combinational.priorityencoder.valid.bias'].view(pop_size)
+                out_valid = heaviside((val_bits * w_valid).sum(-1) + b_valid)
+
+                if int(out_valid[0].item()) == expected_valid:
+                    scores += 1
+                total += 1
+
+                # Index outputs (3 bits)
+                if expected_valid == 1:
+                    for idx_bit in range(3):
+                        try:
+                            w_idx = pop[f'combinational.priorityencoder.idx{idx_bit}.weight'].view(pop_size, 8)
+                            b_idx = pop[f'combinational.priorityencoder.idx{idx_bit}.bias'].view(pop_size)
+                            out_idx = heaviside((val_bits * w_idx).sum(-1) + b_idx)
+                            expected_bit = (expected_idx >> (2 - idx_bit)) & 1
+                            if int(out_idx[0].item()) == expected_bit:
+                                scores += 1
+                            total += 1
+                        except KeyError:
+                            pass
+
+            self._record('combinational.priorityencoder', int(scores[0].item()), total, [])
+            if debug:
+                r = self.results[-1]
+                print(f"  {r.name}: {r.passed}/{r.total} {'PASS' if r.success else 'FAIL'}")
+        except (KeyError, RuntimeError) as e:
+            if debug:
+                print(f"  combinational.priorityencoder: SKIP ({e})")
+
         return scores, total
 
     # =========================================================================