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

Evaluate metrics for use by the Viterbi algorithm.

Constructor Specific Documentation:

Parameters:
  • constellation
  • TYPE
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

Convolutional encoder.

Constructor Specific Documentation:

Parameters:
  • FSM
  • ST
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

Convolutional encoder.

Constructor Specific Documentation:

Parameters:
  • FSM
  • ST
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

Convolutional encoder.

Constructor Specific Documentation:

Parameters:
  • FSM
  • ST
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

Convolutional encoder.

Constructor Specific Documentation:

Parameters:
  • FSM
  • ST
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

Convolutional encoder.

Constructor Specific Documentation:

Parameters:
  • FSM
  • ST
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

Convolutional encoder.

Constructor Specific Documentation:

Parameters:
  • FSM
  • ST
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

Evaluate metrics for use by the Viterbi algorithm.

Constructor Specific Documentation:

Parameters:
  • O
  • D
  • TABLE
  • TYPE
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

Evaluate metrics for use by the Viterbi algorithm.

Constructor Specific Documentation:

Parameters:
  • O
  • D
  • TABLE
  • TYPE
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

Evaluate metrics for use by the Viterbi algorithm.

Constructor Specific Documentation:

Parameters:
  • O
  • D
  • TABLE
  • TYPE
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

Evaluate metrics for use by the Viterbi algorithm.

Constructor Specific Documentation:

Parameters:
  • O
  • D
  • TABLE
  • TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSM1
  • ST10
  • ST1K
  • FSM2
  • ST20
  • ST2K
  • INTERLEAVER
  • blocklength
  • repetitions
  • SISO_TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo0
  • SToK
  • FSMi
  • STi0
  • STiK
  • INTERLEAVER
  • blocklength
  • repetitions
  • SISO_TYPE
  • D
  • TABLE
  • METRIC_TYPE
  • scaling
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

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo0
  • SToK
  • FSMi
  • STi0
  • STiK
  • INTERLEAVER
  • blocklength
  • repetitions
  • SISO_TYPE
  • D
  • TABLE
  • METRIC_TYPE
  • scaling
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

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo0
  • SToK
  • FSMi
  • STi0
  • STiK
  • INTERLEAVER
  • blocklength
  • repetitions
  • SISO_TYPE
  • D
  • TABLE
  • METRIC_TYPE
  • scaling
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

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo0
  • SToK
  • FSMi
  • STi0
  • STiK
  • INTERLEAVER
  • blocklength
  • repetitions
  • SISO_TYPE
  • D
  • TABLE
  • METRIC_TYPE
  • scaling
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

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo0
  • SToK
  • FSMi
  • STi0
  • STiK
  • INTERLEAVER
  • blocklength
  • repetitions
  • SISO_TYPE
  • D
  • TABLE
  • METRIC_TYPE
  • scaling
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

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo0
  • SToK
  • FSMi
  • STi0
  • STiK
  • INTERLEAVER
  • blocklength
  • repetitions
  • SISO_TYPE
  • D
  • TABLE
  • METRIC_TYPE
  • scaling
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

Constructor Specific Documentation:

Parameters:
  • FSM1
  • ST10
  • ST1K
  • FSM2
  • ST20
  • ST2K
  • INTERLEAVER
  • blocklength
  • repetitions
  • SISO_TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSM1
  • ST10
  • ST1K
  • FSM2
  • ST20
  • ST2K
  • INTERLEAVER
  • blocklength
  • repetitions
  • SISO_TYPE
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.

Constructor Specific Documentation:

Parameters:
  • FSM1
  • ST1
  • FSM2
  • ST2
  • INTERLEAVER
  • blocklength
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.

Constructor Specific Documentation:

Parameters:
  • FSM1
  • ST1
  • FSM2
  • ST2
  • INTERLEAVER
  • blocklength
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.

Constructor Specific Documentation:

Parameters:
  • FSM1
  • ST1
  • FSM2
  • ST2
  • INTERLEAVER
  • blocklength
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.

Constructor Specific Documentation:

Parameters:
  • FSM1
  • ST1
  • FSM2
  • ST2
  • INTERLEAVER
  • blocklength
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.

Constructor Specific Documentation:

Parameters:
  • FSM1
  • ST1
  • FSM2
  • ST2
  • INTERLEAVER
  • blocklength
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.

Constructor Specific Documentation:

Parameters:
  • FSM1
  • ST1
  • FSM2
  • ST2
  • INTERLEAVER
  • blocklength
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.

Constructor Specific Documentation:

Parameters:
  • K
  • TABLE
  • SYMS_PER_BLOCK
  • NBYTES
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

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo0
  • SToK
  • FSMi
  • STi0
  • STiK
  • INTERLEAVER
  • blocklength
  • repetitions
  • SISO_TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo0
  • SToK
  • FSMi
  • STi0
  • STiK
  • INTERLEAVER
  • blocklength
  • repetitions
  • SISO_TYPE
  • D
  • TABLE
  • METRIC_TYPE
  • scaling
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

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo0
  • SToK
  • FSMi
  • STi0
  • STiK
  • INTERLEAVER
  • blocklength
  • repetitions
  • SISO_TYPE
  • D
  • TABLE
  • METRIC_TYPE
  • scaling
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

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo0
  • SToK
  • FSMi
  • STi0
  • STiK
  • INTERLEAVER
  • blocklength
  • repetitions
  • SISO_TYPE
  • D
  • TABLE
  • METRIC_TYPE
  • scaling
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

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo0
  • SToK
  • FSMi
  • STi0
  • STiK
  • INTERLEAVER
  • blocklength
  • repetitions
  • SISO_TYPE
  • D
  • TABLE
  • METRIC_TYPE
  • scaling
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

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo0
  • SToK
  • FSMi
  • STi0
  • STiK
  • INTERLEAVER
  • blocklength
  • repetitions
  • SISO_TYPE
  • D
  • TABLE
  • METRIC_TYPE
  • scaling
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

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo0
  • SToK
  • FSMi
  • STi0
  • STiK
  • INTERLEAVER
  • blocklength
  • repetitions
  • SISO_TYPE
  • D
  • TABLE
  • METRIC_TYPE
  • scaling
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

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo0
  • SToK
  • FSMi
  • STi0
  • STiK
  • INTERLEAVER
  • blocklength
  • repetitions
  • SISO_TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo0
  • SToK
  • FSMi
  • STi0
  • STiK
  • INTERLEAVER
  • blocklength
  • repetitions
  • SISO_TYPE
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.

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo
  • FSMi
  • STi
  • INTERLEAVER
  • blocklength
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.

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo
  • FSMi
  • STi
  • INTERLEAVER
  • blocklength
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.

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo
  • FSMi
  • STi
  • INTERLEAVER
  • blocklength
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.

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo
  • FSMi
  • STi
  • INTERLEAVER
  • blocklength
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.

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo
  • FSMi
  • STi
  • INTERLEAVER
  • blocklength
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.

Constructor Specific Documentation:

Parameters:
  • FSMo
  • STo
  • FSMi
  • STi
  • INTERLEAVER
  • blocklength
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

Constructor Specific Documentation:

Parameters:
  • FSM
  • K
  • S0
  • SK
  • POSTI
  • POSTO
  • d_SISO_TYPE
  • D
  • TABLE
  • TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSM
  • K
  • S0
  • SK
  • POSTI
  • POSTO
  • d_SISO_TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSM
  • K
  • S0
  • SK
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

Constructor Specific Documentation:

Parameters:
  • FSM
  • K
  • S0
  • SK
  • D
  • TABLE
  • TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSM
  • K
  • S0
  • SK
  • D
  • TABLE
  • TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSM
  • K
  • S0
  • SK
  • D
  • TABLE
  • TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSM
  • K
  • S0
  • SK
  • D
  • TABLE
  • TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSM
  • K
  • S0
  • SK
  • D
  • TABLE
  • TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSM
  • K
  • S0
  • SK
  • D
  • TABLE
  • TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSM
  • K
  • S0
  • SK
  • D
  • TABLE
  • TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSM
  • K
  • S0
  • SK
  • D
  • TABLE
  • TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSM
  • K
  • S0
  • SK
  • D
  • TABLE
  • TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSM
  • K
  • S0
  • SK
  • D
  • TABLE
  • TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSM
  • K
  • S0
  • SK
  • D
  • TABLE
  • TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSM
  • K
  • S0
  • SK
  • D
  • TABLE
  • TYPE
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

Constructor Specific Documentation:

Parameters:
  • FSM
  • K
  • S0
  • SK
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

Constructor Specific Documentation:

Parameters:
  • FSM
  • K
  • S0
  • SK
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