Merge pull request #45 from BastienTr/master

New features (MIMO channel and detection, conv coding) & maintenance task

Author: veeresht

README.md

@@ -55,6 +55,7 @@ Available Features
 - MIMO Maximum Likelihood (ML) Detection.
 - MIMO K-best Schnorr-Euchner Detection.
 - Convert channel matrix to Bit-level representation.
+- Computation of LogLikelihood ratio using max-log approximation.
 
 [Sequences](https://github.com/veeresht/CommPy/blob/master/commpy/sequences.py)
 ---------
@@ -100,17 +101,20 @@ Requirements/Dependencies
 Installation
 ------------
 
-- To use the released version on PyPi, use pip or conda to install as follows::
+- To use the released version on PyPi, use pip to install as follows::
 ```
 $ pip install scikit-commpy
-$ conda install -c https://conda.binstar.org/veeresht scikit-commpy
 ```
 - To work with the development branch, clone from github and install as follows::
 ```
 $ git clone https://github.com/veeresht/CommPy.git
 $ cd CommPy
 $ python setup.py install
 ```
+- conda version is curently outdated but v0.3 is still available using::
+```
+$ conda install -c https://conda.binstar.org/veeresht scikit-commpy
+```
 
 Citing CommPy
 -------------

commpy/channelcoding/algcode.py

@@ -1,12 +1,9 @@
-
-
-# Authors: Veeresh Taranalli <veeresht@gmail.com>
+# Authors: CommPy contributors
 # License: BSD 3-Clause
 
-from fractions import gcd
 from numpy import array, arange, concatenate, convolve
 
-from commpy.channelcoding.gfields import GF, polymultiply, poly_to_string
+from commpy.channelcoding.gfields import GF, poly_to_string
 from commpy.utilities import dec2bitarray, bitarray2dec
 
 __all__ = ['cyclic_code_genpoly']

commpy/channelcoding/convcode.py

@@ -1,13 +1,12 @@
-
-
-# Authors: Veeresh Taranalli <veeresht@gmail.com>
+# Authors: CommPy contributors
 # License: BSD 3-Clause
 
 """ Galois Fields """
 
 from fractions import gcd
+
 from numpy import array, zeros, arange, convolve, ndarray, concatenate
-from itertools import *
+
 from commpy.utilities import dec2bitarray, bitarray2dec
 
 __all__ = ['GF', 'polydivide', 'polymultiply', 'poly_to_string']

commpy/channelcoding/gfields.py

@@ -1,5 +1,4 @@
-
-# Authors: Veeresh Taranalli <veeresht@gmail.com>
+# Authors: CommPy contributors
 # License: BSD 3-Clause
 
 """ Interleavers and De-interleavers """
@@ -9,7 +8,6 @@
 
 __all__ = ['RandInterlv']
 
-
 class _Interleaver:
 
     def interlv(self, in_array):

commpy/channelcoding/interleavers.py

@@ -1,6 +1,4 @@
-
-
-# Authors: Veeresh Taranalli <veeresht@gmail.com>
+# Authors: CommPy contributors
 # License: BSD 3-Clause
 
 """ LDPC Codes """

commpy/channelcoding/ldpc.py

@@ -1,91 +1,159 @@
-
-
-# Authors: Veeresh Taranalli <veeresht@gmail.com>
+# Authors: CommPy contributors
 # License: BSD 3-Clause
 
-from numpy import array
-from numpy.random import randint
-from numpy.testing import assert_array_equal
+from numpy import array, inf
+from numpy.random import randint, randn, seed
+from numpy.testing import assert_array_equal, dec, run_module_suite
+
 from commpy.channelcoding.convcode import Trellis, conv_encode, viterbi_decode
 
+
 class TestConvCode(object):
 
     @classmethod
     def setup_class(cls):
+        cls.trellis = []
+        cls.desired_next_state_table = []
+        cls.desired_output_table = []
+        cls.desired_encode_msg = []
+        cls.mes = array((0, 0, 1, 0))
+
+        ### 1/2 - rate codes  ###
+
         # Convolutional Code 1: G(D) = [1+D^2, 1+D+D^2]
         memory = array([2])
-        g_matrix = array([[0o5, 0o7]])
-        cls.code_type_1 = 'default'
-        cls.trellis_1 = Trellis(memory, g_matrix, 0, cls.code_type_1)
-        cls.desired_next_state_table_1 = array([[0, 2],
-                                                [0, 2],
-                                                [1, 3],
-                                                [1, 3]])
-        cls.desired_output_table_1 = array([[0, 3],
-                                            [3, 0],
-                                            [1, 2],
-                                            [2, 1]])
-
+        g_matrix = array([[5, 7]])
+        cls.trellis.append(Trellis(memory, g_matrix, code_type='default'))
+        cls.desired_next_state_table.append(array([[0, 2],
+                                                   [0, 2],
+                                                   [1, 3],
+                                                   [1, 3]]))
+        cls.desired_output_table.append(array([[0, 3],
+                                               [3, 0],
+                                               [1, 2],
+                                               [2, 1]]))
+        cls.desired_encode_msg.append(array([0., 0., 0., 0., 1., 1., 0., 1.]))
 
         # Convolutional Code 2: G(D) = [1 1+D+D^2/1+D]
         memory = array([2])
-        g_matrix = array([[0o1, 0o7]])
-        feedback = 0o5
-        cls.code_type_2 = 'rsc'
-        cls.trellis_2 = Trellis(memory, g_matrix, feedback, cls.code_type_2)
-        cls.desired_next_state_table_2 = array([[0, 2],
-                                                [2, 0],
-                                                [1, 3],
-                                                [3, 1]])
-        cls.desired_output_table_2 = array([[0, 3],
-                                            [0, 3],
-                                            [1, 2],
-                                            [1, 2]])
-
+        g_matrix = array([[1, 7]])
+        feedback = 5
+        cls.trellis.append(Trellis(memory, g_matrix, feedback, 'rsc'))
+        cls.desired_next_state_table.append(array([[0, 2],
+                                                   [2, 0],
+                                                   [1, 3],
+                                                   [3, 1]]))
+        cls.desired_output_table.append(array([[0, 3],
+                                               [0, 3],
+                                               [1, 2],
+                                               [1, 2]]))
+        cls.desired_encode_msg.append(array([0., 0., 0., 0., 1., 1., 0., 1.]))
+
+        ### 2/3 - rate codes  ###
+
+        # Convolutional Code 1: G(D) = [[1+D^2, 1+D+D^2 0], [0, D, 1+D]]
+        memory = array([2, 1])
+        g_matrix = array([[5, 7, 0], [0, 2, 3]])
+        cls.trellis.append(Trellis(memory, g_matrix, code_type='default'))
+        cls.desired_next_state_table.append(array([[0, 1, 4, 5],
+                                                   [0, 1, 4, 5],
+                                                   [0, 1, 4, 5],
+                                                   [0, 1, 4, 5],
+                                                   [2, 3, 6, 7],
+                                                   [2, 3, 6, 7],
+                                                   [2, 3, 6, 7],
+                                                   [2, 3, 6, 7]]))
+        cls.desired_output_table.append(array([[0, 1, 6, 7],
+                                               [3, 2, 5, 4],
+                                               [6, 7, 0, 1],
+                                               [5, 4, 3, 2],
+                                               [2, 3, 4, 5],
+                                               [1, 0, 7, 6],
+                                               [4, 5, 2, 3],
+                                               [7, 6, 1, 0]]))
+        cls.desired_encode_msg.append(array([0., 0., 0., 1., 1., 0.]))
+
+        # Convolutional Code 2: G(D) = [[1, 0, 0], [0, 1, 1+D]]; F(D) = [[D, D], [1+D, 1]]
+        memory = array([1, 1])
+        g_matrix = array([[1, 0, 0], [0, 1, 3]])
+        feedback = array([[2, 2], [3, 1]])
+        cls.trellis.append(Trellis(memory, g_matrix, feedback, 'rsc'))
+        cls.desired_next_state_table.append(array([[0, 1, 1, 0],
+                                                   [2, 3, 3, 2],
+                                                   [3, 2, 2, 3],
+                                                   [1, 0, 0, 1]]))
+        cls.desired_output_table.append(array([[0, 3, 4, 7],
+                                               [1, 2, 5, 6],
+                                               [0, 3, 4, 7],
+                                               [1, 2, 5, 6]]))
+        cls.desired_encode_msg.append(array([0., 0., 0., 1., 0., 0.]))
 
     @classmethod
     def teardown_class(cls):
         pass
 
     def test_next_state_table(self):
-        assert_array_equal(self.trellis_1.next_state_table, self.desired_next_state_table_1)
-        assert_array_equal(self.trellis_2.next_state_table, self.desired_next_state_table_2)
+        for i in range(len(self.trellis)):
+            assert_array_equal(self.trellis[i].next_state_table, self.desired_next_state_table[i])
 
     def test_output_table(self):
-        assert_array_equal(self.trellis_1.output_table, self.desired_output_table_1)
-        assert_array_equal(self.trellis_2.output_table, self.desired_output_table_2)
+        for i in range(len(self.trellis)):
+            assert_array_equal(self.trellis[i].output_table, self.desired_output_table[i])
 
     def test_conv_encode(self):
-        pass
+        for i in range(len(self.trellis)):
+            assert_array_equal(conv_encode(self.mes, self.trellis[i],'cont'), self.desired_encode_msg[i])
 
     def test_viterbi_decode(self):
-        pass
+        pass  # Tested below
 
+    @dec.slow
     def test_conv_encode_viterbi_decode(self):
         niters = 10
         blocklength = 1000
 
-        for i in range(niters):
+        for n in range(niters):
             msg = randint(0, 2, blocklength)
 
-            coded_bits = conv_encode(msg, self.trellis_1)
-            decoded_bits = viterbi_decode(coded_bits.astype(float), self.trellis_1, 15)
-            assert_array_equal(decoded_bits[:-2], msg)
-            
-            coded_bits = conv_encode(msg, self.trellis_1, termination = 'cont')
-            decoded_bits = viterbi_decode(coded_bits.astype(float), self.trellis_1, 15)
-            assert_array_equal(decoded_bits, msg)
-
-            coded_bits = conv_encode(msg, self.trellis_1)
-            coded_syms = 2.0*coded_bits - 1
-            decoded_bits = viterbi_decode(coded_syms, self.trellis_1, 15, 'unquantized')
-            assert_array_equal(decoded_bits[:-2], msg)
-
-            coded_bits = conv_encode(msg, self.trellis_2)
-            decoded_bits = viterbi_decode(coded_bits.astype(float), self.trellis_2, 15)
-            assert_array_equal(decoded_bits[:-2], msg)
-
-            coded_bits = conv_encode(msg, self.trellis_2)
-            coded_syms = 2.0*coded_bits - 1
-            decoded_bits = viterbi_decode(coded_syms, self.trellis_2, 15, 'unquantized')
-            assert_array_equal(decoded_bits[:-2], msg)
+            # Previous tests
+            for i in range(len(self.trellis)):
+                coded_bits = conv_encode(msg, self.trellis[i])
+                decoded_bits = viterbi_decode(coded_bits.astype(float), self.trellis[i], 15)
+                assert_array_equal(decoded_bits[:len(msg)], msg)
+
+                coded_bits = conv_encode(msg, self.trellis[i], termination='cont')
+                decoded_bits = viterbi_decode(coded_bits.astype(float), self.trellis[i], 15)
+                assert_array_equal(decoded_bits, msg)
+
+                coded_bits = conv_encode(msg, self.trellis[i])
+                coded_syms = 2.0 * coded_bits - 1
+                decoded_bits = viterbi_decode(coded_syms, self.trellis[i], 15, 'unquantized')
+                assert_array_equal(decoded_bits[:len(msg)], msg)
+
+                coded_bits = conv_encode(msg, self.trellis[i])
+                coded_syms = 10.0 * coded_bits - 5 + randn(len(coded_bits)) * 2
+                decoded_bits = viterbi_decode(coded_syms, self.trellis[i], 15, 'soft')
+                assert_array_equal(decoded_bits[:len(msg)], msg)
+
+                coded_bits = conv_encode(msg, self.trellis[i], termination='cont')
+                coded_syms = 10.0 * coded_bits - 5 + randn(len(coded_bits)) * 2
+                decoded_bits = viterbi_decode(coded_syms, self.trellis[i], 15, 'soft')
+                assert_array_equal(decoded_bits, msg)
+
+                coded_bits = conv_encode(msg, self.trellis[i])
+                coded_syms = (2.0 * coded_bits - 1) * inf
+                decoded_bits = viterbi_decode(coded_syms, self.trellis[i], 15, 'soft')
+                assert_array_equal(decoded_bits[:len(msg)], msg)
+
+                coded = conv_encode(msg, self.trellis[i], termination='cont')
+                coded_bits = coded.astype(float)
+                coded_bits[coded_bits == 1.0] = inf
+                coded_bits[coded_bits == 0.0] = -inf
+                decoded_bits = viterbi_decode(coded_bits, self.trellis[i], 15, 'soft')
+                assert_array_equal(decoded_bits, msg)
+
+
+if __name__ == "__main__":
+    seed(17121996)
+    run_module_suite()
+

commpy/channelcoding/tests/test_convcode.py

@@ -1,9 +1,9 @@
-
-# Authors: Veeresh Taranalli <veeresht@gmail.com>
+# Authors: CommPy contributors
 # License: BSD 3 clause
 
-from numpy import array, ones_like, arange
-from numpy.testing import assert_array_almost_equal, assert_array_equal, assert_, assert_equal
+from numpy import array, arange
+from numpy.testing import assert_array_equal, assert_
+
 from commpy.channelcoding.gfields import GF
 
 

commpy/channelcoding/tests/test_gfields.py

@@ -1,4 +1,4 @@
-# Authors: Veeresh Taranalli <veeresht@gmail.com>
+# Authors: CommPy contributors
 # License: BSD 3-Clause
 
 import os

commpy/channelcoding/tests/test_ldpc.py

@@ -1,13 +1,14 @@
-
-
-# Authors: Veeresh Taranalli <veeresht@gmail.com>
+# Authors: CommPy contributors
 # License: BSD 3-Clause
 
 """ Turbo Codes """
 
-from numpy import array, append, zeros, exp, pi, log, empty
-from commpy.channelcoding import Trellis, conv_encode
-from commpy.utilities import dec2bitarray, bitarray2dec
+from numpy import array, zeros, exp, log, empty
+
+from commpy.channelcoding import conv_encode
+from commpy.utilities import dec2bitarray
+
+
 #from commpy.channelcoding.map_c import backward_recursion, forward_recursion_decoding
 
 def turbo_encode(msg_bits, trellis1, trellis2, interleaver):