gnuradio.blocks

Processing blocks common to many flowgraphs.

gnuradio.blocks.abs_ff(size_t vlen=1) → abs_ff_sptr
abs_ff_sptr.active_thread_priority(abs_ff_sptr self) → int
abs_ff_sptr.declare_sample_delay(abs_ff_sptr self, int which, int delay)

declare_sample_delay(abs_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(abs_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(abs_ff_sptr self) -> pmt_vector_float

abs_ff_sptr.pc_throughput_avg(abs_ff_sptr self) → float
abs_ff_sptr.pc_work_time_avg(abs_ff_sptr self) → float
abs_ff_sptr.pc_work_time_total(abs_ff_sptr self) → float
abs_ff_sptr.sample_delay(abs_ff_sptr self, int which) → unsigned int
abs_ff_sptr.set_min_noutput_items(abs_ff_sptr self, int m)
abs_ff_sptr.set_thread_priority(abs_ff_sptr self, int priority) → int
abs_ff_sptr.thread_priority(abs_ff_sptr self) → int
gnuradio.blocks.abs_ii(size_t vlen=1) → abs_ii_sptr
abs_ii_sptr.active_thread_priority(abs_ii_sptr self) → int
abs_ii_sptr.declare_sample_delay(abs_ii_sptr self, int which, int delay)

declare_sample_delay(abs_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(abs_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(abs_ii_sptr self) -> pmt_vector_float

abs_ii_sptr.pc_throughput_avg(abs_ii_sptr self) → float
abs_ii_sptr.pc_work_time_avg(abs_ii_sptr self) → float
abs_ii_sptr.pc_work_time_total(abs_ii_sptr self) → float
abs_ii_sptr.sample_delay(abs_ii_sptr self, int which) → unsigned int
abs_ii_sptr.set_min_noutput_items(abs_ii_sptr self, int m)
abs_ii_sptr.set_thread_priority(abs_ii_sptr self, int priority) → int
abs_ii_sptr.thread_priority(abs_ii_sptr self) → int
gnuradio.blocks.abs_ss(size_t vlen=1) → abs_ss_sptr
abs_ss_sptr.active_thread_priority(abs_ss_sptr self) → int
abs_ss_sptr.declare_sample_delay(abs_ss_sptr self, int which, int delay)

declare_sample_delay(abs_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(abs_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(abs_ss_sptr self) -> pmt_vector_float

abs_ss_sptr.pc_throughput_avg(abs_ss_sptr self) → float
abs_ss_sptr.pc_work_time_avg(abs_ss_sptr self) → float
abs_ss_sptr.pc_work_time_total(abs_ss_sptr self) → float
abs_ss_sptr.sample_delay(abs_ss_sptr self, int which) → unsigned int
abs_ss_sptr.set_min_noutput_items(abs_ss_sptr self, int m)
abs_ss_sptr.set_thread_priority(abs_ss_sptr self, int priority) → int
abs_ss_sptr.thread_priority(abs_ss_sptr self) → int
gnuradio.blocks.add_cc(size_t vlen=1) → add_cc_sptr
add_cc_sptr.active_thread_priority(add_cc_sptr self) → int
add_cc_sptr.declare_sample_delay(add_cc_sptr self, int which, int delay)

declare_sample_delay(add_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(add_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_cc_sptr self) -> pmt_vector_float

add_cc_sptr.pc_throughput_avg(add_cc_sptr self) → float
add_cc_sptr.pc_work_time_avg(add_cc_sptr self) → float
add_cc_sptr.pc_work_time_total(add_cc_sptr self) → float
add_cc_sptr.sample_delay(add_cc_sptr self, int which) → unsigned int
add_cc_sptr.set_min_noutput_items(add_cc_sptr self, int m)
add_cc_sptr.set_thread_priority(add_cc_sptr self, int priority) → int
add_cc_sptr.thread_priority(add_cc_sptr self) → int
gnuradio.blocks.add_const_bb(unsigned char k) → add_const_bb_sptr
add_const_bb_sptr.active_thread_priority(add_const_bb_sptr self) → int
add_const_bb_sptr.declare_sample_delay(add_const_bb_sptr self, int which, int delay)

declare_sample_delay(add_const_bb_sptr self, unsigned int delay)

add_const_bb_sptr.k(add_const_bb_sptr self) → unsigned char
add_const_bb_sptr.message_subscribers(add_const_bb_sptr self, swig_int_ptr which_port) → swig_int_ptr
add_const_bb_sptr.min_noutput_items(add_const_bb_sptr self) → int
add_const_bb_sptr.pc_input_buffers_full_avg(add_const_bb_sptr self, int which) → float

pc_input_buffers_full_avg(add_const_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_bb_sptr self) -> pmt_vector_float

add_const_bb_sptr.pc_throughput_avg(add_const_bb_sptr self) → float
add_const_bb_sptr.pc_work_time_avg(add_const_bb_sptr self) → float
add_const_bb_sptr.pc_work_time_total(add_const_bb_sptr self) → float
add_const_bb_sptr.sample_delay(add_const_bb_sptr self, int which) → unsigned int
add_const_bb_sptr.set_k(add_const_bb_sptr self, unsigned char k)
add_const_bb_sptr.set_min_noutput_items(add_const_bb_sptr self, int m)
add_const_bb_sptr.set_thread_priority(add_const_bb_sptr self, int priority) → int
add_const_bb_sptr.thread_priority(add_const_bb_sptr self) → int
gnuradio.blocks.add_const_cc(gr_complex k) → add_const_cc_sptr
add_const_cc_sptr.active_thread_priority(add_const_cc_sptr self) → int
add_const_cc_sptr.declare_sample_delay(add_const_cc_sptr self, int which, int delay)

declare_sample_delay(add_const_cc_sptr self, unsigned int delay)

add_const_cc_sptr.k(add_const_cc_sptr self) → gr_complex
add_const_cc_sptr.message_subscribers(add_const_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr
add_const_cc_sptr.min_noutput_items(add_const_cc_sptr self) → int
add_const_cc_sptr.pc_input_buffers_full_avg(add_const_cc_sptr self, int which) → float

pc_input_buffers_full_avg(add_const_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_cc_sptr self) -> pmt_vector_float

add_const_cc_sptr.pc_throughput_avg(add_const_cc_sptr self) → float
add_const_cc_sptr.pc_work_time_avg(add_const_cc_sptr self) → float
add_const_cc_sptr.pc_work_time_total(add_const_cc_sptr self) → float
add_const_cc_sptr.sample_delay(add_const_cc_sptr self, int which) → unsigned int
add_const_cc_sptr.set_k(add_const_cc_sptr self, gr_complex k)
add_const_cc_sptr.set_min_noutput_items(add_const_cc_sptr self, int m)
add_const_cc_sptr.set_thread_priority(add_const_cc_sptr self, int priority) → int
add_const_cc_sptr.thread_priority(add_const_cc_sptr self) → int
gnuradio.blocks.add_const_ff(float k) → add_const_ff_sptr
add_const_ff_sptr.active_thread_priority(add_const_ff_sptr self) → int
add_const_ff_sptr.declare_sample_delay(add_const_ff_sptr self, int which, int delay)

declare_sample_delay(add_const_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(add_const_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_ff_sptr self) -> pmt_vector_float

add_const_ff_sptr.pc_throughput_avg(add_const_ff_sptr self) → float
add_const_ff_sptr.pc_work_time_avg(add_const_ff_sptr self) → float
add_const_ff_sptr.pc_work_time_total(add_const_ff_sptr self) → float
add_const_ff_sptr.sample_delay(add_const_ff_sptr self, int which) → unsigned int
add_const_ff_sptr.set_k(add_const_ff_sptr self, float k)
add_const_ff_sptr.set_min_noutput_items(add_const_ff_sptr self, int m)
add_const_ff_sptr.set_thread_priority(add_const_ff_sptr self, int priority) → int
add_const_ff_sptr.thread_priority(add_const_ff_sptr self) → int
gnuradio.blocks.add_const_ii(int k) → add_const_ii_sptr
add_const_ii_sptr.active_thread_priority(add_const_ii_sptr self) → int
add_const_ii_sptr.declare_sample_delay(add_const_ii_sptr self, int which, int delay)

declare_sample_delay(add_const_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(add_const_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_ii_sptr self) -> pmt_vector_float

add_const_ii_sptr.pc_throughput_avg(add_const_ii_sptr self) → float
add_const_ii_sptr.pc_work_time_avg(add_const_ii_sptr self) → float
add_const_ii_sptr.pc_work_time_total(add_const_ii_sptr self) → float
add_const_ii_sptr.sample_delay(add_const_ii_sptr self, int which) → unsigned int
add_const_ii_sptr.set_k(add_const_ii_sptr self, int k)
add_const_ii_sptr.set_min_noutput_items(add_const_ii_sptr self, int m)
add_const_ii_sptr.set_thread_priority(add_const_ii_sptr self, int priority) → int
add_const_ii_sptr.thread_priority(add_const_ii_sptr self) → int
gnuradio.blocks.add_const_ss(short k) → add_const_ss_sptr
add_const_ss_sptr.active_thread_priority(add_const_ss_sptr self) → int
add_const_ss_sptr.declare_sample_delay(add_const_ss_sptr self, int which, int delay)

declare_sample_delay(add_const_ss_sptr self, unsigned int delay)

add_const_ss_sptr.k(add_const_ss_sptr self) → short
add_const_ss_sptr.message_subscribers(add_const_ss_sptr self, swig_int_ptr which_port) → swig_int_ptr
add_const_ss_sptr.min_noutput_items(add_const_ss_sptr self) → int
add_const_ss_sptr.pc_input_buffers_full_avg(add_const_ss_sptr self, int which) → float

pc_input_buffers_full_avg(add_const_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_ss_sptr self) -> pmt_vector_float

add_const_ss_sptr.pc_throughput_avg(add_const_ss_sptr self) → float
add_const_ss_sptr.pc_work_time_avg(add_const_ss_sptr self) → float
add_const_ss_sptr.pc_work_time_total(add_const_ss_sptr self) → float
add_const_ss_sptr.sample_delay(add_const_ss_sptr self, int which) → unsigned int
add_const_ss_sptr.set_k(add_const_ss_sptr self, short k)
add_const_ss_sptr.set_min_noutput_items(add_const_ss_sptr self, int m)
add_const_ss_sptr.set_thread_priority(add_const_ss_sptr self, int priority) → int
add_const_ss_sptr.thread_priority(add_const_ss_sptr self) → int
gnuradio.blocks.add_const_vbb(std::vector< unsigned char, std::allocator< unsigned char > > k) → add_const_vbb_sptr
add_const_vbb_sptr.active_thread_priority(add_const_vbb_sptr self) → int
add_const_vbb_sptr.declare_sample_delay(add_const_vbb_sptr self, int which, int delay)

declare_sample_delay(add_const_vbb_sptr self, unsigned int delay)

add_const_vbb_sptr.k(add_const_vbb_sptr self) → std::vector< unsigned char,std::allocator< unsigned char > >
add_const_vbb_sptr.message_subscribers(add_const_vbb_sptr self, swig_int_ptr which_port) → swig_int_ptr
add_const_vbb_sptr.min_noutput_items(add_const_vbb_sptr self) → int
add_const_vbb_sptr.pc_input_buffers_full_avg(add_const_vbb_sptr self, int which) → float

pc_input_buffers_full_avg(add_const_vbb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_vbb_sptr self) -> pmt_vector_float

add_const_vbb_sptr.pc_throughput_avg(add_const_vbb_sptr self) → float
add_const_vbb_sptr.pc_work_time_avg(add_const_vbb_sptr self) → float
add_const_vbb_sptr.pc_work_time_total(add_const_vbb_sptr self) → float
add_const_vbb_sptr.sample_delay(add_const_vbb_sptr self, int which) → unsigned int
add_const_vbb_sptr.set_k(add_const_vbb_sptr self, std::vector< unsigned char, std::allocator< unsigned char > > k)
add_const_vbb_sptr.set_min_noutput_items(add_const_vbb_sptr self, int m)
add_const_vbb_sptr.set_thread_priority(add_const_vbb_sptr self, int priority) → int
add_const_vbb_sptr.thread_priority(add_const_vbb_sptr self) → int
gnuradio.blocks.add_const_vcc(pmt_vector_cfloat k) → add_const_vcc_sptr
add_const_vcc_sptr.active_thread_priority(add_const_vcc_sptr self) → int
add_const_vcc_sptr.declare_sample_delay(add_const_vcc_sptr self, int which, int delay)

declare_sample_delay(add_const_vcc_sptr self, unsigned int delay)

add_const_vcc_sptr.k(add_const_vcc_sptr self) → pmt_vector_cfloat
add_const_vcc_sptr.message_subscribers(add_const_vcc_sptr self, swig_int_ptr which_port) → swig_int_ptr
add_const_vcc_sptr.min_noutput_items(add_const_vcc_sptr self) → int
add_const_vcc_sptr.pc_input_buffers_full_avg(add_const_vcc_sptr self, int which) → float

pc_input_buffers_full_avg(add_const_vcc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_vcc_sptr self) -> pmt_vector_float

add_const_vcc_sptr.pc_throughput_avg(add_const_vcc_sptr self) → float
add_const_vcc_sptr.pc_work_time_avg(add_const_vcc_sptr self) → float
add_const_vcc_sptr.pc_work_time_total(add_const_vcc_sptr self) → float
add_const_vcc_sptr.sample_delay(add_const_vcc_sptr self, int which) → unsigned int
add_const_vcc_sptr.set_k(add_const_vcc_sptr self, pmt_vector_cfloat k)
add_const_vcc_sptr.set_min_noutput_items(add_const_vcc_sptr self, int m)
add_const_vcc_sptr.set_thread_priority(add_const_vcc_sptr self, int priority) → int
add_const_vcc_sptr.thread_priority(add_const_vcc_sptr self) → int
gnuradio.blocks.add_const_vff(pmt_vector_float k) → add_const_vff_sptr
add_const_vff_sptr.active_thread_priority(add_const_vff_sptr self) → int
add_const_vff_sptr.declare_sample_delay(add_const_vff_sptr self, int which, int delay)

declare_sample_delay(add_const_vff_sptr self, unsigned int delay)

add_const_vff_sptr.k(add_const_vff_sptr self) → pmt_vector_float
add_const_vff_sptr.message_subscribers(add_const_vff_sptr self, swig_int_ptr which_port) → swig_int_ptr
add_const_vff_sptr.min_noutput_items(add_const_vff_sptr self) → int
add_const_vff_sptr.pc_input_buffers_full_avg(add_const_vff_sptr self, int which) → float

pc_input_buffers_full_avg(add_const_vff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_vff_sptr self) -> pmt_vector_float

add_const_vff_sptr.pc_throughput_avg(add_const_vff_sptr self) → float
add_const_vff_sptr.pc_work_time_avg(add_const_vff_sptr self) → float
add_const_vff_sptr.pc_work_time_total(add_const_vff_sptr self) → float
add_const_vff_sptr.sample_delay(add_const_vff_sptr self, int which) → unsigned int
add_const_vff_sptr.set_k(add_const_vff_sptr self, pmt_vector_float k)
add_const_vff_sptr.set_min_noutput_items(add_const_vff_sptr self, int m)
add_const_vff_sptr.set_thread_priority(add_const_vff_sptr self, int priority) → int
add_const_vff_sptr.thread_priority(add_const_vff_sptr self) → int
gnuradio.blocks.add_const_vii(std::vector< int, std::allocator< int > > k) → add_const_vii_sptr
add_const_vii_sptr.active_thread_priority(add_const_vii_sptr self) → int
add_const_vii_sptr.declare_sample_delay(add_const_vii_sptr self, int which, int delay)

declare_sample_delay(add_const_vii_sptr self, unsigned int delay)

add_const_vii_sptr.k(add_const_vii_sptr self) → std::vector< int,std::allocator< int > >
add_const_vii_sptr.message_subscribers(add_const_vii_sptr self, swig_int_ptr which_port) → swig_int_ptr
add_const_vii_sptr.min_noutput_items(add_const_vii_sptr self) → int
add_const_vii_sptr.pc_input_buffers_full_avg(add_const_vii_sptr self, int which) → float

pc_input_buffers_full_avg(add_const_vii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_vii_sptr self) -> pmt_vector_float

add_const_vii_sptr.pc_throughput_avg(add_const_vii_sptr self) → float
add_const_vii_sptr.pc_work_time_avg(add_const_vii_sptr self) → float
add_const_vii_sptr.pc_work_time_total(add_const_vii_sptr self) → float
add_const_vii_sptr.sample_delay(add_const_vii_sptr self, int which) → unsigned int
add_const_vii_sptr.set_k(add_const_vii_sptr self, std::vector< int, std::allocator< int > > k)
add_const_vii_sptr.set_min_noutput_items(add_const_vii_sptr self, int m)
add_const_vii_sptr.set_thread_priority(add_const_vii_sptr self, int priority) → int
add_const_vii_sptr.thread_priority(add_const_vii_sptr self) → int
gnuradio.blocks.add_const_vss(std::vector< short, std::allocator< short > > k) → add_const_vss_sptr
add_const_vss_sptr.active_thread_priority(add_const_vss_sptr self) → int
add_const_vss_sptr.declare_sample_delay(add_const_vss_sptr self, int which, int delay)

declare_sample_delay(add_const_vss_sptr self, unsigned int delay)

add_const_vss_sptr.k(add_const_vss_sptr self) → std::vector< short,std::allocator< short > >
add_const_vss_sptr.message_subscribers(add_const_vss_sptr self, swig_int_ptr which_port) → swig_int_ptr
add_const_vss_sptr.min_noutput_items(add_const_vss_sptr self) → int
add_const_vss_sptr.pc_input_buffers_full_avg(add_const_vss_sptr self, int which) → float

pc_input_buffers_full_avg(add_const_vss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_vss_sptr self) -> pmt_vector_float

add_const_vss_sptr.pc_throughput_avg(add_const_vss_sptr self) → float
add_const_vss_sptr.pc_work_time_avg(add_const_vss_sptr self) → float
add_const_vss_sptr.pc_work_time_total(add_const_vss_sptr self) → float
add_const_vss_sptr.sample_delay(add_const_vss_sptr self, int which) → unsigned int
add_const_vss_sptr.set_k(add_const_vss_sptr self, std::vector< short, std::allocator< short > > k)
add_const_vss_sptr.set_min_noutput_items(add_const_vss_sptr self, int m)
add_const_vss_sptr.set_thread_priority(add_const_vss_sptr self, int priority) → int
add_const_vss_sptr.thread_priority(add_const_vss_sptr self) → int
gnuradio.blocks.add_ff(size_t vlen=1) → add_ff_sptr
add_ff_sptr.active_thread_priority(add_ff_sptr self) → int
add_ff_sptr.declare_sample_delay(add_ff_sptr self, int which, int delay)

declare_sample_delay(add_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(add_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_ff_sptr self) -> pmt_vector_float

add_ff_sptr.pc_throughput_avg(add_ff_sptr self) → float
add_ff_sptr.pc_work_time_avg(add_ff_sptr self) → float
add_ff_sptr.pc_work_time_total(add_ff_sptr self) → float
add_ff_sptr.sample_delay(add_ff_sptr self, int which) → unsigned int
add_ff_sptr.set_min_noutput_items(add_ff_sptr self, int m)
add_ff_sptr.set_thread_priority(add_ff_sptr self, int priority) → int
add_ff_sptr.thread_priority(add_ff_sptr self) → int
gnuradio.blocks.add_ii(size_t vlen=1) → add_ii_sptr
add_ii_sptr.active_thread_priority(add_ii_sptr self) → int
add_ii_sptr.declare_sample_delay(add_ii_sptr self, int which, int delay)

declare_sample_delay(add_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(add_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_ii_sptr self) -> pmt_vector_float

add_ii_sptr.pc_throughput_avg(add_ii_sptr self) → float
add_ii_sptr.pc_work_time_avg(add_ii_sptr self) → float
add_ii_sptr.pc_work_time_total(add_ii_sptr self) → float
add_ii_sptr.sample_delay(add_ii_sptr self, int which) → unsigned int
add_ii_sptr.set_min_noutput_items(add_ii_sptr self, int m)
add_ii_sptr.set_thread_priority(add_ii_sptr self, int priority) → int
add_ii_sptr.thread_priority(add_ii_sptr self) → int
gnuradio.blocks.add_ss(size_t vlen=1) → add_ss_sptr
add_ss_sptr.active_thread_priority(add_ss_sptr self) → int
add_ss_sptr.declare_sample_delay(add_ss_sptr self, int which, int delay)

declare_sample_delay(add_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(add_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_ss_sptr self) -> pmt_vector_float

add_ss_sptr.pc_throughput_avg(add_ss_sptr self) → float
add_ss_sptr.pc_work_time_avg(add_ss_sptr self) → float
add_ss_sptr.pc_work_time_total(add_ss_sptr self) → float
add_ss_sptr.sample_delay(add_ss_sptr self, int which) → unsigned int
add_ss_sptr.set_min_noutput_items(add_ss_sptr self, int m)
add_ss_sptr.set_thread_priority(add_ss_sptr self, int priority) → int
add_ss_sptr.thread_priority(add_ss_sptr self) → int
gnuradio.blocks.and_bb(size_t vlen=1) → and_bb_sptr
and_bb_sptr.active_thread_priority(and_bb_sptr self) → int
and_bb_sptr.declare_sample_delay(and_bb_sptr self, int which, int delay)

declare_sample_delay(and_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(and_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(and_bb_sptr self) -> pmt_vector_float

and_bb_sptr.pc_throughput_avg(and_bb_sptr self) → float
and_bb_sptr.pc_work_time_avg(and_bb_sptr self) → float
and_bb_sptr.pc_work_time_total(and_bb_sptr self) → float
and_bb_sptr.sample_delay(and_bb_sptr self, int which) → unsigned int
and_bb_sptr.set_min_noutput_items(and_bb_sptr self, int m)
and_bb_sptr.set_thread_priority(and_bb_sptr self, int priority) → int
and_bb_sptr.thread_priority(and_bb_sptr self) → int
gnuradio.blocks.and_const_bb(unsigned char k) → and_const_bb_sptr
and_const_bb_sptr.active_thread_priority(and_const_bb_sptr self) → int
and_const_bb_sptr.declare_sample_delay(and_const_bb_sptr self, int which, int delay)

declare_sample_delay(and_const_bb_sptr self, unsigned int delay)

and_const_bb_sptr.k(and_const_bb_sptr self) → unsigned char
and_const_bb_sptr.message_subscribers(and_const_bb_sptr self, swig_int_ptr which_port) → swig_int_ptr
and_const_bb_sptr.min_noutput_items(and_const_bb_sptr self) → int
and_const_bb_sptr.pc_input_buffers_full_avg(and_const_bb_sptr self, int which) → float

pc_input_buffers_full_avg(and_const_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(and_const_bb_sptr self) -> pmt_vector_float

and_const_bb_sptr.pc_throughput_avg(and_const_bb_sptr self) → float
and_const_bb_sptr.pc_work_time_avg(and_const_bb_sptr self) → float
and_const_bb_sptr.pc_work_time_total(and_const_bb_sptr self) → float
and_const_bb_sptr.sample_delay(and_const_bb_sptr self, int which) → unsigned int
and_const_bb_sptr.set_k(and_const_bb_sptr self, unsigned char k)
and_const_bb_sptr.set_min_noutput_items(and_const_bb_sptr self, int m)
and_const_bb_sptr.set_thread_priority(and_const_bb_sptr self, int priority) → int
and_const_bb_sptr.thread_priority(and_const_bb_sptr self) → int
gnuradio.blocks.and_const_ii(int k) → and_const_ii_sptr
and_const_ii_sptr.active_thread_priority(and_const_ii_sptr self) → int
and_const_ii_sptr.declare_sample_delay(and_const_ii_sptr self, int which, int delay)

declare_sample_delay(and_const_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(and_const_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(and_const_ii_sptr self) -> pmt_vector_float

and_const_ii_sptr.pc_throughput_avg(and_const_ii_sptr self) → float
and_const_ii_sptr.pc_work_time_avg(and_const_ii_sptr self) → float
and_const_ii_sptr.pc_work_time_total(and_const_ii_sptr self) → float
and_const_ii_sptr.sample_delay(and_const_ii_sptr self, int which) → unsigned int
and_const_ii_sptr.set_k(and_const_ii_sptr self, int k)
and_const_ii_sptr.set_min_noutput_items(and_const_ii_sptr self, int m)
and_const_ii_sptr.set_thread_priority(and_const_ii_sptr self, int priority) → int
and_const_ii_sptr.thread_priority(and_const_ii_sptr self) → int
gnuradio.blocks.and_const_ss(short k) → and_const_ss_sptr
and_const_ss_sptr.active_thread_priority(and_const_ss_sptr self) → int
and_const_ss_sptr.declare_sample_delay(and_const_ss_sptr self, int which, int delay)

declare_sample_delay(and_const_ss_sptr self, unsigned int delay)

and_const_ss_sptr.k(and_const_ss_sptr self) → short
and_const_ss_sptr.message_subscribers(and_const_ss_sptr self, swig_int_ptr which_port) → swig_int_ptr
and_const_ss_sptr.min_noutput_items(and_const_ss_sptr self) → int
and_const_ss_sptr.pc_input_buffers_full_avg(and_const_ss_sptr self, int which) → float

pc_input_buffers_full_avg(and_const_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(and_const_ss_sptr self) -> pmt_vector_float

and_const_ss_sptr.pc_throughput_avg(and_const_ss_sptr self) → float
and_const_ss_sptr.pc_work_time_avg(and_const_ss_sptr self) → float
and_const_ss_sptr.pc_work_time_total(and_const_ss_sptr self) → float
and_const_ss_sptr.sample_delay(and_const_ss_sptr self, int which) → unsigned int
and_const_ss_sptr.set_k(and_const_ss_sptr self, short k)
and_const_ss_sptr.set_min_noutput_items(and_const_ss_sptr self, int m)
and_const_ss_sptr.set_thread_priority(and_const_ss_sptr self, int priority) → int
and_const_ss_sptr.thread_priority(and_const_ss_sptr self) → int
gnuradio.blocks.and_ii(size_t vlen=1) → and_ii_sptr
and_ii_sptr.active_thread_priority(and_ii_sptr self) → int
and_ii_sptr.declare_sample_delay(and_ii_sptr self, int which, int delay)

declare_sample_delay(and_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(and_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(and_ii_sptr self) -> pmt_vector_float

and_ii_sptr.pc_throughput_avg(and_ii_sptr self) → float
and_ii_sptr.pc_work_time_avg(and_ii_sptr self) → float
and_ii_sptr.pc_work_time_total(and_ii_sptr self) → float
and_ii_sptr.sample_delay(and_ii_sptr self, int which) → unsigned int
and_ii_sptr.set_min_noutput_items(and_ii_sptr self, int m)
and_ii_sptr.set_thread_priority(and_ii_sptr self, int priority) → int
and_ii_sptr.thread_priority(and_ii_sptr self) → int
gnuradio.blocks.and_ss(size_t vlen=1) → and_ss_sptr
and_ss_sptr.active_thread_priority(and_ss_sptr self) → int
and_ss_sptr.declare_sample_delay(and_ss_sptr self, int which, int delay)

declare_sample_delay(and_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(and_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(and_ss_sptr self) -> pmt_vector_float

and_ss_sptr.pc_throughput_avg(and_ss_sptr self) → float
and_ss_sptr.pc_work_time_avg(and_ss_sptr self) → float
and_ss_sptr.pc_work_time_total(and_ss_sptr self) → float
and_ss_sptr.sample_delay(and_ss_sptr self, int which) → unsigned int
and_ss_sptr.set_min_noutput_items(and_ss_sptr self, int m)
and_ss_sptr.set_thread_priority(and_ss_sptr self, int priority) → int
and_ss_sptr.thread_priority(and_ss_sptr self) → int
gnuradio.blocks.annotator_1to1(int when, size_t sizeof_stream_item) → annotator_1to1_sptr
annotator_1to1_sptr.active_thread_priority(annotator_1to1_sptr self) → int
annotator_1to1_sptr.data(annotator_1to1_sptr self) → tags_vector_t
annotator_1to1_sptr.declare_sample_delay(annotator_1to1_sptr self, int which, int delay)

declare_sample_delay(annotator_1to1_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(annotator_1to1_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(annotator_1to1_sptr self) -> pmt_vector_float

annotator_1to1_sptr.pc_throughput_avg(annotator_1to1_sptr self) → float
annotator_1to1_sptr.pc_work_time_avg(annotator_1to1_sptr self) → float
annotator_1to1_sptr.pc_work_time_total(annotator_1to1_sptr self) → float
annotator_1to1_sptr.sample_delay(annotator_1to1_sptr self, int which) → unsigned int
annotator_1to1_sptr.set_min_noutput_items(annotator_1to1_sptr self, int m)
annotator_1to1_sptr.set_thread_priority(annotator_1to1_sptr self, int priority) → int
annotator_1to1_sptr.thread_priority(annotator_1to1_sptr self) → int
gnuradio.blocks.annotator_alltoall(int when, size_t sizeof_stream_item) → annotator_alltoall_sptr
annotator_alltoall_sptr.active_thread_priority(annotator_alltoall_sptr self) → int
annotator_alltoall_sptr.data(annotator_alltoall_sptr self) → tags_vector_t
annotator_alltoall_sptr.declare_sample_delay(annotator_alltoall_sptr self, int which, int delay)

declare_sample_delay(annotator_alltoall_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(annotator_alltoall_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(annotator_alltoall_sptr self) -> pmt_vector_float

annotator_alltoall_sptr.pc_throughput_avg(annotator_alltoall_sptr self) → float
annotator_alltoall_sptr.pc_work_time_avg(annotator_alltoall_sptr self) → float
annotator_alltoall_sptr.pc_work_time_total(annotator_alltoall_sptr self) → float
annotator_alltoall_sptr.sample_delay(annotator_alltoall_sptr self, int which) → unsigned int
annotator_alltoall_sptr.set_min_noutput_items(annotator_alltoall_sptr self, int m)
annotator_alltoall_sptr.set_thread_priority(annotator_alltoall_sptr self, int priority) → int
annotator_alltoall_sptr.thread_priority(annotator_alltoall_sptr self) → int
gnuradio.blocks.annotator_raw(size_t sizeof_stream_item) → annotator_raw_sptr
annotator_raw_sptr.active_thread_priority(annotator_raw_sptr self) → int
annotator_raw_sptr.add_tag(annotator_raw_sptr self, uint64_t offset, swig_int_ptr key, swig_int_ptr val)
annotator_raw_sptr.declare_sample_delay(annotator_raw_sptr self, int which, int delay)

declare_sample_delay(annotator_raw_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(annotator_raw_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(annotator_raw_sptr self) -> pmt_vector_float

annotator_raw_sptr.pc_throughput_avg(annotator_raw_sptr self) → float
annotator_raw_sptr.pc_work_time_avg(annotator_raw_sptr self) → float
annotator_raw_sptr.pc_work_time_total(annotator_raw_sptr self) → float
annotator_raw_sptr.sample_delay(annotator_raw_sptr self, int which) → unsigned int
annotator_raw_sptr.set_min_noutput_items(annotator_raw_sptr self, int m)
annotator_raw_sptr.set_thread_priority(annotator_raw_sptr self, int priority) → int
annotator_raw_sptr.thread_priority(annotator_raw_sptr self) → int
gnuradio.blocks.argmax_fs(size_t vlen) → argmax_fs_sptr
argmax_fs_sptr.active_thread_priority(argmax_fs_sptr self) → int
argmax_fs_sptr.declare_sample_delay(argmax_fs_sptr self, int which, int delay)

declare_sample_delay(argmax_fs_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(argmax_fs_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(argmax_fs_sptr self) -> pmt_vector_float

argmax_fs_sptr.pc_throughput_avg(argmax_fs_sptr self) → float
argmax_fs_sptr.pc_work_time_avg(argmax_fs_sptr self) → float
argmax_fs_sptr.pc_work_time_total(argmax_fs_sptr self) → float
argmax_fs_sptr.sample_delay(argmax_fs_sptr self, int which) → unsigned int
argmax_fs_sptr.set_min_noutput_items(argmax_fs_sptr self, int m)
argmax_fs_sptr.set_thread_priority(argmax_fs_sptr self, int priority) → int
argmax_fs_sptr.thread_priority(argmax_fs_sptr self) → int
gnuradio.blocks.argmax_is(size_t vlen) → argmax_is_sptr
argmax_is_sptr.active_thread_priority(argmax_is_sptr self) → int
argmax_is_sptr.declare_sample_delay(argmax_is_sptr self, int which, int delay)

declare_sample_delay(argmax_is_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(argmax_is_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(argmax_is_sptr self) -> pmt_vector_float

argmax_is_sptr.pc_throughput_avg(argmax_is_sptr self) → float
argmax_is_sptr.pc_work_time_avg(argmax_is_sptr self) → float
argmax_is_sptr.pc_work_time_total(argmax_is_sptr self) → float
argmax_is_sptr.sample_delay(argmax_is_sptr self, int which) → unsigned int
argmax_is_sptr.set_min_noutput_items(argmax_is_sptr self, int m)
argmax_is_sptr.set_thread_priority(argmax_is_sptr self, int priority) → int
argmax_is_sptr.thread_priority(argmax_is_sptr self) → int
gnuradio.blocks.argmax_ss(size_t vlen) → argmax_ss_sptr
argmax_ss_sptr.active_thread_priority(argmax_ss_sptr self) → int
argmax_ss_sptr.declare_sample_delay(argmax_ss_sptr self, int which, int delay)

declare_sample_delay(argmax_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(argmax_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(argmax_ss_sptr self) -> pmt_vector_float

argmax_ss_sptr.pc_throughput_avg(argmax_ss_sptr self) → float
argmax_ss_sptr.pc_work_time_avg(argmax_ss_sptr self) → float
argmax_ss_sptr.pc_work_time_total(argmax_ss_sptr self) → float
argmax_ss_sptr.sample_delay(argmax_ss_sptr self, int which) → unsigned int
argmax_ss_sptr.set_min_noutput_items(argmax_ss_sptr self, int m)
argmax_ss_sptr.set_thread_priority(argmax_ss_sptr self, int priority) → int
argmax_ss_sptr.thread_priority(argmax_ss_sptr self) → int
gnuradio.blocks.bin_statistics_f(unsigned int vlen, msg_queue_sptr msgq, gr::feval_dd * tune, size_t tune_delay, size_t dwell_delay) → bin_statistics_f_sptr
bin_statistics_f_sptr.active_thread_priority(bin_statistics_f_sptr self) → int
bin_statistics_f_sptr.declare_sample_delay(bin_statistics_f_sptr self, int which, int delay)

declare_sample_delay(bin_statistics_f_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(bin_statistics_f_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(bin_statistics_f_sptr self) -> pmt_vector_float

bin_statistics_f_sptr.pc_throughput_avg(bin_statistics_f_sptr self) → float
bin_statistics_f_sptr.pc_work_time_avg(bin_statistics_f_sptr self) → float
bin_statistics_f_sptr.pc_work_time_total(bin_statistics_f_sptr self) → float
bin_statistics_f_sptr.sample_delay(bin_statistics_f_sptr self, int which) → unsigned int
bin_statistics_f_sptr.set_min_noutput_items(bin_statistics_f_sptr self, int m)
bin_statistics_f_sptr.set_thread_priority(bin_statistics_f_sptr self, int priority) → int
bin_statistics_f_sptr.thread_priority(bin_statistics_f_sptr self) → int
gnuradio.blocks.burst_tagger(size_t itemsize) → burst_tagger_sptr
burst_tagger_sptr.active_thread_priority(burst_tagger_sptr self) → int
burst_tagger_sptr.declare_sample_delay(burst_tagger_sptr self, int which, int delay)

declare_sample_delay(burst_tagger_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(burst_tagger_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(burst_tagger_sptr self) -> pmt_vector_float

burst_tagger_sptr.pc_throughput_avg(burst_tagger_sptr self) → float
burst_tagger_sptr.pc_work_time_avg(burst_tagger_sptr self) → float
burst_tagger_sptr.pc_work_time_total(burst_tagger_sptr self) → float
burst_tagger_sptr.sample_delay(burst_tagger_sptr self, int which) → unsigned int
burst_tagger_sptr.set_false_tag(burst_tagger_sptr self, std::string const & key, bool value)
burst_tagger_sptr.set_min_noutput_items(burst_tagger_sptr self, int m)
burst_tagger_sptr.set_thread_priority(burst_tagger_sptr self, int priority) → int
burst_tagger_sptr.set_true_tag(burst_tagger_sptr self, std::string const & key, bool value)
burst_tagger_sptr.thread_priority(burst_tagger_sptr self) → int
gnuradio.blocks.char_to_float(size_t vlen=1, float scale=1.0) → char_to_float_sptr
char_to_float_sptr.active_thread_priority(char_to_float_sptr self) → int
char_to_float_sptr.declare_sample_delay(char_to_float_sptr self, int which, int delay)

declare_sample_delay(char_to_float_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(char_to_float_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(char_to_float_sptr self) -> pmt_vector_float

char_to_float_sptr.pc_throughput_avg(char_to_float_sptr self) → float
char_to_float_sptr.pc_work_time_avg(char_to_float_sptr self) → float
char_to_float_sptr.pc_work_time_total(char_to_float_sptr self) → float
char_to_float_sptr.sample_delay(char_to_float_sptr self, int which) → unsigned int
char_to_float_sptr.scale(char_to_float_sptr self) → float
char_to_float_sptr.set_min_noutput_items(char_to_float_sptr self, int m)
char_to_float_sptr.set_scale(char_to_float_sptr self, float scale)
char_to_float_sptr.set_thread_priority(char_to_float_sptr self, int priority) → int
char_to_float_sptr.thread_priority(char_to_float_sptr self) → int
gnuradio.blocks.char_to_short(size_t vlen=1) → char_to_short_sptr
char_to_short_sptr.active_thread_priority(char_to_short_sptr self) → int
char_to_short_sptr.declare_sample_delay(char_to_short_sptr self, int which, int delay)

declare_sample_delay(char_to_short_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(char_to_short_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(char_to_short_sptr self) -> pmt_vector_float

char_to_short_sptr.pc_throughput_avg(char_to_short_sptr self) → float
char_to_short_sptr.pc_work_time_avg(char_to_short_sptr self) → float
char_to_short_sptr.pc_work_time_total(char_to_short_sptr self) → float
char_to_short_sptr.sample_delay(char_to_short_sptr self, int which) → unsigned int
char_to_short_sptr.set_min_noutput_items(char_to_short_sptr self, int m)
char_to_short_sptr.set_thread_priority(char_to_short_sptr self, int priority) → int
char_to_short_sptr.thread_priority(char_to_short_sptr self) → int
gnuradio.blocks.check_lfsr_32k_s() → check_lfsr_32k_s_sptr
check_lfsr_32k_s_sptr.active_thread_priority(check_lfsr_32k_s_sptr self) → int
check_lfsr_32k_s_sptr.declare_sample_delay(check_lfsr_32k_s_sptr self, int which, int delay)

declare_sample_delay(check_lfsr_32k_s_sptr self, unsigned int delay)

check_lfsr_32k_s_sptr.message_subscribers(check_lfsr_32k_s_sptr self, swig_int_ptr which_port) → swig_int_ptr
check_lfsr_32k_s_sptr.min_noutput_items(check_lfsr_32k_s_sptr self) → int
check_lfsr_32k_s_sptr.nright(check_lfsr_32k_s_sptr self) → long
check_lfsr_32k_s_sptr.ntotal(check_lfsr_32k_s_sptr self) → long
check_lfsr_32k_s_sptr.pc_input_buffers_full_avg(check_lfsr_32k_s_sptr self, int which) → float

pc_input_buffers_full_avg(check_lfsr_32k_s_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(check_lfsr_32k_s_sptr self) -> pmt_vector_float

check_lfsr_32k_s_sptr.pc_throughput_avg(check_lfsr_32k_s_sptr self) → float
check_lfsr_32k_s_sptr.pc_work_time_avg(check_lfsr_32k_s_sptr self) → float
check_lfsr_32k_s_sptr.pc_work_time_total(check_lfsr_32k_s_sptr self) → float
check_lfsr_32k_s_sptr.runlength(check_lfsr_32k_s_sptr self) → long
check_lfsr_32k_s_sptr.sample_delay(check_lfsr_32k_s_sptr self, int which) → unsigned int
check_lfsr_32k_s_sptr.set_min_noutput_items(check_lfsr_32k_s_sptr self, int m)
check_lfsr_32k_s_sptr.set_thread_priority(check_lfsr_32k_s_sptr self, int priority) → int
check_lfsr_32k_s_sptr.thread_priority(check_lfsr_32k_s_sptr self) → int
gnuradio.blocks.complex_to_arg(size_t vlen=1) → complex_to_arg_sptr
complex_to_arg_sptr.active_thread_priority(complex_to_arg_sptr self) → int
complex_to_arg_sptr.declare_sample_delay(complex_to_arg_sptr self, int which, int delay)

declare_sample_delay(complex_to_arg_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(complex_to_arg_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(complex_to_arg_sptr self) -> pmt_vector_float

complex_to_arg_sptr.pc_throughput_avg(complex_to_arg_sptr self) → float
complex_to_arg_sptr.pc_work_time_avg(complex_to_arg_sptr self) → float
complex_to_arg_sptr.pc_work_time_total(complex_to_arg_sptr self) → float
complex_to_arg_sptr.sample_delay(complex_to_arg_sptr self, int which) → unsigned int
complex_to_arg_sptr.set_min_noutput_items(complex_to_arg_sptr self, int m)
complex_to_arg_sptr.set_thread_priority(complex_to_arg_sptr self, int priority) → int
complex_to_arg_sptr.thread_priority(complex_to_arg_sptr self) → int
gnuradio.blocks.complex_to_float(size_t vlen=1) → complex_to_float_sptr
complex_to_float_sptr.active_thread_priority(complex_to_float_sptr self) → int
complex_to_float_sptr.declare_sample_delay(complex_to_float_sptr self, int which, int delay)

declare_sample_delay(complex_to_float_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(complex_to_float_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(complex_to_float_sptr self) -> pmt_vector_float

complex_to_float_sptr.pc_throughput_avg(complex_to_float_sptr self) → float
complex_to_float_sptr.pc_work_time_avg(complex_to_float_sptr self) → float
complex_to_float_sptr.pc_work_time_total(complex_to_float_sptr self) → float
complex_to_float_sptr.sample_delay(complex_to_float_sptr self, int which) → unsigned int
complex_to_float_sptr.set_min_noutput_items(complex_to_float_sptr self, int m)
complex_to_float_sptr.set_thread_priority(complex_to_float_sptr self, int priority) → int
complex_to_float_sptr.thread_priority(complex_to_float_sptr self) → int
gnuradio.blocks.complex_to_imag(size_t vlen=1) → complex_to_imag_sptr
complex_to_imag_sptr.active_thread_priority(complex_to_imag_sptr self) → int
complex_to_imag_sptr.declare_sample_delay(complex_to_imag_sptr self, int which, int delay)

declare_sample_delay(complex_to_imag_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(complex_to_imag_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(complex_to_imag_sptr self) -> pmt_vector_float

complex_to_imag_sptr.pc_throughput_avg(complex_to_imag_sptr self) → float
complex_to_imag_sptr.pc_work_time_avg(complex_to_imag_sptr self) → float
complex_to_imag_sptr.pc_work_time_total(complex_to_imag_sptr self) → float
complex_to_imag_sptr.sample_delay(complex_to_imag_sptr self, int which) → unsigned int
complex_to_imag_sptr.set_min_noutput_items(complex_to_imag_sptr self, int m)
complex_to_imag_sptr.set_thread_priority(complex_to_imag_sptr self, int priority) → int
complex_to_imag_sptr.thread_priority(complex_to_imag_sptr self) → int
gnuradio.blocks.complex_to_interleaved_short(bool vector=False) → complex_to_interleaved_short_sptr
complex_to_interleaved_short_sptr.active_thread_priority(complex_to_interleaved_short_sptr self) → int
complex_to_interleaved_short_sptr.declare_sample_delay(complex_to_interleaved_short_sptr self, int which, int delay)

declare_sample_delay(complex_to_interleaved_short_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(complex_to_interleaved_short_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(complex_to_interleaved_short_sptr self) -> pmt_vector_float

complex_to_interleaved_short_sptr.pc_throughput_avg(complex_to_interleaved_short_sptr self) → float
complex_to_interleaved_short_sptr.pc_work_time_avg(complex_to_interleaved_short_sptr self) → float
complex_to_interleaved_short_sptr.pc_work_time_total(complex_to_interleaved_short_sptr self) → float
complex_to_interleaved_short_sptr.sample_delay(complex_to_interleaved_short_sptr self, int which) → unsigned int
complex_to_interleaved_short_sptr.set_min_noutput_items(complex_to_interleaved_short_sptr self, int m)
complex_to_interleaved_short_sptr.set_thread_priority(complex_to_interleaved_short_sptr self, int priority) → int
complex_to_interleaved_short_sptr.thread_priority(complex_to_interleaved_short_sptr self) → int
gnuradio.blocks.complex_to_mag(size_t vlen=1) → complex_to_mag_sptr
complex_to_mag_sptr.active_thread_priority(complex_to_mag_sptr self) → int
complex_to_mag_sptr.declare_sample_delay(complex_to_mag_sptr self, int which, int delay)

declare_sample_delay(complex_to_mag_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(complex_to_mag_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(complex_to_mag_sptr self) -> pmt_vector_float

complex_to_mag_sptr.pc_throughput_avg(complex_to_mag_sptr self) → float
complex_to_mag_sptr.pc_work_time_avg(complex_to_mag_sptr self) → float
complex_to_mag_sptr.pc_work_time_total(complex_to_mag_sptr self) → float
complex_to_mag_sptr.sample_delay(complex_to_mag_sptr self, int which) → unsigned int
complex_to_mag_sptr.set_min_noutput_items(complex_to_mag_sptr self, int m)
complex_to_mag_sptr.set_thread_priority(complex_to_mag_sptr self, int priority) → int
complex_to_mag_sptr.thread_priority(complex_to_mag_sptr self) → int
gnuradio.blocks.complex_to_mag_squared(size_t vlen=1) → complex_to_mag_squared_sptr
complex_to_mag_squared_sptr.active_thread_priority(complex_to_mag_squared_sptr self) → int
complex_to_mag_squared_sptr.declare_sample_delay(complex_to_mag_squared_sptr self, int which, int delay)

declare_sample_delay(complex_to_mag_squared_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(complex_to_mag_squared_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(complex_to_mag_squared_sptr self) -> pmt_vector_float

complex_to_mag_squared_sptr.pc_throughput_avg(complex_to_mag_squared_sptr self) → float
complex_to_mag_squared_sptr.pc_work_time_avg(complex_to_mag_squared_sptr self) → float
complex_to_mag_squared_sptr.pc_work_time_total(complex_to_mag_squared_sptr self) → float
complex_to_mag_squared_sptr.sample_delay(complex_to_mag_squared_sptr self, int which) → unsigned int
complex_to_mag_squared_sptr.set_min_noutput_items(complex_to_mag_squared_sptr self, int m)
complex_to_mag_squared_sptr.set_thread_priority(complex_to_mag_squared_sptr self, int priority) → int
complex_to_mag_squared_sptr.thread_priority(complex_to_mag_squared_sptr self) → int
gnuradio.blocks.complex_to_real(size_t vlen=1) → complex_to_real_sptr
complex_to_real_sptr.active_thread_priority(complex_to_real_sptr self) → int
complex_to_real_sptr.declare_sample_delay(complex_to_real_sptr self, int which, int delay)

declare_sample_delay(complex_to_real_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(complex_to_real_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(complex_to_real_sptr self) -> pmt_vector_float

complex_to_real_sptr.pc_throughput_avg(complex_to_real_sptr self) → float
complex_to_real_sptr.pc_work_time_avg(complex_to_real_sptr self) → float
complex_to_real_sptr.pc_work_time_total(complex_to_real_sptr self) → float
complex_to_real_sptr.sample_delay(complex_to_real_sptr self, int which) → unsigned int
complex_to_real_sptr.set_min_noutput_items(complex_to_real_sptr self, int m)
complex_to_real_sptr.set_thread_priority(complex_to_real_sptr self, int priority) → int
complex_to_real_sptr.thread_priority(complex_to_real_sptr self) → int
gnuradio.blocks.conjugate_cc() → conjugate_cc_sptr
conjugate_cc_sptr.active_thread_priority(conjugate_cc_sptr self) → int
conjugate_cc_sptr.declare_sample_delay(conjugate_cc_sptr self, int which, int delay)

declare_sample_delay(conjugate_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(conjugate_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(conjugate_cc_sptr self) -> pmt_vector_float

conjugate_cc_sptr.pc_throughput_avg(conjugate_cc_sptr self) → float
conjugate_cc_sptr.pc_work_time_avg(conjugate_cc_sptr self) → float
conjugate_cc_sptr.pc_work_time_total(conjugate_cc_sptr self) → float
conjugate_cc_sptr.sample_delay(conjugate_cc_sptr self, int which) → unsigned int
conjugate_cc_sptr.set_min_noutput_items(conjugate_cc_sptr self, int m)
conjugate_cc_sptr.set_thread_priority(conjugate_cc_sptr self, int priority) → int
conjugate_cc_sptr.thread_priority(conjugate_cc_sptr self) → int
gnuradio.blocks.copy(size_t itemsize) → copy_sptr
copy_sptr.active_thread_priority(copy_sptr self) → int
copy_sptr.declare_sample_delay(copy_sptr self, int which, int delay)

declare_sample_delay(copy_sptr self, unsigned int delay)

copy_sptr.enabled(copy_sptr self) → bool
copy_sptr.message_subscribers(copy_sptr self, swig_int_ptr which_port) → swig_int_ptr
copy_sptr.min_noutput_items(copy_sptr self) → int
copy_sptr.pc_input_buffers_full_avg(copy_sptr self, int which) → float

pc_input_buffers_full_avg(copy_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(copy_sptr self) -> pmt_vector_float

copy_sptr.pc_throughput_avg(copy_sptr self) → float
copy_sptr.pc_work_time_avg(copy_sptr self) → float
copy_sptr.pc_work_time_total(copy_sptr self) → float
copy_sptr.sample_delay(copy_sptr self, int which) → unsigned int
copy_sptr.set_enabled(copy_sptr self, bool enable)
copy_sptr.set_min_noutput_items(copy_sptr self, int m)
copy_sptr.set_thread_priority(copy_sptr self, int priority) → int
copy_sptr.thread_priority(copy_sptr self) → int
gnuradio.blocks.ctrlport_probe2_b(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) → ctrlport_probe2_b_sptr
ctrlport_probe2_b_sptr.active_thread_priority(ctrlport_probe2_b_sptr self) → int
ctrlport_probe2_b_sptr.declare_sample_delay(ctrlport_probe2_b_sptr self, int which, int delay)

declare_sample_delay(ctrlport_probe2_b_sptr self, unsigned int delay)

ctrlport_probe2_b_sptr.get(ctrlport_probe2_b_sptr self) → std::vector< signed char,std::allocator< signed char > >
ctrlport_probe2_b_sptr.message_subscribers(ctrlport_probe2_b_sptr self, swig_int_ptr which_port) → swig_int_ptr
ctrlport_probe2_b_sptr.min_noutput_items(ctrlport_probe2_b_sptr self) → int
ctrlport_probe2_b_sptr.pc_input_buffers_full_avg(ctrlport_probe2_b_sptr self, int which) → float

pc_input_buffers_full_avg(ctrlport_probe2_b_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ctrlport_probe2_b_sptr self) -> pmt_vector_float

ctrlport_probe2_b_sptr.pc_throughput_avg(ctrlport_probe2_b_sptr self) → float
ctrlport_probe2_b_sptr.pc_work_time_avg(ctrlport_probe2_b_sptr self) → float
ctrlport_probe2_b_sptr.pc_work_time_total(ctrlport_probe2_b_sptr self) → float
ctrlport_probe2_b_sptr.sample_delay(ctrlport_probe2_b_sptr self, int which) → unsigned int
ctrlport_probe2_b_sptr.set_length(ctrlport_probe2_b_sptr self, int len)
ctrlport_probe2_b_sptr.set_min_noutput_items(ctrlport_probe2_b_sptr self, int m)
ctrlport_probe2_b_sptr.set_thread_priority(ctrlport_probe2_b_sptr self, int priority) → int
ctrlport_probe2_b_sptr.thread_priority(ctrlport_probe2_b_sptr self) → int
gnuradio.blocks.ctrlport_probe2_c(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) → ctrlport_probe2_c_sptr
ctrlport_probe2_c_sptr.active_thread_priority(ctrlport_probe2_c_sptr self) → int
ctrlport_probe2_c_sptr.declare_sample_delay(ctrlport_probe2_c_sptr self, int which, int delay)

declare_sample_delay(ctrlport_probe2_c_sptr self, unsigned int delay)

ctrlport_probe2_c_sptr.get(ctrlport_probe2_c_sptr self) → pmt_vector_cfloat
ctrlport_probe2_c_sptr.message_subscribers(ctrlport_probe2_c_sptr self, swig_int_ptr which_port) → swig_int_ptr
ctrlport_probe2_c_sptr.min_noutput_items(ctrlport_probe2_c_sptr self) → int
ctrlport_probe2_c_sptr.pc_input_buffers_full_avg(ctrlport_probe2_c_sptr self, int which) → float

pc_input_buffers_full_avg(ctrlport_probe2_c_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ctrlport_probe2_c_sptr self) -> pmt_vector_float

ctrlport_probe2_c_sptr.pc_throughput_avg(ctrlport_probe2_c_sptr self) → float
ctrlport_probe2_c_sptr.pc_work_time_avg(ctrlport_probe2_c_sptr self) → float
ctrlport_probe2_c_sptr.pc_work_time_total(ctrlport_probe2_c_sptr self) → float
ctrlport_probe2_c_sptr.sample_delay(ctrlport_probe2_c_sptr self, int which) → unsigned int
ctrlport_probe2_c_sptr.set_length(ctrlport_probe2_c_sptr self, int len)
ctrlport_probe2_c_sptr.set_min_noutput_items(ctrlport_probe2_c_sptr self, int m)
ctrlport_probe2_c_sptr.set_thread_priority(ctrlport_probe2_c_sptr self, int priority) → int
ctrlport_probe2_c_sptr.thread_priority(ctrlport_probe2_c_sptr self) → int
gnuradio.blocks.ctrlport_probe2_f(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) → ctrlport_probe2_f_sptr
ctrlport_probe2_f_sptr.active_thread_priority(ctrlport_probe2_f_sptr self) → int
ctrlport_probe2_f_sptr.declare_sample_delay(ctrlport_probe2_f_sptr self, int which, int delay)

declare_sample_delay(ctrlport_probe2_f_sptr self, unsigned int delay)

ctrlport_probe2_f_sptr.get(ctrlport_probe2_f_sptr self) → pmt_vector_float
ctrlport_probe2_f_sptr.message_subscribers(ctrlport_probe2_f_sptr self, swig_int_ptr which_port) → swig_int_ptr
ctrlport_probe2_f_sptr.min_noutput_items(ctrlport_probe2_f_sptr self) → int
ctrlport_probe2_f_sptr.pc_input_buffers_full_avg(ctrlport_probe2_f_sptr self, int which) → float

pc_input_buffers_full_avg(ctrlport_probe2_f_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ctrlport_probe2_f_sptr self) -> pmt_vector_float

ctrlport_probe2_f_sptr.pc_throughput_avg(ctrlport_probe2_f_sptr self) → float
ctrlport_probe2_f_sptr.pc_work_time_avg(ctrlport_probe2_f_sptr self) → float
ctrlport_probe2_f_sptr.pc_work_time_total(ctrlport_probe2_f_sptr self) → float
ctrlport_probe2_f_sptr.sample_delay(ctrlport_probe2_f_sptr self, int which) → unsigned int
ctrlport_probe2_f_sptr.set_length(ctrlport_probe2_f_sptr self, int len)
ctrlport_probe2_f_sptr.set_min_noutput_items(ctrlport_probe2_f_sptr self, int m)
ctrlport_probe2_f_sptr.set_thread_priority(ctrlport_probe2_f_sptr self, int priority) → int
ctrlport_probe2_f_sptr.thread_priority(ctrlport_probe2_f_sptr self) → int
gnuradio.blocks.ctrlport_probe2_i(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) → ctrlport_probe2_i_sptr
ctrlport_probe2_i_sptr.active_thread_priority(ctrlport_probe2_i_sptr self) → int
ctrlport_probe2_i_sptr.declare_sample_delay(ctrlport_probe2_i_sptr self, int which, int delay)

declare_sample_delay(ctrlport_probe2_i_sptr self, unsigned int delay)

ctrlport_probe2_i_sptr.get(ctrlport_probe2_i_sptr self) → std::vector< int,std::allocator< int > >
ctrlport_probe2_i_sptr.message_subscribers(ctrlport_probe2_i_sptr self, swig_int_ptr which_port) → swig_int_ptr
ctrlport_probe2_i_sptr.min_noutput_items(ctrlport_probe2_i_sptr self) → int
ctrlport_probe2_i_sptr.pc_input_buffers_full_avg(ctrlport_probe2_i_sptr self, int which) → float

pc_input_buffers_full_avg(ctrlport_probe2_i_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ctrlport_probe2_i_sptr self) -> pmt_vector_float

ctrlport_probe2_i_sptr.pc_throughput_avg(ctrlport_probe2_i_sptr self) → float
ctrlport_probe2_i_sptr.pc_work_time_avg(ctrlport_probe2_i_sptr self) → float
ctrlport_probe2_i_sptr.pc_work_time_total(ctrlport_probe2_i_sptr self) → float
ctrlport_probe2_i_sptr.sample_delay(ctrlport_probe2_i_sptr self, int which) → unsigned int
ctrlport_probe2_i_sptr.set_length(ctrlport_probe2_i_sptr self, int len)
ctrlport_probe2_i_sptr.set_min_noutput_items(ctrlport_probe2_i_sptr self, int m)
ctrlport_probe2_i_sptr.set_thread_priority(ctrlport_probe2_i_sptr self, int priority) → int
ctrlport_probe2_i_sptr.thread_priority(ctrlport_probe2_i_sptr self) → int
gnuradio.blocks.ctrlport_probe2_s(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) → ctrlport_probe2_s_sptr
ctrlport_probe2_s_sptr.active_thread_priority(ctrlport_probe2_s_sptr self) → int
ctrlport_probe2_s_sptr.declare_sample_delay(ctrlport_probe2_s_sptr self, int which, int delay)

declare_sample_delay(ctrlport_probe2_s_sptr self, unsigned int delay)

ctrlport_probe2_s_sptr.get(ctrlport_probe2_s_sptr self) → std::vector< short,std::allocator< short > >
ctrlport_probe2_s_sptr.message_subscribers(ctrlport_probe2_s_sptr self, swig_int_ptr which_port) → swig_int_ptr
ctrlport_probe2_s_sptr.min_noutput_items(ctrlport_probe2_s_sptr self) → int
ctrlport_probe2_s_sptr.pc_input_buffers_full_avg(ctrlport_probe2_s_sptr self, int which) → float

pc_input_buffers_full_avg(ctrlport_probe2_s_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ctrlport_probe2_s_sptr self) -> pmt_vector_float

ctrlport_probe2_s_sptr.pc_throughput_avg(ctrlport_probe2_s_sptr self) → float
ctrlport_probe2_s_sptr.pc_work_time_avg(ctrlport_probe2_s_sptr self) → float
ctrlport_probe2_s_sptr.pc_work_time_total(ctrlport_probe2_s_sptr self) → float
ctrlport_probe2_s_sptr.sample_delay(ctrlport_probe2_s_sptr self, int which) → unsigned int
ctrlport_probe2_s_sptr.set_length(ctrlport_probe2_s_sptr self, int len)
ctrlport_probe2_s_sptr.set_min_noutput_items(ctrlport_probe2_s_sptr self, int m)
ctrlport_probe2_s_sptr.set_thread_priority(ctrlport_probe2_s_sptr self, int priority) → int
ctrlport_probe2_s_sptr.thread_priority(ctrlport_probe2_s_sptr self) → int
gnuradio.blocks.ctrlport_probe_c(std::string const & id, std::string const & desc) → ctrlport_probe_c_sptr
ctrlport_probe_c_sptr.active_thread_priority(ctrlport_probe_c_sptr self) → int
ctrlport_probe_c_sptr.declare_sample_delay(ctrlport_probe_c_sptr self, int which, int delay)

declare_sample_delay(ctrlport_probe_c_sptr self, unsigned int delay)

ctrlport_probe_c_sptr.get(ctrlport_probe_c_sptr self) → pmt_vector_cfloat
ctrlport_probe_c_sptr.message_subscribers(ctrlport_probe_c_sptr self, swig_int_ptr which_port) → swig_int_ptr
ctrlport_probe_c_sptr.min_noutput_items(ctrlport_probe_c_sptr self) → int
ctrlport_probe_c_sptr.pc_input_buffers_full_avg(ctrlport_probe_c_sptr self, int which) → float

pc_input_buffers_full_avg(ctrlport_probe_c_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ctrlport_probe_c_sptr self) -> pmt_vector_float

ctrlport_probe_c_sptr.pc_throughput_avg(ctrlport_probe_c_sptr self) → float
ctrlport_probe_c_sptr.pc_work_time_avg(ctrlport_probe_c_sptr self) → float
ctrlport_probe_c_sptr.pc_work_time_total(ctrlport_probe_c_sptr self) → float
ctrlport_probe_c_sptr.sample_delay(ctrlport_probe_c_sptr self, int which) → unsigned int
ctrlport_probe_c_sptr.set_min_noutput_items(ctrlport_probe_c_sptr self, int m)
ctrlport_probe_c_sptr.set_thread_priority(ctrlport_probe_c_sptr self, int priority) → int
ctrlport_probe_c_sptr.thread_priority(ctrlport_probe_c_sptr self) → int
gnuradio.blocks.deinterleave(size_t itemsize, unsigned int blocksize=1) → deinterleave_sptr
deinterleave_sptr.active_thread_priority(deinterleave_sptr self) → int
deinterleave_sptr.declare_sample_delay(deinterleave_sptr self, int which, int delay)

declare_sample_delay(deinterleave_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(deinterleave_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(deinterleave_sptr self) -> pmt_vector_float

deinterleave_sptr.pc_throughput_avg(deinterleave_sptr self) → float
deinterleave_sptr.pc_work_time_avg(deinterleave_sptr self) → float
deinterleave_sptr.pc_work_time_total(deinterleave_sptr self) → float
deinterleave_sptr.sample_delay(deinterleave_sptr self, int which) → unsigned int
deinterleave_sptr.set_min_noutput_items(deinterleave_sptr self, int m)
deinterleave_sptr.set_thread_priority(deinterleave_sptr self, int priority) → int
deinterleave_sptr.thread_priority(deinterleave_sptr self) → int
gnuradio.blocks.delay(size_t itemsize, int delay) → delay_sptr
delay_sptr.active_thread_priority(delay_sptr self) → int
delay_sptr.declare_sample_delay(delay_sptr self, int which, int delay)

declare_sample_delay(delay_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(delay_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(delay_sptr self) -> pmt_vector_float

delay_sptr.pc_throughput_avg(delay_sptr self) → float
delay_sptr.pc_work_time_avg(delay_sptr self) → float
delay_sptr.pc_work_time_total(delay_sptr self) → float
delay_sptr.sample_delay(delay_sptr self, int which) → unsigned int
delay_sptr.set_dly(delay_sptr self, int d)
delay_sptr.set_min_noutput_items(delay_sptr self, int m)
delay_sptr.set_thread_priority(delay_sptr self, int priority) → int
delay_sptr.thread_priority(delay_sptr self) → int
gnuradio.blocks.divide_cc(size_t vlen=1) → divide_cc_sptr
divide_cc_sptr.active_thread_priority(divide_cc_sptr self) → int
divide_cc_sptr.declare_sample_delay(divide_cc_sptr self, int which, int delay)

declare_sample_delay(divide_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(divide_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(divide_cc_sptr self) -> pmt_vector_float

divide_cc_sptr.pc_throughput_avg(divide_cc_sptr self) → float
divide_cc_sptr.pc_work_time_avg(divide_cc_sptr self) → float
divide_cc_sptr.pc_work_time_total(divide_cc_sptr self) → float
divide_cc_sptr.sample_delay(divide_cc_sptr self, int which) → unsigned int
divide_cc_sptr.set_min_noutput_items(divide_cc_sptr self, int m)
divide_cc_sptr.set_thread_priority(divide_cc_sptr self, int priority) → int
divide_cc_sptr.thread_priority(divide_cc_sptr self) → int
gnuradio.blocks.divide_ff(size_t vlen=1) → divide_ff_sptr
divide_ff_sptr.active_thread_priority(divide_ff_sptr self) → int
divide_ff_sptr.declare_sample_delay(divide_ff_sptr self, int which, int delay)

declare_sample_delay(divide_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(divide_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(divide_ff_sptr self) -> pmt_vector_float

divide_ff_sptr.pc_throughput_avg(divide_ff_sptr self) → float
divide_ff_sptr.pc_work_time_avg(divide_ff_sptr self) → float
divide_ff_sptr.pc_work_time_total(divide_ff_sptr self) → float
divide_ff_sptr.sample_delay(divide_ff_sptr self, int which) → unsigned int
divide_ff_sptr.set_min_noutput_items(divide_ff_sptr self, int m)
divide_ff_sptr.set_thread_priority(divide_ff_sptr self, int priority) → int
divide_ff_sptr.thread_priority(divide_ff_sptr self) → int
gnuradio.blocks.divide_ii(size_t vlen=1) → divide_ii_sptr
divide_ii_sptr.active_thread_priority(divide_ii_sptr self) → int
divide_ii_sptr.declare_sample_delay(divide_ii_sptr self, int which, int delay)

declare_sample_delay(divide_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(divide_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(divide_ii_sptr self) -> pmt_vector_float

divide_ii_sptr.pc_throughput_avg(divide_ii_sptr self) → float
divide_ii_sptr.pc_work_time_avg(divide_ii_sptr self) → float
divide_ii_sptr.pc_work_time_total(divide_ii_sptr self) → float
divide_ii_sptr.sample_delay(divide_ii_sptr self, int which) → unsigned int
divide_ii_sptr.set_min_noutput_items(divide_ii_sptr self, int m)
divide_ii_sptr.set_thread_priority(divide_ii_sptr self, int priority) → int
divide_ii_sptr.thread_priority(divide_ii_sptr self) → int
gnuradio.blocks.divide_ss(size_t vlen=1) → divide_ss_sptr
divide_ss_sptr.active_thread_priority(divide_ss_sptr self) → int
divide_ss_sptr.declare_sample_delay(divide_ss_sptr self, int which, int delay)

declare_sample_delay(divide_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(divide_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(divide_ss_sptr self) -> pmt_vector_float

divide_ss_sptr.pc_throughput_avg(divide_ss_sptr self) → float
divide_ss_sptr.pc_work_time_avg(divide_ss_sptr self) → float
divide_ss_sptr.pc_work_time_total(divide_ss_sptr self) → float
divide_ss_sptr.sample_delay(divide_ss_sptr self, int which) → unsigned int
divide_ss_sptr.set_min_noutput_items(divide_ss_sptr self, int m)
divide_ss_sptr.set_thread_priority(divide_ss_sptr self, int priority) → int
divide_ss_sptr.thread_priority(divide_ss_sptr self) → int
gnuradio.blocks.endian_swap(size_t item_size_bytes=1) → endian_swap_sptr
endian_swap_sptr.active_thread_priority(endian_swap_sptr self) → int
endian_swap_sptr.declare_sample_delay(endian_swap_sptr self, int which, int delay)

declare_sample_delay(endian_swap_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(endian_swap_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(endian_swap_sptr self) -> pmt_vector_float

endian_swap_sptr.pc_throughput_avg(endian_swap_sptr self) → float
endian_swap_sptr.pc_work_time_avg(endian_swap_sptr self) → float
endian_swap_sptr.pc_work_time_total(endian_swap_sptr self) → float
endian_swap_sptr.sample_delay(endian_swap_sptr self, int which) → unsigned int
endian_swap_sptr.set_min_noutput_items(endian_swap_sptr self, int m)
endian_swap_sptr.set_thread_priority(endian_swap_sptr self, int priority) → int
endian_swap_sptr.thread_priority(endian_swap_sptr self) → int
gnuradio.blocks.file_descriptor_sink(size_t itemsize, int fd) → file_descriptor_sink_sptr
file_descriptor_sink_sptr.active_thread_priority(file_descriptor_sink_sptr self) → int
file_descriptor_sink_sptr.declare_sample_delay(file_descriptor_sink_sptr self, int which, int delay)

declare_sample_delay(file_descriptor_sink_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(file_descriptor_sink_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(file_descriptor_sink_sptr self) -> pmt_vector_float

file_descriptor_sink_sptr.pc_throughput_avg(file_descriptor_sink_sptr self) → float
file_descriptor_sink_sptr.pc_work_time_avg(file_descriptor_sink_sptr self) → float
file_descriptor_sink_sptr.pc_work_time_total(file_descriptor_sink_sptr self) → float
file_descriptor_sink_sptr.sample_delay(file_descriptor_sink_sptr self, int which) → unsigned int
file_descriptor_sink_sptr.set_min_noutput_items(file_descriptor_sink_sptr self, int m)
file_descriptor_sink_sptr.set_thread_priority(file_descriptor_sink_sptr self, int priority) → int
file_descriptor_sink_sptr.thread_priority(file_descriptor_sink_sptr self) → int
gnuradio.blocks.file_descriptor_source(size_t itemsize, int fd, bool repeat=False) → file_descriptor_source_sptr
file_descriptor_source_sptr.active_thread_priority(file_descriptor_source_sptr self) → int
file_descriptor_source_sptr.declare_sample_delay(file_descriptor_source_sptr self, int which, int delay)

declare_sample_delay(file_descriptor_source_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(file_descriptor_source_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(file_descriptor_source_sptr self) -> pmt_vector_float

file_descriptor_source_sptr.pc_throughput_avg(file_descriptor_source_sptr self) → float
file_descriptor_source_sptr.pc_work_time_avg(file_descriptor_source_sptr self) → float
file_descriptor_source_sptr.pc_work_time_total(file_descriptor_source_sptr self) → float
file_descriptor_source_sptr.sample_delay(file_descriptor_source_sptr self, int which) → unsigned int
file_descriptor_source_sptr.set_min_noutput_items(file_descriptor_source_sptr self, int m)
file_descriptor_source_sptr.set_thread_priority(file_descriptor_source_sptr self, int priority) → int
file_descriptor_source_sptr.thread_priority(file_descriptor_source_sptr self) → int
gnuradio.blocks.file_meta_sink(size_t itemsize, std::string const & filename, double samp_rate=1, double relative_rate=1, gr::blocks::gr_file_types type=GR_FILE_FLOAT, bool complex=True, size_t max_segment_size=1000000, std::string const & extra_dict="", bool detached_header=False) → file_meta_sink_sptr
file_meta_sink_sptr.active_thread_priority(file_meta_sink_sptr self) → int
file_meta_sink_sptr.close(file_meta_sink_sptr self)
file_meta_sink_sptr.declare_sample_delay(file_meta_sink_sptr self, int which, int delay)

declare_sample_delay(file_meta_sink_sptr self, unsigned int delay)

file_meta_sink_sptr.do_update(file_meta_sink_sptr self)
file_meta_sink_sptr.message_subscribers(file_meta_sink_sptr self, swig_int_ptr which_port) → swig_int_ptr
file_meta_sink_sptr.min_noutput_items(file_meta_sink_sptr self) → int
file_meta_sink_sptr.open(file_meta_sink_sptr self, std::string const & filename) → bool
file_meta_sink_sptr.pc_input_buffers_full_avg(file_meta_sink_sptr self, int which) → float

pc_input_buffers_full_avg(file_meta_sink_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(file_meta_sink_sptr self) -> pmt_vector_float

file_meta_sink_sptr.pc_throughput_avg(file_meta_sink_sptr self) → float
file_meta_sink_sptr.pc_work_time_avg(file_meta_sink_sptr self) → float
file_meta_sink_sptr.pc_work_time_total(file_meta_sink_sptr self) → float
file_meta_sink_sptr.sample_delay(file_meta_sink_sptr self, int which) → unsigned int
file_meta_sink_sptr.set_min_noutput_items(file_meta_sink_sptr self, int m)
file_meta_sink_sptr.set_thread_priority(file_meta_sink_sptr self, int priority) → int
file_meta_sink_sptr.set_unbuffered(file_meta_sink_sptr self, bool unbuffered)
file_meta_sink_sptr.thread_priority(file_meta_sink_sptr self) → int
gnuradio.blocks.file_meta_source(std::string const & filename, bool repeat=False, bool detached_header=False, std::string const & hdr_filename="") → file_meta_source_sptr
file_meta_source_sptr.active_thread_priority(file_meta_source_sptr self) → int
file_meta_source_sptr.close(file_meta_source_sptr self)
file_meta_source_sptr.declare_sample_delay(file_meta_source_sptr self, int which, int delay)

declare_sample_delay(file_meta_source_sptr self, unsigned int delay)

file_meta_source_sptr.do_update(file_meta_source_sptr self)
file_meta_source_sptr.message_subscribers(file_meta_source_sptr self, swig_int_ptr which_port) → swig_int_ptr
file_meta_source_sptr.min_noutput_items(file_meta_source_sptr self) → int
file_meta_source_sptr.open(file_meta_source_sptr self, std::string const & filename, std::string const & hdr_filename="") → bool
file_meta_source_sptr.pc_input_buffers_full_avg(file_meta_source_sptr self, int which) → float

pc_input_buffers_full_avg(file_meta_source_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(file_meta_source_sptr self) -> pmt_vector_float

file_meta_source_sptr.pc_throughput_avg(file_meta_source_sptr self) → float
file_meta_source_sptr.pc_work_time_avg(file_meta_source_sptr self) → float
file_meta_source_sptr.pc_work_time_total(file_meta_source_sptr self) → float
file_meta_source_sptr.sample_delay(file_meta_source_sptr self, int which) → unsigned int
file_meta_source_sptr.set_min_noutput_items(file_meta_source_sptr self, int m)
file_meta_source_sptr.set_thread_priority(file_meta_source_sptr self, int priority) → int
file_meta_source_sptr.thread_priority(file_meta_source_sptr self) → int
gnuradio.blocks.file_sink(size_t itemsize, char const * filename, bool append=False) → file_sink_sptr
file_sink_sptr.active_thread_priority(file_sink_sptr self) → int
file_sink_sptr.close(file_sink_sptr self)
file_sink_sptr.declare_sample_delay(file_sink_sptr self, int which, int delay)

declare_sample_delay(file_sink_sptr self, unsigned int delay)

file_sink_sptr.do_update(file_sink_sptr self)
file_sink_sptr.message_subscribers(file_sink_sptr self, swig_int_ptr which_port) → swig_int_ptr
file_sink_sptr.min_noutput_items(file_sink_sptr self) → int
file_sink_sptr.open(file_sink_sptr self, char const * filename) → bool
file_sink_sptr.pc_input_buffers_full_avg(file_sink_sptr self, int which) → float

pc_input_buffers_full_avg(file_sink_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(file_sink_sptr self) -> pmt_vector_float

file_sink_sptr.pc_throughput_avg(file_sink_sptr self) → float
file_sink_sptr.pc_work_time_avg(file_sink_sptr self) → float
file_sink_sptr.pc_work_time_total(file_sink_sptr self) → float
file_sink_sptr.sample_delay(file_sink_sptr self, int which) → unsigned int
file_sink_sptr.set_min_noutput_items(file_sink_sptr self, int m)
file_sink_sptr.set_thread_priority(file_sink_sptr self, int priority) → int
file_sink_sptr.set_unbuffered(file_sink_sptr self, bool unbuffered)
file_sink_sptr.thread_priority(file_sink_sptr self) → int
gnuradio.blocks.file_source(size_t itemsize, char const * filename, bool repeat=False) → file_source_sptr
file_source_sptr.active_thread_priority(file_source_sptr self) → int
file_source_sptr.close(file_source_sptr self)
file_source_sptr.declare_sample_delay(file_source_sptr self, int which, int delay)

declare_sample_delay(file_source_sptr self, unsigned int delay)

file_source_sptr.message_subscribers(file_source_sptr self, swig_int_ptr which_port) → swig_int_ptr
file_source_sptr.min_noutput_items(file_source_sptr self) → int
file_source_sptr.open(file_source_sptr self, char const * filename, bool repeat)
file_source_sptr.pc_input_buffers_full_avg(file_source_sptr self, int which) → float

pc_input_buffers_full_avg(file_source_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(file_source_sptr self) -> pmt_vector_float

file_source_sptr.pc_throughput_avg(file_source_sptr self) → float
file_source_sptr.pc_work_time_avg(file_source_sptr self) → float
file_source_sptr.pc_work_time_total(file_source_sptr self) → float
file_source_sptr.sample_delay(file_source_sptr self, int which) → unsigned int
file_source_sptr.seek(file_source_sptr self, long seek_point, int whence) → bool
file_source_sptr.set_min_noutput_items(file_source_sptr self, int m)
file_source_sptr.set_thread_priority(file_source_sptr self, int priority) → int
file_source_sptr.thread_priority(file_source_sptr self) → int
gnuradio.blocks.float_to_char(size_t vlen=1, float scale=1.0) → float_to_char_sptr
float_to_char_sptr.active_thread_priority(float_to_char_sptr self) → int
float_to_char_sptr.declare_sample_delay(float_to_char_sptr self, int which, int delay)

declare_sample_delay(float_to_char_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(float_to_char_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(float_to_char_sptr self) -> pmt_vector_float

float_to_char_sptr.pc_throughput_avg(float_to_char_sptr self) → float
float_to_char_sptr.pc_work_time_avg(float_to_char_sptr self) → float
float_to_char_sptr.pc_work_time_total(float_to_char_sptr self) → float
float_to_char_sptr.sample_delay(float_to_char_sptr self, int which) → unsigned int
float_to_char_sptr.scale(float_to_char_sptr self) → float
float_to_char_sptr.set_min_noutput_items(float_to_char_sptr self, int m)
float_to_char_sptr.set_scale(float_to_char_sptr self, float scale)
float_to_char_sptr.set_thread_priority(float_to_char_sptr self, int priority) → int
float_to_char_sptr.thread_priority(float_to_char_sptr self) → int
gnuradio.blocks.float_to_complex(size_t vlen=1) → float_to_complex_sptr
float_to_complex_sptr.active_thread_priority(float_to_complex_sptr self) → int
float_to_complex_sptr.declare_sample_delay(float_to_complex_sptr self, int which, int delay)

declare_sample_delay(float_to_complex_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(float_to_complex_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(float_to_complex_sptr self) -> pmt_vector_float

float_to_complex_sptr.pc_throughput_avg(float_to_complex_sptr self) → float
float_to_complex_sptr.pc_work_time_avg(float_to_complex_sptr self) → float
float_to_complex_sptr.pc_work_time_total(float_to_complex_sptr self) → float
float_to_complex_sptr.sample_delay(float_to_complex_sptr self, int which) → unsigned int
float_to_complex_sptr.set_min_noutput_items(float_to_complex_sptr self, int m)
float_to_complex_sptr.set_thread_priority(float_to_complex_sptr self, int priority) → int
float_to_complex_sptr.thread_priority(float_to_complex_sptr self) → int
gnuradio.blocks.float_to_int(size_t vlen=1, float scale=1.0) → float_to_int_sptr
float_to_int_sptr.active_thread_priority(float_to_int_sptr self) → int
float_to_int_sptr.declare_sample_delay(float_to_int_sptr self, int which, int delay)

declare_sample_delay(float_to_int_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(float_to_int_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(float_to_int_sptr self) -> pmt_vector_float

float_to_int_sptr.pc_throughput_avg(float_to_int_sptr self) → float
float_to_int_sptr.pc_work_time_avg(float_to_int_sptr self) → float
float_to_int_sptr.pc_work_time_total(float_to_int_sptr self) → float
float_to_int_sptr.sample_delay(float_to_int_sptr self, int which) → unsigned int
float_to_int_sptr.scale(float_to_int_sptr self) → float
float_to_int_sptr.set_min_noutput_items(float_to_int_sptr self, int m)
float_to_int_sptr.set_scale(float_to_int_sptr self, float scale)
float_to_int_sptr.set_thread_priority(float_to_int_sptr self, int priority) → int
float_to_int_sptr.thread_priority(float_to_int_sptr self) → int
gnuradio.blocks.float_to_short(size_t vlen=1, float scale=1.0) → float_to_short_sptr
float_to_short_sptr.active_thread_priority(float_to_short_sptr self) → int
float_to_short_sptr.declare_sample_delay(float_to_short_sptr self, int which, int delay)

declare_sample_delay(float_to_short_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(float_to_short_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(float_to_short_sptr self) -> pmt_vector_float

float_to_short_sptr.pc_throughput_avg(float_to_short_sptr self) → float
float_to_short_sptr.pc_work_time_avg(float_to_short_sptr self) → float
float_to_short_sptr.pc_work_time_total(float_to_short_sptr self) → float
float_to_short_sptr.sample_delay(float_to_short_sptr self, int which) → unsigned int
float_to_short_sptr.scale(float_to_short_sptr self) → float
float_to_short_sptr.set_min_noutput_items(float_to_short_sptr self, int m)
float_to_short_sptr.set_scale(float_to_short_sptr self, float scale)
float_to_short_sptr.set_thread_priority(float_to_short_sptr self, int priority) → int
float_to_short_sptr.thread_priority(float_to_short_sptr self) → int
gnuradio.blocks.float_to_uchar() → float_to_uchar_sptr
float_to_uchar_sptr.active_thread_priority(float_to_uchar_sptr self) → int
float_to_uchar_sptr.declare_sample_delay(float_to_uchar_sptr self, int which, int delay)

declare_sample_delay(float_to_uchar_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(float_to_uchar_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(float_to_uchar_sptr self) -> pmt_vector_float

float_to_uchar_sptr.pc_throughput_avg(float_to_uchar_sptr self) → float
float_to_uchar_sptr.pc_work_time_avg(float_to_uchar_sptr self) → float
float_to_uchar_sptr.pc_work_time_total(float_to_uchar_sptr self) → float
float_to_uchar_sptr.sample_delay(float_to_uchar_sptr self, int which) → unsigned int
float_to_uchar_sptr.set_min_noutput_items(float_to_uchar_sptr self, int m)
float_to_uchar_sptr.set_thread_priority(float_to_uchar_sptr self, int priority) → int
float_to_uchar_sptr.thread_priority(float_to_uchar_sptr self) → int
gnuradio.blocks.head(size_t sizeof_stream_item, uint64_t nitems) → head_sptr
head_sptr.active_thread_priority(head_sptr self) → int
head_sptr.declare_sample_delay(head_sptr self, int which, int delay)

declare_sample_delay(head_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(head_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(head_sptr self) -> pmt_vector_float

head_sptr.pc_throughput_avg(head_sptr self) → float
head_sptr.pc_work_time_avg(head_sptr self) → float
head_sptr.pc_work_time_total(head_sptr self) → float
head_sptr.reset(head_sptr self)
head_sptr.sample_delay(head_sptr self, int which) → unsigned int
head_sptr.set_length(head_sptr self, uint64_t nitems)
head_sptr.set_min_noutput_items(head_sptr self, int m)
head_sptr.set_thread_priority(head_sptr self, int priority) → int
head_sptr.thread_priority(head_sptr self) → int
gnuradio.blocks.int_to_float(size_t vlen=1, float scale=1.0) → int_to_float_sptr
int_to_float_sptr.active_thread_priority(int_to_float_sptr self) → int
int_to_float_sptr.declare_sample_delay(int_to_float_sptr self, int which, int delay)

declare_sample_delay(int_to_float_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(int_to_float_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(int_to_float_sptr self) -> pmt_vector_float

int_to_float_sptr.pc_throughput_avg(int_to_float_sptr self) → float
int_to_float_sptr.pc_work_time_avg(int_to_float_sptr self) → float
int_to_float_sptr.pc_work_time_total(int_to_float_sptr self) → float
int_to_float_sptr.sample_delay(int_to_float_sptr self, int which) → unsigned int
int_to_float_sptr.scale(int_to_float_sptr self) → float
int_to_float_sptr.set_min_noutput_items(int_to_float_sptr self, int m)
int_to_float_sptr.set_scale(int_to_float_sptr self, float scale)
int_to_float_sptr.set_thread_priority(int_to_float_sptr self, int priority) → int
int_to_float_sptr.thread_priority(int_to_float_sptr self) → int
gnuradio.blocks.integrate_cc(int decim, int vlen=1) → integrate_cc_sptr
integrate_cc_sptr.active_thread_priority(integrate_cc_sptr self) → int
integrate_cc_sptr.declare_sample_delay(integrate_cc_sptr self, int which, int delay)

declare_sample_delay(integrate_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(integrate_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(integrate_cc_sptr self) -> pmt_vector_float

integrate_cc_sptr.pc_throughput_avg(integrate_cc_sptr self) → float
integrate_cc_sptr.pc_work_time_avg(integrate_cc_sptr self) → float
integrate_cc_sptr.pc_work_time_total(integrate_cc_sptr self) → float
integrate_cc_sptr.sample_delay(integrate_cc_sptr self, int which) → unsigned int
integrate_cc_sptr.set_min_noutput_items(integrate_cc_sptr self, int m)
integrate_cc_sptr.set_thread_priority(integrate_cc_sptr self, int priority) → int
integrate_cc_sptr.thread_priority(integrate_cc_sptr self) → int
gnuradio.blocks.integrate_ff(int decim, int vlen=1) → integrate_ff_sptr
integrate_ff_sptr.active_thread_priority(integrate_ff_sptr self) → int
integrate_ff_sptr.declare_sample_delay(integrate_ff_sptr self, int which, int delay)

declare_sample_delay(integrate_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(integrate_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(integrate_ff_sptr self) -> pmt_vector_float

integrate_ff_sptr.pc_throughput_avg(integrate_ff_sptr self) → float
integrate_ff_sptr.pc_work_time_avg(integrate_ff_sptr self) → float
integrate_ff_sptr.pc_work_time_total(integrate_ff_sptr self) → float
integrate_ff_sptr.sample_delay(integrate_ff_sptr self, int which) → unsigned int
integrate_ff_sptr.set_min_noutput_items(integrate_ff_sptr self, int m)
integrate_ff_sptr.set_thread_priority(integrate_ff_sptr self, int priority) → int
integrate_ff_sptr.thread_priority(integrate_ff_sptr self) → int
gnuradio.blocks.integrate_ii(int decim, int vlen=1) → integrate_ii_sptr
integrate_ii_sptr.active_thread_priority(integrate_ii_sptr self) → int
integrate_ii_sptr.declare_sample_delay(integrate_ii_sptr self, int which, int delay)

declare_sample_delay(integrate_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(integrate_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(integrate_ii_sptr self) -> pmt_vector_float

integrate_ii_sptr.pc_throughput_avg(integrate_ii_sptr self) → float
integrate_ii_sptr.pc_work_time_avg(integrate_ii_sptr self) → float
integrate_ii_sptr.pc_work_time_total(integrate_ii_sptr self) → float
integrate_ii_sptr.sample_delay(integrate_ii_sptr self, int which) → unsigned int
integrate_ii_sptr.set_min_noutput_items(integrate_ii_sptr self, int m)
integrate_ii_sptr.set_thread_priority(integrate_ii_sptr self, int priority) → int
integrate_ii_sptr.thread_priority(integrate_ii_sptr self) → int
gnuradio.blocks.integrate_ss(int decim, int vlen=1) → integrate_ss_sptr
integrate_ss_sptr.active_thread_priority(integrate_ss_sptr self) → int
integrate_ss_sptr.declare_sample_delay(integrate_ss_sptr self, int which, int delay)

declare_sample_delay(integrate_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(integrate_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(integrate_ss_sptr self) -> pmt_vector_float

integrate_ss_sptr.pc_throughput_avg(integrate_ss_sptr self) → float
integrate_ss_sptr.pc_work_time_avg(integrate_ss_sptr self) → float
integrate_ss_sptr.pc_work_time_total(integrate_ss_sptr self) → float
integrate_ss_sptr.sample_delay(integrate_ss_sptr self, int which) → unsigned int
integrate_ss_sptr.set_min_noutput_items(integrate_ss_sptr self, int m)
integrate_ss_sptr.set_thread_priority(integrate_ss_sptr self, int priority) → int
integrate_ss_sptr.thread_priority(integrate_ss_sptr self) → int
gnuradio.blocks.interleave(size_t itemsize, unsigned int blocksize=1) → interleave_sptr
interleave_sptr.active_thread_priority(interleave_sptr self) → int
interleave_sptr.declare_sample_delay(interleave_sptr self, int which, int delay)

declare_sample_delay(interleave_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(interleave_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(interleave_sptr self) -> pmt_vector_float

interleave_sptr.pc_throughput_avg(interleave_sptr self) → float
interleave_sptr.pc_work_time_avg(interleave_sptr self) → float
interleave_sptr.pc_work_time_total(interleave_sptr self) → float
interleave_sptr.sample_delay(interleave_sptr self, int which) → unsigned int
interleave_sptr.set_min_noutput_items(interleave_sptr self, int m)
interleave_sptr.set_thread_priority(interleave_sptr self, int priority) → int
interleave_sptr.thread_priority(interleave_sptr self) → int
gnuradio.blocks.interleaved_char_to_complex(bool vector_input=False) → interleaved_char_to_complex_sptr
interleaved_char_to_complex_sptr.active_thread_priority(interleaved_char_to_complex_sptr self) → int
interleaved_char_to_complex_sptr.declare_sample_delay(interleaved_char_to_complex_sptr self, int which, int delay)

declare_sample_delay(interleaved_char_to_complex_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(interleaved_char_to_complex_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(interleaved_char_to_complex_sptr self) -> pmt_vector_float

interleaved_char_to_complex_sptr.pc_throughput_avg(interleaved_char_to_complex_sptr self) → float
interleaved_char_to_complex_sptr.pc_work_time_avg(interleaved_char_to_complex_sptr self) → float
interleaved_char_to_complex_sptr.pc_work_time_total(interleaved_char_to_complex_sptr self) → float
interleaved_char_to_complex_sptr.sample_delay(interleaved_char_to_complex_sptr self, int which) → unsigned int
interleaved_char_to_complex_sptr.set_min_noutput_items(interleaved_char_to_complex_sptr self, int m)
interleaved_char_to_complex_sptr.set_thread_priority(interleaved_char_to_complex_sptr self, int priority) → int
interleaved_char_to_complex_sptr.thread_priority(interleaved_char_to_complex_sptr self) → int
gnuradio.blocks.interleaved_short_to_complex(bool vector_input=False, bool swap=False) → interleaved_short_to_complex_sptr
interleaved_short_to_complex_sptr.active_thread_priority(interleaved_short_to_complex_sptr self) → int
interleaved_short_to_complex_sptr.declare_sample_delay(interleaved_short_to_complex_sptr self, int which, int delay)

declare_sample_delay(interleaved_short_to_complex_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(interleaved_short_to_complex_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(interleaved_short_to_complex_sptr self) -> pmt_vector_float

interleaved_short_to_complex_sptr.pc_throughput_avg(interleaved_short_to_complex_sptr self) → float
interleaved_short_to_complex_sptr.pc_work_time_avg(interleaved_short_to_complex_sptr self) → float
interleaved_short_to_complex_sptr.pc_work_time_total(interleaved_short_to_complex_sptr self) → float
interleaved_short_to_complex_sptr.sample_delay(interleaved_short_to_complex_sptr self, int which) → unsigned int
interleaved_short_to_complex_sptr.set_min_noutput_items(interleaved_short_to_complex_sptr self, int m)
interleaved_short_to_complex_sptr.set_swap(interleaved_short_to_complex_sptr self, bool swap)
interleaved_short_to_complex_sptr.set_thread_priority(interleaved_short_to_complex_sptr self, int priority) → int
interleaved_short_to_complex_sptr.thread_priority(interleaved_short_to_complex_sptr self) → int
gnuradio.blocks.keep_m_in_n(size_t itemsize, int m, int n, int offset) → keep_m_in_n_sptr
keep_m_in_n_sptr.active_thread_priority(keep_m_in_n_sptr self) → int
keep_m_in_n_sptr.declare_sample_delay(keep_m_in_n_sptr self, int which, int delay)

declare_sample_delay(keep_m_in_n_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(keep_m_in_n_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(keep_m_in_n_sptr self) -> pmt_vector_float

keep_m_in_n_sptr.pc_throughput_avg(keep_m_in_n_sptr self) → float
keep_m_in_n_sptr.pc_work_time_avg(keep_m_in_n_sptr self) → float
keep_m_in_n_sptr.pc_work_time_total(keep_m_in_n_sptr self) → float
keep_m_in_n_sptr.sample_delay(keep_m_in_n_sptr self, int which) → unsigned int
keep_m_in_n_sptr.set_m(keep_m_in_n_sptr self, int m)
keep_m_in_n_sptr.set_min_noutput_items(keep_m_in_n_sptr self, int m)
keep_m_in_n_sptr.set_n(keep_m_in_n_sptr self, int n)
keep_m_in_n_sptr.set_offset(keep_m_in_n_sptr self, int offset)
keep_m_in_n_sptr.set_thread_priority(keep_m_in_n_sptr self, int priority) → int
keep_m_in_n_sptr.thread_priority(keep_m_in_n_sptr self) → int
gnuradio.blocks.keep_one_in_n(size_t itemsize, int n) → keep_one_in_n_sptr
keep_one_in_n_sptr.active_thread_priority(keep_one_in_n_sptr self) → int
keep_one_in_n_sptr.declare_sample_delay(keep_one_in_n_sptr self, int which, int delay)

declare_sample_delay(keep_one_in_n_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(keep_one_in_n_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(keep_one_in_n_sptr self) -> pmt_vector_float

keep_one_in_n_sptr.pc_throughput_avg(keep_one_in_n_sptr self) → float
keep_one_in_n_sptr.pc_work_time_avg(keep_one_in_n_sptr self) → float
keep_one_in_n_sptr.pc_work_time_total(keep_one_in_n_sptr self) → float
keep_one_in_n_sptr.sample_delay(keep_one_in_n_sptr self, int which) → unsigned int
keep_one_in_n_sptr.set_min_noutput_items(keep_one_in_n_sptr self, int m)
keep_one_in_n_sptr.set_n(keep_one_in_n_sptr self, int n)
keep_one_in_n_sptr.set_thread_priority(keep_one_in_n_sptr self, int priority) → int
keep_one_in_n_sptr.thread_priority(keep_one_in_n_sptr self) → int
gnuradio.blocks.lfsr_32k_source_s() → lfsr_32k_source_s_sptr
lfsr_32k_source_s_sptr.active_thread_priority(lfsr_32k_source_s_sptr self) → int
lfsr_32k_source_s_sptr.declare_sample_delay(lfsr_32k_source_s_sptr self, int which, int delay)

declare_sample_delay(lfsr_32k_source_s_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(lfsr_32k_source_s_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(lfsr_32k_source_s_sptr self) -> pmt_vector_float

lfsr_32k_source_s_sptr.pc_throughput_avg(lfsr_32k_source_s_sptr self) → float
lfsr_32k_source_s_sptr.pc_work_time_avg(lfsr_32k_source_s_sptr self) → float
lfsr_32k_source_s_sptr.pc_work_time_total(lfsr_32k_source_s_sptr self) → float
lfsr_32k_source_s_sptr.sample_delay(lfsr_32k_source_s_sptr self, int which) → unsigned int
lfsr_32k_source_s_sptr.set_min_noutput_items(lfsr_32k_source_s_sptr self, int m)
lfsr_32k_source_s_sptr.set_thread_priority(lfsr_32k_source_s_sptr self, int priority) → int
lfsr_32k_source_s_sptr.thread_priority(lfsr_32k_source_s_sptr self) → int
gnuradio.blocks.max_ff(size_t vlen, size_t vlen_out=1) → max_ff_sptr
max_ff_sptr.active_thread_priority(max_ff_sptr self) → int
max_ff_sptr.declare_sample_delay(max_ff_sptr self, int which, int delay)

declare_sample_delay(max_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(max_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(max_ff_sptr self) -> pmt_vector_float

max_ff_sptr.pc_throughput_avg(max_ff_sptr self) → float
max_ff_sptr.pc_work_time_avg(max_ff_sptr self) → float
max_ff_sptr.pc_work_time_total(max_ff_sptr self) → float
max_ff_sptr.sample_delay(max_ff_sptr self, int which) → unsigned int
max_ff_sptr.set_min_noutput_items(max_ff_sptr self, int m)
max_ff_sptr.set_thread_priority(max_ff_sptr self, int priority) → int
max_ff_sptr.thread_priority(max_ff_sptr self) → int
gnuradio.blocks.max_ii(size_t vlen, size_t vlen_out=1) → max_ii_sptr
max_ii_sptr.active_thread_priority(max_ii_sptr self) → int
max_ii_sptr.declare_sample_delay(max_ii_sptr self, int which, int delay)

declare_sample_delay(max_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(max_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(max_ii_sptr self) -> pmt_vector_float

max_ii_sptr.pc_throughput_avg(max_ii_sptr self) → float
max_ii_sptr.pc_work_time_avg(max_ii_sptr self) → float
max_ii_sptr.pc_work_time_total(max_ii_sptr self) → float
max_ii_sptr.sample_delay(max_ii_sptr self, int which) → unsigned int
max_ii_sptr.set_min_noutput_items(max_ii_sptr self, int m)
max_ii_sptr.set_thread_priority(max_ii_sptr self, int priority) → int
max_ii_sptr.thread_priority(max_ii_sptr self) → int
gnuradio.blocks.max_ss(size_t vlen, size_t vlen_out=1) → max_ss_sptr
max_ss_sptr.active_thread_priority(max_ss_sptr self) → int
max_ss_sptr.declare_sample_delay(max_ss_sptr self, int which, int delay)

declare_sample_delay(max_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(max_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(max_ss_sptr self) -> pmt_vector_float

max_ss_sptr.pc_throughput_avg(max_ss_sptr self) → float
max_ss_sptr.pc_work_time_avg(max_ss_sptr self) → float
max_ss_sptr.pc_work_time_total(max_ss_sptr self) → float
max_ss_sptr.sample_delay(max_ss_sptr self, int which) → unsigned int
max_ss_sptr.set_min_noutput_items(max_ss_sptr self, int m)
max_ss_sptr.set_thread_priority(max_ss_sptr self, int priority) → int
max_ss_sptr.thread_priority(max_ss_sptr self) → int
gnuradio.blocks.message_burst_source(size_t itemsize, int msgq_limit) → message_burst_source_sptr

make(size_t itemsize, msg_queue_sptr msgq) -> message_burst_source_sptr

message_burst_source_sptr.active_thread_priority(message_burst_source_sptr self) → int
message_burst_source_sptr.declare_sample_delay(message_burst_source_sptr self, int which, int delay)

declare_sample_delay(message_burst_source_sptr self, unsigned int delay)

message_burst_source_sptr.message_subscribers(message_burst_source_sptr self, swig_int_ptr which_port) → swig_int_ptr
message_burst_source_sptr.min_noutput_items(message_burst_source_sptr self) → int
message_burst_source_sptr.msgq(message_burst_source_sptr self) → msg_queue_sptr
message_burst_source_sptr.pc_input_buffers_full_avg(message_burst_source_sptr self, int which) → float

pc_input_buffers_full_avg(message_burst_source_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(message_burst_source_sptr self) -> pmt_vector_float

message_burst_source_sptr.pc_throughput_avg(message_burst_source_sptr self) → float
message_burst_source_sptr.pc_work_time_avg(message_burst_source_sptr self) → float
message_burst_source_sptr.pc_work_time_total(message_burst_source_sptr self) → float
message_burst_source_sptr.sample_delay(message_burst_source_sptr self, int which) → unsigned int
message_burst_source_sptr.set_min_noutput_items(message_burst_source_sptr self, int m)
message_burst_source_sptr.set_thread_priority(message_burst_source_sptr self, int priority) → int
message_burst_source_sptr.thread_priority(message_burst_source_sptr self) → int
gnuradio.blocks.message_debug() → message_debug_sptr
message_debug_sptr.active_thread_priority(message_debug_sptr self) → int
message_debug_sptr.declare_sample_delay(message_debug_sptr self, int which, int delay)

declare_sample_delay(message_debug_sptr self, unsigned int delay)

message_debug_sptr.get_message(message_debug_sptr self, int i) → swig_int_ptr
message_debug_sptr.message_subscribers(message_debug_sptr self, swig_int_ptr which_port) → swig_int_ptr
message_debug_sptr.min_noutput_items(message_debug_sptr self) → int
message_debug_sptr.num_messages(message_debug_sptr self) → int
message_debug_sptr.pc_input_buffers_full_avg(message_debug_sptr self, int which) → float

pc_input_buffers_full_avg(message_debug_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(message_debug_sptr self) -> pmt_vector_float

message_debug_sptr.pc_throughput_avg(message_debug_sptr self) → float
message_debug_sptr.pc_work_time_avg(message_debug_sptr self) → float
message_debug_sptr.pc_work_time_total(message_debug_sptr self) → float
message_debug_sptr.sample_delay(message_debug_sptr self, int which) → unsigned int
message_debug_sptr.set_min_noutput_items(message_debug_sptr self, int m)
message_debug_sptr.set_thread_priority(message_debug_sptr self, int priority) → int
message_debug_sptr.thread_priority(message_debug_sptr self) → int
gnuradio.blocks.message_sink(size_t itemsize, msg_queue_sptr msgq, bool dont_block) → message_sink_sptr

make(size_t itemsize, msg_queue_sptr msgq, bool dont_block, std::string const & lengthtagname) -> message_sink_sptr

message_sink_sptr.active_thread_priority(message_sink_sptr self) → int
message_sink_sptr.declare_sample_delay(message_sink_sptr self, int which, int delay)

declare_sample_delay(message_sink_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(message_sink_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(message_sink_sptr self) -> pmt_vector_float

message_sink_sptr.pc_throughput_avg(message_sink_sptr self) → float
message_sink_sptr.pc_work_time_avg(message_sink_sptr self) → float
message_sink_sptr.pc_work_time_total(message_sink_sptr self) → float
message_sink_sptr.sample_delay(message_sink_sptr self, int which) → unsigned int
message_sink_sptr.set_min_noutput_items(message_sink_sptr self, int m)
message_sink_sptr.set_thread_priority(message_sink_sptr self, int priority) → int
message_sink_sptr.thread_priority(message_sink_sptr self) → int
gnuradio.blocks.message_source(size_t itemsize, int msgq_limit=0) → message_source_sptr

make(size_t itemsize, msg_queue_sptr msgq) -> message_source_sptr make(size_t itemsize, msg_queue_sptr msgq, std::string const & lengthtagname) -> message_source_sptr

message_source_sptr.active_thread_priority(message_source_sptr self) → int
message_source_sptr.declare_sample_delay(message_source_sptr self, int which, int delay)

declare_sample_delay(message_source_sptr self, unsigned int delay)

message_source_sptr.message_subscribers(message_source_sptr self, swig_int_ptr which_port) → swig_int_ptr
message_source_sptr.min_noutput_items(message_source_sptr self) → int
message_source_sptr.msgq(message_source_sptr self) → msg_queue_sptr
message_source_sptr.pc_input_buffers_full_avg(message_source_sptr self, int which) → float

pc_input_buffers_full_avg(message_source_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(message_source_sptr self) -> pmt_vector_float

message_source_sptr.pc_throughput_avg(message_source_sptr self) → float
message_source_sptr.pc_work_time_avg(message_source_sptr self) → float
message_source_sptr.pc_work_time_total(message_source_sptr self) → float
message_source_sptr.sample_delay(message_source_sptr self, int which) → unsigned int
message_source_sptr.set_min_noutput_items(message_source_sptr self, int m)
message_source_sptr.set_thread_priority(message_source_sptr self, int priority) → int
message_source_sptr.thread_priority(message_source_sptr self) → int
gnuradio.blocks.message_strobe(swig_int_ptr msg, float period_ms) → message_strobe_sptr
message_strobe_sptr.active_thread_priority(message_strobe_sptr self) → int
message_strobe_sptr.declare_sample_delay(message_strobe_sptr self, int which, int delay)

declare_sample_delay(message_strobe_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(message_strobe_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(message_strobe_sptr self) -> pmt_vector_float

message_strobe_sptr.pc_throughput_avg(message_strobe_sptr self) → float
message_strobe_sptr.pc_work_time_avg(message_strobe_sptr self) → float
message_strobe_sptr.pc_work_time_total(message_strobe_sptr self) → float
message_strobe_sptr.period(message_strobe_sptr self) → float
message_strobe_sptr.sample_delay(message_strobe_sptr self, int which) → unsigned int
message_strobe_sptr.set_min_noutput_items(message_strobe_sptr self, int m)
message_strobe_sptr.set_msg(message_strobe_sptr self, swig_int_ptr msg)
message_strobe_sptr.set_period(message_strobe_sptr self, float period_ms)
message_strobe_sptr.set_thread_priority(message_strobe_sptr self, int priority) → int
message_strobe_sptr.thread_priority(message_strobe_sptr self) → int
gnuradio.blocks.message_strobe_random(swig_int_ptr msg, gr::blocks::message_strobe_random_distribution_t dist, float mean_ms, float std_ms) → message_strobe_random_sptr
message_strobe_random_sptr.active_thread_priority(message_strobe_random_sptr self) → int
message_strobe_random_sptr.declare_sample_delay(message_strobe_random_sptr self, int which, int delay)

declare_sample_delay(message_strobe_random_sptr self, unsigned int delay)

message_strobe_random_sptr.dist(message_strobe_random_sptr self) → gr::blocks::message_strobe_random_distribution_t
message_strobe_random_sptr.mean(message_strobe_random_sptr self) → float
message_strobe_random_sptr.message_subscribers(message_strobe_random_sptr self, swig_int_ptr which_port) → swig_int_ptr
message_strobe_random_sptr.min_noutput_items(message_strobe_random_sptr self) → int
message_strobe_random_sptr.msg(message_strobe_random_sptr self) → swig_int_ptr
message_strobe_random_sptr.pc_input_buffers_full_avg(message_strobe_random_sptr self, int which) → float

pc_input_buffers_full_avg(message_strobe_random_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(message_strobe_random_sptr self) -> pmt_vector_float

message_strobe_random_sptr.pc_throughput_avg(message_strobe_random_sptr self) → float
message_strobe_random_sptr.pc_work_time_avg(message_strobe_random_sptr self) → float
message_strobe_random_sptr.pc_work_time_total(message_strobe_random_sptr self) → float
message_strobe_random_sptr.sample_delay(message_strobe_random_sptr self, int which) → unsigned int
message_strobe_random_sptr.set_dist(message_strobe_random_sptr self, gr::blocks::message_strobe_random_distribution_t dist)
message_strobe_random_sptr.set_mean(message_strobe_random_sptr self, float mean)
message_strobe_random_sptr.set_min_noutput_items(message_strobe_random_sptr self, int m)
message_strobe_random_sptr.set_msg(message_strobe_random_sptr self, swig_int_ptr msg)
message_strobe_random_sptr.set_std(message_strobe_random_sptr self, float std)
message_strobe_random_sptr.set_thread_priority(message_strobe_random_sptr self, int priority) → int
message_strobe_random_sptr.std(message_strobe_random_sptr self) → float
message_strobe_random_sptr.thread_priority(message_strobe_random_sptr self) → int
gnuradio.blocks.min_ff(size_t vlen, size_t vlen_out=1) → min_ff_sptr
min_ff_sptr.active_thread_priority(min_ff_sptr self) → int
min_ff_sptr.declare_sample_delay(min_ff_sptr self, int which, int delay)

declare_sample_delay(min_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(min_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(min_ff_sptr self) -> pmt_vector_float

min_ff_sptr.pc_throughput_avg(min_ff_sptr self) → float
min_ff_sptr.pc_work_time_avg(min_ff_sptr self) → float
min_ff_sptr.pc_work_time_total(min_ff_sptr self) → float
min_ff_sptr.sample_delay(min_ff_sptr self, int which) → unsigned int
min_ff_sptr.set_min_noutput_items(min_ff_sptr self, int m)
min_ff_sptr.set_thread_priority(min_ff_sptr self, int priority) → int
min_ff_sptr.thread_priority(min_ff_sptr self) → int
gnuradio.blocks.min_ii(size_t vlen, size_t vlen_out=1) → min_ii_sptr
min_ii_sptr.active_thread_priority(min_ii_sptr self) → int
min_ii_sptr.declare_sample_delay(min_ii_sptr self, int which, int delay)

declare_sample_delay(min_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(min_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(min_ii_sptr self) -> pmt_vector_float

min_ii_sptr.pc_throughput_avg(min_ii_sptr self) → float
min_ii_sptr.pc_work_time_avg(min_ii_sptr self) → float
min_ii_sptr.pc_work_time_total(min_ii_sptr self) → float
min_ii_sptr.sample_delay(min_ii_sptr self, int which) → unsigned int
min_ii_sptr.set_min_noutput_items(min_ii_sptr self, int m)
min_ii_sptr.set_thread_priority(min_ii_sptr self, int priority) → int
min_ii_sptr.thread_priority(min_ii_sptr self) → int
gnuradio.blocks.min_ss(size_t vlen, size_t vlen_out=1) → min_ss_sptr
min_ss_sptr.active_thread_priority(min_ss_sptr self) → int
min_ss_sptr.declare_sample_delay(min_ss_sptr self, int which, int delay)

declare_sample_delay(min_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(min_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(min_ss_sptr self) -> pmt_vector_float

min_ss_sptr.pc_throughput_avg(min_ss_sptr self) → float
min_ss_sptr.pc_work_time_avg(min_ss_sptr self) → float
min_ss_sptr.pc_work_time_total(min_ss_sptr self) → float
min_ss_sptr.sample_delay(min_ss_sptr self, int which) → unsigned int
min_ss_sptr.set_min_noutput_items(min_ss_sptr self, int m)
min_ss_sptr.set_thread_priority(min_ss_sptr self, int priority) → int
min_ss_sptr.thread_priority(min_ss_sptr self) → int
gnuradio.blocks.moving_average_cc(int length, gr_complex scale, int max_iter=4096) → moving_average_cc_sptr
moving_average_cc_sptr.active_thread_priority(moving_average_cc_sptr self) → int
moving_average_cc_sptr.declare_sample_delay(moving_average_cc_sptr self, int which, int delay)

declare_sample_delay(moving_average_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(moving_average_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(moving_average_cc_sptr self) -> pmt_vector_float

moving_average_cc_sptr.pc_throughput_avg(moving_average_cc_sptr self) → float
moving_average_cc_sptr.pc_work_time_avg(moving_average_cc_sptr self) → float
moving_average_cc_sptr.pc_work_time_total(moving_average_cc_sptr self) → float
moving_average_cc_sptr.sample_delay(moving_average_cc_sptr self, int which) → unsigned int
moving_average_cc_sptr.scale(moving_average_cc_sptr self) → gr_complex
moving_average_cc_sptr.set_length(moving_average_cc_sptr self, int length)
moving_average_cc_sptr.set_length_and_scale(moving_average_cc_sptr self, int length, gr_complex scale)
moving_average_cc_sptr.set_min_noutput_items(moving_average_cc_sptr self, int m)
moving_average_cc_sptr.set_scale(moving_average_cc_sptr self, gr_complex scale)
moving_average_cc_sptr.set_thread_priority(moving_average_cc_sptr self, int priority) → int
moving_average_cc_sptr.thread_priority(moving_average_cc_sptr self) → int
gnuradio.blocks.moving_average_ff(int length, float scale, int max_iter=4096) → moving_average_ff_sptr
moving_average_ff_sptr.active_thread_priority(moving_average_ff_sptr self) → int
moving_average_ff_sptr.declare_sample_delay(moving_average_ff_sptr self, int which, int delay)

declare_sample_delay(moving_average_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(moving_average_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(moving_average_ff_sptr self) -> pmt_vector_float

moving_average_ff_sptr.pc_throughput_avg(moving_average_ff_sptr self) → float
moving_average_ff_sptr.pc_work_time_avg(moving_average_ff_sptr self) → float
moving_average_ff_sptr.pc_work_time_total(moving_average_ff_sptr self) → float
moving_average_ff_sptr.sample_delay(moving_average_ff_sptr self, int which) → unsigned int
moving_average_ff_sptr.scale(moving_average_ff_sptr self) → float
moving_average_ff_sptr.set_length(moving_average_ff_sptr self, int length)
moving_average_ff_sptr.set_length_and_scale(moving_average_ff_sptr self, int length, float scale)
moving_average_ff_sptr.set_min_noutput_items(moving_average_ff_sptr self, int m)
moving_average_ff_sptr.set_scale(moving_average_ff_sptr self, float scale)
moving_average_ff_sptr.set_thread_priority(moving_average_ff_sptr self, int priority) → int
moving_average_ff_sptr.thread_priority(moving_average_ff_sptr self) → int
gnuradio.blocks.moving_average_ii(int length, int scale, int max_iter=4096) → moving_average_ii_sptr
moving_average_ii_sptr.active_thread_priority(moving_average_ii_sptr self) → int
moving_average_ii_sptr.declare_sample_delay(moving_average_ii_sptr self, int which, int delay)

declare_sample_delay(moving_average_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(moving_average_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(moving_average_ii_sptr self) -> pmt_vector_float

moving_average_ii_sptr.pc_throughput_avg(moving_average_ii_sptr self) → float
moving_average_ii_sptr.pc_work_time_avg(moving_average_ii_sptr self) → float
moving_average_ii_sptr.pc_work_time_total(moving_average_ii_sptr self) → float
moving_average_ii_sptr.sample_delay(moving_average_ii_sptr self, int which) → unsigned int
moving_average_ii_sptr.scale(moving_average_ii_sptr self) → int
moving_average_ii_sptr.set_length(moving_average_ii_sptr self, int length)
moving_average_ii_sptr.set_length_and_scale(moving_average_ii_sptr self, int length, int scale)
moving_average_ii_sptr.set_min_noutput_items(moving_average_ii_sptr self, int m)
moving_average_ii_sptr.set_scale(moving_average_ii_sptr self, int scale)
moving_average_ii_sptr.set_thread_priority(moving_average_ii_sptr self, int priority) → int
moving_average_ii_sptr.thread_priority(moving_average_ii_sptr self) → int
gnuradio.blocks.moving_average_ss(int length, short scale, int max_iter=4096) → moving_average_ss_sptr
moving_average_ss_sptr.active_thread_priority(moving_average_ss_sptr self) → int
moving_average_ss_sptr.declare_sample_delay(moving_average_ss_sptr self, int which, int delay)

declare_sample_delay(moving_average_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(moving_average_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(moving_average_ss_sptr self) -> pmt_vector_float

moving_average_ss_sptr.pc_throughput_avg(moving_average_ss_sptr self) → float
moving_average_ss_sptr.pc_work_time_avg(moving_average_ss_sptr self) → float
moving_average_ss_sptr.pc_work_time_total(moving_average_ss_sptr self) → float
moving_average_ss_sptr.sample_delay(moving_average_ss_sptr self, int which) → unsigned int
moving_average_ss_sptr.scale(moving_average_ss_sptr self) → short
moving_average_ss_sptr.set_length(moving_average_ss_sptr self, int length)
moving_average_ss_sptr.set_length_and_scale(moving_average_ss_sptr self, int length, short scale)
moving_average_ss_sptr.set_min_noutput_items(moving_average_ss_sptr self, int m)
moving_average_ss_sptr.set_scale(moving_average_ss_sptr self, short scale)
moving_average_ss_sptr.set_thread_priority(moving_average_ss_sptr self, int priority) → int
moving_average_ss_sptr.thread_priority(moving_average_ss_sptr self) → int
gnuradio.blocks.multiply_cc(size_t vlen=1) → multiply_cc_sptr
multiply_cc_sptr.active_thread_priority(multiply_cc_sptr self) → int
multiply_cc_sptr.declare_sample_delay(multiply_cc_sptr self, int which, int delay)

declare_sample_delay(multiply_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(multiply_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_cc_sptr self) -> pmt_vector_float

multiply_cc_sptr.pc_throughput_avg(multiply_cc_sptr self) → float
multiply_cc_sptr.pc_work_time_avg(multiply_cc_sptr self) → float
multiply_cc_sptr.pc_work_time_total(multiply_cc_sptr self) → float
multiply_cc_sptr.sample_delay(multiply_cc_sptr self, int which) → unsigned int
multiply_cc_sptr.set_min_noutput_items(multiply_cc_sptr self, int m)
multiply_cc_sptr.set_thread_priority(multiply_cc_sptr self, int priority) → int
multiply_cc_sptr.thread_priority(multiply_cc_sptr self) → int
gnuradio.blocks.multiply_conjugate_cc(size_t vlen=1) → multiply_conjugate_cc_sptr
multiply_conjugate_cc_sptr.active_thread_priority(multiply_conjugate_cc_sptr self) → int
multiply_conjugate_cc_sptr.declare_sample_delay(multiply_conjugate_cc_sptr self, int which, int delay)

declare_sample_delay(multiply_conjugate_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(multiply_conjugate_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_conjugate_cc_sptr self) -> pmt_vector_float

multiply_conjugate_cc_sptr.pc_throughput_avg(multiply_conjugate_cc_sptr self) → float
multiply_conjugate_cc_sptr.pc_work_time_avg(multiply_conjugate_cc_sptr self) → float
multiply_conjugate_cc_sptr.pc_work_time_total(multiply_conjugate_cc_sptr self) → float
multiply_conjugate_cc_sptr.sample_delay(multiply_conjugate_cc_sptr self, int which) → unsigned int
multiply_conjugate_cc_sptr.set_min_noutput_items(multiply_conjugate_cc_sptr self, int m)
multiply_conjugate_cc_sptr.set_thread_priority(multiply_conjugate_cc_sptr self, int priority) → int
multiply_conjugate_cc_sptr.thread_priority(multiply_conjugate_cc_sptr self) → int
gnuradio.blocks.multiply_const_cc(gr_complex k, size_t vlen=1) → multiply_const_cc_sptr
multiply_const_cc_sptr.active_thread_priority(multiply_const_cc_sptr self) → int
multiply_const_cc_sptr.declare_sample_delay(multiply_const_cc_sptr self, int which, int delay)

declare_sample_delay(multiply_const_cc_sptr self, unsigned int delay)

multiply_const_cc_sptr.k(multiply_const_cc_sptr self) → gr_complex
multiply_const_cc_sptr.message_subscribers(multiply_const_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr
multiply_const_cc_sptr.min_noutput_items(multiply_const_cc_sptr self) → int
multiply_const_cc_sptr.pc_input_buffers_full_avg(multiply_const_cc_sptr self, int which) → float

pc_input_buffers_full_avg(multiply_const_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_const_cc_sptr self) -> pmt_vector_float

multiply_const_cc_sptr.pc_throughput_avg(multiply_const_cc_sptr self) → float
multiply_const_cc_sptr.pc_work_time_avg(multiply_const_cc_sptr self) → float
multiply_const_cc_sptr.pc_work_time_total(multiply_const_cc_sptr self) → float
multiply_const_cc_sptr.sample_delay(multiply_const_cc_sptr self, int which) → unsigned int
multiply_const_cc_sptr.set_k(multiply_const_cc_sptr self, gr_complex k)
multiply_const_cc_sptr.set_min_noutput_items(multiply_const_cc_sptr self, int m)
multiply_const_cc_sptr.set_thread_priority(multiply_const_cc_sptr self, int priority) → int
multiply_const_cc_sptr.thread_priority(multiply_const_cc_sptr self) → int
gnuradio.blocks.multiply_const_ff(float k, size_t vlen=1) → multiply_const_ff_sptr
multiply_const_ff_sptr.active_thread_priority(multiply_const_ff_sptr self) → int
multiply_const_ff_sptr.declare_sample_delay(multiply_const_ff_sptr self, int which, int delay)

declare_sample_delay(multiply_const_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(multiply_const_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_const_ff_sptr self) -> pmt_vector_float

multiply_const_ff_sptr.pc_throughput_avg(multiply_const_ff_sptr self) → float
multiply_const_ff_sptr.pc_work_time_avg(multiply_const_ff_sptr self) → float
multiply_const_ff_sptr.pc_work_time_total(multiply_const_ff_sptr self) → float
multiply_const_ff_sptr.sample_delay(multiply_const_ff_sptr self, int which) → unsigned int
multiply_const_ff_sptr.set_k(multiply_const_ff_sptr self, float k)
multiply_const_ff_sptr.set_min_noutput_items(multiply_const_ff_sptr self, int m)
multiply_const_ff_sptr.set_thread_priority(multiply_const_ff_sptr self, int priority) → int
multiply_const_ff_sptr.thread_priority(multiply_const_ff_sptr self) → int
gnuradio.blocks.multiply_const_ii(int k) → multiply_const_ii_sptr
multiply_const_ii_sptr.active_thread_priority(multiply_const_ii_sptr self) → int
multiply_const_ii_sptr.declare_sample_delay(multiply_const_ii_sptr self, int which, int delay)

declare_sample_delay(multiply_const_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(multiply_const_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_const_ii_sptr self) -> pmt_vector_float

multiply_const_ii_sptr.pc_throughput_avg(multiply_const_ii_sptr self) → float
multiply_const_ii_sptr.pc_work_time_avg(multiply_const_ii_sptr self) → float
multiply_const_ii_sptr.pc_work_time_total(multiply_const_ii_sptr self) → float
multiply_const_ii_sptr.sample_delay(multiply_const_ii_sptr self, int which) → unsigned int
multiply_const_ii_sptr.set_k(multiply_const_ii_sptr self, int k)
multiply_const_ii_sptr.set_min_noutput_items(multiply_const_ii_sptr self, int m)
multiply_const_ii_sptr.set_thread_priority(multiply_const_ii_sptr self, int priority) → int
multiply_const_ii_sptr.thread_priority(multiply_const_ii_sptr self) → int
gnuradio.blocks.multiply_const_ss(short k) → multiply_const_ss_sptr
multiply_const_ss_sptr.active_thread_priority(multiply_const_ss_sptr self) → int
multiply_const_ss_sptr.declare_sample_delay(multiply_const_ss_sptr self, int which, int delay)

declare_sample_delay(multiply_const_ss_sptr self, unsigned int delay)

multiply_const_ss_sptr.k(multiply_const_ss_sptr self) → short
multiply_const_ss_sptr.message_subscribers(multiply_const_ss_sptr self, swig_int_ptr which_port) → swig_int_ptr
multiply_const_ss_sptr.min_noutput_items(multiply_const_ss_sptr self) → int
multiply_const_ss_sptr.pc_input_buffers_full_avg(multiply_const_ss_sptr self, int which) → float

pc_input_buffers_full_avg(multiply_const_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_const_ss_sptr self) -> pmt_vector_float

multiply_const_ss_sptr.pc_throughput_avg(multiply_const_ss_sptr self) → float
multiply_const_ss_sptr.pc_work_time_avg(multiply_const_ss_sptr self) → float
multiply_const_ss_sptr.pc_work_time_total(multiply_const_ss_sptr self) → float
multiply_const_ss_sptr.sample_delay(multiply_const_ss_sptr self, int which) → unsigned int
multiply_const_ss_sptr.set_k(multiply_const_ss_sptr self, short k)
multiply_const_ss_sptr.set_min_noutput_items(multiply_const_ss_sptr self, int m)
multiply_const_ss_sptr.set_thread_priority(multiply_const_ss_sptr self, int priority) → int
multiply_const_ss_sptr.thread_priority(multiply_const_ss_sptr self) → int
gnuradio.blocks.multiply_const_vcc(pmt_vector_cfloat k) → multiply_const_vcc_sptr
multiply_const_vcc_sptr.active_thread_priority(multiply_const_vcc_sptr self) → int
multiply_const_vcc_sptr.declare_sample_delay(multiply_const_vcc_sptr self, int which, int delay)

declare_sample_delay(multiply_const_vcc_sptr self, unsigned int delay)

multiply_const_vcc_sptr.k(multiply_const_vcc_sptr self) → pmt_vector_cfloat
multiply_const_vcc_sptr.message_subscribers(multiply_const_vcc_sptr self, swig_int_ptr which_port) → swig_int_ptr
multiply_const_vcc_sptr.min_noutput_items(multiply_const_vcc_sptr self) → int
multiply_const_vcc_sptr.pc_input_buffers_full_avg(multiply_const_vcc_sptr self, int which) → float

pc_input_buffers_full_avg(multiply_const_vcc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_const_vcc_sptr self) -> pmt_vector_float

multiply_const_vcc_sptr.pc_throughput_avg(multiply_const_vcc_sptr self) → float
multiply_const_vcc_sptr.pc_work_time_avg(multiply_const_vcc_sptr self) → float
multiply_const_vcc_sptr.pc_work_time_total(multiply_const_vcc_sptr self) → float
multiply_const_vcc_sptr.sample_delay(multiply_const_vcc_sptr self, int which) → unsigned int
multiply_const_vcc_sptr.set_k(multiply_const_vcc_sptr self, pmt_vector_cfloat k)
multiply_const_vcc_sptr.set_min_noutput_items(multiply_const_vcc_sptr self, int m)
multiply_const_vcc_sptr.set_thread_priority(multiply_const_vcc_sptr self, int priority) → int
multiply_const_vcc_sptr.thread_priority(multiply_const_vcc_sptr self) → int
gnuradio.blocks.multiply_const_vff(pmt_vector_float k) → multiply_const_vff_sptr
multiply_const_vff_sptr.active_thread_priority(multiply_const_vff_sptr self) → int
multiply_const_vff_sptr.declare_sample_delay(multiply_const_vff_sptr self, int which, int delay)

declare_sample_delay(multiply_const_vff_sptr self, unsigned int delay)

multiply_const_vff_sptr.k(multiply_const_vff_sptr self) → pmt_vector_float
multiply_const_vff_sptr.message_subscribers(multiply_const_vff_sptr self, swig_int_ptr which_port) → swig_int_ptr
multiply_const_vff_sptr.min_noutput_items(multiply_const_vff_sptr self) → int
multiply_const_vff_sptr.pc_input_buffers_full_avg(multiply_const_vff_sptr self, int which) → float

pc_input_buffers_full_avg(multiply_const_vff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_const_vff_sptr self) -> pmt_vector_float

multiply_const_vff_sptr.pc_throughput_avg(multiply_const_vff_sptr self) → float
multiply_const_vff_sptr.pc_work_time_avg(multiply_const_vff_sptr self) → float
multiply_const_vff_sptr.pc_work_time_total(multiply_const_vff_sptr self) → float
multiply_const_vff_sptr.sample_delay(multiply_const_vff_sptr self, int which) → unsigned int
multiply_const_vff_sptr.set_k(multiply_const_vff_sptr self, pmt_vector_float k)
multiply_const_vff_sptr.set_min_noutput_items(multiply_const_vff_sptr self, int m)
multiply_const_vff_sptr.set_thread_priority(multiply_const_vff_sptr self, int priority) → int
multiply_const_vff_sptr.thread_priority(multiply_const_vff_sptr self) → int
gnuradio.blocks.multiply_const_vii(std::vector< int, std::allocator< int > > k) → multiply_const_vii_sptr
multiply_const_vii_sptr.active_thread_priority(multiply_const_vii_sptr self) → int
multiply_const_vii_sptr.declare_sample_delay(multiply_const_vii_sptr self, int which, int delay)

declare_sample_delay(multiply_const_vii_sptr self, unsigned int delay)

multiply_const_vii_sptr.k(multiply_const_vii_sptr self) → std::vector< int,std::allocator< int > >
multiply_const_vii_sptr.message_subscribers(multiply_const_vii_sptr self, swig_int_ptr which_port) → swig_int_ptr
multiply_const_vii_sptr.min_noutput_items(multiply_const_vii_sptr self) → int
multiply_const_vii_sptr.pc_input_buffers_full_avg(multiply_const_vii_sptr self, int which) → float

pc_input_buffers_full_avg(multiply_const_vii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_const_vii_sptr self) -> pmt_vector_float

multiply_const_vii_sptr.pc_throughput_avg(multiply_const_vii_sptr self) → float
multiply_const_vii_sptr.pc_work_time_avg(multiply_const_vii_sptr self) → float
multiply_const_vii_sptr.pc_work_time_total(multiply_const_vii_sptr self) → float
multiply_const_vii_sptr.sample_delay(multiply_const_vii_sptr self, int which) → unsigned int
multiply_const_vii_sptr.set_k(multiply_const_vii_sptr self, std::vector< int, std::allocator< int > > k)
multiply_const_vii_sptr.set_min_noutput_items(multiply_const_vii_sptr self, int m)
multiply_const_vii_sptr.set_thread_priority(multiply_const_vii_sptr self, int priority) → int
multiply_const_vii_sptr.thread_priority(multiply_const_vii_sptr self) → int
gnuradio.blocks.multiply_const_vss(std::vector< short, std::allocator< short > > k) → multiply_const_vss_sptr
multiply_const_vss_sptr.active_thread_priority(multiply_const_vss_sptr self) → int
multiply_const_vss_sptr.declare_sample_delay(multiply_const_vss_sptr self, int which, int delay)

declare_sample_delay(multiply_const_vss_sptr self, unsigned int delay)

multiply_const_vss_sptr.k(multiply_const_vss_sptr self) → std::vector< short,std::allocator< short > >
multiply_const_vss_sptr.message_subscribers(multiply_const_vss_sptr self, swig_int_ptr which_port) → swig_int_ptr
multiply_const_vss_sptr.min_noutput_items(multiply_const_vss_sptr self) → int
multiply_const_vss_sptr.pc_input_buffers_full_avg(multiply_const_vss_sptr self, int which) → float

pc_input_buffers_full_avg(multiply_const_vss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_const_vss_sptr self) -> pmt_vector_float

multiply_const_vss_sptr.pc_throughput_avg(multiply_const_vss_sptr self) → float
multiply_const_vss_sptr.pc_work_time_avg(multiply_const_vss_sptr self) → float
multiply_const_vss_sptr.pc_work_time_total(multiply_const_vss_sptr self) → float
multiply_const_vss_sptr.sample_delay(multiply_const_vss_sptr self, int which) → unsigned int
multiply_const_vss_sptr.set_k(multiply_const_vss_sptr self, std::vector< short, std::allocator< short > > k)
multiply_const_vss_sptr.set_min_noutput_items(multiply_const_vss_sptr self, int m)
multiply_const_vss_sptr.set_thread_priority(multiply_const_vss_sptr self, int priority) → int
multiply_const_vss_sptr.thread_priority(multiply_const_vss_sptr self) → int
gnuradio.blocks.multiply_ff(size_t vlen=1) → multiply_ff_sptr
multiply_ff_sptr.active_thread_priority(multiply_ff_sptr self) → int
multiply_ff_sptr.declare_sample_delay(multiply_ff_sptr self, int which, int delay)

declare_sample_delay(multiply_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(multiply_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_ff_sptr self) -> pmt_vector_float

multiply_ff_sptr.pc_throughput_avg(multiply_ff_sptr self) → float
multiply_ff_sptr.pc_work_time_avg(multiply_ff_sptr self) → float
multiply_ff_sptr.pc_work_time_total(multiply_ff_sptr self) → float
multiply_ff_sptr.sample_delay(multiply_ff_sptr self, int which) → unsigned int
multiply_ff_sptr.set_min_noutput_items(multiply_ff_sptr self, int m)
multiply_ff_sptr.set_thread_priority(multiply_ff_sptr self, int priority) → int
multiply_ff_sptr.thread_priority(multiply_ff_sptr self) → int
gnuradio.blocks.multiply_ii(size_t vlen=1) → multiply_ii_sptr
multiply_ii_sptr.active_thread_priority(multiply_ii_sptr self) → int
multiply_ii_sptr.declare_sample_delay(multiply_ii_sptr self, int which, int delay)

declare_sample_delay(multiply_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(multiply_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_ii_sptr self) -> pmt_vector_float

multiply_ii_sptr.pc_throughput_avg(multiply_ii_sptr self) → float
multiply_ii_sptr.pc_work_time_avg(multiply_ii_sptr self) → float
multiply_ii_sptr.pc_work_time_total(multiply_ii_sptr self) → float
multiply_ii_sptr.sample_delay(multiply_ii_sptr self, int which) → unsigned int
multiply_ii_sptr.set_min_noutput_items(multiply_ii_sptr self, int m)
multiply_ii_sptr.set_thread_priority(multiply_ii_sptr self, int priority) → int
multiply_ii_sptr.thread_priority(multiply_ii_sptr self) → int
gnuradio.blocks.multiply_matrix_ff(std::vector< std::vector< float, std::allocator< float > >, std::allocator< std::vector< float, std::allocator< float > > > > A, gr::block::tag_propagation_policy_t tag_propagation_policy=gr::block::TPP_ALL_TO_ALL) → multiply_matrix_ff_sptr
multiply_matrix_ff_sptr.MSG_PORT_NAME_SET_A(multiply_matrix_ff_sptr self) → std::string const &
multiply_matrix_ff_sptr.TPP_SELECT_BY_MATRIX(multiply_matrix_ff_sptr self) → int const
multiply_matrix_ff_sptr.active_thread_priority(multiply_matrix_ff_sptr self) → int
multiply_matrix_ff_sptr.declare_sample_delay(multiply_matrix_ff_sptr self, int which, int delay)

declare_sample_delay(multiply_matrix_ff_sptr self, unsigned int delay)

multiply_matrix_ff_sptr.get_A(multiply_matrix_ff_sptr self) → std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &
multiply_matrix_ff_sptr.message_subscribers(multiply_matrix_ff_sptr self, swig_int_ptr which_port) → swig_int_ptr
multiply_matrix_ff_sptr.min_noutput_items(multiply_matrix_ff_sptr self) → int
multiply_matrix_ff_sptr.pc_input_buffers_full_avg(multiply_matrix_ff_sptr self, int which) → float

pc_input_buffers_full_avg(multiply_matrix_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_matrix_ff_sptr self) -> pmt_vector_float

multiply_matrix_ff_sptr.pc_throughput_avg(multiply_matrix_ff_sptr self) → float
multiply_matrix_ff_sptr.pc_work_time_avg(multiply_matrix_ff_sptr self) → float
multiply_matrix_ff_sptr.pc_work_time_total(multiply_matrix_ff_sptr self) → float
multiply_matrix_ff_sptr.sample_delay(multiply_matrix_ff_sptr self, int which) → unsigned int
multiply_matrix_ff_sptr.set_A(multiply_matrix_ff_sptr self, std::vector< std::vector< float, std::allocator< float > >, std::allocator< std::vector< float, std::allocator< float > > > > const & new_A) → bool
multiply_matrix_ff_sptr.set_min_noutput_items(multiply_matrix_ff_sptr self, int m)
multiply_matrix_ff_sptr.set_tag_propagation_policy(multiply_matrix_ff_sptr self, gr::block::tag_propagation_policy_t p)
multiply_matrix_ff_sptr.set_thread_priority(multiply_matrix_ff_sptr self, int priority) → int
multiply_matrix_ff_sptr.thread_priority(multiply_matrix_ff_sptr self) → int
gnuradio.blocks.multiply_ss(size_t vlen=1) → multiply_ss_sptr
multiply_ss_sptr.active_thread_priority(multiply_ss_sptr self) → int
multiply_ss_sptr.declare_sample_delay(multiply_ss_sptr self, int which, int delay)

declare_sample_delay(multiply_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(multiply_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_ss_sptr self) -> pmt_vector_float

multiply_ss_sptr.pc_throughput_avg(multiply_ss_sptr self) → float
multiply_ss_sptr.pc_work_time_avg(multiply_ss_sptr self) → float
multiply_ss_sptr.pc_work_time_total(multiply_ss_sptr self) → float
multiply_ss_sptr.sample_delay(multiply_ss_sptr self, int which) → unsigned int
multiply_ss_sptr.set_min_noutput_items(multiply_ss_sptr self, int m)
multiply_ss_sptr.set_thread_priority(multiply_ss_sptr self, int priority) → int
multiply_ss_sptr.thread_priority(multiply_ss_sptr self) → int
gnuradio.blocks.mute_cc(bool mute=False) → mute_cc_sptr
mute_cc_sptr.active_thread_priority(mute_cc_sptr self) → int
mute_cc_sptr.declare_sample_delay(mute_cc_sptr self, int which, int delay)

declare_sample_delay(mute_cc_sptr self, unsigned int delay)

mute_cc_sptr.message_subscribers(mute_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr
mute_cc_sptr.min_noutput_items(mute_cc_sptr self) → int
mute_cc_sptr.mute(mute_cc_sptr self) → bool
mute_cc_sptr.pc_input_buffers_full_avg(mute_cc_sptr self, int which) → float

pc_input_buffers_full_avg(mute_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(mute_cc_sptr self) -> pmt_vector_float

mute_cc_sptr.pc_throughput_avg(mute_cc_sptr self) → float
mute_cc_sptr.pc_work_time_avg(mute_cc_sptr self) → float
mute_cc_sptr.pc_work_time_total(mute_cc_sptr self) → float
mute_cc_sptr.sample_delay(mute_cc_sptr self, int which) → unsigned int
mute_cc_sptr.set_min_noutput_items(mute_cc_sptr self, int m)
mute_cc_sptr.set_mute(mute_cc_sptr self, bool mute=False)
mute_cc_sptr.set_thread_priority(mute_cc_sptr self, int priority) → int
mute_cc_sptr.thread_priority(mute_cc_sptr self) → int
gnuradio.blocks.mute_ff(bool mute=False) → mute_ff_sptr
mute_ff_sptr.active_thread_priority(mute_ff_sptr self) → int
mute_ff_sptr.declare_sample_delay(mute_ff_sptr self, int which, int delay)

declare_sample_delay(mute_ff_sptr self, unsigned int delay)

mute_ff_sptr.message_subscribers(mute_ff_sptr self, swig_int_ptr which_port) → swig_int_ptr
mute_ff_sptr.min_noutput_items(mute_ff_sptr self) → int
mute_ff_sptr.mute(mute_ff_sptr self) → bool
mute_ff_sptr.pc_input_buffers_full_avg(mute_ff_sptr self, int which) → float

pc_input_buffers_full_avg(mute_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(mute_ff_sptr self) -> pmt_vector_float

mute_ff_sptr.pc_throughput_avg(mute_ff_sptr self) → float
mute_ff_sptr.pc_work_time_avg(mute_ff_sptr self) → float
mute_ff_sptr.pc_work_time_total(mute_ff_sptr self) → float
mute_ff_sptr.sample_delay(mute_ff_sptr self, int which) → unsigned int
mute_ff_sptr.set_min_noutput_items(mute_ff_sptr self, int m)
mute_ff_sptr.set_mute(mute_ff_sptr self, bool mute=False)
mute_ff_sptr.set_thread_priority(mute_ff_sptr self, int priority) → int
mute_ff_sptr.thread_priority(mute_ff_sptr self) → int
gnuradio.blocks.mute_ii(bool mute=False) → mute_ii_sptr
mute_ii_sptr.active_thread_priority(mute_ii_sptr self) → int
mute_ii_sptr.declare_sample_delay(mute_ii_sptr self, int which, int delay)

declare_sample_delay(mute_ii_sptr self, unsigned int delay)

mute_ii_sptr.message_subscribers(mute_ii_sptr self, swig_int_ptr which_port) → swig_int_ptr
mute_ii_sptr.min_noutput_items(mute_ii_sptr self) → int
mute_ii_sptr.mute(mute_ii_sptr self) → bool
mute_ii_sptr.pc_input_buffers_full_avg(mute_ii_sptr self, int which) → float

pc_input_buffers_full_avg(mute_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(mute_ii_sptr self) -> pmt_vector_float

mute_ii_sptr.pc_throughput_avg(mute_ii_sptr self) → float
mute_ii_sptr.pc_work_time_avg(mute_ii_sptr self) → float
mute_ii_sptr.pc_work_time_total(mute_ii_sptr self) → float
mute_ii_sptr.sample_delay(mute_ii_sptr self, int which) → unsigned int
mute_ii_sptr.set_min_noutput_items(mute_ii_sptr self, int m)
mute_ii_sptr.set_mute(mute_ii_sptr self, bool mute=False)
mute_ii_sptr.set_thread_priority(mute_ii_sptr self, int priority) → int
mute_ii_sptr.thread_priority(mute_ii_sptr self) → int
gnuradio.blocks.mute_ss(bool mute=False) → mute_ss_sptr
mute_ss_sptr.active_thread_priority(mute_ss_sptr self) → int
mute_ss_sptr.declare_sample_delay(mute_ss_sptr self, int which, int delay)

declare_sample_delay(mute_ss_sptr self, unsigned int delay)

mute_ss_sptr.message_subscribers(mute_ss_sptr self, swig_int_ptr which_port) → swig_int_ptr
mute_ss_sptr.min_noutput_items(mute_ss_sptr self) → int
mute_ss_sptr.mute(mute_ss_sptr self) → bool
mute_ss_sptr.pc_input_buffers_full_avg(mute_ss_sptr self, int which) → float

pc_input_buffers_full_avg(mute_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(mute_ss_sptr self) -> pmt_vector_float

mute_ss_sptr.pc_throughput_avg(mute_ss_sptr self) → float
mute_ss_sptr.pc_work_time_avg(mute_ss_sptr self) → float
mute_ss_sptr.pc_work_time_total(mute_ss_sptr self) → float
mute_ss_sptr.sample_delay(mute_ss_sptr self, int which) → unsigned int
mute_ss_sptr.set_min_noutput_items(mute_ss_sptr self, int m)
mute_ss_sptr.set_mute(mute_ss_sptr self, bool mute=False)
mute_ss_sptr.set_thread_priority(mute_ss_sptr self, int priority) → int
mute_ss_sptr.thread_priority(mute_ss_sptr self) → int
gnuradio.blocks.nlog10_ff(float n=1.0, size_t vlen=1, float k=0.0) → nlog10_ff_sptr
nlog10_ff_sptr.active_thread_priority(nlog10_ff_sptr self) → int
nlog10_ff_sptr.declare_sample_delay(nlog10_ff_sptr self, int which, int delay)

declare_sample_delay(nlog10_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(nlog10_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(nlog10_ff_sptr self) -> pmt_vector_float

nlog10_ff_sptr.pc_throughput_avg(nlog10_ff_sptr self) → float
nlog10_ff_sptr.pc_work_time_avg(nlog10_ff_sptr self) → float
nlog10_ff_sptr.pc_work_time_total(nlog10_ff_sptr self) → float
nlog10_ff_sptr.sample_delay(nlog10_ff_sptr self, int which) → unsigned int
nlog10_ff_sptr.set_min_noutput_items(nlog10_ff_sptr self, int m)
nlog10_ff_sptr.set_thread_priority(nlog10_ff_sptr self, int priority) → int
nlog10_ff_sptr.thread_priority(nlog10_ff_sptr self) → int
gnuradio.blocks.nop(size_t sizeof_stream_item) → nop_sptr
nop_sptr.active_thread_priority(nop_sptr self) → int
nop_sptr.ctrlport_test(nop_sptr self) → int
nop_sptr.declare_sample_delay(nop_sptr self, int which, int delay)

declare_sample_delay(nop_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(nop_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(nop_sptr self) -> pmt_vector_float

nop_sptr.pc_throughput_avg(nop_sptr self) → float
nop_sptr.pc_work_time_avg(nop_sptr self) → float
nop_sptr.pc_work_time_total(nop_sptr self) → float
nop_sptr.sample_delay(nop_sptr self, int which) → unsigned int
nop_sptr.set_ctrlport_test(nop_sptr self, int x)
nop_sptr.set_min_noutput_items(nop_sptr self, int m)
nop_sptr.set_thread_priority(nop_sptr self, int priority) → int
nop_sptr.thread_priority(nop_sptr self) → int
gnuradio.blocks.not_bb(size_t vlen=1) → not_bb_sptr
not_bb_sptr.active_thread_priority(not_bb_sptr self) → int
not_bb_sptr.declare_sample_delay(not_bb_sptr self, int which, int delay)

declare_sample_delay(not_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(not_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(not_bb_sptr self) -> pmt_vector_float

not_bb_sptr.pc_throughput_avg(not_bb_sptr self) → float
not_bb_sptr.pc_work_time_avg(not_bb_sptr self) → float
not_bb_sptr.pc_work_time_total(not_bb_sptr self) → float
not_bb_sptr.sample_delay(not_bb_sptr self, int which) → unsigned int
not_bb_sptr.set_min_noutput_items(not_bb_sptr self, int m)
not_bb_sptr.set_thread_priority(not_bb_sptr self, int priority) → int
not_bb_sptr.thread_priority(not_bb_sptr self) → int
gnuradio.blocks.not_ii(size_t vlen=1) → not_ii_sptr
not_ii_sptr.active_thread_priority(not_ii_sptr self) → int
not_ii_sptr.declare_sample_delay(not_ii_sptr self, int which, int delay)

declare_sample_delay(not_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(not_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(not_ii_sptr self) -> pmt_vector_float

not_ii_sptr.pc_throughput_avg(not_ii_sptr self) → float
not_ii_sptr.pc_work_time_avg(not_ii_sptr self) → float
not_ii_sptr.pc_work_time_total(not_ii_sptr self) → float
not_ii_sptr.sample_delay(not_ii_sptr self, int which) → unsigned int
not_ii_sptr.set_min_noutput_items(not_ii_sptr self, int m)
not_ii_sptr.set_thread_priority(not_ii_sptr self, int priority) → int
not_ii_sptr.thread_priority(not_ii_sptr self) → int
gnuradio.blocks.not_ss(size_t vlen=1) → not_ss_sptr
not_ss_sptr.active_thread_priority(not_ss_sptr self) → int
not_ss_sptr.declare_sample_delay(not_ss_sptr self, int which, int delay)

declare_sample_delay(not_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(not_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(not_ss_sptr self) -> pmt_vector_float

not_ss_sptr.pc_throughput_avg(not_ss_sptr self) → float
not_ss_sptr.pc_work_time_avg(not_ss_sptr self) → float
not_ss_sptr.pc_work_time_total(not_ss_sptr self) → float
not_ss_sptr.sample_delay(not_ss_sptr self, int which) → unsigned int
not_ss_sptr.set_min_noutput_items(not_ss_sptr self, int m)
not_ss_sptr.set_thread_priority(not_ss_sptr self, int priority) → int
not_ss_sptr.thread_priority(not_ss_sptr self) → int
gnuradio.blocks.null_sink(size_t sizeof_stream_item) → null_sink_sptr
null_sink_sptr.active_thread_priority(null_sink_sptr self) → int
null_sink_sptr.declare_sample_delay(null_sink_sptr self, int which, int delay)

declare_sample_delay(null_sink_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(null_sink_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(null_sink_sptr self) -> pmt_vector_float

null_sink_sptr.pc_throughput_avg(null_sink_sptr self) → float
null_sink_sptr.pc_work_time_avg(null_sink_sptr self) → float
null_sink_sptr.pc_work_time_total(null_sink_sptr self) → float
null_sink_sptr.sample_delay(null_sink_sptr self, int which) → unsigned int
null_sink_sptr.set_min_noutput_items(null_sink_sptr self, int m)
null_sink_sptr.set_thread_priority(null_sink_sptr self, int priority) → int
null_sink_sptr.thread_priority(null_sink_sptr self) → int
gnuradio.blocks.null_source(size_t sizeof_stream_item) → null_source_sptr
null_source_sptr.active_thread_priority(null_source_sptr self) → int
null_source_sptr.declare_sample_delay(null_source_sptr self, int which, int delay)

declare_sample_delay(null_source_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(null_source_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(null_source_sptr self) -> pmt_vector_float

null_source_sptr.pc_throughput_avg(null_source_sptr self) → float
null_source_sptr.pc_work_time_avg(null_source_sptr self) → float
null_source_sptr.pc_work_time_total(null_source_sptr self) → float
null_source_sptr.sample_delay(null_source_sptr self, int which) → unsigned int
null_source_sptr.set_min_noutput_items(null_source_sptr self, int m)
null_source_sptr.set_thread_priority(null_source_sptr self, int priority) → int
null_source_sptr.thread_priority(null_source_sptr self) → int
gnuradio.blocks.or_bb(size_t vlen=1) → or_bb_sptr
or_bb_sptr.active_thread_priority(or_bb_sptr self) → int
or_bb_sptr.declare_sample_delay(or_bb_sptr self, int which, int delay)

declare_sample_delay(or_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(or_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(or_bb_sptr self) -> pmt_vector_float

or_bb_sptr.pc_throughput_avg(or_bb_sptr self) → float
or_bb_sptr.pc_work_time_avg(or_bb_sptr self) → float
or_bb_sptr.pc_work_time_total(or_bb_sptr self) → float
or_bb_sptr.sample_delay(or_bb_sptr self, int which) → unsigned int
or_bb_sptr.set_min_noutput_items(or_bb_sptr self, int m)
or_bb_sptr.set_thread_priority(or_bb_sptr self, int priority) → int
or_bb_sptr.thread_priority(or_bb_sptr self) → int
gnuradio.blocks.or_ii(size_t vlen=1) → or_ii_sptr
or_ii_sptr.active_thread_priority(or_ii_sptr self) → int
or_ii_sptr.declare_sample_delay(or_ii_sptr self, int which, int delay)

declare_sample_delay(or_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(or_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(or_ii_sptr self) -> pmt_vector_float

or_ii_sptr.pc_throughput_avg(or_ii_sptr self) → float
or_ii_sptr.pc_work_time_avg(or_ii_sptr self) → float
or_ii_sptr.pc_work_time_total(or_ii_sptr self) → float
or_ii_sptr.sample_delay(or_ii_sptr self, int which) → unsigned int
or_ii_sptr.set_min_noutput_items(or_ii_sptr self, int m)
or_ii_sptr.set_thread_priority(or_ii_sptr self, int priority) → int
or_ii_sptr.thread_priority(or_ii_sptr self) → int
gnuradio.blocks.or_ss(size_t vlen=1) → or_ss_sptr
or_ss_sptr.active_thread_priority(or_ss_sptr self) → int
or_ss_sptr.declare_sample_delay(or_ss_sptr self, int which, int delay)

declare_sample_delay(or_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(or_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(or_ss_sptr self) -> pmt_vector_float

or_ss_sptr.pc_throughput_avg(or_ss_sptr self) → float
or_ss_sptr.pc_work_time_avg(or_ss_sptr self) → float
or_ss_sptr.pc_work_time_total(or_ss_sptr self) → float
or_ss_sptr.sample_delay(or_ss_sptr self, int which) → unsigned int
or_ss_sptr.set_min_noutput_items(or_ss_sptr self, int m)
or_ss_sptr.set_thread_priority(or_ss_sptr self, int priority) → int
or_ss_sptr.thread_priority(or_ss_sptr self) → int
gnuradio.blocks.pack_k_bits_bb(unsigned int k) → pack_k_bits_bb_sptr
pack_k_bits_bb_sptr.active_thread_priority(pack_k_bits_bb_sptr self) → int
pack_k_bits_bb_sptr.declare_sample_delay(pack_k_bits_bb_sptr self, int which, int delay)

declare_sample_delay(pack_k_bits_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(pack_k_bits_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(pack_k_bits_bb_sptr self) -> pmt_vector_float

pack_k_bits_bb_sptr.pc_throughput_avg(pack_k_bits_bb_sptr self) → float
pack_k_bits_bb_sptr.pc_work_time_avg(pack_k_bits_bb_sptr self) → float
pack_k_bits_bb_sptr.pc_work_time_total(pack_k_bits_bb_sptr self) → float
pack_k_bits_bb_sptr.sample_delay(pack_k_bits_bb_sptr self, int which) → unsigned int
pack_k_bits_bb_sptr.set_min_noutput_items(pack_k_bits_bb_sptr self, int m)
pack_k_bits_bb_sptr.set_thread_priority(pack_k_bits_bb_sptr self, int priority) → int
pack_k_bits_bb_sptr.thread_priority(pack_k_bits_bb_sptr self) → int
gnuradio.blocks.packed_to_unpacked_bb(unsigned int bits_per_chunk, gr::endianness_t endianness) → packed_to_unpacked_bb_sptr
packed_to_unpacked_bb_sptr.active_thread_priority(packed_to_unpacked_bb_sptr self) → int
packed_to_unpacked_bb_sptr.declare_sample_delay(packed_to_unpacked_bb_sptr self, int which, int delay)

declare_sample_delay(packed_to_unpacked_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(packed_to_unpacked_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(packed_to_unpacked_bb_sptr self) -> pmt_vector_float

packed_to_unpacked_bb_sptr.pc_throughput_avg(packed_to_unpacked_bb_sptr self) → float
packed_to_unpacked_bb_sptr.pc_work_time_avg(packed_to_unpacked_bb_sptr self) → float
packed_to_unpacked_bb_sptr.pc_work_time_total(packed_to_unpacked_bb_sptr self) → float
packed_to_unpacked_bb_sptr.sample_delay(packed_to_unpacked_bb_sptr self, int which) → unsigned int
packed_to_unpacked_bb_sptr.set_min_noutput_items(packed_to_unpacked_bb_sptr self, int m)
packed_to_unpacked_bb_sptr.set_thread_priority(packed_to_unpacked_bb_sptr self, int priority) → int
packed_to_unpacked_bb_sptr.thread_priority(packed_to_unpacked_bb_sptr self) → int
gnuradio.blocks.packed_to_unpacked_ii(unsigned int bits_per_chunk, gr::endianness_t endianness) → packed_to_unpacked_ii_sptr
packed_to_unpacked_ii_sptr.active_thread_priority(packed_to_unpacked_ii_sptr self) → int
packed_to_unpacked_ii_sptr.declare_sample_delay(packed_to_unpacked_ii_sptr self, int which, int delay)

declare_sample_delay(packed_to_unpacked_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(packed_to_unpacked_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(packed_to_unpacked_ii_sptr self) -> pmt_vector_float

packed_to_unpacked_ii_sptr.pc_throughput_avg(packed_to_unpacked_ii_sptr self) → float
packed_to_unpacked_ii_sptr.pc_work_time_avg(packed_to_unpacked_ii_sptr self) → float
packed_to_unpacked_ii_sptr.pc_work_time_total(packed_to_unpacked_ii_sptr self) → float
packed_to_unpacked_ii_sptr.sample_delay(packed_to_unpacked_ii_sptr self, int which) → unsigned int
packed_to_unpacked_ii_sptr.set_min_noutput_items(packed_to_unpacked_ii_sptr self, int m)
packed_to_unpacked_ii_sptr.set_thread_priority(packed_to_unpacked_ii_sptr self, int priority) → int
packed_to_unpacked_ii_sptr.thread_priority(packed_to_unpacked_ii_sptr self) → int
gnuradio.blocks.packed_to_unpacked_ss(unsigned int bits_per_chunk, gr::endianness_t endianness) → packed_to_unpacked_ss_sptr
packed_to_unpacked_ss_sptr.active_thread_priority(packed_to_unpacked_ss_sptr self) → int
packed_to_unpacked_ss_sptr.declare_sample_delay(packed_to_unpacked_ss_sptr self, int which, int delay)

declare_sample_delay(packed_to_unpacked_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(packed_to_unpacked_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(packed_to_unpacked_ss_sptr self) -> pmt_vector_float

packed_to_unpacked_ss_sptr.pc_throughput_avg(packed_to_unpacked_ss_sptr self) → float
packed_to_unpacked_ss_sptr.pc_work_time_avg(packed_to_unpacked_ss_sptr self) → float
packed_to_unpacked_ss_sptr.pc_work_time_total(packed_to_unpacked_ss_sptr self) → float
packed_to_unpacked_ss_sptr.sample_delay(packed_to_unpacked_ss_sptr self, int which) → unsigned int
packed_to_unpacked_ss_sptr.set_min_noutput_items(packed_to_unpacked_ss_sptr self, int m)
packed_to_unpacked_ss_sptr.set_thread_priority(packed_to_unpacked_ss_sptr self, int priority) → int
packed_to_unpacked_ss_sptr.thread_priority(packed_to_unpacked_ss_sptr self) → int
gnuradio.blocks.patterned_interleaver(size_t itemsize, std::vector< int, std::allocator< int > > pattern) → patterned_interleaver_sptr
patterned_interleaver_sptr.active_thread_priority(patterned_interleaver_sptr self) → int
patterned_interleaver_sptr.declare_sample_delay(patterned_interleaver_sptr self, int which, int delay)

declare_sample_delay(patterned_interleaver_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(patterned_interleaver_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(patterned_interleaver_sptr self) -> pmt_vector_float

patterned_interleaver_sptr.pc_throughput_avg(patterned_interleaver_sptr self) → float
patterned_interleaver_sptr.pc_work_time_avg(patterned_interleaver_sptr self) → float
patterned_interleaver_sptr.pc_work_time_total(patterned_interleaver_sptr self) → float
patterned_interleaver_sptr.sample_delay(patterned_interleaver_sptr self, int which) → unsigned int
patterned_interleaver_sptr.set_min_noutput_items(patterned_interleaver_sptr self, int m)
patterned_interleaver_sptr.set_thread_priority(patterned_interleaver_sptr self, int priority) → int
patterned_interleaver_sptr.thread_priority(patterned_interleaver_sptr self) → int
gnuradio.blocks.pdu_filter(swig_int_ptr k, swig_int_ptr v, bool invert=False) → pdu_filter_sptr
pdu_filter_sptr.active_thread_priority(pdu_filter_sptr self) → int
pdu_filter_sptr.declare_sample_delay(pdu_filter_sptr self, int which, int delay)

declare_sample_delay(pdu_filter_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(pdu_filter_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(pdu_filter_sptr self) -> pmt_vector_float

pdu_filter_sptr.pc_throughput_avg(pdu_filter_sptr self) → float
pdu_filter_sptr.pc_work_time_avg(pdu_filter_sptr self) → float
pdu_filter_sptr.pc_work_time_total(pdu_filter_sptr self) → float
pdu_filter_sptr.sample_delay(pdu_filter_sptr self, int which) → unsigned int
pdu_filter_sptr.set_min_noutput_items(pdu_filter_sptr self, int m)
pdu_filter_sptr.set_thread_priority(pdu_filter_sptr self, int priority) → int
pdu_filter_sptr.thread_priority(pdu_filter_sptr self) → int
gnuradio.blocks.pdu_remove(swig_int_ptr k) → pdu_remove_sptr
pdu_remove_sptr.active_thread_priority(pdu_remove_sptr self) → int
pdu_remove_sptr.declare_sample_delay(pdu_remove_sptr self, int which, int delay)

declare_sample_delay(pdu_remove_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(pdu_remove_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(pdu_remove_sptr self) -> pmt_vector_float

pdu_remove_sptr.pc_throughput_avg(pdu_remove_sptr self) → float
pdu_remove_sptr.pc_work_time_avg(pdu_remove_sptr self) → float
pdu_remove_sptr.pc_work_time_total(pdu_remove_sptr self) → float
pdu_remove_sptr.sample_delay(pdu_remove_sptr self, int which) → unsigned int
pdu_remove_sptr.set_min_noutput_items(pdu_remove_sptr self, int m)
pdu_remove_sptr.set_thread_priority(pdu_remove_sptr self, int priority) → int
pdu_remove_sptr.thread_priority(pdu_remove_sptr self) → int
gnuradio.blocks.pdu_set(swig_int_ptr k, swig_int_ptr v) → pdu_set_sptr
pdu_set_sptr.active_thread_priority(pdu_set_sptr self) → int
pdu_set_sptr.declare_sample_delay(pdu_set_sptr self, int which, int delay)

declare_sample_delay(pdu_set_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(pdu_set_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(pdu_set_sptr self) -> pmt_vector_float

pdu_set_sptr.pc_throughput_avg(pdu_set_sptr self) → float
pdu_set_sptr.pc_work_time_avg(pdu_set_sptr self) → float
pdu_set_sptr.pc_work_time_total(pdu_set_sptr self) → float
pdu_set_sptr.sample_delay(pdu_set_sptr self, int which) → unsigned int
pdu_set_sptr.set_min_noutput_items(pdu_set_sptr self, int m)
pdu_set_sptr.set_thread_priority(pdu_set_sptr self, int priority) → int
pdu_set_sptr.thread_priority(pdu_set_sptr self) → int
gnuradio.blocks.pdu_to_tagged_stream(gr::blocks::pdu::vector_type type, std::string const & lengthtagname="packet_len") → pdu_to_tagged_stream_sptr
pdu_to_tagged_stream_sptr.active_thread_priority(pdu_to_tagged_stream_sptr self) → int
pdu_to_tagged_stream_sptr.declare_sample_delay(pdu_to_tagged_stream_sptr self, int which, int delay)

declare_sample_delay(pdu_to_tagged_stream_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(pdu_to_tagged_stream_sptr self) -> pmt_vector_float

pdu_to_tagged_stream_sptr.pc_noutput_items_avg(pdu_to_tagged_stream_sptr self) → float
pdu_to_tagged_stream_