we should select the largest column as root column

Author: williamzheng0711

__pycache__/binmatrix.cpython-39.pyc

@@ -95,7 +95,13 @@
 ## LLC
 print(" -Phase 1 (decoding) now starts.")
 tic = time.time()
-rxBits_llc, usedRootsIndex, listSizeOrder = slow_decoder(np.ones((listSize,L),dtype=int), rx_coded_symbols_llc, L, J, parityLen, messageLen, listSize, parityInvolved, whichGMatrix, windowSize)
+losses = np.count_nonzero(rx_coded_symbols_llc == -1, axis=0) # losses is a L-long array
+chosenRoot = np.argmin(losses)
+print("chosenRoot: " + str(chosenRoot))
+rx_coded_symbols_llc[:,range(L)] = rx_coded_symbols_llc[:, np.mod(np.arange(chosenRoot, chosenRoot+L),L) ]
+whichGMatrix[:,range(L)] = whichGMatrix[:,np.mod(np.arange(chosenRoot, chosenRoot+L),L)]
+whichGMatrix[range(L),:] = whichGMatrix[np.mod(np.arange(chosenRoot, chosenRoot+L),L),:]
+rxBits_llc, usedRootsIndex, listSizeOrder = slow_decoder(np.ones((listSize,L),dtype=int), rx_coded_symbols_llc, L, J, parityLen, messageLen, listSize, parityInvolved, whichGMatrix, windowSize, chosenRoot)
 toc = time.time()
 print(" | Time of LLC decode " + str(toc-tic))
 if rxBits_llc.shape[0] > K: 
@@ -129,19 +135,19 @@
 print(f' | In phase 1, LDPC decodes {LDPC_num_matches}/{len(rx_user_codewords)} codewords. ')
 
 
+print(" -Phase 1 Done.")
 
 
 
 
 
 
-print(" -Phase 1 Done.")
 
 
 # *Corrector. PAINPOINT
 print(" -Phase 2 (correction) now starts.")
 tic = time.time()
-rxBits_corrected_llc= slow_corrector(np.ones((listSize,L),dtype=int),rx_coded_symbols_llc,L,J,messageLen,parityLen,listSize,parityInvolved,usedRootsIndex,whichGMatrix,windowSize,listSizeOrder)
+rxBits_corrected_llc= slow_corrector(np.ones((listSize,L),dtype=int),rx_coded_symbols_llc,L,J,messageLen,parityLen,listSize,parityInvolved,usedRootsIndex,whichGMatrix,windowSize,listSizeOrder,chosenRoot)
 toc = time.time()
 print(" | Time of correct " + str(toc-tic))
 # print(" | corrected shape: " + str( rxBits_corrected_llc.shape))

__pycache__/slow_lib.cpython-39.pyc

@@ -24,59 +24,59 @@
 
 
 
-import numpy as np
-import matplotlib.pyplot as pyplot
+# import numpy as np
+# import matplotlib.pyplot as pyplot
 
 
-phase1_llc_true = np.array([20, 36, 68, 100])
-phase1_llc_false= np.array([0,  0,  0, 0])
-phase2_llc_true = np.array([36, 38, 22, 0])
-phase2_llc_false= np.array([0,  2,  0, 0])
-phase1_tc_true =  np.array([20, 36, 68, 100])
-phase1_tc_false=  np.array([0, 0, 0, 0])
-p_es = np.array(["0.1", "0.05", "0.025", "0"])
-x_axis = np.arange(len(p_es))
+# phase1_llc_true = np.array([20, 36, 68, 100])
+# phase1_llc_false= np.array([0,  0,  0, 0])
+# phase2_llc_true = np.array([36, 38, 22, 0])
+# phase2_llc_false= np.array([0,  2,  0, 0])
+# phase1_tc_true =  np.array([20, 36, 68, 100])
+# phase1_tc_false=  np.array([0, 0, 0, 0])
+# p_es = np.array(["0.1", "0.05", "0.025", "0"])
+# x_axis = np.arange(len(p_es))
 
-pyplot.axhline(y = 100, color = 'black', linestyle = 'dashed')
-pyplot.bar(x_axis-0.15, phase1_llc_true,  0.2)
-pyplot.bar(x_axis-0.15, phase2_llc_true,  0.2, bottom = phase1_llc_true)
-pyplot.bar(x_axis-0.15, phase1_llc_false, 0.2, bottom = phase1_llc_true + phase2_llc_true)
-pyplot.bar(x_axis-0.15, phase2_llc_false, 0.2, bottom = phase1_llc_true + phase2_llc_true + phase1_llc_false)
+# pyplot.axhline(y = 100, color = 'black', linestyle = 'dashed')
+# pyplot.bar(x_axis-0.15, phase1_llc_true,  0.2)
+# pyplot.bar(x_axis-0.15, phase2_llc_true,  0.2, bottom = phase1_llc_true)
+# pyplot.bar(x_axis-0.15, phase1_llc_false, 0.2, bottom = phase1_llc_true + phase2_llc_true)
+# pyplot.bar(x_axis-0.15, phase2_llc_false, 0.2, bottom = phase1_llc_true + phase2_llc_true + phase1_llc_false)
 
-pyplot.bar(x_axis+0.15, phase1_tc_true,  0.2)
-pyplot.bar(x_axis+0.15, phase1_tc_false, 0.2,  bottom = phase1_tc_true)
+# pyplot.bar(x_axis+0.15, phase1_tc_true,  0.2)
+# pyplot.bar(x_axis+0.15, phase1_tc_false, 0.2,  bottom = phase1_tc_true)
 
-pyplot.xticks(x_axis, p_es)
-pyplot.legend([ "K=100","Ph.1 True (LLC)", "Ph.2 True (LLC)","Ph.1 False (LLC)",  "Ph.2 False (LLC)", "Ph.1 True (TreeCode)", "Ph.1 False (TreeCode)"])
-pyplot.xlabel("p_e")
-pyplot.ylim([0,110])
-pyplot.title("K= 100 Linked-loop code and Tree code")
-pyplot.show()
+# pyplot.xticks(x_axis, p_es)
+# pyplot.legend([ "K=100","Ph.1 True (LLC)", "Ph.2 True (LLC)","Ph.1 False (LLC)",  "Ph.2 False (LLC)", "Ph.1 True (TreeCode)", "Ph.1 False (TreeCode)"])
+# pyplot.xlabel("p_e")
+# pyplot.ylim([0,110])
+# pyplot.title("K= 100 Linked-loop code and Tree code")
+# pyplot.show()
 
 
 
-phase1_llc_true = np.array([28, 59, 107, 150])
-phase1_llc_false= np.array([0,  0,  0, 0])
-phase2_llc_true = np.array([37, 56, 30, 0])
-phase2_llc_false= np.array([4,  3,  0, 0])
-phase1_tc_true  = np.array([28, 59, 108, 150])
-phase1_tc_false = np.array([1,  0,  0, 0])
+# phase1_llc_true = np.array([28, 59, 107, 150])
+# phase1_llc_false= np.array([0,  0,  0, 0])
+# phase2_llc_true = np.array([37, 56, 30, 0])
+# phase2_llc_false= np.array([4,  3,  0, 0])
+# phase1_tc_true  = np.array([28, 59, 108, 150])
+# phase1_tc_false = np.array([1,  0,  0, 0])
 
-pyplot.axhline(y = 150, color = 'black', linestyle = 'dashed')
-pyplot.bar(x_axis-0.15, phase1_llc_true,  0.2)
-pyplot.bar(x_axis-0.15, phase2_llc_true,  0.2, bottom = phase1_llc_true)
-pyplot.bar(x_axis-0.15, phase1_llc_false, 0.2, bottom = phase1_llc_true + phase2_llc_true)
-pyplot.bar(x_axis-0.15, phase2_llc_false, 0.2, bottom = phase1_llc_true + phase2_llc_true + phase1_llc_false)
+# pyplot.axhline(y = 150, color = 'black', linestyle = 'dashed')
+# pyplot.bar(x_axis-0.15, phase1_llc_true,  0.2)
+# pyplot.bar(x_axis-0.15, phase2_llc_true,  0.2, bottom = phase1_llc_true)
+# pyplot.bar(x_axis-0.15, phase1_llc_false, 0.2, bottom = phase1_llc_true + phase2_llc_true)
+# pyplot.bar(x_axis-0.15, phase2_llc_false, 0.2, bottom = phase1_llc_true + phase2_llc_true + phase1_llc_false)
 
-pyplot.bar(x_axis+0.15, phase1_tc_true,  0.2)
-pyplot.bar(x_axis+0.15, phase1_tc_false, 0.2,  bottom = phase1_tc_true)
+# pyplot.bar(x_axis+0.15, phase1_tc_true,  0.2)
+# pyplot.bar(x_axis+0.15, phase1_tc_false, 0.2,  bottom = phase1_tc_true)
 
-pyplot.xticks(x_axis, p_es)
-pyplot.legend([ "K=150","Ph.1 True (LLC)", "Ph.2 True (LLC)","Ph.1 False (LLC)",  "Ph.2 False (LLC)", "Ph.1 True (TreeCode)", "Ph.1 False (TreeCode)"])
-pyplot.xlabel("p_e")
-pyplot.ylim([0,160])
-pyplot.title("K= 150 Linked-loop code and Tree code")
-pyplot.show()
+# pyplot.xticks(x_axis, p_es)
+# pyplot.legend([ "K=150","Ph.1 True (LLC)", "Ph.2 True (LLC)","Ph.1 False (LLC)",  "Ph.2 False (LLC)", "Ph.1 True (TreeCode)", "Ph.1 False (TreeCode)"])
+# pyplot.xlabel("p_e")
+# pyplot.ylim([0,160])
+# pyplot.title("K= 150 Linked-loop code and Tree code")
+# pyplot.show()
 
 
 
@@ -92,4 +92,25 @@
 
 # np.random.seed(2)
 # applyErrs = np.where(bernoulli.rvs(0.1, size=100))[0]
-# print(applyErrs)
+# print(applyErrs)
+
+
+
+import numpy as np
+
+# create a sample 2D array
+arr = np.array([[1, -1, 3], 
+                [1, 0, -1], 
+                [7, -1, 3]])
+
+# count the number of -1 values in each column
+counts = np.count_nonzero(arr == -1, axis=0)
+
+# print(counts)
+
+chosenRoot = 5
+L = 16
+a = np.mod(np.arange(chosenRoot, chosenRoot+L),L)
+print(a)
+b = a[np.mod(np.arange(L-chosenRoot, 2*L-chosenRoot),L)]
+print(b)

__pycache__/slow_utils.cpython-39.pyc

@@ -42,7 +42,7 @@ def slow_encode(tx_message, K, L, J, Pa, w, messageLen, parityLen, parityDistrib
 
     return encoded_tx_message
 
-def slow_decoder(sigValues, sigPos, L, J, parityLen, messageLen, listSize, parityInvolved, whichGMatrix, windowSize):
+def slow_decoder(sigValues, sigPos, L, J, parityLen, messageLen, listSize, parityInvolved, whichGMatrix, windowSize, chosenRoot):
     """
     Phase 1 decoder (no erasure correction)
 
@@ -71,53 +71,60 @@ def slow_decoder(sigValues, sigPos, L, J, parityLen, messageLen, listSize, parit
                 a = np.binary_repr(sigPos[id_row, id_col], width=J)      # print("a = " + str(a))
                 b = np.array([int(n) for n in a] ).reshape(1,-1)         # print("b = " + str(b))
                 cs_decoded_tx_message[id_row, id_col*J:(id_col+1)*J] = b[0,:]
-            elif id_col == 0 :
+            elif id_col == 0:
                 if id_row not in bad_roots:
                     bad_roots.append(id_row)
 
-    bad_roots = np.array(bad_roots, dtype=int)
-    # print("bad_roots" + str(bad_roots))
-
-    # Step 2: find parity consistent paths
     listSizeOrder = np.argsort(sigValues[:, 0])[::-1]
-    # print("listSizeOrder: " + str(listSizeOrder))
+
+
+    # Step 2: find parity consistent paths    
     results = Parallel(n_jobs=-1)(delayed(slow_decode_deal_with_root_i)(idx, L, cs_decoded_tx_message, J, parityInvolved, whichGMatrix, messageLen, listSize, parityLen, windowSize) for idx in listSizeOrder)     
 
-    used_index = [a for a in range(len(results)) if sum(np.sum(results[a],axis=1)) >=0 ]
+    used_index = [a for a in range(len(results)) if sum(np.sum(results[a],axis=1)) >=0]
     tree_decoded_tx_message = np.empty((0,0), dtype=int)
     for gd_idx in used_index:
         tree_decoded_tx_message = np.vstack((tree_decoded_tx_message,results[gd_idx])) if tree_decoded_tx_message.size else results[gd_idx]
 
-    return tree_decoded_tx_message, np.concatenate((listSizeOrder[used_index],bad_roots),axis=None), listSizeOrder
+    tree_decoded_tx_message[:,range(messageLen*L)] = tree_decoded_tx_message[:, np.mod( np.arange(messageLen*L)+(L-chosenRoot)*messageLen  , messageLen*L) ]
+    return tree_decoded_tx_message, np.concatenate((listSizeOrder[used_index], np.array(bad_roots, dtype=int)),axis=None), listSizeOrder
 
 
-def slow_corrector(sigValues, sigPos, L, J, messageLen, parityLen, listSize, parityInvolved, usedRootsIndex, whichGMatrix, windowSize, listSizeOrder):
+def slow_corrector(sigValues, sigPos, L, J, messageLen, parityLen, listSize, parityInvolved, usedRootsIndex, whichGMatrix, windowSize, listSizeOrder, chosenRoot):
     cs_decoded_tx_message = np.zeros( (listSize, L*J) )
     for id_row in range(sigPos.shape[0]):
         for id_col in range(sigPos.shape[1]):
             a = np.binary_repr(sigPos[id_row][id_col], width=J)
             b = np.array([int(n) for n in a] ).reshape(1,-1)
             cs_decoded_tx_message[ id_row, id_col*J: (id_col+1)*J ] = b[0, 0:J]
-
+    
     listSizeOrder_remained = [x for x in listSizeOrder if x not in usedRootsIndex] # exclude used roots.
     tree_decoded_tx_message = np.empty(shape=(0,0))
     targetingSections = np.mod(np.arange(1,L+1),L)
 
-    for i, idx in zip(listSizeOrder_remained, tqdm(range(len(listSizeOrder_remained)))):
-        # if cs_decoded_tx_message[i,0] == -1: print("我是-1 !!!!")
+    for i, idx in zip(listSizeOrder_remained, 
+                    #   tqdm(
+        range(len(listSizeOrder_remained))
+        # )
+        ):
+        assert cs_decoded_tx_message[i,0] != -1
         Paths = np.array([[i]])
         for l in targetingSections:
             # print( "Target section: " + str(l) + " | No. of paths: " + str(Paths.shape[0]) + " | How many contains -1: " + str(sum([1 for Path in Paths if np.any(Path<0)])) )
             if Paths.shape[0] == 0: 
-                print("-------"); break
+                break
             newAll=np.empty( shape=(0,0))
 
-            if l!=0 :  # We still need to enlarge lenth of Paths.
-                survivePaths = Parallel(n_jobs=-1)(delayed(slow_correct_each_section_and_path)(l, j, Paths, cs_decoded_tx_message, J, parityInvolved, whichGMatrix, listSize, messageLen, parityLen, L, windowSize) for j in range(Paths.shape[0]))
+            if l != 0 :  # We still need to enlarge lenth of Paths.
+                survivePaths = Parallel(n_jobs=-1)(delayed(slow_correct_each_section_and_path)(l, j, Paths, cs_decoded_tx_message, J, 
+                                                                                               parityInvolved, whichGMatrix, listSize, 
+                                                                                               messageLen, parityLen, L, windowSize) 
+                                                                                            for j in range(Paths.shape[0]))
                 for survivePath in survivePaths:
                     if survivePath.size:
                         newAll = np.vstack((newAll, survivePath)) if newAll.size else survivePath
                 Paths = newAll 
+
             else: # We dont enlarge length of Paths anymore
                 PathsUpdated = np.empty( shape=(0,0))
                 for j in range(Paths.shape[0]):
@@ -155,6 +162,7 @@ def slow_corrector(sigValues, sigPos, L, J, messageLen, parityLen, listSize, par
             if recovered_message != np.array([], dtype= int).reshape(1,-1):
                 tree_decoded_tx_message = np.vstack((tree_decoded_tx_message, recovered_message)) if tree_decoded_tx_message.size else recovered_message
 
+    tree_decoded_tx_message[:,range(messageLen*L)] = tree_decoded_tx_message[:, np.mod( np.arange(messageLen*L)+(L-chosenRoot)*messageLen  , messageLen*L) ]
     return tree_decoded_tx_message
 
 

__pycache__/utils.cpython-39.pyc

@@ -24,7 +24,7 @@
 assert windowSize > 0
 Pa = L*parityLen                                    # Total number of parity check bits, in this case Pa=w=128
 N = int((30000/2**J)*M)                             # number of channel uses (real d.o.f)
-numAMPIter = 10                                      # number of AMP iterations desired
+numAMPIter = 2                                      # number of AMP iterations desired
 listSize = K + int(np.ceil(K/20))                   # list size retained per section after AMP converges
 sigma_n = 1                                         # AWGN noise standard deviation, hence set to 1. "n" stands for "normal"
 EbNo = 10**(SNR/10)                                 # Eb/No

ach_runner.py

@@ -1,17 +1,19 @@
 import numpy as np
 from utils import *
+from binmatrix import *
 
 def slow_compute_permissible_parity(Path,cs_decoded_tx_message,J, parityInvolved, toCheck, whichGMatrix, parityLen, messageLen):
     # If path length  = 2, then we wanna have parity for section 2. toCheck = 2
     parityDist = parityInvolved[:,toCheck].reshape(1,-1)[0]
-    # print("----------parityDist: " + str(parityDist))
+    # print("----------parityDist: " + str(parityDist), "toCheck: " + str(toCheck))
     deciders = np.nonzero(parityDist)[0] # w(decider), where decider \in deciders, decide p(toCheck) collectively
     focusPath = Path[0]
 
     Parity_computed = np.zeros(parityLen, dtype=int)
     for decider in deciders:      # l labels the sections we gonna check to fix toCheck's parities
         if focusPath[decider] == -1:
             return -1 * np.ones((1,parityLen),dtype=int)
+        assert whichGMatrix[decider][toCheck] != -1
         gen_mat = matrix_repo(dim=messageLen)[ whichGMatrix[decider][toCheck] ] 
         Parity_computed = Parity_computed + np.matmul( cs_decoded_tx_message[focusPath[decider], decider*J : decider*J+messageLen], gen_mat)
     Parity_computed = np.mod(Parity_computed, 2)
@@ -82,8 +84,12 @@ def slow_parity_check(Parity_computed,Path,k,cs_decoded_tx_message,J,messageLen,
                 theLostPart = np.mod(np.matmul(np.mod(minuend - subtrahend,2),gen_binmat_inv),2)
                 solutions = np.vstack((solutions,theLostPart)) if solutions.size else theLostPart
 
-            if np.all(solutions == solutions[0]): return True
-            else: return False
+            if np.all(solutions == solutions[0]): 
+                # print("對的")
+                return True
+            else:
+                # print("不對") 
+                return False
 
     else: # Path is already full
         lostSection = losts[0] if len(losts)>0 else -1
@@ -169,7 +175,7 @@ def slow_decode_deal_with_root_i(i,L,cs_decoded_tx_message, J,parityInvolved, wh
     # Every i is a root.
     # If section ZERO contains -1, then this root is defective
     if cs_decoded_tx_message[i,0] == -1:
-        # print("i= " + str(i)+" 是-1")
+        print("i= " + str(i)+" 是-1")
         return -1*np.ones((1,messageLen * L), dtype=int)
 
     # This root is not defective.
@@ -248,3 +254,4 @@ def slow_correct_each_section_and_path(l, j, Paths, cs_decoded_tx_message, J, pa
     return new
 
 
+

demo.py

@@ -448,4 +448,5 @@ def check_phase_1(txBits, rxBits, name):
             txBits_remained_llc = np.vstack( (txBits_remained_llc, txBits[i,:]) ) if txBits_remained_llc.size else  txBits[i,:]
     print(" | In phase 1, " + str(name) + " decodes " + str(thisIter) + " true message out of " +str(rxBits.shape[0]))
     # print(" - " + str(name) + " Phase 1 is done.")
-    return txBits_remained_llc
+    return txBits_remained_llc
+