Merge branch 'master' into Release_v0.6

Author: BastienTr

.travis.yml

@@ -26,12 +26,12 @@ install:
     - conda create -q -n test-environment python=$TRAVIS_PYTHON_VERSION numpy scipy matplotlib nose
     - source activate test-environment
     #- conda install --yes -c dan_blanchard python-coveralls nose-cov
-    - pip install python-coveralls
+    - pip install coveralls
     - pip install coverage
     - python setup.py install
 script:
     # Your test script goes here
-    - nosetests -a '!slow' --with-coverage --cover-package=commpy --logging-level=INFO
+    - nosetests --with-coverage --cover-package=commpy --logging-level=INFO
 # Calculate coverage
 after_success:
     - coveralls

THANKS.txt

@@ -2,6 +2,7 @@ Please add names as needed so that we can keep up with all the contributors.
 
 Veeresh Taranalli for initial creation and contribution of CommPy.
 Bastien Trotobas for adding some features, bugfixes, maintenance.
+Eduardo Soares (@eSoares) for several enhancements including WiFi 802.11 class and code speedups.
 Vladimir Fadeev for bugfixes, addition of convolutional code puncturing and readme explanation of codings.
 Youness Akourim for adding features and fixing some bugs.
 Rey Tucker for python3 compatibility fixes.

commpy/channelcoding/README.md

@@ -78,11 +78,12 @@ The [following](https://en.wikipedia.org/wiki/File:Conv_code_177_133.png) convol
 Convolutional encoder parameters:
 
 ```python
+generator_matrix = np.array([[5, 7]]) # generator branches
+trellis = cc.Trellis(np.array([M]), generator_matrix) # Trellis structure
+
 rate = 1/2 # code rate
 L = 7 # constraint length
 m = np.array([L-1]) # number of delay elements
-generator_matrix = np.array([[0o171, 0o133]]) # generator branches
-trellis = cc.Trellis(M, generator_matrix) # Trellis structure
 ```
 
 Viterbi decoder parameters:
@@ -106,9 +107,9 @@ noiseVar = 10**(-snrdB/10) # noise variance (power)
 
 N_c = 10 # number of trials
 
-BER_soft = np.empty((N_c,))
-BER_hard = np.empty((N_c,))
-BER_uncoded = np.empty((N_c,))
+BER_soft = np.zeros(N_c)
+BER_hard = np.zeros(N_c)
+BER_uncoded = np.zeros(N_c)
 
 for cntr in range(N_c):
 
@@ -136,31 +137,30 @@ for cntr in range(N_c):
     decoded_soft = cc.viterbi_decode(demodulated_soft, trellis, tb_depth, decoding_type='unquantized') # decoding (soft decision)
     decoded_hard = cc.viterbi_decode(demodulated_hard, trellis, tb_depth, decoding_type='hard') # decoding (hard decision)
 
+    NumErr, BER_soft[cntr] = BER_calc(message_bits, decoded_soft[:message_bits.size]) # bit-error ratio (soft decision)
+    NumErr, BER_hard[cntr] = BER_calc(message_bits, decoded_hard[:message_bits.size]) # bit-error ratio (hard decision)
+    NumErr, BER_uncoded[cntr] = BER_calc(message_bits, demodulated_uncoded[:message_bits.size]) # bit-error ratio (uncoded case)
 
-    NumErr, BER_soft[cntr] = BER_calc(message_bits, decoded_soft[:-(L-1)]) # bit-error ratio (soft decision)
-    NumErr, BER_hard[cntr] = BER_calc(message_bits, decoded_hard[:-(L-1)]) # bit-error ratio (hard decision)
-    NumErr, BER_uncoded[cntr] = BER_calc(message_bits, demodulated_uncoded) # bit-error ratio (uncoded case)
-
-mean_BER_soft = np.mean(BER_soft) # averaged bit-error ratio (soft decision)
-mean_BER_hard = np.mean(BER_hard) # averaged bit-error ratio (hard decision)
-mean_BER_uncoded = np.mean(BER_uncoded) # averaged bit-error ratio (uncoded case)
+mean_BER_soft = BER_soft.mean() # averaged bit-error ratio (soft decision)
+mean_BER_hard = BER_hard.mean() # averaged bit-error ratio (hard decision)
+mean_BER_uncoded = BER_uncoded.mean() # averaged bit-error ratio (uncoded case)
 
-print("Soft decision:\n"+str(mean_BER_soft)+"\n")
-print("Hard decision:\n"+str(mean_BER_hard)+"\n")
-print("Uncoded message:\n"+str(mean_BER_uncoded)+"\n")
+print("Soft decision:\n{}\n".format(mean_BER_soft))
+print("Hard decision:\n{}\n".format(mean_BER_hard))
+print("Uncoded message:\n{}\n".format(mean_BER_uncoded))
 ```
 
 Outputs:
 
 ```python
->>> Soft decision:
->>> 0.0
->>>
->>> Hard decision:
->>> 3.0000000000000004e-05
->>>
->>> Uncoded message:
->>> 0.008782
+Soft decision:
+2.8000000000000003e-05
+
+Hard decision:
+0.0007809999999999999
+
+Uncoded message:
+0.009064
 ```
 
 ### Reference

commpy/channelcoding/convcode.py

@@ -573,7 +573,9 @@ def _where_c(inarray, rows, cols, search_value, index_array):
 
 
 @functools.lru_cache(maxsize=128, typed=False)
-def _compute_branch_metrics(decoding_type, r_codeword, i_codeword_array):
+def _compute_branch_metrics(decoding_type, _r_codeword: tuple, _i_codeword_array: tuple):
+    r_codeword = np.array(_r_codeword)
+    i_codeword_array = np.array(_i_codeword_array)
     if decoding_type == 'hard':
         return hamming_dist(r_codeword.astype(int), i_codeword_array.astype(int))
     elif decoding_type == 'soft':
@@ -693,12 +695,13 @@ def viterbi_decode(coded_bits, trellis, tb_depth=None, decoding_type='hard'):
     rate = k/n
     total_memory = trellis.total_memory
 
-    if tb_depth is None:
-        tb_depth = 5*total_memory
-
     # Number of message bits after decoding
     L = int(len(coded_bits)*rate)
 
+    if tb_depth is None:
+        tb_depth = min(5 * total_memory, L)
+
+
     path_metrics = np.full((trellis.number_states, 2), np.inf)
     path_metrics[0][0] = 0
     paths = np.empty((trellis.number_states, tb_depth), 'int')
@@ -745,7 +748,8 @@ def viterbi_decode(coded_bits, trellis, tb_depth=None, decoding_type='hard'):
 
     return decoded_bits[:L]
 
-def puncturing(message, punct_vec):
+
+def puncturing(message: np.ndarray, punct_vec: np.ndarray) -> np.ndarray:
     """
     Applying of the punctured procedure.
     Parameters
@@ -769,7 +773,8 @@ def puncturing(message, punct_vec):
             shift = shift + 1
     return np.array(punctured)
 
-def depuncturing(punctured, punct_vec, shouldbe):
+
+def depuncturing(punctured: np.ndarray, punct_vec: np.ndarray, shouldbe: int) -> np.ndarray:
     """
     Applying of the inserting zeros procedure.
     Parameters
@@ -795,5 +800,5 @@ def depuncturing(punctured, punct_vec, shouldbe):
         else:
             shift2 = shift2 + 1
         if idx%N == 0:
-            shift = shift + 1;
+            shift = shift + 1
     return depunctured

commpy/channelcoding/gfields.py

@@ -3,7 +3,7 @@
 
 """ Galois Fields """
 
-from fractions import gcd
+from math import gcd
 
 from numpy import array, zeros, arange, convolve, ndarray, concatenate
 
@@ -52,7 +52,7 @@ def __init__(self, x, m):
         if type(x) is int and x >= 0 and x < pow(2, m):
             self.elements = array([x])
         elif type(x) is ndarray and len(x) >= 1:
-            self.elements = x
+            self.elements = x.astype(int)
 
     # Overloading addition operator for Galois Field
     def __add__(self, x):

commpy/channelcoding/ldpc.py

@@ -241,8 +241,8 @@ def ldpc_bp_decode(llr_vec, ldpc_code_params, decoder_algorithm, n_iters):
 
             # Variable Node Update
             msg_sum = np.array(message_matrix.sum(0)).squeeze()
-            message_matrix *= -1
-            message_matrix += parity_check_matrix.multiply(msg_sum + llr_vec[i_start:i_stop])
+            message_matrix.data *= -1
+            message_matrix.data += parity_check_matrix.multiply(msg_sum + llr_vec[i_start:i_stop]).data
 
             out_llrs = msg_sum + llr_vec[i_start:i_stop]
             np.signbit(out_llrs, out=dec_word[i_start:i_stop])

commpy/channelcoding/tests/test_convcode.py

@@ -131,6 +131,9 @@ def test_viterbi_decode(self):
 
     @dec.slow
     def test_conv_encode_viterbi_decode(self):
+        # Set seed
+        seed(17121996)
+
         niters = 10
         blocklength = 1000
 
@@ -176,6 +179,5 @@ def test_conv_encode_viterbi_decode(self):
 
 
 if __name__ == "__main__":
-    seed(17121996)
     run_module_suite()
 

commpy/channels.py

@@ -54,7 +54,7 @@ def generate_noises(self, dims):
         else:
             self.noises = standard_normal(dims) * self.noise_std
 
-    def set_SNR_dB(self, SNR_dB, code_rate=1, Es=1):
+    def set_SNR_dB(self, SNR_dB, code_rate: float = 1., Es=1):
 
         """
         Sets the the noise standard deviation based on SNR expressed in dB.

commpy/examples/wifi80211_conv_encode_decode.py

@@ -0,0 +1,34 @@
+# Authors: CommPy contributors
+# License: BSD 3-Clause
+
+import math
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import commpy.channels as chan
+# ==================================================================================================
+# Complete example using Commpy Wifi 802.11 physical parameters
+# ==================================================================================================
+from commpy.wifi80211 import Wifi80211
+
+# AWGN channel
+channels = chan.SISOFlatChannel(None, (1 + 0j, 0j))
+
+w2 = Wifi80211(mcs=2)
+w3 = Wifi80211(mcs=3)
+
+# SNR range to test
+SNRs2 = np.arange(0, 6) + 10 * math.log10(w2.get_modem().num_bits_symbol)
+SNRs3 = np.arange(0, 6) + 10 * math.log10(w3.get_modem().num_bits_symbol)
+
+BERs_mcs2 = w2.link_performance(channels, SNRs2, 10, 10, 600, stop_on_surpass_error=False)
+BERs_mcs3 = w3.link_performance(channels, SNRs3, 10, 10, 600, stop_on_surpass_error=False)
+
+# Test
+plt.semilogy(SNRs2, BERs_mcs2, 'o-', SNRs3, BERs_mcs3, 'o-')
+plt.grid()
+plt.xlabel('Signal to Noise Ration (dB)')
+plt.ylabel('Bit Error Rate')
+plt.legend(('MCS 2', 'MCS 3'))
+plt.show()