gnuradio.filters¶

Filter blocks and related functions.

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

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¶

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_ccc(int decimation, pmt_vector_cfloat taps, int nthreads=1) → fft_filter_ccc_sptr¶

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.fft_filter_ccf(int decimation, pmt_vector_float taps, int nthreads=1) → fft_filter_ccf_sptr¶

fft_filter_ccf_sptr.active_thread_priority(fft_filter_ccf_sptr self) → int¶

fft_filter_ccf_sptr.declare_sample_delay(fft_filter_ccf_sptr self, int which, int delay)¶: declare_sample_delay(fft_filter_ccf_sptr self, unsigned int delay)

fft_filter_ccf_sptr.message_subscribers(fft_filter_ccf_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

fft_filter_ccf_sptr.min_noutput_items(fft_filter_ccf_sptr self) → int¶

fft_filter_ccf_sptr.pc_input_buffers_full_avg(fft_filter_ccf_sptr self, int which) → float¶: pc_input_buffers_full_avg(fft_filter_ccf_sptr self) -> pmt_vector_float

fft_filter_ccf_sptr.pc_noutput_items_avg(fft_filter_ccf_sptr self) → float¶

fft_filter_ccf_sptr.pc_nproduced_avg(fft_filter_ccf_sptr self) → float¶

fft_filter_ccf_sptr.pc_output_buffers_full_avg(fft_filter_ccf_sptr self, int which) → float¶: pc_output_buffers_full_avg(fft_filter_ccf_sptr self) -> pmt_vector_float

fft_filter_ccf_sptr.pc_throughput_avg(fft_filter_ccf_sptr self) → float¶

fft_filter_ccf_sptr.pc_work_time_avg(fft_filter_ccf_sptr self) → float¶

fft_filter_ccf_sptr.pc_work_time_total(fft_filter_ccf_sptr self) → float¶

fft_filter_ccf_sptr.sample_delay(fft_filter_ccf_sptr self, int which) → unsigned int¶

fft_filter_ccf_sptr.set_min_noutput_items(fft_filter_ccf_sptr self, int m)¶

fft_filter_ccf_sptr.set_taps(fft_filter_ccf_sptr self, pmt_vector_float taps)¶

fft_filter_ccf_sptr.set_thread_priority(fft_filter_ccf_sptr self, int priority) → int¶

fft_filter_ccf_sptr.taps(fft_filter_ccf_sptr self) → pmt_vector_float¶

fft_filter_ccf_sptr.thread_priority(fft_filter_ccf_sptr self) → int¶

gnuradio.filter.fft_filter_fff(int decimation, pmt_vector_float taps, int nthreads=1) → fft_filter_fff_sptr¶

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.filter_delay_fc(pmt_vector_float taps) → filter_delay_fc_sptr¶

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.filterbank_vcvcf(std::vector< std::vector< float, std::allocator< float > >, std::allocator< std::vector< float, std::allocator< float > > > > const & taps) → filterbank_vcvcf_sptr¶

filterbank_vcvcf_sptr.active_thread_priority(filterbank_vcvcf_sptr self) → int¶

filterbank_vcvcf_sptr.declare_sample_delay(filterbank_vcvcf_sptr self, int which, int delay)¶: declare_sample_delay(filterbank_vcvcf_sptr self, unsigned int delay)

filterbank_vcvcf_sptr.message_subscribers(filterbank_vcvcf_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

filterbank_vcvcf_sptr.min_noutput_items(filterbank_vcvcf_sptr self) → int¶

filterbank_vcvcf_sptr.pc_input_buffers_full_avg(filterbank_vcvcf_sptr self, int which) → float¶: pc_input_buffers_full_avg(filterbank_vcvcf_sptr self) -> pmt_vector_float

filterbank_vcvcf_sptr.pc_noutput_items_avg(filterbank_vcvcf_sptr self) → float¶

filterbank_vcvcf_sptr.pc_nproduced_avg(filterbank_vcvcf_sptr self) → float¶

filterbank_vcvcf_sptr.pc_output_buffers_full_avg(filterbank_vcvcf_sptr self, int which) → float¶: pc_output_buffers_full_avg(filterbank_vcvcf_sptr self) -> pmt_vector_float

filterbank_vcvcf_sptr.pc_throughput_avg(filterbank_vcvcf_sptr self) → float¶

filterbank_vcvcf_sptr.pc_work_time_avg(filterbank_vcvcf_sptr self) → float¶

filterbank_vcvcf_sptr.pc_work_time_total(filterbank_vcvcf_sptr self) → float¶

filterbank_vcvcf_sptr.print_taps(filterbank_vcvcf_sptr self)¶

filterbank_vcvcf_sptr.sample_delay(filterbank_vcvcf_sptr self, int which) → unsigned int¶

filterbank_vcvcf_sptr.set_min_noutput_items(filterbank_vcvcf_sptr self, int m)¶

filterbank_vcvcf_sptr.set_taps(filterbank_vcvcf_sptr self, std::vector< std::vector< float, std::allocator< float > >, std::allocator< std::vector< float, std::allocator< float > > > > const & taps)¶

filterbank_vcvcf_sptr.set_thread_priority(filterbank_vcvcf_sptr self, int priority) → int¶

filterbank_vcvcf_sptr.taps(filterbank_vcvcf_sptr self) → std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >¶

filterbank_vcvcf_sptr.thread_priority(filterbank_vcvcf_sptr self) → int¶

gnuradio.filter.fir_filter_ccc(int decimation, pmt_vector_cfloat taps) → fir_filter_ccc_sptr¶

fir_filter_ccc_sptr.active_thread_priority(fir_filter_ccc_sptr self) → int¶

fir_filter_ccc_sptr.declare_sample_delay(fir_filter_ccc_sptr self, int which, int delay)¶: declare_sample_delay(fir_filter_ccc_sptr self, unsigned int delay)

fir_filter_ccc_sptr.message_subscribers(fir_filter_ccc_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

fir_filter_ccc_sptr.min_noutput_items(fir_filter_ccc_sptr self) → int¶

fir_filter_ccc_sptr.pc_input_buffers_full_avg(fir_filter_ccc_sptr self, int which) → float¶: pc_input_buffers_full_avg(fir_filter_ccc_sptr self) -> pmt_vector_float

fir_filter_ccc_sptr.pc_noutput_items_avg(fir_filter_ccc_sptr self) → float¶

fir_filter_ccc_sptr.pc_nproduced_avg(fir_filter_ccc_sptr self) → float¶

fir_filter_ccc_sptr.pc_output_buffers_full_avg(fir_filter_ccc_sptr self, int which) → float¶: pc_output_buffers_full_avg(fir_filter_ccc_sptr self) -> pmt_vector_float

fir_filter_ccc_sptr.pc_throughput_avg(fir_filter_ccc_sptr self) → float¶

fir_filter_ccc_sptr.pc_work_time_avg(fir_filter_ccc_sptr self) → float¶

fir_filter_ccc_sptr.pc_work_time_total(fir_filter_ccc_sptr self) → float¶

fir_filter_ccc_sptr.sample_delay(fir_filter_ccc_sptr self, int which) → unsigned int¶

fir_filter_ccc_sptr.set_min_noutput_items(fir_filter_ccc_sptr self, int m)¶

fir_filter_ccc_sptr.set_taps(fir_filter_ccc_sptr self, pmt_vector_cfloat taps)¶

fir_filter_ccc_sptr.set_thread_priority(fir_filter_ccc_sptr self, int priority) → int¶

fir_filter_ccc_sptr.taps(fir_filter_ccc_sptr self) → pmt_vector_cfloat¶

fir_filter_ccc_sptr.thread_priority(fir_filter_ccc_sptr self) → int¶

gnuradio.filter.fir_filter_ccf(int decimation, pmt_vector_float taps) → fir_filter_ccf_sptr¶

fir_filter_ccf_sptr.active_thread_priority(fir_filter_ccf_sptr self) → int¶

fir_filter_ccf_sptr.declare_sample_delay(fir_filter_ccf_sptr self, int which, int delay)¶: declare_sample_delay(fir_filter_ccf_sptr self, unsigned int delay)

fir_filter_ccf_sptr.message_subscribers(fir_filter_ccf_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

fir_filter_ccf_sptr.min_noutput_items(fir_filter_ccf_sptr self) → int¶

fir_filter_ccf_sptr.pc_input_buffers_full_avg(fir_filter_ccf_sptr self, int which) → float¶: pc_input_buffers_full_avg(fir_filter_ccf_sptr self) -> pmt_vector_float

fir_filter_ccf_sptr.pc_noutput_items_avg(fir_filter_ccf_sptr self) → float¶

fir_filter_ccf_sptr.pc_nproduced_avg(fir_filter_ccf_sptr self) → float¶

fir_filter_ccf_sptr.pc_output_buffers_full_avg(fir_filter_ccf_sptr self, int which) → float¶: pc_output_buffers_full_avg(fir_filter_ccf_sptr self) -> pmt_vector_float

fir_filter_ccf_sptr.pc_throughput_avg(fir_filter_ccf_sptr self) → float¶

fir_filter_ccf_sptr.pc_work_time_avg(fir_filter_ccf_sptr self) → float¶

fir_filter_ccf_sptr.pc_work_time_total(fir_filter_ccf_sptr self) → float¶

fir_filter_ccf_sptr.sample_delay(fir_filter_ccf_sptr self, int which) → unsigned int¶

fir_filter_ccf_sptr.set_min_noutput_items(fir_filter_ccf_sptr self, int m)¶

fir_filter_ccf_sptr.set_taps(fir_filter_ccf_sptr self, pmt_vector_float taps)¶

fir_filter_ccf_sptr.set_thread_priority(fir_filter_ccf_sptr self, int priority) → int¶

fir_filter_ccf_sptr.taps(fir_filter_ccf_sptr self) → pmt_vector_float¶

fir_filter_ccf_sptr.thread_priority(fir_filter_ccf_sptr self) → int¶

gnuradio.filter.fir_filter_fcc(int decimation, pmt_vector_cfloat taps) → fir_filter_fcc_sptr¶

fir_filter_fcc_sptr.active_thread_priority(fir_filter_fcc_sptr self) → int¶

fir_filter_fcc_sptr.declare_sample_delay(fir_filter_fcc_sptr self, int which, int delay)¶: declare_sample_delay(fir_filter_fcc_sptr self, unsigned int delay)

fir_filter_fcc_sptr.message_subscribers(fir_filter_fcc_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

fir_filter_fcc_sptr.min_noutput_items(fir_filter_fcc_sptr self) → int¶

fir_filter_fcc_sptr.pc_input_buffers_full_avg(fir_filter_fcc_sptr self, int which) → float¶: pc_input_buffers_full_avg(fir_filter_fcc_sptr self) -> pmt_vector_float

fir_filter_fcc_sptr.pc_noutput_items_avg(fir_filter_fcc_sptr self) → float¶

fir_filter_fcc_sptr.pc_nproduced_avg(fir_filter_fcc_sptr self) → float¶

fir_filter_fcc_sptr.pc_output_buffers_full_avg(fir_filter_fcc_sptr self, int which) → float¶: pc_output_buffers_full_avg(fir_filter_fcc_sptr self) -> pmt_vector_float

fir_filter_fcc_sptr.pc_throughput_avg(fir_filter_fcc_sptr self) → float¶

fir_filter_fcc_sptr.pc_work_time_avg(fir_filter_fcc_sptr self) → float¶

fir_filter_fcc_sptr.pc_work_time_total(fir_filter_fcc_sptr self) → float¶

fir_filter_fcc_sptr.sample_delay(fir_filter_fcc_sptr self, int which) → unsigned int¶

fir_filter_fcc_sptr.set_min_noutput_items(fir_filter_fcc_sptr self, int m)¶

fir_filter_fcc_sptr.set_taps(fir_filter_fcc_sptr self, pmt_vector_cfloat taps)¶

fir_filter_fcc_sptr.set_thread_priority(fir_filter_fcc_sptr self, int priority) → int¶

fir_filter_fcc_sptr.taps(fir_filter_fcc_sptr self) → pmt_vector_cfloat¶

fir_filter_fcc_sptr.thread_priority(fir_filter_fcc_sptr self) → int¶

gnuradio.filter.fir_filter_fff(int decimation, pmt_vector_float taps) → fir_filter_fff_sptr¶

fir_filter_fff_sptr.active_thread_priority(fir_filter_fff_sptr self) → int¶

fir_filter_fff_sptr.declare_sample_delay(fir_filter_fff_sptr self, int which, int delay)¶: declare_sample_delay(fir_filter_fff_sptr self, unsigned int delay)

fir_filter_fff_sptr.message_subscribers(fir_filter_fff_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

fir_filter_fff_sptr.min_noutput_items(fir_filter_fff_sptr self) → int¶

fir_filter_fff_sptr.pc_input_buffers_full_avg(fir_filter_fff_sptr self, int which) → float¶: pc_input_buffers_full_avg(fir_filter_fff_sptr self) -> pmt_vector_float

fir_filter_fff_sptr.pc_noutput_items_avg(fir_filter_fff_sptr self) → float¶

fir_filter_fff_sptr.pc_nproduced_avg(fir_filter_fff_sptr self) → float¶

fir_filter_fff_sptr.pc_output_buffers_full_avg(fir_filter_fff_sptr self, int which) → float¶: pc_output_buffers_full_avg(fir_filter_fff_sptr self) -> pmt_vector_float

fir_filter_fff_sptr.pc_throughput_avg(fir_filter_fff_sptr self) → float¶

fir_filter_fff_sptr.pc_work_time_avg(fir_filter_fff_sptr self) → float¶

fir_filter_fff_sptr.pc_work_time_total(fir_filter_fff_sptr self) → float¶

fir_filter_fff_sptr.sample_delay(fir_filter_fff_sptr self, int which) → unsigned int¶

fir_filter_fff_sptr.set_min_noutput_items(fir_filter_fff_sptr self, int m)¶

fir_filter_fff_sptr.set_taps(fir_filter_fff_sptr self, pmt_vector_float taps)¶

fir_filter_fff_sptr.set_thread_priority(fir_filter_fff_sptr self, int priority) → int¶

fir_filter_fff_sptr.taps(fir_filter_fff_sptr self) → pmt_vector_float¶

fir_filter_fff_sptr.thread_priority(fir_filter_fff_sptr self) → int¶

gnuradio.filter.fir_filter_fsf(int decimation, pmt_vector_float taps) → fir_filter_fsf_sptr¶

fir_filter_fsf_sptr.active_thread_priority(fir_filter_fsf_sptr self) → int¶

fir_filter_fsf_sptr.declare_sample_delay(fir_filter_fsf_sptr self, int which, int delay)¶: declare_sample_delay(fir_filter_fsf_sptr self, unsigned int delay)

fir_filter_fsf_sptr.message_subscribers(fir_filter_fsf_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

fir_filter_fsf_sptr.min_noutput_items(fir_filter_fsf_sptr self) → int¶

fir_filter_fsf_sptr.pc_input_buffers_full_avg(fir_filter_fsf_sptr self, int which) → float¶: pc_input_buffers_full_avg(fir_filter_fsf_sptr self) -> pmt_vector_float

fir_filter_fsf_sptr.pc_noutput_items_avg(fir_filter_fsf_sptr self) → float¶

fir_filter_fsf_sptr.pc_nproduced_avg(fir_filter_fsf_sptr self) → float¶

fir_filter_fsf_sptr.pc_output_buffers_full_avg(fir_filter_fsf_sptr self, int which) → float¶: pc_output_buffers_full_avg(fir_filter_fsf_sptr self) -> pmt_vector_float

fir_filter_fsf_sptr.pc_throughput_avg(fir_filter_fsf_sptr self) → float¶

fir_filter_fsf_sptr.pc_work_time_avg(fir_filter_fsf_sptr self) → float¶

fir_filter_fsf_sptr.pc_work_time_total(fir_filter_fsf_sptr self) → float¶

fir_filter_fsf_sptr.sample_delay(fir_filter_fsf_sptr self, int which) → unsigned int¶

fir_filter_fsf_sptr.set_min_noutput_items(fir_filter_fsf_sptr self, int m)¶

fir_filter_fsf_sptr.set_taps(fir_filter_fsf_sptr self, pmt_vector_float taps)¶

fir_filter_fsf_sptr.set_thread_priority(fir_filter_fsf_sptr self, int priority) → int¶

fir_filter_fsf_sptr.taps(fir_filter_fsf_sptr self) → pmt_vector_float¶

fir_filter_fsf_sptr.thread_priority(fir_filter_fsf_sptr self) → int¶

gnuradio.filter.fir_filter_scc(int decimation, pmt_vector_cfloat taps) → fir_filter_scc_sptr¶

fir_filter_scc_sptr.active_thread_priority(fir_filter_scc_sptr self) → int¶

fir_filter_scc_sptr.declare_sample_delay(fir_filter_scc_sptr self, int which, int delay)¶: declare_sample_delay(fir_filter_scc_sptr self, unsigned int delay)

fir_filter_scc_sptr.message_subscribers(fir_filter_scc_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

fir_filter_scc_sptr.min_noutput_items(fir_filter_scc_sptr self) → int¶

fir_filter_scc_sptr.pc_input_buffers_full_avg(fir_filter_scc_sptr self, int which) → float¶: pc_input_buffers_full_avg(fir_filter_scc_sptr self) -> pmt_vector_float

fir_filter_scc_sptr.pc_noutput_items_avg(fir_filter_scc_sptr self) → float¶

fir_filter_scc_sptr.pc_nproduced_avg(fir_filter_scc_sptr self) → float¶

fir_filter_scc_sptr.pc_output_buffers_full_avg(fir_filter_scc_sptr self, int which) → float¶: pc_output_buffers_full_avg(fir_filter_scc_sptr self) -> pmt_vector_float

fir_filter_scc_sptr.pc_throughput_avg(fir_filter_scc_sptr self) → float¶

fir_filter_scc_sptr.pc_work_time_avg(fir_filter_scc_sptr self) → float¶

fir_filter_scc_sptr.pc_work_time_total(fir_filter_scc_sptr self) → float¶

fir_filter_scc_sptr.sample_delay(fir_filter_scc_sptr self, int which) → unsigned int¶

fir_filter_scc_sptr.set_min_noutput_items(fir_filter_scc_sptr self, int m)¶

fir_filter_scc_sptr.set_taps(fir_filter_scc_sptr self, pmt_vector_cfloat taps)¶

fir_filter_scc_sptr.set_thread_priority(fir_filter_scc_sptr self, int priority) → int¶

fir_filter_scc_sptr.taps(fir_filter_scc_sptr self) → pmt_vector_cfloat¶

fir_filter_scc_sptr.thread_priority(fir_filter_scc_sptr self) → int¶

gnuradio.filter.fractional_interpolator_cc(float phase_shift, float interp_ratio) → fractional_interpolator_cc_sptr¶

fractional_interpolator_cc_sptr.active_thread_priority(fractional_interpolator_cc_sptr self) → int¶

fractional_interpolator_cc_sptr.declare_sample_delay(fractional_interpolator_cc_sptr self, int which, int delay)¶: declare_sample_delay(fractional_interpolator_cc_sptr self, unsigned int delay)

fractional_interpolator_cc_sptr.interp_ratio(fractional_interpolator_cc_sptr self) → float¶

fractional_interpolator_cc_sptr.message_subscribers(fractional_interpolator_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

fractional_interpolator_cc_sptr.min_noutput_items(fractional_interpolator_cc_sptr self) → int¶

fractional_interpolator_cc_sptr.mu(fractional_interpolator_cc_sptr self) → float¶

fractional_interpolator_cc_sptr.pc_input_buffers_full_avg(fractional_interpolator_cc_sptr self, int which) → float¶: pc_input_buffers_full_avg(fractional_interpolator_cc_sptr self) -> pmt_vector_float

fractional_interpolator_cc_sptr.pc_noutput_items_avg(fractional_interpolator_cc_sptr self) → float¶

fractional_interpolator_cc_sptr.pc_nproduced_avg(fractional_interpolator_cc_sptr self) → float¶

fractional_interpolator_cc_sptr.pc_output_buffers_full_avg(fractional_interpolator_cc_sptr self, int which) → float¶: pc_output_buffers_full_avg(fractional_interpolator_cc_sptr self) -> pmt_vector_float

fractional_interpolator_cc_sptr.pc_throughput_avg(fractional_interpolator_cc_sptr self) → float¶

fractional_interpolator_cc_sptr.pc_work_time_avg(fractional_interpolator_cc_sptr self) → float¶

fractional_interpolator_cc_sptr.pc_work_time_total(fractional_interpolator_cc_sptr self) → float¶

fractional_interpolator_cc_sptr.sample_delay(fractional_interpolator_cc_sptr self, int which) → unsigned int¶

fractional_interpolator_cc_sptr.set_interp_ratio(fractional_interpolator_cc_sptr self, float interp_ratio)¶

fractional_interpolator_cc_sptr.set_min_noutput_items(fractional_interpolator_cc_sptr self, int m)¶

fractional_interpolator_cc_sptr.set_mu(fractional_interpolator_cc_sptr self, float mu)¶

fractional_interpolator_cc_sptr.set_thread_priority(fractional_interpolator_cc_sptr self, int priority) → int¶

fractional_interpolator_cc_sptr.thread_priority(fractional_interpolator_cc_sptr self) → int¶

gnuradio.filter.fractional_interpolator_ff(float phase_shift, float interp_ratio) → fractional_interpolator_ff_sptr¶

fractional_interpolator_ff_sptr.active_thread_priority(fractional_interpolator_ff_sptr self) → int¶

fractional_interpolator_ff_sptr.declare_sample_delay(fractional_interpolator_ff_sptr self, int which, int delay)¶: declare_sample_delay(fractional_interpolator_ff_sptr self, unsigned int delay)

fractional_interpolator_ff_sptr.interp_ratio(fractional_interpolator_ff_sptr self) → float¶

fractional_interpolator_ff_sptr.message_subscribers(fractional_interpolator_ff_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

fractional_interpolator_ff_sptr.min_noutput_items(fractional_interpolator_ff_sptr self) → int¶

fractional_interpolator_ff_sptr.mu(fractional_interpolator_ff_sptr self) → float¶

fractional_interpolator_ff_sptr.pc_input_buffers_full_avg(fractional_interpolator_ff_sptr self, int which) → float¶: pc_input_buffers_full_avg(fractional_interpolator_ff_sptr self) -> pmt_vector_float

fractional_interpolator_ff_sptr.pc_noutput_items_avg(fractional_interpolator_ff_sptr self) → float¶

fractional_interpolator_ff_sptr.pc_nproduced_avg(fractional_interpolator_ff_sptr self) → float¶

fractional_interpolator_ff_sptr.pc_output_buffers_full_avg(fractional_interpolator_ff_sptr self, int which) → float¶: pc_output_buffers_full_avg(fractional_interpolator_ff_sptr self) -> pmt_vector_float

fractional_interpolator_ff_sptr.pc_throughput_avg(fractional_interpolator_ff_sptr self) → float¶

fractional_interpolator_ff_sptr.pc_work_time_avg(fractional_interpolator_ff_sptr self) → float¶

fractional_interpolator_ff_sptr.pc_work_time_total(fractional_interpolator_ff_sptr self) → float¶

fractional_interpolator_ff_sptr.sample_delay(fractional_interpolator_ff_sptr self, int which) → unsigned int¶

fractional_interpolator_ff_sptr.set_interp_ratio(fractional_interpolator_ff_sptr self, float interp_ratio)¶

fractional_interpolator_ff_sptr.set_min_noutput_items(fractional_interpolator_ff_sptr self, int m)¶

fractional_interpolator_ff_sptr.set_mu(fractional_interpolator_ff_sptr self, float mu)¶

fractional_interpolator_ff_sptr.set_thread_priority(fractional_interpolator_ff_sptr self, int priority) → int¶

fractional_interpolator_ff_sptr.thread_priority(fractional_interpolator_ff_sptr self) → int¶

gnuradio.filter.fractional_resampler_cc(float phase_shift, float resamp_ratio) → fractional_resampler_cc_sptr¶

fractional_resampler_cc_sptr.active_thread_priority(fractional_resampler_cc_sptr self) → int¶

fractional_resampler_cc_sptr.declare_sample_delay(fractional_resampler_cc_sptr self, int which, int delay)¶: declare_sample_delay(fractional_resampler_cc_sptr self, unsigned int delay)

fractional_resampler_cc_sptr.message_subscribers(fractional_resampler_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

fractional_resampler_cc_sptr.min_noutput_items(fractional_resampler_cc_sptr self) → int¶

fractional_resampler_cc_sptr.mu(fractional_resampler_cc_sptr self) → float¶

fractional_resampler_cc_sptr.pc_input_buffers_full_avg(fractional_resampler_cc_sptr self, int which) → float¶: pc_input_buffers_full_avg(fractional_resampler_cc_sptr self) -> pmt_vector_float

fractional_resampler_cc_sptr.pc_noutput_items_avg(fractional_resampler_cc_sptr self) → float¶

fractional_resampler_cc_sptr.pc_nproduced_avg(fractional_resampler_cc_sptr self) → float¶

fractional_resampler_cc_sptr.pc_output_buffers_full_avg(fractional_resampler_cc_sptr self, int which) → float¶: pc_output_buffers_full_avg(fractional_resampler_cc_sptr self) -> pmt_vector_float

fractional_resampler_cc_sptr.pc_throughput_avg(fractional_resampler_cc_sptr self) → float¶

fractional_resampler_cc_sptr.pc_work_time_avg(fractional_resampler_cc_sptr self) → float¶

fractional_resampler_cc_sptr.pc_work_time_total(fractional_resampler_cc_sptr self) → float¶

fractional_resampler_cc_sptr.resamp_ratio(fractional_resampler_cc_sptr self) → float¶

fractional_resampler_cc_sptr.sample_delay(fractional_resampler_cc_sptr self, int which) → unsigned int¶

fractional_resampler_cc_sptr.set_min_noutput_items(fractional_resampler_cc_sptr self, int m)¶

fractional_resampler_cc_sptr.set_mu(fractional_resampler_cc_sptr self, float mu)¶

fractional_resampler_cc_sptr.set_resamp_ratio(fractional_resampler_cc_sptr self, float resamp_ratio)¶

fractional_resampler_cc_sptr.set_thread_priority(fractional_resampler_cc_sptr self, int priority) → int¶

fractional_resampler_cc_sptr.thread_priority(fractional_resampler_cc_sptr self) → int¶

gnuradio.filter.fractional_resampler_ff(float phase_shift, float resamp_ratio) → fractional_resampler_ff_sptr¶

fractional_resampler_ff_sptr.active_thread_priority(fractional_resampler_ff_sptr self) → int¶

fractional_resampler_ff_sptr.declare_sample_delay(fractional_resampler_ff_sptr self, int which, int delay)¶: declare_sample_delay(fractional_resampler_ff_sptr self, unsigned int delay)

fractional_resampler_ff_sptr.message_subscribers(fractional_resampler_ff_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

fractional_resampler_ff_sptr.min_noutput_items(fractional_resampler_ff_sptr self) → int¶

fractional_resampler_ff_sptr.mu(fractional_resampler_ff_sptr self) → float¶

fractional_resampler_ff_sptr.pc_input_buffers_full_avg(fractional_resampler_ff_sptr self, int which) → float¶: pc_input_buffers_full_avg(fractional_resampler_ff_sptr self) -> pmt_vector_float

fractional_resampler_ff_sptr.pc_noutput_items_avg(fractional_resampler_ff_sptr self) → float¶

fractional_resampler_ff_sptr.pc_nproduced_avg(fractional_resampler_ff_sptr self) → float¶

fractional_resampler_ff_sptr.pc_output_buffers_full_avg(fractional_resampler_ff_sptr self, int which) → float¶: pc_output_buffers_full_avg(fractional_resampler_ff_sptr self) -> pmt_vector_float

fractional_resampler_ff_sptr.pc_throughput_avg(fractional_resampler_ff_sptr self) → float¶

fractional_resampler_ff_sptr.pc_work_time_avg(fractional_resampler_ff_sptr self) → float¶

fractional_resampler_ff_sptr.pc_work_time_total(fractional_resampler_ff_sptr self) → float¶

fractional_resampler_ff_sptr.resamp_ratio(fractional_resampler_ff_sptr self) → float¶

fractional_resampler_ff_sptr.sample_delay(fractional_resampler_ff_sptr self, int which) → unsigned int¶

fractional_resampler_ff_sptr.set_min_noutput_items(fractional_resampler_ff_sptr self, int m)¶

fractional_resampler_ff_sptr.set_mu(fractional_resampler_ff_sptr self, float mu)¶

fractional_resampler_ff_sptr.set_resamp_ratio(fractional_resampler_ff_sptr self, float resamp_ratio)¶

fractional_resampler_ff_sptr.set_thread_priority(fractional_resampler_ff_sptr self, int priority) → int¶

fractional_resampler_ff_sptr.thread_priority(fractional_resampler_ff_sptr self) → int¶

gnuradio.filter.freq_xlating_fir_filter_ccc(int decimation, pmt_vector_cfloat taps, double center_freq, double sampling_freq) → freq_xlating_fir_filter_ccc_sptr¶

freq_xlating_fir_filter_ccc_sptr.active_thread_priority(freq_xlating_fir_filter_ccc_sptr self) → int¶

freq_xlating_fir_filter_ccc_sptr.center_freq(freq_xlating_fir_filter_ccc_sptr self) → double¶

freq_xlating_fir_filter_ccc_sptr.declare_sample_delay(freq_xlating_fir_filter_ccc_sptr self, int which, int delay)¶: declare_sample_delay(freq_xlating_fir_filter_ccc_sptr self, unsigned int delay)

freq_xlating_fir_filter_ccc_sptr.message_subscribers(freq_xlating_fir_filter_ccc_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

freq_xlating_fir_filter_ccc_sptr.min_noutput_items(freq_xlating_fir_filter_ccc_sptr self) → int¶

freq_xlating_fir_filter_ccc_sptr.pc_input_buffers_full_avg(freq_xlating_fir_filter_ccc_sptr self, int which) → float¶: pc_input_buffers_full_avg(freq_xlating_fir_filter_ccc_sptr self) -> pmt_vector_float

freq_xlating_fir_filter_ccc_sptr.pc_noutput_items_avg(freq_xlating_fir_filter_ccc_sptr self) → float¶

freq_xlating_fir_filter_ccc_sptr.pc_nproduced_avg(freq_xlating_fir_filter_ccc_sptr self) → float¶

freq_xlating_fir_filter_ccc_sptr.pc_output_buffers_full_avg(freq_xlating_fir_filter_ccc_sptr self, int which) → float¶: pc_output_buffers_full_avg(freq_xlating_fir_filter_ccc_sptr self) -> pmt_vector_float

freq_xlating_fir_filter_ccc_sptr.pc_throughput_avg(freq_xlating_fir_filter_ccc_sptr self) → float¶

freq_xlating_fir_filter_ccc_sptr.pc_work_time_avg(freq_xlating_fir_filter_ccc_sptr self) → float¶

freq_xlating_fir_filter_ccc_sptr.pc_work_time_total(freq_xlating_fir_filter_ccc_sptr self) → float¶

freq_xlating_fir_filter_ccc_sptr.sample_delay(freq_xlating_fir_filter_ccc_sptr self, int which) → unsigned int¶

freq_xlating_fir_filter_ccc_sptr.set_center_freq(freq_xlating_fir_filter_ccc_sptr self, double center_freq)¶

freq_xlating_fir_filter_ccc_sptr.set_min_noutput_items(freq_xlating_fir_filter_ccc_sptr self, int m)¶

freq_xlating_fir_filter_ccc_sptr.set_taps(freq_xlating_fir_filter_ccc_sptr self, pmt_vector_cfloat taps)¶

freq_xlating_fir_filter_ccc_sptr.set_thread_priority(freq_xlating_fir_filter_ccc_sptr self, int priority) → int¶

freq_xlating_fir_filter_ccc_sptr.taps(freq_xlating_fir_filter_ccc_sptr self) → pmt_vector_cfloat¶

freq_xlating_fir_filter_ccc_sptr.thread_priority(freq_xlating_fir_filter_ccc_sptr self) → int¶

gnuradio.filter.freq_xlating_fir_filter_ccf(int decimation, pmt_vector_float taps, double center_freq, double sampling_freq) → freq_xlating_fir_filter_ccf_sptr¶

freq_xlating_fir_filter_ccf_sptr.active_thread_priority(freq_xlating_fir_filter_ccf_sptr self) → int¶

freq_xlating_fir_filter_ccf_sptr.center_freq(freq_xlating_fir_filter_ccf_sptr self) → double¶

freq_xlating_fir_filter_ccf_sptr.declare_sample_delay(freq_xlating_fir_filter_ccf_sptr self, int which, int delay)¶: declare_sample_delay(freq_xlating_fir_filter_ccf_sptr self, unsigned int delay)

freq_xlating_fir_filter_ccf_sptr.message_subscribers(freq_xlating_fir_filter_ccf_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

freq_xlating_fir_filter_ccf_sptr.min_noutput_items(freq_xlating_fir_filter_ccf_sptr self) → int¶

freq_xlating_fir_filter_ccf_sptr.pc_input_buffers_full_avg(freq_xlating_fir_filter_ccf_sptr self, int which) → float¶: pc_input_buffers_full_avg(freq_xlating_fir_filter_ccf_sptr self) -> pmt_vector_float

freq_xlating_fir_filter_ccf_sptr.pc_noutput_items_avg(freq_xlating_fir_filter_ccf_sptr self) → float¶

freq_xlating_fir_filter_ccf_sptr.pc_nproduced_avg(freq_xlating_fir_filter_ccf_sptr self) → float¶

freq_xlating_fir_filter_ccf_sptr.pc_output_buffers_full_avg(freq_xlating_fir_filter_ccf_sptr self, int which) → float¶: pc_output_buffers_full_avg(freq_xlating_fir_filter_ccf_sptr self) -> pmt_vector_float

freq_xlating_fir_filter_ccf_sptr.pc_throughput_avg(freq_xlating_fir_filter_ccf_sptr self) → float¶

freq_xlating_fir_filter_ccf_sptr.pc_work_time_avg(freq_xlating_fir_filter_ccf_sptr self) → float¶

freq_xlating_fir_filter_ccf_sptr.pc_work_time_total(freq_xlating_fir_filter_ccf_sptr self) → float¶

freq_xlating_fir_filter_ccf_sptr.sample_delay(freq_xlating_fir_filter_ccf_sptr self, int which) → unsigned int¶

freq_xlating_fir_filter_ccf_sptr.set_center_freq(freq_xlating_fir_filter_ccf_sptr self, double center_freq)¶

freq_xlating_fir_filter_ccf_sptr.set_min_noutput_items(freq_xlating_fir_filter_ccf_sptr self, int m)¶

freq_xlating_fir_filter_ccf_sptr.set_taps(freq_xlating_fir_filter_ccf_sptr self, pmt_vector_float taps)¶

freq_xlating_fir_filter_ccf_sptr.set_thread_priority(freq_xlating_fir_filter_ccf_sptr self, int priority) → int¶

freq_xlating_fir_filter_ccf_sptr.taps(freq_xlating_fir_filter_ccf_sptr self) → pmt_vector_float¶

freq_xlating_fir_filter_ccf_sptr.thread_priority(freq_xlating_fir_filter_ccf_sptr self) → int¶

gnuradio.filter.freq_xlating_fir_filter_fcc(int decimation, pmt_vector_cfloat taps, double center_freq, double sampling_freq) → freq_xlating_fir_filter_fcc_sptr¶

freq_xlating_fir_filter_fcc_sptr.active_thread_priority(freq_xlating_fir_filter_fcc_sptr self) → int¶

freq_xlating_fir_filter_fcc_sptr.center_freq(freq_xlating_fir_filter_fcc_sptr self) → double¶

freq_xlating_fir_filter_fcc_sptr.declare_sample_delay(freq_xlating_fir_filter_fcc_sptr self, int which, int delay)¶: declare_sample_delay(freq_xlating_fir_filter_fcc_sptr self, unsigned int delay)

freq_xlating_fir_filter_fcc_sptr.message_subscribers(freq_xlating_fir_filter_fcc_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

freq_xlating_fir_filter_fcc_sptr.min_noutput_items(freq_xlating_fir_filter_fcc_sptr self) → int¶

freq_xlating_fir_filter_fcc_sptr.pc_input_buffers_full_avg(freq_xlating_fir_filter_fcc_sptr self, int which) → float¶: pc_input_buffers_full_avg(freq_xlating_fir_filter_fcc_sptr self) -> pmt_vector_float

freq_xlating_fir_filter_fcc_sptr.pc_noutput_items_avg(freq_xlating_fir_filter_fcc_sptr self) → float¶

freq_xlating_fir_filter_fcc_sptr.pc_nproduced_avg(freq_xlating_fir_filter_fcc_sptr self) → float¶

freq_xlating_fir_filter_fcc_sptr.pc_output_buffers_full_avg(freq_xlating_fir_filter_fcc_sptr self, int which) → float¶: pc_output_buffers_full_avg(freq_xlating_fir_filter_fcc_sptr self) -> pmt_vector_float

freq_xlating_fir_filter_fcc_sptr.pc_throughput_avg(freq_xlating_fir_filter_fcc_sptr self) → float¶

freq_xlating_fir_filter_fcc_sptr.pc_work_time_avg(freq_xlating_fir_filter_fcc_sptr self) → float¶

freq_xlating_fir_filter_fcc_sptr.pc_work_time_total(freq_xlating_fir_filter_fcc_sptr self) → float¶

freq_xlating_fir_filter_fcc_sptr.sample_delay(freq_xlating_fir_filter_fcc_sptr self, int which) → unsigned int¶

freq_xlating_fir_filter_fcc_sptr.set_center_freq(freq_xlating_fir_filter_fcc_sptr self, double center_freq)¶

freq_xlating_fir_filter_fcc_sptr.set_min_noutput_items(freq_xlating_fir_filter_fcc_sptr self, int m)¶

freq_xlating_fir_filter_fcc_sptr.set_taps(freq_xlating_fir_filter_fcc_sptr self, pmt_vector_cfloat taps)¶

freq_xlating_fir_filter_fcc_sptr.set_thread_priority(freq_xlating_fir_filter_fcc_sptr self, int priority) → int¶

freq_xlating_fir_filter_fcc_sptr.taps(freq_xlating_fir_filter_fcc_sptr self) → pmt_vector_cfloat¶

freq_xlating_fir_filter_fcc_sptr.thread_priority(freq_xlating_fir_filter_fcc_sptr self) → int¶

gnuradio.filter.freq_xlating_fir_filter_fcf(int decimation, pmt_vector_float taps, double center_freq, double sampling_freq) → freq_xlating_fir_filter_fcf_sptr¶

freq_xlating_fir_filter_fcf_sptr.active_thread_priority(freq_xlating_fir_filter_fcf_sptr self) → int¶

freq_xlating_fir_filter_fcf_sptr.center_freq(freq_xlating_fir_filter_fcf_sptr self) → double¶

freq_xlating_fir_filter_fcf_sptr.declare_sample_delay(freq_xlating_fir_filter_fcf_sptr self, int which, int delay)¶: declare_sample_delay(freq_xlating_fir_filter_fcf_sptr self, unsigned int delay)

freq_xlating_fir_filter_fcf_sptr.message_subscribers(freq_xlating_fir_filter_fcf_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

freq_xlating_fir_filter_fcf_sptr.min_noutput_items(freq_xlating_fir_filter_fcf_sptr self) → int¶

freq_xlating_fir_filter_fcf_sptr.pc_input_buffers_full_avg(freq_xlating_fir_filter_fcf_sptr self, int which) → float¶: pc_input_buffers_full_avg(freq_xlating_fir_filter_fcf_sptr self) -> pmt_vector_float

freq_xlating_fir_filter_fcf_sptr.pc_noutput_items_avg(freq_xlating_fir_filter_fcf_sptr self) → float¶

freq_xlating_fir_filter_fcf_sptr.pc_nproduced_avg(freq_xlating_fir_filter_fcf_sptr self) → float¶

freq_xlating_fir_filter_fcf_sptr.pc_output_buffers_full_avg(freq_xlating_fir_filter_fcf_sptr self, int which) → float¶: pc_output_buffers_full_avg(freq_xlating_fir_filter_fcf_sptr self) -> pmt_vector_float

freq_xlating_fir_filter_fcf_sptr.pc_throughput_avg(freq_xlating_fir_filter_fcf_sptr self) → float¶

freq_xlating_fir_filter_fcf_sptr.pc_work_time_avg(freq_xlating_fir_filter_fcf_sptr self) → float¶

freq_xlating_fir_filter_fcf_sptr.pc_work_time_total(freq_xlating_fir_filter_fcf_sptr self) → float¶

freq_xlating_fir_filter_fcf_sptr.sample_delay(freq_xlating_fir_filter_fcf_sptr self, int which) → unsigned int¶

freq_xlating_fir_filter_fcf_sptr.set_center_freq(freq_xlating_fir_filter_fcf_sptr self, double center_freq)¶

freq_xlating_fir_filter_fcf_sptr.set_min_noutput_items(freq_xlating_fir_filter_fcf_sptr self, int m)¶

freq_xlating_fir_filter_fcf_sptr.set_taps(freq_xlating_fir_filter_fcf_sptr self, pmt_vector_float taps)¶

freq_xlating_fir_filter_fcf_sptr.set_thread_priority(freq_xlating_fir_filter_fcf_sptr self, int priority) → int¶

freq_xlating_fir_filter_fcf_sptr.taps(freq_xlating_fir_filter_fcf_sptr self) → pmt_vector_float¶

freq_xlating_fir_filter_fcf_sptr.thread_priority(freq_xlating_fir_filter_fcf_sptr self) → int¶

gnuradio.filter.freq_xlating_fir_filter_scc(int decimation, pmt_vector_cfloat taps, double center_freq, double sampling_freq) → freq_xlating_fir_filter_scc_sptr¶

freq_xlating_fir_filter_scc_sptr.active_thread_priority(freq_xlating_fir_filter_scc_sptr self) → int¶

freq_xlating_fir_filter_scc_sptr.center_freq(freq_xlating_fir_filter_scc_sptr self) → double¶

freq_xlating_fir_filter_scc_sptr.declare_sample_delay(freq_xlating_fir_filter_scc_sptr self, int which, int delay)¶: declare_sample_delay(freq_xlating_fir_filter_scc_sptr self, unsigned int delay)

freq_xlating_fir_filter_scc_sptr.message_subscribers(freq_xlating_fir_filter_scc_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

freq_xlating_fir_filter_scc_sptr.min_noutput_items(freq_xlating_fir_filter_scc_sptr self) → int¶

freq_xlating_fir_filter_scc_sptr.pc_input_buffers_full_avg(freq_xlating_fir_filter_scc_sptr self, int which) → float¶: pc_input_buffers_full_avg(freq_xlating_fir_filter_scc_sptr self) -> pmt_vector_float

freq_xlating_fir_filter_scc_sptr.pc_noutput_items_avg(freq_xlating_fir_filter_scc_sptr self) → float¶

freq_xlating_fir_filter_scc_sptr.pc_nproduced_avg(freq_xlating_fir_filter_scc_sptr self) → float¶

freq_xlating_fir_filter_scc_sptr.pc_output_buffers_full_avg(freq_xlating_fir_filter_scc_sptr self, int which) → float¶: pc_output_buffers_full_avg(freq_xlating_fir_filter_scc_sptr self) -> pmt_vector_float

freq_xlating_fir_filter_scc_sptr.pc_throughput_avg(freq_xlating_fir_filter_scc_sptr self) → float¶

freq_xlating_fir_filter_scc_sptr.pc_work_time_avg(freq_xlating_fir_filter_scc_sptr self) → float¶

freq_xlating_fir_filter_scc_sptr.pc_work_time_total(freq_xlating_fir_filter_scc_sptr self) → float¶

freq_xlating_fir_filter_scc_sptr.sample_delay(freq_xlating_fir_filter_scc_sptr self, int which) → unsigned int¶

freq_xlating_fir_filter_scc_sptr.set_center_freq(freq_xlating_fir_filter_scc_sptr self, double center_freq)¶

freq_xlating_fir_filter_scc_sptr.set_min_noutput_items(freq_xlating_fir_filter_scc_sptr self, int m)¶

freq_xlating_fir_filter_scc_sptr.set_taps(freq_xlating_fir_filter_scc_sptr self, pmt_vector_cfloat taps)¶

freq_xlating_fir_filter_scc_sptr.set_thread_priority(freq_xlating_fir_filter_scc_sptr self, int priority) → int¶

freq_xlating_fir_filter_scc_sptr.taps(freq_xlating_fir_filter_scc_sptr self) → pmt_vector_cfloat¶

freq_xlating_fir_filter_scc_sptr.thread_priority(freq_xlating_fir_filter_scc_sptr self) → int¶

gnuradio.filter.freq_xlating_fir_filter_scf(int decimation, pmt_vector_float taps, double center_freq, double sampling_freq) → freq_xlating_fir_filter_scf_sptr¶

freq_xlating_fir_filter_scf_sptr.active_thread_priority(freq_xlating_fir_filter_scf_sptr self) → int¶

freq_xlating_fir_filter_scf_sptr.center_freq(freq_xlating_fir_filter_scf_sptr self) → double¶

freq_xlating_fir_filter_scf_sptr.declare_sample_delay(freq_xlating_fir_filter_scf_sptr self, int which, int delay)¶: declare_sample_delay(freq_xlating_fir_filter_scf_sptr self, unsigned int delay)

freq_xlating_fir_filter_scf_sptr.message_subscribers(freq_xlating_fir_filter_scf_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

freq_xlating_fir_filter_scf_sptr.min_noutput_items(freq_xlating_fir_filter_scf_sptr self) → int¶

freq_xlating_fir_filter_scf_sptr.pc_input_buffers_full_avg(freq_xlating_fir_filter_scf_sptr self, int which) → float¶: pc_input_buffers_full_avg(freq_xlating_fir_filter_scf_sptr self) -> pmt_vector_float

freq_xlating_fir_filter_scf_sptr.pc_noutput_items_avg(freq_xlating_fir_filter_scf_sptr self) → float¶

freq_xlating_fir_filter_scf_sptr.pc_nproduced_avg(freq_xlating_fir_filter_scf_sptr self) → float¶

freq_xlating_fir_filter_scf_sptr.pc_output_buffers_full_avg(freq_xlating_fir_filter_scf_sptr self, int which) → float¶: pc_output_buffers_full_avg(freq_xlating_fir_filter_scf_sptr self) -> pmt_vector_float

freq_xlating_fir_filter_scf_sptr.pc_throughput_avg(freq_xlating_fir_filter_scf_sptr self) → float¶

freq_xlating_fir_filter_scf_sptr.pc_work_time_avg(freq_xlating_fir_filter_scf_sptr self) → float¶

freq_xlating_fir_filter_scf_sptr.pc_work_time_total(freq_xlating_fir_filter_scf_sptr self) → float¶

freq_xlating_fir_filter_scf_sptr.sample_delay(freq_xlating_fir_filter_scf_sptr self, int which) → unsigned int¶

freq_xlating_fir_filter_scf_sptr.set_center_freq(freq_xlating_fir_filter_scf_sptr self, double center_freq)¶

freq_xlating_fir_filter_scf_sptr.set_min_noutput_items(freq_xlating_fir_filter_scf_sptr self, int m)¶

freq_xlating_fir_filter_scf_sptr.set_taps(freq_xlating_fir_filter_scf_sptr self, pmt_vector_float taps)¶

freq_xlating_fir_filter_scf_sptr.set_thread_priority(freq_xlating_fir_filter_scf_sptr self, int priority) → int¶

freq_xlating_fir_filter_scf_sptr.taps(freq_xlating_fir_filter_scf_sptr self) → pmt_vector_float¶

freq_xlating_fir_filter_scf_sptr.thread_priority(freq_xlating_fir_filter_scf_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_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_ccc(pmt_vector_cfloat fftaps, pmt_vector_cfloat fbtaps, bool oldstyle=True) → iir_filter_ccc_sptr¶

iir_filter_ccc_sptr.active_thread_priority(iir_filter_ccc_sptr self) → int¶

iir_filter_ccc_sptr.declare_sample_delay(iir_filter_ccc_sptr self, int which, int delay)¶: declare_sample_delay(iir_filter_ccc_sptr self, unsigned int delay)

iir_filter_ccc_sptr.message_subscribers(iir_filter_ccc_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

iir_filter_ccc_sptr.min_noutput_items(iir_filter_ccc_sptr self) → int¶

iir_filter_ccc_sptr.pc_input_buffers_full_avg(iir_filter_ccc_sptr self, int which) → float¶: pc_input_buffers_full_avg(iir_filter_ccc_sptr self) -> pmt_vector_float

iir_filter_ccc_sptr.pc_noutput_items_avg(iir_filter_ccc_sptr self) → float¶

iir_filter_ccc_sptr.pc_nproduced_avg(iir_filter_ccc_sptr self) → float¶

iir_filter_ccc_sptr.pc_output_buffers_full_avg(iir_filter_ccc_sptr self, int which) → float¶: pc_output_buffers_full_avg(iir_filter_ccc_sptr self) -> pmt_vector_float

iir_filter_ccc_sptr.pc_throughput_avg(iir_filter_ccc_sptr self) → float¶

iir_filter_ccc_sptr.pc_work_time_avg(iir_filter_ccc_sptr self) → float¶

iir_filter_ccc_sptr.pc_work_time_total(iir_filter_ccc_sptr self) → float¶

iir_filter_ccc_sptr.sample_delay(iir_filter_ccc_sptr self, int which) → unsigned int¶

iir_filter_ccc_sptr.set_min_noutput_items(iir_filter_ccc_sptr self, int m)¶

iir_filter_ccc_sptr.set_taps(iir_filter_ccc_sptr self, pmt_vector_cfloat fftaps, pmt_vector_cfloat fbtaps)¶

iir_filter_ccc_sptr.set_thread_priority(iir_filter_ccc_sptr self, int priority) → int¶

iir_filter_ccc_sptr.thread_priority(iir_filter_ccc_sptr self) → int¶

gnuradio.filter.iir_filter_ccd(pmt_vector_double fftaps, pmt_vector_double fbtaps, bool oldstyle=True) → iir_filter_ccd_sptr¶

iir_filter_ccd_sptr.active_thread_priority(iir_filter_ccd_sptr self) → int¶

iir_filter_ccd_sptr.declare_sample_delay(iir_filter_ccd_sptr self, int which, int delay)¶: declare_sample_delay(iir_filter_ccd_sptr self, unsigned int delay)

iir_filter_ccd_sptr.message_subscribers(iir_filter_ccd_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

iir_filter_ccd_sptr.min_noutput_items(iir_filter_ccd_sptr self) → int¶

iir_filter_ccd_sptr.pc_input_buffers_full_avg(iir_filter_ccd_sptr self, int which) → float¶: pc_input_buffers_full_avg(iir_filter_ccd_sptr self) -> pmt_vector_float

iir_filter_ccd_sptr.pc_noutput_items_avg(iir_filter_ccd_sptr self) → float¶

iir_filter_ccd_sptr.pc_nproduced_avg(iir_filter_ccd_sptr self) → float¶

iir_filter_ccd_sptr.pc_output_buffers_full_avg(iir_filter_ccd_sptr self, int which) → float¶: pc_output_buffers_full_avg(iir_filter_ccd_sptr self) -> pmt_vector_float

iir_filter_ccd_sptr.pc_throughput_avg(iir_filter_ccd_sptr self) → float¶

iir_filter_ccd_sptr.pc_work_time_avg(iir_filter_ccd_sptr self) → float¶

iir_filter_ccd_sptr.pc_work_time_total(iir_filter_ccd_sptr self) → float¶

iir_filter_ccd_sptr.sample_delay(iir_filter_ccd_sptr self, int which) → unsigned int¶

iir_filter_ccd_sptr.set_min_noutput_items(iir_filter_ccd_sptr self, int m)¶

iir_filter_ccd_sptr.set_taps(iir_filter_ccd_sptr self, pmt_vector_double fftaps, pmt_vector_double fbtaps)¶

iir_filter_ccd_sptr.set_thread_priority(iir_filter_ccd_sptr self, int priority) → int¶

iir_filter_ccd_sptr.thread_priority(iir_filter_ccd_sptr self) → int¶

gnuradio.filter.iir_filter_ccf(pmt_vector_float fftaps, pmt_vector_float fbtaps, bool oldstyle=True) → iir_filter_ccf_sptr¶

iir_filter_ccf_sptr.active_thread_priority(iir_filter_ccf_sptr self) → int¶

iir_filter_ccf_sptr.declare_sample_delay(iir_filter_ccf_sptr self, int which, int delay)¶: declare_sample_delay(iir_filter_ccf_sptr self, unsigned int delay)

iir_filter_ccf_sptr.message_subscribers(iir_filter_ccf_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

iir_filter_ccf_sptr.min_noutput_items(iir_filter_ccf_sptr self) → int¶

iir_filter_ccf_sptr.pc_input_buffers_full_avg(iir_filter_ccf_sptr self, int which) → float¶: pc_input_buffers_full_avg(iir_filter_ccf_sptr self) -> pmt_vector_float

iir_filter_ccf_sptr.pc_noutput_items_avg(iir_filter_ccf_sptr self) → float¶

iir_filter_ccf_sptr.pc_nproduced_avg(iir_filter_ccf_sptr self) → float¶

iir_filter_ccf_sptr.pc_output_buffers_full_avg(iir_filter_ccf_sptr self, int which) → float¶: pc_output_buffers_full_avg(iir_filter_ccf_sptr self) -> pmt_vector_float

iir_filter_ccf_sptr.pc_throughput_avg(iir_filter_ccf_sptr self) → float¶

iir_filter_ccf_sptr.pc_work_time_avg(iir_filter_ccf_sptr self) → float¶

iir_filter_ccf_sptr.pc_work_time_total(iir_filter_ccf_sptr self) → float¶

iir_filter_ccf_sptr.sample_delay(iir_filter_ccf_sptr self, int which) → unsigned int¶

iir_filter_ccf_sptr.set_min_noutput_items(iir_filter_ccf_sptr self, int m)¶

iir_filter_ccf_sptr.set_taps(iir_filter_ccf_sptr self, pmt_vector_float fftaps, pmt_vector_float fbtaps)¶

iir_filter_ccf_sptr.set_thread_priority(iir_filter_ccf_sptr self, int priority) → int¶

iir_filter_ccf_sptr.thread_priority(iir_filter_ccf_sptr self) → int¶

gnuradio.filter.iir_filter_ccz(pmt_vector_cdouble fftaps, pmt_vector_cdouble fbtaps, bool oldstyle=True) → iir_filter_ccz_sptr¶

iir_filter_ccz_sptr.active_thread_priority(iir_filter_ccz_sptr self) → int¶

iir_filter_ccz_sptr.declare_sample_delay(iir_filter_ccz_sptr self, int which, int delay)¶: declare_sample_delay(iir_filter_ccz_sptr self, unsigned int delay)

iir_filter_ccz_sptr.message_subscribers(iir_filter_ccz_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

iir_filter_ccz_sptr.min_noutput_items(iir_filter_ccz_sptr self) → int¶

iir_filter_ccz_sptr.pc_input_buffers_full_avg(iir_filter_ccz_sptr self, int which) → float¶: pc_input_buffers_full_avg(iir_filter_ccz_sptr self) -> pmt_vector_float

iir_filter_ccz_sptr.pc_noutput_items_avg(iir_filter_ccz_sptr self) → float¶

iir_filter_ccz_sptr.pc_nproduced_avg(iir_filter_ccz_sptr self) → float¶

iir_filter_ccz_sptr.pc_output_buffers_full_avg(iir_filter_ccz_sptr self, int which) → float¶: pc_output_buffers_full_avg(iir_filter_ccz_sptr self) -> pmt_vector_float

iir_filter_ccz_sptr.pc_throughput_avg(iir_filter_ccz_sptr self) → float¶

iir_filter_ccz_sptr.pc_work_time_avg(iir_filter_ccz_sptr self) → float¶

iir_filter_ccz_sptr.pc_work_time_total(iir_filter_ccz_sptr self) → float¶

iir_filter_ccz_sptr.sample_delay(iir_filter_ccz_sptr self, int which) → unsigned int¶

iir_filter_ccz_sptr.set_min_noutput_items(iir_filter_ccz_sptr self, int m)¶

iir_filter_ccz_sptr.set_taps(iir_filter_ccz_sptr self, pmt_vector_cdouble fftaps, pmt_vector_cdouble fbtaps)¶

iir_filter_ccz_sptr.set_thread_priority(iir_filter_ccz_sptr self, int priority) → int¶

iir_filter_ccz_sptr.thread_priority(iir_filter_ccz_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_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¶

gnuradio.filter.interp_fir_filter_ccc(unsigned int interpolation, pmt_vector_cfloat taps) → interp_fir_filter_ccc_sptr¶

interp_fir_filter_ccc_sptr.active_thread_priority(interp_fir_filter_ccc_sptr self) → int¶

interp_fir_filter_ccc_sptr.declare_sample_delay(interp_fir_filter_ccc_sptr self, int which, int delay)¶: declare_sample_delay(interp_fir_filter_ccc_sptr self, unsigned int delay)

interp_fir_filter_ccc_sptr.message_subscribers(interp_fir_filter_ccc_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

interp_fir_filter_ccc_sptr.min_noutput_items(interp_fir_filter_ccc_sptr self) → int¶

interp_fir_filter_ccc_sptr.pc_input_buffers_full_avg(interp_fir_filter_ccc_sptr self, int which) → float¶: pc_input_buffers_full_avg(interp_fir_filter_ccc_sptr self) -> pmt_vector_float

interp_fir_filter_ccc_sptr.pc_noutput_items_avg(interp_fir_filter_ccc_sptr self) → float¶

interp_fir_filter_ccc_sptr.pc_nproduced_avg(interp_fir_filter_ccc_sptr self) → float¶

interp_fir_filter_ccc_sptr.pc_output_buffers_full_avg(interp_fir_filter_ccc_sptr self, int which) → float¶: pc_output_buffers_full_avg(interp_fir_filter_ccc_sptr self) -> pmt_vector_float

interp_fir_filter_ccc_sptr.pc_throughput_avg(interp_fir_filter_ccc_sptr self) → float¶

interp_fir_filter_ccc_sptr.pc_work_time_avg(interp_fir_filter_ccc_sptr self) → float¶

interp_fir_filter_ccc_sptr.pc_work_time_total(interp_fir_filter_ccc_sptr self) → float¶

interp_fir_filter_ccc_sptr.sample_delay(interp_fir_filter_ccc_sptr self, int which) → unsigned int¶

interp_fir_filter_ccc_sptr.set_min_noutput_items(interp_fir_filter_ccc_sptr self, int m)¶

interp_fir_filter_ccc_sptr.set_taps(interp_fir_filter_ccc_sptr self, pmt_vector_cfloat taps)¶

interp_fir_filter_ccc_sptr.set_thread_priority(interp_fir_filter_ccc_sptr self, int priority) → int¶

interp_fir_filter_ccc_sptr.taps(interp_fir_filter_ccc_sptr self) → pmt_vector_cfloat¶

interp_fir_filter_ccc_sptr.thread_priority(interp_fir_filter_ccc_sptr self) → int¶

gnuradio.filter.interp_fir_filter_ccf(unsigned int interpolation, pmt_vector_float taps) → interp_fir_filter_ccf_sptr¶

interp_fir_filter_ccf_sptr.active_thread_priority(interp_fir_filter_ccf_sptr self) → int¶

interp_fir_filter_ccf_sptr.declare_sample_delay(interp_fir_filter_ccf_sptr self, int which, int delay)¶: declare_sample_delay(interp_fir_filter_ccf_sptr self, unsigned int delay)

interp_fir_filter_ccf_sptr.message_subscribers(interp_fir_filter_ccf_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

interp_fir_filter_ccf_sptr.min_noutput_items(interp_fir_filter_ccf_sptr self) → int¶

interp_fir_filter_ccf_sptr.pc_input_buffers_full_avg(interp_fir_filter_ccf_sptr self, int which) → float¶: pc_input_buffers_full_avg(interp_fir_filter_ccf_sptr self) -> pmt_vector_float

interp_fir_filter_ccf_sptr.pc_noutput_items_avg(interp_fir_filter_ccf_sptr self) → float¶

interp_fir_filter_ccf_sptr.pc_nproduced_avg(interp_fir_filter_ccf_sptr self) → float¶

interp_fir_filter_ccf_sptr.pc_output_buffers_full_avg(interp_fir_filter_ccf_sptr self, int which) → float¶: pc_output_buffers_full_avg(interp_fir_filter_ccf_sptr self) -> pmt_vector_float

interp_fir_filter_ccf_sptr.pc_throughput_avg(interp_fir_filter_ccf_sptr self) → float¶

interp_fir_filter_ccf_sptr.pc_work_time_avg(interp_fir_filter_ccf_sptr self) → float¶

interp_fir_filter_ccf_sptr.pc_work_time_total(interp_fir_filter_ccf_sptr self) → float¶

interp_fir_filter_ccf_sptr.sample_delay(interp_fir_filter_ccf_sptr self, int which) → unsigned int¶

interp_fir_filter_ccf_sptr.set_min_noutput_items(interp_fir_filter_ccf_sptr self, int m)¶

interp_fir_filter_ccf_sptr.set_taps(interp_fir_filter_ccf_sptr self, pmt_vector_float taps)¶

interp_fir_filter_ccf_sptr.set_thread_priority(interp_fir_filter_ccf_sptr self, int priority) → int¶

interp_fir_filter_ccf_sptr.taps(interp_fir_filter_ccf_sptr self) → pmt_vector_float¶

interp_fir_filter_ccf_sptr.thread_priority(interp_fir_filter_ccf_sptr self) → int¶

gnuradio.filter.interp_fir_filter_fcc(unsigned int interpolation, pmt_vector_cfloat taps) → interp_fir_filter_fcc_sptr¶

interp_fir_filter_fcc_sptr.active_thread_priority(interp_fir_filter_fcc_sptr self) → int¶

interp_fir_filter_fcc_sptr.declare_sample_delay(interp_fir_filter_fcc_sptr self, int which, int delay)¶: declare_sample_delay(interp_fir_filter_fcc_sptr self, unsigned int delay)

interp_fir_filter_fcc_sptr.message_subscribers(interp_fir_filter_fcc_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

interp_fir_filter_fcc_sptr.min_noutput_items(interp_fir_filter_fcc_sptr self) → int¶

interp_fir_filter_fcc_sptr.pc_input_buffers_full_avg(interp_fir_filter_fcc_sptr self, int which) → float¶: pc_input_buffers_full_avg(interp_fir_filter_fcc_sptr self) -> pmt_vector_float

interp_fir_filter_fcc_sptr.pc_noutput_items_avg(interp_fir_filter_fcc_sptr self) → float¶

interp_fir_filter_fcc_sptr.pc_nproduced_avg(interp_fir_filter_fcc_sptr self) → float¶

interp_fir_filter_fcc_sptr.pc_output_buffers_full_avg(interp_fir_filter_fcc_sptr self, int which) → float¶: pc_output_buffers_full_avg(interp_fir_filter_fcc_sptr self) -> pmt_vector_float

interp_fir_filter_fcc_sptr.pc_throughput_avg(interp_fir_filter_fcc_sptr self) → float¶

interp_fir_filter_fcc_sptr.pc_work_time_avg(interp_fir_filter_fcc_sptr self) → float¶

interp_fir_filter_fcc_sptr.pc_work_time_total(interp_fir_filter_fcc_sptr self) → float¶

interp_fir_filter_fcc_sptr.sample_delay(interp_fir_filter_fcc_sptr self, int which) → unsigned int¶

interp_fir_filter_fcc_sptr.set_min_noutput_items(interp_fir_filter_fcc_sptr self, int m)¶

interp_fir_filter_fcc_sptr.set_taps(interp_fir_filter_fcc_sptr self, pmt_vector_cfloat taps)¶

interp_fir_filter_fcc_sptr.set_thread_priority(interp_fir_filter_fcc_sptr self, int priority) → int¶

interp_fir_filter_fcc_sptr.taps(interp_fir_filter_fcc_sptr self) → pmt_vector_cfloat¶

interp_fir_filter_fcc_sptr.thread_priority(interp_fir_filter_fcc_sptr self) → int¶

gnuradio.filter.interp_fir_filter_fff(unsigned int interpolation, pmt_vector_float taps) → interp_fir_filter_fff_sptr¶

interp_fir_filter_fff_sptr.active_thread_priority(interp_fir_filter_fff_sptr self) → int¶

interp_fir_filter_fff_sptr.declare_sample_delay(interp_fir_filter_fff_sptr self, int which, int delay)¶: declare_sample_delay(interp_fir_filter_fff_sptr self, unsigned int delay)

interp_fir_filter_fff_sptr.message_subscribers(interp_fir_filter_fff_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

interp_fir_filter_fff_sptr.min_noutput_items(interp_fir_filter_fff_sptr self) → int¶

interp_fir_filter_fff_sptr.pc_input_buffers_full_avg(interp_fir_filter_fff_sptr self, int which) → float¶: pc_input_buffers_full_avg(interp_fir_filter_fff_sptr self) -> pmt_vector_float

interp_fir_filter_fff_sptr.pc_noutput_items_avg(interp_fir_filter_fff_sptr self) → float¶

interp_fir_filter_fff_sptr.pc_nproduced_avg(interp_fir_filter_fff_sptr self) → float¶

interp_fir_filter_fff_sptr.pc_output_buffers_full_avg(interp_fir_filter_fff_sptr self, int which) → float¶: pc_output_buffers_full_avg(interp_fir_filter_fff_sptr self) -> pmt_vector_float

interp_fir_filter_fff_sptr.pc_throughput_avg(interp_fir_filter_fff_sptr self) → float¶

interp_fir_filter_fff_sptr.pc_work_time_avg(interp_fir_filter_fff_sptr self) → float¶

interp_fir_filter_fff_sptr.pc_work_time_total(interp_fir_filter_fff_sptr self) → float¶

interp_fir_filter_fff_sptr.sample_delay(interp_fir_filter_fff_sptr self, int which) → unsigned int¶

interp_fir_filter_fff_sptr.set_min_noutput_items(interp_fir_filter_fff_sptr self, int m)¶

interp_fir_filter_fff_sptr.set_taps(interp_fir_filter_fff_sptr self, pmt_vector_float taps)¶

interp_fir_filter_fff_sptr.set_thread_priority(interp_fir_filter_fff_sptr self, int priority) → int¶

interp_fir_filter_fff_sptr.taps(interp_fir_filter_fff_sptr self) → pmt_vector_float¶

interp_fir_filter_fff_sptr.thread_priority(interp_fir_filter_fff_sptr self) → int¶

gnuradio.filter.interp_fir_filter_fsf(unsigned int interpolation, pmt_vector_float taps) → interp_fir_filter_fsf_sptr¶

interp_fir_filter_fsf_sptr.active_thread_priority(interp_fir_filter_fsf_sptr self) → int¶

interp_fir_filter_fsf_sptr.declare_sample_delay(interp_fir_filter_fsf_sptr self, int which, int delay)¶: declare_sample_delay(interp_fir_filter_fsf_sptr self, unsigned int delay)

interp_fir_filter_fsf_sptr.message_subscribers(interp_fir_filter_fsf_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

interp_fir_filter_fsf_sptr.min_noutput_items(interp_fir_filter_fsf_sptr self) → int¶

interp_fir_filter_fsf_sptr.pc_input_buffers_full_avg(interp_fir_filter_fsf_sptr self, int which) → float¶: pc_input_buffers_full_avg(interp_fir_filter_fsf_sptr self) -> pmt_vector_float

interp_fir_filter_fsf_sptr.pc_noutput_items_avg(interp_fir_filter_fsf_sptr self) → float¶

interp_fir_filter_fsf_sptr.pc_nproduced_avg(interp_fir_filter_fsf_sptr self) → float¶

interp_fir_filter_fsf_sptr.pc_output_buffers_full_avg(interp_fir_filter_fsf_sptr self, int which) → float¶: pc_output_buffers_full_avg(interp_fir_filter_fsf_sptr self) -> pmt_vector_float

interp_fir_filter_fsf_sptr.pc_throughput_avg(interp_fir_filter_fsf_sptr self) → float¶

interp_fir_filter_fsf_sptr.pc_work_time_avg(interp_fir_filter_fsf_sptr self) → float¶

interp_fir_filter_fsf_sptr.pc_work_time_total(interp_fir_filter_fsf_sptr self) → float¶

interp_fir_filter_fsf_sptr.sample_delay(interp_fir_filter_fsf_sptr self, int which) → unsigned int¶

interp_fir_filter_fsf_sptr.set_min_noutput_items(interp_fir_filter_fsf_sptr self, int m)¶

interp_fir_filter_fsf_sptr.set_taps(interp_fir_filter_fsf_sptr self, pmt_vector_float taps)¶

interp_fir_filter_fsf_sptr.set_thread_priority(interp_fir_filter_fsf_sptr self, int priority) → int¶

interp_fir_filter_fsf_sptr.taps(interp_fir_filter_fsf_sptr self) → pmt_vector_float¶

interp_fir_filter_fsf_sptr.thread_priority(interp_fir_filter_fsf_sptr self) → int¶

gnuradio.filter.interp_fir_filter_scc(unsigned int interpolation, pmt_vector_cfloat taps) → interp_fir_filter_scc_sptr¶

interp_fir_filter_scc_sptr.active_thread_priority(interp_fir_filter_scc_sptr self) → int¶

interp_fir_filter_scc_sptr.declare_sample_delay(interp_fir_filter_scc_sptr self, int which, int delay)¶: declare_sample_delay(interp_fir_filter_scc_sptr self, unsigned int delay)

interp_fir_filter_scc_sptr.message_subscribers(interp_fir_filter_scc_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

interp_fir_filter_scc_sptr.min_noutput_items(interp_fir_filter_scc_sptr self) → int¶

interp_fir_filter_scc_sptr.pc_input_buffers_full_avg(interp_fir_filter_scc_sptr self, int which) → float¶: pc_input_buffers_full_avg(interp_fir_filter_scc_sptr self) -> pmt_vector_float

interp_fir_filter_scc_sptr.pc_noutput_items_avg(interp_fir_filter_scc_sptr self) → float¶

interp_fir_filter_scc_sptr.pc_nproduced_avg(interp_fir_filter_scc_sptr self) → float¶

interp_fir_filter_scc_sptr.pc_output_buffers_full_avg(interp_fir_filter_scc_sptr self, int which) → float¶: pc_output_buffers_full_avg(interp_fir_filter_scc_sptr self) -> pmt_vector_float

interp_fir_filter_scc_sptr.pc_throughput_avg(interp_fir_filter_scc_sptr self) → float¶

interp_fir_filter_scc_sptr.pc_work_time_avg(interp_fir_filter_scc_sptr self) → float¶

interp_fir_filter_scc_sptr.pc_work_time_total(interp_fir_filter_scc_sptr self) → float¶

interp_fir_filter_scc_sptr.sample_delay(interp_fir_filter_scc_sptr self, int which) → unsigned int¶

interp_fir_filter_scc_sptr.set_min_noutput_items(interp_fir_filter_scc_sptr self, int m)¶

interp_fir_filter_scc_sptr.set_taps(interp_fir_filter_scc_sptr self, pmt_vector_cfloat taps)¶

interp_fir_filter_scc_sptr.set_thread_priority(interp_fir_filter_scc_sptr self, int priority) → int¶

interp_fir_filter_scc_sptr.taps(interp_fir_filter_scc_sptr self) → pmt_vector_cfloat¶

interp_fir_filter_scc_sptr.thread_priority(interp_fir_filter_scc_sptr self) → int¶

gnuradio.filter.pfb_arb_resampler_ccc(float rate, pmt_vector_cfloat taps, unsigned int filter_size=32) → pfb_arb_resampler_ccc_sptr¶

pfb_arb_resampler_ccc_sptr.active_thread_priority(pfb_arb_resampler_ccc_sptr self) → int¶

pfb_arb_resampler_ccc_sptr.decimation_rate(pfb_arb_resampler_ccc_sptr self) → unsigned int¶

pfb_arb_resampler_ccc_sptr.declare_sample_delay(pfb_arb_resampler_ccc_sptr self, int which, int delay)¶: declare_sample_delay(pfb_arb_resampler_ccc_sptr self, unsigned int delay)

pfb_arb_resampler_ccc_sptr.fractional_rate(pfb_arb_resampler_ccc_sptr self) → float¶

pfb_arb_resampler_ccc_sptr.group_delay(pfb_arb_resampler_ccc_sptr self) → int¶

pfb_arb_resampler_ccc_sptr.interpolation_rate(pfb_arb_resampler_ccc_sptr self) → unsigned int¶

pfb_arb_resampler_ccc_sptr.message_subscribers(pfb_arb_resampler_ccc_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

pfb_arb_resampler_ccc_sptr.min_noutput_items(pfb_arb_resampler_ccc_sptr self) → int¶

pfb_arb_resampler_ccc_sptr.pc_input_buffers_full_avg(pfb_arb_resampler_ccc_sptr self, int which) → float¶: pc_input_buffers_full_avg(pfb_arb_resampler_ccc_sptr self) -> pmt_vector_float

pfb_arb_resampler_ccc_sptr.pc_noutput_items_avg(pfb_arb_resampler_ccc_sptr self) → float¶

pfb_arb_resampler_ccc_sptr.pc_nproduced_avg(pfb_arb_resampler_ccc_sptr self) → float¶

pfb_arb_resampler_ccc_sptr.pc_output_buffers_full_avg(pfb_arb_resampler_ccc_sptr self, int which) → float¶: pc_output_buffers_full_avg(pfb_arb_resampler_ccc_sptr self) -> pmt_vector_float

pfb_arb_resampler_ccc_sptr.pc_throughput_avg(pfb_arb_resampler_ccc_sptr self) → float¶

pfb_arb_resampler_ccc_sptr.pc_work_time_avg(pfb_arb_resampler_ccc_sptr self) → float¶

pfb_arb_resampler_ccc_sptr.pc_work_time_total(pfb_arb_resampler_ccc_sptr self) → float¶

pfb_arb_resampler_ccc_sptr.phase(pfb_arb_resampler_ccc_sptr self) → float¶

pfb_arb_resampler_ccc_sptr.phase_offset(pfb_arb_resampler_ccc_sptr self, float freq, float fs) → float¶

pfb_arb_resampler_ccc_sptr.print_taps(pfb_arb_resampler_ccc_sptr self)¶

pfb_arb_resampler_ccc_sptr.sample_delay(pfb_arb_resampler_ccc_sptr self, int which) → unsigned int¶

pfb_arb_resampler_ccc_sptr.set_min_noutput_items(pfb_arb_resampler_ccc_sptr self, int m)¶

pfb_arb_resampler_ccc_sptr.set_phase(pfb_arb_resampler_ccc_sptr self, float ph)¶

pfb_arb_resampler_ccc_sptr.set_rate(pfb_arb_resampler_ccc_sptr self, float rate)¶

pfb_arb_resampler_ccc_sptr.set_taps(pfb_arb_resampler_ccc_sptr self, pmt_vector_cfloat taps)¶

pfb_arb_resampler_ccc_sptr.set_thread_priority(pfb_arb_resampler_ccc_sptr self, int priority) → int¶

pfb_arb_resampler_ccc_sptr.taps(pfb_arb_resampler_ccc_sptr self) → gr_vector_vector_complexf¶

pfb_arb_resampler_ccc_sptr.taps_per_filter(pfb_arb_resampler_ccc_sptr self) → unsigned int¶

pfb_arb_resampler_ccc_sptr.thread_priority(pfb_arb_resampler_ccc_sptr self) → int¶

gnuradio.filter.pfb_arb_resampler_ccf(float rate, pmt_vector_float taps, unsigned int filter_size=32) → pfb_arb_resampler_ccf_sptr¶

pfb_arb_resampler_ccf_sptr.active_thread_priority(pfb_arb_resampler_ccf_sptr self) → int¶

pfb_arb_resampler_ccf_sptr.decimation_rate(pfb_arb_resampler_ccf_sptr self) → unsigned int¶

pfb_arb_resampler_ccf_sptr.declare_sample_delay(pfb_arb_resampler_ccf_sptr self, int which, int delay)¶: declare_sample_delay(pfb_arb_resampler_ccf_sptr self, unsigned int delay)

pfb_arb_resampler_ccf_sptr.fractional_rate(pfb_arb_resampler_ccf_sptr self) → float¶

pfb_arb_resampler_ccf_sptr.group_delay(pfb_arb_resampler_ccf_sptr self) → int¶

pfb_arb_resampler_ccf_sptr.interpolation_rate(pfb_arb_resampler_ccf_sptr self) → unsigned int¶

pfb_arb_resampler_ccf_sptr.message_subscribers(pfb_arb_resampler_ccf_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

pfb_arb_resampler_ccf_sptr.min_noutput_items(pfb_arb_resampler_ccf_sptr self) → int¶

pfb_arb_resampler_ccf_sptr.pc_input_buffers_full_avg(pfb_arb_resampler_ccf_sptr self, int which) → float¶: pc_input_buffers_full_avg(pfb_arb_resampler_ccf_sptr self) -> pmt_vector_float

pfb_arb_resampler_ccf_sptr.pc_noutput_items_avg(pfb_arb_resampler_ccf_sptr self) → float¶

pfb_arb_resampler_ccf_sptr.pc_nproduced_avg(pfb_arb_resampler_ccf_sptr self) → float¶

pfb_arb_resampler_ccf_sptr.pc_output_buffers_full_avg(pfb_arb_resampler_ccf_sptr self, int which) → float¶: pc_output_buffers_full_avg(pfb_arb_resampler_ccf_sptr self) -> pmt_vector_float

pfb_arb_resampler_ccf_sptr.pc_throughput_avg(pfb_arb_resampler_ccf_sptr self) → float¶

pfb_arb_resampler_ccf_sptr.pc_work_time_avg(pfb_arb_resampler_ccf_sptr self) → float¶

pfb_arb_resampler_ccf_sptr.pc_work_time_total(pfb_arb_resampler_ccf_sptr self) → float¶

pfb_arb_resampler_ccf_sptr.phase(pfb_arb_resampler_ccf_sptr self) → float¶

pfb_arb_resampler_ccf_sptr.phase_offset(pfb_arb_resampler_ccf_sptr self, float freq, float fs) → float¶

pfb_arb_resampler_ccf_sptr.print_taps(pfb_arb_resampler_ccf_sptr self)¶

pfb_arb_resampler_ccf_sptr.sample_delay(pfb_arb_resampler_ccf_sptr self, int which) → unsigned int¶

pfb_arb_resampler_ccf_sptr.set_min_noutput_items(pfb_arb_resampler_ccf_sptr self, int m)¶

pfb_arb_resampler_ccf_sptr.set_phase(pfb_arb_resampler_ccf_sptr self, float ph)¶

pfb_arb_resampler_ccf_sptr.set_rate(pfb_arb_resampler_ccf_sptr self, float rate)¶

pfb_arb_resampler_ccf_sptr.set_taps(pfb_arb_resampler_ccf_sptr self, pmt_vector_float taps)¶

pfb_arb_resampler_ccf_sptr.set_thread_priority(pfb_arb_resampler_ccf_sptr self, int priority) → int¶

pfb_arb_resampler_ccf_sptr.taps(pfb_arb_resampler_ccf_sptr self) → std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >¶

pfb_arb_resampler_ccf_sptr.taps_per_filter(pfb_arb_resampler_ccf_sptr self) → unsigned int¶

pfb_arb_resampler_ccf_sptr.thread_priority(pfb_arb_resampler_ccf_sptr self) → int¶

gnuradio.filter.pfb_arb_resampler_fff(float rate, pmt_vector_float taps, unsigned int filter_size=32) → pfb_arb_resampler_fff_sptr¶

pfb_arb_resampler_fff_sptr.active_thread_priority(pfb_arb_resampler_fff_sptr self) → int¶

pfb_arb_resampler_fff_sptr.decimation_rate(pfb_arb_resampler_fff_sptr self) → unsigned int¶

pfb_arb_resampler_fff_sptr.declare_sample_delay(pfb_arb_resampler_fff_sptr self, int which, int delay)¶: declare_sample_delay(pfb_arb_resampler_fff_sptr self, unsigned int delay)

pfb_arb_resampler_fff_sptr.fractional_rate(pfb_arb_resampler_fff_sptr self) → float¶

pfb_arb_resampler_fff_sptr.group_delay(pfb_arb_resampler_fff_sptr self) → int¶

pfb_arb_resampler_fff_sptr.interpolation_rate(pfb_arb_resampler_fff_sptr self) → unsigned int¶

pfb_arb_resampler_fff_sptr.message_subscribers(pfb_arb_resampler_fff_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

pfb_arb_resampler_fff_sptr.min_noutput_items(pfb_arb_resampler_fff_sptr self) → int¶

pfb_arb_resampler_fff_sptr.pc_input_buffers_full_avg(pfb_arb_resampler_fff_sptr self, int which) → float¶: pc_input_buffers_full_avg(pfb_arb_resampler_fff_sptr self) -> pmt_vector_float

pfb_arb_resampler_fff_sptr.pc_noutput_items_avg(pfb_arb_resampler_fff_sptr self) → float¶

pfb_arb_resampler_fff_sptr.pc_nproduced_avg(pfb_arb_resampler_fff_sptr self) → float¶

pfb_arb_resampler_fff_sptr.pc_output_buffers_full_avg(pfb_arb_resampler_fff_sptr self, int which) → float¶: pc_output_buffers_full_avg(pfb_arb_resampler_fff_sptr self) -> pmt_vector_float

pfb_arb_resampler_fff_sptr.pc_throughput_avg(pfb_arb_resampler_fff_sptr self) → float¶

pfb_arb_resampler_fff_sptr.pc_work_time_avg(pfb_arb_resampler_fff_sptr self) → float¶

pfb_arb_resampler_fff_sptr.pc_work_time_total(pfb_arb_resampler_fff_sptr self) → float¶

pfb_arb_resampler_fff_sptr.phase(pfb_arb_resampler_fff_sptr self) → float¶

pfb_arb_resampler_fff_sptr.phase_offset(pfb_arb_resampler_fff_sptr self, float freq, float fs) → float¶

pfb_arb_resampler_fff_sptr.print_taps(pfb_arb_resampler_fff_sptr self)¶

pfb_arb_resampler_fff_sptr.sample_delay(pfb_arb_resampler_fff_sptr self, int which) → unsigned int¶

pfb_arb_resampler_fff_sptr.set_min_noutput_items(pfb_arb_resampler_fff_sptr self, int m)¶

pfb_arb_resampler_fff_sptr.set_phase(pfb_arb_resampler_fff_sptr self, float ph)¶

pfb_arb_resampler_fff_sptr.set_rate(pfb_arb_resampler_fff_sptr self, float rate)¶

pfb_arb_resampler_fff_sptr.set_taps(pfb_arb_resampler_fff_sptr self, pmt_vector_float taps)¶

pfb_arb_resampler_fff_sptr.set_thread_priority(pfb_arb_resampler_fff_sptr self, int priority) → int¶

pfb_arb_resampler_fff_sptr.taps(pfb_arb_resampler_fff_sptr self) → std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >¶

pfb_arb_resampler_fff_sptr.taps_per_filter(pfb_arb_resampler_fff_sptr self) → unsigned int¶

pfb_arb_resampler_fff_sptr.thread_priority(pfb_arb_resampler_fff_sptr self) → int¶

gnuradio.filter.pfb_channelizer_ccf(unsigned int numchans, pmt_vector_float taps, float oversample_rate) → pfb_channelizer_ccf_sptr¶

pfb_channelizer_ccf_sptr.active_thread_priority(pfb_channelizer_ccf_sptr self) → int¶

pfb_channelizer_ccf_sptr.channel_map(pfb_channelizer_ccf_sptr self) → std::vector< int,std::allocator< int > >¶

pfb_channelizer_ccf_sptr.declare_sample_delay(pfb_channelizer_ccf_sptr self, int which, int delay)¶: declare_sample_delay(pfb_channelizer_ccf_sptr self, unsigned int delay)

pfb_channelizer_ccf_sptr.message_subscribers(pfb_channelizer_ccf_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

pfb_channelizer_ccf_sptr.min_noutput_items(pfb_channelizer_ccf_sptr self) → int¶

pfb_channelizer_ccf_sptr.pc_input_buffers_full_avg(pfb_channelizer_ccf_sptr self, int which) → float¶: pc_input_buffers_full_avg(pfb_channelizer_ccf_sptr self) -> pmt_vector_float

pfb_channelizer_ccf_sptr.pc_noutput_items_avg(pfb_channelizer_ccf_sptr self) → float¶

pfb_channelizer_ccf_sptr.pc_nproduced_avg(pfb_channelizer_ccf_sptr self) → float¶

pfb_channelizer_ccf_sptr.pc_output_buffers_full_avg(pfb_channelizer_ccf_sptr self, int which) → float¶: pc_output_buffers_full_avg(pfb_channelizer_ccf_sptr self) -> pmt_vector_float

pfb_channelizer_ccf_sptr.pc_throughput_avg(pfb_channelizer_ccf_sptr self) → float¶

pfb_channelizer_ccf_sptr.pc_work_time_avg(pfb_channelizer_ccf_sptr self) → float¶

pfb_channelizer_ccf_sptr.pc_work_time_total(pfb_channelizer_ccf_sptr self) → float¶

pfb_channelizer_ccf_sptr.print_taps(pfb_channelizer_ccf_sptr self)¶

pfb_channelizer_ccf_sptr.sample_delay(pfb_channelizer_ccf_sptr self, int which) → unsigned int¶

pfb_channelizer_ccf_sptr.set_channel_map(pfb_channelizer_ccf_sptr self, std::vector< int, std::allocator< int > > const & map)¶

pfb_channelizer_ccf_sptr.set_min_noutput_items(pfb_channelizer_ccf_sptr self, int m)¶

pfb_channelizer_ccf_sptr.set_taps(pfb_channelizer_ccf_sptr self, pmt_vector_float taps)¶

pfb_channelizer_ccf_sptr.set_thread_priority(pfb_channelizer_ccf_sptr self, int priority) → int¶

pfb_channelizer_ccf_sptr.taps(pfb_channelizer_ccf_sptr self) → std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >¶

pfb_channelizer_ccf_sptr.thread_priority(pfb_channelizer_ccf_sptr self) → int¶

gnuradio.filter.pfb_decimator_ccf(unsigned int decim, pmt_vector_float taps, unsigned int channel, bool use_fft_rotator=True, bool use_fft_filters=True) → pfb_decimator_ccf_sptr¶

pfb_decimator_ccf_sptr.active_thread_priority(pfb_decimator_ccf_sptr self) → int¶

pfb_decimator_ccf_sptr.declare_sample_delay(pfb_decimator_ccf_sptr self, int which, int delay)¶: declare_sample_delay(pfb_decimator_ccf_sptr self, unsigned int delay)

pfb_decimator_ccf_sptr.message_subscribers(pfb_decimator_ccf_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

pfb_decimator_ccf_sptr.min_noutput_items(pfb_decimator_ccf_sptr self) → int¶

pfb_decimator_ccf_sptr.pc_input_buffers_full_avg(pfb_decimator_ccf_sptr self, int which) → float¶: pc_input_buffers_full_avg(pfb_decimator_ccf_sptr self) -> pmt_vector_float

pfb_decimator_ccf_sptr.pc_noutput_items_avg(pfb_decimator_ccf_sptr self) → float¶

pfb_decimator_ccf_sptr.pc_nproduced_avg(pfb_decimator_ccf_sptr self) → float¶

pfb_decimator_ccf_sptr.pc_output_buffers_full_avg(pfb_decimator_ccf_sptr self, int which) → float¶: pc_output_buffers_full_avg(pfb_decimator_ccf_sptr self) -> pmt_vector_float

pfb_decimator_ccf_sptr.pc_throughput_avg(pfb_decimator_ccf_sptr self) → float¶

pfb_decimator_ccf_sptr.pc_work_time_avg(pfb_decimator_ccf_sptr self) → float¶

pfb_decimator_ccf_sptr.pc_work_time_total(pfb_decimator_ccf_sptr self) → float¶

pfb_decimator_ccf_sptr.print_taps(pfb_decimator_ccf_sptr self)¶

pfb_decimator_ccf_sptr.sample_delay(pfb_decimator_ccf_sptr self, int which) → unsigned int¶

pfb_decimator_ccf_sptr.set_channel(pfb_decimator_ccf_sptr self, unsigned int const channel)¶

pfb_decimator_ccf_sptr.set_min_noutput_items(pfb_decimator_ccf_sptr self, int m)¶

pfb_decimator_ccf_sptr.set_taps(pfb_decimator_ccf_sptr self, pmt_vector_float taps)¶

pfb_decimator_ccf_sptr.set_thread_priority(pfb_decimator_ccf_sptr self, int priority) → int¶

pfb_decimator_ccf_sptr.taps(pfb_decimator_ccf_sptr self) → std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >¶

pfb_decimator_ccf_sptr.thread_priority(pfb_decimator_ccf_sptr self) → int¶

gnuradio.filter.pfb_interpolator_ccf(unsigned int interp, pmt_vector_float taps) → pfb_interpolator_ccf_sptr¶

pfb_interpolator_ccf_sptr.active_thread_priority(pfb_interpolator_ccf_sptr self) → int¶

pfb_interpolator_ccf_sptr.declare_sample_delay(pfb_interpolator_ccf_sptr self, int which, int delay)¶: declare_sample_delay(pfb_interpolator_ccf_sptr self, unsigned int delay)

pfb_interpolator_ccf_sptr.message_subscribers(pfb_interpolator_ccf_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

pfb_interpolator_ccf_sptr.min_noutput_items(pfb_interpolator_ccf_sptr self) → int¶

pfb_interpolator_ccf_sptr.pc_input_buffers_full_avg(pfb_interpolator_ccf_sptr self, int which) → float¶: pc_input_buffers_full_avg(pfb_interpolator_ccf_sptr self) -> pmt_vector_float

pfb_interpolator_ccf_sptr.pc_noutput_items_avg(pfb_interpolator_ccf_sptr self) → float¶

pfb_interpolator_ccf_sptr.pc_nproduced_avg(pfb_interpolator_ccf_sptr self) → float¶

pfb_interpolator_ccf_sptr.pc_output_buffers_full_avg(pfb_interpolator_ccf_sptr self, int which) → float¶: pc_output_buffers_full_avg(pfb_interpolator_ccf_sptr self) -> pmt_vector_float

pfb_interpolator_ccf_sptr.pc_throughput_avg(pfb_interpolator_ccf_sptr self) → float¶

pfb_interpolator_ccf_sptr.pc_work_time_avg(pfb_interpolator_ccf_sptr self) → float¶

pfb_interpolator_ccf_sptr.pc_work_time_total(pfb_interpolator_ccf_sptr self) → float¶

pfb_interpolator_ccf_sptr.print_taps(pfb_interpolator_ccf_sptr self)¶

pfb_interpolator_ccf_sptr.sample_delay(pfb_interpolator_ccf_sptr self, int which) → unsigned int¶

pfb_interpolator_ccf_sptr.set_min_noutput_items(pfb_interpolator_ccf_sptr self, int m)¶

pfb_interpolator_ccf_sptr.set_taps(pfb_interpolator_ccf_sptr self, pmt_vector_float taps)¶

pfb_interpolator_ccf_sptr.set_thread_priority(pfb_interpolator_ccf_sptr self, int priority) → int¶

pfb_interpolator_ccf_sptr.taps(pfb_interpolator_ccf_sptr self) → std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >¶

pfb_interpolator_ccf_sptr.thread_priority(pfb_interpolator_ccf_sptr self) → int¶

gnuradio.filter.pfb_synthesizer_ccf(unsigned int numchans, pmt_vector_float taps, bool twox=False) → pfb_synthesizer_ccf_sptr¶

pfb_synthesizer_ccf_sptr.active_thread_priority(pfb_synthesizer_ccf_sptr self) → int¶

pfb_synthesizer_ccf_sptr.channel_map(pfb_synthesizer_ccf_sptr self) → std::vector< int,std::allocator< int > >¶

pfb_synthesizer_ccf_sptr.declare_sample_delay(pfb_synthesizer_ccf_sptr self, int which, int delay)¶: declare_sample_delay(pfb_synthesizer_ccf_sptr self, unsigned int delay)

pfb_synthesizer_ccf_sptr.message_subscribers(pfb_synthesizer_ccf_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

pfb_synthesizer_ccf_sptr.min_noutput_items(pfb_synthesizer_ccf_sptr self) → int¶

pfb_synthesizer_ccf_sptr.pc_input_buffers_full_avg(pfb_synthesizer_ccf_sptr self, int which) → float¶: pc_input_buffers_full_avg(pfb_synthesizer_ccf_sptr self) -> pmt_vector_float

pfb_synthesizer_ccf_sptr.pc_noutput_items_avg(pfb_synthesizer_ccf_sptr self) → float¶

pfb_synthesizer_ccf_sptr.pc_nproduced_avg(pfb_synthesizer_ccf_sptr self) → float¶

pfb_synthesizer_ccf_sptr.pc_output_buffers_full_avg(pfb_synthesizer_ccf_sptr self, int which) → float¶: pc_output_buffers_full_avg(pfb_synthesizer_ccf_sptr self) -> pmt_vector_float

pfb_synthesizer_ccf_sptr.pc_throughput_avg(pfb_synthesizer_ccf_sptr self) → float¶

pfb_synthesizer_ccf_sptr.pc_work_time_avg(pfb_synthesizer_ccf_sptr self) → float¶

pfb_synthesizer_ccf_sptr.pc_work_time_total(pfb_synthesizer_ccf_sptr self) → float¶

pfb_synthesizer_ccf_sptr.print_taps(pfb_synthesizer_ccf_sptr self)¶

pfb_synthesizer_ccf_sptr.sample_delay(pfb_synthesizer_ccf_sptr self, int which) → unsigned int¶

pfb_synthesizer_ccf_sptr.set_channel_map(pfb_synthesizer_ccf_sptr self, std::vector< int, std::allocator< int > > const & map)¶

pfb_synthesizer_ccf_sptr.set_min_noutput_items(pfb_synthesizer_ccf_sptr self, int m)¶

pfb_synthesizer_ccf_sptr.set_taps(pfb_synthesizer_ccf_sptr self, pmt_vector_float taps)¶

pfb_synthesizer_ccf_sptr.set_thread_priority(pfb_synthesizer_ccf_sptr self, int priority) → int¶

pfb_synthesizer_ccf_sptr.taps(pfb_synthesizer_ccf_sptr self) → std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >¶

pfb_synthesizer_ccf_sptr.thread_priority(pfb_synthesizer_ccf_sptr self) → int¶

gnuradio.filter.rational_resampler_base_ccc(unsigned int interpolation, unsigned int decimation, pmt_vector_cfloat taps) → rational_resampler_base_ccc_sptr¶

rational_resampler_base_ccc_sptr.active_thread_priority(rational_resampler_base_ccc_sptr self) → int¶

rational_resampler_base_ccc_sptr.decimation(rational_resampler_base_ccc_sptr self) → unsigned int¶

rational_resampler_base_ccc_sptr.declare_sample_delay(rational_resampler_base_ccc_sptr self, int which, int delay)¶: declare_sample_delay(rational_resampler_base_ccc_sptr self, unsigned int delay)

rational_resampler_base_ccc_sptr.interpolation(rational_resampler_base_ccc_sptr self) → unsigned int¶

rational_resampler_base_ccc_sptr.message_subscribers(rational_resampler_base_ccc_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

rational_resampler_base_ccc_sptr.min_noutput_items(rational_resampler_base_ccc_sptr self) → int¶

rational_resampler_base_ccc_sptr.pc_input_buffers_full_avg(rational_resampler_base_ccc_sptr self, int which) → float¶: pc_input_buffers_full_avg(rational_resampler_base_ccc_sptr self) -> pmt_vector_float

rational_resampler_base_ccc_sptr.pc_noutput_items_avg(rational_resampler_base_ccc_sptr self) → float¶

rational_resampler_base_ccc_sptr.pc_nproduced_avg(rational_resampler_base_ccc_sptr self) → float¶

rational_resampler_base_ccc_sptr.pc_output_buffers_full_avg(rational_resampler_base_ccc_sptr self, int which) → float¶: pc_output_buffers_full_avg(rational_resampler_base_ccc_sptr self) -> pmt_vector_float

rational_resampler_base_ccc_sptr.pc_throughput_avg(rational_resampler_base_ccc_sptr self) → float¶

rational_resampler_base_ccc_sptr.pc_work_time_avg(rational_resampler_base_ccc_sptr self) → float¶

rational_resampler_base_ccc_sptr.pc_work_time_total(rational_resampler_base_ccc_sptr self) → float¶

rational_resampler_base_ccc_sptr.sample_delay(rational_resampler_base_ccc_sptr self, int which) → unsigned int¶

rational_resampler_base_ccc_sptr.set_min_noutput_items(rational_resampler_base_ccc_sptr self, int m)¶

rational_resampler_base_ccc_sptr.set_taps(rational_resampler_base_ccc_sptr self, pmt_vector_cfloat taps)¶

rational_resampler_base_ccc_sptr.set_thread_priority(rational_resampler_base_ccc_sptr self, int priority) → int¶

rational_resampler_base_ccc_sptr.taps(rational_resampler_base_ccc_sptr self) → pmt_vector_cfloat¶

rational_resampler_base_ccc_sptr.thread_priority(rational_resampler_base_ccc_sptr self) → int¶

gnuradio.filter.rational_resampler_base_ccf(unsigned int interpolation, unsigned int decimation, pmt_vector_float taps) → rational_resampler_base_ccf_sptr¶

rational_resampler_base_ccf_sptr.active_thread_priority(rational_resampler_base_ccf_sptr self) → int¶

rational_resampler_base_ccf_sptr.decimation(rational_resampler_base_ccf_sptr self) → unsigned int¶

rational_resampler_base_ccf_sptr.declare_sample_delay(rational_resampler_base_ccf_sptr self, int which, int delay)¶: declare_sample_delay(rational_resampler_base_ccf_sptr self, unsigned int delay)

rational_resampler_base_ccf_sptr.interpolation(rational_resampler_base_ccf_sptr self) → unsigned int¶

rational_resampler_base_ccf_sptr.message_subscribers(rational_resampler_base_ccf_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

rational_resampler_base_ccf_sptr.min_noutput_items(rational_resampler_base_ccf_sptr self) → int¶

rational_resampler_base_ccf_sptr.pc_input_buffers_full_avg(rational_resampler_base_ccf_sptr self, int which) → float¶: pc_input_buffers_full_avg(rational_resampler_base_ccf_sptr self) -> pmt_vector_float

rational_resampler_base_ccf_sptr.pc_noutput_items_avg(rational_resampler_base_ccf_sptr self) → float¶

rational_resampler_base_ccf_sptr.pc_nproduced_avg(rational_resampler_base_ccf_sptr self) → float¶

rational_resampler_base_ccf_sptr.pc_output_buffers_full_avg(rational_resampler_base_ccf_sptr self, int which) → float¶: pc_output_buffers_full_avg(rational_resampler_base_ccf_sptr self) -> pmt_vector_float

rational_resampler_base_ccf_sptr.pc_throughput_avg(rational_resampler_base_ccf_sptr self) → float¶

rational_resampler_base_ccf_sptr.pc_work_time_avg(rational_resampler_base_ccf_sptr self) → float¶

rational_resampler_base_ccf_sptr.pc_work_time_total(rational_resampler_base_ccf_sptr self) → float¶

rational_resampler_base_ccf_sptr.sample_delay(rational_resampler_base_ccf_sptr self, int which) → unsigned int¶

rational_resampler_base_ccf_sptr.set_min_noutput_items(rational_resampler_base_ccf_sptr self, int m)¶

rational_resampler_base_ccf_sptr.set_taps(rational_resampler_base_ccf_sptr self, pmt_vector_float taps)¶

rational_resampler_base_ccf_sptr.set_thread_priority(rational_resampler_base_ccf_sptr self, int priority) → int¶

rational_resampler_base_ccf_sptr.taps(rational_resampler_base_ccf_sptr self) → pmt_vector_float¶

rational_resampler_base_ccf_sptr.thread_priority(rational_resampler_base_ccf_sptr self) → int¶

gnuradio.filter.rational_resampler_base_fcc(unsigned int interpolation, unsigned int decimation, pmt_vector_cfloat taps) → rational_resampler_base_fcc_sptr¶

rational_resampler_base_fcc_sptr.active_thread_priority(rational_resampler_base_fcc_sptr self) → int¶

rational_resampler_base_fcc_sptr.decimation(rational_resampler_base_fcc_sptr self) → unsigned int¶

rational_resampler_base_fcc_sptr.declare_sample_delay(rational_resampler_base_fcc_sptr self, int which, int delay)¶: declare_sample_delay(rational_resampler_base_fcc_sptr self, unsigned int delay)

rational_resampler_base_fcc_sptr.interpolation(rational_resampler_base_fcc_sptr self) → unsigned int¶

rational_resampler_base_fcc_sptr.message_subscribers(rational_resampler_base_fcc_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

rational_resampler_base_fcc_sptr.min_noutput_items(rational_resampler_base_fcc_sptr self) → int¶

rational_resampler_base_fcc_sptr.pc_input_buffers_full_avg(rational_resampler_base_fcc_sptr self, int which) → float¶: pc_input_buffers_full_avg(rational_resampler_base_fcc_sptr self) -> pmt_vector_float

rational_resampler_base_fcc_sptr.pc_noutput_items_avg(rational_resampler_base_fcc_sptr self) → float¶

rational_resampler_base_fcc_sptr.pc_nproduced_avg(rational_resampler_base_fcc_sptr self) → float¶

rational_resampler_base_fcc_sptr.pc_output_buffers_full_avg(rational_resampler_base_fcc_sptr self, int which) → float¶: pc_output_buffers_full_avg(rational_resampler_base_fcc_sptr self) -> pmt_vector_float

rational_resampler_base_fcc_sptr.pc_throughput_avg(rational_resampler_base_fcc_sptr self) → float¶

rational_resampler_base_fcc_sptr.pc_work_time_avg(rational_resampler_base_fcc_sptr self) → float¶

rational_resampler_base_fcc_sptr.pc_work_time_total(rational_resampler_base_fcc_sptr self) → float¶

rational_resampler_base_fcc_sptr.sample_delay(rational_resampler_base_fcc_sptr self, int which) → unsigned int¶

rational_resampler_base_fcc_sptr.set_min_noutput_items(rational_resampler_base_fcc_sptr self, int m)¶

rational_resampler_base_fcc_sptr.set_taps(rational_resampler_base_fcc_sptr self, pmt_vector_cfloat taps)¶

rational_resampler_base_fcc_sptr.set_thread_priority(rational_resampler_base_fcc_sptr self, int priority) → int¶

rational_resampler_base_fcc_sptr.taps(rational_resampler_base_fcc_sptr self) → pmt_vector_cfloat¶

rational_resampler_base_fcc_sptr.thread_priority(rational_resampler_base_fcc_sptr self) → int¶

gnuradio.filter.rational_resampler_base_fff(unsigned int interpolation, unsigned int decimation, pmt_vector_float taps) → rational_resampler_base_fff_sptr¶

rational_resampler_base_fff_sptr.active_thread_priority(rational_resampler_base_fff_sptr self) → int¶

rational_resampler_base_fff_sptr.decimation(rational_resampler_base_fff_sptr self) → unsigned int¶

rational_resampler_base_fff_sptr.declare_sample_delay(rational_resampler_base_fff_sptr self, int which, int delay)¶: declare_sample_delay(rational_resampler_base_fff_sptr self, unsigned int delay)

rational_resampler_base_fff_sptr.interpolation(rational_resampler_base_fff_sptr self) → unsigned int¶

rational_resampler_base_fff_sptr.message_subscribers(rational_resampler_base_fff_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

rational_resampler_base_fff_sptr.min_noutput_items(rational_resampler_base_fff_sptr self) → int¶

rational_resampler_base_fff_sptr.pc_input_buffers_full_avg(rational_resampler_base_fff_sptr self, int which) → float¶: pc_input_buffers_full_avg(rational_resampler_base_fff_sptr self) -> pmt_vector_float

rational_resampler_base_fff_sptr.pc_noutput_items_avg(rational_resampler_base_fff_sptr self) → float¶

rational_resampler_base_fff_sptr.pc_nproduced_avg(rational_resampler_base_fff_sptr self) → float¶

rational_resampler_base_fff_sptr.pc_output_buffers_full_avg(rational_resampler_base_fff_sptr self, int which) → float¶: pc_output_buffers_full_avg(rational_resampler_base_fff_sptr self) -> pmt_vector_float

rational_resampler_base_fff_sptr.pc_throughput_avg(rational_resampler_base_fff_sptr self) → float¶

rational_resampler_base_fff_sptr.pc_work_time_avg(rational_resampler_base_fff_sptr self) → float¶

rational_resampler_base_fff_sptr.pc_work_time_total(rational_resampler_base_fff_sptr self) → float¶

rational_resampler_base_fff_sptr.sample_delay(rational_resampler_base_fff_sptr self, int which) → unsigned int¶

rational_resampler_base_fff_sptr.set_min_noutput_items(rational_resampler_base_fff_sptr self, int m)¶

rational_resampler_base_fff_sptr.set_taps(rational_resampler_base_fff_sptr self, pmt_vector_float taps)¶

rational_resampler_base_fff_sptr.set_thread_priority(rational_resampler_base_fff_sptr self, int priority) → int¶

rational_resampler_base_fff_sptr.taps(rational_resampler_base_fff_sptr self) → pmt_vector_float¶

rational_resampler_base_fff_sptr.thread_priority(rational_resampler_base_fff_sptr self) → int¶

gnuradio.filter.rational_resampler_base_fsf(unsigned int interpolation, unsigned int decimation, pmt_vector_float taps) → rational_resampler_base_fsf_sptr¶

rational_resampler_base_fsf_sptr.active_thread_priority(rational_resampler_base_fsf_sptr self) → int¶

rational_resampler_base_fsf_sptr.decimation(rational_resampler_base_fsf_sptr self) → unsigned int¶

rational_resampler_base_fsf_sptr.declare_sample_delay(rational_resampler_base_fsf_sptr self, int which, int delay)¶: declare_sample_delay(rational_resampler_base_fsf_sptr self, unsigned int delay)

rational_resampler_base_fsf_sptr.interpolation(rational_resampler_base_fsf_sptr self) → unsigned int¶

rational_resampler_base_fsf_sptr.message_subscribers(rational_resampler_base_fsf_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

rational_resampler_base_fsf_sptr.min_noutput_items(rational_resampler_base_fsf_sptr self) → int¶

rational_resampler_base_fsf_sptr.pc_input_buffers_full_avg(rational_resampler_base_fsf_sptr self, int which) → float¶: pc_input_buffers_full_avg(rational_resampler_base_fsf_sptr self) -> pmt_vector_float

rational_resampler_base_fsf_sptr.pc_noutput_items_avg(rational_resampler_base_fsf_sptr self) → float¶

rational_resampler_base_fsf_sptr.pc_nproduced_avg(rational_resampler_base_fsf_sptr self) → float¶

rational_resampler_base_fsf_sptr.pc_output_buffers_full_avg(rational_resampler_base_fsf_sptr self, int which) → float¶: pc_output_buffers_full_avg(rational_resampler_base_fsf_sptr self) -> pmt_vector_float

rational_resampler_base_fsf_sptr.pc_throughput_avg(rational_resampler_base_fsf_sptr self) → float¶

rational_resampler_base_fsf_sptr.pc_work_time_avg(rational_resampler_base_fsf_sptr self) → float¶

rational_resampler_base_fsf_sptr.pc_work_time_total(rational_resampler_base_fsf_sptr self) → float¶

rational_resampler_base_fsf_sptr.sample_delay(rational_resampler_base_fsf_sptr self, int which) → unsigned int¶

rational_resampler_base_fsf_sptr.set_min_noutput_items(rational_resampler_base_fsf_sptr self, int m)¶

rational_resampler_base_fsf_sptr.set_taps(rational_resampler_base_fsf_sptr self, pmt_vector_float taps)¶

rational_resampler_base_fsf_sptr.set_thread_priority(rational_resampler_base_fsf_sptr self, int priority) → int¶

rational_resampler_base_fsf_sptr.taps(rational_resampler_base_fsf_sptr self) → pmt_vector_float¶

rational_resampler_base_fsf_sptr.thread_priority(rational_resampler_base_fsf_sptr self) → int¶

gnuradio.filter.rational_resampler_base_scc(unsigned int interpolation, unsigned int decimation, pmt_vector_cfloat taps) → rational_resampler_base_scc_sptr¶

rational_resampler_base_scc_sptr.active_thread_priority(rational_resampler_base_scc_sptr self) → int¶

rational_resampler_base_scc_sptr.decimation(rational_resampler_base_scc_sptr self) → unsigned int¶

rational_resampler_base_scc_sptr.declare_sample_delay(rational_resampler_base_scc_sptr self, int which, int delay)¶: declare_sample_delay(rational_resampler_base_scc_sptr self, unsigned int delay)

rational_resampler_base_scc_sptr.interpolation(rational_resampler_base_scc_sptr self) → unsigned int¶

rational_resampler_base_scc_sptr.message_subscribers(rational_resampler_base_scc_sptr self, swig_int_ptr which_port) → swig_int_ptr¶

rational_resampler_base_scc_sptr.min_noutput_items(rational_resampler_base_scc_sptr self) → int¶

rational_resampler_base_scc_sptr.pc_input_buffers_full_avg(rational_resampler_base_scc_sptr self, int which) → float¶: pc_input_buffers_full_avg(rational_resampler_base_scc_sptr self) -> pmt_vector_float

rational_resampler_base_scc_sptr.pc_noutput_items_avg(rational_resampler_base_scc_sptr self) → float¶

rational_resampler_base_scc_sptr.pc_nproduced_avg(rational_resampler_base_scc_sptr self) → float¶

rational_resampler_base_scc_sptr.pc_output_buffers_full_avg(rational_resampler_base_scc_sptr self, int which) → float¶: pc_output_buffers_full_avg(rational_resampler_base_scc_sptr self) -> pmt_vector_float

rational_resampler_base_scc_sptr.pc_throughput_avg(rational_resampler_base_scc_sptr self) → float¶

rational_resampler_base_scc_sptr.pc_work_time_avg(rational_resampler_base_scc_sptr self) → float¶

rational_resampler_base_scc_sptr.pc_work_time_total(rational_resampler_base_scc_sptr self) → float¶

rational_resampler_base_scc_sptr.sample_delay(rational_resampler_base_scc_sptr self, int which) → unsigned int¶

rational_resampler_base_scc_sptr.set_min_noutput_items(rational_resampler_base_scc_sptr self, int m)¶

rational_resampler_base_scc_sptr.set_taps(rational_resampler_base_scc_sptr self, pmt_vector_cfloat taps)¶

rational_resampler_base_scc_sptr.set_thread_priority(rational_resampler_base_scc_sptr self, int priority) → int¶

rational_resampler_base_scc_sptr.taps(rational_resampler_base_scc_sptr self) → pmt_vector_cfloat¶

rational_resampler_base_scc_sptr.thread_priority(rational_resampler_base_scc_sptr self) → int¶

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

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_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¶

gnuradio.filters¶

Previous topic

Next topic

This Page

Navigation

gnuradio.filters¶

Previous topic

Next topic

This Page

Quick search

Navigation