feat: add free distance method to convolutional codes

Author: rwnobrega

src/komm/_error_control_convolutional/ConvolutionalCode.py

@@ -273,6 +273,43 @@ def feedback_taps(self) -> list[npt.NDArray[np.integer]]:
             for nu, q in zip(self.constraint_lengths, self.feedback_polynomials)
         ]
 
+    @cache
+    def free_distance(self) -> int:
+        r"""
+        Returns the *free distance* $d_\mathrm{free}$ of the code. This is equal to the minimum Hamming weight among all non-zero encoded bit sequences
+
+        Examples:
+            >>> code = komm.ConvolutionalCode([[0b111, 0b101]])
+            >>> code.free_distance()
+            5
+        """
+        fsm = self.finite_state_machine()
+
+        def hamming_weight(y: int, _: int) -> int:
+            return y.bit_count()
+
+        # Start at all-zero state
+        metrics = np.full(fsm.num_states, np.inf)
+        metrics[0] = 0.0
+
+        _, metrics = fsm.viterbi(
+            observed=[-1],  # dummy
+            metric_function=hamming_weight,
+            initial_metrics=metrics,
+        )
+
+        # Block return to all-zero state at the first step
+        metrics[0] = np.inf
+
+        while metrics[0] > np.min(metrics[1:]):
+            _, metrics = fsm.viterbi(
+                observed=[-1],  # dummy
+                metric_function=hamming_weight,
+                initial_metrics=metrics,
+            )
+
+        return int(metrics[0])
+
     @cache
     def state_space_representation(
         self,

src/komm/_finite_state_machine/MealyMachine.py

@@ -212,7 +212,7 @@ def viterbi(
             final_metrics: The final metrics for each state. It is a 1D-array of length $|\mathcal{S}|$.
         """
         L, num_states = len(observed), self.num_states
-        choices = np.empty((L, num_states), dtype=int)
+        choices = np.zeros((L, num_states), dtype=int)
         metrics = np.full((L + 1, num_states), fill_value=np.inf)
         if initial_metrics is None:
             metrics[0, :] = np.zeros(num_states, dtype=float)

tests/error_control_convolutional/test_convolutional_code.py

@@ -295,11 +295,6 @@ def test_convolutional_code_free_distance_g(
     overall_constraint_length, feedforward_polynomials, free_distance
 ):
     # Lin.Costello.04, p. 539--540
-    convolutional_code = komm.ConvolutionalCode(feedforward_polynomials)
-    assert convolutional_code.overall_constraint_length == overall_constraint_length
-    code = komm.TerminatedConvolutionalCode(
-        convolutional_code=convolutional_code,
-        num_blocks=overall_constraint_length,
-        mode="zero-termination",
-    )
-    assert code.minimum_distance() == free_distance
+    code = komm.ConvolutionalCode(feedforward_polynomials)
+    assert code.overall_constraint_length == overall_constraint_length
+    assert code.free_distance() == free_distance