def test_002_one_vector(self): print "test_002_one_vector" expo = 6 block_size = 2 ** expo num_info_bits = 2 ** (expo - 1) max_list_size = 2 ** (expo - 2) num_frozen_bits = block_size - num_info_bits frozen_bit_positions = cc.frozen_bit_positions(block_size, num_info_bits, 0.0) frozen_bit_values = np.array([0] * num_frozen_bits,) bits = np.random.randint(2, size=num_info_bits) encoder = PolarEncoder(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values) data = encoder.encode(bits) gr_data = 2.0 * data - 1.0 polar_decoder = fec.polar_decoder_sc_list.make(max_list_size, block_size, num_info_bits, frozen_bit_positions, frozen_bit_values) src = blocks.vector_source_f(gr_data, False) dec_block = extended_decoder(polar_decoder, None) snk = blocks.vector_sink_b(1) self.tb.connect(src, dec_block) self.tb.connect(dec_block, snk) self.tb.run() res = np.array(snk.data()).astype(dtype=int) print("\ninput -> result -> bits") print(data) print(res) print(bits) self.assertTupleEqual(tuple(res), tuple(bits))
def test_003_stream(self): print "test_003_stream" nframes = 5 expo = 8 block_size = 2 ** expo num_info_bits = 2 ** (expo - 1) max_list_size = 2 ** (expo - 2) num_frozen_bits = block_size - num_info_bits frozen_bit_positions = cc.frozen_bit_positions(block_size, num_info_bits, 0.0) frozen_bit_values = np.array([0] * num_frozen_bits,) encoder = PolarEncoder(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values) ref = np.array([], dtype=int) data = np.array([], dtype=int) for i in range(nframes): b = np.random.randint(2, size=num_info_bits) d = encoder.encode(b) data = np.append(data, d) ref = np.append(ref, b) gr_data = 2.0 * data - 1.0 polar_decoder = fec.polar_decoder_sc_list.make(max_list_size, block_size, num_info_bits, frozen_bit_positions, frozen_bit_values) src = blocks.vector_source_f(gr_data, False) dec_block = extended_decoder(polar_decoder, None) snk = blocks.vector_sink_b(1) self.tb.connect(src, dec_block) self.tb.connect(dec_block, snk) self.tb.run() res = np.array(snk.data()).astype(dtype=int) self.assertTupleEqual(tuple(res), tuple(ref))
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_parallelism2_01(self): frame_size = 30 dims1 = 16 dims2 = 16 dec = map((lambda b: map((lambda a: fec.dummy_decoder_make(frame_size*8)), range(0,dims1))), range(0,dims2)) threading = 'capillary' self.assertRaises(AttributeError, lambda: extended_decoder(dec, threading=threading, puncpat="11"))
def test_parallelism1_06(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_decoder(dec, threading=threading, puncpat="11"))
def test_parallelism1_06(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() dec = map((lambda a: fec.ldpc_bit_flip_decoder.make(LDPC_matrix_object.get_base_sptr())), range(0,dims)) threading = 'capillary' self.assertRaises(AttributeError, lambda: extended_decoder(dec, threading=threading, puncpat="11"))
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_parallelism1_06(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() dec = map((lambda a: fec.ldpc_bit_flip_decoder.make(LDPC_matrix_object. get_base_sptr())), range(0, dims)) threading = 'capillary' self.assertRaises( AttributeError, lambda: extended_decoder(dec, threading=threading, puncpat="11"))
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_002_one_vector(self): block_power = 4 block_size = 2 ** block_power num_info_bits = block_size // 2 frozen_bit_positions = cc.frozen_bit_positions(block_size, num_info_bits, 0.0) bits, gr_data = self.generate_test_data(block_size, num_info_bits, frozen_bit_positions, 1, False) polar_decoder = fec.polar_decoder_sc_systematic.make(block_size, num_info_bits, frozen_bit_positions) src = blocks.vector_source_f(gr_data, False) dec_block = extended_decoder(polar_decoder, None) snk = blocks.vector_sink_b(1) self.tb.connect(src, dec_block) self.tb.connect(dec_block, snk) self.tb.run() res = np.array(snk.data()).astype(dtype=int) self.assertTupleEqual(tuple(res), tuple(bits))
def test_002_one_vector(self): block_power = 10 block_size = 2 ** block_power num_info_bits = 2 ** (block_power - 1) num_frozen_bits = block_size - num_info_bits frozen_bit_positions = cc.frozen_bit_positions(block_size, num_info_bits, 0.0) frozen_bit_values = np.array([0] * num_frozen_bits,) bits, gr_data = self.generate_test_data(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values, 1, True) polar_decoder = fec.polar_decoder_sc.make(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values) src = blocks.vector_source_f(gr_data, False) dec_block = extended_decoder(polar_decoder, None) snk = blocks.vector_sink_b(1) self.tb.connect(src, dec_block) self.tb.connect(dec_block, snk) self.tb.run() res = np.array(snk.data()).astype(dtype=int) self.assertTupleEqual(tuple(res), tuple(bits))
def test_003_stream(self): nframes = 3 block_power = 8 block_size = 2 ** block_power num_info_bits = 2 ** (block_power - 1) num_frozen_bits = block_size - num_info_bits frozen_bit_positions = cc.frozen_bit_positions(block_size, num_info_bits, 0.0) frozen_bit_values = np.array([0] * num_frozen_bits,) bits, gr_data = self.generate_test_data(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values, nframes, False) polar_decoder = fec.polar_decoder_sc.make(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values) src = blocks.vector_source_f(gr_data, False) dec_block = extended_decoder(polar_decoder, None) snk = blocks.vector_sink_b(1) self.tb.connect(src, dec_block) self.tb.connect(dec_block, snk) self.tb.run() res = np.array(snk.data()).astype(dtype=int) self.assertTupleEqual(tuple(res), tuple(bits))
def test_003_stream(self): nframes = 3 block_power = 8 block_size = 2**block_power num_info_bits = block_size // 2 frozen_bit_positions = cc.frozen_bit_positions(block_size, num_info_bits, 0.0) bits, gr_data = self.generate_test_data(block_size, num_info_bits, frozen_bit_positions, nframes, False) polar_decoder = fec.polar_decoder_sc_systematic.make( block_size, num_info_bits, frozen_bit_positions) src = blocks.vector_source_f(gr_data, False) dec_block = extended_decoder(polar_decoder, None) snk = blocks.vector_sink_b(1) self.tb.connect(src, dec_block) self.tb.connect(dec_block, snk) self.tb.run() res = np.array(snk.data()).astype(dtype=int) self.assertTupleEqual(tuple(res), tuple(bits))