gnuradio.blocks: Boolean Operators

gnuradio.blocks.and_bb(size_t vlen=1) → and_bb_sptr

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

bitwise boolean AND across all input streams.

Constructor Specific Documentation:

Parameters:vlen –

and_bb_sptr.active_thread_priority(and_bb_sptr self) → int

and_bb_sptr.declare_sample_delay(and_bb_sptr self, int which, int delay)

declare_sample_delay(and_bb_sptr self, unsigned int delay)

and_bb_sptr.message_subscribers(and_bb_sptr self, swig_int_ptr which_port) → swig_int_ptr

and_bb_sptr.min_noutput_items(and_bb_sptr self) → int

and_bb_sptr.pc_input_buffers_full_avg(and_bb_sptr self, int which) → float

pc_input_buffers_full_avg(and_bb_sptr self) -> pmt_vector_float

and_bb_sptr.pc_noutput_items_avg(and_bb_sptr self) → float

and_bb_sptr.pc_nproduced_avg(and_bb_sptr self) → float

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

pc_output_buffers_full_avg(and_bb_sptr self) -> pmt_vector_float

and_bb_sptr.pc_throughput_avg(and_bb_sptr self) → float

and_bb_sptr.pc_work_time_avg(and_bb_sptr self) → float

and_bb_sptr.pc_work_time_total(and_bb_sptr self) → float

and_bb_sptr.sample_delay(and_bb_sptr self, int which) → unsigned int

and_bb_sptr.set_min_noutput_items(and_bb_sptr self, int m)

and_bb_sptr.set_thread_priority(and_bb_sptr self, int priority) → int

and_bb_sptr.thread_priority(and_bb_sptr self) → int

gnuradio.blocks.and_const_bb(unsigned char k) → and_const_bb_sptr

output[m] = input[m] & value for all M streams.

Bitwise boolean AND of constant with the data stream.

Constructor Specific Documentation:

Create an instance of and_const_bb.

Parameters:k – AND constant

and_const_bb_sptr.active_thread_priority(and_const_bb_sptr self) → int

and_const_bb_sptr.declare_sample_delay(and_const_bb_sptr self, int which, int delay)

declare_sample_delay(and_const_bb_sptr self, unsigned int delay)

and_const_bb_sptr.k(and_const_bb_sptr self) → unsigned char

Return AND constant.

and_const_bb_sptr.message_subscribers(and_const_bb_sptr self, swig_int_ptr which_port) → swig_int_ptr

and_const_bb_sptr.min_noutput_items(and_const_bb_sptr self) → int

and_const_bb_sptr.pc_input_buffers_full_avg(and_const_bb_sptr self, int which) → float

pc_input_buffers_full_avg(and_const_bb_sptr self) -> pmt_vector_float

and_const_bb_sptr.pc_noutput_items_avg(and_const_bb_sptr self) → float

and_const_bb_sptr.pc_nproduced_avg(and_const_bb_sptr self) → float

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

pc_output_buffers_full_avg(and_const_bb_sptr self) -> pmt_vector_float

and_const_bb_sptr.pc_throughput_avg(and_const_bb_sptr self) → float

and_const_bb_sptr.pc_work_time_avg(and_const_bb_sptr self) → float

and_const_bb_sptr.pc_work_time_total(and_const_bb_sptr self) → float

and_const_bb_sptr.sample_delay(and_const_bb_sptr self, int which) → unsigned int

and_const_bb_sptr.set_k(and_const_bb_sptr self, unsigned char k)

Set AND constant.

and_const_bb_sptr.set_min_noutput_items(and_const_bb_sptr self, int m)

and_const_bb_sptr.set_thread_priority(and_const_bb_sptr self, int priority) → int

and_const_bb_sptr.thread_priority(and_const_bb_sptr self) → int

gnuradio.blocks.and_const_ii(int k) → and_const_ii_sptr

output[m] = input[m] & value for all M streams.

Bitwise boolean AND of constant with the data stream.

Constructor Specific Documentation:

Create an instance of and_const_ii.

Parameters:k – AND constant

and_const_ii_sptr.active_thread_priority(and_const_ii_sptr self) → int

and_const_ii_sptr.declare_sample_delay(and_const_ii_sptr self, int which, int delay)

declare_sample_delay(and_const_ii_sptr self, unsigned int delay)

and_const_ii_sptr.k(and_const_ii_sptr self) → int

Return AND constant.

and_const_ii_sptr.message_subscribers(and_const_ii_sptr self, swig_int_ptr which_port) → swig_int_ptr

and_const_ii_sptr.min_noutput_items(and_const_ii_sptr self) → int

and_const_ii_sptr.pc_input_buffers_full_avg(and_const_ii_sptr self, int which) → float

pc_input_buffers_full_avg(and_const_ii_sptr self) -> pmt_vector_float

and_const_ii_sptr.pc_noutput_items_avg(and_const_ii_sptr self) → float

and_const_ii_sptr.pc_nproduced_avg(and_const_ii_sptr self) → float

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

pc_output_buffers_full_avg(and_const_ii_sptr self) -> pmt_vector_float

and_const_ii_sptr.pc_throughput_avg(and_const_ii_sptr self) → float

and_const_ii_sptr.pc_work_time_avg(and_const_ii_sptr self) → float

and_const_ii_sptr.pc_work_time_total(and_const_ii_sptr self) → float

and_const_ii_sptr.sample_delay(and_const_ii_sptr self, int which) → unsigned int

and_const_ii_sptr.set_k(and_const_ii_sptr self, int k)

Set AND constant.

and_const_ii_sptr.set_min_noutput_items(and_const_ii_sptr self, int m)

and_const_ii_sptr.set_thread_priority(and_const_ii_sptr self, int priority) → int

and_const_ii_sptr.thread_priority(and_const_ii_sptr self) → int

gnuradio.blocks.and_const_ss(short k) → and_const_ss_sptr

output[m] = input[m] & value for all M streams.

Bitwise boolean AND of constant with the data stream.

Constructor Specific Documentation:

Create an instance of and_const_ss.

Parameters:k – AND constant

and_const_ss_sptr.active_thread_priority(and_const_ss_sptr self) → int

and_const_ss_sptr.declare_sample_delay(and_const_ss_sptr self, int which, int delay)

declare_sample_delay(and_const_ss_sptr self, unsigned int delay)

and_const_ss_sptr.k(and_const_ss_sptr self) → short

Return AND constant.

and_const_ss_sptr.message_subscribers(and_const_ss_sptr self, swig_int_ptr which_port) → swig_int_ptr

and_const_ss_sptr.min_noutput_items(and_const_ss_sptr self) → int

and_const_ss_sptr.pc_input_buffers_full_avg(and_const_ss_sptr self, int which) → float

pc_input_buffers_full_avg(and_const_ss_sptr self) -> pmt_vector_float

and_const_ss_sptr.pc_noutput_items_avg(and_const_ss_sptr self) → float

and_const_ss_sptr.pc_nproduced_avg(and_const_ss_sptr self) → float

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

pc_output_buffers_full_avg(and_const_ss_sptr self) -> pmt_vector_float

and_const_ss_sptr.pc_throughput_avg(and_const_ss_sptr self) → float

and_const_ss_sptr.pc_work_time_avg(and_const_ss_sptr self) → float

and_const_ss_sptr.pc_work_time_total(and_const_ss_sptr self) → float

and_const_ss_sptr.sample_delay(and_const_ss_sptr self, int which) → unsigned int

and_const_ss_sptr.set_k(and_const_ss_sptr self, short k)

Set AND constant.

and_const_ss_sptr.set_min_noutput_items(and_const_ss_sptr self, int m)

and_const_ss_sptr.set_thread_priority(and_const_ss_sptr self, int priority) → int

and_const_ss_sptr.thread_priority(and_const_ss_sptr self) → int

gnuradio.blocks.and_ii(size_t vlen=1) → and_ii_sptr

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

bitwise boolean AND across all input streams.

Constructor Specific Documentation:

Parameters:vlen –

and_ii_sptr.active_thread_priority(and_ii_sptr self) → int

and_ii_sptr.declare_sample_delay(and_ii_sptr self, int which, int delay)

declare_sample_delay(and_ii_sptr self, unsigned int delay)

and_ii_sptr.message_subscribers(and_ii_sptr self, swig_int_ptr which_port) → swig_int_ptr

and_ii_sptr.min_noutput_items(and_ii_sptr self) → int

and_ii_sptr.pc_input_buffers_full_avg(and_ii_sptr self, int which) → float

pc_input_buffers_full_avg(and_ii_sptr self) -> pmt_vector_float

and_ii_sptr.pc_noutput_items_avg(and_ii_sptr self) → float

and_ii_sptr.pc_nproduced_avg(and_ii_sptr self) → float

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

pc_output_buffers_full_avg(and_ii_sptr self) -> pmt_vector_float

and_ii_sptr.pc_throughput_avg(and_ii_sptr self) → float

and_ii_sptr.pc_work_time_avg(and_ii_sptr self) → float

and_ii_sptr.pc_work_time_total(and_ii_sptr self) → float

and_ii_sptr.sample_delay(and_ii_sptr self, int which) → unsigned int

and_ii_sptr.set_min_noutput_items(and_ii_sptr self, int m)

and_ii_sptr.set_thread_priority(and_ii_sptr self, int priority) → int

and_ii_sptr.thread_priority(and_ii_sptr self) → int

gnuradio.blocks.and_ss(size_t vlen=1) → and_ss_sptr

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

bitwise boolean AND across all input streams.

Constructor Specific Documentation:

Parameters:vlen –

and_ss_sptr.active_thread_priority(and_ss_sptr self) → int

and_ss_sptr.declare_sample_delay(and_ss_sptr self, int which, int delay)

declare_sample_delay(and_ss_sptr self, unsigned int delay)

and_ss_sptr.message_subscribers(and_ss_sptr self, swig_int_ptr which_port) → swig_int_ptr

and_ss_sptr.min_noutput_items(and_ss_sptr self) → int

and_ss_sptr.pc_input_buffers_full_avg(and_ss_sptr self, int which) → float

pc_input_buffers_full_avg(and_ss_sptr self) -> pmt_vector_float

and_ss_sptr.pc_noutput_items_avg(and_ss_sptr self) → float

and_ss_sptr.pc_nproduced_avg(and_ss_sptr self) → float

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

pc_output_buffers_full_avg(and_ss_sptr self) -> pmt_vector_float

and_ss_sptr.pc_throughput_avg(and_ss_sptr self) → float

and_ss_sptr.pc_work_time_avg(and_ss_sptr self) → float

and_ss_sptr.pc_work_time_total(and_ss_sptr self) → float

and_ss_sptr.sample_delay(and_ss_sptr self, int which) → unsigned int

and_ss_sptr.set_min_noutput_items(and_ss_sptr self, int m)

and_ss_sptr.set_thread_priority(and_ss_sptr self, int priority) → int

and_ss_sptr.thread_priority(and_ss_sptr self) → int

gnuradio.blocks.not_bb(size_t vlen=1) → not_bb_sptr

output = ~input

bitwise boolean not of input streams.

Constructor Specific Documentation:

Parameters:vlen –

not_bb_sptr.active_thread_priority(not_bb_sptr self) → int

not_bb_sptr.declare_sample_delay(not_bb_sptr self, int which, int delay)

declare_sample_delay(not_bb_sptr self, unsigned int delay)

not_bb_sptr.message_subscribers(not_bb_sptr self, swig_int_ptr which_port) → swig_int_ptr

not_bb_sptr.min_noutput_items(not_bb_sptr self) → int

not_bb_sptr.pc_input_buffers_full_avg(not_bb_sptr self, int which) → float

pc_input_buffers_full_avg(not_bb_sptr self) -> pmt_vector_float

not_bb_sptr.pc_noutput_items_avg(not_bb_sptr self) → float

not_bb_sptr.pc_nproduced_avg(not_bb_sptr self) → float

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

pc_output_buffers_full_avg(not_bb_sptr self) -> pmt_vector_float

not_bb_sptr.pc_throughput_avg(not_bb_sptr self) → float

not_bb_sptr.pc_work_time_avg(not_bb_sptr self) → float

not_bb_sptr.pc_work_time_total(not_bb_sptr self) → float

not_bb_sptr.sample_delay(not_bb_sptr self, int which) → unsigned int

not_bb_sptr.set_min_noutput_items(not_bb_sptr self, int m)

not_bb_sptr.set_thread_priority(not_bb_sptr self, int priority) → int

not_bb_sptr.thread_priority(not_bb_sptr self) → int

gnuradio.blocks.not_ii(size_t vlen=1) → not_ii_sptr

output = ~input

bitwise boolean not of input streams.

Constructor Specific Documentation:

Parameters:vlen –

not_ii_sptr.active_thread_priority(not_ii_sptr self) → int

not_ii_sptr.declare_sample_delay(not_ii_sptr self, int which, int delay)

declare_sample_delay(not_ii_sptr self, unsigned int delay)

not_ii_sptr.message_subscribers(not_ii_sptr self, swig_int_ptr which_port) → swig_int_ptr

not_ii_sptr.min_noutput_items(not_ii_sptr self) → int

not_ii_sptr.pc_input_buffers_full_avg(not_ii_sptr self, int which) → float

pc_input_buffers_full_avg(not_ii_sptr self) -> pmt_vector_float

not_ii_sptr.pc_noutput_items_avg(not_ii_sptr self) → float

not_ii_sptr.pc_nproduced_avg(not_ii_sptr self) → float

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

pc_output_buffers_full_avg(not_ii_sptr self) -> pmt_vector_float

not_ii_sptr.pc_throughput_avg(not_ii_sptr self) → float

not_ii_sptr.pc_work_time_avg(not_ii_sptr self) → float

not_ii_sptr.pc_work_time_total(not_ii_sptr self) → float

not_ii_sptr.sample_delay(not_ii_sptr self, int which) → unsigned int

not_ii_sptr.set_min_noutput_items(not_ii_sptr self, int m)

not_ii_sptr.set_thread_priority(not_ii_sptr self, int priority) → int

not_ii_sptr.thread_priority(not_ii_sptr self) → int

gnuradio.blocks.not_ss(size_t vlen=1) → not_ss_sptr

output = ~input

bitwise boolean not of input streams.

Constructor Specific Documentation:

Parameters:vlen –

not_ss_sptr.active_thread_priority(not_ss_sptr self) → int

not_ss_sptr.declare_sample_delay(not_ss_sptr self, int which, int delay)

declare_sample_delay(not_ss_sptr self, unsigned int delay)

not_ss_sptr.message_subscribers(not_ss_sptr self, swig_int_ptr which_port) → swig_int_ptr

not_ss_sptr.min_noutput_items(not_ss_sptr self) → int

not_ss_sptr.pc_input_buffers_full_avg(not_ss_sptr self, int which) → float

pc_input_buffers_full_avg(not_ss_sptr self) -> pmt_vector_float

not_ss_sptr.pc_noutput_items_avg(not_ss_sptr self) → float

not_ss_sptr.pc_nproduced_avg(not_ss_sptr self) → float

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

pc_output_buffers_full_avg(not_ss_sptr self) -> pmt_vector_float

not_ss_sptr.pc_throughput_avg(not_ss_sptr self) → float

not_ss_sptr.pc_work_time_avg(not_ss_sptr self) → float

not_ss_sptr.pc_work_time_total(not_ss_sptr self) → float

not_ss_sptr.sample_delay(not_ss_sptr self, int which) → unsigned int

not_ss_sptr.set_min_noutput_items(not_ss_sptr self, int m)

not_ss_sptr.set_thread_priority(not_ss_sptr self, int priority) → int

not_ss_sptr.thread_priority(not_ss_sptr self) → int

gnuradio.blocks.or_bb(size_t vlen=1) → or_bb_sptr

output = input_0 | input_1 | , ... | input_N)

Bitwise boolean or across all input streams.

Constructor Specific Documentation:

Parameters:vlen –

or_bb_sptr.active_thread_priority(or_bb_sptr self) → int

or_bb_sptr.declare_sample_delay(or_bb_sptr self, int which, int delay)

declare_sample_delay(or_bb_sptr self, unsigned int delay)

or_bb_sptr.message_subscribers(or_bb_sptr self, swig_int_ptr which_port) → swig_int_ptr

or_bb_sptr.min_noutput_items(or_bb_sptr self) → int

or_bb_sptr.pc_input_buffers_full_avg(or_bb_sptr self, int which) → float

pc_input_buffers_full_avg(or_bb_sptr self) -> pmt_vector_float

or_bb_sptr.pc_noutput_items_avg(or_bb_sptr self) → float

or_bb_sptr.pc_nproduced_avg(or_bb_sptr self) → float

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

pc_output_buffers_full_avg(or_bb_sptr self) -> pmt_vector_float

or_bb_sptr.pc_throughput_avg(or_bb_sptr self) → float

or_bb_sptr.pc_work_time_avg(or_bb_sptr self) → float

or_bb_sptr.pc_work_time_total(or_bb_sptr self) → float

or_bb_sptr.sample_delay(or_bb_sptr self, int which) → unsigned int

or_bb_sptr.set_min_noutput_items(or_bb_sptr self, int m)

or_bb_sptr.set_thread_priority(or_bb_sptr self, int priority) → int

or_bb_sptr.thread_priority(or_bb_sptr self) → int

gnuradio.blocks.or_ii(size_t vlen=1) → or_ii_sptr

output = input_0 | input_1 | , ... | input_N)

Bitwise boolean or across all input streams.

Constructor Specific Documentation:

Parameters:vlen –

or_ii_sptr.active_thread_priority(or_ii_sptr self) → int

or_ii_sptr.declare_sample_delay(or_ii_sptr self, int which, int delay)

declare_sample_delay(or_ii_sptr self, unsigned int delay)

or_ii_sptr.message_subscribers(or_ii_sptr self, swig_int_ptr which_port) → swig_int_ptr

or_ii_sptr.min_noutput_items(or_ii_sptr self) → int

or_ii_sptr.pc_input_buffers_full_avg(or_ii_sptr self, int which) → float

pc_input_buffers_full_avg(or_ii_sptr self) -> pmt_vector_float

or_ii_sptr.pc_noutput_items_avg(or_ii_sptr self) → float

or_ii_sptr.pc_nproduced_avg(or_ii_sptr self) → float

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

pc_output_buffers_full_avg(or_ii_sptr self) -> pmt_vector_float

or_ii_sptr.pc_throughput_avg(or_ii_sptr self) → float

or_ii_sptr.pc_work_time_avg(or_ii_sptr self) → float

or_ii_sptr.pc_work_time_total(or_ii_sptr self) → float

or_ii_sptr.sample_delay(or_ii_sptr self, int which) → unsigned int

or_ii_sptr.set_min_noutput_items(or_ii_sptr self, int m)

or_ii_sptr.set_thread_priority(or_ii_sptr self, int priority) → int

or_ii_sptr.thread_priority(or_ii_sptr self) → int

gnuradio.blocks.or_ss(size_t vlen=1) → or_ss_sptr

output = input_0 | input_1 | , ... | input_N)

Bitwise boolean or across all input streams.

Constructor Specific Documentation:

Parameters:vlen –

or_ss_sptr.active_thread_priority(or_ss_sptr self) → int

or_ss_sptr.declare_sample_delay(or_ss_sptr self, int which, int delay)

declare_sample_delay(or_ss_sptr self, unsigned int delay)

or_ss_sptr.message_subscribers(or_ss_sptr self, swig_int_ptr which_port) → swig_int_ptr

or_ss_sptr.min_noutput_items(or_ss_sptr self) → int

or_ss_sptr.pc_input_buffers_full_avg(or_ss_sptr self, int which) → float

pc_input_buffers_full_avg(or_ss_sptr self) -> pmt_vector_float

or_ss_sptr.pc_noutput_items_avg(or_ss_sptr self) → float

or_ss_sptr.pc_nproduced_avg(or_ss_sptr self) → float

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

pc_output_buffers_full_avg(or_ss_sptr self) -> pmt_vector_float

or_ss_sptr.pc_throughput_avg(or_ss_sptr self) → float

or_ss_sptr.pc_work_time_avg(or_ss_sptr self) → float

or_ss_sptr.pc_work_time_total(or_ss_sptr self) → float

or_ss_sptr.sample_delay(or_ss_sptr self, int which) → unsigned int

or_ss_sptr.set_min_noutput_items(or_ss_sptr self, int m)

or_ss_sptr.set_thread_priority(or_ss_sptr self, int priority) → int

or_ss_sptr.thread_priority(or_ss_sptr self) → int

gnuradio.blocks.xor_bb(size_t vlen=1) → xor_bb_sptr

output = input_0 ^ input_1 ^ , ... ^ input_N)

Bitwise boolean xor across all input streams.

Constructor Specific Documentation:

Parameters:vlen –

xor_bb_sptr.active_thread_priority(xor_bb_sptr self) → int

xor_bb_sptr.declare_sample_delay(xor_bb_sptr self, int which, int delay)

declare_sample_delay(xor_bb_sptr self, unsigned int delay)

xor_bb_sptr.message_subscribers(xor_bb_sptr self, swig_int_ptr which_port) → swig_int_ptr

xor_bb_sptr.min_noutput_items(xor_bb_sptr self) → int

xor_bb_sptr.pc_input_buffers_full_avg(xor_bb_sptr self, int which) → float

pc_input_buffers_full_avg(xor_bb_sptr self) -> pmt_vector_float

xor_bb_sptr.pc_noutput_items_avg(xor_bb_sptr self) → float

xor_bb_sptr.pc_nproduced_avg(xor_bb_sptr self) → float

xor_bb_sptr.pc_output_buffers_full_avg(xor_bb_sptr self, int which) → float

pc_output_buffers_full_avg(xor_bb_sptr self) -> pmt_vector_float

xor_bb_sptr.pc_throughput_avg(xor_bb_sptr self) → float

xor_bb_sptr.pc_work_time_avg(xor_bb_sptr self) → float

xor_bb_sptr.pc_work_time_total(xor_bb_sptr self) → float

xor_bb_sptr.sample_delay(xor_bb_sptr self, int which) → unsigned int

xor_bb_sptr.set_min_noutput_items(xor_bb_sptr self, int m)

xor_bb_sptr.set_thread_priority(xor_bb_sptr self, int priority) → int

xor_bb_sptr.thread_priority(xor_bb_sptr self) → int

gnuradio.blocks.xor_ii(size_t vlen=1) → xor_ii_sptr

output = input_0 ^ input_1 ^ , ... ^ input_N)

Bitwise boolean xor across all input streams.

Constructor Specific Documentation:

Parameters:vlen –

xor_ii_sptr.active_thread_priority(xor_ii_sptr self) → int

xor_ii_sptr.declare_sample_delay(xor_ii_sptr self, int which, int delay)

declare_sample_delay(xor_ii_sptr self, unsigned int delay)

xor_ii_sptr.message_subscribers(xor_ii_sptr self, swig_int_ptr which_port) → swig_int_ptr

xor_ii_sptr.min_noutput_items(xor_ii_sptr self) → int

xor_ii_sptr.pc_input_buffers_full_avg(xor_ii_sptr self, int which) → float

pc_input_buffers_full_avg(xor_ii_sptr self) -> pmt_vector_float

xor_ii_sptr.pc_noutput_items_avg(xor_ii_sptr self) → float

xor_ii_sptr.pc_nproduced_avg(xor_ii_sptr self) → float

xor_ii_sptr.pc_output_buffers_full_avg(xor_ii_sptr self, int which) → float

pc_output_buffers_full_avg(xor_ii_sptr self) -> pmt_vector_float

xor_ii_sptr.pc_throughput_avg(xor_ii_sptr self) → float

xor_ii_sptr.pc_work_time_avg(xor_ii_sptr self) → float

xor_ii_sptr.pc_work_time_total(xor_ii_sptr self) → float

xor_ii_sptr.sample_delay(xor_ii_sptr self, int which) → unsigned int

xor_ii_sptr.set_min_noutput_items(xor_ii_sptr self, int m)

xor_ii_sptr.set_thread_priority(xor_ii_sptr self, int priority) → int

xor_ii_sptr.thread_priority(xor_ii_sptr self) → int

gnuradio.blocks.xor_ss(size_t vlen=1) → xor_ss_sptr

output = input_0 ^ input_1 ^ , ... ^ input_N)

Bitwise boolean xor across all input streams.

Constructor Specific Documentation:

Parameters:vlen –

xor_ss_sptr.active_thread_priority(xor_ss_sptr self) → int

xor_ss_sptr.declare_sample_delay(xor_ss_sptr self, int which, int delay)

declare_sample_delay(xor_ss_sptr self, unsigned int delay)

xor_ss_sptr.message_subscribers(xor_ss_sptr self, swig_int_ptr which_port) → swig_int_ptr

xor_ss_sptr.min_noutput_items(xor_ss_sptr self) → int

xor_ss_sptr.pc_input_buffers_full_avg(xor_ss_sptr self, int which) → float

pc_input_buffers_full_avg(xor_ss_sptr self) -> pmt_vector_float

xor_ss_sptr.pc_noutput_items_avg(xor_ss_sptr self) → float

xor_ss_sptr.pc_nproduced_avg(xor_ss_sptr self) → float

xor_ss_sptr.pc_output_buffers_full_avg(xor_ss_sptr self, int which) → float

pc_output_buffers_full_avg(xor_ss_sptr self) -> pmt_vector_float

xor_ss_sptr.pc_throughput_avg(xor_ss_sptr self) → float

xor_ss_sptr.pc_work_time_avg(xor_ss_sptr self) → float

xor_ss_sptr.pc_work_time_total(xor_ss_sptr self) → float

xor_ss_sptr.sample_delay(xor_ss_sptr self, int which) → unsigned int

xor_ss_sptr.set_min_noutput_items(xor_ss_sptr self, int m)

xor_ss_sptr.set_thread_priority(xor_ss_sptr self, int priority) → int

xor_ss_sptr.thread_priority(xor_ss_sptr self) → int