def test_extended_pack_data(self):
# test if extended encoder gets correct values for input and output conversion.
n_frames = 10
frame_size = 32
data = np.random.randint(0, 2, n_frames * frame_size)
packed_data = np.packbits(data)
tb = gr.top_block()
src = blocks.vector_source_b(data)
snk0 = blocks.vector_sink_b(1)
snk1 = blocks.vector_sink_b(1)
snk2 = blocks.vector_sink_b(1)
snk3 = blocks.vector_sink_b(1)
packer = blocks.pack_k_bits_bb(8)
tb.connect(src, packer, snk0)
enc_unpacked = fec.dummy_encoder_make(frame_size, False, False)
ext_enc_unp = extended_encoder(enc_unpacked,
threading='none',
puncpat='11')
tb.connect(src, ext_enc_unp, snk1)
enc_pack = fec.dummy_encoder_make(frame_size // 8, True, False)
ext_enc_pack = extended_encoder(enc_pack,
threading='none',
puncpat='11')
tb.connect(src, ext_enc_pack, snk2)
enc_packed_bits = fec.dummy_encoder_make(frame_size // 8, False, True)
ext_enc_packed_bits = extended_encoder(enc_packed_bits,
threading='none',
puncpat='11')
tb.connect(packer, ext_enc_packed_bits, snk3)
tb.run()
r0 = snk0.data()
r1 = snk1.data()
r2 = snk2.data()
r3 = snk3.data()
data = tuple(data)
packed_data = tuple(packed_data)
self.assertTupleEqual(packed_data, r0)
self.assertTupleEqual(data, r1)
self.assertTupleEqual(packed_data, r2)
self.assertTupleEqual(data, r3)
def __init__(self, data_size, enc, dec, threading):
gr.top_block.__init__(self, "_qa_helper")
self.puncpat = puncpat = '11'
self.enc = enc
self.dec = dec
self.data_size = data_size
self.threading = threading
self.ext_encoder = extended_encoder(enc,
threading=self.threading,
puncpat=self.puncpat)
self.ext_decoder = extended_decoder(dec,
threading=self.threading,
ann=None,
puncpat=self.puncpat,
integration_period=10000)
self.src = blocks.vector_source_b(
data_size * [0, 1, 2, 3, 5, 7, 9, 13, 15, 25, 31, 45, 63, 95, 127],
False)
self.unpack = blocks.unpack_k_bits_bb(8)
self.map = map_bb([-1, 1])
self.to_float = blocks.char_to_float(1)
self.snk_input = blocks.vector_sink_b()
self.snk_output = blocks.vector_sink_b()
self.connect(self.src, self.unpack, self.ext_encoder)
self.connect(self.ext_encoder, self.map, self.to_float)
self.connect(self.to_float, self.ext_decoder)
self.connect(self.unpack, self.snk_input)
self.connect(self.ext_decoder, self.snk_output)
def __init__(self, data_size, enc, dec, threading):
gr.top_block.__init__(self, "_qa_helper")
self.puncpat = puncpat = '11'
self.enc = enc
self.dec = dec
self.data_size = data_size
self.threading = threading
self.ext_encoder = extended_encoder(enc, threading=self.threading, puncpat=self.puncpat)
self.ext_decoder= extended_decoder(dec, threading=self.threading, ann=None,
puncpat=self.puncpat, integration_period=10000)
self.src = blocks.vector_source_b(data_size*[0, 1, 2, 3, 5, 7, 9, 13, 15, 25, 31, 45, 63, 95, 127], False)
self.unpack = blocks.unpack_k_bits_bb(8)
self.map = map_bb([-1, 1])
self.to_float = blocks.char_to_float(1)
self.snk_input = blocks.vector_sink_b()
self.snk_output = blocks.vector_sink_b()
self.connect(self.src, self.unpack, self.ext_encoder)
self.connect(self.ext_encoder, self.map, self.to_float)
self.connect(self.to_float, self.ext_decoder)
self.connect(self.unpack, self.snk_input)
self.connect(self.ext_decoder, self.snk_output)
def test_parallelism1_05(self):
frame_size = 30
dims = 5
enc = map((lambda a: fec.dummy_encoder_make(frame_size*8)), range(0,dims))
#dec = map((lambda a: fec.dummy_decoder.make(frame_size*8)), range(0,dims))
threading = 'capillary'
self.assertRaises(AttributeError, lambda: extended_encoder(enc, threading=threading, puncpat="11"))
def test_parallelism1_05(self):
frame_size = 30
dims = 5
enc = map((lambda a: fec.dummy_encoder_make(frame_size*8)), range(0,dims))
#dec = map((lambda a: fec.dummy_decoder.make(frame_size*8)), range(0,dims))
threading = 'capillary'
self.assertRaises(AttributeError, lambda: extended_encoder(enc, threading=threading, puncpat="11"))
def test_extended_pack_data(self):
# test if extended encoder gets correct values for input and output conversion.
n_frames = 10
frame_size = 32
data = np.random.randint(0, 2, n_frames * frame_size)
packed_data = np.packbits(data)
tb = gr.top_block()
src = blocks.vector_source_b(data)
snk0 = blocks.vector_sink_b(1)
snk1 = blocks.vector_sink_b(1)
snk2 = blocks.vector_sink_b(1)
snk3 = blocks.vector_sink_b(1)
packer = blocks.pack_k_bits_bb(8)
tb.connect(src, packer, snk0)
enc_unpacked = fec.dummy_encoder_make(frame_size, False, False)
ext_enc_unp = extended_encoder(enc_unpacked, threading='none', puncpat='11')
tb.connect(src, ext_enc_unp, snk1)
enc_pack = fec.dummy_encoder_make(frame_size // 8, True, False)
ext_enc_pack = extended_encoder(enc_pack, threading='none', puncpat='11')
tb.connect(src, ext_enc_pack, snk2)
enc_packed_bits = fec.dummy_encoder_make(frame_size // 8, False, True)
ext_enc_packed_bits = extended_encoder(enc_packed_bits, threading='none', puncpat='11')
tb.connect(packer, ext_enc_packed_bits, snk3)
tb.run()
r0 = snk0.data()
r1 = snk1.data()
r2 = snk2.data()
r3 = snk3.data()
data = tuple(data)
packed_data = tuple(packed_data)
self.assertTupleEqual(packed_data, r0)
self.assertTupleEqual(data, r1)
self.assertTupleEqual(packed_data, r2)
self.assertTupleEqual(data, r3)
def __init__(self,
generic_encoder=0,
generic_decoder=0,
esno=0,
samp_rate=3200000,
threading="capillary",
puncpat='11',
seed=0):
gr.hier_block2.__init__(self, "fec_test",
gr.io_signature(1, 1, gr.sizeof_char * 1),
gr.io_signature(2, 2, gr.sizeof_char * 1))
self.generic_encoder = generic_encoder
self.generic_decoder = generic_decoder
self.esno = esno
self.samp_rate = samp_rate
self.threading = threading
self.puncpat = puncpat
self.map_bb = digital.map_bb(([-1, 1]))
self.b2f = blocks.char_to_float(1, 1)
self.unpack8 = blocks.unpack_k_bits_bb(8)
self.pack8 = blocks.pack_k_bits_bb(8)
self.encoder = extended_encoder(encoder_obj_list=generic_encoder,
threading=threading,
puncpat=puncpat)
self.decoder = extended_decoder(decoder_obj_list=generic_decoder,
threading=threading,
ann=None,
puncpat=puncpat,
integration_period=10000,
rotator=None)
noise = math.sqrt((10.0**(-esno / 10.0)) / 2.0)
#self.fastnoise = analog.fastnoise_source_f(analog.GR_GAUSSIAN, noise, seed, 8192)
self.fastnoise = analog.noise_source_f(analog.GR_GAUSSIAN, noise, seed)
self.addnoise = blocks.add_ff(1)
# Send packed input directly to the second output
self.copy_packed = blocks.copy(gr.sizeof_char)
self.connect(self, self.copy_packed)
self.connect(self.copy_packed, (self, 1))
# Unpack inputl encode, convert to +/-1, add noise, decode, repack
self.connect(self, self.unpack8)
self.connect(self.unpack8, self.encoder)
self.connect(self.encoder, self.map_bb)
self.connect(self.map_bb, self.b2f)
self.connect(self.b2f, (self.addnoise, 0))
self.connect(self.fastnoise, (self.addnoise, 1))
self.connect(self.addnoise, self.decoder)
self.connect(self.decoder, self.pack8)
self.connect(self.pack8, (self, 0))
def test_parallelism2_00(self):
filename = LDPC_ALIST_DIR + "n_0100_k_0027_gap_04.alist"
gap = 4
dims = 5
LDPC_matrix_object = fec.ldpc_H_matrix(filename, gap)
k = LDPC_matrix_object.k()
dims1 = 16
dims2 = 16
enc = map((lambda b: map((lambda a: fec.ldpc_par_mtrx_encoder.make_H(LDPC_matrix_object)),
range(0,dims1))), range(0,dims2))
threading = 'capillary'
self.assertRaises(AttributeError, lambda: extended_encoder(enc, threading=threading, puncpat="11"))
def test_002_work_function_packed(self):
block_size = 256
num_info_bits = block_size // 2
data, ref, polar_encoder = self.get_test_data(block_size, num_info_bits, 1)
src = blocks.vector_source_b(data, False)
enc_block = extended_encoder(polar_encoder, None, '11')
snk = blocks.vector_sink_b(1)
self.tb.connect(src, enc_block, snk)
self.tb.run()
res = np.array(snk.data()).astype(dtype=int)
self.assertTupleEqual(tuple(res), tuple(ref))
def __init__(self, generic_encoder=0, generic_decoder=0, esno=0,
samp_rate=3200000, threading="capillary", puncpat='11',
seed=0):
gr.hier_block2.__init__(self, "fec_test",
gr.io_signature(1, 1, gr.sizeof_char*1),
gr.io_signature(2, 2, gr.sizeof_char*1))
self.generic_encoder = generic_encoder
self.generic_decoder = generic_decoder
self.esno = esno
self.samp_rate = samp_rate
self.threading = threading
self.puncpat = puncpat
self.map_bb = digital.map_bb(([-1, 1]))
self.b2f = blocks.char_to_float(1, 1)
self.unpack8 = blocks.unpack_k_bits_bb(8)
self.pack8 = blocks.pack_k_bits_bb(8)
self.encoder = extended_encoder(encoder_obj_list=generic_encoder,
threading=threading,
puncpat=puncpat)
self.decoder = extended_decoder(decoder_obj_list=generic_decoder,
threading=threading,
ann=None, puncpat=puncpat,
integration_period=10000, rotator=None)
noise = math.sqrt((10.0**(-esno/10.0))/2.0)
#self.fastnoise = analog.fastnoise_source_f(analog.GR_GAUSSIAN, noise, seed, 8192)
self.fastnoise = analog.noise_source_f(analog.GR_GAUSSIAN, noise, seed)
self.addnoise = blocks.add_ff(1)
# Send packed input directly to the second output
self.copy_packed = blocks.copy(gr.sizeof_char)
self.connect(self, self.copy_packed)
self.connect(self.copy_packed, (self, 1))
# Unpack inputl encode, convert to +/-1, add noise, decode, repack
self.connect(self, self.unpack8)
self.connect(self.unpack8, self.encoder)
self.connect(self.encoder, self.map_bb)
self.connect(self.map_bb, self.b2f)
self.connect(self.b2f, (self.addnoise, 0))
self.connect(self.fastnoise, (self.addnoise,1))
self.connect(self.addnoise, self.decoder)
self.connect(self.decoder, self.pack8)
self.connect(self.pack8, (self, 0))
def test_004_big_input(self):
num_blocks = 30
block_size = 1024
num_info_bits = block_size // 8
data, ref, polar_encoder = self.get_test_data(block_size, num_info_bits, num_blocks)
src = blocks.vector_source_b(data, False)
enc_block = extended_encoder(polar_encoder, None, '11')
snk = blocks.vector_sink_b(1)
self.tb.connect(src, enc_block, snk)
self.tb.run()
res = np.array(snk.data()).astype(dtype=int)
self.assertTupleEqual(tuple(res), tuple(ref))
def test_002_work_function_packed(self):
block_size = 256
num_info_bits = block_size // 2
data, ref, polar_encoder = self.get_test_data(block_size,
num_info_bits, 1)
src = blocks.vector_source_b(data, False)
enc_block = extended_encoder(polar_encoder, None, '11')
snk = blocks.vector_sink_b(1)
self.tb.connect(src, enc_block, snk)
self.tb.run()
res = np.array(snk.data()).astype(dtype=int)
self.assertTupleEqual(tuple(res), tuple(ref))
def test_parallelism2_00(self):
filename = LDPC_ALIST_DIR + "n_0100_k_0027_gap_04.alist"
gap = 4
dims = 5
LDPC_matrix_object = fec.ldpc_H_matrix(filename, gap)
k = LDPC_matrix_object.k()
dims1 = 16
dims2 = 16
enc = map((lambda b: map(
(lambda a: fec.ldpc_par_mtrx_encoder.make_H(LDPC_matrix_object)),
range(0, dims1))), range(0, dims2))
threading = 'capillary'
self.assertRaises(
AttributeError,
lambda: extended_encoder(enc, threading=threading, puncpat="11"))
def test_004_big_input(self):
num_blocks = 30
block_size = 1024
num_info_bits = block_size // 8
data, ref, polar_encoder = self.get_test_data(block_size,
num_info_bits,
num_blocks)
src = blocks.vector_source_b(data, False)
enc_block = extended_encoder(polar_encoder, None, '11')
snk = blocks.vector_sink_b(1)
self.tb.connect(src, enc_block, snk)
self.tb.run()
res = np.array(snk.data()).astype(dtype=int)
self.assertTupleEqual(tuple(res), tuple(ref))
def test_parallelism1_05(self):
filename = LDPC_ALIST_DIR + "n_0100_k_0027_gap_04.alist"
gap = 4
dims = 5
enc = []
for n in range(0,dims):
H = fec.ldpc_H_matrix(filename, gap)
enc.append(fec.ldpc_par_mtrx_encoder.make_H(H))
dec = []
for n in range(0,dims):
H = fec.ldpc_H_matrix(filename, gap)
dec.append(fec.ldpc_bit_flip_decoder.make(H.get_base_sptr()))
k = H.k()
threading = 'capillary'
self.assertRaises(AttributeError, lambda: extended_encoder(enc, threading=threading, puncpat="11"))
def test_parallelism1_05(self):
filename = LDPC_ALIST_DIR + "n_0100_k_0027_gap_04.alist"
gap = 4
dims = 5
enc = []
for n in range(0, dims):
H = fec.ldpc_H_matrix(filename, gap)
enc.append(fec.ldpc_par_mtrx_encoder.make_H(H))
dec = []
for n in range(0, dims):
H = fec.ldpc_H_matrix(filename, gap)
dec.append(fec.ldpc_bit_flip_decoder.make(H.get_base_sptr()))
k = H.k()
threading = 'capillary'
self.assertRaises(
AttributeError,
lambda: extended_encoder(enc, threading=threading, puncpat="11"))