gnuradio.trellis

Blocks and utilities for trellis coding and related.

gnuradio.trellis.constellation_metrics_cf(gr::digital::constellation_sptr constellation, gr::digital::trellis_metric_type_t TYPE) → constellation_metrics_cf_sptr

constellation_metrics_cf_sptr.active_thread_priority(constellation_metrics_cf_sptr self) → int

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

declare_sample_delay(constellation_metrics_cf_sptr self, unsigned int delay)

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

constellation_metrics_cf_sptr.min_noutput_items(constellation_metrics_cf_sptr self) → int

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

pc_input_buffers_full_avg(constellation_metrics_cf_sptr self) -> pmt_vector_float

constellation_metrics_cf_sptr.pc_noutput_items_avg(constellation_metrics_cf_sptr self) → float

constellation_metrics_cf_sptr.pc_nproduced_avg(constellation_metrics_cf_sptr self) → float

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

pc_output_buffers_full_avg(constellation_metrics_cf_sptr self) -> pmt_vector_float

constellation_metrics_cf_sptr.pc_throughput_avg(constellation_metrics_cf_sptr self) → float

constellation_metrics_cf_sptr.pc_work_time_avg(constellation_metrics_cf_sptr self) → float

constellation_metrics_cf_sptr.pc_work_time_total(constellation_metrics_cf_sptr self) → float

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

constellation_metrics_cf_sptr.set_min_noutput_items(constellation_metrics_cf_sptr self, int m)

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

constellation_metrics_cf_sptr.thread_priority(constellation_metrics_cf_sptr self) → int

gnuradio.trellis.encoder_bb(fsm FSM, int ST) → encoder_bb_sptr

make(fsm FSM, int ST, int K) -> encoder_bb_sptr

encoder_bb_sptr.FSM(encoder_bb_sptr self) → fsm

encoder_bb_sptr.K(encoder_bb_sptr self) → int

encoder_bb_sptr.ST(encoder_bb_sptr self) → int

encoder_bb_sptr.active_thread_priority(encoder_bb_sptr self) → int

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

declare_sample_delay(encoder_bb_sptr self, unsigned int delay)

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

encoder_bb_sptr.min_noutput_items(encoder_bb_sptr self) → int

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

pc_input_buffers_full_avg(encoder_bb_sptr self) -> pmt_vector_float

encoder_bb_sptr.pc_noutput_items_avg(encoder_bb_sptr self) → float

encoder_bb_sptr.pc_nproduced_avg(encoder_bb_sptr self) → float

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

pc_output_buffers_full_avg(encoder_bb_sptr self) -> pmt_vector_float

encoder_bb_sptr.pc_throughput_avg(encoder_bb_sptr self) → float

encoder_bb_sptr.pc_work_time_avg(encoder_bb_sptr self) → float

encoder_bb_sptr.pc_work_time_total(encoder_bb_sptr self) → float

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

encoder_bb_sptr.set_FSM(encoder_bb_sptr self, fsm FSM)

encoder_bb_sptr.set_K(encoder_bb_sptr self, int K)

encoder_bb_sptr.set_ST(encoder_bb_sptr self, int ST)

encoder_bb_sptr.set_min_noutput_items(encoder_bb_sptr self, int m)

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

encoder_bb_sptr.thread_priority(encoder_bb_sptr self) → int

gnuradio.trellis.encoder_bi(fsm FSM, int ST) → encoder_bi_sptr

make(fsm FSM, int ST, int K) -> encoder_bi_sptr

encoder_bi_sptr.FSM(encoder_bi_sptr self) → fsm

encoder_bi_sptr.K(encoder_bi_sptr self) → int

encoder_bi_sptr.ST(encoder_bi_sptr self) → int

encoder_bi_sptr.active_thread_priority(encoder_bi_sptr self) → int

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

declare_sample_delay(encoder_bi_sptr self, unsigned int delay)

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

encoder_bi_sptr.min_noutput_items(encoder_bi_sptr self) → int

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

pc_input_buffers_full_avg(encoder_bi_sptr self) -> pmt_vector_float

encoder_bi_sptr.pc_noutput_items_avg(encoder_bi_sptr self) → float

encoder_bi_sptr.pc_nproduced_avg(encoder_bi_sptr self) → float

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

pc_output_buffers_full_avg(encoder_bi_sptr self) -> pmt_vector_float

encoder_bi_sptr.pc_throughput_avg(encoder_bi_sptr self) → float

encoder_bi_sptr.pc_work_time_avg(encoder_bi_sptr self) → float

encoder_bi_sptr.pc_work_time_total(encoder_bi_sptr self) → float

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

encoder_bi_sptr.set_FSM(encoder_bi_sptr self, fsm FSM)

encoder_bi_sptr.set_K(encoder_bi_sptr self, int K)

encoder_bi_sptr.set_ST(encoder_bi_sptr self, int ST)

encoder_bi_sptr.set_min_noutput_items(encoder_bi_sptr self, int m)

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

encoder_bi_sptr.thread_priority(encoder_bi_sptr self) → int

gnuradio.trellis.encoder_bs(fsm FSM, int ST) → encoder_bs_sptr

make(fsm FSM, int ST, int K) -> encoder_bs_sptr

encoder_bs_sptr.FSM(encoder_bs_sptr self) → fsm

encoder_bs_sptr.K(encoder_bs_sptr self) → int

encoder_bs_sptr.ST(encoder_bs_sptr self) → int

encoder_bs_sptr.active_thread_priority(encoder_bs_sptr self) → int

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

declare_sample_delay(encoder_bs_sptr self, unsigned int delay)

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

encoder_bs_sptr.min_noutput_items(encoder_bs_sptr self) → int

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

pc_input_buffers_full_avg(encoder_bs_sptr self) -> pmt_vector_float

encoder_bs_sptr.pc_noutput_items_avg(encoder_bs_sptr self) → float

encoder_bs_sptr.pc_nproduced_avg(encoder_bs_sptr self) → float

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

pc_output_buffers_full_avg(encoder_bs_sptr self) -> pmt_vector_float

encoder_bs_sptr.pc_throughput_avg(encoder_bs_sptr self) → float

encoder_bs_sptr.pc_work_time_avg(encoder_bs_sptr self) → float

encoder_bs_sptr.pc_work_time_total(encoder_bs_sptr self) → float

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

encoder_bs_sptr.set_FSM(encoder_bs_sptr self, fsm FSM)

encoder_bs_sptr.set_K(encoder_bs_sptr self, int K)

encoder_bs_sptr.set_ST(encoder_bs_sptr self, int ST)

encoder_bs_sptr.set_min_noutput_items(encoder_bs_sptr self, int m)

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

encoder_bs_sptr.thread_priority(encoder_bs_sptr self) → int

gnuradio.trellis.encoder_ii(fsm FSM, int ST) → encoder_ii_sptr

make(fsm FSM, int ST, int K) -> encoder_ii_sptr

encoder_ii_sptr.FSM(encoder_ii_sptr self) → fsm

encoder_ii_sptr.K(encoder_ii_sptr self) → int

encoder_ii_sptr.ST(encoder_ii_sptr self) → int

encoder_ii_sptr.active_thread_priority(encoder_ii_sptr self) → int

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

declare_sample_delay(encoder_ii_sptr self, unsigned int delay)

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

encoder_ii_sptr.min_noutput_items(encoder_ii_sptr self) → int

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

pc_input_buffers_full_avg(encoder_ii_sptr self) -> pmt_vector_float

encoder_ii_sptr.pc_noutput_items_avg(encoder_ii_sptr self) → float

encoder_ii_sptr.pc_nproduced_avg(encoder_ii_sptr self) → float

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

pc_output_buffers_full_avg(encoder_ii_sptr self) -> pmt_vector_float

encoder_ii_sptr.pc_throughput_avg(encoder_ii_sptr self) → float

encoder_ii_sptr.pc_work_time_avg(encoder_ii_sptr self) → float

encoder_ii_sptr.pc_work_time_total(encoder_ii_sptr self) → float

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

encoder_ii_sptr.set_FSM(encoder_ii_sptr self, fsm FSM)

encoder_ii_sptr.set_K(encoder_ii_sptr self, int K)

encoder_ii_sptr.set_ST(encoder_ii_sptr self, int ST)

encoder_ii_sptr.set_min_noutput_items(encoder_ii_sptr self, int m)

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

encoder_ii_sptr.thread_priority(encoder_ii_sptr self) → int

gnuradio.trellis.encoder_si(fsm FSM, int ST) → encoder_si_sptr

make(fsm FSM, int ST, int K) -> encoder_si_sptr

encoder_si_sptr.FSM(encoder_si_sptr self) → fsm

encoder_si_sptr.K(encoder_si_sptr self) → int

encoder_si_sptr.ST(encoder_si_sptr self) → int

encoder_si_sptr.active_thread_priority(encoder_si_sptr self) → int

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

declare_sample_delay(encoder_si_sptr self, unsigned int delay)

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

encoder_si_sptr.min_noutput_items(encoder_si_sptr self) → int

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

pc_input_buffers_full_avg(encoder_si_sptr self) -> pmt_vector_float

encoder_si_sptr.pc_noutput_items_avg(encoder_si_sptr self) → float

encoder_si_sptr.pc_nproduced_avg(encoder_si_sptr self) → float

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

pc_output_buffers_full_avg(encoder_si_sptr self) -> pmt_vector_float

encoder_si_sptr.pc_throughput_avg(encoder_si_sptr self) → float

encoder_si_sptr.pc_work_time_avg(encoder_si_sptr self) → float

encoder_si_sptr.pc_work_time_total(encoder_si_sptr self) → float

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

encoder_si_sptr.set_FSM(encoder_si_sptr self, fsm FSM)

encoder_si_sptr.set_K(encoder_si_sptr self, int K)

encoder_si_sptr.set_ST(encoder_si_sptr self, int ST)

encoder_si_sptr.set_min_noutput_items(encoder_si_sptr self, int m)

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

encoder_si_sptr.thread_priority(encoder_si_sptr self) → int

gnuradio.trellis.encoder_ss(fsm FSM, int ST) → encoder_ss_sptr

make(fsm FSM, int ST, int K) -> encoder_ss_sptr

encoder_ss_sptr.FSM(encoder_ss_sptr self) → fsm

encoder_ss_sptr.K(encoder_ss_sptr self) → int

encoder_ss_sptr.ST(encoder_ss_sptr self) → int

encoder_ss_sptr.active_thread_priority(encoder_ss_sptr self) → int

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

declare_sample_delay(encoder_ss_sptr self, unsigned int delay)

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

encoder_ss_sptr.min_noutput_items(encoder_ss_sptr self) → int

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

pc_input_buffers_full_avg(encoder_ss_sptr self) -> pmt_vector_float

encoder_ss_sptr.pc_noutput_items_avg(encoder_ss_sptr self) → float

encoder_ss_sptr.pc_nproduced_avg(encoder_ss_sptr self) → float

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

pc_output_buffers_full_avg(encoder_ss_sptr self) -> pmt_vector_float

encoder_ss_sptr.pc_throughput_avg(encoder_ss_sptr self) → float

encoder_ss_sptr.pc_work_time_avg(encoder_ss_sptr self) → float

encoder_ss_sptr.pc_work_time_total(encoder_ss_sptr self) → float

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

encoder_ss_sptr.set_FSM(encoder_ss_sptr self, fsm FSM)

encoder_ss_sptr.set_K(encoder_ss_sptr self, int K)

encoder_ss_sptr.set_ST(encoder_ss_sptr self, int ST)

encoder_ss_sptr.set_min_noutput_items(encoder_ss_sptr self, int m)

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

encoder_ss_sptr.thread_priority(encoder_ss_sptr self) → int

gnuradio.trellis.metrics_c(int O, int D, pmt_vector_cfloat TABLE, gr::digital::trellis_metric_type_t TYPE) → metrics_c_sptr

metrics_c_sptr.D(metrics_c_sptr self) → int

metrics_c_sptr.O(metrics_c_sptr self) → int

metrics_c_sptr.TABLE(metrics_c_sptr self) → pmt_vector_cfloat

metrics_c_sptr.TYPE(metrics_c_sptr self) → gr::digital::trellis_metric_type_t

metrics_c_sptr.active_thread_priority(metrics_c_sptr self) → int

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

declare_sample_delay(metrics_c_sptr self, unsigned int delay)

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

metrics_c_sptr.min_noutput_items(metrics_c_sptr self) → int

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

pc_input_buffers_full_avg(metrics_c_sptr self) -> pmt_vector_float

metrics_c_sptr.pc_noutput_items_avg(metrics_c_sptr self) → float

metrics_c_sptr.pc_nproduced_avg(metrics_c_sptr self) → float

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

pc_output_buffers_full_avg(metrics_c_sptr self) -> pmt_vector_float

metrics_c_sptr.pc_throughput_avg(metrics_c_sptr self) → float

metrics_c_sptr.pc_work_time_avg(metrics_c_sptr self) → float

metrics_c_sptr.pc_work_time_total(metrics_c_sptr self) → float

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

metrics_c_sptr.set_D(metrics_c_sptr self, int D)

metrics_c_sptr.set_O(metrics_c_sptr self, int O)

metrics_c_sptr.set_TABLE(metrics_c_sptr self, pmt_vector_cfloat table)

metrics_c_sptr.set_TYPE(metrics_c_sptr self, gr::digital::trellis_metric_type_t type)

metrics_c_sptr.set_min_noutput_items(metrics_c_sptr self, int m)

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

metrics_c_sptr.thread_priority(metrics_c_sptr self) → int

gnuradio.trellis.metrics_f(int O, int D, pmt_vector_float TABLE, gr::digital::trellis_metric_type_t TYPE) → metrics_f_sptr

metrics_f_sptr.D(metrics_f_sptr self) → int

metrics_f_sptr.O(metrics_f_sptr self) → int

metrics_f_sptr.TABLE(metrics_f_sptr self) → pmt_vector_float

metrics_f_sptr.TYPE(metrics_f_sptr self) → gr::digital::trellis_metric_type_t

metrics_f_sptr.active_thread_priority(metrics_f_sptr self) → int

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

declare_sample_delay(metrics_f_sptr self, unsigned int delay)

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

metrics_f_sptr.min_noutput_items(metrics_f_sptr self) → int

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

pc_input_buffers_full_avg(metrics_f_sptr self) -> pmt_vector_float

metrics_f_sptr.pc_noutput_items_avg(metrics_f_sptr self) → float

metrics_f_sptr.pc_nproduced_avg(metrics_f_sptr self) → float

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

pc_output_buffers_full_avg(metrics_f_sptr self) -> pmt_vector_float

metrics_f_sptr.pc_throughput_avg(metrics_f_sptr self) → float

metrics_f_sptr.pc_work_time_avg(metrics_f_sptr self) → float

metrics_f_sptr.pc_work_time_total(metrics_f_sptr self) → float

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

metrics_f_sptr.set_D(metrics_f_sptr self, int D)

metrics_f_sptr.set_O(metrics_f_sptr self, int O)

metrics_f_sptr.set_TABLE(metrics_f_sptr self, pmt_vector_float table)

metrics_f_sptr.set_TYPE(metrics_f_sptr self, gr::digital::trellis_metric_type_t type)

metrics_f_sptr.set_min_noutput_items(metrics_f_sptr self, int m)

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

metrics_f_sptr.thread_priority(metrics_f_sptr self) → int

gnuradio.trellis.metrics_i(int O, int D, std::vector< int, std::allocator< int > > const & TABLE, gr::digital::trellis_metric_type_t TYPE) → metrics_i_sptr

metrics_i_sptr.D(metrics_i_sptr self) → int

metrics_i_sptr.O(metrics_i_sptr self) → int

metrics_i_sptr.TABLE(metrics_i_sptr self) → std::vector< int,std::allocator< int > >

metrics_i_sptr.TYPE(metrics_i_sptr self) → gr::digital::trellis_metric_type_t

metrics_i_sptr.active_thread_priority(metrics_i_sptr self) → int

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

declare_sample_delay(metrics_i_sptr self, unsigned int delay)

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

metrics_i_sptr.min_noutput_items(metrics_i_sptr self) → int

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

pc_input_buffers_full_avg(metrics_i_sptr self) -> pmt_vector_float

metrics_i_sptr.pc_noutput_items_avg(metrics_i_sptr self) → float

metrics_i_sptr.pc_nproduced_avg(metrics_i_sptr self) → float

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

pc_output_buffers_full_avg(metrics_i_sptr self) -> pmt_vector_float

metrics_i_sptr.pc_throughput_avg(metrics_i_sptr self) → float

metrics_i_sptr.pc_work_time_avg(metrics_i_sptr self) → float

metrics_i_sptr.pc_work_time_total(metrics_i_sptr self) → float

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

metrics_i_sptr.set_D(metrics_i_sptr self, int D)

metrics_i_sptr.set_O(metrics_i_sptr self, int O)

metrics_i_sptr.set_TABLE(metrics_i_sptr self, std::vector< int, std::allocator< int > > const & table)

metrics_i_sptr.set_TYPE(metrics_i_sptr self, gr::digital::trellis_metric_type_t type)

metrics_i_sptr.set_min_noutput_items(metrics_i_sptr self, int m)

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

metrics_i_sptr.thread_priority(metrics_i_sptr self) → int

gnuradio.trellis.metrics_s(int O, int D, std::vector< short, std::allocator< short > > const & TABLE, gr::digital::trellis_metric_type_t TYPE) → metrics_s_sptr

metrics_s_sptr.D(metrics_s_sptr self) → int

metrics_s_sptr.O(metrics_s_sptr self) → int

metrics_s_sptr.TABLE(metrics_s_sptr self) → std::vector< short,std::allocator< short > >

metrics_s_sptr.TYPE(metrics_s_sptr self) → gr::digital::trellis_metric_type_t

metrics_s_sptr.active_thread_priority(metrics_s_sptr self) → int

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

declare_sample_delay(metrics_s_sptr self, unsigned int delay)

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

metrics_s_sptr.min_noutput_items(metrics_s_sptr self) → int

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

pc_input_buffers_full_avg(metrics_s_sptr self) -> pmt_vector_float

metrics_s_sptr.pc_noutput_items_avg(metrics_s_sptr self) → float

metrics_s_sptr.pc_nproduced_avg(metrics_s_sptr self) → float

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

pc_output_buffers_full_avg(metrics_s_sptr self) -> pmt_vector_float

metrics_s_sptr.pc_throughput_avg(metrics_s_sptr self) → float

metrics_s_sptr.pc_work_time_avg(metrics_s_sptr self) → float

metrics_s_sptr.pc_work_time_total(metrics_s_sptr self) → float

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

metrics_s_sptr.set_D(metrics_s_sptr self, int D)

metrics_s_sptr.set_O(metrics_s_sptr self, int O)

metrics_s_sptr.set_TABLE(metrics_s_sptr self, std::vector< short, std::allocator< short > > const & table)

metrics_s_sptr.set_TYPE(metrics_s_sptr self, gr::digital::trellis_metric_type_t type)

metrics_s_sptr.set_min_noutput_items(metrics_s_sptr self, int m)

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

metrics_s_sptr.thread_priority(metrics_s_sptr self) → int

gnuradio.trellis.pccc_decoder_b(fsm FSM1, int ST10, int ST1K, fsm FSM2, int ST20, int ST2K, interleaver INTERLEAVER, int blocklength, int repetitions, gr::trellis::siso_type_t SISO_TYPE) → pccc_decoder_b_sptr

pccc_decoder_b_sptr.FSM1(pccc_decoder_b_sptr self) → fsm

pccc_decoder_b_sptr.FSM2(pccc_decoder_b_sptr self) → fsm

pccc_decoder_b_sptr.INTERLEAVER(pccc_decoder_b_sptr self) → interleaver

pccc_decoder_b_sptr.SISO_TYPE(pccc_decoder_b_sptr self) → gr::trellis::siso_type_t

pccc_decoder_b_sptr.ST10(pccc_decoder_b_sptr self) → int

pccc_decoder_b_sptr.ST1K(pccc_decoder_b_sptr self) → int

pccc_decoder_b_sptr.ST20(pccc_decoder_b_sptr self) → int

pccc_decoder_b_sptr.ST2K(pccc_decoder_b_sptr self) → int

pccc_decoder_b_sptr.active_thread_priority(pccc_decoder_b_sptr self) → int

pccc_decoder_b_sptr.blocklength(pccc_decoder_b_sptr self) → int

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

declare_sample_delay(pccc_decoder_b_sptr self, unsigned int delay)

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

pccc_decoder_b_sptr.min_noutput_items(pccc_decoder_b_sptr self) → int

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

pc_input_buffers_full_avg(pccc_decoder_b_sptr self) -> pmt_vector_float

pccc_decoder_b_sptr.pc_noutput_items_avg(pccc_decoder_b_sptr self) → float

pccc_decoder_b_sptr.pc_nproduced_avg(pccc_decoder_b_sptr self) → float

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

pc_output_buffers_full_avg(pccc_decoder_b_sptr self) -> pmt_vector_float

pccc_decoder_b_sptr.pc_throughput_avg(pccc_decoder_b_sptr self) → float

pccc_decoder_b_sptr.pc_work_time_avg(pccc_decoder_b_sptr self) → float

pccc_decoder_b_sptr.pc_work_time_total(pccc_decoder_b_sptr self) → float

pccc_decoder_b_sptr.repetitions(pccc_decoder_b_sptr self) → int

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

pccc_decoder_b_sptr.set_min_noutput_items(pccc_decoder_b_sptr self, int m)

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

pccc_decoder_b_sptr.thread_priority(pccc_decoder_b_sptr self) → int

gnuradio.trellis.pccc_decoder_combined_cb(fsm FSMo, int STo0, int SToK, fsm FSMi, int STi0, int STiK, interleaver INTERLEAVER, int blocklength, int repetitions, gr::trellis::siso_type_t SISO_TYPE, int D, pmt_vector_cfloat TABLE, gr::digital::trellis_metric_type_t METRIC_TYPE, float scaling) → pccc_decoder_combined_cb_sptr

pccc_decoder_combined_cb_sptr.D(pccc_decoder_combined_cb_sptr self) → int

pccc_decoder_combined_cb_sptr.FSM1(pccc_decoder_combined_cb_sptr self) → fsm

pccc_decoder_combined_cb_sptr.FSM2(pccc_decoder_combined_cb_sptr self) → fsm

pccc_decoder_combined_cb_sptr.INTERLEAVER(pccc_decoder_combined_cb_sptr self) → interleaver

pccc_decoder_combined_cb_sptr.METRIC_TYPE(pccc_decoder_combined_cb_sptr self) → gr::digital::trellis_metric_type_t

pccc_decoder_combined_cb_sptr.SISO_TYPE(pccc_decoder_combined_cb_sptr self) → gr::trellis::siso_type_t

pccc_decoder_combined_cb_sptr.ST10(pccc_decoder_combined_cb_sptr self) → int

pccc_decoder_combined_cb_sptr.ST1K(pccc_decoder_combined_cb_sptr self) → int

pccc_decoder_combined_cb_sptr.ST20(pccc_decoder_combined_cb_sptr self) → int

pccc_decoder_combined_cb_sptr.ST2K(pccc_decoder_combined_cb_sptr self) → int

pccc_decoder_combined_cb_sptr.TABLE(pccc_decoder_combined_cb_sptr self) → pmt_vector_cfloat

pccc_decoder_combined_cb_sptr.active_thread_priority(pccc_decoder_combined_cb_sptr self) → int

pccc_decoder_combined_cb_sptr.blocklength(pccc_decoder_combined_cb_sptr self) → int

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

declare_sample_delay(pccc_decoder_combined_cb_sptr self, unsigned int delay)

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

pccc_decoder_combined_cb_sptr.min_noutput_items(pccc_decoder_combined_cb_sptr self) → int

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

pc_input_buffers_full_avg(pccc_decoder_combined_cb_sptr self) -> pmt_vector_float

pccc_decoder_combined_cb_sptr.pc_noutput_items_avg(pccc_decoder_combined_cb_sptr self) → float

pccc_decoder_combined_cb_sptr.pc_nproduced_avg(pccc_decoder_combined_cb_sptr self) → float

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

pc_output_buffers_full_avg(pccc_decoder_combined_cb_sptr self) -> pmt_vector_float

pccc_decoder_combined_cb_sptr.pc_throughput_avg(pccc_decoder_combined_cb_sptr self) → float

pccc_decoder_combined_cb_sptr.pc_work_time_avg(pccc_decoder_combined_cb_sptr self) → float

pccc_decoder_combined_cb_sptr.pc_work_time_total(pccc_decoder_combined_cb_sptr self) → float

pccc_decoder_combined_cb_sptr.repetitions(pccc_decoder_combined_cb_sptr self) → int

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

pccc_decoder_combined_cb_sptr.scaling(pccc_decoder_combined_cb_sptr self) → float

pccc_decoder_combined_cb_sptr.set_min_noutput_items(pccc_decoder_combined_cb_sptr self, int m)

pccc_decoder_combined_cb_sptr.set_scaling(pccc_decoder_combined_cb_sptr self, float scaling)

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

pccc_decoder_combined_cb_sptr.thread_priority(pccc_decoder_combined_cb_sptr self) → int

gnuradio.trellis.pccc_decoder_combined_ci(fsm FSMo, int STo0, int SToK, fsm FSMi, int STi0, int STiK, interleaver INTERLEAVER, int blocklength, int repetitions, gr::trellis::siso_type_t SISO_TYPE, int D, pmt_vector_cfloat TABLE, gr::digital::trellis_metric_type_t METRIC_TYPE, float scaling) → pccc_decoder_combined_ci_sptr

pccc_decoder_combined_ci_sptr.D(pccc_decoder_combined_ci_sptr self) → int

pccc_decoder_combined_ci_sptr.FSM1(pccc_decoder_combined_ci_sptr self) → fsm

pccc_decoder_combined_ci_sptr.FSM2(pccc_decoder_combined_ci_sptr self) → fsm

pccc_decoder_combined_ci_sptr.INTERLEAVER(pccc_decoder_combined_ci_sptr self) → interleaver

pccc_decoder_combined_ci_sptr.METRIC_TYPE(pccc_decoder_combined_ci_sptr self) → gr::digital::trellis_metric_type_t

pccc_decoder_combined_ci_sptr.SISO_TYPE(pccc_decoder_combined_ci_sptr self) → gr::trellis::siso_type_t

pccc_decoder_combined_ci_sptr.ST10(pccc_decoder_combined_ci_sptr self) → int

pccc_decoder_combined_ci_sptr.ST1K(pccc_decoder_combined_ci_sptr self) → int

pccc_decoder_combined_ci_sptr.ST20(pccc_decoder_combined_ci_sptr self) → int

pccc_decoder_combined_ci_sptr.ST2K(pccc_decoder_combined_ci_sptr self) → int

pccc_decoder_combined_ci_sptr.TABLE(pccc_decoder_combined_ci_sptr self) → pmt_vector_cfloat

pccc_decoder_combined_ci_sptr.active_thread_priority(pccc_decoder_combined_ci_sptr self) → int

pccc_decoder_combined_ci_sptr.blocklength(pccc_decoder_combined_ci_sptr self) → int

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

declare_sample_delay(pccc_decoder_combined_ci_sptr self, unsigned int delay)

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

pccc_decoder_combined_ci_sptr.min_noutput_items(pccc_decoder_combined_ci_sptr self) → int

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

pc_input_buffers_full_avg(pccc_decoder_combined_ci_sptr self) -> pmt_vector_float

pccc_decoder_combined_ci_sptr.pc_noutput_items_avg(pccc_decoder_combined_ci_sptr self) → float

pccc_decoder_combined_ci_sptr.pc_nproduced_avg(pccc_decoder_combined_ci_sptr self) → float

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

pc_output_buffers_full_avg(pccc_decoder_combined_ci_sptr self) -> pmt_vector_float

pccc_decoder_combined_ci_sptr.pc_throughput_avg(pccc_decoder_combined_ci_sptr self) → float

pccc_decoder_combined_ci_sptr.pc_work_time_avg(pccc_decoder_combined_ci_sptr self) → float

pccc_decoder_combined_ci_sptr.pc_work_time_total(pccc_decoder_combined_ci_sptr self) → float

pccc_decoder_combined_ci_sptr.repetitions(pccc_decoder_combined_ci_sptr self) → int

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

pccc_decoder_combined_ci_sptr.scaling(pccc_decoder_combined_ci_sptr self) → float

pccc_decoder_combined_ci_sptr.set_min_noutput_items(pccc_decoder_combined_ci_sptr self, int m)

pccc_decoder_combined_ci_sptr.set_scaling(pccc_decoder_combined_ci_sptr self, float scaling)

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

pccc_decoder_combined_ci_sptr.thread_priority(pccc_decoder_combined_ci_sptr self) → int

gnuradio.trellis.pccc_decoder_combined_cs(fsm FSMo, int STo0, int SToK, fsm FSMi, int STi0, int STiK, interleaver INTERLEAVER, int blocklength, int repetitions, gr::trellis::siso_type_t SISO_TYPE, int D, pmt_vector_cfloat TABLE, gr::digital::trellis_metric_type_t METRIC_TYPE, float scaling) → pccc_decoder_combined_cs_sptr

pccc_decoder_combined_cs_sptr.D(pccc_decoder_combined_cs_sptr self) → int

pccc_decoder_combined_cs_sptr.FSM1(pccc_decoder_combined_cs_sptr self) → fsm

pccc_decoder_combined_cs_sptr.FSM2(pccc_decoder_combined_cs_sptr self) → fsm

pccc_decoder_combined_cs_sptr.INTERLEAVER(pccc_decoder_combined_cs_sptr self) → interleaver

pccc_decoder_combined_cs_sptr.METRIC_TYPE(pccc_decoder_combined_cs_sptr self) → gr::digital::trellis_metric_type_t

pccc_decoder_combined_cs_sptr.SISO_TYPE(pccc_decoder_combined_cs_sptr self) → gr::trellis::siso_type_t

pccc_decoder_combined_cs_sptr.ST10(pccc_decoder_combined_cs_sptr self) → int

pccc_decoder_combined_cs_sptr.ST1K(pccc_decoder_combined_cs_sptr self) → int

pccc_decoder_combined_cs_sptr.ST20(pccc_decoder_combined_cs_sptr self) → int

pccc_decoder_combined_cs_sptr.ST2K(pccc_decoder_combined_cs_sptr self) → int

pccc_decoder_combined_cs_sptr.TABLE(pccc_decoder_combined_cs_sptr self) → pmt_vector_cfloat

pccc_decoder_combined_cs_sptr.active_thread_priority(pccc_decoder_combined_cs_sptr self) → int

pccc_decoder_combined_cs_sptr.blocklength(pccc_decoder_combined_cs_sptr self) → int

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

declare_sample_delay(pccc_decoder_combined_cs_sptr self, unsigned int delay)

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

pccc_decoder_combined_cs_sptr.min_noutput_items(pccc_decoder_combined_cs_sptr self) → int

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

pc_input_buffers_full_avg(pccc_decoder_combined_cs_sptr self) -> pmt_vector_float

pccc_decoder_combined_cs_sptr.pc_noutput_items_avg(pccc_decoder_combined_cs_sptr self) → float

pccc_decoder_combined_cs_sptr.pc_nproduced_avg(pccc_decoder_combined_cs_sptr self) → float

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

pc_output_buffers_full_avg(pccc_decoder_combined_cs_sptr self) -> pmt_vector_float

pccc_decoder_combined_cs_sptr.pc_throughput_avg(pccc_decoder_combined_cs_sptr self) → float

pccc_decoder_combined_cs_sptr.pc_work_time_avg(pccc_decoder_combined_cs_sptr self) → float

pccc_decoder_combined_cs_sptr.pc_work_time_total(pccc_decoder_combined_cs_sptr self) → float

pccc_decoder_combined_cs_sptr.repetitions(pccc_decoder_combined_cs_sptr self) → int

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

pccc_decoder_combined_cs_sptr.scaling(pccc_decoder_combined_cs_sptr self) → float

pccc_decoder_combined_cs_sptr.set_min_noutput_items(pccc_decoder_combined_cs_sptr self, int m)

pccc_decoder_combined_cs_sptr.set_scaling(pccc_decoder_combined_cs_sptr self, float scaling)

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

pccc_decoder_combined_cs_sptr.thread_priority(pccc_decoder_combined_cs_sptr self) → int

gnuradio.trellis.pccc_decoder_combined_fb(fsm FSMo, int STo0, int SToK, fsm FSMi, int STi0, int STiK, interleaver INTERLEAVER, int blocklength, int repetitions, gr::trellis::siso_type_t SISO_TYPE, int D, pmt_vector_float TABLE, gr::digital::trellis_metric_type_t METRIC_TYPE, float scaling) → pccc_decoder_combined_fb_sptr

pccc_decoder_combined_fb_sptr.D(pccc_decoder_combined_fb_sptr self) → int

pccc_decoder_combined_fb_sptr.FSM1(pccc_decoder_combined_fb_sptr self) → fsm

pccc_decoder_combined_fb_sptr.FSM2(pccc_decoder_combined_fb_sptr self) → fsm

pccc_decoder_combined_fb_sptr.INTERLEAVER(pccc_decoder_combined_fb_sptr self) → interleaver

pccc_decoder_combined_fb_sptr.METRIC_TYPE(pccc_decoder_combined_fb_sptr self) → gr::digital::trellis_metric_type_t

pccc_decoder_combined_fb_sptr.SISO_TYPE(pccc_decoder_combined_fb_sptr self) → gr::trellis::siso_type_t

pccc_decoder_combined_fb_sptr.ST10(pccc_decoder_combined_fb_sptr self) → int

pccc_decoder_combined_fb_sptr.ST1K(pccc_decoder_combined_fb_sptr self) → int

pccc_decoder_combined_fb_sptr.ST20(pccc_decoder_combined_fb_sptr self) → int

pccc_decoder_combined_fb_sptr.ST2K(pccc_decoder_combined_fb_sptr self) → int

pccc_decoder_combined_fb_sptr.TABLE(pccc_decoder_combined_fb_sptr self) → pmt_vector_float

pccc_decoder_combined_fb_sptr.active_thread_priority(pccc_decoder_combined_fb_sptr self) → int

pccc_decoder_combined_fb_sptr.blocklength(pccc_decoder_combined_fb_sptr self) → int

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

declare_sample_delay(pccc_decoder_combined_fb_sptr self, unsigned int delay)

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

pccc_decoder_combined_fb_sptr.min_noutput_items(pccc_decoder_combined_fb_sptr self) → int

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

pc_input_buffers_full_avg(pccc_decoder_combined_fb_sptr self) -> pmt_vector_float

pccc_decoder_combined_fb_sptr.pc_noutput_items_avg(pccc_decoder_combined_fb_sptr self) → float

pccc_decoder_combined_fb_sptr.pc_nproduced_avg(pccc_decoder_combined_fb_sptr self) → float

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

pc_output_buffers_full_avg(pccc_decoder_combined_fb_sptr self) -> pmt_vector_float

pccc_decoder_combined_fb_sptr.pc_throughput_avg(pccc_decoder_combined_fb_sptr self) → float

pccc_decoder_combined_fb_sptr.pc_work_time_avg(pccc_decoder_combined_fb_sptr self) → float

pccc_decoder_combined_fb_sptr.pc_work_time_total(pccc_decoder_combined_fb_sptr self) → float

pccc_decoder_combined_fb_sptr.repetitions(pccc_decoder_combined_fb_sptr self) → int

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

pccc_decoder_combined_fb_sptr.scaling(pccc_decoder_combined_fb_sptr self) → float

pccc_decoder_combined_fb_sptr.set_min_noutput_items(pccc_decoder_combined_fb_sptr self, int m)

pccc_decoder_combined_fb_sptr.set_scaling(pccc_decoder_combined_fb_sptr self, float scaling)

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

pccc_decoder_combined_fb_sptr.thread_priority(pccc_decoder_combined_fb_sptr self) → int

gnuradio.trellis.pccc_decoder_combined_fi(fsm FSMo, int STo0, int SToK, fsm FSMi, int STi0, int STiK, interleaver INTERLEAVER, int blocklength, int repetitions, gr::trellis::siso_type_t SISO_TYPE, int D, pmt_vector_float TABLE, gr::digital::trellis_metric_type_t METRIC_TYPE, float scaling) → pccc_decoder_combined_fi_sptr

pccc_decoder_combined_fi_sptr.D(pccc_decoder_combined_fi_sptr self) → int

pccc_decoder_combined_fi_sptr.FSM1(pccc_decoder_combined_fi_sptr self) → fsm

pccc_decoder_combined_fi_sptr.FSM2(pccc_decoder_combined_fi_sptr self) → fsm

pccc_decoder_combined_fi_sptr.INTERLEAVER(pccc_decoder_combined_fi_sptr self) → interleaver

pccc_decoder_combined_fi_sptr.METRIC_TYPE(pccc_decoder_combined_fi_sptr self) → gr::digital::trellis_metric_type_t

pccc_decoder_combined_fi_sptr.SISO_TYPE(pccc_decoder_combined_fi_sptr self) → gr::trellis::siso_type_t

pccc_decoder_combined_fi_sptr.ST10(pccc_decoder_combined_fi_sptr self) → int

pccc_decoder_combined_fi_sptr.ST1K(pccc_decoder_combined_fi_sptr self) → int

pccc_decoder_combined_fi_sptr.ST20(pccc_decoder_combined_fi_sptr self) → int

pccc_decoder_combined_fi_sptr.ST2K(pccc_decoder_combined_fi_sptr self) → int

pccc_decoder_combined_fi_sptr.TABLE(pccc_decoder_combined_fi_sptr self) → pmt_vector_float

pccc_decoder_combined_fi_sptr.active_thread_priority(pccc_decoder_combined_fi_sptr self) → int

pccc_decoder_combined_fi_sptr.blocklength(pccc_decoder_combined_fi_sptr self) → int

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

declare_sample_delay(pccc_decoder_combined_fi_sptr self, unsigned int delay)

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

pccc_decoder_combined_fi_sptr.min_noutput_items(pccc_decoder_combined_fi_sptr self) → int

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

pc_input_buffers_full_avg(pccc_decoder_combined_fi_sptr self) -> pmt_vector_float

pccc_decoder_combined_fi_sptr.pc_noutput_items_avg(pccc_decoder_combined_fi_sptr self) → float

pccc_decoder_combined_fi_sptr.pc_nproduced_avg(pccc_decoder_combined_fi_sptr self) → float

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

pc_output_buffers_full_avg(pccc_decoder_combined_fi_sptr self) -> pmt_vector_float

pccc_decoder_combined_fi_sptr.pc_throughput_avg(pccc_decoder_combined_fi_sptr self) → float

pccc_decoder_combined_fi_sptr.pc_work_time_avg(pccc_decoder_combined_fi_sptr self) → float

pccc_decoder_combined_fi_sptr.pc_work_time_total(pccc_decoder_combined_fi_sptr self) → float

pccc_decoder_combined_fi_sptr.repetitions(pccc_decoder_combined_fi_sptr self) → int

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

pccc_decoder_combined_fi_sptr.scaling(pccc_decoder_combined_fi_sptr self) → float

pccc_decoder_combined_fi_sptr.set_min_noutput_items(pccc_decoder_combined_fi_sptr self, int m)

pccc_decoder_combined_fi_sptr.set_scaling(pccc_decoder_combined_fi_sptr self, float scaling)

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

pccc_decoder_combined_fi_sptr.thread_priority(pccc_decoder_combined_fi_sptr self) → int

gnuradio.trellis.pccc_decoder_combined_fs(fsm FSMo, int STo0, int SToK, fsm FSMi, int STi0, int STiK, interleaver INTERLEAVER, int blocklength, int repetitions, gr::trellis::siso_type_t SISO_TYPE, int D, pmt_vector_float TABLE, gr::digital::trellis_metric_type_t METRIC_TYPE, float scaling) → pccc_decoder_combined_fs_sptr

pccc_decoder_combined_fs_sptr.D(pccc_decoder_combined_fs_sptr self) → int

pccc_decoder_combined_fs_sptr.FSM1(pccc_decoder_combined_fs_sptr self) → fsm

pccc_decoder_combined_fs_sptr.FSM2(pccc_decoder_combined_fs_sptr self) → fsm

pccc_decoder_combined_fs_sptr.INTERLEAVER(pccc_decoder_combined_fs_sptr self) → interleaver

pccc_decoder_combined_fs_sptr.METRIC_TYPE(pccc_decoder_combined_fs_sptr self) → gr::digital::trellis_metric_type_t

pccc_decoder_combined_fs_sptr.SISO_TYPE(pccc_decoder_combined_fs_sptr self) → gr::trellis::siso_type_t

pccc_decoder_combined_fs_sptr.ST10(pccc_decoder_combined_fs_sptr self) → int

pccc_decoder_combined_fs_sptr.ST1K(pccc_decoder_combined_fs_sptr self) → int

pccc_decoder_combined_fs_sptr.ST20(pccc_decoder_combined_fs_sptr self) → int

pccc_decoder_combined_fs_sptr.ST2K(pccc_decoder_combined_fs_sptr self) → int

pccc_decoder_combined_fs_sptr.TABLE(pccc_decoder_combined_fs_sptr self) → pmt_vector_float

pccc_decoder_combined_fs_sptr.active_thread_priority(pccc_decoder_combined_fs_sptr self) → int

pccc_decoder_combined_fs_sptr.blocklength(pccc_decoder_combined_fs_sptr self) → int

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

declare_sample_delay(pccc_decoder_combined_fs_sptr self, unsigned int delay)

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

pccc_decoder_combined_fs_sptr.min_noutput_items(pccc_decoder_combined_fs_sptr self) → int

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

pc_input_buffers_full_avg(pccc_decoder_combined_fs_sptr self) -> pmt_vector_float

pccc_decoder_combined_fs_sptr.pc_noutput_items_avg(pccc_decoder_combined_fs_sptr self) → float

pccc_decoder_combined_fs_sptr.pc_nproduced_avg(pccc_decoder_combined_fs_sptr self) → float

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

pc_output_buffers_full_avg(pccc_decoder_combined_fs_sptr self) -> pmt_vector_float

pccc_decoder_combined_fs_sptr.pc_throughput_avg(pccc_decoder_combined_fs_sptr self) → float

pccc_decoder_combined_fs_sptr.pc_work_time_avg(pccc_decoder_combined_fs_sptr self) → float

pccc_decoder_combined_fs_sptr.pc_work_time_total(pccc_decoder_combined_fs_sptr self) → float

pccc_decoder_combined_fs_sptr.repetitions(pccc_decoder_combined_fs_sptr self) → int

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

pccc_decoder_combined_fs_sptr.scaling(pccc_decoder_combined_fs_sptr self) → float

pccc_decoder_combined_fs_sptr.set_min_noutput_items(pccc_decoder_combined_fs_sptr self, int m)

pccc_decoder_combined_fs_sptr.set_scaling(pccc_decoder_combined_fs_sptr self, float scaling)

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

pccc_decoder_combined_fs_sptr.thread_priority(pccc_decoder_combined_fs_sptr self) → int

gnuradio.trellis.pccc_decoder_i(fsm FSM1, int ST10, int ST1K, fsm FSM2, int ST20, int ST2K, interleaver INTERLEAVER, int blocklength, int repetitions, gr::trellis::siso_type_t SISO_TYPE) → pccc_decoder_i_sptr

pccc_decoder_i_sptr.FSM1(pccc_decoder_i_sptr self) → fsm

pccc_decoder_i_sptr.FSM2(pccc_decoder_i_sptr self) → fsm

pccc_decoder_i_sptr.INTERLEAVER(pccc_decoder_i_sptr self) → interleaver

pccc_decoder_i_sptr.SISO_TYPE(pccc_decoder_i_sptr self) → gr::trellis::siso_type_t

pccc_decoder_i_sptr.ST10(pccc_decoder_i_sptr self) → int

pccc_decoder_i_sptr.ST1K(pccc_decoder_i_sptr self) → int

pccc_decoder_i_sptr.ST20(pccc_decoder_i_sptr self) → int

pccc_decoder_i_sptr.ST2K(pccc_decoder_i_sptr self) → int

pccc_decoder_i_sptr.active_thread_priority(pccc_decoder_i_sptr self) → int

pccc_decoder_i_sptr.blocklength(pccc_decoder_i_sptr self) → int

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

declare_sample_delay(pccc_decoder_i_sptr self, unsigned int delay)

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

pccc_decoder_i_sptr.min_noutput_items(pccc_decoder_i_sptr self) → int

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

pc_input_buffers_full_avg(pccc_decoder_i_sptr self) -> pmt_vector_float

pccc_decoder_i_sptr.pc_noutput_items_avg(pccc_decoder_i_sptr self) → float

pccc_decoder_i_sptr.pc_nproduced_avg(pccc_decoder_i_sptr self) → float

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

pc_output_buffers_full_avg(pccc_decoder_i_sptr self) -> pmt_vector_float

pccc_decoder_i_sptr.pc_throughput_avg(pccc_decoder_i_sptr self) → float

pccc_decoder_i_sptr.pc_work_time_avg(pccc_decoder_i_sptr self) → float

pccc_decoder_i_sptr.pc_work_time_total(pccc_decoder_i_sptr self) → float

pccc_decoder_i_sptr.repetitions(pccc_decoder_i_sptr self) → int

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

pccc_decoder_i_sptr.set_min_noutput_items(pccc_decoder_i_sptr self, int m)

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

pccc_decoder_i_sptr.thread_priority(pccc_decoder_i_sptr self) → int

gnuradio.trellis.pccc_decoder_s(fsm FSM1, int ST10, int ST1K, fsm FSM2, int ST20, int ST2K, interleaver INTERLEAVER, int blocklength, int repetitions, gr::trellis::siso_type_t SISO_TYPE) → pccc_decoder_s_sptr

pccc_decoder_s_sptr.FSM1(pccc_decoder_s_sptr self) → fsm

pccc_decoder_s_sptr.FSM2(pccc_decoder_s_sptr self) → fsm

pccc_decoder_s_sptr.INTERLEAVER(pccc_decoder_s_sptr self) → interleaver

pccc_decoder_s_sptr.SISO_TYPE(pccc_decoder_s_sptr self) → gr::trellis::siso_type_t

pccc_decoder_s_sptr.ST10(pccc_decoder_s_sptr self) → int

pccc_decoder_s_sptr.ST1K(pccc_decoder_s_sptr self) → int

pccc_decoder_s_sptr.ST20(pccc_decoder_s_sptr self) → int

pccc_decoder_s_sptr.ST2K(pccc_decoder_s_sptr self) → int

pccc_decoder_s_sptr.active_thread_priority(pccc_decoder_s_sptr self) → int

pccc_decoder_s_sptr.blocklength(pccc_decoder_s_sptr self) → int

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

declare_sample_delay(pccc_decoder_s_sptr self, unsigned int delay)

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

pccc_decoder_s_sptr.min_noutput_items(pccc_decoder_s_sptr self) → int

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

pc_input_buffers_full_avg(pccc_decoder_s_sptr self) -> pmt_vector_float

pccc_decoder_s_sptr.pc_noutput_items_avg(pccc_decoder_s_sptr self) → float

pccc_decoder_s_sptr.pc_nproduced_avg(pccc_decoder_s_sptr self) → float

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

pc_output_buffers_full_avg(pccc_decoder_s_sptr self) -> pmt_vector_float

pccc_decoder_s_sptr.pc_throughput_avg(pccc_decoder_s_sptr self) → float

pccc_decoder_s_sptr.pc_work_time_avg(pccc_decoder_s_sptr self) → float

pccc_decoder_s_sptr.pc_work_time_total(pccc_decoder_s_sptr self) → float

pccc_decoder_s_sptr.repetitions(pccc_decoder_s_sptr self) → int

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

pccc_decoder_s_sptr.set_min_noutput_items(pccc_decoder_s_sptr self, int m)

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

pccc_decoder_s_sptr.thread_priority(pccc_decoder_s_sptr self) → int

gnuradio.trellis.pccc_encoder_bb(fsm FSM1, int ST1, fsm FSM2, int ST2, interleaver INTERLEAVER, int blocklength) → pccc_encoder_bb_sptr

pccc_encoder_bb_sptr.FSM1(pccc_encoder_bb_sptr self) → fsm

pccc_encoder_bb_sptr.FSM2(pccc_encoder_bb_sptr self) → fsm

pccc_encoder_bb_sptr.INTERLEAVER(pccc_encoder_bb_sptr self) → interleaver

pccc_encoder_bb_sptr.ST1(pccc_encoder_bb_sptr self) → int

pccc_encoder_bb_sptr.ST2(pccc_encoder_bb_sptr self) → int

pccc_encoder_bb_sptr.active_thread_priority(pccc_encoder_bb_sptr self) → int

pccc_encoder_bb_sptr.blocklength(pccc_encoder_bb_sptr self) → int

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

declare_sample_delay(pccc_encoder_bb_sptr self, unsigned int delay)

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

pccc_encoder_bb_sptr.min_noutput_items(pccc_encoder_bb_sptr self) → int

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

pc_input_buffers_full_avg(pccc_encoder_bb_sptr self) -> pmt_vector_float

pccc_encoder_bb_sptr.pc_noutput_items_avg(pccc_encoder_bb_sptr self) → float

pccc_encoder_bb_sptr.pc_nproduced_avg(pccc_encoder_bb_sptr self) → float

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

pc_output_buffers_full_avg(pccc_encoder_bb_sptr self) -> pmt_vector_float

pccc_encoder_bb_sptr.pc_throughput_avg(pccc_encoder_bb_sptr self) → float

pccc_encoder_bb_sptr.pc_work_time_avg(pccc_encoder_bb_sptr self) → float

pccc_encoder_bb_sptr.pc_work_time_total(pccc_encoder_bb_sptr self) → float

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

pccc_encoder_bb_sptr.set_min_noutput_items(pccc_encoder_bb_sptr self, int m)

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

pccc_encoder_bb_sptr.thread_priority(pccc_encoder_bb_sptr self) → int

gnuradio.trellis.pccc_encoder_bi(fsm FSM1, int ST1, fsm FSM2, int ST2, interleaver INTERLEAVER, int blocklength) → pccc_encoder_bi_sptr

pccc_encoder_bi_sptr.FSM1(pccc_encoder_bi_sptr self) → fsm

pccc_encoder_bi_sptr.FSM2(pccc_encoder_bi_sptr self) → fsm

pccc_encoder_bi_sptr.INTERLEAVER(pccc_encoder_bi_sptr self) → interleaver

pccc_encoder_bi_sptr.ST1(pccc_encoder_bi_sptr self) → int

pccc_encoder_bi_sptr.ST2(pccc_encoder_bi_sptr self) → int

pccc_encoder_bi_sptr.active_thread_priority(pccc_encoder_bi_sptr self) → int

pccc_encoder_bi_sptr.blocklength(pccc_encoder_bi_sptr self) → int

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

declare_sample_delay(pccc_encoder_bi_sptr self, unsigned int delay)

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

pccc_encoder_bi_sptr.min_noutput_items(pccc_encoder_bi_sptr self) → int

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

pc_input_buffers_full_avg(pccc_encoder_bi_sptr self) -> pmt_vector_float

pccc_encoder_bi_sptr.pc_noutput_items_avg(pccc_encoder_bi_sptr self) → float

pccc_encoder_bi_sptr.pc_nproduced_avg(pccc_encoder_bi_sptr self) → float

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

pc_output_buffers_full_avg(pccc_encoder_bi_sptr self) -> pmt_vector_float

pccc_encoder_bi_sptr.pc_throughput_avg(pccc_encoder_bi_sptr self) → float

pccc_encoder_bi_sptr.pc_work_time_avg(pccc_encoder_bi_sptr self) → float

pccc_encoder_bi_sptr.pc_work_time_total(pccc_encoder_bi_sptr self) → float

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

pccc_encoder_bi_sptr.set_min_noutput_items(pccc_encoder_bi_sptr self, int m)

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

pccc_encoder_bi_sptr.thread_priority(pccc_encoder_bi_sptr self) → int

gnuradio.trellis.pccc_encoder_bs(fsm FSM1, int ST1, fsm FSM2, int ST2, interleaver INTERLEAVER, int blocklength) → pccc_encoder_bs_sptr

pccc_encoder_bs_sptr.FSM1(pccc_encoder_bs_sptr self) → fsm

pccc_encoder_bs_sptr.FSM2(pccc_encoder_bs_sptr self) → fsm

pccc_encoder_bs_sptr.INTERLEAVER(pccc_encoder_bs_sptr self) → interleaver

pccc_encoder_bs_sptr.ST1(pccc_encoder_bs_sptr self) → int

pccc_encoder_bs_sptr.ST2(pccc_encoder_bs_sptr self) → int

pccc_encoder_bs_sptr.active_thread_priority(pccc_encoder_bs_sptr self) → int

pccc_encoder_bs_sptr.blocklength(pccc_encoder_bs_sptr self) → int

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

declare_sample_delay(pccc_encoder_bs_sptr self, unsigned int delay)

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

pccc_encoder_bs_sptr.min_noutput_items(pccc_encoder_bs_sptr self) → int

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

pc_input_buffers_full_avg(pccc_encoder_bs_sptr self) -> pmt_vector_float

pccc_encoder_bs_sptr.pc_noutput_items_avg(pccc_encoder_bs_sptr self) → float

pccc_encoder_bs_sptr.pc_nproduced_avg(pccc_encoder_bs_sptr self) → float

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

pc_output_buffers_full_avg(pccc_encoder_bs_sptr self) -> pmt_vector_float

pccc_encoder_bs_sptr.pc_throughput_avg(pccc_encoder_bs_sptr self) → float

pccc_encoder_bs_sptr.pc_work_time_avg(pccc_encoder_bs_sptr self) → float

pccc_encoder_bs_sptr.pc_work_time_total(pccc_encoder_bs_sptr self) → float

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

pccc_encoder_bs_sptr.set_min_noutput_items(pccc_encoder_bs_sptr self, int m)

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

pccc_encoder_bs_sptr.thread_priority(pccc_encoder_bs_sptr self) → int

gnuradio.trellis.pccc_encoder_ii(fsm FSM1, int ST1, fsm FSM2, int ST2, interleaver INTERLEAVER, int blocklength) → pccc_encoder_ii_sptr

pccc_encoder_ii_sptr.FSM1(pccc_encoder_ii_sptr self) → fsm

pccc_encoder_ii_sptr.FSM2(pccc_encoder_ii_sptr self) → fsm

pccc_encoder_ii_sptr.INTERLEAVER(pccc_encoder_ii_sptr self) → interleaver

pccc_encoder_ii_sptr.ST1(pccc_encoder_ii_sptr self) → int

pccc_encoder_ii_sptr.ST2(pccc_encoder_ii_sptr self) → int

pccc_encoder_ii_sptr.active_thread_priority(pccc_encoder_ii_sptr self) → int

pccc_encoder_ii_sptr.blocklength(pccc_encoder_ii_sptr self) → int

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

declare_sample_delay(pccc_encoder_ii_sptr self, unsigned int delay)

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

pccc_encoder_ii_sptr.min_noutput_items(pccc_encoder_ii_sptr self) → int

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

pc_input_buffers_full_avg(pccc_encoder_ii_sptr self) -> pmt_vector_float

pccc_encoder_ii_sptr.pc_noutput_items_avg(pccc_encoder_ii_sptr self) → float

pccc_encoder_ii_sptr.pc_nproduced_avg(pccc_encoder_ii_sptr self) → float

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

pc_output_buffers_full_avg(pccc_encoder_ii_sptr self) -> pmt_vector_float

pccc_encoder_ii_sptr.pc_throughput_avg(pccc_encoder_ii_sptr self) → float

pccc_encoder_ii_sptr.pc_work_time_avg(pccc_encoder_ii_sptr self) → float

pccc_encoder_ii_sptr.pc_work_time_total(pccc_encoder_ii_sptr self) → float

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

pccc_encoder_ii_sptr.set_min_noutput_items(pccc_encoder_ii_sptr self, int m)

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

pccc_encoder_ii_sptr.thread_priority(pccc_encoder_ii_sptr self) → int

gnuradio.trellis.pccc_encoder_si(fsm FSM1, int ST1, fsm FSM2, int ST2, interleaver INTERLEAVER, int blocklength) → pccc_encoder_si_sptr

pccc_encoder_si_sptr.FSM1(pccc_encoder_si_sptr self) → fsm

pccc_encoder_si_sptr.FSM2(pccc_encoder_si_sptr self) → fsm

pccc_encoder_si_sptr.INTERLEAVER(pccc_encoder_si_sptr self) → interleaver

pccc_encoder_si_sptr.ST1(pccc_encoder_si_sptr self) → int

pccc_encoder_si_sptr.ST2(pccc_encoder_si_sptr self) → int

pccc_encoder_si_sptr.active_thread_priority(pccc_encoder_si_sptr self) → int

pccc_encoder_si_sptr.blocklength(pccc_encoder_si_sptr self) → int

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

declare_sample_delay(pccc_encoder_si_sptr self, unsigned int delay)

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

pccc_encoder_si_sptr.min_noutput_items(pccc_encoder_si_sptr self) → int

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

pc_input_buffers_full_avg(pccc_encoder_si_sptr self) -> pmt_vector_float

pccc_encoder_si_sptr.pc_noutput_items_avg(pccc_encoder_si_sptr self) → float

pccc_encoder_si_sptr.pc_nproduced_avg(pccc_encoder_si_sptr self) → float

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

pc_output_buffers_full_avg(pccc_encoder_si_sptr self) -> pmt_vector_float

pccc_encoder_si_sptr.pc_throughput_avg(pccc_encoder_si_sptr self) → float

pccc_encoder_si_sptr.pc_work_time_avg(pccc_encoder_si_sptr self) → float

pccc_encoder_si_sptr.pc_work_time_total(pccc_encoder_si_sptr self) → float

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

pccc_encoder_si_sptr.set_min_noutput_items(pccc_encoder_si_sptr self, int m)

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

pccc_encoder_si_sptr.thread_priority(pccc_encoder_si_sptr self) → int

gnuradio.trellis.pccc_encoder_ss(fsm FSM1, int ST1, fsm FSM2, int ST2, interleaver INTERLEAVER, int blocklength) → pccc_encoder_ss_sptr

pccc_encoder_ss_sptr.FSM1(pccc_encoder_ss_sptr self) → fsm

pccc_encoder_ss_sptr.FSM2(pccc_encoder_ss_sptr self) → fsm

pccc_encoder_ss_sptr.INTERLEAVER(pccc_encoder_ss_sptr self) → interleaver

pccc_encoder_ss_sptr.ST1(pccc_encoder_ss_sptr self) → int

pccc_encoder_ss_sptr.ST2(pccc_encoder_ss_sptr self) → int

pccc_encoder_ss_sptr.active_thread_priority(pccc_encoder_ss_sptr self) → int

pccc_encoder_ss_sptr.blocklength(pccc_encoder_ss_sptr self) → int

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

declare_sample_delay(pccc_encoder_ss_sptr self, unsigned int delay)

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

pccc_encoder_ss_sptr.min_noutput_items(pccc_encoder_ss_sptr self) → int

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

pc_input_buffers_full_avg(pccc_encoder_ss_sptr self) -> pmt_vector_float

pccc_encoder_ss_sptr.pc_noutput_items_avg(pccc_encoder_ss_sptr self) → float

pccc_encoder_ss_sptr.pc_nproduced_avg(pccc_encoder_ss_sptr self) → float

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

pc_output_buffers_full_avg(pccc_encoder_ss_sptr self) -> pmt_vector_float

pccc_encoder_ss_sptr.pc_throughput_avg(pccc_encoder_ss_sptr self) → float

pccc_encoder_ss_sptr.pc_work_time_avg(pccc_encoder_ss_sptr self) → float

pccc_encoder_ss_sptr.pc_work_time_total(pccc_encoder_ss_sptr self) → float

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

pccc_encoder_ss_sptr.set_min_noutput_items(pccc_encoder_ss_sptr self, int m)

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

pccc_encoder_ss_sptr.thread_priority(pccc_encoder_ss_sptr self) → int

gnuradio.trellis.permutation(int K, std::vector< int, std::allocator< int > > const & TABLE, int SYMS_PER_BLOCK, size_t NBYTES) → permutation_sptr

permutation_sptr.BYTES_PER_SYMBOL(permutation_sptr self) → size_t

permutation_sptr.K(permutation_sptr self) → int

permutation_sptr.SYMS_PER_BLOCK(permutation_sptr self) → int

permutation_sptr.TABLE(permutation_sptr self) → std::vector< int,std::allocator< int > >

permutation_sptr.active_thread_priority(permutation_sptr self) → int

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

declare_sample_delay(permutation_sptr self, unsigned int delay)

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

permutation_sptr.min_noutput_items(permutation_sptr self) → int

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

pc_input_buffers_full_avg(permutation_sptr self) -> pmt_vector_float

permutation_sptr.pc_noutput_items_avg(permutation_sptr self) → float

permutation_sptr.pc_nproduced_avg(permutation_sptr self) → float

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

pc_output_buffers_full_avg(permutation_sptr self) -> pmt_vector_float

permutation_sptr.pc_throughput_avg(permutation_sptr self) → float

permutation_sptr.pc_work_time_avg(permutation_sptr self) → float

permutation_sptr.pc_work_time_total(permutation_sptr self) → float

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

permutation_sptr.set_K(permutation_sptr self, int K)

permutation_sptr.set_SYMS_PER_BLOCK(permutation_sptr self, int spb)

permutation_sptr.set_TABLE(permutation_sptr self, std::vector< int, std::allocator< int > > const & table)

permutation_sptr.set_min_noutput_items(permutation_sptr self, int m)

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

permutation_sptr.thread_priority(permutation_sptr self) → int

gnuradio.trellis.sccc_decoder_b(fsm FSMo, int STo0, int SToK, fsm FSMi, int STi0, int STiK, interleaver INTERLEAVER, int blocklength, int repetitions, gr::trellis::siso_type_t SISO_TYPE) → sccc_decoder_b_sptr

sccc_decoder_b_sptr.FSMi(sccc_decoder_b_sptr self) → fsm

sccc_decoder_b_sptr.FSMo(sccc_decoder_b_sptr self) → fsm

sccc_decoder_b_sptr.INTERLEAVER(sccc_decoder_b_sptr self) → interleaver

sccc_decoder_b_sptr.SISO_TYPE(sccc_decoder_b_sptr self) → gr::trellis::siso_type_t

sccc_decoder_b_sptr.STi0(sccc_decoder_b_sptr self) → int

sccc_decoder_b_sptr.STiK(sccc_decoder_b_sptr self) → int

sccc_decoder_b_sptr.STo0(sccc_decoder_b_sptr self) → int

sccc_decoder_b_sptr.SToK(sccc_decoder_b_sptr self) → int

sccc_decoder_b_sptr.active_thread_priority(sccc_decoder_b_sptr self) → int

sccc_decoder_b_sptr.blocklength(sccc_decoder_b_sptr self) → int

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

declare_sample_delay(sccc_decoder_b_sptr self, unsigned int delay)

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

sccc_decoder_b_sptr.min_noutput_items(sccc_decoder_b_sptr self) → int

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

pc_input_buffers_full_avg(sccc_decoder_b_sptr self) -> pmt_vector_float

sccc_decoder_b_sptr.pc_noutput_items_avg(sccc_decoder_b_sptr self) → float

sccc_decoder_b_sptr.pc_nproduced_avg(sccc_decoder_b_sptr self) → float

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

pc_output_buffers_full_avg(sccc_decoder_b_sptr self) -> pmt_vector_float

sccc_decoder_b_sptr.pc_throughput_avg(sccc_decoder_b_sptr self) → float

sccc_decoder_b_sptr.pc_work_time_avg(sccc_decoder_b_sptr self) → float

sccc_decoder_b_sptr.pc_work_time_total(sccc_decoder_b_sptr self) → float

sccc_decoder_b_sptr.repetitions(sccc_decoder_b_sptr self) → int

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

sccc_decoder_b_sptr.set_min_noutput_items(sccc_decoder_b_sptr self, int m)

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

sccc_decoder_b_sptr.thread_priority(sccc_decoder_b_sptr self) → int

gnuradio.trellis.sccc_decoder_combined_cb(fsm FSMo, int STo0, int SToK, fsm FSMi, int STi0, int STiK, interleaver INTERLEAVER, int blocklength, int repetitions, gr::trellis::siso_type_t SISO_TYPE, int D, pmt_vector_cfloat TABLE, gr::digital::trellis_metric_type_t METRIC_TYPE, float scaling) → sccc_decoder_combined_cb_sptr

sccc_decoder_combined_cb_sptr.D(sccc_decoder_combined_cb_sptr self) → int

sccc_decoder_combined_cb_sptr.FSMi(sccc_decoder_combined_cb_sptr self) → fsm

sccc_decoder_combined_cb_sptr.FSMo(sccc_decoder_combined_cb_sptr self) → fsm

sccc_decoder_combined_cb_sptr.INTERLEAVER(sccc_decoder_combined_cb_sptr self) → interleaver

sccc_decoder_combined_cb_sptr.METRIC_TYPE(sccc_decoder_combined_cb_sptr self) → gr::digital::trellis_metric_type_t

sccc_decoder_combined_cb_sptr.SISO_TYPE(sccc_decoder_combined_cb_sptr self) → gr::trellis::siso_type_t

sccc_decoder_combined_cb_sptr.STi0(sccc_decoder_combined_cb_sptr self) → int

sccc_decoder_combined_cb_sptr.STiK(sccc_decoder_combined_cb_sptr self) → int

sccc_decoder_combined_cb_sptr.STo0(sccc_decoder_combined_cb_sptr self) → int

sccc_decoder_combined_cb_sptr.SToK(sccc_decoder_combined_cb_sptr self) → int

sccc_decoder_combined_cb_sptr.TABLE(sccc_decoder_combined_cb_sptr self) → pmt_vector_cfloat

sccc_decoder_combined_cb_sptr.active_thread_priority(sccc_decoder_combined_cb_sptr self) → int

sccc_decoder_combined_cb_sptr.blocklength(sccc_decoder_combined_cb_sptr self) → int

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

declare_sample_delay(sccc_decoder_combined_cb_sptr self, unsigned int delay)

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

sccc_decoder_combined_cb_sptr.min_noutput_items(sccc_decoder_combined_cb_sptr self) → int

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

pc_input_buffers_full_avg(sccc_decoder_combined_cb_sptr self) -> pmt_vector_float

sccc_decoder_combined_cb_sptr.pc_noutput_items_avg(sccc_decoder_combined_cb_sptr self) → float

sccc_decoder_combined_cb_sptr.pc_nproduced_avg(sccc_decoder_combined_cb_sptr self) → float

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

pc_output_buffers_full_avg(sccc_decoder_combined_cb_sptr self) -> pmt_vector_float

sccc_decoder_combined_cb_sptr.pc_throughput_avg(sccc_decoder_combined_cb_sptr self) → float

sccc_decoder_combined_cb_sptr.pc_work_time_avg(sccc_decoder_combined_cb_sptr self) → float

sccc_decoder_combined_cb_sptr.pc_work_time_total(sccc_decoder_combined_cb_sptr self) → float

sccc_decoder_combined_cb_sptr.repetitions(sccc_decoder_combined_cb_sptr self) → int

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

sccc_decoder_combined_cb_sptr.scaling(sccc_decoder_combined_cb_sptr self) → float

sccc_decoder_combined_cb_sptr.set_min_noutput_items(sccc_decoder_combined_cb_sptr self, int m)

sccc_decoder_combined_cb_sptr.set_scaling(sccc_decoder_combined_cb_sptr self, float scaling)

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

sccc_decoder_combined_cb_sptr.thread_priority(sccc_decoder_combined_cb_sptr self) → int

gnuradio.trellis.sccc_decoder_combined_ci(fsm FSMo, int STo0, int SToK, fsm FSMi, int STi0, int STiK, interleaver INTERLEAVER, int blocklength, int repetitions, gr::trellis::siso_type_t SISO_TYPE, int D, pmt_vector_cfloat TABLE, gr::digital::trellis_metric_type_t METRIC_TYPE, float scaling) → sccc_decoder_combined_ci_sptr

sccc_decoder_combined_ci_sptr.D(sccc_decoder_combined_ci_sptr self) → int

sccc_decoder_combined_ci_sptr.FSMi(sccc_decoder_combined_ci_sptr self) → fsm

sccc_decoder_combined_ci_sptr.FSMo(sccc_decoder_combined_ci_sptr self) → fsm

sccc_decoder_combined_ci_sptr.INTERLEAVER(sccc_decoder_combined_ci_sptr self) → interleaver

sccc_decoder_combined_ci_sptr.METRIC_TYPE(sccc_decoder_combined_ci_sptr self) → gr::digital::trellis_metric_type_t

sccc_decoder_combined_ci_sptr.SISO_TYPE(sccc_decoder_combined_ci_sptr self) → gr::trellis::siso_type_t

sccc_decoder_combined_ci_sptr.STi0(sccc_decoder_combined_ci_sptr self) → int

sccc_decoder_combined_ci_sptr.STiK(sccc_decoder_combined_ci_sptr self) → int

sccc_decoder_combined_ci_sptr.STo0(sccc_decoder_combined_ci_sptr self) → int

sccc_decoder_combined_ci_sptr.SToK(sccc_decoder_combined_ci_sptr self) → int

sccc_decoder_combined_ci_sptr.TABLE(sccc_decoder_combined_ci_sptr self) → pmt_vector_cfloat

sccc_decoder_combined_ci_sptr.active_thread_priority(sccc_decoder_combined_ci_sptr self) → int

sccc_decoder_combined_ci_sptr.blocklength(sccc_decoder_combined_ci_sptr self) → int

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

declare_sample_delay(sccc_decoder_combined_ci_sptr self, unsigned int delay)

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

sccc_decoder_combined_ci_sptr.min_noutput_items(sccc_decoder_combined_ci_sptr self) → int

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

pc_input_buffers_full_avg(sccc_decoder_combined_ci_sptr self) -> pmt_vector_float

sccc_decoder_combined_ci_sptr.pc_noutput_items_avg(sccc_decoder_combined_ci_sptr self) → float

sccc_decoder_combined_ci_sptr.pc_nproduced_avg(sccc_decoder_combined_ci_sptr self) → float

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

pc_output_buffers_full_avg(sccc_decoder_combined_ci_sptr self) -> pmt_vector_float

sccc_decoder_combined_ci_sptr.pc_throughput_avg(sccc_decoder_combined_ci_sptr self) → float

sccc_decoder_combined_ci_sptr.pc_work_time_avg(sccc_decoder_combined_ci_sptr self) → float

sccc_decoder_combined_ci_sptr.pc_work_time_total(sccc_decoder_combined_ci_sptr self) → float

sccc_decoder_combined_ci_sptr.repetitions(sccc_decoder_combined_ci_sptr self) → int

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

sccc_decoder_combined_ci_sptr.scaling(sccc_decoder_combined_ci_sptr self) → float

sccc_decoder_combined_ci_sptr.set_min_noutput_items(sccc_decoder_combined_ci_sptr self, int m)

sccc_decoder_combined_ci_sptr.set_scaling(sccc_decoder_combined_ci_sptr self, float scaling)

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

sccc_decoder_combined_ci_sptr.thread_priority(sccc_decoder_combined_ci_sptr self) → int

gnuradio.trellis.sccc_decoder_combined_cs(fsm FSMo, int STo0, int SToK, fsm FSMi, int STi0, int STiK, interleaver INTERLEAVER, int blocklength, int repetitions, gr::trellis::siso_type_t SISO_TYPE, int D, pmt_vector_cfloat TABLE, gr::digital::trellis_metric_type_t METRIC_TYPE, float scaling) → sccc_decoder_combined_cs_sptr

sccc_decoder_combined_cs_sptr.D(sccc_decoder_combined_cs_sptr self) → int

sccc_decoder_combined_cs_sptr.FSMi(sccc_decoder_combined_cs_sptr self) → fsm

sccc_decoder_combined_cs_sptr.FSMo(sccc_decoder_combined_cs_sptr self) → fsm

sccc_decoder_combined_cs_sptr.INTERLEAVER(sccc_decoder_combined_cs_sptr self) → interleaver

sccc_decoder_combined_cs_sptr.METRIC_TYPE(sccc_decoder_combined_cs_sptr self) → gr::digital::trellis_metric_type_t

sccc_decoder_combined_cs_sptr.SISO_TYPE(sccc_decoder_combined_cs_sptr self) → gr::trellis::siso_type_t

sccc_decoder_combined_cs_sptr.STi0(sccc_decoder_combined_cs_sptr self) → int

sccc_decoder_combined_cs_sptr.STiK(sccc_decoder_combined_cs_sptr self) → int

sccc_decoder_combined_cs_sptr.STo0(sccc_decoder_combined_cs_sptr self) → int

sccc_decoder_combined_cs_sptr.SToK(sccc_decoder_combined_cs_sptr self) → int

sccc_decoder_combined_cs_sptr.TABLE(sccc_decoder_combined_cs_sptr self) → pmt_vector_cfloat

sccc_decoder_combined_cs_sptr.active_thread_priority(sccc_decoder_combined_cs_sptr self) → int

sccc_decoder_combined_cs_sptr.blocklength(sccc_decoder_combined_cs_sptr self) → int

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

declare_sample_delay(sccc_decoder_combined_cs_sptr self, unsigned int delay)

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

sccc_decoder_combined_cs_sptr.min_noutput_items(sccc_decoder_combined_cs_sptr self) → int

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

pc_input_buffers_full_avg(sccc_decoder_combined_cs_sptr self) -> pmt_vector_float

sccc_decoder_combined_cs_sptr.pc_noutput_items_avg(sccc_decoder_combined_cs_sptr self) → float

sccc_decoder_combined_cs_sptr.pc_nproduced_avg(sccc_decoder_combined_cs_sptr self) → float

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

pc_output_buffers_full_avg(sccc_decoder_combined_cs_sptr self) -> pmt_vector_float

sccc_decoder_combined_cs_sptr.pc_throughput_avg(sccc_decoder_combined_cs_sptr self) → float

sccc_decoder_combined_cs_sptr.pc_work_time_avg(sccc_decoder_combined_cs_sptr self) → float

sccc_decoder_combined_cs_sptr.pc_work_time_total(sccc_decoder_combined_cs_sptr self) → float

sccc_decoder_combined_cs_sptr.repetitions(sccc_decoder_combined_cs_sptr self) → int

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

sccc_decoder_combined_cs_sptr.scaling(sccc_decoder_combined_cs_sptr self) → float

sccc_decoder_combined_cs_sptr.set_min_noutput_items(sccc_decoder_combined_cs_sptr self, int m)

sccc_decoder_combined_cs_sptr.set_scaling(sccc_decoder_combined_cs_sptr self, float scaling)

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

sccc_decoder_combined_cs_sptr.thread_priority(sccc_decoder_combined_cs_sptr self) → int

gnuradio.trellis.sccc_decoder_combined_fb(fsm FSMo, int STo0, int SToK, fsm FSMi, int STi0, int STiK, interleaver INTERLEAVER, int blocklength, int repetitions, gr::trellis::siso_type_t SISO_TYPE, int D, pmt_vector_float TABLE, gr::digital::trellis_metric_type_t METRIC_TYPE, float scaling) → sccc_decoder_combined_fb_sptr

sccc_decoder_combined_fb_sptr.D(sccc_decoder_combined_fb_sptr self) → int

sccc_decoder_combined_fb_sptr.FSMi(sccc_decoder_combined_fb_sptr self) → fsm

sccc_decoder_combined_fb_sptr.FSMo(sccc_decoder_combined_fb_sptr self) → fsm

sccc_decoder_combined_fb_sptr.INTERLEAVER(sccc_decoder_combined_fb_sptr self) → interleaver

sccc_decoder_combined_fb_sptr.METRIC_TYPE(sccc_decoder_combined_fb_sptr self) → gr::digital::trellis_metric_type_t

sccc_decoder_combined_fb_sptr.SISO_TYPE(sccc_decoder_combined_fb_sptr self) → gr::trellis::siso_type_t

sccc_decoder_combined_fb_sptr.STi0(sccc_decoder_combined_fb_sptr self) → int

sccc_decoder_combined_fb_sptr.STiK(sccc_decoder_combined_fb_sptr self) → int

sccc_decoder_combined_fb_sptr.STo0(sccc_decoder_combined_fb_sptr self) → int

sccc_decoder_combined_fb_sptr.SToK(sccc_decoder_combined_fb_sptr self) → int

sccc_decoder_combined_fb_sptr.TABLE(sccc_decoder_combined_fb_sptr self) → pmt_vector_float

sccc_decoder_combined_fb_sptr.active_thread_priority(sccc_decoder_combined_fb_sptr self) → int

sccc_decoder_combined_fb_sptr.blocklength(sccc_decoder_combined_fb_sptr self) → int

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

declare_sample_delay(sccc_decoder_combined_fb_sptr self, unsigned int delay)

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

sccc_decoder_combined_fb_sptr.min_noutput_items(sccc_decoder_combined_fb_sptr self) → int

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

pc_input_buffers_full_avg(sccc_decoder_combined_fb_sptr self) -> pmt_vector_float

sccc_decoder_combined_fb_sptr.pc_noutput_items_avg(sccc_decoder_combined_fb_sptr self) → float

sccc_decoder_combined_fb_sptr.pc_nproduced_avg(sccc_decoder_combined_fb_sptr self) → float

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

pc_output_buffers_full_avg(sccc_decoder_combined_fb_sptr self) -> pmt_vector_float

sccc_decoder_combined_fb_sptr.pc_throughput_avg(sccc_decoder_combined_fb_sptr self) → float

sccc_decoder_combined_fb_sptr.pc_work_time_avg(sccc_decoder_combined_fb_sptr self) → float

sccc_decoder_combined_fb_sptr.pc_work_time_total(sccc_decoder_combined_fb_sptr self) → float

sccc_decoder_combined_fb_sptr.repetitions(sccc_decoder_combined_fb_sptr self) → int

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

sccc_decoder_combined_fb_sptr.scaling(sccc_decoder_combined_fb_sptr self) → float

sccc_decoder_combined_fb_sptr.set_min_noutput_items(sccc_decoder_combined_fb_sptr self, int m)

sccc_decoder_combined_fb_sptr.set_scaling(sccc_decoder_combined_fb_sptr self, float scaling)

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

sccc_decoder_combined_fb_sptr.thread_priority(sccc_decoder_combined_fb_sptr self) → int

gnuradio.trellis.sccc_decoder_combined_fi(fsm FSMo, int STo0, int SToK, fsm FSMi, int STi0, int STiK, interleaver INTERLEAVER, int blocklength, int repetitions, gr::trellis::siso_type_t SISO_TYPE, int D, pmt_vector_float TABLE, gr::digital::trellis_metric_type_t METRIC_TYPE, float scaling) → sccc_decoder_combined_fi_sptr

sccc_decoder_combined_fi_sptr.D(sccc_decoder_combined_fi_sptr self) → int

sccc_decoder_combined_fi_sptr.FSMi(sccc_decoder_combined_fi_sptr self) → fsm

sccc_decoder_combined_fi_sptr.FSMo(sccc_decoder_combined_fi_sptr self) → fsm

sccc_decoder_combined_fi_sptr.INTERLEAVER(sccc_decoder_combined_fi_sptr self) → interleaver

sccc_decoder_combined_fi_sptr.METRIC_TYPE(sccc_decoder_combined_fi_sptr self) → gr::digital::trellis_metric_type_t

sccc_decoder_combined_fi_sptr.SISO_TYPE(sccc_decoder_combined_fi_sptr self) → gr::trellis::siso_type_t

sccc_decoder_combined_fi_sptr.STi0(sccc_decoder_combined_fi_sptr self) → int

sccc_decoder_combined_fi_sptr.STiK(sccc_decoder_combined_fi_sptr self) → int

sccc_decoder_combined_fi_sptr.STo0(sccc_decoder_combined_fi_sptr self) → int

sccc_decoder_combined_fi_sptr.SToK(sccc_decoder_combined_fi_sptr self) → int

sccc_decoder_combined_fi_sptr.TABLE(sccc_decoder_combined_fi_sptr self) → pmt_vector_float

sccc_decoder_combined_fi_sptr.active_thread_priority(sccc_decoder_combined_fi_sptr self) → int

sccc_decoder_combined_fi_sptr.blocklength(sccc_decoder_combined_fi_sptr self) → int

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

declare_sample_delay(sccc_decoder_combined_fi_sptr self, unsigned int delay)

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

sccc_decoder_combined_fi_sptr.min_noutput_items(sccc_decoder_combined_fi_sptr self) → int

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

pc_input_buffers_full_avg(sccc_decoder_combined_fi_sptr self) -> pmt_vector_float

sccc_decoder_combined_fi_sptr.pc_noutput_items_avg(sccc_decoder_combined_fi_sptr self) → float

sccc_decoder_combined_fi_sptr.pc_nproduced_avg(sccc_decoder_combined_fi_sptr self) → float

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

pc_output_buffers_full_avg(sccc_decoder_combined_fi_sptr self) -> pmt_vector_float

sccc_decoder_combined_fi_sptr.pc_throughput_avg(sccc_decoder_combined_fi_sptr self) → float

sccc_decoder_combined_fi_sptr.pc_work_time_avg(sccc_decoder_combined_fi_sptr self) → float

sccc_decoder_combined_fi_sptr.pc_work_time_total(sccc_decoder_combined_fi_sptr self) → float

sccc_decoder_combined_fi_sptr.repetitions(sccc_decoder_combined_fi_sptr self) → int

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

sccc_decoder_combined_fi_sptr.scaling(sccc_decoder_combined_fi_sptr self) → float

sccc_decoder_combined_fi_sptr.set_min_noutput_items(sccc_decoder_combined_fi_sptr self, int m)

sccc_decoder_combined_fi_sptr.set_scaling(sccc_decoder_combined_fi_sptr self, float scaling)

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

sccc_decoder_combined_fi_sptr.thread_priority(sccc_decoder_combined_fi_sptr self) → int

gnuradio.trellis.sccc_decoder_combined_fs(fsm FSMo, int STo0, int SToK, fsm FSMi, int STi0, int STiK, interleaver INTERLEAVER, int blocklength, int repetitions, gr::trellis::siso_type_t SISO_TYPE, int D, pmt_vector_float TABLE, gr::digital::trellis_metric_type_t METRIC_TYPE, float scaling) → sccc_decoder_combined_fs_sptr

sccc_decoder_combined_fs_sptr.D(sccc_decoder_combined_fs_sptr self) → int

sccc_decoder_combined_fs_sptr.FSMi(sccc_decoder_combined_fs_sptr self) → fsm

sccc_decoder_combined_fs_sptr.FSMo(sccc_decoder_combined_fs_sptr self) → fsm

sccc_decoder_combined_fs_sptr.INTERLEAVER(sccc_decoder_combined_fs_sptr self) → interleaver

sccc_decoder_combined_fs_sptr.METRIC_TYPE(sccc_decoder_combined_fs_sptr self) → gr::digital::trellis_metric_type_t

sccc_decoder_combined_fs_sptr.SISO_TYPE(sccc_decoder_combined_fs_sptr self) → gr::trellis::siso_type_t

sccc_decoder_combined_fs_sptr.STi0(sccc_decoder_combined_fs_sptr self) → int

sccc_decoder_combined_fs_sptr.STiK(sccc_decoder_combined_fs_sptr self) → int

sccc_decoder_combined_fs_sptr.STo0(sccc_decoder_combined_fs_sptr self) → int

sccc_decoder_combined_fs_sptr.SToK(sccc_decoder_combined_fs_sptr self) → int

sccc_decoder_combined_fs_sptr.TABLE(sccc_decoder_combined_fs_sptr self) → pmt_vector_float

sccc_decoder_combined_fs_sptr.active_thread_priority(sccc_decoder_combined_fs_sptr self) → int

sccc_decoder_combined_fs_sptr.blocklength(sccc_decoder_combined_fs_sptr self) → int

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

declare_sample_delay(sccc_decoder_combined_fs_sptr self, unsigned int delay)

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

sccc_decoder_combined_fs_sptr.min_noutput_items(sccc_decoder_combined_fs_sptr self) → int

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

pc_input_buffers_full_avg(sccc_decoder_combined_fs_sptr self) -> pmt_vector_float

sccc_decoder_combined_fs_sptr.pc_noutput_items_avg(sccc_decoder_combined_fs_sptr self) → float

sccc_decoder_combined_fs_sptr.pc_nproduced_avg(sccc_decoder_combined_fs_sptr self) → float

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

pc_output_buffers_full_avg(sccc_decoder_combined_fs_sptr self) -> pmt_vector_float

sccc_decoder_combined_fs_sptr.pc_throughput_avg(sccc_decoder_combined_fs_sptr self) → float

sccc_decoder_combined_fs_sptr.pc_work_time_avg(sccc_decoder_combined_fs_sptr self) → float

sccc_decoder_combined_fs_sptr.pc_work_time_total(sccc_decoder_combined_fs_sptr self) → float

sccc_decoder_combined_fs_sptr.repetitions(sccc_decoder_combined_fs_sptr self) → int

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

sccc_decoder_combined_fs_sptr.scaling(sccc_decoder_combined_fs_sptr self) → float

sccc_decoder_combined_fs_sptr.set_min_noutput_items(sccc_decoder_combined_fs_sptr self, int m)

sccc_decoder_combined_fs_sptr.set_scaling(sccc_decoder_combined_fs_sptr self, float scaling)

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

sccc_decoder_combined_fs_sptr.thread_priority(sccc_decoder_combined_fs_sptr self) → int

gnuradio.trellis.sccc_decoder_i(fsm FSMo, int STo0, int SToK, fsm FSMi, int STi0, int STiK, interleaver INTERLEAVER, int blocklength, int repetitions, gr::trellis::siso_type_t SISO_TYPE) → sccc_decoder_i_sptr

sccc_decoder_i_sptr.FSMi(sccc_decoder_i_sptr self) → fsm

sccc_decoder_i_sptr.FSMo(sccc_decoder_i_sptr self) → fsm

sccc_decoder_i_sptr.INTERLEAVER(sccc_decoder_i_sptr self) → interleaver

sccc_decoder_i_sptr.SISO_TYPE(sccc_decoder_i_sptr self) → gr::trellis::siso_type_t

sccc_decoder_i_sptr.STi0(sccc_decoder_i_sptr self) → int

sccc_decoder_i_sptr.STiK(sccc_decoder_i_sptr self) → int

sccc_decoder_i_sptr.STo0(sccc_decoder_i_sptr self) → int

sccc_decoder_i_sptr.SToK(sccc_decoder_i_sptr self) → int

sccc_decoder_i_sptr.active_thread_priority(sccc_decoder_i_sptr self) → int

sccc_decoder_i_sptr.blocklength(sccc_decoder_i_sptr self) → int

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

declare_sample_delay(sccc_decoder_i_sptr self, unsigned int delay)

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

sccc_decoder_i_sptr.min_noutput_items(sccc_decoder_i_sptr self) → int

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

pc_input_buffers_full_avg(sccc_decoder_i_sptr self) -> pmt_vector_float

sccc_decoder_i_sptr.pc_noutput_items_avg(sccc_decoder_i_sptr self) → float

sccc_decoder_i_sptr.pc_nproduced_avg(sccc_decoder_i_sptr self) → float

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

pc_output_buffers_full_avg(sccc_decoder_i_sptr self) -> pmt_vector_float

sccc_decoder_i_sptr.pc_throughput_avg(sccc_decoder_i_sptr self) → float

sccc_decoder_i_sptr.pc_work_time_avg(sccc_decoder_i_sptr self) → float

sccc_decoder_i_sptr.pc_work_time_total(sccc_decoder_i_sptr self) → float

sccc_decoder_i_sptr.repetitions(sccc_decoder_i_sptr self) → int

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

sccc_decoder_i_sptr.set_min_noutput_items(sccc_decoder_i_sptr self, int m)

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

sccc_decoder_i_sptr.thread_priority(sccc_decoder_i_sptr self) → int

gnuradio.trellis.sccc_decoder_s(fsm FSMo, int STo0, int SToK, fsm FSMi, int STi0, int STiK, interleaver INTERLEAVER, int blocklength, int repetitions, gr::trellis::siso_type_t SISO_TYPE) → sccc_decoder_s_sptr

sccc_decoder_s_sptr.FSMi(sccc_decoder_s_sptr self) → fsm

sccc_decoder_s_sptr.FSMo(sccc_decoder_s_sptr self) → fsm

sccc_decoder_s_sptr.INTERLEAVER(sccc_decoder_s_sptr self) → interleaver

sccc_decoder_s_sptr.SISO_TYPE(sccc_decoder_s_sptr self) → gr::trellis::siso_type_t

sccc_decoder_s_sptr.STi0(sccc_decoder_s_sptr self) → int

sccc_decoder_s_sptr.STiK(sccc_decoder_s_sptr self) → int

sccc_decoder_s_sptr.STo0(sccc_decoder_s_sptr self) → int

sccc_decoder_s_sptr.SToK(sccc_decoder_s_sptr self) → int

sccc_decoder_s_sptr.active_thread_priority(sccc_decoder_s_sptr self) → int

sccc_decoder_s_sptr.blocklength(sccc_decoder_s_sptr self) → int

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

declare_sample_delay(sccc_decoder_s_sptr self, unsigned int delay)

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

sccc_decoder_s_sptr.min_noutput_items(sccc_decoder_s_sptr self) → int

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

pc_input_buffers_full_avg(sccc_decoder_s_sptr self) -> pmt_vector_float

sccc_decoder_s_sptr.pc_noutput_items_avg(sccc_decoder_s_sptr self) → float

sccc_decoder_s_sptr.pc_nproduced_avg(sccc_decoder_s_sptr self) → float

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

pc_output_buffers_full_avg(sccc_decoder_s_sptr self) -> pmt_vector_float

sccc_decoder_s_sptr.pc_throughput_avg(sccc_decoder_s_sptr self) → float

sccc_decoder_s_sptr.pc_work_time_avg(sccc_decoder_s_sptr self) → float

sccc_decoder_s_sptr.pc_work_time_total(sccc_decoder_s_sptr self) → float

sccc_decoder_s_sptr.repetitions(sccc_decoder_s_sptr self) → int

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

sccc_decoder_s_sptr.set_min_noutput_items(sccc_decoder_s_sptr self, int m)

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

sccc_decoder_s_sptr.thread_priority(sccc_decoder_s_sptr self) → int

gnuradio.trellis.sccc_encoder_bb(fsm FSMo, int STo, fsm FSMi, int STi, interleaver INTERLEAVER, int blocklength) → sccc_encoder_bb_sptr

sccc_encoder_bb_sptr.FSMi(sccc_encoder_bb_sptr self) → fsm

sccc_encoder_bb_sptr.FSMo(sccc_encoder_bb_sptr self) → fsm

sccc_encoder_bb_sptr.INTERLEAVER(sccc_encoder_bb_sptr self) → interleaver

sccc_encoder_bb_sptr.STi(sccc_encoder_bb_sptr self) → int

sccc_encoder_bb_sptr.STo(sccc_encoder_bb_sptr self) → int

sccc_encoder_bb_sptr.active_thread_priority(sccc_encoder_bb_sptr self) → int

sccc_encoder_bb_sptr.blocklength(sccc_encoder_bb_sptr self) → int

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

declare_sample_delay(sccc_encoder_bb_sptr self, unsigned int delay)

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

sccc_encoder_bb_sptr.min_noutput_items(sccc_encoder_bb_sptr self) → int

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

pc_input_buffers_full_avg(sccc_encoder_bb_sptr self) -> pmt_vector_float

sccc_encoder_bb_sptr.pc_noutput_items_avg(sccc_encoder_bb_sptr self) → float

sccc_encoder_bb_sptr.pc_nproduced_avg(sccc_encoder_bb_sptr self) → float

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

pc_output_buffers_full_avg(sccc_encoder_bb_sptr self) -> pmt_vector_float

sccc_encoder_bb_sptr.pc_throughput_avg(sccc_encoder_bb_sptr self) → float

sccc_encoder_bb_sptr.pc_work_time_avg(sccc_encoder_bb_sptr self) → float

sccc_encoder_bb_sptr.pc_work_time_total(sccc_encoder_bb_sptr self) → float

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

sccc_encoder_bb_sptr.set_min_noutput_items(sccc_encoder_bb_sptr self, int m)

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

sccc_encoder_bb_sptr.thread_priority(sccc_encoder_bb_sptr self) → int

gnuradio.trellis.sccc_encoder_bi(fsm FSMo, int STo, fsm FSMi, int STi, interleaver INTERLEAVER, int blocklength) → sccc_encoder_bi_sptr

sccc_encoder_bi_sptr.FSMi(sccc_encoder_bi_sptr self) → fsm

sccc_encoder_bi_sptr.FSMo(sccc_encoder_bi_sptr self) → fsm

sccc_encoder_bi_sptr.INTERLEAVER(sccc_encoder_bi_sptr self) → interleaver

sccc_encoder_bi_sptr.STi(sccc_encoder_bi_sptr self) → int

sccc_encoder_bi_sptr.STo(sccc_encoder_bi_sptr self) → int

sccc_encoder_bi_sptr.active_thread_priority(sccc_encoder_bi_sptr self) → int

sccc_encoder_bi_sptr.blocklength(sccc_encoder_bi_sptr self) → int

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

declare_sample_delay(sccc_encoder_bi_sptr self, unsigned int delay)

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

sccc_encoder_bi_sptr.min_noutput_items(sccc_encoder_bi_sptr self) → int

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

pc_input_buffers_full_avg(sccc_encoder_bi_sptr self) -> pmt_vector_float

sccc_encoder_bi_sptr.pc_noutput_items_avg(sccc_encoder_bi_sptr self) → float

sccc_encoder_bi_sptr.pc_nproduced_avg(sccc_encoder_bi_sptr self) → float

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

pc_output_buffers_full_avg(sccc_encoder_bi_sptr self) -> pmt_vector_float

sccc_encoder_bi_sptr.pc_throughput_avg(sccc_encoder_bi_sptr self) → float

sccc_encoder_bi_sptr.pc_work_time_avg(sccc_encoder_bi_sptr self) → float

sccc_encoder_bi_sptr.pc_work_time_total(sccc_encoder_bi_sptr self) → float

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

sccc_encoder_bi_sptr.set_min_noutput_items(sccc_encoder_bi_sptr self, int m)

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

sccc_encoder_bi_sptr.thread_priority(sccc_encoder_bi_sptr self) → int

gnuradio.trellis.sccc_encoder_bs(fsm FSMo, int STo, fsm FSMi, int STi, interleaver INTERLEAVER, int blocklength) → sccc_encoder_bs_sptr

sccc_encoder_bs_sptr.FSMi(sccc_encoder_bs_sptr self) → fsm

sccc_encoder_bs_sptr.FSMo(sccc_encoder_bs_sptr self) → fsm

sccc_encoder_bs_sptr.INTERLEAVER(sccc_encoder_bs_sptr self) → interleaver

sccc_encoder_bs_sptr.STi(sccc_encoder_bs_sptr self) → int

sccc_encoder_bs_sptr.STo(sccc_encoder_bs_sptr self) → int

sccc_encoder_bs_sptr.active_thread_priority(sccc_encoder_bs_sptr self) → int

sccc_encoder_bs_sptr.blocklength(sccc_encoder_bs_sptr self) → int

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

declare_sample_delay(sccc_encoder_bs_sptr self, unsigned int delay)

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

sccc_encoder_bs_sptr.min_noutput_items(sccc_encoder_bs_sptr self) → int

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

pc_input_buffers_full_avg(sccc_encoder_bs_sptr self) -> pmt_vector_float

sccc_encoder_bs_sptr.pc_noutput_items_avg(sccc_encoder_bs_sptr self) → float

sccc_encoder_bs_sptr.pc_nproduced_avg(sccc_encoder_bs_sptr self) → float

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

pc_output_buffers_full_avg(sccc_encoder_bs_sptr self) -> pmt_vector_float

sccc_encoder_bs_sptr.pc_throughput_avg(sccc_encoder_bs_sptr self) → float

sccc_encoder_bs_sptr.pc_work_time_avg(sccc_encoder_bs_sptr self) → float

sccc_encoder_bs_sptr.pc_work_time_total(sccc_encoder_bs_sptr self) → float

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

sccc_encoder_bs_sptr.set_min_noutput_items(sccc_encoder_bs_sptr self, int m)

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

sccc_encoder_bs_sptr.thread_priority(sccc_encoder_bs_sptr self) → int

gnuradio.trellis.sccc_encoder_ii(fsm FSMo, int STo, fsm FSMi, int STi, interleaver INTERLEAVER, int blocklength) → sccc_encoder_ii_sptr

sccc_encoder_ii_sptr.FSMi(sccc_encoder_ii_sptr self) → fsm

sccc_encoder_ii_sptr.FSMo(sccc_encoder_ii_sptr self) → fsm

sccc_encoder_ii_sptr.INTERLEAVER(sccc_encoder_ii_sptr self) → interleaver

sccc_encoder_ii_sptr.STi(sccc_encoder_ii_sptr self) → int

sccc_encoder_ii_sptr.STo(sccc_encoder_ii_sptr self) → int

sccc_encoder_ii_sptr.active_thread_priority(sccc_encoder_ii_sptr self) → int

sccc_encoder_ii_sptr.blocklength(sccc_encoder_ii_sptr self) → int

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

declare_sample_delay(sccc_encoder_ii_sptr self, unsigned int delay)

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

sccc_encoder_ii_sptr.min_noutput_items(sccc_encoder_ii_sptr self) → int

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

pc_input_buffers_full_avg(sccc_encoder_ii_sptr self) -> pmt_vector_float

sccc_encoder_ii_sptr.pc_noutput_items_avg(sccc_encoder_ii_sptr self) → float

sccc_encoder_ii_sptr.pc_nproduced_avg(sccc_encoder_ii_sptr self) → float

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

pc_output_buffers_full_avg(sccc_encoder_ii_sptr self) -> pmt_vector_float

sccc_encoder_ii_sptr.pc_throughput_avg(sccc_encoder_ii_sptr self) → float

sccc_encoder_ii_sptr.pc_work_time_avg(sccc_encoder_ii_sptr self) → float

sccc_encoder_ii_sptr.pc_work_time_total(sccc_encoder_ii_sptr self) → float

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

sccc_encoder_ii_sptr.set_min_noutput_items(sccc_encoder_ii_sptr self, int m)

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

sccc_encoder_ii_sptr.thread_priority(sccc_encoder_ii_sptr self) → int

gnuradio.trellis.sccc_encoder_si(fsm FSMo, int STo, fsm FSMi, int STi, interleaver INTERLEAVER, int blocklength) → sccc_encoder_si_sptr

sccc_encoder_si_sptr.FSMi(sccc_encoder_si_sptr self) → fsm

sccc_encoder_si_sptr.FSMo(sccc_encoder_si_sptr self) → fsm

sccc_encoder_si_sptr.INTERLEAVER(sccc_encoder_si_sptr self) → interleaver

sccc_encoder_si_sptr.STi(sccc_encoder_si_sptr self) → int

sccc_encoder_si_sptr.STo(sccc_encoder_si_sptr self) → int

sccc_encoder_si_sptr.active_thread_priority(sccc_encoder_si_sptr self) → int

sccc_encoder_si_sptr.blocklength(sccc_encoder_si_sptr self) → int

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

declare_sample_delay(sccc_encoder_si_sptr self, unsigned int delay)

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

sccc_encoder_si_sptr.min_noutput_items(sccc_encoder_si_sptr self) → int

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

pc_input_buffers_full_avg(sccc_encoder_si_sptr self) -> pmt_vector_float

sccc_encoder_si_sptr.pc_noutput_items_avg(sccc_encoder_si_sptr self) → float

sccc_encoder_si_sptr.pc_nproduced_avg(sccc_encoder_si_sptr self) → float

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

pc_output_buffers_full_avg(sccc_encoder_si_sptr self) -> pmt_vector_float

sccc_encoder_si_sptr.pc_throughput_avg(sccc_encoder_si_sptr self) → float

sccc_encoder_si_sptr.pc_work_time_avg(sccc_encoder_si_sptr self) → float

sccc_encoder_si_sptr.pc_work_time_total(sccc_encoder_si_sptr self) → float

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

sccc_encoder_si_sptr.set_min_noutput_items(sccc_encoder_si_sptr self, int m)

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

sccc_encoder_si_sptr.thread_priority(sccc_encoder_si_sptr self) → int

gnuradio.trellis.sccc_encoder_ss(fsm FSMo, int STo, fsm FSMi, int STi, interleaver INTERLEAVER, int blocklength) → sccc_encoder_ss_sptr

sccc_encoder_ss_sptr.FSMi(sccc_encoder_ss_sptr self) → fsm

sccc_encoder_ss_sptr.FSMo(sccc_encoder_ss_sptr self) → fsm

sccc_encoder_ss_sptr.INTERLEAVER(sccc_encoder_ss_sptr self) → interleaver

sccc_encoder_ss_sptr.STi(sccc_encoder_ss_sptr self) → int

sccc_encoder_ss_sptr.STo(sccc_encoder_ss_sptr self) → int

sccc_encoder_ss_sptr.active_thread_priority(sccc_encoder_ss_sptr self) → int

sccc_encoder_ss_sptr.blocklength(sccc_encoder_ss_sptr self) → int

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

declare_sample_delay(sccc_encoder_ss_sptr self, unsigned int delay)

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

sccc_encoder_ss_sptr.min_noutput_items(sccc_encoder_ss_sptr self) → int

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

pc_input_buffers_full_avg(sccc_encoder_ss_sptr self) -> pmt_vector_float

sccc_encoder_ss_sptr.pc_noutput_items_avg(sccc_encoder_ss_sptr self) → float

sccc_encoder_ss_sptr.pc_nproduced_avg(sccc_encoder_ss_sptr self) → float

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

pc_output_buffers_full_avg(sccc_encoder_ss_sptr self) -> pmt_vector_float

sccc_encoder_ss_sptr.pc_throughput_avg(sccc_encoder_ss_sptr self) → float

sccc_encoder_ss_sptr.pc_work_time_avg(sccc_encoder_ss_sptr self) → float

sccc_encoder_ss_sptr.pc_work_time_total(sccc_encoder_ss_sptr self) → float

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

sccc_encoder_ss_sptr.set_min_noutput_items(sccc_encoder_ss_sptr self, int m)

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

sccc_encoder_ss_sptr.thread_priority(sccc_encoder_ss_sptr self) → int

gnuradio.trellis.siso_combined_f(fsm FSM, int K, int S0, int SK, bool POSTI, bool POSTO, gr::trellis::siso_type_t d_SISO_TYPE, int D, pmt_vector_float TABLE, gr::digital::trellis_metric_type_t TYPE) → siso_combined_f_sptr

siso_combined_f_sptr.D(siso_combined_f_sptr self) → int

siso_combined_f_sptr.FSM(siso_combined_f_sptr self) → fsm

siso_combined_f_sptr.K(siso_combined_f_sptr self) → int

siso_combined_f_sptr.POSTI(siso_combined_f_sptr self) → bool

siso_combined_f_sptr.POSTO(siso_combined_f_sptr self) → bool

siso_combined_f_sptr.S0(siso_combined_f_sptr self) → int

siso_combined_f_sptr.SISO_TYPE(siso_combined_f_sptr self) → gr::trellis::siso_type_t

siso_combined_f_sptr.SK(siso_combined_f_sptr self) → int

siso_combined_f_sptr.TABLE(siso_combined_f_sptr self) → pmt_vector_float

siso_combined_f_sptr.TYPE(siso_combined_f_sptr self) → gr::digital::trellis_metric_type_t

siso_combined_f_sptr.active_thread_priority(siso_combined_f_sptr self) → int

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

declare_sample_delay(siso_combined_f_sptr self, unsigned int delay)

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

siso_combined_f_sptr.min_noutput_items(siso_combined_f_sptr self) → int

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

pc_input_buffers_full_avg(siso_combined_f_sptr self) -> pmt_vector_float

siso_combined_f_sptr.pc_noutput_items_avg(siso_combined_f_sptr self) → float

siso_combined_f_sptr.pc_nproduced_avg(siso_combined_f_sptr self) → float

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

pc_output_buffers_full_avg(siso_combined_f_sptr self) -> pmt_vector_float

siso_combined_f_sptr.pc_throughput_avg(siso_combined_f_sptr self) → float

siso_combined_f_sptr.pc_work_time_avg(siso_combined_f_sptr self) → float

siso_combined_f_sptr.pc_work_time_total(siso_combined_f_sptr self) → float

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

siso_combined_f_sptr.set_D(siso_combined_f_sptr self, int D)

siso_combined_f_sptr.set_FSM(siso_combined_f_sptr self, fsm FSM)

siso_combined_f_sptr.set_K(siso_combined_f_sptr self, int K)

siso_combined_f_sptr.set_POSTI(siso_combined_f_sptr self, bool POSTI)

siso_combined_f_sptr.set_POSTO(siso_combined_f_sptr self, bool POSTO)

siso_combined_f_sptr.set_S0(siso_combined_f_sptr self, int S0)

siso_combined_f_sptr.set_SISO_TYPE(siso_combined_f_sptr self, gr::trellis::siso_type_t type)

siso_combined_f_sptr.set_SK(siso_combined_f_sptr self, int SK)

siso_combined_f_sptr.set_TABLE(siso_combined_f_sptr self, pmt_vector_float table)

siso_combined_f_sptr.set_TYPE(siso_combined_f_sptr self, gr::digital::trellis_metric_type_t type)

siso_combined_f_sptr.set_min_noutput_items(siso_combined_f_sptr self, int m)

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

siso_combined_f_sptr.thread_priority(siso_combined_f_sptr self) → int

gnuradio.trellis.siso_f(fsm FSM, int K, int S0, int SK, bool POSTI, bool POSTO, gr::trellis::siso_type_t d_SISO_TYPE) → siso_f_sptr

siso_f_sptr.FSM(siso_f_sptr self) → fsm

siso_f_sptr.K(siso_f_sptr self) → int

siso_f_sptr.POSTI(siso_f_sptr self) → bool

siso_f_sptr.POSTO(siso_f_sptr self) → bool

siso_f_sptr.S0(siso_f_sptr self) → int

siso_f_sptr.SISO_TYPE(siso_f_sptr self) → gr::trellis::siso_type_t

siso_f_sptr.SK(siso_f_sptr self) → int

siso_f_sptr.active_thread_priority(siso_f_sptr self) → int

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

declare_sample_delay(siso_f_sptr self, unsigned int delay)

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

siso_f_sptr.min_noutput_items(siso_f_sptr self) → int

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

pc_input_buffers_full_avg(siso_f_sptr self) -> pmt_vector_float

siso_f_sptr.pc_noutput_items_avg(siso_f_sptr self) → float

siso_f_sptr.pc_nproduced_avg(siso_f_sptr self) → float

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

pc_output_buffers_full_avg(siso_f_sptr self) -> pmt_vector_float

siso_f_sptr.pc_throughput_avg(siso_f_sptr self) → float

siso_f_sptr.pc_work_time_avg(siso_f_sptr self) → float

siso_f_sptr.pc_work_time_total(siso_f_sptr self) → float

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

siso_f_sptr.set_FSM(siso_f_sptr self, fsm FSM)

siso_f_sptr.set_K(siso_f_sptr self, int K)

siso_f_sptr.set_POSTI(siso_f_sptr self, bool posti)

siso_f_sptr.set_POSTO(siso_f_sptr self, bool posto)

siso_f_sptr.set_S0(siso_f_sptr self, int S0)

siso_f_sptr.set_SISO_TYPE(siso_f_sptr self, gr::trellis::siso_type_t type)

siso_f_sptr.set_SK(siso_f_sptr self, int SK)

siso_f_sptr.set_min_noutput_items(siso_f_sptr self, int m)

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

siso_f_sptr.thread_priority(siso_f_sptr self) → int

gnuradio.trellis.viterbi_b(fsm FSM, int K, int S0, int SK) → viterbi_b_sptr

viterbi_b_sptr.FSM(viterbi_b_sptr self) → fsm

viterbi_b_sptr.K(viterbi_b_sptr self) → int

viterbi_b_sptr.S0(viterbi_b_sptr self) → int

viterbi_b_sptr.SK(viterbi_b_sptr self) → int

viterbi_b_sptr.active_thread_priority(viterbi_b_sptr self) → int

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

declare_sample_delay(viterbi_b_sptr self, unsigned int delay)

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

viterbi_b_sptr.min_noutput_items(viterbi_b_sptr self) → int

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

pc_input_buffers_full_avg(viterbi_b_sptr self) -> pmt_vector_float

viterbi_b_sptr.pc_noutput_items_avg(viterbi_b_sptr self) → float

viterbi_b_sptr.pc_nproduced_avg(viterbi_b_sptr self) → float

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

pc_output_buffers_full_avg(viterbi_b_sptr self) -> pmt_vector_float

viterbi_b_sptr.pc_throughput_avg(viterbi_b_sptr self) → float

viterbi_b_sptr.pc_work_time_avg(viterbi_b_sptr self) → float

viterbi_b_sptr.pc_work_time_total(viterbi_b_sptr self) → float

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

viterbi_b_sptr.set_FSM(viterbi_b_sptr self, fsm FSM)

viterbi_b_sptr.set_K(viterbi_b_sptr self, int K)

viterbi_b_sptr.set_S0(viterbi_b_sptr self, int S0)

viterbi_b_sptr.set_SK(viterbi_b_sptr self, int SK)

viterbi_b_sptr.set_min_noutput_items(viterbi_b_sptr self, int m)

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

viterbi_b_sptr.thread_priority(viterbi_b_sptr self) → int

gnuradio.trellis.viterbi_combined_cb(fsm FSM, int K, int S0, int SK, int D, pmt_vector_cfloat TABLE, gr::digital::trellis_metric_type_t TYPE) → viterbi_combined_cb_sptr

viterbi_combined_cb_sptr.D(viterbi_combined_cb_sptr self) → int

viterbi_combined_cb_sptr.FSM(viterbi_combined_cb_sptr self) → fsm

viterbi_combined_cb_sptr.K(viterbi_combined_cb_sptr self) → int

viterbi_combined_cb_sptr.S0(viterbi_combined_cb_sptr self) → int

viterbi_combined_cb_sptr.SK(viterbi_combined_cb_sptr self) → int

viterbi_combined_cb_sptr.TABLE(viterbi_combined_cb_sptr self) → pmt_vector_cfloat

viterbi_combined_cb_sptr.TYPE(viterbi_combined_cb_sptr self) → gr::digital::trellis_metric_type_t

viterbi_combined_cb_sptr.active_thread_priority(viterbi_combined_cb_sptr self) → int

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

declare_sample_delay(viterbi_combined_cb_sptr self, unsigned int delay)

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

viterbi_combined_cb_sptr.min_noutput_items(viterbi_combined_cb_sptr self) → int

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

pc_input_buffers_full_avg(viterbi_combined_cb_sptr self) -> pmt_vector_float

viterbi_combined_cb_sptr.pc_noutput_items_avg(viterbi_combined_cb_sptr self) → float

viterbi_combined_cb_sptr.pc_nproduced_avg(viterbi_combined_cb_sptr self) → float

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

pc_output_buffers_full_avg(viterbi_combined_cb_sptr self) -> pmt_vector_float

viterbi_combined_cb_sptr.pc_throughput_avg(viterbi_combined_cb_sptr self) → float

viterbi_combined_cb_sptr.pc_work_time_avg(viterbi_combined_cb_sptr self) → float

viterbi_combined_cb_sptr.pc_work_time_total(viterbi_combined_cb_sptr self) → float

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

viterbi_combined_cb_sptr.set_D(viterbi_combined_cb_sptr self, int D)

viterbi_combined_cb_sptr.set_FSM(viterbi_combined_cb_sptr self, fsm FSM)

viterbi_combined_cb_sptr.set_K(viterbi_combined_cb_sptr self, int K)

viterbi_combined_cb_sptr.set_S0(viterbi_combined_cb_sptr self, int S0)

viterbi_combined_cb_sptr.set_SK(viterbi_combined_cb_sptr self, int SK)

viterbi_combined_cb_sptr.set_TABLE(viterbi_combined_cb_sptr self, pmt_vector_cfloat table)

viterbi_combined_cb_sptr.set_TYPE(viterbi_combined_cb_sptr self, gr::digital::trellis_metric_type_t type)

viterbi_combined_cb_sptr.set_min_noutput_items(viterbi_combined_cb_sptr self, int m)

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

viterbi_combined_cb_sptr.thread_priority(viterbi_combined_cb_sptr self) → int

gnuradio.trellis.viterbi_combined_ci(fsm FSM, int K, int S0, int SK, int D, pmt_vector_cfloat TABLE, gr::digital::trellis_metric_type_t TYPE) → viterbi_combined_ci_sptr

viterbi_combined_ci_sptr.D(viterbi_combined_ci_sptr self) → int

viterbi_combined_ci_sptr.FSM(viterbi_combined_ci_sptr self) → fsm

viterbi_combined_ci_sptr.K(viterbi_combined_ci_sptr self) → int

viterbi_combined_ci_sptr.S0(viterbi_combined_ci_sptr self) → int

viterbi_combined_ci_sptr.SK(viterbi_combined_ci_sptr self) → int

viterbi_combined_ci_sptr.TABLE(viterbi_combined_ci_sptr self) → pmt_vector_cfloat

viterbi_combined_ci_sptr.TYPE(viterbi_combined_ci_sptr self) → gr::digital::trellis_metric_type_t

viterbi_combined_ci_sptr.active_thread_priority(viterbi_combined_ci_sptr self) → int

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

declare_sample_delay(viterbi_combined_ci_sptr self, unsigned int delay)

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

viterbi_combined_ci_sptr.min_noutput_items(viterbi_combined_ci_sptr self) → int

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

pc_input_buffers_full_avg(viterbi_combined_ci_sptr self) -> pmt_vector_float

viterbi_combined_ci_sptr.pc_noutput_items_avg(viterbi_combined_ci_sptr self) → float

viterbi_combined_ci_sptr.pc_nproduced_avg(viterbi_combined_ci_sptr self) → float

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

pc_output_buffers_full_avg(viterbi_combined_ci_sptr self) -> pmt_vector_float

viterbi_combined_ci_sptr.pc_throughput_avg(viterbi_combined_ci_sptr self) → float

viterbi_combined_ci_sptr.pc_work_time_avg(viterbi_combined_ci_sptr self) → float

viterbi_combined_ci_sptr.pc_work_time_total(viterbi_combined_ci_sptr self) → float

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

viterbi_combined_ci_sptr.set_D(viterbi_combined_ci_sptr self, int D)

viterbi_combined_ci_sptr.set_FSM(viterbi_combined_ci_sptr self, fsm FSM)

viterbi_combined_ci_sptr.set_K(viterbi_combined_ci_sptr self, int K)

viterbi_combined_ci_sptr.set_S0(viterbi_combined_ci_sptr self, int S0)

viterbi_combined_ci_sptr.set_SK(viterbi_combined_ci_sptr self, int SK)

viterbi_combined_ci_sptr.set_TABLE(viterbi_combined_ci_sptr self, pmt_vector_cfloat table)

viterbi_combined_ci_sptr.set_TYPE(viterbi_combined_ci_sptr self, gr::digital::trellis_metric_type_t type)

viterbi_combined_ci_sptr.set_min_noutput_items(viterbi_combined_ci_sptr self, int m)

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

viterbi_combined_ci_sptr.thread_priority(viterbi_combined_ci_sptr self) → int

gnuradio.trellis.viterbi_combined_cs(fsm FSM, int K, int S0, int SK, int D, pmt_vector_cfloat TABLE, gr::digital::trellis_metric_type_t TYPE) → viterbi_combined_cs_sptr

viterbi_combined_cs_sptr.D(viterbi_combined_cs_sptr self) → int

viterbi_combined_cs_sptr.FSM(viterbi_combined_cs_sptr self) → fsm

viterbi_combined_cs_sptr.K(viterbi_combined_cs_sptr self) → int

viterbi_combined_cs_sptr.S0(viterbi_combined_cs_sptr self) → int

viterbi_combined_cs_sptr.SK(viterbi_combined_cs_sptr self) → int

viterbi_combined_cs_sptr.TABLE(viterbi_combined_cs_sptr self) → pmt_vector_cfloat

viterbi_combined_cs_sptr.TYPE(viterbi_combined_cs_sptr self) → gr::digital::trellis_metric_type_t

viterbi_combined_cs_sptr.active_thread_priority(viterbi_combined_cs_sptr self) → int

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

declare_sample_delay(viterbi_combined_cs_sptr self, unsigned int delay)

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

viterbi_combined_cs_sptr.min_noutput_items(viterbi_combined_cs_sptr self) → int

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

pc_input_buffers_full_avg(viterbi_combined_cs_sptr self) -> pmt_vector_float

viterbi_combined_cs_sptr.pc_noutput_items_avg(viterbi_combined_cs_sptr self) → float

viterbi_combined_cs_sptr.pc_nproduced_avg(viterbi_combined_cs_sptr self) → float

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

pc_output_buffers_full_avg(viterbi_combined_cs_sptr self) -> pmt_vector_float

viterbi_combined_cs_sptr.pc_throughput_avg(viterbi_combined_cs_sptr self) → float

viterbi_combined_cs_sptr.pc_work_time_avg(viterbi_combined_cs_sptr self) → float

viterbi_combined_cs_sptr.pc_work_time_total(viterbi_combined_cs_sptr self) → float

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

viterbi_combined_cs_sptr.set_D(viterbi_combined_cs_sptr self, int D)

viterbi_combined_cs_sptr.set_FSM(viterbi_combined_cs_sptr self, fsm FSM)

viterbi_combined_cs_sptr.set_K(viterbi_combined_cs_sptr self, int K)

viterbi_combined_cs_sptr.set_S0(viterbi_combined_cs_sptr self, int S0)

viterbi_combined_cs_sptr.set_SK(viterbi_combined_cs_sptr self, int SK)

viterbi_combined_cs_sptr.set_TABLE(viterbi_combined_cs_sptr self, pmt_vector_cfloat table)

viterbi_combined_cs_sptr.set_TYPE(viterbi_combined_cs_sptr self, gr::digital::trellis_metric_type_t type)

viterbi_combined_cs_sptr.set_min_noutput_items(viterbi_combined_cs_sptr self, int m)

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

viterbi_combined_cs_sptr.thread_priority(viterbi_combined_cs_sptr self) → int

gnuradio.trellis.viterbi_combined_fb(fsm FSM, int K, int S0, int SK, int D, pmt_vector_float TABLE, gr::digital::trellis_metric_type_t TYPE) → viterbi_combined_fb_sptr

viterbi_combined_fb_sptr.D(viterbi_combined_fb_sptr self) → int

viterbi_combined_fb_sptr.FSM(viterbi_combined_fb_sptr self) → fsm

viterbi_combined_fb_sptr.K(viterbi_combined_fb_sptr self) → int

viterbi_combined_fb_sptr.S0(viterbi_combined_fb_sptr self) → int

viterbi_combined_fb_sptr.SK(viterbi_combined_fb_sptr self) → int

viterbi_combined_fb_sptr.TABLE(viterbi_combined_fb_sptr self) → pmt_vector_float

viterbi_combined_fb_sptr.TYPE(viterbi_combined_fb_sptr self) → gr::digital::trellis_metric_type_t

viterbi_combined_fb_sptr.active_thread_priority(viterbi_combined_fb_sptr self) → int

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

declare_sample_delay(viterbi_combined_fb_sptr self, unsigned int delay)

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

viterbi_combined_fb_sptr.min_noutput_items(viterbi_combined_fb_sptr self) → int

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

pc_input_buffers_full_avg(viterbi_combined_fb_sptr self) -> pmt_vector_float

viterbi_combined_fb_sptr.pc_noutput_items_avg(viterbi_combined_fb_sptr self) → float

viterbi_combined_fb_sptr.pc_nproduced_avg(viterbi_combined_fb_sptr self) → float

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

pc_output_buffers_full_avg(viterbi_combined_fb_sptr self) -> pmt_vector_float

viterbi_combined_fb_sptr.pc_throughput_avg(viterbi_combined_fb_sptr self) → float

viterbi_combined_fb_sptr.pc_work_time_avg(viterbi_combined_fb_sptr self) → float

viterbi_combined_fb_sptr.pc_work_time_total(viterbi_combined_fb_sptr self) → float

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

viterbi_combined_fb_sptr.set_D(viterbi_combined_fb_sptr self, int D)

viterbi_combined_fb_sptr.set_FSM(viterbi_combined_fb_sptr self, fsm FSM)

viterbi_combined_fb_sptr.set_K(viterbi_combined_fb_sptr self, int K)

viterbi_combined_fb_sptr.set_S0(viterbi_combined_fb_sptr self, int S0)

viterbi_combined_fb_sptr.set_SK(viterbi_combined_fb_sptr self, int SK)

viterbi_combined_fb_sptr.set_TABLE(viterbi_combined_fb_sptr self, pmt_vector_float table)

viterbi_combined_fb_sptr.set_TYPE(viterbi_combined_fb_sptr self, gr::digital::trellis_metric_type_t type)

viterbi_combined_fb_sptr.set_min_noutput_items(viterbi_combined_fb_sptr self, int m)

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

viterbi_combined_fb_sptr.thread_priority(viterbi_combined_fb_sptr self) → int

gnuradio.trellis.viterbi_combined_fi(fsm FSM, int K, int S0, int SK, int D, pmt_vector_float TABLE, gr::digital::trellis_metric_type_t TYPE) → viterbi_combined_fi_sptr

viterbi_combined_fi_sptr.D(viterbi_combined_fi_sptr self) → int

viterbi_combined_fi_sptr.FSM(viterbi_combined_fi_sptr self) → fsm

viterbi_combined_fi_sptr.K(viterbi_combined_fi_sptr self) → int

viterbi_combined_fi_sptr.S0(viterbi_combined_fi_sptr self) → int

viterbi_combined_fi_sptr.SK(viterbi_combined_fi_sptr self) → int

viterbi_combined_fi_sptr.TABLE(viterbi_combined_fi_sptr self) → pmt_vector_float

viterbi_combined_fi_sptr.TYPE(viterbi_combined_fi_sptr self) → gr::digital::trellis_metric_type_t

viterbi_combined_fi_sptr.active_thread_priority(viterbi_combined_fi_sptr self) → int

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

declare_sample_delay(viterbi_combined_fi_sptr self, unsigned int delay)

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

viterbi_combined_fi_sptr.min_noutput_items(viterbi_combined_fi_sptr self) → int

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

pc_input_buffers_full_avg(viterbi_combined_fi_sptr self) -> pmt_vector_float

viterbi_combined_fi_sptr.pc_noutput_items_avg(viterbi_combined_fi_sptr self) → float

viterbi_combined_fi_sptr.pc_nproduced_avg(viterbi_combined_fi_sptr self) → float

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

pc_output_buffers_full_avg(viterbi_combined_fi_sptr self) -> pmt_vector_float

viterbi_combined_fi_sptr.pc_throughput_avg(viterbi_combined_fi_sptr self) → float

viterbi_combined_fi_sptr.pc_work_time_avg(viterbi_combined_fi_sptr self) → float

viterbi_combined_fi_sptr.pc_work_time_total(viterbi_combined_fi_sptr self) → float

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

viterbi_combined_fi_sptr.set_D(viterbi_combined_fi_sptr self, int D)

viterbi_combined_fi_sptr.set_FSM(viterbi_combined_fi_sptr self, fsm FSM)

viterbi_combined_fi_sptr.set_K(viterbi_combined_fi_sptr self, int K)

viterbi_combined_fi_sptr.set_S0(viterbi_combined_fi_sptr self, int S0)

viterbi_combined_fi_sptr.set_SK(viterbi_combined_fi_sptr self, int SK)

viterbi_combined_fi_sptr.set_TABLE(viterbi_combined_fi_sptr self, pmt_vector_float table)

viterbi_combined_fi_sptr.set_TYPE(viterbi_combined_fi_sptr self, gr::digital::trellis_metric_type_t type)

viterbi_combined_fi_sptr.set_min_noutput_items(viterbi_combined_fi_sptr self, int m)

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

viterbi_combined_fi_sptr.thread_priority(viterbi_combined_fi_sptr self) → int

gnuradio.trellis.viterbi_combined_fs(fsm FSM, int K, int S0, int SK, int D, pmt_vector_float TABLE, gr::digital::trellis_metric_type_t TYPE) → viterbi_combined_fs_sptr

viterbi_combined_fs_sptr.D(viterbi_combined_fs_sptr self) → int

viterbi_combined_fs_sptr.FSM(viterbi_combined_fs_sptr self) → fsm

viterbi_combined_fs_sptr.K(viterbi_combined_fs_sptr self) → int

viterbi_combined_fs_sptr.S0(viterbi_combined_fs_sptr self) → int

viterbi_combined_fs_sptr.SK(viterbi_combined_fs_sptr self) → int

viterbi_combined_fs_sptr.TABLE(viterbi_combined_fs_sptr self) → pmt_vector_float

viterbi_combined_fs_sptr.TYPE(viterbi_combined_fs_sptr self) → gr::digital::trellis_metric_type_t

viterbi_combined_fs_sptr.active_thread_priority(viterbi_combined_fs_sptr self) → int

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

declare_sample_delay(viterbi_combined_fs_sptr self, unsigned int delay)

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

viterbi_combined_fs_sptr.min_noutput_items(viterbi_combined_fs_sptr self) → int

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

pc_input_buffers_full_avg(viterbi_combined_fs_sptr self) -> pmt_vector_float

viterbi_combined_fs_sptr.pc_noutput_items_avg(viterbi_combined_fs_sptr self) → float

viterbi_combined_fs_sptr.pc_nproduced_avg(viterbi_combined_fs_sptr self) → float

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

pc_output_buffers_full_avg(viterbi_combined_fs_sptr self) -> pmt_vector_float

viterbi_combined_fs_sptr.pc_throughput_avg(viterbi_combined_fs_sptr self) → float

viterbi_combined_fs_sptr.pc_work_time_avg(viterbi_combined_fs_sptr self) → float

viterbi_combined_fs_sptr.pc_work_time_total(viterbi_combined_fs_sptr self) → float

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

viterbi_combined_fs_sptr.set_D(viterbi_combined_fs_sptr self, int D)

viterbi_combined_fs_sptr.set_FSM(viterbi_combined_fs_sptr self, fsm FSM)

viterbi_combined_fs_sptr.set_K(viterbi_combined_fs_sptr self, int K)

viterbi_combined_fs_sptr.set_S0(viterbi_combined_fs_sptr self, int S0)

viterbi_combined_fs_sptr.set_SK(viterbi_combined_fs_sptr self, int SK)

viterbi_combined_fs_sptr.set_TABLE(viterbi_combined_fs_sptr self, pmt_vector_float table)

viterbi_combined_fs_sptr.set_TYPE(viterbi_combined_fs_sptr self, gr::digital::trellis_metric_type_t type)

viterbi_combined_fs_sptr.set_min_noutput_items(viterbi_combined_fs_sptr self, int m)

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

viterbi_combined_fs_sptr.thread_priority(viterbi_combined_fs_sptr self) → int

gnuradio.trellis.viterbi_combined_ib(fsm FSM, int K, int S0, int SK, int D, std::vector< int, std::allocator< int > > const & TABLE, gr::digital::trellis_metric_type_t TYPE) → viterbi_combined_ib_sptr

viterbi_combined_ib_sptr.D(viterbi_combined_ib_sptr self) → int

viterbi_combined_ib_sptr.FSM(viterbi_combined_ib_sptr self) → fsm

viterbi_combined_ib_sptr.K(viterbi_combined_ib_sptr self) → int

viterbi_combined_ib_sptr.S0(viterbi_combined_ib_sptr self) → int

viterbi_combined_ib_sptr.SK(viterbi_combined_ib_sptr self) → int

viterbi_combined_ib_sptr.TABLE(viterbi_combined_ib_sptr self) → std::vector< int,std::allocator< int > >

viterbi_combined_ib_sptr.TYPE(viterbi_combined_ib_sptr self) → gr::digital::trellis_metric_type_t

viterbi_combined_ib_sptr.active_thread_priority(viterbi_combined_ib_sptr self) → int

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

declare_sample_delay(viterbi_combined_ib_sptr self, unsigned int delay)

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

viterbi_combined_ib_sptr.min_noutput_items(viterbi_combined_ib_sptr self) → int

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

pc_input_buffers_full_avg(viterbi_combined_ib_sptr self) -> pmt_vector_float

viterbi_combined_ib_sptr.pc_noutput_items_avg(viterbi_combined_ib_sptr self) → float

viterbi_combined_ib_sptr.pc_nproduced_avg(viterbi_combined_ib_sptr self) → float

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

pc_output_buffers_full_avg(viterbi_combined_ib_sptr self) -> pmt_vector_float

viterbi_combined_ib_sptr.pc_throughput_avg(viterbi_combined_ib_sptr self) → float

viterbi_combined_ib_sptr.pc_work_time_avg(viterbi_combined_ib_sptr self) → float

viterbi_combined_ib_sptr.pc_work_time_total(viterbi_combined_ib_sptr self) → float

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

viterbi_combined_ib_sptr.set_D(viterbi_combined_ib_sptr self, int D)

viterbi_combined_ib_sptr.set_FSM(viterbi_combined_ib_sptr self, fsm FSM)

viterbi_combined_ib_sptr.set_K(viterbi_combined_ib_sptr self, int K)

viterbi_combined_ib_sptr.set_S0(viterbi_combined_ib_sptr self, int S0)

viterbi_combined_ib_sptr.set_SK(viterbi_combined_ib_sptr self, int SK)

viterbi_combined_ib_sptr.set_TABLE(viterbi_combined_ib_sptr self, std::vector< int, std::allocator< int > > const & table)

viterbi_combined_ib_sptr.set_TYPE(viterbi_combined_ib_sptr self, gr::digital::trellis_metric_type_t type)

viterbi_combined_ib_sptr.set_min_noutput_items(viterbi_combined_ib_sptr self, int m)

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

viterbi_combined_ib_sptr.thread_priority(viterbi_combined_ib_sptr self) → int

gnuradio.trellis.viterbi_combined_ii(fsm FSM, int K, int S0, int SK, int D, std::vector< int, std::allocator< int > > const & TABLE, gr::digital::trellis_metric_type_t TYPE) → viterbi_combined_ii_sptr

viterbi_combined_ii_sptr.D(viterbi_combined_ii_sptr self) → int

viterbi_combined_ii_sptr.FSM(viterbi_combined_ii_sptr self) → fsm

viterbi_combined_ii_sptr.K(viterbi_combined_ii_sptr self) → int

viterbi_combined_ii_sptr.S0(viterbi_combined_ii_sptr self) → int

viterbi_combined_ii_sptr.SK(viterbi_combined_ii_sptr self) → int

viterbi_combined_ii_sptr.TABLE(viterbi_combined_ii_sptr self) → std::vector< int,std::allocator< int > >

viterbi_combined_ii_sptr.TYPE(viterbi_combined_ii_sptr self) → gr::digital::trellis_metric_type_t

viterbi_combined_ii_sptr.active_thread_priority(viterbi_combined_ii_sptr self) → int

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

declare_sample_delay(viterbi_combined_ii_sptr self, unsigned int delay)

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

viterbi_combined_ii_sptr.min_noutput_items(viterbi_combined_ii_sptr self) → int

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

pc_input_buffers_full_avg(viterbi_combined_ii_sptr self) -> pmt_vector_float

viterbi_combined_ii_sptr.pc_noutput_items_avg(viterbi_combined_ii_sptr self) → float

viterbi_combined_ii_sptr.pc_nproduced_avg(viterbi_combined_ii_sptr self) → float

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

pc_output_buffers_full_avg(viterbi_combined_ii_sptr self) -> pmt_vector_float

viterbi_combined_ii_sptr.pc_throughput_avg(viterbi_combined_ii_sptr self) → float

viterbi_combined_ii_sptr.pc_work_time_avg(viterbi_combined_ii_sptr self) → float

viterbi_combined_ii_sptr.pc_work_time_total(viterbi_combined_ii_sptr self) → float

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

viterbi_combined_ii_sptr.set_D(viterbi_combined_ii_sptr self, int D)

viterbi_combined_ii_sptr.set_FSM(viterbi_combined_ii_sptr self, fsm FSM)

viterbi_combined_ii_sptr.set_K(viterbi_combined_ii_sptr self, int K)

viterbi_combined_ii_sptr.set_S0(viterbi_combined_ii_sptr self, int S0)

viterbi_combined_ii_sptr.set_SK(viterbi_combined_ii_sptr self, int SK)

viterbi_combined_ii_sptr.set_TABLE(viterbi_combined_ii_sptr self, std::vector< int, std::allocator< int > > const & table)

viterbi_combined_ii_sptr.set_TYPE(viterbi_combined_ii_sptr self, gr::digital::trellis_metric_type_t type)

viterbi_combined_ii_sptr.set_min_noutput_items(viterbi_combined_ii_sptr self, int m)

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

viterbi_combined_ii_sptr.thread_priority(viterbi_combined_ii_sptr self) → int

gnuradio.trellis.viterbi_combined_is(fsm FSM, int K, int S0, int SK, int D, std::vector< int, std::allocator< int > > const & TABLE, gr::digital::trellis_metric_type_t TYPE) → viterbi_combined_is_sptr

viterbi_combined_is_sptr.D(viterbi_combined_is_sptr self) → int

viterbi_combined_is_sptr.FSM(viterbi_combined_is_sptr self) → fsm

viterbi_combined_is_sptr.K(viterbi_combined_is_sptr self) → int

viterbi_combined_is_sptr.S0(viterbi_combined_is_sptr self) → int

viterbi_combined_is_sptr.SK(viterbi_combined_is_sptr self) → int

viterbi_combined_is_sptr.TABLE(viterbi_combined_is_sptr self) → std::vector< int,std::allocator< int > >

viterbi_combined_is_sptr.TYPE(viterbi_combined_is_sptr self) → gr::digital::trellis_metric_type_t

viterbi_combined_is_sptr.active_thread_priority(viterbi_combined_is_sptr self) → int

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

declare_sample_delay(viterbi_combined_is_sptr self, unsigned int delay)

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

viterbi_combined_is_sptr.min_noutput_items(viterbi_combined_is_sptr self) → int

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

pc_input_buffers_full_avg(viterbi_combined_is_sptr self) -> pmt_vector_float

viterbi_combined_is_sptr.pc_noutput_items_avg(viterbi_combined_is_sptr self) → float

viterbi_combined_is_sptr.pc_nproduced_avg(viterbi_combined_is_sptr self) → float

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

pc_output_buffers_full_avg(viterbi_combined_is_sptr self) -> pmt_vector_float

viterbi_combined_is_sptr.pc_throughput_avg(viterbi_combined_is_sptr self) → float

viterbi_combined_is_sptr.pc_work_time_avg(viterbi_combined_is_sptr self) → float

viterbi_combined_is_sptr.pc_work_time_total(viterbi_combined_is_sptr self) → float

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

viterbi_combined_is_sptr.set_D(viterbi_combined_is_sptr self, int D)

viterbi_combined_is_sptr.set_FSM(viterbi_combined_is_sptr self, fsm FSM)

viterbi_combined_is_sptr.set_K(viterbi_combined_is_sptr self, int K)

viterbi_combined_is_sptr.set_S0(viterbi_combined_is_sptr self, int S0)

viterbi_combined_is_sptr.set_SK(viterbi_combined_is_sptr self, int SK)

viterbi_combined_is_sptr.set_TABLE(viterbi_combined_is_sptr self, std::vector< int, std::allocator< int > > const & table)

viterbi_combined_is_sptr.set_TYPE(viterbi_combined_is_sptr self, gr::digital::trellis_metric_type_t type)

viterbi_combined_is_sptr.set_min_noutput_items(viterbi_combined_is_sptr self, int m)

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

viterbi_combined_is_sptr.thread_priority(viterbi_combined_is_sptr self) → int

gnuradio.trellis.viterbi_combined_sb(fsm FSM, int K, int S0, int SK, int D, std::vector< short, std::allocator< short > > const & TABLE, gr::digital::trellis_metric_type_t TYPE) → viterbi_combined_sb_sptr

viterbi_combined_sb_sptr.D(viterbi_combined_sb_sptr self) → int

viterbi_combined_sb_sptr.FSM(viterbi_combined_sb_sptr self) → fsm

viterbi_combined_sb_sptr.K(viterbi_combined_sb_sptr self) → int

viterbi_combined_sb_sptr.S0(viterbi_combined_sb_sptr self) → int

viterbi_combined_sb_sptr.SK(viterbi_combined_sb_sptr self) → int

viterbi_combined_sb_sptr.TABLE(viterbi_combined_sb_sptr self) → std::vector< short,std::allocator< short > >

viterbi_combined_sb_sptr.TYPE(viterbi_combined_sb_sptr self) → gr::digital::trellis_metric_type_t

viterbi_combined_sb_sptr.active_thread_priority(viterbi_combined_sb_sptr self) → int

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

declare_sample_delay(viterbi_combined_sb_sptr self, unsigned int delay)

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

viterbi_combined_sb_sptr.min_noutput_items(viterbi_combined_sb_sptr self) → int

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

pc_input_buffers_full_avg(viterbi_combined_sb_sptr self) -> pmt_vector_float

viterbi_combined_sb_sptr.pc_noutput_items_avg(viterbi_combined_sb_sptr self) → float

viterbi_combined_sb_sptr.pc_nproduced_avg(viterbi_combined_sb_sptr self) → float

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

pc_output_buffers_full_avg(viterbi_combined_sb_sptr self) -> pmt_vector_float

viterbi_combined_sb_sptr.pc_throughput_avg(viterbi_combined_sb_sptr self) → float

viterbi_combined_sb_sptr.pc_work_time_avg(viterbi_combined_sb_sptr self) → float

viterbi_combined_sb_sptr.pc_work_time_total(viterbi_combined_sb_sptr self) → float

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

viterbi_combined_sb_sptr.set_D(viterbi_combined_sb_sptr self, int D)

viterbi_combined_sb_sptr.set_FSM(viterbi_combined_sb_sptr self, fsm FSM)

viterbi_combined_sb_sptr.set_K(viterbi_combined_sb_sptr self, int K)

viterbi_combined_sb_sptr.set_S0(viterbi_combined_sb_sptr self, int S0)

viterbi_combined_sb_sptr.set_SK(viterbi_combined_sb_sptr self, int SK)

viterbi_combined_sb_sptr.set_TABLE(viterbi_combined_sb_sptr self, std::vector< short, std::allocator< short > > const & table)

viterbi_combined_sb_sptr.set_TYPE(viterbi_combined_sb_sptr self, gr::digital::trellis_metric_type_t type)

viterbi_combined_sb_sptr.set_min_noutput_items(viterbi_combined_sb_sptr self, int m)

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

viterbi_combined_sb_sptr.thread_priority(viterbi_combined_sb_sptr self) → int

gnuradio.trellis.viterbi_combined_si(fsm FSM, int K, int S0, int SK, int D, std::vector< short, std::allocator< short > > const & TABLE, gr::digital::trellis_metric_type_t TYPE) → viterbi_combined_si_sptr

viterbi_combined_si_sptr.D(viterbi_combined_si_sptr self) → int

viterbi_combined_si_sptr.FSM(viterbi_combined_si_sptr self) → fsm

viterbi_combined_si_sptr.K(viterbi_combined_si_sptr self) → int

viterbi_combined_si_sptr.S0(viterbi_combined_si_sptr self) → int

viterbi_combined_si_sptr.SK(viterbi_combined_si_sptr self) → int

viterbi_combined_si_sptr.TABLE(viterbi_combined_si_sptr self) → std::vector< short,std::allocator< short > >

viterbi_combined_si_sptr.TYPE(viterbi_combined_si_sptr self) → gr::digital::trellis_metric_type_t

viterbi_combined_si_sptr.active_thread_priority(viterbi_combined_si_sptr self) → int

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

declare_sample_delay(viterbi_combined_si_sptr self, unsigned int delay)

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

viterbi_combined_si_sptr.min_noutput_items(viterbi_combined_si_sptr self) → int

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

pc_input_buffers_full_avg(viterbi_combined_si_sptr self) -> pmt_vector_float

viterbi_combined_si_sptr.pc_noutput_items_avg(viterbi_combined_si_sptr self) → float

viterbi_combined_si_sptr.pc_nproduced_avg(viterbi_combined_si_sptr self) → float

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

pc_output_buffers_full_avg(viterbi_combined_si_sptr self) -> pmt_vector_float

viterbi_combined_si_sptr.pc_throughput_avg(viterbi_combined_si_sptr self) → float

viterbi_combined_si_sptr.pc_work_time_avg(viterbi_combined_si_sptr self) → float

viterbi_combined_si_sptr.pc_work_time_total(viterbi_combined_si_sptr self) → float

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

viterbi_combined_si_sptr.set_D(viterbi_combined_si_sptr self, int D)

viterbi_combined_si_sptr.set_FSM(viterbi_combined_si_sptr self, fsm FSM)

viterbi_combined_si_sptr.set_K(viterbi_combined_si_sptr self, int K)

viterbi_combined_si_sptr.set_S0(viterbi_combined_si_sptr self, int S0)

viterbi_combined_si_sptr.set_SK(viterbi_combined_si_sptr self, int SK)

viterbi_combined_si_sptr.set_TABLE(viterbi_combined_si_sptr self, std::vector< short, std::allocator< short > > const & table)

viterbi_combined_si_sptr.set_TYPE(viterbi_combined_si_sptr self, gr::digital::trellis_metric_type_t type)

viterbi_combined_si_sptr.set_min_noutput_items(viterbi_combined_si_sptr self, int m)

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

viterbi_combined_si_sptr.thread_priority(viterbi_combined_si_sptr self) → int

gnuradio.trellis.viterbi_combined_ss(fsm FSM, int K, int S0, int SK, int D, std::vector< short, std::allocator< short > > const & TABLE, gr::digital::trellis_metric_type_t TYPE) → viterbi_combined_ss_sptr

viterbi_combined_ss_sptr.D(viterbi_combined_ss_sptr self) → int

viterbi_combined_ss_sptr.FSM(viterbi_combined_ss_sptr self) → fsm

viterbi_combined_ss_sptr.K(viterbi_combined_ss_sptr self) → int

viterbi_combined_ss_sptr.S0(viterbi_combined_ss_sptr self) → int

viterbi_combined_ss_sptr.SK(viterbi_combined_ss_sptr self) → int

viterbi_combined_ss_sptr.TABLE(viterbi_combined_ss_sptr self) → std::vector< short,std::allocator< short > >

viterbi_combined_ss_sptr.TYPE(viterbi_combined_ss_sptr self) → gr::digital::trellis_metric_type_t

viterbi_combined_ss_sptr.active_thread_priority(viterbi_combined_ss_sptr self) → int

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

declare_sample_delay(viterbi_combined_ss_sptr self, unsigned int delay)

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

viterbi_combined_ss_sptr.min_noutput_items(viterbi_combined_ss_sptr self) → int

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

pc_input_buffers_full_avg(viterbi_combined_ss_sptr self) -> pmt_vector_float

viterbi_combined_ss_sptr.pc_noutput_items_avg(viterbi_combined_ss_sptr self) → float

viterbi_combined_ss_sptr.pc_nproduced_avg(viterbi_combined_ss_sptr self) → float

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

pc_output_buffers_full_avg(viterbi_combined_ss_sptr self) -> pmt_vector_float

viterbi_combined_ss_sptr.pc_throughput_avg(viterbi_combined_ss_sptr self) → float

viterbi_combined_ss_sptr.pc_work_time_avg(viterbi_combined_ss_sptr self) → float

viterbi_combined_ss_sptr.pc_work_time_total(viterbi_combined_ss_sptr self) → float

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

viterbi_combined_ss_sptr.set_D(viterbi_combined_ss_sptr self, int D)

viterbi_combined_ss_sptr.set_FSM(viterbi_combined_ss_sptr self, fsm FSM)

viterbi_combined_ss_sptr.set_K(viterbi_combined_ss_sptr self, int K)

viterbi_combined_ss_sptr.set_S0(viterbi_combined_ss_sptr self, int S0)

viterbi_combined_ss_sptr.set_SK(viterbi_combined_ss_sptr self, int SK)

viterbi_combined_ss_sptr.set_TABLE(viterbi_combined_ss_sptr self, std::vector< short, std::allocator< short > > const & table)

viterbi_combined_ss_sptr.set_TYPE(viterbi_combined_ss_sptr self, gr::digital::trellis_metric_type_t type)

viterbi_combined_ss_sptr.set_min_noutput_items(viterbi_combined_ss_sptr self, int m)

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

viterbi_combined_ss_sptr.thread_priority(viterbi_combined_ss_sptr self) → int

gnuradio.trellis.viterbi_i(fsm FSM, int K, int S0, int SK) → viterbi_i_sptr

viterbi_i_sptr.FSM(viterbi_i_sptr self) → fsm

viterbi_i_sptr.K(viterbi_i_sptr self) → int

viterbi_i_sptr.S0(viterbi_i_sptr self) → int

viterbi_i_sptr.SK(viterbi_i_sptr self) → int

viterbi_i_sptr.active_thread_priority(viterbi_i_sptr self) → int

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

declare_sample_delay(viterbi_i_sptr self, unsigned int delay)

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

viterbi_i_sptr.min_noutput_items(viterbi_i_sptr self) → int

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

pc_input_buffers_full_avg(viterbi_i_sptr self) -> pmt_vector_float

viterbi_i_sptr.pc_noutput_items_avg(viterbi_i_sptr self) → float

viterbi_i_sptr.pc_nproduced_avg(viterbi_i_sptr self) → float

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

pc_output_buffers_full_avg(viterbi_i_sptr self) -> pmt_vector_float

viterbi_i_sptr.pc_throughput_avg(viterbi_i_sptr self) → float

viterbi_i_sptr.pc_work_time_avg(viterbi_i_sptr self) → float

viterbi_i_sptr.pc_work_time_total(viterbi_i_sptr self) → float

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

viterbi_i_sptr.set_FSM(viterbi_i_sptr self, fsm FSM)

viterbi_i_sptr.set_K(viterbi_i_sptr self, int K)

viterbi_i_sptr.set_S0(viterbi_i_sptr self, int S0)

viterbi_i_sptr.set_SK(viterbi_i_sptr self, int SK)

viterbi_i_sptr.set_min_noutput_items(viterbi_i_sptr self, int m)

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

viterbi_i_sptr.thread_priority(viterbi_i_sptr self) → int

gnuradio.trellis.viterbi_s(fsm FSM, int K, int S0, int SK) → viterbi_s_sptr

viterbi_s_sptr.FSM(viterbi_s_sptr self) → fsm

viterbi_s_sptr.K(viterbi_s_sptr self) → int

viterbi_s_sptr.S0(viterbi_s_sptr self) → int

viterbi_s_sptr.SK(viterbi_s_sptr self) → int

viterbi_s_sptr.active_thread_priority(viterbi_s_sptr self) → int

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

declare_sample_delay(viterbi_s_sptr self, unsigned int delay)

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

viterbi_s_sptr.min_noutput_items(viterbi_s_sptr self) → int

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

pc_input_buffers_full_avg(viterbi_s_sptr self) -> pmt_vector_float

viterbi_s_sptr.pc_noutput_items_avg(viterbi_s_sptr self) → float

viterbi_s_sptr.pc_nproduced_avg(viterbi_s_sptr self) → float

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

pc_output_buffers_full_avg(viterbi_s_sptr self) -> pmt_vector_float

viterbi_s_sptr.pc_throughput_avg(viterbi_s_sptr self) → float

viterbi_s_sptr.pc_work_time_avg(viterbi_s_sptr self) → float

viterbi_s_sptr.pc_work_time_total(viterbi_s_sptr self) → float

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

viterbi_s_sptr.set_FSM(viterbi_s_sptr self, fsm FSM)

viterbi_s_sptr.set_K(viterbi_s_sptr self, int K)

viterbi_s_sptr.set_S0(viterbi_s_sptr self, int S0)

viterbi_s_sptr.set_SK(viterbi_s_sptr self, int SK)

viterbi_s_sptr.set_min_noutput_items(viterbi_s_sptr self, int m)

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

viterbi_s_sptr.thread_priority(viterbi_s_sptr self) → int