1#!/usr/bin/env python
2#
3# Copyright 2015 Free Software Foundation, Inc.
4#
5# This file is part of GNU Radio
6#
7# GNU Radio is free software; you can redistribute it and/or modify
8# it under the terms of the GNU General Public License as published by
9# the Free Software Foundation; either version 3, or (at your option)
10# any later version.
11#
12# GNU Radio is distributed in the hope that it will be useful,
13# but WITHOUT ANY WARRANTY; without even the implied warranty of
14# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15# GNU General Public License for more details.
16#
17# You should have received a copy of the GNU General Public License
18# along with GNU Radio; see the file COPYING.  If not, write to
19# the Free Software Foundation, Inc., 51 Franklin Street,
20# Boston, MA 02110-1301, USA.
21#
22
23from __future__ import print_function
24from __future__ import absolute_import
25from __future__ import division
26
27
28import numpy as np
29
30from gnuradio import gr, gr_unittest, blocks, fec
31from gnuradio.fec import extended_decoder
32from gnuradio.fec.polar.encoder import PolarEncoder
33from gnuradio.fec.polar import channel_construction as cc
34
35# import os
36# print('PID:', os.getpid())
37# raw_input('tell me smth')
38
39
40class test_polar_decoder_sc_list(gr_unittest.TestCase):
41
42    def setUp(self):
43        self.tb = gr.top_block()
44
45    def tearDown(self):
46        self.tb = None
47
48    def test_001_setup(self):
49        block_size = 16
50        num_info_bits = 8
51        max_list_size = 4
52        frozen_bit_positions = np.arange(block_size - num_info_bits)
53        frozen_bit_values = np.array([],)
54
55        polar_decoder = fec.polar_decoder_sc_list.make(max_list_size, block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)
56
57        self.assertEqual(num_info_bits, polar_decoder.get_output_size())
58        self.assertEqual(block_size, polar_decoder.get_input_size())
59        self.assertFloatTuplesAlmostEqual((float(num_info_bits) / block_size, ), (polar_decoder.rate(), ))
60        self.assertFalse(polar_decoder.set_frame_size(10))
61
62    def test_002_one_vector(self):
63        print("test_002_one_vector")
64        expo = 6
65        block_size = 2 ** expo
66        num_info_bits = 2 ** (expo - 1)
67        max_list_size = 2 ** (expo - 2)
68        num_frozen_bits = block_size - num_info_bits
69        frozen_bit_positions = cc.frozen_bit_positions(block_size, num_info_bits, 0.0)
70        frozen_bit_values = np.array([0] * num_frozen_bits,)
71
72        bits = np.random.randint(2, size=num_info_bits)
73        encoder = PolarEncoder(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)
74        data = encoder.encode(bits)
75        gr_data = 2.0 * data - 1.0
76
77        polar_decoder = fec.polar_decoder_sc_list.make(max_list_size, block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)
78        src = blocks.vector_source_f(gr_data, False)
79        dec_block = extended_decoder(polar_decoder, None)
80        snk = blocks.vector_sink_b(1)
81
82        self.tb.connect(src, dec_block)
83        self.tb.connect(dec_block, snk)
84        self.tb.run()
85
86        res = np.array(snk.data()).astype(dtype=int)
87
88        print("\ninput -> result -> bits")
89        print(data)
90        print(res)
91        print(bits)
92
93        self.assertTupleEqual(tuple(res), tuple(bits))
94
95    def test_003_stream(self):
96        print("test_003_stream")
97        nframes = 5
98        expo = 8
99        block_size = 2 ** expo
100        num_info_bits = 2 ** (expo - 1)
101        max_list_size = 2 ** (expo - 2)
102        num_frozen_bits = block_size - num_info_bits
103        frozen_bit_positions = cc.frozen_bit_positions(block_size, num_info_bits, 0.0)
104        frozen_bit_values = np.array([0] * num_frozen_bits,)
105
106        encoder = PolarEncoder(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)
107
108        ref = np.array([], dtype=int)
109        data = np.array([], dtype=int)
110        for i in range(nframes):
111            b = np.random.randint(2, size=num_info_bits)
112            d = encoder.encode(b)
113            data = np.append(data, d)
114            ref = np.append(ref, b)
115        gr_data = 2.0 * data - 1.0
116
117        polar_decoder = fec.polar_decoder_sc_list.make(max_list_size, block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)
118        src = blocks.vector_source_f(gr_data, False)
119        dec_block = extended_decoder(polar_decoder, None)
120        snk = blocks.vector_sink_b(1)
121
122        self.tb.connect(src, dec_block)
123        self.tb.connect(dec_block, snk)
124        self.tb.run()
125
126        res = np.array(snk.data()).astype(dtype=int)
127        self.assertTupleEqual(tuple(res), tuple(ref))
128
129
130if __name__ == '__main__':
131    gr_unittest.run(test_polar_decoder_sc_list, "test_polar_decoder_sc_list.xml")
132