# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.1
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _analog_swig
else:
    import _analog_swig

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)



def high_res_timer_now() -> "gr::high_res_timer_type":
    r"""high_res_timer_now() -> gr::high_res_timer_type"""
    return _analog_swig.high_res_timer_now()

def high_res_timer_now_perfmon() -> "gr::high_res_timer_type":
    r"""high_res_timer_now_perfmon() -> gr::high_res_timer_type"""
    return _analog_swig.high_res_timer_now_perfmon()

def high_res_timer_tps() -> "gr::high_res_timer_type":
    r"""high_res_timer_tps() -> gr::high_res_timer_type"""
    return _analog_swig.high_res_timer_tps()

def high_res_timer_epoch() -> "gr::high_res_timer_type":
    r"""high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _analog_swig.high_res_timer_epoch()
class control_loop(object):
    r"""Proxy of C++ gr::blocks::control_loop class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(control_loop self) -> control_loop
        __init__(control_loop self, float loop_bw, float max_freq, float min_freq) -> control_loop
        """
        _analog_swig.control_loop_swiginit(self, _analog_swig.new_control_loop(*args))
    __swig_destroy__ = _analog_swig.delete_control_loop

    def update_gains(self) -> "void":
        r"""update_gains(control_loop self)"""
        return _analog_swig.control_loop_update_gains(self)

    def advance_loop(self, error: "float") -> "void":
        r"""advance_loop(control_loop self, float error)"""
        return _analog_swig.control_loop_advance_loop(self, error)

    def phase_wrap(self) -> "void":
        r"""phase_wrap(control_loop self)"""
        return _analog_swig.control_loop_phase_wrap(self)

    def frequency_limit(self) -> "void":
        r"""frequency_limit(control_loop self)"""
        return _analog_swig.control_loop_frequency_limit(self)

    def set_loop_bandwidth(self, bw: "float") -> "void":
        r"""set_loop_bandwidth(control_loop self, float bw)"""
        return _analog_swig.control_loop_set_loop_bandwidth(self, bw)

    def set_damping_factor(self, df: "float") -> "void":
        r"""set_damping_factor(control_loop self, float df)"""
        return _analog_swig.control_loop_set_damping_factor(self, df)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(control_loop self, float alpha)"""
        return _analog_swig.control_loop_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(control_loop self, float beta)"""
        return _analog_swig.control_loop_set_beta(self, beta)

    def set_frequency(self, freq: "float") -> "void":
        r"""set_frequency(control_loop self, float freq)"""
        return _analog_swig.control_loop_set_frequency(self, freq)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(control_loop self, float phase)"""
        return _analog_swig.control_loop_set_phase(self, phase)

    def set_max_freq(self, freq: "float") -> "void":
        r"""set_max_freq(control_loop self, float freq)"""
        return _analog_swig.control_loop_set_max_freq(self, freq)

    def set_min_freq(self, freq: "float") -> "void":
        r"""set_min_freq(control_loop self, float freq)"""
        return _analog_swig.control_loop_set_min_freq(self, freq)

    def get_loop_bandwidth(self) -> "float":
        r"""get_loop_bandwidth(control_loop self) -> float"""
        return _analog_swig.control_loop_get_loop_bandwidth(self)

    def get_damping_factor(self) -> "float":
        r"""get_damping_factor(control_loop self) -> float"""
        return _analog_swig.control_loop_get_damping_factor(self)

    def get_alpha(self) -> "float":
        r"""get_alpha(control_loop self) -> float"""
        return _analog_swig.control_loop_get_alpha(self)

    def get_beta(self) -> "float":
        r"""get_beta(control_loop self) -> float"""
        return _analog_swig.control_loop_get_beta(self)

    def get_frequency(self) -> "float":
        r"""get_frequency(control_loop self) -> float"""
        return _analog_swig.control_loop_get_frequency(self)

    def get_phase(self) -> "float":
        r"""get_phase(control_loop self) -> float"""
        return _analog_swig.control_loop_get_phase(self)

    def get_max_freq(self) -> "float":
        r"""get_max_freq(control_loop self) -> float"""
        return _analog_swig.control_loop_get_max_freq(self)

    def get_min_freq(self) -> "float":
        r"""get_min_freq(control_loop self) -> float"""
        return _analog_swig.control_loop_get_min_freq(self)

# Register control_loop in _analog_swig:
_analog_swig.control_loop_swigregister(control_loop)


def tanhf_lut(x: "float") -> "float":
    r"""tanhf_lut(float x) -> float"""
    return _analog_swig.tanhf_lut(x)
class cpm(object):
    r"""Proxy of C++ gr::analog::cpm class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    LRC = _analog_swig.cpm_LRC
    
    LSRC = _analog_swig.cpm_LSRC
    
    LREC = _analog_swig.cpm_LREC
    
    TFM = _analog_swig.cpm_TFM
    
    GAUSSIAN = _analog_swig.cpm_GAUSSIAN
    
    GENERIC = _analog_swig.cpm_GENERIC
    

    @staticmethod
    def phase_response(type: "gr::analog::cpm::cpm_type", samples_per_sym: "unsigned int", L: "unsigned int", beta: "double"=0.3) -> "std::vector< float,std::allocator< float > >":
        r"""phase_response(gr::analog::cpm::cpm_type type, unsigned int samples_per_sym, unsigned int L, double beta=0.3) -> pmt_vector_float"""
        return _analog_swig.cpm_phase_response(type, samples_per_sym, L, beta)

    def __init__(self):
        r"""__init__(cpm self) -> cpm"""
        _analog_swig.cpm_swiginit(self, _analog_swig.new_cpm())
    __swig_destroy__ = _analog_swig.delete_cpm

# Register cpm in _analog_swig:
_analog_swig.cpm_swigregister(cpm)
cvar = _analog_swig.cvar

def cpm_phase_response(type: "gr::analog::cpm::cpm_type", samples_per_sym: "unsigned int", L: "unsigned int", beta: "double"=0.3) -> "std::vector< float,std::allocator< float > >":
    r"""cpm_phase_response(gr::analog::cpm::cpm_type type, unsigned int samples_per_sym, unsigned int L, double beta=0.3) -> pmt_vector_float"""
    return _analog_swig.cpm_phase_response(type, samples_per_sym, L, beta)

GR_UNIFORM = _analog_swig.GR_UNIFORM

GR_GAUSSIAN = _analog_swig.GR_GAUSSIAN

GR_LAPLACIAN = _analog_swig.GR_LAPLACIAN

GR_IMPULSE = _analog_swig.GR_IMPULSE

class agc_cc(object):
    r"""Proxy of C++ gr::analog::agc_cc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(rate: "float"=1e-4, reference: "float"=1.0, gain: "float"=1.0) -> "gr::analog::agc_cc::sptr":
        r"""make(float rate=1e-4, float reference=1.0, float gain=1.0) -> agc_cc_sptr"""
        return _analog_swig.agc_cc_make(rate, reference, gain)

    def rate(self) -> "float":
        r"""rate(agc_cc self) -> float"""
        return _analog_swig.agc_cc_rate(self)

    def reference(self) -> "float":
        r"""reference(agc_cc self) -> float"""
        return _analog_swig.agc_cc_reference(self)

    def gain(self) -> "float":
        r"""gain(agc_cc self) -> float"""
        return _analog_swig.agc_cc_gain(self)

    def max_gain(self) -> "float":
        r"""max_gain(agc_cc self) -> float"""
        return _analog_swig.agc_cc_max_gain(self)

    def set_rate(self, rate: "float") -> "void":
        r"""set_rate(agc_cc self, float rate)"""
        return _analog_swig.agc_cc_set_rate(self, rate)

    def set_reference(self, reference: "float") -> "void":
        r"""set_reference(agc_cc self, float reference)"""
        return _analog_swig.agc_cc_set_reference(self, reference)

    def set_gain(self, gain: "float") -> "void":
        r"""set_gain(agc_cc self, float gain)"""
        return _analog_swig.agc_cc_set_gain(self, gain)

    def set_max_gain(self, max_gain: "float") -> "void":
        r"""set_max_gain(agc_cc self, float max_gain)"""
        return _analog_swig.agc_cc_set_max_gain(self, max_gain)
    __swig_destroy__ = _analog_swig.delete_agc_cc

# Register agc_cc in _analog_swig:
_analog_swig.agc_cc_swigregister(agc_cc)

def agc_cc_make(rate: "float"=1e-4, reference: "float"=1.0, gain: "float"=1.0) -> "gr::analog::agc_cc::sptr":
    r"""agc_cc_make(float rate=1e-4, float reference=1.0, float gain=1.0) -> agc_cc_sptr"""
    return _analog_swig.agc_cc_make(rate, reference, gain)

class agc_ff(object):
    r"""Proxy of C++ gr::analog::agc_ff class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(rate: "float"=1e-4, reference: "float"=1.0, gain: "float"=1.0) -> "gr::analog::agc_ff::sptr":
        r"""make(float rate=1e-4, float reference=1.0, float gain=1.0) -> agc_ff_sptr"""
        return _analog_swig.agc_ff_make(rate, reference, gain)

    def rate(self) -> "float":
        r"""rate(agc_ff self) -> float"""
        return _analog_swig.agc_ff_rate(self)

    def reference(self) -> "float":
        r"""reference(agc_ff self) -> float"""
        return _analog_swig.agc_ff_reference(self)

    def gain(self) -> "float":
        r"""gain(agc_ff self) -> float"""
        return _analog_swig.agc_ff_gain(self)

    def max_gain(self) -> "float":
        r"""max_gain(agc_ff self) -> float"""
        return _analog_swig.agc_ff_max_gain(self)

    def set_rate(self, rate: "float") -> "void":
        r"""set_rate(agc_ff self, float rate)"""
        return _analog_swig.agc_ff_set_rate(self, rate)

    def set_reference(self, reference: "float") -> "void":
        r"""set_reference(agc_ff self, float reference)"""
        return _analog_swig.agc_ff_set_reference(self, reference)

    def set_gain(self, gain: "float") -> "void":
        r"""set_gain(agc_ff self, float gain)"""
        return _analog_swig.agc_ff_set_gain(self, gain)

    def set_max_gain(self, max_gain: "float") -> "void":
        r"""set_max_gain(agc_ff self, float max_gain)"""
        return _analog_swig.agc_ff_set_max_gain(self, max_gain)
    __swig_destroy__ = _analog_swig.delete_agc_ff

# Register agc_ff in _analog_swig:
_analog_swig.agc_ff_swigregister(agc_ff)

def agc_ff_make(rate: "float"=1e-4, reference: "float"=1.0, gain: "float"=1.0) -> "gr::analog::agc_ff::sptr":
    r"""agc_ff_make(float rate=1e-4, float reference=1.0, float gain=1.0) -> agc_ff_sptr"""
    return _analog_swig.agc_ff_make(rate, reference, gain)

class agc2_cc(object):
    r"""Proxy of C++ gr::analog::agc2_cc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(attack_rate: "float"=1e-1, decay_rate: "float"=1e-2, reference: "float"=1.0, gain: "float"=1.0) -> "gr::analog::agc2_cc::sptr":
        r"""make(float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0, float gain=1.0) -> agc2_cc_sptr"""
        return _analog_swig.agc2_cc_make(attack_rate, decay_rate, reference, gain)

    def attack_rate(self) -> "float":
        r"""attack_rate(agc2_cc self) -> float"""
        return _analog_swig.agc2_cc_attack_rate(self)

    def decay_rate(self) -> "float":
        r"""decay_rate(agc2_cc self) -> float"""
        return _analog_swig.agc2_cc_decay_rate(self)

    def reference(self) -> "float":
        r"""reference(agc2_cc self) -> float"""
        return _analog_swig.agc2_cc_reference(self)

    def gain(self) -> "float":
        r"""gain(agc2_cc self) -> float"""
        return _analog_swig.agc2_cc_gain(self)

    def max_gain(self) -> "float":
        r"""max_gain(agc2_cc self) -> float"""
        return _analog_swig.agc2_cc_max_gain(self)

    def set_attack_rate(self, rate: "float") -> "void":
        r"""set_attack_rate(agc2_cc self, float rate)"""
        return _analog_swig.agc2_cc_set_attack_rate(self, rate)

    def set_decay_rate(self, rate: "float") -> "void":
        r"""set_decay_rate(agc2_cc self, float rate)"""
        return _analog_swig.agc2_cc_set_decay_rate(self, rate)

    def set_reference(self, reference: "float") -> "void":
        r"""set_reference(agc2_cc self, float reference)"""
        return _analog_swig.agc2_cc_set_reference(self, reference)

    def set_gain(self, gain: "float") -> "void":
        r"""set_gain(agc2_cc self, float gain)"""
        return _analog_swig.agc2_cc_set_gain(self, gain)

    def set_max_gain(self, max_gain: "float") -> "void":
        r"""set_max_gain(agc2_cc self, float max_gain)"""
        return _analog_swig.agc2_cc_set_max_gain(self, max_gain)
    __swig_destroy__ = _analog_swig.delete_agc2_cc

# Register agc2_cc in _analog_swig:
_analog_swig.agc2_cc_swigregister(agc2_cc)

def agc2_cc_make(attack_rate: "float"=1e-1, decay_rate: "float"=1e-2, reference: "float"=1.0, gain: "float"=1.0) -> "gr::analog::agc2_cc::sptr":
    r"""agc2_cc_make(float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0, float gain=1.0) -> agc2_cc_sptr"""
    return _analog_swig.agc2_cc_make(attack_rate, decay_rate, reference, gain)

class agc2_ff(object):
    r"""Proxy of C++ gr::analog::agc2_ff class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(attack_rate: "float"=1e-1, decay_rate: "float"=1e-2, reference: "float"=1.0, gain: "float"=1.0) -> "gr::analog::agc2_ff::sptr":
        r"""make(float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0, float gain=1.0) -> agc2_ff_sptr"""
        return _analog_swig.agc2_ff_make(attack_rate, decay_rate, reference, gain)

    def attack_rate(self) -> "float":
        r"""attack_rate(agc2_ff self) -> float"""
        return _analog_swig.agc2_ff_attack_rate(self)

    def decay_rate(self) -> "float":
        r"""decay_rate(agc2_ff self) -> float"""
        return _analog_swig.agc2_ff_decay_rate(self)

    def reference(self) -> "float":
        r"""reference(agc2_ff self) -> float"""
        return _analog_swig.agc2_ff_reference(self)

    def gain(self) -> "float":
        r"""gain(agc2_ff self) -> float"""
        return _analog_swig.agc2_ff_gain(self)

    def max_gain(self) -> "float":
        r"""max_gain(agc2_ff self) -> float"""
        return _analog_swig.agc2_ff_max_gain(self)

    def set_attack_rate(self, rate: "float") -> "void":
        r"""set_attack_rate(agc2_ff self, float rate)"""
        return _analog_swig.agc2_ff_set_attack_rate(self, rate)

    def set_decay_rate(self, rate: "float") -> "void":
        r"""set_decay_rate(agc2_ff self, float rate)"""
        return _analog_swig.agc2_ff_set_decay_rate(self, rate)

    def set_reference(self, reference: "float") -> "void":
        r"""set_reference(agc2_ff self, float reference)"""
        return _analog_swig.agc2_ff_set_reference(self, reference)

    def set_gain(self, gain: "float") -> "void":
        r"""set_gain(agc2_ff self, float gain)"""
        return _analog_swig.agc2_ff_set_gain(self, gain)

    def set_max_gain(self, max_gain: "float") -> "void":
        r"""set_max_gain(agc2_ff self, float max_gain)"""
        return _analog_swig.agc2_ff_set_max_gain(self, max_gain)
    __swig_destroy__ = _analog_swig.delete_agc2_ff

# Register agc2_ff in _analog_swig:
_analog_swig.agc2_ff_swigregister(agc2_ff)

def agc2_ff_make(attack_rate: "float"=1e-1, decay_rate: "float"=1e-2, reference: "float"=1.0, gain: "float"=1.0) -> "gr::analog::agc2_ff::sptr":
    r"""agc2_ff_make(float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0, float gain=1.0) -> agc2_ff_sptr"""
    return _analog_swig.agc2_ff_make(attack_rate, decay_rate, reference, gain)

class agc3_cc(object):
    r"""Proxy of C++ gr::analog::agc3_cc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(attack_rate: "float"=1e-1, decay_rate: "float"=1e-2, reference: "float"=1.0, gain: "float"=1.0, iir_update_decim: "int"=1) -> "gr::analog::agc3_cc::sptr":
        r"""make(float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0, float gain=1.0, int iir_update_decim=1) -> agc3_cc_sptr"""
        return _analog_swig.agc3_cc_make(attack_rate, decay_rate, reference, gain, iir_update_decim)

    def attack_rate(self) -> "float":
        r"""attack_rate(agc3_cc self) -> float"""
        return _analog_swig.agc3_cc_attack_rate(self)

    def decay_rate(self) -> "float":
        r"""decay_rate(agc3_cc self) -> float"""
        return _analog_swig.agc3_cc_decay_rate(self)

    def reference(self) -> "float":
        r"""reference(agc3_cc self) -> float"""
        return _analog_swig.agc3_cc_reference(self)

    def gain(self) -> "float":
        r"""gain(agc3_cc self) -> float"""
        return _analog_swig.agc3_cc_gain(self)

    def max_gain(self) -> "float":
        r"""max_gain(agc3_cc self) -> float"""
        return _analog_swig.agc3_cc_max_gain(self)

    def set_attack_rate(self, rate: "float") -> "void":
        r"""set_attack_rate(agc3_cc self, float rate)"""
        return _analog_swig.agc3_cc_set_attack_rate(self, rate)

    def set_decay_rate(self, rate: "float") -> "void":
        r"""set_decay_rate(agc3_cc self, float rate)"""
        return _analog_swig.agc3_cc_set_decay_rate(self, rate)

    def set_reference(self, reference: "float") -> "void":
        r"""set_reference(agc3_cc self, float reference)"""
        return _analog_swig.agc3_cc_set_reference(self, reference)

    def set_gain(self, gain: "float") -> "void":
        r"""set_gain(agc3_cc self, float gain)"""
        return _analog_swig.agc3_cc_set_gain(self, gain)

    def set_max_gain(self, max_gain: "float") -> "void":
        r"""set_max_gain(agc3_cc self, float max_gain)"""
        return _analog_swig.agc3_cc_set_max_gain(self, max_gain)
    __swig_destroy__ = _analog_swig.delete_agc3_cc

# Register agc3_cc in _analog_swig:
_analog_swig.agc3_cc_swigregister(agc3_cc)

def agc3_cc_make(attack_rate: "float"=1e-1, decay_rate: "float"=1e-2, reference: "float"=1.0, gain: "float"=1.0, iir_update_decim: "int"=1) -> "gr::analog::agc3_cc::sptr":
    r"""agc3_cc_make(float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0, float gain=1.0, int iir_update_decim=1) -> agc3_cc_sptr"""
    return _analog_swig.agc3_cc_make(attack_rate, decay_rate, reference, gain, iir_update_decim)

class cpfsk_bc(object):
    r"""Proxy of C++ gr::analog::cpfsk_bc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(k: "float", ampl: "float", samples_per_sym: "int") -> "gr::analog::cpfsk_bc::sptr":
        r"""make(float k, float ampl, int samples_per_sym) -> cpfsk_bc_sptr"""
        return _analog_swig.cpfsk_bc_make(k, ampl, samples_per_sym)

    def set_amplitude(self, amplitude: "float") -> "void":
        r"""set_amplitude(cpfsk_bc self, float amplitude)"""
        return _analog_swig.cpfsk_bc_set_amplitude(self, amplitude)

    def amplitude(self) -> "float":
        r"""amplitude(cpfsk_bc self) -> float"""
        return _analog_swig.cpfsk_bc_amplitude(self)

    def freq(self) -> "float":
        r"""freq(cpfsk_bc self) -> float"""
        return _analog_swig.cpfsk_bc_freq(self)

    def phase(self) -> "float":
        r"""phase(cpfsk_bc self) -> float"""
        return _analog_swig.cpfsk_bc_phase(self)
    __swig_destroy__ = _analog_swig.delete_cpfsk_bc

# Register cpfsk_bc in _analog_swig:
_analog_swig.cpfsk_bc_swigregister(cpfsk_bc)

def cpfsk_bc_make(k: "float", ampl: "float", samples_per_sym: "int") -> "gr::analog::cpfsk_bc::sptr":
    r"""cpfsk_bc_make(float k, float ampl, int samples_per_sym) -> cpfsk_bc_sptr"""
    return _analog_swig.cpfsk_bc_make(k, ampl, samples_per_sym)

class ctcss_squelch_ff(object):
    r"""Proxy of C++ gr::analog::ctcss_squelch_ff class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(rate: "int", freq: "float", level: "float", len: "int", ramp: "int", gate: "bool") -> "gr::analog::ctcss_squelch_ff::sptr":
        r"""make(int rate, float freq, float level, int len, int ramp, bool gate) -> ctcss_squelch_ff_sptr"""
        return _analog_swig.ctcss_squelch_ff_make(rate, freq, level, len, ramp, gate)

    def squelch_range(self) -> "std::vector< float,std::allocator< float > >":
        r"""squelch_range(ctcss_squelch_ff self) -> pmt_vector_float"""
        return _analog_swig.ctcss_squelch_ff_squelch_range(self)

    def level(self) -> "float":
        r"""level(ctcss_squelch_ff self) -> float"""
        return _analog_swig.ctcss_squelch_ff_level(self)

    def set_level(self, level: "float") -> "void":
        r"""set_level(ctcss_squelch_ff self, float level)"""
        return _analog_swig.ctcss_squelch_ff_set_level(self, level)

    def len(self) -> "int":
        r"""len(ctcss_squelch_ff self) -> int"""
        return _analog_swig.ctcss_squelch_ff_len(self)

    def frequency(self) -> "float":
        r"""frequency(ctcss_squelch_ff self) -> float"""
        return _analog_swig.ctcss_squelch_ff_frequency(self)

    def set_frequency(self, frequency: "float") -> "void":
        r"""set_frequency(ctcss_squelch_ff self, float frequency)"""
        return _analog_swig.ctcss_squelch_ff_set_frequency(self, frequency)

    def ramp(self) -> "int":
        r"""ramp(ctcss_squelch_ff self) -> int"""
        return _analog_swig.ctcss_squelch_ff_ramp(self)

    def set_ramp(self, ramp: "int") -> "void":
        r"""set_ramp(ctcss_squelch_ff self, int ramp)"""
        return _analog_swig.ctcss_squelch_ff_set_ramp(self, ramp)

    def gate(self) -> "bool":
        r"""gate(ctcss_squelch_ff self) -> bool"""
        return _analog_swig.ctcss_squelch_ff_gate(self)

    def set_gate(self, gate: "bool") -> "void":
        r"""set_gate(ctcss_squelch_ff self, bool gate)"""
        return _analog_swig.ctcss_squelch_ff_set_gate(self, gate)

    def unmuted(self) -> "bool":
        r"""unmuted(ctcss_squelch_ff self) -> bool"""
        return _analog_swig.ctcss_squelch_ff_unmuted(self)
    __swig_destroy__ = _analog_swig.delete_ctcss_squelch_ff

# Register ctcss_squelch_ff in _analog_swig:
_analog_swig.ctcss_squelch_ff_swigregister(ctcss_squelch_ff)

def ctcss_squelch_ff_make(rate: "int", freq: "float", level: "float", len: "int", ramp: "int", gate: "bool") -> "gr::analog::ctcss_squelch_ff::sptr":
    r"""ctcss_squelch_ff_make(int rate, float freq, float level, int len, int ramp, bool gate) -> ctcss_squelch_ff_sptr"""
    return _analog_swig.ctcss_squelch_ff_make(rate, freq, level, len, ramp, gate)

class dpll_bb(object):
    r"""Proxy of C++ gr::analog::dpll_bb class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(period: "float", gain: "float") -> "gr::analog::dpll_bb::sptr":
        r"""make(float period, float gain) -> dpll_bb_sptr"""
        return _analog_swig.dpll_bb_make(period, gain)

    def set_gain(self, gain: "float") -> "void":
        r"""set_gain(dpll_bb self, float gain)"""
        return _analog_swig.dpll_bb_set_gain(self, gain)

    def set_decision_threshold(self, thresh: "float") -> "void":
        r"""set_decision_threshold(dpll_bb self, float thresh)"""
        return _analog_swig.dpll_bb_set_decision_threshold(self, thresh)

    def gain(self) -> "float":
        r"""gain(dpll_bb self) -> float"""
        return _analog_swig.dpll_bb_gain(self)

    def freq(self) -> "float":
        r"""freq(dpll_bb self) -> float"""
        return _analog_swig.dpll_bb_freq(self)

    def phase(self) -> "float":
        r"""phase(dpll_bb self) -> float"""
        return _analog_swig.dpll_bb_phase(self)

    def decision_threshold(self) -> "float":
        r"""decision_threshold(dpll_bb self) -> float"""
        return _analog_swig.dpll_bb_decision_threshold(self)
    __swig_destroy__ = _analog_swig.delete_dpll_bb

# Register dpll_bb in _analog_swig:
_analog_swig.dpll_bb_swigregister(dpll_bb)

def dpll_bb_make(period: "float", gain: "float") -> "gr::analog::dpll_bb::sptr":
    r"""dpll_bb_make(float period, float gain) -> dpll_bb_sptr"""
    return _analog_swig.dpll_bb_make(period, gain)

class feedforward_agc_cc(object):
    r"""Proxy of C++ gr::analog::feedforward_agc_cc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make(nsamples: "int", reference: "float") -> "gr::analog::feedforward_agc_cc::sptr":
        r"""make(int nsamples, float reference) -> feedforward_agc_cc_sptr"""
        return _analog_swig.feedforward_agc_cc_make(nsamples, reference)
    __swig_destroy__ = _analog_swig.delete_feedforward_agc_cc

# Register feedforward_agc_cc in _analog_swig:
_analog_swig.feedforward_agc_cc_swigregister(feedforward_agc_cc)

def feedforward_agc_cc_make(nsamples: "int", reference: "float") -> "gr::analog::feedforward_agc_cc::sptr":
    r"""feedforward_agc_cc_make(int nsamples, float reference) -> feedforward_agc_cc_sptr"""
    return _analog_swig.feedforward_agc_cc_make(nsamples, reference)

class fmdet_cf(object):
    r"""Proxy of C++ gr::analog::fmdet_cf class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(samplerate: "float", freq_low: "float", freq_high: "float", scl: "float") -> "gr::analog::fmdet_cf::sptr":
        r"""make(float samplerate, float freq_low, float freq_high, float scl) -> fmdet_cf_sptr"""
        return _analog_swig.fmdet_cf_make(samplerate, freq_low, freq_high, scl)

    def set_scale(self, scl: "float") -> "void":
        r"""set_scale(fmdet_cf self, float scl)"""
        return _analog_swig.fmdet_cf_set_scale(self, scl)

    def set_freq_range(self, freq_low: "float", freq_high: "float") -> "void":
        r"""set_freq_range(fmdet_cf self, float freq_low, float freq_high)"""
        return _analog_swig.fmdet_cf_set_freq_range(self, freq_low, freq_high)

    def freq(self) -> "float":
        r"""freq(fmdet_cf self) -> float"""
        return _analog_swig.fmdet_cf_freq(self)

    def freq_high(self) -> "float":
        r"""freq_high(fmdet_cf self) -> float"""
        return _analog_swig.fmdet_cf_freq_high(self)

    def freq_low(self) -> "float":
        r"""freq_low(fmdet_cf self) -> float"""
        return _analog_swig.fmdet_cf_freq_low(self)

    def scale(self) -> "float":
        r"""scale(fmdet_cf self) -> float"""
        return _analog_swig.fmdet_cf_scale(self)

    def bias(self) -> "float":
        r"""bias(fmdet_cf self) -> float"""
        return _analog_swig.fmdet_cf_bias(self)
    __swig_destroy__ = _analog_swig.delete_fmdet_cf

# Register fmdet_cf in _analog_swig:
_analog_swig.fmdet_cf_swigregister(fmdet_cf)

def fmdet_cf_make(samplerate: "float", freq_low: "float", freq_high: "float", scl: "float") -> "gr::analog::fmdet_cf::sptr":
    r"""fmdet_cf_make(float samplerate, float freq_low, float freq_high, float scl) -> fmdet_cf_sptr"""
    return _analog_swig.fmdet_cf_make(samplerate, freq_low, freq_high, scl)

class frequency_modulator_fc(object):
    r"""Proxy of C++ gr::analog::frequency_modulator_fc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(sensitivity: "float") -> "gr::analog::frequency_modulator_fc::sptr":
        r"""make(float sensitivity) -> frequency_modulator_fc_sptr"""
        return _analog_swig.frequency_modulator_fc_make(sensitivity)

    def set_sensitivity(self, sens: "float") -> "void":
        r"""set_sensitivity(frequency_modulator_fc self, float sens)"""
        return _analog_swig.frequency_modulator_fc_set_sensitivity(self, sens)

    def sensitivity(self) -> "float":
        r"""sensitivity(frequency_modulator_fc self) -> float"""
        return _analog_swig.frequency_modulator_fc_sensitivity(self)
    __swig_destroy__ = _analog_swig.delete_frequency_modulator_fc

# Register frequency_modulator_fc in _analog_swig:
_analog_swig.frequency_modulator_fc_swigregister(frequency_modulator_fc)

def frequency_modulator_fc_make(sensitivity: "float") -> "gr::analog::frequency_modulator_fc::sptr":
    r"""frequency_modulator_fc_make(float sensitivity) -> frequency_modulator_fc_sptr"""
    return _analog_swig.frequency_modulator_fc_make(sensitivity)

class phase_modulator_fc(object):
    r"""Proxy of C++ gr::analog::phase_modulator_fc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(sensitivity: "double") -> "gr::analog::phase_modulator_fc::sptr":
        r"""make(double sensitivity) -> phase_modulator_fc_sptr"""
        return _analog_swig.phase_modulator_fc_make(sensitivity)

    def sensitivity(self) -> "double":
        r"""sensitivity(phase_modulator_fc self) -> double"""
        return _analog_swig.phase_modulator_fc_sensitivity(self)

    def phase(self) -> "double":
        r"""phase(phase_modulator_fc self) -> double"""
        return _analog_swig.phase_modulator_fc_phase(self)

    def set_sensitivity(self, s: "double") -> "void":
        r"""set_sensitivity(phase_modulator_fc self, double s)"""
        return _analog_swig.phase_modulator_fc_set_sensitivity(self, s)

    def set_phase(self, p: "double") -> "void":
        r"""set_phase(phase_modulator_fc self, double p)"""
        return _analog_swig.phase_modulator_fc_set_phase(self, p)
    __swig_destroy__ = _analog_swig.delete_phase_modulator_fc

# Register phase_modulator_fc in _analog_swig:
_analog_swig.phase_modulator_fc_swigregister(phase_modulator_fc)

def phase_modulator_fc_make(sensitivity: "double") -> "gr::analog::phase_modulator_fc::sptr":
    r"""phase_modulator_fc_make(double sensitivity) -> phase_modulator_fc_sptr"""
    return _analog_swig.phase_modulator_fc_make(sensitivity)

class pll_carriertracking_cc(control_loop):
    r"""Proxy of C++ gr::analog::pll_carriertracking_cc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(loop_bw: "float", max_freq: "float", min_freq: "float") -> "gr::analog::pll_carriertracking_cc::sptr":
        r"""make(float loop_bw, float max_freq, float min_freq) -> pll_carriertracking_cc_sptr"""
        return _analog_swig.pll_carriertracking_cc_make(loop_bw, max_freq, min_freq)

    def lock_detector(self) -> "bool":
        r"""lock_detector(pll_carriertracking_cc self) -> bool"""
        return _analog_swig.pll_carriertracking_cc_lock_detector(self)

    def squelch_enable(self, arg2: "bool") -> "bool":
        r"""squelch_enable(pll_carriertracking_cc self, bool arg2) -> bool"""
        return _analog_swig.pll_carriertracking_cc_squelch_enable(self, arg2)

    def set_lock_threshold(self, arg2: "float") -> "float":
        r"""set_lock_threshold(pll_carriertracking_cc self, float arg2) -> float"""
        return _analog_swig.pll_carriertracking_cc_set_lock_threshold(self, arg2)

    def set_damping_factor(self, df: "float") -> "void":
        r"""set_damping_factor(pll_carriertracking_cc self, float df)"""
        return _analog_swig.pll_carriertracking_cc_set_damping_factor(self, df)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(pll_carriertracking_cc self, float alpha)"""
        return _analog_swig.pll_carriertracking_cc_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(pll_carriertracking_cc self, float beta)"""
        return _analog_swig.pll_carriertracking_cc_set_beta(self, beta)

    def set_frequency(self, freq: "float") -> "void":
        r"""set_frequency(pll_carriertracking_cc self, float freq)"""
        return _analog_swig.pll_carriertracking_cc_set_frequency(self, freq)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(pll_carriertracking_cc self, float phase)"""
        return _analog_swig.pll_carriertracking_cc_set_phase(self, phase)

    def set_min_freq(self, freq: "float") -> "void":
        r"""set_min_freq(pll_carriertracking_cc self, float freq)"""
        return _analog_swig.pll_carriertracking_cc_set_min_freq(self, freq)

    def set_max_freq(self, freq: "float") -> "void":
        r"""set_max_freq(pll_carriertracking_cc self, float freq)"""
        return _analog_swig.pll_carriertracking_cc_set_max_freq(self, freq)

    def get_loop_bandwidth(self) -> "float":
        r"""get_loop_bandwidth(pll_carriertracking_cc self) -> float"""
        return _analog_swig.pll_carriertracking_cc_get_loop_bandwidth(self)

    def get_damping_factor(self) -> "float":
        r"""get_damping_factor(pll_carriertracking_cc self) -> float"""
        return _analog_swig.pll_carriertracking_cc_get_damping_factor(self)

    def get_alpha(self) -> "float":
        r"""get_alpha(pll_carriertracking_cc self) -> float"""
        return _analog_swig.pll_carriertracking_cc_get_alpha(self)

    def get_beta(self) -> "float":
        r"""get_beta(pll_carriertracking_cc self) -> float"""
        return _analog_swig.pll_carriertracking_cc_get_beta(self)

    def get_frequency(self) -> "float":
        r"""get_frequency(pll_carriertracking_cc self) -> float"""
        return _analog_swig.pll_carriertracking_cc_get_frequency(self)

    def get_phase(self) -> "float":
        r"""get_phase(pll_carriertracking_cc self) -> float"""
        return _analog_swig.pll_carriertracking_cc_get_phase(self)

    def get_min_freq(self) -> "float":
        r"""get_min_freq(pll_carriertracking_cc self) -> float"""
        return _analog_swig.pll_carriertracking_cc_get_min_freq(self)

    def get_max_freq(self) -> "float":
        r"""get_max_freq(pll_carriertracking_cc self) -> float"""
        return _analog_swig.pll_carriertracking_cc_get_max_freq(self)
    __swig_destroy__ = _analog_swig.delete_pll_carriertracking_cc

# Register pll_carriertracking_cc in _analog_swig:
_analog_swig.pll_carriertracking_cc_swigregister(pll_carriertracking_cc)

def pll_carriertracking_cc_make(loop_bw: "float", max_freq: "float", min_freq: "float") -> "gr::analog::pll_carriertracking_cc::sptr":
    r"""pll_carriertracking_cc_make(float loop_bw, float max_freq, float min_freq) -> pll_carriertracking_cc_sptr"""
    return _analog_swig.pll_carriertracking_cc_make(loop_bw, max_freq, min_freq)

class pll_freqdet_cf(control_loop):
    r"""Proxy of C++ gr::analog::pll_freqdet_cf class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(loop_bw: "float", max_freq: "float", min_freq: "float") -> "gr::analog::pll_freqdet_cf::sptr":
        r"""make(float loop_bw, float max_freq, float min_freq) -> pll_freqdet_cf_sptr"""
        return _analog_swig.pll_freqdet_cf_make(loop_bw, max_freq, min_freq)

    def set_damping_factor(self, df: "float") -> "void":
        r"""set_damping_factor(pll_freqdet_cf self, float df)"""
        return _analog_swig.pll_freqdet_cf_set_damping_factor(self, df)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(pll_freqdet_cf self, float alpha)"""
        return _analog_swig.pll_freqdet_cf_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(pll_freqdet_cf self, float beta)"""
        return _analog_swig.pll_freqdet_cf_set_beta(self, beta)

    def set_frequency(self, freq: "float") -> "void":
        r"""set_frequency(pll_freqdet_cf self, float freq)"""
        return _analog_swig.pll_freqdet_cf_set_frequency(self, freq)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(pll_freqdet_cf self, float phase)"""
        return _analog_swig.pll_freqdet_cf_set_phase(self, phase)

    def set_min_freq(self, freq: "float") -> "void":
        r"""set_min_freq(pll_freqdet_cf self, float freq)"""
        return _analog_swig.pll_freqdet_cf_set_min_freq(self, freq)

    def set_max_freq(self, freq: "float") -> "void":
        r"""set_max_freq(pll_freqdet_cf self, float freq)"""
        return _analog_swig.pll_freqdet_cf_set_max_freq(self, freq)

    def get_loop_bandwidth(self) -> "float":
        r"""get_loop_bandwidth(pll_freqdet_cf self) -> float"""
        return _analog_swig.pll_freqdet_cf_get_loop_bandwidth(self)

    def get_damping_factor(self) -> "float":
        r"""get_damping_factor(pll_freqdet_cf self) -> float"""
        return _analog_swig.pll_freqdet_cf_get_damping_factor(self)

    def get_alpha(self) -> "float":
        r"""get_alpha(pll_freqdet_cf self) -> float"""
        return _analog_swig.pll_freqdet_cf_get_alpha(self)

    def get_beta(self) -> "float":
        r"""get_beta(pll_freqdet_cf self) -> float"""
        return _analog_swig.pll_freqdet_cf_get_beta(self)

    def get_frequency(self) -> "float":
        r"""get_frequency(pll_freqdet_cf self) -> float"""
        return _analog_swig.pll_freqdet_cf_get_frequency(self)

    def get_phase(self) -> "float":
        r"""get_phase(pll_freqdet_cf self) -> float"""
        return _analog_swig.pll_freqdet_cf_get_phase(self)

    def get_min_freq(self) -> "float":
        r"""get_min_freq(pll_freqdet_cf self) -> float"""
        return _analog_swig.pll_freqdet_cf_get_min_freq(self)

    def get_max_freq(self) -> "float":
        r"""get_max_freq(pll_freqdet_cf self) -> float"""
        return _analog_swig.pll_freqdet_cf_get_max_freq(self)
    __swig_destroy__ = _analog_swig.delete_pll_freqdet_cf

# Register pll_freqdet_cf in _analog_swig:
_analog_swig.pll_freqdet_cf_swigregister(pll_freqdet_cf)

def pll_freqdet_cf_make(loop_bw: "float", max_freq: "float", min_freq: "float") -> "gr::analog::pll_freqdet_cf::sptr":
    r"""pll_freqdet_cf_make(float loop_bw, float max_freq, float min_freq) -> pll_freqdet_cf_sptr"""
    return _analog_swig.pll_freqdet_cf_make(loop_bw, max_freq, min_freq)

class pll_refout_cc(control_loop):
    r"""Proxy of C++ gr::analog::pll_refout_cc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make(loop_bw: "float", max_freq: "float", min_freq: "float") -> "gr::analog::pll_refout_cc::sptr":
        r"""make(float loop_bw, float max_freq, float min_freq) -> pll_refout_cc_sptr"""
        return _analog_swig.pll_refout_cc_make(loop_bw, max_freq, min_freq)
    __swig_destroy__ = _analog_swig.delete_pll_refout_cc

# Register pll_refout_cc in _analog_swig:
_analog_swig.pll_refout_cc_swigregister(pll_refout_cc)

def pll_refout_cc_make(loop_bw: "float", max_freq: "float", min_freq: "float") -> "gr::analog::pll_refout_cc::sptr":
    r"""pll_refout_cc_make(float loop_bw, float max_freq, float min_freq) -> pll_refout_cc_sptr"""
    return _analog_swig.pll_refout_cc_make(loop_bw, max_freq, min_freq)

class probe_avg_mag_sqrd_c(object):
    r"""Proxy of C++ gr::analog::probe_avg_mag_sqrd_c class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(threshold_db: "double", alpha: "double"=0.0001) -> "gr::analog::probe_avg_mag_sqrd_c::sptr":
        r"""make(double threshold_db, double alpha=0.0001) -> probe_avg_mag_sqrd_c_sptr"""
        return _analog_swig.probe_avg_mag_sqrd_c_make(threshold_db, alpha)

    def unmuted(self) -> "bool":
        r"""unmuted(probe_avg_mag_sqrd_c self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_c_unmuted(self)

    def level(self) -> "double":
        r"""level(probe_avg_mag_sqrd_c self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_c_level(self)

    def threshold(self) -> "double":
        r"""threshold(probe_avg_mag_sqrd_c self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_c_threshold(self)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(probe_avg_mag_sqrd_c self, double alpha)"""
        return _analog_swig.probe_avg_mag_sqrd_c_set_alpha(self, alpha)

    def set_threshold(self, decibels: "double") -> "void":
        r"""set_threshold(probe_avg_mag_sqrd_c self, double decibels)"""
        return _analog_swig.probe_avg_mag_sqrd_c_set_threshold(self, decibels)

    def reset(self) -> "void":
        r"""reset(probe_avg_mag_sqrd_c self)"""
        return _analog_swig.probe_avg_mag_sqrd_c_reset(self)
    __swig_destroy__ = _analog_swig.delete_probe_avg_mag_sqrd_c

# Register probe_avg_mag_sqrd_c in _analog_swig:
_analog_swig.probe_avg_mag_sqrd_c_swigregister(probe_avg_mag_sqrd_c)

def probe_avg_mag_sqrd_c_make(threshold_db: "double", alpha: "double"=0.0001) -> "gr::analog::probe_avg_mag_sqrd_c::sptr":
    r"""probe_avg_mag_sqrd_c_make(double threshold_db, double alpha=0.0001) -> probe_avg_mag_sqrd_c_sptr"""
    return _analog_swig.probe_avg_mag_sqrd_c_make(threshold_db, alpha)

class probe_avg_mag_sqrd_cf(object):
    r"""Proxy of C++ gr::analog::probe_avg_mag_sqrd_cf class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(threshold_db: "double", alpha: "double"=0.0001) -> "gr::analog::probe_avg_mag_sqrd_cf::sptr":
        r"""make(double threshold_db, double alpha=0.0001) -> probe_avg_mag_sqrd_cf_sptr"""
        return _analog_swig.probe_avg_mag_sqrd_cf_make(threshold_db, alpha)

    def unmuted(self) -> "bool":
        r"""unmuted(probe_avg_mag_sqrd_cf self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_cf_unmuted(self)

    def level(self) -> "double":
        r"""level(probe_avg_mag_sqrd_cf self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_cf_level(self)

    def threshold(self) -> "double":
        r"""threshold(probe_avg_mag_sqrd_cf self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_cf_threshold(self)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(probe_avg_mag_sqrd_cf self, double alpha)"""
        return _analog_swig.probe_avg_mag_sqrd_cf_set_alpha(self, alpha)

    def set_threshold(self, decibels: "double") -> "void":
        r"""set_threshold(probe_avg_mag_sqrd_cf self, double decibels)"""
        return _analog_swig.probe_avg_mag_sqrd_cf_set_threshold(self, decibels)

    def reset(self) -> "void":
        r"""reset(probe_avg_mag_sqrd_cf self)"""
        return _analog_swig.probe_avg_mag_sqrd_cf_reset(self)
    __swig_destroy__ = _analog_swig.delete_probe_avg_mag_sqrd_cf

# Register probe_avg_mag_sqrd_cf in _analog_swig:
_analog_swig.probe_avg_mag_sqrd_cf_swigregister(probe_avg_mag_sqrd_cf)

def probe_avg_mag_sqrd_cf_make(threshold_db: "double", alpha: "double"=0.0001) -> "gr::analog::probe_avg_mag_sqrd_cf::sptr":
    r"""probe_avg_mag_sqrd_cf_make(double threshold_db, double alpha=0.0001) -> probe_avg_mag_sqrd_cf_sptr"""
    return _analog_swig.probe_avg_mag_sqrd_cf_make(threshold_db, alpha)

class probe_avg_mag_sqrd_f(object):
    r"""Proxy of C++ gr::analog::probe_avg_mag_sqrd_f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(threshold_db: "double", alpha: "double"=0.0001) -> "gr::analog::probe_avg_mag_sqrd_f::sptr":
        r"""make(double threshold_db, double alpha=0.0001) -> probe_avg_mag_sqrd_f_sptr"""
        return _analog_swig.probe_avg_mag_sqrd_f_make(threshold_db, alpha)

    def unmuted(self) -> "bool":
        r"""unmuted(probe_avg_mag_sqrd_f self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_f_unmuted(self)

    def level(self) -> "double":
        r"""level(probe_avg_mag_sqrd_f self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_f_level(self)

    def threshold(self) -> "double":
        r"""threshold(probe_avg_mag_sqrd_f self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_f_threshold(self)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(probe_avg_mag_sqrd_f self, double alpha)"""
        return _analog_swig.probe_avg_mag_sqrd_f_set_alpha(self, alpha)

    def set_threshold(self, decibels: "double") -> "void":
        r"""set_threshold(probe_avg_mag_sqrd_f self, double decibels)"""
        return _analog_swig.probe_avg_mag_sqrd_f_set_threshold(self, decibels)

    def reset(self) -> "void":
        r"""reset(probe_avg_mag_sqrd_f self)"""
        return _analog_swig.probe_avg_mag_sqrd_f_reset(self)
    __swig_destroy__ = _analog_swig.delete_probe_avg_mag_sqrd_f

# Register probe_avg_mag_sqrd_f in _analog_swig:
_analog_swig.probe_avg_mag_sqrd_f_swigregister(probe_avg_mag_sqrd_f)

def probe_avg_mag_sqrd_f_make(threshold_db: "double", alpha: "double"=0.0001) -> "gr::analog::probe_avg_mag_sqrd_f::sptr":
    r"""probe_avg_mag_sqrd_f_make(double threshold_db, double alpha=0.0001) -> probe_avg_mag_sqrd_f_sptr"""
    return _analog_swig.probe_avg_mag_sqrd_f_make(threshold_db, alpha)

class pwr_squelch_cc(object):
    r"""Proxy of C++ gr::analog::pwr_squelch_cc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(db: "double", alpha: "double"=0.0001, ramp: "int"=0, gate: "bool"=False) -> "gr::analog::pwr_squelch_cc::sptr":
        r"""make(double db, double alpha=0.0001, int ramp=0, bool gate=False) -> pwr_squelch_cc_sptr"""
        return _analog_swig.pwr_squelch_cc_make(db, alpha, ramp, gate)

    def squelch_range(self) -> "std::vector< float,std::allocator< float > >":
        r"""squelch_range(pwr_squelch_cc self) -> pmt_vector_float"""
        return _analog_swig.pwr_squelch_cc_squelch_range(self)

    def threshold(self) -> "double":
        r"""threshold(pwr_squelch_cc self) -> double"""
        return _analog_swig.pwr_squelch_cc_threshold(self)

    def set_threshold(self, db: "double") -> "void":
        r"""set_threshold(pwr_squelch_cc self, double db)"""
        return _analog_swig.pwr_squelch_cc_set_threshold(self, db)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(pwr_squelch_cc self, double alpha)"""
        return _analog_swig.pwr_squelch_cc_set_alpha(self, alpha)

    def ramp(self) -> "int":
        r"""ramp(pwr_squelch_cc self) -> int"""
        return _analog_swig.pwr_squelch_cc_ramp(self)

    def set_ramp(self, ramp: "int") -> "void":
        r"""set_ramp(pwr_squelch_cc self, int ramp)"""
        return _analog_swig.pwr_squelch_cc_set_ramp(self, ramp)

    def gate(self) -> "bool":
        r"""gate(pwr_squelch_cc self) -> bool"""
        return _analog_swig.pwr_squelch_cc_gate(self)

    def set_gate(self, gate: "bool") -> "void":
        r"""set_gate(pwr_squelch_cc self, bool gate)"""
        return _analog_swig.pwr_squelch_cc_set_gate(self, gate)

    def unmuted(self) -> "bool":
        r"""unmuted(pwr_squelch_cc self) -> bool"""
        return _analog_swig.pwr_squelch_cc_unmuted(self)
    __swig_destroy__ = _analog_swig.delete_pwr_squelch_cc

# Register pwr_squelch_cc in _analog_swig:
_analog_swig.pwr_squelch_cc_swigregister(pwr_squelch_cc)

def pwr_squelch_cc_make(db: "double", alpha: "double"=0.0001, ramp: "int"=0, gate: "bool"=False) -> "gr::analog::pwr_squelch_cc::sptr":
    r"""pwr_squelch_cc_make(double db, double alpha=0.0001, int ramp=0, bool gate=False) -> pwr_squelch_cc_sptr"""
    return _analog_swig.pwr_squelch_cc_make(db, alpha, ramp, gate)

class pwr_squelch_ff(object):
    r"""Proxy of C++ gr::analog::pwr_squelch_ff class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(db: "double", alpha: "double"=0.0001, ramp: "int"=0, gate: "bool"=False) -> "gr::analog::pwr_squelch_ff::sptr":
        r"""make(double db, double alpha=0.0001, int ramp=0, bool gate=False) -> pwr_squelch_ff_sptr"""
        return _analog_swig.pwr_squelch_ff_make(db, alpha, ramp, gate)

    def squelch_range(self) -> "std::vector< float,std::allocator< float > >":
        r"""squelch_range(pwr_squelch_ff self) -> pmt_vector_float"""
        return _analog_swig.pwr_squelch_ff_squelch_range(self)

    def threshold(self) -> "double":
        r"""threshold(pwr_squelch_ff self) -> double"""
        return _analog_swig.pwr_squelch_ff_threshold(self)

    def set_threshold(self, db: "double") -> "void":
        r"""set_threshold(pwr_squelch_ff self, double db)"""
        return _analog_swig.pwr_squelch_ff_set_threshold(self, db)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(pwr_squelch_ff self, double alpha)"""
        return _analog_swig.pwr_squelch_ff_set_alpha(self, alpha)

    def ramp(self) -> "int":
        r"""ramp(pwr_squelch_ff self) -> int"""
        return _analog_swig.pwr_squelch_ff_ramp(self)

    def set_ramp(self, ramp: "int") -> "void":
        r"""set_ramp(pwr_squelch_ff self, int ramp)"""
        return _analog_swig.pwr_squelch_ff_set_ramp(self, ramp)

    def gate(self) -> "bool":
        r"""gate(pwr_squelch_ff self) -> bool"""
        return _analog_swig.pwr_squelch_ff_gate(self)

    def set_gate(self, gate: "bool") -> "void":
        r"""set_gate(pwr_squelch_ff self, bool gate)"""
        return _analog_swig.pwr_squelch_ff_set_gate(self, gate)

    def unmuted(self) -> "bool":
        r"""unmuted(pwr_squelch_ff self) -> bool"""
        return _analog_swig.pwr_squelch_ff_unmuted(self)
    __swig_destroy__ = _analog_swig.delete_pwr_squelch_ff

# Register pwr_squelch_ff in _analog_swig:
_analog_swig.pwr_squelch_ff_swigregister(pwr_squelch_ff)

def pwr_squelch_ff_make(db: "double", alpha: "double"=0.0001, ramp: "int"=0, gate: "bool"=False) -> "gr::analog::pwr_squelch_ff::sptr":
    r"""pwr_squelch_ff_make(double db, double alpha=0.0001, int ramp=0, bool gate=False) -> pwr_squelch_ff_sptr"""
    return _analog_swig.pwr_squelch_ff_make(db, alpha, ramp, gate)

class quadrature_demod_cf(object):
    r"""Proxy of C++ gr::analog::quadrature_demod_cf class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(gain: "float") -> "gr::analog::quadrature_demod_cf::sptr":
        r"""make(float gain) -> quadrature_demod_cf_sptr"""
        return _analog_swig.quadrature_demod_cf_make(gain)

    def set_gain(self, gain: "float") -> "void":
        r"""set_gain(quadrature_demod_cf self, float gain)"""
        return _analog_swig.quadrature_demod_cf_set_gain(self, gain)

    def gain(self) -> "float":
        r"""gain(quadrature_demod_cf self) -> float"""
        return _analog_swig.quadrature_demod_cf_gain(self)
    __swig_destroy__ = _analog_swig.delete_quadrature_demod_cf

# Register quadrature_demod_cf in _analog_swig:
_analog_swig.quadrature_demod_cf_swigregister(quadrature_demod_cf)

def quadrature_demod_cf_make(gain: "float") -> "gr::analog::quadrature_demod_cf::sptr":
    r"""quadrature_demod_cf_make(float gain) -> quadrature_demod_cf_sptr"""
    return _analog_swig.quadrature_demod_cf_make(gain)

class rail_ff(object):
    r"""Proxy of C++ gr::analog::rail_ff class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(lo: "float", hi: "float") -> "gr::analog::rail_ff::sptr":
        r"""make(float lo, float hi) -> rail_ff_sptr"""
        return _analog_swig.rail_ff_make(lo, hi)

    def lo(self) -> "float":
        r"""lo(rail_ff self) -> float"""
        return _analog_swig.rail_ff_lo(self)

    def hi(self) -> "float":
        r"""hi(rail_ff self) -> float"""
        return _analog_swig.rail_ff_hi(self)

    def set_lo(self, lo: "float") -> "void":
        r"""set_lo(rail_ff self, float lo)"""
        return _analog_swig.rail_ff_set_lo(self, lo)

    def set_hi(self, hi: "float") -> "void":
        r"""set_hi(rail_ff self, float hi)"""
        return _analog_swig.rail_ff_set_hi(self, hi)
    __swig_destroy__ = _analog_swig.delete_rail_ff

# Register rail_ff in _analog_swig:
_analog_swig.rail_ff_swigregister(rail_ff)

def rail_ff_make(lo: "float", hi: "float") -> "gr::analog::rail_ff::sptr":
    r"""rail_ff_make(float lo, float hi) -> rail_ff_sptr"""
    return _analog_swig.rail_ff_make(lo, hi)

GR_CONST_WAVE = _analog_swig.GR_CONST_WAVE

GR_SIN_WAVE = _analog_swig.GR_SIN_WAVE

GR_COS_WAVE = _analog_swig.GR_COS_WAVE

GR_SQR_WAVE = _analog_swig.GR_SQR_WAVE

GR_TRI_WAVE = _analog_swig.GR_TRI_WAVE

GR_SAW_WAVE = _analog_swig.GR_SAW_WAVE

class simple_squelch_cc(object):
    r"""Proxy of C++ gr::analog::simple_squelch_cc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(threshold_db: "double", alpha: "double") -> "gr::analog::simple_squelch_cc::sptr":
        r"""make(double threshold_db, double alpha) -> simple_squelch_cc_sptr"""
        return _analog_swig.simple_squelch_cc_make(threshold_db, alpha)

    def unmuted(self) -> "bool":
        r"""unmuted(simple_squelch_cc self) -> bool"""
        return _analog_swig.simple_squelch_cc_unmuted(self)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(simple_squelch_cc self, double alpha)"""
        return _analog_swig.simple_squelch_cc_set_alpha(self, alpha)

    def set_threshold(self, decibels: "double") -> "void":
        r"""set_threshold(simple_squelch_cc self, double decibels)"""
        return _analog_swig.simple_squelch_cc_set_threshold(self, decibels)

    def threshold(self) -> "double":
        r"""threshold(simple_squelch_cc self) -> double"""
        return _analog_swig.simple_squelch_cc_threshold(self)

    def squelch_range(self) -> "std::vector< float,std::allocator< float > >":
        r"""squelch_range(simple_squelch_cc self) -> pmt_vector_float"""
        return _analog_swig.simple_squelch_cc_squelch_range(self)
    __swig_destroy__ = _analog_swig.delete_simple_squelch_cc

# Register simple_squelch_cc in _analog_swig:
_analog_swig.simple_squelch_cc_swigregister(simple_squelch_cc)

def simple_squelch_cc_make(threshold_db: "double", alpha: "double") -> "gr::analog::simple_squelch_cc::sptr":
    r"""simple_squelch_cc_make(double threshold_db, double alpha) -> simple_squelch_cc_sptr"""
    return _analog_swig.simple_squelch_cc_make(threshold_db, alpha)

class squelch_base_cc(object):
    r"""Proxy of C++ gr::analog::squelch_base_cc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def ramp(self) -> "int":
        r"""ramp(squelch_base_cc self) -> int"""
        return _analog_swig.squelch_base_cc_ramp(self)

    def set_ramp(self, ramp: "int") -> "void":
        r"""set_ramp(squelch_base_cc self, int ramp)"""
        return _analog_swig.squelch_base_cc_set_ramp(self, ramp)

    def gate(self) -> "bool":
        r"""gate(squelch_base_cc self) -> bool"""
        return _analog_swig.squelch_base_cc_gate(self)

    def set_gate(self, gate: "bool") -> "void":
        r"""set_gate(squelch_base_cc self, bool gate)"""
        return _analog_swig.squelch_base_cc_set_gate(self, gate)

    def unmuted(self) -> "bool":
        r"""unmuted(squelch_base_cc self) -> bool"""
        return _analog_swig.squelch_base_cc_unmuted(self)

    def squelch_range(self) -> "std::vector< float,std::allocator< float > >":
        r"""squelch_range(squelch_base_cc self) -> pmt_vector_float"""
        return _analog_swig.squelch_base_cc_squelch_range(self)
    __swig_destroy__ = _analog_swig.delete_squelch_base_cc

# Register squelch_base_cc in _analog_swig:
_analog_swig.squelch_base_cc_swigregister(squelch_base_cc)

class squelch_base_ff(object):
    r"""Proxy of C++ gr::analog::squelch_base_ff class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def ramp(self) -> "int":
        r"""ramp(squelch_base_ff self) -> int"""
        return _analog_swig.squelch_base_ff_ramp(self)

    def set_ramp(self, ramp: "int") -> "void":
        r"""set_ramp(squelch_base_ff self, int ramp)"""
        return _analog_swig.squelch_base_ff_set_ramp(self, ramp)

    def gate(self) -> "bool":
        r"""gate(squelch_base_ff self) -> bool"""
        return _analog_swig.squelch_base_ff_gate(self)

    def set_gate(self, gate: "bool") -> "void":
        r"""set_gate(squelch_base_ff self, bool gate)"""
        return _analog_swig.squelch_base_ff_set_gate(self, gate)

    def unmuted(self) -> "bool":
        r"""unmuted(squelch_base_ff self) -> bool"""
        return _analog_swig.squelch_base_ff_unmuted(self)

    def squelch_range(self) -> "std::vector< float,std::allocator< float > >":
        r"""squelch_range(squelch_base_ff self) -> pmt_vector_float"""
        return _analog_swig.squelch_base_ff_squelch_range(self)
    __swig_destroy__ = _analog_swig.delete_squelch_base_ff

# Register squelch_base_ff in _analog_swig:
_analog_swig.squelch_base_ff_swigregister(squelch_base_ff)

class agc_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::agc_cc > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(agc_cc_sptr self) -> agc_cc_sptr
        __init__(agc_cc_sptr self, agc_cc p) -> agc_cc_sptr
        """
        _analog_swig.agc_cc_sptr_swiginit(self, _analog_swig.new_agc_cc_sptr(*args))

    def __deref__(self) -> "gr::analog::agc_cc *":
        r"""__deref__(agc_cc_sptr self) -> agc_cc"""
        return _analog_swig.agc_cc_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_agc_cc_sptr

    def make(self, rate: "float"=1e-4, reference: "float"=1.0, gain: "float"=1.0) -> "gr::analog::agc_cc::sptr":
        r"""make(agc_cc_sptr self, float rate=1e-4, float reference=1.0, float gain=1.0) -> agc_cc_sptr"""
        return _analog_swig.agc_cc_sptr_make(self, rate, reference, gain)

    def rate(self) -> "float":
        r"""rate(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_rate(self)

    def reference(self) -> "float":
        r"""reference(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_reference(self)

    def gain(self) -> "float":
        r"""gain(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_gain(self)

    def max_gain(self) -> "float":
        r"""max_gain(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_max_gain(self)

    def set_rate(self, rate: "float") -> "void":
        r"""set_rate(agc_cc_sptr self, float rate)"""
        return _analog_swig.agc_cc_sptr_set_rate(self, rate)

    def set_reference(self, reference: "float") -> "void":
        r"""set_reference(agc_cc_sptr self, float reference)"""
        return _analog_swig.agc_cc_sptr_set_reference(self, reference)

    def set_gain(self, gain: "float") -> "void":
        r"""set_gain(agc_cc_sptr self, float gain)"""
        return _analog_swig.agc_cc_sptr_set_gain(self, gain)

    def set_max_gain(self, max_gain: "float") -> "void":
        r"""set_max_gain(agc_cc_sptr self, float max_gain)"""
        return _analog_swig.agc_cc_sptr_set_max_gain(self, max_gain)

    def history(self) -> "unsigned int":
        r"""history(agc_cc_sptr self) -> unsigned int"""
        return _analog_swig.agc_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(agc_cc_sptr self, int which, int delay)
        declare_sample_delay(agc_cc_sptr self, unsigned int delay)
        """
        return _analog_swig.agc_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(agc_cc_sptr self, int which) -> unsigned int"""
        return _analog_swig.agc_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(agc_cc_sptr self, int multiple)"""
        return _analog_swig.agc_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(agc_cc_sptr self) -> int"""
        return _analog_swig.agc_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(agc_cc_sptr self) -> double"""
        return _analog_swig.agc_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(agc_cc_sptr self) -> uint64_t"""
        return _analog_swig.agc_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(agc_cc_sptr self) -> uint64_t"""
        return _analog_swig.agc_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(agc_cc_sptr self) -> bool"""
        return _analog_swig.agc_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(agc_cc_sptr self) -> bool"""
        return _analog_swig.agc_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(agc_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.agc_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(agc_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.agc_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(agc_cc_sptr self, std::string level)"""
        return _analog_swig.agc_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(agc_cc_sptr self) -> std::string"""
        return _analog_swig.agc_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(agc_cc_sptr self) -> int"""
        return _analog_swig.agc_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(agc_cc_sptr self, int m)"""
        return _analog_swig.agc_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(agc_cc_sptr self)"""
        return _analog_swig.agc_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(agc_cc_sptr self) -> bool"""
        return _analog_swig.agc_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(agc_cc_sptr self, int m)"""
        return _analog_swig.agc_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(agc_cc_sptr self) -> int"""
        return _analog_swig.agc_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(agc_cc_sptr self, int i) -> long"""
        return _analog_swig.agc_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(agc_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(agc_cc_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.agc_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(agc_cc_sptr self, int i) -> long"""
        return _analog_swig.agc_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(agc_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(agc_cc_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.agc_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(agc_cc_sptr self, int which) -> float
        pc_input_buffers_full(agc_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc_cc_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(agc_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(agc_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc_cc_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(agc_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(agc_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc_cc_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(agc_cc_sptr self, int which) -> float
        pc_output_buffers_full(agc_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc_cc_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(agc_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(agc_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc_cc_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(agc_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(agc_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc_cc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(agc_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.agc_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(agc_cc_sptr self)"""
        return _analog_swig.agc_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(agc_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.agc_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(agc_cc_sptr self) -> int"""
        return _analog_swig.agc_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(agc_cc_sptr self) -> int"""
        return _analog_swig.agc_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(agc_cc_sptr self, int priority) -> int"""
        return _analog_swig.agc_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(agc_cc_sptr self) -> std::string"""
        return _analog_swig.agc_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(agc_cc_sptr self) -> std::string"""
        return _analog_swig.agc_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(agc_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(agc_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(agc_cc_sptr self) -> long"""
        return _analog_swig.agc_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(agc_cc_sptr self) -> basic_block_sptr"""
        return _analog_swig.agc_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(agc_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.agc_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(agc_cc_sptr self) -> std::string"""
        return _analog_swig.agc_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(agc_cc_sptr self, std::string name)"""
        return _analog_swig.agc_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(agc_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.agc_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(agc_cc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.agc_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(agc_cc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.agc_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(agc_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.agc_cc_sptr_message_subscribers(self, which_port)

# Register agc_cc_sptr in _analog_swig:
_analog_swig.agc_cc_sptr_swigregister(agc_cc_sptr)


agc_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
agc_cc = agc_cc.make;

class agc_ff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::agc_ff > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(agc_ff_sptr self) -> agc_ff_sptr
        __init__(agc_ff_sptr self, agc_ff p) -> agc_ff_sptr
        """
        _analog_swig.agc_ff_sptr_swiginit(self, _analog_swig.new_agc_ff_sptr(*args))

    def __deref__(self) -> "gr::analog::agc_ff *":
        r"""__deref__(agc_ff_sptr self) -> agc_ff"""
        return _analog_swig.agc_ff_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_agc_ff_sptr

    def make(self, rate: "float"=1e-4, reference: "float"=1.0, gain: "float"=1.0) -> "gr::analog::agc_ff::sptr":
        r"""make(agc_ff_sptr self, float rate=1e-4, float reference=1.0, float gain=1.0) -> agc_ff_sptr"""
        return _analog_swig.agc_ff_sptr_make(self, rate, reference, gain)

    def rate(self) -> "float":
        r"""rate(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_rate(self)

    def reference(self) -> "float":
        r"""reference(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_reference(self)

    def gain(self) -> "float":
        r"""gain(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_gain(self)

    def max_gain(self) -> "float":
        r"""max_gain(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_max_gain(self)

    def set_rate(self, rate: "float") -> "void":
        r"""set_rate(agc_ff_sptr self, float rate)"""
        return _analog_swig.agc_ff_sptr_set_rate(self, rate)

    def set_reference(self, reference: "float") -> "void":
        r"""set_reference(agc_ff_sptr self, float reference)"""
        return _analog_swig.agc_ff_sptr_set_reference(self, reference)

    def set_gain(self, gain: "float") -> "void":
        r"""set_gain(agc_ff_sptr self, float gain)"""
        return _analog_swig.agc_ff_sptr_set_gain(self, gain)

    def set_max_gain(self, max_gain: "float") -> "void":
        r"""set_max_gain(agc_ff_sptr self, float max_gain)"""
        return _analog_swig.agc_ff_sptr_set_max_gain(self, max_gain)

    def history(self) -> "unsigned int":
        r"""history(agc_ff_sptr self) -> unsigned int"""
        return _analog_swig.agc_ff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(agc_ff_sptr self, int which, int delay)
        declare_sample_delay(agc_ff_sptr self, unsigned int delay)
        """
        return _analog_swig.agc_ff_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(agc_ff_sptr self, int which) -> unsigned int"""
        return _analog_swig.agc_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(agc_ff_sptr self, int multiple)"""
        return _analog_swig.agc_ff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(agc_ff_sptr self) -> int"""
        return _analog_swig.agc_ff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(agc_ff_sptr self) -> double"""
        return _analog_swig.agc_ff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(agc_ff_sptr self) -> uint64_t"""
        return _analog_swig.agc_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(agc_ff_sptr self) -> uint64_t"""
        return _analog_swig.agc_ff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(agc_ff_sptr self) -> bool"""
        return _analog_swig.agc_ff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(agc_ff_sptr self) -> bool"""
        return _analog_swig.agc_ff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(agc_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.agc_ff_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(agc_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.agc_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(agc_ff_sptr self, std::string level)"""
        return _analog_swig.agc_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(agc_ff_sptr self) -> std::string"""
        return _analog_swig.agc_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(agc_ff_sptr self) -> int"""
        return _analog_swig.agc_ff_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(agc_ff_sptr self, int m)"""
        return _analog_swig.agc_ff_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(agc_ff_sptr self)"""
        return _analog_swig.agc_ff_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(agc_ff_sptr self) -> bool"""
        return _analog_swig.agc_ff_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(agc_ff_sptr self, int m)"""
        return _analog_swig.agc_ff_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(agc_ff_sptr self) -> int"""
        return _analog_swig.agc_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(agc_ff_sptr self, int i) -> long"""
        return _analog_swig.agc_ff_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(agc_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(agc_ff_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.agc_ff_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(agc_ff_sptr self, int i) -> long"""
        return _analog_swig.agc_ff_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(agc_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(agc_ff_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.agc_ff_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(agc_ff_sptr self, int which) -> float
        pc_input_buffers_full(agc_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc_ff_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(agc_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(agc_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc_ff_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(agc_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(agc_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc_ff_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(agc_ff_sptr self, int which) -> float
        pc_output_buffers_full(agc_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc_ff_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(agc_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(agc_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc_ff_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(agc_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(agc_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc_ff_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(agc_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.agc_ff_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(agc_ff_sptr self)"""
        return _analog_swig.agc_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(agc_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.agc_ff_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(agc_ff_sptr self) -> int"""
        return _analog_swig.agc_ff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(agc_ff_sptr self) -> int"""
        return _analog_swig.agc_ff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(agc_ff_sptr self, int priority) -> int"""
        return _analog_swig.agc_ff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(agc_ff_sptr self) -> std::string"""
        return _analog_swig.agc_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(agc_ff_sptr self) -> std::string"""
        return _analog_swig.agc_ff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(agc_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(agc_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc_ff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(agc_ff_sptr self) -> long"""
        return _analog_swig.agc_ff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(agc_ff_sptr self) -> basic_block_sptr"""
        return _analog_swig.agc_ff_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(agc_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.agc_ff_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(agc_ff_sptr self) -> std::string"""
        return _analog_swig.agc_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(agc_ff_sptr self, std::string name)"""
        return _analog_swig.agc_ff_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(agc_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.agc_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(agc_ff_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.agc_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(agc_ff_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.agc_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(agc_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.agc_ff_sptr_message_subscribers(self, which_port)

# Register agc_ff_sptr in _analog_swig:
_analog_swig.agc_ff_sptr_swigregister(agc_ff_sptr)


agc_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
agc_ff = agc_ff.make;

class agc2_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::agc2_cc > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(agc2_cc_sptr self) -> agc2_cc_sptr
        __init__(agc2_cc_sptr self, agc2_cc p) -> agc2_cc_sptr
        """
        _analog_swig.agc2_cc_sptr_swiginit(self, _analog_swig.new_agc2_cc_sptr(*args))

    def __deref__(self) -> "gr::analog::agc2_cc *":
        r"""__deref__(agc2_cc_sptr self) -> agc2_cc"""
        return _analog_swig.agc2_cc_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_agc2_cc_sptr

    def make(self, attack_rate: "float"=1e-1, decay_rate: "float"=1e-2, reference: "float"=1.0, gain: "float"=1.0) -> "gr::analog::agc2_cc::sptr":
        r"""make(agc2_cc_sptr self, float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0, float gain=1.0) -> agc2_cc_sptr"""
        return _analog_swig.agc2_cc_sptr_make(self, attack_rate, decay_rate, reference, gain)

    def attack_rate(self) -> "float":
        r"""attack_rate(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_attack_rate(self)

    def decay_rate(self) -> "float":
        r"""decay_rate(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_decay_rate(self)

    def reference(self) -> "float":
        r"""reference(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_reference(self)

    def gain(self) -> "float":
        r"""gain(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_gain(self)

    def max_gain(self) -> "float":
        r"""max_gain(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_max_gain(self)

    def set_attack_rate(self, rate: "float") -> "void":
        r"""set_attack_rate(agc2_cc_sptr self, float rate)"""
        return _analog_swig.agc2_cc_sptr_set_attack_rate(self, rate)

    def set_decay_rate(self, rate: "float") -> "void":
        r"""set_decay_rate(agc2_cc_sptr self, float rate)"""
        return _analog_swig.agc2_cc_sptr_set_decay_rate(self, rate)

    def set_reference(self, reference: "float") -> "void":
        r"""set_reference(agc2_cc_sptr self, float reference)"""
        return _analog_swig.agc2_cc_sptr_set_reference(self, reference)

    def set_gain(self, gain: "float") -> "void":
        r"""set_gain(agc2_cc_sptr self, float gain)"""
        return _analog_swig.agc2_cc_sptr_set_gain(self, gain)

    def set_max_gain(self, max_gain: "float") -> "void":
        r"""set_max_gain(agc2_cc_sptr self, float max_gain)"""
        return _analog_swig.agc2_cc_sptr_set_max_gain(self, max_gain)

    def history(self) -> "unsigned int":
        r"""history(agc2_cc_sptr self) -> unsigned int"""
        return _analog_swig.agc2_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(agc2_cc_sptr self, int which, int delay)
        declare_sample_delay(agc2_cc_sptr self, unsigned int delay)
        """
        return _analog_swig.agc2_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(agc2_cc_sptr self, int which) -> unsigned int"""
        return _analog_swig.agc2_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(agc2_cc_sptr self, int multiple)"""
        return _analog_swig.agc2_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(agc2_cc_sptr self) -> int"""
        return _analog_swig.agc2_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(agc2_cc_sptr self) -> double"""
        return _analog_swig.agc2_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(agc2_cc_sptr self) -> uint64_t"""
        return _analog_swig.agc2_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(agc2_cc_sptr self) -> uint64_t"""
        return _analog_swig.agc2_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(agc2_cc_sptr self) -> bool"""
        return _analog_swig.agc2_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(agc2_cc_sptr self) -> bool"""
        return _analog_swig.agc2_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(agc2_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.agc2_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(agc2_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.agc2_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(agc2_cc_sptr self, std::string level)"""
        return _analog_swig.agc2_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(agc2_cc_sptr self) -> std::string"""
        return _analog_swig.agc2_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(agc2_cc_sptr self) -> int"""
        return _analog_swig.agc2_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(agc2_cc_sptr self, int m)"""
        return _analog_swig.agc2_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(agc2_cc_sptr self)"""
        return _analog_swig.agc2_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(agc2_cc_sptr self) -> bool"""
        return _analog_swig.agc2_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(agc2_cc_sptr self, int m)"""
        return _analog_swig.agc2_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(agc2_cc_sptr self) -> int"""
        return _analog_swig.agc2_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(agc2_cc_sptr self, int i) -> long"""
        return _analog_swig.agc2_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(agc2_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(agc2_cc_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.agc2_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(agc2_cc_sptr self, int i) -> long"""
        return _analog_swig.agc2_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(agc2_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(agc2_cc_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.agc2_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(agc2_cc_sptr self, int which) -> float
        pc_input_buffers_full(agc2_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc2_cc_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(agc2_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(agc2_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc2_cc_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(agc2_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(agc2_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc2_cc_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(agc2_cc_sptr self, int which) -> float
        pc_output_buffers_full(agc2_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc2_cc_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(agc2_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(agc2_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc2_cc_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(agc2_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(agc2_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc2_cc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(agc2_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.agc2_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(agc2_cc_sptr self)"""
        return _analog_swig.agc2_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(agc2_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.agc2_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(agc2_cc_sptr self) -> int"""
        return _analog_swig.agc2_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(agc2_cc_sptr self) -> int"""
        return _analog_swig.agc2_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(agc2_cc_sptr self, int priority) -> int"""
        return _analog_swig.agc2_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(agc2_cc_sptr self) -> std::string"""
        return _analog_swig.agc2_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(agc2_cc_sptr self) -> std::string"""
        return _analog_swig.agc2_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(agc2_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc2_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(agc2_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc2_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(agc2_cc_sptr self) -> long"""
        return _analog_swig.agc2_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(agc2_cc_sptr self) -> basic_block_sptr"""
        return _analog_swig.agc2_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(agc2_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.agc2_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(agc2_cc_sptr self) -> std::string"""
        return _analog_swig.agc2_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(agc2_cc_sptr self, std::string name)"""
        return _analog_swig.agc2_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(agc2_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.agc2_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(agc2_cc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.agc2_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(agc2_cc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.agc2_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(agc2_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.agc2_cc_sptr_message_subscribers(self, which_port)

# Register agc2_cc_sptr in _analog_swig:
_analog_swig.agc2_cc_sptr_swigregister(agc2_cc_sptr)


agc2_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
agc2_cc = agc2_cc.make;

class agc2_ff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::agc2_ff > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(agc2_ff_sptr self) -> agc2_ff_sptr
        __init__(agc2_ff_sptr self, agc2_ff p) -> agc2_ff_sptr
        """
        _analog_swig.agc2_ff_sptr_swiginit(self, _analog_swig.new_agc2_ff_sptr(*args))

    def __deref__(self) -> "gr::analog::agc2_ff *":
        r"""__deref__(agc2_ff_sptr self) -> agc2_ff"""
        return _analog_swig.agc2_ff_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_agc2_ff_sptr

    def make(self, attack_rate: "float"=1e-1, decay_rate: "float"=1e-2, reference: "float"=1.0, gain: "float"=1.0) -> "gr::analog::agc2_ff::sptr":
        r"""make(agc2_ff_sptr self, float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0, float gain=1.0) -> agc2_ff_sptr"""
        return _analog_swig.agc2_ff_sptr_make(self, attack_rate, decay_rate, reference, gain)

    def attack_rate(self) -> "float":
        r"""attack_rate(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_attack_rate(self)

    def decay_rate(self) -> "float":
        r"""decay_rate(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_decay_rate(self)

    def reference(self) -> "float":
        r"""reference(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_reference(self)

    def gain(self) -> "float":
        r"""gain(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_gain(self)

    def max_gain(self) -> "float":
        r"""max_gain(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_max_gain(self)

    def set_attack_rate(self, rate: "float") -> "void":
        r"""set_attack_rate(agc2_ff_sptr self, float rate)"""
        return _analog_swig.agc2_ff_sptr_set_attack_rate(self, rate)

    def set_decay_rate(self, rate: "float") -> "void":
        r"""set_decay_rate(agc2_ff_sptr self, float rate)"""
        return _analog_swig.agc2_ff_sptr_set_decay_rate(self, rate)

    def set_reference(self, reference: "float") -> "void":
        r"""set_reference(agc2_ff_sptr self, float reference)"""
        return _analog_swig.agc2_ff_sptr_set_reference(self, reference)

    def set_gain(self, gain: "float") -> "void":
        r"""set_gain(agc2_ff_sptr self, float gain)"""
        return _analog_swig.agc2_ff_sptr_set_gain(self, gain)

    def set_max_gain(self, max_gain: "float") -> "void":
        r"""set_max_gain(agc2_ff_sptr self, float max_gain)"""
        return _analog_swig.agc2_ff_sptr_set_max_gain(self, max_gain)

    def history(self) -> "unsigned int":
        r"""history(agc2_ff_sptr self) -> unsigned int"""
        return _analog_swig.agc2_ff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(agc2_ff_sptr self, int which, int delay)
        declare_sample_delay(agc2_ff_sptr self, unsigned int delay)
        """
        return _analog_swig.agc2_ff_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(agc2_ff_sptr self, int which) -> unsigned int"""
        return _analog_swig.agc2_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(agc2_ff_sptr self, int multiple)"""
        return _analog_swig.agc2_ff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(agc2_ff_sptr self) -> int"""
        return _analog_swig.agc2_ff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(agc2_ff_sptr self) -> double"""
        return _analog_swig.agc2_ff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(agc2_ff_sptr self) -> uint64_t"""
        return _analog_swig.agc2_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(agc2_ff_sptr self) -> uint64_t"""
        return _analog_swig.agc2_ff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(agc2_ff_sptr self) -> bool"""
        return _analog_swig.agc2_ff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(agc2_ff_sptr self) -> bool"""
        return _analog_swig.agc2_ff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(agc2_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.agc2_ff_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(agc2_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.agc2_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(agc2_ff_sptr self, std::string level)"""
        return _analog_swig.agc2_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(agc2_ff_sptr self) -> std::string"""
        return _analog_swig.agc2_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(agc2_ff_sptr self) -> int"""
        return _analog_swig.agc2_ff_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(agc2_ff_sptr self, int m)"""
        return _analog_swig.agc2_ff_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(agc2_ff_sptr self)"""
        return _analog_swig.agc2_ff_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(agc2_ff_sptr self) -> bool"""
        return _analog_swig.agc2_ff_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(agc2_ff_sptr self, int m)"""
        return _analog_swig.agc2_ff_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(agc2_ff_sptr self) -> int"""
        return _analog_swig.agc2_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(agc2_ff_sptr self, int i) -> long"""
        return _analog_swig.agc2_ff_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(agc2_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(agc2_ff_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.agc2_ff_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(agc2_ff_sptr self, int i) -> long"""
        return _analog_swig.agc2_ff_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(agc2_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(agc2_ff_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.agc2_ff_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(agc2_ff_sptr self, int which) -> float
        pc_input_buffers_full(agc2_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc2_ff_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(agc2_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(agc2_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc2_ff_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(agc2_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(agc2_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc2_ff_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(agc2_ff_sptr self, int which) -> float
        pc_output_buffers_full(agc2_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc2_ff_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(agc2_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(agc2_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc2_ff_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(agc2_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(agc2_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc2_ff_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(agc2_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.agc2_ff_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(agc2_ff_sptr self)"""
        return _analog_swig.agc2_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(agc2_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.agc2_ff_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(agc2_ff_sptr self) -> int"""
        return _analog_swig.agc2_ff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(agc2_ff_sptr self) -> int"""
        return _analog_swig.agc2_ff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(agc2_ff_sptr self, int priority) -> int"""
        return _analog_swig.agc2_ff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(agc2_ff_sptr self) -> std::string"""
        return _analog_swig.agc2_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(agc2_ff_sptr self) -> std::string"""
        return _analog_swig.agc2_ff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(agc2_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc2_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(agc2_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc2_ff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(agc2_ff_sptr self) -> long"""
        return _analog_swig.agc2_ff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(agc2_ff_sptr self) -> basic_block_sptr"""
        return _analog_swig.agc2_ff_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(agc2_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.agc2_ff_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(agc2_ff_sptr self) -> std::string"""
        return _analog_swig.agc2_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(agc2_ff_sptr self, std::string name)"""
        return _analog_swig.agc2_ff_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(agc2_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.agc2_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(agc2_ff_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.agc2_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(agc2_ff_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.agc2_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(agc2_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.agc2_ff_sptr_message_subscribers(self, which_port)

# Register agc2_ff_sptr in _analog_swig:
_analog_swig.agc2_ff_sptr_swigregister(agc2_ff_sptr)


agc2_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
agc2_ff = agc2_ff.make;

class agc3_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::agc3_cc > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(agc3_cc_sptr self) -> agc3_cc_sptr
        __init__(agc3_cc_sptr self, agc3_cc p) -> agc3_cc_sptr
        """
        _analog_swig.agc3_cc_sptr_swiginit(self, _analog_swig.new_agc3_cc_sptr(*args))

    def __deref__(self) -> "gr::analog::agc3_cc *":
        r"""__deref__(agc3_cc_sptr self) -> agc3_cc"""
        return _analog_swig.agc3_cc_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_agc3_cc_sptr

    def make(self, attack_rate: "float"=1e-1, decay_rate: "float"=1e-2, reference: "float"=1.0, gain: "float"=1.0, iir_update_decim: "int"=1) -> "gr::analog::agc3_cc::sptr":
        r"""make(agc3_cc_sptr self, float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0, float gain=1.0, int iir_update_decim=1) -> agc3_cc_sptr"""
        return _analog_swig.agc3_cc_sptr_make(self, attack_rate, decay_rate, reference, gain, iir_update_decim)

    def attack_rate(self) -> "float":
        r"""attack_rate(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_attack_rate(self)

    def decay_rate(self) -> "float":
        r"""decay_rate(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_decay_rate(self)

    def reference(self) -> "float":
        r"""reference(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_reference(self)

    def gain(self) -> "float":
        r"""gain(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_gain(self)

    def max_gain(self) -> "float":
        r"""max_gain(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_max_gain(self)

    def set_attack_rate(self, rate: "float") -> "void":
        r"""set_attack_rate(agc3_cc_sptr self, float rate)"""
        return _analog_swig.agc3_cc_sptr_set_attack_rate(self, rate)

    def set_decay_rate(self, rate: "float") -> "void":
        r"""set_decay_rate(agc3_cc_sptr self, float rate)"""
        return _analog_swig.agc3_cc_sptr_set_decay_rate(self, rate)

    def set_reference(self, reference: "float") -> "void":
        r"""set_reference(agc3_cc_sptr self, float reference)"""
        return _analog_swig.agc3_cc_sptr_set_reference(self, reference)

    def set_gain(self, gain: "float") -> "void":
        r"""set_gain(agc3_cc_sptr self, float gain)"""
        return _analog_swig.agc3_cc_sptr_set_gain(self, gain)

    def set_max_gain(self, max_gain: "float") -> "void":
        r"""set_max_gain(agc3_cc_sptr self, float max_gain)"""
        return _analog_swig.agc3_cc_sptr_set_max_gain(self, max_gain)

    def history(self) -> "unsigned int":
        r"""history(agc3_cc_sptr self) -> unsigned int"""
        return _analog_swig.agc3_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(agc3_cc_sptr self, int which, int delay)
        declare_sample_delay(agc3_cc_sptr self, unsigned int delay)
        """
        return _analog_swig.agc3_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(agc3_cc_sptr self, int which) -> unsigned int"""
        return _analog_swig.agc3_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(agc3_cc_sptr self, int multiple)"""
        return _analog_swig.agc3_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(agc3_cc_sptr self) -> int"""
        return _analog_swig.agc3_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(agc3_cc_sptr self) -> double"""
        return _analog_swig.agc3_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(agc3_cc_sptr self) -> uint64_t"""
        return _analog_swig.agc3_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(agc3_cc_sptr self) -> uint64_t"""
        return _analog_swig.agc3_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(agc3_cc_sptr self) -> bool"""
        return _analog_swig.agc3_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(agc3_cc_sptr self) -> bool"""
        return _analog_swig.agc3_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(agc3_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.agc3_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(agc3_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.agc3_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(agc3_cc_sptr self, std::string level)"""
        return _analog_swig.agc3_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(agc3_cc_sptr self) -> std::string"""
        return _analog_swig.agc3_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(agc3_cc_sptr self) -> int"""
        return _analog_swig.agc3_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(agc3_cc_sptr self, int m)"""
        return _analog_swig.agc3_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(agc3_cc_sptr self)"""
        return _analog_swig.agc3_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(agc3_cc_sptr self) -> bool"""
        return _analog_swig.agc3_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(agc3_cc_sptr self, int m)"""
        return _analog_swig.agc3_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(agc3_cc_sptr self) -> int"""
        return _analog_swig.agc3_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(agc3_cc_sptr self, int i) -> long"""
        return _analog_swig.agc3_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(agc3_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(agc3_cc_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.agc3_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(agc3_cc_sptr self, int i) -> long"""
        return _analog_swig.agc3_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(agc3_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(agc3_cc_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.agc3_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(agc3_cc_sptr self, int which) -> float
        pc_input_buffers_full(agc3_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc3_cc_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(agc3_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(agc3_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc3_cc_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(agc3_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(agc3_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc3_cc_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(agc3_cc_sptr self, int which) -> float
        pc_output_buffers_full(agc3_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc3_cc_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(agc3_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(agc3_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc3_cc_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(agc3_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(agc3_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.agc3_cc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(agc3_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.agc3_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(agc3_cc_sptr self)"""
        return _analog_swig.agc3_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(agc3_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.agc3_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(agc3_cc_sptr self) -> int"""
        return _analog_swig.agc3_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(agc3_cc_sptr self) -> int"""
        return _analog_swig.agc3_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(agc3_cc_sptr self, int priority) -> int"""
        return _analog_swig.agc3_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(agc3_cc_sptr self) -> std::string"""
        return _analog_swig.agc3_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(agc3_cc_sptr self) -> std::string"""
        return _analog_swig.agc3_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(agc3_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc3_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(agc3_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc3_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(agc3_cc_sptr self) -> long"""
        return _analog_swig.agc3_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(agc3_cc_sptr self) -> basic_block_sptr"""
        return _analog_swig.agc3_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(agc3_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.agc3_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(agc3_cc_sptr self) -> std::string"""
        return _analog_swig.agc3_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(agc3_cc_sptr self, std::string name)"""
        return _analog_swig.agc3_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(agc3_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.agc3_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(agc3_cc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.agc3_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(agc3_cc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.agc3_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(agc3_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.agc3_cc_sptr_message_subscribers(self, which_port)

# Register agc3_cc_sptr in _analog_swig:
_analog_swig.agc3_cc_sptr_swigregister(agc3_cc_sptr)


agc3_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
agc3_cc = agc3_cc.make;

class cpfsk_bc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::cpfsk_bc > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(cpfsk_bc_sptr self) -> cpfsk_bc_sptr
        __init__(cpfsk_bc_sptr self, cpfsk_bc p) -> cpfsk_bc_sptr
        """
        _analog_swig.cpfsk_bc_sptr_swiginit(self, _analog_swig.new_cpfsk_bc_sptr(*args))

    def __deref__(self) -> "gr::analog::cpfsk_bc *":
        r"""__deref__(cpfsk_bc_sptr self) -> cpfsk_bc"""
        return _analog_swig.cpfsk_bc_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_cpfsk_bc_sptr

    def make(self, k: "float", ampl: "float", samples_per_sym: "int") -> "gr::analog::cpfsk_bc::sptr":
        r"""make(cpfsk_bc_sptr self, float k, float ampl, int samples_per_sym) -> cpfsk_bc_sptr"""
        return _analog_swig.cpfsk_bc_sptr_make(self, k, ampl, samples_per_sym)

    def set_amplitude(self, amplitude: "float") -> "void":
        r"""set_amplitude(cpfsk_bc_sptr self, float amplitude)"""
        return _analog_swig.cpfsk_bc_sptr_set_amplitude(self, amplitude)

    def amplitude(self) -> "float":
        r"""amplitude(cpfsk_bc_sptr self) -> float"""
        return _analog_swig.cpfsk_bc_sptr_amplitude(self)

    def freq(self) -> "float":
        r"""freq(cpfsk_bc_sptr self) -> float"""
        return _analog_swig.cpfsk_bc_sptr_freq(self)

    def phase(self) -> "float":
        r"""phase(cpfsk_bc_sptr self) -> float"""
        return _analog_swig.cpfsk_bc_sptr_phase(self)

    def history(self) -> "unsigned int":
        r"""history(cpfsk_bc_sptr self) -> unsigned int"""
        return _analog_swig.cpfsk_bc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(cpfsk_bc_sptr self, int which, int delay)
        declare_sample_delay(cpfsk_bc_sptr self, unsigned int delay)
        """
        return _analog_swig.cpfsk_bc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(cpfsk_bc_sptr self, int which) -> unsigned int"""
        return _analog_swig.cpfsk_bc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(cpfsk_bc_sptr self, int multiple)"""
        return _analog_swig.cpfsk_bc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(cpfsk_bc_sptr self) -> int"""
        return _analog_swig.cpfsk_bc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(cpfsk_bc_sptr self) -> double"""
        return _analog_swig.cpfsk_bc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(cpfsk_bc_sptr self) -> uint64_t"""
        return _analog_swig.cpfsk_bc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(cpfsk_bc_sptr self) -> uint64_t"""
        return _analog_swig.cpfsk_bc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(cpfsk_bc_sptr self) -> bool"""
        return _analog_swig.cpfsk_bc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(cpfsk_bc_sptr self) -> bool"""
        return _analog_swig.cpfsk_bc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(cpfsk_bc_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.cpfsk_bc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(cpfsk_bc_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.cpfsk_bc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(cpfsk_bc_sptr self, std::string level)"""
        return _analog_swig.cpfsk_bc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(cpfsk_bc_sptr self) -> std::string"""
        return _analog_swig.cpfsk_bc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(cpfsk_bc_sptr self) -> int"""
        return _analog_swig.cpfsk_bc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(cpfsk_bc_sptr self, int m)"""
        return _analog_swig.cpfsk_bc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(cpfsk_bc_sptr self)"""
        return _analog_swig.cpfsk_bc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(cpfsk_bc_sptr self) -> bool"""
        return _analog_swig.cpfsk_bc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(cpfsk_bc_sptr self, int m)"""
        return _analog_swig.cpfsk_bc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(cpfsk_bc_sptr self) -> int"""
        return _analog_swig.cpfsk_bc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(cpfsk_bc_sptr self, int i) -> long"""
        return _analog_swig.cpfsk_bc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(cpfsk_bc_sptr self, long max_output_buffer)
        set_max_output_buffer(cpfsk_bc_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.cpfsk_bc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(cpfsk_bc_sptr self, int i) -> long"""
        return _analog_swig.cpfsk_bc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(cpfsk_bc_sptr self, long min_output_buffer)
        set_min_output_buffer(cpfsk_bc_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.cpfsk_bc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(cpfsk_bc_sptr self) -> float"""
        return _analog_swig.cpfsk_bc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(cpfsk_bc_sptr self) -> float"""
        return _analog_swig.cpfsk_bc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(cpfsk_bc_sptr self) -> float"""
        return _analog_swig.cpfsk_bc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(cpfsk_bc_sptr self) -> float"""
        return _analog_swig.cpfsk_bc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(cpfsk_bc_sptr self) -> float"""
        return _analog_swig.cpfsk_bc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(cpfsk_bc_sptr self) -> float"""
        return _analog_swig.cpfsk_bc_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(cpfsk_bc_sptr self, int which) -> float
        pc_input_buffers_full(cpfsk_bc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.cpfsk_bc_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(cpfsk_bc_sptr self, int which) -> float
        pc_input_buffers_full_avg(cpfsk_bc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.cpfsk_bc_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(cpfsk_bc_sptr self, int which) -> float
        pc_input_buffers_full_var(cpfsk_bc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.cpfsk_bc_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(cpfsk_bc_sptr self, int which) -> float
        pc_output_buffers_full(cpfsk_bc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.cpfsk_bc_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(cpfsk_bc_sptr self, int which) -> float
        pc_output_buffers_full_avg(cpfsk_bc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.cpfsk_bc_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(cpfsk_bc_sptr self, int which) -> float
        pc_output_buffers_full_var(cpfsk_bc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.cpfsk_bc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(cpfsk_bc_sptr self) -> float"""
        return _analog_swig.cpfsk_bc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(cpfsk_bc_sptr self) -> float"""
        return _analog_swig.cpfsk_bc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(cpfsk_bc_sptr self) -> float"""
        return _analog_swig.cpfsk_bc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(cpfsk_bc_sptr self) -> float"""
        return _analog_swig.cpfsk_bc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(cpfsk_bc_sptr self) -> float"""
        return _analog_swig.cpfsk_bc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(cpfsk_bc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.cpfsk_bc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(cpfsk_bc_sptr self)"""
        return _analog_swig.cpfsk_bc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(cpfsk_bc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.cpfsk_bc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(cpfsk_bc_sptr self) -> int"""
        return _analog_swig.cpfsk_bc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(cpfsk_bc_sptr self) -> int"""
        return _analog_swig.cpfsk_bc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(cpfsk_bc_sptr self, int priority) -> int"""
        return _analog_swig.cpfsk_bc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(cpfsk_bc_sptr self) -> std::string"""
        return _analog_swig.cpfsk_bc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(cpfsk_bc_sptr self) -> std::string"""
        return _analog_swig.cpfsk_bc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(cpfsk_bc_sptr self) -> io_signature_sptr"""
        return _analog_swig.cpfsk_bc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(cpfsk_bc_sptr self) -> io_signature_sptr"""
        return _analog_swig.cpfsk_bc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(cpfsk_bc_sptr self) -> long"""
        return _analog_swig.cpfsk_bc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(cpfsk_bc_sptr self) -> basic_block_sptr"""
        return _analog_swig.cpfsk_bc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(cpfsk_bc_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.cpfsk_bc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(cpfsk_bc_sptr self) -> std::string"""
        return _analog_swig.cpfsk_bc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(cpfsk_bc_sptr self, std::string name)"""
        return _analog_swig.cpfsk_bc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(cpfsk_bc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.cpfsk_bc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(cpfsk_bc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.cpfsk_bc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(cpfsk_bc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.cpfsk_bc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(cpfsk_bc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.cpfsk_bc_sptr_message_subscribers(self, which_port)

# Register cpfsk_bc_sptr in _analog_swig:
_analog_swig.cpfsk_bc_sptr_swigregister(cpfsk_bc_sptr)


cpfsk_bc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
cpfsk_bc = cpfsk_bc.make;

class ctcss_squelch_ff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::ctcss_squelch_ff > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(ctcss_squelch_ff_sptr self) -> ctcss_squelch_ff_sptr
        __init__(ctcss_squelch_ff_sptr self, ctcss_squelch_ff p) -> ctcss_squelch_ff_sptr
        """
        _analog_swig.ctcss_squelch_ff_sptr_swiginit(self, _analog_swig.new_ctcss_squelch_ff_sptr(*args))

    def __deref__(self) -> "gr::analog::ctcss_squelch_ff *":
        r"""__deref__(ctcss_squelch_ff_sptr self) -> ctcss_squelch_ff"""
        return _analog_swig.ctcss_squelch_ff_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_ctcss_squelch_ff_sptr

    def make(self, rate: "int", freq: "float", level: "float", len: "int", ramp: "int", gate: "bool") -> "gr::analog::ctcss_squelch_ff::sptr":
        r"""make(ctcss_squelch_ff_sptr self, int rate, float freq, float level, int len, int ramp, bool gate) -> ctcss_squelch_ff_sptr"""
        return _analog_swig.ctcss_squelch_ff_sptr_make(self, rate, freq, level, len, ramp, gate)

    def squelch_range(self) -> "std::vector< float,std::allocator< float > >":
        r"""squelch_range(ctcss_squelch_ff_sptr self) -> pmt_vector_float"""
        return _analog_swig.ctcss_squelch_ff_sptr_squelch_range(self)

    def level(self) -> "float":
        r"""level(ctcss_squelch_ff_sptr self) -> float"""
        return _analog_swig.ctcss_squelch_ff_sptr_level(self)

    def set_level(self, level: "float") -> "void":
        r"""set_level(ctcss_squelch_ff_sptr self, float level)"""
        return _analog_swig.ctcss_squelch_ff_sptr_set_level(self, level)

    def len(self) -> "int":
        r"""len(ctcss_squelch_ff_sptr self) -> int"""
        return _analog_swig.ctcss_squelch_ff_sptr_len(self)

    def frequency(self) -> "float":
        r"""frequency(ctcss_squelch_ff_sptr self) -> float"""
        return _analog_swig.ctcss_squelch_ff_sptr_frequency(self)

    def set_frequency(self, frequency: "float") -> "void":
        r"""set_frequency(ctcss_squelch_ff_sptr self, float frequency)"""
        return _analog_swig.ctcss_squelch_ff_sptr_set_frequency(self, frequency)

    def ramp(self) -> "int":
        r"""ramp(ctcss_squelch_ff_sptr self) -> int"""
        return _analog_swig.ctcss_squelch_ff_sptr_ramp(self)

    def set_ramp(self, ramp: "int") -> "void":
        r"""set_ramp(ctcss_squelch_ff_sptr self, int ramp)"""
        return _analog_swig.ctcss_squelch_ff_sptr_set_ramp(self, ramp)

    def gate(self) -> "bool":
        r"""gate(ctcss_squelch_ff_sptr self) -> bool"""
        return _analog_swig.ctcss_squelch_ff_sptr_gate(self)

    def set_gate(self, gate: "bool") -> "void":
        r"""set_gate(ctcss_squelch_ff_sptr self, bool gate)"""
        return _analog_swig.ctcss_squelch_ff_sptr_set_gate(self, gate)

    def unmuted(self) -> "bool":
        r"""unmuted(ctcss_squelch_ff_sptr self) -> bool"""
        return _analog_swig.ctcss_squelch_ff_sptr_unmuted(self)

    def history(self) -> "unsigned int":
        r"""history(ctcss_squelch_ff_sptr self) -> unsigned int"""
        return _analog_swig.ctcss_squelch_ff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(ctcss_squelch_ff_sptr self, int which, int delay)
        declare_sample_delay(ctcss_squelch_ff_sptr self, unsigned int delay)
        """
        return _analog_swig.ctcss_squelch_ff_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(ctcss_squelch_ff_sptr self, int which) -> unsigned int"""
        return _analog_swig.ctcss_squelch_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(ctcss_squelch_ff_sptr self, int multiple)"""
        return _analog_swig.ctcss_squelch_ff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(ctcss_squelch_ff_sptr self) -> int"""
        return _analog_swig.ctcss_squelch_ff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(ctcss_squelch_ff_sptr self) -> double"""
        return _analog_swig.ctcss_squelch_ff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(ctcss_squelch_ff_sptr self) -> uint64_t"""
        return _analog_swig.ctcss_squelch_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(ctcss_squelch_ff_sptr self) -> uint64_t"""
        return _analog_swig.ctcss_squelch_ff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(ctcss_squelch_ff_sptr self) -> bool"""
        return _analog_swig.ctcss_squelch_ff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(ctcss_squelch_ff_sptr self) -> bool"""
        return _analog_swig.ctcss_squelch_ff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(ctcss_squelch_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.ctcss_squelch_ff_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(ctcss_squelch_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.ctcss_squelch_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(ctcss_squelch_ff_sptr self, std::string level)"""
        return _analog_swig.ctcss_squelch_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(ctcss_squelch_ff_sptr self) -> std::string"""
        return _analog_swig.ctcss_squelch_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(ctcss_squelch_ff_sptr self) -> int"""
        return _analog_swig.ctcss_squelch_ff_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(ctcss_squelch_ff_sptr self, int m)"""
        return _analog_swig.ctcss_squelch_ff_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(ctcss_squelch_ff_sptr self)"""
        return _analog_swig.ctcss_squelch_ff_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(ctcss_squelch_ff_sptr self) -> bool"""
        return _analog_swig.ctcss_squelch_ff_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(ctcss_squelch_ff_sptr self, int m)"""
        return _analog_swig.ctcss_squelch_ff_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(ctcss_squelch_ff_sptr self) -> int"""
        return _analog_swig.ctcss_squelch_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(ctcss_squelch_ff_sptr self, int i) -> long"""
        return _analog_swig.ctcss_squelch_ff_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(ctcss_squelch_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(ctcss_squelch_ff_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.ctcss_squelch_ff_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(ctcss_squelch_ff_sptr self, int i) -> long"""
        return _analog_swig.ctcss_squelch_ff_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(ctcss_squelch_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(ctcss_squelch_ff_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.ctcss_squelch_ff_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(ctcss_squelch_ff_sptr self) -> float"""
        return _analog_swig.ctcss_squelch_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(ctcss_squelch_ff_sptr self) -> float"""
        return _analog_swig.ctcss_squelch_ff_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(ctcss_squelch_ff_sptr self) -> float"""
        return _analog_swig.ctcss_squelch_ff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(ctcss_squelch_ff_sptr self) -> float"""
        return _analog_swig.ctcss_squelch_ff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(ctcss_squelch_ff_sptr self) -> float"""
        return _analog_swig.ctcss_squelch_ff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(ctcss_squelch_ff_sptr self) -> float"""
        return _analog_swig.ctcss_squelch_ff_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(ctcss_squelch_ff_sptr self, int which) -> float
        pc_input_buffers_full(ctcss_squelch_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.ctcss_squelch_ff_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(ctcss_squelch_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(ctcss_squelch_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.ctcss_squelch_ff_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(ctcss_squelch_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(ctcss_squelch_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.ctcss_squelch_ff_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(ctcss_squelch_ff_sptr self, int which) -> float
        pc_output_buffers_full(ctcss_squelch_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.ctcss_squelch_ff_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(ctcss_squelch_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(ctcss_squelch_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.ctcss_squelch_ff_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(ctcss_squelch_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(ctcss_squelch_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.ctcss_squelch_ff_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(ctcss_squelch_ff_sptr self) -> float"""
        return _analog_swig.ctcss_squelch_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(ctcss_squelch_ff_sptr self) -> float"""
        return _analog_swig.ctcss_squelch_ff_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(ctcss_squelch_ff_sptr self) -> float"""
        return _analog_swig.ctcss_squelch_ff_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(ctcss_squelch_ff_sptr self) -> float"""
        return _analog_swig.ctcss_squelch_ff_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(ctcss_squelch_ff_sptr self) -> float"""
        return _analog_swig.ctcss_squelch_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(ctcss_squelch_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.ctcss_squelch_ff_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(ctcss_squelch_ff_sptr self)"""
        return _analog_swig.ctcss_squelch_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(ctcss_squelch_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.ctcss_squelch_ff_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(ctcss_squelch_ff_sptr self) -> int"""
        return _analog_swig.ctcss_squelch_ff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(ctcss_squelch_ff_sptr self) -> int"""
        return _analog_swig.ctcss_squelch_ff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(ctcss_squelch_ff_sptr self, int priority) -> int"""
        return _analog_swig.ctcss_squelch_ff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(ctcss_squelch_ff_sptr self) -> std::string"""
        return _analog_swig.ctcss_squelch_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(ctcss_squelch_ff_sptr self) -> std::string"""
        return _analog_swig.ctcss_squelch_ff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(ctcss_squelch_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.ctcss_squelch_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(ctcss_squelch_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.ctcss_squelch_ff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(ctcss_squelch_ff_sptr self) -> long"""
        return _analog_swig.ctcss_squelch_ff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(ctcss_squelch_ff_sptr self) -> basic_block_sptr"""
        return _analog_swig.ctcss_squelch_ff_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(ctcss_squelch_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.ctcss_squelch_ff_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(ctcss_squelch_ff_sptr self) -> std::string"""
        return _analog_swig.ctcss_squelch_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(ctcss_squelch_ff_sptr self, std::string name)"""
        return _analog_swig.ctcss_squelch_ff_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(ctcss_squelch_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.ctcss_squelch_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(ctcss_squelch_ff_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.ctcss_squelch_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(ctcss_squelch_ff_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.ctcss_squelch_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(ctcss_squelch_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.ctcss_squelch_ff_sptr_message_subscribers(self, which_port)

# Register ctcss_squelch_ff_sptr in _analog_swig:
_analog_swig.ctcss_squelch_ff_sptr_swigregister(ctcss_squelch_ff_sptr)


ctcss_squelch_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
ctcss_squelch_ff = ctcss_squelch_ff.make;

class dpll_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::dpll_bb > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(dpll_bb_sptr self) -> dpll_bb_sptr
        __init__(dpll_bb_sptr self, dpll_bb p) -> dpll_bb_sptr
        """
        _analog_swig.dpll_bb_sptr_swiginit(self, _analog_swig.new_dpll_bb_sptr(*args))

    def __deref__(self) -> "gr::analog::dpll_bb *":
        r"""__deref__(dpll_bb_sptr self) -> dpll_bb"""
        return _analog_swig.dpll_bb_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_dpll_bb_sptr

    def make(self, period: "float", gain: "float") -> "gr::analog::dpll_bb::sptr":
        r"""make(dpll_bb_sptr self, float period, float gain) -> dpll_bb_sptr"""
        return _analog_swig.dpll_bb_sptr_make(self, period, gain)

    def set_gain(self, gain: "float") -> "void":
        r"""set_gain(dpll_bb_sptr self, float gain)"""
        return _analog_swig.dpll_bb_sptr_set_gain(self, gain)

    def set_decision_threshold(self, thresh: "float") -> "void":
        r"""set_decision_threshold(dpll_bb_sptr self, float thresh)"""
        return _analog_swig.dpll_bb_sptr_set_decision_threshold(self, thresh)

    def gain(self) -> "float":
        r"""gain(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_gain(self)

    def freq(self) -> "float":
        r"""freq(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_freq(self)

    def phase(self) -> "float":
        r"""phase(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_phase(self)

    def decision_threshold(self) -> "float":
        r"""decision_threshold(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_decision_threshold(self)

    def history(self) -> "unsigned int":
        r"""history(dpll_bb_sptr self) -> unsigned int"""
        return _analog_swig.dpll_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(dpll_bb_sptr self, int which, int delay)
        declare_sample_delay(dpll_bb_sptr self, unsigned int delay)
        """
        return _analog_swig.dpll_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(dpll_bb_sptr self, int which) -> unsigned int"""
        return _analog_swig.dpll_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(dpll_bb_sptr self, int multiple)"""
        return _analog_swig.dpll_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(dpll_bb_sptr self) -> int"""
        return _analog_swig.dpll_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(dpll_bb_sptr self) -> double"""
        return _analog_swig.dpll_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(dpll_bb_sptr self) -> uint64_t"""
        return _analog_swig.dpll_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(dpll_bb_sptr self) -> uint64_t"""
        return _analog_swig.dpll_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(dpll_bb_sptr self) -> bool"""
        return _analog_swig.dpll_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(dpll_bb_sptr self) -> bool"""
        return _analog_swig.dpll_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(dpll_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.dpll_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(dpll_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.dpll_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(dpll_bb_sptr self, std::string level)"""
        return _analog_swig.dpll_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(dpll_bb_sptr self) -> std::string"""
        return _analog_swig.dpll_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(dpll_bb_sptr self) -> int"""
        return _analog_swig.dpll_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(dpll_bb_sptr self, int m)"""
        return _analog_swig.dpll_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(dpll_bb_sptr self)"""
        return _analog_swig.dpll_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(dpll_bb_sptr self) -> bool"""
        return _analog_swig.dpll_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(dpll_bb_sptr self, int m)"""
        return _analog_swig.dpll_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(dpll_bb_sptr self) -> int"""
        return _analog_swig.dpll_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(dpll_bb_sptr self, int i) -> long"""
        return _analog_swig.dpll_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(dpll_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(dpll_bb_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.dpll_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(dpll_bb_sptr self, int i) -> long"""
        return _analog_swig.dpll_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(dpll_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(dpll_bb_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.dpll_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(dpll_bb_sptr self, int which) -> float
        pc_input_buffers_full(dpll_bb_sptr self) -> pmt_vector_float
        """
        return _analog_swig.dpll_bb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(dpll_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(dpll_bb_sptr self) -> pmt_vector_float
        """
        return _analog_swig.dpll_bb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(dpll_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(dpll_bb_sptr self) -> pmt_vector_float
        """
        return _analog_swig.dpll_bb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(dpll_bb_sptr self, int which) -> float
        pc_output_buffers_full(dpll_bb_sptr self) -> pmt_vector_float
        """
        return _analog_swig.dpll_bb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(dpll_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(dpll_bb_sptr self) -> pmt_vector_float
        """
        return _analog_swig.dpll_bb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(dpll_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(dpll_bb_sptr self) -> pmt_vector_float
        """
        return _analog_swig.dpll_bb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(dpll_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.dpll_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(dpll_bb_sptr self)"""
        return _analog_swig.dpll_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(dpll_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.dpll_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(dpll_bb_sptr self) -> int"""
        return _analog_swig.dpll_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(dpll_bb_sptr self) -> int"""
        return _analog_swig.dpll_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(dpll_bb_sptr self, int priority) -> int"""
        return _analog_swig.dpll_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(dpll_bb_sptr self) -> std::string"""
        return _analog_swig.dpll_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(dpll_bb_sptr self) -> std::string"""
        return _analog_swig.dpll_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(dpll_bb_sptr self) -> io_signature_sptr"""
        return _analog_swig.dpll_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(dpll_bb_sptr self) -> io_signature_sptr"""
        return _analog_swig.dpll_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(dpll_bb_sptr self) -> long"""
        return _analog_swig.dpll_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(dpll_bb_sptr self) -> basic_block_sptr"""
        return _analog_swig.dpll_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(dpll_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.dpll_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(dpll_bb_sptr self) -> std::string"""
        return _analog_swig.dpll_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(dpll_bb_sptr self, std::string name)"""
        return _analog_swig.dpll_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(dpll_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.dpll_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(dpll_bb_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.dpll_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(dpll_bb_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.dpll_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(dpll_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.dpll_bb_sptr_message_subscribers(self, which_port)

# Register dpll_bb_sptr in _analog_swig:
_analog_swig.dpll_bb_sptr_swigregister(dpll_bb_sptr)


dpll_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
dpll_bb = dpll_bb.make;

class feedforward_agc_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::feedforward_agc_cc > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(feedforward_agc_cc_sptr self) -> feedforward_agc_cc_sptr
        __init__(feedforward_agc_cc_sptr self, feedforward_agc_cc p) -> feedforward_agc_cc_sptr
        """
        _analog_swig.feedforward_agc_cc_sptr_swiginit(self, _analog_swig.new_feedforward_agc_cc_sptr(*args))

    def __deref__(self) -> "gr::analog::feedforward_agc_cc *":
        r"""__deref__(feedforward_agc_cc_sptr self) -> feedforward_agc_cc"""
        return _analog_swig.feedforward_agc_cc_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_feedforward_agc_cc_sptr

    def make(self, nsamples: "int", reference: "float") -> "gr::analog::feedforward_agc_cc::sptr":
        r"""make(feedforward_agc_cc_sptr self, int nsamples, float reference) -> feedforward_agc_cc_sptr"""
        return _analog_swig.feedforward_agc_cc_sptr_make(self, nsamples, reference)

    def history(self) -> "unsigned int":
        r"""history(feedforward_agc_cc_sptr self) -> unsigned int"""
        return _analog_swig.feedforward_agc_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(feedforward_agc_cc_sptr self, int which, int delay)
        declare_sample_delay(feedforward_agc_cc_sptr self, unsigned int delay)
        """
        return _analog_swig.feedforward_agc_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(feedforward_agc_cc_sptr self, int which) -> unsigned int"""
        return _analog_swig.feedforward_agc_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(feedforward_agc_cc_sptr self, int multiple)"""
        return _analog_swig.feedforward_agc_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(feedforward_agc_cc_sptr self) -> int"""
        return _analog_swig.feedforward_agc_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(feedforward_agc_cc_sptr self) -> double"""
        return _analog_swig.feedforward_agc_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(feedforward_agc_cc_sptr self) -> uint64_t"""
        return _analog_swig.feedforward_agc_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(feedforward_agc_cc_sptr self) -> uint64_t"""
        return _analog_swig.feedforward_agc_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(feedforward_agc_cc_sptr self) -> bool"""
        return _analog_swig.feedforward_agc_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(feedforward_agc_cc_sptr self) -> bool"""
        return _analog_swig.feedforward_agc_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(feedforward_agc_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.feedforward_agc_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(feedforward_agc_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.feedforward_agc_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(feedforward_agc_cc_sptr self, std::string level)"""
        return _analog_swig.feedforward_agc_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(feedforward_agc_cc_sptr self) -> std::string"""
        return _analog_swig.feedforward_agc_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(feedforward_agc_cc_sptr self) -> int"""
        return _analog_swig.feedforward_agc_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(feedforward_agc_cc_sptr self, int m)"""
        return _analog_swig.feedforward_agc_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(feedforward_agc_cc_sptr self)"""
        return _analog_swig.feedforward_agc_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(feedforward_agc_cc_sptr self) -> bool"""
        return _analog_swig.feedforward_agc_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(feedforward_agc_cc_sptr self, int m)"""
        return _analog_swig.feedforward_agc_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(feedforward_agc_cc_sptr self) -> int"""
        return _analog_swig.feedforward_agc_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(feedforward_agc_cc_sptr self, int i) -> long"""
        return _analog_swig.feedforward_agc_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(feedforward_agc_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(feedforward_agc_cc_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.feedforward_agc_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(feedforward_agc_cc_sptr self, int i) -> long"""
        return _analog_swig.feedforward_agc_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(feedforward_agc_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(feedforward_agc_cc_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.feedforward_agc_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(feedforward_agc_cc_sptr self) -> float"""
        return _analog_swig.feedforward_agc_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(feedforward_agc_cc_sptr self) -> float"""
        return _analog_swig.feedforward_agc_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(feedforward_agc_cc_sptr self) -> float"""
        return _analog_swig.feedforward_agc_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(feedforward_agc_cc_sptr self) -> float"""
        return _analog_swig.feedforward_agc_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(feedforward_agc_cc_sptr self) -> float"""
        return _analog_swig.feedforward_agc_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(feedforward_agc_cc_sptr self) -> float"""
        return _analog_swig.feedforward_agc_cc_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(feedforward_agc_cc_sptr self, int which) -> float
        pc_input_buffers_full(feedforward_agc_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.feedforward_agc_cc_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(feedforward_agc_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(feedforward_agc_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.feedforward_agc_cc_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(feedforward_agc_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(feedforward_agc_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.feedforward_agc_cc_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(feedforward_agc_cc_sptr self, int which) -> float
        pc_output_buffers_full(feedforward_agc_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.feedforward_agc_cc_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(feedforward_agc_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(feedforward_agc_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.feedforward_agc_cc_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(feedforward_agc_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(feedforward_agc_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.feedforward_agc_cc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(feedforward_agc_cc_sptr self) -> float"""
        return _analog_swig.feedforward_agc_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(feedforward_agc_cc_sptr self) -> float"""
        return _analog_swig.feedforward_agc_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(feedforward_agc_cc_sptr self) -> float"""
        return _analog_swig.feedforward_agc_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(feedforward_agc_cc_sptr self) -> float"""
        return _analog_swig.feedforward_agc_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(feedforward_agc_cc_sptr self) -> float"""
        return _analog_swig.feedforward_agc_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(feedforward_agc_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.feedforward_agc_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(feedforward_agc_cc_sptr self)"""
        return _analog_swig.feedforward_agc_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(feedforward_agc_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.feedforward_agc_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(feedforward_agc_cc_sptr self) -> int"""
        return _analog_swig.feedforward_agc_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(feedforward_agc_cc_sptr self) -> int"""
        return _analog_swig.feedforward_agc_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(feedforward_agc_cc_sptr self, int priority) -> int"""
        return _analog_swig.feedforward_agc_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(feedforward_agc_cc_sptr self) -> std::string"""
        return _analog_swig.feedforward_agc_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(feedforward_agc_cc_sptr self) -> std::string"""
        return _analog_swig.feedforward_agc_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(feedforward_agc_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.feedforward_agc_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(feedforward_agc_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.feedforward_agc_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(feedforward_agc_cc_sptr self) -> long"""
        return _analog_swig.feedforward_agc_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(feedforward_agc_cc_sptr self) -> basic_block_sptr"""
        return _analog_swig.feedforward_agc_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(feedforward_agc_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.feedforward_agc_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(feedforward_agc_cc_sptr self) -> std::string"""
        return _analog_swig.feedforward_agc_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(feedforward_agc_cc_sptr self, std::string name)"""
        return _analog_swig.feedforward_agc_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(feedforward_agc_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.feedforward_agc_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(feedforward_agc_cc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.feedforward_agc_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(feedforward_agc_cc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.feedforward_agc_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(feedforward_agc_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.feedforward_agc_cc_sptr_message_subscribers(self, which_port)

# Register feedforward_agc_cc_sptr in _analog_swig:
_analog_swig.feedforward_agc_cc_sptr_swigregister(feedforward_agc_cc_sptr)


feedforward_agc_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
feedforward_agc_cc = feedforward_agc_cc.make;

class fmdet_cf_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::fmdet_cf > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(fmdet_cf_sptr self) -> fmdet_cf_sptr
        __init__(fmdet_cf_sptr self, fmdet_cf p) -> fmdet_cf_sptr
        """
        _analog_swig.fmdet_cf_sptr_swiginit(self, _analog_swig.new_fmdet_cf_sptr(*args))

    def __deref__(self) -> "gr::analog::fmdet_cf *":
        r"""__deref__(fmdet_cf_sptr self) -> fmdet_cf"""
        return _analog_swig.fmdet_cf_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_fmdet_cf_sptr

    def make(self, samplerate: "float", freq_low: "float", freq_high: "float", scl: "float") -> "gr::analog::fmdet_cf::sptr":
        r"""make(fmdet_cf_sptr self, float samplerate, float freq_low, float freq_high, float scl) -> fmdet_cf_sptr"""
        return _analog_swig.fmdet_cf_sptr_make(self, samplerate, freq_low, freq_high, scl)

    def set_scale(self, scl: "float") -> "void":
        r"""set_scale(fmdet_cf_sptr self, float scl)"""
        return _analog_swig.fmdet_cf_sptr_set_scale(self, scl)

    def set_freq_range(self, freq_low: "float", freq_high: "float") -> "void":
        r"""set_freq_range(fmdet_cf_sptr self, float freq_low, float freq_high)"""
        return _analog_swig.fmdet_cf_sptr_set_freq_range(self, freq_low, freq_high)

    def freq(self) -> "float":
        r"""freq(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_freq(self)

    def freq_high(self) -> "float":
        r"""freq_high(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_freq_high(self)

    def freq_low(self) -> "float":
        r"""freq_low(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_freq_low(self)

    def scale(self) -> "float":
        r"""scale(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_scale(self)

    def bias(self) -> "float":
        r"""bias(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_bias(self)

    def history(self) -> "unsigned int":
        r"""history(fmdet_cf_sptr self) -> unsigned int"""
        return _analog_swig.fmdet_cf_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(fmdet_cf_sptr self, int which, int delay)
        declare_sample_delay(fmdet_cf_sptr self, unsigned int delay)
        """
        return _analog_swig.fmdet_cf_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(fmdet_cf_sptr self, int which) -> unsigned int"""
        return _analog_swig.fmdet_cf_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(fmdet_cf_sptr self, int multiple)"""
        return _analog_swig.fmdet_cf_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(fmdet_cf_sptr self) -> int"""
        return _analog_swig.fmdet_cf_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(fmdet_cf_sptr self) -> double"""
        return _analog_swig.fmdet_cf_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(fmdet_cf_sptr self) -> uint64_t"""
        return _analog_swig.fmdet_cf_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(fmdet_cf_sptr self) -> uint64_t"""
        return _analog_swig.fmdet_cf_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(fmdet_cf_sptr self) -> bool"""
        return _analog_swig.fmdet_cf_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(fmdet_cf_sptr self) -> bool"""
        return _analog_swig.fmdet_cf_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(fmdet_cf_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.fmdet_cf_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(fmdet_cf_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.fmdet_cf_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(fmdet_cf_sptr self, std::string level)"""
        return _analog_swig.fmdet_cf_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(fmdet_cf_sptr self) -> std::string"""
        return _analog_swig.fmdet_cf_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(fmdet_cf_sptr self) -> int"""
        return _analog_swig.fmdet_cf_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(fmdet_cf_sptr self, int m)"""
        return _analog_swig.fmdet_cf_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(fmdet_cf_sptr self)"""
        return _analog_swig.fmdet_cf_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(fmdet_cf_sptr self) -> bool"""
        return _analog_swig.fmdet_cf_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(fmdet_cf_sptr self, int m)"""
        return _analog_swig.fmdet_cf_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(fmdet_cf_sptr self) -> int"""
        return _analog_swig.fmdet_cf_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(fmdet_cf_sptr self, int i) -> long"""
        return _analog_swig.fmdet_cf_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(fmdet_cf_sptr self, long max_output_buffer)
        set_max_output_buffer(fmdet_cf_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.fmdet_cf_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(fmdet_cf_sptr self, int i) -> long"""
        return _analog_swig.fmdet_cf_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(fmdet_cf_sptr self, long min_output_buffer)
        set_min_output_buffer(fmdet_cf_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.fmdet_cf_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(fmdet_cf_sptr self, int which) -> float
        pc_input_buffers_full(fmdet_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fmdet_cf_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(fmdet_cf_sptr self, int which) -> float
        pc_input_buffers_full_avg(fmdet_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fmdet_cf_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(fmdet_cf_sptr self, int which) -> float
        pc_input_buffers_full_var(fmdet_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fmdet_cf_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(fmdet_cf_sptr self, int which) -> float
        pc_output_buffers_full(fmdet_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fmdet_cf_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(fmdet_cf_sptr self, int which) -> float
        pc_output_buffers_full_avg(fmdet_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fmdet_cf_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(fmdet_cf_sptr self, int which) -> float
        pc_output_buffers_full_var(fmdet_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fmdet_cf_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(fmdet_cf_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.fmdet_cf_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(fmdet_cf_sptr self)"""
        return _analog_swig.fmdet_cf_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(fmdet_cf_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.fmdet_cf_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(fmdet_cf_sptr self) -> int"""
        return _analog_swig.fmdet_cf_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(fmdet_cf_sptr self) -> int"""
        return _analog_swig.fmdet_cf_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(fmdet_cf_sptr self, int priority) -> int"""
        return _analog_swig.fmdet_cf_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(fmdet_cf_sptr self) -> std::string"""
        return _analog_swig.fmdet_cf_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(fmdet_cf_sptr self) -> std::string"""
        return _analog_swig.fmdet_cf_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(fmdet_cf_sptr self) -> io_signature_sptr"""
        return _analog_swig.fmdet_cf_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(fmdet_cf_sptr self) -> io_signature_sptr"""
        return _analog_swig.fmdet_cf_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(fmdet_cf_sptr self) -> long"""
        return _analog_swig.fmdet_cf_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(fmdet_cf_sptr self) -> basic_block_sptr"""
        return _analog_swig.fmdet_cf_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(fmdet_cf_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.fmdet_cf_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(fmdet_cf_sptr self) -> std::string"""
        return _analog_swig.fmdet_cf_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(fmdet_cf_sptr self, std::string name)"""
        return _analog_swig.fmdet_cf_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(fmdet_cf_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.fmdet_cf_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(fmdet_cf_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.fmdet_cf_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(fmdet_cf_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.fmdet_cf_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(fmdet_cf_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.fmdet_cf_sptr_message_subscribers(self, which_port)

# Register fmdet_cf_sptr in _analog_swig:
_analog_swig.fmdet_cf_sptr_swigregister(fmdet_cf_sptr)


fmdet_cf_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
fmdet_cf = fmdet_cf.make;

class frequency_modulator_fc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::frequency_modulator_fc > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(frequency_modulator_fc_sptr self) -> frequency_modulator_fc_sptr
        __init__(frequency_modulator_fc_sptr self, frequency_modulator_fc p) -> frequency_modulator_fc_sptr
        """
        _analog_swig.frequency_modulator_fc_sptr_swiginit(self, _analog_swig.new_frequency_modulator_fc_sptr(*args))

    def __deref__(self) -> "gr::analog::frequency_modulator_fc *":
        r"""__deref__(frequency_modulator_fc_sptr self) -> frequency_modulator_fc"""
        return _analog_swig.frequency_modulator_fc_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_frequency_modulator_fc_sptr

    def make(self, sensitivity: "float") -> "gr::analog::frequency_modulator_fc::sptr":
        r"""make(frequency_modulator_fc_sptr self, float sensitivity) -> frequency_modulator_fc_sptr"""
        return _analog_swig.frequency_modulator_fc_sptr_make(self, sensitivity)

    def set_sensitivity(self, sens: "float") -> "void":
        r"""set_sensitivity(frequency_modulator_fc_sptr self, float sens)"""
        return _analog_swig.frequency_modulator_fc_sptr_set_sensitivity(self, sens)

    def sensitivity(self) -> "float":
        r"""sensitivity(frequency_modulator_fc_sptr self) -> float"""
        return _analog_swig.frequency_modulator_fc_sptr_sensitivity(self)

    def history(self) -> "unsigned int":
        r"""history(frequency_modulator_fc_sptr self) -> unsigned int"""
        return _analog_swig.frequency_modulator_fc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(frequency_modulator_fc_sptr self, int which, int delay)
        declare_sample_delay(frequency_modulator_fc_sptr self, unsigned int delay)
        """
        return _analog_swig.frequency_modulator_fc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(frequency_modulator_fc_sptr self, int which) -> unsigned int"""
        return _analog_swig.frequency_modulator_fc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(frequency_modulator_fc_sptr self, int multiple)"""
        return _analog_swig.frequency_modulator_fc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(frequency_modulator_fc_sptr self) -> int"""
        return _analog_swig.frequency_modulator_fc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(frequency_modulator_fc_sptr self) -> double"""
        return _analog_swig.frequency_modulator_fc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(frequency_modulator_fc_sptr self) -> uint64_t"""
        return _analog_swig.frequency_modulator_fc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(frequency_modulator_fc_sptr self) -> uint64_t"""
        return _analog_swig.frequency_modulator_fc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(frequency_modulator_fc_sptr self) -> bool"""
        return _analog_swig.frequency_modulator_fc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(frequency_modulator_fc_sptr self) -> bool"""
        return _analog_swig.frequency_modulator_fc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(frequency_modulator_fc_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.frequency_modulator_fc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(frequency_modulator_fc_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.frequency_modulator_fc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(frequency_modulator_fc_sptr self, std::string level)"""
        return _analog_swig.frequency_modulator_fc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(frequency_modulator_fc_sptr self) -> std::string"""
        return _analog_swig.frequency_modulator_fc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(frequency_modulator_fc_sptr self) -> int"""
        return _analog_swig.frequency_modulator_fc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(frequency_modulator_fc_sptr self, int m)"""
        return _analog_swig.frequency_modulator_fc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(frequency_modulator_fc_sptr self)"""
        return _analog_swig.frequency_modulator_fc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(frequency_modulator_fc_sptr self) -> bool"""
        return _analog_swig.frequency_modulator_fc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(frequency_modulator_fc_sptr self, int m)"""
        return _analog_swig.frequency_modulator_fc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(frequency_modulator_fc_sptr self) -> int"""
        return _analog_swig.frequency_modulator_fc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(frequency_modulator_fc_sptr self, int i) -> long"""
        return _analog_swig.frequency_modulator_fc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(frequency_modulator_fc_sptr self, long max_output_buffer)
        set_max_output_buffer(frequency_modulator_fc_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.frequency_modulator_fc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(frequency_modulator_fc_sptr self, int i) -> long"""
        return _analog_swig.frequency_modulator_fc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(frequency_modulator_fc_sptr self, long min_output_buffer)
        set_min_output_buffer(frequency_modulator_fc_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.frequency_modulator_fc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(frequency_modulator_fc_sptr self) -> float"""
        return _analog_swig.frequency_modulator_fc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(frequency_modulator_fc_sptr self) -> float"""
        return _analog_swig.frequency_modulator_fc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(frequency_modulator_fc_sptr self) -> float"""
        return _analog_swig.frequency_modulator_fc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(frequency_modulator_fc_sptr self) -> float"""
        return _analog_swig.frequency_modulator_fc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(frequency_modulator_fc_sptr self) -> float"""
        return _analog_swig.frequency_modulator_fc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(frequency_modulator_fc_sptr self) -> float"""
        return _analog_swig.frequency_modulator_fc_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(frequency_modulator_fc_sptr self, int which) -> float
        pc_input_buffers_full(frequency_modulator_fc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.frequency_modulator_fc_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(frequency_modulator_fc_sptr self, int which) -> float
        pc_input_buffers_full_avg(frequency_modulator_fc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.frequency_modulator_fc_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(frequency_modulator_fc_sptr self, int which) -> float
        pc_input_buffers_full_var(frequency_modulator_fc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.frequency_modulator_fc_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(frequency_modulator_fc_sptr self, int which) -> float
        pc_output_buffers_full(frequency_modulator_fc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.frequency_modulator_fc_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(frequency_modulator_fc_sptr self, int which) -> float
        pc_output_buffers_full_avg(frequency_modulator_fc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.frequency_modulator_fc_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(frequency_modulator_fc_sptr self, int which) -> float
        pc_output_buffers_full_var(frequency_modulator_fc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.frequency_modulator_fc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(frequency_modulator_fc_sptr self) -> float"""
        return _analog_swig.frequency_modulator_fc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(frequency_modulator_fc_sptr self) -> float"""
        return _analog_swig.frequency_modulator_fc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(frequency_modulator_fc_sptr self) -> float"""
        return _analog_swig.frequency_modulator_fc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(frequency_modulator_fc_sptr self) -> float"""
        return _analog_swig.frequency_modulator_fc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(frequency_modulator_fc_sptr self) -> float"""
        return _analog_swig.frequency_modulator_fc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(frequency_modulator_fc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.frequency_modulator_fc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(frequency_modulator_fc_sptr self)"""
        return _analog_swig.frequency_modulator_fc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(frequency_modulator_fc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.frequency_modulator_fc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(frequency_modulator_fc_sptr self) -> int"""
        return _analog_swig.frequency_modulator_fc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(frequency_modulator_fc_sptr self) -> int"""
        return _analog_swig.frequency_modulator_fc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(frequency_modulator_fc_sptr self, int priority) -> int"""
        return _analog_swig.frequency_modulator_fc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(frequency_modulator_fc_sptr self) -> std::string"""
        return _analog_swig.frequency_modulator_fc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(frequency_modulator_fc_sptr self) -> std::string"""
        return _analog_swig.frequency_modulator_fc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(frequency_modulator_fc_sptr self) -> io_signature_sptr"""
        return _analog_swig.frequency_modulator_fc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(frequency_modulator_fc_sptr self) -> io_signature_sptr"""
        return _analog_swig.frequency_modulator_fc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(frequency_modulator_fc_sptr self) -> long"""
        return _analog_swig.frequency_modulator_fc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(frequency_modulator_fc_sptr self) -> basic_block_sptr"""
        return _analog_swig.frequency_modulator_fc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(frequency_modulator_fc_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.frequency_modulator_fc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(frequency_modulator_fc_sptr self) -> std::string"""
        return _analog_swig.frequency_modulator_fc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(frequency_modulator_fc_sptr self, std::string name)"""
        return _analog_swig.frequency_modulator_fc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(frequency_modulator_fc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.frequency_modulator_fc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(frequency_modulator_fc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.frequency_modulator_fc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(frequency_modulator_fc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.frequency_modulator_fc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(frequency_modulator_fc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.frequency_modulator_fc_sptr_message_subscribers(self, which_port)

# Register frequency_modulator_fc_sptr in _analog_swig:
_analog_swig.frequency_modulator_fc_sptr_swigregister(frequency_modulator_fc_sptr)


frequency_modulator_fc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
frequency_modulator_fc = frequency_modulator_fc.make;

class fastnoise_source_s(object):
    r"""Proxy of C++ gr::analog::fastnoise_source< std::int16_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(*args, **kwargs) -> "gr::analog::fastnoise_source< short >::sptr":
        r"""make(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024*16) -> fastnoise_source_s_sptr"""
        return _analog_swig.fastnoise_source_s_make(*args, **kwargs)

    def sample(self) -> "std::int16_t":
        r"""sample(fastnoise_source_s self) -> std::int16_t"""
        return _analog_swig.fastnoise_source_s_sample(self)

    def sample_unbiased(self) -> "std::int16_t":
        r"""sample_unbiased(fastnoise_source_s self) -> std::int16_t"""
        return _analog_swig.fastnoise_source_s_sample_unbiased(self)

    def samples(self) -> "std::vector< std::int16_t,std::allocator< std::int16_t > > const &":
        r"""samples(fastnoise_source_s self) -> std::vector< std::int16_t,std::allocator< std::int16_t > > const &"""
        return _analog_swig.fastnoise_source_s_samples(self)

    def set_type(self, type: "gr::analog::noise_type_t") -> "void":
        r"""set_type(fastnoise_source_s self, gr::analog::noise_type_t type)"""
        return _analog_swig.fastnoise_source_s_set_type(self, type)

    def set_amplitude(self, ampl: "float") -> "void":
        r"""set_amplitude(fastnoise_source_s self, float ampl)"""
        return _analog_swig.fastnoise_source_s_set_amplitude(self, ampl)

    def type(self) -> "gr::analog::noise_type_t":
        r"""type(fastnoise_source_s self) -> gr::analog::noise_type_t"""
        return _analog_swig.fastnoise_source_s_type(self)

    def amplitude(self) -> "float":
        r"""amplitude(fastnoise_source_s self) -> float"""
        return _analog_swig.fastnoise_source_s_amplitude(self)
    __swig_destroy__ = _analog_swig.delete_fastnoise_source_s

# Register fastnoise_source_s in _analog_swig:
_analog_swig.fastnoise_source_s_swigregister(fastnoise_source_s)

def fastnoise_source_s_make(*args, **kwargs) -> "gr::analog::fastnoise_source< short >::sptr":
    r"""fastnoise_source_s_make(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024*16) -> fastnoise_source_s_sptr"""
    return _analog_swig.fastnoise_source_s_make(*args, **kwargs)

class fastnoise_source_s_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::fastnoise_source< std::int16_t > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(fastnoise_source_s_sptr self) -> fastnoise_source_s_sptr
        __init__(fastnoise_source_s_sptr self, fastnoise_source_s p) -> fastnoise_source_s_sptr
        """
        _analog_swig.fastnoise_source_s_sptr_swiginit(self, _analog_swig.new_fastnoise_source_s_sptr(*args))

    def __deref__(self) -> "gr::analog::fastnoise_source< std::int16_t > *":
        r"""__deref__(fastnoise_source_s_sptr self) -> fastnoise_source_s"""
        return _analog_swig.fastnoise_source_s_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_fastnoise_source_s_sptr

    def make(self, *args, **kwargs) -> "gr::analog::fastnoise_source< short >::sptr":
        r"""make(fastnoise_source_s_sptr self, gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024*16) -> fastnoise_source_s_sptr"""
        return _analog_swig.fastnoise_source_s_sptr_make(self, *args, **kwargs)

    def sample(self) -> "std::int16_t":
        r"""sample(fastnoise_source_s_sptr self) -> std::int16_t"""
        return _analog_swig.fastnoise_source_s_sptr_sample(self)

    def sample_unbiased(self) -> "std::int16_t":
        r"""sample_unbiased(fastnoise_source_s_sptr self) -> std::int16_t"""
        return _analog_swig.fastnoise_source_s_sptr_sample_unbiased(self)

    def samples(self) -> "std::vector< std::int16_t,std::allocator< std::int16_t > > const &":
        r"""samples(fastnoise_source_s_sptr self) -> std::vector< std::int16_t,std::allocator< std::int16_t > > const &"""
        return _analog_swig.fastnoise_source_s_sptr_samples(self)

    def set_type(self, type: "gr::analog::noise_type_t") -> "void":
        r"""set_type(fastnoise_source_s_sptr self, gr::analog::noise_type_t type)"""
        return _analog_swig.fastnoise_source_s_sptr_set_type(self, type)

    def set_amplitude(self, ampl: "float") -> "void":
        r"""set_amplitude(fastnoise_source_s_sptr self, float ampl)"""
        return _analog_swig.fastnoise_source_s_sptr_set_amplitude(self, ampl)

    def type(self) -> "gr::analog::noise_type_t":
        r"""type(fastnoise_source_s_sptr self) -> gr::analog::noise_type_t"""
        return _analog_swig.fastnoise_source_s_sptr_type(self)

    def amplitude(self) -> "float":
        r"""amplitude(fastnoise_source_s_sptr self) -> float"""
        return _analog_swig.fastnoise_source_s_sptr_amplitude(self)

    def history(self) -> "unsigned int":
        r"""history(fastnoise_source_s_sptr self) -> unsigned int"""
        return _analog_swig.fastnoise_source_s_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(fastnoise_source_s_sptr self, int which, int delay)
        declare_sample_delay(fastnoise_source_s_sptr self, unsigned int delay)
        """
        return _analog_swig.fastnoise_source_s_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(fastnoise_source_s_sptr self, int which) -> unsigned int"""
        return _analog_swig.fastnoise_source_s_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(fastnoise_source_s_sptr self, int multiple)"""
        return _analog_swig.fastnoise_source_s_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(fastnoise_source_s_sptr self) -> int"""
        return _analog_swig.fastnoise_source_s_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(fastnoise_source_s_sptr self) -> double"""
        return _analog_swig.fastnoise_source_s_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(fastnoise_source_s_sptr self) -> uint64_t"""
        return _analog_swig.fastnoise_source_s_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(fastnoise_source_s_sptr self) -> uint64_t"""
        return _analog_swig.fastnoise_source_s_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(fastnoise_source_s_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_s_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(fastnoise_source_s_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_s_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(fastnoise_source_s_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.fastnoise_source_s_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(fastnoise_source_s_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.fastnoise_source_s_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(fastnoise_source_s_sptr self, std::string level)"""
        return _analog_swig.fastnoise_source_s_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(fastnoise_source_s_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_s_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(fastnoise_source_s_sptr self) -> int"""
        return _analog_swig.fastnoise_source_s_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(fastnoise_source_s_sptr self, int m)"""
        return _analog_swig.fastnoise_source_s_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(fastnoise_source_s_sptr self)"""
        return _analog_swig.fastnoise_source_s_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(fastnoise_source_s_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_s_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(fastnoise_source_s_sptr self, int m)"""
        return _analog_swig.fastnoise_source_s_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(fastnoise_source_s_sptr self) -> int"""
        return _analog_swig.fastnoise_source_s_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(fastnoise_source_s_sptr self, int i) -> long"""
        return _analog_swig.fastnoise_source_s_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(fastnoise_source_s_sptr self, long max_output_buffer)
        set_max_output_buffer(fastnoise_source_s_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.fastnoise_source_s_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(fastnoise_source_s_sptr self, int i) -> long"""
        return _analog_swig.fastnoise_source_s_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(fastnoise_source_s_sptr self, long min_output_buffer)
        set_min_output_buffer(fastnoise_source_s_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.fastnoise_source_s_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(fastnoise_source_s_sptr self) -> float"""
        return _analog_swig.fastnoise_source_s_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(fastnoise_source_s_sptr self) -> float"""
        return _analog_swig.fastnoise_source_s_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(fastnoise_source_s_sptr self) -> float"""
        return _analog_swig.fastnoise_source_s_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(fastnoise_source_s_sptr self) -> float"""
        return _analog_swig.fastnoise_source_s_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(fastnoise_source_s_sptr self) -> float"""
        return _analog_swig.fastnoise_source_s_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(fastnoise_source_s_sptr self) -> float"""
        return _analog_swig.fastnoise_source_s_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(fastnoise_source_s_sptr self, int which) -> float
        pc_input_buffers_full(fastnoise_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_s_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(fastnoise_source_s_sptr self, int which) -> float
        pc_input_buffers_full_avg(fastnoise_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_s_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(fastnoise_source_s_sptr self, int which) -> float
        pc_input_buffers_full_var(fastnoise_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_s_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(fastnoise_source_s_sptr self, int which) -> float
        pc_output_buffers_full(fastnoise_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_s_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(fastnoise_source_s_sptr self, int which) -> float
        pc_output_buffers_full_avg(fastnoise_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_s_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(fastnoise_source_s_sptr self, int which) -> float
        pc_output_buffers_full_var(fastnoise_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_s_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(fastnoise_source_s_sptr self) -> float"""
        return _analog_swig.fastnoise_source_s_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(fastnoise_source_s_sptr self) -> float"""
        return _analog_swig.fastnoise_source_s_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(fastnoise_source_s_sptr self) -> float"""
        return _analog_swig.fastnoise_source_s_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(fastnoise_source_s_sptr self) -> float"""
        return _analog_swig.fastnoise_source_s_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(fastnoise_source_s_sptr self) -> float"""
        return _analog_swig.fastnoise_source_s_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(fastnoise_source_s_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.fastnoise_source_s_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(fastnoise_source_s_sptr self)"""
        return _analog_swig.fastnoise_source_s_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(fastnoise_source_s_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.fastnoise_source_s_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(fastnoise_source_s_sptr self) -> int"""
        return _analog_swig.fastnoise_source_s_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(fastnoise_source_s_sptr self) -> int"""
        return _analog_swig.fastnoise_source_s_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(fastnoise_source_s_sptr self, int priority) -> int"""
        return _analog_swig.fastnoise_source_s_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(fastnoise_source_s_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_s_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(fastnoise_source_s_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_s_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(fastnoise_source_s_sptr self) -> io_signature_sptr"""
        return _analog_swig.fastnoise_source_s_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(fastnoise_source_s_sptr self) -> io_signature_sptr"""
        return _analog_swig.fastnoise_source_s_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(fastnoise_source_s_sptr self) -> long"""
        return _analog_swig.fastnoise_source_s_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(fastnoise_source_s_sptr self) -> basic_block_sptr"""
        return _analog_swig.fastnoise_source_s_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(fastnoise_source_s_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.fastnoise_source_s_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(fastnoise_source_s_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_s_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(fastnoise_source_s_sptr self, std::string name)"""
        return _analog_swig.fastnoise_source_s_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(fastnoise_source_s_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.fastnoise_source_s_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(fastnoise_source_s_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.fastnoise_source_s_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(fastnoise_source_s_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.fastnoise_source_s_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(fastnoise_source_s_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.fastnoise_source_s_sptr_message_subscribers(self, which_port)

# Register fastnoise_source_s_sptr in _analog_swig:
_analog_swig.fastnoise_source_s_sptr_swigregister(fastnoise_source_s_sptr)


fastnoise_source_s_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
fastnoise_source_s = fastnoise_source_s.make

class fastnoise_source_i(object):
    r"""Proxy of C++ gr::analog::fastnoise_source< std::int32_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(*args, **kwargs) -> "gr::analog::fastnoise_source< int >::sptr":
        r"""make(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024*16) -> fastnoise_source_i_sptr"""
        return _analog_swig.fastnoise_source_i_make(*args, **kwargs)

    def sample(self) -> "std::int32_t":
        r"""sample(fastnoise_source_i self) -> std::int32_t"""
        return _analog_swig.fastnoise_source_i_sample(self)

    def sample_unbiased(self) -> "std::int32_t":
        r"""sample_unbiased(fastnoise_source_i self) -> std::int32_t"""
        return _analog_swig.fastnoise_source_i_sample_unbiased(self)

    def samples(self) -> "std::vector< std::int32_t,std::allocator< std::int32_t > > const &":
        r"""samples(fastnoise_source_i self) -> std::vector< std::int32_t,std::allocator< std::int32_t > > const &"""
        return _analog_swig.fastnoise_source_i_samples(self)

    def set_type(self, type: "gr::analog::noise_type_t") -> "void":
        r"""set_type(fastnoise_source_i self, gr::analog::noise_type_t type)"""
        return _analog_swig.fastnoise_source_i_set_type(self, type)

    def set_amplitude(self, ampl: "float") -> "void":
        r"""set_amplitude(fastnoise_source_i self, float ampl)"""
        return _analog_swig.fastnoise_source_i_set_amplitude(self, ampl)

    def type(self) -> "gr::analog::noise_type_t":
        r"""type(fastnoise_source_i self) -> gr::analog::noise_type_t"""
        return _analog_swig.fastnoise_source_i_type(self)

    def amplitude(self) -> "float":
        r"""amplitude(fastnoise_source_i self) -> float"""
        return _analog_swig.fastnoise_source_i_amplitude(self)
    __swig_destroy__ = _analog_swig.delete_fastnoise_source_i

# Register fastnoise_source_i in _analog_swig:
_analog_swig.fastnoise_source_i_swigregister(fastnoise_source_i)

def fastnoise_source_i_make(*args, **kwargs) -> "gr::analog::fastnoise_source< int >::sptr":
    r"""fastnoise_source_i_make(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024*16) -> fastnoise_source_i_sptr"""
    return _analog_swig.fastnoise_source_i_make(*args, **kwargs)

class fastnoise_source_i_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::fastnoise_source< std::int32_t > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(fastnoise_source_i_sptr self) -> fastnoise_source_i_sptr
        __init__(fastnoise_source_i_sptr self, fastnoise_source_i p) -> fastnoise_source_i_sptr
        """
        _analog_swig.fastnoise_source_i_sptr_swiginit(self, _analog_swig.new_fastnoise_source_i_sptr(*args))

    def __deref__(self) -> "gr::analog::fastnoise_source< std::int32_t > *":
        r"""__deref__(fastnoise_source_i_sptr self) -> fastnoise_source_i"""
        return _analog_swig.fastnoise_source_i_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_fastnoise_source_i_sptr

    def make(self, *args, **kwargs) -> "gr::analog::fastnoise_source< int >::sptr":
        r"""make(fastnoise_source_i_sptr self, gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024*16) -> fastnoise_source_i_sptr"""
        return _analog_swig.fastnoise_source_i_sptr_make(self, *args, **kwargs)

    def sample(self) -> "std::int32_t":
        r"""sample(fastnoise_source_i_sptr self) -> std::int32_t"""
        return _analog_swig.fastnoise_source_i_sptr_sample(self)

    def sample_unbiased(self) -> "std::int32_t":
        r"""sample_unbiased(fastnoise_source_i_sptr self) -> std::int32_t"""
        return _analog_swig.fastnoise_source_i_sptr_sample_unbiased(self)

    def samples(self) -> "std::vector< std::int32_t,std::allocator< std::int32_t > > const &":
        r"""samples(fastnoise_source_i_sptr self) -> std::vector< std::int32_t,std::allocator< std::int32_t > > const &"""
        return _analog_swig.fastnoise_source_i_sptr_samples(self)

    def set_type(self, type: "gr::analog::noise_type_t") -> "void":
        r"""set_type(fastnoise_source_i_sptr self, gr::analog::noise_type_t type)"""
        return _analog_swig.fastnoise_source_i_sptr_set_type(self, type)

    def set_amplitude(self, ampl: "float") -> "void":
        r"""set_amplitude(fastnoise_source_i_sptr self, float ampl)"""
        return _analog_swig.fastnoise_source_i_sptr_set_amplitude(self, ampl)

    def type(self) -> "gr::analog::noise_type_t":
        r"""type(fastnoise_source_i_sptr self) -> gr::analog::noise_type_t"""
        return _analog_swig.fastnoise_source_i_sptr_type(self)

    def amplitude(self) -> "float":
        r"""amplitude(fastnoise_source_i_sptr self) -> float"""
        return _analog_swig.fastnoise_source_i_sptr_amplitude(self)

    def history(self) -> "unsigned int":
        r"""history(fastnoise_source_i_sptr self) -> unsigned int"""
        return _analog_swig.fastnoise_source_i_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(fastnoise_source_i_sptr self, int which, int delay)
        declare_sample_delay(fastnoise_source_i_sptr self, unsigned int delay)
        """
        return _analog_swig.fastnoise_source_i_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(fastnoise_source_i_sptr self, int which) -> unsigned int"""
        return _analog_swig.fastnoise_source_i_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(fastnoise_source_i_sptr self, int multiple)"""
        return _analog_swig.fastnoise_source_i_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(fastnoise_source_i_sptr self) -> int"""
        return _analog_swig.fastnoise_source_i_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(fastnoise_source_i_sptr self) -> double"""
        return _analog_swig.fastnoise_source_i_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(fastnoise_source_i_sptr self) -> uint64_t"""
        return _analog_swig.fastnoise_source_i_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(fastnoise_source_i_sptr self) -> uint64_t"""
        return _analog_swig.fastnoise_source_i_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(fastnoise_source_i_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_i_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(fastnoise_source_i_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_i_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(fastnoise_source_i_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.fastnoise_source_i_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(fastnoise_source_i_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.fastnoise_source_i_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(fastnoise_source_i_sptr self, std::string level)"""
        return _analog_swig.fastnoise_source_i_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(fastnoise_source_i_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_i_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(fastnoise_source_i_sptr self) -> int"""
        return _analog_swig.fastnoise_source_i_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(fastnoise_source_i_sptr self, int m)"""
        return _analog_swig.fastnoise_source_i_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(fastnoise_source_i_sptr self)"""
        return _analog_swig.fastnoise_source_i_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(fastnoise_source_i_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_i_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(fastnoise_source_i_sptr self, int m)"""
        return _analog_swig.fastnoise_source_i_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(fastnoise_source_i_sptr self) -> int"""
        return _analog_swig.fastnoise_source_i_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(fastnoise_source_i_sptr self, int i) -> long"""
        return _analog_swig.fastnoise_source_i_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(fastnoise_source_i_sptr self, long max_output_buffer)
        set_max_output_buffer(fastnoise_source_i_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.fastnoise_source_i_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(fastnoise_source_i_sptr self, int i) -> long"""
        return _analog_swig.fastnoise_source_i_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(fastnoise_source_i_sptr self, long min_output_buffer)
        set_min_output_buffer(fastnoise_source_i_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.fastnoise_source_i_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(fastnoise_source_i_sptr self) -> float"""
        return _analog_swig.fastnoise_source_i_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(fastnoise_source_i_sptr self) -> float"""
        return _analog_swig.fastnoise_source_i_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(fastnoise_source_i_sptr self) -> float"""
        return _analog_swig.fastnoise_source_i_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(fastnoise_source_i_sptr self) -> float"""
        return _analog_swig.fastnoise_source_i_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(fastnoise_source_i_sptr self) -> float"""
        return _analog_swig.fastnoise_source_i_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(fastnoise_source_i_sptr self) -> float"""
        return _analog_swig.fastnoise_source_i_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(fastnoise_source_i_sptr self, int which) -> float
        pc_input_buffers_full(fastnoise_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_i_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(fastnoise_source_i_sptr self, int which) -> float
        pc_input_buffers_full_avg(fastnoise_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_i_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(fastnoise_source_i_sptr self, int which) -> float
        pc_input_buffers_full_var(fastnoise_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_i_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(fastnoise_source_i_sptr self, int which) -> float
        pc_output_buffers_full(fastnoise_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_i_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(fastnoise_source_i_sptr self, int which) -> float
        pc_output_buffers_full_avg(fastnoise_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_i_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(fastnoise_source_i_sptr self, int which) -> float
        pc_output_buffers_full_var(fastnoise_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_i_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(fastnoise_source_i_sptr self) -> float"""
        return _analog_swig.fastnoise_source_i_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(fastnoise_source_i_sptr self) -> float"""
        return _analog_swig.fastnoise_source_i_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(fastnoise_source_i_sptr self) -> float"""
        return _analog_swig.fastnoise_source_i_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(fastnoise_source_i_sptr self) -> float"""
        return _analog_swig.fastnoise_source_i_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(fastnoise_source_i_sptr self) -> float"""
        return _analog_swig.fastnoise_source_i_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(fastnoise_source_i_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.fastnoise_source_i_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(fastnoise_source_i_sptr self)"""
        return _analog_swig.fastnoise_source_i_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(fastnoise_source_i_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.fastnoise_source_i_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(fastnoise_source_i_sptr self) -> int"""
        return _analog_swig.fastnoise_source_i_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(fastnoise_source_i_sptr self) -> int"""
        return _analog_swig.fastnoise_source_i_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(fastnoise_source_i_sptr self, int priority) -> int"""
        return _analog_swig.fastnoise_source_i_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(fastnoise_source_i_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_i_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(fastnoise_source_i_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_i_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(fastnoise_source_i_sptr self) -> io_signature_sptr"""
        return _analog_swig.fastnoise_source_i_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(fastnoise_source_i_sptr self) -> io_signature_sptr"""
        return _analog_swig.fastnoise_source_i_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(fastnoise_source_i_sptr self) -> long"""
        return _analog_swig.fastnoise_source_i_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(fastnoise_source_i_sptr self) -> basic_block_sptr"""
        return _analog_swig.fastnoise_source_i_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(fastnoise_source_i_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.fastnoise_source_i_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(fastnoise_source_i_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_i_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(fastnoise_source_i_sptr self, std::string name)"""
        return _analog_swig.fastnoise_source_i_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(fastnoise_source_i_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.fastnoise_source_i_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(fastnoise_source_i_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.fastnoise_source_i_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(fastnoise_source_i_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.fastnoise_source_i_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(fastnoise_source_i_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.fastnoise_source_i_sptr_message_subscribers(self, which_port)

# Register fastnoise_source_i_sptr in _analog_swig:
_analog_swig.fastnoise_source_i_sptr_swigregister(fastnoise_source_i_sptr)


fastnoise_source_i_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
fastnoise_source_i = fastnoise_source_i.make

class fastnoise_source_f(object):
    r"""Proxy of C++ gr::analog::fastnoise_source< float > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(*args, **kwargs) -> "gr::analog::fastnoise_source< float >::sptr":
        r"""make(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024*16) -> fastnoise_source_f_sptr"""
        return _analog_swig.fastnoise_source_f_make(*args, **kwargs)

    def sample(self) -> "float":
        r"""sample(fastnoise_source_f self) -> float"""
        return _analog_swig.fastnoise_source_f_sample(self)

    def sample_unbiased(self) -> "float":
        r"""sample_unbiased(fastnoise_source_f self) -> float"""
        return _analog_swig.fastnoise_source_f_sample_unbiased(self)

    def samples(self) -> "std::vector< float,std::allocator< float > > const &":
        r"""samples(fastnoise_source_f self) -> pmt_vector_float"""
        return _analog_swig.fastnoise_source_f_samples(self)

    def set_type(self, type: "gr::analog::noise_type_t") -> "void":
        r"""set_type(fastnoise_source_f self, gr::analog::noise_type_t type)"""
        return _analog_swig.fastnoise_source_f_set_type(self, type)

    def set_amplitude(self, ampl: "float") -> "void":
        r"""set_amplitude(fastnoise_source_f self, float ampl)"""
        return _analog_swig.fastnoise_source_f_set_amplitude(self, ampl)

    def type(self) -> "gr::analog::noise_type_t":
        r"""type(fastnoise_source_f self) -> gr::analog::noise_type_t"""
        return _analog_swig.fastnoise_source_f_type(self)

    def amplitude(self) -> "float":
        r"""amplitude(fastnoise_source_f self) -> float"""
        return _analog_swig.fastnoise_source_f_amplitude(self)
    __swig_destroy__ = _analog_swig.delete_fastnoise_source_f

# Register fastnoise_source_f in _analog_swig:
_analog_swig.fastnoise_source_f_swigregister(fastnoise_source_f)

def fastnoise_source_f_make(*args, **kwargs) -> "gr::analog::fastnoise_source< float >::sptr":
    r"""fastnoise_source_f_make(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024*16) -> fastnoise_source_f_sptr"""
    return _analog_swig.fastnoise_source_f_make(*args, **kwargs)

class fastnoise_source_f_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::fastnoise_source< float > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(fastnoise_source_f_sptr self) -> fastnoise_source_f_sptr
        __init__(fastnoise_source_f_sptr self, fastnoise_source_f p) -> fastnoise_source_f_sptr
        """
        _analog_swig.fastnoise_source_f_sptr_swiginit(self, _analog_swig.new_fastnoise_source_f_sptr(*args))

    def __deref__(self) -> "gr::analog::fastnoise_source< float > *":
        r"""__deref__(fastnoise_source_f_sptr self) -> fastnoise_source_f"""
        return _analog_swig.fastnoise_source_f_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_fastnoise_source_f_sptr

    def make(self, *args, **kwargs) -> "gr::analog::fastnoise_source< float >::sptr":
        r"""make(fastnoise_source_f_sptr self, gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024*16) -> fastnoise_source_f_sptr"""
        return _analog_swig.fastnoise_source_f_sptr_make(self, *args, **kwargs)

    def sample(self) -> "float":
        r"""sample(fastnoise_source_f_sptr self) -> float"""
        return _analog_swig.fastnoise_source_f_sptr_sample(self)

    def sample_unbiased(self) -> "float":
        r"""sample_unbiased(fastnoise_source_f_sptr self) -> float"""
        return _analog_swig.fastnoise_source_f_sptr_sample_unbiased(self)

    def samples(self) -> "std::vector< float,std::allocator< float > > const &":
        r"""samples(fastnoise_source_f_sptr self) -> pmt_vector_float"""
        return _analog_swig.fastnoise_source_f_sptr_samples(self)

    def set_type(self, type: "gr::analog::noise_type_t") -> "void":
        r"""set_type(fastnoise_source_f_sptr self, gr::analog::noise_type_t type)"""
        return _analog_swig.fastnoise_source_f_sptr_set_type(self, type)

    def set_amplitude(self, ampl: "float") -> "void":
        r"""set_amplitude(fastnoise_source_f_sptr self, float ampl)"""
        return _analog_swig.fastnoise_source_f_sptr_set_amplitude(self, ampl)

    def type(self) -> "gr::analog::noise_type_t":
        r"""type(fastnoise_source_f_sptr self) -> gr::analog::noise_type_t"""
        return _analog_swig.fastnoise_source_f_sptr_type(self)

    def amplitude(self) -> "float":
        r"""amplitude(fastnoise_source_f_sptr self) -> float"""
        return _analog_swig.fastnoise_source_f_sptr_amplitude(self)

    def history(self) -> "unsigned int":
        r"""history(fastnoise_source_f_sptr self) -> unsigned int"""
        return _analog_swig.fastnoise_source_f_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(fastnoise_source_f_sptr self, int which, int delay)
        declare_sample_delay(fastnoise_source_f_sptr self, unsigned int delay)
        """
        return _analog_swig.fastnoise_source_f_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(fastnoise_source_f_sptr self, int which) -> unsigned int"""
        return _analog_swig.fastnoise_source_f_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(fastnoise_source_f_sptr self, int multiple)"""
        return _analog_swig.fastnoise_source_f_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(fastnoise_source_f_sptr self) -> int"""
        return _analog_swig.fastnoise_source_f_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(fastnoise_source_f_sptr self) -> double"""
        return _analog_swig.fastnoise_source_f_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(fastnoise_source_f_sptr self) -> uint64_t"""
        return _analog_swig.fastnoise_source_f_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(fastnoise_source_f_sptr self) -> uint64_t"""
        return _analog_swig.fastnoise_source_f_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(fastnoise_source_f_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_f_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(fastnoise_source_f_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_f_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(fastnoise_source_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.fastnoise_source_f_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(fastnoise_source_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.fastnoise_source_f_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(fastnoise_source_f_sptr self, std::string level)"""
        return _analog_swig.fastnoise_source_f_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(fastnoise_source_f_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_f_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(fastnoise_source_f_sptr self) -> int"""
        return _analog_swig.fastnoise_source_f_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(fastnoise_source_f_sptr self, int m)"""
        return _analog_swig.fastnoise_source_f_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(fastnoise_source_f_sptr self)"""
        return _analog_swig.fastnoise_source_f_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(fastnoise_source_f_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_f_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(fastnoise_source_f_sptr self, int m)"""
        return _analog_swig.fastnoise_source_f_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(fastnoise_source_f_sptr self) -> int"""
        return _analog_swig.fastnoise_source_f_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(fastnoise_source_f_sptr self, int i) -> long"""
        return _analog_swig.fastnoise_source_f_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(fastnoise_source_f_sptr self, long max_output_buffer)
        set_max_output_buffer(fastnoise_source_f_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.fastnoise_source_f_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(fastnoise_source_f_sptr self, int i) -> long"""
        return _analog_swig.fastnoise_source_f_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(fastnoise_source_f_sptr self, long min_output_buffer)
        set_min_output_buffer(fastnoise_source_f_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.fastnoise_source_f_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(fastnoise_source_f_sptr self) -> float"""
        return _analog_swig.fastnoise_source_f_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(fastnoise_source_f_sptr self) -> float"""
        return _analog_swig.fastnoise_source_f_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(fastnoise_source_f_sptr self) -> float"""
        return _analog_swig.fastnoise_source_f_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(fastnoise_source_f_sptr self) -> float"""
        return _analog_swig.fastnoise_source_f_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(fastnoise_source_f_sptr self) -> float"""
        return _analog_swig.fastnoise_source_f_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(fastnoise_source_f_sptr self) -> float"""
        return _analog_swig.fastnoise_source_f_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(fastnoise_source_f_sptr self, int which) -> float
        pc_input_buffers_full(fastnoise_source_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_f_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(fastnoise_source_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(fastnoise_source_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_f_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(fastnoise_source_f_sptr self, int which) -> float
        pc_input_buffers_full_var(fastnoise_source_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_f_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(fastnoise_source_f_sptr self, int which) -> float
        pc_output_buffers_full(fastnoise_source_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_f_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(fastnoise_source_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(fastnoise_source_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_f_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(fastnoise_source_f_sptr self, int which) -> float
        pc_output_buffers_full_var(fastnoise_source_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_f_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(fastnoise_source_f_sptr self) -> float"""
        return _analog_swig.fastnoise_source_f_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(fastnoise_source_f_sptr self) -> float"""
        return _analog_swig.fastnoise_source_f_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(fastnoise_source_f_sptr self) -> float"""
        return _analog_swig.fastnoise_source_f_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(fastnoise_source_f_sptr self) -> float"""
        return _analog_swig.fastnoise_source_f_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(fastnoise_source_f_sptr self) -> float"""
        return _analog_swig.fastnoise_source_f_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(fastnoise_source_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.fastnoise_source_f_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(fastnoise_source_f_sptr self)"""
        return _analog_swig.fastnoise_source_f_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(fastnoise_source_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.fastnoise_source_f_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(fastnoise_source_f_sptr self) -> int"""
        return _analog_swig.fastnoise_source_f_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(fastnoise_source_f_sptr self) -> int"""
        return _analog_swig.fastnoise_source_f_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(fastnoise_source_f_sptr self, int priority) -> int"""
        return _analog_swig.fastnoise_source_f_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(fastnoise_source_f_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_f_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(fastnoise_source_f_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_f_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(fastnoise_source_f_sptr self) -> io_signature_sptr"""
        return _analog_swig.fastnoise_source_f_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(fastnoise_source_f_sptr self) -> io_signature_sptr"""
        return _analog_swig.fastnoise_source_f_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(fastnoise_source_f_sptr self) -> long"""
        return _analog_swig.fastnoise_source_f_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(fastnoise_source_f_sptr self) -> basic_block_sptr"""
        return _analog_swig.fastnoise_source_f_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(fastnoise_source_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.fastnoise_source_f_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(fastnoise_source_f_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_f_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(fastnoise_source_f_sptr self, std::string name)"""
        return _analog_swig.fastnoise_source_f_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(fastnoise_source_f_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.fastnoise_source_f_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(fastnoise_source_f_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.fastnoise_source_f_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(fastnoise_source_f_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.fastnoise_source_f_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(fastnoise_source_f_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.fastnoise_source_f_sptr_message_subscribers(self, which_port)

# Register fastnoise_source_f_sptr in _analog_swig:
_analog_swig.fastnoise_source_f_sptr_swigregister(fastnoise_source_f_sptr)


fastnoise_source_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
fastnoise_source_f = fastnoise_source_f.make

class fastnoise_source_c(object):
    r"""Proxy of C++ gr::analog::fastnoise_source< gr_complex > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(*args, **kwargs) -> "gr::analog::fastnoise_source< std::complex< float > >::sptr":
        r"""make(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024*16) -> fastnoise_source_c_sptr"""
        return _analog_swig.fastnoise_source_c_make(*args, **kwargs)

    def sample(self) -> "std::complex< float >":
        r"""sample(fastnoise_source_c self) -> std::complex< float >"""
        return _analog_swig.fastnoise_source_c_sample(self)

    def sample_unbiased(self) -> "std::complex< float >":
        r"""sample_unbiased(fastnoise_source_c self) -> std::complex< float >"""
        return _analog_swig.fastnoise_source_c_sample_unbiased(self)

    def samples(self) -> "std::vector< std::complex< float >,std::allocator< std::complex< float > > > const &":
        r"""samples(fastnoise_source_c self) -> pmt_vector_cfloat"""
        return _analog_swig.fastnoise_source_c_samples(self)

    def set_type(self, type: "gr::analog::noise_type_t") -> "void":
        r"""set_type(fastnoise_source_c self, gr::analog::noise_type_t type)"""
        return _analog_swig.fastnoise_source_c_set_type(self, type)

    def set_amplitude(self, ampl: "float") -> "void":
        r"""set_amplitude(fastnoise_source_c self, float ampl)"""
        return _analog_swig.fastnoise_source_c_set_amplitude(self, ampl)

    def type(self) -> "gr::analog::noise_type_t":
        r"""type(fastnoise_source_c self) -> gr::analog::noise_type_t"""
        return _analog_swig.fastnoise_source_c_type(self)

    def amplitude(self) -> "float":
        r"""amplitude(fastnoise_source_c self) -> float"""
        return _analog_swig.fastnoise_source_c_amplitude(self)
    __swig_destroy__ = _analog_swig.delete_fastnoise_source_c

# Register fastnoise_source_c in _analog_swig:
_analog_swig.fastnoise_source_c_swigregister(fastnoise_source_c)

def fastnoise_source_c_make(*args, **kwargs) -> "gr::analog::fastnoise_source< std::complex< float > >::sptr":
    r"""fastnoise_source_c_make(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024*16) -> fastnoise_source_c_sptr"""
    return _analog_swig.fastnoise_source_c_make(*args, **kwargs)

class fastnoise_source_c_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::fastnoise_source< gr_complex > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(fastnoise_source_c_sptr self) -> fastnoise_source_c_sptr
        __init__(fastnoise_source_c_sptr self, fastnoise_source_c p) -> fastnoise_source_c_sptr
        """
        _analog_swig.fastnoise_source_c_sptr_swiginit(self, _analog_swig.new_fastnoise_source_c_sptr(*args))

    def __deref__(self) -> "gr::analog::fastnoise_source< gr_complex > *":
        r"""__deref__(fastnoise_source_c_sptr self) -> fastnoise_source_c"""
        return _analog_swig.fastnoise_source_c_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_fastnoise_source_c_sptr

    def make(self, *args, **kwargs) -> "gr::analog::fastnoise_source< std::complex< float > >::sptr":
        r"""make(fastnoise_source_c_sptr self, gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024*16) -> fastnoise_source_c_sptr"""
        return _analog_swig.fastnoise_source_c_sptr_make(self, *args, **kwargs)

    def sample(self) -> "std::complex< float >":
        r"""sample(fastnoise_source_c_sptr self) -> std::complex< float >"""
        return _analog_swig.fastnoise_source_c_sptr_sample(self)

    def sample_unbiased(self) -> "std::complex< float >":
        r"""sample_unbiased(fastnoise_source_c_sptr self) -> std::complex< float >"""
        return _analog_swig.fastnoise_source_c_sptr_sample_unbiased(self)

    def samples(self) -> "std::vector< std::complex< float >,std::allocator< std::complex< float > > > const &":
        r"""samples(fastnoise_source_c_sptr self) -> pmt_vector_cfloat"""
        return _analog_swig.fastnoise_source_c_sptr_samples(self)

    def set_type(self, type: "gr::analog::noise_type_t") -> "void":
        r"""set_type(fastnoise_source_c_sptr self, gr::analog::noise_type_t type)"""
        return _analog_swig.fastnoise_source_c_sptr_set_type(self, type)

    def set_amplitude(self, ampl: "float") -> "void":
        r"""set_amplitude(fastnoise_source_c_sptr self, float ampl)"""
        return _analog_swig.fastnoise_source_c_sptr_set_amplitude(self, ampl)

    def type(self) -> "gr::analog::noise_type_t":
        r"""type(fastnoise_source_c_sptr self) -> gr::analog::noise_type_t"""
        return _analog_swig.fastnoise_source_c_sptr_type(self)

    def amplitude(self) -> "float":
        r"""amplitude(fastnoise_source_c_sptr self) -> float"""
        return _analog_swig.fastnoise_source_c_sptr_amplitude(self)

    def history(self) -> "unsigned int":
        r"""history(fastnoise_source_c_sptr self) -> unsigned int"""
        return _analog_swig.fastnoise_source_c_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(fastnoise_source_c_sptr self, int which, int delay)
        declare_sample_delay(fastnoise_source_c_sptr self, unsigned int delay)
        """
        return _analog_swig.fastnoise_source_c_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(fastnoise_source_c_sptr self, int which) -> unsigned int"""
        return _analog_swig.fastnoise_source_c_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(fastnoise_source_c_sptr self, int multiple)"""
        return _analog_swig.fastnoise_source_c_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(fastnoise_source_c_sptr self) -> int"""
        return _analog_swig.fastnoise_source_c_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(fastnoise_source_c_sptr self) -> double"""
        return _analog_swig.fastnoise_source_c_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(fastnoise_source_c_sptr self) -> uint64_t"""
        return _analog_swig.fastnoise_source_c_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(fastnoise_source_c_sptr self) -> uint64_t"""
        return _analog_swig.fastnoise_source_c_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(fastnoise_source_c_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_c_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(fastnoise_source_c_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_c_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(fastnoise_source_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.fastnoise_source_c_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(fastnoise_source_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.fastnoise_source_c_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(fastnoise_source_c_sptr self, std::string level)"""
        return _analog_swig.fastnoise_source_c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(fastnoise_source_c_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_c_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(fastnoise_source_c_sptr self) -> int"""
        return _analog_swig.fastnoise_source_c_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(fastnoise_source_c_sptr self, int m)"""
        return _analog_swig.fastnoise_source_c_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(fastnoise_source_c_sptr self)"""
        return _analog_swig.fastnoise_source_c_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(fastnoise_source_c_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_c_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(fastnoise_source_c_sptr self, int m)"""
        return _analog_swig.fastnoise_source_c_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(fastnoise_source_c_sptr self) -> int"""
        return _analog_swig.fastnoise_source_c_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(fastnoise_source_c_sptr self, int i) -> long"""
        return _analog_swig.fastnoise_source_c_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(fastnoise_source_c_sptr self, long max_output_buffer)
        set_max_output_buffer(fastnoise_source_c_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.fastnoise_source_c_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(fastnoise_source_c_sptr self, int i) -> long"""
        return _analog_swig.fastnoise_source_c_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(fastnoise_source_c_sptr self, long min_output_buffer)
        set_min_output_buffer(fastnoise_source_c_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.fastnoise_source_c_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(fastnoise_source_c_sptr self) -> float"""
        return _analog_swig.fastnoise_source_c_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(fastnoise_source_c_sptr self) -> float"""
        return _analog_swig.fastnoise_source_c_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(fastnoise_source_c_sptr self) -> float"""
        return _analog_swig.fastnoise_source_c_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(fastnoise_source_c_sptr self) -> float"""
        return _analog_swig.fastnoise_source_c_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(fastnoise_source_c_sptr self) -> float"""
        return _analog_swig.fastnoise_source_c_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(fastnoise_source_c_sptr self) -> float"""
        return _analog_swig.fastnoise_source_c_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(fastnoise_source_c_sptr self, int which) -> float
        pc_input_buffers_full(fastnoise_source_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_c_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(fastnoise_source_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(fastnoise_source_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_c_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(fastnoise_source_c_sptr self, int which) -> float
        pc_input_buffers_full_var(fastnoise_source_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_c_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(fastnoise_source_c_sptr self, int which) -> float
        pc_output_buffers_full(fastnoise_source_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_c_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(fastnoise_source_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(fastnoise_source_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_c_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(fastnoise_source_c_sptr self, int which) -> float
        pc_output_buffers_full_var(fastnoise_source_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.fastnoise_source_c_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(fastnoise_source_c_sptr self) -> float"""
        return _analog_swig.fastnoise_source_c_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(fastnoise_source_c_sptr self) -> float"""
        return _analog_swig.fastnoise_source_c_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(fastnoise_source_c_sptr self) -> float"""
        return _analog_swig.fastnoise_source_c_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(fastnoise_source_c_sptr self) -> float"""
        return _analog_swig.fastnoise_source_c_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(fastnoise_source_c_sptr self) -> float"""
        return _analog_swig.fastnoise_source_c_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(fastnoise_source_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.fastnoise_source_c_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(fastnoise_source_c_sptr self)"""
        return _analog_swig.fastnoise_source_c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(fastnoise_source_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.fastnoise_source_c_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(fastnoise_source_c_sptr self) -> int"""
        return _analog_swig.fastnoise_source_c_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(fastnoise_source_c_sptr self) -> int"""
        return _analog_swig.fastnoise_source_c_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(fastnoise_source_c_sptr self, int priority) -> int"""
        return _analog_swig.fastnoise_source_c_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(fastnoise_source_c_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_c_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(fastnoise_source_c_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_c_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(fastnoise_source_c_sptr self) -> io_signature_sptr"""
        return _analog_swig.fastnoise_source_c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(fastnoise_source_c_sptr self) -> io_signature_sptr"""
        return _analog_swig.fastnoise_source_c_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(fastnoise_source_c_sptr self) -> long"""
        return _analog_swig.fastnoise_source_c_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(fastnoise_source_c_sptr self) -> basic_block_sptr"""
        return _analog_swig.fastnoise_source_c_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(fastnoise_source_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.fastnoise_source_c_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(fastnoise_source_c_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(fastnoise_source_c_sptr self, std::string name)"""
        return _analog_swig.fastnoise_source_c_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(fastnoise_source_c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.fastnoise_source_c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(fastnoise_source_c_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.fastnoise_source_c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(fastnoise_source_c_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.fastnoise_source_c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(fastnoise_source_c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.fastnoise_source_c_sptr_message_subscribers(self, which_port)

# Register fastnoise_source_c_sptr in _analog_swig:
_analog_swig.fastnoise_source_c_sptr_swigregister(fastnoise_source_c_sptr)


fastnoise_source_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
fastnoise_source_c = fastnoise_source_c.make

class noise_source_s(object):
    r"""Proxy of C++ gr::analog::noise_source< std::int16_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(type: "gr::analog::noise_type_t", ampl: "float", seed: "long"=0) -> "gr::analog::noise_source< short >::sptr":
        r"""make(gr::analog::noise_type_t type, float ampl, long seed=0) -> noise_source_s_sptr"""
        return _analog_swig.noise_source_s_make(type, ampl, seed)

    def set_type(self, type: "gr::analog::noise_type_t") -> "void":
        r"""set_type(noise_source_s self, gr::analog::noise_type_t type)"""
        return _analog_swig.noise_source_s_set_type(self, type)

    def set_amplitude(self, ampl: "float") -> "void":
        r"""set_amplitude(noise_source_s self, float ampl)"""
        return _analog_swig.noise_source_s_set_amplitude(self, ampl)

    def type(self) -> "gr::analog::noise_type_t":
        r"""type(noise_source_s self) -> gr::analog::noise_type_t"""
        return _analog_swig.noise_source_s_type(self)

    def amplitude(self) -> "float":
        r"""amplitude(noise_source_s self) -> float"""
        return _analog_swig.noise_source_s_amplitude(self)
    __swig_destroy__ = _analog_swig.delete_noise_source_s

# Register noise_source_s in _analog_swig:
_analog_swig.noise_source_s_swigregister(noise_source_s)

def noise_source_s_make(type: "gr::analog::noise_type_t", ampl: "float", seed: "long"=0) -> "gr::analog::noise_source< short >::sptr":
    r"""noise_source_s_make(gr::analog::noise_type_t type, float ampl, long seed=0) -> noise_source_s_sptr"""
    return _analog_swig.noise_source_s_make(type, ampl, seed)

class noise_source_s_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::noise_source< std::int16_t > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(noise_source_s_sptr self) -> noise_source_s_sptr
        __init__(noise_source_s_sptr self, noise_source_s p) -> noise_source_s_sptr
        """
        _analog_swig.noise_source_s_sptr_swiginit(self, _analog_swig.new_noise_source_s_sptr(*args))

    def __deref__(self) -> "gr::analog::noise_source< std::int16_t > *":
        r"""__deref__(noise_source_s_sptr self) -> noise_source_s"""
        return _analog_swig.noise_source_s_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_noise_source_s_sptr

    def make(self, type: "gr::analog::noise_type_t", ampl: "float", seed: "long"=0) -> "gr::analog::noise_source< short >::sptr":
        r"""make(noise_source_s_sptr self, gr::analog::noise_type_t type, float ampl, long seed=0) -> noise_source_s_sptr"""
        return _analog_swig.noise_source_s_sptr_make(self, type, ampl, seed)

    def set_type(self, type: "gr::analog::noise_type_t") -> "void":
        r"""set_type(noise_source_s_sptr self, gr::analog::noise_type_t type)"""
        return _analog_swig.noise_source_s_sptr_set_type(self, type)

    def set_amplitude(self, ampl: "float") -> "void":
        r"""set_amplitude(noise_source_s_sptr self, float ampl)"""
        return _analog_swig.noise_source_s_sptr_set_amplitude(self, ampl)

    def type(self) -> "gr::analog::noise_type_t":
        r"""type(noise_source_s_sptr self) -> gr::analog::noise_type_t"""
        return _analog_swig.noise_source_s_sptr_type(self)

    def amplitude(self) -> "float":
        r"""amplitude(noise_source_s_sptr self) -> float"""
        return _analog_swig.noise_source_s_sptr_amplitude(self)

    def history(self) -> "unsigned int":
        r"""history(noise_source_s_sptr self) -> unsigned int"""
        return _analog_swig.noise_source_s_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(noise_source_s_sptr self, int which, int delay)
        declare_sample_delay(noise_source_s_sptr self, unsigned int delay)
        """
        return _analog_swig.noise_source_s_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(noise_source_s_sptr self, int which) -> unsigned int"""
        return _analog_swig.noise_source_s_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(noise_source_s_sptr self, int multiple)"""
        return _analog_swig.noise_source_s_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(noise_source_s_sptr self) -> int"""
        return _analog_swig.noise_source_s_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(noise_source_s_sptr self) -> double"""
        return _analog_swig.noise_source_s_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(noise_source_s_sptr self) -> uint64_t"""
        return _analog_swig.noise_source_s_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(noise_source_s_sptr self) -> uint64_t"""
        return _analog_swig.noise_source_s_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(noise_source_s_sptr self) -> bool"""
        return _analog_swig.noise_source_s_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(noise_source_s_sptr self) -> bool"""
        return _analog_swig.noise_source_s_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(noise_source_s_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.noise_source_s_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(noise_source_s_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.noise_source_s_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(noise_source_s_sptr self, std::string level)"""
        return _analog_swig.noise_source_s_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(noise_source_s_sptr self) -> std::string"""
        return _analog_swig.noise_source_s_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(noise_source_s_sptr self) -> int"""
        return _analog_swig.noise_source_s_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(noise_source_s_sptr self, int m)"""
        return _analog_swig.noise_source_s_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(noise_source_s_sptr self)"""
        return _analog_swig.noise_source_s_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(noise_source_s_sptr self) -> bool"""
        return _analog_swig.noise_source_s_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(noise_source_s_sptr self, int m)"""
        return _analog_swig.noise_source_s_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(noise_source_s_sptr self) -> int"""
        return _analog_swig.noise_source_s_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(noise_source_s_sptr self, int i) -> long"""
        return _analog_swig.noise_source_s_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(noise_source_s_sptr self, long max_output_buffer)
        set_max_output_buffer(noise_source_s_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.noise_source_s_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(noise_source_s_sptr self, int i) -> long"""
        return _analog_swig.noise_source_s_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(noise_source_s_sptr self, long min_output_buffer)
        set_min_output_buffer(noise_source_s_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.noise_source_s_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(noise_source_s_sptr self) -> float"""
        return _analog_swig.noise_source_s_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(noise_source_s_sptr self) -> float"""
        return _analog_swig.noise_source_s_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(noise_source_s_sptr self) -> float"""
        return _analog_swig.noise_source_s_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(noise_source_s_sptr self) -> float"""
        return _analog_swig.noise_source_s_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(noise_source_s_sptr self) -> float"""
        return _analog_swig.noise_source_s_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(noise_source_s_sptr self) -> float"""
        return _analog_swig.noise_source_s_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(noise_source_s_sptr self, int which) -> float
        pc_input_buffers_full(noise_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_s_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(noise_source_s_sptr self, int which) -> float
        pc_input_buffers_full_avg(noise_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_s_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(noise_source_s_sptr self, int which) -> float
        pc_input_buffers_full_var(noise_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_s_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(noise_source_s_sptr self, int which) -> float
        pc_output_buffers_full(noise_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_s_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(noise_source_s_sptr self, int which) -> float
        pc_output_buffers_full_avg(noise_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_s_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(noise_source_s_sptr self, int which) -> float
        pc_output_buffers_full_var(noise_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_s_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(noise_source_s_sptr self) -> float"""
        return _analog_swig.noise_source_s_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(noise_source_s_sptr self) -> float"""
        return _analog_swig.noise_source_s_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(noise_source_s_sptr self) -> float"""
        return _analog_swig.noise_source_s_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(noise_source_s_sptr self) -> float"""
        return _analog_swig.noise_source_s_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(noise_source_s_sptr self) -> float"""
        return _analog_swig.noise_source_s_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(noise_source_s_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.noise_source_s_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(noise_source_s_sptr self)"""
        return _analog_swig.noise_source_s_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(noise_source_s_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.noise_source_s_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(noise_source_s_sptr self) -> int"""
        return _analog_swig.noise_source_s_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(noise_source_s_sptr self) -> int"""
        return _analog_swig.noise_source_s_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(noise_source_s_sptr self, int priority) -> int"""
        return _analog_swig.noise_source_s_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(noise_source_s_sptr self) -> std::string"""
        return _analog_swig.noise_source_s_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(noise_source_s_sptr self) -> std::string"""
        return _analog_swig.noise_source_s_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(noise_source_s_sptr self) -> io_signature_sptr"""
        return _analog_swig.noise_source_s_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(noise_source_s_sptr self) -> io_signature_sptr"""
        return _analog_swig.noise_source_s_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(noise_source_s_sptr self) -> long"""
        return _analog_swig.noise_source_s_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(noise_source_s_sptr self) -> basic_block_sptr"""
        return _analog_swig.noise_source_s_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(noise_source_s_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.noise_source_s_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(noise_source_s_sptr self) -> std::string"""
        return _analog_swig.noise_source_s_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(noise_source_s_sptr self, std::string name)"""
        return _analog_swig.noise_source_s_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(noise_source_s_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.noise_source_s_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(noise_source_s_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.noise_source_s_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(noise_source_s_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.noise_source_s_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(noise_source_s_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.noise_source_s_sptr_message_subscribers(self, which_port)

# Register noise_source_s_sptr in _analog_swig:
_analog_swig.noise_source_s_sptr_swigregister(noise_source_s_sptr)


noise_source_s_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
noise_source_s = noise_source_s.make

class noise_source_i(object):
    r"""Proxy of C++ gr::analog::noise_source< std::int32_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(type: "gr::analog::noise_type_t", ampl: "float", seed: "long"=0) -> "gr::analog::noise_source< int >::sptr":
        r"""make(gr::analog::noise_type_t type, float ampl, long seed=0) -> noise_source_i_sptr"""
        return _analog_swig.noise_source_i_make(type, ampl, seed)

    def set_type(self, type: "gr::analog::noise_type_t") -> "void":
        r"""set_type(noise_source_i self, gr::analog::noise_type_t type)"""
        return _analog_swig.noise_source_i_set_type(self, type)

    def set_amplitude(self, ampl: "float") -> "void":
        r"""set_amplitude(noise_source_i self, float ampl)"""
        return _analog_swig.noise_source_i_set_amplitude(self, ampl)

    def type(self) -> "gr::analog::noise_type_t":
        r"""type(noise_source_i self) -> gr::analog::noise_type_t"""
        return _analog_swig.noise_source_i_type(self)

    def amplitude(self) -> "float":
        r"""amplitude(noise_source_i self) -> float"""
        return _analog_swig.noise_source_i_amplitude(self)
    __swig_destroy__ = _analog_swig.delete_noise_source_i

# Register noise_source_i in _analog_swig:
_analog_swig.noise_source_i_swigregister(noise_source_i)

def noise_source_i_make(type: "gr::analog::noise_type_t", ampl: "float", seed: "long"=0) -> "gr::analog::noise_source< int >::sptr":
    r"""noise_source_i_make(gr::analog::noise_type_t type, float ampl, long seed=0) -> noise_source_i_sptr"""
    return _analog_swig.noise_source_i_make(type, ampl, seed)

class noise_source_i_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::noise_source< std::int32_t > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(noise_source_i_sptr self) -> noise_source_i_sptr
        __init__(noise_source_i_sptr self, noise_source_i p) -> noise_source_i_sptr
        """
        _analog_swig.noise_source_i_sptr_swiginit(self, _analog_swig.new_noise_source_i_sptr(*args))

    def __deref__(self) -> "gr::analog::noise_source< std::int32_t > *":
        r"""__deref__(noise_source_i_sptr self) -> noise_source_i"""
        return _analog_swig.noise_source_i_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_noise_source_i_sptr

    def make(self, type: "gr::analog::noise_type_t", ampl: "float", seed: "long"=0) -> "gr::analog::noise_source< int >::sptr":
        r"""make(noise_source_i_sptr self, gr::analog::noise_type_t type, float ampl, long seed=0) -> noise_source_i_sptr"""
        return _analog_swig.noise_source_i_sptr_make(self, type, ampl, seed)

    def set_type(self, type: "gr::analog::noise_type_t") -> "void":
        r"""set_type(noise_source_i_sptr self, gr::analog::noise_type_t type)"""
        return _analog_swig.noise_source_i_sptr_set_type(self, type)

    def set_amplitude(self, ampl: "float") -> "void":
        r"""set_amplitude(noise_source_i_sptr self, float ampl)"""
        return _analog_swig.noise_source_i_sptr_set_amplitude(self, ampl)

    def type(self) -> "gr::analog::noise_type_t":
        r"""type(noise_source_i_sptr self) -> gr::analog::noise_type_t"""
        return _analog_swig.noise_source_i_sptr_type(self)

    def amplitude(self) -> "float":
        r"""amplitude(noise_source_i_sptr self) -> float"""
        return _analog_swig.noise_source_i_sptr_amplitude(self)

    def history(self) -> "unsigned int":
        r"""history(noise_source_i_sptr self) -> unsigned int"""
        return _analog_swig.noise_source_i_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(noise_source_i_sptr self, int which, int delay)
        declare_sample_delay(noise_source_i_sptr self, unsigned int delay)
        """
        return _analog_swig.noise_source_i_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(noise_source_i_sptr self, int which) -> unsigned int"""
        return _analog_swig.noise_source_i_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(noise_source_i_sptr self, int multiple)"""
        return _analog_swig.noise_source_i_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(noise_source_i_sptr self) -> int"""
        return _analog_swig.noise_source_i_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(noise_source_i_sptr self) -> double"""
        return _analog_swig.noise_source_i_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(noise_source_i_sptr self) -> uint64_t"""
        return _analog_swig.noise_source_i_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(noise_source_i_sptr self) -> uint64_t"""
        return _analog_swig.noise_source_i_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(noise_source_i_sptr self) -> bool"""
        return _analog_swig.noise_source_i_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(noise_source_i_sptr self) -> bool"""
        return _analog_swig.noise_source_i_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(noise_source_i_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.noise_source_i_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(noise_source_i_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.noise_source_i_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(noise_source_i_sptr self, std::string level)"""
        return _analog_swig.noise_source_i_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(noise_source_i_sptr self) -> std::string"""
        return _analog_swig.noise_source_i_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(noise_source_i_sptr self) -> int"""
        return _analog_swig.noise_source_i_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(noise_source_i_sptr self, int m)"""
        return _analog_swig.noise_source_i_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(noise_source_i_sptr self)"""
        return _analog_swig.noise_source_i_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(noise_source_i_sptr self) -> bool"""
        return _analog_swig.noise_source_i_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(noise_source_i_sptr self, int m)"""
        return _analog_swig.noise_source_i_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(noise_source_i_sptr self) -> int"""
        return _analog_swig.noise_source_i_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(noise_source_i_sptr self, int i) -> long"""
        return _analog_swig.noise_source_i_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(noise_source_i_sptr self, long max_output_buffer)
        set_max_output_buffer(noise_source_i_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.noise_source_i_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(noise_source_i_sptr self, int i) -> long"""
        return _analog_swig.noise_source_i_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(noise_source_i_sptr self, long min_output_buffer)
        set_min_output_buffer(noise_source_i_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.noise_source_i_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(noise_source_i_sptr self) -> float"""
        return _analog_swig.noise_source_i_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(noise_source_i_sptr self) -> float"""
        return _analog_swig.noise_source_i_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(noise_source_i_sptr self) -> float"""
        return _analog_swig.noise_source_i_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(noise_source_i_sptr self) -> float"""
        return _analog_swig.noise_source_i_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(noise_source_i_sptr self) -> float"""
        return _analog_swig.noise_source_i_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(noise_source_i_sptr self) -> float"""
        return _analog_swig.noise_source_i_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(noise_source_i_sptr self, int which) -> float
        pc_input_buffers_full(noise_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_i_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(noise_source_i_sptr self, int which) -> float
        pc_input_buffers_full_avg(noise_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_i_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(noise_source_i_sptr self, int which) -> float
        pc_input_buffers_full_var(noise_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_i_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(noise_source_i_sptr self, int which) -> float
        pc_output_buffers_full(noise_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_i_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(noise_source_i_sptr self, int which) -> float
        pc_output_buffers_full_avg(noise_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_i_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(noise_source_i_sptr self, int which) -> float
        pc_output_buffers_full_var(noise_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_i_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(noise_source_i_sptr self) -> float"""
        return _analog_swig.noise_source_i_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(noise_source_i_sptr self) -> float"""
        return _analog_swig.noise_source_i_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(noise_source_i_sptr self) -> float"""
        return _analog_swig.noise_source_i_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(noise_source_i_sptr self) -> float"""
        return _analog_swig.noise_source_i_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(noise_source_i_sptr self) -> float"""
        return _analog_swig.noise_source_i_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(noise_source_i_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.noise_source_i_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(noise_source_i_sptr self)"""
        return _analog_swig.noise_source_i_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(noise_source_i_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.noise_source_i_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(noise_source_i_sptr self) -> int"""
        return _analog_swig.noise_source_i_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(noise_source_i_sptr self) -> int"""
        return _analog_swig.noise_source_i_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(noise_source_i_sptr self, int priority) -> int"""
        return _analog_swig.noise_source_i_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(noise_source_i_sptr self) -> std::string"""
        return _analog_swig.noise_source_i_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(noise_source_i_sptr self) -> std::string"""
        return _analog_swig.noise_source_i_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(noise_source_i_sptr self) -> io_signature_sptr"""
        return _analog_swig.noise_source_i_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(noise_source_i_sptr self) -> io_signature_sptr"""
        return _analog_swig.noise_source_i_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(noise_source_i_sptr self) -> long"""
        return _analog_swig.noise_source_i_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(noise_source_i_sptr self) -> basic_block_sptr"""
        return _analog_swig.noise_source_i_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(noise_source_i_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.noise_source_i_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(noise_source_i_sptr self) -> std::string"""
        return _analog_swig.noise_source_i_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(noise_source_i_sptr self, std::string name)"""
        return _analog_swig.noise_source_i_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(noise_source_i_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.noise_source_i_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(noise_source_i_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.noise_source_i_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(noise_source_i_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.noise_source_i_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(noise_source_i_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.noise_source_i_sptr_message_subscribers(self, which_port)

# Register noise_source_i_sptr in _analog_swig:
_analog_swig.noise_source_i_sptr_swigregister(noise_source_i_sptr)


noise_source_i_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
noise_source_i = noise_source_i.make

class noise_source_f(object):
    r"""Proxy of C++ gr::analog::noise_source< float > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(type: "gr::analog::noise_type_t", ampl: "float", seed: "long"=0) -> "gr::analog::noise_source< float >::sptr":
        r"""make(gr::analog::noise_type_t type, float ampl, long seed=0) -> noise_source_f_sptr"""
        return _analog_swig.noise_source_f_make(type, ampl, seed)

    def set_type(self, type: "gr::analog::noise_type_t") -> "void":
        r"""set_type(noise_source_f self, gr::analog::noise_type_t type)"""
        return _analog_swig.noise_source_f_set_type(self, type)

    def set_amplitude(self, ampl: "float") -> "void":
        r"""set_amplitude(noise_source_f self, float ampl)"""
        return _analog_swig.noise_source_f_set_amplitude(self, ampl)

    def type(self) -> "gr::analog::noise_type_t":
        r"""type(noise_source_f self) -> gr::analog::noise_type_t"""
        return _analog_swig.noise_source_f_type(self)

    def amplitude(self) -> "float":
        r"""amplitude(noise_source_f self) -> float"""
        return _analog_swig.noise_source_f_amplitude(self)
    __swig_destroy__ = _analog_swig.delete_noise_source_f

# Register noise_source_f in _analog_swig:
_analog_swig.noise_source_f_swigregister(noise_source_f)

def noise_source_f_make(type: "gr::analog::noise_type_t", ampl: "float", seed: "long"=0) -> "gr::analog::noise_source< float >::sptr":
    r"""noise_source_f_make(gr::analog::noise_type_t type, float ampl, long seed=0) -> noise_source_f_sptr"""
    return _analog_swig.noise_source_f_make(type, ampl, seed)

class noise_source_f_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::noise_source< float > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(noise_source_f_sptr self) -> noise_source_f_sptr
        __init__(noise_source_f_sptr self, noise_source_f p) -> noise_source_f_sptr
        """
        _analog_swig.noise_source_f_sptr_swiginit(self, _analog_swig.new_noise_source_f_sptr(*args))

    def __deref__(self) -> "gr::analog::noise_source< float > *":
        r"""__deref__(noise_source_f_sptr self) -> noise_source_f"""
        return _analog_swig.noise_source_f_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_noise_source_f_sptr

    def make(self, type: "gr::analog::noise_type_t", ampl: "float", seed: "long"=0) -> "gr::analog::noise_source< float >::sptr":
        r"""make(noise_source_f_sptr self, gr::analog::noise_type_t type, float ampl, long seed=0) -> noise_source_f_sptr"""
        return _analog_swig.noise_source_f_sptr_make(self, type, ampl, seed)

    def set_type(self, type: "gr::analog::noise_type_t") -> "void":
        r"""set_type(noise_source_f_sptr self, gr::analog::noise_type_t type)"""
        return _analog_swig.noise_source_f_sptr_set_type(self, type)

    def set_amplitude(self, ampl: "float") -> "void":
        r"""set_amplitude(noise_source_f_sptr self, float ampl)"""
        return _analog_swig.noise_source_f_sptr_set_amplitude(self, ampl)

    def type(self) -> "gr::analog::noise_type_t":
        r"""type(noise_source_f_sptr self) -> gr::analog::noise_type_t"""
        return _analog_swig.noise_source_f_sptr_type(self)

    def amplitude(self) -> "float":
        r"""amplitude(noise_source_f_sptr self) -> float"""
        return _analog_swig.noise_source_f_sptr_amplitude(self)

    def history(self) -> "unsigned int":
        r"""history(noise_source_f_sptr self) -> unsigned int"""
        return _analog_swig.noise_source_f_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(noise_source_f_sptr self, int which, int delay)
        declare_sample_delay(noise_source_f_sptr self, unsigned int delay)
        """
        return _analog_swig.noise_source_f_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(noise_source_f_sptr self, int which) -> unsigned int"""
        return _analog_swig.noise_source_f_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(noise_source_f_sptr self, int multiple)"""
        return _analog_swig.noise_source_f_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(noise_source_f_sptr self) -> int"""
        return _analog_swig.noise_source_f_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(noise_source_f_sptr self) -> double"""
        return _analog_swig.noise_source_f_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(noise_source_f_sptr self) -> uint64_t"""
        return _analog_swig.noise_source_f_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(noise_source_f_sptr self) -> uint64_t"""
        return _analog_swig.noise_source_f_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(noise_source_f_sptr self) -> bool"""
        return _analog_swig.noise_source_f_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(noise_source_f_sptr self) -> bool"""
        return _analog_swig.noise_source_f_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(noise_source_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.noise_source_f_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(noise_source_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.noise_source_f_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(noise_source_f_sptr self, std::string level)"""
        return _analog_swig.noise_source_f_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(noise_source_f_sptr self) -> std::string"""
        return _analog_swig.noise_source_f_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(noise_source_f_sptr self) -> int"""
        return _analog_swig.noise_source_f_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(noise_source_f_sptr self, int m)"""
        return _analog_swig.noise_source_f_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(noise_source_f_sptr self)"""
        return _analog_swig.noise_source_f_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(noise_source_f_sptr self) -> bool"""
        return _analog_swig.noise_source_f_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(noise_source_f_sptr self, int m)"""
        return _analog_swig.noise_source_f_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(noise_source_f_sptr self) -> int"""
        return _analog_swig.noise_source_f_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(noise_source_f_sptr self, int i) -> long"""
        return _analog_swig.noise_source_f_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(noise_source_f_sptr self, long max_output_buffer)
        set_max_output_buffer(noise_source_f_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.noise_source_f_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(noise_source_f_sptr self, int i) -> long"""
        return _analog_swig.noise_source_f_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(noise_source_f_sptr self, long min_output_buffer)
        set_min_output_buffer(noise_source_f_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.noise_source_f_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(noise_source_f_sptr self) -> float"""
        return _analog_swig.noise_source_f_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(noise_source_f_sptr self) -> float"""
        return _analog_swig.noise_source_f_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(noise_source_f_sptr self) -> float"""
        return _analog_swig.noise_source_f_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(noise_source_f_sptr self) -> float"""
        return _analog_swig.noise_source_f_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(noise_source_f_sptr self) -> float"""
        return _analog_swig.noise_source_f_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(noise_source_f_sptr self) -> float"""
        return _analog_swig.noise_source_f_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(noise_source_f_sptr self, int which) -> float
        pc_input_buffers_full(noise_source_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_f_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(noise_source_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(noise_source_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_f_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(noise_source_f_sptr self, int which) -> float
        pc_input_buffers_full_var(noise_source_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_f_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(noise_source_f_sptr self, int which) -> float
        pc_output_buffers_full(noise_source_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_f_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(noise_source_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(noise_source_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_f_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(noise_source_f_sptr self, int which) -> float
        pc_output_buffers_full_var(noise_source_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_f_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(noise_source_f_sptr self) -> float"""
        return _analog_swig.noise_source_f_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(noise_source_f_sptr self) -> float"""
        return _analog_swig.noise_source_f_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(noise_source_f_sptr self) -> float"""
        return _analog_swig.noise_source_f_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(noise_source_f_sptr self) -> float"""
        return _analog_swig.noise_source_f_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(noise_source_f_sptr self) -> float"""
        return _analog_swig.noise_source_f_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(noise_source_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.noise_source_f_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(noise_source_f_sptr self)"""
        return _analog_swig.noise_source_f_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(noise_source_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.noise_source_f_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(noise_source_f_sptr self) -> int"""
        return _analog_swig.noise_source_f_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(noise_source_f_sptr self) -> int"""
        return _analog_swig.noise_source_f_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(noise_source_f_sptr self, int priority) -> int"""
        return _analog_swig.noise_source_f_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(noise_source_f_sptr self) -> std::string"""
        return _analog_swig.noise_source_f_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(noise_source_f_sptr self) -> std::string"""
        return _analog_swig.noise_source_f_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(noise_source_f_sptr self) -> io_signature_sptr"""
        return _analog_swig.noise_source_f_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(noise_source_f_sptr self) -> io_signature_sptr"""
        return _analog_swig.noise_source_f_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(noise_source_f_sptr self) -> long"""
        return _analog_swig.noise_source_f_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(noise_source_f_sptr self) -> basic_block_sptr"""
        return _analog_swig.noise_source_f_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(noise_source_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.noise_source_f_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(noise_source_f_sptr self) -> std::string"""
        return _analog_swig.noise_source_f_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(noise_source_f_sptr self, std::string name)"""
        return _analog_swig.noise_source_f_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(noise_source_f_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.noise_source_f_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(noise_source_f_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.noise_source_f_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(noise_source_f_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.noise_source_f_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(noise_source_f_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.noise_source_f_sptr_message_subscribers(self, which_port)

# Register noise_source_f_sptr in _analog_swig:
_analog_swig.noise_source_f_sptr_swigregister(noise_source_f_sptr)


noise_source_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
noise_source_f = noise_source_f.make

class noise_source_c(object):
    r"""Proxy of C++ gr::analog::noise_source< gr_complex > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(type: "gr::analog::noise_type_t", ampl: "float", seed: "long"=0) -> "gr::analog::noise_source< std::complex< float > >::sptr":
        r"""make(gr::analog::noise_type_t type, float ampl, long seed=0) -> noise_source_c_sptr"""
        return _analog_swig.noise_source_c_make(type, ampl, seed)

    def set_type(self, type: "gr::analog::noise_type_t") -> "void":
        r"""set_type(noise_source_c self, gr::analog::noise_type_t type)"""
        return _analog_swig.noise_source_c_set_type(self, type)

    def set_amplitude(self, ampl: "float") -> "void":
        r"""set_amplitude(noise_source_c self, float ampl)"""
        return _analog_swig.noise_source_c_set_amplitude(self, ampl)

    def type(self) -> "gr::analog::noise_type_t":
        r"""type(noise_source_c self) -> gr::analog::noise_type_t"""
        return _analog_swig.noise_source_c_type(self)

    def amplitude(self) -> "float":
        r"""amplitude(noise_source_c self) -> float"""
        return _analog_swig.noise_source_c_amplitude(self)
    __swig_destroy__ = _analog_swig.delete_noise_source_c

# Register noise_source_c in _analog_swig:
_analog_swig.noise_source_c_swigregister(noise_source_c)

def noise_source_c_make(type: "gr::analog::noise_type_t", ampl: "float", seed: "long"=0) -> "gr::analog::noise_source< std::complex< float > >::sptr":
    r"""noise_source_c_make(gr::analog::noise_type_t type, float ampl, long seed=0) -> noise_source_c_sptr"""
    return _analog_swig.noise_source_c_make(type, ampl, seed)

class noise_source_c_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::noise_source< gr_complex > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(noise_source_c_sptr self) -> noise_source_c_sptr
        __init__(noise_source_c_sptr self, noise_source_c p) -> noise_source_c_sptr
        """
        _analog_swig.noise_source_c_sptr_swiginit(self, _analog_swig.new_noise_source_c_sptr(*args))

    def __deref__(self) -> "gr::analog::noise_source< gr_complex > *":
        r"""__deref__(noise_source_c_sptr self) -> noise_source_c"""
        return _analog_swig.noise_source_c_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_noise_source_c_sptr

    def make(self, type: "gr::analog::noise_type_t", ampl: "float", seed: "long"=0) -> "gr::analog::noise_source< std::complex< float > >::sptr":
        r"""make(noise_source_c_sptr self, gr::analog::noise_type_t type, float ampl, long seed=0) -> noise_source_c_sptr"""
        return _analog_swig.noise_source_c_sptr_make(self, type, ampl, seed)

    def set_type(self, type: "gr::analog::noise_type_t") -> "void":
        r"""set_type(noise_source_c_sptr self, gr::analog::noise_type_t type)"""
        return _analog_swig.noise_source_c_sptr_set_type(self, type)

    def set_amplitude(self, ampl: "float") -> "void":
        r"""set_amplitude(noise_source_c_sptr self, float ampl)"""
        return _analog_swig.noise_source_c_sptr_set_amplitude(self, ampl)

    def type(self) -> "gr::analog::noise_type_t":
        r"""type(noise_source_c_sptr self) -> gr::analog::noise_type_t"""
        return _analog_swig.noise_source_c_sptr_type(self)

    def amplitude(self) -> "float":
        r"""amplitude(noise_source_c_sptr self) -> float"""
        return _analog_swig.noise_source_c_sptr_amplitude(self)

    def history(self) -> "unsigned int":
        r"""history(noise_source_c_sptr self) -> unsigned int"""
        return _analog_swig.noise_source_c_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(noise_source_c_sptr self, int which, int delay)
        declare_sample_delay(noise_source_c_sptr self, unsigned int delay)
        """
        return _analog_swig.noise_source_c_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(noise_source_c_sptr self, int which) -> unsigned int"""
        return _analog_swig.noise_source_c_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(noise_source_c_sptr self, int multiple)"""
        return _analog_swig.noise_source_c_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(noise_source_c_sptr self) -> int"""
        return _analog_swig.noise_source_c_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(noise_source_c_sptr self) -> double"""
        return _analog_swig.noise_source_c_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(noise_source_c_sptr self) -> uint64_t"""
        return _analog_swig.noise_source_c_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(noise_source_c_sptr self) -> uint64_t"""
        return _analog_swig.noise_source_c_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(noise_source_c_sptr self) -> bool"""
        return _analog_swig.noise_source_c_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(noise_source_c_sptr self) -> bool"""
        return _analog_swig.noise_source_c_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(noise_source_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.noise_source_c_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(noise_source_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.noise_source_c_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(noise_source_c_sptr self, std::string level)"""
        return _analog_swig.noise_source_c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(noise_source_c_sptr self) -> std::string"""
        return _analog_swig.noise_source_c_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(noise_source_c_sptr self) -> int"""
        return _analog_swig.noise_source_c_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(noise_source_c_sptr self, int m)"""
        return _analog_swig.noise_source_c_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(noise_source_c_sptr self)"""
        return _analog_swig.noise_source_c_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(noise_source_c_sptr self) -> bool"""
        return _analog_swig.noise_source_c_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(noise_source_c_sptr self, int m)"""
        return _analog_swig.noise_source_c_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(noise_source_c_sptr self) -> int"""
        return _analog_swig.noise_source_c_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(noise_source_c_sptr self, int i) -> long"""
        return _analog_swig.noise_source_c_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(noise_source_c_sptr self, long max_output_buffer)
        set_max_output_buffer(noise_source_c_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.noise_source_c_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(noise_source_c_sptr self, int i) -> long"""
        return _analog_swig.noise_source_c_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(noise_source_c_sptr self, long min_output_buffer)
        set_min_output_buffer(noise_source_c_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.noise_source_c_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(noise_source_c_sptr self) -> float"""
        return _analog_swig.noise_source_c_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(noise_source_c_sptr self) -> float"""
        return _analog_swig.noise_source_c_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(noise_source_c_sptr self) -> float"""
        return _analog_swig.noise_source_c_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(noise_source_c_sptr self) -> float"""
        return _analog_swig.noise_source_c_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(noise_source_c_sptr self) -> float"""
        return _analog_swig.noise_source_c_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(noise_source_c_sptr self) -> float"""
        return _analog_swig.noise_source_c_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(noise_source_c_sptr self, int which) -> float
        pc_input_buffers_full(noise_source_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_c_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(noise_source_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(noise_source_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_c_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(noise_source_c_sptr self, int which) -> float
        pc_input_buffers_full_var(noise_source_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_c_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(noise_source_c_sptr self, int which) -> float
        pc_output_buffers_full(noise_source_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_c_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(noise_source_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(noise_source_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_c_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(noise_source_c_sptr self, int which) -> float
        pc_output_buffers_full_var(noise_source_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.noise_source_c_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(noise_source_c_sptr self) -> float"""
        return _analog_swig.noise_source_c_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(noise_source_c_sptr self) -> float"""
        return _analog_swig.noise_source_c_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(noise_source_c_sptr self) -> float"""
        return _analog_swig.noise_source_c_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(noise_source_c_sptr self) -> float"""
        return _analog_swig.noise_source_c_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(noise_source_c_sptr self) -> float"""
        return _analog_swig.noise_source_c_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(noise_source_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.noise_source_c_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(noise_source_c_sptr self)"""
        return _analog_swig.noise_source_c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(noise_source_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.noise_source_c_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(noise_source_c_sptr self) -> int"""
        return _analog_swig.noise_source_c_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(noise_source_c_sptr self) -> int"""
        return _analog_swig.noise_source_c_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(noise_source_c_sptr self, int priority) -> int"""
        return _analog_swig.noise_source_c_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(noise_source_c_sptr self) -> std::string"""
        return _analog_swig.noise_source_c_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(noise_source_c_sptr self) -> std::string"""
        return _analog_swig.noise_source_c_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(noise_source_c_sptr self) -> io_signature_sptr"""
        return _analog_swig.noise_source_c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(noise_source_c_sptr self) -> io_signature_sptr"""
        return _analog_swig.noise_source_c_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(noise_source_c_sptr self) -> long"""
        return _analog_swig.noise_source_c_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(noise_source_c_sptr self) -> basic_block_sptr"""
        return _analog_swig.noise_source_c_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(noise_source_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.noise_source_c_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(noise_source_c_sptr self) -> std::string"""
        return _analog_swig.noise_source_c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(noise_source_c_sptr self, std::string name)"""
        return _analog_swig.noise_source_c_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(noise_source_c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.noise_source_c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(noise_source_c_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.noise_source_c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(noise_source_c_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.noise_source_c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(noise_source_c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.noise_source_c_sptr_message_subscribers(self, which_port)

# Register noise_source_c_sptr in _analog_swig:
_analog_swig.noise_source_c_sptr_swigregister(noise_source_c_sptr)


noise_source_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
noise_source_c = noise_source_c.make

class phase_modulator_fc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::phase_modulator_fc > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(phase_modulator_fc_sptr self) -> phase_modulator_fc_sptr
        __init__(phase_modulator_fc_sptr self, phase_modulator_fc p) -> phase_modulator_fc_sptr
        """
        _analog_swig.phase_modulator_fc_sptr_swiginit(self, _analog_swig.new_phase_modulator_fc_sptr(*args))

    def __deref__(self) -> "gr::analog::phase_modulator_fc *":
        r"""__deref__(phase_modulator_fc_sptr self) -> phase_modulator_fc"""
        return _analog_swig.phase_modulator_fc_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_phase_modulator_fc_sptr

    def make(self, sensitivity: "double") -> "gr::analog::phase_modulator_fc::sptr":
        r"""make(phase_modulator_fc_sptr self, double sensitivity) -> phase_modulator_fc_sptr"""
        return _analog_swig.phase_modulator_fc_sptr_make(self, sensitivity)

    def sensitivity(self) -> "double":
        r"""sensitivity(phase_modulator_fc_sptr self) -> double"""
        return _analog_swig.phase_modulator_fc_sptr_sensitivity(self)

    def phase(self) -> "double":
        r"""phase(phase_modulator_fc_sptr self) -> double"""
        return _analog_swig.phase_modulator_fc_sptr_phase(self)

    def set_sensitivity(self, s: "double") -> "void":
        r"""set_sensitivity(phase_modulator_fc_sptr self, double s)"""
        return _analog_swig.phase_modulator_fc_sptr_set_sensitivity(self, s)

    def set_phase(self, p: "double") -> "void":
        r"""set_phase(phase_modulator_fc_sptr self, double p)"""
        return _analog_swig.phase_modulator_fc_sptr_set_phase(self, p)

    def history(self) -> "unsigned int":
        r"""history(phase_modulator_fc_sptr self) -> unsigned int"""
        return _analog_swig.phase_modulator_fc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(phase_modulator_fc_sptr self, int which, int delay)
        declare_sample_delay(phase_modulator_fc_sptr self, unsigned int delay)
        """
        return _analog_swig.phase_modulator_fc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(phase_modulator_fc_sptr self, int which) -> unsigned int"""
        return _analog_swig.phase_modulator_fc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(phase_modulator_fc_sptr self, int multiple)"""
        return _analog_swig.phase_modulator_fc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(phase_modulator_fc_sptr self) -> int"""
        return _analog_swig.phase_modulator_fc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(phase_modulator_fc_sptr self) -> double"""
        return _analog_swig.phase_modulator_fc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(phase_modulator_fc_sptr self) -> uint64_t"""
        return _analog_swig.phase_modulator_fc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(phase_modulator_fc_sptr self) -> uint64_t"""
        return _analog_swig.phase_modulator_fc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(phase_modulator_fc_sptr self) -> bool"""
        return _analog_swig.phase_modulator_fc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(phase_modulator_fc_sptr self) -> bool"""
        return _analog_swig.phase_modulator_fc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(phase_modulator_fc_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.phase_modulator_fc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(phase_modulator_fc_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.phase_modulator_fc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(phase_modulator_fc_sptr self, std::string level)"""
        return _analog_swig.phase_modulator_fc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(phase_modulator_fc_sptr self) -> std::string"""
        return _analog_swig.phase_modulator_fc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(phase_modulator_fc_sptr self) -> int"""
        return _analog_swig.phase_modulator_fc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(phase_modulator_fc_sptr self, int m)"""
        return _analog_swig.phase_modulator_fc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(phase_modulator_fc_sptr self)"""
        return _analog_swig.phase_modulator_fc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(phase_modulator_fc_sptr self) -> bool"""
        return _analog_swig.phase_modulator_fc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(phase_modulator_fc_sptr self, int m)"""
        return _analog_swig.phase_modulator_fc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(phase_modulator_fc_sptr self) -> int"""
        return _analog_swig.phase_modulator_fc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(phase_modulator_fc_sptr self, int i) -> long"""
        return _analog_swig.phase_modulator_fc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(phase_modulator_fc_sptr self, long max_output_buffer)
        set_max_output_buffer(phase_modulator_fc_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.phase_modulator_fc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(phase_modulator_fc_sptr self, int i) -> long"""
        return _analog_swig.phase_modulator_fc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(phase_modulator_fc_sptr self, long min_output_buffer)
        set_min_output_buffer(phase_modulator_fc_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.phase_modulator_fc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(phase_modulator_fc_sptr self) -> float"""
        return _analog_swig.phase_modulator_fc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(phase_modulator_fc_sptr self) -> float"""
        return _analog_swig.phase_modulator_fc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(phase_modulator_fc_sptr self) -> float"""
        return _analog_swig.phase_modulator_fc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(phase_modulator_fc_sptr self) -> float"""
        return _analog_swig.phase_modulator_fc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(phase_modulator_fc_sptr self) -> float"""
        return _analog_swig.phase_modulator_fc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(phase_modulator_fc_sptr self) -> float"""
        return _analog_swig.phase_modulator_fc_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(phase_modulator_fc_sptr self, int which) -> float
        pc_input_buffers_full(phase_modulator_fc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.phase_modulator_fc_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(phase_modulator_fc_sptr self, int which) -> float
        pc_input_buffers_full_avg(phase_modulator_fc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.phase_modulator_fc_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(phase_modulator_fc_sptr self, int which) -> float
        pc_input_buffers_full_var(phase_modulator_fc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.phase_modulator_fc_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(phase_modulator_fc_sptr self, int which) -> float
        pc_output_buffers_full(phase_modulator_fc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.phase_modulator_fc_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(phase_modulator_fc_sptr self, int which) -> float
        pc_output_buffers_full_avg(phase_modulator_fc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.phase_modulator_fc_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(phase_modulator_fc_sptr self, int which) -> float
        pc_output_buffers_full_var(phase_modulator_fc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.phase_modulator_fc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(phase_modulator_fc_sptr self) -> float"""
        return _analog_swig.phase_modulator_fc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(phase_modulator_fc_sptr self) -> float"""
        return _analog_swig.phase_modulator_fc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(phase_modulator_fc_sptr self) -> float"""
        return _analog_swig.phase_modulator_fc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(phase_modulator_fc_sptr self) -> float"""
        return _analog_swig.phase_modulator_fc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(phase_modulator_fc_sptr self) -> float"""
        return _analog_swig.phase_modulator_fc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(phase_modulator_fc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.phase_modulator_fc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(phase_modulator_fc_sptr self)"""
        return _analog_swig.phase_modulator_fc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(phase_modulator_fc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.phase_modulator_fc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(phase_modulator_fc_sptr self) -> int"""
        return _analog_swig.phase_modulator_fc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(phase_modulator_fc_sptr self) -> int"""
        return _analog_swig.phase_modulator_fc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(phase_modulator_fc_sptr self, int priority) -> int"""
        return _analog_swig.phase_modulator_fc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(phase_modulator_fc_sptr self) -> std::string"""
        return _analog_swig.phase_modulator_fc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(phase_modulator_fc_sptr self) -> std::string"""
        return _analog_swig.phase_modulator_fc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(phase_modulator_fc_sptr self) -> io_signature_sptr"""
        return _analog_swig.phase_modulator_fc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(phase_modulator_fc_sptr self) -> io_signature_sptr"""
        return _analog_swig.phase_modulator_fc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(phase_modulator_fc_sptr self) -> long"""
        return _analog_swig.phase_modulator_fc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(phase_modulator_fc_sptr self) -> basic_block_sptr"""
        return _analog_swig.phase_modulator_fc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(phase_modulator_fc_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.phase_modulator_fc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(phase_modulator_fc_sptr self) -> std::string"""
        return _analog_swig.phase_modulator_fc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(phase_modulator_fc_sptr self, std::string name)"""
        return _analog_swig.phase_modulator_fc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(phase_modulator_fc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.phase_modulator_fc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(phase_modulator_fc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.phase_modulator_fc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(phase_modulator_fc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.phase_modulator_fc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(phase_modulator_fc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.phase_modulator_fc_sptr_message_subscribers(self, which_port)

# Register phase_modulator_fc_sptr in _analog_swig:
_analog_swig.phase_modulator_fc_sptr_swigregister(phase_modulator_fc_sptr)


phase_modulator_fc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
phase_modulator_fc = phase_modulator_fc.make;

class pll_carriertracking_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::pll_carriertracking_cc > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(pll_carriertracking_cc_sptr self) -> pll_carriertracking_cc_sptr
        __init__(pll_carriertracking_cc_sptr self, pll_carriertracking_cc p) -> pll_carriertracking_cc_sptr
        """
        _analog_swig.pll_carriertracking_cc_sptr_swiginit(self, _analog_swig.new_pll_carriertracking_cc_sptr(*args))

    def __deref__(self) -> "gr::analog::pll_carriertracking_cc *":
        r"""__deref__(pll_carriertracking_cc_sptr self) -> pll_carriertracking_cc"""
        return _analog_swig.pll_carriertracking_cc_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_pll_carriertracking_cc_sptr

    def make(self, loop_bw: "float", max_freq: "float", min_freq: "float") -> "gr::analog::pll_carriertracking_cc::sptr":
        r"""make(pll_carriertracking_cc_sptr self, float loop_bw, float max_freq, float min_freq) -> pll_carriertracking_cc_sptr"""
        return _analog_swig.pll_carriertracking_cc_sptr_make(self, loop_bw, max_freq, min_freq)

    def lock_detector(self) -> "bool":
        r"""lock_detector(pll_carriertracking_cc_sptr self) -> bool"""
        return _analog_swig.pll_carriertracking_cc_sptr_lock_detector(self)

    def squelch_enable(self, arg2: "bool") -> "bool":
        r"""squelch_enable(pll_carriertracking_cc_sptr self, bool arg2) -> bool"""
        return _analog_swig.pll_carriertracking_cc_sptr_squelch_enable(self, arg2)

    def set_lock_threshold(self, arg2: "float") -> "float":
        r"""set_lock_threshold(pll_carriertracking_cc_sptr self, float arg2) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_set_lock_threshold(self, arg2)

    def set_damping_factor(self, df: "float") -> "void":
        r"""set_damping_factor(pll_carriertracking_cc_sptr self, float df)"""
        return _analog_swig.pll_carriertracking_cc_sptr_set_damping_factor(self, df)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(pll_carriertracking_cc_sptr self, float alpha)"""
        return _analog_swig.pll_carriertracking_cc_sptr_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(pll_carriertracking_cc_sptr self, float beta)"""
        return _analog_swig.pll_carriertracking_cc_sptr_set_beta(self, beta)

    def set_frequency(self, freq: "float") -> "void":
        r"""set_frequency(pll_carriertracking_cc_sptr self, float freq)"""
        return _analog_swig.pll_carriertracking_cc_sptr_set_frequency(self, freq)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(pll_carriertracking_cc_sptr self, float phase)"""
        return _analog_swig.pll_carriertracking_cc_sptr_set_phase(self, phase)

    def set_min_freq(self, freq: "float") -> "void":
        r"""set_min_freq(pll_carriertracking_cc_sptr self, float freq)"""
        return _analog_swig.pll_carriertracking_cc_sptr_set_min_freq(self, freq)

    def set_max_freq(self, freq: "float") -> "void":
        r"""set_max_freq(pll_carriertracking_cc_sptr self, float freq)"""
        return _analog_swig.pll_carriertracking_cc_sptr_set_max_freq(self, freq)

    def get_loop_bandwidth(self) -> "float":
        r"""get_loop_bandwidth(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_get_loop_bandwidth(self)

    def get_damping_factor(self) -> "float":
        r"""get_damping_factor(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_get_damping_factor(self)

    def get_alpha(self) -> "float":
        r"""get_alpha(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_get_alpha(self)

    def get_beta(self) -> "float":
        r"""get_beta(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_get_beta(self)

    def get_frequency(self) -> "float":
        r"""get_frequency(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_get_frequency(self)

    def get_phase(self) -> "float":
        r"""get_phase(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_get_phase(self)

    def get_min_freq(self) -> "float":
        r"""get_min_freq(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_get_min_freq(self)

    def get_max_freq(self) -> "float":
        r"""get_max_freq(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_get_max_freq(self)

    def history(self) -> "unsigned int":
        r"""history(pll_carriertracking_cc_sptr self) -> unsigned int"""
        return _analog_swig.pll_carriertracking_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(pll_carriertracking_cc_sptr self, int which, int delay)
        declare_sample_delay(pll_carriertracking_cc_sptr self, unsigned int delay)
        """
        return _analog_swig.pll_carriertracking_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(pll_carriertracking_cc_sptr self, int which) -> unsigned int"""
        return _analog_swig.pll_carriertracking_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(pll_carriertracking_cc_sptr self, int multiple)"""
        return _analog_swig.pll_carriertracking_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(pll_carriertracking_cc_sptr self) -> int"""
        return _analog_swig.pll_carriertracking_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(pll_carriertracking_cc_sptr self) -> double"""
        return _analog_swig.pll_carriertracking_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(pll_carriertracking_cc_sptr self) -> uint64_t"""
        return _analog_swig.pll_carriertracking_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(pll_carriertracking_cc_sptr self) -> uint64_t"""
        return _analog_swig.pll_carriertracking_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(pll_carriertracking_cc_sptr self) -> bool"""
        return _analog_swig.pll_carriertracking_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(pll_carriertracking_cc_sptr self) -> bool"""
        return _analog_swig.pll_carriertracking_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(pll_carriertracking_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.pll_carriertracking_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(pll_carriertracking_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.pll_carriertracking_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(pll_carriertracking_cc_sptr self, std::string level)"""
        return _analog_swig.pll_carriertracking_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(pll_carriertracking_cc_sptr self) -> std::string"""
        return _analog_swig.pll_carriertracking_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(pll_carriertracking_cc_sptr self) -> int"""
        return _analog_swig.pll_carriertracking_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(pll_carriertracking_cc_sptr self, int m)"""
        return _analog_swig.pll_carriertracking_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(pll_carriertracking_cc_sptr self)"""
        return _analog_swig.pll_carriertracking_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(pll_carriertracking_cc_sptr self) -> bool"""
        return _analog_swig.pll_carriertracking_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(pll_carriertracking_cc_sptr self, int m)"""
        return _analog_swig.pll_carriertracking_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(pll_carriertracking_cc_sptr self) -> int"""
        return _analog_swig.pll_carriertracking_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(pll_carriertracking_cc_sptr self, int i) -> long"""
        return _analog_swig.pll_carriertracking_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(pll_carriertracking_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(pll_carriertracking_cc_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.pll_carriertracking_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(pll_carriertracking_cc_sptr self, int i) -> long"""
        return _analog_swig.pll_carriertracking_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(pll_carriertracking_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(pll_carriertracking_cc_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.pll_carriertracking_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(pll_carriertracking_cc_sptr self, int which) -> float
        pc_input_buffers_full(pll_carriertracking_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pll_carriertracking_cc_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(pll_carriertracking_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(pll_carriertracking_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pll_carriertracking_cc_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(pll_carriertracking_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(pll_carriertracking_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pll_carriertracking_cc_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(pll_carriertracking_cc_sptr self, int which) -> float
        pc_output_buffers_full(pll_carriertracking_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pll_carriertracking_cc_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(pll_carriertracking_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(pll_carriertracking_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pll_carriertracking_cc_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(pll_carriertracking_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(pll_carriertracking_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pll_carriertracking_cc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(pll_carriertracking_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.pll_carriertracking_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(pll_carriertracking_cc_sptr self)"""
        return _analog_swig.pll_carriertracking_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(pll_carriertracking_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.pll_carriertracking_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(pll_carriertracking_cc_sptr self) -> int"""
        return _analog_swig.pll_carriertracking_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(pll_carriertracking_cc_sptr self) -> int"""
        return _analog_swig.pll_carriertracking_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(pll_carriertracking_cc_sptr self, int priority) -> int"""
        return _analog_swig.pll_carriertracking_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(pll_carriertracking_cc_sptr self) -> std::string"""
        return _analog_swig.pll_carriertracking_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(pll_carriertracking_cc_sptr self) -> std::string"""
        return _analog_swig.pll_carriertracking_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(pll_carriertracking_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.pll_carriertracking_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(pll_carriertracking_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.pll_carriertracking_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(pll_carriertracking_cc_sptr self) -> long"""
        return _analog_swig.pll_carriertracking_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(pll_carriertracking_cc_sptr self) -> basic_block_sptr"""
        return _analog_swig.pll_carriertracking_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(pll_carriertracking_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.pll_carriertracking_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(pll_carriertracking_cc_sptr self) -> std::string"""
        return _analog_swig.pll_carriertracking_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(pll_carriertracking_cc_sptr self, std::string name)"""
        return _analog_swig.pll_carriertracking_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(pll_carriertracking_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.pll_carriertracking_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(pll_carriertracking_cc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.pll_carriertracking_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(pll_carriertracking_cc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.pll_carriertracking_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(pll_carriertracking_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.pll_carriertracking_cc_sptr_message_subscribers(self, which_port)

    def update_gains(self) -> "void":
        r"""update_gains(pll_carriertracking_cc_sptr self)"""
        return _analog_swig.pll_carriertracking_cc_sptr_update_gains(self)

    def advance_loop(self, error: "float") -> "void":
        r"""advance_loop(pll_carriertracking_cc_sptr self, float error)"""
        return _analog_swig.pll_carriertracking_cc_sptr_advance_loop(self, error)

    def phase_wrap(self) -> "void":
        r"""phase_wrap(pll_carriertracking_cc_sptr self)"""
        return _analog_swig.pll_carriertracking_cc_sptr_phase_wrap(self)

    def frequency_limit(self) -> "void":
        r"""frequency_limit(pll_carriertracking_cc_sptr self)"""
        return _analog_swig.pll_carriertracking_cc_sptr_frequency_limit(self)

    def set_loop_bandwidth(self, bw: "float") -> "void":
        r"""set_loop_bandwidth(pll_carriertracking_cc_sptr self, float bw)"""
        return _analog_swig.pll_carriertracking_cc_sptr_set_loop_bandwidth(self, bw)

# Register pll_carriertracking_cc_sptr in _analog_swig:
_analog_swig.pll_carriertracking_cc_sptr_swigregister(pll_carriertracking_cc_sptr)


pll_carriertracking_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
pll_carriertracking_cc = pll_carriertracking_cc.make;

class pll_freqdet_cf_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::pll_freqdet_cf > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(pll_freqdet_cf_sptr self) -> pll_freqdet_cf_sptr
        __init__(pll_freqdet_cf_sptr self, pll_freqdet_cf p) -> pll_freqdet_cf_sptr
        """
        _analog_swig.pll_freqdet_cf_sptr_swiginit(self, _analog_swig.new_pll_freqdet_cf_sptr(*args))

    def __deref__(self) -> "gr::analog::pll_freqdet_cf *":
        r"""__deref__(pll_freqdet_cf_sptr self) -> pll_freqdet_cf"""
        return _analog_swig.pll_freqdet_cf_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_pll_freqdet_cf_sptr

    def make(self, loop_bw: "float", max_freq: "float", min_freq: "float") -> "gr::analog::pll_freqdet_cf::sptr":
        r"""make(pll_freqdet_cf_sptr self, float loop_bw, float max_freq, float min_freq) -> pll_freqdet_cf_sptr"""
        return _analog_swig.pll_freqdet_cf_sptr_make(self, loop_bw, max_freq, min_freq)

    def set_damping_factor(self, df: "float") -> "void":
        r"""set_damping_factor(pll_freqdet_cf_sptr self, float df)"""
        return _analog_swig.pll_freqdet_cf_sptr_set_damping_factor(self, df)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(pll_freqdet_cf_sptr self, float alpha)"""
        return _analog_swig.pll_freqdet_cf_sptr_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(pll_freqdet_cf_sptr self, float beta)"""
        return _analog_swig.pll_freqdet_cf_sptr_set_beta(self, beta)

    def set_frequency(self, freq: "float") -> "void":
        r"""set_frequency(pll_freqdet_cf_sptr self, float freq)"""
        return _analog_swig.pll_freqdet_cf_sptr_set_frequency(self, freq)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(pll_freqdet_cf_sptr self, float phase)"""
        return _analog_swig.pll_freqdet_cf_sptr_set_phase(self, phase)

    def set_min_freq(self, freq: "float") -> "void":
        r"""set_min_freq(pll_freqdet_cf_sptr self, float freq)"""
        return _analog_swig.pll_freqdet_cf_sptr_set_min_freq(self, freq)

    def set_max_freq(self, freq: "float") -> "void":
        r"""set_max_freq(pll_freqdet_cf_sptr self, float freq)"""
        return _analog_swig.pll_freqdet_cf_sptr_set_max_freq(self, freq)

    def get_loop_bandwidth(self) -> "float":
        r"""get_loop_bandwidth(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_get_loop_bandwidth(self)

    def get_damping_factor(self) -> "float":
        r"""get_damping_factor(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_get_damping_factor(self)

    def get_alpha(self) -> "float":
        r"""get_alpha(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_get_alpha(self)

    def get_beta(self) -> "float":
        r"""get_beta(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_get_beta(self)

    def get_frequency(self) -> "float":
        r"""get_frequency(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_get_frequency(self)

    def get_phase(self) -> "float":
        r"""get_phase(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_get_phase(self)

    def get_min_freq(self) -> "float":
        r"""get_min_freq(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_get_min_freq(self)

    def get_max_freq(self) -> "float":
        r"""get_max_freq(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_get_max_freq(self)

    def history(self) -> "unsigned int":
        r"""history(pll_freqdet_cf_sptr self) -> unsigned int"""
        return _analog_swig.pll_freqdet_cf_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(pll_freqdet_cf_sptr self, int which, int delay)
        declare_sample_delay(pll_freqdet_cf_sptr self, unsigned int delay)
        """
        return _analog_swig.pll_freqdet_cf_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(pll_freqdet_cf_sptr self, int which) -> unsigned int"""
        return _analog_swig.pll_freqdet_cf_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(pll_freqdet_cf_sptr self, int multiple)"""
        return _analog_swig.pll_freqdet_cf_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(pll_freqdet_cf_sptr self) -> int"""
        return _analog_swig.pll_freqdet_cf_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(pll_freqdet_cf_sptr self) -> double"""
        return _analog_swig.pll_freqdet_cf_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(pll_freqdet_cf_sptr self) -> uint64_t"""
        return _analog_swig.pll_freqdet_cf_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(pll_freqdet_cf_sptr self) -> uint64_t"""
        return _analog_swig.pll_freqdet_cf_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(pll_freqdet_cf_sptr self) -> bool"""
        return _analog_swig.pll_freqdet_cf_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(pll_freqdet_cf_sptr self) -> bool"""
        return _analog_swig.pll_freqdet_cf_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(pll_freqdet_cf_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.pll_freqdet_cf_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(pll_freqdet_cf_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.pll_freqdet_cf_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(pll_freqdet_cf_sptr self, std::string level)"""
        return _analog_swig.pll_freqdet_cf_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(pll_freqdet_cf_sptr self) -> std::string"""
        return _analog_swig.pll_freqdet_cf_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(pll_freqdet_cf_sptr self) -> int"""
        return _analog_swig.pll_freqdet_cf_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(pll_freqdet_cf_sptr self, int m)"""
        return _analog_swig.pll_freqdet_cf_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(pll_freqdet_cf_sptr self)"""
        return _analog_swig.pll_freqdet_cf_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(pll_freqdet_cf_sptr self) -> bool"""
        return _analog_swig.pll_freqdet_cf_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(pll_freqdet_cf_sptr self, int m)"""
        return _analog_swig.pll_freqdet_cf_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(pll_freqdet_cf_sptr self) -> int"""
        return _analog_swig.pll_freqdet_cf_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(pll_freqdet_cf_sptr self, int i) -> long"""
        return _analog_swig.pll_freqdet_cf_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(pll_freqdet_cf_sptr self, long max_output_buffer)
        set_max_output_buffer(pll_freqdet_cf_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.pll_freqdet_cf_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(pll_freqdet_cf_sptr self, int i) -> long"""
        return _analog_swig.pll_freqdet_cf_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(pll_freqdet_cf_sptr self, long min_output_buffer)
        set_min_output_buffer(pll_freqdet_cf_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.pll_freqdet_cf_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(pll_freqdet_cf_sptr self, int which) -> float
        pc_input_buffers_full(pll_freqdet_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pll_freqdet_cf_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(pll_freqdet_cf_sptr self, int which) -> float
        pc_input_buffers_full_avg(pll_freqdet_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pll_freqdet_cf_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(pll_freqdet_cf_sptr self, int which) -> float
        pc_input_buffers_full_var(pll_freqdet_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pll_freqdet_cf_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(pll_freqdet_cf_sptr self, int which) -> float
        pc_output_buffers_full(pll_freqdet_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pll_freqdet_cf_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(pll_freqdet_cf_sptr self, int which) -> float
        pc_output_buffers_full_avg(pll_freqdet_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pll_freqdet_cf_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(pll_freqdet_cf_sptr self, int which) -> float
        pc_output_buffers_full_var(pll_freqdet_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pll_freqdet_cf_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(pll_freqdet_cf_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.pll_freqdet_cf_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(pll_freqdet_cf_sptr self)"""
        return _analog_swig.pll_freqdet_cf_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(pll_freqdet_cf_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.pll_freqdet_cf_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(pll_freqdet_cf_sptr self) -> int"""
        return _analog_swig.pll_freqdet_cf_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(pll_freqdet_cf_sptr self) -> int"""
        return _analog_swig.pll_freqdet_cf_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(pll_freqdet_cf_sptr self, int priority) -> int"""
        return _analog_swig.pll_freqdet_cf_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(pll_freqdet_cf_sptr self) -> std::string"""
        return _analog_swig.pll_freqdet_cf_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(pll_freqdet_cf_sptr self) -> std::string"""
        return _analog_swig.pll_freqdet_cf_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(pll_freqdet_cf_sptr self) -> io_signature_sptr"""
        return _analog_swig.pll_freqdet_cf_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(pll_freqdet_cf_sptr self) -> io_signature_sptr"""
        return _analog_swig.pll_freqdet_cf_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(pll_freqdet_cf_sptr self) -> long"""
        return _analog_swig.pll_freqdet_cf_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(pll_freqdet_cf_sptr self) -> basic_block_sptr"""
        return _analog_swig.pll_freqdet_cf_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(pll_freqdet_cf_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.pll_freqdet_cf_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(pll_freqdet_cf_sptr self) -> std::string"""
        return _analog_swig.pll_freqdet_cf_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(pll_freqdet_cf_sptr self, std::string name)"""
        return _analog_swig.pll_freqdet_cf_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(pll_freqdet_cf_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.pll_freqdet_cf_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(pll_freqdet_cf_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.pll_freqdet_cf_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(pll_freqdet_cf_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.pll_freqdet_cf_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(pll_freqdet_cf_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.pll_freqdet_cf_sptr_message_subscribers(self, which_port)

    def update_gains(self) -> "void":
        r"""update_gains(pll_freqdet_cf_sptr self)"""
        return _analog_swig.pll_freqdet_cf_sptr_update_gains(self)

    def advance_loop(self, error: "float") -> "void":
        r"""advance_loop(pll_freqdet_cf_sptr self, float error)"""
        return _analog_swig.pll_freqdet_cf_sptr_advance_loop(self, error)

    def phase_wrap(self) -> "void":
        r"""phase_wrap(pll_freqdet_cf_sptr self)"""
        return _analog_swig.pll_freqdet_cf_sptr_phase_wrap(self)

    def frequency_limit(self) -> "void":
        r"""frequency_limit(pll_freqdet_cf_sptr self)"""
        return _analog_swig.pll_freqdet_cf_sptr_frequency_limit(self)

    def set_loop_bandwidth(self, bw: "float") -> "void":
        r"""set_loop_bandwidth(pll_freqdet_cf_sptr self, float bw)"""
        return _analog_swig.pll_freqdet_cf_sptr_set_loop_bandwidth(self, bw)

# Register pll_freqdet_cf_sptr in _analog_swig:
_analog_swig.pll_freqdet_cf_sptr_swigregister(pll_freqdet_cf_sptr)


pll_freqdet_cf_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
pll_freqdet_cf = pll_freqdet_cf.make;

class pll_refout_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::pll_refout_cc > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(pll_refout_cc_sptr self) -> pll_refout_cc_sptr
        __init__(pll_refout_cc_sptr self, pll_refout_cc p) -> pll_refout_cc_sptr
        """
        _analog_swig.pll_refout_cc_sptr_swiginit(self, _analog_swig.new_pll_refout_cc_sptr(*args))

    def __deref__(self) -> "gr::analog::pll_refout_cc *":
        r"""__deref__(pll_refout_cc_sptr self) -> pll_refout_cc"""
        return _analog_swig.pll_refout_cc_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_pll_refout_cc_sptr

    def make(self, loop_bw: "float", max_freq: "float", min_freq: "float") -> "gr::analog::pll_refout_cc::sptr":
        r"""make(pll_refout_cc_sptr self, float loop_bw, float max_freq, float min_freq) -> pll_refout_cc_sptr"""
        return _analog_swig.pll_refout_cc_sptr_make(self, loop_bw, max_freq, min_freq)

    def history(self) -> "unsigned int":
        r"""history(pll_refout_cc_sptr self) -> unsigned int"""
        return _analog_swig.pll_refout_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(pll_refout_cc_sptr self, int which, int delay)
        declare_sample_delay(pll_refout_cc_sptr self, unsigned int delay)
        """
        return _analog_swig.pll_refout_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(pll_refout_cc_sptr self, int which) -> unsigned int"""
        return _analog_swig.pll_refout_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(pll_refout_cc_sptr self, int multiple)"""
        return _analog_swig.pll_refout_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(pll_refout_cc_sptr self) -> int"""
        return _analog_swig.pll_refout_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(pll_refout_cc_sptr self) -> double"""
        return _analog_swig.pll_refout_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(pll_refout_cc_sptr self) -> uint64_t"""
        return _analog_swig.pll_refout_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(pll_refout_cc_sptr self) -> uint64_t"""
        return _analog_swig.pll_refout_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(pll_refout_cc_sptr self) -> bool"""
        return _analog_swig.pll_refout_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(pll_refout_cc_sptr self) -> bool"""
        return _analog_swig.pll_refout_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(pll_refout_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.pll_refout_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(pll_refout_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.pll_refout_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(pll_refout_cc_sptr self, std::string level)"""
        return _analog_swig.pll_refout_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(pll_refout_cc_sptr self) -> std::string"""
        return _analog_swig.pll_refout_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(pll_refout_cc_sptr self) -> int"""
        return _analog_swig.pll_refout_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(pll_refout_cc_sptr self, int m)"""
        return _analog_swig.pll_refout_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(pll_refout_cc_sptr self)"""
        return _analog_swig.pll_refout_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(pll_refout_cc_sptr self) -> bool"""
        return _analog_swig.pll_refout_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(pll_refout_cc_sptr self, int m)"""
        return _analog_swig.pll_refout_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(pll_refout_cc_sptr self) -> int"""
        return _analog_swig.pll_refout_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(pll_refout_cc_sptr self, int i) -> long"""
        return _analog_swig.pll_refout_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(pll_refout_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(pll_refout_cc_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.pll_refout_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(pll_refout_cc_sptr self, int i) -> long"""
        return _analog_swig.pll_refout_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(pll_refout_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(pll_refout_cc_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.pll_refout_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(pll_refout_cc_sptr self, int which) -> float
        pc_input_buffers_full(pll_refout_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pll_refout_cc_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(pll_refout_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(pll_refout_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pll_refout_cc_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(pll_refout_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(pll_refout_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pll_refout_cc_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(pll_refout_cc_sptr self, int which) -> float
        pc_output_buffers_full(pll_refout_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pll_refout_cc_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(pll_refout_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(pll_refout_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pll_refout_cc_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(pll_refout_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(pll_refout_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pll_refout_cc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(pll_refout_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.pll_refout_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(pll_refout_cc_sptr self)"""
        return _analog_swig.pll_refout_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(pll_refout_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.pll_refout_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(pll_refout_cc_sptr self) -> int"""
        return _analog_swig.pll_refout_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(pll_refout_cc_sptr self) -> int"""
        return _analog_swig.pll_refout_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(pll_refout_cc_sptr self, int priority) -> int"""
        return _analog_swig.pll_refout_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(pll_refout_cc_sptr self) -> std::string"""
        return _analog_swig.pll_refout_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(pll_refout_cc_sptr self) -> std::string"""
        return _analog_swig.pll_refout_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(pll_refout_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.pll_refout_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(pll_refout_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.pll_refout_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(pll_refout_cc_sptr self) -> long"""
        return _analog_swig.pll_refout_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(pll_refout_cc_sptr self) -> basic_block_sptr"""
        return _analog_swig.pll_refout_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(pll_refout_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.pll_refout_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(pll_refout_cc_sptr self) -> std::string"""
        return _analog_swig.pll_refout_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(pll_refout_cc_sptr self, std::string name)"""
        return _analog_swig.pll_refout_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(pll_refout_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.pll_refout_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(pll_refout_cc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.pll_refout_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(pll_refout_cc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.pll_refout_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(pll_refout_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.pll_refout_cc_sptr_message_subscribers(self, which_port)

    def update_gains(self) -> "void":
        r"""update_gains(pll_refout_cc_sptr self)"""
        return _analog_swig.pll_refout_cc_sptr_update_gains(self)

    def advance_loop(self, error: "float") -> "void":
        r"""advance_loop(pll_refout_cc_sptr self, float error)"""
        return _analog_swig.pll_refout_cc_sptr_advance_loop(self, error)

    def phase_wrap(self) -> "void":
        r"""phase_wrap(pll_refout_cc_sptr self)"""
        return _analog_swig.pll_refout_cc_sptr_phase_wrap(self)

    def frequency_limit(self) -> "void":
        r"""frequency_limit(pll_refout_cc_sptr self)"""
        return _analog_swig.pll_refout_cc_sptr_frequency_limit(self)

    def set_loop_bandwidth(self, bw: "float") -> "void":
        r"""set_loop_bandwidth(pll_refout_cc_sptr self, float bw)"""
        return _analog_swig.pll_refout_cc_sptr_set_loop_bandwidth(self, bw)

    def set_damping_factor(self, df: "float") -> "void":
        r"""set_damping_factor(pll_refout_cc_sptr self, float df)"""
        return _analog_swig.pll_refout_cc_sptr_set_damping_factor(self, df)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(pll_refout_cc_sptr self, float alpha)"""
        return _analog_swig.pll_refout_cc_sptr_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(pll_refout_cc_sptr self, float beta)"""
        return _analog_swig.pll_refout_cc_sptr_set_beta(self, beta)

    def set_frequency(self, freq: "float") -> "void":
        r"""set_frequency(pll_refout_cc_sptr self, float freq)"""
        return _analog_swig.pll_refout_cc_sptr_set_frequency(self, freq)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(pll_refout_cc_sptr self, float phase)"""
        return _analog_swig.pll_refout_cc_sptr_set_phase(self, phase)

    def set_max_freq(self, freq: "float") -> "void":
        r"""set_max_freq(pll_refout_cc_sptr self, float freq)"""
        return _analog_swig.pll_refout_cc_sptr_set_max_freq(self, freq)

    def set_min_freq(self, freq: "float") -> "void":
        r"""set_min_freq(pll_refout_cc_sptr self, float freq)"""
        return _analog_swig.pll_refout_cc_sptr_set_min_freq(self, freq)

    def get_loop_bandwidth(self) -> "float":
        r"""get_loop_bandwidth(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_get_loop_bandwidth(self)

    def get_damping_factor(self) -> "float":
        r"""get_damping_factor(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_get_damping_factor(self)

    def get_alpha(self) -> "float":
        r"""get_alpha(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_get_alpha(self)

    def get_beta(self) -> "float":
        r"""get_beta(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_get_beta(self)

    def get_frequency(self) -> "float":
        r"""get_frequency(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_get_frequency(self)

    def get_phase(self) -> "float":
        r"""get_phase(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_get_phase(self)

    def get_max_freq(self) -> "float":
        r"""get_max_freq(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_get_max_freq(self)

    def get_min_freq(self) -> "float":
        r"""get_min_freq(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_get_min_freq(self)

# Register pll_refout_cc_sptr in _analog_swig:
_analog_swig.pll_refout_cc_sptr_swigregister(pll_refout_cc_sptr)


pll_refout_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
pll_refout_cc = pll_refout_cc.make;

class probe_avg_mag_sqrd_c_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::probe_avg_mag_sqrd_c > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(probe_avg_mag_sqrd_c_sptr self) -> probe_avg_mag_sqrd_c_sptr
        __init__(probe_avg_mag_sqrd_c_sptr self, probe_avg_mag_sqrd_c p) -> probe_avg_mag_sqrd_c_sptr
        """
        _analog_swig.probe_avg_mag_sqrd_c_sptr_swiginit(self, _analog_swig.new_probe_avg_mag_sqrd_c_sptr(*args))

    def __deref__(self) -> "gr::analog::probe_avg_mag_sqrd_c *":
        r"""__deref__(probe_avg_mag_sqrd_c_sptr self) -> probe_avg_mag_sqrd_c"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_probe_avg_mag_sqrd_c_sptr

    def make(self, threshold_db: "double", alpha: "double"=0.0001) -> "gr::analog::probe_avg_mag_sqrd_c::sptr":
        r"""make(probe_avg_mag_sqrd_c_sptr self, double threshold_db, double alpha=0.0001) -> probe_avg_mag_sqrd_c_sptr"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_make(self, threshold_db, alpha)

    def unmuted(self) -> "bool":
        r"""unmuted(probe_avg_mag_sqrd_c_sptr self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_unmuted(self)

    def level(self) -> "double":
        r"""level(probe_avg_mag_sqrd_c_sptr self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_level(self)

    def threshold(self) -> "double":
        r"""threshold(probe_avg_mag_sqrd_c_sptr self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_threshold(self)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(probe_avg_mag_sqrd_c_sptr self, double alpha)"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_set_alpha(self, alpha)

    def set_threshold(self, decibels: "double") -> "void":
        r"""set_threshold(probe_avg_mag_sqrd_c_sptr self, double decibels)"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_set_threshold(self, decibels)

    def reset(self) -> "void":
        r"""reset(probe_avg_mag_sqrd_c_sptr self)"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_reset(self)

    def history(self) -> "unsigned int":
        r"""history(probe_avg_mag_sqrd_c_sptr self) -> unsigned int"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(probe_avg_mag_sqrd_c_sptr self, int which, int delay)
        declare_sample_delay(probe_avg_mag_sqrd_c_sptr self, unsigned int delay)
        """
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(probe_avg_mag_sqrd_c_sptr self, int which) -> unsigned int"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(probe_avg_mag_sqrd_c_sptr self, int multiple)"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(probe_avg_mag_sqrd_c_sptr self) -> int"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(probe_avg_mag_sqrd_c_sptr self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(probe_avg_mag_sqrd_c_sptr self) -> uint64_t"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(probe_avg_mag_sqrd_c_sptr self) -> uint64_t"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(probe_avg_mag_sqrd_c_sptr self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(probe_avg_mag_sqrd_c_sptr self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(probe_avg_mag_sqrd_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(probe_avg_mag_sqrd_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(probe_avg_mag_sqrd_c_sptr self, std::string level)"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(probe_avg_mag_sqrd_c_sptr self) -> std::string"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(probe_avg_mag_sqrd_c_sptr self) -> int"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(probe_avg_mag_sqrd_c_sptr self, int m)"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(probe_avg_mag_sqrd_c_sptr self)"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(probe_avg_mag_sqrd_c_sptr self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(probe_avg_mag_sqrd_c_sptr self, int m)"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(probe_avg_mag_sqrd_c_sptr self) -> int"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(probe_avg_mag_sqrd_c_sptr self, int i) -> long"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(probe_avg_mag_sqrd_c_sptr self, long max_output_buffer)
        set_max_output_buffer(probe_avg_mag_sqrd_c_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(probe_avg_mag_sqrd_c_sptr self, int i) -> long"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(probe_avg_mag_sqrd_c_sptr self, long min_output_buffer)
        set_min_output_buffer(probe_avg_mag_sqrd_c_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(probe_avg_mag_sqrd_c_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(probe_avg_mag_sqrd_c_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(probe_avg_mag_sqrd_c_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(probe_avg_mag_sqrd_c_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(probe_avg_mag_sqrd_c_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(probe_avg_mag_sqrd_c_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(probe_avg_mag_sqrd_c_sptr self, int which) -> float
        pc_input_buffers_full(probe_avg_mag_sqrd_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(probe_avg_mag_sqrd_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(probe_avg_mag_sqrd_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(probe_avg_mag_sqrd_c_sptr self, int which) -> float
        pc_input_buffers_full_var(probe_avg_mag_sqrd_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(probe_avg_mag_sqrd_c_sptr self, int which) -> float
        pc_output_buffers_full(probe_avg_mag_sqrd_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(probe_avg_mag_sqrd_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(probe_avg_mag_sqrd_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(probe_avg_mag_sqrd_c_sptr self, int which) -> float
        pc_output_buffers_full_var(probe_avg_mag_sqrd_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(probe_avg_mag_sqrd_c_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(probe_avg_mag_sqrd_c_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(probe_avg_mag_sqrd_c_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(probe_avg_mag_sqrd_c_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(probe_avg_mag_sqrd_c_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(probe_avg_mag_sqrd_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(probe_avg_mag_sqrd_c_sptr self)"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(probe_avg_mag_sqrd_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(probe_avg_mag_sqrd_c_sptr self) -> int"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(probe_avg_mag_sqrd_c_sptr self) -> int"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(probe_avg_mag_sqrd_c_sptr self, int priority) -> int"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(probe_avg_mag_sqrd_c_sptr self) -> std::string"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(probe_avg_mag_sqrd_c_sptr self) -> std::string"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(probe_avg_mag_sqrd_c_sptr self) -> io_signature_sptr"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(probe_avg_mag_sqrd_c_sptr self) -> io_signature_sptr"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(probe_avg_mag_sqrd_c_sptr self) -> long"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(probe_avg_mag_sqrd_c_sptr self) -> basic_block_sptr"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(probe_avg_mag_sqrd_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(probe_avg_mag_sqrd_c_sptr self) -> std::string"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(probe_avg_mag_sqrd_c_sptr self, std::string name)"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(probe_avg_mag_sqrd_c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(probe_avg_mag_sqrd_c_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(probe_avg_mag_sqrd_c_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(probe_avg_mag_sqrd_c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_message_subscribers(self, which_port)

# Register probe_avg_mag_sqrd_c_sptr in _analog_swig:
_analog_swig.probe_avg_mag_sqrd_c_sptr_swigregister(probe_avg_mag_sqrd_c_sptr)


probe_avg_mag_sqrd_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
probe_avg_mag_sqrd_c = probe_avg_mag_sqrd_c.make;

class probe_avg_mag_sqrd_cf_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::probe_avg_mag_sqrd_cf > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(probe_avg_mag_sqrd_cf_sptr self) -> probe_avg_mag_sqrd_cf_sptr
        __init__(probe_avg_mag_sqrd_cf_sptr self, probe_avg_mag_sqrd_cf p) -> probe_avg_mag_sqrd_cf_sptr
        """
        _analog_swig.probe_avg_mag_sqrd_cf_sptr_swiginit(self, _analog_swig.new_probe_avg_mag_sqrd_cf_sptr(*args))

    def __deref__(self) -> "gr::analog::probe_avg_mag_sqrd_cf *":
        r"""__deref__(probe_avg_mag_sqrd_cf_sptr self) -> probe_avg_mag_sqrd_cf"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_probe_avg_mag_sqrd_cf_sptr

    def make(self, threshold_db: "double", alpha: "double"=0.0001) -> "gr::analog::probe_avg_mag_sqrd_cf::sptr":
        r"""make(probe_avg_mag_sqrd_cf_sptr self, double threshold_db, double alpha=0.0001) -> probe_avg_mag_sqrd_cf_sptr"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_make(self, threshold_db, alpha)

    def unmuted(self) -> "bool":
        r"""unmuted(probe_avg_mag_sqrd_cf_sptr self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_unmuted(self)

    def level(self) -> "double":
        r"""level(probe_avg_mag_sqrd_cf_sptr self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_level(self)

    def threshold(self) -> "double":
        r"""threshold(probe_avg_mag_sqrd_cf_sptr self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_threshold(self)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(probe_avg_mag_sqrd_cf_sptr self, double alpha)"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_set_alpha(self, alpha)

    def set_threshold(self, decibels: "double") -> "void":
        r"""set_threshold(probe_avg_mag_sqrd_cf_sptr self, double decibels)"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_set_threshold(self, decibels)

    def reset(self) -> "void":
        r"""reset(probe_avg_mag_sqrd_cf_sptr self)"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_reset(self)

    def history(self) -> "unsigned int":
        r"""history(probe_avg_mag_sqrd_cf_sptr self) -> unsigned int"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(probe_avg_mag_sqrd_cf_sptr self, int which, int delay)
        declare_sample_delay(probe_avg_mag_sqrd_cf_sptr self, unsigned int delay)
        """
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(probe_avg_mag_sqrd_cf_sptr self, int which) -> unsigned int"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(probe_avg_mag_sqrd_cf_sptr self, int multiple)"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(probe_avg_mag_sqrd_cf_sptr self) -> int"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(probe_avg_mag_sqrd_cf_sptr self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(probe_avg_mag_sqrd_cf_sptr self) -> uint64_t"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(probe_avg_mag_sqrd_cf_sptr self) -> uint64_t"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(probe_avg_mag_sqrd_cf_sptr self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(probe_avg_mag_sqrd_cf_sptr self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(probe_avg_mag_sqrd_cf_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(probe_avg_mag_sqrd_cf_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(probe_avg_mag_sqrd_cf_sptr self, std::string level)"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(probe_avg_mag_sqrd_cf_sptr self) -> std::string"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(probe_avg_mag_sqrd_cf_sptr self) -> int"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(probe_avg_mag_sqrd_cf_sptr self, int m)"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(probe_avg_mag_sqrd_cf_sptr self)"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(probe_avg_mag_sqrd_cf_sptr self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(probe_avg_mag_sqrd_cf_sptr self, int m)"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(probe_avg_mag_sqrd_cf_sptr self) -> int"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(probe_avg_mag_sqrd_cf_sptr self, int i) -> long"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(probe_avg_mag_sqrd_cf_sptr self, long max_output_buffer)
        set_max_output_buffer(probe_avg_mag_sqrd_cf_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(probe_avg_mag_sqrd_cf_sptr self, int i) -> long"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(probe_avg_mag_sqrd_cf_sptr self, long min_output_buffer)
        set_min_output_buffer(probe_avg_mag_sqrd_cf_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(probe_avg_mag_sqrd_cf_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(probe_avg_mag_sqrd_cf_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(probe_avg_mag_sqrd_cf_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(probe_avg_mag_sqrd_cf_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(probe_avg_mag_sqrd_cf_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(probe_avg_mag_sqrd_cf_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(probe_avg_mag_sqrd_cf_sptr self, int which) -> float
        pc_input_buffers_full(probe_avg_mag_sqrd_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(probe_avg_mag_sqrd_cf_sptr self, int which) -> float
        pc_input_buffers_full_avg(probe_avg_mag_sqrd_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(probe_avg_mag_sqrd_cf_sptr self, int which) -> float
        pc_input_buffers_full_var(probe_avg_mag_sqrd_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(probe_avg_mag_sqrd_cf_sptr self, int which) -> float
        pc_output_buffers_full(probe_avg_mag_sqrd_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(probe_avg_mag_sqrd_cf_sptr self, int which) -> float
        pc_output_buffers_full_avg(probe_avg_mag_sqrd_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(probe_avg_mag_sqrd_cf_sptr self, int which) -> float
        pc_output_buffers_full_var(probe_avg_mag_sqrd_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(probe_avg_mag_sqrd_cf_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(probe_avg_mag_sqrd_cf_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(probe_avg_mag_sqrd_cf_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(probe_avg_mag_sqrd_cf_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(probe_avg_mag_sqrd_cf_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(probe_avg_mag_sqrd_cf_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(probe_avg_mag_sqrd_cf_sptr self)"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(probe_avg_mag_sqrd_cf_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(probe_avg_mag_sqrd_cf_sptr self) -> int"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(probe_avg_mag_sqrd_cf_sptr self) -> int"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(probe_avg_mag_sqrd_cf_sptr self, int priority) -> int"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(probe_avg_mag_sqrd_cf_sptr self) -> std::string"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(probe_avg_mag_sqrd_cf_sptr self) -> std::string"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(probe_avg_mag_sqrd_cf_sptr self) -> io_signature_sptr"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(probe_avg_mag_sqrd_cf_sptr self) -> io_signature_sptr"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(probe_avg_mag_sqrd_cf_sptr self) -> long"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(probe_avg_mag_sqrd_cf_sptr self) -> basic_block_sptr"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(probe_avg_mag_sqrd_cf_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(probe_avg_mag_sqrd_cf_sptr self) -> std::string"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(probe_avg_mag_sqrd_cf_sptr self, std::string name)"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(probe_avg_mag_sqrd_cf_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(probe_avg_mag_sqrd_cf_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(probe_avg_mag_sqrd_cf_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(probe_avg_mag_sqrd_cf_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_message_subscribers(self, which_port)

# Register probe_avg_mag_sqrd_cf_sptr in _analog_swig:
_analog_swig.probe_avg_mag_sqrd_cf_sptr_swigregister(probe_avg_mag_sqrd_cf_sptr)


probe_avg_mag_sqrd_cf_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
probe_avg_mag_sqrd_cf = probe_avg_mag_sqrd_cf.make;

class probe_avg_mag_sqrd_f_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::probe_avg_mag_sqrd_f > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(probe_avg_mag_sqrd_f_sptr self) -> probe_avg_mag_sqrd_f_sptr
        __init__(probe_avg_mag_sqrd_f_sptr self, probe_avg_mag_sqrd_f p) -> probe_avg_mag_sqrd_f_sptr
        """
        _analog_swig.probe_avg_mag_sqrd_f_sptr_swiginit(self, _analog_swig.new_probe_avg_mag_sqrd_f_sptr(*args))

    def __deref__(self) -> "gr::analog::probe_avg_mag_sqrd_f *":
        r"""__deref__(probe_avg_mag_sqrd_f_sptr self) -> probe_avg_mag_sqrd_f"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_probe_avg_mag_sqrd_f_sptr

    def make(self, threshold_db: "double", alpha: "double"=0.0001) -> "gr::analog::probe_avg_mag_sqrd_f::sptr":
        r"""make(probe_avg_mag_sqrd_f_sptr self, double threshold_db, double alpha=0.0001) -> probe_avg_mag_sqrd_f_sptr"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_make(self, threshold_db, alpha)

    def unmuted(self) -> "bool":
        r"""unmuted(probe_avg_mag_sqrd_f_sptr self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_unmuted(self)

    def level(self) -> "double":
        r"""level(probe_avg_mag_sqrd_f_sptr self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_level(self)

    def threshold(self) -> "double":
        r"""threshold(probe_avg_mag_sqrd_f_sptr self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_threshold(self)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(probe_avg_mag_sqrd_f_sptr self, double alpha)"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_set_alpha(self, alpha)

    def set_threshold(self, decibels: "double") -> "void":
        r"""set_threshold(probe_avg_mag_sqrd_f_sptr self, double decibels)"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_set_threshold(self, decibels)

    def reset(self) -> "void":
        r"""reset(probe_avg_mag_sqrd_f_sptr self)"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_reset(self)

    def history(self) -> "unsigned int":
        r"""history(probe_avg_mag_sqrd_f_sptr self) -> unsigned int"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(probe_avg_mag_sqrd_f_sptr self, int which, int delay)
        declare_sample_delay(probe_avg_mag_sqrd_f_sptr self, unsigned int delay)
        """
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(probe_avg_mag_sqrd_f_sptr self, int which) -> unsigned int"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(probe_avg_mag_sqrd_f_sptr self, int multiple)"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(probe_avg_mag_sqrd_f_sptr self) -> int"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(probe_avg_mag_sqrd_f_sptr self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(probe_avg_mag_sqrd_f_sptr self) -> uint64_t"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(probe_avg_mag_sqrd_f_sptr self) -> uint64_t"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(probe_avg_mag_sqrd_f_sptr self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(probe_avg_mag_sqrd_f_sptr self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(probe_avg_mag_sqrd_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(probe_avg_mag_sqrd_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(probe_avg_mag_sqrd_f_sptr self, std::string level)"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(probe_avg_mag_sqrd_f_sptr self) -> std::string"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(probe_avg_mag_sqrd_f_sptr self) -> int"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(probe_avg_mag_sqrd_f_sptr self, int m)"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(probe_avg_mag_sqrd_f_sptr self)"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(probe_avg_mag_sqrd_f_sptr self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(probe_avg_mag_sqrd_f_sptr self, int m)"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(probe_avg_mag_sqrd_f_sptr self) -> int"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(probe_avg_mag_sqrd_f_sptr self, int i) -> long"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(probe_avg_mag_sqrd_f_sptr self, long max_output_buffer)
        set_max_output_buffer(probe_avg_mag_sqrd_f_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(probe_avg_mag_sqrd_f_sptr self, int i) -> long"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(probe_avg_mag_sqrd_f_sptr self, long min_output_buffer)
        set_min_output_buffer(probe_avg_mag_sqrd_f_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(probe_avg_mag_sqrd_f_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(probe_avg_mag_sqrd_f_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(probe_avg_mag_sqrd_f_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(probe_avg_mag_sqrd_f_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(probe_avg_mag_sqrd_f_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(probe_avg_mag_sqrd_f_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(probe_avg_mag_sqrd_f_sptr self, int which) -> float
        pc_input_buffers_full(probe_avg_mag_sqrd_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(probe_avg_mag_sqrd_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(probe_avg_mag_sqrd_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(probe_avg_mag_sqrd_f_sptr self, int which) -> float
        pc_input_buffers_full_var(probe_avg_mag_sqrd_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(probe_avg_mag_sqrd_f_sptr self, int which) -> float
        pc_output_buffers_full(probe_avg_mag_sqrd_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(probe_avg_mag_sqrd_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(probe_avg_mag_sqrd_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(probe_avg_mag_sqrd_f_sptr self, int which) -> float
        pc_output_buffers_full_var(probe_avg_mag_sqrd_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(probe_avg_mag_sqrd_f_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(probe_avg_mag_sqrd_f_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(probe_avg_mag_sqrd_f_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(probe_avg_mag_sqrd_f_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(probe_avg_mag_sqrd_f_sptr self) -> float"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(probe_avg_mag_sqrd_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(probe_avg_mag_sqrd_f_sptr self)"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(probe_avg_mag_sqrd_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(probe_avg_mag_sqrd_f_sptr self) -> int"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(probe_avg_mag_sqrd_f_sptr self) -> int"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(probe_avg_mag_sqrd_f_sptr self, int priority) -> int"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(probe_avg_mag_sqrd_f_sptr self) -> std::string"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(probe_avg_mag_sqrd_f_sptr self) -> std::string"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(probe_avg_mag_sqrd_f_sptr self) -> io_signature_sptr"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(probe_avg_mag_sqrd_f_sptr self) -> io_signature_sptr"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(probe_avg_mag_sqrd_f_sptr self) -> long"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(probe_avg_mag_sqrd_f_sptr self) -> basic_block_sptr"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(probe_avg_mag_sqrd_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(probe_avg_mag_sqrd_f_sptr self) -> std::string"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(probe_avg_mag_sqrd_f_sptr self, std::string name)"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(probe_avg_mag_sqrd_f_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(probe_avg_mag_sqrd_f_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(probe_avg_mag_sqrd_f_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(probe_avg_mag_sqrd_f_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_message_subscribers(self, which_port)

# Register probe_avg_mag_sqrd_f_sptr in _analog_swig:
_analog_swig.probe_avg_mag_sqrd_f_sptr_swigregister(probe_avg_mag_sqrd_f_sptr)


probe_avg_mag_sqrd_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
probe_avg_mag_sqrd_f = probe_avg_mag_sqrd_f.make;

class pwr_squelch_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::pwr_squelch_cc > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(pwr_squelch_cc_sptr self) -> pwr_squelch_cc_sptr
        __init__(pwr_squelch_cc_sptr self, pwr_squelch_cc p) -> pwr_squelch_cc_sptr
        """
        _analog_swig.pwr_squelch_cc_sptr_swiginit(self, _analog_swig.new_pwr_squelch_cc_sptr(*args))

    def __deref__(self) -> "gr::analog::pwr_squelch_cc *":
        r"""__deref__(pwr_squelch_cc_sptr self) -> pwr_squelch_cc"""
        return _analog_swig.pwr_squelch_cc_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_pwr_squelch_cc_sptr

    def make(self, db: "double", alpha: "double"=0.0001, ramp: "int"=0, gate: "bool"=False) -> "gr::analog::pwr_squelch_cc::sptr":
        r"""make(pwr_squelch_cc_sptr self, double db, double alpha=0.0001, int ramp=0, bool gate=False) -> pwr_squelch_cc_sptr"""
        return _analog_swig.pwr_squelch_cc_sptr_make(self, db, alpha, ramp, gate)

    def squelch_range(self) -> "std::vector< float,std::allocator< float > >":
        r"""squelch_range(pwr_squelch_cc_sptr self) -> pmt_vector_float"""
        return _analog_swig.pwr_squelch_cc_sptr_squelch_range(self)

    def threshold(self) -> "double":
        r"""threshold(pwr_squelch_cc_sptr self) -> double"""
        return _analog_swig.pwr_squelch_cc_sptr_threshold(self)

    def set_threshold(self, db: "double") -> "void":
        r"""set_threshold(pwr_squelch_cc_sptr self, double db)"""
        return _analog_swig.pwr_squelch_cc_sptr_set_threshold(self, db)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(pwr_squelch_cc_sptr self, double alpha)"""
        return _analog_swig.pwr_squelch_cc_sptr_set_alpha(self, alpha)

    def ramp(self) -> "int":
        r"""ramp(pwr_squelch_cc_sptr self) -> int"""
        return _analog_swig.pwr_squelch_cc_sptr_ramp(self)

    def set_ramp(self, ramp: "int") -> "void":
        r"""set_ramp(pwr_squelch_cc_sptr self, int ramp)"""
        return _analog_swig.pwr_squelch_cc_sptr_set_ramp(self, ramp)

    def gate(self) -> "bool":
        r"""gate(pwr_squelch_cc_sptr self) -> bool"""
        return _analog_swig.pwr_squelch_cc_sptr_gate(self)

    def set_gate(self, gate: "bool") -> "void":
        r"""set_gate(pwr_squelch_cc_sptr self, bool gate)"""
        return _analog_swig.pwr_squelch_cc_sptr_set_gate(self, gate)

    def unmuted(self) -> "bool":
        r"""unmuted(pwr_squelch_cc_sptr self) -> bool"""
        return _analog_swig.pwr_squelch_cc_sptr_unmuted(self)

    def history(self) -> "unsigned int":
        r"""history(pwr_squelch_cc_sptr self) -> unsigned int"""
        return _analog_swig.pwr_squelch_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(pwr_squelch_cc_sptr self, int which, int delay)
        declare_sample_delay(pwr_squelch_cc_sptr self, unsigned int delay)
        """
        return _analog_swig.pwr_squelch_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(pwr_squelch_cc_sptr self, int which) -> unsigned int"""
        return _analog_swig.pwr_squelch_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(pwr_squelch_cc_sptr self, int multiple)"""
        return _analog_swig.pwr_squelch_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(pwr_squelch_cc_sptr self) -> int"""
        return _analog_swig.pwr_squelch_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(pwr_squelch_cc_sptr self) -> double"""
        return _analog_swig.pwr_squelch_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(pwr_squelch_cc_sptr self) -> uint64_t"""
        return _analog_swig.pwr_squelch_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(pwr_squelch_cc_sptr self) -> uint64_t"""
        return _analog_swig.pwr_squelch_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(pwr_squelch_cc_sptr self) -> bool"""
        return _analog_swig.pwr_squelch_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(pwr_squelch_cc_sptr self) -> bool"""
        return _analog_swig.pwr_squelch_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(pwr_squelch_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.pwr_squelch_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(pwr_squelch_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.pwr_squelch_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(pwr_squelch_cc_sptr self, std::string level)"""
        return _analog_swig.pwr_squelch_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(pwr_squelch_cc_sptr self) -> std::string"""
        return _analog_swig.pwr_squelch_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(pwr_squelch_cc_sptr self) -> int"""
        return _analog_swig.pwr_squelch_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(pwr_squelch_cc_sptr self, int m)"""
        return _analog_swig.pwr_squelch_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(pwr_squelch_cc_sptr self)"""
        return _analog_swig.pwr_squelch_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(pwr_squelch_cc_sptr self) -> bool"""
        return _analog_swig.pwr_squelch_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(pwr_squelch_cc_sptr self, int m)"""
        return _analog_swig.pwr_squelch_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(pwr_squelch_cc_sptr self) -> int"""
        return _analog_swig.pwr_squelch_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(pwr_squelch_cc_sptr self, int i) -> long"""
        return _analog_swig.pwr_squelch_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(pwr_squelch_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(pwr_squelch_cc_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.pwr_squelch_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(pwr_squelch_cc_sptr self, int i) -> long"""
        return _analog_swig.pwr_squelch_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(pwr_squelch_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(pwr_squelch_cc_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.pwr_squelch_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(pwr_squelch_cc_sptr self) -> float"""
        return _analog_swig.pwr_squelch_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(pwr_squelch_cc_sptr self) -> float"""
        return _analog_swig.pwr_squelch_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(pwr_squelch_cc_sptr self) -> float"""
        return _analog_swig.pwr_squelch_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(pwr_squelch_cc_sptr self) -> float"""
        return _analog_swig.pwr_squelch_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(pwr_squelch_cc_sptr self) -> float"""
        return _analog_swig.pwr_squelch_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(pwr_squelch_cc_sptr self) -> float"""
        return _analog_swig.pwr_squelch_cc_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(pwr_squelch_cc_sptr self, int which) -> float
        pc_input_buffers_full(pwr_squelch_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pwr_squelch_cc_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(pwr_squelch_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(pwr_squelch_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pwr_squelch_cc_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(pwr_squelch_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(pwr_squelch_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pwr_squelch_cc_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(pwr_squelch_cc_sptr self, int which) -> float
        pc_output_buffers_full(pwr_squelch_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pwr_squelch_cc_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(pwr_squelch_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(pwr_squelch_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pwr_squelch_cc_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(pwr_squelch_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(pwr_squelch_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pwr_squelch_cc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(pwr_squelch_cc_sptr self) -> float"""
        return _analog_swig.pwr_squelch_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(pwr_squelch_cc_sptr self) -> float"""
        return _analog_swig.pwr_squelch_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(pwr_squelch_cc_sptr self) -> float"""
        return _analog_swig.pwr_squelch_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(pwr_squelch_cc_sptr self) -> float"""
        return _analog_swig.pwr_squelch_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(pwr_squelch_cc_sptr self) -> float"""
        return _analog_swig.pwr_squelch_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(pwr_squelch_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.pwr_squelch_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(pwr_squelch_cc_sptr self)"""
        return _analog_swig.pwr_squelch_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(pwr_squelch_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.pwr_squelch_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(pwr_squelch_cc_sptr self) -> int"""
        return _analog_swig.pwr_squelch_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(pwr_squelch_cc_sptr self) -> int"""
        return _analog_swig.pwr_squelch_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(pwr_squelch_cc_sptr self, int priority) -> int"""
        return _analog_swig.pwr_squelch_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(pwr_squelch_cc_sptr self) -> std::string"""
        return _analog_swig.pwr_squelch_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(pwr_squelch_cc_sptr self) -> std::string"""
        return _analog_swig.pwr_squelch_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(pwr_squelch_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.pwr_squelch_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(pwr_squelch_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.pwr_squelch_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(pwr_squelch_cc_sptr self) -> long"""
        return _analog_swig.pwr_squelch_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(pwr_squelch_cc_sptr self) -> basic_block_sptr"""
        return _analog_swig.pwr_squelch_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(pwr_squelch_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.pwr_squelch_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(pwr_squelch_cc_sptr self) -> std::string"""
        return _analog_swig.pwr_squelch_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(pwr_squelch_cc_sptr self, std::string name)"""
        return _analog_swig.pwr_squelch_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(pwr_squelch_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.pwr_squelch_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(pwr_squelch_cc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.pwr_squelch_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(pwr_squelch_cc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.pwr_squelch_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(pwr_squelch_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.pwr_squelch_cc_sptr_message_subscribers(self, which_port)

# Register pwr_squelch_cc_sptr in _analog_swig:
_analog_swig.pwr_squelch_cc_sptr_swigregister(pwr_squelch_cc_sptr)


pwr_squelch_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
pwr_squelch_cc = pwr_squelch_cc.make;

class pwr_squelch_ff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::pwr_squelch_ff > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(pwr_squelch_ff_sptr self) -> pwr_squelch_ff_sptr
        __init__(pwr_squelch_ff_sptr self, pwr_squelch_ff p) -> pwr_squelch_ff_sptr
        """
        _analog_swig.pwr_squelch_ff_sptr_swiginit(self, _analog_swig.new_pwr_squelch_ff_sptr(*args))

    def __deref__(self) -> "gr::analog::pwr_squelch_ff *":
        r"""__deref__(pwr_squelch_ff_sptr self) -> pwr_squelch_ff"""
        return _analog_swig.pwr_squelch_ff_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_pwr_squelch_ff_sptr

    def make(self, db: "double", alpha: "double"=0.0001, ramp: "int"=0, gate: "bool"=False) -> "gr::analog::pwr_squelch_ff::sptr":
        r"""make(pwr_squelch_ff_sptr self, double db, double alpha=0.0001, int ramp=0, bool gate=False) -> pwr_squelch_ff_sptr"""
        return _analog_swig.pwr_squelch_ff_sptr_make(self, db, alpha, ramp, gate)

    def squelch_range(self) -> "std::vector< float,std::allocator< float > >":
        r"""squelch_range(pwr_squelch_ff_sptr self) -> pmt_vector_float"""
        return _analog_swig.pwr_squelch_ff_sptr_squelch_range(self)

    def threshold(self) -> "double":
        r"""threshold(pwr_squelch_ff_sptr self) -> double"""
        return _analog_swig.pwr_squelch_ff_sptr_threshold(self)

    def set_threshold(self, db: "double") -> "void":
        r"""set_threshold(pwr_squelch_ff_sptr self, double db)"""
        return _analog_swig.pwr_squelch_ff_sptr_set_threshold(self, db)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(pwr_squelch_ff_sptr self, double alpha)"""
        return _analog_swig.pwr_squelch_ff_sptr_set_alpha(self, alpha)

    def ramp(self) -> "int":
        r"""ramp(pwr_squelch_ff_sptr self) -> int"""
        return _analog_swig.pwr_squelch_ff_sptr_ramp(self)

    def set_ramp(self, ramp: "int") -> "void":
        r"""set_ramp(pwr_squelch_ff_sptr self, int ramp)"""
        return _analog_swig.pwr_squelch_ff_sptr_set_ramp(self, ramp)

    def gate(self) -> "bool":
        r"""gate(pwr_squelch_ff_sptr self) -> bool"""
        return _analog_swig.pwr_squelch_ff_sptr_gate(self)

    def set_gate(self, gate: "bool") -> "void":
        r"""set_gate(pwr_squelch_ff_sptr self, bool gate)"""
        return _analog_swig.pwr_squelch_ff_sptr_set_gate(self, gate)

    def unmuted(self) -> "bool":
        r"""unmuted(pwr_squelch_ff_sptr self) -> bool"""
        return _analog_swig.pwr_squelch_ff_sptr_unmuted(self)

    def history(self) -> "unsigned int":
        r"""history(pwr_squelch_ff_sptr self) -> unsigned int"""
        return _analog_swig.pwr_squelch_ff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(pwr_squelch_ff_sptr self, int which, int delay)
        declare_sample_delay(pwr_squelch_ff_sptr self, unsigned int delay)
        """
        return _analog_swig.pwr_squelch_ff_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(pwr_squelch_ff_sptr self, int which) -> unsigned int"""
        return _analog_swig.pwr_squelch_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(pwr_squelch_ff_sptr self, int multiple)"""
        return _analog_swig.pwr_squelch_ff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(pwr_squelch_ff_sptr self) -> int"""
        return _analog_swig.pwr_squelch_ff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(pwr_squelch_ff_sptr self) -> double"""
        return _analog_swig.pwr_squelch_ff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(pwr_squelch_ff_sptr self) -> uint64_t"""
        return _analog_swig.pwr_squelch_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(pwr_squelch_ff_sptr self) -> uint64_t"""
        return _analog_swig.pwr_squelch_ff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(pwr_squelch_ff_sptr self) -> bool"""
        return _analog_swig.pwr_squelch_ff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(pwr_squelch_ff_sptr self) -> bool"""
        return _analog_swig.pwr_squelch_ff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(pwr_squelch_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.pwr_squelch_ff_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(pwr_squelch_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.pwr_squelch_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(pwr_squelch_ff_sptr self, std::string level)"""
        return _analog_swig.pwr_squelch_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(pwr_squelch_ff_sptr self) -> std::string"""
        return _analog_swig.pwr_squelch_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(pwr_squelch_ff_sptr self) -> int"""
        return _analog_swig.pwr_squelch_ff_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(pwr_squelch_ff_sptr self, int m)"""
        return _analog_swig.pwr_squelch_ff_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(pwr_squelch_ff_sptr self)"""
        return _analog_swig.pwr_squelch_ff_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(pwr_squelch_ff_sptr self) -> bool"""
        return _analog_swig.pwr_squelch_ff_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(pwr_squelch_ff_sptr self, int m)"""
        return _analog_swig.pwr_squelch_ff_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(pwr_squelch_ff_sptr self) -> int"""
        return _analog_swig.pwr_squelch_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(pwr_squelch_ff_sptr self, int i) -> long"""
        return _analog_swig.pwr_squelch_ff_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(pwr_squelch_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(pwr_squelch_ff_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.pwr_squelch_ff_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(pwr_squelch_ff_sptr self, int i) -> long"""
        return _analog_swig.pwr_squelch_ff_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(pwr_squelch_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(pwr_squelch_ff_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.pwr_squelch_ff_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(pwr_squelch_ff_sptr self) -> float"""
        return _analog_swig.pwr_squelch_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(pwr_squelch_ff_sptr self) -> float"""
        return _analog_swig.pwr_squelch_ff_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(pwr_squelch_ff_sptr self) -> float"""
        return _analog_swig.pwr_squelch_ff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(pwr_squelch_ff_sptr self) -> float"""
        return _analog_swig.pwr_squelch_ff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(pwr_squelch_ff_sptr self) -> float"""
        return _analog_swig.pwr_squelch_ff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(pwr_squelch_ff_sptr self) -> float"""
        return _analog_swig.pwr_squelch_ff_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(pwr_squelch_ff_sptr self, int which) -> float
        pc_input_buffers_full(pwr_squelch_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pwr_squelch_ff_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(pwr_squelch_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(pwr_squelch_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pwr_squelch_ff_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(pwr_squelch_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(pwr_squelch_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pwr_squelch_ff_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(pwr_squelch_ff_sptr self, int which) -> float
        pc_output_buffers_full(pwr_squelch_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pwr_squelch_ff_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(pwr_squelch_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(pwr_squelch_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pwr_squelch_ff_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(pwr_squelch_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(pwr_squelch_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.pwr_squelch_ff_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(pwr_squelch_ff_sptr self) -> float"""
        return _analog_swig.pwr_squelch_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(pwr_squelch_ff_sptr self) -> float"""
        return _analog_swig.pwr_squelch_ff_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(pwr_squelch_ff_sptr self) -> float"""
        return _analog_swig.pwr_squelch_ff_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(pwr_squelch_ff_sptr self) -> float"""
        return _analog_swig.pwr_squelch_ff_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(pwr_squelch_ff_sptr self) -> float"""
        return _analog_swig.pwr_squelch_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(pwr_squelch_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.pwr_squelch_ff_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(pwr_squelch_ff_sptr self)"""
        return _analog_swig.pwr_squelch_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(pwr_squelch_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.pwr_squelch_ff_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(pwr_squelch_ff_sptr self) -> int"""
        return _analog_swig.pwr_squelch_ff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(pwr_squelch_ff_sptr self) -> int"""
        return _analog_swig.pwr_squelch_ff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(pwr_squelch_ff_sptr self, int priority) -> int"""
        return _analog_swig.pwr_squelch_ff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(pwr_squelch_ff_sptr self) -> std::string"""
        return _analog_swig.pwr_squelch_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(pwr_squelch_ff_sptr self) -> std::string"""
        return _analog_swig.pwr_squelch_ff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(pwr_squelch_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.pwr_squelch_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(pwr_squelch_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.pwr_squelch_ff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(pwr_squelch_ff_sptr self) -> long"""
        return _analog_swig.pwr_squelch_ff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(pwr_squelch_ff_sptr self) -> basic_block_sptr"""
        return _analog_swig.pwr_squelch_ff_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(pwr_squelch_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.pwr_squelch_ff_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(pwr_squelch_ff_sptr self) -> std::string"""
        return _analog_swig.pwr_squelch_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(pwr_squelch_ff_sptr self, std::string name)"""
        return _analog_swig.pwr_squelch_ff_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(pwr_squelch_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.pwr_squelch_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(pwr_squelch_ff_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.pwr_squelch_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(pwr_squelch_ff_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.pwr_squelch_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(pwr_squelch_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.pwr_squelch_ff_sptr_message_subscribers(self, which_port)

# Register pwr_squelch_ff_sptr in _analog_swig:
_analog_swig.pwr_squelch_ff_sptr_swigregister(pwr_squelch_ff_sptr)


pwr_squelch_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
pwr_squelch_ff = pwr_squelch_ff.make;

class quadrature_demod_cf_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::quadrature_demod_cf > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(quadrature_demod_cf_sptr self) -> quadrature_demod_cf_sptr
        __init__(quadrature_demod_cf_sptr self, quadrature_demod_cf p) -> quadrature_demod_cf_sptr
        """
        _analog_swig.quadrature_demod_cf_sptr_swiginit(self, _analog_swig.new_quadrature_demod_cf_sptr(*args))

    def __deref__(self) -> "gr::analog::quadrature_demod_cf *":
        r"""__deref__(quadrature_demod_cf_sptr self) -> quadrature_demod_cf"""
        return _analog_swig.quadrature_demod_cf_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_quadrature_demod_cf_sptr

    def make(self, gain: "float") -> "gr::analog::quadrature_demod_cf::sptr":
        r"""make(quadrature_demod_cf_sptr self, float gain) -> quadrature_demod_cf_sptr"""
        return _analog_swig.quadrature_demod_cf_sptr_make(self, gain)

    def set_gain(self, gain: "float") -> "void":
        r"""set_gain(quadrature_demod_cf_sptr self, float gain)"""
        return _analog_swig.quadrature_demod_cf_sptr_set_gain(self, gain)

    def gain(self) -> "float":
        r"""gain(quadrature_demod_cf_sptr self) -> float"""
        return _analog_swig.quadrature_demod_cf_sptr_gain(self)

    def history(self) -> "unsigned int":
        r"""history(quadrature_demod_cf_sptr self) -> unsigned int"""
        return _analog_swig.quadrature_demod_cf_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(quadrature_demod_cf_sptr self, int which, int delay)
        declare_sample_delay(quadrature_demod_cf_sptr self, unsigned int delay)
        """
        return _analog_swig.quadrature_demod_cf_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(quadrature_demod_cf_sptr self, int which) -> unsigned int"""
        return _analog_swig.quadrature_demod_cf_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(quadrature_demod_cf_sptr self, int multiple)"""
        return _analog_swig.quadrature_demod_cf_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(quadrature_demod_cf_sptr self) -> int"""
        return _analog_swig.quadrature_demod_cf_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(quadrature_demod_cf_sptr self) -> double"""
        return _analog_swig.quadrature_demod_cf_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(quadrature_demod_cf_sptr self) -> uint64_t"""
        return _analog_swig.quadrature_demod_cf_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(quadrature_demod_cf_sptr self) -> uint64_t"""
        return _analog_swig.quadrature_demod_cf_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(quadrature_demod_cf_sptr self) -> bool"""
        return _analog_swig.quadrature_demod_cf_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(quadrature_demod_cf_sptr self) -> bool"""
        return _analog_swig.quadrature_demod_cf_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(quadrature_demod_cf_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.quadrature_demod_cf_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(quadrature_demod_cf_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.quadrature_demod_cf_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(quadrature_demod_cf_sptr self, std::string level)"""
        return _analog_swig.quadrature_demod_cf_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(quadrature_demod_cf_sptr self) -> std::string"""
        return _analog_swig.quadrature_demod_cf_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(quadrature_demod_cf_sptr self) -> int"""
        return _analog_swig.quadrature_demod_cf_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(quadrature_demod_cf_sptr self, int m)"""
        return _analog_swig.quadrature_demod_cf_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(quadrature_demod_cf_sptr self)"""
        return _analog_swig.quadrature_demod_cf_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(quadrature_demod_cf_sptr self) -> bool"""
        return _analog_swig.quadrature_demod_cf_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(quadrature_demod_cf_sptr self, int m)"""
        return _analog_swig.quadrature_demod_cf_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(quadrature_demod_cf_sptr self) -> int"""
        return _analog_swig.quadrature_demod_cf_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(quadrature_demod_cf_sptr self, int i) -> long"""
        return _analog_swig.quadrature_demod_cf_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(quadrature_demod_cf_sptr self, long max_output_buffer)
        set_max_output_buffer(quadrature_demod_cf_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.quadrature_demod_cf_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(quadrature_demod_cf_sptr self, int i) -> long"""
        return _analog_swig.quadrature_demod_cf_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(quadrature_demod_cf_sptr self, long min_output_buffer)
        set_min_output_buffer(quadrature_demod_cf_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.quadrature_demod_cf_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(quadrature_demod_cf_sptr self) -> float"""
        return _analog_swig.quadrature_demod_cf_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(quadrature_demod_cf_sptr self) -> float"""
        return _analog_swig.quadrature_demod_cf_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(quadrature_demod_cf_sptr self) -> float"""
        return _analog_swig.quadrature_demod_cf_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(quadrature_demod_cf_sptr self) -> float"""
        return _analog_swig.quadrature_demod_cf_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(quadrature_demod_cf_sptr self) -> float"""
        return _analog_swig.quadrature_demod_cf_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(quadrature_demod_cf_sptr self) -> float"""
        return _analog_swig.quadrature_demod_cf_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(quadrature_demod_cf_sptr self, int which) -> float
        pc_input_buffers_full(quadrature_demod_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.quadrature_demod_cf_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(quadrature_demod_cf_sptr self, int which) -> float
        pc_input_buffers_full_avg(quadrature_demod_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.quadrature_demod_cf_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(quadrature_demod_cf_sptr self, int which) -> float
        pc_input_buffers_full_var(quadrature_demod_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.quadrature_demod_cf_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(quadrature_demod_cf_sptr self, int which) -> float
        pc_output_buffers_full(quadrature_demod_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.quadrature_demod_cf_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(quadrature_demod_cf_sptr self, int which) -> float
        pc_output_buffers_full_avg(quadrature_demod_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.quadrature_demod_cf_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(quadrature_demod_cf_sptr self, int which) -> float
        pc_output_buffers_full_var(quadrature_demod_cf_sptr self) -> pmt_vector_float
        """
        return _analog_swig.quadrature_demod_cf_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(quadrature_demod_cf_sptr self) -> float"""
        return _analog_swig.quadrature_demod_cf_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(quadrature_demod_cf_sptr self) -> float"""
        return _analog_swig.quadrature_demod_cf_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(quadrature_demod_cf_sptr self) -> float"""
        return _analog_swig.quadrature_demod_cf_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(quadrature_demod_cf_sptr self) -> float"""
        return _analog_swig.quadrature_demod_cf_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(quadrature_demod_cf_sptr self) -> float"""
        return _analog_swig.quadrature_demod_cf_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(quadrature_demod_cf_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.quadrature_demod_cf_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(quadrature_demod_cf_sptr self)"""
        return _analog_swig.quadrature_demod_cf_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(quadrature_demod_cf_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.quadrature_demod_cf_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(quadrature_demod_cf_sptr self) -> int"""
        return _analog_swig.quadrature_demod_cf_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(quadrature_demod_cf_sptr self) -> int"""
        return _analog_swig.quadrature_demod_cf_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(quadrature_demod_cf_sptr self, int priority) -> int"""
        return _analog_swig.quadrature_demod_cf_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(quadrature_demod_cf_sptr self) -> std::string"""
        return _analog_swig.quadrature_demod_cf_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(quadrature_demod_cf_sptr self) -> std::string"""
        return _analog_swig.quadrature_demod_cf_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(quadrature_demod_cf_sptr self) -> io_signature_sptr"""
        return _analog_swig.quadrature_demod_cf_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(quadrature_demod_cf_sptr self) -> io_signature_sptr"""
        return _analog_swig.quadrature_demod_cf_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(quadrature_demod_cf_sptr self) -> long"""
        return _analog_swig.quadrature_demod_cf_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(quadrature_demod_cf_sptr self) -> basic_block_sptr"""
        return _analog_swig.quadrature_demod_cf_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(quadrature_demod_cf_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.quadrature_demod_cf_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(quadrature_demod_cf_sptr self) -> std::string"""
        return _analog_swig.quadrature_demod_cf_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(quadrature_demod_cf_sptr self, std::string name)"""
        return _analog_swig.quadrature_demod_cf_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(quadrature_demod_cf_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.quadrature_demod_cf_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(quadrature_demod_cf_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.quadrature_demod_cf_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(quadrature_demod_cf_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.quadrature_demod_cf_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(quadrature_demod_cf_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.quadrature_demod_cf_sptr_message_subscribers(self, which_port)

# Register quadrature_demod_cf_sptr in _analog_swig:
_analog_swig.quadrature_demod_cf_sptr_swigregister(quadrature_demod_cf_sptr)


quadrature_demod_cf_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
quadrature_demod_cf = quadrature_demod_cf.make;

class rail_ff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::rail_ff > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(rail_ff_sptr self) -> rail_ff_sptr
        __init__(rail_ff_sptr self, rail_ff p) -> rail_ff_sptr
        """
        _analog_swig.rail_ff_sptr_swiginit(self, _analog_swig.new_rail_ff_sptr(*args))

    def __deref__(self) -> "gr::analog::rail_ff *":
        r"""__deref__(rail_ff_sptr self) -> rail_ff"""
        return _analog_swig.rail_ff_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_rail_ff_sptr

    def make(self, lo: "float", hi: "float") -> "gr::analog::rail_ff::sptr":
        r"""make(rail_ff_sptr self, float lo, float hi) -> rail_ff_sptr"""
        return _analog_swig.rail_ff_sptr_make(self, lo, hi)

    def lo(self) -> "float":
        r"""lo(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_lo(self)

    def hi(self) -> "float":
        r"""hi(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_hi(self)

    def set_lo(self, lo: "float") -> "void":
        r"""set_lo(rail_ff_sptr self, float lo)"""
        return _analog_swig.rail_ff_sptr_set_lo(self, lo)

    def set_hi(self, hi: "float") -> "void":
        r"""set_hi(rail_ff_sptr self, float hi)"""
        return _analog_swig.rail_ff_sptr_set_hi(self, hi)

    def history(self) -> "unsigned int":
        r"""history(rail_ff_sptr self) -> unsigned int"""
        return _analog_swig.rail_ff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(rail_ff_sptr self, int which, int delay)
        declare_sample_delay(rail_ff_sptr self, unsigned int delay)
        """
        return _analog_swig.rail_ff_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(rail_ff_sptr self, int which) -> unsigned int"""
        return _analog_swig.rail_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(rail_ff_sptr self, int multiple)"""
        return _analog_swig.rail_ff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(rail_ff_sptr self) -> int"""
        return _analog_swig.rail_ff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(rail_ff_sptr self) -> double"""
        return _analog_swig.rail_ff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(rail_ff_sptr self) -> uint64_t"""
        return _analog_swig.rail_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(rail_ff_sptr self) -> uint64_t"""
        return _analog_swig.rail_ff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(rail_ff_sptr self) -> bool"""
        return _analog_swig.rail_ff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(rail_ff_sptr self) -> bool"""
        return _analog_swig.rail_ff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(rail_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.rail_ff_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(rail_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.rail_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(rail_ff_sptr self, std::string level)"""
        return _analog_swig.rail_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(rail_ff_sptr self) -> std::string"""
        return _analog_swig.rail_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(rail_ff_sptr self) -> int"""
        return _analog_swig.rail_ff_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(rail_ff_sptr self, int m)"""
        return _analog_swig.rail_ff_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(rail_ff_sptr self)"""
        return _analog_swig.rail_ff_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(rail_ff_sptr self) -> bool"""
        return _analog_swig.rail_ff_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(rail_ff_sptr self, int m)"""
        return _analog_swig.rail_ff_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(rail_ff_sptr self) -> int"""
        return _analog_swig.rail_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(rail_ff_sptr self, int i) -> long"""
        return _analog_swig.rail_ff_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(rail_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(rail_ff_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.rail_ff_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(rail_ff_sptr self, int i) -> long"""
        return _analog_swig.rail_ff_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(rail_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(rail_ff_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.rail_ff_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(rail_ff_sptr self, int which) -> float
        pc_input_buffers_full(rail_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.rail_ff_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(rail_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(rail_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.rail_ff_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(rail_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(rail_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.rail_ff_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(rail_ff_sptr self, int which) -> float
        pc_output_buffers_full(rail_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.rail_ff_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(rail_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(rail_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.rail_ff_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(rail_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(rail_ff_sptr self) -> pmt_vector_float
        """
        return _analog_swig.rail_ff_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(rail_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.rail_ff_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(rail_ff_sptr self)"""
        return _analog_swig.rail_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(rail_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.rail_ff_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(rail_ff_sptr self) -> int"""
        return _analog_swig.rail_ff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(rail_ff_sptr self) -> int"""
        return _analog_swig.rail_ff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(rail_ff_sptr self, int priority) -> int"""
        return _analog_swig.rail_ff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(rail_ff_sptr self) -> std::string"""
        return _analog_swig.rail_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(rail_ff_sptr self) -> std::string"""
        return _analog_swig.rail_ff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(rail_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.rail_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(rail_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.rail_ff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(rail_ff_sptr self) -> long"""
        return _analog_swig.rail_ff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(rail_ff_sptr self) -> basic_block_sptr"""
        return _analog_swig.rail_ff_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(rail_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.rail_ff_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(rail_ff_sptr self) -> std::string"""
        return _analog_swig.rail_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(rail_ff_sptr self, std::string name)"""
        return _analog_swig.rail_ff_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(rail_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.rail_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(rail_ff_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.rail_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(rail_ff_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.rail_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(rail_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.rail_ff_sptr_message_subscribers(self, which_port)

# Register rail_ff_sptr in _analog_swig:
_analog_swig.rail_ff_sptr_swigregister(rail_ff_sptr)


rail_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
rail_ff = rail_ff.make;

class sig_source_b(object):
    r"""Proxy of C++ gr::analog::sig_source< std::int8_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(sampling_freq: "double", waveform: "gr::analog::gr_waveform_t", wave_freq: "double", ampl: "double", offset: "std::int8_t"=0, phase: "float"=0) -> "gr::analog::sig_source< signed char >::sptr":
        r"""make(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, std::int8_t offset=0, float phase=0) -> sig_source_b_sptr"""
        return _analog_swig.sig_source_b_make(sampling_freq, waveform, wave_freq, ampl, offset, phase)

    def sampling_freq(self) -> "double":
        r"""sampling_freq(sig_source_b self) -> double"""
        return _analog_swig.sig_source_b_sampling_freq(self)

    def waveform(self) -> "gr::analog::gr_waveform_t":
        r"""waveform(sig_source_b self) -> gr::analog::gr_waveform_t"""
        return _analog_swig.sig_source_b_waveform(self)

    def frequency(self) -> "double":
        r"""frequency(sig_source_b self) -> double"""
        return _analog_swig.sig_source_b_frequency(self)

    def amplitude(self) -> "double":
        r"""amplitude(sig_source_b self) -> double"""
        return _analog_swig.sig_source_b_amplitude(self)

    def offset(self) -> "std::int8_t":
        r"""offset(sig_source_b self) -> std::int8_t"""
        return _analog_swig.sig_source_b_offset(self)

    def phase(self) -> "float":
        r"""phase(sig_source_b self) -> float"""
        return _analog_swig.sig_source_b_phase(self)

    def set_sampling_freq(self, sampling_freq: "double") -> "void":
        r"""set_sampling_freq(sig_source_b self, double sampling_freq)"""
        return _analog_swig.sig_source_b_set_sampling_freq(self, sampling_freq)

    def set_waveform(self, waveform: "gr::analog::gr_waveform_t") -> "void":
        r"""set_waveform(sig_source_b self, gr::analog::gr_waveform_t waveform)"""
        return _analog_swig.sig_source_b_set_waveform(self, waveform)

    def set_frequency(self, frequency: "double") -> "void":
        r"""set_frequency(sig_source_b self, double frequency)"""
        return _analog_swig.sig_source_b_set_frequency(self, frequency)

    def set_amplitude(self, ampl: "double") -> "void":
        r"""set_amplitude(sig_source_b self, double ampl)"""
        return _analog_swig.sig_source_b_set_amplitude(self, ampl)

    def set_offset(self, offset: "std::int8_t") -> "void":
        r"""set_offset(sig_source_b self, std::int8_t offset)"""
        return _analog_swig.sig_source_b_set_offset(self, offset)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(sig_source_b self, float phase)"""
        return _analog_swig.sig_source_b_set_phase(self, phase)
    __swig_destroy__ = _analog_swig.delete_sig_source_b

# Register sig_source_b in _analog_swig:
_analog_swig.sig_source_b_swigregister(sig_source_b)

def sig_source_b_make(sampling_freq: "double", waveform: "gr::analog::gr_waveform_t", wave_freq: "double", ampl: "double", offset: "std::int8_t"=0, phase: "float"=0) -> "gr::analog::sig_source< signed char >::sptr":
    r"""sig_source_b_make(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, std::int8_t offset=0, float phase=0) -> sig_source_b_sptr"""
    return _analog_swig.sig_source_b_make(sampling_freq, waveform, wave_freq, ampl, offset, phase)

class sig_source_b_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::sig_source< std::int8_t > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(sig_source_b_sptr self) -> sig_source_b_sptr
        __init__(sig_source_b_sptr self, sig_source_b p) -> sig_source_b_sptr
        """
        _analog_swig.sig_source_b_sptr_swiginit(self, _analog_swig.new_sig_source_b_sptr(*args))

    def __deref__(self) -> "gr::analog::sig_source< std::int8_t > *":
        r"""__deref__(sig_source_b_sptr self) -> sig_source_b"""
        return _analog_swig.sig_source_b_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_sig_source_b_sptr

    def make(self, sampling_freq: "double", waveform: "gr::analog::gr_waveform_t", wave_freq: "double", ampl: "double", offset: "std::int8_t"=0, phase: "float"=0) -> "gr::analog::sig_source< signed char >::sptr":
        r"""make(sig_source_b_sptr self, double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, std::int8_t offset=0, float phase=0) -> sig_source_b_sptr"""
        return _analog_swig.sig_source_b_sptr_make(self, sampling_freq, waveform, wave_freq, ampl, offset, phase)

    def sampling_freq(self) -> "double":
        r"""sampling_freq(sig_source_b_sptr self) -> double"""
        return _analog_swig.sig_source_b_sptr_sampling_freq(self)

    def waveform(self) -> "gr::analog::gr_waveform_t":
        r"""waveform(sig_source_b_sptr self) -> gr::analog::gr_waveform_t"""
        return _analog_swig.sig_source_b_sptr_waveform(self)

    def frequency(self) -> "double":
        r"""frequency(sig_source_b_sptr self) -> double"""
        return _analog_swig.sig_source_b_sptr_frequency(self)

    def amplitude(self) -> "double":
        r"""amplitude(sig_source_b_sptr self) -> double"""
        return _analog_swig.sig_source_b_sptr_amplitude(self)

    def offset(self) -> "std::int8_t":
        r"""offset(sig_source_b_sptr self) -> std::int8_t"""
        return _analog_swig.sig_source_b_sptr_offset(self)

    def phase(self) -> "float":
        r"""phase(sig_source_b_sptr self) -> float"""
        return _analog_swig.sig_source_b_sptr_phase(self)

    def set_sampling_freq(self, sampling_freq: "double") -> "void":
        r"""set_sampling_freq(sig_source_b_sptr self, double sampling_freq)"""
        return _analog_swig.sig_source_b_sptr_set_sampling_freq(self, sampling_freq)

    def set_waveform(self, waveform: "gr::analog::gr_waveform_t") -> "void":
        r"""set_waveform(sig_source_b_sptr self, gr::analog::gr_waveform_t waveform)"""
        return _analog_swig.sig_source_b_sptr_set_waveform(self, waveform)

    def set_frequency(self, frequency: "double") -> "void":
        r"""set_frequency(sig_source_b_sptr self, double frequency)"""
        return _analog_swig.sig_source_b_sptr_set_frequency(self, frequency)

    def set_amplitude(self, ampl: "double") -> "void":
        r"""set_amplitude(sig_source_b_sptr self, double ampl)"""
        return _analog_swig.sig_source_b_sptr_set_amplitude(self, ampl)

    def set_offset(self, offset: "std::int8_t") -> "void":
        r"""set_offset(sig_source_b_sptr self, std::int8_t offset)"""
        return _analog_swig.sig_source_b_sptr_set_offset(self, offset)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(sig_source_b_sptr self, float phase)"""
        return _analog_swig.sig_source_b_sptr_set_phase(self, phase)

    def history(self) -> "unsigned int":
        r"""history(sig_source_b_sptr self) -> unsigned int"""
        return _analog_swig.sig_source_b_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(sig_source_b_sptr self, int which, int delay)
        declare_sample_delay(sig_source_b_sptr self, unsigned int delay)
        """
        return _analog_swig.sig_source_b_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(sig_source_b_sptr self, int which) -> unsigned int"""
        return _analog_swig.sig_source_b_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(sig_source_b_sptr self, int multiple)"""
        return _analog_swig.sig_source_b_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(sig_source_b_sptr self) -> int"""
        return _analog_swig.sig_source_b_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(sig_source_b_sptr self) -> double"""
        return _analog_swig.sig_source_b_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(sig_source_b_sptr self) -> uint64_t"""
        return _analog_swig.sig_source_b_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(sig_source_b_sptr self) -> uint64_t"""
        return _analog_swig.sig_source_b_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(sig_source_b_sptr self) -> bool"""
        return _analog_swig.sig_source_b_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(sig_source_b_sptr self) -> bool"""
        return _analog_swig.sig_source_b_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(sig_source_b_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.sig_source_b_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(sig_source_b_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.sig_source_b_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(sig_source_b_sptr self, std::string level)"""
        return _analog_swig.sig_source_b_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(sig_source_b_sptr self) -> std::string"""
        return _analog_swig.sig_source_b_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(sig_source_b_sptr self) -> int"""
        return _analog_swig.sig_source_b_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(sig_source_b_sptr self, int m)"""
        return _analog_swig.sig_source_b_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(sig_source_b_sptr self)"""
        return _analog_swig.sig_source_b_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(sig_source_b_sptr self) -> bool"""
        return _analog_swig.sig_source_b_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(sig_source_b_sptr self, int m)"""
        return _analog_swig.sig_source_b_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(sig_source_b_sptr self) -> int"""
        return _analog_swig.sig_source_b_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(sig_source_b_sptr self, int i) -> long"""
        return _analog_swig.sig_source_b_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(sig_source_b_sptr self, long max_output_buffer)
        set_max_output_buffer(sig_source_b_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.sig_source_b_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(sig_source_b_sptr self, int i) -> long"""
        return _analog_swig.sig_source_b_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(sig_source_b_sptr self, long min_output_buffer)
        set_min_output_buffer(sig_source_b_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.sig_source_b_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(sig_source_b_sptr self) -> float"""
        return _analog_swig.sig_source_b_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(sig_source_b_sptr self) -> float"""
        return _analog_swig.sig_source_b_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(sig_source_b_sptr self) -> float"""
        return _analog_swig.sig_source_b_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(sig_source_b_sptr self) -> float"""
        return _analog_swig.sig_source_b_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(sig_source_b_sptr self) -> float"""
        return _analog_swig.sig_source_b_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(sig_source_b_sptr self) -> float"""
        return _analog_swig.sig_source_b_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(sig_source_b_sptr self, int which) -> float
        pc_input_buffers_full(sig_source_b_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_b_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(sig_source_b_sptr self, int which) -> float
        pc_input_buffers_full_avg(sig_source_b_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_b_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(sig_source_b_sptr self, int which) -> float
        pc_input_buffers_full_var(sig_source_b_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_b_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(sig_source_b_sptr self, int which) -> float
        pc_output_buffers_full(sig_source_b_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_b_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(sig_source_b_sptr self, int which) -> float
        pc_output_buffers_full_avg(sig_source_b_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_b_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(sig_source_b_sptr self, int which) -> float
        pc_output_buffers_full_var(sig_source_b_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_b_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(sig_source_b_sptr self) -> float"""
        return _analog_swig.sig_source_b_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(sig_source_b_sptr self) -> float"""
        return _analog_swig.sig_source_b_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(sig_source_b_sptr self) -> float"""
        return _analog_swig.sig_source_b_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(sig_source_b_sptr self) -> float"""
        return _analog_swig.sig_source_b_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(sig_source_b_sptr self) -> float"""
        return _analog_swig.sig_source_b_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(sig_source_b_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.sig_source_b_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(sig_source_b_sptr self)"""
        return _analog_swig.sig_source_b_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(sig_source_b_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.sig_source_b_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(sig_source_b_sptr self) -> int"""
        return _analog_swig.sig_source_b_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(sig_source_b_sptr self) -> int"""
        return _analog_swig.sig_source_b_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(sig_source_b_sptr self, int priority) -> int"""
        return _analog_swig.sig_source_b_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(sig_source_b_sptr self) -> std::string"""
        return _analog_swig.sig_source_b_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(sig_source_b_sptr self) -> std::string"""
        return _analog_swig.sig_source_b_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(sig_source_b_sptr self) -> io_signature_sptr"""
        return _analog_swig.sig_source_b_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(sig_source_b_sptr self) -> io_signature_sptr"""
        return _analog_swig.sig_source_b_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(sig_source_b_sptr self) -> long"""
        return _analog_swig.sig_source_b_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(sig_source_b_sptr self) -> basic_block_sptr"""
        return _analog_swig.sig_source_b_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(sig_source_b_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.sig_source_b_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(sig_source_b_sptr self) -> std::string"""
        return _analog_swig.sig_source_b_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(sig_source_b_sptr self, std::string name)"""
        return _analog_swig.sig_source_b_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(sig_source_b_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.sig_source_b_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(sig_source_b_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.sig_source_b_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(sig_source_b_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.sig_source_b_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(sig_source_b_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.sig_source_b_sptr_message_subscribers(self, which_port)

# Register sig_source_b_sptr in _analog_swig:
_analog_swig.sig_source_b_sptr_swigregister(sig_source_b_sptr)


sig_source_b_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
sig_source_b = sig_source_b.make

class sig_source_s(object):
    r"""Proxy of C++ gr::analog::sig_source< std::int16_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(sampling_freq: "double", waveform: "gr::analog::gr_waveform_t", wave_freq: "double", ampl: "double", offset: "std::int16_t"=0, phase: "float"=0) -> "gr::analog::sig_source< short >::sptr":
        r"""make(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, std::int16_t offset=0, float phase=0) -> sig_source_s_sptr"""
        return _analog_swig.sig_source_s_make(sampling_freq, waveform, wave_freq, ampl, offset, phase)

    def sampling_freq(self) -> "double":
        r"""sampling_freq(sig_source_s self) -> double"""
        return _analog_swig.sig_source_s_sampling_freq(self)

    def waveform(self) -> "gr::analog::gr_waveform_t":
        r"""waveform(sig_source_s self) -> gr::analog::gr_waveform_t"""
        return _analog_swig.sig_source_s_waveform(self)

    def frequency(self) -> "double":
        r"""frequency(sig_source_s self) -> double"""
        return _analog_swig.sig_source_s_frequency(self)

    def amplitude(self) -> "double":
        r"""amplitude(sig_source_s self) -> double"""
        return _analog_swig.sig_source_s_amplitude(self)

    def offset(self) -> "std::int16_t":
        r"""offset(sig_source_s self) -> std::int16_t"""
        return _analog_swig.sig_source_s_offset(self)

    def phase(self) -> "float":
        r"""phase(sig_source_s self) -> float"""
        return _analog_swig.sig_source_s_phase(self)

    def set_sampling_freq(self, sampling_freq: "double") -> "void":
        r"""set_sampling_freq(sig_source_s self, double sampling_freq)"""
        return _analog_swig.sig_source_s_set_sampling_freq(self, sampling_freq)

    def set_waveform(self, waveform: "gr::analog::gr_waveform_t") -> "void":
        r"""set_waveform(sig_source_s self, gr::analog::gr_waveform_t waveform)"""
        return _analog_swig.sig_source_s_set_waveform(self, waveform)

    def set_frequency(self, frequency: "double") -> "void":
        r"""set_frequency(sig_source_s self, double frequency)"""
        return _analog_swig.sig_source_s_set_frequency(self, frequency)

    def set_amplitude(self, ampl: "double") -> "void":
        r"""set_amplitude(sig_source_s self, double ampl)"""
        return _analog_swig.sig_source_s_set_amplitude(self, ampl)

    def set_offset(self, offset: "std::int16_t") -> "void":
        r"""set_offset(sig_source_s self, std::int16_t offset)"""
        return _analog_swig.sig_source_s_set_offset(self, offset)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(sig_source_s self, float phase)"""
        return _analog_swig.sig_source_s_set_phase(self, phase)
    __swig_destroy__ = _analog_swig.delete_sig_source_s

# Register sig_source_s in _analog_swig:
_analog_swig.sig_source_s_swigregister(sig_source_s)

def sig_source_s_make(sampling_freq: "double", waveform: "gr::analog::gr_waveform_t", wave_freq: "double", ampl: "double", offset: "std::int16_t"=0, phase: "float"=0) -> "gr::analog::sig_source< short >::sptr":
    r"""sig_source_s_make(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, std::int16_t offset=0, float phase=0) -> sig_source_s_sptr"""
    return _analog_swig.sig_source_s_make(sampling_freq, waveform, wave_freq, ampl, offset, phase)

class sig_source_s_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::sig_source< std::int16_t > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(sig_source_s_sptr self) -> sig_source_s_sptr
        __init__(sig_source_s_sptr self, sig_source_s p) -> sig_source_s_sptr
        """
        _analog_swig.sig_source_s_sptr_swiginit(self, _analog_swig.new_sig_source_s_sptr(*args))

    def __deref__(self) -> "gr::analog::sig_source< std::int16_t > *":
        r"""__deref__(sig_source_s_sptr self) -> sig_source_s"""
        return _analog_swig.sig_source_s_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_sig_source_s_sptr

    def make(self, sampling_freq: "double", waveform: "gr::analog::gr_waveform_t", wave_freq: "double", ampl: "double", offset: "std::int16_t"=0, phase: "float"=0) -> "gr::analog::sig_source< short >::sptr":
        r"""make(sig_source_s_sptr self, double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, std::int16_t offset=0, float phase=0) -> sig_source_s_sptr"""
        return _analog_swig.sig_source_s_sptr_make(self, sampling_freq, waveform, wave_freq, ampl, offset, phase)

    def sampling_freq(self) -> "double":
        r"""sampling_freq(sig_source_s_sptr self) -> double"""
        return _analog_swig.sig_source_s_sptr_sampling_freq(self)

    def waveform(self) -> "gr::analog::gr_waveform_t":
        r"""waveform(sig_source_s_sptr self) -> gr::analog::gr_waveform_t"""
        return _analog_swig.sig_source_s_sptr_waveform(self)

    def frequency(self) -> "double":
        r"""frequency(sig_source_s_sptr self) -> double"""
        return _analog_swig.sig_source_s_sptr_frequency(self)

    def amplitude(self) -> "double":
        r"""amplitude(sig_source_s_sptr self) -> double"""
        return _analog_swig.sig_source_s_sptr_amplitude(self)

    def offset(self) -> "std::int16_t":
        r"""offset(sig_source_s_sptr self) -> std::int16_t"""
        return _analog_swig.sig_source_s_sptr_offset(self)

    def phase(self) -> "float":
        r"""phase(sig_source_s_sptr self) -> float"""
        return _analog_swig.sig_source_s_sptr_phase(self)

    def set_sampling_freq(self, sampling_freq: "double") -> "void":
        r"""set_sampling_freq(sig_source_s_sptr self, double sampling_freq)"""
        return _analog_swig.sig_source_s_sptr_set_sampling_freq(self, sampling_freq)

    def set_waveform(self, waveform: "gr::analog::gr_waveform_t") -> "void":
        r"""set_waveform(sig_source_s_sptr self, gr::analog::gr_waveform_t waveform)"""
        return _analog_swig.sig_source_s_sptr_set_waveform(self, waveform)

    def set_frequency(self, frequency: "double") -> "void":
        r"""set_frequency(sig_source_s_sptr self, double frequency)"""
        return _analog_swig.sig_source_s_sptr_set_frequency(self, frequency)

    def set_amplitude(self, ampl: "double") -> "void":
        r"""set_amplitude(sig_source_s_sptr self, double ampl)"""
        return _analog_swig.sig_source_s_sptr_set_amplitude(self, ampl)

    def set_offset(self, offset: "std::int16_t") -> "void":
        r"""set_offset(sig_source_s_sptr self, std::int16_t offset)"""
        return _analog_swig.sig_source_s_sptr_set_offset(self, offset)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(sig_source_s_sptr self, float phase)"""
        return _analog_swig.sig_source_s_sptr_set_phase(self, phase)

    def history(self) -> "unsigned int":
        r"""history(sig_source_s_sptr self) -> unsigned int"""
        return _analog_swig.sig_source_s_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(sig_source_s_sptr self, int which, int delay)
        declare_sample_delay(sig_source_s_sptr self, unsigned int delay)
        """
        return _analog_swig.sig_source_s_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(sig_source_s_sptr self, int which) -> unsigned int"""
        return _analog_swig.sig_source_s_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(sig_source_s_sptr self, int multiple)"""
        return _analog_swig.sig_source_s_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(sig_source_s_sptr self) -> int"""
        return _analog_swig.sig_source_s_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(sig_source_s_sptr self) -> double"""
        return _analog_swig.sig_source_s_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(sig_source_s_sptr self) -> uint64_t"""
        return _analog_swig.sig_source_s_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(sig_source_s_sptr self) -> uint64_t"""
        return _analog_swig.sig_source_s_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(sig_source_s_sptr self) -> bool"""
        return _analog_swig.sig_source_s_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(sig_source_s_sptr self) -> bool"""
        return _analog_swig.sig_source_s_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(sig_source_s_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.sig_source_s_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(sig_source_s_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.sig_source_s_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(sig_source_s_sptr self, std::string level)"""
        return _analog_swig.sig_source_s_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(sig_source_s_sptr self) -> std::string"""
        return _analog_swig.sig_source_s_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(sig_source_s_sptr self) -> int"""
        return _analog_swig.sig_source_s_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(sig_source_s_sptr self, int m)"""
        return _analog_swig.sig_source_s_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(sig_source_s_sptr self)"""
        return _analog_swig.sig_source_s_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(sig_source_s_sptr self) -> bool"""
        return _analog_swig.sig_source_s_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(sig_source_s_sptr self, int m)"""
        return _analog_swig.sig_source_s_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(sig_source_s_sptr self) -> int"""
        return _analog_swig.sig_source_s_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(sig_source_s_sptr self, int i) -> long"""
        return _analog_swig.sig_source_s_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(sig_source_s_sptr self, long max_output_buffer)
        set_max_output_buffer(sig_source_s_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.sig_source_s_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(sig_source_s_sptr self, int i) -> long"""
        return _analog_swig.sig_source_s_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(sig_source_s_sptr self, long min_output_buffer)
        set_min_output_buffer(sig_source_s_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.sig_source_s_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(sig_source_s_sptr self) -> float"""
        return _analog_swig.sig_source_s_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(sig_source_s_sptr self) -> float"""
        return _analog_swig.sig_source_s_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(sig_source_s_sptr self) -> float"""
        return _analog_swig.sig_source_s_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(sig_source_s_sptr self) -> float"""
        return _analog_swig.sig_source_s_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(sig_source_s_sptr self) -> float"""
        return _analog_swig.sig_source_s_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(sig_source_s_sptr self) -> float"""
        return _analog_swig.sig_source_s_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(sig_source_s_sptr self, int which) -> float
        pc_input_buffers_full(sig_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_s_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(sig_source_s_sptr self, int which) -> float
        pc_input_buffers_full_avg(sig_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_s_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(sig_source_s_sptr self, int which) -> float
        pc_input_buffers_full_var(sig_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_s_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(sig_source_s_sptr self, int which) -> float
        pc_output_buffers_full(sig_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_s_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(sig_source_s_sptr self, int which) -> float
        pc_output_buffers_full_avg(sig_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_s_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(sig_source_s_sptr self, int which) -> float
        pc_output_buffers_full_var(sig_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_s_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(sig_source_s_sptr self) -> float"""
        return _analog_swig.sig_source_s_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(sig_source_s_sptr self) -> float"""
        return _analog_swig.sig_source_s_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(sig_source_s_sptr self) -> float"""
        return _analog_swig.sig_source_s_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(sig_source_s_sptr self) -> float"""
        return _analog_swig.sig_source_s_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(sig_source_s_sptr self) -> float"""
        return _analog_swig.sig_source_s_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(sig_source_s_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.sig_source_s_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(sig_source_s_sptr self)"""
        return _analog_swig.sig_source_s_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(sig_source_s_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.sig_source_s_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(sig_source_s_sptr self) -> int"""
        return _analog_swig.sig_source_s_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(sig_source_s_sptr self) -> int"""
        return _analog_swig.sig_source_s_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(sig_source_s_sptr self, int priority) -> int"""
        return _analog_swig.sig_source_s_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(sig_source_s_sptr self) -> std::string"""
        return _analog_swig.sig_source_s_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(sig_source_s_sptr self) -> std::string"""
        return _analog_swig.sig_source_s_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(sig_source_s_sptr self) -> io_signature_sptr"""
        return _analog_swig.sig_source_s_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(sig_source_s_sptr self) -> io_signature_sptr"""
        return _analog_swig.sig_source_s_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(sig_source_s_sptr self) -> long"""
        return _analog_swig.sig_source_s_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(sig_source_s_sptr self) -> basic_block_sptr"""
        return _analog_swig.sig_source_s_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(sig_source_s_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.sig_source_s_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(sig_source_s_sptr self) -> std::string"""
        return _analog_swig.sig_source_s_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(sig_source_s_sptr self, std::string name)"""
        return _analog_swig.sig_source_s_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(sig_source_s_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.sig_source_s_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(sig_source_s_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.sig_source_s_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(sig_source_s_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.sig_source_s_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(sig_source_s_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.sig_source_s_sptr_message_subscribers(self, which_port)

# Register sig_source_s_sptr in _analog_swig:
_analog_swig.sig_source_s_sptr_swigregister(sig_source_s_sptr)


sig_source_s_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
sig_source_s = sig_source_s.make

class sig_source_i(object):
    r"""Proxy of C++ gr::analog::sig_source< std::int32_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(sampling_freq: "double", waveform: "gr::analog::gr_waveform_t", wave_freq: "double", ampl: "double", offset: "std::int32_t"=0, phase: "float"=0) -> "gr::analog::sig_source< int >::sptr":
        r"""make(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, std::int32_t offset=0, float phase=0) -> sig_source_i_sptr"""
        return _analog_swig.sig_source_i_make(sampling_freq, waveform, wave_freq, ampl, offset, phase)

    def sampling_freq(self) -> "double":
        r"""sampling_freq(sig_source_i self) -> double"""
        return _analog_swig.sig_source_i_sampling_freq(self)

    def waveform(self) -> "gr::analog::gr_waveform_t":
        r"""waveform(sig_source_i self) -> gr::analog::gr_waveform_t"""
        return _analog_swig.sig_source_i_waveform(self)

    def frequency(self) -> "double":
        r"""frequency(sig_source_i self) -> double"""
        return _analog_swig.sig_source_i_frequency(self)

    def amplitude(self) -> "double":
        r"""amplitude(sig_source_i self) -> double"""
        return _analog_swig.sig_source_i_amplitude(self)

    def offset(self) -> "std::int32_t":
        r"""offset(sig_source_i self) -> std::int32_t"""
        return _analog_swig.sig_source_i_offset(self)

    def phase(self) -> "float":
        r"""phase(sig_source_i self) -> float"""
        return _analog_swig.sig_source_i_phase(self)

    def set_sampling_freq(self, sampling_freq: "double") -> "void":
        r"""set_sampling_freq(sig_source_i self, double sampling_freq)"""
        return _analog_swig.sig_source_i_set_sampling_freq(self, sampling_freq)

    def set_waveform(self, waveform: "gr::analog::gr_waveform_t") -> "void":
        r"""set_waveform(sig_source_i self, gr::analog::gr_waveform_t waveform)"""
        return _analog_swig.sig_source_i_set_waveform(self, waveform)

    def set_frequency(self, frequency: "double") -> "void":
        r"""set_frequency(sig_source_i self, double frequency)"""
        return _analog_swig.sig_source_i_set_frequency(self, frequency)

    def set_amplitude(self, ampl: "double") -> "void":
        r"""set_amplitude(sig_source_i self, double ampl)"""
        return _analog_swig.sig_source_i_set_amplitude(self, ampl)

    def set_offset(self, offset: "std::int32_t") -> "void":
        r"""set_offset(sig_source_i self, std::int32_t offset)"""
        return _analog_swig.sig_source_i_set_offset(self, offset)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(sig_source_i self, float phase)"""
        return _analog_swig.sig_source_i_set_phase(self, phase)
    __swig_destroy__ = _analog_swig.delete_sig_source_i

# Register sig_source_i in _analog_swig:
_analog_swig.sig_source_i_swigregister(sig_source_i)

def sig_source_i_make(sampling_freq: "double", waveform: "gr::analog::gr_waveform_t", wave_freq: "double", ampl: "double", offset: "std::int32_t"=0, phase: "float"=0) -> "gr::analog::sig_source< int >::sptr":
    r"""sig_source_i_make(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, std::int32_t offset=0, float phase=0) -> sig_source_i_sptr"""
    return _analog_swig.sig_source_i_make(sampling_freq, waveform, wave_freq, ampl, offset, phase)

class sig_source_i_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::sig_source< std::int32_t > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(sig_source_i_sptr self) -> sig_source_i_sptr
        __init__(sig_source_i_sptr self, sig_source_i p) -> sig_source_i_sptr
        """
        _analog_swig.sig_source_i_sptr_swiginit(self, _analog_swig.new_sig_source_i_sptr(*args))

    def __deref__(self) -> "gr::analog::sig_source< std::int32_t > *":
        r"""__deref__(sig_source_i_sptr self) -> sig_source_i"""
        return _analog_swig.sig_source_i_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_sig_source_i_sptr

    def make(self, sampling_freq: "double", waveform: "gr::analog::gr_waveform_t", wave_freq: "double", ampl: "double", offset: "std::int32_t"=0, phase: "float"=0) -> "gr::analog::sig_source< int >::sptr":
        r"""make(sig_source_i_sptr self, double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, std::int32_t offset=0, float phase=0) -> sig_source_i_sptr"""
        return _analog_swig.sig_source_i_sptr_make(self, sampling_freq, waveform, wave_freq, ampl, offset, phase)

    def sampling_freq(self) -> "double":
        r"""sampling_freq(sig_source_i_sptr self) -> double"""
        return _analog_swig.sig_source_i_sptr_sampling_freq(self)

    def waveform(self) -> "gr::analog::gr_waveform_t":
        r"""waveform(sig_source_i_sptr self) -> gr::analog::gr_waveform_t"""
        return _analog_swig.sig_source_i_sptr_waveform(self)

    def frequency(self) -> "double":
        r"""frequency(sig_source_i_sptr self) -> double"""
        return _analog_swig.sig_source_i_sptr_frequency(self)

    def amplitude(self) -> "double":
        r"""amplitude(sig_source_i_sptr self) -> double"""
        return _analog_swig.sig_source_i_sptr_amplitude(self)

    def offset(self) -> "std::int32_t":
        r"""offset(sig_source_i_sptr self) -> std::int32_t"""
        return _analog_swig.sig_source_i_sptr_offset(self)

    def phase(self) -> "float":
        r"""phase(sig_source_i_sptr self) -> float"""
        return _analog_swig.sig_source_i_sptr_phase(self)

    def set_sampling_freq(self, sampling_freq: "double") -> "void":
        r"""set_sampling_freq(sig_source_i_sptr self, double sampling_freq)"""
        return _analog_swig.sig_source_i_sptr_set_sampling_freq(self, sampling_freq)

    def set_waveform(self, waveform: "gr::analog::gr_waveform_t") -> "void":
        r"""set_waveform(sig_source_i_sptr self, gr::analog::gr_waveform_t waveform)"""
        return _analog_swig.sig_source_i_sptr_set_waveform(self, waveform)

    def set_frequency(self, frequency: "double") -> "void":
        r"""set_frequency(sig_source_i_sptr self, double frequency)"""
        return _analog_swig.sig_source_i_sptr_set_frequency(self, frequency)

    def set_amplitude(self, ampl: "double") -> "void":
        r"""set_amplitude(sig_source_i_sptr self, double ampl)"""
        return _analog_swig.sig_source_i_sptr_set_amplitude(self, ampl)

    def set_offset(self, offset: "std::int32_t") -> "void":
        r"""set_offset(sig_source_i_sptr self, std::int32_t offset)"""
        return _analog_swig.sig_source_i_sptr_set_offset(self, offset)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(sig_source_i_sptr self, float phase)"""
        return _analog_swig.sig_source_i_sptr_set_phase(self, phase)

    def history(self) -> "unsigned int":
        r"""history(sig_source_i_sptr self) -> unsigned int"""
        return _analog_swig.sig_source_i_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(sig_source_i_sptr self, int which, int delay)
        declare_sample_delay(sig_source_i_sptr self, unsigned int delay)
        """
        return _analog_swig.sig_source_i_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(sig_source_i_sptr self, int which) -> unsigned int"""
        return _analog_swig.sig_source_i_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(sig_source_i_sptr self, int multiple)"""
        return _analog_swig.sig_source_i_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(sig_source_i_sptr self) -> int"""
        return _analog_swig.sig_source_i_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(sig_source_i_sptr self) -> double"""
        return _analog_swig.sig_source_i_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(sig_source_i_sptr self) -> uint64_t"""
        return _analog_swig.sig_source_i_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(sig_source_i_sptr self) -> uint64_t"""
        return _analog_swig.sig_source_i_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(sig_source_i_sptr self) -> bool"""
        return _analog_swig.sig_source_i_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(sig_source_i_sptr self) -> bool"""
        return _analog_swig.sig_source_i_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(sig_source_i_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.sig_source_i_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(sig_source_i_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.sig_source_i_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(sig_source_i_sptr self, std::string level)"""
        return _analog_swig.sig_source_i_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(sig_source_i_sptr self) -> std::string"""
        return _analog_swig.sig_source_i_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(sig_source_i_sptr self) -> int"""
        return _analog_swig.sig_source_i_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(sig_source_i_sptr self, int m)"""
        return _analog_swig.sig_source_i_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(sig_source_i_sptr self)"""
        return _analog_swig.sig_source_i_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(sig_source_i_sptr self) -> bool"""
        return _analog_swig.sig_source_i_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(sig_source_i_sptr self, int m)"""
        return _analog_swig.sig_source_i_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(sig_source_i_sptr self) -> int"""
        return _analog_swig.sig_source_i_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(sig_source_i_sptr self, int i) -> long"""
        return _analog_swig.sig_source_i_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(sig_source_i_sptr self, long max_output_buffer)
        set_max_output_buffer(sig_source_i_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.sig_source_i_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(sig_source_i_sptr self, int i) -> long"""
        return _analog_swig.sig_source_i_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(sig_source_i_sptr self, long min_output_buffer)
        set_min_output_buffer(sig_source_i_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.sig_source_i_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(sig_source_i_sptr self) -> float"""
        return _analog_swig.sig_source_i_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(sig_source_i_sptr self) -> float"""
        return _analog_swig.sig_source_i_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(sig_source_i_sptr self) -> float"""
        return _analog_swig.sig_source_i_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(sig_source_i_sptr self) -> float"""
        return _analog_swig.sig_source_i_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(sig_source_i_sptr self) -> float"""
        return _analog_swig.sig_source_i_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(sig_source_i_sptr self) -> float"""
        return _analog_swig.sig_source_i_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(sig_source_i_sptr self, int which) -> float
        pc_input_buffers_full(sig_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_i_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(sig_source_i_sptr self, int which) -> float
        pc_input_buffers_full_avg(sig_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_i_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(sig_source_i_sptr self, int which) -> float
        pc_input_buffers_full_var(sig_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_i_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(sig_source_i_sptr self, int which) -> float
        pc_output_buffers_full(sig_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_i_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(sig_source_i_sptr self, int which) -> float
        pc_output_buffers_full_avg(sig_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_i_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(sig_source_i_sptr self, int which) -> float
        pc_output_buffers_full_var(sig_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_i_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(sig_source_i_sptr self) -> float"""
        return _analog_swig.sig_source_i_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(sig_source_i_sptr self) -> float"""
        return _analog_swig.sig_source_i_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(sig_source_i_sptr self) -> float"""
        return _analog_swig.sig_source_i_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(sig_source_i_sptr self) -> float"""
        return _analog_swig.sig_source_i_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(sig_source_i_sptr self) -> float"""
        return _analog_swig.sig_source_i_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(sig_source_i_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.sig_source_i_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(sig_source_i_sptr self)"""
        return _analog_swig.sig_source_i_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(sig_source_i_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.sig_source_i_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(sig_source_i_sptr self) -> int"""
        return _analog_swig.sig_source_i_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(sig_source_i_sptr self) -> int"""
        return _analog_swig.sig_source_i_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(sig_source_i_sptr self, int priority) -> int"""
        return _analog_swig.sig_source_i_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(sig_source_i_sptr self) -> std::string"""
        return _analog_swig.sig_source_i_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(sig_source_i_sptr self) -> std::string"""
        return _analog_swig.sig_source_i_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(sig_source_i_sptr self) -> io_signature_sptr"""
        return _analog_swig.sig_source_i_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(sig_source_i_sptr self) -> io_signature_sptr"""
        return _analog_swig.sig_source_i_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(sig_source_i_sptr self) -> long"""
        return _analog_swig.sig_source_i_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(sig_source_i_sptr self) -> basic_block_sptr"""
        return _analog_swig.sig_source_i_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(sig_source_i_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.sig_source_i_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(sig_source_i_sptr self) -> std::string"""
        return _analog_swig.sig_source_i_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(sig_source_i_sptr self, std::string name)"""
        return _analog_swig.sig_source_i_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(sig_source_i_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.sig_source_i_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(sig_source_i_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.sig_source_i_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(sig_source_i_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.sig_source_i_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(sig_source_i_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.sig_source_i_sptr_message_subscribers(self, which_port)

# Register sig_source_i_sptr in _analog_swig:
_analog_swig.sig_source_i_sptr_swigregister(sig_source_i_sptr)


sig_source_i_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
sig_source_i = sig_source_i.make

class sig_source_f(object):
    r"""Proxy of C++ gr::analog::sig_source< float > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(sampling_freq: "double", waveform: "gr::analog::gr_waveform_t", wave_freq: "double", ampl: "double", offset: "float"=0, phase: "float"=0) -> "gr::analog::sig_source< float >::sptr":
        r"""make(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, float offset=0, float phase=0) -> sig_source_f_sptr"""
        return _analog_swig.sig_source_f_make(sampling_freq, waveform, wave_freq, ampl, offset, phase)

    def sampling_freq(self) -> "double":
        r"""sampling_freq(sig_source_f self) -> double"""
        return _analog_swig.sig_source_f_sampling_freq(self)

    def waveform(self) -> "gr::analog::gr_waveform_t":
        r"""waveform(sig_source_f self) -> gr::analog::gr_waveform_t"""
        return _analog_swig.sig_source_f_waveform(self)

    def frequency(self) -> "double":
        r"""frequency(sig_source_f self) -> double"""
        return _analog_swig.sig_source_f_frequency(self)

    def amplitude(self) -> "double":
        r"""amplitude(sig_source_f self) -> double"""
        return _analog_swig.sig_source_f_amplitude(self)

    def offset(self) -> "float":
        r"""offset(sig_source_f self) -> float"""
        return _analog_swig.sig_source_f_offset(self)

    def phase(self) -> "float":
        r"""phase(sig_source_f self) -> float"""
        return _analog_swig.sig_source_f_phase(self)

    def set_sampling_freq(self, sampling_freq: "double") -> "void":
        r"""set_sampling_freq(sig_source_f self, double sampling_freq)"""
        return _analog_swig.sig_source_f_set_sampling_freq(self, sampling_freq)

    def set_waveform(self, waveform: "gr::analog::gr_waveform_t") -> "void":
        r"""set_waveform(sig_source_f self, gr::analog::gr_waveform_t waveform)"""
        return _analog_swig.sig_source_f_set_waveform(self, waveform)

    def set_frequency(self, frequency: "double") -> "void":
        r"""set_frequency(sig_source_f self, double frequency)"""
        return _analog_swig.sig_source_f_set_frequency(self, frequency)

    def set_amplitude(self, ampl: "double") -> "void":
        r"""set_amplitude(sig_source_f self, double ampl)"""
        return _analog_swig.sig_source_f_set_amplitude(self, ampl)

    def set_offset(self, offset: "float") -> "void":
        r"""set_offset(sig_source_f self, float offset)"""
        return _analog_swig.sig_source_f_set_offset(self, offset)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(sig_source_f self, float phase)"""
        return _analog_swig.sig_source_f_set_phase(self, phase)
    __swig_destroy__ = _analog_swig.delete_sig_source_f

# Register sig_source_f in _analog_swig:
_analog_swig.sig_source_f_swigregister(sig_source_f)

def sig_source_f_make(sampling_freq: "double", waveform: "gr::analog::gr_waveform_t", wave_freq: "double", ampl: "double", offset: "float"=0, phase: "float"=0) -> "gr::analog::sig_source< float >::sptr":
    r"""sig_source_f_make(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, float offset=0, float phase=0) -> sig_source_f_sptr"""
    return _analog_swig.sig_source_f_make(sampling_freq, waveform, wave_freq, ampl, offset, phase)

class sig_source_f_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::sig_source< float > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(sig_source_f_sptr self) -> sig_source_f_sptr
        __init__(sig_source_f_sptr self, sig_source_f p) -> sig_source_f_sptr
        """
        _analog_swig.sig_source_f_sptr_swiginit(self, _analog_swig.new_sig_source_f_sptr(*args))

    def __deref__(self) -> "gr::analog::sig_source< float > *":
        r"""__deref__(sig_source_f_sptr self) -> sig_source_f"""
        return _analog_swig.sig_source_f_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_sig_source_f_sptr

    def make(self, sampling_freq: "double", waveform: "gr::analog::gr_waveform_t", wave_freq: "double", ampl: "double", offset: "float"=0, phase: "float"=0) -> "gr::analog::sig_source< float >::sptr":
        r"""make(sig_source_f_sptr self, double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, float offset=0, float phase=0) -> sig_source_f_sptr"""
        return _analog_swig.sig_source_f_sptr_make(self, sampling_freq, waveform, wave_freq, ampl, offset, phase)

    def sampling_freq(self) -> "double":
        r"""sampling_freq(sig_source_f_sptr self) -> double"""
        return _analog_swig.sig_source_f_sptr_sampling_freq(self)

    def waveform(self) -> "gr::analog::gr_waveform_t":
        r"""waveform(sig_source_f_sptr self) -> gr::analog::gr_waveform_t"""
        return _analog_swig.sig_source_f_sptr_waveform(self)

    def frequency(self) -> "double":
        r"""frequency(sig_source_f_sptr self) -> double"""
        return _analog_swig.sig_source_f_sptr_frequency(self)

    def amplitude(self) -> "double":
        r"""amplitude(sig_source_f_sptr self) -> double"""
        return _analog_swig.sig_source_f_sptr_amplitude(self)

    def offset(self) -> "float":
        r"""offset(sig_source_f_sptr self) -> float"""
        return _analog_swig.sig_source_f_sptr_offset(self)

    def phase(self) -> "float":
        r"""phase(sig_source_f_sptr self) -> float"""
        return _analog_swig.sig_source_f_sptr_phase(self)

    def set_sampling_freq(self, sampling_freq: "double") -> "void":
        r"""set_sampling_freq(sig_source_f_sptr self, double sampling_freq)"""
        return _analog_swig.sig_source_f_sptr_set_sampling_freq(self, sampling_freq)

    def set_waveform(self, waveform: "gr::analog::gr_waveform_t") -> "void":
        r"""set_waveform(sig_source_f_sptr self, gr::analog::gr_waveform_t waveform)"""
        return _analog_swig.sig_source_f_sptr_set_waveform(self, waveform)

    def set_frequency(self, frequency: "double") -> "void":
        r"""set_frequency(sig_source_f_sptr self, double frequency)"""
        return _analog_swig.sig_source_f_sptr_set_frequency(self, frequency)

    def set_amplitude(self, ampl: "double") -> "void":
        r"""set_amplitude(sig_source_f_sptr self, double ampl)"""
        return _analog_swig.sig_source_f_sptr_set_amplitude(self, ampl)

    def set_offset(self, offset: "float") -> "void":
        r"""set_offset(sig_source_f_sptr self, float offset)"""
        return _analog_swig.sig_source_f_sptr_set_offset(self, offset)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(sig_source_f_sptr self, float phase)"""
        return _analog_swig.sig_source_f_sptr_set_phase(self, phase)

    def history(self) -> "unsigned int":
        r"""history(sig_source_f_sptr self) -> unsigned int"""
        return _analog_swig.sig_source_f_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(sig_source_f_sptr self, int which, int delay)
        declare_sample_delay(sig_source_f_sptr self, unsigned int delay)
        """
        return _analog_swig.sig_source_f_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(sig_source_f_sptr self, int which) -> unsigned int"""
        return _analog_swig.sig_source_f_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(sig_source_f_sptr self, int multiple)"""
        return _analog_swig.sig_source_f_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(sig_source_f_sptr self) -> int"""
        return _analog_swig.sig_source_f_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(sig_source_f_sptr self) -> double"""
        return _analog_swig.sig_source_f_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(sig_source_f_sptr self) -> uint64_t"""
        return _analog_swig.sig_source_f_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(sig_source_f_sptr self) -> uint64_t"""
        return _analog_swig.sig_source_f_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(sig_source_f_sptr self) -> bool"""
        return _analog_swig.sig_source_f_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(sig_source_f_sptr self) -> bool"""
        return _analog_swig.sig_source_f_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(sig_source_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.sig_source_f_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(sig_source_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.sig_source_f_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(sig_source_f_sptr self, std::string level)"""
        return _analog_swig.sig_source_f_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(sig_source_f_sptr self) -> std::string"""
        return _analog_swig.sig_source_f_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(sig_source_f_sptr self) -> int"""
        return _analog_swig.sig_source_f_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(sig_source_f_sptr self, int m)"""
        return _analog_swig.sig_source_f_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(sig_source_f_sptr self)"""
        return _analog_swig.sig_source_f_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(sig_source_f_sptr self) -> bool"""
        return _analog_swig.sig_source_f_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(sig_source_f_sptr self, int m)"""
        return _analog_swig.sig_source_f_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(sig_source_f_sptr self) -> int"""
        return _analog_swig.sig_source_f_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(sig_source_f_sptr self, int i) -> long"""
        return _analog_swig.sig_source_f_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(sig_source_f_sptr self, long max_output_buffer)
        set_max_output_buffer(sig_source_f_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.sig_source_f_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(sig_source_f_sptr self, int i) -> long"""
        return _analog_swig.sig_source_f_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(sig_source_f_sptr self, long min_output_buffer)
        set_min_output_buffer(sig_source_f_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.sig_source_f_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(sig_source_f_sptr self) -> float"""
        return _analog_swig.sig_source_f_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(sig_source_f_sptr self) -> float"""
        return _analog_swig.sig_source_f_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(sig_source_f_sptr self) -> float"""
        return _analog_swig.sig_source_f_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(sig_source_f_sptr self) -> float"""
        return _analog_swig.sig_source_f_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(sig_source_f_sptr self) -> float"""
        return _analog_swig.sig_source_f_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(sig_source_f_sptr self) -> float"""
        return _analog_swig.sig_source_f_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(sig_source_f_sptr self, int which) -> float
        pc_input_buffers_full(sig_source_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_f_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(sig_source_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(sig_source_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_f_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(sig_source_f_sptr self, int which) -> float
        pc_input_buffers_full_var(sig_source_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_f_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(sig_source_f_sptr self, int which) -> float
        pc_output_buffers_full(sig_source_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_f_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(sig_source_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(sig_source_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_f_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(sig_source_f_sptr self, int which) -> float
        pc_output_buffers_full_var(sig_source_f_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_f_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(sig_source_f_sptr self) -> float"""
        return _analog_swig.sig_source_f_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(sig_source_f_sptr self) -> float"""
        return _analog_swig.sig_source_f_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(sig_source_f_sptr self) -> float"""
        return _analog_swig.sig_source_f_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(sig_source_f_sptr self) -> float"""
        return _analog_swig.sig_source_f_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(sig_source_f_sptr self) -> float"""
        return _analog_swig.sig_source_f_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(sig_source_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.sig_source_f_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(sig_source_f_sptr self)"""
        return _analog_swig.sig_source_f_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(sig_source_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.sig_source_f_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(sig_source_f_sptr self) -> int"""
        return _analog_swig.sig_source_f_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(sig_source_f_sptr self) -> int"""
        return _analog_swig.sig_source_f_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(sig_source_f_sptr self, int priority) -> int"""
        return _analog_swig.sig_source_f_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(sig_source_f_sptr self) -> std::string"""
        return _analog_swig.sig_source_f_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(sig_source_f_sptr self) -> std::string"""
        return _analog_swig.sig_source_f_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(sig_source_f_sptr self) -> io_signature_sptr"""
        return _analog_swig.sig_source_f_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(sig_source_f_sptr self) -> io_signature_sptr"""
        return _analog_swig.sig_source_f_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(sig_source_f_sptr self) -> long"""
        return _analog_swig.sig_source_f_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(sig_source_f_sptr self) -> basic_block_sptr"""
        return _analog_swig.sig_source_f_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(sig_source_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.sig_source_f_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(sig_source_f_sptr self) -> std::string"""
        return _analog_swig.sig_source_f_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(sig_source_f_sptr self, std::string name)"""
        return _analog_swig.sig_source_f_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(sig_source_f_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.sig_source_f_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(sig_source_f_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.sig_source_f_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(sig_source_f_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.sig_source_f_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(sig_source_f_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.sig_source_f_sptr_message_subscribers(self, which_port)

# Register sig_source_f_sptr in _analog_swig:
_analog_swig.sig_source_f_sptr_swigregister(sig_source_f_sptr)


sig_source_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
sig_source_f = sig_source_f.make

class sig_source_c(object):
    r"""Proxy of C++ gr::analog::sig_source< gr_complex > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(sampling_freq: "double", waveform: "gr::analog::gr_waveform_t", wave_freq: "double", ampl: "double", offset: "std::complex< float >"=0, phase: "float"=0) -> "gr::analog::sig_source< std::complex< float > >::sptr":
        r"""make(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, std::complex< float > offset=0, float phase=0) -> sig_source_c_sptr"""
        return _analog_swig.sig_source_c_make(sampling_freq, waveform, wave_freq, ampl, offset, phase)

    def sampling_freq(self) -> "double":
        r"""sampling_freq(sig_source_c self) -> double"""
        return _analog_swig.sig_source_c_sampling_freq(self)

    def waveform(self) -> "gr::analog::gr_waveform_t":
        r"""waveform(sig_source_c self) -> gr::analog::gr_waveform_t"""
        return _analog_swig.sig_source_c_waveform(self)

    def frequency(self) -> "double":
        r"""frequency(sig_source_c self) -> double"""
        return _analog_swig.sig_source_c_frequency(self)

    def amplitude(self) -> "double":
        r"""amplitude(sig_source_c self) -> double"""
        return _analog_swig.sig_source_c_amplitude(self)

    def offset(self) -> "std::complex< float >":
        r"""offset(sig_source_c self) -> std::complex< float >"""
        return _analog_swig.sig_source_c_offset(self)

    def phase(self) -> "float":
        r"""phase(sig_source_c self) -> float"""
        return _analog_swig.sig_source_c_phase(self)

    def set_sampling_freq(self, sampling_freq: "double") -> "void":
        r"""set_sampling_freq(sig_source_c self, double sampling_freq)"""
        return _analog_swig.sig_source_c_set_sampling_freq(self, sampling_freq)

    def set_waveform(self, waveform: "gr::analog::gr_waveform_t") -> "void":
        r"""set_waveform(sig_source_c self, gr::analog::gr_waveform_t waveform)"""
        return _analog_swig.sig_source_c_set_waveform(self, waveform)

    def set_frequency(self, frequency: "double") -> "void":
        r"""set_frequency(sig_source_c self, double frequency)"""
        return _analog_swig.sig_source_c_set_frequency(self, frequency)

    def set_amplitude(self, ampl: "double") -> "void":
        r"""set_amplitude(sig_source_c self, double ampl)"""
        return _analog_swig.sig_source_c_set_amplitude(self, ampl)

    def set_offset(self, offset: "std::complex< float >") -> "void":
        r"""set_offset(sig_source_c self, std::complex< float > offset)"""
        return _analog_swig.sig_source_c_set_offset(self, offset)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(sig_source_c self, float phase)"""
        return _analog_swig.sig_source_c_set_phase(self, phase)
    __swig_destroy__ = _analog_swig.delete_sig_source_c

# Register sig_source_c in _analog_swig:
_analog_swig.sig_source_c_swigregister(sig_source_c)

def sig_source_c_make(sampling_freq: "double", waveform: "gr::analog::gr_waveform_t", wave_freq: "double", ampl: "double", offset: "std::complex< float >"=0, phase: "float"=0) -> "gr::analog::sig_source< std::complex< float > >::sptr":
    r"""sig_source_c_make(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, std::complex< float > offset=0, float phase=0) -> sig_source_c_sptr"""
    return _analog_swig.sig_source_c_make(sampling_freq, waveform, wave_freq, ampl, offset, phase)

class sig_source_c_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::sig_source< gr_complex > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(sig_source_c_sptr self) -> sig_source_c_sptr
        __init__(sig_source_c_sptr self, sig_source_c p) -> sig_source_c_sptr
        """
        _analog_swig.sig_source_c_sptr_swiginit(self, _analog_swig.new_sig_source_c_sptr(*args))

    def __deref__(self) -> "gr::analog::sig_source< gr_complex > *":
        r"""__deref__(sig_source_c_sptr self) -> sig_source_c"""
        return _analog_swig.sig_source_c_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_sig_source_c_sptr

    def make(self, sampling_freq: "double", waveform: "gr::analog::gr_waveform_t", wave_freq: "double", ampl: "double", offset: "std::complex< float >"=0, phase: "float"=0) -> "gr::analog::sig_source< std::complex< float > >::sptr":
        r"""make(sig_source_c_sptr self, double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, std::complex< float > offset=0, float phase=0) -> sig_source_c_sptr"""
        return _analog_swig.sig_source_c_sptr_make(self, sampling_freq, waveform, wave_freq, ampl, offset, phase)

    def sampling_freq(self) -> "double":
        r"""sampling_freq(sig_source_c_sptr self) -> double"""
        return _analog_swig.sig_source_c_sptr_sampling_freq(self)

    def waveform(self) -> "gr::analog::gr_waveform_t":
        r"""waveform(sig_source_c_sptr self) -> gr::analog::gr_waveform_t"""
        return _analog_swig.sig_source_c_sptr_waveform(self)

    def frequency(self) -> "double":
        r"""frequency(sig_source_c_sptr self) -> double"""
        return _analog_swig.sig_source_c_sptr_frequency(self)

    def amplitude(self) -> "double":
        r"""amplitude(sig_source_c_sptr self) -> double"""
        return _analog_swig.sig_source_c_sptr_amplitude(self)

    def offset(self) -> "std::complex< float >":
        r"""offset(sig_source_c_sptr self) -> std::complex< float >"""
        return _analog_swig.sig_source_c_sptr_offset(self)

    def phase(self) -> "float":
        r"""phase(sig_source_c_sptr self) -> float"""
        return _analog_swig.sig_source_c_sptr_phase(self)

    def set_sampling_freq(self, sampling_freq: "double") -> "void":
        r"""set_sampling_freq(sig_source_c_sptr self, double sampling_freq)"""
        return _analog_swig.sig_source_c_sptr_set_sampling_freq(self, sampling_freq)

    def set_waveform(self, waveform: "gr::analog::gr_waveform_t") -> "void":
        r"""set_waveform(sig_source_c_sptr self, gr::analog::gr_waveform_t waveform)"""
        return _analog_swig.sig_source_c_sptr_set_waveform(self, waveform)

    def set_frequency(self, frequency: "double") -> "void":
        r"""set_frequency(sig_source_c_sptr self, double frequency)"""
        return _analog_swig.sig_source_c_sptr_set_frequency(self, frequency)

    def set_amplitude(self, ampl: "double") -> "void":
        r"""set_amplitude(sig_source_c_sptr self, double ampl)"""
        return _analog_swig.sig_source_c_sptr_set_amplitude(self, ampl)

    def set_offset(self, offset: "std::complex< float >") -> "void":
        r"""set_offset(sig_source_c_sptr self, std::complex< float > offset)"""
        return _analog_swig.sig_source_c_sptr_set_offset(self, offset)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(sig_source_c_sptr self, float phase)"""
        return _analog_swig.sig_source_c_sptr_set_phase(self, phase)

    def history(self) -> "unsigned int":
        r"""history(sig_source_c_sptr self) -> unsigned int"""
        return _analog_swig.sig_source_c_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(sig_source_c_sptr self, int which, int delay)
        declare_sample_delay(sig_source_c_sptr self, unsigned int delay)
        """
        return _analog_swig.sig_source_c_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(sig_source_c_sptr self, int which) -> unsigned int"""
        return _analog_swig.sig_source_c_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(sig_source_c_sptr self, int multiple)"""
        return _analog_swig.sig_source_c_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(sig_source_c_sptr self) -> int"""
        return _analog_swig.sig_source_c_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(sig_source_c_sptr self) -> double"""
        return _analog_swig.sig_source_c_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(sig_source_c_sptr self) -> uint64_t"""
        return _analog_swig.sig_source_c_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(sig_source_c_sptr self) -> uint64_t"""
        return _analog_swig.sig_source_c_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(sig_source_c_sptr self) -> bool"""
        return _analog_swig.sig_source_c_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(sig_source_c_sptr self) -> bool"""
        return _analog_swig.sig_source_c_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(sig_source_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.sig_source_c_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(sig_source_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.sig_source_c_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(sig_source_c_sptr self, std::string level)"""
        return _analog_swig.sig_source_c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(sig_source_c_sptr self) -> std::string"""
        return _analog_swig.sig_source_c_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(sig_source_c_sptr self) -> int"""
        return _analog_swig.sig_source_c_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(sig_source_c_sptr self, int m)"""
        return _analog_swig.sig_source_c_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(sig_source_c_sptr self)"""
        return _analog_swig.sig_source_c_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(sig_source_c_sptr self) -> bool"""
        return _analog_swig.sig_source_c_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(sig_source_c_sptr self, int m)"""
        return _analog_swig.sig_source_c_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(sig_source_c_sptr self) -> int"""
        return _analog_swig.sig_source_c_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(sig_source_c_sptr self, int i) -> long"""
        return _analog_swig.sig_source_c_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(sig_source_c_sptr self, long max_output_buffer)
        set_max_output_buffer(sig_source_c_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.sig_source_c_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(sig_source_c_sptr self, int i) -> long"""
        return _analog_swig.sig_source_c_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(sig_source_c_sptr self, long min_output_buffer)
        set_min_output_buffer(sig_source_c_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.sig_source_c_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(sig_source_c_sptr self) -> float"""
        return _analog_swig.sig_source_c_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(sig_source_c_sptr self) -> float"""
        return _analog_swig.sig_source_c_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(sig_source_c_sptr self) -> float"""
        return _analog_swig.sig_source_c_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(sig_source_c_sptr self) -> float"""
        return _analog_swig.sig_source_c_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(sig_source_c_sptr self) -> float"""
        return _analog_swig.sig_source_c_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(sig_source_c_sptr self) -> float"""
        return _analog_swig.sig_source_c_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(sig_source_c_sptr self, int which) -> float
        pc_input_buffers_full(sig_source_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_c_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(sig_source_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(sig_source_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_c_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(sig_source_c_sptr self, int which) -> float
        pc_input_buffers_full_var(sig_source_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_c_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(sig_source_c_sptr self, int which) -> float
        pc_output_buffers_full(sig_source_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_c_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(sig_source_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(sig_source_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_c_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(sig_source_c_sptr self, int which) -> float
        pc_output_buffers_full_var(sig_source_c_sptr self) -> pmt_vector_float
        """
        return _analog_swig.sig_source_c_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(sig_source_c_sptr self) -> float"""
        return _analog_swig.sig_source_c_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(sig_source_c_sptr self) -> float"""
        return _analog_swig.sig_source_c_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(sig_source_c_sptr self) -> float"""
        return _analog_swig.sig_source_c_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(sig_source_c_sptr self) -> float"""
        return _analog_swig.sig_source_c_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(sig_source_c_sptr self) -> float"""
        return _analog_swig.sig_source_c_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(sig_source_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.sig_source_c_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(sig_source_c_sptr self)"""
        return _analog_swig.sig_source_c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(sig_source_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.sig_source_c_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(sig_source_c_sptr self) -> int"""
        return _analog_swig.sig_source_c_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(sig_source_c_sptr self) -> int"""
        return _analog_swig.sig_source_c_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(sig_source_c_sptr self, int priority) -> int"""
        return _analog_swig.sig_source_c_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(sig_source_c_sptr self) -> std::string"""
        return _analog_swig.sig_source_c_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(sig_source_c_sptr self) -> std::string"""
        return _analog_swig.sig_source_c_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(sig_source_c_sptr self) -> io_signature_sptr"""
        return _analog_swig.sig_source_c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(sig_source_c_sptr self) -> io_signature_sptr"""
        return _analog_swig.sig_source_c_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(sig_source_c_sptr self) -> long"""
        return _analog_swig.sig_source_c_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(sig_source_c_sptr self) -> basic_block_sptr"""
        return _analog_swig.sig_source_c_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(sig_source_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.sig_source_c_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(sig_source_c_sptr self) -> std::string"""
        return _analog_swig.sig_source_c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(sig_source_c_sptr self, std::string name)"""
        return _analog_swig.sig_source_c_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(sig_source_c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.sig_source_c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(sig_source_c_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.sig_source_c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(sig_source_c_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.sig_source_c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(sig_source_c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.sig_source_c_sptr_message_subscribers(self, which_port)

# Register sig_source_c_sptr in _analog_swig:
_analog_swig.sig_source_c_sptr_swigregister(sig_source_c_sptr)


sig_source_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
sig_source_c = sig_source_c.make

class simple_squelch_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::simple_squelch_cc > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(simple_squelch_cc_sptr self) -> simple_squelch_cc_sptr
        __init__(simple_squelch_cc_sptr self, simple_squelch_cc p) -> simple_squelch_cc_sptr
        """
        _analog_swig.simple_squelch_cc_sptr_swiginit(self, _analog_swig.new_simple_squelch_cc_sptr(*args))

    def __deref__(self) -> "gr::analog::simple_squelch_cc *":
        r"""__deref__(simple_squelch_cc_sptr self) -> simple_squelch_cc"""
        return _analog_swig.simple_squelch_cc_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_simple_squelch_cc_sptr

    def make(self, threshold_db: "double", alpha: "double") -> "gr::analog::simple_squelch_cc::sptr":
        r"""make(simple_squelch_cc_sptr self, double threshold_db, double alpha) -> simple_squelch_cc_sptr"""
        return _analog_swig.simple_squelch_cc_sptr_make(self, threshold_db, alpha)

    def unmuted(self) -> "bool":
        r"""unmuted(simple_squelch_cc_sptr self) -> bool"""
        return _analog_swig.simple_squelch_cc_sptr_unmuted(self)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(simple_squelch_cc_sptr self, double alpha)"""
        return _analog_swig.simple_squelch_cc_sptr_set_alpha(self, alpha)

    def set_threshold(self, decibels: "double") -> "void":
        r"""set_threshold(simple_squelch_cc_sptr self, double decibels)"""
        return _analog_swig.simple_squelch_cc_sptr_set_threshold(self, decibels)

    def threshold(self) -> "double":
        r"""threshold(simple_squelch_cc_sptr self) -> double"""
        return _analog_swig.simple_squelch_cc_sptr_threshold(self)

    def squelch_range(self) -> "std::vector< float,std::allocator< float > >":
        r"""squelch_range(simple_squelch_cc_sptr self) -> pmt_vector_float"""
        return _analog_swig.simple_squelch_cc_sptr_squelch_range(self)

    def history(self) -> "unsigned int":
        r"""history(simple_squelch_cc_sptr self) -> unsigned int"""
        return _analog_swig.simple_squelch_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(simple_squelch_cc_sptr self, int which, int delay)
        declare_sample_delay(simple_squelch_cc_sptr self, unsigned int delay)
        """
        return _analog_swig.simple_squelch_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(simple_squelch_cc_sptr self, int which) -> unsigned int"""
        return _analog_swig.simple_squelch_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(simple_squelch_cc_sptr self, int multiple)"""
        return _analog_swig.simple_squelch_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(simple_squelch_cc_sptr self) -> int"""
        return _analog_swig.simple_squelch_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(simple_squelch_cc_sptr self) -> double"""
        return _analog_swig.simple_squelch_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(simple_squelch_cc_sptr self) -> uint64_t"""
        return _analog_swig.simple_squelch_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(simple_squelch_cc_sptr self) -> uint64_t"""
        return _analog_swig.simple_squelch_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(simple_squelch_cc_sptr self) -> bool"""
        return _analog_swig.simple_squelch_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(simple_squelch_cc_sptr self) -> bool"""
        return _analog_swig.simple_squelch_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(simple_squelch_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.simple_squelch_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(simple_squelch_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.simple_squelch_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(simple_squelch_cc_sptr self, std::string level)"""
        return _analog_swig.simple_squelch_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(simple_squelch_cc_sptr self) -> std::string"""
        return _analog_swig.simple_squelch_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(simple_squelch_cc_sptr self) -> int"""
        return _analog_swig.simple_squelch_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(simple_squelch_cc_sptr self, int m)"""
        return _analog_swig.simple_squelch_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(simple_squelch_cc_sptr self)"""
        return _analog_swig.simple_squelch_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(simple_squelch_cc_sptr self) -> bool"""
        return _analog_swig.simple_squelch_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(simple_squelch_cc_sptr self, int m)"""
        return _analog_swig.simple_squelch_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(simple_squelch_cc_sptr self) -> int"""
        return _analog_swig.simple_squelch_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(simple_squelch_cc_sptr self, int i) -> long"""
        return _analog_swig.simple_squelch_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(simple_squelch_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(simple_squelch_cc_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.simple_squelch_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(simple_squelch_cc_sptr self, int i) -> long"""
        return _analog_swig.simple_squelch_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(simple_squelch_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(simple_squelch_cc_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.simple_squelch_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(simple_squelch_cc_sptr self) -> float"""
        return _analog_swig.simple_squelch_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(simple_squelch_cc_sptr self) -> float"""
        return _analog_swig.simple_squelch_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(simple_squelch_cc_sptr self) -> float"""
        return _analog_swig.simple_squelch_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(simple_squelch_cc_sptr self) -> float"""
        return _analog_swig.simple_squelch_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(simple_squelch_cc_sptr self) -> float"""
        return _analog_swig.simple_squelch_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(simple_squelch_cc_sptr self) -> float"""
        return _analog_swig.simple_squelch_cc_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(simple_squelch_cc_sptr self, int which) -> float
        pc_input_buffers_full(simple_squelch_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.simple_squelch_cc_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(simple_squelch_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(simple_squelch_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.simple_squelch_cc_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(simple_squelch_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(simple_squelch_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.simple_squelch_cc_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(simple_squelch_cc_sptr self, int which) -> float
        pc_output_buffers_full(simple_squelch_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.simple_squelch_cc_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(simple_squelch_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(simple_squelch_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.simple_squelch_cc_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(simple_squelch_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(simple_squelch_cc_sptr self) -> pmt_vector_float
        """
        return _analog_swig.simple_squelch_cc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(simple_squelch_cc_sptr self) -> float"""
        return _analog_swig.simple_squelch_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(simple_squelch_cc_sptr self) -> float"""
        return _analog_swig.simple_squelch_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(simple_squelch_cc_sptr self) -> float"""
        return _analog_swig.simple_squelch_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(simple_squelch_cc_sptr self) -> float"""
        return _analog_swig.simple_squelch_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(simple_squelch_cc_sptr self) -> float"""
        return _analog_swig.simple_squelch_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(simple_squelch_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.simple_squelch_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(simple_squelch_cc_sptr self)"""
        return _analog_swig.simple_squelch_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(simple_squelch_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.simple_squelch_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(simple_squelch_cc_sptr self) -> int"""
        return _analog_swig.simple_squelch_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(simple_squelch_cc_sptr self) -> int"""
        return _analog_swig.simple_squelch_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(simple_squelch_cc_sptr self, int priority) -> int"""
        return _analog_swig.simple_squelch_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(simple_squelch_cc_sptr self) -> std::string"""
        return _analog_swig.simple_squelch_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(simple_squelch_cc_sptr self) -> std::string"""
        return _analog_swig.simple_squelch_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(simple_squelch_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.simple_squelch_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(simple_squelch_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.simple_squelch_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(simple_squelch_cc_sptr self) -> long"""
        return _analog_swig.simple_squelch_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(simple_squelch_cc_sptr self) -> basic_block_sptr"""
        return _analog_swig.simple_squelch_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(simple_squelch_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.simple_squelch_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(simple_squelch_cc_sptr self) -> std::string"""
        return _analog_swig.simple_squelch_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(simple_squelch_cc_sptr self, std::string name)"""
        return _analog_swig.simple_squelch_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(simple_squelch_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.simple_squelch_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(simple_squelch_cc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.simple_squelch_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(simple_squelch_cc_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.simple_squelch_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(simple_squelch_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.simple_squelch_cc_sptr_message_subscribers(self, which_port)

# Register simple_squelch_cc_sptr in _analog_swig:
_analog_swig.simple_squelch_cc_sptr_swigregister(simple_squelch_cc_sptr)


simple_squelch_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
simple_squelch_cc = simple_squelch_cc.make;

class random_uniform_source_b(object):
    r"""Proxy of C++ gr::analog::random_uniform_source< std::uint8_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make(minimum: "int", maximum: "int", seed: "int") -> "gr::analog::random_uniform_source< unsigned char >::sptr":
        r"""make(int minimum, int maximum, int seed) -> random_uniform_source_b_sptr"""
        return _analog_swig.random_uniform_source_b_make(minimum, maximum, seed)
    __swig_destroy__ = _analog_swig.delete_random_uniform_source_b

# Register random_uniform_source_b in _analog_swig:
_analog_swig.random_uniform_source_b_swigregister(random_uniform_source_b)

def random_uniform_source_b_make(minimum: "int", maximum: "int", seed: "int") -> "gr::analog::random_uniform_source< unsigned char >::sptr":
    r"""random_uniform_source_b_make(int minimum, int maximum, int seed) -> random_uniform_source_b_sptr"""
    return _analog_swig.random_uniform_source_b_make(minimum, maximum, seed)

class random_uniform_source_b_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::random_uniform_source< std::uint8_t > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(random_uniform_source_b_sptr self) -> random_uniform_source_b_sptr
        __init__(random_uniform_source_b_sptr self, random_uniform_source_b p) -> random_uniform_source_b_sptr
        """
        _analog_swig.random_uniform_source_b_sptr_swiginit(self, _analog_swig.new_random_uniform_source_b_sptr(*args))

    def __deref__(self) -> "gr::analog::random_uniform_source< std::uint8_t > *":
        r"""__deref__(random_uniform_source_b_sptr self) -> random_uniform_source_b"""
        return _analog_swig.random_uniform_source_b_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_random_uniform_source_b_sptr

    def make(self, minimum: "int", maximum: "int", seed: "int") -> "gr::analog::random_uniform_source< unsigned char >::sptr":
        r"""make(random_uniform_source_b_sptr self, int minimum, int maximum, int seed) -> random_uniform_source_b_sptr"""
        return _analog_swig.random_uniform_source_b_sptr_make(self, minimum, maximum, seed)

    def history(self) -> "unsigned int":
        r"""history(random_uniform_source_b_sptr self) -> unsigned int"""
        return _analog_swig.random_uniform_source_b_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(random_uniform_source_b_sptr self, int which, int delay)
        declare_sample_delay(random_uniform_source_b_sptr self, unsigned int delay)
        """
        return _analog_swig.random_uniform_source_b_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(random_uniform_source_b_sptr self, int which) -> unsigned int"""
        return _analog_swig.random_uniform_source_b_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(random_uniform_source_b_sptr self, int multiple)"""
        return _analog_swig.random_uniform_source_b_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(random_uniform_source_b_sptr self) -> int"""
        return _analog_swig.random_uniform_source_b_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(random_uniform_source_b_sptr self) -> double"""
        return _analog_swig.random_uniform_source_b_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(random_uniform_source_b_sptr self) -> uint64_t"""
        return _analog_swig.random_uniform_source_b_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(random_uniform_source_b_sptr self) -> uint64_t"""
        return _analog_swig.random_uniform_source_b_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(random_uniform_source_b_sptr self) -> bool"""
        return _analog_swig.random_uniform_source_b_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(random_uniform_source_b_sptr self) -> bool"""
        return _analog_swig.random_uniform_source_b_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(random_uniform_source_b_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.random_uniform_source_b_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(random_uniform_source_b_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.random_uniform_source_b_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(random_uniform_source_b_sptr self, std::string level)"""
        return _analog_swig.random_uniform_source_b_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(random_uniform_source_b_sptr self) -> std::string"""
        return _analog_swig.random_uniform_source_b_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(random_uniform_source_b_sptr self) -> int"""
        return _analog_swig.random_uniform_source_b_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(random_uniform_source_b_sptr self, int m)"""
        return _analog_swig.random_uniform_source_b_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(random_uniform_source_b_sptr self)"""
        return _analog_swig.random_uniform_source_b_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(random_uniform_source_b_sptr self) -> bool"""
        return _analog_swig.random_uniform_source_b_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(random_uniform_source_b_sptr self, int m)"""
        return _analog_swig.random_uniform_source_b_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(random_uniform_source_b_sptr self) -> int"""
        return _analog_swig.random_uniform_source_b_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(random_uniform_source_b_sptr self, int i) -> long"""
        return _analog_swig.random_uniform_source_b_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(random_uniform_source_b_sptr self, long max_output_buffer)
        set_max_output_buffer(random_uniform_source_b_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.random_uniform_source_b_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(random_uniform_source_b_sptr self, int i) -> long"""
        return _analog_swig.random_uniform_source_b_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(random_uniform_source_b_sptr self, long min_output_buffer)
        set_min_output_buffer(random_uniform_source_b_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.random_uniform_source_b_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(random_uniform_source_b_sptr self) -> float"""
        return _analog_swig.random_uniform_source_b_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(random_uniform_source_b_sptr self) -> float"""
        return _analog_swig.random_uniform_source_b_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(random_uniform_source_b_sptr self) -> float"""
        return _analog_swig.random_uniform_source_b_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(random_uniform_source_b_sptr self) -> float"""
        return _analog_swig.random_uniform_source_b_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(random_uniform_source_b_sptr self) -> float"""
        return _analog_swig.random_uniform_source_b_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(random_uniform_source_b_sptr self) -> float"""
        return _analog_swig.random_uniform_source_b_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(random_uniform_source_b_sptr self, int which) -> float
        pc_input_buffers_full(random_uniform_source_b_sptr self) -> pmt_vector_float
        """
        return _analog_swig.random_uniform_source_b_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(random_uniform_source_b_sptr self, int which) -> float
        pc_input_buffers_full_avg(random_uniform_source_b_sptr self) -> pmt_vector_float
        """
        return _analog_swig.random_uniform_source_b_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(random_uniform_source_b_sptr self, int which) -> float
        pc_input_buffers_full_var(random_uniform_source_b_sptr self) -> pmt_vector_float
        """
        return _analog_swig.random_uniform_source_b_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(random_uniform_source_b_sptr self, int which) -> float
        pc_output_buffers_full(random_uniform_source_b_sptr self) -> pmt_vector_float
        """
        return _analog_swig.random_uniform_source_b_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(random_uniform_source_b_sptr self, int which) -> float
        pc_output_buffers_full_avg(random_uniform_source_b_sptr self) -> pmt_vector_float
        """
        return _analog_swig.random_uniform_source_b_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(random_uniform_source_b_sptr self, int which) -> float
        pc_output_buffers_full_var(random_uniform_source_b_sptr self) -> pmt_vector_float
        """
        return _analog_swig.random_uniform_source_b_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(random_uniform_source_b_sptr self) -> float"""
        return _analog_swig.random_uniform_source_b_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(random_uniform_source_b_sptr self) -> float"""
        return _analog_swig.random_uniform_source_b_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(random_uniform_source_b_sptr self) -> float"""
        return _analog_swig.random_uniform_source_b_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(random_uniform_source_b_sptr self) -> float"""
        return _analog_swig.random_uniform_source_b_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(random_uniform_source_b_sptr self) -> float"""
        return _analog_swig.random_uniform_source_b_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(random_uniform_source_b_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.random_uniform_source_b_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(random_uniform_source_b_sptr self)"""
        return _analog_swig.random_uniform_source_b_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(random_uniform_source_b_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.random_uniform_source_b_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(random_uniform_source_b_sptr self) -> int"""
        return _analog_swig.random_uniform_source_b_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(random_uniform_source_b_sptr self) -> int"""
        return _analog_swig.random_uniform_source_b_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(random_uniform_source_b_sptr self, int priority) -> int"""
        return _analog_swig.random_uniform_source_b_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(random_uniform_source_b_sptr self) -> std::string"""
        return _analog_swig.random_uniform_source_b_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(random_uniform_source_b_sptr self) -> std::string"""
        return _analog_swig.random_uniform_source_b_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(random_uniform_source_b_sptr self) -> io_signature_sptr"""
        return _analog_swig.random_uniform_source_b_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(random_uniform_source_b_sptr self) -> io_signature_sptr"""
        return _analog_swig.random_uniform_source_b_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(random_uniform_source_b_sptr self) -> long"""
        return _analog_swig.random_uniform_source_b_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(random_uniform_source_b_sptr self) -> basic_block_sptr"""
        return _analog_swig.random_uniform_source_b_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(random_uniform_source_b_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.random_uniform_source_b_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(random_uniform_source_b_sptr self) -> std::string"""
        return _analog_swig.random_uniform_source_b_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(random_uniform_source_b_sptr self, std::string name)"""
        return _analog_swig.random_uniform_source_b_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(random_uniform_source_b_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.random_uniform_source_b_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(random_uniform_source_b_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.random_uniform_source_b_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(random_uniform_source_b_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.random_uniform_source_b_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(random_uniform_source_b_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.random_uniform_source_b_sptr_message_subscribers(self, which_port)

# Register random_uniform_source_b_sptr in _analog_swig:
_analog_swig.random_uniform_source_b_sptr_swigregister(random_uniform_source_b_sptr)


random_uniform_source_b_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
random_uniform_source_b = random_uniform_source_b.make

class random_uniform_source_s(object):
    r"""Proxy of C++ gr::analog::random_uniform_source< std::int16_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make(minimum: "int", maximum: "int", seed: "int") -> "gr::analog::random_uniform_source< short >::sptr":
        r"""make(int minimum, int maximum, int seed) -> random_uniform_source_s_sptr"""
        return _analog_swig.random_uniform_source_s_make(minimum, maximum, seed)
    __swig_destroy__ = _analog_swig.delete_random_uniform_source_s

# Register random_uniform_source_s in _analog_swig:
_analog_swig.random_uniform_source_s_swigregister(random_uniform_source_s)

def random_uniform_source_s_make(minimum: "int", maximum: "int", seed: "int") -> "gr::analog::random_uniform_source< short >::sptr":
    r"""random_uniform_source_s_make(int minimum, int maximum, int seed) -> random_uniform_source_s_sptr"""
    return _analog_swig.random_uniform_source_s_make(minimum, maximum, seed)

class random_uniform_source_s_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::random_uniform_source< std::int16_t > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(random_uniform_source_s_sptr self) -> random_uniform_source_s_sptr
        __init__(random_uniform_source_s_sptr self, random_uniform_source_s p) -> random_uniform_source_s_sptr
        """
        _analog_swig.random_uniform_source_s_sptr_swiginit(self, _analog_swig.new_random_uniform_source_s_sptr(*args))

    def __deref__(self) -> "gr::analog::random_uniform_source< std::int16_t > *":
        r"""__deref__(random_uniform_source_s_sptr self) -> random_uniform_source_s"""
        return _analog_swig.random_uniform_source_s_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_random_uniform_source_s_sptr

    def make(self, minimum: "int", maximum: "int", seed: "int") -> "gr::analog::random_uniform_source< short >::sptr":
        r"""make(random_uniform_source_s_sptr self, int minimum, int maximum, int seed) -> random_uniform_source_s_sptr"""
        return _analog_swig.random_uniform_source_s_sptr_make(self, minimum, maximum, seed)

    def history(self) -> "unsigned int":
        r"""history(random_uniform_source_s_sptr self) -> unsigned int"""
        return _analog_swig.random_uniform_source_s_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(random_uniform_source_s_sptr self, int which, int delay)
        declare_sample_delay(random_uniform_source_s_sptr self, unsigned int delay)
        """
        return _analog_swig.random_uniform_source_s_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(random_uniform_source_s_sptr self, int which) -> unsigned int"""
        return _analog_swig.random_uniform_source_s_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(random_uniform_source_s_sptr self, int multiple)"""
        return _analog_swig.random_uniform_source_s_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(random_uniform_source_s_sptr self) -> int"""
        return _analog_swig.random_uniform_source_s_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(random_uniform_source_s_sptr self) -> double"""
        return _analog_swig.random_uniform_source_s_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(random_uniform_source_s_sptr self) -> uint64_t"""
        return _analog_swig.random_uniform_source_s_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(random_uniform_source_s_sptr self) -> uint64_t"""
        return _analog_swig.random_uniform_source_s_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(random_uniform_source_s_sptr self) -> bool"""
        return _analog_swig.random_uniform_source_s_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(random_uniform_source_s_sptr self) -> bool"""
        return _analog_swig.random_uniform_source_s_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(random_uniform_source_s_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.random_uniform_source_s_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(random_uniform_source_s_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.random_uniform_source_s_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(random_uniform_source_s_sptr self, std::string level)"""
        return _analog_swig.random_uniform_source_s_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(random_uniform_source_s_sptr self) -> std::string"""
        return _analog_swig.random_uniform_source_s_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(random_uniform_source_s_sptr self) -> int"""
        return _analog_swig.random_uniform_source_s_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(random_uniform_source_s_sptr self, int m)"""
        return _analog_swig.random_uniform_source_s_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(random_uniform_source_s_sptr self)"""
        return _analog_swig.random_uniform_source_s_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(random_uniform_source_s_sptr self) -> bool"""
        return _analog_swig.random_uniform_source_s_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(random_uniform_source_s_sptr self, int m)"""
        return _analog_swig.random_uniform_source_s_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(random_uniform_source_s_sptr self) -> int"""
        return _analog_swig.random_uniform_source_s_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(random_uniform_source_s_sptr self, int i) -> long"""
        return _analog_swig.random_uniform_source_s_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(random_uniform_source_s_sptr self, long max_output_buffer)
        set_max_output_buffer(random_uniform_source_s_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.random_uniform_source_s_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(random_uniform_source_s_sptr self, int i) -> long"""
        return _analog_swig.random_uniform_source_s_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(random_uniform_source_s_sptr self, long min_output_buffer)
        set_min_output_buffer(random_uniform_source_s_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.random_uniform_source_s_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(random_uniform_source_s_sptr self) -> float"""
        return _analog_swig.random_uniform_source_s_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(random_uniform_source_s_sptr self) -> float"""
        return _analog_swig.random_uniform_source_s_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(random_uniform_source_s_sptr self) -> float"""
        return _analog_swig.random_uniform_source_s_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(random_uniform_source_s_sptr self) -> float"""
        return _analog_swig.random_uniform_source_s_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(random_uniform_source_s_sptr self) -> float"""
        return _analog_swig.random_uniform_source_s_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(random_uniform_source_s_sptr self) -> float"""
        return _analog_swig.random_uniform_source_s_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(random_uniform_source_s_sptr self, int which) -> float
        pc_input_buffers_full(random_uniform_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.random_uniform_source_s_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(random_uniform_source_s_sptr self, int which) -> float
        pc_input_buffers_full_avg(random_uniform_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.random_uniform_source_s_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(random_uniform_source_s_sptr self, int which) -> float
        pc_input_buffers_full_var(random_uniform_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.random_uniform_source_s_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(random_uniform_source_s_sptr self, int which) -> float
        pc_output_buffers_full(random_uniform_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.random_uniform_source_s_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(random_uniform_source_s_sptr self, int which) -> float
        pc_output_buffers_full_avg(random_uniform_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.random_uniform_source_s_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(random_uniform_source_s_sptr self, int which) -> float
        pc_output_buffers_full_var(random_uniform_source_s_sptr self) -> pmt_vector_float
        """
        return _analog_swig.random_uniform_source_s_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(random_uniform_source_s_sptr self) -> float"""
        return _analog_swig.random_uniform_source_s_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(random_uniform_source_s_sptr self) -> float"""
        return _analog_swig.random_uniform_source_s_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(random_uniform_source_s_sptr self) -> float"""
        return _analog_swig.random_uniform_source_s_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(random_uniform_source_s_sptr self) -> float"""
        return _analog_swig.random_uniform_source_s_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(random_uniform_source_s_sptr self) -> float"""
        return _analog_swig.random_uniform_source_s_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(random_uniform_source_s_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.random_uniform_source_s_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(random_uniform_source_s_sptr self)"""
        return _analog_swig.random_uniform_source_s_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(random_uniform_source_s_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.random_uniform_source_s_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(random_uniform_source_s_sptr self) -> int"""
        return _analog_swig.random_uniform_source_s_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(random_uniform_source_s_sptr self) -> int"""
        return _analog_swig.random_uniform_source_s_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(random_uniform_source_s_sptr self, int priority) -> int"""
        return _analog_swig.random_uniform_source_s_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(random_uniform_source_s_sptr self) -> std::string"""
        return _analog_swig.random_uniform_source_s_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(random_uniform_source_s_sptr self) -> std::string"""
        return _analog_swig.random_uniform_source_s_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(random_uniform_source_s_sptr self) -> io_signature_sptr"""
        return _analog_swig.random_uniform_source_s_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(random_uniform_source_s_sptr self) -> io_signature_sptr"""
        return _analog_swig.random_uniform_source_s_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(random_uniform_source_s_sptr self) -> long"""
        return _analog_swig.random_uniform_source_s_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(random_uniform_source_s_sptr self) -> basic_block_sptr"""
        return _analog_swig.random_uniform_source_s_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(random_uniform_source_s_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.random_uniform_source_s_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(random_uniform_source_s_sptr self) -> std::string"""
        return _analog_swig.random_uniform_source_s_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(random_uniform_source_s_sptr self, std::string name)"""
        return _analog_swig.random_uniform_source_s_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(random_uniform_source_s_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.random_uniform_source_s_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(random_uniform_source_s_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.random_uniform_source_s_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(random_uniform_source_s_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.random_uniform_source_s_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(random_uniform_source_s_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.random_uniform_source_s_sptr_message_subscribers(self, which_port)

# Register random_uniform_source_s_sptr in _analog_swig:
_analog_swig.random_uniform_source_s_sptr_swigregister(random_uniform_source_s_sptr)


random_uniform_source_s_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
random_uniform_source_s = random_uniform_source_s.make

class random_uniform_source_i(object):
    r"""Proxy of C++ gr::analog::random_uniform_source< std::int32_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make(minimum: "int", maximum: "int", seed: "int") -> "gr::analog::random_uniform_source< int >::sptr":
        r"""make(int minimum, int maximum, int seed) -> random_uniform_source_i_sptr"""
        return _analog_swig.random_uniform_source_i_make(minimum, maximum, seed)
    __swig_destroy__ = _analog_swig.delete_random_uniform_source_i

# Register random_uniform_source_i in _analog_swig:
_analog_swig.random_uniform_source_i_swigregister(random_uniform_source_i)

def random_uniform_source_i_make(minimum: "int", maximum: "int", seed: "int") -> "gr::analog::random_uniform_source< int >::sptr":
    r"""random_uniform_source_i_make(int minimum, int maximum, int seed) -> random_uniform_source_i_sptr"""
    return _analog_swig.random_uniform_source_i_make(minimum, maximum, seed)

class random_uniform_source_i_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::analog::random_uniform_source< std::int32_t > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(random_uniform_source_i_sptr self) -> random_uniform_source_i_sptr
        __init__(random_uniform_source_i_sptr self, random_uniform_source_i p) -> random_uniform_source_i_sptr
        """
        _analog_swig.random_uniform_source_i_sptr_swiginit(self, _analog_swig.new_random_uniform_source_i_sptr(*args))

    def __deref__(self) -> "gr::analog::random_uniform_source< std::int32_t > *":
        r"""__deref__(random_uniform_source_i_sptr self) -> random_uniform_source_i"""
        return _analog_swig.random_uniform_source_i_sptr___deref__(self)
    __swig_destroy__ = _analog_swig.delete_random_uniform_source_i_sptr

    def make(self, minimum: "int", maximum: "int", seed: "int") -> "gr::analog::random_uniform_source< int >::sptr":
        r"""make(random_uniform_source_i_sptr self, int minimum, int maximum, int seed) -> random_uniform_source_i_sptr"""
        return _analog_swig.random_uniform_source_i_sptr_make(self, minimum, maximum, seed)

    def history(self) -> "unsigned int":
        r"""history(random_uniform_source_i_sptr self) -> unsigned int"""
        return _analog_swig.random_uniform_source_i_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(random_uniform_source_i_sptr self, int which, int delay)
        declare_sample_delay(random_uniform_source_i_sptr self, unsigned int delay)
        """
        return _analog_swig.random_uniform_source_i_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(random_uniform_source_i_sptr self, int which) -> unsigned int"""
        return _analog_swig.random_uniform_source_i_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(random_uniform_source_i_sptr self, int multiple)"""
        return _analog_swig.random_uniform_source_i_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(random_uniform_source_i_sptr self) -> int"""
        return _analog_swig.random_uniform_source_i_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(random_uniform_source_i_sptr self) -> double"""
        return _analog_swig.random_uniform_source_i_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(random_uniform_source_i_sptr self) -> uint64_t"""
        return _analog_swig.random_uniform_source_i_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(random_uniform_source_i_sptr self) -> uint64_t"""
        return _analog_swig.random_uniform_source_i_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(random_uniform_source_i_sptr self) -> bool"""
        return _analog_swig.random_uniform_source_i_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(random_uniform_source_i_sptr self) -> bool"""
        return _analog_swig.random_uniform_source_i_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(random_uniform_source_i_sptr self, unsigned int which_input) -> uint64_t"""
        return _analog_swig.random_uniform_source_i_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(random_uniform_source_i_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.random_uniform_source_i_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(random_uniform_source_i_sptr self, std::string level)"""
        return _analog_swig.random_uniform_source_i_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(random_uniform_source_i_sptr self) -> std::string"""
        return _analog_swig.random_uniform_source_i_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(random_uniform_source_i_sptr self) -> int"""
        return _analog_swig.random_uniform_source_i_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(random_uniform_source_i_sptr self, int m)"""
        return _analog_swig.random_uniform_source_i_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(random_uniform_source_i_sptr self)"""
        return _analog_swig.random_uniform_source_i_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(random_uniform_source_i_sptr self) -> bool"""
        return _analog_swig.random_uniform_source_i_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(random_uniform_source_i_sptr self, int m)"""
        return _analog_swig.random_uniform_source_i_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(random_uniform_source_i_sptr self) -> int"""
        return _analog_swig.random_uniform_source_i_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(random_uniform_source_i_sptr self, int i) -> long"""
        return _analog_swig.random_uniform_source_i_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(random_uniform_source_i_sptr self, long max_output_buffer)
        set_max_output_buffer(random_uniform_source_i_sptr self, int port, long max_output_buffer)
        """
        return _analog_swig.random_uniform_source_i_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(random_uniform_source_i_sptr self, int i) -> long"""
        return _analog_swig.random_uniform_source_i_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(random_uniform_source_i_sptr self, long min_output_buffer)
        set_min_output_buffer(random_uniform_source_i_sptr self, int port, long min_output_buffer)
        """
        return _analog_swig.random_uniform_source_i_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(random_uniform_source_i_sptr self) -> float"""
        return _analog_swig.random_uniform_source_i_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(random_uniform_source_i_sptr self) -> float"""
        return _analog_swig.random_uniform_source_i_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(random_uniform_source_i_sptr self) -> float"""
        return _analog_swig.random_uniform_source_i_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(random_uniform_source_i_sptr self) -> float"""
        return _analog_swig.random_uniform_source_i_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(random_uniform_source_i_sptr self) -> float"""
        return _analog_swig.random_uniform_source_i_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(random_uniform_source_i_sptr self) -> float"""
        return _analog_swig.random_uniform_source_i_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(random_uniform_source_i_sptr self, int which) -> float
        pc_input_buffers_full(random_uniform_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.random_uniform_source_i_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(random_uniform_source_i_sptr self, int which) -> float
        pc_input_buffers_full_avg(random_uniform_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.random_uniform_source_i_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(random_uniform_source_i_sptr self, int which) -> float
        pc_input_buffers_full_var(random_uniform_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.random_uniform_source_i_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(random_uniform_source_i_sptr self, int which) -> float
        pc_output_buffers_full(random_uniform_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.random_uniform_source_i_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(random_uniform_source_i_sptr self, int which) -> float
        pc_output_buffers_full_avg(random_uniform_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.random_uniform_source_i_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(random_uniform_source_i_sptr self, int which) -> float
        pc_output_buffers_full_var(random_uniform_source_i_sptr self) -> pmt_vector_float
        """
        return _analog_swig.random_uniform_source_i_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(random_uniform_source_i_sptr self) -> float"""
        return _analog_swig.random_uniform_source_i_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(random_uniform_source_i_sptr self) -> float"""
        return _analog_swig.random_uniform_source_i_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(random_uniform_source_i_sptr self) -> float"""
        return _analog_swig.random_uniform_source_i_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(random_uniform_source_i_sptr self) -> float"""
        return _analog_swig.random_uniform_source_i_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(random_uniform_source_i_sptr self) -> float"""
        return _analog_swig.random_uniform_source_i_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(random_uniform_source_i_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _analog_swig.random_uniform_source_i_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(random_uniform_source_i_sptr self)"""
        return _analog_swig.random_uniform_source_i_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(random_uniform_source_i_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _analog_swig.random_uniform_source_i_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(random_uniform_source_i_sptr self) -> int"""
        return _analog_swig.random_uniform_source_i_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(random_uniform_source_i_sptr self) -> int"""
        return _analog_swig.random_uniform_source_i_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(random_uniform_source_i_sptr self, int priority) -> int"""
        return _analog_swig.random_uniform_source_i_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(random_uniform_source_i_sptr self) -> std::string"""
        return _analog_swig.random_uniform_source_i_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(random_uniform_source_i_sptr self) -> std::string"""
        return _analog_swig.random_uniform_source_i_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(random_uniform_source_i_sptr self) -> io_signature_sptr"""
        return _analog_swig.random_uniform_source_i_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(random_uniform_source_i_sptr self) -> io_signature_sptr"""
        return _analog_swig.random_uniform_source_i_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(random_uniform_source_i_sptr self) -> long"""
        return _analog_swig.random_uniform_source_i_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(random_uniform_source_i_sptr self) -> basic_block_sptr"""
        return _analog_swig.random_uniform_source_i_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(random_uniform_source_i_sptr self, int ninputs, int noutputs) -> bool"""
        return _analog_swig.random_uniform_source_i_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(random_uniform_source_i_sptr self) -> std::string"""
        return _analog_swig.random_uniform_source_i_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(random_uniform_source_i_sptr self, std::string name)"""
        return _analog_swig.random_uniform_source_i_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(random_uniform_source_i_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _analog_swig.random_uniform_source_i_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(random_uniform_source_i_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.random_uniform_source_i_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(random_uniform_source_i_sptr self) -> swig_pmt_ptr"""
        return _analog_swig.random_uniform_source_i_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(random_uniform_source_i_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _analog_swig.random_uniform_source_i_sptr_message_subscribers(self, which_port)

# Register random_uniform_source_i_sptr in _analog_swig:
_analog_swig.random_uniform_source_i_sptr_swigregister(random_uniform_source_i_sptr)


random_uniform_source_i_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
random_uniform_source_i = random_uniform_source_i.make



