Пример #1
0
    def test_001(self):
        tb = self.tb

        src1_data = (0,0.2,-0.3,0,12,0)
        src2_data = (0,0.0,3.0,0,10,0)
        src3_data = (0,0.0,3.0,0,1,0)

        src1 = blocks.vector_source_f(src1_data)
        s2v1 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data))
        tb.connect(src1, s2v1)

        src2 = blocks.vector_source_f(src2_data)
        s2v2 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data))
        tb.connect(src2, s2v2)

        src3 = blocks.vector_source_f(src3_data)
        s2v3 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data))
        tb.connect(src3, s2v3)

        dst1 = blocks.vector_sink_s()
        dst2 = blocks.vector_sink_s()
        argmax = blocks.argmax_fs(len(src1_data))

        tb.connect(s2v1, (argmax, 0))
        tb.connect(s2v2, (argmax, 1))
        tb.connect(s2v3, (argmax, 2))

        tb.connect((argmax,0), dst1)
        tb.connect((argmax,1), dst2)

        tb.run()
        index = dst1.data()
        source = dst2.data()
        self.assertEqual(index, (4,))
        self.assertEqual(source, (0,))
Пример #2
0
    def test_stretch_01(self):
        tb = self.tb

        data = 10*[1,]
        data0 = map(lambda x: x/20.0, data)
        data1 = map(lambda x: x/10.0, data)

        expected_result0 = 10*[0.05,]
        expected_result1 = 10*[0.1,]

        src0 = blocks.vector_source_f(data0, False)
        src1 = blocks.vector_source_f(data1, False)
        inter = blocks.streams_to_vector(gr.sizeof_float, 2)
        op = blocks.stretch_ff(0.1, 2)
        deinter = blocks.vector_to_streams(gr.sizeof_float, 2)
        dst0 = blocks.vector_sink_f()
        dst1 = blocks.vector_sink_f()
        
        tb.connect(src0, (inter,0))
        tb.connect(src1, (inter,1))
        tb.connect(inter, op)
        tb.connect(op, deinter)
        tb.connect((deinter,0), dst0)
        tb.connect((deinter,1), dst1)
        tb.run()

        dst0_data = dst0.data()
        dst1_data = dst1.data()

        self.assertFloatTuplesAlmostEqual(expected_result0, dst0_data, 4)
        self.assertFloatTuplesAlmostEqual(expected_result1, dst1_data, 4)
Пример #3
0
    def test_001(self):
        tb = self.tb

        src1_data = (0, 0.2, -0.3, 0, 12, 0)
        src2_data = (0, 0.0, 3.0, 0, 10, 0)
        src3_data = (0, 0.0, 3.0, 0, 1, 0)

        src1 = blocks.vector_source_f(src1_data)
        s2v1 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data))
        tb.connect(src1, s2v1)

        src2 = blocks.vector_source_f(src2_data)
        s2v2 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data))
        tb.connect(src2, s2v2)

        src3 = blocks.vector_source_f(src3_data)
        s2v3 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data))
        tb.connect(src3, s2v3)

        dst1 = blocks.vector_sink_s()
        dst2 = blocks.vector_sink_s()
        argmax = blocks.argmax_fs(len(src1_data))

        tb.connect(s2v1, (argmax, 0))
        tb.connect(s2v2, (argmax, 1))
        tb.connect(s2v3, (argmax, 2))

        tb.connect((argmax, 0), dst1)
        tb.connect((argmax, 1), dst2)

        tb.run()
        index = dst1.data()
        source = dst2.data()
        self.assertEqual(index, (4, ))
        self.assertEqual(source, (0, ))
Пример #4
0
 def test_interleaving(self):
     # Takes 3 streams (a, b and c)
     # Outputs 2 streams.
     # First (d) is interleaving of a and b.
     # Second (e) is interleaving of a and b and c.  c is taken in
     #     chunks of 2 which are reversed.
     A = (1, 2, 3, 4, 5)
     B = (11, 12, 13, 14, 15)
     C = (99, 98, 97, 96, 95, 94, 93, 92, 91, 90)
     expected_D = (1, 11, 2, 12, 3, 13, 4, 14, 5, 15)
     expected_E = (1, 11, 98, 99, 2, 12, 96, 97, 3, 13, 94, 95,
                   4, 14, 92, 93, 5, 15, 90, 91)
     mapping = [[(0, 0), (1, 0)], # mapping to produce D
                [(0, 0), (1, 0), (2, 1), (2, 0)], # mapping to produce E
                ]
     srcA = blocks.vector_source_f(A, False, 1)
     srcB = blocks.vector_source_f(B, False, 1)
     srcC = blocks.vector_source_f(C, False, 2)
     vmap =  blocks.vector_map(gr.sizeof_int, (1, 1, 2), mapping)
     dstD = blocks.vector_sink_f(2)
     dstE = blocks.vector_sink_f(4)
     self.tb.connect(srcA, (vmap, 0))
     self.tb.connect(srcB, (vmap, 1)) 
     self.tb.connect(srcC, (vmap, 2)) 
     self.tb.connect((vmap, 0), dstD)
     self.tb.connect((vmap, 1), dstE)
     self.tb.run()
     self.assertEqual(expected_D, dstD.data())
     self.assertEqual(expected_E, dstE.data())
Пример #5
0
 def test_add_f32(self):
     tb = gr.top_block()
     src0 = blocks.vector_source_f([1, 3, 5, 7, 9], False)
     src1 = blocks.vector_source_f([0, 2, 4, 6, 8], False)
     adder = add_2_f32_1_f32()
     sink = blocks.vector_sink_f()
     tb.connect((src0, 0), (adder, 0))
     tb.connect((src1, 0), (adder, 1))
     tb.connect(adder, sink)
     tb.run()
     self.assertEqual(sink.data(), (1, 5, 9, 13, 17))
Пример #6
0
 def test_add_f32(self):
     tb = gr.top_block()
     src0 = blocks.vector_source_f([1, 3, 5, 7, 9], False)
     src1 = blocks.vector_source_f([0, 2, 4, 6, 8], False)
     adder = add_2_f32_1_f32()
     sink = blocks.vector_sink_f()
     tb.connect((src0, 0), (adder, 0))
     tb.connect((src1, 0), (adder, 1))
     tb.connect(adder, sink)
     tb.run()
     self.assertEqual(sink.data(), (1, 5, 9, 13, 17))
Пример #7
0
 def test_float_to_complex_2(self):
     src1_data = (1.0, 3.0, 5.0, 7.0, 9.0)
     src2_data = (2.0, 4.0, 6.0, 8.0, 10.0)
     expected_data = (1+2j, 3+4j, 5+6j, 7+8j, 9+10j)
     src1 = blocks.vector_source_f(src1_data)
     src2 = blocks.vector_source_f(src2_data)
     op = blocks.float_to_complex()
     dst = blocks.vector_sink_c()
     self.tb.connect(src1, (op, 0))
     self.tb.connect(src2, (op, 1))
     self.tb.connect(op, dst)
     self.tb.run()
     self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
Пример #8
0
 def test_float_to_complex_2(self):
     src1_data = (1.0, 3.0, 5.0, 7.0, 9.0)
     src2_data = (2.0, 4.0, 6.0, 8.0, 10.0)
     expected_data = (1 + 2j, 3 + 4j, 5 + 6j, 7 + 8j, 9 + 10j)
     src1 = blocks.vector_source_f(src1_data)
     src2 = blocks.vector_source_f(src2_data)
     op = blocks.float_to_complex()
     dst = blocks.vector_sink_c()
     self.tb.connect(src1, (op, 0))
     self.tb.connect(src2, (op, 1))
     self.tb.connect(op, dst)
     self.tb.run()
     self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
Пример #9
0
    def help_stream_2ff(self, N, stream_sizes):
        v0 = blocks.vector_source_f(N*[1,], False)
        v1 = blocks.vector_source_f(N*[2,], False)

        mux = blocks.stream_mux(gr.sizeof_float, stream_sizes)

        dst = blocks.vector_sink_f ()

        self.tb.connect (v0, (mux,0))
        self.tb.connect (v1, (mux,1))
        self.tb.connect (mux, dst)
        self.tb.run ()

        return dst.data ()
Пример #10
0
    def test_descriptor_001(self):
        src_data = range(1000)
        expected_result = range(1000)

        filename = "tmp.32f"
        fhandle0 = open(filename, "wb")
        fd0 = fhandle0.fileno()

        src = blocks.vector_source_f(src_data)
        snk = blocks.file_descriptor_sink(gr.sizeof_float, fd0)

        self.tb.connect(src, snk)
        self.tb.run()
        os.fsync(fd0)
        fhandle0.close()

        fhandle1 = open(filename, "rb")
        fd1 = fhandle1.fileno()
        src2 = blocks.file_descriptor_source(gr.sizeof_float, fd1, False)
        snk2 = blocks.vector_sink_f()

        self.tb.disconnect(src, snk)
        self.tb.connect(src2, snk2)
        self.tb.run()
        os.fsync(fd1)
        fhandle1.close()

        os.remove(filename)

        result_data = snk2.data()
        self.assertFloatTuplesAlmostEqual(expected_result, result_data)
Пример #11
0
    def test_f_003(self):
        # Test scenariou where we have defined a puncture pattern with
        # more bits than the puncsize with a delay. The python code
        # doesn't account for this when creating self.expected, but
        # this should be equivalent to a puncpat of the correct size.

        self.puncsize = 4
        self.puncpat0 = 0x5555  # too many bits set
        self.puncpat1 = 0x55  # num bits = puncsize
        self.delay = 1

        src = blocks.vector_source_f(self.src_data)
        op0 = fec.puncture_ff(self.puncsize, self.puncpat0, self.delay)
        op1 = fec.puncture_ff(self.puncsize, self.puncpat1, self.delay)
        dst0 = blocks.vector_sink_f()
        dst1 = blocks.vector_sink_f()

        self.tb.connect(src, op0, dst0)
        self.tb.connect(src, op1, dst1)
        self.tb.run()

        dst_data0 = list(dst0.data())
        dst_data1 = list(dst1.data())

        self.assertEqual(dst_data1, dst_data0)
Пример #12
0
 def test_fir_filter_fcc_002(self):
     self.generate_fcc_source()
     expected_data = (
         (-6.94218761055e-05 - 9.90489479591e-06j),
         (-2.56973435171e-05 + 8.05932795629e-05j),
         (7.01698663761e-05 + 7.36373840482e-05j), (7.57163215894e-05 -
                                                    4.65324592369e-05j),
         (-3.01657128148e-05 - 0.000122838056996j), (-9.53659764491e-05 -
                                                     3.73945695173e-05j),
         (-2.33501577895e-05 + 0.000109135726234j), (6.65136758471e-05 +
                                                     0.000125709688291j),
         (3.08501912514e-05 - 9.16842873266e-06j), (-2.64703612629e-05 -
                                                    0.000135892929393j),
         (0.000136643866426 - 0.000162003751029j), (0.000501801609062 -
                                                    0.000185820827028j),
         (0.000694551155902 - 0.000299874518532j), (0.000424396857852 -
                                                    0.00038379128091j),
         (-9.1786707344e-05 - 0.000242479465669j), (-0.000337087287335 +
                                                    7.45999423089e-05j),
         (-0.000116414521472 + 0.000258556567132j), (0.000215422536712 +
                                                     0.000116706112749j),
         (0.000224391726078 - 0.000156330308528j), (-5.96956087975e-05 -
                                                    0.000211163976928j))
     src = blocks.vector_source_f(self.src_data)
     op = filter.freq_xlating_fir_filter_fcc(4, self.taps, self.fc, self.fs)
     dst = blocks.vector_sink_c()
     self.tb.connect(src, op, dst)
     self.tb.run()
     result_data = dst.data()
     self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:],
                                         5)
 def test_fir_filter_fcc_002(self):
     self.generate_fcc_source()
     expected_data = ((-6.94218761055e-05-9.90489479591e-06j),
                      (-2.56973435171e-05+8.05932795629e-05j),
                      (7.01698663761e-05+7.36373840482e-05j),
                      (7.57163215894e-05-4.65324592369e-05j),
                      (-3.01657128148e-05-0.000122838056996j),
                      (-9.53659764491e-05-3.73945695173e-05j),
                      (-2.33501577895e-05+0.000109135726234j),
                      (6.65136758471e-05+0.000125709688291j),
                      (3.08501912514e-05-9.16842873266e-06j),
                      (-2.64703612629e-05-0.000135892929393j),
                      (0.000136643866426-0.000162003751029j),
                      (0.000501801609062-0.000185820827028j),
                      (0.000694551155902-0.000299874518532j),
                      (0.000424396857852-0.00038379128091j),
                      (-9.1786707344e-05-0.000242479465669j),
                      (-0.000337087287335+7.45999423089e-05j),
                      (-0.000116414521472+0.000258556567132j),
                      (0.000215422536712+0.000116706112749j),
                      (0.000224391726078-0.000156330308528j),
                      (-5.96956087975e-05-0.000211163976928j))
     src = blocks.vector_source_f(self.src_data)
     op  = filter.freq_xlating_fir_filter_fcc(4, self.taps, self.fc, self.fs)
     dst = blocks.vector_sink_c()
     self.tb.connect(src, op, dst)
     self.tb.run()
     result_data = dst.data()
     self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
Пример #14
0
    def xtest_004_decim_random_vals(self):
        MAX_TAPS = 9
        MAX_DECIM = 7
        OUTPUT_LEN = 9

        random.seed(0)  # we want reproducibility

        for ntaps in xrange(1, MAX_TAPS + 1):
            for decim in xrange(1, MAX_DECIM + 1):
                for ilen in xrange(ntaps + decim, ntaps + OUTPUT_LEN * decim):
                    src_data = random_floats(ilen)
                    taps = random_floats(ntaps)
                    expected_result = reference_dec_filter(src_data, decim, taps)

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

                    L1 = len(result_data)
                    L2 = len(expected_result)
                    L = min(L1, L2)
                    if False:
                        sys.stderr.write(
                            "delta = %2d: ntaps = %d decim = %d ilen = %d\n" % (L2 - L1, ntaps, decim, ilen)
                        )
                        sys.stderr.write(
                            "  len(result_data) = %d  len(expected_result) = %d\n"
                            % (len(result_data), len(expected_result))
                        )
                    self.assertEqual(expected_result[0:L], result_data[0:L])
Пример #15
0
    def test_deint_001 (self):
        lenx = 64
        src = blocks.vector_source_f (range (lenx))
        op = blocks.deinterleave (gr.sizeof_float)
        dst0 = blocks.vector_sink_f ()
        dst1 = blocks.vector_sink_f ()
        dst2 = blocks.vector_sink_f ()
        dst3 = blocks.vector_sink_f ()

        self.tb.connect (src, op)
        self.tb.connect ((op, 0), dst0)
        self.tb.connect ((op, 1), dst1)
        self.tb.connect ((op, 2), dst2)
        self.tb.connect ((op, 3), dst3)
        self.tb.run ()

        expected_result0 = tuple (range (0, lenx, 4))
        expected_result1 = tuple (range (1, lenx, 4))
        expected_result2 = tuple (range (2, lenx, 4))
        expected_result3 = tuple (range (3, lenx, 4))

        self.assertFloatTuplesAlmostEqual (expected_result0, dst0.data ())
        self.assertFloatTuplesAlmostEqual (expected_result1, dst1.data ())
        self.assertFloatTuplesAlmostEqual (expected_result2, dst2.data ())
        self.assertFloatTuplesAlmostEqual (expected_result3, dst3.data ())
Пример #16
0
    def test_005_(self):

        src_data = (1.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0)

        dwav = numpy.array(src_data)
        wvps = numpy.zeros(3)
        # wavelet power spectrum
        scl = 1.0 / sqr(dwav[0])
        k = 1
        for e in range(len(wvps)):
            wvps[e] = scl * sqr(dwav[k:k + (01 << e)]).sum()
            k += 01 << e

        src = blocks.vector_source_f(src_data, False, len(src_data))
        kon = wavelet_swig.wvps_ff(len(src_data))
        dst = blocks.vector_sink_f(int(math.ceil(math.log(len(src_data), 2))))

        self.tb.connect(src, kon)
        self.tb.connect(kon, dst)

        self.tb.run()
        snk_data = dst.data()

        sum = 0
        for (u, v) in zip(snk_data, wvps):
            w = u - v
            sum += w * w
        sum /= float(len(snk_data))
        assert sum < 1e-6
    def test_000(self):
        dst_data = [0, 0, 1, 2, 0, 2, 1, 0]
        src0 = blocks.vector_source_f(200 * [0])
        src1 = blocks.vector_source_f(200 * [1])
        src2 = blocks.vector_source_f(200 * [2])
        itg = blocks.patterned_interleaver(gr.sizeof_float, dst_data)
        dst = blocks.vector_sink_f()
        head = blocks.head(gr.sizeof_float, 8)

        self.tb.connect(src0, (itg, 0))
        self.tb.connect(src1, (itg, 1))
        self.tb.connect(src2, (itg, 2))
        self.tb.connect(itg, head, dst)

        self.tb.run()
        self.assertEqual(list(dst_data), list(dst.data()))
Пример #18
0
    def test_f_003(self):
        # Test scenariou where we have defined a puncture pattern with
        # more bits than the puncsize with a delay. The python code
        # doesn't account for this when creating self.expected, but
        # this should be equivalent to a puncpat of the correct size.

        self.puncsize = 4
        self.puncpat0 = 0x5555 # too many bits set
        self.puncpat1 = 0x55   # num bits = puncsize
        self.delay = 1

        src = blocks.vector_source_f(self.src_data)
	op0  = fec.puncture_ff(self.puncsize, self.puncpat0, self.delay)
	op1  = fec.puncture_ff(self.puncsize, self.puncpat1, self.delay)
	dst0 = blocks.vector_sink_f()
	dst1 = blocks.vector_sink_f()

	self.tb.connect(src, op0, dst0)
	self.tb.connect(src, op1, dst1)
	self.tb.run()

	dst_data0 = list(dst0.data())
	dst_data1 = list(dst1.data())

        self.assertEqual(dst_data1, dst_data0)
Пример #19
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 = blocks.vector_source_f(src_data)
            op = filter.fft_filter_fff(1, taps)
            dst = blocks.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
Пример #20
0
    def test_002(self):
        port = 65500

        n_data = 100
        src_data = [float(x) for x in range(n_data)]
        expected_result = tuple(src_data)
        src = blocks.vector_source_f(src_data, False)
        udp_snd = blocks.udp_sink(gr.sizeof_float, 'localhost', port)
        self.tb_snd.connect(src, udp_snd)

        udp_rcv = blocks.udp_source(gr.sizeof_float, 'localhost', port)
        dst = blocks.vector_sink_f()
        self.tb_rcv.connect(udp_rcv, dst)

        self.tb_rcv.start()
        self.tb_snd.run()
        udp_snd.disconnect()
        self.timeout = False
        q = Timer(2.0,self.stop_rcv)
        q.start()
        self.tb_rcv.wait()
        q.cancel()

        result_data = dst.data()
        self.assertEqual(expected_result, result_data)
        self.assert_(not self.timeout)
Пример #21
0
    def test_000(self):
        dst_data = [0, 0, 1, 2, 0, 2, 1, 0]
        src0 = blocks.vector_source_f(200 * [0])
        src1 = blocks.vector_source_f(200 * [1])
        src2 = blocks.vector_source_f(200 * [2])
        itg = blocks.patterned_interleaver(gr.sizeof_float, dst_data)
        dst = blocks.vector_sink_f()
        head = blocks.head(gr.sizeof_float, 8)

        self.tb.connect(src0, (itg, 0))
        self.tb.connect(src1, (itg, 1))
        self.tb.connect(src2, (itg, 2))
        self.tb.connect(itg, head, dst)

        self.tb.run()
        self.assertEqual(list(dst_data), list(dst.data()))
Пример #22
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 = blocks.vector_source_f(src_data)
            op = filter.fft_filter_fff(1, taps)
            dst = blocks.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 test_fir_filter_fcc_001(self):
     self.generate_fcc_source()
     expected_data = ((-0.000337088305969+7.46004516259e-05j),
                      (-5.63409266761e-05+0.000301144464174j),
                      (9.16960561881e-05-2.89259278361e-05j),
                      (-0.000231866899412-6.25764005235e-05j),
                      (-0.000116414688819+0.000258557556663j),
                      (0.000206079319469+5.05045172758e-05j),
                      (-3.85114690289e-05-0.00019276549574j),
                      (-0.000146380873048+0.000112079876999j),
                      (0.000215423395275+0.000116706331028j),
                      (0.000136050162837-0.000232611957472j),
                      (-0.000155499437824-5.41604022146e-05j),
                      (0.000106907449663+0.00016310159117j),
                      (0.000224392410018-0.000156331108883j),
                      (-0.000131131906528-0.000172063446371j),
                      (-5.92393880652e-05+0.00016801241145j),
                      (0.000214921761653-5.32235890205e-06j),
                      (-5.96960526309e-05-0.000211164733628j),
                      (-0.000193948610104+0.000113364716526j),
                      (0.000134820176754+0.000142527525895j),
                      (4.74465123261e-05-0.000175131688593j))
     src = blocks.vector_source_f(self.src_data)
     op  = filter.freq_xlating_fir_filter_fcc(1, self.taps, self.fc, self.fs)
     dst = blocks.vector_sink_c()
     self.tb.connect(src, op, dst)
     self.tb.run()
     result_data = dst.data()
     self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
Пример #24
0
    def test_003(self):
        udp_rcv = blocks.udp_source(gr.sizeof_float, '0.0.0.0', 0, eof=False)
        rcv_port = udp_rcv.get_port()

        udp_snd = blocks.udp_sink(gr.sizeof_float, '127.0.0.1', 65500)
        udp_snd.connect('localhost', rcv_port)

        n_data = 16
        src_data = [float(x) for x in range(n_data)]
        expected_result = tuple(src_data)
        src = blocks.vector_source_f(src_data)
        dst = blocks.vector_sink_f()

        self.tb_snd.connect(src, udp_snd)
        self.tb_rcv.connect(udp_rcv, dst)

        self.tb_rcv.start()
        self.tb_snd.run()
        udp_snd.disconnect()
        self.timeout = False
        q = Timer(2.0,self.stop_rcv)
        q.start()
        self.tb_rcv.wait()
        q.cancel()

        result_data = dst.data()
        self.assertEqual(expected_result, result_data)
        self.assert_(self.timeout)  # source ignores EOF?
Пример #25
0
 def test_fir_filter_fcf_001(self):
     self.generate_fcf_source()
     expected_data = (
         (0.000247188087087 - 0.000157509770361j),
         (-0.000155229790835 - 0.000246197130764j),
         (-0.000264906557277 + 0.000174603672349j), (6.99016964063e-05 +
                                                     0.000174961372977j),
         (-5.48477692064e-05 - 0.0001131295503j), (-0.000237467131228 +
                                                   0.000118011368613j),
         (0.000136614587973 + 0.000229531884543j), (0.000229347482673 -
                                                    0.000166581812664j),
         (-0.000106010869786 - 0.000150042149471j), (2.92293734674e-05 +
                                                     0.000142060467624j),
         (0.000228707227507 - 9.30760797928e-05j), (-0.000124306126963 -
                                                    0.000216641055886j),
         (-0.000204823678359 + 0.00016052465071j), (0.00012825592421 +
                                                    0.000133123627165j),
         (-1.18284006021e-05 - 0.000159015646204j), (-0.000219973371713 +
                                                     7.5438656495e-05j),
         (0.000114713984658 + 0.000205190401175j), (0.000185727752978 -
                                                    0.000154630601173j),
         (-0.000141745767905 - 0.000120098840853j), (-3.9850056055e-07 +
                                                     0.000168364742422j))
     src = blocks.vector_source_f(self.src_data)
     op = filter.freq_xlating_fir_filter_fcf(1, self.taps, self.fc, self.fs)
     dst = blocks.vector_sink_c()
     self.tb.connect(src, op, dst)
     self.tb.run()
     result_data = dst.data()
     self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:],
                                         5)
 def test_fir_filter_fcf_002(self):
     self.generate_fcf_source()
     expected_data = ((7.3052920925e-05-3.91741014028e-06j),
                      (3.11913172482e-05-0.000109872074972j),
                      (-0.000128646017401-3.49857727997e-05j),
                      (-5.49546712136e-05+8.96326746442e-05j),
                      (5.14321582159e-05+9.64698920143e-05j),
                      (0.000120189361041+2.4231892894e-05j),
                      (0.000100405508419-0.000223224604269j),
                      (-0.000274751859251-2.33274622587e-05j),
                      (1.52600114234e-06+0.000133301247843j),
                      (3.77224641852e-05+5.29596509296e-05j),
                      (-3.60160379387e-06+0.000247975171078j),
                      (0.00113093166146-0.000663110695314j),
                      (0.00059568521101-0.00099650840275j),
                      (-0.000475480686873+0.000250602373853j),
                      (0.000191397906747+0.000271986238658j),
                      (0.000247183139436-0.000157510468853j),
                      (-5.48357638763e-05-0.000113135029096j),
                      (-0.00010601492977-0.00015005269961j),
                      (-0.000204817260965+0.000160534662427j),
                      (0.000114742244477+0.000205190313864j))
     src = blocks.vector_source_f(self.src_data)
     op  = filter.freq_xlating_fir_filter_fcf(4, self.taps, self.fc, self.fs)
     dst = blocks.vector_sink_c()
     self.tb.connect(src, op, dst)
     self.tb.run()
     result_data = dst.data()
     self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
Пример #27
0
 def test_fir_filter_fcf_002(self):
     self.generate_fcf_source()
     expected_data = (
         (7.3052920925e-05 - 3.91741014028e-06j),
         (3.11913172482e-05 - 0.000109872074972j),
         (-0.000128646017401 - 3.49857727997e-05j), (-5.49546712136e-05 +
                                                     8.96326746442e-05j),
         (5.14321582159e-05 + 9.64698920143e-05j), (0.000120189361041 +
                                                    2.4231892894e-05j),
         (0.000100405508419 - 0.000223224604269j), (-0.000274751859251 -
                                                    2.33274622587e-05j),
         (1.52600114234e-06 + 0.000133301247843j), (3.77224641852e-05 +
                                                    5.29596509296e-05j),
         (-3.60160379387e-06 + 0.000247975171078j), (0.00113093166146 -
                                                     0.000663110695314j),
         (0.00059568521101 - 0.00099650840275j), (-0.000475480686873 +
                                                  0.000250602373853j),
         (0.000191397906747 + 0.000271986238658j), (0.000247183139436 -
                                                    0.000157510468853j),
         (-5.48357638763e-05 - 0.000113135029096j), (-0.00010601492977 -
                                                     0.00015005269961j),
         (-0.000204817260965 + 0.000160534662427j), (0.000114742244477 +
                                                     0.000205190313864j))
     src = blocks.vector_source_f(self.src_data)
     op = filter.freq_xlating_fir_filter_fcf(4, self.taps, self.fc, self.fs)
     dst = blocks.vector_sink_c()
     self.tb.connect(src, op, dst)
     self.tb.run()
     result_data = dst.data()
     self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:],
                                         5)
Пример #28
0
    def xtest_005_interp_random_vals(self):
        MAX_TAPS = 9
        MAX_INTERP = 7
        INPUT_LEN = 9

        random.seed(0)  # we want reproducibility

        for ntaps in xrange(1, MAX_TAPS + 1):
            for interp in xrange(1, MAX_INTERP + 1):
                for ilen in xrange(ntaps, ntaps + INPUT_LEN):
                    src_data = random_floats(ilen)
                    taps = random_floats(ntaps)
                    expected_result = reference_interp_filter(src_data, interp, taps)

                    tb = gr.top_block()
                    src = blocks.vector_source_f(src_data)
                    op = filter.rational_resampler_base_fff(interp, 1, taps)
                    dst = blocks.vector_sink_f()
                    tb.connect(src, op, dst)
                    tb.run()
                    tb = None
                    result_data = dst.data()
                    L1 = len(result_data)
                    L2 = len(expected_result)
                    L = min(L1, L2)
                    # if True or abs(L1-L2) > 1:
                    if False:
                        sys.stderr.write(
                            "delta = %2d: ntaps = %d interp = %d ilen = %d\n" % (L2 - L1, ntaps, interp, ilen)
                        )
                        # sys.stderr.write('  len(result_data) = %d  len(expected_result) = %d\n' %
                        #                 (len(result_data), len(expected_result)))
                    # self.assertEqual(expected_result[0:L], result_data[0:L])
                    # FIXME check first ntaps+1 answers
                    self.assertEqual(expected_result[ntaps + 1 : L], result_data[ntaps + 1 : L])
Пример #29
0
 def test_fir_filter_fcc_001(self):
     self.generate_fcc_source()
     expected_data = (
         (-0.000337088305969 + 7.46004516259e-05j),
         (-5.63409266761e-05 + 0.000301144464174j),
         (9.16960561881e-05 - 2.89259278361e-05j), (-0.000231866899412 -
                                                    6.25764005235e-05j),
         (-0.000116414688819 + 0.000258557556663j), (0.000206079319469 +
                                                     5.05045172758e-05j),
         (-3.85114690289e-05 - 0.00019276549574j), (-0.000146380873048 +
                                                    0.000112079876999j),
         (0.000215423395275 + 0.000116706331028j), (0.000136050162837 -
                                                    0.000232611957472j),
         (-0.000155499437824 - 5.41604022146e-05j), (0.000106907449663 +
                                                     0.00016310159117j),
         (0.000224392410018 - 0.000156331108883j), (-0.000131131906528 -
                                                    0.000172063446371j),
         (-5.92393880652e-05 + 0.00016801241145j), (0.000214921761653 -
                                                    5.32235890205e-06j),
         (-5.96960526309e-05 - 0.000211164733628j), (-0.000193948610104 +
                                                     0.000113364716526j),
         (0.000134820176754 + 0.000142527525895j), (4.74465123261e-05 -
                                                    0.000175131688593j))
     src = blocks.vector_source_f(self.src_data)
     op = filter.freq_xlating_fir_filter_fcc(1, self.taps, self.fc, self.fs)
     dst = blocks.vector_sink_c()
     self.tb.connect(src, op, dst)
     self.tb.run()
     result_data = dst.data()
     self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:],
                                         5)
Пример #30
0
    def test_005_(self):

        src_data = (1.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0)

        dwav = numpy.array(src_data)
        wvps = numpy.zeros(3)
        # wavelet power spectrum
        scl = 1.0/sqr(dwav[0])
        k = 1
        for e in range(len(wvps)):
            wvps[e] = scl*sqr(dwav[k:k+(01<<e)]).sum()
            k += 01<<e

        src = blocks.vector_source_f(src_data, False, len(src_data))
        kon = wavelet_swig.wvps_ff(len(src_data))
        dst = blocks.vector_sink_f(int(math.ceil(math.log(len(src_data), 2))))

        self.tb.connect(src, kon)
        self.tb.connect(kon, dst)

        self.tb.run()
        snk_data = dst.data()

        sum = 0
        for (u,v) in zip(snk_data, wvps):
            w = u - v
            sum += w * w
        sum /= float(len(snk_data))
        assert sum < 1e-6
Пример #31
0
    def xtest_004_decim_random_vals(self):
        MAX_TAPS = 9
        MAX_DECIM = 7
        OUTPUT_LEN = 9

        random.seed(0)  # we want reproducibility

        for ntaps in xrange(1, MAX_TAPS + 1):
            for decim in xrange(1, MAX_DECIM + 1):
                for ilen in xrange(ntaps + decim, ntaps + OUTPUT_LEN * decim):
                    src_data = random_floats(ilen)
                    taps = random_floats(ntaps)
                    expected_result = reference_dec_filter(
                        src_data, decim, taps)

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

                    L1 = len(result_data)
                    L2 = len(expected_result)
                    L = min(L1, L2)
                    if False:
                        sys.stderr.write(
                            'delta = %2d: ntaps = %d decim = %d ilen = %d\n' %
                            (L2 - L1, ntaps, decim, ilen))
                        sys.stderr.write(
                            '  len(result_data) = %d  len(expected_result) = %d\n'
                            % (len(result_data), len(expected_result)))
                    self.assertEqual(expected_result[0:L], result_data[0:L])
Пример #32
0
    def test_fff_000(self):
        N = 1000  # number of samples to use
        fs = 1000  # baseband sampling rate
        rrate = 1.123  # resampling rate

        nfilts = 32
        taps = filter.firdes.low_pass_2(
            nfilts,
            nfilts * fs,
            fs / 2,
            fs / 10,
            attenuation_dB=80,
            window=filter.firdes.WIN_BLACKMAN_hARRIS)

        freq = 100
        data = sig_source_f(fs, freq, 1, N)
        signal = blocks.vector_source_f(data)
        pfb = filter.pfb_arb_resampler_fff(rrate, taps)
        snk = blocks.vector_sink_f()

        self.tb.connect(signal, pfb, snk)
        self.tb.run()

        Ntest = 50
        L = len(snk.data())
        t = map(lambda x: float(x) / (fs * rrate), xrange(L))

        phase = 0.53013
        expected_data = map(
            lambda x: math.sin(2. * math.pi * freq * x + phase), t)

        dst_data = snk.data()
        self.assertFloatTuplesAlmostEqual(expected_data[-Ntest:],
                                          dst_data[-Ntest:], 3)
Пример #33
0
    def test_002(self):
        port = 65500

        n_data = 100
        src_data = [float(x) for x in range(n_data)]
        expected_result = tuple(src_data)
        src = blocks.vector_source_f(src_data, False)
        udp_snd = blocks.udp_sink(gr.sizeof_float, 'localhost', port)
        self.tb_snd.connect(src, udp_snd)

        udp_rcv = blocks.udp_source(gr.sizeof_float, 'localhost', port)
        dst = blocks.vector_sink_f()
        self.tb_rcv.connect(udp_rcv, dst)

        self.tb_rcv.start()
        self.tb_snd.run()
        udp_snd.disconnect()
        self.timeout = False
        q = Timer(2.0, self.stop_rcv)
        q.start()
        self.tb_rcv.wait()
        q.cancel()

        result_data = dst.data()
        self.assertEqual(expected_result, result_data)
        self.assert_(not self.timeout)
 def test_fir_filter_fcf_001(self):
     self.generate_fcf_source()
     expected_data = ((0.000247188087087-0.000157509770361j),
                      (-0.000155229790835-0.000246197130764j),
                      (-0.000264906557277+0.000174603672349j),
                      (6.99016964063e-05+0.000174961372977j),
                      (-5.48477692064e-05-0.0001131295503j),
                      (-0.000237467131228+0.000118011368613j),
                      (0.000136614587973+0.000229531884543j),
                      (0.000229347482673-0.000166581812664j),
                      (-0.000106010869786-0.000150042149471j),
                      (2.92293734674e-05+0.000142060467624j),
                      (0.000228707227507-9.30760797928e-05j),
                      (-0.000124306126963-0.000216641055886j),
                      (-0.000204823678359+0.00016052465071j),
                      (0.00012825592421+0.000133123627165j),
                      (-1.18284006021e-05-0.000159015646204j),
                      (-0.000219973371713+7.5438656495e-05j),
                      (0.000114713984658+0.000205190401175j),
                      (0.000185727752978-0.000154630601173j),
                      (-0.000141745767905-0.000120098840853j),
                      (-3.9850056055e-07+0.000168364742422j))
     src = blocks.vector_source_f(self.src_data)
     op  = filter.freq_xlating_fir_filter_fcf(1, self.taps, self.fc, self.fs)
     dst = blocks.vector_sink_c()
     self.tb.connect(src, op, dst)
     self.tb.run()
     result_data = dst.data()
     self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
Пример #35
0
    def test02(self):
        # Test float/float version
        omega = 2
        gain_omega = 0.01
        mu = 0.5
        gain_mu = 0.01
        omega_rel_lim = 0.001

        self.test = digital.clock_recovery_mm_ff(omega, gain_omega,
                                                 mu, gain_mu,
                                                 omega_rel_lim)
        
        data = 100*[1,]
        self.src = blocks.vector_source_f(data, False)
        self.snk = blocks.vector_sink_f()

        self.tb.connect(self.src, self.test, self.snk)
        self.tb.run()
        
        expected_result = 100*[0.99972, ] # doesn't quite get to 1.0
        dst_data = self.snk.data()

        # Only compare last Ncmp samples
        Ncmp = 30
        len_e = len(expected_result)
        len_d = len(dst_data)
        expected_result = expected_result[len_e - Ncmp:]
        dst_data = dst_data[len_d - Ncmp:]

        #print expected_result
        #print dst_data
        
        self.assertFloatTuplesAlmostEqual(expected_result, dst_data, 5)
Пример #36
0
    def transform(self, src_data, rate, freq):
	src = blocks.vector_source_f(src_data, False)
        dft = fft.goertzel_fc(rate, rate, freq)
	dst = blocks.vector_sink_c()
	self.tb.connect(src, dft, dst)
	self.tb.run()
	return dst.data()
Пример #37
0
 def test_fir_filter_fff_001(self):
     src_data = 40*[1, 2, 3, 4]
     expected_data = (0.5, 1.5, 3.0, 5.0, 5.5, 6.5, 8.0, 10.0,
                      10.5, 11.5, 13.0, 15.0, 15.5, 16.5, 18.0,
                      20.0, 20.5, 21.5, 23.0, 25.0, 25.5, 26.5,
                      28.0, 30.0, 30.5, 31.5, 33.0, 35.0, 35.5,
                      36.5, 38.0, 40.0, 40.5, 41.5, 43.0, 45.0,
                      45.5, 46.5, 48.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0)
     src = blocks.vector_source_f(src_data)
     op  = filter.fir_filter_fff(1, 20*[0.5, 0.5])
     dst = blocks.vector_sink_f()
     self.tb.connect(src, op, dst)
     self.tb.run()
     result_data = dst.data()
     self.assertFloatTuplesAlmostEqual(expected_data, result_data, 5)
Пример #38
0
    def test_004(self):
        vlen = 4
        tune = counter4(self, 1)
        tune_delay = 1
        dwell_delay = 2
        msgq = gr.msg_queue()

        src_data = tuple([float(x) for x in
                          ( 1,  2,  3,  4,
                            9,  6, 11,  8,
                            5, 10,  7, 12,
                            13, 14, 15, 16
                            )])

        expected_results = tuple([float(x) for x in
                                  ( 9, 10, 11, 12)])

        src = blocks.vector_source_f(src_data, False)
        s2v = blocks.stream_to_vector(gr.sizeof_float, vlen)
        stats = blocks.bin_statistics_f(vlen, msgq, tune, tune_delay, dwell_delay)
        self.tb.connect(src, s2v, stats)
        self.tb.run()
        self.assertEqual(1, msgq.count())
        for i in range(1):
            m = parse_msg(msgq.delete_head())
            #print "m =", m.center_freq, m.data
            self.assertEqual(expected_results[vlen*i:vlen*i + vlen], m.data)
Пример #39
0
    def test_003(self):
        udp_rcv = blocks.udp_source(gr.sizeof_float, '0.0.0.0', 0, eof=False)
        rcv_port = udp_rcv.get_port()

        udp_snd = blocks.udp_sink(gr.sizeof_float, '127.0.0.1', 65500)
        udp_snd.connect('localhost', rcv_port)

        n_data = 16
        src_data = [float(x) for x in range(n_data)]
        expected_result = tuple(src_data)
        src = blocks.vector_source_f(src_data)
        dst = blocks.vector_sink_f()

        self.tb_snd.connect(src, udp_snd)
        self.tb_rcv.connect(udp_rcv, dst)

        self.tb_rcv.start()
        self.tb_snd.run()
        udp_snd.disconnect()
        self.timeout = False
        q = Timer(2.0, self.stop_rcv)
        q.start()
        self.tb_rcv.wait()
        q.cancel()

        result_data = dst.data()
        self.assertEqual(expected_result, result_data)
        self.assert_(self.timeout)  # source ignores EOF?
Пример #40
0
 def test_convolve(self):
     tb = gr.top_block()
     src = blocks.vector_source_f([1, 2, 3, 4, 5, 6, 7, 8], False)
     cv = convolve()
     sink = blocks.vector_sink_f()
     tb.connect(src, cv, sink)
     tb.run()
     self.assertEqual(sink.data(), (1, 2, 3, 4, 5, 6, 7, 8))
Пример #41
0
 def test_interp2x(self):
     tb = gr.top_block()
     src = blocks.vector_source_f([1, 3, 5, 7, 9], False)
     i2x = interp2x()
     sink = blocks.vector_sink_f()
     tb.connect(src, i2x, sink)
     tb.run()
     self.assertEqual(sink.data(), (1, 1, 3, 3, 5, 5, 7, 7, 9, 9))
Пример #42
0
 def test_decim2x(self):
     tb = gr.top_block()
     src = blocks.vector_source_f([1, 2, 3, 4, 5, 6, 7, 8], False)
     d2x = decim2x()
     sink = blocks.vector_sink_f()
     tb.connect(src, d2x, sink)
     tb.run()
     self.assertEqual(sink.data(), (1, 3, 5, 7))
Пример #43
0
 def test_convolve(self):
     tb = gr.top_block()
     src = blocks.vector_source_f([1, 2, 3, 4, 5, 6, 7, 8], False)
     cv = convolve()
     sink = blocks.vector_sink_f()
     tb.connect(src, cv, sink)
     tb.run()
     self.assertEqual(sink.data(), (1, 2, 3, 4, 5, 6, 7, 8))
Пример #44
0
 def test_decim2x(self):
     tb = gr.top_block()
     src = blocks.vector_source_f([1, 2, 3, 4, 5, 6, 7, 8], False)
     d2x = decim2x()
     sink = blocks.vector_sink_f()
     tb.connect(src, d2x, sink)
     tb.run()
     self.assertEqual(sink.data(), (1, 3, 5, 7))
Пример #45
0
    def test_020_run(self):
	hblock = gr.top_block("test_block")
	data = (1.0, 2.0, 3.0, 4.0)
	src = blocks.vector_source_f(data, False)
	dst = blocks.vector_sink_f()
	hblock.connect(src, dst)
	hblock.run()
	self.assertEquals(data, dst.data())
Пример #46
0
 def test_020_run(self):
     hblock = gr.top_block("test_block")
     data = (1.0, 2.0, 3.0, 4.0)
     src = blocks.vector_source_f(data, False)
     dst = blocks.vector_sink_f()
     hblock.connect(src, dst)
     hblock.run()
     self.assertEquals(data, dst.data())
Пример #47
0
 def test_interp2x(self):
     tb = gr.top_block()
     src = blocks.vector_source_f([1, 3, 5, 7, 9], False)
     i2x = interp2x()
     sink = blocks.vector_sink_f()
     tb.connect(src, i2x, sink)
     tb.run()
     self.assertEqual(sink.data(), (1, 1, 3, 3, 5, 5, 7, 7, 9, 9))
Пример #48
0
 def test_float_to_uchar(self):
     src_data = (1.0, -2.0, 3.0, -4.0, 256.0)
     expected_data = (1, 0, 3, 0, 255)
     src = blocks.vector_source_f(src_data)
     op = blocks.float_to_uchar()
     dst = blocks.vector_sink_b()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertEqual(expected_data, dst.data())
Пример #49
0
 def test_float_to_short_scale(self):
     src_data = (1.0, 2.0, 3.0, 4.0, 5.0)
     expected_data = (5, 10, 15, 20, 25)
     src = blocks.vector_source_f(src_data)
     op = blocks.float_to_short(1, 5)
     dst = blocks.vector_sink_s()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertEqual(expected_data, dst.data())
Пример #50
0
 def test_float_to_uchar(self):
     src_data = (1.0, -2.0, 3.0, -4.0, 256.0)
     expected_data = (1, 0, 3, 0, 255)
     src = blocks.vector_source_f(src_data)
     op = blocks.float_to_uchar()
     dst = blocks.vector_sink_b()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertEqual(expected_data, dst.data())
Пример #51
0
 def test_float_to_short_identity(self):
     src_data = (1.0, 2.0, 3.0, 4.0, 5.0)
     expected_data = (1, 2, 3, 4, 5)
     src = blocks.vector_source_f(src_data)
     op = blocks.float_to_short()
     dst = blocks.vector_sink_s()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertEqual(expected_data, dst.data())
Пример #52
0
 def test_float_to_complex_1(self):
     src_data = (1.0, 3.0, 5.0, 7.0, 9.0)
     expected_data = (1 + 0j, 3 + 0j, 5 + 0j, 7 + 0j, 9 + 0j)
     src = blocks.vector_source_f(src_data)
     op = blocks.float_to_complex()
     dst = blocks.vector_sink_c()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
Пример #53
0
 def test_float_to_short_scale(self):
     src_data = (1.0, 2.0, 3.0, 4.0, 5.0)
     expected_data = (5, 10, 15, 20, 25)
     src = blocks.vector_source_f(src_data)
     op = blocks.float_to_short(1, 5)
     dst = blocks.vector_sink_s()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertEqual(expected_data, dst.data())