Imported Upstream version 3.2.2

[debian/gnuradio] / gnuradio-core / src / python / gnuradio / gr / qa_complex_to_xxx.py

diff --git a/gnuradio-core/src/python/gnuradio/gr/qa_complex_to_xxx.py b/gnuradio-core/src/python/gnuradio/gr/qa_complex_to_xxx.py
index 91ee9748190f904c02993e4ccd6a0dd6dd0a97b8..10f3668798ea8739f00b59d4e311ce05840bd458 100755 (executable)
--- a/gnuradio-core/src/python/gnuradio/gr/qa_complex_to_xxx.py
+++ b/gnuradio-core/src/python/gnuradio/gr/qa_complex_to_xxx.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 #
-# Copyright 2004 Free Software Foundation, Inc.
+# Copyright 2004,2007 Free Software Foundation, Inc.
 # 
 # This file is part of GNU Radio
 # 
@@ -26,10 +26,10 @@ import math
 class test_complex_ops (gr_unittest.TestCase):
 
     def setUp (self):
-        self.fg = gr.flow_graph ()
+        self.tb = gr.top_block ()
 
     def tearDown (self):
-        self.fg = None
+        self.tb = None
 
     def test_complex_to_float_1 (self):
         src_data = (0, 1, -1, 3+4j, -3-4j, -3+4j)
@@ -37,9 +37,9 @@ class test_complex_ops (gr_unittest.TestCase):
         src = gr.vector_source_c (src_data)
         op = gr.complex_to_float ()
         dst = gr.vector_sink_f ()
-        self.fg.connect (src, op)
-        self.fg.connect (op, dst)
-        self.fg.run ()               # run the graph and wait for it to finish
+        self.tb.connect (src, op)
+        self.tb.connect (op, dst)
+        self.tb.run ()               # run the graph and wait for it to finish
         actual_result = dst.data ()  # fetch the contents of the sink
         self.assertFloatTuplesAlmostEqual (expected_result, actual_result)
 
@@ -51,10 +51,10 @@ class test_complex_ops (gr_unittest.TestCase):
         op = gr.complex_to_float ()
         dst0 = gr.vector_sink_f ()
         dst1 = gr.vector_sink_f ()
-        self.fg.connect (src, op)
-        self.fg.connect ((op, 0), dst0)
-        self.fg.connect ((op, 1), dst1)
-        self.fg.run ()
+        self.tb.connect (src, op)
+        self.tb.connect ((op, 0), dst0)
+        self.tb.connect ((op, 1), dst1)
+        self.tb.run ()
         actual_result = dst0.data ()
         self.assertFloatTuplesAlmostEqual (expected_result0, actual_result)
         actual_result = dst1.data ()
@@ -66,9 +66,9 @@ class test_complex_ops (gr_unittest.TestCase):
         src = gr.vector_source_c (src_data)
         op = gr.complex_to_real ()
         dst = gr.vector_sink_f ()
-        self.fg.connect (src, op)
-        self.fg.connect (op, dst)
-        self.fg.run ()
+        self.tb.connect (src, op)
+        self.tb.connect (op, dst)
+        self.tb.run ()
         actual_result = dst.data ()
         self.assertFloatTuplesAlmostEqual (expected_result, actual_result)
 
@@ -78,9 +78,9 @@ class test_complex_ops (gr_unittest.TestCase):
         src = gr.vector_source_c (src_data)
         op = gr.complex_to_imag ()
         dst = gr.vector_sink_f ()
-        self.fg.connect (src, op)
-        self.fg.connect (op, dst)
-        self.fg.run ()
+        self.tb.connect (src, op)
+        self.tb.connect (op, dst)
+        self.tb.run ()
         actual_result = dst.data ()
         self.assertFloatTuplesAlmostEqual (expected_result, actual_result,5)
 
@@ -90,9 +90,9 @@ class test_complex_ops (gr_unittest.TestCase):
         src = gr.vector_source_c (src_data)
         op = gr.complex_to_mag ()
         dst = gr.vector_sink_f ()
-        self.fg.connect (src, op)
-        self.fg.connect (op, dst)
-        self.fg.run ()
+        self.tb.connect (src, op)
+        self.tb.connect (op, dst)
+        self.tb.run ()
         actual_result = dst.data ()
         self.assertFloatTuplesAlmostEqual (expected_result, actual_result,5)
 
@@ -102,24 +102,38 @@ class test_complex_ops (gr_unittest.TestCase):
         src = gr.vector_source_c (src_data)
         op = gr.complex_to_mag_squared ()
         dst = gr.vector_sink_f ()
-        self.fg.connect (src, op)
-        self.fg.connect (op, dst)
-        self.fg.run ()
+        self.tb.connect (src, op)
+        self.tb.connect (op, dst)
+        self.tb.run ()
         actual_result = dst.data ()
         self.assertFloatTuplesAlmostEqual (expected_result, actual_result,5)
 
     def test_complex_to_arg (self):
         pi = math.pi
-        expected_result = (0, pi/6, pi/4, pi/2, 3*pi/4, 7*pi/8,
-                           -pi/6, -pi/4, -pi/2, -3*pi/4, -7*pi/8)
-        src_data = tuple ([math.cos (x) + math.sin (x) * 1j for x in expected_result])
+        input_data = (0, pi/6, pi/4, pi/2, 3*pi/4, 7*pi/8,
+                      -pi/6, -pi/4, -pi/2, -3*pi/4, -7*pi/8)
+
+        expected_result = (0.0,                  # 0
+                           0.52382522821426392,  # pi/6
+                           0.78539806604385376,  # pi/4
+                           1.5707963705062866,   # pi/2
+                           2.3561947345733643,   # 3pi/4
+                           2.7491819858551025,   # 7pi/8
+                           -0.52382522821426392, # -pi/6
+                           -0.78539806604385376, # -pi/4
+                           -1.5707963705062866,  # -pi/2
+                           -2.3561947345733643,  # -3pi/4
+                           -2.7491819858551025)  # -7pi/8
+
+        src_data = tuple ([math.cos (x) + math.sin (x) * 1j for x in input_data])
         src = gr.vector_source_c (src_data)
         op = gr.complex_to_arg ()
         dst = gr.vector_sink_f ()
-        self.fg.connect (src, op)
-        self.fg.connect (op, dst)
-        self.fg.run ()
+        self.tb.connect (src, op)
+        self.tb.connect (op, dst)
+        self.tb.run ()
         actual_result = dst.data ()
+
         self.assertFloatTuplesAlmostEqual (expected_result, actual_result, 5)