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

Previous topic

gnuradio.blocks: ControlPort

Next topic

gnuradio.blocks: Stream Tag Tools

This Page