def test_003_t (self):
""" two states, random switching """
n_bytes = 10000
ber = (0, 0.5)
trans_matrix = (0.5, 0.5,
0.5, 0.5)
src = gr.glfsr_source_b(32) # Create some pseudo-random bits
head = gr.head(1, n_bytes)
chan = cc.markovchan_bb(ber, trans_matrix, 8)
ber = cc.ber_b(8)
sink_state = gr.vector_sink_i()
self.tb.connect(src, head, chan, (ber, 0))
self.tb.connect(head, (ber, 1))
self.tb.connect((chan, 1), sink_state)
self.tb.run ()
n_times_in_state_1 = np.sum(sink_state.data())
print "\nNumber of times in state 1 = " + str(n_times_in_state_1)
print " Expected value = " + str(n_bytes/2)
self.assertTrue(n_times_in_state_1 > 3500 and n_times_in_state_1 < 6500,
"Due to the statistical nature of the bsc, this can actually fail (though very unlikely). Try again.")
print " Measured BER = " + str(ber.ber())
print "Expected value = 0.25"
self.assertTrue(abs(ber.ber()- 0.25) < 0.05,
msg="Due to the statistical nature of the bsc, this can actually fail (though very unlikely). Try again.")
def test_stream_interleaving_symbols(self):
n_rows = 32
n_cols = 128
src = gr.glfsr_source_b(32)
head = gr.head(gr.sizeof_char, n_rows * n_cols * 3)
interleaver = cc.blockinterleaver_bb(n_rows, n_cols)
deinterleaver = cc.blockdeinterleaver_bb(n_rows, n_cols)
ber = cc.ber_b(8)
self.tb.connect(src, head, interleaver, deinterleaver, ber)
self.tb.connect(head, (ber, 1))
self.tb.run()
self.assertEqual(ber.ber(), 0)
def test_stream_interleaving_symbols(self):
n_rows = 32
n_cols = 128
src = gr.glfsr_source_b(32)
head = gr.head(gr.sizeof_char, n_rows * n_cols * 3)
interleaver = cc.blockinterleaver_bb(n_rows, n_cols)
deinterleaver = cc.blockdeinterleaver_bb(n_rows, n_cols)
ber = cc.ber_b(8)
self.tb.connect(src, head, interleaver, deinterleaver, ber)
self.tb.connect(head, (ber, 1))
self.tb.run()
self.assertEqual(ber.ber(), 0)
def test_002_packeddata (self):
""" Pack 4 bits into a byte and run the check again """
src1 = gr.vector_source_b((0b1111, 0b1111, 0b1111))
src2 = gr.vector_source_b((0b1111, 0b1111, 0b1110))
ber = chancoding.ber_b(4)
sink = gr.vector_sink_f()
self.tb.connect(src1, (ber, 0))
self.tb.connect(src2, (ber, 1))
self.tb.connect(ber, sink)
self.tb.run()
self.assertAlmostEqual(ber.ber(), 1./12)
self.assertEqual(ber.bit_errors(), 1)
self.assertFloatTuplesAlmostEqual(sink.data(), (0,0,1./12), 8)
def test_001_berout (self):
""" Check the float output and the ber() function with unpacked data """
src1 = gr.vector_source_b((1,1,1,1,1,1,1,1,1,1))
src2 = gr.vector_source_b((1,1,1,1,1,1,1,1,1,0))
ber = chancoding.ber_b()
sink = gr.vector_sink_f()
self.tb.connect(src1, (ber, 0))
self.tb.connect(src2, (ber, 1))
self.tb.connect(ber, sink)
self.tb.run()
self.assertAlmostEqual(ber.ber(), 0.1)
self.assertEqual(ber.bit_errors(), 1)
self.assertFloatTuplesAlmostEqual(sink.data(), (0,0,0,0,0,0,0,0,0,0.1), 8)
def test_002_packeddata(self):
""" Pack 4 bits into a byte and run the check again """
src1 = gr.vector_source_b((0b1111, 0b1111, 0b1111))
src2 = gr.vector_source_b((0b1111, 0b1111, 0b1110))
ber = chancoding.ber_b(4)
sink = gr.vector_sink_f()
self.tb.connect(src1, (ber, 0))
self.tb.connect(src2, (ber, 1))
self.tb.connect(ber, sink)
self.tb.run()
self.assertAlmostEqual(ber.ber(), 1. / 12)
self.assertEqual(ber.bit_errors(), 1)
self.assertFloatTuplesAlmostEqual(sink.data(), (0, 0, 1. / 12), 8)
def test_001_berout(self):
""" Check the float output and the ber() function with unpacked data """
src1 = gr.vector_source_b((1, 1, 1, 1, 1, 1, 1, 1, 1, 1))
src2 = gr.vector_source_b((1, 1, 1, 1, 1, 1, 1, 1, 1, 0))
ber = chancoding.ber_b()
sink = gr.vector_sink_f()
self.tb.connect(src1, (ber, 0))
self.tb.connect(src2, (ber, 1))
self.tb.connect(ber, sink)
self.tb.run()
self.assertAlmostEqual(ber.ber(), 0.1)
self.assertEqual(ber.bit_errors(), 1)
self.assertFloatTuplesAlmostEqual(sink.data(),
(0, 0, 0, 0, 0, 0, 0, 0, 0, 0.1), 8)
def test_002_t (self):
""" two state: one errorless, and the other can never be reached """
n_bytes = 10000
ber = (0, 0.5)
trans_matrix = (1.0, 0.0,
1.0, 0.0)
src = gr.glfsr_source_b(32) # Create some pseudo-random bits
head = gr.head(1, n_bytes)
chan = cc.markovchan_bb(ber, trans_matrix, 8)
ber = cc.ber_b(8)
sink_state = gr.vector_sink_i()
self.tb.connect(src, head, chan, (ber, 0))
self.tb.connect(head, (ber, 1))
self.tb.connect((chan, 1), sink_state)
self.tb.run ()
self.assertEqual(ber.ber(), 0)
self.assertEqual(sink_state.data(), (0,) * n_bytes, "State was not always 0!")
