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,))
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)
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, ))
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())
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))
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())
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())
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 ()
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)
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)
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)
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])
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 ())
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()))
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_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 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)
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?
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)
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)
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])
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)
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 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])
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)
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)
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)
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()
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)
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)
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?
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))
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))
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))
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())
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())
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())
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())
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())