git.gag.com Git - debian/gnuradio/blob - gnuradio-core/src/python/gnuradio/gr/qa_fft_filter.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright 2004,2005 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
  23 from gnuradio import gr, gr_unittest
  24 import sys
  25 import random
  26
  27 def make_random_complex_tuple(L):
  28     result = []
  29     for x in range(L):
  30         result.append(complex(random.uniform(-1000,1000),
  31                               random.uniform(-1000,1000)))
  32     return tuple(result)
  33
  34 def make_random_float_tuple(L):
  35     result = []
  36     for x in range(L):
  37         result.append(float(int(random.uniform(-1000,1000))))
  38     return tuple(result)
  39
  40
  41 def reference_filter_ccc(dec, taps, input):
  42     """
  43     compute result using conventional fir filter
  44     """
  45     fg = gr.flow_graph()
  46     #src = gr.vector_source_c(((0,) * (len(taps) - 1)) + input)
  47     src = gr.vector_source_c(input)
  48     op = gr.fir_filter_ccc(dec, taps)
  49     dst = gr.vector_sink_c()
  50     fg.connect(src, op, dst)
  51     fg.run()
  52     return dst.data()
  53
  54 def reference_filter_fff(dec, taps, input):
  55     """
  56     compute result using conventional fir filter
  57     """
  58     fg = gr.flow_graph()
  59     #src = gr.vector_source_f(((0,) * (len(taps) - 1)) + input)
  60     src = gr.vector_source_f(input)
  61     op = gr.fir_filter_fff(dec, taps)
  62     dst = gr.vector_sink_f()
  63     fg.connect(src, op, dst)
  64     fg.run()
  65     return dst.data()
  66
  67
  68 def print_complex(x):
  69     for i in x:
  70         i = complex(i)
  71         sys.stdout.write("(%6.3f,%6.3fj), " % (i.real, i.imag))
  72     sys.stdout.write('\n')
  73
  74
  75 class test_fft_filter(gr_unittest.TestCase):
  76
  77     def setUp(self):
  78         self.fg = gr.flow_graph ()
  79
  80     def tearDown(self):
  81         self.fg = None
  82
  83     def assert_fft_ok2(self, expected_result, result_data):
  84         expected_result = expected_result[:len(result_data)]
  85         self.assertComplexTuplesAlmostEqual2 (expected_result, result_data,
  86                                               abs_eps=1e-9, rel_eps=4e-4)
  87
  88     def assert_fft_float_ok2(self, expected_result, result_data, abs_eps=1e-9, rel_eps=4e-4):
  89         expected_result = expected_result[:len(result_data)]
  90         self.assertFloatTuplesAlmostEqual2 (expected_result, result_data,
  91                                             abs_eps, rel_eps)
  92
  93     #def test_ccc_000(self):
  94     #    self.assertRaises (RuntimeError, gr.fft_filter_ccc, 2, (1,))
  95
  96     def test_ccc_001(self):
  97         src_data = (0,1,2,3,4,5,6,7)
  98         taps = (1,)
  99         expected_result = tuple([complex(x) for x in (0,1,2,3,4,5,6,7)])
 100         src = gr.vector_source_c(src_data)
 101         op = gr.fft_filter_ccc(1, taps)
 102         dst = gr.vector_sink_c()
 103         self.fg.connect(src, op, dst)
 104         self.fg.run()
 105         result_data = dst.data()
 106         #print 'expected:', expected_result
 107         #print 'results: ', result_data
 108         self.assertComplexTuplesAlmostEqual (expected_result, result_data, 5)
 109
 110
 111     def test_ccc_002(self):
 112         src_data = (0,1,2,3,4,5,6,7)
 113         taps = (2,)
 114         expected_result = tuple([2 * complex(x) for x in (0,1,2,3,4,5,6,7)])
 115         src = gr.vector_source_c(src_data)
 116         op = gr.fft_filter_ccc(1, taps)
 117         dst = gr.vector_sink_c()
 118         self.fg.connect(src, op, dst)
 119         self.fg.run()
 120         result_data = dst.data()
 121         #print 'expected:', expected_result
 122         #print 'results: ', result_data
 123         self.assertComplexTuplesAlmostEqual (expected_result, result_data, 5)
 124
 125     def test_ccc_004(self):
 126         random.seed(0)
 127         for i in xrange(25):
 128             # sys.stderr.write("\n>>> Loop = %d\n" % (i,))
 129             src_len = 4*1024
 130             src_data = make_random_complex_tuple(src_len)
 131             ntaps = int(random.uniform(2, 1000))
 132             taps = make_random_complex_tuple(ntaps)
 133             expected_result = reference_filter_ccc(1, taps, src_data)
 134
 135             src = gr.vector_source_c(src_data)
 136             op = gr.fft_filter_ccc(1, taps)
 137             dst = gr.vector_sink_c()
 138             self.fg.connect(src, op, dst)
 139             self.fg.run()
 140             result_data = dst.data()
 141
 142             self.assert_fft_ok2(expected_result, result_data)
 143
 144     def test_ccc_005(self):
 145         random.seed(0)
 146         for i in xrange(25):
 147             # sys.stderr.write("\n>>> Loop = %d\n" % (i,))
 148             dec = i + 1
 149             src_len = 4*1024
 150             src_data = make_random_complex_tuple(src_len)
 151             ntaps = int(random.uniform(2, 100))
 152             taps = make_random_complex_tuple(ntaps)
 153             expected_result = reference_filter_ccc(dec, taps, src_data)
 154
 155             src = gr.vector_source_c(src_data)
 156             op = gr.fft_filter_ccc(dec, taps)
 157             dst = gr.vector_sink_c()
 158             self.fg.connect(src, op, dst)
 159             self.fg.run()
 160             result_data = dst.data()
 161
 162             self.assert_fft_ok2(expected_result, result_data)
 163
 164     # ----------------------------------------------------------------
 165     # test _fff version
 166     # ----------------------------------------------------------------
 167
 168     def test_fff_001(self):
 169         src_data = (0,1,2,3,4,5,6,7)
 170         taps = (1,)
 171         expected_result = tuple([float(x) for x in (0,1,2,3,4,5,6,7)])
 172         src = gr.vector_source_f(src_data)
 173         op = gr.fft_filter_fff(1, taps)
 174         dst = gr.vector_sink_f()
 175         self.fg.connect(src, op, dst)
 176         self.fg.run()
 177         result_data = dst.data()
 178         #print 'expected:', expected_result
 179         #print 'results: ', result_data
 180         self.assertFloatTuplesAlmostEqual (expected_result, result_data, 5)
 181
 182
 183     def test_fff_002(self):
 184         src_data = (0,1,2,3,4,5,6,7)
 185         taps = (2,)
 186         expected_result = tuple([2 * float(x) for x in (0,1,2,3,4,5,6,7)])
 187         src = gr.vector_source_f(src_data)
 188         op = gr.fft_filter_fff(1, taps)
 189         dst = gr.vector_sink_f()
 190         self.fg.connect(src, op, dst)
 191         self.fg.run()
 192         result_data = dst.data()
 193         #print 'expected:', expected_result
 194         #print 'results: ', result_data
 195         self.assertFloatTuplesAlmostEqual (expected_result, result_data, 5)
 196
 197     def xtest_fff_003(self):
 198         random.seed(0)
 199         for i in xrange(25):
 200             sys.stderr.write("\n>>> Loop = %d\n" % (i,))
 201             src_len = 4096
 202             src_data = make_random_float_tuple(src_len)
 203             ntaps = int(random.uniform(2, 1000))
 204             taps = make_random_float_tuple(ntaps)
 205             expected_result = reference_filter_fff(1, taps, src_data)
 206
 207             src = gr.vector_source_f(src_data)
 208             op = gr.fft_filter_fff(1, taps)
 209             dst = gr.vector_sink_f()
 210             self.fg.connect(src, op, dst)
 211             self.fg.run()
 212             result_data = dst.data()
 213
 214             #print "src_len =", src_len, " ntaps =", ntaps
 215             try:
 216                 self.assert_fft_float_ok2(expected_result, result_data, abs_eps=1.0)
 217             except:
 218                 expected = open('expected', 'w')
 219                 for x in expected_result:
 220                     expected.write(`x` + '\n')
 221                 actual = open('actual', 'w')
 222                 for x in result_data:
 223                     actual.write(`x` + '\n')
 224                 raise
 225
 226     def xtest_fff_004(self):
 227         random.seed(0)
 228         for i in xrange(25):
 229             sys.stderr.write("\n>>> Loop = %d\n" % (i,))
 230             src_len = 4*1024
 231             src_data = make_random_float_tuple(src_len)
 232             ntaps = int(random.uniform(2, 1000))
 233             taps = make_random_float_tuple(ntaps)
 234             expected_result = reference_filter_fff(1, taps, src_data)
 235
 236             src = gr.vector_source_f(src_data)
 237             op = gr.fft_filter_fff(1, taps)
 238             dst = gr.vector_sink_f()
 239             self.fg.connect(src, op, dst)
 240             self.fg.run()
 241             result_data = dst.data()
 242
 243             self.assert_fft_float_ok2(expected_result, result_data, abs_eps=2.0)
 244
 245     def xtest_fff_005(self):
 246         random.seed(0)
 247         for i in xrange(25):
 248             sys.stderr.write("\n>>> Loop = %d\n" % (i,))
 249             dec = i + 1
 250             src_len = 4*1024
 251             src_data = make_random_float_tuple(src_len)
 252             ntaps = int(random.uniform(2, 100))
 253             taps = make_random_float_tuple(ntaps)
 254             expected_result = reference_filter_fff(dec, taps, src_data)
 255
 256             src = gr.vector_source_f(src_data)
 257             op = gr.fft_filter_fff(dec, taps)
 258             dst = gr.vector_sink_f()
 259             self.fg.connect(src, op, dst)
 260             self.fg.run()
 261             result_data = dst.data()
 262
 263             self.assert_fft_float_ok2(expected_result, result_data)
 264
 265
 266 if __name__ == '__main__':
 267     gr_unittest.main ()
 268