def __LDPCGenerate__(n, rate=0.5):
'''
LDPC Generate
inputs:
n: number of messages to encode. We use integers 0:n-1 to represent the n messages
rate: the rate of LDPC code, float number in (0, 1)
returns:
message_length: length (in bits) of the encoded messages
code_length: length (in bits) of the codewords
codeword_mat: a matrix of size (code_length, n). The i-th column stores the
codeword for the i-th message
ldpc_code: an ldpc code object
G: ldpc encode matrix
'''
dv = 3
dc = 6
log_n = int(math.ceil(math.log(n, 2)))
flag = False
H = 0
G = 0
code_length = 0
while flag == False:
code_length = int(math.ceil(log_n / float(rate)))
if code_length % dc != 0:
# dc must divide code_length
code_length += (dc - code_length % dc)
H = pyldpc.RegularH(code_length, dv, dc)
G = pyldpc.CodingMatrix(H)
if G.shape[1] >= log_n:
flag = True
else:
rate = rate / 2.0
# Now H is the binary check matrix and G is the encoding matrix
# Size of G is (code_length, message_length)
message_length = G.shape[1]
# Convert integers in xrange(n) to binary numbers
binary_mat = zeros([message_length, n], dtype=int)
for i in xrange(n):
bin_str = np.binary_repr(i, log_n)
for j in xrange(log_n):
binary_mat[j, i] = ord(bin_str[log_n - j - 1]) - 48
codeword_mat = (dot(G, binary_mat)) % 2
check_node_num = code_length * dv / dc
L = []
for i in range(check_node_num):
non_zero_pos = np.where(H[i, :] != 0)
L.append((non_zero_pos[0]).tolist())
E = reduce(lambda x, y: x + y, map(lambda z: len(z), L))
ldpc_code = LDPCCode(code_length, check_node_num, E, L)
return message_length, code_length, codeword_mat, ldpc_code, G
def initEncoder(self):
self.j=3;
if(self.encoder_type=='hamming'):
n_hamm = 2**self.j - 1;
k_hamm = n_hamm-self.j
r = k_hamm/n_hamm
self.N = np.int(self.k/r)
if(self.encoder_type=='ldpc'):
self.k=6;
self.N,d_v,d_c = 15,4,5;
self.H = pyldpc.RegularH(self.N,d_v,d_c)
self.Gt = pyldpc.CodingMatrix(self.H);
def LDPCEncoder(n, rate=0.5):
dv = 3
dc = 6
log_n = int(math.ceil(math.log(n, 2)))
flag = False
H = 0
G = 0
code_length = 0
while flag == False:
code_length = int(math.ceil(log_n / float(rate)))
if code_length % dc != 0:
# dc must divide code_length
code_length += (dc - code_length % dc)
H = pyldpc.RegularH(code_length, dv, dc)
G = pyldpc.CodingMatrix(H)
if G.shape[1] >= log_n:
flag = True
else:
rate = rate / 2.0
# Now H is the binary check matrix and G is the encoding matrix
# Size of G is (code_length, message_length)
message_length = G.shape[1]
# Convert integers in xrange(n) to binary numbers
binary_mat = zeros([message_length, n], dtype=int)
for i in xrange(n):
bin_str = np.binary_repr(i, log_n)
for j in xrange(log_n):
binary_mat[j, i] = ord(bin_str[log_n - j - 1]) - 48
codeword_mat = (dot(G, binary_mat)) % 2
check_node_num = code_length * dv / dc
L = []
for i in range(check_node_num):
non_zero_pos = np.where(H[i, :] != 0)
L.append((non_zero_pos[0]).tolist())
E = reduce(lambda x, y: x + y, map(lambda z: len(z), L))
ldpc_code = LDPCCode(code_length, check_node_num, E, L)
return message_length, code_length, codeword_mat, ldpc_code, G
x_decoded = pyldpc.Decoding_logBP(H,received,snr,max_iter)
v_received = pyldpc.DecodedMessage(tG,x_decoded)
return v_received
## define LDPC parameters
n = 15 # Number of columns
d_v = 3 # Number of ones per column, must be lower than d_c (because H must have more rows than columns)
d_c = 5 # Number of ones per row, must divide n (because if H has m rows: m*d_c = n*d_v (compute number of ones in H))
max_iter = 10
num_block = 100
H = pyldpc.RegularH(n,d_v,d_c)
tG = pyldpc.CodingMatrix(H)
n,k = tG.shape
print 'LDPC has shape', n, k
snrs = [0.5*item for item in range(-3, 5)]
print snrs
train_X, train_Y = [], []
train_snr = 0.0
for _ in range(num_block):
message = np.random.randint(2,size=k)
received = ldpc_regularldpc_encoder(message, tG, train_snr)
def getH(N, dv, dc):
return pl.RegularH(2 * N, dv,
dc) #builds a regular parity check matrix H (n,dv,dc)
def construct_h_matrix(self, col_num, ones_per_col, ones_per_row):
#assert any(guess % ones_per_row == 0) == True
assert ones_per_col < ones_per_row
self.current_h_matrix = pyldpc.RegularH(col_num, ones_per_col,
ones_per_row)
return self.current_h_matrix
'''
Created on Jul 11, 2016
@author: laurynas
'''
import pyldpc
from numpy import *
if __name__ == '__main__':
msg = array([0, 1, 0, 1, 1, 0])
n = 15 # Number of columns
column_weight = 4 # Number of ones per column, must be lower than d_c (because H must have more rows than columns)
row_weight = 5
snr = 8
H = pyldpc.RegularH(n, column_weight, row_weight)
tG = pyldpc.CodingMatrix(H)
new_H, sys_tG = pyldpc.CodingMatrix_systematic(H)
y = pyldpc.Coding(tG, msg, snr)
x_decoded = pyldpc.Decoding_logBP(H, y, snr, 5)
print("H.x' = ", pyldpc.BinaryProduct(H, x_decoded))
v_received = pyldpc.DecodedMessage(tG, x_decoded)
print v_received