Move basic files

Author: fr0mhell

python_polar_coding/polar_codes/base/__init__.py

@@ -0,0 +1,4 @@
+from .codec import BasePolarCodec, BasePolarCodeWithCRC
+from .decoder import BaseDecoder
+from .functions import *
+from .decoding_path import DecodingPathMixin

…ar_coding/polar_codes/base/polar_code.py …n_polar_coding/polar_codes/base/codec.pypython_polar_coding/polar_codes/base/polar_code.py renamed to python_polar_coding/polar_codes/base/codec.py python_polar_coding/polar_codes/base/polar_code.py renamed to python_polar_coding/polar_codes/base/codec.py

@@ -4,14 +4,15 @@
 
 import numpy as np
 
-from . import crc, encoder, pcc, utils
+from . import encoder
+from python_polar_coding.polar_codes import utils, crc, pcc
 
 
-class BasicPolarCode(metaclass=abc.ABCMeta):
-    """Basic Polar code class.
+class BasePolarCodec(metaclass=abc.ABCMeta):
+    """Basic codec for Polar code.
 
     Includes code construction.
-    Provides the basic workflow for encoding and decoding.
+    Defines the basic workflow for encoding and decoding.
 
     Supports creation of a polar code from custom mask.
 
@@ -47,8 +48,8 @@ def __init__(self, N: int, K: int,
             N=self.N, n=self.n, design_snr=design_snr, pcc_method=pcc_method)
         self.mask = self._polar_code_construction(mask)
 
-        self.encoder = self.get_encoder()
-        self.decoder = self.get_decoder()
+        self.encoder = self.init_encoder()
+        self.decoder = self.init_decoder()
 
     def __str__(self):
         return (f'({self.N}, {self.K}) Polar code.\n'
@@ -67,13 +68,13 @@ def to_dict(self):
             'mask': ''.join(str(m) for m in self.mask),
         }
 
-    def get_encoder(self):
+    def init_encoder(self):
         """Get Polar Encoder instance."""
         return self.encoder_class(mask=self.mask, n=self.n,
                                   is_systematic=self.is_systematic)
 
     @abc.abstractmethod
-    def get_decoder(self):
+    def init_decoder(self):
         """Get Polar Decoder instance."""
 
     def encode(self, message: np.array) -> np.array:
@@ -132,7 +133,7 @@ def _construct_polar_mask(self, K):
         return np.array([m[2] for m in mask])
 
 
-class BasicPolarCodeWithCRC(BasicPolarCode):
+class BasePolarCodeWithCRC(BasePolarCodec):
     """Basic Polar code class with CRC support.
 
     Provides the support of CRC 16 and CRC 32.
@@ -145,7 +146,7 @@ def __init__(self, N: int, K: int,
                  is_systematic: bool = True,
                  crc_size: int = 32,
                  mask: Union[str, None] = None,
-                 pcc_method: str = BasicPolarCode.BHATTACHARYYA):
+                 pcc_method: str = BasePolarCodec.BHATTACHARYYA):
 
         assert crc_size in [16, 32], f'Unsupported CRC size ({crc_size})'
         assert K + crc_size < N, (f'Cannot create Polar code with N = {N},'
@@ -167,7 +168,7 @@ def to_dict(self):
         d.update({'crc_size': self.crc_size})
         return d
 
-    def get_encoder(self):
+    def init_encoder(self):
         """Get Polar Encoder instance."""
         return self.encoder_class(mask=self.mask, n=self.n,
                                   is_systematic=self.is_systematic,

python_polar_coding/polar_codes/base/decoding_path.py

@@ -0,0 +1,86 @@
+from copy import deepcopy
+
+import numpy as np
+
+
+class DecodingPathMixin:
+    """Decoding Path for list decoding."""
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        # Probability that current path contains correct decoding result
+        self._path_metric = 0
+
+    def __eq__(self, other):
+        return self._path_metric == other._path_metric
+
+    def __gt__(self, other):
+        return self._path_metric > other._path_metric
+
+    def __ge__(self, other):
+        return self > other or self == other
+
+    def __lt__(self, other):
+        return not (self >= other)
+
+    def __le__(self, other):
+        return not (self > other)
+
+    def __str__(self):
+        return (
+            f'LLR: {self.current_llr}; '
+            f'Decision: {self._current_decision}; '
+            f'Path metric: {self._path_metric}'
+        )
+
+    @property
+    def current_llr(self):
+        return self.intermediate_llr[-1][0]
+
+    def __deepcopy__(self, memodict={}):
+        new_path = self.__class__(n=self.n, mask=self.mask,
+                                  is_systematic=self.is_systematic)
+
+        # Copy intermediate LLR values
+        new_path.intermediate_llr = [
+            np.array(llrs) for llrs in self.intermediate_llr
+        ]
+        # Copy intermediate bit values
+        new_path.intermediate_bits = [
+            np.array(bits) for bits in self.intermediate_bits
+        ]
+        # Copy current state
+        new_path.current_state = np.array(self.current_state)
+        # Copy previous state
+        new_path.previous_state = np.array(self.previous_state)
+
+        # Copy path metric
+        new_path._path_metric = self._path_metric
+
+        # Make opposite decisions for each path
+        self._current_decision = 0
+        new_path._current_decision = 1
+
+        return new_path
+
+    def update_path_metric(self):
+        """Update path metrics using LLR-based metric.
+
+        Source: https://arxiv.org/abs/1411.7282 Section III-B
+
+        """
+        if self.current_llr >= 0:
+            self._path_metric -= (self.current_llr * self._current_decision)
+        if self.current_llr < 0:
+            self._path_metric += (self.current_llr * (1 - self._current_decision))
+
+    def split_path(self):
+        """Make a copy of SC path with another decision.
+
+        If LLR of the current position is out of bounds, there is no sense
+        of splitting path because LLR >= 20 means 0 and LLR <= -20 means 1.
+
+        """
+        new_path = deepcopy(self)
+        return [self, new_path]

python_polar_coding/polar_codes/base/encoder.py

@@ -1,7 +1,7 @@
 import numpy as np
 from numba import njit
 
-from .crc import CRC
+from python_polar_coding.polar_codes.crc import CRC
 
 
 class Encoder:

python_polar_coding/polar_codes/base/functions.py

@@ -20,7 +20,7 @@ def compute_encoding_step(level, n, source, result):
 
 
 @numba.njit
-def basic_llr_computation(a, b):
+def compute_alpha(a, b):
     """Basic function to compute intermediate LLR values."""
     c = np.zeros(a.shape[0])
     for i in range(c.shape[0]):
@@ -35,7 +35,7 @@ def function_1(a, b, c):
     Source: doi:10.1007/s12243-018-0634-7, formula 1.
 
     """
-    return basic_llr_computation(a, b + c)
+    return compute_alpha(a, b + c)
 
 
 @numba.njit
@@ -45,7 +45,7 @@ def function_2(a, b, c):
     Source: doi:10.1007/s12243-018-0634-7, formula 2.
 
     """
-    return basic_llr_computation(a, b) + c
+    return compute_alpha(a, b) + c
 
 
 @numba.njit

…hon_polar_coding/polar_codes/base/crc.py python_polar_coding/polar_codes/crc.pypython_polar_coding/polar_codes/base/crc.py renamed to python_polar_coding/polar_codes/crc.py python_polar_coding/polar_codes/base/crc.py renamed to python_polar_coding/polar_codes/crc.py

@@ -2,7 +2,7 @@
 from PyCRC.CRC32 import CRC32
 from PyCRC.CRCCCITT import CRCCCITT
 
-from . import utils
+from python_polar_coding.polar_codes import utils
 
 
 class CRC: