Example #1
0
    def xtest_fff_004(self):
        random.seed(0)
        for i in xrange(25):
            sys.stderr.write("\n>>> Loop = %d\n" % (i, ))
            src_len = 4096
            src_data = make_random_float_tuple(src_len)
            ntaps = int(random.uniform(2, 1000))
            taps = make_random_float_tuple(ntaps)
            expected_result = reference_filter_fff(1, taps, src_data)

            src = gr.vector_source_f(src_data)
            op = filter.fft_filter_fff(1, taps)
            dst = gr.vector_sink_f()
            tb = gr.top_block()
            tb.connect(src, op, dst)
            tb.run()
            result_data = dst.data()

            #print "src_len =", src_len, " ntaps =", ntaps
            try:
                self.assert_fft_float_ok2(expected_result,
                                          result_data,
                                          abs_eps=1.0)
            except:
                expected = open('expected', 'w')
                for x in expected_result:
                    expected.write( ` x ` + '\n')
                actual = open('actual', 'w')
                for x in result_data:
                    actual.write( ` x ` + '\n')
                raise
    def xtest_fff_004(self):
        random.seed(0)
        for i in xrange(25):
            sys.stderr.write("\n>>> Loop = %d\n" % (i,))
            src_len = 4096
            src_data = make_random_float_tuple(src_len)
            ntaps = int(random.uniform(2, 1000))
            taps = make_random_float_tuple(ntaps)
            expected_result = reference_filter_fff(1, taps, src_data)

            src = gr.vector_source_f(src_data)
            op = filter.fft_filter_fff(1, taps)
            dst = gr.vector_sink_f()
            tb = gr.top_block()
            tb.connect(src, op, dst)
            tb.run()
            result_data = dst.data()

            #print "src_len =", src_len, " ntaps =", ntaps
            try:
                self.assert_fft_float_ok2(expected_result, result_data, abs_eps=1.0)
            except:
                expected = open('expected', 'w')
                for x in expected_result:
                    expected.write(`x` + '\n')
                actual = open('actual', 'w')
                for x in result_data:
                    actual.write(`x` + '\n')
                raise
Example #3
0
    def test_fff_get0(self):
        random.seed(0)
        for i in xrange(25):
            ntaps = int(random.uniform(2, 100))
            taps = make_random_float_tuple(ntaps)

            op = filter.fft_filter_fff(1, taps)
            result_data = op.taps()
            #print result_data

            self.assertEqual(taps, result_data)
Example #4
0
    def test_fff_get0(self):
        random.seed(0)
        for i in xrange(25):
            ntaps = int(random.uniform(2, 100))
            taps = make_random_float_tuple(ntaps)

            op = filter.fft_filter_fff(1, taps)
            result_data = op.taps()
            #print result_data

            self.assertEqual(taps, result_data)
Example #5
0
 def test_fff_001(self):
     tb = gr.top_block()
     src_data = (0, 1, 2, 3, 4, 5, 6, 7)
     taps = (1, )
     expected_result = tuple([float(x) for x in (0, 1, 2, 3, 4, 5, 6, 7)])
     src = gr.vector_source_f(src_data)
     op = filter.fft_filter_fff(1, taps)
     dst = gr.vector_sink_f()
     tb.connect(src, op, dst)
     tb.run()
     result_data = dst.data()
     #print 'expected:', expected_result
     #print 'results: ', result_data
     self.assertFloatTuplesAlmostEqual(expected_result, result_data, 5)
 def test_fff_003(self):
     # Test 02 with nthreads
     tb = gr.top_block()
     src_data = (0,1,2,3,4,5,6,7)
     taps = (2,)
     nthreads = 2
     expected_result = tuple([2 * float(x) for x in (0,1,2,3,4,5,6,7)])
     src = gr.vector_source_f(src_data)
     op = filter.fft_filter_fff(1, taps, nthreads)
     dst = gr.vector_sink_f()
     tb.connect(src, op, dst)
     tb.run()
     result_data = dst.data()
     self.assertFloatTuplesAlmostEqual (expected_result, result_data, 5)
 def test_fff_002(self):
     tb = gr.top_block()
     src_data = (0,1,2,3,4,5,6,7)
     taps = (2,)
     expected_result = tuple([2 * float(x) for x in (0,1,2,3,4,5,6,7)])
     src = gr.vector_source_f(src_data)
     op = filter.fft_filter_fff(1, taps)
     dst = gr.vector_sink_f()
     tb.connect(src, op, dst)
     tb.run()
     result_data = dst.data()
     #print 'expected:', expected_result
     #print 'results: ', result_data
     self.assertFloatTuplesAlmostEqual (expected_result, result_data, 5)
Example #8
0
 def test_fff_003(self):
     # Test 02 with nthreads
     tb = gr.top_block()
     src_data = (0, 1, 2, 3, 4, 5, 6, 7)
     taps = (2, )
     nthreads = 2
     expected_result = tuple(
         [2 * float(x) for x in (0, 1, 2, 3, 4, 5, 6, 7)])
     src = gr.vector_source_f(src_data)
     op = filter.fft_filter_fff(1, taps, nthreads)
     dst = gr.vector_sink_f()
     tb.connect(src, op, dst)
     tb.run()
     result_data = dst.data()
     self.assertFloatTuplesAlmostEqual(expected_result, result_data, 5)
    def xtest_fff_005(self):
        random.seed(0)
        for i in xrange(25):
            sys.stderr.write("\n>>> Loop = %d\n" % (i,))
            src_len = 4*1024
            src_data = make_random_float_tuple(src_len)
            ntaps = int(random.uniform(2, 1000))
            taps = make_random_float_tuple(ntaps)
            expected_result = reference_filter_fff(1, taps, src_data)

            src = gr.vector_source_f(src_data)
            op = filter.fft_filter_fff(1, taps)
            dst = gr.vector_sink_f()
            tb = gr.top_block()
            tb.connect(src, op, dst)
            tb.run()
            result_data = dst.data()

            self.assert_fft_float_ok2(expected_result, result_data, abs_eps=2.0)
Example #10
0
    def xtest_fff_006(self):
        random.seed(0)
        for i in xrange(25):
            sys.stderr.write("\n>>> Loop = %d\n" % (i, ))
            dec = i + 1
            src_len = 4 * 1024
            src_data = make_random_float_tuple(src_len)
            ntaps = int(random.uniform(2, 100))
            taps = make_random_float_tuple(ntaps)
            expected_result = reference_filter_fff(dec, taps, src_data)

            src = gr.vector_source_f(src_data)
            op = filter.fft_filter_fff(dec, taps)
            dst = gr.vector_sink_f()
            tb = gr.top_block()
            tb.connect(src, op, dst)
            tb.run()
            result_data = dst.data()

            self.assert_fft_float_ok2(expected_result, result_data)
Example #11
0
    def xtest_fff_007(self):
        # test decimation with nthreads
        random.seed(0)
        nthreads = 2
        for i in xrange(25):
            sys.stderr.write("\n>>> Loop = %d\n" % (i,))
            dec = i + 1
            src_len = 4*1024
            src_data = make_random_float_tuple(src_len)
            ntaps = int(random.uniform(2, 100))
            taps = make_random_float_tuple(ntaps)
            expected_result = reference_filter_fff(dec, taps, src_data)

            src = blocks.vector_source_f(src_data)
            op = filter.fft_filter_fff(dec, taps, nthreads)
            dst = blocks.vector_sink_f()
    	    tb = gr.top_block()
            tb.connect(src, op, dst)
            tb.run()
            result_data = dst.data()

            self.assert_fft_float_ok2(expected_result, result_data)