filter: removed all references to filter functions from gr namespace to filter.

20 files changed, 51 insertions, 78 deletions

diff --git a/gr-filter/examples/channelize.py b/gr-filter/examples/channelize.py
index affce7b57..1f784d9b0 100755
--- a/gr-filter/examples/channelize.py
+++ b/gr-filter/examples/channelize.py
@@ -48,9 +48,9 @@ class pfb_top_block(gr.top_block):
         self._ifs = M*self._fs   # initial sampling rate
 
         # Create a set of taps for the PFB channelizer
-        self._taps = gr.firdes.low_pass_2(1, self._ifs, 475.50, 50,
-                                          attenuation_dB=100,
-                                          window=gr.firdes.WIN_BLACKMAN_hARRIS)
+        self._taps = filter.firdes.low_pass_2(1, self._ifs, 475.50, 50,
+                                              attenuation_dB=100,
+                                              window=filter.firdes.WIN_BLACKMAN_hARRIS)
 
         # Calculate the number of taps per channel for our own information
         tpc = scipy.ceil(float(len(self._taps)) /  float(self._M))
diff --git a/gr-filter/examples/chirp_channelize.py b/gr-filter/examples/chirp_channelize.py
index 99bf3b6e2..3638c55d1 100755
--- a/gr-filter/examples/chirp_channelize.py
+++ b/gr-filter/examples/chirp_channelize.py
@@ -47,8 +47,9 @@ class pfb_top_block(gr.top_block):
         self._M = 9              # Number of channels to channelize
 
         # Create a set of taps for the PFB channelizer
-        self._taps = gr.firdes.low_pass_2(1, self._fs, 500, 20,
-                                          attenuation_dB=10, window=gr.firdes.WIN_BLACKMAN_hARRIS)
+        self._taps = filter.firdes.low_pass_2(1, self._fs, 500, 20,
+                                              attenuation_dB=10,
+                                              window=filter.firdes.WIN_BLACKMAN_hARRIS)
 
         # Calculate the number of taps per channel for our own information
         tpc = scipy.ceil(float(len(self._taps)) /  float(self._M))
diff --git a/gr-filter/examples/fft_filter_ccc.py b/gr-filter/examples/fft_filter_ccc.py
index cc70e2b15..45e241a6f 100755
--- a/gr-filter/examples/fft_filter_ccc.py
+++ b/gr-filter/examples/fft_filter_ccc.py
@@ -37,16 +37,12 @@ class example_fft_filter_ccc(gr.top_block):
         self.head = gr.head(gr.sizeof_gr_complex, self._nsamps)
 
         self.filt0 = filter.fft_filter_ccc(self._decim, taps)
-        self.filt1 = gr.fft_filter_ccc(self._decim, taps)
-        #self.filt1 = filter.fft_filter_ccc(self._decim, taps)
 
         self.vsnk_src = gr.vector_sink_c()
         self.vsnk_out = gr.vector_sink_c()
-        self.vsnk_gr = gr.vector_sink_c()
 
         self.connect(self.src, self.head, self.vsnk_src)
         self.connect(self.head, self.filt0, self.vsnk_out)
-        self.connect(self.head, self.filt1, self.vsnk_gr)
 
 def main():
     parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
@@ -77,7 +73,6 @@ def main():
 
     data_src = scipy.array(put.vsnk_src.data())
     data_snk = scipy.array(put.vsnk_out.data())
-    data_gr = scipy.array(put.vsnk_gr.data())
 
     # Plot the signals PSDs
     nfft = 1024
@@ -87,15 +82,11 @@ def main():
            Fs=options.samplerate)
     s1.psd(data_snk, NFFT=nfft, noverlap=nfft/4,
            Fs=options.samplerate)
-    s1.psd(data_gr, NFFT=nfft, noverlap=nfft/4,
-           Fs=options.samplerate)
-
 
     f2 = pylab.figure(2, figsize=(12,10))
     s2 = f2.add_subplot(1,1,1)
     s2.plot(data_src)
     s2.plot(data_snk.real, 'g')
-    s2.plot(data_gr.real, 'r--')
 
     pylab.show()
     
diff --git a/gr-filter/examples/fir_filter_ccc.py b/gr-filter/examples/fir_filter_ccc.py
index b5a461d2c..baa05eeb7 100755
--- a/gr-filter/examples/fir_filter_ccc.py
+++ b/gr-filter/examples/fir_filter_ccc.py
@@ -34,16 +34,12 @@ class example_fir_filter_ccc(gr.top_block):
         self.head = gr.head(gr.sizeof_gr_complex, self._nsamps)
 
         self.filt0 = filter.fir_filter_ccc(self._decim, taps)
-        self.filt1 = gr.fir_filter_ccc(self._decim, taps)
-        #self.filt1 = filter.fft_filter_ccc(self._decim, taps)
 
         self.vsnk_src = gr.vector_sink_c()
         self.vsnk_out = gr.vector_sink_c()
-        self.vsnk_gr = gr.vector_sink_c()
 
         self.connect(self.src, self.head, self.vsnk_src)
         self.connect(self.head, self.filt0, self.vsnk_out)
-        self.connect(self.head, self.filt1, self.vsnk_gr)
 
 def main():
     parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
@@ -71,7 +67,6 @@ def main():
 
     data_src = scipy.array(put.vsnk_src.data())
     data_snk = scipy.array(put.vsnk_out.data())
-    data_gr = scipy.array(put.vsnk_gr.data())
 
     # Plot the signals PSDs
     nfft = 1024
@@ -81,15 +76,11 @@ def main():
            Fs=options.samplerate)
     s1.psd(data_snk, NFFT=nfft, noverlap=nfft/4,
            Fs=options.samplerate)
-    s1.psd(data_gr, NFFT=nfft, noverlap=nfft/4,
-           Fs=options.samplerate)
-
 
     f2 = pylab.figure(2, figsize=(12,10))
     s2 = f2.add_subplot(1,1,1)
     s2.plot(data_src)
     s2.plot(data_snk.real, 'g')
-    s2.plot(data_gr.real, 'r--')
 
     pylab.show()
     
diff --git a/gr-filter/examples/fir_filter_fff.py b/gr-filter/examples/fir_filter_fff.py
index 983088622..48769f00d 100755
--- a/gr-filter/examples/fir_filter_fff.py
+++ b/gr-filter/examples/fir_filter_fff.py
@@ -34,15 +34,12 @@ class example_fir_filter_fff(gr.top_block):
         self.head = gr.head(gr.sizeof_float, self._nsamps)
 
         self.filt0 = filter.fir_filter_fff(self._decim, taps)
-        self.filt1 = gr.fir_filter_fff(self._decim, taps)
 
         self.vsnk_src = gr.vector_sink_f()
         self.vsnk_out = gr.vector_sink_f()
-        self.vsnk_gr = gr.vector_sink_f()
 
         self.connect(self.src, self.head, self.vsnk_src)
         self.connect(self.head, self.filt0, self.vsnk_out)
-        self.connect(self.head, self.filt1, self.vsnk_gr)
 
 def main():
     parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
@@ -70,7 +67,6 @@ def main():
 
     data_src = scipy.array(put.vsnk_src.data())
     data_snk = scipy.array(put.vsnk_out.data())
-    data_gr = scipy.array(put.vsnk_gr.data())
 
     # Plot the signals PSDs
     nfft = 1024
@@ -80,15 +76,11 @@ def main():
            Fs=options.samplerate)
     s1.psd(data_snk, NFFT=nfft, noverlap=nfft/4,
            Fs=options.samplerate)
-    s1.psd(data_gr, NFFT=nfft, noverlap=nfft/4,
-           Fs=options.samplerate)
-
 
     f2 = pylab.figure(2, figsize=(12,10))
     s2 = f2.add_subplot(1,1,1)
     s2.plot(data_src)
     s2.plot(data_snk.real, 'g')
-    s2.plot(data_gr.real, 'r--')
 
     pylab.show()
     
diff --git a/gr-filter/include/filter/pfb_arb_resampler_ccf.h b/gr-filter/include/filter/pfb_arb_resampler_ccf.h
index 1436674b2..cf5fa4a3b 100644
--- a/gr-filter/include/filter/pfb_arb_resampler_ccf.h
+++ b/gr-filter/include/filter/pfb_arb_resampler_ccf.h
@@ -85,8 +85,8 @@ namespace gr {
      * gain of the filter, which we specify here as the interpolation
      * rate (<EM>32</EM>).
      *
-     *   <B><EM>self._taps = gr.firdes.low_pass_2(32, 32*fs, BW, TB,
-     *      attenuation_dB=ATT, window=gr.firdes.WIN_BLACKMAN_hARRIS)</EM></B>
+     *   <B><EM>self._taps = filter.firdes.low_pass_2(32, 32*fs, BW, TB,
+     *      attenuation_dB=ATT, window=filter.firdes.WIN_BLACKMAN_hARRIS)</EM></B>
      *
      * The theory behind this block can be found in Chapter 7.5 of
      * the following book.
diff --git a/gr-filter/include/filter/pfb_arb_resampler_fff.h b/gr-filter/include/filter/pfb_arb_resampler_fff.h
index 7449ea0cb..2504c92ec 100644
--- a/gr-filter/include/filter/pfb_arb_resampler_fff.h
+++ b/gr-filter/include/filter/pfb_arb_resampler_fff.h
@@ -85,8 +85,8 @@ namespace gr {
      * gain of the filter, which we specify here as the interpolation
      * rate (<EM>32</EM>).
      *
-     *   <B><EM>self._taps = gr.firdes.low_pass_2(32, 32*fs, BW, TB,
-     *      attenuation_dB=ATT, window=gr.firdes.WIN_BLACKMAN_hARRIS)</EM></B>
+     *   <B><EM>self._taps = filter.firdes.low_pass_2(32, 32*fs, BW, TB,
+     *      attenuation_dB=ATT, window=filter.firdes.WIN_BLACKMAN_hARRIS)</EM></B>
      *
      * The theory behind this block can be found in Chapter 7.5 of the
      * following book.
diff --git a/gr-filter/include/filter/pfb_channelizer_ccf.h b/gr-filter/include/filter/pfb_channelizer_ccf.h
index ba55782b4..7726809f2 100644
--- a/gr-filter/include/filter/pfb_channelizer_ccf.h
+++ b/gr-filter/include/filter/pfb_channelizer_ccf.h
@@ -81,8 +81,8 @@ namespace gr {
      * function (a Blackman-harris window in this case). The first input
      *  is the gain of the filter, which we specify here as unity.
      *
-     *      <B><EM>self._taps = gr.firdes.low_pass_2(1, fs, BW, TB,
-     *           attenuation_dB=ATT, window=gr.firdes.WIN_BLACKMAN_hARRIS)</EM></B>
+     *      <B><EM>self._taps = filter.firdes.low_pass_2(1, fs, BW, TB,
+     *           attenuation_dB=ATT, window=filter.firdes.WIN_BLACKMAN_hARRIS)</EM></B>
      *
      * The filter output can also be overs ampled. The over sampling rate
      * is the ratio of the the actual output sampling rate to the normal
diff --git a/gr-filter/include/filter/pfb_decimator_ccf.h b/gr-filter/include/filter/pfb_decimator_ccf.h
index e41f16cd2..9db11b88d 100644
--- a/gr-filter/include/filter/pfb_decimator_ccf.h
+++ b/gr-filter/include/filter/pfb_decimator_ccf.h
@@ -71,8 +71,8 @@ namespace gr {
      * input is the gain of the filter, which we specify here as
      * unity.
      *
-     *   <B><EM>self._taps = gr.firdes.low_pass_2(1, fs, BW, TB,
-     *      attenuation_dB=ATT, window=gr.firdes.WIN_BLACKMAN_hARRIS)</EM></B>
+     *   <B><EM>self._taps = filter.firdes.low_pass_2(1, fs, BW, TB,
+     *      attenuation_dB=ATT, window=filter.firdes.WIN_BLACKMAN_hARRIS)</EM></B>
      *
      * The PFB decimator code takes the taps generated above and
      * builds a set of filters. The set contains <EM>decim</EM> number
diff --git a/gr-filter/include/filter/pfb_interpolator_ccf.h b/gr-filter/include/filter/pfb_interpolator_ccf.h
index d32b8b688..a31ca7129 100644
--- a/gr-filter/include/filter/pfb_interpolator_ccf.h
+++ b/gr-filter/include/filter/pfb_interpolator_ccf.h
@@ -59,8 +59,8 @@ namespace gr {
      * the output levels are the same as the input (this creates an
      * overall increase in power).
      *
-     *   <B><EM>self._taps = gr.firdes.low_pass_2(interp, interp*fs, BW, TB,
-     *      attenuation_dB=ATT, window=gr.firdes.WIN_BLACKMAN_hARRIS)</EM></B>
+     *   <B><EM>self._taps = filter.firdes.low_pass_2(interp, interp*fs, BW, TB,
+     *      attenuation_dB=ATT, window=filter.firdes.WIN_BLACKMAN_hARRIS)</EM></B>
      *
      * The PFB interpolator code takes the taps generated above and
      * builds a set of filters. The set contains <EM>interp</EM>
diff --git a/gr-filter/include/filter/polyphase_filterbank.h b/gr-filter/include/filter/polyphase_filterbank.h
index 50d087340..33e9522e1 100644
--- a/gr-filter/include/filter/polyphase_filterbank.h
+++ b/gr-filter/include/filter/polyphase_filterbank.h
@@ -87,8 +87,8 @@ namespace gr {
        * input is the gain of the filter, which we specify here as
        * unity.
        *
-       *      <B><EM>self._taps = gr.firdes.low_pass_2(1, fs, BW, TB,
-       *           attenuation_dB=ATT, window=gr.firdes.WIN_BLACKMAN_hARRIS)</EM></B>
+       *      <B><EM>self._taps = filter.firdes.low_pass_2(1, fs, BW, TB,
+       *           attenuation_dB=ATT, window=filter.firdes.WIN_BLACKMAN_hARRIS)</EM></B>
        *
        * More on the theory of polyphase filterbanks can be found in
        * the following book.
diff --git a/gr-filter/python/qa_fractional_interpolator.py b/gr-filter/python/qa_fractional_interpolator.py
index 51c8f9530..74dae5d85 100755
--- a/gr-filter/python/qa_fractional_interpolator.py
+++ b/gr-filter/python/qa_fractional_interpolator.py
@@ -32,8 +32,8 @@ class test_fractional_resampler(gr_unittest.TestCase):
         self.tb = None
 
     def test_000_make(self):
-        op = gr.fractional_interpolator_ff(0.0, 1.0)
-        op2 = gr.fractional_interpolator_cc(0.0, 1.0)
+        op = filter.fractional_interpolator_ff(0.0, 1.0)
+        op2 = filter.fractional_interpolator_cc(0.0, 1.0)
 
 if __name__ == '__main__':
     gr_unittest.run(test_fractional_resampler, "test_fractional_resampler.xml")
diff --git a/gr-filter/python/qa_interp_fir_filter.py b/gr-filter/python/qa_interp_fir_filter.py
index 97901963e..839330539 100755
--- a/gr-filter/python/qa_interp_fir_filter.py
+++ b/gr-filter/python/qa_interp_fir_filter.py
@@ -46,7 +46,7 @@ class test_interp_fir_filter(gr_unittest.TestCase):
         expected_result = tuple([float(x) for x in xr])
 
         src = gr.vector_source_f(src_data)
-        op = gr.interp_fir_filter_fff(interpolation, taps)
+        op = filter.interp_fir_filter_fff(interpolation, taps)
         dst = gr.vector_sink_f()
         self.tb.connect(src, op)
         self.tb.connect(op, dst)
diff --git a/gr-filter/python/qa_pfb_arb_resampler.py b/gr-filter/python/qa_pfb_arb_resampler.py
index 655b680f0..a4e22f4c0 100755
--- a/gr-filter/python/qa_pfb_arb_resampler.py
+++ b/gr-filter/python/qa_pfb_arb_resampler.py
@@ -38,9 +38,9 @@ class test_pfb_arb_resampler(gr_unittest.TestCase):
         rrate = 1.123    # resampling rate
 
         nfilts = 32
-        taps = gr.firdes.low_pass_2(nfilts, nfilts*fs, fs/2, fs/10,
-                                    attenuation_dB=80,
-                                    window=gr.firdes.WIN_BLACKMAN_hARRIS)
+        taps = filter.firdes.low_pass_2(nfilts, nfilts*fs, fs/2, fs/10,
+                                        attenuation_dB=80,
+                                        window=filter.firdes.WIN_BLACKMAN_hARRIS)
 
         freq = 100
         signal = gr.sig_source_f(fs, gr.GR_SIN_WAVE, freq, 1)
@@ -67,9 +67,9 @@ class test_pfb_arb_resampler(gr_unittest.TestCase):
         rrate = 1.123    # resampling rate
 
         nfilts = 32
-        taps = gr.firdes.low_pass_2(nfilts, nfilts*fs, fs/2, fs/10,
-                                    attenuation_dB=80,
-                                    window=gr.firdes.WIN_BLACKMAN_hARRIS)
+        taps = filter.firdes.low_pass_2(nfilts, nfilts*fs, fs/2, fs/10,
+                                        attenuation_dB=80,
+                                        window=filter.firdes.WIN_BLACKMAN_hARRIS)
 
         freq = 100
         signal = gr.sig_source_c(fs, gr.GR_SIN_WAVE, freq, 1)
diff --git a/gr-filter/python/qa_pfb_channelizer.py b/gr-filter/python/qa_pfb_channelizer.py
index b52c80e8b..33d2b2188 100755
--- a/gr-filter/python/qa_pfb_channelizer.py
+++ b/gr-filter/python/qa_pfb_channelizer.py
@@ -38,9 +38,9 @@ class test_pfb_channelizer(gr_unittest.TestCase):
         fs = 1000        # baseband sampling rate
         ifs = M*fs       # input samp rate to channelizer
 
-        taps = gr.firdes.low_pass_2(1, ifs, 500, 50,
-                                    attenuation_dB=80,
-                                    window=gr.firdes.WIN_BLACKMAN_hARRIS)
+        taps = filter.firdes.low_pass_2(1, ifs, 500, 50,
+                                        attenuation_dB=80,
+                                        window=filter.firdes.WIN_BLACKMAN_hARRIS)
 
         signals = list()
         add = gr.add_cc()
diff --git a/gr-filter/python/qa_pfb_decimator.py b/gr-filter/python/qa_pfb_decimator.py
index c8fd408be..063845f63 100755
--- a/gr-filter/python/qa_pfb_decimator.py
+++ b/gr-filter/python/qa_pfb_decimator.py
@@ -39,9 +39,9 @@ class test_pfb_decimator(gr_unittest.TestCase):
         ifs = M*fs       # input samp rate to decimator
         channel = 0      # Extract channel 0
 
-        taps = gr.firdes.low_pass_2(1, ifs, fs/2, fs/10,
-                                    attenuation_dB=80,
-                                    window=gr.firdes.WIN_BLACKMAN_hARRIS)
+        taps = filter.firdes.low_pass_2(1, ifs, fs/2, fs/10,
+                                        attenuation_dB=80,
+                                        window=filter.firdes.WIN_BLACKMAN_hARRIS)
 
         signals = list()
         add = gr.add_cc()
@@ -84,9 +84,9 @@ class test_pfb_decimator(gr_unittest.TestCase):
         ifs = M*fs       # input samp rate to decimator
         channel = 1      # Extract channel 0
 
-        taps = gr.firdes.low_pass_2(1, ifs, fs/2, fs/10,
+        taps = filter.firdes.low_pass_2(1, ifs, fs/2, fs/10,
                                     attenuation_dB=80,
-                                    window=gr.firdes.WIN_BLACKMAN_hARRIS)
+                                    window=filter.firdes.WIN_BLACKMAN_hARRIS)
 
         signals = list()
         add = gr.add_cc()
diff --git a/gr-filter/python/qa_pfb_interpolator.py b/gr-filter/python/qa_pfb_interpolator.py
index f83c57d60..5b84b7c64 100755
--- a/gr-filter/python/qa_pfb_interpolator.py
+++ b/gr-filter/python/qa_pfb_interpolator.py
@@ -38,9 +38,9 @@ class test_pfb_interpolator(gr_unittest.TestCase):
         fs = 1000        # baseband sampling rate
         ifs = M*fs       # input samp rate to decimator
 
-        taps = gr.firdes.low_pass_2(M, ifs, fs/2, fs/10,
-                                    attenuation_dB=80,
-                                    window=gr.firdes.WIN_BLACKMAN_hARRIS)
+        taps = filter.firdes.low_pass_2(M, ifs, fs/2, fs/10,
+                                        attenuation_dB=80,
+                                        window=filter.firdes.WIN_BLACKMAN_hARRIS)
 
         freq = 100
         signal = gr.sig_source_c(fs, gr.GR_COS_WAVE, freq, 1)
diff --git a/gr-filter/python/qa_pfb_synthesizer.py b/gr-filter/python/qa_pfb_synthesizer.py
index 8b69ccb12..e8164d268 100755
--- a/gr-filter/python/qa_pfb_synthesizer.py
+++ b/gr-filter/python/qa_pfb_synthesizer.py
@@ -38,9 +38,9 @@ class test_pfb_synthesizer(gr_unittest.TestCase):
         fs = 1000        # baseband sampling rate
         ofs = M*fs       # input samp rate to decimator
 
-        taps = gr.firdes.low_pass_2(M, ofs, fs/2, fs/10,
-                                    attenuation_dB=80,
-                                    window=gr.firdes.WIN_BLACKMAN_hARRIS)
+        taps = filter.firdes.low_pass_2(M, ofs, fs/2, fs/10,
+                                        attenuation_dB=80,
+                                        window=filter.firdes.WIN_BLACKMAN_hARRIS)
 
         signals = list()
         freqs = [0, 100, 200, -200, -100]
diff --git a/gr-filter/python/qa_pm_remez.py b/gr-filter/python/qa_pm_remez.py
index 765e2ea6a..a76e14c93 100755
--- a/gr-filter/python/qa_pm_remez.py
+++ b/gr-filter/python/qa_pm_remez.py
@@ -159,7 +159,7 @@ class test_pm_remez(gr_unittest.TestCase):
         desired_ampls = (gain, 0)
         (n, fo, ao, w) = remezord([freq1, freq2], desired_ampls,
                                   [passband_dev, stopband_dev], Fs)
-        new_taps = gr.remez(n + 2, fo, ao, w, "bandpass")
+        new_taps = filter.pm_remez(n + 2, fo, ao, w, "bandpass")
 
         known_taps = (-0.0008370135734511828, -0.0006622211673134374,
                        0.0008501079576365787, 0.003059609130249229,
diff --git a/gr-filter/python/rational_resampler.py b/gr-filter/python/rational_resampler.py
index eea12af95..312b011d3 100644
--- a/gr-filter/python/rational_resampler.py
+++ b/gr-filter/python/rational_resampler.py
@@ -44,14 +44,12 @@ def design_filter(interpolation, decimation, fractional_bw):
     trans_width = 0.5 - fractional_bw
     mid_transition_band = 0.5 - trans_width/2
 
-    taps = gr.firdes.low_pass(interpolation,                     # gain
-                              1,                                 # Fs
-                              mid_transition_band/interpolation, # trans mid point
-                              trans_width/interpolation,         # transition width
-                              gr.firdes.WIN_KAISER,
-                              beta                               # beta
-                              )
-
+    taps = filter.firdes.low_pass(interpolation,                     # gain
+                                  1,                                 # Fs
+                                  mid_transition_band/interpolation, # trans mid point
+                                  trans_width/interpolation,         # transition width
+                                  filter.firdes.WIN_KAISER,
+                                  beta)                              # beta
     return taps
 
 
@@ -109,7 +107,7 @@ class rational_resampler_fff(_rational_resampler_base):
         Rational resampling polyphase FIR filter with
         float input, float output and float taps.
         """
-        _rational_resampler_base.__init__(self, gr.rational_resampler_base_fff,
+        _rational_resampler_base.__init__(self, filter.rational_resampler_base_fff,
 				          interpolation, decimation, taps, fractional_bw)
 
 class rational_resampler_ccf(_rational_resampler_base):
@@ -118,7 +116,7 @@ class rational_resampler_ccf(_rational_resampler_base):
         Rational resampling polyphase FIR filter with
         complex input, complex output and float taps.
         """
-        _rational_resampler_base.__init__(self, gr.rational_resampler_base_ccf,
+        _rational_resampler_base.__init__(self, filter.rational_resampler_base_ccf,
                                           interpolation, decimation, taps, fractional_bw)
 
 class rational_resampler_ccc(_rational_resampler_base):
@@ -127,5 +125,5 @@ class rational_resampler_ccc(_rational_resampler_base):
         Rational resampling polyphase FIR filter with
         complex input, complex output and complex taps.
         """
-        _rational_resampler_base.__init__(self, gr.rational_resampler_base_ccc,
+        _rational_resampler_base.__init__(self, filter.rational_resampler_base_ccc,
                                           interpolation, decimation, taps, fractional_bw)