Update example to include max_log_bcjr.

Alexandre Marquet · Alexandre Marquet · commit 2f6c995681a0 · 2019-08-09T13:38:36.000+02:00
diff --git a/examples/75_cc.py b/examples/75_cc.py
@@ -1,4 +1,5 @@
 from PyTurbo import PyLogBCJR as bcjr
+from PyTurbo import PyMaxLogBCJR as max_log_bcjr
 from PyTurbo import PyViterbi as viterbi
 from matplotlib import pyplot as plt
 
@@ -46,8 +47,20 @@ def log_bcjr_branch_metrics(bits_rcvd, nbits_cw, sigma_b2):
 
     return ret_val.flatten()
 
+def max_log_bcjr_branch_metrics(bits_rcvd, nbits_cw, sigma_b2):
+    N_cw = (2**nbits_cw)
+    K = int(len(bits_rcvd)/nbits_cw)
+    ret_val = numpy.zeros((K, N_cw), dtype=numpy.float32);
+    cw = numpy.array([[0.0,0.0], [0.0,1.0], [1.0,0.0], [1.0,1.0]]) #The 4 different codewords
+
+    bits_rcvd = numpy.array(bits_rcvd).reshape((K, nbits_cw))
+    for k in range(0, K):
+        ret_val[k][:] = -numpy.sum(numpy.abs(bits_rcvd[k][:]-cw)**2, axis=1)
+
+    return ret_val.flatten()
+
 #Compute bit LLR from a posteriori-probabilities
-def compute_llr(app, K, S):
+def log_bcjr_compute_llr(app, K, S):
     llr = numpy.zeros(K, dtype=numpy.float32)
 
     app = app.reshape((K, S, 2))
@@ -57,6 +70,16 @@ def compute_llr(app, K, S):
 
     return llr
 
+def max_log_bcjr_compute_llr(app, K, S):
+    llr = numpy.zeros(K, dtype=numpy.float32)
+
+    app = app.reshape((K, S, 2))
+    llr = numpy.max(app[:,:,0], axis=1) - numpy.max(app[:,:,1], axis=1)
+    #for k in range(0, K):
+    #    llr[k] = numpy.max(app[k,:,0]) - numpy.max(app[k,:,1])
+
+    return llr
+
 #Define trellis
 I=2
 S=4
@@ -86,9 +109,11 @@ def compute_llr(app, K, S):
 #Create decoder instance
 dec_vit = viterbi(I, S, O, NS, OS)
 dec_log_bcjr = bcjr(I, S, O, NS, OS)
+dec_max_log_bcjr = max_log_bcjr(I, S, O, NS, OS)
 
 BER_viterbi = numpy.zeros(len(EbN0dB))
 BER_log_bcjr = numpy.zeros(len(EbN0dB))
+BER_max_log_bcjr = numpy.zeros(len(EbN0dB))
 for i in range(0, len(EbN0dB)):
     #Generate message
     m = numpy.random.randint(0, 2, K_m, dtype=numpy.bool)
@@ -120,17 +145,32 @@ def compute_llr(app, K, S):
     post_log_bcjr = dec_log_bcjr.log_bcjr_algorithm(A0, BK, bm_log_bcjr);
 
     #Compute bit LLR and take decisions
-    llr = compute_llr(post_log_bcjr, K_m, S)
-    m_hat_log_bcjr = (llr<0)
+    llr_log_bcjr = log_bcjr_compute_llr(post_log_bcjr, K_m, S)
+    m_hat_log_bcjr = (llr_log_bcjr<0)
+
+    ## Max-Log BCJR
+    #Compute branch metrics
+    bm_max_log_bcjr = max_log_bcjr_branch_metrics(r, int(1/R), sigma_b2[i])
+
+    #Compute posterior probabilities of codewords
+    post_max_log_bcjr = dec_max_log_bcjr.log_bcjr_algorithm(A0, BK, bm_max_log_bcjr);
+
+    #Compute bit LLR and take decisions
+    llr_max_log_bcjr = max_log_bcjr_compute_llr(post_max_log_bcjr, K_m, S)
+    m_hat_max_log_bcjr = (llr_max_log_bcjr<0)
 
     ##Compute BER
     BER_viterbi[i] = numpy.mean(numpy.abs(m!=m_hat_viterbi))
     print('BER For viterbi at Eb/N0 = ' + str(EbN0dB[i]) + 'dB: ' + str(BER_viterbi[i]))
     BER_log_bcjr[i] = numpy.mean(numpy.abs(m!=m_hat_log_bcjr))
     print('BER For log_bcjr at Eb/N0 = ' + str(EbN0dB[i]) + 'dB: ' + str(BER_log_bcjr[i]))
+    BER_max_log_bcjr[i] = numpy.mean(numpy.abs(m!=m_hat_max_log_bcjr))
+    print('BER For max_log_bcjr at Eb/N0 = ' + str(EbN0dB[i]) + 'dB: ' + str(BER_max_log_bcjr[i]))
+    print('')
 
 plt.semilogy(EbN0dB, BER_viterbi, label="Viterbi")
 plt.semilogy(EbN0dB, BER_log_bcjr, label="Log-BCJR")
+plt.semilogy(EbN0dB, BER_max_log_bcjr, label="Max-Log-BCJR")
 plt.legend()
 plt.xlabel("E_b/N_0 (dB)")
 plt.ylabel("BER")
