gnuradio.filter: Filters

gnuradio.filter.dc_blocker_cc(int D, bool long_form) → dc_blocker_cc_sptr

a computationally efficient controllable DC blocker

This block implements a computationally efficient DC blocker that produces a tighter notch filter around DC for a smaller group delay than an equivalent FIR filter or using a single pole IIR filter (though the IIR filter is computationally cheaper).

The block defaults to using a delay line of length 32 and the long form of the filter. Optionally, the delay line length can be changed to alter the width of the DC notch (longer lines will decrease the width).

The long form of the filter produces a nearly flat response outside of the notch but at the cost of a group delay of 2D-2.

The short form of the filter does not have as flat a response in the passband but has a group delay of only D-1 and is cheaper to compute.

The theory behind this block can be found in the paper:

Constructor Specific Documentation:

Make a DC blocker block.

Parameters:
  • D – (int) the length of the delay line
  • long_form – (bool) whether to use long (true, default) or short form
dc_blocker_cc_sptr.active_thread_priority(dc_blocker_cc_sptr self) → int
dc_blocker_cc_sptr.declare_sample_delay(dc_blocker_cc_sptr self, int which, int delay)

declare_sample_delay(dc_blocker_cc_sptr self, unsigned int delay)

dc_blocker_cc_sptr.group_delay(dc_blocker_cc_sptr self) → int
dc_blocker_cc_sptr.message_subscribers(dc_blocker_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr
dc_blocker_cc_sptr.min_noutput_items(dc_blocker_cc_sptr self) → int
dc_blocker_cc_sptr.pc_input_buffers_full_avg(dc_blocker_cc_sptr self, int which) → float

pc_input_buffers_full_avg(dc_blocker_cc_sptr self) -> pmt_vector_float

dc_blocker_cc_sptr.pc_noutput_items_avg(dc_blocker_cc_sptr self) → float
dc_blocker_cc_sptr.pc_nproduced_avg(dc_blocker_cc_sptr self) → float
dc_blocker_cc_sptr.pc_output_buffers_full_avg(dc_blocker_cc_sptr self, int which) → float

pc_output_buffers_full_avg(dc_blocker_cc_sptr self) -> pmt_vector_float

dc_blocker_cc_sptr.pc_throughput_avg(dc_blocker_cc_sptr self) → float
dc_blocker_cc_sptr.pc_work_time_avg(dc_blocker_cc_sptr self) → float
dc_blocker_cc_sptr.pc_work_time_total(dc_blocker_cc_sptr self) → float
dc_blocker_cc_sptr.sample_delay(dc_blocker_cc_sptr self, int which) → unsigned int
dc_blocker_cc_sptr.set_min_noutput_items(dc_blocker_cc_sptr self, int m)
dc_blocker_cc_sptr.set_thread_priority(dc_blocker_cc_sptr self, int priority) → int
dc_blocker_cc_sptr.thread_priority(dc_blocker_cc_sptr self) → int
gnuradio.filter.dc_blocker_ff(int D, bool long_form=True) → dc_blocker_ff_sptr

a computationally efficient controllable DC blocker

This block implements a computationally efficient DC blocker that produces a tighter notch filter around DC for a smaller group delay than an equivalent FIR filter or using a single pole IIR filter (though the IIR filter is computationally cheaper).

The block defaults to using a delay line of length 32 and the long form of the filter. Optionally, the delay line length can be changed to alter the width of the DC notch (longer lines will decrease the width).

The long form of the filter produces a nearly flat response outside of the notch but at the cost of a group delay of 2D-2.

The short form of the filter does not have as flat a response in the passband but has a group delay of only D-1 and is cheaper to compute.

The theory behind this block can be found in the paper:

Constructor Specific Documentation:

Make a DC blocker block.

Parameters:
  • D – (int) the length of the delay line
  • long_form – (bool) whether to use long (true, default) or short form
dc_blocker_ff_sptr.active_thread_priority(dc_blocker_ff_sptr self) → int
dc_blocker_ff_sptr.declare_sample_delay(dc_blocker_ff_sptr self, int which, int delay)

declare_sample_delay(dc_blocker_ff_sptr self, unsigned int delay)

dc_blocker_ff_sptr.group_delay(dc_blocker_ff_sptr self) → int
dc_blocker_ff_sptr.message_subscribers(dc_blocker_ff_sptr self, swig_int_ptr which_port) → swig_int_ptr
dc_blocker_ff_sptr.min_noutput_items(dc_blocker_ff_sptr self) → int
dc_blocker_ff_sptr.pc_input_buffers_full_avg(dc_blocker_ff_sptr self, int which) → float

pc_input_buffers_full_avg(dc_blocker_ff_sptr self) -> pmt_vector_float

dc_blocker_ff_sptr.pc_noutput_items_avg(dc_blocker_ff_sptr self) → float
dc_blocker_ff_sptr.pc_nproduced_avg(dc_blocker_ff_sptr self) → float
dc_blocker_ff_sptr.pc_output_buffers_full_avg(dc_blocker_ff_sptr self, int which) → float

pc_output_buffers_full_avg(dc_blocker_ff_sptr self) -> pmt_vector_float

dc_blocker_ff_sptr.pc_throughput_avg(dc_blocker_ff_sptr self) → float
dc_blocker_ff_sptr.pc_work_time_avg(dc_blocker_ff_sptr self) → float
dc_blocker_ff_sptr.pc_work_time_total(dc_blocker_ff_sptr self) → float
dc_blocker_ff_sptr.sample_delay(dc_blocker_ff_sptr self, int which) → unsigned int
dc_blocker_ff_sptr.set_min_noutput_items(dc_blocker_ff_sptr self, int m)
dc_blocker_ff_sptr.set_thread_priority(dc_blocker_ff_sptr self, int priority) → int
dc_blocker_ff_sptr.thread_priority(dc_blocker_ff_sptr self) → int
gnuradio.filter.fft_filter_fff(int decimation, pmt_vector_float taps, int nthreads=1) → fft_filter_fff_sptr

Fast FFT filter with float input, float output and float taps.

This block implements a real-value decimating filter using the fast convolution method via an FFT. The decimation factor is an interger that is greater than or equal to 1.

The filter takes a set of real-valued taps to use in the filtering operation. These taps can be defined as anything that satisfies the user’s filtering needs. For standard filters such as lowpass, highpass, bandpass, etc., the filter.firdes and filter.optfir classes provide convenient generating methods.

This filter is implemented by using the FFTW package to perform the required FFTs. An optional argument, nthreads, may be passed to the constructor (or set using the set_nthreads member function) to split the FFT among N number of threads. This can improve performance on very large FFTs (that is, if the number of taps used is very large) if you have enough threads/cores to support it.

Constructor Specific Documentation:

Build an FFT filter block.

Parameters:
  • decimation – >= 1
  • taps – float filter taps
  • nthreads – number of threads for the FFT to use
fft_filter_fff_sptr.active_thread_priority(fft_filter_fff_sptr self) → int
fft_filter_fff_sptr.declare_sample_delay(fft_filter_fff_sptr self, int which, int delay)

declare_sample_delay(fft_filter_fff_sptr self, unsigned int delay)

fft_filter_fff_sptr.message_subscribers(fft_filter_fff_sptr self, swig_int_ptr which_port) → swig_int_ptr
fft_filter_fff_sptr.min_noutput_items(fft_filter_fff_sptr self) → int
fft_filter_fff_sptr.pc_input_buffers_full_avg(fft_filter_fff_sptr self, int which) → float

pc_input_buffers_full_avg(fft_filter_fff_sptr self) -> pmt_vector_float

fft_filter_fff_sptr.pc_noutput_items_avg(fft_filter_fff_sptr self) → float
fft_filter_fff_sptr.pc_nproduced_avg(fft_filter_fff_sptr self) → float
fft_filter_fff_sptr.pc_output_buffers_full_avg(fft_filter_fff_sptr self, int which) → float

pc_output_buffers_full_avg(fft_filter_fff_sptr self) -> pmt_vector_float

fft_filter_fff_sptr.pc_throughput_avg(fft_filter_fff_sptr self) → float
fft_filter_fff_sptr.pc_work_time_avg(fft_filter_fff_sptr self) → float
fft_filter_fff_sptr.pc_work_time_total(fft_filter_fff_sptr self) → float
fft_filter_fff_sptr.sample_delay(fft_filter_fff_sptr self, int which) → unsigned int
fft_filter_fff_sptr.set_min_noutput_items(fft_filter_fff_sptr self, int m)
fft_filter_fff_sptr.set_taps(fft_filter_fff_sptr self, pmt_vector_float taps)
fft_filter_fff_sptr.set_thread_priority(fft_filter_fff_sptr self, int priority) → int
fft_filter_fff_sptr.taps(fft_filter_fff_sptr self) → pmt_vector_float
fft_filter_fff_sptr.thread_priority(fft_filter_fff_sptr self) → int
gnuradio.filter.fft_filter_ccc(int decimation, pmt_vector_cfloat taps, int nthreads=1) → fft_filter_ccc_sptr

Fast FFT filter with gr_complex input, gr_complex output and gr_complex taps.

This block implements a complex decimating filter using the fast convolution method via an FFT. The decimation factor is an interger that is greater than or equal to 1.

The filter takes a set of complex (or real) taps to use in the filtering operation. These taps can be defined as anything that satisfies the user’s filtering needs. For standard filters such as lowpass, highpass, bandpass, etc., the filter.firdes and filter.optfir classes provide convenient generating methods.

This filter is implemented by using the FFTW package to perform the required FFTs. An optional argument, nthreads, may be passed to the constructor (or set using the set_nthreads member function) to split the FFT among N number of threads. This can improve performance on very large FFTs (that is, if the number of taps used is very large) if you have enough threads/cores to support it.

Constructor Specific Documentation:

Build an FFT filter blocks.

Parameters:
  • decimation – >= 1
  • taps – complex filter taps
  • nthreads – number of threads for the FFT to use
fft_filter_ccc_sptr.active_thread_priority(fft_filter_ccc_sptr self) → int
fft_filter_ccc_sptr.declare_sample_delay(fft_filter_ccc_sptr self, int which, int delay)

declare_sample_delay(fft_filter_ccc_sptr self, unsigned int delay)

fft_filter_ccc_sptr.message_subscribers(fft_filter_ccc_sptr self, swig_int_ptr which_port) → swig_int_ptr
fft_filter_ccc_sptr.min_noutput_items(fft_filter_ccc_sptr self) → int
fft_filter_ccc_sptr.pc_input_buffers_full_avg(fft_filter_ccc_sptr self, int which) → float

pc_input_buffers_full_avg(fft_filter_ccc_sptr self) -> pmt_vector_float

fft_filter_ccc_sptr.pc_noutput_items_avg(fft_filter_ccc_sptr self) → float
fft_filter_ccc_sptr.pc_nproduced_avg(fft_filter_ccc_sptr self) → float
fft_filter_ccc_sptr.pc_output_buffers_full_avg(fft_filter_ccc_sptr self, int which) → float

pc_output_buffers_full_avg(fft_filter_ccc_sptr self) -> pmt_vector_float

fft_filter_ccc_sptr.pc_throughput_avg(fft_filter_ccc_sptr self) → float
fft_filter_ccc_sptr.pc_work_time_avg(fft_filter_ccc_sptr self) → float
fft_filter_ccc_sptr.pc_work_time_total(fft_filter_ccc_sptr self) → float
fft_filter_ccc_sptr.sample_delay(fft_filter_ccc_sptr self, int which) → unsigned int
fft_filter_ccc_sptr.set_min_noutput_items(fft_filter_ccc_sptr self, int m)
fft_filter_ccc_sptr.set_taps(fft_filter_ccc_sptr self, pmt_vector_cfloat taps)
fft_filter_ccc_sptr.set_thread_priority(fft_filter_ccc_sptr self, int priority) → int
fft_filter_ccc_sptr.taps(fft_filter_ccc_sptr self) → pmt_vector_cfloat
fft_filter_ccc_sptr.thread_priority(fft_filter_ccc_sptr self) → int
gnuradio.filter.filter_delay_fc(pmt_vector_float taps) → filter_delay_fc_sptr

Filter-Delay Combination Block.

The block takes one or two float stream and outputs a complex stream.

If only one float stream is input, the real output is a delayed version of this input and the imaginary output is the filtered output.

If two floats are connected to the input, then the real output is the delayed version of the first input, and the imaginary output is the filtered output.

The delay in the real path accounts for the group delay introduced by the filter in the imaginary path. The filter taps needs to be calculated before initializing this block.

Constructor Specific Documentation:

Build a filter with delay block.

Parameters:taps
filter_delay_fc_sptr.active_thread_priority(filter_delay_fc_sptr self) → int
filter_delay_fc_sptr.declare_sample_delay(filter_delay_fc_sptr self, int which, int delay)

declare_sample_delay(filter_delay_fc_sptr self, unsigned int delay)

filter_delay_fc_sptr.message_subscribers(filter_delay_fc_sptr self, swig_int_ptr which_port) → swig_int_ptr
filter_delay_fc_sptr.min_noutput_items(filter_delay_fc_sptr self) → int
filter_delay_fc_sptr.pc_input_buffers_full_avg(filter_delay_fc_sptr self, int which) → float

pc_input_buffers_full_avg(filter_delay_fc_sptr self) -> pmt_vector_float

filter_delay_fc_sptr.pc_noutput_items_avg(filter_delay_fc_sptr self) → float
filter_delay_fc_sptr.pc_nproduced_avg(filter_delay_fc_sptr self) → float
filter_delay_fc_sptr.pc_output_buffers_full_avg(filter_delay_fc_sptr self, int which) → float

pc_output_buffers_full_avg(filter_delay_fc_sptr self) -> pmt_vector_float

filter_delay_fc_sptr.pc_throughput_avg(filter_delay_fc_sptr self) → float
filter_delay_fc_sptr.pc_work_time_avg(filter_delay_fc_sptr self) → float
filter_delay_fc_sptr.pc_work_time_total(filter_delay_fc_sptr self) → float
filter_delay_fc_sptr.sample_delay(filter_delay_fc_sptr self, int which) → unsigned int
filter_delay_fc_sptr.set_min_noutput_items(filter_delay_fc_sptr self, int m)
filter_delay_fc_sptr.set_thread_priority(filter_delay_fc_sptr self, int priority) → int
filter_delay_fc_sptr.thread_priority(filter_delay_fc_sptr self) → int
gnuradio.filter.hilbert_fc(unsigned int ntaps, gr::filter::firdes::win_type window=WIN_HAMMING, double beta=6.76) → hilbert_fc_sptr

Hilbert transformer.

real output is input appropriately delayed. imaginary output is hilbert filtered (90 degree phase shift) version of input.

Constructor Specific Documentation:

Build a Hilbert transformer filter block.

Parameters:
  • ntaps – The number of taps for the filter.
  • window – Window type (see firdes::win_type) to use.
  • beta – Beta value for a Kaiser window.
hilbert_fc_sptr.active_thread_priority(hilbert_fc_sptr self) → int
hilbert_fc_sptr.declare_sample_delay(hilbert_fc_sptr self, int which, int delay)

declare_sample_delay(hilbert_fc_sptr self, unsigned int delay)

hilbert_fc_sptr.message_subscribers(hilbert_fc_sptr self, swig_int_ptr which_port) → swig_int_ptr
hilbert_fc_sptr.min_noutput_items(hilbert_fc_sptr self) → int
hilbert_fc_sptr.pc_input_buffers_full_avg(hilbert_fc_sptr self, int which) → float

pc_input_buffers_full_avg(hilbert_fc_sptr self) -> pmt_vector_float

hilbert_fc_sptr.pc_noutput_items_avg(hilbert_fc_sptr self) → float
hilbert_fc_sptr.pc_nproduced_avg(hilbert_fc_sptr self) → float
hilbert_fc_sptr.pc_output_buffers_full_avg(hilbert_fc_sptr self, int which) → float

pc_output_buffers_full_avg(hilbert_fc_sptr self) -> pmt_vector_float

hilbert_fc_sptr.pc_throughput_avg(hilbert_fc_sptr self) → float
hilbert_fc_sptr.pc_work_time_avg(hilbert_fc_sptr self) → float
hilbert_fc_sptr.pc_work_time_total(hilbert_fc_sptr self) → float
hilbert_fc_sptr.sample_delay(hilbert_fc_sptr self, int which) → unsigned int
hilbert_fc_sptr.set_min_noutput_items(hilbert_fc_sptr self, int m)
hilbert_fc_sptr.set_thread_priority(hilbert_fc_sptr self, int priority) → int
hilbert_fc_sptr.thread_priority(hilbert_fc_sptr self) → int
gnuradio.filter.iir_filter_ffd(pmt_vector_double fftaps, pmt_vector_double fbtaps, bool oldstyle=True) → iir_filter_ffd_sptr

IIR filter with float input, float output and double taps.

This filter uses the Direct Form I implementation, where contains the feed-forward taps, and the feedback ones.

The old style of the IIR filter uses feedback taps that are negative of what most definitions use (scipy and Matlab among them). This parameter keeps using the old GNU Radio style and is set to TRUE by default. When taps generated from scipy, Matlab, or gr_filter_design, use the new style by setting this to FALSE.

The input and output satisfy a difference equation of the form

y[n] - sum_{k=1}^{M} a_k y[n-k] = sum_{k=0}^{N} b_k x[n-k]

with the corresponding rational system function

H(z) = frac{sum_{k=0}^{M} b_k z^{-k}}{1 - sum_{k=1}^{N} a_k z^{-k}}

Constructor Specific Documentation:

Parameters:
  • fftaps
  • fbtaps
  • oldstyle
iir_filter_ffd_sptr.active_thread_priority(iir_filter_ffd_sptr self) → int
iir_filter_ffd_sptr.declare_sample_delay(iir_filter_ffd_sptr self, int which, int delay)

declare_sample_delay(iir_filter_ffd_sptr self, unsigned int delay)

iir_filter_ffd_sptr.message_subscribers(iir_filter_ffd_sptr self, swig_int_ptr which_port) → swig_int_ptr
iir_filter_ffd_sptr.min_noutput_items(iir_filter_ffd_sptr self) → int
iir_filter_ffd_sptr.pc_input_buffers_full_avg(iir_filter_ffd_sptr self, int which) → float

pc_input_buffers_full_avg(iir_filter_ffd_sptr self) -> pmt_vector_float

iir_filter_ffd_sptr.pc_noutput_items_avg(iir_filter_ffd_sptr self) → float
iir_filter_ffd_sptr.pc_nproduced_avg(iir_filter_ffd_sptr self) → float
iir_filter_ffd_sptr.pc_output_buffers_full_avg(iir_filter_ffd_sptr self, int which) → float

pc_output_buffers_full_avg(iir_filter_ffd_sptr self) -> pmt_vector_float

iir_filter_ffd_sptr.pc_throughput_avg(iir_filter_ffd_sptr self) → float
iir_filter_ffd_sptr.pc_work_time_avg(iir_filter_ffd_sptr self) → float
iir_filter_ffd_sptr.pc_work_time_total(iir_filter_ffd_sptr self) → float
iir_filter_ffd_sptr.sample_delay(iir_filter_ffd_sptr self, int which) → unsigned int
iir_filter_ffd_sptr.set_min_noutput_items(iir_filter_ffd_sptr self, int m)
iir_filter_ffd_sptr.set_taps(iir_filter_ffd_sptr self, pmt_vector_double fftaps, pmt_vector_double fbtaps)
iir_filter_ffd_sptr.set_thread_priority(iir_filter_ffd_sptr self, int priority) → int
iir_filter_ffd_sptr.thread_priority(iir_filter_ffd_sptr self) → int
class gnuradio.filter.analysis_filterbank(mpoints, taps=None)

Uniformly modulated polyphase DFT filter bank: analysis

See http://cnx.org/content/m10424/latest

class gnuradio.filter.synthesis_filterbank(mpoints, taps=None)

Uniformly modulated polyphase DFT filter bank: synthesis

See http://cnx.org/content/m10424/latest

gnuradio.filter.single_pole_iir_filter_cc(double alpha, unsigned int vlen=1) → single_pole_iir_filter_cc_sptr

single pole IIR filter with complex input, complex output

The input and output satisfy a difference equation of the form

y[n] - (1-alpha) y[n-1] = alpha x[n]

with the corresponding rational system function

H(z) = frac{alpha}{1 - (1-alpha) z^{-1}}

Note that some texts define the system function with a + in the denominator. If you’re using that convention, you’ll need to negate the feedback tap.

Constructor Specific Documentation:

Parameters:
  • alpha
  • vlen
single_pole_iir_filter_cc_sptr.active_thread_priority(single_pole_iir_filter_cc_sptr self) → int
single_pole_iir_filter_cc_sptr.declare_sample_delay(single_pole_iir_filter_cc_sptr self, int which, int delay)

declare_sample_delay(single_pole_iir_filter_cc_sptr self, unsigned int delay)

single_pole_iir_filter_cc_sptr.message_subscribers(single_pole_iir_filter_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr
single_pole_iir_filter_cc_sptr.min_noutput_items(single_pole_iir_filter_cc_sptr self) → int
single_pole_iir_filter_cc_sptr.pc_input_buffers_full_avg(single_pole_iir_filter_cc_sptr self, int which) → float

pc_input_buffers_full_avg(single_pole_iir_filter_cc_sptr self) -> pmt_vector_float

single_pole_iir_filter_cc_sptr.pc_noutput_items_avg(single_pole_iir_filter_cc_sptr self) → float
single_pole_iir_filter_cc_sptr.pc_nproduced_avg(single_pole_iir_filter_cc_sptr self) → float
single_pole_iir_filter_cc_sptr.pc_output_buffers_full_avg(single_pole_iir_filter_cc_sptr self, int which) → float

pc_output_buffers_full_avg(single_pole_iir_filter_cc_sptr self) -> pmt_vector_float

single_pole_iir_filter_cc_sptr.pc_throughput_avg(single_pole_iir_filter_cc_sptr self) → float
single_pole_iir_filter_cc_sptr.pc_work_time_avg(single_pole_iir_filter_cc_sptr self) → float
single_pole_iir_filter_cc_sptr.pc_work_time_total(single_pole_iir_filter_cc_sptr self) → float
single_pole_iir_filter_cc_sptr.sample_delay(single_pole_iir_filter_cc_sptr self, int which) → unsigned int
single_pole_iir_filter_cc_sptr.set_min_noutput_items(single_pole_iir_filter_cc_sptr self, int m)
single_pole_iir_filter_cc_sptr.set_taps(single_pole_iir_filter_cc_sptr self, double alpha)
single_pole_iir_filter_cc_sptr.set_thread_priority(single_pole_iir_filter_cc_sptr self, int priority) → int
single_pole_iir_filter_cc_sptr.thread_priority(single_pole_iir_filter_cc_sptr self) → int
gnuradio.filter.single_pole_iir_filter_ff(double alpha, unsigned int vlen=1) → single_pole_iir_filter_ff_sptr

single pole IIR filter with float input, float output

The input and output satisfy a difference equation of the form

y[n] - (1-alpha) y[n-1] = alpha x[n]

with the corresponding rational system function

H(z) = frac{alpha}{1 - (1-alpha) z^{-1}}

Note that some texts define the system function with a + in the denominator. If you’re using that convention, you’ll need to negate the feedback tap.

Constructor Specific Documentation:

Parameters:
  • alpha
  • vlen
single_pole_iir_filter_ff_sptr.active_thread_priority(single_pole_iir_filter_ff_sptr self) → int
single_pole_iir_filter_ff_sptr.declare_sample_delay(single_pole_iir_filter_ff_sptr self, int which, int delay)

declare_sample_delay(single_pole_iir_filter_ff_sptr self, unsigned int delay)

single_pole_iir_filter_ff_sptr.message_subscribers(single_pole_iir_filter_ff_sptr self, swig_int_ptr which_port) → swig_int_ptr
single_pole_iir_filter_ff_sptr.min_noutput_items(single_pole_iir_filter_ff_sptr self) → int
single_pole_iir_filter_ff_sptr.pc_input_buffers_full_avg(single_pole_iir_filter_ff_sptr self, int which) → float

pc_input_buffers_full_avg(single_pole_iir_filter_ff_sptr self) -> pmt_vector_float

single_pole_iir_filter_ff_sptr.pc_noutput_items_avg(single_pole_iir_filter_ff_sptr self) → float
single_pole_iir_filter_ff_sptr.pc_nproduced_avg(single_pole_iir_filter_ff_sptr self) → float
single_pole_iir_filter_ff_sptr.pc_output_buffers_full_avg(single_pole_iir_filter_ff_sptr self, int which) → float

pc_output_buffers_full_avg(single_pole_iir_filter_ff_sptr self) -> pmt_vector_float

single_pole_iir_filter_ff_sptr.pc_throughput_avg(single_pole_iir_filter_ff_sptr self) → float
single_pole_iir_filter_ff_sptr.pc_work_time_avg(single_pole_iir_filter_ff_sptr self) → float
single_pole_iir_filter_ff_sptr.pc_work_time_total(single_pole_iir_filter_ff_sptr self) → float
single_pole_iir_filter_ff_sptr.sample_delay(single_pole_iir_filter_ff_sptr self, int which) → unsigned int
single_pole_iir_filter_ff_sptr.set_min_noutput_items(single_pole_iir_filter_ff_sptr self, int m)
single_pole_iir_filter_ff_sptr.set_taps(single_pole_iir_filter_ff_sptr self, double alpha)
single_pole_iir_filter_ff_sptr.set_thread_priority(single_pole_iir_filter_ff_sptr self, int priority) → int
single_pole_iir_filter_ff_sptr.thread_priority(single_pole_iir_filter_ff_sptr self) → int

Previous topic

gnuradio.filter: Resamplers

Next topic

gnuradio.filter: Digital Filter Design

This Page