gnuradio.blocks: Math Operators¶

gnuradio.blocks.add_cc(size_t vlen=1) → add_cc_sptr¶

output = sum(input[0], input[1], ..., input[M-1])

Add samples across all input streams. For all samples on all input streams :

Constructor Specific Documentation:

Parameters:	vlen –

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¶

output = input + constant

Constructor Specific Documentation:

Create an instance of add_const_bb.

Parameters:	k – additive constant

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¶: Return additive constant.

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)¶: Set additive constant.

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¶

output = input + constant

Constructor Specific Documentation:

Create an instance of add_const_cc.

Parameters:	k – additive constant

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¶: Return additive constant.

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)¶: Set additive constant.

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¶

output = input + constant

Constructor Specific Documentation:

Create an instance of add_const_ff.

Parameters:	k – additive constant

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¶: Return additive constant.

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)¶: Set additive constant.

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¶

output = input + constant

Constructor Specific Documentation:

Create an instance of add_const_ii.

Parameters:	k – additive constant

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¶: Return additive constant.

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)¶: Set additive constant.

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¶

output = input + constant

Constructor Specific Documentation:

Create an instance of add_const_ss.

Parameters:	k – additive constant

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¶: Return additive constant.

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)¶: Set additive constant.

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¶

output[m] = input[m] + constant vector for all M streams.

Constructor Specific Documentation:

Create an instance of add_const_vbb.

Parameters:	k – additive constant vector

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 > >¶: Return additive constant vector.

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)¶: Set additive constant vector.

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¶

output[m] = input[m] + constant vector for all M streams.

Constructor Specific Documentation:

Create an instance of add_const_vcc.

Parameters:	k – additive constant vector

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¶: Return additive constant vector.

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)¶: Set additive constant vector.

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¶

output[m] = input[m] + constant vector for all M streams.

Constructor Specific Documentation:

Create an instance of add_const_vff.

Parameters:	k – additive constant vector

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¶: Return additive constant vector.

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)¶: Set additive constant vector.

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¶

output[m] = input[m] + constant vector for all M streams.

Constructor Specific Documentation:

Create an instance of add_const_vii.

Parameters:	k – additive constant vector

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 > >¶: Return additive constant vector.

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)¶: Set additive constant vector.

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¶

output[m] = input[m] + constant vector for all M streams.

Constructor Specific Documentation:

Create an instance of add_const_vss.

Parameters:	k – additive constant vector

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 > >¶: Return additive constant vector.

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)¶: Set additive constant vector.

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_ii(size_t vlen=1) → add_ii_sptr¶

output = sum(input[0], input[1], ..., input[M-1])

Add samples across all input streams. For all samples on all input streams :

Constructor Specific Documentation:

Parameters:	vlen –

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¶

output = sum(input[0], input[1], ..., input[M-1])

Add samples across all input streams. For all samples on all input streams :

Constructor Specific Documentation:

Parameters:	vlen –

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.argmax_fs(size_t vlen) → argmax_fs_sptr¶

Compares vectors from multiple streams and determines the index in the vector and stream number where the maximum value occurred.

Data is passed in as a vector of length from multiple input sources. It will look through these streams of data items and output two streams:

Constructor Specific Documentation:

Parameters:	vlen –

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¶

Compares vectors from multiple streams and determines the index in the vector and stream number where the maximum value occurred.

Data is passed in as a vector of length from multiple input sources. It will look through these streams of data items and output two streams:

Constructor Specific Documentation:

Parameters:	vlen –

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¶

Compares vectors from multiple streams and determines the index in the vector and stream number where the maximum value occurred.

Data is passed in as a vector of length from multiple input sources. It will look through these streams of data items and output two streams:

Constructor Specific Documentation:

Parameters:	vlen –

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.divide_cc(size_t vlen=1) → divide_cc_sptr¶

output = input[0] / input[1] / ... / input[M-1]

Divide across all input streams.

Constructor Specific Documentation:

Parameters:	vlen –

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¶

output = input[0] / input[1] / ... / input[M-1]

Divide across all input streams.

Constructor Specific Documentation:

Parameters:	vlen –

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¶

output = input[0] / input[1] / ... / input[M-1]

Divide across all input streams.

Constructor Specific Documentation:

Parameters:	vlen –

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¶

output = input[0] / input[1] / ... / input[M-1]

Divide across all input streams.

Constructor Specific Documentation:

Parameters:	vlen –

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.integrate_cc(int decim, int vlen=1) → integrate_cc_sptr¶

Integrate successive samples and decimate.

Constructor Specific Documentation:

Parameters:	decim – vlen –

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 successive samples and decimate.

Constructor Specific Documentation:

Parameters:	decim – vlen –

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 successive samples and decimate.

Constructor Specific Documentation:

Parameters:	decim – vlen –

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 successive samples and decimate.

Constructor Specific Documentation:

Parameters:	decim – vlen –

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.max_ff(size_t vlen) → max_ff_sptr¶

Compares vectors from multiple streams and determines the maximum value from each vector over all streams.

Data is passed in as a vector of length from multiple input sources. It will look through these streams of data items and the output stream will contain the maximum value in the vector.

Constructor Specific Documentation:

Parameters:	vlen –

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) → max_ii_sptr¶

Compares vectors from multiple streams and determines the maximum value from each vector over all streams.

Data is passed in as a vector of length from multiple input sources. It will look through these streams of data items and the output stream will contain the maximum value in the vector.

Constructor Specific Documentation:

Parameters:	vlen –

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) → max_ss_sptr¶

Compares vectors from multiple streams and determines the maximum value from each vector over all streams.

Data is passed in as a vector of length from multiple input sources. It will look through these streams of data items and the output stream will contain the maximum value in the vector.

Constructor Specific Documentation:

Parameters:	vlen –

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.multiply_const_ii(int k) → multiply_const_ii_sptr¶

output = input * constant

Constructor Specific Documentation:

Create an instance of multiply_const_ii.

Parameters:	k – multiplicative constant

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¶: Return multiplicative constant.

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)¶: Set multiplicative constant.

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¶

output = input * constant

Constructor Specific Documentation:

Create an instance of multiply_const_ss.

Parameters:	k – multiplicative constant

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¶: Return multiplicative constant.

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)¶: Set multiplicative constant.

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¶

output = input * constant vector (element-wise)

Constructor Specific Documentation:

Create an instance of multiply_const_vcc.

Parameters:	k – multiplicative constant vector

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¶: Return multiplicative constant vector.

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)¶: Set multiplicative constant vector.

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¶

output = input * constant vector (element-wise)

Constructor Specific Documentation:

Create an instance of multiply_const_vff.

Parameters:	k – multiplicative constant vector

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¶: Return multiplicative constant vector.

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)¶: Set multiplicative constant vector.

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¶

output = input * constant vector (element-wise)

Constructor Specific Documentation:

Create an instance of multiply_const_vii.

Parameters:	k – multiplicative constant vector

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 > >¶: Return multiplicative constant vector.

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)¶: Set multiplicative constant vector.

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¶

output = input * constant vector (element-wise)

Constructor Specific Documentation:

Create an instance of multiply_const_vss.

Parameters:	k – multiplicative constant vector

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 > >¶: Return multiplicative constant vector.

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)¶: Set multiplicative constant vector.

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_ii(size_t vlen=1) → multiply_ii_sptr¶

output = prod (input_0, input_1, ...)

Multiply across all input streams.

Constructor Specific Documentation:

Parameters:	vlen –

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_ss(size_t vlen=1) → multiply_ss_sptr¶

output = prod (input_0, input_1, ...)

Multiply across all input streams.

Constructor Specific Documentation:

Parameters:	vlen –

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.sub_cc(size_t vlen=1) → sub_cc_sptr¶

output = input_0 - input_1 - ...)

Subtract across all input streams.

Constructor Specific Documentation:

Parameters:	vlen –

sub_cc_sptr.active_thread_priority(sub_cc_sptr self) → int¶

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

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

sub_cc_sptr.min_noutput_items(sub_cc_sptr self) → int¶

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

sub_cc_sptr.pc_noutput_items_avg(sub_cc_sptr self) → float¶

sub_cc_sptr.pc_nproduced_avg(sub_cc_sptr self) → float¶

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

sub_cc_sptr.pc_throughput_avg(sub_cc_sptr self) → float¶

sub_cc_sptr.pc_work_time_avg(sub_cc_sptr self) → float¶

sub_cc_sptr.pc_work_time_total(sub_cc_sptr self) → float¶

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

sub_cc_sptr.set_min_noutput_items(sub_cc_sptr self, int m)¶

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

sub_cc_sptr.thread_priority(sub_cc_sptr self) → int¶

gnuradio.blocks.sub_ff(size_t vlen=1) → sub_ff_sptr¶

output = input_0 - input_1 - ...)

Subtract across all input streams.

Constructor Specific Documentation:

Parameters:	vlen –

sub_ff_sptr.active_thread_priority(sub_ff_sptr self) → int¶

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

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

sub_ff_sptr.min_noutput_items(sub_ff_sptr self) → int¶

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

sub_ff_sptr.pc_noutput_items_avg(sub_ff_sptr self) → float¶

sub_ff_sptr.pc_nproduced_avg(sub_ff_sptr self) → float¶

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

sub_ff_sptr.pc_throughput_avg(sub_ff_sptr self) → float¶

sub_ff_sptr.pc_work_time_avg(sub_ff_sptr self) → float¶

sub_ff_sptr.pc_work_time_total(sub_ff_sptr self) → float¶

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

sub_ff_sptr.set_min_noutput_items(sub_ff_sptr self, int m)¶

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

sub_ff_sptr.thread_priority(sub_ff_sptr self) → int¶

gnuradio.blocks.sub_ii(size_t vlen=1) → sub_ii_sptr¶

output = input_0 - input_1 - ...)

Subtract across all input streams.

Constructor Specific Documentation:

Parameters:	vlen –

sub_ii_sptr.active_thread_priority(sub_ii_sptr self) → int¶

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

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

sub_ii_sptr.min_noutput_items(sub_ii_sptr self) → int¶

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

sub_ii_sptr.pc_noutput_items_avg(sub_ii_sptr self) → float¶

sub_ii_sptr.pc_nproduced_avg(sub_ii_sptr self) → float¶

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

sub_ii_sptr.pc_throughput_avg(sub_ii_sptr self) → float¶

sub_ii_sptr.pc_work_time_avg(sub_ii_sptr self) → float¶

sub_ii_sptr.pc_work_time_total(sub_ii_sptr self) → float¶

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

sub_ii_sptr.set_min_noutput_items(sub_ii_sptr self, int m)¶

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

sub_ii_sptr.thread_priority(sub_ii_sptr self) → int¶

gnuradio.blocks.sub_ss(size_t vlen=1) → sub_ss_sptr¶

output = input_0 - input_1 - ...)

Subtract across all input streams.

Constructor Specific Documentation:

Parameters:	vlen –

sub_ss_sptr.active_thread_priority(sub_ss_sptr self) → int¶

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

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

sub_ss_sptr.min_noutput_items(sub_ss_sptr self) → int¶

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

sub_ss_sptr.pc_noutput_items_avg(sub_ss_sptr self) → float¶

sub_ss_sptr.pc_nproduced_avg(sub_ss_sptr self) → float¶

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

sub_ss_sptr.pc_throughput_avg(sub_ss_sptr self) → float¶

sub_ss_sptr.pc_work_time_avg(sub_ss_sptr self) → float¶

sub_ss_sptr.pc_work_time_total(sub_ss_sptr self) → float¶

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

sub_ss_sptr.set_min_noutput_items(sub_ss_sptr self, int m)¶

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

sub_ss_sptr.thread_priority(sub_ss_sptr self) → int¶

gnuradio.blocks.add_ff(size_t vlen=1) → add_ff_sptr¶

output = sum (input_0, input_1, ...)

Add across all input streams.

Constructor Specific Documentation:

Add streams of float values.

Parameters:	vlen – Vector length

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.conjugate_cc() → conjugate_cc_sptr¶

output = complex conjugate of input

Constructor Specific Documentation:

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.multiply_cc(size_t vlen=1) → multiply_cc_sptr¶

output = prod (input_0, input_1, ...)

Multiply across all input streams.

Constructor Specific Documentation:

Multiply streams of complex values.

Parameters:	vlen – Vector length

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¶

Multiplies stream 0 by the complex conjugate of stream 1.

Constructor Specific Documentation:

Multiplies a streams by the conjugate of a second stream.

Parameters:	vlen – Vector length

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¶

output = input * complex constant

Constructor Specific Documentation:

Create an instance of multiply_const_cc.

Parameters:	k – complex multiplicative constant vlen – Vector length of incoming stream

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¶: Return complex multiplicative constant.

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)¶: Set complex multiplicative constant.

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¶

output = input * real constant

Constructor Specific Documentation:

Create an instance of multiply_const_ff.

Parameters:	k – real multiplicative constant vlen – Vector length of incoming stream

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¶: Return real multiplicative constant.

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)¶: Set real multiplicative constant.

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_ff(size_t vlen=1) → multiply_ff_sptr¶

output = prod (input_0, input_1, ...)

Multiply across all input streams.

Constructor Specific Documentation:

Multiply streams of float values.

Parameters:	vlen – Vector length

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.nlog10_ff(float n=1.0, size_t vlen=1, float k=0.0) → nlog10_ff_sptr¶

output = n*log10(input) + k

Constructor Specific Documentation:

Make an instance of an nlog10_ff block.

Parameters:	n – Scalar multiplicative constant vlen – Input vector length k – Scalar additive constant

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.rms_cf(double alpha=0.0001) → rms_cf_sptr¶

RMS average power.

Constructor Specific Documentation:

Make an RMS calc. block.

Parameters:	alpha – gain for running average filter.

rms_cf_sptr.active_thread_priority(rms_cf_sptr self) → int¶

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

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

rms_cf_sptr.min_noutput_items(rms_cf_sptr self) → int¶

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

rms_cf_sptr.pc_noutput_items_avg(rms_cf_sptr self) → float¶

rms_cf_sptr.pc_nproduced_avg(rms_cf_sptr self) → float¶

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

rms_cf_sptr.pc_throughput_avg(rms_cf_sptr self) → float¶

rms_cf_sptr.pc_work_time_avg(rms_cf_sptr self) → float¶

rms_cf_sptr.pc_work_time_total(rms_cf_sptr self) → float¶

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

rms_cf_sptr.set_alpha(rms_cf_sptr self, double alpha)¶

rms_cf_sptr.set_min_noutput_items(rms_cf_sptr self, int m)¶

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

rms_cf_sptr.thread_priority(rms_cf_sptr self) → int¶

gnuradio.blocks.rms_ff(double alpha=0.0001) → rms_ff_sptr¶

RMS average power.

Constructor Specific Documentation:

Make an RMS calc. block.

Parameters:	alpha – gain for running average filter.

rms_ff_sptr.active_thread_priority(rms_ff_sptr self) → int¶

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

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

rms_ff_sptr.min_noutput_items(rms_ff_sptr self) → int¶

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

rms_ff_sptr.pc_noutput_items_avg(rms_ff_sptr self) → float¶

rms_ff_sptr.pc_nproduced_avg(rms_ff_sptr self) → float¶

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

rms_ff_sptr.pc_throughput_avg(rms_ff_sptr self) → float¶

rms_ff_sptr.pc_work_time_avg(rms_ff_sptr self) → float¶

rms_ff_sptr.pc_work_time_total(rms_ff_sptr self) → float¶

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

rms_ff_sptr.set_alpha(rms_ff_sptr self, double alpha)¶

rms_ff_sptr.set_min_noutput_items(rms_ff_sptr self, int m)¶

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

rms_ff_sptr.thread_priority(rms_ff_sptr self) → int¶

gnuradio.blocks.transcendental(std::string const & name, std::string const & type="float") → transcendental_sptr¶

A block that performs various transcendental math operations.

Possible function names can be found in the cmath library. IO may be either complex or real, double or single precision.

Possible type strings: float, double, complex_float, complex_double

output[i] = trans_fcn(input[i])

Constructor Specific Documentation:

Parameters:	name – type –

transcendental_sptr.active_thread_priority(transcendental_sptr self) → int¶

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

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

transcendental_sptr.min_noutput_items(transcendental_sptr self) → int¶

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

transcendental_sptr.pc_noutput_items_avg(transcendental_sptr self) → float¶

transcendental_sptr.pc_nproduced_avg(transcendental_sptr self) → float¶

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

transcendental_sptr.pc_throughput_avg(transcendental_sptr self) → float¶

transcendental_sptr.pc_work_time_avg(transcendental_sptr self) → float¶

transcendental_sptr.pc_work_time_total(transcendental_sptr self) → float¶

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

transcendental_sptr.set_min_noutput_items(transcendental_sptr self, int m)¶

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

transcendental_sptr.thread_priority(transcendental_sptr self) → int¶

gnuradio.blocks: Math Operators¶

Previous topic

Next topic

This Page

Navigation

gnuradio.blocks: Math Operators¶

Previous topic

Next topic

This Page

Quick search

Navigation