# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.7
#
# 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
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_analog_swig', [dirname(__file__)])
        except ImportError:
            import _analog_swig
            return _analog_swig
        if fp is not None:
            try:
                _mod = imp.load_module('_analog_swig', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _analog_swig = swig_import_helper()
    del swig_import_helper
else:
    import _analog_swig
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0



def _swig_setattr_nondynamic_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr



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

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

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

def high_res_timer_epoch():
    """high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _analog_swig.high_res_timer_epoch()
class control_loop(object):
    """Proxy of C++ gr::blocks::control_loop class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(gr::blocks::control_loop self) -> control_loop
        __init__(gr::blocks::control_loop self, float loop_bw, float max_freq, float min_freq) -> control_loop
        """
        this = _analog_swig.new_control_loop(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _analog_swig.delete_control_loop
    __del__ = lambda self: None

    def update_gains(self):
        """update_gains(control_loop self)"""
        return _analog_swig.control_loop_update_gains(self)


    def advance_loop(self, error):
        """advance_loop(control_loop self, float error)"""
        return _analog_swig.control_loop_advance_loop(self, error)


    def phase_wrap(self):
        """phase_wrap(control_loop self)"""
        return _analog_swig.control_loop_phase_wrap(self)


    def frequency_limit(self):
        """frequency_limit(control_loop self)"""
        return _analog_swig.control_loop_frequency_limit(self)


    def set_loop_bandwidth(self, bw):
        """set_loop_bandwidth(control_loop self, float bw)"""
        return _analog_swig.control_loop_set_loop_bandwidth(self, bw)


    def set_damping_factor(self, df):
        """set_damping_factor(control_loop self, float df)"""
        return _analog_swig.control_loop_set_damping_factor(self, df)


    def set_alpha(self, alpha):
        """set_alpha(control_loop self, float alpha)"""
        return _analog_swig.control_loop_set_alpha(self, alpha)


    def set_beta(self, beta):
        """set_beta(control_loop self, float beta)"""
        return _analog_swig.control_loop_set_beta(self, beta)


    def set_frequency(self, freq):
        """set_frequency(control_loop self, float freq)"""
        return _analog_swig.control_loop_set_frequency(self, freq)


    def set_phase(self, phase):
        """set_phase(control_loop self, float phase)"""
        return _analog_swig.control_loop_set_phase(self, phase)


    def set_max_freq(self, freq):
        """set_max_freq(control_loop self, float freq)"""
        return _analog_swig.control_loop_set_max_freq(self, freq)


    def set_min_freq(self, freq):
        """set_min_freq(control_loop self, float freq)"""
        return _analog_swig.control_loop_set_min_freq(self, freq)


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


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


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


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


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


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


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


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

control_loop_swigregister = _analog_swig.control_loop_swigregister
control_loop_swigregister(control_loop)


def tanhf_lut(x):
    """tanhf_lut(float x) -> float"""
    return _analog_swig.tanhf_lut(x)
class cpm(object):
    """Proxy of C++ gr::analog::cpm class"""
    thisown = _swig_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

    def phase_response(type, samples_per_sym, L, beta=0.3):
        """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)

    phase_response = staticmethod(phase_response)

    def __init__(self):
        """__init__(gr::analog::cpm self) -> cpm"""
        this = _analog_swig.new_cpm()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _analog_swig.delete_cpm
    __del__ = lambda self: None
cpm_swigregister = _analog_swig.cpm_swigregister
cpm_swigregister(cpm)
cvar = _analog_swig.cvar

def cpm_phase_response(type, samples_per_sym, L, beta=0.3):
    """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)


_analog_swig.GR_UNIFORM_swigconstant(_analog_swig)
GR_UNIFORM = _analog_swig.GR_UNIFORM

_analog_swig.GR_GAUSSIAN_swigconstant(_analog_swig)
GR_GAUSSIAN = _analog_swig.GR_GAUSSIAN

_analog_swig.GR_LAPLACIAN_swigconstant(_analog_swig)
GR_LAPLACIAN = _analog_swig.GR_LAPLACIAN

_analog_swig.GR_IMPULSE_swigconstant(_analog_swig)
GR_IMPULSE = _analog_swig.GR_IMPULSE
class agc_cc(object):
    """Proxy of C++ gr::analog::agc_cc class"""
    thisown = _swig_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 make(rate=1e-4, reference=1.0, gain=1.0):
        """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)

    make = staticmethod(make)

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


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


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


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


    def set_rate(self, rate):
        """set_rate(agc_cc self, float rate)"""
        return _analog_swig.agc_cc_set_rate(self, rate)


    def set_reference(self, reference):
        """set_reference(agc_cc self, float reference)"""
        return _analog_swig.agc_cc_set_reference(self, reference)


    def set_gain(self, gain):
        """set_gain(agc_cc self, float gain)"""
        return _analog_swig.agc_cc_set_gain(self, gain)


    def set_max_gain(self, max_gain):
        """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
    __del__ = lambda self: None
agc_cc_swigregister = _analog_swig.agc_cc_swigregister
agc_cc_swigregister(agc_cc)

def agc_cc_make(rate=1e-4, reference=1.0, gain=1.0):
    """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):
    """Proxy of C++ gr::analog::agc_ff class"""
    thisown = _swig_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 make(rate=1e-4, reference=1.0, gain=1.0):
        """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)

    make = staticmethod(make)

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


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


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


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


    def set_rate(self, rate):
        """set_rate(agc_ff self, float rate)"""
        return _analog_swig.agc_ff_set_rate(self, rate)


    def set_reference(self, reference):
        """set_reference(agc_ff self, float reference)"""
        return _analog_swig.agc_ff_set_reference(self, reference)


    def set_gain(self, gain):
        """set_gain(agc_ff self, float gain)"""
        return _analog_swig.agc_ff_set_gain(self, gain)


    def set_max_gain(self, max_gain):
        """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
    __del__ = lambda self: None
agc_ff_swigregister = _analog_swig.agc_ff_swigregister
agc_ff_swigregister(agc_ff)

def agc_ff_make(rate=1e-4, reference=1.0, gain=1.0):
    """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):
    """Proxy of C++ gr::analog::agc2_cc class"""
    thisown = _swig_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 make(attack_rate=1e-1, decay_rate=1e-2, reference=1.0, gain=1.0):
        """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)

    make = staticmethod(make)

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


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


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


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


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


    def set_attack_rate(self, rate):
        """set_attack_rate(agc2_cc self, float rate)"""
        return _analog_swig.agc2_cc_set_attack_rate(self, rate)


    def set_decay_rate(self, rate):
        """set_decay_rate(agc2_cc self, float rate)"""
        return _analog_swig.agc2_cc_set_decay_rate(self, rate)


    def set_reference(self, reference):
        """set_reference(agc2_cc self, float reference)"""
        return _analog_swig.agc2_cc_set_reference(self, reference)


    def set_gain(self, gain):
        """set_gain(agc2_cc self, float gain)"""
        return _analog_swig.agc2_cc_set_gain(self, gain)


    def set_max_gain(self, max_gain):
        """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
    __del__ = lambda self: None
agc2_cc_swigregister = _analog_swig.agc2_cc_swigregister
agc2_cc_swigregister(agc2_cc)

def agc2_cc_make(attack_rate=1e-1, decay_rate=1e-2, reference=1.0, gain=1.0):
    """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):
    """Proxy of C++ gr::analog::agc2_ff class"""
    thisown = _swig_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 make(attack_rate=1e-1, decay_rate=1e-2, reference=1.0, gain=1.0):
        """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)

    make = staticmethod(make)

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


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


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


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


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


    def set_attack_rate(self, rate):
        """set_attack_rate(agc2_ff self, float rate)"""
        return _analog_swig.agc2_ff_set_attack_rate(self, rate)


    def set_decay_rate(self, rate):
        """set_decay_rate(agc2_ff self, float rate)"""
        return _analog_swig.agc2_ff_set_decay_rate(self, rate)


    def set_reference(self, reference):
        """set_reference(agc2_ff self, float reference)"""
        return _analog_swig.agc2_ff_set_reference(self, reference)


    def set_gain(self, gain):
        """set_gain(agc2_ff self, float gain)"""
        return _analog_swig.agc2_ff_set_gain(self, gain)


    def set_max_gain(self, max_gain):
        """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
    __del__ = lambda self: None
agc2_ff_swigregister = _analog_swig.agc2_ff_swigregister
agc2_ff_swigregister(agc2_ff)

def agc2_ff_make(attack_rate=1e-1, decay_rate=1e-2, reference=1.0, gain=1.0):
    """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):
    """Proxy of C++ gr::analog::agc3_cc class"""
    thisown = _swig_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 make(attack_rate=1e-1, decay_rate=1e-2, reference=1.0, gain=1.0, iir_update_decim=1):
        """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)

    make = staticmethod(make)

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


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


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


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


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


    def set_attack_rate(self, rate):
        """set_attack_rate(agc3_cc self, float rate)"""
        return _analog_swig.agc3_cc_set_attack_rate(self, rate)


    def set_decay_rate(self, rate):
        """set_decay_rate(agc3_cc self, float rate)"""
        return _analog_swig.agc3_cc_set_decay_rate(self, rate)


    def set_reference(self, reference):
        """set_reference(agc3_cc self, float reference)"""
        return _analog_swig.agc3_cc_set_reference(self, reference)


    def set_gain(self, gain):
        """set_gain(agc3_cc self, float gain)"""
        return _analog_swig.agc3_cc_set_gain(self, gain)


    def set_max_gain(self, max_gain):
        """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
    __del__ = lambda self: None
agc3_cc_swigregister = _analog_swig.agc3_cc_swigregister
agc3_cc_swigregister(agc3_cc)

def agc3_cc_make(attack_rate=1e-1, decay_rate=1e-2, reference=1.0, gain=1.0, iir_update_decim=1):
    """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):
    """Proxy of C++ gr::analog::cpfsk_bc class"""
    thisown = _swig_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 make(k, ampl, samples_per_sym):
        """make(float k, float ampl, int samples_per_sym) -> cpfsk_bc_sptr"""
        return _analog_swig.cpfsk_bc_make(k, ampl, samples_per_sym)

    make = staticmethod(make)

    def set_amplitude(self, amplitude):
        """set_amplitude(cpfsk_bc self, float amplitude)"""
        return _analog_swig.cpfsk_bc_set_amplitude(self, amplitude)


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


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


    def phase(self):
        """phase(cpfsk_bc self) -> float"""
        return _analog_swig.cpfsk_bc_phase(self)

    __swig_destroy__ = _analog_swig.delete_cpfsk_bc
    __del__ = lambda self: None
cpfsk_bc_swigregister = _analog_swig.cpfsk_bc_swigregister
cpfsk_bc_swigregister(cpfsk_bc)

def cpfsk_bc_make(k, ampl, samples_per_sym):
    """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):
    """Proxy of C++ gr::analog::ctcss_squelch_ff class"""
    thisown = _swig_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 make(rate, freq, level, len, ramp, gate):
        """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)

    make = staticmethod(make)

    def squelch_range(self):
        """squelch_range(ctcss_squelch_ff self) -> pmt_vector_float"""
        return _analog_swig.ctcss_squelch_ff_squelch_range(self)


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


    def set_level(self, level):
        """set_level(ctcss_squelch_ff self, float level)"""
        return _analog_swig.ctcss_squelch_ff_set_level(self, level)


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


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


    def set_frequency(self, frequency):
        """set_frequency(ctcss_squelch_ff self, float frequency)"""
        return _analog_swig.ctcss_squelch_ff_set_frequency(self, frequency)


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


    def set_ramp(self, ramp):
        """set_ramp(ctcss_squelch_ff self, int ramp)"""
        return _analog_swig.ctcss_squelch_ff_set_ramp(self, ramp)


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


    def set_gate(self, gate):
        """set_gate(ctcss_squelch_ff self, bool gate)"""
        return _analog_swig.ctcss_squelch_ff_set_gate(self, gate)


    def unmuted(self):
        """unmuted(ctcss_squelch_ff self) -> bool"""
        return _analog_swig.ctcss_squelch_ff_unmuted(self)

    __swig_destroy__ = _analog_swig.delete_ctcss_squelch_ff
    __del__ = lambda self: None
ctcss_squelch_ff_swigregister = _analog_swig.ctcss_squelch_ff_swigregister
ctcss_squelch_ff_swigregister(ctcss_squelch_ff)

def ctcss_squelch_ff_make(rate, freq, level, len, ramp, gate):
    """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):
    """Proxy of C++ gr::analog::dpll_bb class"""
    thisown = _swig_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 make(period, gain):
        """make(float period, float gain) -> dpll_bb_sptr"""
        return _analog_swig.dpll_bb_make(period, gain)

    make = staticmethod(make)

    def set_gain(self, gain):
        """set_gain(dpll_bb self, float gain)"""
        return _analog_swig.dpll_bb_set_gain(self, gain)


    def set_decision_threshold(self, thresh):
        """set_decision_threshold(dpll_bb self, float thresh)"""
        return _analog_swig.dpll_bb_set_decision_threshold(self, thresh)


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


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


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


    def decision_threshold(self):
        """decision_threshold(dpll_bb self) -> float"""
        return _analog_swig.dpll_bb_decision_threshold(self)

    __swig_destroy__ = _analog_swig.delete_dpll_bb
    __del__ = lambda self: None
dpll_bb_swigregister = _analog_swig.dpll_bb_swigregister
dpll_bb_swigregister(dpll_bb)

def dpll_bb_make(period, gain):
    """dpll_bb_make(float period, float gain) -> dpll_bb_sptr"""
    return _analog_swig.dpll_bb_make(period, gain)

class feedforward_agc_cc(object):
    """Proxy of C++ gr::analog::feedforward_agc_cc class"""
    thisown = _swig_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

    def make(nsamples, reference):
        """make(int nsamples, float reference) -> feedforward_agc_cc_sptr"""
        return _analog_swig.feedforward_agc_cc_make(nsamples, reference)

    make = staticmethod(make)
    __swig_destroy__ = _analog_swig.delete_feedforward_agc_cc
    __del__ = lambda self: None
feedforward_agc_cc_swigregister = _analog_swig.feedforward_agc_cc_swigregister
feedforward_agc_cc_swigregister(feedforward_agc_cc)

def feedforward_agc_cc_make(nsamples, reference):
    """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):
    """Proxy of C++ gr::analog::fmdet_cf class"""
    thisown = _swig_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 make(samplerate, freq_low, freq_high, scl):
        """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)

    make = staticmethod(make)

    def set_scale(self, scl):
        """set_scale(fmdet_cf self, float scl)"""
        return _analog_swig.fmdet_cf_set_scale(self, scl)


    def set_freq_range(self, freq_low, freq_high):
        """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):
        """freq(fmdet_cf self) -> float"""
        return _analog_swig.fmdet_cf_freq(self)


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


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


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


    def bias(self):
        """bias(fmdet_cf self) -> float"""
        return _analog_swig.fmdet_cf_bias(self)

    __swig_destroy__ = _analog_swig.delete_fmdet_cf
    __del__ = lambda self: None
fmdet_cf_swigregister = _analog_swig.fmdet_cf_swigregister
fmdet_cf_swigregister(fmdet_cf)

def fmdet_cf_make(samplerate, freq_low, freq_high, scl):
    """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):
    """Proxy of C++ gr::analog::frequency_modulator_fc class"""
    thisown = _swig_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 make(sensitivity):
        """make(float sensitivity) -> frequency_modulator_fc_sptr"""
        return _analog_swig.frequency_modulator_fc_make(sensitivity)

    make = staticmethod(make)

    def set_sensitivity(self, sens):
        """set_sensitivity(frequency_modulator_fc self, float sens)"""
        return _analog_swig.frequency_modulator_fc_set_sensitivity(self, sens)


    def sensitivity(self):
        """sensitivity(frequency_modulator_fc self) -> float"""
        return _analog_swig.frequency_modulator_fc_sensitivity(self)

    __swig_destroy__ = _analog_swig.delete_frequency_modulator_fc
    __del__ = lambda self: None
frequency_modulator_fc_swigregister = _analog_swig.frequency_modulator_fc_swigregister
frequency_modulator_fc_swigregister(frequency_modulator_fc)

def frequency_modulator_fc_make(sensitivity):
    """frequency_modulator_fc_make(float sensitivity) -> frequency_modulator_fc_sptr"""
    return _analog_swig.frequency_modulator_fc_make(sensitivity)

class fastnoise_source_s(object):
    """Proxy of C++ gr::analog::fastnoise_source_s class"""
    thisown = _swig_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 make(type, ampl, seed=0, samples=1024):
        """make(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024) -> fastnoise_source_s_sptr"""
        return _analog_swig.fastnoise_source_s_make(type, ampl, seed, samples)

    make = staticmethod(make)

    def sample(self):
        """sample(fastnoise_source_s self) -> short"""
        return _analog_swig.fastnoise_source_s_sample(self)


    def sample_unbiased(self):
        """sample_unbiased(fastnoise_source_s self) -> short"""
        return _analog_swig.fastnoise_source_s_sample_unbiased(self)


    def set_type(self, type):
        """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):
        """set_amplitude(fastnoise_source_s self, float ampl)"""
        return _analog_swig.fastnoise_source_s_set_amplitude(self, ampl)


    def type(self):
        """type(fastnoise_source_s self) -> gr::analog::noise_type_t"""
        return _analog_swig.fastnoise_source_s_type(self)


    def amplitude(self):
        """amplitude(fastnoise_source_s self) -> float"""
        return _analog_swig.fastnoise_source_s_amplitude(self)

    __swig_destroy__ = _analog_swig.delete_fastnoise_source_s
    __del__ = lambda self: None
fastnoise_source_s_swigregister = _analog_swig.fastnoise_source_s_swigregister
fastnoise_source_s_swigregister(fastnoise_source_s)

def fastnoise_source_s_make(type, ampl, seed=0, samples=1024):
    """fastnoise_source_s_make(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024) -> fastnoise_source_s_sptr"""
    return _analog_swig.fastnoise_source_s_make(type, ampl, seed, samples)

class fastnoise_source_i(object):
    """Proxy of C++ gr::analog::fastnoise_source_i class"""
    thisown = _swig_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 make(type, ampl, seed=0, samples=1024):
        """make(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024) -> fastnoise_source_i_sptr"""
        return _analog_swig.fastnoise_source_i_make(type, ampl, seed, samples)

    make = staticmethod(make)

    def sample(self):
        """sample(fastnoise_source_i self) -> int"""
        return _analog_swig.fastnoise_source_i_sample(self)


    def sample_unbiased(self):
        """sample_unbiased(fastnoise_source_i self) -> int"""
        return _analog_swig.fastnoise_source_i_sample_unbiased(self)


    def set_type(self, type):
        """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):
        """set_amplitude(fastnoise_source_i self, float ampl)"""
        return _analog_swig.fastnoise_source_i_set_amplitude(self, ampl)


    def type(self):
        """type(fastnoise_source_i self) -> gr::analog::noise_type_t"""
        return _analog_swig.fastnoise_source_i_type(self)


    def amplitude(self):
        """amplitude(fastnoise_source_i self) -> float"""
        return _analog_swig.fastnoise_source_i_amplitude(self)

    __swig_destroy__ = _analog_swig.delete_fastnoise_source_i
    __del__ = lambda self: None
fastnoise_source_i_swigregister = _analog_swig.fastnoise_source_i_swigregister
fastnoise_source_i_swigregister(fastnoise_source_i)

def fastnoise_source_i_make(type, ampl, seed=0, samples=1024):
    """fastnoise_source_i_make(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024) -> fastnoise_source_i_sptr"""
    return _analog_swig.fastnoise_source_i_make(type, ampl, seed, samples)

class fastnoise_source_f(object):
    """Proxy of C++ gr::analog::fastnoise_source_f class"""
    thisown = _swig_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 make(type, ampl, seed=0, samples=1024):
        """make(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024) -> fastnoise_source_f_sptr"""
        return _analog_swig.fastnoise_source_f_make(type, ampl, seed, samples)

    make = staticmethod(make)

    def sample(self):
        """sample(fastnoise_source_f self) -> float"""
        return _analog_swig.fastnoise_source_f_sample(self)


    def sample_unbiased(self):
        """sample_unbiased(fastnoise_source_f self) -> float"""
        return _analog_swig.fastnoise_source_f_sample_unbiased(self)


    def set_type(self, type):
        """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):
        """set_amplitude(fastnoise_source_f self, float ampl)"""
        return _analog_swig.fastnoise_source_f_set_amplitude(self, ampl)


    def type(self):
        """type(fastnoise_source_f self) -> gr::analog::noise_type_t"""
        return _analog_swig.fastnoise_source_f_type(self)


    def amplitude(self):
        """amplitude(fastnoise_source_f self) -> float"""
        return _analog_swig.fastnoise_source_f_amplitude(self)

    __swig_destroy__ = _analog_swig.delete_fastnoise_source_f
    __del__ = lambda self: None
fastnoise_source_f_swigregister = _analog_swig.fastnoise_source_f_swigregister
fastnoise_source_f_swigregister(fastnoise_source_f)

def fastnoise_source_f_make(type, ampl, seed=0, samples=1024):
    """fastnoise_source_f_make(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024) -> fastnoise_source_f_sptr"""
    return _analog_swig.fastnoise_source_f_make(type, ampl, seed, samples)

class fastnoise_source_c(object):
    """Proxy of C++ gr::analog::fastnoise_source_c class"""
    thisown = _swig_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 make(type, ampl, seed=0, samples=1024):
        """make(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024) -> fastnoise_source_c_sptr"""
        return _analog_swig.fastnoise_source_c_make(type, ampl, seed, samples)

    make = staticmethod(make)

    def sample(self):
        """sample(fastnoise_source_c self) -> gr_complex"""
        return _analog_swig.fastnoise_source_c_sample(self)


    def sample_unbiased(self):
        """sample_unbiased(fastnoise_source_c self) -> gr_complex"""
        return _analog_swig.fastnoise_source_c_sample_unbiased(self)


    def set_type(self, type):
        """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):
        """set_amplitude(fastnoise_source_c self, float ampl)"""
        return _analog_swig.fastnoise_source_c_set_amplitude(self, ampl)


    def type(self):
        """type(fastnoise_source_c self) -> gr::analog::noise_type_t"""
        return _analog_swig.fastnoise_source_c_type(self)


    def amplitude(self):
        """amplitude(fastnoise_source_c self) -> float"""
        return _analog_swig.fastnoise_source_c_amplitude(self)

    __swig_destroy__ = _analog_swig.delete_fastnoise_source_c
    __del__ = lambda self: None
fastnoise_source_c_swigregister = _analog_swig.fastnoise_source_c_swigregister
fastnoise_source_c_swigregister(fastnoise_source_c)

def fastnoise_source_c_make(type, ampl, seed=0, samples=1024):
    """fastnoise_source_c_make(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024) -> fastnoise_source_c_sptr"""
    return _analog_swig.fastnoise_source_c_make(type, ampl, seed, samples)

class noise_source_s(object):
    """Proxy of C++ gr::analog::noise_source_s class"""
    thisown = _swig_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 make(type, ampl, seed=0):
        """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)

    make = staticmethod(make)

    def set_type(self, type):
        """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):
        """set_amplitude(noise_source_s self, float ampl)"""
        return _analog_swig.noise_source_s_set_amplitude(self, ampl)


    def type(self):
        """type(noise_source_s self) -> gr::analog::noise_type_t"""
        return _analog_swig.noise_source_s_type(self)


    def amplitude(self):
        """amplitude(noise_source_s self) -> float"""
        return _analog_swig.noise_source_s_amplitude(self)

    __swig_destroy__ = _analog_swig.delete_noise_source_s
    __del__ = lambda self: None
noise_source_s_swigregister = _analog_swig.noise_source_s_swigregister
noise_source_s_swigregister(noise_source_s)

def noise_source_s_make(type, ampl, seed=0):
    """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_i(object):
    """Proxy of C++ gr::analog::noise_source_i class"""
    thisown = _swig_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 make(type, ampl, seed=0):
        """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)

    make = staticmethod(make)

    def set_type(self, type):
        """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):
        """set_amplitude(noise_source_i self, float ampl)"""
        return _analog_swig.noise_source_i_set_amplitude(self, ampl)


    def type(self):
        """type(noise_source_i self) -> gr::analog::noise_type_t"""
        return _analog_swig.noise_source_i_type(self)


    def amplitude(self):
        """amplitude(noise_source_i self) -> float"""
        return _analog_swig.noise_source_i_amplitude(self)

    __swig_destroy__ = _analog_swig.delete_noise_source_i
    __del__ = lambda self: None
noise_source_i_swigregister = _analog_swig.noise_source_i_swigregister
noise_source_i_swigregister(noise_source_i)

def noise_source_i_make(type, ampl, seed=0):
    """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_f(object):
    """Proxy of C++ gr::analog::noise_source_f class"""
    thisown = _swig_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 make(type, ampl, seed=0):
        """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)

    make = staticmethod(make)

    def set_type(self, type):
        """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):
        """set_amplitude(noise_source_f self, float ampl)"""
        return _analog_swig.noise_source_f_set_amplitude(self, ampl)


    def type(self):
        """type(noise_source_f self) -> gr::analog::noise_type_t"""
        return _analog_swig.noise_source_f_type(self)


    def amplitude(self):
        """amplitude(noise_source_f self) -> float"""
        return _analog_swig.noise_source_f_amplitude(self)

    __swig_destroy__ = _analog_swig.delete_noise_source_f
    __del__ = lambda self: None
noise_source_f_swigregister = _analog_swig.noise_source_f_swigregister
noise_source_f_swigregister(noise_source_f)

def noise_source_f_make(type, ampl, seed=0):
    """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_c(object):
    """Proxy of C++ gr::analog::noise_source_c class"""
    thisown = _swig_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 make(type, ampl, seed=0):
        """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)

    make = staticmethod(make)

    def set_type(self, type):
        """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):
        """set_amplitude(noise_source_c self, float ampl)"""
        return _analog_swig.noise_source_c_set_amplitude(self, ampl)


    def type(self):
        """type(noise_source_c self) -> gr::analog::noise_type_t"""
        return _analog_swig.noise_source_c_type(self)


    def amplitude(self):
        """amplitude(noise_source_c self) -> float"""
        return _analog_swig.noise_source_c_amplitude(self)

    __swig_destroy__ = _analog_swig.delete_noise_source_c
    __del__ = lambda self: None
noise_source_c_swigregister = _analog_swig.noise_source_c_swigregister
noise_source_c_swigregister(noise_source_c)

def noise_source_c_make(type, ampl, seed=0):
    """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 phase_modulator_fc(object):
    """Proxy of C++ gr::analog::phase_modulator_fc class"""
    thisown = _swig_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 make(sensitivity):
        """make(double sensitivity) -> phase_modulator_fc_sptr"""
        return _analog_swig.phase_modulator_fc_make(sensitivity)

    make = staticmethod(make)

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


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


    def set_sensitivity(self, s):
        """set_sensitivity(phase_modulator_fc self, double s)"""
        return _analog_swig.phase_modulator_fc_set_sensitivity(self, s)


    def set_phase(self, p):
        """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
    __del__ = lambda self: None
phase_modulator_fc_swigregister = _analog_swig.phase_modulator_fc_swigregister
phase_modulator_fc_swigregister(phase_modulator_fc)

def phase_modulator_fc_make(sensitivity):
    """phase_modulator_fc_make(double sensitivity) -> phase_modulator_fc_sptr"""
    return _analog_swig.phase_modulator_fc_make(sensitivity)

class pll_carriertracking_cc(control_loop):
    """Proxy of C++ gr::analog::pll_carriertracking_cc class"""
    thisown = _swig_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 make(loop_bw, max_freq, min_freq):
        """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)

    make = staticmethod(make)

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


    def squelch_enable(self, arg2):
        """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):
        """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):
        """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):
        """set_alpha(pll_carriertracking_cc self, float alpha)"""
        return _analog_swig.pll_carriertracking_cc_set_alpha(self, alpha)


    def set_beta(self, beta):
        """set_beta(pll_carriertracking_cc self, float beta)"""
        return _analog_swig.pll_carriertracking_cc_set_beta(self, beta)


    def set_frequency(self, freq):
        """set_frequency(pll_carriertracking_cc self, float freq)"""
        return _analog_swig.pll_carriertracking_cc_set_frequency(self, freq)


    def set_phase(self, phase):
        """set_phase(pll_carriertracking_cc self, float phase)"""
        return _analog_swig.pll_carriertracking_cc_set_phase(self, phase)


    def set_min_freq(self, freq):
        """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):
        """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):
        """get_loop_bandwidth(pll_carriertracking_cc self) -> float"""
        return _analog_swig.pll_carriertracking_cc_get_loop_bandwidth(self)


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


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


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


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


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


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


    def get_max_freq(self):
        """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
    __del__ = lambda self: None
pll_carriertracking_cc_swigregister = _analog_swig.pll_carriertracking_cc_swigregister
pll_carriertracking_cc_swigregister(pll_carriertracking_cc)

def pll_carriertracking_cc_make(loop_bw, max_freq, min_freq):
    """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):
    """Proxy of C++ gr::analog::pll_freqdet_cf class"""
    thisown = _swig_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 make(loop_bw, max_freq, min_freq):
        """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)

    make = staticmethod(make)

    def set_damping_factor(self, df):
        """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):
        """set_alpha(pll_freqdet_cf self, float alpha)"""
        return _analog_swig.pll_freqdet_cf_set_alpha(self, alpha)


    def set_beta(self, beta):
        """set_beta(pll_freqdet_cf self, float beta)"""
        return _analog_swig.pll_freqdet_cf_set_beta(self, beta)


    def set_frequency(self, freq):
        """set_frequency(pll_freqdet_cf self, float freq)"""
        return _analog_swig.pll_freqdet_cf_set_frequency(self, freq)


    def set_phase(self, phase):
        """set_phase(pll_freqdet_cf self, float phase)"""
        return _analog_swig.pll_freqdet_cf_set_phase(self, phase)


    def set_min_freq(self, freq):
        """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):
        """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):
        """get_loop_bandwidth(pll_freqdet_cf self) -> float"""
        return _analog_swig.pll_freqdet_cf_get_loop_bandwidth(self)


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


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


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


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


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


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


    def get_max_freq(self):
        """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
    __del__ = lambda self: None
pll_freqdet_cf_swigregister = _analog_swig.pll_freqdet_cf_swigregister
pll_freqdet_cf_swigregister(pll_freqdet_cf)

def pll_freqdet_cf_make(loop_bw, max_freq, min_freq):
    """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):
    """Proxy of C++ gr::analog::pll_refout_cc class"""
    thisown = _swig_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

    def make(loop_bw, max_freq, min_freq):
        """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)

    make = staticmethod(make)
    __swig_destroy__ = _analog_swig.delete_pll_refout_cc
    __del__ = lambda self: None
pll_refout_cc_swigregister = _analog_swig.pll_refout_cc_swigregister
pll_refout_cc_swigregister(pll_refout_cc)

def pll_refout_cc_make(loop_bw, max_freq, min_freq):
    """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):
    """Proxy of C++ gr::analog::probe_avg_mag_sqrd_c class"""
    thisown = _swig_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 make(threshold_db, alpha=0.0001):
        """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)

    make = staticmethod(make)

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


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


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


    def set_alpha(self, alpha):
        """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):
        """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):
        """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
    __del__ = lambda self: None
probe_avg_mag_sqrd_c_swigregister = _analog_swig.probe_avg_mag_sqrd_c_swigregister
probe_avg_mag_sqrd_c_swigregister(probe_avg_mag_sqrd_c)

def probe_avg_mag_sqrd_c_make(threshold_db, alpha=0.0001):
    """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):
    """Proxy of C++ gr::analog::probe_avg_mag_sqrd_cf class"""
    thisown = _swig_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 make(threshold_db, alpha=0.0001):
        """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)

    make = staticmethod(make)

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


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


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


    def set_alpha(self, alpha):
        """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):
        """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):
        """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
    __del__ = lambda self: None
probe_avg_mag_sqrd_cf_swigregister = _analog_swig.probe_avg_mag_sqrd_cf_swigregister
probe_avg_mag_sqrd_cf_swigregister(probe_avg_mag_sqrd_cf)

def probe_avg_mag_sqrd_cf_make(threshold_db, alpha=0.0001):
    """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):
    """Proxy of C++ gr::analog::probe_avg_mag_sqrd_f class"""
    thisown = _swig_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 make(threshold_db, alpha=0.0001):
        """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)

    make = staticmethod(make)

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


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


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


    def set_alpha(self, alpha):
        """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):
        """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):
        """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
    __del__ = lambda self: None
probe_avg_mag_sqrd_f_swigregister = _analog_swig.probe_avg_mag_sqrd_f_swigregister
probe_avg_mag_sqrd_f_swigregister(probe_avg_mag_sqrd_f)

def probe_avg_mag_sqrd_f_make(threshold_db, alpha=0.0001):
    """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):
    """Proxy of C++ gr::analog::pwr_squelch_cc class"""
    thisown = _swig_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 make(db, alpha=0.0001, ramp=0, gate=False):
        """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)

    make = staticmethod(make)

    def squelch_range(self):
        """squelch_range(pwr_squelch_cc self) -> pmt_vector_float"""
        return _analog_swig.pwr_squelch_cc_squelch_range(self)


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


    def set_threshold(self, db):
        """set_threshold(pwr_squelch_cc self, double db)"""
        return _analog_swig.pwr_squelch_cc_set_threshold(self, db)


    def set_alpha(self, alpha):
        """set_alpha(pwr_squelch_cc self, double alpha)"""
        return _analog_swig.pwr_squelch_cc_set_alpha(self, alpha)


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


    def set_ramp(self, ramp):
        """set_ramp(pwr_squelch_cc self, int ramp)"""
        return _analog_swig.pwr_squelch_cc_set_ramp(self, ramp)


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


    def set_gate(self, gate):
        """set_gate(pwr_squelch_cc self, bool gate)"""
        return _analog_swig.pwr_squelch_cc_set_gate(self, gate)


    def unmuted(self):
        """unmuted(pwr_squelch_cc self) -> bool"""
        return _analog_swig.pwr_squelch_cc_unmuted(self)

    __swig_destroy__ = _analog_swig.delete_pwr_squelch_cc
    __del__ = lambda self: None
pwr_squelch_cc_swigregister = _analog_swig.pwr_squelch_cc_swigregister
pwr_squelch_cc_swigregister(pwr_squelch_cc)

def pwr_squelch_cc_make(db, alpha=0.0001, ramp=0, gate=False):
    """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):
    """Proxy of C++ gr::analog::pwr_squelch_ff class"""
    thisown = _swig_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 make(db, alpha=0.0001, ramp=0, gate=False):
        """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)

    make = staticmethod(make)

    def squelch_range(self):
        """squelch_range(pwr_squelch_ff self) -> pmt_vector_float"""
        return _analog_swig.pwr_squelch_ff_squelch_range(self)


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


    def set_threshold(self, db):
        """set_threshold(pwr_squelch_ff self, double db)"""
        return _analog_swig.pwr_squelch_ff_set_threshold(self, db)


    def set_alpha(self, alpha):
        """set_alpha(pwr_squelch_ff self, double alpha)"""
        return _analog_swig.pwr_squelch_ff_set_alpha(self, alpha)


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


    def set_ramp(self, ramp):
        """set_ramp(pwr_squelch_ff self, int ramp)"""
        return _analog_swig.pwr_squelch_ff_set_ramp(self, ramp)


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


    def set_gate(self, gate):
        """set_gate(pwr_squelch_ff self, bool gate)"""
        return _analog_swig.pwr_squelch_ff_set_gate(self, gate)


    def unmuted(self):
        """unmuted(pwr_squelch_ff self) -> bool"""
        return _analog_swig.pwr_squelch_ff_unmuted(self)

    __swig_destroy__ = _analog_swig.delete_pwr_squelch_ff
    __del__ = lambda self: None
pwr_squelch_ff_swigregister = _analog_swig.pwr_squelch_ff_swigregister
pwr_squelch_ff_swigregister(pwr_squelch_ff)

def pwr_squelch_ff_make(db, alpha=0.0001, ramp=0, gate=False):
    """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):
    """Proxy of C++ gr::analog::quadrature_demod_cf class"""
    thisown = _swig_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 make(gain):
        """make(float gain) -> quadrature_demod_cf_sptr"""
        return _analog_swig.quadrature_demod_cf_make(gain)

    make = staticmethod(make)

    def set_gain(self, gain):
        """set_gain(quadrature_demod_cf self, float gain)"""
        return _analog_swig.quadrature_demod_cf_set_gain(self, gain)


    def gain(self):
        """gain(quadrature_demod_cf self) -> float"""
        return _analog_swig.quadrature_demod_cf_gain(self)

    __swig_destroy__ = _analog_swig.delete_quadrature_demod_cf
    __del__ = lambda self: None
quadrature_demod_cf_swigregister = _analog_swig.quadrature_demod_cf_swigregister
quadrature_demod_cf_swigregister(quadrature_demod_cf)

def quadrature_demod_cf_make(gain):
    """quadrature_demod_cf_make(float gain) -> quadrature_demod_cf_sptr"""
    return _analog_swig.quadrature_demod_cf_make(gain)

class rail_ff(object):
    """Proxy of C++ gr::analog::rail_ff class"""
    thisown = _swig_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 make(lo, hi):
        """make(float lo, float hi) -> rail_ff_sptr"""
        return _analog_swig.rail_ff_make(lo, hi)

    make = staticmethod(make)

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


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


    def set_lo(self, lo):
        """set_lo(rail_ff self, float lo)"""
        return _analog_swig.rail_ff_set_lo(self, lo)


    def set_hi(self, hi):
        """set_hi(rail_ff self, float hi)"""
        return _analog_swig.rail_ff_set_hi(self, hi)

    __swig_destroy__ = _analog_swig.delete_rail_ff
    __del__ = lambda self: None
rail_ff_swigregister = _analog_swig.rail_ff_swigregister
rail_ff_swigregister(rail_ff)

def rail_ff_make(lo, hi):
    """rail_ff_make(float lo, float hi) -> rail_ff_sptr"""
    return _analog_swig.rail_ff_make(lo, hi)

class sig_source_s(object):
    """Proxy of C++ gr::analog::sig_source_s class"""
    thisown = _swig_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 make(sampling_freq, waveform, wave_freq, ampl, offset=0):
        """make(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, short offset=0) -> sig_source_s_sptr"""
        return _analog_swig.sig_source_s_make(sampling_freq, waveform, wave_freq, ampl, offset)

    make = staticmethod(make)

    def sampling_freq(self):
        """sampling_freq(sig_source_s self) -> double"""
        return _analog_swig.sig_source_s_sampling_freq(self)


    def waveform(self):
        """waveform(sig_source_s self) -> gr::analog::gr_waveform_t"""
        return _analog_swig.sig_source_s_waveform(self)


    def frequency(self):
        """frequency(sig_source_s self) -> double"""
        return _analog_swig.sig_source_s_frequency(self)


    def amplitude(self):
        """amplitude(sig_source_s self) -> double"""
        return _analog_swig.sig_source_s_amplitude(self)


    def offset(self):
        """offset(sig_source_s self) -> short"""
        return _analog_swig.sig_source_s_offset(self)


    def set_sampling_freq(self, sampling_freq):
        """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):
        """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):
        """set_frequency(sig_source_s self, double frequency)"""
        return _analog_swig.sig_source_s_set_frequency(self, frequency)


    def set_amplitude(self, ampl):
        """set_amplitude(sig_source_s self, double ampl)"""
        return _analog_swig.sig_source_s_set_amplitude(self, ampl)


    def set_offset(self, offset):
        """set_offset(sig_source_s self, short offset)"""
        return _analog_swig.sig_source_s_set_offset(self, offset)

    __swig_destroy__ = _analog_swig.delete_sig_source_s
    __del__ = lambda self: None
sig_source_s_swigregister = _analog_swig.sig_source_s_swigregister
sig_source_s_swigregister(sig_source_s)

def sig_source_s_make(sampling_freq, waveform, wave_freq, ampl, offset=0):
    """sig_source_s_make(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, short offset=0) -> sig_source_s_sptr"""
    return _analog_swig.sig_source_s_make(sampling_freq, waveform, wave_freq, ampl, offset)

class sig_source_i(object):
    """Proxy of C++ gr::analog::sig_source_i class"""
    thisown = _swig_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 make(sampling_freq, waveform, wave_freq, ampl, offset=0):
        """make(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, int offset=0) -> sig_source_i_sptr"""
        return _analog_swig.sig_source_i_make(sampling_freq, waveform, wave_freq, ampl, offset)

    make = staticmethod(make)

    def sampling_freq(self):
        """sampling_freq(sig_source_i self) -> double"""
        return _analog_swig.sig_source_i_sampling_freq(self)


    def waveform(self):
        """waveform(sig_source_i self) -> gr::analog::gr_waveform_t"""
        return _analog_swig.sig_source_i_waveform(self)


    def frequency(self):
        """frequency(sig_source_i self) -> double"""
        return _analog_swig.sig_source_i_frequency(self)


    def amplitude(self):
        """amplitude(sig_source_i self) -> double"""
        return _analog_swig.sig_source_i_amplitude(self)


    def offset(self):
        """offset(sig_source_i self) -> int"""
        return _analog_swig.sig_source_i_offset(self)


    def set_sampling_freq(self, sampling_freq):
        """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):
        """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):
        """set_frequency(sig_source_i self, double frequency)"""
        return _analog_swig.sig_source_i_set_frequency(self, frequency)


    def set_amplitude(self, ampl):
        """set_amplitude(sig_source_i self, double ampl)"""
        return _analog_swig.sig_source_i_set_amplitude(self, ampl)


    def set_offset(self, offset):
        """set_offset(sig_source_i self, int offset)"""
        return _analog_swig.sig_source_i_set_offset(self, offset)

    __swig_destroy__ = _analog_swig.delete_sig_source_i
    __del__ = lambda self: None
sig_source_i_swigregister = _analog_swig.sig_source_i_swigregister
sig_source_i_swigregister(sig_source_i)

def sig_source_i_make(sampling_freq, waveform, wave_freq, ampl, offset=0):
    """sig_source_i_make(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, int offset=0) -> sig_source_i_sptr"""
    return _analog_swig.sig_source_i_make(sampling_freq, waveform, wave_freq, ampl, offset)

class sig_source_f(object):
    """Proxy of C++ gr::analog::sig_source_f class"""
    thisown = _swig_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 make(sampling_freq, waveform, wave_freq, ampl, offset=0):
        """make(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, float offset=0) -> sig_source_f_sptr"""
        return _analog_swig.sig_source_f_make(sampling_freq, waveform, wave_freq, ampl, offset)

    make = staticmethod(make)

    def sampling_freq(self):
        """sampling_freq(sig_source_f self) -> double"""
        return _analog_swig.sig_source_f_sampling_freq(self)


    def waveform(self):
        """waveform(sig_source_f self) -> gr::analog::gr_waveform_t"""
        return _analog_swig.sig_source_f_waveform(self)


    def frequency(self):
        """frequency(sig_source_f self) -> double"""
        return _analog_swig.sig_source_f_frequency(self)


    def amplitude(self):
        """amplitude(sig_source_f self) -> double"""
        return _analog_swig.sig_source_f_amplitude(self)


    def offset(self):
        """offset(sig_source_f self) -> float"""
        return _analog_swig.sig_source_f_offset(self)


    def set_sampling_freq(self, sampling_freq):
        """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):
        """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):
        """set_frequency(sig_source_f self, double frequency)"""
        return _analog_swig.sig_source_f_set_frequency(self, frequency)


    def set_amplitude(self, ampl):
        """set_amplitude(sig_source_f self, double ampl)"""
        return _analog_swig.sig_source_f_set_amplitude(self, ampl)


    def set_offset(self, offset):
        """set_offset(sig_source_f self, float offset)"""
        return _analog_swig.sig_source_f_set_offset(self, offset)

    __swig_destroy__ = _analog_swig.delete_sig_source_f
    __del__ = lambda self: None
sig_source_f_swigregister = _analog_swig.sig_source_f_swigregister
sig_source_f_swigregister(sig_source_f)

def sig_source_f_make(sampling_freq, waveform, wave_freq, ampl, offset=0):
    """sig_source_f_make(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, float offset=0) -> sig_source_f_sptr"""
    return _analog_swig.sig_source_f_make(sampling_freq, waveform, wave_freq, ampl, offset)

class sig_source_c(object):
    """Proxy of C++ gr::analog::sig_source_c class"""
    thisown = _swig_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 make(sampling_freq, waveform, wave_freq, ampl, offset=0):
        """make(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, gr_complex offset=0) -> sig_source_c_sptr"""
        return _analog_swig.sig_source_c_make(sampling_freq, waveform, wave_freq, ampl, offset)

    make = staticmethod(make)

    def sampling_freq(self):
        """sampling_freq(sig_source_c self) -> double"""
        return _analog_swig.sig_source_c_sampling_freq(self)


    def waveform(self):
        """waveform(sig_source_c self) -> gr::analog::gr_waveform_t"""
        return _analog_swig.sig_source_c_waveform(self)


    def frequency(self):
        """frequency(sig_source_c self) -> double"""
        return _analog_swig.sig_source_c_frequency(self)


    def amplitude(self):
        """amplitude(sig_source_c self) -> double"""
        return _analog_swig.sig_source_c_amplitude(self)


    def offset(self):
        """offset(sig_source_c self) -> gr_complex"""
        return _analog_swig.sig_source_c_offset(self)


    def set_sampling_freq(self, sampling_freq):
        """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):
        """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):
        """set_frequency(sig_source_c self, double frequency)"""
        return _analog_swig.sig_source_c_set_frequency(self, frequency)


    def set_amplitude(self, ampl):
        """set_amplitude(sig_source_c self, double ampl)"""
        return _analog_swig.sig_source_c_set_amplitude(self, ampl)


    def set_offset(self, offset):
        """set_offset(sig_source_c self, gr_complex offset)"""
        return _analog_swig.sig_source_c_set_offset(self, offset)

    __swig_destroy__ = _analog_swig.delete_sig_source_c
    __del__ = lambda self: None
sig_source_c_swigregister = _analog_swig.sig_source_c_swigregister
sig_source_c_swigregister(sig_source_c)

def sig_source_c_make(sampling_freq, waveform, wave_freq, ampl, offset=0):
    """sig_source_c_make(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, gr_complex offset=0) -> sig_source_c_sptr"""
    return _analog_swig.sig_source_c_make(sampling_freq, waveform, wave_freq, ampl, offset)


_analog_swig.GR_CONST_WAVE_swigconstant(_analog_swig)
GR_CONST_WAVE = _analog_swig.GR_CONST_WAVE

_analog_swig.GR_SIN_WAVE_swigconstant(_analog_swig)
GR_SIN_WAVE = _analog_swig.GR_SIN_WAVE

_analog_swig.GR_COS_WAVE_swigconstant(_analog_swig)
GR_COS_WAVE = _analog_swig.GR_COS_WAVE

_analog_swig.GR_SQR_WAVE_swigconstant(_analog_swig)
GR_SQR_WAVE = _analog_swig.GR_SQR_WAVE

_analog_swig.GR_TRI_WAVE_swigconstant(_analog_swig)
GR_TRI_WAVE = _analog_swig.GR_TRI_WAVE

_analog_swig.GR_SAW_WAVE_swigconstant(_analog_swig)
GR_SAW_WAVE = _analog_swig.GR_SAW_WAVE
class simple_squelch_cc(object):
    """Proxy of C++ gr::analog::simple_squelch_cc class"""
    thisown = _swig_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 make(threshold_db, alpha):
        """make(double threshold_db, double alpha) -> simple_squelch_cc_sptr"""
        return _analog_swig.simple_squelch_cc_make(threshold_db, alpha)

    make = staticmethod(make)

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


    def set_alpha(self, alpha):
        """set_alpha(simple_squelch_cc self, double alpha)"""
        return _analog_swig.simple_squelch_cc_set_alpha(self, alpha)


    def set_threshold(self, decibels):
        """set_threshold(simple_squelch_cc self, double decibels)"""
        return _analog_swig.simple_squelch_cc_set_threshold(self, decibels)


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


    def squelch_range(self):
        """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
    __del__ = lambda self: None
simple_squelch_cc_swigregister = _analog_swig.simple_squelch_cc_swigregister
simple_squelch_cc_swigregister(simple_squelch_cc)

def simple_squelch_cc_make(threshold_db, alpha):
    """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):
    """Proxy of C++ gr::analog::squelch_base_cc class"""
    thisown = _swig_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):
        """ramp(squelch_base_cc self) -> int"""
        return _analog_swig.squelch_base_cc_ramp(self)


    def set_ramp(self, ramp):
        """set_ramp(squelch_base_cc self, int ramp)"""
        return _analog_swig.squelch_base_cc_set_ramp(self, ramp)


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


    def set_gate(self, gate):
        """set_gate(squelch_base_cc self, bool gate)"""
        return _analog_swig.squelch_base_cc_set_gate(self, gate)


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


    def squelch_range(self):
        """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
    __del__ = lambda self: None
squelch_base_cc_swigregister = _analog_swig.squelch_base_cc_swigregister
squelch_base_cc_swigregister(squelch_base_cc)

class squelch_base_ff(object):
    """Proxy of C++ gr::analog::squelch_base_ff class"""
    thisown = _swig_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):
        """ramp(squelch_base_ff self) -> int"""
        return _analog_swig.squelch_base_ff_ramp(self)


    def set_ramp(self, ramp):
        """set_ramp(squelch_base_ff self, int ramp)"""
        return _analog_swig.squelch_base_ff_set_ramp(self, ramp)


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


    def set_gate(self, gate):
        """set_gate(squelch_base_ff self, bool gate)"""
        return _analog_swig.squelch_base_ff_set_gate(self, gate)


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


    def squelch_range(self):
        """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
    __del__ = lambda self: None
squelch_base_ff_swigregister = _analog_swig.squelch_base_ff_swigregister
squelch_base_ff_swigregister(squelch_base_ff)

class agc_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::analog::agc_cc)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::agc_cc)> self) -> agc_cc_sptr
        __init__(boost::shared_ptr<(gr::analog::agc_cc)> self, agc_cc p) -> agc_cc_sptr
        """
        this = _analog_swig.new_agc_cc_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(agc_cc_sptr self) -> agc_cc"""
        return _analog_swig.agc_cc_sptr___deref__(self)

    __swig_destroy__ = _analog_swig.delete_agc_cc_sptr
    __del__ = lambda self: None

    def make(self, rate=1e-4, reference=1.0, gain=1.0):
        """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):
        """rate(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_rate(self)


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


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


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


    def set_rate(self, rate):
        """set_rate(agc_cc_sptr self, float rate)"""
        return _analog_swig.agc_cc_sptr_set_rate(self, rate)


    def set_reference(self, reference):
        """set_reference(agc_cc_sptr self, float reference)"""
        return _analog_swig.agc_cc_sptr_set_reference(self, reference)


    def set_gain(self, gain):
        """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):
        """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):
        """history(agc_cc_sptr self) -> unsigned int"""
        return _analog_swig.agc_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(agc_cc_sptr self, int which) -> unsigned int"""
        return _analog_swig.agc_cc_sptr_sample_delay(self, which)


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


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


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


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


    def nitems_read(self, which_input):
        """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):
        """nitems_written(agc_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.agc_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """min_noutput_items(agc_cc_sptr self) -> int"""
        return _analog_swig.agc_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """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):
        """
        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):
        """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):
        """
        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):
        """pc_noutput_items(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """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):
        """pc_noutput_items_var(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_pc_noutput_items_var(self)


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


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


    def pc_nproduced_var(self):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """pc_work_time(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """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):
        """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):
        """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):
        """pc_throughput_avg(agc_cc_sptr self) -> float"""
        return _analog_swig.agc_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """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):
        """unset_processor_affinity(agc_cc_sptr self)"""
        return _analog_swig.agc_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(agc_cc_sptr self) -> int"""
        return _analog_swig.agc_cc_sptr_active_thread_priority(self)


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


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


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


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


    def input_signature(self):
        """input_signature(agc_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(agc_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc_cc_sptr_output_signature(self)


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


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(agc_cc_sptr self) -> std::string"""
        return _analog_swig.agc_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(agc_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.agc_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(agc_cc_sptr self) -> swig_int_ptr"""
        return _analog_swig.agc_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(agc_cc_sptr self) -> swig_int_ptr"""
        return _analog_swig.agc_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(agc_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.agc_cc_sptr_message_subscribers(self, which_port)

agc_cc_sptr_swigregister = _analog_swig.agc_cc_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::agc_ff)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::agc_ff)> self) -> agc_ff_sptr
        __init__(boost::shared_ptr<(gr::analog::agc_ff)> self, agc_ff p) -> agc_ff_sptr
        """
        this = _analog_swig.new_agc_ff_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(agc_ff_sptr self) -> agc_ff"""
        return _analog_swig.agc_ff_sptr___deref__(self)

    __swig_destroy__ = _analog_swig.delete_agc_ff_sptr
    __del__ = lambda self: None

    def make(self, rate=1e-4, reference=1.0, gain=1.0):
        """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):
        """rate(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_rate(self)


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


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


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


    def set_rate(self, rate):
        """set_rate(agc_ff_sptr self, float rate)"""
        return _analog_swig.agc_ff_sptr_set_rate(self, rate)


    def set_reference(self, reference):
        """set_reference(agc_ff_sptr self, float reference)"""
        return _analog_swig.agc_ff_sptr_set_reference(self, reference)


    def set_gain(self, gain):
        """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):
        """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):
        """history(agc_ff_sptr self) -> unsigned int"""
        return _analog_swig.agc_ff_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(agc_ff_sptr self, int which) -> unsigned int"""
        return _analog_swig.agc_ff_sptr_sample_delay(self, which)


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


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


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


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


    def nitems_read(self, which_input):
        """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):
        """nitems_written(agc_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.agc_ff_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """min_noutput_items(agc_ff_sptr self) -> int"""
        return _analog_swig.agc_ff_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """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):
        """
        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):
        """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):
        """
        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):
        """pc_noutput_items(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """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):
        """pc_noutput_items_var(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_pc_noutput_items_var(self)


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


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


    def pc_nproduced_var(self):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """pc_work_time(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """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):
        """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):
        """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):
        """pc_throughput_avg(agc_ff_sptr self) -> float"""
        return _analog_swig.agc_ff_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """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):
        """unset_processor_affinity(agc_ff_sptr self)"""
        return _analog_swig.agc_ff_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(agc_ff_sptr self) -> int"""
        return _analog_swig.agc_ff_sptr_active_thread_priority(self)


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


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


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


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


    def input_signature(self):
        """input_signature(agc_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc_ff_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(agc_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc_ff_sptr_output_signature(self)


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


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(agc_ff_sptr self) -> std::string"""
        return _analog_swig.agc_ff_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(agc_ff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.agc_ff_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(agc_ff_sptr self) -> swig_int_ptr"""
        return _analog_swig.agc_ff_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(agc_ff_sptr self) -> swig_int_ptr"""
        return _analog_swig.agc_ff_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(agc_ff_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.agc_ff_sptr_message_subscribers(self, which_port)

agc_ff_sptr_swigregister = _analog_swig.agc_ff_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::agc2_cc)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::agc2_cc)> self) -> agc2_cc_sptr
        __init__(boost::shared_ptr<(gr::analog::agc2_cc)> self, agc2_cc p) -> agc2_cc_sptr
        """
        this = _analog_swig.new_agc2_cc_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(agc2_cc_sptr self) -> agc2_cc"""
        return _analog_swig.agc2_cc_sptr___deref__(self)

    __swig_destroy__ = _analog_swig.delete_agc2_cc_sptr
    __del__ = lambda self: None

    def make(self, attack_rate=1e-1, decay_rate=1e-2, reference=1.0, gain=1.0):
        """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):
        """attack_rate(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_attack_rate(self)


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


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


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


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


    def set_attack_rate(self, rate):
        """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):
        """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):
        """set_reference(agc2_cc_sptr self, float reference)"""
        return _analog_swig.agc2_cc_sptr_set_reference(self, reference)


    def set_gain(self, gain):
        """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):
        """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):
        """history(agc2_cc_sptr self) -> unsigned int"""
        return _analog_swig.agc2_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(agc2_cc_sptr self, int which) -> unsigned int"""
        return _analog_swig.agc2_cc_sptr_sample_delay(self, which)


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


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


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


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


    def nitems_read(self, which_input):
        """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):
        """nitems_written(agc2_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.agc2_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """min_noutput_items(agc2_cc_sptr self) -> int"""
        return _analog_swig.agc2_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """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):
        """
        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):
        """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):
        """
        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):
        """pc_noutput_items(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """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):
        """pc_noutput_items_var(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_pc_noutput_items_var(self)


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


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


    def pc_nproduced_var(self):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """pc_work_time(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """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):
        """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):
        """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):
        """pc_throughput_avg(agc2_cc_sptr self) -> float"""
        return _analog_swig.agc2_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """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):
        """unset_processor_affinity(agc2_cc_sptr self)"""
        return _analog_swig.agc2_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(agc2_cc_sptr self) -> int"""
        return _analog_swig.agc2_cc_sptr_active_thread_priority(self)


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


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


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


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


    def input_signature(self):
        """input_signature(agc2_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc2_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(agc2_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc2_cc_sptr_output_signature(self)


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


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(agc2_cc_sptr self) -> std::string"""
        return _analog_swig.agc2_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(agc2_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.agc2_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(agc2_cc_sptr self) -> swig_int_ptr"""
        return _analog_swig.agc2_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(agc2_cc_sptr self) -> swig_int_ptr"""
        return _analog_swig.agc2_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(agc2_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.agc2_cc_sptr_message_subscribers(self, which_port)

agc2_cc_sptr_swigregister = _analog_swig.agc2_cc_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::agc2_ff)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::agc2_ff)> self) -> agc2_ff_sptr
        __init__(boost::shared_ptr<(gr::analog::agc2_ff)> self, agc2_ff p) -> agc2_ff_sptr
        """
        this = _analog_swig.new_agc2_ff_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(agc2_ff_sptr self) -> agc2_ff"""
        return _analog_swig.agc2_ff_sptr___deref__(self)

    __swig_destroy__ = _analog_swig.delete_agc2_ff_sptr
    __del__ = lambda self: None

    def make(self, attack_rate=1e-1, decay_rate=1e-2, reference=1.0, gain=1.0):
        """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):
        """attack_rate(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_attack_rate(self)


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


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


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


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


    def set_attack_rate(self, rate):
        """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):
        """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):
        """set_reference(agc2_ff_sptr self, float reference)"""
        return _analog_swig.agc2_ff_sptr_set_reference(self, reference)


    def set_gain(self, gain):
        """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):
        """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):
        """history(agc2_ff_sptr self) -> unsigned int"""
        return _analog_swig.agc2_ff_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(agc2_ff_sptr self, int which) -> unsigned int"""
        return _analog_swig.agc2_ff_sptr_sample_delay(self, which)


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


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


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


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


    def nitems_read(self, which_input):
        """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):
        """nitems_written(agc2_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.agc2_ff_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """min_noutput_items(agc2_ff_sptr self) -> int"""
        return _analog_swig.agc2_ff_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """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):
        """
        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):
        """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):
        """
        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):
        """pc_noutput_items(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """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):
        """pc_noutput_items_var(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_pc_noutput_items_var(self)


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


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


    def pc_nproduced_var(self):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """pc_work_time(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """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):
        """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):
        """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):
        """pc_throughput_avg(agc2_ff_sptr self) -> float"""
        return _analog_swig.agc2_ff_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """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):
        """unset_processor_affinity(agc2_ff_sptr self)"""
        return _analog_swig.agc2_ff_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(agc2_ff_sptr self) -> int"""
        return _analog_swig.agc2_ff_sptr_active_thread_priority(self)


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


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


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


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


    def input_signature(self):
        """input_signature(agc2_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc2_ff_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(agc2_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc2_ff_sptr_output_signature(self)


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


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(agc2_ff_sptr self) -> std::string"""
        return _analog_swig.agc2_ff_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(agc2_ff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.agc2_ff_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(agc2_ff_sptr self) -> swig_int_ptr"""
        return _analog_swig.agc2_ff_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(agc2_ff_sptr self) -> swig_int_ptr"""
        return _analog_swig.agc2_ff_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(agc2_ff_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.agc2_ff_sptr_message_subscribers(self, which_port)

agc2_ff_sptr_swigregister = _analog_swig.agc2_ff_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::agc3_cc)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::agc3_cc)> self) -> agc3_cc_sptr
        __init__(boost::shared_ptr<(gr::analog::agc3_cc)> self, agc3_cc p) -> agc3_cc_sptr
        """
        this = _analog_swig.new_agc3_cc_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(agc3_cc_sptr self) -> agc3_cc"""
        return _analog_swig.agc3_cc_sptr___deref__(self)

    __swig_destroy__ = _analog_swig.delete_agc3_cc_sptr
    __del__ = lambda self: None

    def make(self, attack_rate=1e-1, decay_rate=1e-2, reference=1.0, gain=1.0, iir_update_decim=1):
        """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):
        """attack_rate(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_attack_rate(self)


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


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


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


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


    def set_attack_rate(self, rate):
        """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):
        """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):
        """set_reference(agc3_cc_sptr self, float reference)"""
        return _analog_swig.agc3_cc_sptr_set_reference(self, reference)


    def set_gain(self, gain):
        """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):
        """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):
        """history(agc3_cc_sptr self) -> unsigned int"""
        return _analog_swig.agc3_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(agc3_cc_sptr self, int which) -> unsigned int"""
        return _analog_swig.agc3_cc_sptr_sample_delay(self, which)


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


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


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


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


    def nitems_read(self, which_input):
        """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):
        """nitems_written(agc3_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.agc3_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """min_noutput_items(agc3_cc_sptr self) -> int"""
        return _analog_swig.agc3_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """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):
        """
        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):
        """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):
        """
        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):
        """pc_noutput_items(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """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):
        """pc_noutput_items_var(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_pc_noutput_items_var(self)


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


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


    def pc_nproduced_var(self):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """pc_work_time(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """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):
        """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):
        """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):
        """pc_throughput_avg(agc3_cc_sptr self) -> float"""
        return _analog_swig.agc3_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """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):
        """unset_processor_affinity(agc3_cc_sptr self)"""
        return _analog_swig.agc3_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(agc3_cc_sptr self) -> int"""
        return _analog_swig.agc3_cc_sptr_active_thread_priority(self)


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


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


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


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


    def input_signature(self):
        """input_signature(agc3_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc3_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(agc3_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.agc3_cc_sptr_output_signature(self)


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


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(agc3_cc_sptr self) -> std::string"""
        return _analog_swig.agc3_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(agc3_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.agc3_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(agc3_cc_sptr self) -> swig_int_ptr"""
        return _analog_swig.agc3_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(agc3_cc_sptr self) -> swig_int_ptr"""
        return _analog_swig.agc3_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(agc3_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.agc3_cc_sptr_message_subscribers(self, which_port)

agc3_cc_sptr_swigregister = _analog_swig.agc3_cc_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::cpfsk_bc)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::cpfsk_bc)> self) -> cpfsk_bc_sptr
        __init__(boost::shared_ptr<(gr::analog::cpfsk_bc)> self, cpfsk_bc p) -> cpfsk_bc_sptr
        """
        this = _analog_swig.new_cpfsk_bc_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(cpfsk_bc_sptr self) -> cpfsk_bc"""
        return _analog_swig.cpfsk_bc_sptr___deref__(self)

    __swig_destroy__ = _analog_swig.delete_cpfsk_bc_sptr
    __del__ = lambda self: None

    def make(self, k, ampl, samples_per_sym):
        """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):
        """set_amplitude(cpfsk_bc_sptr self, float amplitude)"""
        return _analog_swig.cpfsk_bc_sptr_set_amplitude(self, amplitude)


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


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


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


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


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(cpfsk_bc_sptr self, int which) -> unsigned int"""
        return _analog_swig.cpfsk_bc_sptr_sample_delay(self, which)


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


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


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


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


    def nitems_read(self, which_input):
        """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):
        """nitems_written(cpfsk_bc_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.cpfsk_bc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """min_noutput_items(cpfsk_bc_sptr self) -> int"""
        return _analog_swig.cpfsk_bc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """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):
        """
        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):
        """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):
        """
        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):
        """pc_noutput_items(cpfsk_bc_sptr self) -> float"""
        return _analog_swig.cpfsk_bc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """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):
        """pc_noutput_items_var(cpfsk_bc_sptr self) -> float"""
        return _analog_swig.cpfsk_bc_sptr_pc_noutput_items_var(self)


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


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


    def pc_nproduced_var(self):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """pc_work_time(cpfsk_bc_sptr self) -> float"""
        return _analog_swig.cpfsk_bc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """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):
        """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):
        """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):
        """pc_throughput_avg(cpfsk_bc_sptr self) -> float"""
        return _analog_swig.cpfsk_bc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """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):
        """unset_processor_affinity(cpfsk_bc_sptr self)"""
        return _analog_swig.cpfsk_bc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(cpfsk_bc_sptr self) -> int"""
        return _analog_swig.cpfsk_bc_sptr_active_thread_priority(self)


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


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


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


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


    def input_signature(self):
        """input_signature(cpfsk_bc_sptr self) -> io_signature_sptr"""
        return _analog_swig.cpfsk_bc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(cpfsk_bc_sptr self) -> io_signature_sptr"""
        return _analog_swig.cpfsk_bc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(cpfsk_bc_sptr self) -> long"""
        return _analog_swig.cpfsk_bc_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(cpfsk_bc_sptr self) -> std::string"""
        return _analog_swig.cpfsk_bc_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(cpfsk_bc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.cpfsk_bc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(cpfsk_bc_sptr self) -> swig_int_ptr"""
        return _analog_swig.cpfsk_bc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(cpfsk_bc_sptr self) -> swig_int_ptr"""
        return _analog_swig.cpfsk_bc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(cpfsk_bc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.cpfsk_bc_sptr_message_subscribers(self, which_port)

cpfsk_bc_sptr_swigregister = _analog_swig.cpfsk_bc_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::ctcss_squelch_ff)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::ctcss_squelch_ff)> self) -> ctcss_squelch_ff_sptr
        __init__(boost::shared_ptr<(gr::analog::ctcss_squelch_ff)> self, ctcss_squelch_ff p) -> ctcss_squelch_ff_sptr
        """
        this = _analog_swig.new_ctcss_squelch_ff_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, rate, freq, level, len, ramp, gate):
        """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):
        """squelch_range(ctcss_squelch_ff_sptr self) -> pmt_vector_float"""
        return _analog_swig.ctcss_squelch_ff_sptr_squelch_range(self)


    def level(self):
        """level(ctcss_squelch_ff_sptr self) -> float"""
        return _analog_swig.ctcss_squelch_ff_sptr_level(self)


    def set_level(self, level):
        """set_level(ctcss_squelch_ff_sptr self, float level)"""
        return _analog_swig.ctcss_squelch_ff_sptr_set_level(self, level)


    def len(self):
        """len(ctcss_squelch_ff_sptr self) -> int"""
        return _analog_swig.ctcss_squelch_ff_sptr_len(self)


    def frequency(self):
        """frequency(ctcss_squelch_ff_sptr self) -> float"""
        return _analog_swig.ctcss_squelch_ff_sptr_frequency(self)


    def set_frequency(self, frequency):
        """set_frequency(ctcss_squelch_ff_sptr self, float frequency)"""
        return _analog_swig.ctcss_squelch_ff_sptr_set_frequency(self, frequency)


    def ramp(self):
        """ramp(ctcss_squelch_ff_sptr self) -> int"""
        return _analog_swig.ctcss_squelch_ff_sptr_ramp(self)


    def set_ramp(self, ramp):
        """set_ramp(ctcss_squelch_ff_sptr self, int ramp)"""
        return _analog_swig.ctcss_squelch_ff_sptr_set_ramp(self, ramp)


    def gate(self):
        """gate(ctcss_squelch_ff_sptr self) -> bool"""
        return _analog_swig.ctcss_squelch_ff_sptr_gate(self)


    def set_gate(self, gate):
        """set_gate(ctcss_squelch_ff_sptr self, bool gate)"""
        return _analog_swig.ctcss_squelch_ff_sptr_set_gate(self, gate)


    def unmuted(self):
        """unmuted(ctcss_squelch_ff_sptr self) -> bool"""
        return _analog_swig.ctcss_squelch_ff_sptr_unmuted(self)


    def history(self):
        """history(ctcss_squelch_ff_sptr self) -> unsigned int"""
        return _analog_swig.ctcss_squelch_ff_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(ctcss_squelch_ff_sptr self, int which) -> unsigned int"""
        return _analog_swig.ctcss_squelch_ff_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(ctcss_squelch_ff_sptr self) -> int"""
        return _analog_swig.ctcss_squelch_ff_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(ctcss_squelch_ff_sptr self) -> double"""
        return _analog_swig.ctcss_squelch_ff_sptr_relative_rate(self)


    def start(self):
        """start(ctcss_squelch_ff_sptr self) -> bool"""
        return _analog_swig.ctcss_squelch_ff_sptr_start(self)


    def stop(self):
        """stop(ctcss_squelch_ff_sptr self) -> bool"""
        return _analog_swig.ctcss_squelch_ff_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(ctcss_squelch_ff_sptr self) -> float"""
        return _analog_swig.ctcss_squelch_ff_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(ctcss_squelch_ff_sptr self)"""
        return _analog_swig.ctcss_squelch_ff_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(ctcss_squelch_ff_sptr self) -> int"""
        return _analog_swig.ctcss_squelch_ff_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(ctcss_squelch_ff_sptr self) -> int"""
        return _analog_swig.ctcss_squelch_ff_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(ctcss_squelch_ff_sptr self) -> std::string"""
        return _analog_swig.ctcss_squelch_ff_sptr_name(self)


    def symbol_name(self):
        """symbol_name(ctcss_squelch_ff_sptr self) -> std::string"""
        return _analog_swig.ctcss_squelch_ff_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(ctcss_squelch_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.ctcss_squelch_ff_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(ctcss_squelch_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.ctcss_squelch_ff_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(ctcss_squelch_ff_sptr self) -> long"""
        return _analog_swig.ctcss_squelch_ff_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(ctcss_squelch_ff_sptr self) -> std::string"""
        return _analog_swig.ctcss_squelch_ff_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(ctcss_squelch_ff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.ctcss_squelch_ff_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(ctcss_squelch_ff_sptr self) -> swig_int_ptr"""
        return _analog_swig.ctcss_squelch_ff_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(ctcss_squelch_ff_sptr self) -> swig_int_ptr"""
        return _analog_swig.ctcss_squelch_ff_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(ctcss_squelch_ff_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.ctcss_squelch_ff_sptr_message_subscribers(self, which_port)

ctcss_squelch_ff_sptr_swigregister = _analog_swig.ctcss_squelch_ff_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::dpll_bb)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::dpll_bb)> self) -> dpll_bb_sptr
        __init__(boost::shared_ptr<(gr::analog::dpll_bb)> self, dpll_bb p) -> dpll_bb_sptr
        """
        this = _analog_swig.new_dpll_bb_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(dpll_bb_sptr self) -> dpll_bb"""
        return _analog_swig.dpll_bb_sptr___deref__(self)

    __swig_destroy__ = _analog_swig.delete_dpll_bb_sptr
    __del__ = lambda self: None

    def make(self, period, gain):
        """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):
        """set_gain(dpll_bb_sptr self, float gain)"""
        return _analog_swig.dpll_bb_sptr_set_gain(self, gain)


    def set_decision_threshold(self, thresh):
        """set_decision_threshold(dpll_bb_sptr self, float thresh)"""
        return _analog_swig.dpll_bb_sptr_set_decision_threshold(self, thresh)


    def gain(self):
        """gain(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_gain(self)


    def freq(self):
        """freq(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_freq(self)


    def phase(self):
        """phase(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_phase(self)


    def decision_threshold(self):
        """decision_threshold(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_decision_threshold(self)


    def history(self):
        """history(dpll_bb_sptr self) -> unsigned int"""
        return _analog_swig.dpll_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(dpll_bb_sptr self, int which) -> unsigned int"""
        return _analog_swig.dpll_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(dpll_bb_sptr self) -> int"""
        return _analog_swig.dpll_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(dpll_bb_sptr self) -> double"""
        return _analog_swig.dpll_bb_sptr_relative_rate(self)


    def start(self):
        """start(dpll_bb_sptr self) -> bool"""
        return _analog_swig.dpll_bb_sptr_start(self)


    def stop(self):
        """stop(dpll_bb_sptr self) -> bool"""
        return _analog_swig.dpll_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """nitems_written(dpll_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.dpll_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """min_noutput_items(dpll_bb_sptr self) -> int"""
        return _analog_swig.dpll_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """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):
        """
        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):
        """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):
        """
        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):
        """pc_noutput_items(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """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):
        """pc_noutput_items_var(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """pc_work_time(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """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):
        """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):
        """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):
        """pc_throughput_avg(dpll_bb_sptr self) -> float"""
        return _analog_swig.dpll_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """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):
        """unset_processor_affinity(dpll_bb_sptr self)"""
        return _analog_swig.dpll_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(dpll_bb_sptr self) -> int"""
        return _analog_swig.dpll_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(dpll_bb_sptr self) -> int"""
        return _analog_swig.dpll_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(dpll_bb_sptr self, int priority) -> int"""
        return _analog_swig.dpll_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(dpll_bb_sptr self) -> std::string"""
        return _analog_swig.dpll_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(dpll_bb_sptr self) -> std::string"""
        return _analog_swig.dpll_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(dpll_bb_sptr self) -> io_signature_sptr"""
        return _analog_swig.dpll_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(dpll_bb_sptr self) -> io_signature_sptr"""
        return _analog_swig.dpll_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(dpll_bb_sptr self) -> long"""
        return _analog_swig.dpll_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(dpll_bb_sptr self) -> std::string"""
        return _analog_swig.dpll_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(dpll_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.dpll_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(dpll_bb_sptr self) -> swig_int_ptr"""
        return _analog_swig.dpll_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(dpll_bb_sptr self) -> swig_int_ptr"""
        return _analog_swig.dpll_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(dpll_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.dpll_bb_sptr_message_subscribers(self, which_port)

dpll_bb_sptr_swigregister = _analog_swig.dpll_bb_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::feedforward_agc_cc)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::feedforward_agc_cc)> self) -> feedforward_agc_cc_sptr
        __init__(boost::shared_ptr<(gr::analog::feedforward_agc_cc)> self, feedforward_agc_cc p) -> feedforward_agc_cc_sptr
        """
        this = _analog_swig.new_feedforward_agc_cc_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, nsamples, reference):
        """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):
        """history(feedforward_agc_cc_sptr self) -> unsigned int"""
        return _analog_swig.feedforward_agc_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(feedforward_agc_cc_sptr self, int which) -> unsigned int"""
        return _analog_swig.feedforward_agc_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(feedforward_agc_cc_sptr self) -> int"""
        return _analog_swig.feedforward_agc_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(feedforward_agc_cc_sptr self) -> double"""
        return _analog_swig.feedforward_agc_cc_sptr_relative_rate(self)


    def start(self):
        """start(feedforward_agc_cc_sptr self) -> bool"""
        return _analog_swig.feedforward_agc_cc_sptr_start(self)


    def stop(self):
        """stop(feedforward_agc_cc_sptr self) -> bool"""
        return _analog_swig.feedforward_agc_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(feedforward_agc_cc_sptr self) -> float"""
        return _analog_swig.feedforward_agc_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(feedforward_agc_cc_sptr self)"""
        return _analog_swig.feedforward_agc_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(feedforward_agc_cc_sptr self) -> int"""
        return _analog_swig.feedforward_agc_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(feedforward_agc_cc_sptr self) -> int"""
        return _analog_swig.feedforward_agc_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(feedforward_agc_cc_sptr self) -> std::string"""
        return _analog_swig.feedforward_agc_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(feedforward_agc_cc_sptr self) -> std::string"""
        return _analog_swig.feedforward_agc_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(feedforward_agc_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.feedforward_agc_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(feedforward_agc_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.feedforward_agc_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(feedforward_agc_cc_sptr self) -> long"""
        return _analog_swig.feedforward_agc_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(feedforward_agc_cc_sptr self) -> std::string"""
        return _analog_swig.feedforward_agc_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(feedforward_agc_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.feedforward_agc_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(feedforward_agc_cc_sptr self) -> swig_int_ptr"""
        return _analog_swig.feedforward_agc_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(feedforward_agc_cc_sptr self) -> swig_int_ptr"""
        return _analog_swig.feedforward_agc_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(feedforward_agc_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.feedforward_agc_cc_sptr_message_subscribers(self, which_port)

feedforward_agc_cc_sptr_swigregister = _analog_swig.feedforward_agc_cc_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::fmdet_cf)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::fmdet_cf)> self) -> fmdet_cf_sptr
        __init__(boost::shared_ptr<(gr::analog::fmdet_cf)> self, fmdet_cf p) -> fmdet_cf_sptr
        """
        this = _analog_swig.new_fmdet_cf_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(fmdet_cf_sptr self) -> fmdet_cf"""
        return _analog_swig.fmdet_cf_sptr___deref__(self)

    __swig_destroy__ = _analog_swig.delete_fmdet_cf_sptr
    __del__ = lambda self: None

    def make(self, samplerate, freq_low, freq_high, scl):
        """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):
        """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, freq_high):
        """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):
        """freq(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_freq(self)


    def freq_high(self):
        """freq_high(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_freq_high(self)


    def freq_low(self):
        """freq_low(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_freq_low(self)


    def scale(self):
        """scale(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_scale(self)


    def bias(self):
        """bias(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_bias(self)


    def history(self):
        """history(fmdet_cf_sptr self) -> unsigned int"""
        return _analog_swig.fmdet_cf_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(fmdet_cf_sptr self, int which) -> unsigned int"""
        return _analog_swig.fmdet_cf_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(fmdet_cf_sptr self) -> int"""
        return _analog_swig.fmdet_cf_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(fmdet_cf_sptr self) -> double"""
        return _analog_swig.fmdet_cf_sptr_relative_rate(self)


    def start(self):
        """start(fmdet_cf_sptr self) -> bool"""
        return _analog_swig.fmdet_cf_sptr_start(self)


    def stop(self):
        """stop(fmdet_cf_sptr self) -> bool"""
        return _analog_swig.fmdet_cf_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """nitems_written(fmdet_cf_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.fmdet_cf_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """min_noutput_items(fmdet_cf_sptr self) -> int"""
        return _analog_swig.fmdet_cf_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """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):
        """
        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):
        """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):
        """
        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):
        """pc_noutput_items(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """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):
        """pc_noutput_items_var(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """pc_work_time(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """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):
        """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):
        """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):
        """pc_throughput_avg(fmdet_cf_sptr self) -> float"""
        return _analog_swig.fmdet_cf_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """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):
        """unset_processor_affinity(fmdet_cf_sptr self)"""
        return _analog_swig.fmdet_cf_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(fmdet_cf_sptr self) -> int"""
        return _analog_swig.fmdet_cf_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(fmdet_cf_sptr self) -> int"""
        return _analog_swig.fmdet_cf_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(fmdet_cf_sptr self, int priority) -> int"""
        return _analog_swig.fmdet_cf_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(fmdet_cf_sptr self) -> std::string"""
        return _analog_swig.fmdet_cf_sptr_name(self)


    def symbol_name(self):
        """symbol_name(fmdet_cf_sptr self) -> std::string"""
        return _analog_swig.fmdet_cf_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(fmdet_cf_sptr self) -> io_signature_sptr"""
        return _analog_swig.fmdet_cf_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(fmdet_cf_sptr self) -> io_signature_sptr"""
        return _analog_swig.fmdet_cf_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(fmdet_cf_sptr self) -> long"""
        return _analog_swig.fmdet_cf_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(fmdet_cf_sptr self) -> std::string"""
        return _analog_swig.fmdet_cf_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(fmdet_cf_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.fmdet_cf_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(fmdet_cf_sptr self) -> swig_int_ptr"""
        return _analog_swig.fmdet_cf_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(fmdet_cf_sptr self) -> swig_int_ptr"""
        return _analog_swig.fmdet_cf_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(fmdet_cf_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.fmdet_cf_sptr_message_subscribers(self, which_port)

fmdet_cf_sptr_swigregister = _analog_swig.fmdet_cf_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::frequency_modulator_fc)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::frequency_modulator_fc)> self) -> frequency_modulator_fc_sptr
        __init__(boost::shared_ptr<(gr::analog::frequency_modulator_fc)> self, frequency_modulator_fc p) -> frequency_modulator_fc_sptr
        """
        this = _analog_swig.new_frequency_modulator_fc_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, sensitivity):
        """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):
        """set_sensitivity(frequency_modulator_fc_sptr self, float sens)"""
        return _analog_swig.frequency_modulator_fc_sptr_set_sensitivity(self, sens)


    def sensitivity(self):
        """sensitivity(frequency_modulator_fc_sptr self) -> float"""
        return _analog_swig.frequency_modulator_fc_sptr_sensitivity(self)


    def history(self):
        """history(frequency_modulator_fc_sptr self) -> unsigned int"""
        return _analog_swig.frequency_modulator_fc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(frequency_modulator_fc_sptr self, int which) -> unsigned int"""
        return _analog_swig.frequency_modulator_fc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(frequency_modulator_fc_sptr self) -> int"""
        return _analog_swig.frequency_modulator_fc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(frequency_modulator_fc_sptr self) -> double"""
        return _analog_swig.frequency_modulator_fc_sptr_relative_rate(self)


    def start(self):
        """start(frequency_modulator_fc_sptr self) -> bool"""
        return _analog_swig.frequency_modulator_fc_sptr_start(self)


    def stop(self):
        """stop(frequency_modulator_fc_sptr self) -> bool"""
        return _analog_swig.frequency_modulator_fc_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(frequency_modulator_fc_sptr self) -> float"""
        return _analog_swig.frequency_modulator_fc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(frequency_modulator_fc_sptr self)"""
        return _analog_swig.frequency_modulator_fc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(frequency_modulator_fc_sptr self) -> int"""
        return _analog_swig.frequency_modulator_fc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(frequency_modulator_fc_sptr self) -> int"""
        return _analog_swig.frequency_modulator_fc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(frequency_modulator_fc_sptr self) -> std::string"""
        return _analog_swig.frequency_modulator_fc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(frequency_modulator_fc_sptr self) -> std::string"""
        return _analog_swig.frequency_modulator_fc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(frequency_modulator_fc_sptr self) -> io_signature_sptr"""
        return _analog_swig.frequency_modulator_fc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(frequency_modulator_fc_sptr self) -> io_signature_sptr"""
        return _analog_swig.frequency_modulator_fc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(frequency_modulator_fc_sptr self) -> long"""
        return _analog_swig.frequency_modulator_fc_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(frequency_modulator_fc_sptr self) -> std::string"""
        return _analog_swig.frequency_modulator_fc_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(frequency_modulator_fc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.frequency_modulator_fc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(frequency_modulator_fc_sptr self) -> swig_int_ptr"""
        return _analog_swig.frequency_modulator_fc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(frequency_modulator_fc_sptr self) -> swig_int_ptr"""
        return _analog_swig.frequency_modulator_fc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(frequency_modulator_fc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.frequency_modulator_fc_sptr_message_subscribers(self, which_port)

frequency_modulator_fc_sptr_swigregister = _analog_swig.frequency_modulator_fc_sptr_swigregister
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_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::analog::fastnoise_source_s)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::fastnoise_source_s)> self) -> fastnoise_source_s_sptr
        __init__(boost::shared_ptr<(gr::analog::fastnoise_source_s)> self, fastnoise_source_s p) -> fastnoise_source_s_sptr
        """
        this = _analog_swig.new_fastnoise_source_s_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, type, ampl, seed=0, samples=1024):
        """make(fastnoise_source_s_sptr self, gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024) -> fastnoise_source_s_sptr"""
        return _analog_swig.fastnoise_source_s_sptr_make(self, type, ampl, seed, samples)


    def sample(self):
        """sample(fastnoise_source_s_sptr self) -> short"""
        return _analog_swig.fastnoise_source_s_sptr_sample(self)


    def sample_unbiased(self):
        """sample_unbiased(fastnoise_source_s_sptr self) -> short"""
        return _analog_swig.fastnoise_source_s_sptr_sample_unbiased(self)


    def set_type(self, type):
        """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):
        """set_amplitude(fastnoise_source_s_sptr self, float ampl)"""
        return _analog_swig.fastnoise_source_s_sptr_set_amplitude(self, ampl)


    def type(self):
        """type(fastnoise_source_s_sptr self) -> gr::analog::noise_type_t"""
        return _analog_swig.fastnoise_source_s_sptr_type(self)


    def amplitude(self):
        """amplitude(fastnoise_source_s_sptr self) -> float"""
        return _analog_swig.fastnoise_source_s_sptr_amplitude(self)


    def history(self):
        """history(fastnoise_source_s_sptr self) -> unsigned int"""
        return _analog_swig.fastnoise_source_s_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(fastnoise_source_s_sptr self, int which) -> unsigned int"""
        return _analog_swig.fastnoise_source_s_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(fastnoise_source_s_sptr self) -> int"""
        return _analog_swig.fastnoise_source_s_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(fastnoise_source_s_sptr self) -> double"""
        return _analog_swig.fastnoise_source_s_sptr_relative_rate(self)


    def start(self):
        """start(fastnoise_source_s_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_s_sptr_start(self)


    def stop(self):
        """stop(fastnoise_source_s_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_s_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(fastnoise_source_s_sptr self) -> float"""
        return _analog_swig.fastnoise_source_s_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(fastnoise_source_s_sptr self)"""
        return _analog_swig.fastnoise_source_s_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(fastnoise_source_s_sptr self) -> int"""
        return _analog_swig.fastnoise_source_s_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(fastnoise_source_s_sptr self) -> int"""
        return _analog_swig.fastnoise_source_s_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(fastnoise_source_s_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_s_sptr_name(self)


    def symbol_name(self):
        """symbol_name(fastnoise_source_s_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_s_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(fastnoise_source_s_sptr self) -> io_signature_sptr"""
        return _analog_swig.fastnoise_source_s_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(fastnoise_source_s_sptr self) -> io_signature_sptr"""
        return _analog_swig.fastnoise_source_s_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(fastnoise_source_s_sptr self) -> long"""
        return _analog_swig.fastnoise_source_s_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(fastnoise_source_s_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_s_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(fastnoise_source_s_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.fastnoise_source_s_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(fastnoise_source_s_sptr self) -> swig_int_ptr"""
        return _analog_swig.fastnoise_source_s_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(fastnoise_source_s_sptr self) -> swig_int_ptr"""
        return _analog_swig.fastnoise_source_s_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(fastnoise_source_s_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.fastnoise_source_s_sptr_message_subscribers(self, which_port)

fastnoise_source_s_sptr_swigregister = _analog_swig.fastnoise_source_s_sptr_swigregister
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_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::analog::fastnoise_source_i)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::fastnoise_source_i)> self) -> fastnoise_source_i_sptr
        __init__(boost::shared_ptr<(gr::analog::fastnoise_source_i)> self, fastnoise_source_i p) -> fastnoise_source_i_sptr
        """
        this = _analog_swig.new_fastnoise_source_i_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, type, ampl, seed=0, samples=1024):
        """make(fastnoise_source_i_sptr self, gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024) -> fastnoise_source_i_sptr"""
        return _analog_swig.fastnoise_source_i_sptr_make(self, type, ampl, seed, samples)


    def sample(self):
        """sample(fastnoise_source_i_sptr self) -> int"""
        return _analog_swig.fastnoise_source_i_sptr_sample(self)


    def sample_unbiased(self):
        """sample_unbiased(fastnoise_source_i_sptr self) -> int"""
        return _analog_swig.fastnoise_source_i_sptr_sample_unbiased(self)


    def set_type(self, type):
        """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):
        """set_amplitude(fastnoise_source_i_sptr self, float ampl)"""
        return _analog_swig.fastnoise_source_i_sptr_set_amplitude(self, ampl)


    def type(self):
        """type(fastnoise_source_i_sptr self) -> gr::analog::noise_type_t"""
        return _analog_swig.fastnoise_source_i_sptr_type(self)


    def amplitude(self):
        """amplitude(fastnoise_source_i_sptr self) -> float"""
        return _analog_swig.fastnoise_source_i_sptr_amplitude(self)


    def history(self):
        """history(fastnoise_source_i_sptr self) -> unsigned int"""
        return _analog_swig.fastnoise_source_i_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(fastnoise_source_i_sptr self, int which) -> unsigned int"""
        return _analog_swig.fastnoise_source_i_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(fastnoise_source_i_sptr self) -> int"""
        return _analog_swig.fastnoise_source_i_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(fastnoise_source_i_sptr self) -> double"""
        return _analog_swig.fastnoise_source_i_sptr_relative_rate(self)


    def start(self):
        """start(fastnoise_source_i_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_i_sptr_start(self)


    def stop(self):
        """stop(fastnoise_source_i_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_i_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(fastnoise_source_i_sptr self) -> float"""
        return _analog_swig.fastnoise_source_i_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(fastnoise_source_i_sptr self)"""
        return _analog_swig.fastnoise_source_i_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(fastnoise_source_i_sptr self) -> int"""
        return _analog_swig.fastnoise_source_i_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(fastnoise_source_i_sptr self) -> int"""
        return _analog_swig.fastnoise_source_i_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(fastnoise_source_i_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_i_sptr_name(self)


    def symbol_name(self):
        """symbol_name(fastnoise_source_i_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_i_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(fastnoise_source_i_sptr self) -> io_signature_sptr"""
        return _analog_swig.fastnoise_source_i_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(fastnoise_source_i_sptr self) -> io_signature_sptr"""
        return _analog_swig.fastnoise_source_i_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(fastnoise_source_i_sptr self) -> long"""
        return _analog_swig.fastnoise_source_i_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(fastnoise_source_i_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_i_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(fastnoise_source_i_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.fastnoise_source_i_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(fastnoise_source_i_sptr self) -> swig_int_ptr"""
        return _analog_swig.fastnoise_source_i_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(fastnoise_source_i_sptr self) -> swig_int_ptr"""
        return _analog_swig.fastnoise_source_i_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(fastnoise_source_i_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.fastnoise_source_i_sptr_message_subscribers(self, which_port)

fastnoise_source_i_sptr_swigregister = _analog_swig.fastnoise_source_i_sptr_swigregister
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_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::analog::fastnoise_source_f)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::fastnoise_source_f)> self) -> fastnoise_source_f_sptr
        __init__(boost::shared_ptr<(gr::analog::fastnoise_source_f)> self, fastnoise_source_f p) -> fastnoise_source_f_sptr
        """
        this = _analog_swig.new_fastnoise_source_f_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, type, ampl, seed=0, samples=1024):
        """make(fastnoise_source_f_sptr self, gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024) -> fastnoise_source_f_sptr"""
        return _analog_swig.fastnoise_source_f_sptr_make(self, type, ampl, seed, samples)


    def sample(self):
        """sample(fastnoise_source_f_sptr self) -> float"""
        return _analog_swig.fastnoise_source_f_sptr_sample(self)


    def sample_unbiased(self):
        """sample_unbiased(fastnoise_source_f_sptr self) -> float"""
        return _analog_swig.fastnoise_source_f_sptr_sample_unbiased(self)


    def set_type(self, type):
        """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):
        """set_amplitude(fastnoise_source_f_sptr self, float ampl)"""
        return _analog_swig.fastnoise_source_f_sptr_set_amplitude(self, ampl)


    def type(self):
        """type(fastnoise_source_f_sptr self) -> gr::analog::noise_type_t"""
        return _analog_swig.fastnoise_source_f_sptr_type(self)


    def amplitude(self):
        """amplitude(fastnoise_source_f_sptr self) -> float"""
        return _analog_swig.fastnoise_source_f_sptr_amplitude(self)


    def history(self):
        """history(fastnoise_source_f_sptr self) -> unsigned int"""
        return _analog_swig.fastnoise_source_f_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(fastnoise_source_f_sptr self, int which) -> unsigned int"""
        return _analog_swig.fastnoise_source_f_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(fastnoise_source_f_sptr self) -> int"""
        return _analog_swig.fastnoise_source_f_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(fastnoise_source_f_sptr self) -> double"""
        return _analog_swig.fastnoise_source_f_sptr_relative_rate(self)


    def start(self):
        """start(fastnoise_source_f_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_f_sptr_start(self)


    def stop(self):
        """stop(fastnoise_source_f_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_f_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(fastnoise_source_f_sptr self) -> float"""
        return _analog_swig.fastnoise_source_f_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(fastnoise_source_f_sptr self)"""
        return _analog_swig.fastnoise_source_f_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(fastnoise_source_f_sptr self) -> int"""
        return _analog_swig.fastnoise_source_f_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(fastnoise_source_f_sptr self) -> int"""
        return _analog_swig.fastnoise_source_f_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(fastnoise_source_f_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_f_sptr_name(self)


    def symbol_name(self):
        """symbol_name(fastnoise_source_f_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_f_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(fastnoise_source_f_sptr self) -> io_signature_sptr"""
        return _analog_swig.fastnoise_source_f_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(fastnoise_source_f_sptr self) -> io_signature_sptr"""
        return _analog_swig.fastnoise_source_f_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(fastnoise_source_f_sptr self) -> long"""
        return _analog_swig.fastnoise_source_f_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(fastnoise_source_f_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_f_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(fastnoise_source_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.fastnoise_source_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(fastnoise_source_f_sptr self) -> swig_int_ptr"""
        return _analog_swig.fastnoise_source_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(fastnoise_source_f_sptr self) -> swig_int_ptr"""
        return _analog_swig.fastnoise_source_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(fastnoise_source_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.fastnoise_source_f_sptr_message_subscribers(self, which_port)

fastnoise_source_f_sptr_swigregister = _analog_swig.fastnoise_source_f_sptr_swigregister
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_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::analog::fastnoise_source_c)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::fastnoise_source_c)> self) -> fastnoise_source_c_sptr
        __init__(boost::shared_ptr<(gr::analog::fastnoise_source_c)> self, fastnoise_source_c p) -> fastnoise_source_c_sptr
        """
        this = _analog_swig.new_fastnoise_source_c_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, type, ampl, seed=0, samples=1024):
        """make(fastnoise_source_c_sptr self, gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024) -> fastnoise_source_c_sptr"""
        return _analog_swig.fastnoise_source_c_sptr_make(self, type, ampl, seed, samples)


    def sample(self):
        """sample(fastnoise_source_c_sptr self) -> gr_complex"""
        return _analog_swig.fastnoise_source_c_sptr_sample(self)


    def sample_unbiased(self):
        """sample_unbiased(fastnoise_source_c_sptr self) -> gr_complex"""
        return _analog_swig.fastnoise_source_c_sptr_sample_unbiased(self)


    def set_type(self, type):
        """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):
        """set_amplitude(fastnoise_source_c_sptr self, float ampl)"""
        return _analog_swig.fastnoise_source_c_sptr_set_amplitude(self, ampl)


    def type(self):
        """type(fastnoise_source_c_sptr self) -> gr::analog::noise_type_t"""
        return _analog_swig.fastnoise_source_c_sptr_type(self)


    def amplitude(self):
        """amplitude(fastnoise_source_c_sptr self) -> float"""
        return _analog_swig.fastnoise_source_c_sptr_amplitude(self)


    def history(self):
        """history(fastnoise_source_c_sptr self) -> unsigned int"""
        return _analog_swig.fastnoise_source_c_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(fastnoise_source_c_sptr self, int which) -> unsigned int"""
        return _analog_swig.fastnoise_source_c_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(fastnoise_source_c_sptr self) -> int"""
        return _analog_swig.fastnoise_source_c_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(fastnoise_source_c_sptr self) -> double"""
        return _analog_swig.fastnoise_source_c_sptr_relative_rate(self)


    def start(self):
        """start(fastnoise_source_c_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_c_sptr_start(self)


    def stop(self):
        """stop(fastnoise_source_c_sptr self) -> bool"""
        return _analog_swig.fastnoise_source_c_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(fastnoise_source_c_sptr self) -> float"""
        return _analog_swig.fastnoise_source_c_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(fastnoise_source_c_sptr self)"""
        return _analog_swig.fastnoise_source_c_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(fastnoise_source_c_sptr self) -> int"""
        return _analog_swig.fastnoise_source_c_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(fastnoise_source_c_sptr self) -> int"""
        return _analog_swig.fastnoise_source_c_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(fastnoise_source_c_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_c_sptr_name(self)


    def symbol_name(self):
        """symbol_name(fastnoise_source_c_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_c_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(fastnoise_source_c_sptr self) -> io_signature_sptr"""
        return _analog_swig.fastnoise_source_c_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(fastnoise_source_c_sptr self) -> io_signature_sptr"""
        return _analog_swig.fastnoise_source_c_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(fastnoise_source_c_sptr self) -> long"""
        return _analog_swig.fastnoise_source_c_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(fastnoise_source_c_sptr self) -> std::string"""
        return _analog_swig.fastnoise_source_c_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(fastnoise_source_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.fastnoise_source_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(fastnoise_source_c_sptr self) -> swig_int_ptr"""
        return _analog_swig.fastnoise_source_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(fastnoise_source_c_sptr self) -> swig_int_ptr"""
        return _analog_swig.fastnoise_source_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(fastnoise_source_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.fastnoise_source_c_sptr_message_subscribers(self, which_port)

fastnoise_source_c_sptr_swigregister = _analog_swig.fastnoise_source_c_sptr_swigregister
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_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::analog::noise_source_s)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::noise_source_s)> self) -> noise_source_s_sptr
        __init__(boost::shared_ptr<(gr::analog::noise_source_s)> self, noise_source_s p) -> noise_source_s_sptr
        """
        this = _analog_swig.new_noise_source_s_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, type, ampl, seed=0):
        """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):
        """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):
        """set_amplitude(noise_source_s_sptr self, float ampl)"""
        return _analog_swig.noise_source_s_sptr_set_amplitude(self, ampl)


    def type(self):
        """type(noise_source_s_sptr self) -> gr::analog::noise_type_t"""
        return _analog_swig.noise_source_s_sptr_type(self)


    def amplitude(self):
        """amplitude(noise_source_s_sptr self) -> float"""
        return _analog_swig.noise_source_s_sptr_amplitude(self)


    def history(self):
        """history(noise_source_s_sptr self) -> unsigned int"""
        return _analog_swig.noise_source_s_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(noise_source_s_sptr self, int which) -> unsigned int"""
        return _analog_swig.noise_source_s_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(noise_source_s_sptr self) -> int"""
        return _analog_swig.noise_source_s_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(noise_source_s_sptr self) -> double"""
        return _analog_swig.noise_source_s_sptr_relative_rate(self)


    def start(self):
        """start(noise_source_s_sptr self) -> bool"""
        return _analog_swig.noise_source_s_sptr_start(self)


    def stop(self):
        """stop(noise_source_s_sptr self) -> bool"""
        return _analog_swig.noise_source_s_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(noise_source_s_sptr self) -> float"""
        return _analog_swig.noise_source_s_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(noise_source_s_sptr self)"""
        return _analog_swig.noise_source_s_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(noise_source_s_sptr self) -> int"""
        return _analog_swig.noise_source_s_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(noise_source_s_sptr self) -> int"""
        return _analog_swig.noise_source_s_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(noise_source_s_sptr self) -> std::string"""
        return _analog_swig.noise_source_s_sptr_name(self)


    def symbol_name(self):
        """symbol_name(noise_source_s_sptr self) -> std::string"""
        return _analog_swig.noise_source_s_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(noise_source_s_sptr self) -> io_signature_sptr"""
        return _analog_swig.noise_source_s_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(noise_source_s_sptr self) -> io_signature_sptr"""
        return _analog_swig.noise_source_s_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(noise_source_s_sptr self) -> long"""
        return _analog_swig.noise_source_s_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(noise_source_s_sptr self) -> std::string"""
        return _analog_swig.noise_source_s_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(noise_source_s_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.noise_source_s_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(noise_source_s_sptr self) -> swig_int_ptr"""
        return _analog_swig.noise_source_s_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(noise_source_s_sptr self) -> swig_int_ptr"""
        return _analog_swig.noise_source_s_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(noise_source_s_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.noise_source_s_sptr_message_subscribers(self, which_port)

noise_source_s_sptr_swigregister = _analog_swig.noise_source_s_sptr_swigregister
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_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::analog::noise_source_i)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::noise_source_i)> self) -> noise_source_i_sptr
        __init__(boost::shared_ptr<(gr::analog::noise_source_i)> self, noise_source_i p) -> noise_source_i_sptr
        """
        this = _analog_swig.new_noise_source_i_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, type, ampl, seed=0):
        """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):
        """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):
        """set_amplitude(noise_source_i_sptr self, float ampl)"""
        return _analog_swig.noise_source_i_sptr_set_amplitude(self, ampl)


    def type(self):
        """type(noise_source_i_sptr self) -> gr::analog::noise_type_t"""
        return _analog_swig.noise_source_i_sptr_type(self)


    def amplitude(self):
        """amplitude(noise_source_i_sptr self) -> float"""
        return _analog_swig.noise_source_i_sptr_amplitude(self)


    def history(self):
        """history(noise_source_i_sptr self) -> unsigned int"""
        return _analog_swig.noise_source_i_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(noise_source_i_sptr self, int which) -> unsigned int"""
        return _analog_swig.noise_source_i_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(noise_source_i_sptr self) -> int"""
        return _analog_swig.noise_source_i_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(noise_source_i_sptr self) -> double"""
        return _analog_swig.noise_source_i_sptr_relative_rate(self)


    def start(self):
        """start(noise_source_i_sptr self) -> bool"""
        return _analog_swig.noise_source_i_sptr_start(self)


    def stop(self):
        """stop(noise_source_i_sptr self) -> bool"""
        return _analog_swig.noise_source_i_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(noise_source_i_sptr self) -> float"""
        return _analog_swig.noise_source_i_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(noise_source_i_sptr self)"""
        return _analog_swig.noise_source_i_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(noise_source_i_sptr self) -> int"""
        return _analog_swig.noise_source_i_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(noise_source_i_sptr self) -> int"""
        return _analog_swig.noise_source_i_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(noise_source_i_sptr self) -> std::string"""
        return _analog_swig.noise_source_i_sptr_name(self)


    def symbol_name(self):
        """symbol_name(noise_source_i_sptr self) -> std::string"""
        return _analog_swig.noise_source_i_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(noise_source_i_sptr self) -> io_signature_sptr"""
        return _analog_swig.noise_source_i_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(noise_source_i_sptr self) -> io_signature_sptr"""
        return _analog_swig.noise_source_i_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(noise_source_i_sptr self) -> long"""
        return _analog_swig.noise_source_i_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(noise_source_i_sptr self) -> std::string"""
        return _analog_swig.noise_source_i_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(noise_source_i_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.noise_source_i_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(noise_source_i_sptr self) -> swig_int_ptr"""
        return _analog_swig.noise_source_i_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(noise_source_i_sptr self) -> swig_int_ptr"""
        return _analog_swig.noise_source_i_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(noise_source_i_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.noise_source_i_sptr_message_subscribers(self, which_port)

noise_source_i_sptr_swigregister = _analog_swig.noise_source_i_sptr_swigregister
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_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::analog::noise_source_f)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::noise_source_f)> self) -> noise_source_f_sptr
        __init__(boost::shared_ptr<(gr::analog::noise_source_f)> self, noise_source_f p) -> noise_source_f_sptr
        """
        this = _analog_swig.new_noise_source_f_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, type, ampl, seed=0):
        """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):
        """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):
        """set_amplitude(noise_source_f_sptr self, float ampl)"""
        return _analog_swig.noise_source_f_sptr_set_amplitude(self, ampl)


    def type(self):
        """type(noise_source_f_sptr self) -> gr::analog::noise_type_t"""
        return _analog_swig.noise_source_f_sptr_type(self)


    def amplitude(self):
        """amplitude(noise_source_f_sptr self) -> float"""
        return _analog_swig.noise_source_f_sptr_amplitude(self)


    def history(self):
        """history(noise_source_f_sptr self) -> unsigned int"""
        return _analog_swig.noise_source_f_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(noise_source_f_sptr self, int which) -> unsigned int"""
        return _analog_swig.noise_source_f_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(noise_source_f_sptr self) -> int"""
        return _analog_swig.noise_source_f_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(noise_source_f_sptr self) -> double"""
        return _analog_swig.noise_source_f_sptr_relative_rate(self)


    def start(self):
        """start(noise_source_f_sptr self) -> bool"""
        return _analog_swig.noise_source_f_sptr_start(self)


    def stop(self):
        """stop(noise_source_f_sptr self) -> bool"""
        return _analog_swig.noise_source_f_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(noise_source_f_sptr self) -> float"""
        return _analog_swig.noise_source_f_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(noise_source_f_sptr self)"""
        return _analog_swig.noise_source_f_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(noise_source_f_sptr self) -> int"""
        return _analog_swig.noise_source_f_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(noise_source_f_sptr self) -> int"""
        return _analog_swig.noise_source_f_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(noise_source_f_sptr self) -> std::string"""
        return _analog_swig.noise_source_f_sptr_name(self)


    def symbol_name(self):
        """symbol_name(noise_source_f_sptr self) -> std::string"""
        return _analog_swig.noise_source_f_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(noise_source_f_sptr self) -> io_signature_sptr"""
        return _analog_swig.noise_source_f_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(noise_source_f_sptr self) -> io_signature_sptr"""
        return _analog_swig.noise_source_f_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(noise_source_f_sptr self) -> long"""
        return _analog_swig.noise_source_f_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(noise_source_f_sptr self) -> std::string"""
        return _analog_swig.noise_source_f_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(noise_source_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.noise_source_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(noise_source_f_sptr self) -> swig_int_ptr"""
        return _analog_swig.noise_source_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(noise_source_f_sptr self) -> swig_int_ptr"""
        return _analog_swig.noise_source_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(noise_source_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.noise_source_f_sptr_message_subscribers(self, which_port)

noise_source_f_sptr_swigregister = _analog_swig.noise_source_f_sptr_swigregister
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_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::analog::noise_source_c)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::noise_source_c)> self) -> noise_source_c_sptr
        __init__(boost::shared_ptr<(gr::analog::noise_source_c)> self, noise_source_c p) -> noise_source_c_sptr
        """
        this = _analog_swig.new_noise_source_c_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, type, ampl, seed=0):
        """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):
        """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):
        """set_amplitude(noise_source_c_sptr self, float ampl)"""
        return _analog_swig.noise_source_c_sptr_set_amplitude(self, ampl)


    def type(self):
        """type(noise_source_c_sptr self) -> gr::analog::noise_type_t"""
        return _analog_swig.noise_source_c_sptr_type(self)


    def amplitude(self):
        """amplitude(noise_source_c_sptr self) -> float"""
        return _analog_swig.noise_source_c_sptr_amplitude(self)


    def history(self):
        """history(noise_source_c_sptr self) -> unsigned int"""
        return _analog_swig.noise_source_c_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(noise_source_c_sptr self, int which) -> unsigned int"""
        return _analog_swig.noise_source_c_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(noise_source_c_sptr self) -> int"""
        return _analog_swig.noise_source_c_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(noise_source_c_sptr self) -> double"""
        return _analog_swig.noise_source_c_sptr_relative_rate(self)


    def start(self):
        """start(noise_source_c_sptr self) -> bool"""
        return _analog_swig.noise_source_c_sptr_start(self)


    def stop(self):
        """stop(noise_source_c_sptr self) -> bool"""
        return _analog_swig.noise_source_c_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(noise_source_c_sptr self) -> float"""
        return _analog_swig.noise_source_c_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(noise_source_c_sptr self)"""
        return _analog_swig.noise_source_c_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(noise_source_c_sptr self) -> int"""
        return _analog_swig.noise_source_c_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(noise_source_c_sptr self) -> int"""
        return _analog_swig.noise_source_c_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(noise_source_c_sptr self) -> std::string"""
        return _analog_swig.noise_source_c_sptr_name(self)


    def symbol_name(self):
        """symbol_name(noise_source_c_sptr self) -> std::string"""
        return _analog_swig.noise_source_c_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(noise_source_c_sptr self) -> io_signature_sptr"""
        return _analog_swig.noise_source_c_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(noise_source_c_sptr self) -> io_signature_sptr"""
        return _analog_swig.noise_source_c_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(noise_source_c_sptr self) -> long"""
        return _analog_swig.noise_source_c_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(noise_source_c_sptr self) -> std::string"""
        return _analog_swig.noise_source_c_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(noise_source_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.noise_source_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(noise_source_c_sptr self) -> swig_int_ptr"""
        return _analog_swig.noise_source_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(noise_source_c_sptr self) -> swig_int_ptr"""
        return _analog_swig.noise_source_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(noise_source_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.noise_source_c_sptr_message_subscribers(self, which_port)

noise_source_c_sptr_swigregister = _analog_swig.noise_source_c_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::phase_modulator_fc)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::phase_modulator_fc)> self) -> phase_modulator_fc_sptr
        __init__(boost::shared_ptr<(gr::analog::phase_modulator_fc)> self, phase_modulator_fc p) -> phase_modulator_fc_sptr
        """
        this = _analog_swig.new_phase_modulator_fc_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, sensitivity):
        """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):
        """sensitivity(phase_modulator_fc_sptr self) -> double"""
        return _analog_swig.phase_modulator_fc_sptr_sensitivity(self)


    def phase(self):
        """phase(phase_modulator_fc_sptr self) -> double"""
        return _analog_swig.phase_modulator_fc_sptr_phase(self)


    def set_sensitivity(self, s):
        """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):
        """set_phase(phase_modulator_fc_sptr self, double p)"""
        return _analog_swig.phase_modulator_fc_sptr_set_phase(self, p)


    def history(self):
        """history(phase_modulator_fc_sptr self) -> unsigned int"""
        return _analog_swig.phase_modulator_fc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(phase_modulator_fc_sptr self, int which) -> unsigned int"""
        return _analog_swig.phase_modulator_fc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(phase_modulator_fc_sptr self) -> int"""
        return _analog_swig.phase_modulator_fc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(phase_modulator_fc_sptr self) -> double"""
        return _analog_swig.phase_modulator_fc_sptr_relative_rate(self)


    def start(self):
        """start(phase_modulator_fc_sptr self) -> bool"""
        return _analog_swig.phase_modulator_fc_sptr_start(self)


    def stop(self):
        """stop(phase_modulator_fc_sptr self) -> bool"""
        return _analog_swig.phase_modulator_fc_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(phase_modulator_fc_sptr self) -> float"""
        return _analog_swig.phase_modulator_fc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(phase_modulator_fc_sptr self)"""
        return _analog_swig.phase_modulator_fc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(phase_modulator_fc_sptr self) -> int"""
        return _analog_swig.phase_modulator_fc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(phase_modulator_fc_sptr self) -> int"""
        return _analog_swig.phase_modulator_fc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(phase_modulator_fc_sptr self) -> std::string"""
        return _analog_swig.phase_modulator_fc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(phase_modulator_fc_sptr self) -> std::string"""
        return _analog_swig.phase_modulator_fc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(phase_modulator_fc_sptr self) -> io_signature_sptr"""
        return _analog_swig.phase_modulator_fc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(phase_modulator_fc_sptr self) -> io_signature_sptr"""
        return _analog_swig.phase_modulator_fc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(phase_modulator_fc_sptr self) -> long"""
        return _analog_swig.phase_modulator_fc_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(phase_modulator_fc_sptr self) -> std::string"""
        return _analog_swig.phase_modulator_fc_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(phase_modulator_fc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.phase_modulator_fc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(phase_modulator_fc_sptr self) -> swig_int_ptr"""
        return _analog_swig.phase_modulator_fc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(phase_modulator_fc_sptr self) -> swig_int_ptr"""
        return _analog_swig.phase_modulator_fc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(phase_modulator_fc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.phase_modulator_fc_sptr_message_subscribers(self, which_port)

phase_modulator_fc_sptr_swigregister = _analog_swig.phase_modulator_fc_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::pll_carriertracking_cc)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::pll_carriertracking_cc)> self) -> pll_carriertracking_cc_sptr
        __init__(boost::shared_ptr<(gr::analog::pll_carriertracking_cc)> self, pll_carriertracking_cc p) -> pll_carriertracking_cc_sptr
        """
        this = _analog_swig.new_pll_carriertracking_cc_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, loop_bw, max_freq, min_freq):
        """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):
        """lock_detector(pll_carriertracking_cc_sptr self) -> bool"""
        return _analog_swig.pll_carriertracking_cc_sptr_lock_detector(self)


    def squelch_enable(self, arg2):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """get_damping_factor(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_get_damping_factor(self)


    def get_alpha(self):
        """get_alpha(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_get_alpha(self)


    def get_beta(self):
        """get_beta(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_get_beta(self)


    def get_frequency(self):
        """get_frequency(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_get_frequency(self)


    def get_phase(self):
        """get_phase(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_get_phase(self)


    def get_min_freq(self):
        """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):
        """get_max_freq(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_get_max_freq(self)


    def history(self):
        """history(pll_carriertracking_cc_sptr self) -> unsigned int"""
        return _analog_swig.pll_carriertracking_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(pll_carriertracking_cc_sptr self, int which) -> unsigned int"""
        return _analog_swig.pll_carriertracking_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(pll_carriertracking_cc_sptr self) -> int"""
        return _analog_swig.pll_carriertracking_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(pll_carriertracking_cc_sptr self) -> double"""
        return _analog_swig.pll_carriertracking_cc_sptr_relative_rate(self)


    def start(self):
        """start(pll_carriertracking_cc_sptr self) -> bool"""
        return _analog_swig.pll_carriertracking_cc_sptr_start(self)


    def stop(self):
        """stop(pll_carriertracking_cc_sptr self) -> bool"""
        return _analog_swig.pll_carriertracking_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(pll_carriertracking_cc_sptr self) -> float"""
        return _analog_swig.pll_carriertracking_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(pll_carriertracking_cc_sptr self)"""
        return _analog_swig.pll_carriertracking_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(pll_carriertracking_cc_sptr self) -> int"""
        return _analog_swig.pll_carriertracking_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(pll_carriertracking_cc_sptr self) -> int"""
        return _analog_swig.pll_carriertracking_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(pll_carriertracking_cc_sptr self) -> std::string"""
        return _analog_swig.pll_carriertracking_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(pll_carriertracking_cc_sptr self) -> std::string"""
        return _analog_swig.pll_carriertracking_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(pll_carriertracking_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.pll_carriertracking_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(pll_carriertracking_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.pll_carriertracking_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(pll_carriertracking_cc_sptr self) -> long"""
        return _analog_swig.pll_carriertracking_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(pll_carriertracking_cc_sptr self) -> std::string"""
        return _analog_swig.pll_carriertracking_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(pll_carriertracking_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.pll_carriertracking_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(pll_carriertracking_cc_sptr self) -> swig_int_ptr"""
        return _analog_swig.pll_carriertracking_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(pll_carriertracking_cc_sptr self) -> swig_int_ptr"""
        return _analog_swig.pll_carriertracking_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(pll_carriertracking_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.pll_carriertracking_cc_sptr_message_subscribers(self, which_port)


    def update_gains(self):
        """update_gains(pll_carriertracking_cc_sptr self)"""
        return _analog_swig.pll_carriertracking_cc_sptr_update_gains(self)


    def advance_loop(self, error):
        """advance_loop(pll_carriertracking_cc_sptr self, float error)"""
        return _analog_swig.pll_carriertracking_cc_sptr_advance_loop(self, error)


    def phase_wrap(self):
        """phase_wrap(pll_carriertracking_cc_sptr self)"""
        return _analog_swig.pll_carriertracking_cc_sptr_phase_wrap(self)


    def frequency_limit(self):
        """frequency_limit(pll_carriertracking_cc_sptr self)"""
        return _analog_swig.pll_carriertracking_cc_sptr_frequency_limit(self)


    def set_loop_bandwidth(self, bw):
        """set_loop_bandwidth(pll_carriertracking_cc_sptr self, float bw)"""
        return _analog_swig.pll_carriertracking_cc_sptr_set_loop_bandwidth(self, bw)

pll_carriertracking_cc_sptr_swigregister = _analog_swig.pll_carriertracking_cc_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::pll_freqdet_cf)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::pll_freqdet_cf)> self) -> pll_freqdet_cf_sptr
        __init__(boost::shared_ptr<(gr::analog::pll_freqdet_cf)> self, pll_freqdet_cf p) -> pll_freqdet_cf_sptr
        """
        this = _analog_swig.new_pll_freqdet_cf_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, loop_bw, max_freq, min_freq):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """get_damping_factor(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_get_damping_factor(self)


    def get_alpha(self):
        """get_alpha(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_get_alpha(self)


    def get_beta(self):
        """get_beta(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_get_beta(self)


    def get_frequency(self):
        """get_frequency(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_get_frequency(self)


    def get_phase(self):
        """get_phase(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_get_phase(self)


    def get_min_freq(self):
        """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):
        """get_max_freq(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_get_max_freq(self)


    def history(self):
        """history(pll_freqdet_cf_sptr self) -> unsigned int"""
        return _analog_swig.pll_freqdet_cf_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(pll_freqdet_cf_sptr self, int which) -> unsigned int"""
        return _analog_swig.pll_freqdet_cf_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(pll_freqdet_cf_sptr self) -> int"""
        return _analog_swig.pll_freqdet_cf_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(pll_freqdet_cf_sptr self) -> double"""
        return _analog_swig.pll_freqdet_cf_sptr_relative_rate(self)


    def start(self):
        """start(pll_freqdet_cf_sptr self) -> bool"""
        return _analog_swig.pll_freqdet_cf_sptr_start(self)


    def stop(self):
        """stop(pll_freqdet_cf_sptr self) -> bool"""
        return _analog_swig.pll_freqdet_cf_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(pll_freqdet_cf_sptr self) -> float"""
        return _analog_swig.pll_freqdet_cf_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(pll_freqdet_cf_sptr self)"""
        return _analog_swig.pll_freqdet_cf_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(pll_freqdet_cf_sptr self) -> int"""
        return _analog_swig.pll_freqdet_cf_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(pll_freqdet_cf_sptr self) -> int"""
        return _analog_swig.pll_freqdet_cf_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(pll_freqdet_cf_sptr self) -> std::string"""
        return _analog_swig.pll_freqdet_cf_sptr_name(self)


    def symbol_name(self):
        """symbol_name(pll_freqdet_cf_sptr self) -> std::string"""
        return _analog_swig.pll_freqdet_cf_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(pll_freqdet_cf_sptr self) -> io_signature_sptr"""
        return _analog_swig.pll_freqdet_cf_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(pll_freqdet_cf_sptr self) -> io_signature_sptr"""
        return _analog_swig.pll_freqdet_cf_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(pll_freqdet_cf_sptr self) -> long"""
        return _analog_swig.pll_freqdet_cf_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(pll_freqdet_cf_sptr self) -> std::string"""
        return _analog_swig.pll_freqdet_cf_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(pll_freqdet_cf_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.pll_freqdet_cf_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(pll_freqdet_cf_sptr self) -> swig_int_ptr"""
        return _analog_swig.pll_freqdet_cf_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(pll_freqdet_cf_sptr self) -> swig_int_ptr"""
        return _analog_swig.pll_freqdet_cf_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(pll_freqdet_cf_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.pll_freqdet_cf_sptr_message_subscribers(self, which_port)


    def update_gains(self):
        """update_gains(pll_freqdet_cf_sptr self)"""
        return _analog_swig.pll_freqdet_cf_sptr_update_gains(self)


    def advance_loop(self, error):
        """advance_loop(pll_freqdet_cf_sptr self, float error)"""
        return _analog_swig.pll_freqdet_cf_sptr_advance_loop(self, error)


    def phase_wrap(self):
        """phase_wrap(pll_freqdet_cf_sptr self)"""
        return _analog_swig.pll_freqdet_cf_sptr_phase_wrap(self)


    def frequency_limit(self):
        """frequency_limit(pll_freqdet_cf_sptr self)"""
        return _analog_swig.pll_freqdet_cf_sptr_frequency_limit(self)


    def set_loop_bandwidth(self, bw):
        """set_loop_bandwidth(pll_freqdet_cf_sptr self, float bw)"""
        return _analog_swig.pll_freqdet_cf_sptr_set_loop_bandwidth(self, bw)

pll_freqdet_cf_sptr_swigregister = _analog_swig.pll_freqdet_cf_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::pll_refout_cc)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::pll_refout_cc)> self) -> pll_refout_cc_sptr
        __init__(boost::shared_ptr<(gr::analog::pll_refout_cc)> self, pll_refout_cc p) -> pll_refout_cc_sptr
        """
        this = _analog_swig.new_pll_refout_cc_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, loop_bw, max_freq, min_freq):
        """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):
        """history(pll_refout_cc_sptr self) -> unsigned int"""
        return _analog_swig.pll_refout_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(pll_refout_cc_sptr self, int which) -> unsigned int"""
        return _analog_swig.pll_refout_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(pll_refout_cc_sptr self) -> int"""
        return _analog_swig.pll_refout_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(pll_refout_cc_sptr self) -> double"""
        return _analog_swig.pll_refout_cc_sptr_relative_rate(self)


    def start(self):
        """start(pll_refout_cc_sptr self) -> bool"""
        return _analog_swig.pll_refout_cc_sptr_start(self)


    def stop(self):
        """stop(pll_refout_cc_sptr self) -> bool"""
        return _analog_swig.pll_refout_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(pll_refout_cc_sptr self)"""
        return _analog_swig.pll_refout_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(pll_refout_cc_sptr self) -> int"""
        return _analog_swig.pll_refout_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(pll_refout_cc_sptr self) -> int"""
        return _analog_swig.pll_refout_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(pll_refout_cc_sptr self) -> std::string"""
        return _analog_swig.pll_refout_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(pll_refout_cc_sptr self) -> std::string"""
        return _analog_swig.pll_refout_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(pll_refout_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.pll_refout_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(pll_refout_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.pll_refout_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(pll_refout_cc_sptr self) -> long"""
        return _analog_swig.pll_refout_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(pll_refout_cc_sptr self) -> std::string"""
        return _analog_swig.pll_refout_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(pll_refout_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.pll_refout_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(pll_refout_cc_sptr self) -> swig_int_ptr"""
        return _analog_swig.pll_refout_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(pll_refout_cc_sptr self) -> swig_int_ptr"""
        return _analog_swig.pll_refout_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(pll_refout_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.pll_refout_cc_sptr_message_subscribers(self, which_port)


    def update_gains(self):
        """update_gains(pll_refout_cc_sptr self)"""
        return _analog_swig.pll_refout_cc_sptr_update_gains(self)


    def advance_loop(self, error):
        """advance_loop(pll_refout_cc_sptr self, float error)"""
        return _analog_swig.pll_refout_cc_sptr_advance_loop(self, error)


    def phase_wrap(self):
        """phase_wrap(pll_refout_cc_sptr self)"""
        return _analog_swig.pll_refout_cc_sptr_phase_wrap(self)


    def frequency_limit(self):
        """frequency_limit(pll_refout_cc_sptr self)"""
        return _analog_swig.pll_refout_cc_sptr_frequency_limit(self)


    def set_loop_bandwidth(self, bw):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """get_damping_factor(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_get_damping_factor(self)


    def get_alpha(self):
        """get_alpha(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_get_alpha(self)


    def get_beta(self):
        """get_beta(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_get_beta(self)


    def get_frequency(self):
        """get_frequency(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_get_frequency(self)


    def get_phase(self):
        """get_phase(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_get_phase(self)


    def get_max_freq(self):
        """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):
        """get_min_freq(pll_refout_cc_sptr self) -> float"""
        return _analog_swig.pll_refout_cc_sptr_get_min_freq(self)

pll_refout_cc_sptr_swigregister = _analog_swig.pll_refout_cc_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::probe_avg_mag_sqrd_c)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::probe_avg_mag_sqrd_c)> self) -> probe_avg_mag_sqrd_c_sptr
        __init__(boost::shared_ptr<(gr::analog::probe_avg_mag_sqrd_c)> self, probe_avg_mag_sqrd_c p) -> probe_avg_mag_sqrd_c_sptr
        """
        this = _analog_swig.new_probe_avg_mag_sqrd_c_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, threshold_db, alpha=0.0001):
        """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):
        """unmuted(probe_avg_mag_sqrd_c_sptr self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_unmuted(self)


    def level(self):
        """level(probe_avg_mag_sqrd_c_sptr self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_level(self)


    def threshold(self):
        """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):
        """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):
        """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):
        """reset(probe_avg_mag_sqrd_c_sptr self)"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_reset(self)


    def history(self):
        """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):
        """
        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):
        """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 output_multiple(self):
        """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):
        """relative_rate(probe_avg_mag_sqrd_c_sptr self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_relative_rate(self)


    def start(self):
        """start(probe_avg_mag_sqrd_c_sptr self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_start(self)


    def stop(self):
        """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):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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, noutputs):
        """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):
        """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):
        """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, msg):
        """_post(probe_avg_mag_sqrd_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(probe_avg_mag_sqrd_c_sptr self) -> swig_int_ptr"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(probe_avg_mag_sqrd_c_sptr self) -> swig_int_ptr"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(probe_avg_mag_sqrd_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.probe_avg_mag_sqrd_c_sptr_message_subscribers(self, which_port)

probe_avg_mag_sqrd_c_sptr_swigregister = _analog_swig.probe_avg_mag_sqrd_c_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::probe_avg_mag_sqrd_cf)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::probe_avg_mag_sqrd_cf)> self) -> probe_avg_mag_sqrd_cf_sptr
        __init__(boost::shared_ptr<(gr::analog::probe_avg_mag_sqrd_cf)> self, probe_avg_mag_sqrd_cf p) -> probe_avg_mag_sqrd_cf_sptr
        """
        this = _analog_swig.new_probe_avg_mag_sqrd_cf_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, threshold_db, alpha=0.0001):
        """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):
        """unmuted(probe_avg_mag_sqrd_cf_sptr self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_unmuted(self)


    def level(self):
        """level(probe_avg_mag_sqrd_cf_sptr self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_level(self)


    def threshold(self):
        """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):
        """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):
        """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):
        """reset(probe_avg_mag_sqrd_cf_sptr self)"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_reset(self)


    def history(self):
        """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):
        """
        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):
        """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 output_multiple(self):
        """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):
        """relative_rate(probe_avg_mag_sqrd_cf_sptr self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_relative_rate(self)


    def start(self):
        """start(probe_avg_mag_sqrd_cf_sptr self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_start(self)


    def stop(self):
        """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):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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, noutputs):
        """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):
        """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):
        """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, msg):
        """_post(probe_avg_mag_sqrd_cf_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(probe_avg_mag_sqrd_cf_sptr self) -> swig_int_ptr"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(probe_avg_mag_sqrd_cf_sptr self) -> swig_int_ptr"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(probe_avg_mag_sqrd_cf_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.probe_avg_mag_sqrd_cf_sptr_message_subscribers(self, which_port)

probe_avg_mag_sqrd_cf_sptr_swigregister = _analog_swig.probe_avg_mag_sqrd_cf_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::probe_avg_mag_sqrd_f)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::probe_avg_mag_sqrd_f)> self) -> probe_avg_mag_sqrd_f_sptr
        __init__(boost::shared_ptr<(gr::analog::probe_avg_mag_sqrd_f)> self, probe_avg_mag_sqrd_f p) -> probe_avg_mag_sqrd_f_sptr
        """
        this = _analog_swig.new_probe_avg_mag_sqrd_f_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, threshold_db, alpha=0.0001):
        """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):
        """unmuted(probe_avg_mag_sqrd_f_sptr self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_unmuted(self)


    def level(self):
        """level(probe_avg_mag_sqrd_f_sptr self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_level(self)


    def threshold(self):
        """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):
        """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):
        """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):
        """reset(probe_avg_mag_sqrd_f_sptr self)"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_reset(self)


    def history(self):
        """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):
        """
        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):
        """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 output_multiple(self):
        """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):
        """relative_rate(probe_avg_mag_sqrd_f_sptr self) -> double"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_relative_rate(self)


    def start(self):
        """start(probe_avg_mag_sqrd_f_sptr self) -> bool"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_start(self)


    def stop(self):
        """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):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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, noutputs):
        """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):
        """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):
        """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, msg):
        """_post(probe_avg_mag_sqrd_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(probe_avg_mag_sqrd_f_sptr self) -> swig_int_ptr"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(probe_avg_mag_sqrd_f_sptr self) -> swig_int_ptr"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(probe_avg_mag_sqrd_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.probe_avg_mag_sqrd_f_sptr_message_subscribers(self, which_port)

probe_avg_mag_sqrd_f_sptr_swigregister = _analog_swig.probe_avg_mag_sqrd_f_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::pwr_squelch_cc)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::pwr_squelch_cc)> self) -> pwr_squelch_cc_sptr
        __init__(boost::shared_ptr<(gr::analog::pwr_squelch_cc)> self, pwr_squelch_cc p) -> pwr_squelch_cc_sptr
        """
        this = _analog_swig.new_pwr_squelch_cc_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, db, alpha=0.0001, ramp=0, gate=False):
        """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):
        """squelch_range(pwr_squelch_cc_sptr self) -> pmt_vector_float"""
        return _analog_swig.pwr_squelch_cc_sptr_squelch_range(self)


    def threshold(self):
        """threshold(pwr_squelch_cc_sptr self) -> double"""
        return _analog_swig.pwr_squelch_cc_sptr_threshold(self)


    def set_threshold(self, db):
        """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):
        """set_alpha(pwr_squelch_cc_sptr self, double alpha)"""
        return _analog_swig.pwr_squelch_cc_sptr_set_alpha(self, alpha)


    def ramp(self):
        """ramp(pwr_squelch_cc_sptr self) -> int"""
        return _analog_swig.pwr_squelch_cc_sptr_ramp(self)


    def set_ramp(self, ramp):
        """set_ramp(pwr_squelch_cc_sptr self, int ramp)"""
        return _analog_swig.pwr_squelch_cc_sptr_set_ramp(self, ramp)


    def gate(self):
        """gate(pwr_squelch_cc_sptr self) -> bool"""
        return _analog_swig.pwr_squelch_cc_sptr_gate(self)


    def set_gate(self, gate):
        """set_gate(pwr_squelch_cc_sptr self, bool gate)"""
        return _analog_swig.pwr_squelch_cc_sptr_set_gate(self, gate)


    def unmuted(self):
        """unmuted(pwr_squelch_cc_sptr self) -> bool"""
        return _analog_swig.pwr_squelch_cc_sptr_unmuted(self)


    def history(self):
        """history(pwr_squelch_cc_sptr self) -> unsigned int"""
        return _analog_swig.pwr_squelch_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(pwr_squelch_cc_sptr self, int which) -> unsigned int"""
        return _analog_swig.pwr_squelch_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(pwr_squelch_cc_sptr self) -> int"""
        return _analog_swig.pwr_squelch_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(pwr_squelch_cc_sptr self) -> double"""
        return _analog_swig.pwr_squelch_cc_sptr_relative_rate(self)


    def start(self):
        """start(pwr_squelch_cc_sptr self) -> bool"""
        return _analog_swig.pwr_squelch_cc_sptr_start(self)


    def stop(self):
        """stop(pwr_squelch_cc_sptr self) -> bool"""
        return _analog_swig.pwr_squelch_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(pwr_squelch_cc_sptr self) -> float"""
        return _analog_swig.pwr_squelch_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(pwr_squelch_cc_sptr self)"""
        return _analog_swig.pwr_squelch_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(pwr_squelch_cc_sptr self) -> int"""
        return _analog_swig.pwr_squelch_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(pwr_squelch_cc_sptr self) -> int"""
        return _analog_swig.pwr_squelch_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(pwr_squelch_cc_sptr self) -> std::string"""
        return _analog_swig.pwr_squelch_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(pwr_squelch_cc_sptr self) -> std::string"""
        return _analog_swig.pwr_squelch_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(pwr_squelch_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.pwr_squelch_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(pwr_squelch_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.pwr_squelch_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(pwr_squelch_cc_sptr self) -> long"""
        return _analog_swig.pwr_squelch_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(pwr_squelch_cc_sptr self) -> std::string"""
        return _analog_swig.pwr_squelch_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(pwr_squelch_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.pwr_squelch_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(pwr_squelch_cc_sptr self) -> swig_int_ptr"""
        return _analog_swig.pwr_squelch_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(pwr_squelch_cc_sptr self) -> swig_int_ptr"""
        return _analog_swig.pwr_squelch_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(pwr_squelch_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.pwr_squelch_cc_sptr_message_subscribers(self, which_port)

pwr_squelch_cc_sptr_swigregister = _analog_swig.pwr_squelch_cc_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::pwr_squelch_ff)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::pwr_squelch_ff)> self) -> pwr_squelch_ff_sptr
        __init__(boost::shared_ptr<(gr::analog::pwr_squelch_ff)> self, pwr_squelch_ff p) -> pwr_squelch_ff_sptr
        """
        this = _analog_swig.new_pwr_squelch_ff_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, db, alpha=0.0001, ramp=0, gate=False):
        """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):
        """squelch_range(pwr_squelch_ff_sptr self) -> pmt_vector_float"""
        return _analog_swig.pwr_squelch_ff_sptr_squelch_range(self)


    def threshold(self):
        """threshold(pwr_squelch_ff_sptr self) -> double"""
        return _analog_swig.pwr_squelch_ff_sptr_threshold(self)


    def set_threshold(self, db):
        """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):
        """set_alpha(pwr_squelch_ff_sptr self, double alpha)"""
        return _analog_swig.pwr_squelch_ff_sptr_set_alpha(self, alpha)


    def ramp(self):
        """ramp(pwr_squelch_ff_sptr self) -> int"""
        return _analog_swig.pwr_squelch_ff_sptr_ramp(self)


    def set_ramp(self, ramp):
        """set_ramp(pwr_squelch_ff_sptr self, int ramp)"""
        return _analog_swig.pwr_squelch_ff_sptr_set_ramp(self, ramp)


    def gate(self):
        """gate(pwr_squelch_ff_sptr self) -> bool"""
        return _analog_swig.pwr_squelch_ff_sptr_gate(self)


    def set_gate(self, gate):
        """set_gate(pwr_squelch_ff_sptr self, bool gate)"""
        return _analog_swig.pwr_squelch_ff_sptr_set_gate(self, gate)


    def unmuted(self):
        """unmuted(pwr_squelch_ff_sptr self) -> bool"""
        return _analog_swig.pwr_squelch_ff_sptr_unmuted(self)


    def history(self):
        """history(pwr_squelch_ff_sptr self) -> unsigned int"""
        return _analog_swig.pwr_squelch_ff_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(pwr_squelch_ff_sptr self, int which) -> unsigned int"""
        return _analog_swig.pwr_squelch_ff_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(pwr_squelch_ff_sptr self) -> int"""
        return _analog_swig.pwr_squelch_ff_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(pwr_squelch_ff_sptr self) -> double"""
        return _analog_swig.pwr_squelch_ff_sptr_relative_rate(self)


    def start(self):
        """start(pwr_squelch_ff_sptr self) -> bool"""
        return _analog_swig.pwr_squelch_ff_sptr_start(self)


    def stop(self):
        """stop(pwr_squelch_ff_sptr self) -> bool"""
        return _analog_swig.pwr_squelch_ff_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(pwr_squelch_ff_sptr self) -> float"""
        return _analog_swig.pwr_squelch_ff_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(pwr_squelch_ff_sptr self)"""
        return _analog_swig.pwr_squelch_ff_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(pwr_squelch_ff_sptr self) -> int"""
        return _analog_swig.pwr_squelch_ff_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(pwr_squelch_ff_sptr self) -> int"""
        return _analog_swig.pwr_squelch_ff_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(pwr_squelch_ff_sptr self) -> std::string"""
        return _analog_swig.pwr_squelch_ff_sptr_name(self)


    def symbol_name(self):
        """symbol_name(pwr_squelch_ff_sptr self) -> std::string"""
        return _analog_swig.pwr_squelch_ff_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(pwr_squelch_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.pwr_squelch_ff_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(pwr_squelch_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.pwr_squelch_ff_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(pwr_squelch_ff_sptr self) -> long"""
        return _analog_swig.pwr_squelch_ff_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(pwr_squelch_ff_sptr self) -> std::string"""
        return _analog_swig.pwr_squelch_ff_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(pwr_squelch_ff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.pwr_squelch_ff_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(pwr_squelch_ff_sptr self) -> swig_int_ptr"""
        return _analog_swig.pwr_squelch_ff_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(pwr_squelch_ff_sptr self) -> swig_int_ptr"""
        return _analog_swig.pwr_squelch_ff_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(pwr_squelch_ff_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.pwr_squelch_ff_sptr_message_subscribers(self, which_port)

pwr_squelch_ff_sptr_swigregister = _analog_swig.pwr_squelch_ff_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::quadrature_demod_cf)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::quadrature_demod_cf)> self) -> quadrature_demod_cf_sptr
        __init__(boost::shared_ptr<(gr::analog::quadrature_demod_cf)> self, quadrature_demod_cf p) -> quadrature_demod_cf_sptr
        """
        this = _analog_swig.new_quadrature_demod_cf_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, gain):
        """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):
        """set_gain(quadrature_demod_cf_sptr self, float gain)"""
        return _analog_swig.quadrature_demod_cf_sptr_set_gain(self, gain)


    def gain(self):
        """gain(quadrature_demod_cf_sptr self) -> float"""
        return _analog_swig.quadrature_demod_cf_sptr_gain(self)


    def history(self):
        """history(quadrature_demod_cf_sptr self) -> unsigned int"""
        return _analog_swig.quadrature_demod_cf_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(quadrature_demod_cf_sptr self, int which) -> unsigned int"""
        return _analog_swig.quadrature_demod_cf_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(quadrature_demod_cf_sptr self) -> int"""
        return _analog_swig.quadrature_demod_cf_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(quadrature_demod_cf_sptr self) -> double"""
        return _analog_swig.quadrature_demod_cf_sptr_relative_rate(self)


    def start(self):
        """start(quadrature_demod_cf_sptr self) -> bool"""
        return _analog_swig.quadrature_demod_cf_sptr_start(self)


    def stop(self):
        """stop(quadrature_demod_cf_sptr self) -> bool"""
        return _analog_swig.quadrature_demod_cf_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(quadrature_demod_cf_sptr self) -> float"""
        return _analog_swig.quadrature_demod_cf_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(quadrature_demod_cf_sptr self)"""
        return _analog_swig.quadrature_demod_cf_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(quadrature_demod_cf_sptr self) -> int"""
        return _analog_swig.quadrature_demod_cf_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(quadrature_demod_cf_sptr self) -> int"""
        return _analog_swig.quadrature_demod_cf_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(quadrature_demod_cf_sptr self) -> std::string"""
        return _analog_swig.quadrature_demod_cf_sptr_name(self)


    def symbol_name(self):
        """symbol_name(quadrature_demod_cf_sptr self) -> std::string"""
        return _analog_swig.quadrature_demod_cf_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(quadrature_demod_cf_sptr self) -> io_signature_sptr"""
        return _analog_swig.quadrature_demod_cf_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(quadrature_demod_cf_sptr self) -> io_signature_sptr"""
        return _analog_swig.quadrature_demod_cf_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(quadrature_demod_cf_sptr self) -> long"""
        return _analog_swig.quadrature_demod_cf_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(quadrature_demod_cf_sptr self) -> std::string"""
        return _analog_swig.quadrature_demod_cf_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(quadrature_demod_cf_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.quadrature_demod_cf_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(quadrature_demod_cf_sptr self) -> swig_int_ptr"""
        return _analog_swig.quadrature_demod_cf_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(quadrature_demod_cf_sptr self) -> swig_int_ptr"""
        return _analog_swig.quadrature_demod_cf_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(quadrature_demod_cf_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.quadrature_demod_cf_sptr_message_subscribers(self, which_port)

quadrature_demod_cf_sptr_swigregister = _analog_swig.quadrature_demod_cf_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::rail_ff)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::rail_ff)> self) -> rail_ff_sptr
        __init__(boost::shared_ptr<(gr::analog::rail_ff)> self, rail_ff p) -> rail_ff_sptr
        """
        this = _analog_swig.new_rail_ff_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(rail_ff_sptr self) -> rail_ff"""
        return _analog_swig.rail_ff_sptr___deref__(self)

    __swig_destroy__ = _analog_swig.delete_rail_ff_sptr
    __del__ = lambda self: None

    def make(self, lo, hi):
        """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):
        """lo(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_lo(self)


    def hi(self):
        """hi(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_hi(self)


    def set_lo(self, lo):
        """set_lo(rail_ff_sptr self, float lo)"""
        return _analog_swig.rail_ff_sptr_set_lo(self, lo)


    def set_hi(self, hi):
        """set_hi(rail_ff_sptr self, float hi)"""
        return _analog_swig.rail_ff_sptr_set_hi(self, hi)


    def history(self):
        """history(rail_ff_sptr self) -> unsigned int"""
        return _analog_swig.rail_ff_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(rail_ff_sptr self, int which) -> unsigned int"""
        return _analog_swig.rail_ff_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(rail_ff_sptr self) -> int"""
        return _analog_swig.rail_ff_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(rail_ff_sptr self) -> double"""
        return _analog_swig.rail_ff_sptr_relative_rate(self)


    def start(self):
        """start(rail_ff_sptr self) -> bool"""
        return _analog_swig.rail_ff_sptr_start(self)


    def stop(self):
        """stop(rail_ff_sptr self) -> bool"""
        return _analog_swig.rail_ff_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """nitems_written(rail_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _analog_swig.rail_ff_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """min_noutput_items(rail_ff_sptr self) -> int"""
        return _analog_swig.rail_ff_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """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):
        """
        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):
        """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):
        """
        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):
        """pc_noutput_items(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """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):
        """pc_noutput_items_var(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """pc_work_time(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """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):
        """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):
        """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):
        """pc_throughput_avg(rail_ff_sptr self) -> float"""
        return _analog_swig.rail_ff_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """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):
        """unset_processor_affinity(rail_ff_sptr self)"""
        return _analog_swig.rail_ff_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(rail_ff_sptr self) -> int"""
        return _analog_swig.rail_ff_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(rail_ff_sptr self) -> int"""
        return _analog_swig.rail_ff_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(rail_ff_sptr self, int priority) -> int"""
        return _analog_swig.rail_ff_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(rail_ff_sptr self) -> std::string"""
        return _analog_swig.rail_ff_sptr_name(self)


    def symbol_name(self):
        """symbol_name(rail_ff_sptr self) -> std::string"""
        return _analog_swig.rail_ff_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(rail_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.rail_ff_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(rail_ff_sptr self) -> io_signature_sptr"""
        return _analog_swig.rail_ff_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(rail_ff_sptr self) -> long"""
        return _analog_swig.rail_ff_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(rail_ff_sptr self) -> std::string"""
        return _analog_swig.rail_ff_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(rail_ff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.rail_ff_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(rail_ff_sptr self) -> swig_int_ptr"""
        return _analog_swig.rail_ff_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(rail_ff_sptr self) -> swig_int_ptr"""
        return _analog_swig.rail_ff_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(rail_ff_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.rail_ff_sptr_message_subscribers(self, which_port)

rail_ff_sptr_swigregister = _analog_swig.rail_ff_sptr_swigregister
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_s_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::analog::sig_source_s)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::sig_source_s)> self) -> sig_source_s_sptr
        __init__(boost::shared_ptr<(gr::analog::sig_source_s)> self, sig_source_s p) -> sig_source_s_sptr
        """
        this = _analog_swig.new_sig_source_s_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, sampling_freq, waveform, wave_freq, ampl, offset=0):
        """make(sig_source_s_sptr self, double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, short offset=0) -> sig_source_s_sptr"""
        return _analog_swig.sig_source_s_sptr_make(self, sampling_freq, waveform, wave_freq, ampl, offset)


    def sampling_freq(self):
        """sampling_freq(sig_source_s_sptr self) -> double"""
        return _analog_swig.sig_source_s_sptr_sampling_freq(self)


    def waveform(self):
        """waveform(sig_source_s_sptr self) -> gr::analog::gr_waveform_t"""
        return _analog_swig.sig_source_s_sptr_waveform(self)


    def frequency(self):
        """frequency(sig_source_s_sptr self) -> double"""
        return _analog_swig.sig_source_s_sptr_frequency(self)


    def amplitude(self):
        """amplitude(sig_source_s_sptr self) -> double"""
        return _analog_swig.sig_source_s_sptr_amplitude(self)


    def offset(self):
        """offset(sig_source_s_sptr self) -> short"""
        return _analog_swig.sig_source_s_sptr_offset(self)


    def set_sampling_freq(self, sampling_freq):
        """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):
        """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):
        """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):
        """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):
        """set_offset(sig_source_s_sptr self, short offset)"""
        return _analog_swig.sig_source_s_sptr_set_offset(self, offset)


    def history(self):
        """history(sig_source_s_sptr self) -> unsigned int"""
        return _analog_swig.sig_source_s_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(sig_source_s_sptr self, int which) -> unsigned int"""
        return _analog_swig.sig_source_s_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(sig_source_s_sptr self) -> int"""
        return _analog_swig.sig_source_s_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(sig_source_s_sptr self) -> double"""
        return _analog_swig.sig_source_s_sptr_relative_rate(self)


    def start(self):
        """start(sig_source_s_sptr self) -> bool"""
        return _analog_swig.sig_source_s_sptr_start(self)


    def stop(self):
        """stop(sig_source_s_sptr self) -> bool"""
        return _analog_swig.sig_source_s_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(sig_source_s_sptr self) -> float"""
        return _analog_swig.sig_source_s_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(sig_source_s_sptr self)"""
        return _analog_swig.sig_source_s_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(sig_source_s_sptr self) -> int"""
        return _analog_swig.sig_source_s_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(sig_source_s_sptr self) -> int"""
        return _analog_swig.sig_source_s_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(sig_source_s_sptr self) -> std::string"""
        return _analog_swig.sig_source_s_sptr_name(self)


    def symbol_name(self):
        """symbol_name(sig_source_s_sptr self) -> std::string"""
        return _analog_swig.sig_source_s_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(sig_source_s_sptr self) -> io_signature_sptr"""
        return _analog_swig.sig_source_s_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(sig_source_s_sptr self) -> io_signature_sptr"""
        return _analog_swig.sig_source_s_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(sig_source_s_sptr self) -> long"""
        return _analog_swig.sig_source_s_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(sig_source_s_sptr self) -> std::string"""
        return _analog_swig.sig_source_s_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(sig_source_s_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.sig_source_s_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(sig_source_s_sptr self) -> swig_int_ptr"""
        return _analog_swig.sig_source_s_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(sig_source_s_sptr self) -> swig_int_ptr"""
        return _analog_swig.sig_source_s_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(sig_source_s_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.sig_source_s_sptr_message_subscribers(self, which_port)

sig_source_s_sptr_swigregister = _analog_swig.sig_source_s_sptr_swigregister
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_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::analog::sig_source_i)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::sig_source_i)> self) -> sig_source_i_sptr
        __init__(boost::shared_ptr<(gr::analog::sig_source_i)> self, sig_source_i p) -> sig_source_i_sptr
        """
        this = _analog_swig.new_sig_source_i_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, sampling_freq, waveform, wave_freq, ampl, offset=0):
        """make(sig_source_i_sptr self, double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, int offset=0) -> sig_source_i_sptr"""
        return _analog_swig.sig_source_i_sptr_make(self, sampling_freq, waveform, wave_freq, ampl, offset)


    def sampling_freq(self):
        """sampling_freq(sig_source_i_sptr self) -> double"""
        return _analog_swig.sig_source_i_sptr_sampling_freq(self)


    def waveform(self):
        """waveform(sig_source_i_sptr self) -> gr::analog::gr_waveform_t"""
        return _analog_swig.sig_source_i_sptr_waveform(self)


    def frequency(self):
        """frequency(sig_source_i_sptr self) -> double"""
        return _analog_swig.sig_source_i_sptr_frequency(self)


    def amplitude(self):
        """amplitude(sig_source_i_sptr self) -> double"""
        return _analog_swig.sig_source_i_sptr_amplitude(self)


    def offset(self):
        """offset(sig_source_i_sptr self) -> int"""
        return _analog_swig.sig_source_i_sptr_offset(self)


    def set_sampling_freq(self, sampling_freq):
        """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):
        """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):
        """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):
        """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):
        """set_offset(sig_source_i_sptr self, int offset)"""
        return _analog_swig.sig_source_i_sptr_set_offset(self, offset)


    def history(self):
        """history(sig_source_i_sptr self) -> unsigned int"""
        return _analog_swig.sig_source_i_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(sig_source_i_sptr self, int which) -> unsigned int"""
        return _analog_swig.sig_source_i_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(sig_source_i_sptr self) -> int"""
        return _analog_swig.sig_source_i_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(sig_source_i_sptr self) -> double"""
        return _analog_swig.sig_source_i_sptr_relative_rate(self)


    def start(self):
        """start(sig_source_i_sptr self) -> bool"""
        return _analog_swig.sig_source_i_sptr_start(self)


    def stop(self):
        """stop(sig_source_i_sptr self) -> bool"""
        return _analog_swig.sig_source_i_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(sig_source_i_sptr self) -> float"""
        return _analog_swig.sig_source_i_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(sig_source_i_sptr self)"""
        return _analog_swig.sig_source_i_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(sig_source_i_sptr self) -> int"""
        return _analog_swig.sig_source_i_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(sig_source_i_sptr self) -> int"""
        return _analog_swig.sig_source_i_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(sig_source_i_sptr self) -> std::string"""
        return _analog_swig.sig_source_i_sptr_name(self)


    def symbol_name(self):
        """symbol_name(sig_source_i_sptr self) -> std::string"""
        return _analog_swig.sig_source_i_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(sig_source_i_sptr self) -> io_signature_sptr"""
        return _analog_swig.sig_source_i_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(sig_source_i_sptr self) -> io_signature_sptr"""
        return _analog_swig.sig_source_i_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(sig_source_i_sptr self) -> long"""
        return _analog_swig.sig_source_i_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(sig_source_i_sptr self) -> std::string"""
        return _analog_swig.sig_source_i_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(sig_source_i_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.sig_source_i_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(sig_source_i_sptr self) -> swig_int_ptr"""
        return _analog_swig.sig_source_i_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(sig_source_i_sptr self) -> swig_int_ptr"""
        return _analog_swig.sig_source_i_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(sig_source_i_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.sig_source_i_sptr_message_subscribers(self, which_port)

sig_source_i_sptr_swigregister = _analog_swig.sig_source_i_sptr_swigregister
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_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::analog::sig_source_f)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::sig_source_f)> self) -> sig_source_f_sptr
        __init__(boost::shared_ptr<(gr::analog::sig_source_f)> self, sig_source_f p) -> sig_source_f_sptr
        """
        this = _analog_swig.new_sig_source_f_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, sampling_freq, waveform, wave_freq, ampl, offset=0):
        """make(sig_source_f_sptr self, double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, float offset=0) -> sig_source_f_sptr"""
        return _analog_swig.sig_source_f_sptr_make(self, sampling_freq, waveform, wave_freq, ampl, offset)


    def sampling_freq(self):
        """sampling_freq(sig_source_f_sptr self) -> double"""
        return _analog_swig.sig_source_f_sptr_sampling_freq(self)


    def waveform(self):
        """waveform(sig_source_f_sptr self) -> gr::analog::gr_waveform_t"""
        return _analog_swig.sig_source_f_sptr_waveform(self)


    def frequency(self):
        """frequency(sig_source_f_sptr self) -> double"""
        return _analog_swig.sig_source_f_sptr_frequency(self)


    def amplitude(self):
        """amplitude(sig_source_f_sptr self) -> double"""
        return _analog_swig.sig_source_f_sptr_amplitude(self)


    def offset(self):
        """offset(sig_source_f_sptr self) -> float"""
        return _analog_swig.sig_source_f_sptr_offset(self)


    def set_sampling_freq(self, sampling_freq):
        """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):
        """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):
        """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):
        """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):
        """set_offset(sig_source_f_sptr self, float offset)"""
        return _analog_swig.sig_source_f_sptr_set_offset(self, offset)


    def history(self):
        """history(sig_source_f_sptr self) -> unsigned int"""
        return _analog_swig.sig_source_f_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(sig_source_f_sptr self, int which) -> unsigned int"""
        return _analog_swig.sig_source_f_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(sig_source_f_sptr self) -> int"""
        return _analog_swig.sig_source_f_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(sig_source_f_sptr self) -> double"""
        return _analog_swig.sig_source_f_sptr_relative_rate(self)


    def start(self):
        """start(sig_source_f_sptr self) -> bool"""
        return _analog_swig.sig_source_f_sptr_start(self)


    def stop(self):
        """stop(sig_source_f_sptr self) -> bool"""
        return _analog_swig.sig_source_f_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(sig_source_f_sptr self) -> float"""
        return _analog_swig.sig_source_f_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(sig_source_f_sptr self)"""
        return _analog_swig.sig_source_f_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(sig_source_f_sptr self) -> int"""
        return _analog_swig.sig_source_f_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(sig_source_f_sptr self) -> int"""
        return _analog_swig.sig_source_f_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(sig_source_f_sptr self) -> std::string"""
        return _analog_swig.sig_source_f_sptr_name(self)


    def symbol_name(self):
        """symbol_name(sig_source_f_sptr self) -> std::string"""
        return _analog_swig.sig_source_f_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(sig_source_f_sptr self) -> io_signature_sptr"""
        return _analog_swig.sig_source_f_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(sig_source_f_sptr self) -> io_signature_sptr"""
        return _analog_swig.sig_source_f_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(sig_source_f_sptr self) -> long"""
        return _analog_swig.sig_source_f_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(sig_source_f_sptr self) -> std::string"""
        return _analog_swig.sig_source_f_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(sig_source_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.sig_source_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(sig_source_f_sptr self) -> swig_int_ptr"""
        return _analog_swig.sig_source_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(sig_source_f_sptr self) -> swig_int_ptr"""
        return _analog_swig.sig_source_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(sig_source_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.sig_source_f_sptr_message_subscribers(self, which_port)

sig_source_f_sptr_swigregister = _analog_swig.sig_source_f_sptr_swigregister
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_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::analog::sig_source_c)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::sig_source_c)> self) -> sig_source_c_sptr
        __init__(boost::shared_ptr<(gr::analog::sig_source_c)> self, sig_source_c p) -> sig_source_c_sptr
        """
        this = _analog_swig.new_sig_source_c_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, sampling_freq, waveform, wave_freq, ampl, offset=0):
        """make(sig_source_c_sptr self, double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, gr_complex offset=0) -> sig_source_c_sptr"""
        return _analog_swig.sig_source_c_sptr_make(self, sampling_freq, waveform, wave_freq, ampl, offset)


    def sampling_freq(self):
        """sampling_freq(sig_source_c_sptr self) -> double"""
        return _analog_swig.sig_source_c_sptr_sampling_freq(self)


    def waveform(self):
        """waveform(sig_source_c_sptr self) -> gr::analog::gr_waveform_t"""
        return _analog_swig.sig_source_c_sptr_waveform(self)


    def frequency(self):
        """frequency(sig_source_c_sptr self) -> double"""
        return _analog_swig.sig_source_c_sptr_frequency(self)


    def amplitude(self):
        """amplitude(sig_source_c_sptr self) -> double"""
        return _analog_swig.sig_source_c_sptr_amplitude(self)


    def offset(self):
        """offset(sig_source_c_sptr self) -> gr_complex"""
        return _analog_swig.sig_source_c_sptr_offset(self)


    def set_sampling_freq(self, sampling_freq):
        """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):
        """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):
        """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):
        """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):
        """set_offset(sig_source_c_sptr self, gr_complex offset)"""
        return _analog_swig.sig_source_c_sptr_set_offset(self, offset)


    def history(self):
        """history(sig_source_c_sptr self) -> unsigned int"""
        return _analog_swig.sig_source_c_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(sig_source_c_sptr self, int which) -> unsigned int"""
        return _analog_swig.sig_source_c_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(sig_source_c_sptr self) -> int"""
        return _analog_swig.sig_source_c_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(sig_source_c_sptr self) -> double"""
        return _analog_swig.sig_source_c_sptr_relative_rate(self)


    def start(self):
        """start(sig_source_c_sptr self) -> bool"""
        return _analog_swig.sig_source_c_sptr_start(self)


    def stop(self):
        """stop(sig_source_c_sptr self) -> bool"""
        return _analog_swig.sig_source_c_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(sig_source_c_sptr self) -> float"""
        return _analog_swig.sig_source_c_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(sig_source_c_sptr self)"""
        return _analog_swig.sig_source_c_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(sig_source_c_sptr self) -> int"""
        return _analog_swig.sig_source_c_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(sig_source_c_sptr self) -> int"""
        return _analog_swig.sig_source_c_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(sig_source_c_sptr self) -> std::string"""
        return _analog_swig.sig_source_c_sptr_name(self)


    def symbol_name(self):
        """symbol_name(sig_source_c_sptr self) -> std::string"""
        return _analog_swig.sig_source_c_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(sig_source_c_sptr self) -> io_signature_sptr"""
        return _analog_swig.sig_source_c_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(sig_source_c_sptr self) -> io_signature_sptr"""
        return _analog_swig.sig_source_c_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(sig_source_c_sptr self) -> long"""
        return _analog_swig.sig_source_c_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(sig_source_c_sptr self) -> std::string"""
        return _analog_swig.sig_source_c_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(sig_source_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.sig_source_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(sig_source_c_sptr self) -> swig_int_ptr"""
        return _analog_swig.sig_source_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(sig_source_c_sptr self) -> swig_int_ptr"""
        return _analog_swig.sig_source_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(sig_source_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.sig_source_c_sptr_message_subscribers(self, which_port)

sig_source_c_sptr_swigregister = _analog_swig.sig_source_c_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::analog::simple_squelch_cc)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::analog::simple_squelch_cc)> self) -> simple_squelch_cc_sptr
        __init__(boost::shared_ptr<(gr::analog::simple_squelch_cc)> self, simple_squelch_cc p) -> simple_squelch_cc_sptr
        """
        this = _analog_swig.new_simple_squelch_cc_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, threshold_db, alpha):
        """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):
        """unmuted(simple_squelch_cc_sptr self) -> bool"""
        return _analog_swig.simple_squelch_cc_sptr_unmuted(self)


    def set_alpha(self, alpha):
        """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):
        """set_threshold(simple_squelch_cc_sptr self, double decibels)"""
        return _analog_swig.simple_squelch_cc_sptr_set_threshold(self, decibels)


    def threshold(self):
        """threshold(simple_squelch_cc_sptr self) -> double"""
        return _analog_swig.simple_squelch_cc_sptr_threshold(self)


    def squelch_range(self):
        """squelch_range(simple_squelch_cc_sptr self) -> pmt_vector_float"""
        return _analog_swig.simple_squelch_cc_sptr_squelch_range(self)


    def history(self):
        """history(simple_squelch_cc_sptr self) -> unsigned int"""
        return _analog_swig.simple_squelch_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(simple_squelch_cc_sptr self, int which) -> unsigned int"""
        return _analog_swig.simple_squelch_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(simple_squelch_cc_sptr self) -> int"""
        return _analog_swig.simple_squelch_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(simple_squelch_cc_sptr self) -> double"""
        return _analog_swig.simple_squelch_cc_sptr_relative_rate(self)


    def start(self):
        """start(simple_squelch_cc_sptr self) -> bool"""
        return _analog_swig.simple_squelch_cc_sptr_start(self)


    def stop(self):
        """stop(simple_squelch_cc_sptr self) -> bool"""
        return _analog_swig.simple_squelch_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(simple_squelch_cc_sptr self) -> float"""
        return _analog_swig.simple_squelch_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(simple_squelch_cc_sptr self)"""
        return _analog_swig.simple_squelch_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(simple_squelch_cc_sptr self) -> int"""
        return _analog_swig.simple_squelch_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(simple_squelch_cc_sptr self) -> int"""
        return _analog_swig.simple_squelch_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(simple_squelch_cc_sptr self) -> std::string"""
        return _analog_swig.simple_squelch_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(simple_squelch_cc_sptr self) -> std::string"""
        return _analog_swig.simple_squelch_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(simple_squelch_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.simple_squelch_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(simple_squelch_cc_sptr self) -> io_signature_sptr"""
        return _analog_swig.simple_squelch_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(simple_squelch_cc_sptr self) -> long"""
        return _analog_swig.simple_squelch_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(simple_squelch_cc_sptr self) -> std::string"""
        return _analog_swig.simple_squelch_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(simple_squelch_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _analog_swig.simple_squelch_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(simple_squelch_cc_sptr self) -> swig_int_ptr"""
        return _analog_swig.simple_squelch_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(simple_squelch_cc_sptr self) -> swig_int_ptr"""
        return _analog_swig.simple_squelch_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(simple_squelch_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _analog_swig.simple_squelch_cc_sptr_message_subscribers(self, which_port)

simple_squelch_cc_sptr_swigregister = _analog_swig.simple_squelch_cc_sptr_swigregister
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;



