Hamming code deduplicated routines into HammingCommon class

Author: smarek

okdmr/dmrlib/etsi/fec/hamming_13_9_3.py

@@ -1,18 +1,17 @@
 import numpy
-from bitarray import bitarray
 
 from okdmr.dmrlib.etsi.fec.fec_utils import (
     derive_parity_check_matrix_from_generator,
-    get_syndrome_for_word,
 )
+from okdmr.dmrlib.etsi.fec.hamming_common import HammingCommon
 
 
-class Hamming1393:
+class Hamming1393(HammingCommon):
     """
     ETSI TS 102 361-1 V2.5.1 (2017-10) - B.3.4  Hamming (13,9,3), Hamming (15,11,3), and Hamming (16,11,4)
     """
 
-    GENERATOR_MATRIX: numpy.ndarray = numpy.array(
+    GENERATOR_MATRIX = numpy.array(
         [
             [1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
             [0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0],
@@ -26,57 +25,10 @@ class Hamming1393:
         ]
     )
 
-    PARITY_CHECK_MATRIX: numpy.ndarray = derive_parity_check_matrix_from_generator(
-        GENERATOR_MATRIX
-    )
-
-    CORRECT_SYNDROME: numpy.ndarray = numpy.array([0, 0, 0, 0])
-
-    @staticmethod
-    def check(bits: bitarray) -> bool:
-        """
-        Verifies Hamming FEC in 4 end bits of input bitarray
-        :param bits:
-        :return: check result
-        """
-        assert (
-            len(bits) == 13
-        ), f"Hamming (13,9,3) expects exactly 13 bits, got {len(bits)}"
-        return numpy.array_equal(
-            get_syndrome_for_word(
-                numpy.array(bits.tolist()), Hamming1393.PARITY_CHECK_MATRIX
-            ),
-            Hamming1393.CORRECT_SYNDROME,
-        )
-
-    @staticmethod
-    def check_and_correct(bits: bitarray) -> (bool, bitarray):
-        """
-        Will check if parity matches, if not, tries to correct one bit-error
-        :param bits:
-        :return: (parity matches, corrected message)
-        """
-        check = Hamming1393.check(bits)
-
-        if not check:
-            # if check does not pass, find index of flipped bit, and correct it
-            syndrome = get_syndrome_for_word(
-                numpy.array(bits.tolist()), Hamming1393.PARITY_CHECK_MATRIX
-            ).tolist()
-            bits.invert(Hamming1393.PARITY_CHECK_MATRIX.T.tolist().index(syndrome))
+    PARITY_CHECK_MATRIX = derive_parity_check_matrix_from_generator(GENERATOR_MATRIX)
 
-        return check, bits
+    CORRECT_SYNDROME = numpy.array([0, 0, 0, 0])
 
-    @staticmethod
-    def generate(bits: bitarray) -> numpy.ndarray:
-        """
-        Returns 9 bits (input) with 4 bits of Hamming FEC
-        :param bits:
-        :return: 13 bits (9 data bits + 4 FEC bits)
-        """
-        assert (
-            len(bits) == 9
-        ), f"Hamming (13,9,3) expects 9 bits of data to add 4 bits of parity, got {len(bits)}"
-        return divmod(
-            numpy.dot(Hamming1393.GENERATOR_MATRIX.T, numpy.array(bits.tolist())), 2
-        )[1]
+    CODEWORD_LENGTH = 13
+    CODE_DIMENSION = 9
+    MINIMUM_HAMMING_DISTANCE = 3

okdmr/dmrlib/etsi/fec/hamming_15_11_3.py

@@ -1,18 +1,17 @@
 import numpy
-from bitarray import bitarray
 
 from okdmr.dmrlib.etsi.fec.fec_utils import (
     derive_parity_check_matrix_from_generator,
-    get_syndrome_for_word,
 )
+from okdmr.dmrlib.etsi.fec.hamming_common import HammingCommon
 
 
-class Hamming15113:
+class Hamming15113(HammingCommon):
     """
     ETSI TS 102 361-1 V2.5.1 (2017-10) - B.3.4  Hamming (13,9,3), Hamming (15,11,3), and Hamming (16,11,4)
     """
 
-    GENERATOR_MATRIX: numpy.ndarray = numpy.array(
+    GENERATOR_MATRIX = numpy.array(
         [
             [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1],
             [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1],
@@ -28,57 +27,10 @@ class Hamming15113:
         ]
     )
 
-    PARITY_CHECK_MATRIX: numpy.ndarray = derive_parity_check_matrix_from_generator(
-        GENERATOR_MATRIX
-    )
-
-    CORRECT_SYNDROME: numpy.ndarray = numpy.array([0, 0, 0, 0])
-
-    @staticmethod
-    def check(bits: bitarray) -> bool:
-        """
-        Verifies Hamming FEC in 4 end bits of input bitarray
-        :param bits:
-        :return: check result
-        """
-        assert (
-            len(bits) == 15
-        ), f"Hamming (15,11,3) expects exactly 15 bits, got {len(bits)}"
-        return numpy.array_equal(
-            get_syndrome_for_word(
-                numpy.array(bits.tolist()), Hamming15113.PARITY_CHECK_MATRIX
-            ),
-            Hamming15113.CORRECT_SYNDROME,
-        )
-
-    @staticmethod
-    def check_and_correct(bits: bitarray) -> (bool, bitarray):
-        """
-        Will check if parity matches, if not, tries to correct one bit-error
-        :param bits:
-        :return: (parity matches, corrected message)
-        """
-        check = Hamming15113.check(bits)
-
-        if not check:
-            # if check does not pass, find index of flipped bit, and correct it
-            syndrome = get_syndrome_for_word(
-                numpy.array(bits.tolist()), Hamming15113.PARITY_CHECK_MATRIX
-            ).tolist()
-            bits.invert(Hamming15113.PARITY_CHECK_MATRIX.T.tolist().index(syndrome))
+    PARITY_CHECK_MATRIX = derive_parity_check_matrix_from_generator(GENERATOR_MATRIX)
 
-        return check, bits
+    CORRECT_SYNDROME = numpy.array([0, 0, 0, 0])
 
-    @staticmethod
-    def generate(bits: bitarray) -> numpy.ndarray:
-        """
-        Returns 11 bits (input) with 4 bits of Hamming FEC
-        :param bits:
-        :return: 15 bits (11 data bits + 4 FEC bits)
-        """
-        assert (
-            len(bits) == 11
-        ), f"Hamming (15,11,3) expects 11 bits of data to add 4 bits of parity, got {len(bits)}"
-        return divmod(
-            numpy.dot(Hamming15113.GENERATOR_MATRIX.T, numpy.array(bits.tolist())), 2
-        )[1]
+    CODEWORD_LENGTH = 15
+    CODE_DIMENSION = 11
+    MINIMUM_HAMMING_DISTANCE = 3

okdmr/dmrlib/etsi/fec/hamming_16_11_4.py

@@ -1,18 +1,17 @@
 import numpy
-from bitarray import bitarray
 
 from okdmr.dmrlib.etsi.fec.fec_utils import (
     derive_parity_check_matrix_from_generator,
-    get_syndrome_for_word,
 )
+from okdmr.dmrlib.etsi.fec.hamming_common import HammingCommon
 
 
-class Hamming16114:
+class Hamming16114(HammingCommon):
     """
     ETSI TS 102 361-1 V2.5.1 (2017-10) - B.3.4  Hamming (13,9,3), Hamming (15,11,3), and Hamming (16,11,4)
     """
 
-    GENERATOR_MATRIX: numpy.ndarray = numpy.array(
+    GENERATOR_MATRIX = numpy.array(
         [
             [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1],
             [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0],
@@ -28,57 +27,10 @@ class Hamming16114:
         ]
     )
 
-    PARITY_CHECK_MATRIX: numpy.ndarray = derive_parity_check_matrix_from_generator(
-        GENERATOR_MATRIX
-    )
-
-    CORRECT_SYNDROME: numpy.ndarray = numpy.array([0, 0, 0, 0, 0])
-
-    @staticmethod
-    def check(bits: bitarray) -> bool:
-        """
-        Verifies Hamming FEC in 5 end bits of input bitarray
-        :param bits:
-        :return: check result
-        """
-        assert (
-            len(bits) == 16
-        ), f"Hamming (15,11,3) expects exactly 16 bits, got {len(bits)}"
-        return numpy.array_equal(
-            get_syndrome_for_word(
-                numpy.array(bits.tolist()), Hamming16114.PARITY_CHECK_MATRIX
-            ),
-            Hamming16114.CORRECT_SYNDROME,
-        )
-
-    @staticmethod
-    def check_and_correct(bits: bitarray) -> (bool, bitarray):
-        """
-        Will check if parity matches, if not, tries to correct one bit-error
-        :param bits:
-        :return: (parity matches, corrected message)
-        """
-        check = Hamming16114.check(bits)
-
-        if not check:
-            # if check does not pass, find index of flipped bit, and correct it
-            syndrome = get_syndrome_for_word(
-                numpy.array(bits.tolist()), Hamming16114.PARITY_CHECK_MATRIX
-            ).tolist()
-            bits.invert(Hamming16114.PARITY_CHECK_MATRIX.T.tolist().index(syndrome))
+    PARITY_CHECK_MATRIX = derive_parity_check_matrix_from_generator(GENERATOR_MATRIX)
 
-        return check, bits
+    CORRECT_SYNDROME = numpy.array([0, 0, 0, 0, 0])
 
-    @staticmethod
-    def generate(bits: bitarray) -> numpy.ndarray:
-        """
-        Returns 11 bits (input) with 5 bits of Hamming FEC
-        :param bits:
-        :return: 16 bits (11 data bits + 5 FEC bits)
-        """
-        assert (
-            len(bits) == 11
-        ), f"Hamming (15,11,3) expects 9 bits of data to add 5 bits of parity, got {len(bits)}"
-        return divmod(
-            numpy.dot(Hamming16114.GENERATOR_MATRIX.T, numpy.array(bits.tolist())), 2
-        )[1]
+    CODEWORD_LENGTH = 16
+    CODE_DIMENSION = 11
+    MINIMUM_HAMMING_DISTANCE = 4

okdmr/dmrlib/etsi/fec/hamming_17_12_3.py

@@ -1,18 +1,17 @@
 import numpy
-from bitarray import bitarray
 
 from okdmr.dmrlib.etsi.fec.fec_utils import (
     derive_parity_check_matrix_from_generator,
-    get_syndrome_for_word,
 )
+from okdmr.dmrlib.etsi.fec.hamming_common import HammingCommon
 
 
-class Hamming17123:
+class Hamming17123(HammingCommon):
     """
     ETSI TS 102 361-1 V2.5.1 (2017-10) - B.3.3  Hamming (17,12,3)
     """
 
-    GENERATOR_MATRIX: numpy.ndarray = numpy.array(
+    GENERATOR_MATRIX = numpy.array(
         [
             [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1],
             [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
@@ -29,57 +28,10 @@ class Hamming17123:
         ]
     )
 
-    PARITY_CHECK_MATRIX: numpy.ndarray = derive_parity_check_matrix_from_generator(
-        GENERATOR_MATRIX
-    )
-
-    CORRECT_SYNDROME: numpy.ndarray = numpy.array([0, 0, 0, 0, 0])
-
-    @staticmethod
-    def check(bits: bitarray) -> bool:
-        """
-        Verifies Hamming FEC in 5 end bits of input bitarray
-        :param bits:
-        :return: check result
-        """
-        assert (
-            len(bits) == 17
-        ), f"Hamming (17,12,3) expects exactly 17 bits, got {len(bits)}"
-        return numpy.array_equal(
-            get_syndrome_for_word(
-                numpy.array(bits.tolist()), Hamming17123.PARITY_CHECK_MATRIX
-            ),
-            Hamming17123.CORRECT_SYNDROME,
-        )
-
-    @staticmethod
-    def check_and_correct(bits: bitarray) -> (bool, bitarray):
-        """
-        Will check if parity matches, if not, tries to correct one bit-error
-        :param bits:
-        :return: (parity matches, corrected message)
-        """
-        check = Hamming17123.check(bits)
-
-        if not check:
-            # if check does not pass, find index of flipped bit, and correct it
-            syndrome = get_syndrome_for_word(
-                numpy.array(bits.tolist()), Hamming17123.PARITY_CHECK_MATRIX
-            ).tolist()
-            bits.invert(Hamming17123.PARITY_CHECK_MATRIX.T.tolist().index(syndrome))
+    PARITY_CHECK_MATRIX = derive_parity_check_matrix_from_generator(GENERATOR_MATRIX)
 
-        return check, bits
+    CORRECT_SYNDROME = numpy.array([0, 0, 0, 0, 0])
 
-    @staticmethod
-    def generate(bits: bitarray) -> numpy.ndarray:
-        """
-        Returns 11 bits (input) with 5 bits of Hamming FEC
-        :param bits:
-        :return: 16 bits (11 data bits + 5 FEC bits)
-        """
-        assert (
-            len(bits) == 12
-        ), f"Hamming (17,12,3) expects 12 bits of data to add 5 bits of parity, got {len(bits)}"
-        return divmod(
-            numpy.dot(Hamming17123.GENERATOR_MATRIX.T, numpy.array(bits.tolist())), 2
-        )[1]
+    CODEWORD_LENGTH = 17
+    CODE_DIMENSION = 12
+    MINIMUM_HAMMING_DISTANCE = 3