# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.2
#
# 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('_pmt_swig', [dirname(__file__)])
        except ImportError:
            import _pmt_swig
            return _pmt_swig
        if fp is not None:
            try:
                _mod = imp.load_module('_pmt_swig', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _pmt_swig = swig_import_helper()
    del swig_import_helper
else:
    import _pmt_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):
        self.__dict__[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(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

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


class SwigPyIterator(object):
    """Proxy of C++ swig::SwigPyIterator 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
    __swig_destroy__ = _pmt_swig.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _pmt_swig.SwigPyIterator_value(self)

    def incr(self, n=1):
        """incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
        return _pmt_swig.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
        return _pmt_swig.SwigPyIterator_decr(self, n)

    def distance(self, *args, **kwargs):
        """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _pmt_swig.SwigPyIterator_distance(self, *args, **kwargs)

    def equal(self, *args, **kwargs):
        """equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _pmt_swig.SwigPyIterator_equal(self, *args, **kwargs)

    def copy(self):
        """copy(SwigPyIterator self) -> SwigPyIterator"""
        return _pmt_swig.SwigPyIterator_copy(self)

    def next(self):
        """next(SwigPyIterator self) -> PyObject *"""
        return _pmt_swig.SwigPyIterator_next(self)

    def __next__(self):
        """__next__(SwigPyIterator self) -> PyObject *"""
        return _pmt_swig.SwigPyIterator___next__(self)

    def previous(self):
        """previous(SwigPyIterator self) -> PyObject *"""
        return _pmt_swig.SwigPyIterator_previous(self)

    def advance(self, *args, **kwargs):
        """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pmt_swig.SwigPyIterator_advance(self, *args, **kwargs)

    def __eq__(self, *args, **kwargs):
        """__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _pmt_swig.SwigPyIterator___eq__(self, *args, **kwargs)

    def __ne__(self, *args, **kwargs):
        """__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _pmt_swig.SwigPyIterator___ne__(self, *args, **kwargs)

    def __iadd__(self, *args, **kwargs):
        """__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pmt_swig.SwigPyIterator___iadd__(self, *args, **kwargs)

    def __isub__(self, *args, **kwargs):
        """__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pmt_swig.SwigPyIterator___isub__(self, *args, **kwargs)

    def __add__(self, *args, **kwargs):
        """__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pmt_swig.SwigPyIterator___add__(self, *args, **kwargs)

    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _pmt_swig.SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
SwigPyIterator_swigregister = _pmt_swig.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class pmt_vector_int8(object):
    """Proxy of C++ std::vector<(int8_t)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(pmt_vector_int8 self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_int8_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(pmt_vector_int8 self) -> bool"""
        return _pmt_swig.pmt_vector_int8___nonzero__(self)

    def __bool__(self):
        """__bool__(pmt_vector_int8 self) -> bool"""
        return _pmt_swig.pmt_vector_int8___bool__(self)

    def __len__(self):
        """__len__(pmt_vector_int8 self) -> std::vector< signed char >::size_type"""
        return _pmt_swig.pmt_vector_int8___len__(self)

    def pop(self):
        """pop(pmt_vector_int8 self) -> std::vector< signed char >::value_type"""
        return _pmt_swig.pmt_vector_int8_pop(self)

    def __getslice__(self, *args, **kwargs):
        """__getslice__(pmt_vector_int8 self, std::vector< signed char >::difference_type i, std::vector< signed char >::difference_type j) -> pmt_vector_int8"""
        return _pmt_swig.pmt_vector_int8___getslice__(self, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """
        __setslice__(pmt_vector_int8 self, std::vector< signed char >::difference_type i, std::vector< signed char >::difference_type j, 
            pmt_vector_int8 v=std::vector< signed char,std::allocator< signed char > >())
        """
        return _pmt_swig.pmt_vector_int8___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """__delslice__(pmt_vector_int8 self, std::vector< signed char >::difference_type i, std::vector< signed char >::difference_type j)"""
        return _pmt_swig.pmt_vector_int8___delslice__(self, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __delitem__(pmt_vector_int8 self, std::vector< signed char >::difference_type i)
        __delitem__(pmt_vector_int8 self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_int8___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(pmt_vector_int8 self, PySliceObject * slice) -> pmt_vector_int8
        __getitem__(pmt_vector_int8 self, std::vector< signed char >::difference_type i) -> std::vector< signed char >::value_type const &
        """
        return _pmt_swig.pmt_vector_int8___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(pmt_vector_int8 self, PySliceObject * slice, pmt_vector_int8 v)
        __setitem__(pmt_vector_int8 self, PySliceObject * slice)
        __setitem__(pmt_vector_int8 self, std::vector< signed char >::difference_type i, std::vector< signed char >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_int8___setitem__(self, *args)

    def append(self, *args, **kwargs):
        """append(pmt_vector_int8 self, std::vector< signed char >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int8_append(self, *args, **kwargs)

    def empty(self):
        """empty(pmt_vector_int8 self) -> bool"""
        return _pmt_swig.pmt_vector_int8_empty(self)

    def size(self):
        """size(pmt_vector_int8 self) -> std::vector< signed char >::size_type"""
        return _pmt_swig.pmt_vector_int8_size(self)

    def clear(self):
        """clear(pmt_vector_int8 self)"""
        return _pmt_swig.pmt_vector_int8_clear(self)

    def swap(self, *args, **kwargs):
        """swap(pmt_vector_int8 self, pmt_vector_int8 v)"""
        return _pmt_swig.pmt_vector_int8_swap(self, *args, **kwargs)

    def get_allocator(self):
        """get_allocator(pmt_vector_int8 self) -> std::vector< signed char >::allocator_type"""
        return _pmt_swig.pmt_vector_int8_get_allocator(self)

    def begin(self):
        """begin(pmt_vector_int8 self) -> std::vector< signed char >::iterator"""
        return _pmt_swig.pmt_vector_int8_begin(self)

    def end(self):
        """end(pmt_vector_int8 self) -> std::vector< signed char >::iterator"""
        return _pmt_swig.pmt_vector_int8_end(self)

    def rbegin(self):
        """rbegin(pmt_vector_int8 self) -> std::vector< signed char >::reverse_iterator"""
        return _pmt_swig.pmt_vector_int8_rbegin(self)

    def rend(self):
        """rend(pmt_vector_int8 self) -> std::vector< signed char >::reverse_iterator"""
        return _pmt_swig.pmt_vector_int8_rend(self)

    def pop_back(self):
        """pop_back(pmt_vector_int8 self)"""
        return _pmt_swig.pmt_vector_int8_pop_back(self)

    def erase(self, *args):
        """
        erase(pmt_vector_int8 self, std::vector< signed char >::iterator pos) -> std::vector< signed char >::iterator
        erase(pmt_vector_int8 self, std::vector< signed char >::iterator first, std::vector< signed char >::iterator last) -> std::vector< signed char >::iterator
        """
        return _pmt_swig.pmt_vector_int8_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(int8_t)> self) -> pmt_vector_int8
        __init__(std::vector<(int8_t)> self, pmt_vector_int8 arg2) -> pmt_vector_int8
        __init__(std::vector<(int8_t)> self, std::vector< signed char >::size_type size) -> pmt_vector_int8
        __init__(std::vector<(int8_t)> self, std::vector< signed char >::size_type size, std::vector< signed char >::value_type const & value) -> pmt_vector_int8
        """
        this = _pmt_swig.new_pmt_vector_int8(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """push_back(pmt_vector_int8 self, std::vector< signed char >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int8_push_back(self, *args, **kwargs)

    def front(self):
        """front(pmt_vector_int8 self) -> std::vector< signed char >::value_type const &"""
        return _pmt_swig.pmt_vector_int8_front(self)

    def back(self):
        """back(pmt_vector_int8 self) -> std::vector< signed char >::value_type const &"""
        return _pmt_swig.pmt_vector_int8_back(self)

    def assign(self, *args, **kwargs):
        """assign(pmt_vector_int8 self, std::vector< signed char >::size_type n, std::vector< signed char >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int8_assign(self, *args, **kwargs)

    def resize(self, *args):
        """
        resize(pmt_vector_int8 self, std::vector< signed char >::size_type new_size)
        resize(pmt_vector_int8 self, std::vector< signed char >::size_type new_size, std::vector< signed char >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_int8_resize(self, *args)

    def insert(self, *args):
        """
        insert(pmt_vector_int8 self, std::vector< signed char >::iterator pos, std::vector< signed char >::value_type const & x) -> std::vector< signed char >::iterator
        insert(pmt_vector_int8 self, std::vector< signed char >::iterator pos, std::vector< signed char >::size_type n, 
            std::vector< signed char >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_int8_insert(self, *args)

    def reserve(self, *args, **kwargs):
        """reserve(pmt_vector_int8 self, std::vector< signed char >::size_type n)"""
        return _pmt_swig.pmt_vector_int8_reserve(self, *args, **kwargs)

    def capacity(self):
        """capacity(pmt_vector_int8 self) -> std::vector< signed char >::size_type"""
        return _pmt_swig.pmt_vector_int8_capacity(self)

    __swig_destroy__ = _pmt_swig.delete_pmt_vector_int8
    __del__ = lambda self : None;
pmt_vector_int8_swigregister = _pmt_swig.pmt_vector_int8_swigregister
pmt_vector_int8_swigregister(pmt_vector_int8)

class pmt_vector_uint8(object):
    """Proxy of C++ std::vector<(uint8_t)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(pmt_vector_uint8 self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_uint8_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(pmt_vector_uint8 self) -> bool"""
        return _pmt_swig.pmt_vector_uint8___nonzero__(self)

    def __bool__(self):
        """__bool__(pmt_vector_uint8 self) -> bool"""
        return _pmt_swig.pmt_vector_uint8___bool__(self)

    def __len__(self):
        """__len__(pmt_vector_uint8 self) -> std::vector< unsigned char >::size_type"""
        return _pmt_swig.pmt_vector_uint8___len__(self)

    def pop(self):
        """pop(pmt_vector_uint8 self) -> std::vector< unsigned char >::value_type"""
        return _pmt_swig.pmt_vector_uint8_pop(self)

    def __getslice__(self, *args, **kwargs):
        """__getslice__(pmt_vector_uint8 self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j) -> pmt_vector_uint8"""
        return _pmt_swig.pmt_vector_uint8___getslice__(self, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """
        __setslice__(pmt_vector_uint8 self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j, 
            pmt_vector_uint8 v=std::vector< unsigned char,std::allocator< unsigned char > >())
        """
        return _pmt_swig.pmt_vector_uint8___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """__delslice__(pmt_vector_uint8 self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j)"""
        return _pmt_swig.pmt_vector_uint8___delslice__(self, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __delitem__(pmt_vector_uint8 self, std::vector< unsigned char >::difference_type i)
        __delitem__(pmt_vector_uint8 self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_uint8___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(pmt_vector_uint8 self, PySliceObject * slice) -> pmt_vector_uint8
        __getitem__(pmt_vector_uint8 self, std::vector< unsigned char >::difference_type i) -> std::vector< unsigned char >::value_type const &
        """
        return _pmt_swig.pmt_vector_uint8___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(pmt_vector_uint8 self, PySliceObject * slice, pmt_vector_uint8 v)
        __setitem__(pmt_vector_uint8 self, PySliceObject * slice)
        __setitem__(pmt_vector_uint8 self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_uint8___setitem__(self, *args)

    def append(self, *args, **kwargs):
        """append(pmt_vector_uint8 self, std::vector< unsigned char >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint8_append(self, *args, **kwargs)

    def empty(self):
        """empty(pmt_vector_uint8 self) -> bool"""
        return _pmt_swig.pmt_vector_uint8_empty(self)

    def size(self):
        """size(pmt_vector_uint8 self) -> std::vector< unsigned char >::size_type"""
        return _pmt_swig.pmt_vector_uint8_size(self)

    def clear(self):
        """clear(pmt_vector_uint8 self)"""
        return _pmt_swig.pmt_vector_uint8_clear(self)

    def swap(self, *args, **kwargs):
        """swap(pmt_vector_uint8 self, pmt_vector_uint8 v)"""
        return _pmt_swig.pmt_vector_uint8_swap(self, *args, **kwargs)

    def get_allocator(self):
        """get_allocator(pmt_vector_uint8 self) -> std::vector< unsigned char >::allocator_type"""
        return _pmt_swig.pmt_vector_uint8_get_allocator(self)

    def begin(self):
        """begin(pmt_vector_uint8 self) -> std::vector< unsigned char >::iterator"""
        return _pmt_swig.pmt_vector_uint8_begin(self)

    def end(self):
        """end(pmt_vector_uint8 self) -> std::vector< unsigned char >::iterator"""
        return _pmt_swig.pmt_vector_uint8_end(self)

    def rbegin(self):
        """rbegin(pmt_vector_uint8 self) -> std::vector< unsigned char >::reverse_iterator"""
        return _pmt_swig.pmt_vector_uint8_rbegin(self)

    def rend(self):
        """rend(pmt_vector_uint8 self) -> std::vector< unsigned char >::reverse_iterator"""
        return _pmt_swig.pmt_vector_uint8_rend(self)

    def pop_back(self):
        """pop_back(pmt_vector_uint8 self)"""
        return _pmt_swig.pmt_vector_uint8_pop_back(self)

    def erase(self, *args):
        """
        erase(pmt_vector_uint8 self, std::vector< unsigned char >::iterator pos) -> std::vector< unsigned char >::iterator
        erase(pmt_vector_uint8 self, std::vector< unsigned char >::iterator first, std::vector< unsigned char >::iterator last) -> std::vector< unsigned char >::iterator
        """
        return _pmt_swig.pmt_vector_uint8_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(uint8_t)> self) -> pmt_vector_uint8
        __init__(std::vector<(uint8_t)> self, pmt_vector_uint8 arg2) -> pmt_vector_uint8
        __init__(std::vector<(uint8_t)> self, std::vector< unsigned char >::size_type size) -> pmt_vector_uint8
        __init__(std::vector<(uint8_t)> self, std::vector< unsigned char >::size_type size, std::vector< unsigned char >::value_type const & value) -> pmt_vector_uint8
        """
        this = _pmt_swig.new_pmt_vector_uint8(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """push_back(pmt_vector_uint8 self, std::vector< unsigned char >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint8_push_back(self, *args, **kwargs)

    def front(self):
        """front(pmt_vector_uint8 self) -> std::vector< unsigned char >::value_type const &"""
        return _pmt_swig.pmt_vector_uint8_front(self)

    def back(self):
        """back(pmt_vector_uint8 self) -> std::vector< unsigned char >::value_type const &"""
        return _pmt_swig.pmt_vector_uint8_back(self)

    def assign(self, *args, **kwargs):
        """assign(pmt_vector_uint8 self, std::vector< unsigned char >::size_type n, std::vector< unsigned char >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint8_assign(self, *args, **kwargs)

    def resize(self, *args):
        """
        resize(pmt_vector_uint8 self, std::vector< unsigned char >::size_type new_size)
        resize(pmt_vector_uint8 self, std::vector< unsigned char >::size_type new_size, std::vector< unsigned char >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_uint8_resize(self, *args)

    def insert(self, *args):
        """
        insert(pmt_vector_uint8 self, std::vector< unsigned char >::iterator pos, std::vector< unsigned char >::value_type const & x) -> std::vector< unsigned char >::iterator
        insert(pmt_vector_uint8 self, std::vector< unsigned char >::iterator pos, std::vector< unsigned char >::size_type n, 
            std::vector< unsigned char >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_uint8_insert(self, *args)

    def reserve(self, *args, **kwargs):
        """reserve(pmt_vector_uint8 self, std::vector< unsigned char >::size_type n)"""
        return _pmt_swig.pmt_vector_uint8_reserve(self, *args, **kwargs)

    def capacity(self):
        """capacity(pmt_vector_uint8 self) -> std::vector< unsigned char >::size_type"""
        return _pmt_swig.pmt_vector_uint8_capacity(self)

    __swig_destroy__ = _pmt_swig.delete_pmt_vector_uint8
    __del__ = lambda self : None;
pmt_vector_uint8_swigregister = _pmt_swig.pmt_vector_uint8_swigregister
pmt_vector_uint8_swigregister(pmt_vector_uint8)

class pmt_vector_int16(object):
    """Proxy of C++ std::vector<(int16_t)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(pmt_vector_int16 self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_int16_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(pmt_vector_int16 self) -> bool"""
        return _pmt_swig.pmt_vector_int16___nonzero__(self)

    def __bool__(self):
        """__bool__(pmt_vector_int16 self) -> bool"""
        return _pmt_swig.pmt_vector_int16___bool__(self)

    def __len__(self):
        """__len__(pmt_vector_int16 self) -> std::vector< short >::size_type"""
        return _pmt_swig.pmt_vector_int16___len__(self)

    def pop(self):
        """pop(pmt_vector_int16 self) -> std::vector< short >::value_type"""
        return _pmt_swig.pmt_vector_int16_pop(self)

    def __getslice__(self, *args, **kwargs):
        """__getslice__(pmt_vector_int16 self, std::vector< short >::difference_type i, std::vector< short >::difference_type j) -> pmt_vector_int16"""
        return _pmt_swig.pmt_vector_int16___getslice__(self, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """
        __setslice__(pmt_vector_int16 self, std::vector< short >::difference_type i, std::vector< short >::difference_type j, 
            pmt_vector_int16 v=std::vector< short,std::allocator< short > >())
        """
        return _pmt_swig.pmt_vector_int16___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """__delslice__(pmt_vector_int16 self, std::vector< short >::difference_type i, std::vector< short >::difference_type j)"""
        return _pmt_swig.pmt_vector_int16___delslice__(self, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __delitem__(pmt_vector_int16 self, std::vector< short >::difference_type i)
        __delitem__(pmt_vector_int16 self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_int16___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(pmt_vector_int16 self, PySliceObject * slice) -> pmt_vector_int16
        __getitem__(pmt_vector_int16 self, std::vector< short >::difference_type i) -> std::vector< short >::value_type const &
        """
        return _pmt_swig.pmt_vector_int16___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(pmt_vector_int16 self, PySliceObject * slice, pmt_vector_int16 v)
        __setitem__(pmt_vector_int16 self, PySliceObject * slice)
        __setitem__(pmt_vector_int16 self, std::vector< short >::difference_type i, std::vector< short >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_int16___setitem__(self, *args)

    def append(self, *args, **kwargs):
        """append(pmt_vector_int16 self, std::vector< short >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int16_append(self, *args, **kwargs)

    def empty(self):
        """empty(pmt_vector_int16 self) -> bool"""
        return _pmt_swig.pmt_vector_int16_empty(self)

    def size(self):
        """size(pmt_vector_int16 self) -> std::vector< short >::size_type"""
        return _pmt_swig.pmt_vector_int16_size(self)

    def clear(self):
        """clear(pmt_vector_int16 self)"""
        return _pmt_swig.pmt_vector_int16_clear(self)

    def swap(self, *args, **kwargs):
        """swap(pmt_vector_int16 self, pmt_vector_int16 v)"""
        return _pmt_swig.pmt_vector_int16_swap(self, *args, **kwargs)

    def get_allocator(self):
        """get_allocator(pmt_vector_int16 self) -> std::vector< short >::allocator_type"""
        return _pmt_swig.pmt_vector_int16_get_allocator(self)

    def begin(self):
        """begin(pmt_vector_int16 self) -> std::vector< short >::iterator"""
        return _pmt_swig.pmt_vector_int16_begin(self)

    def end(self):
        """end(pmt_vector_int16 self) -> std::vector< short >::iterator"""
        return _pmt_swig.pmt_vector_int16_end(self)

    def rbegin(self):
        """rbegin(pmt_vector_int16 self) -> std::vector< short >::reverse_iterator"""
        return _pmt_swig.pmt_vector_int16_rbegin(self)

    def rend(self):
        """rend(pmt_vector_int16 self) -> std::vector< short >::reverse_iterator"""
        return _pmt_swig.pmt_vector_int16_rend(self)

    def pop_back(self):
        """pop_back(pmt_vector_int16 self)"""
        return _pmt_swig.pmt_vector_int16_pop_back(self)

    def erase(self, *args):
        """
        erase(pmt_vector_int16 self, std::vector< short >::iterator pos) -> std::vector< short >::iterator
        erase(pmt_vector_int16 self, std::vector< short >::iterator first, std::vector< short >::iterator last) -> std::vector< short >::iterator
        """
        return _pmt_swig.pmt_vector_int16_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(int16_t)> self) -> pmt_vector_int16
        __init__(std::vector<(int16_t)> self, pmt_vector_int16 arg2) -> pmt_vector_int16
        __init__(std::vector<(int16_t)> self, std::vector< short >::size_type size) -> pmt_vector_int16
        __init__(std::vector<(int16_t)> self, std::vector< short >::size_type size, std::vector< short >::value_type const & value) -> pmt_vector_int16
        """
        this = _pmt_swig.new_pmt_vector_int16(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """push_back(pmt_vector_int16 self, std::vector< short >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int16_push_back(self, *args, **kwargs)

    def front(self):
        """front(pmt_vector_int16 self) -> std::vector< short >::value_type const &"""
        return _pmt_swig.pmt_vector_int16_front(self)

    def back(self):
        """back(pmt_vector_int16 self) -> std::vector< short >::value_type const &"""
        return _pmt_swig.pmt_vector_int16_back(self)

    def assign(self, *args, **kwargs):
        """assign(pmt_vector_int16 self, std::vector< short >::size_type n, std::vector< short >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int16_assign(self, *args, **kwargs)

    def resize(self, *args):
        """
        resize(pmt_vector_int16 self, std::vector< short >::size_type new_size)
        resize(pmt_vector_int16 self, std::vector< short >::size_type new_size, std::vector< short >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_int16_resize(self, *args)

    def insert(self, *args):
        """
        insert(pmt_vector_int16 self, std::vector< short >::iterator pos, std::vector< short >::value_type const & x) -> std::vector< short >::iterator
        insert(pmt_vector_int16 self, std::vector< short >::iterator pos, std::vector< short >::size_type n, std::vector< short >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_int16_insert(self, *args)

    def reserve(self, *args, **kwargs):
        """reserve(pmt_vector_int16 self, std::vector< short >::size_type n)"""
        return _pmt_swig.pmt_vector_int16_reserve(self, *args, **kwargs)

    def capacity(self):
        """capacity(pmt_vector_int16 self) -> std::vector< short >::size_type"""
        return _pmt_swig.pmt_vector_int16_capacity(self)

    __swig_destroy__ = _pmt_swig.delete_pmt_vector_int16
    __del__ = lambda self : None;
pmt_vector_int16_swigregister = _pmt_swig.pmt_vector_int16_swigregister
pmt_vector_int16_swigregister(pmt_vector_int16)

class pmt_vector_uint16(object):
    """Proxy of C++ std::vector<(uint16_t)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(pmt_vector_uint16 self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_uint16_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(pmt_vector_uint16 self) -> bool"""
        return _pmt_swig.pmt_vector_uint16___nonzero__(self)

    def __bool__(self):
        """__bool__(pmt_vector_uint16 self) -> bool"""
        return _pmt_swig.pmt_vector_uint16___bool__(self)

    def __len__(self):
        """__len__(pmt_vector_uint16 self) -> std::vector< unsigned short >::size_type"""
        return _pmt_swig.pmt_vector_uint16___len__(self)

    def pop(self):
        """pop(pmt_vector_uint16 self) -> std::vector< unsigned short >::value_type"""
        return _pmt_swig.pmt_vector_uint16_pop(self)

    def __getslice__(self, *args, **kwargs):
        """__getslice__(pmt_vector_uint16 self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::difference_type j) -> pmt_vector_uint16"""
        return _pmt_swig.pmt_vector_uint16___getslice__(self, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """
        __setslice__(pmt_vector_uint16 self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::difference_type j, 
            pmt_vector_uint16 v=std::vector< unsigned short,std::allocator< unsigned short > >())
        """
        return _pmt_swig.pmt_vector_uint16___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """__delslice__(pmt_vector_uint16 self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::difference_type j)"""
        return _pmt_swig.pmt_vector_uint16___delslice__(self, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __delitem__(pmt_vector_uint16 self, std::vector< unsigned short >::difference_type i)
        __delitem__(pmt_vector_uint16 self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_uint16___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(pmt_vector_uint16 self, PySliceObject * slice) -> pmt_vector_uint16
        __getitem__(pmt_vector_uint16 self, std::vector< unsigned short >::difference_type i) -> std::vector< unsigned short >::value_type const &
        """
        return _pmt_swig.pmt_vector_uint16___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(pmt_vector_uint16 self, PySliceObject * slice, pmt_vector_uint16 v)
        __setitem__(pmt_vector_uint16 self, PySliceObject * slice)
        __setitem__(pmt_vector_uint16 self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_uint16___setitem__(self, *args)

    def append(self, *args, **kwargs):
        """append(pmt_vector_uint16 self, std::vector< unsigned short >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint16_append(self, *args, **kwargs)

    def empty(self):
        """empty(pmt_vector_uint16 self) -> bool"""
        return _pmt_swig.pmt_vector_uint16_empty(self)

    def size(self):
        """size(pmt_vector_uint16 self) -> std::vector< unsigned short >::size_type"""
        return _pmt_swig.pmt_vector_uint16_size(self)

    def clear(self):
        """clear(pmt_vector_uint16 self)"""
        return _pmt_swig.pmt_vector_uint16_clear(self)

    def swap(self, *args, **kwargs):
        """swap(pmt_vector_uint16 self, pmt_vector_uint16 v)"""
        return _pmt_swig.pmt_vector_uint16_swap(self, *args, **kwargs)

    def get_allocator(self):
        """get_allocator(pmt_vector_uint16 self) -> std::vector< unsigned short >::allocator_type"""
        return _pmt_swig.pmt_vector_uint16_get_allocator(self)

    def begin(self):
        """begin(pmt_vector_uint16 self) -> std::vector< unsigned short >::iterator"""
        return _pmt_swig.pmt_vector_uint16_begin(self)

    def end(self):
        """end(pmt_vector_uint16 self) -> std::vector< unsigned short >::iterator"""
        return _pmt_swig.pmt_vector_uint16_end(self)

    def rbegin(self):
        """rbegin(pmt_vector_uint16 self) -> std::vector< unsigned short >::reverse_iterator"""
        return _pmt_swig.pmt_vector_uint16_rbegin(self)

    def rend(self):
        """rend(pmt_vector_uint16 self) -> std::vector< unsigned short >::reverse_iterator"""
        return _pmt_swig.pmt_vector_uint16_rend(self)

    def pop_back(self):
        """pop_back(pmt_vector_uint16 self)"""
        return _pmt_swig.pmt_vector_uint16_pop_back(self)

    def erase(self, *args):
        """
        erase(pmt_vector_uint16 self, std::vector< unsigned short >::iterator pos) -> std::vector< unsigned short >::iterator
        erase(pmt_vector_uint16 self, std::vector< unsigned short >::iterator first, std::vector< unsigned short >::iterator last) -> std::vector< unsigned short >::iterator
        """
        return _pmt_swig.pmt_vector_uint16_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(uint16_t)> self) -> pmt_vector_uint16
        __init__(std::vector<(uint16_t)> self, pmt_vector_uint16 arg2) -> pmt_vector_uint16
        __init__(std::vector<(uint16_t)> self, std::vector< unsigned short >::size_type size) -> pmt_vector_uint16
        __init__(std::vector<(uint16_t)> self, std::vector< unsigned short >::size_type size, std::vector< unsigned short >::value_type const & value) -> pmt_vector_uint16
        """
        this = _pmt_swig.new_pmt_vector_uint16(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """push_back(pmt_vector_uint16 self, std::vector< unsigned short >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint16_push_back(self, *args, **kwargs)

    def front(self):
        """front(pmt_vector_uint16 self) -> std::vector< unsigned short >::value_type const &"""
        return _pmt_swig.pmt_vector_uint16_front(self)

    def back(self):
        """back(pmt_vector_uint16 self) -> std::vector< unsigned short >::value_type const &"""
        return _pmt_swig.pmt_vector_uint16_back(self)

    def assign(self, *args, **kwargs):
        """assign(pmt_vector_uint16 self, std::vector< unsigned short >::size_type n, std::vector< unsigned short >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint16_assign(self, *args, **kwargs)

    def resize(self, *args):
        """
        resize(pmt_vector_uint16 self, std::vector< unsigned short >::size_type new_size)
        resize(pmt_vector_uint16 self, std::vector< unsigned short >::size_type new_size, std::vector< unsigned short >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_uint16_resize(self, *args)

    def insert(self, *args):
        """
        insert(pmt_vector_uint16 self, std::vector< unsigned short >::iterator pos, std::vector< unsigned short >::value_type const & x) -> std::vector< unsigned short >::iterator
        insert(pmt_vector_uint16 self, std::vector< unsigned short >::iterator pos, std::vector< unsigned short >::size_type n, 
            std::vector< unsigned short >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_uint16_insert(self, *args)

    def reserve(self, *args, **kwargs):
        """reserve(pmt_vector_uint16 self, std::vector< unsigned short >::size_type n)"""
        return _pmt_swig.pmt_vector_uint16_reserve(self, *args, **kwargs)

    def capacity(self):
        """capacity(pmt_vector_uint16 self) -> std::vector< unsigned short >::size_type"""
        return _pmt_swig.pmt_vector_uint16_capacity(self)

    __swig_destroy__ = _pmt_swig.delete_pmt_vector_uint16
    __del__ = lambda self : None;
pmt_vector_uint16_swigregister = _pmt_swig.pmt_vector_uint16_swigregister
pmt_vector_uint16_swigregister(pmt_vector_uint16)

class pmt_vector_int32(object):
    """Proxy of C++ std::vector<(int32_t)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(pmt_vector_int32 self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_int32_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(pmt_vector_int32 self) -> bool"""
        return _pmt_swig.pmt_vector_int32___nonzero__(self)

    def __bool__(self):
        """__bool__(pmt_vector_int32 self) -> bool"""
        return _pmt_swig.pmt_vector_int32___bool__(self)

    def __len__(self):
        """__len__(pmt_vector_int32 self) -> std::vector< int >::size_type"""
        return _pmt_swig.pmt_vector_int32___len__(self)

    def pop(self):
        """pop(pmt_vector_int32 self) -> std::vector< int >::value_type"""
        return _pmt_swig.pmt_vector_int32_pop(self)

    def __getslice__(self, *args, **kwargs):
        """__getslice__(pmt_vector_int32 self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> pmt_vector_int32"""
        return _pmt_swig.pmt_vector_int32___getslice__(self, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """__setslice__(pmt_vector_int32 self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, pmt_vector_int32 v=std::vector< int,std::allocator< int > >())"""
        return _pmt_swig.pmt_vector_int32___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """__delslice__(pmt_vector_int32 self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
        return _pmt_swig.pmt_vector_int32___delslice__(self, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __delitem__(pmt_vector_int32 self, std::vector< int >::difference_type i)
        __delitem__(pmt_vector_int32 self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_int32___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(pmt_vector_int32 self, PySliceObject * slice) -> pmt_vector_int32
        __getitem__(pmt_vector_int32 self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
        """
        return _pmt_swig.pmt_vector_int32___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(pmt_vector_int32 self, PySliceObject * slice, pmt_vector_int32 v)
        __setitem__(pmt_vector_int32 self, PySliceObject * slice)
        __setitem__(pmt_vector_int32 self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_int32___setitem__(self, *args)

    def append(self, *args, **kwargs):
        """append(pmt_vector_int32 self, std::vector< int >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int32_append(self, *args, **kwargs)

    def empty(self):
        """empty(pmt_vector_int32 self) -> bool"""
        return _pmt_swig.pmt_vector_int32_empty(self)

    def size(self):
        """size(pmt_vector_int32 self) -> std::vector< int >::size_type"""
        return _pmt_swig.pmt_vector_int32_size(self)

    def clear(self):
        """clear(pmt_vector_int32 self)"""
        return _pmt_swig.pmt_vector_int32_clear(self)

    def swap(self, *args, **kwargs):
        """swap(pmt_vector_int32 self, pmt_vector_int32 v)"""
        return _pmt_swig.pmt_vector_int32_swap(self, *args, **kwargs)

    def get_allocator(self):
        """get_allocator(pmt_vector_int32 self) -> std::vector< int >::allocator_type"""
        return _pmt_swig.pmt_vector_int32_get_allocator(self)

    def begin(self):
        """begin(pmt_vector_int32 self) -> std::vector< int >::iterator"""
        return _pmt_swig.pmt_vector_int32_begin(self)

    def end(self):
        """end(pmt_vector_int32 self) -> std::vector< int >::iterator"""
        return _pmt_swig.pmt_vector_int32_end(self)

    def rbegin(self):
        """rbegin(pmt_vector_int32 self) -> std::vector< int >::reverse_iterator"""
        return _pmt_swig.pmt_vector_int32_rbegin(self)

    def rend(self):
        """rend(pmt_vector_int32 self) -> std::vector< int >::reverse_iterator"""
        return _pmt_swig.pmt_vector_int32_rend(self)

    def pop_back(self):
        """pop_back(pmt_vector_int32 self)"""
        return _pmt_swig.pmt_vector_int32_pop_back(self)

    def erase(self, *args):
        """
        erase(pmt_vector_int32 self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
        erase(pmt_vector_int32 self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
        """
        return _pmt_swig.pmt_vector_int32_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(int32_t)> self) -> pmt_vector_int32
        __init__(std::vector<(int32_t)> self, pmt_vector_int32 arg2) -> pmt_vector_int32
        __init__(std::vector<(int32_t)> self, std::vector< int >::size_type size) -> pmt_vector_int32
        __init__(std::vector<(int32_t)> self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> pmt_vector_int32
        """
        this = _pmt_swig.new_pmt_vector_int32(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """push_back(pmt_vector_int32 self, std::vector< int >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int32_push_back(self, *args, **kwargs)

    def front(self):
        """front(pmt_vector_int32 self) -> std::vector< int >::value_type const &"""
        return _pmt_swig.pmt_vector_int32_front(self)

    def back(self):
        """back(pmt_vector_int32 self) -> std::vector< int >::value_type const &"""
        return _pmt_swig.pmt_vector_int32_back(self)

    def assign(self, *args, **kwargs):
        """assign(pmt_vector_int32 self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int32_assign(self, *args, **kwargs)

    def resize(self, *args):
        """
        resize(pmt_vector_int32 self, std::vector< int >::size_type new_size)
        resize(pmt_vector_int32 self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_int32_resize(self, *args)

    def insert(self, *args):
        """
        insert(pmt_vector_int32 self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator
        insert(pmt_vector_int32 self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_int32_insert(self, *args)

    def reserve(self, *args, **kwargs):
        """reserve(pmt_vector_int32 self, std::vector< int >::size_type n)"""
        return _pmt_swig.pmt_vector_int32_reserve(self, *args, **kwargs)

    def capacity(self):
        """capacity(pmt_vector_int32 self) -> std::vector< int >::size_type"""
        return _pmt_swig.pmt_vector_int32_capacity(self)

    __swig_destroy__ = _pmt_swig.delete_pmt_vector_int32
    __del__ = lambda self : None;
pmt_vector_int32_swigregister = _pmt_swig.pmt_vector_int32_swigregister
pmt_vector_int32_swigregister(pmt_vector_int32)

class pmt_vector_uint32(object):
    """Proxy of C++ std::vector<(uint32_t)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(pmt_vector_uint32 self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_uint32_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(pmt_vector_uint32 self) -> bool"""
        return _pmt_swig.pmt_vector_uint32___nonzero__(self)

    def __bool__(self):
        """__bool__(pmt_vector_uint32 self) -> bool"""
        return _pmt_swig.pmt_vector_uint32___bool__(self)

    def __len__(self):
        """__len__(pmt_vector_uint32 self) -> std::vector< unsigned int >::size_type"""
        return _pmt_swig.pmt_vector_uint32___len__(self)

    def pop(self):
        """pop(pmt_vector_uint32 self) -> std::vector< unsigned int >::value_type"""
        return _pmt_swig.pmt_vector_uint32_pop(self)

    def __getslice__(self, *args, **kwargs):
        """__getslice__(pmt_vector_uint32 self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j) -> pmt_vector_uint32"""
        return _pmt_swig.pmt_vector_uint32___getslice__(self, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """
        __setslice__(pmt_vector_uint32 self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j, 
            pmt_vector_uint32 v=std::vector< unsigned int,std::allocator< unsigned int > >())
        """
        return _pmt_swig.pmt_vector_uint32___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """__delslice__(pmt_vector_uint32 self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j)"""
        return _pmt_swig.pmt_vector_uint32___delslice__(self, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __delitem__(pmt_vector_uint32 self, std::vector< unsigned int >::difference_type i)
        __delitem__(pmt_vector_uint32 self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_uint32___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(pmt_vector_uint32 self, PySliceObject * slice) -> pmt_vector_uint32
        __getitem__(pmt_vector_uint32 self, std::vector< unsigned int >::difference_type i) -> std::vector< unsigned int >::value_type const &
        """
        return _pmt_swig.pmt_vector_uint32___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(pmt_vector_uint32 self, PySliceObject * slice, pmt_vector_uint32 v)
        __setitem__(pmt_vector_uint32 self, PySliceObject * slice)
        __setitem__(pmt_vector_uint32 self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_uint32___setitem__(self, *args)

    def append(self, *args, **kwargs):
        """append(pmt_vector_uint32 self, std::vector< unsigned int >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint32_append(self, *args, **kwargs)

    def empty(self):
        """empty(pmt_vector_uint32 self) -> bool"""
        return _pmt_swig.pmt_vector_uint32_empty(self)

    def size(self):
        """size(pmt_vector_uint32 self) -> std::vector< unsigned int >::size_type"""
        return _pmt_swig.pmt_vector_uint32_size(self)

    def clear(self):
        """clear(pmt_vector_uint32 self)"""
        return _pmt_swig.pmt_vector_uint32_clear(self)

    def swap(self, *args, **kwargs):
        """swap(pmt_vector_uint32 self, pmt_vector_uint32 v)"""
        return _pmt_swig.pmt_vector_uint32_swap(self, *args, **kwargs)

    def get_allocator(self):
        """get_allocator(pmt_vector_uint32 self) -> std::vector< unsigned int >::allocator_type"""
        return _pmt_swig.pmt_vector_uint32_get_allocator(self)

    def begin(self):
        """begin(pmt_vector_uint32 self) -> std::vector< unsigned int >::iterator"""
        return _pmt_swig.pmt_vector_uint32_begin(self)

    def end(self):
        """end(pmt_vector_uint32 self) -> std::vector< unsigned int >::iterator"""
        return _pmt_swig.pmt_vector_uint32_end(self)

    def rbegin(self):
        """rbegin(pmt_vector_uint32 self) -> std::vector< unsigned int >::reverse_iterator"""
        return _pmt_swig.pmt_vector_uint32_rbegin(self)

    def rend(self):
        """rend(pmt_vector_uint32 self) -> std::vector< unsigned int >::reverse_iterator"""
        return _pmt_swig.pmt_vector_uint32_rend(self)

    def pop_back(self):
        """pop_back(pmt_vector_uint32 self)"""
        return _pmt_swig.pmt_vector_uint32_pop_back(self)

    def erase(self, *args):
        """
        erase(pmt_vector_uint32 self, std::vector< unsigned int >::iterator pos) -> std::vector< unsigned int >::iterator
        erase(pmt_vector_uint32 self, std::vector< unsigned int >::iterator first, std::vector< unsigned int >::iterator last) -> std::vector< unsigned int >::iterator
        """
        return _pmt_swig.pmt_vector_uint32_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(uint32_t)> self) -> pmt_vector_uint32
        __init__(std::vector<(uint32_t)> self, pmt_vector_uint32 arg2) -> pmt_vector_uint32
        __init__(std::vector<(uint32_t)> self, std::vector< unsigned int >::size_type size) -> pmt_vector_uint32
        __init__(std::vector<(uint32_t)> self, std::vector< unsigned int >::size_type size, std::vector< unsigned int >::value_type const & value) -> pmt_vector_uint32
        """
        this = _pmt_swig.new_pmt_vector_uint32(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """push_back(pmt_vector_uint32 self, std::vector< unsigned int >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint32_push_back(self, *args, **kwargs)

    def front(self):
        """front(pmt_vector_uint32 self) -> std::vector< unsigned int >::value_type const &"""
        return _pmt_swig.pmt_vector_uint32_front(self)

    def back(self):
        """back(pmt_vector_uint32 self) -> std::vector< unsigned int >::value_type const &"""
        return _pmt_swig.pmt_vector_uint32_back(self)

    def assign(self, *args, **kwargs):
        """assign(pmt_vector_uint32 self, std::vector< unsigned int >::size_type n, std::vector< unsigned int >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint32_assign(self, *args, **kwargs)

    def resize(self, *args):
        """
        resize(pmt_vector_uint32 self, std::vector< unsigned int >::size_type new_size)
        resize(pmt_vector_uint32 self, std::vector< unsigned int >::size_type new_size, std::vector< unsigned int >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_uint32_resize(self, *args)

    def insert(self, *args):
        """
        insert(pmt_vector_uint32 self, std::vector< unsigned int >::iterator pos, std::vector< unsigned int >::value_type const & x) -> std::vector< unsigned int >::iterator
        insert(pmt_vector_uint32 self, std::vector< unsigned int >::iterator pos, std::vector< unsigned int >::size_type n, 
            std::vector< unsigned int >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_uint32_insert(self, *args)

    def reserve(self, *args, **kwargs):
        """reserve(pmt_vector_uint32 self, std::vector< unsigned int >::size_type n)"""
        return _pmt_swig.pmt_vector_uint32_reserve(self, *args, **kwargs)

    def capacity(self):
        """capacity(pmt_vector_uint32 self) -> std::vector< unsigned int >::size_type"""
        return _pmt_swig.pmt_vector_uint32_capacity(self)

    __swig_destroy__ = _pmt_swig.delete_pmt_vector_uint32
    __del__ = lambda self : None;
pmt_vector_uint32_swigregister = _pmt_swig.pmt_vector_uint32_swigregister
pmt_vector_uint32_swigregister(pmt_vector_uint32)

class pmt_vector_float(object):
    """Proxy of C++ std::vector<(float)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(pmt_vector_float self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_float_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(pmt_vector_float self) -> bool"""
        return _pmt_swig.pmt_vector_float___nonzero__(self)

    def __bool__(self):
        """__bool__(pmt_vector_float self) -> bool"""
        return _pmt_swig.pmt_vector_float___bool__(self)

    def __len__(self):
        """__len__(pmt_vector_float self) -> std::vector< float >::size_type"""
        return _pmt_swig.pmt_vector_float___len__(self)

    def pop(self):
        """pop(pmt_vector_float self) -> std::vector< float >::value_type"""
        return _pmt_swig.pmt_vector_float_pop(self)

    def __getslice__(self, *args, **kwargs):
        """__getslice__(pmt_vector_float self, std::vector< float >::difference_type i, std::vector< float >::difference_type j) -> pmt_vector_float"""
        return _pmt_swig.pmt_vector_float___getslice__(self, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """
        __setslice__(pmt_vector_float self, std::vector< float >::difference_type i, std::vector< float >::difference_type j, 
            pmt_vector_float v=std::vector< float,std::allocator< float > >())
        """
        return _pmt_swig.pmt_vector_float___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """__delslice__(pmt_vector_float self, std::vector< float >::difference_type i, std::vector< float >::difference_type j)"""
        return _pmt_swig.pmt_vector_float___delslice__(self, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __delitem__(pmt_vector_float self, std::vector< float >::difference_type i)
        __delitem__(pmt_vector_float self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_float___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(pmt_vector_float self, PySliceObject * slice) -> pmt_vector_float
        __getitem__(pmt_vector_float self, std::vector< float >::difference_type i) -> std::vector< float >::value_type const &
        """
        return _pmt_swig.pmt_vector_float___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(pmt_vector_float self, PySliceObject * slice, pmt_vector_float v)
        __setitem__(pmt_vector_float self, PySliceObject * slice)
        __setitem__(pmt_vector_float self, std::vector< float >::difference_type i, std::vector< float >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_float___setitem__(self, *args)

    def append(self, *args, **kwargs):
        """append(pmt_vector_float self, std::vector< float >::value_type const & x)"""
        return _pmt_swig.pmt_vector_float_append(self, *args, **kwargs)

    def empty(self):
        """empty(pmt_vector_float self) -> bool"""
        return _pmt_swig.pmt_vector_float_empty(self)

    def size(self):
        """size(pmt_vector_float self) -> std::vector< float >::size_type"""
        return _pmt_swig.pmt_vector_float_size(self)

    def clear(self):
        """clear(pmt_vector_float self)"""
        return _pmt_swig.pmt_vector_float_clear(self)

    def swap(self, *args, **kwargs):
        """swap(pmt_vector_float self, pmt_vector_float v)"""
        return _pmt_swig.pmt_vector_float_swap(self, *args, **kwargs)

    def get_allocator(self):
        """get_allocator(pmt_vector_float self) -> std::vector< float >::allocator_type"""
        return _pmt_swig.pmt_vector_float_get_allocator(self)

    def begin(self):
        """begin(pmt_vector_float self) -> std::vector< float >::iterator"""
        return _pmt_swig.pmt_vector_float_begin(self)

    def end(self):
        """end(pmt_vector_float self) -> std::vector< float >::iterator"""
        return _pmt_swig.pmt_vector_float_end(self)

    def rbegin(self):
        """rbegin(pmt_vector_float self) -> std::vector< float >::reverse_iterator"""
        return _pmt_swig.pmt_vector_float_rbegin(self)

    def rend(self):
        """rend(pmt_vector_float self) -> std::vector< float >::reverse_iterator"""
        return _pmt_swig.pmt_vector_float_rend(self)

    def pop_back(self):
        """pop_back(pmt_vector_float self)"""
        return _pmt_swig.pmt_vector_float_pop_back(self)

    def erase(self, *args):
        """
        erase(pmt_vector_float self, std::vector< float >::iterator pos) -> std::vector< float >::iterator
        erase(pmt_vector_float self, std::vector< float >::iterator first, std::vector< float >::iterator last) -> std::vector< float >::iterator
        """
        return _pmt_swig.pmt_vector_float_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(float)> self) -> pmt_vector_float
        __init__(std::vector<(float)> self, pmt_vector_float arg2) -> pmt_vector_float
        __init__(std::vector<(float)> self, std::vector< float >::size_type size) -> pmt_vector_float
        __init__(std::vector<(float)> self, std::vector< float >::size_type size, std::vector< float >::value_type const & value) -> pmt_vector_float
        """
        this = _pmt_swig.new_pmt_vector_float(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """push_back(pmt_vector_float self, std::vector< float >::value_type const & x)"""
        return _pmt_swig.pmt_vector_float_push_back(self, *args, **kwargs)

    def front(self):
        """front(pmt_vector_float self) -> std::vector< float >::value_type const &"""
        return _pmt_swig.pmt_vector_float_front(self)

    def back(self):
        """back(pmt_vector_float self) -> std::vector< float >::value_type const &"""
        return _pmt_swig.pmt_vector_float_back(self)

    def assign(self, *args, **kwargs):
        """assign(pmt_vector_float self, std::vector< float >::size_type n, std::vector< float >::value_type const & x)"""
        return _pmt_swig.pmt_vector_float_assign(self, *args, **kwargs)

    def resize(self, *args):
        """
        resize(pmt_vector_float self, std::vector< float >::size_type new_size)
        resize(pmt_vector_float self, std::vector< float >::size_type new_size, std::vector< float >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_float_resize(self, *args)

    def insert(self, *args):
        """
        insert(pmt_vector_float self, std::vector< float >::iterator pos, std::vector< float >::value_type const & x) -> std::vector< float >::iterator
        insert(pmt_vector_float self, std::vector< float >::iterator pos, std::vector< float >::size_type n, std::vector< float >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_float_insert(self, *args)

    def reserve(self, *args, **kwargs):
        """reserve(pmt_vector_float self, std::vector< float >::size_type n)"""
        return _pmt_swig.pmt_vector_float_reserve(self, *args, **kwargs)

    def capacity(self):
        """capacity(pmt_vector_float self) -> std::vector< float >::size_type"""
        return _pmt_swig.pmt_vector_float_capacity(self)

    __swig_destroy__ = _pmt_swig.delete_pmt_vector_float
    __del__ = lambda self : None;
pmt_vector_float_swigregister = _pmt_swig.pmt_vector_float_swigregister
pmt_vector_float_swigregister(pmt_vector_float)

class pmt_vector_double(object):
    """Proxy of C++ std::vector<(double)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(pmt_vector_double self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_double_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(pmt_vector_double self) -> bool"""
        return _pmt_swig.pmt_vector_double___nonzero__(self)

    def __bool__(self):
        """__bool__(pmt_vector_double self) -> bool"""
        return _pmt_swig.pmt_vector_double___bool__(self)

    def __len__(self):
        """__len__(pmt_vector_double self) -> std::vector< double >::size_type"""
        return _pmt_swig.pmt_vector_double___len__(self)

    def pop(self):
        """pop(pmt_vector_double self) -> std::vector< double >::value_type"""
        return _pmt_swig.pmt_vector_double_pop(self)

    def __getslice__(self, *args, **kwargs):
        """__getslice__(pmt_vector_double self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> pmt_vector_double"""
        return _pmt_swig.pmt_vector_double___getslice__(self, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """
        __setslice__(pmt_vector_double self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, 
            pmt_vector_double v=std::vector< double,std::allocator< double > >())
        """
        return _pmt_swig.pmt_vector_double___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """__delslice__(pmt_vector_double self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
        return _pmt_swig.pmt_vector_double___delslice__(self, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __delitem__(pmt_vector_double self, std::vector< double >::difference_type i)
        __delitem__(pmt_vector_double self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_double___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(pmt_vector_double self, PySliceObject * slice) -> pmt_vector_double
        __getitem__(pmt_vector_double self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
        """
        return _pmt_swig.pmt_vector_double___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(pmt_vector_double self, PySliceObject * slice, pmt_vector_double v)
        __setitem__(pmt_vector_double self, PySliceObject * slice)
        __setitem__(pmt_vector_double self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_double___setitem__(self, *args)

    def append(self, *args, **kwargs):
        """append(pmt_vector_double self, std::vector< double >::value_type const & x)"""
        return _pmt_swig.pmt_vector_double_append(self, *args, **kwargs)

    def empty(self):
        """empty(pmt_vector_double self) -> bool"""
        return _pmt_swig.pmt_vector_double_empty(self)

    def size(self):
        """size(pmt_vector_double self) -> std::vector< double >::size_type"""
        return _pmt_swig.pmt_vector_double_size(self)

    def clear(self):
        """clear(pmt_vector_double self)"""
        return _pmt_swig.pmt_vector_double_clear(self)

    def swap(self, *args, **kwargs):
        """swap(pmt_vector_double self, pmt_vector_double v)"""
        return _pmt_swig.pmt_vector_double_swap(self, *args, **kwargs)

    def get_allocator(self):
        """get_allocator(pmt_vector_double self) -> std::vector< double >::allocator_type"""
        return _pmt_swig.pmt_vector_double_get_allocator(self)

    def begin(self):
        """begin(pmt_vector_double self) -> std::vector< double >::iterator"""
        return _pmt_swig.pmt_vector_double_begin(self)

    def end(self):
        """end(pmt_vector_double self) -> std::vector< double >::iterator"""
        return _pmt_swig.pmt_vector_double_end(self)

    def rbegin(self):
        """rbegin(pmt_vector_double self) -> std::vector< double >::reverse_iterator"""
        return _pmt_swig.pmt_vector_double_rbegin(self)

    def rend(self):
        """rend(pmt_vector_double self) -> std::vector< double >::reverse_iterator"""
        return _pmt_swig.pmt_vector_double_rend(self)

    def pop_back(self):
        """pop_back(pmt_vector_double self)"""
        return _pmt_swig.pmt_vector_double_pop_back(self)

    def erase(self, *args):
        """
        erase(pmt_vector_double self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
        erase(pmt_vector_double self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
        """
        return _pmt_swig.pmt_vector_double_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(double)> self) -> pmt_vector_double
        __init__(std::vector<(double)> self, pmt_vector_double arg2) -> pmt_vector_double
        __init__(std::vector<(double)> self, std::vector< double >::size_type size) -> pmt_vector_double
        __init__(std::vector<(double)> self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> pmt_vector_double
        """
        this = _pmt_swig.new_pmt_vector_double(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """push_back(pmt_vector_double self, std::vector< double >::value_type const & x)"""
        return _pmt_swig.pmt_vector_double_push_back(self, *args, **kwargs)

    def front(self):
        """front(pmt_vector_double self) -> std::vector< double >::value_type const &"""
        return _pmt_swig.pmt_vector_double_front(self)

    def back(self):
        """back(pmt_vector_double self) -> std::vector< double >::value_type const &"""
        return _pmt_swig.pmt_vector_double_back(self)

    def assign(self, *args, **kwargs):
        """assign(pmt_vector_double self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _pmt_swig.pmt_vector_double_assign(self, *args, **kwargs)

    def resize(self, *args):
        """
        resize(pmt_vector_double self, std::vector< double >::size_type new_size)
        resize(pmt_vector_double self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_double_resize(self, *args)

    def insert(self, *args):
        """
        insert(pmt_vector_double self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
        insert(pmt_vector_double self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_double_insert(self, *args)

    def reserve(self, *args, **kwargs):
        """reserve(pmt_vector_double self, std::vector< double >::size_type n)"""
        return _pmt_swig.pmt_vector_double_reserve(self, *args, **kwargs)

    def capacity(self):
        """capacity(pmt_vector_double self) -> std::vector< double >::size_type"""
        return _pmt_swig.pmt_vector_double_capacity(self)

    __swig_destroy__ = _pmt_swig.delete_pmt_vector_double
    __del__ = lambda self : None;
pmt_vector_double_swigregister = _pmt_swig.pmt_vector_double_swigregister
pmt_vector_double_swigregister(pmt_vector_double)

class pmt_vector_cfloat(object):
    """Proxy of C++ std::vector<(std::complex<(float)>)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(pmt_vector_cfloat self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_cfloat_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(pmt_vector_cfloat self) -> bool"""
        return _pmt_swig.pmt_vector_cfloat___nonzero__(self)

    def __bool__(self):
        """__bool__(pmt_vector_cfloat self) -> bool"""
        return _pmt_swig.pmt_vector_cfloat___bool__(self)

    def __len__(self):
        """__len__(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::size_type"""
        return _pmt_swig.pmt_vector_cfloat___len__(self)

    def pop(self):
        """pop(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::value_type"""
        return _pmt_swig.pmt_vector_cfloat_pop(self)

    def __getslice__(self, *args, **kwargs):
        """__getslice__(pmt_vector_cfloat self, std::vector< std::complex< float > >::difference_type i, std::vector< std::complex< float > >::difference_type j) -> pmt_vector_cfloat"""
        return _pmt_swig.pmt_vector_cfloat___getslice__(self, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """
        __setslice__(pmt_vector_cfloat self, std::vector< std::complex< float > >::difference_type i, std::vector< std::complex< float > >::difference_type j, 
            pmt_vector_cfloat v=std::vector< std::complex< float >,std::allocator< std::complex< float > > >())
        """
        return _pmt_swig.pmt_vector_cfloat___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """__delslice__(pmt_vector_cfloat self, std::vector< std::complex< float > >::difference_type i, std::vector< std::complex< float > >::difference_type j)"""
        return _pmt_swig.pmt_vector_cfloat___delslice__(self, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __delitem__(pmt_vector_cfloat self, std::vector< std::complex< float > >::difference_type i)
        __delitem__(pmt_vector_cfloat self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_cfloat___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(pmt_vector_cfloat self, PySliceObject * slice) -> pmt_vector_cfloat
        __getitem__(pmt_vector_cfloat self, std::vector< std::complex< float > >::difference_type i) -> std::vector< std::complex< float > >::value_type const &
        """
        return _pmt_swig.pmt_vector_cfloat___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(pmt_vector_cfloat self, PySliceObject * slice, pmt_vector_cfloat v)
        __setitem__(pmt_vector_cfloat self, PySliceObject * slice)
        __setitem__(pmt_vector_cfloat self, std::vector< std::complex< float > >::difference_type i, std::vector< std::complex< float > >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_cfloat___setitem__(self, *args)

    def append(self, *args, **kwargs):
        """append(pmt_vector_cfloat self, std::vector< std::complex< float > >::value_type const & x)"""
        return _pmt_swig.pmt_vector_cfloat_append(self, *args, **kwargs)

    def empty(self):
        """empty(pmt_vector_cfloat self) -> bool"""
        return _pmt_swig.pmt_vector_cfloat_empty(self)

    def size(self):
        """size(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::size_type"""
        return _pmt_swig.pmt_vector_cfloat_size(self)

    def clear(self):
        """clear(pmt_vector_cfloat self)"""
        return _pmt_swig.pmt_vector_cfloat_clear(self)

    def swap(self, *args, **kwargs):
        """swap(pmt_vector_cfloat self, pmt_vector_cfloat v)"""
        return _pmt_swig.pmt_vector_cfloat_swap(self, *args, **kwargs)

    def get_allocator(self):
        """get_allocator(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::allocator_type"""
        return _pmt_swig.pmt_vector_cfloat_get_allocator(self)

    def begin(self):
        """begin(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::iterator"""
        return _pmt_swig.pmt_vector_cfloat_begin(self)

    def end(self):
        """end(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::iterator"""
        return _pmt_swig.pmt_vector_cfloat_end(self)

    def rbegin(self):
        """rbegin(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::reverse_iterator"""
        return _pmt_swig.pmt_vector_cfloat_rbegin(self)

    def rend(self):
        """rend(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::reverse_iterator"""
        return _pmt_swig.pmt_vector_cfloat_rend(self)

    def pop_back(self):
        """pop_back(pmt_vector_cfloat self)"""
        return _pmt_swig.pmt_vector_cfloat_pop_back(self)

    def erase(self, *args):
        """
        erase(pmt_vector_cfloat self, std::vector< std::complex< float > >::iterator pos) -> std::vector< std::complex< float > >::iterator
        erase(pmt_vector_cfloat self, std::vector< std::complex< float > >::iterator first, std::vector< std::complex< float > >::iterator last) -> std::vector< std::complex< float > >::iterator
        """
        return _pmt_swig.pmt_vector_cfloat_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(std::complex<(float)>)> self) -> pmt_vector_cfloat
        __init__(std::vector<(std::complex<(float)>)> self, pmt_vector_cfloat arg2) -> pmt_vector_cfloat
        __init__(std::vector<(std::complex<(float)>)> self, std::vector< std::complex< float > >::size_type size) -> pmt_vector_cfloat
        __init__(std::vector<(std::complex<(float)>)> self, std::vector< std::complex< float > >::size_type size, std::vector< std::complex< float > >::value_type const & value) -> pmt_vector_cfloat
        """
        this = _pmt_swig.new_pmt_vector_cfloat(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """push_back(pmt_vector_cfloat self, std::vector< std::complex< float > >::value_type const & x)"""
        return _pmt_swig.pmt_vector_cfloat_push_back(self, *args, **kwargs)

    def front(self):
        """front(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::value_type const &"""
        return _pmt_swig.pmt_vector_cfloat_front(self)

    def back(self):
        """back(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::value_type const &"""
        return _pmt_swig.pmt_vector_cfloat_back(self)

    def assign(self, *args, **kwargs):
        """assign(pmt_vector_cfloat self, std::vector< std::complex< float > >::size_type n, std::vector< std::complex< float > >::value_type const & x)"""
        return _pmt_swig.pmt_vector_cfloat_assign(self, *args, **kwargs)

    def resize(self, *args):
        """
        resize(pmt_vector_cfloat self, std::vector< std::complex< float > >::size_type new_size)
        resize(pmt_vector_cfloat self, std::vector< std::complex< float > >::size_type new_size, std::vector< std::complex< float > >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_cfloat_resize(self, *args)

    def insert(self, *args):
        """
        insert(pmt_vector_cfloat self, std::vector< std::complex< float > >::iterator pos, std::vector< std::complex< float > >::value_type const & x) -> std::vector< std::complex< float > >::iterator
        insert(pmt_vector_cfloat self, std::vector< std::complex< float > >::iterator pos, std::vector< std::complex< float > >::size_type n, 
            std::vector< std::complex< float > >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_cfloat_insert(self, *args)

    def reserve(self, *args, **kwargs):
        """reserve(pmt_vector_cfloat self, std::vector< std::complex< float > >::size_type n)"""
        return _pmt_swig.pmt_vector_cfloat_reserve(self, *args, **kwargs)

    def capacity(self):
        """capacity(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::size_type"""
        return _pmt_swig.pmt_vector_cfloat_capacity(self)

    __swig_destroy__ = _pmt_swig.delete_pmt_vector_cfloat
    __del__ = lambda self : None;
pmt_vector_cfloat_swigregister = _pmt_swig.pmt_vector_cfloat_swigregister
pmt_vector_cfloat_swigregister(pmt_vector_cfloat)

class pmt_vector_cdouble(object):
    """Proxy of C++ std::vector<(std::complex<(double)>)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(pmt_vector_cdouble self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_cdouble_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(pmt_vector_cdouble self) -> bool"""
        return _pmt_swig.pmt_vector_cdouble___nonzero__(self)

    def __bool__(self):
        """__bool__(pmt_vector_cdouble self) -> bool"""
        return _pmt_swig.pmt_vector_cdouble___bool__(self)

    def __len__(self):
        """__len__(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::size_type"""
        return _pmt_swig.pmt_vector_cdouble___len__(self)

    def pop(self):
        """pop(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::value_type"""
        return _pmt_swig.pmt_vector_cdouble_pop(self)

    def __getslice__(self, *args, **kwargs):
        """__getslice__(pmt_vector_cdouble self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j) -> pmt_vector_cdouble"""
        return _pmt_swig.pmt_vector_cdouble___getslice__(self, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """
        __setslice__(pmt_vector_cdouble self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j, 
            pmt_vector_cdouble v=std::vector< std::complex< double >,std::allocator< std::complex< double > > >())
        """
        return _pmt_swig.pmt_vector_cdouble___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """__delslice__(pmt_vector_cdouble self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)"""
        return _pmt_swig.pmt_vector_cdouble___delslice__(self, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __delitem__(pmt_vector_cdouble self, std::vector< std::complex< double > >::difference_type i)
        __delitem__(pmt_vector_cdouble self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_cdouble___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(pmt_vector_cdouble self, PySliceObject * slice) -> pmt_vector_cdouble
        __getitem__(pmt_vector_cdouble self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &
        """
        return _pmt_swig.pmt_vector_cdouble___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(pmt_vector_cdouble self, PySliceObject * slice, pmt_vector_cdouble v)
        __setitem__(pmt_vector_cdouble self, PySliceObject * slice)
        __setitem__(pmt_vector_cdouble self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_cdouble___setitem__(self, *args)

    def append(self, *args, **kwargs):
        """append(pmt_vector_cdouble self, std::vector< std::complex< double > >::value_type const & x)"""
        return _pmt_swig.pmt_vector_cdouble_append(self, *args, **kwargs)

    def empty(self):
        """empty(pmt_vector_cdouble self) -> bool"""
        return _pmt_swig.pmt_vector_cdouble_empty(self)

    def size(self):
        """size(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::size_type"""
        return _pmt_swig.pmt_vector_cdouble_size(self)

    def clear(self):
        """clear(pmt_vector_cdouble self)"""
        return _pmt_swig.pmt_vector_cdouble_clear(self)

    def swap(self, *args, **kwargs):
        """swap(pmt_vector_cdouble self, pmt_vector_cdouble v)"""
        return _pmt_swig.pmt_vector_cdouble_swap(self, *args, **kwargs)

    def get_allocator(self):
        """get_allocator(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::allocator_type"""
        return _pmt_swig.pmt_vector_cdouble_get_allocator(self)

    def begin(self):
        """begin(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::iterator"""
        return _pmt_swig.pmt_vector_cdouble_begin(self)

    def end(self):
        """end(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::iterator"""
        return _pmt_swig.pmt_vector_cdouble_end(self)

    def rbegin(self):
        """rbegin(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::reverse_iterator"""
        return _pmt_swig.pmt_vector_cdouble_rbegin(self)

    def rend(self):
        """rend(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::reverse_iterator"""
        return _pmt_swig.pmt_vector_cdouble_rend(self)

    def pop_back(self):
        """pop_back(pmt_vector_cdouble self)"""
        return _pmt_swig.pmt_vector_cdouble_pop_back(self)

    def erase(self, *args):
        """
        erase(pmt_vector_cdouble self, std::vector< std::complex< double > >::iterator pos) -> std::vector< std::complex< double > >::iterator
        erase(pmt_vector_cdouble self, std::vector< std::complex< double > >::iterator first, std::vector< std::complex< double > >::iterator last) -> std::vector< std::complex< double > >::iterator
        """
        return _pmt_swig.pmt_vector_cdouble_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(std::complex<(double)>)> self) -> pmt_vector_cdouble
        __init__(std::vector<(std::complex<(double)>)> self, pmt_vector_cdouble arg2) -> pmt_vector_cdouble
        __init__(std::vector<(std::complex<(double)>)> self, std::vector< std::complex< double > >::size_type size) -> pmt_vector_cdouble
        __init__(std::vector<(std::complex<(double)>)> self, std::vector< std::complex< double > >::size_type size, std::vector< std::complex< double > >::value_type const & value) -> pmt_vector_cdouble
        """
        this = _pmt_swig.new_pmt_vector_cdouble(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """push_back(pmt_vector_cdouble self, std::vector< std::complex< double > >::value_type const & x)"""
        return _pmt_swig.pmt_vector_cdouble_push_back(self, *args, **kwargs)

    def front(self):
        """front(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::value_type const &"""
        return _pmt_swig.pmt_vector_cdouble_front(self)

    def back(self):
        """back(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::value_type const &"""
        return _pmt_swig.pmt_vector_cdouble_back(self)

    def assign(self, *args, **kwargs):
        """assign(pmt_vector_cdouble self, std::vector< std::complex< double > >::size_type n, std::vector< std::complex< double > >::value_type const & x)"""
        return _pmt_swig.pmt_vector_cdouble_assign(self, *args, **kwargs)

    def resize(self, *args):
        """
        resize(pmt_vector_cdouble self, std::vector< std::complex< double > >::size_type new_size)
        resize(pmt_vector_cdouble self, std::vector< std::complex< double > >::size_type new_size, std::vector< std::complex< double > >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_cdouble_resize(self, *args)

    def insert(self, *args):
        """
        insert(pmt_vector_cdouble self, std::vector< std::complex< double > >::iterator pos, std::vector< std::complex< double > >::value_type const & x) -> std::vector< std::complex< double > >::iterator
        insert(pmt_vector_cdouble self, std::vector< std::complex< double > >::iterator pos, std::vector< std::complex< double > >::size_type n, 
            std::vector< std::complex< double > >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_cdouble_insert(self, *args)

    def reserve(self, *args, **kwargs):
        """reserve(pmt_vector_cdouble self, std::vector< std::complex< double > >::size_type n)"""
        return _pmt_swig.pmt_vector_cdouble_reserve(self, *args, **kwargs)

    def capacity(self):
        """capacity(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::size_type"""
        return _pmt_swig.pmt_vector_cdouble_capacity(self)

    __swig_destroy__ = _pmt_swig.delete_pmt_vector_cdouble
    __del__ = lambda self : None;
pmt_vector_cdouble_swigregister = _pmt_swig.pmt_vector_cdouble_swigregister
pmt_vector_cdouble_swigregister(pmt_vector_cdouble)

class swig_int_ptr(object):
    """Proxy of C++ boost::intrusive_ptr<(pmt::pmt_base)> 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): 
        """__init__(boost::intrusive_ptr<(pmt::pmt_base)> self) -> swig_int_ptr"""
        this = _pmt_swig.new_swig_int_ptr()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pmt_swig.delete_swig_int_ptr
    __del__ = lambda self : None;
swig_int_ptr_swigregister = _pmt_swig.swig_int_ptr_swigregister
swig_int_ptr_swigregister(swig_int_ptr)

swig_int_ptr.__repr__ = lambda self: write_string(self)


def get_PMT_NIL():
  """get_PMT_NIL() -> swig_int_ptr"""
  return _pmt_swig.get_PMT_NIL()

def is_bool(*args, **kwargs):
  """is_bool(swig_int_ptr obj) -> bool"""
  return _pmt_swig.is_bool(*args, **kwargs)

def is_true(*args, **kwargs):
  """is_true(swig_int_ptr obj) -> bool"""
  return _pmt_swig.is_true(*args, **kwargs)

def is_false(*args, **kwargs):
  """is_false(swig_int_ptr obj) -> bool"""
  return _pmt_swig.is_false(*args, **kwargs)

def from_bool(*args, **kwargs):
  """from_bool(bool val) -> swig_int_ptr"""
  return _pmt_swig.from_bool(*args, **kwargs)

def to_bool(*args, **kwargs):
  """to_bool(swig_int_ptr val) -> bool"""
  return _pmt_swig.to_bool(*args, **kwargs)

def is_symbol(*args, **kwargs):
  """is_symbol(swig_int_ptr obj) -> bool"""
  return _pmt_swig.is_symbol(*args, **kwargs)

def string_to_symbol(*args, **kwargs):
  """string_to_symbol(std::string const & s) -> swig_int_ptr"""
  return _pmt_swig.string_to_symbol(*args, **kwargs)

def intern(*args, **kwargs):
  """intern(std::string const & s) -> swig_int_ptr"""
  return _pmt_swig.intern(*args, **kwargs)

def symbol_to_string(*args, **kwargs):
  """symbol_to_string(swig_int_ptr sym) -> std::string const"""
  return _pmt_swig.symbol_to_string(*args, **kwargs)

def is_number(*args, **kwargs):
  """is_number(swig_int_ptr obj) -> bool"""
  return _pmt_swig.is_number(*args, **kwargs)

def is_integer(*args, **kwargs):
  """is_integer(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_integer(*args, **kwargs)

def from_long(*args, **kwargs):
  """from_long(long x) -> swig_int_ptr"""
  return _pmt_swig.from_long(*args, **kwargs)

def to_long(*args, **kwargs):
  """to_long(swig_int_ptr x) -> long"""
  return _pmt_swig.to_long(*args, **kwargs)

def is_uint64(*args, **kwargs):
  """is_uint64(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_uint64(*args, **kwargs)

def from_uint64(*args, **kwargs):
  """from_uint64(uint64_t x) -> swig_int_ptr"""
  return _pmt_swig.from_uint64(*args, **kwargs)

def to_uint64(*args, **kwargs):
  """to_uint64(swig_int_ptr x) -> uint64_t"""
  return _pmt_swig.to_uint64(*args, **kwargs)

def is_real(*args, **kwargs):
  """is_real(swig_int_ptr obj) -> bool"""
  return _pmt_swig.is_real(*args, **kwargs)

def from_double(*args, **kwargs):
  """from_double(double x) -> swig_int_ptr"""
  return _pmt_swig.from_double(*args, **kwargs)

def to_double(*args, **kwargs):
  """to_double(swig_int_ptr x) -> double"""
  return _pmt_swig.to_double(*args, **kwargs)

def is_complex(*args, **kwargs):
  """is_complex(swig_int_ptr obj) -> bool"""
  return _pmt_swig.is_complex(*args, **kwargs)

def make_rectangular(*args, **kwargs):
  """make_rectangular(double re, double im) -> swig_int_ptr"""
  return _pmt_swig.make_rectangular(*args, **kwargs)

def from_complex(*args, **kwargs):
  """from_complex(std::complex< double > const & z) -> swig_int_ptr"""
  return _pmt_swig.from_complex(*args, **kwargs)

def to_complex(*args, **kwargs):
  """to_complex(swig_int_ptr z) -> std::complex< double >"""
  return _pmt_swig.to_complex(*args, **kwargs)

def is_null(*args, **kwargs):
  """is_null(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_null(*args, **kwargs)

def is_pair(*args, **kwargs):
  """is_pair(swig_int_ptr obj) -> bool"""
  return _pmt_swig.is_pair(*args, **kwargs)

def cons(*args, **kwargs):
  """cons(swig_int_ptr x, swig_int_ptr y) -> swig_int_ptr"""
  return _pmt_swig.cons(*args, **kwargs)

def car(*args, **kwargs):
  """car(swig_int_ptr pair) -> swig_int_ptr"""
  return _pmt_swig.car(*args, **kwargs)

def cdr(*args, **kwargs):
  """cdr(swig_int_ptr pair) -> swig_int_ptr"""
  return _pmt_swig.cdr(*args, **kwargs)

def set_car(*args, **kwargs):
  """set_car(swig_int_ptr pair, swig_int_ptr value)"""
  return _pmt_swig.set_car(*args, **kwargs)

def set_cdr(*args, **kwargs):
  """set_cdr(swig_int_ptr pair, swig_int_ptr value)"""
  return _pmt_swig.set_cdr(*args, **kwargs)

def caar(*args, **kwargs):
  """caar(swig_int_ptr pair) -> swig_int_ptr"""
  return _pmt_swig.caar(*args, **kwargs)

def cadr(*args, **kwargs):
  """cadr(swig_int_ptr pair) -> swig_int_ptr"""
  return _pmt_swig.cadr(*args, **kwargs)

def cdar(*args, **kwargs):
  """cdar(swig_int_ptr pair) -> swig_int_ptr"""
  return _pmt_swig.cdar(*args, **kwargs)

def cddr(*args, **kwargs):
  """cddr(swig_int_ptr pair) -> swig_int_ptr"""
  return _pmt_swig.cddr(*args, **kwargs)

def caddr(*args, **kwargs):
  """caddr(swig_int_ptr pair) -> swig_int_ptr"""
  return _pmt_swig.caddr(*args, **kwargs)

def cadddr(*args, **kwargs):
  """cadddr(swig_int_ptr pair) -> swig_int_ptr"""
  return _pmt_swig.cadddr(*args, **kwargs)

def is_tuple(*args, **kwargs):
  """is_tuple(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_tuple(*args, **kwargs)

def make_tuple(*args):
  """
    make_tuple() -> swig_int_ptr
    make_tuple(swig_int_ptr e0) -> swig_int_ptr
    make_tuple(swig_int_ptr e0, swig_int_ptr e1) -> swig_int_ptr
    make_tuple(swig_int_ptr e0, swig_int_ptr e1, swig_int_ptr e2) -> swig_int_ptr
    make_tuple(swig_int_ptr e0, swig_int_ptr e1, swig_int_ptr e2, swig_int_ptr e3) -> swig_int_ptr
    make_tuple(swig_int_ptr e0, swig_int_ptr e1, swig_int_ptr e2, swig_int_ptr e3, swig_int_ptr e4) -> swig_int_ptr
    make_tuple(swig_int_ptr e0, swig_int_ptr e1, swig_int_ptr e2, swig_int_ptr e3, swig_int_ptr e4, 
        swig_int_ptr e5) -> swig_int_ptr
    make_tuple(swig_int_ptr e0, swig_int_ptr e1, swig_int_ptr e2, swig_int_ptr e3, swig_int_ptr e4, 
        swig_int_ptr e5, swig_int_ptr e6) -> swig_int_ptr
    make_tuple(swig_int_ptr e0, swig_int_ptr e1, swig_int_ptr e2, swig_int_ptr e3, swig_int_ptr e4, 
        swig_int_ptr e5, swig_int_ptr e6, swig_int_ptr e7) -> swig_int_ptr
    make_tuple(swig_int_ptr e0, swig_int_ptr e1, swig_int_ptr e2, swig_int_ptr e3, swig_int_ptr e4, 
        swig_int_ptr e5, swig_int_ptr e6, swig_int_ptr e7, swig_int_ptr e8) -> swig_int_ptr
    make_tuple(swig_int_ptr e0, swig_int_ptr e1, swig_int_ptr e2, swig_int_ptr e3, swig_int_ptr e4, 
        swig_int_ptr e5, swig_int_ptr e6, swig_int_ptr e7, swig_int_ptr e8, swig_int_ptr e9) -> swig_int_ptr
    """
  return _pmt_swig.make_tuple(*args)

def to_tuple(*args, **kwargs):
  """to_tuple(swig_int_ptr x) -> swig_int_ptr"""
  return _pmt_swig.to_tuple(*args, **kwargs)

def tuple_ref(*args, **kwargs):
  """tuple_ref(swig_int_ptr tuple, size_t k) -> swig_int_ptr"""
  return _pmt_swig.tuple_ref(*args, **kwargs)

def is_vector(*args, **kwargs):
  """is_vector(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_vector(*args, **kwargs)

def make_vector(*args, **kwargs):
  """make_vector(size_t k, swig_int_ptr fill) -> swig_int_ptr"""
  return _pmt_swig.make_vector(*args, **kwargs)

def vector_ref(*args, **kwargs):
  """vector_ref(swig_int_ptr vector, size_t k) -> swig_int_ptr"""
  return _pmt_swig.vector_ref(*args, **kwargs)

def vector_set(*args, **kwargs):
  """vector_set(swig_int_ptr vector, size_t k, swig_int_ptr obj)"""
  return _pmt_swig.vector_set(*args, **kwargs)

def vector_fill(*args, **kwargs):
  """vector_fill(swig_int_ptr vector, swig_int_ptr fill)"""
  return _pmt_swig.vector_fill(*args, **kwargs)

def is_blob(*args, **kwargs):
  """is_blob(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_blob(*args, **kwargs)

def make_blob(*args, **kwargs):
  """make_blob(void const * buf, size_t len) -> swig_int_ptr"""
  return _pmt_swig.make_blob(*args, **kwargs)

def blob_data(*args, **kwargs):
  """blob_data(swig_int_ptr blob) -> void const *"""
  return _pmt_swig.blob_data(*args, **kwargs)

def blob_length(*args, **kwargs):
  """blob_length(swig_int_ptr blob) -> size_t"""
  return _pmt_swig.blob_length(*args, **kwargs)

def is_uniform_vector(*args, **kwargs):
  """is_uniform_vector(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_uniform_vector(*args, **kwargs)

def is_u8vector(*args, **kwargs):
  """is_u8vector(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_u8vector(*args, **kwargs)

def is_s8vector(*args, **kwargs):
  """is_s8vector(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_s8vector(*args, **kwargs)

def is_u16vector(*args, **kwargs):
  """is_u16vector(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_u16vector(*args, **kwargs)

def is_s16vector(*args, **kwargs):
  """is_s16vector(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_s16vector(*args, **kwargs)

def is_u32vector(*args, **kwargs):
  """is_u32vector(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_u32vector(*args, **kwargs)

def is_s32vector(*args, **kwargs):
  """is_s32vector(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_s32vector(*args, **kwargs)

def is_u64vector(*args, **kwargs):
  """is_u64vector(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_u64vector(*args, **kwargs)

def is_s64vector(*args, **kwargs):
  """is_s64vector(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_s64vector(*args, **kwargs)

def is_f32vector(*args, **kwargs):
  """is_f32vector(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_f32vector(*args, **kwargs)

def is_f64vector(*args, **kwargs):
  """is_f64vector(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_f64vector(*args, **kwargs)

def is_c32vector(*args, **kwargs):
  """is_c32vector(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_c32vector(*args, **kwargs)

def is_c64vector(*args, **kwargs):
  """is_c64vector(swig_int_ptr x) -> bool"""
  return _pmt_swig.is_c64vector(*args, **kwargs)

def uniform_vector_itemsize(*args, **kwargs):
  """uniform_vector_itemsize(swig_int_ptr x) -> size_t"""
  return _pmt_swig.uniform_vector_itemsize(*args, **kwargs)

def make_u8vector(*args, **kwargs):
  """make_u8vector(size_t k, uint8_t fill) -> swig_int_ptr"""
  return _pmt_swig.make_u8vector(*args, **kwargs)

def make_s8vector(*args, **kwargs):
  """make_s8vector(size_t k, int8_t fill) -> swig_int_ptr"""
  return _pmt_swig.make_s8vector(*args, **kwargs)

def make_u16vector(*args, **kwargs):
  """make_u16vector(size_t k, uint16_t fill) -> swig_int_ptr"""
  return _pmt_swig.make_u16vector(*args, **kwargs)

def make_s16vector(*args, **kwargs):
  """make_s16vector(size_t k, int16_t fill) -> swig_int_ptr"""
  return _pmt_swig.make_s16vector(*args, **kwargs)

def make_u32vector(*args, **kwargs):
  """make_u32vector(size_t k, uint32_t fill) -> swig_int_ptr"""
  return _pmt_swig.make_u32vector(*args, **kwargs)

def make_s32vector(*args, **kwargs):
  """make_s32vector(size_t k, int32_t fill) -> swig_int_ptr"""
  return _pmt_swig.make_s32vector(*args, **kwargs)

def make_u64vector(*args, **kwargs):
  """make_u64vector(size_t k, uint64_t fill) -> swig_int_ptr"""
  return _pmt_swig.make_u64vector(*args, **kwargs)

def make_s64vector(*args, **kwargs):
  """make_s64vector(size_t k, int64_t fill) -> swig_int_ptr"""
  return _pmt_swig.make_s64vector(*args, **kwargs)

def make_f32vector(*args, **kwargs):
  """make_f32vector(size_t k, float fill) -> swig_int_ptr"""
  return _pmt_swig.make_f32vector(*args, **kwargs)

def make_f64vector(*args, **kwargs):
  """make_f64vector(size_t k, double fill) -> swig_int_ptr"""
  return _pmt_swig.make_f64vector(*args, **kwargs)

def make_c32vector(*args, **kwargs):
  """make_c32vector(size_t k, std::complex< float > fill) -> swig_int_ptr"""
  return _pmt_swig.make_c32vector(*args, **kwargs)

def make_c64vector(*args, **kwargs):
  """make_c64vector(size_t k, std::complex< double > fill) -> swig_int_ptr"""
  return _pmt_swig.make_c64vector(*args, **kwargs)

def init_u8vector(*args, **kwargs):
  """init_u8vector(size_t k, pmt_vector_uint8 data) -> swig_int_ptr"""
  return _pmt_swig.init_u8vector(*args, **kwargs)

def init_s8vector(*args, **kwargs):
  """init_s8vector(size_t k, pmt_vector_int8 data) -> swig_int_ptr"""
  return _pmt_swig.init_s8vector(*args, **kwargs)

def init_u16vector(*args, **kwargs):
  """init_u16vector(size_t k, pmt_vector_uint16 data) -> swig_int_ptr"""
  return _pmt_swig.init_u16vector(*args, **kwargs)

def init_s16vector(*args, **kwargs):
  """init_s16vector(size_t k, pmt_vector_int16 data) -> swig_int_ptr"""
  return _pmt_swig.init_s16vector(*args, **kwargs)

def init_u32vector(*args, **kwargs):
  """init_u32vector(size_t k, pmt_vector_uint32 data) -> swig_int_ptr"""
  return _pmt_swig.init_u32vector(*args, **kwargs)

def init_s32vector(*args, **kwargs):
  """init_s32vector(size_t k, pmt_vector_int32 data) -> swig_int_ptr"""
  return _pmt_swig.init_s32vector(*args, **kwargs)

def init_f32vector(*args, **kwargs):
  """init_f32vector(size_t k, pmt_vector_float data) -> swig_int_ptr"""
  return _pmt_swig.init_f32vector(*args, **kwargs)

def init_f64vector(*args, **kwargs):
  """init_f64vector(size_t k, pmt_vector_double data) -> swig_int_ptr"""
  return _pmt_swig.init_f64vector(*args, **kwargs)

def init_c32vector(*args, **kwargs):
  """init_c32vector(size_t k, pmt_vector_cfloat data) -> swig_int_ptr"""
  return _pmt_swig.init_c32vector(*args, **kwargs)

def init_c64vector(*args, **kwargs):
  """init_c64vector(size_t k, pmt_vector_cdouble data) -> swig_int_ptr"""
  return _pmt_swig.init_c64vector(*args, **kwargs)

def u8vector_ref(*args, **kwargs):
  """u8vector_ref(swig_int_ptr v, size_t k) -> uint8_t"""
  return _pmt_swig.u8vector_ref(*args, **kwargs)

def s8vector_ref(*args, **kwargs):
  """s8vector_ref(swig_int_ptr v, size_t k) -> int8_t"""
  return _pmt_swig.s8vector_ref(*args, **kwargs)

def u16vector_ref(*args, **kwargs):
  """u16vector_ref(swig_int_ptr v, size_t k) -> uint16_t"""
  return _pmt_swig.u16vector_ref(*args, **kwargs)

def s16vector_ref(*args, **kwargs):
  """s16vector_ref(swig_int_ptr v, size_t k) -> int16_t"""
  return _pmt_swig.s16vector_ref(*args, **kwargs)

def u32vector_ref(*args, **kwargs):
  """u32vector_ref(swig_int_ptr v, size_t k) -> uint32_t"""
  return _pmt_swig.u32vector_ref(*args, **kwargs)

def s32vector_ref(*args, **kwargs):
  """s32vector_ref(swig_int_ptr v, size_t k) -> int32_t"""
  return _pmt_swig.s32vector_ref(*args, **kwargs)

def u64vector_ref(*args, **kwargs):
  """u64vector_ref(swig_int_ptr v, size_t k) -> uint64_t"""
  return _pmt_swig.u64vector_ref(*args, **kwargs)

def s64vector_ref(*args, **kwargs):
  """s64vector_ref(swig_int_ptr v, size_t k) -> int64_t"""
  return _pmt_swig.s64vector_ref(*args, **kwargs)

def f32vector_ref(*args, **kwargs):
  """f32vector_ref(swig_int_ptr v, size_t k) -> float"""
  return _pmt_swig.f32vector_ref(*args, **kwargs)

def f64vector_ref(*args, **kwargs):
  """f64vector_ref(swig_int_ptr v, size_t k) -> double"""
  return _pmt_swig.f64vector_ref(*args, **kwargs)

def c32vector_ref(*args, **kwargs):
  """c32vector_ref(swig_int_ptr v, size_t k) -> std::complex< float >"""
  return _pmt_swig.c32vector_ref(*args, **kwargs)

def c64vector_ref(*args, **kwargs):
  """c64vector_ref(swig_int_ptr v, size_t k) -> std::complex< double >"""
  return _pmt_swig.c64vector_ref(*args, **kwargs)

def u8vector_set(*args, **kwargs):
  """u8vector_set(swig_int_ptr v, size_t k, uint8_t x)"""
  return _pmt_swig.u8vector_set(*args, **kwargs)

def s8vector_set(*args, **kwargs):
  """s8vector_set(swig_int_ptr v, size_t k, int8_t x)"""
  return _pmt_swig.s8vector_set(*args, **kwargs)

def u16vector_set(*args, **kwargs):
  """u16vector_set(swig_int_ptr v, size_t k, uint16_t x)"""
  return _pmt_swig.u16vector_set(*args, **kwargs)

def s16vector_set(*args, **kwargs):
  """s16vector_set(swig_int_ptr v, size_t k, int16_t x)"""
  return _pmt_swig.s16vector_set(*args, **kwargs)

def u32vector_set(*args, **kwargs):
  """u32vector_set(swig_int_ptr v, size_t k, uint32_t x)"""
  return _pmt_swig.u32vector_set(*args, **kwargs)

def s32vector_set(*args, **kwargs):
  """s32vector_set(swig_int_ptr v, size_t k, int32_t x)"""
  return _pmt_swig.s32vector_set(*args, **kwargs)

def u64vector_set(*args, **kwargs):
  """u64vector_set(swig_int_ptr v, size_t k, uint64_t x)"""
  return _pmt_swig.u64vector_set(*args, **kwargs)

def s64vector_set(*args, **kwargs):
  """s64vector_set(swig_int_ptr v, size_t k, int64_t x)"""
  return _pmt_swig.s64vector_set(*args, **kwargs)

def f32vector_set(*args, **kwargs):
  """f32vector_set(swig_int_ptr v, size_t k, float x)"""
  return _pmt_swig.f32vector_set(*args, **kwargs)

def f64vector_set(*args, **kwargs):
  """f64vector_set(swig_int_ptr v, size_t k, double x)"""
  return _pmt_swig.f64vector_set(*args, **kwargs)

def c32vector_set(*args, **kwargs):
  """c32vector_set(swig_int_ptr v, size_t k, std::complex< float > x)"""
  return _pmt_swig.c32vector_set(*args, **kwargs)

def c64vector_set(*args, **kwargs):
  """c64vector_set(swig_int_ptr v, size_t k, std::complex< double > x)"""
  return _pmt_swig.c64vector_set(*args, **kwargs)

def uniform_vector_elements(*args, **kwargs):
  """uniform_vector_elements(swig_int_ptr v, size_t & len) -> void const *"""
  return _pmt_swig.uniform_vector_elements(*args, **kwargs)

def u8vector_elements(*args, **kwargs):
  """u8vector_elements(swig_int_ptr v) -> pmt_vector_uint8"""
  return _pmt_swig.u8vector_elements(*args, **kwargs)

def s8vector_elements(*args, **kwargs):
  """s8vector_elements(swig_int_ptr v) -> pmt_vector_int8"""
  return _pmt_swig.s8vector_elements(*args, **kwargs)

def u16vector_elements(*args, **kwargs):
  """u16vector_elements(swig_int_ptr v) -> pmt_vector_uint16"""
  return _pmt_swig.u16vector_elements(*args, **kwargs)

def s16vector_elements(*args, **kwargs):
  """s16vector_elements(swig_int_ptr v) -> pmt_vector_int16"""
  return _pmt_swig.s16vector_elements(*args, **kwargs)

def u32vector_elements(*args, **kwargs):
  """u32vector_elements(swig_int_ptr v) -> pmt_vector_uint32"""
  return _pmt_swig.u32vector_elements(*args, **kwargs)

def s32vector_elements(*args, **kwargs):
  """s32vector_elements(swig_int_ptr v) -> pmt_vector_int32"""
  return _pmt_swig.s32vector_elements(*args, **kwargs)

def f32vector_elements(*args, **kwargs):
  """f32vector_elements(swig_int_ptr v) -> pmt_vector_float"""
  return _pmt_swig.f32vector_elements(*args, **kwargs)

def f64vector_elements(*args, **kwargs):
  """f64vector_elements(swig_int_ptr v) -> pmt_vector_double"""
  return _pmt_swig.f64vector_elements(*args, **kwargs)

def c32vector_elements(*args, **kwargs):
  """c32vector_elements(swig_int_ptr v) -> pmt_vector_cfloat"""
  return _pmt_swig.c32vector_elements(*args, **kwargs)

def c64vector_elements(*args, **kwargs):
  """c64vector_elements(swig_int_ptr v) -> pmt_vector_cdouble"""
  return _pmt_swig.c64vector_elements(*args, **kwargs)

def is_dict(*args, **kwargs):
  """is_dict(swig_int_ptr obj) -> bool"""
  return _pmt_swig.is_dict(*args, **kwargs)

def make_dict():
  """make_dict() -> swig_int_ptr"""
  return _pmt_swig.make_dict()

def dict_add(*args, **kwargs):
  """dict_add(swig_int_ptr dict, swig_int_ptr key, swig_int_ptr value) -> swig_int_ptr"""
  return _pmt_swig.dict_add(*args, **kwargs)

def dict_delete(*args, **kwargs):
  """dict_delete(swig_int_ptr dict, swig_int_ptr key) -> swig_int_ptr"""
  return _pmt_swig.dict_delete(*args, **kwargs)

def dict_has_key(*args, **kwargs):
  """dict_has_key(swig_int_ptr dict, swig_int_ptr key) -> bool"""
  return _pmt_swig.dict_has_key(*args, **kwargs)

def dict_ref(*args, **kwargs):
  """dict_ref(swig_int_ptr dict, swig_int_ptr key, swig_int_ptr not_found) -> swig_int_ptr"""
  return _pmt_swig.dict_ref(*args, **kwargs)

def dict_items(*args, **kwargs):
  """dict_items(swig_int_ptr dict) -> swig_int_ptr"""
  return _pmt_swig.dict_items(*args, **kwargs)

def dict_keys(*args, **kwargs):
  """dict_keys(swig_int_ptr dict) -> swig_int_ptr"""
  return _pmt_swig.dict_keys(*args, **kwargs)

def dict_update(*args, **kwargs):
  """dict_update(swig_int_ptr dict1, swig_int_ptr dict2) -> swig_int_ptr"""
  return _pmt_swig.dict_update(*args, **kwargs)

def dict_values(*args, **kwargs):
  """dict_values(swig_int_ptr dict) -> swig_int_ptr"""
  return _pmt_swig.dict_values(*args, **kwargs)

def is_any(*args, **kwargs):
  """is_any(swig_int_ptr obj) -> bool"""
  return _pmt_swig.is_any(*args, **kwargs)

def make_any(*args, **kwargs):
  """make_any(boost::any const & any) -> swig_int_ptr"""
  return _pmt_swig.make_any(*args, **kwargs)

def any_ref(*args, **kwargs):
  """any_ref(swig_int_ptr obj) -> boost::any"""
  return _pmt_swig.any_ref(*args, **kwargs)

def any_set(*args, **kwargs):
  """any_set(swig_int_ptr obj, boost::any const & any)"""
  return _pmt_swig.any_set(*args, **kwargs)

def is_msg_accepter(*args, **kwargs):
  """is_msg_accepter(swig_int_ptr obj) -> bool"""
  return _pmt_swig.is_msg_accepter(*args, **kwargs)

def make_msg_accepter(*args, **kwargs):
  """make_msg_accepter(boost::shared_ptr< gr::messages::msg_accepter > ma) -> swig_int_ptr"""
  return _pmt_swig.make_msg_accepter(*args, **kwargs)

def msg_accepter_ref(*args, **kwargs):
  """msg_accepter_ref(swig_int_ptr obj) -> boost::shared_ptr< gr::messages::msg_accepter >"""
  return _pmt_swig.msg_accepter_ref(*args, **kwargs)

def eq(*args, **kwargs):
  """eq(swig_int_ptr x, swig_int_ptr y) -> bool"""
  return _pmt_swig.eq(*args, **kwargs)

def eqv(*args, **kwargs):
  """eqv(swig_int_ptr x, swig_int_ptr y) -> bool"""
  return _pmt_swig.eqv(*args, **kwargs)

def equal(*args, **kwargs):
  """equal(swig_int_ptr x, swig_int_ptr y) -> bool"""
  return _pmt_swig.equal(*args, **kwargs)

def length(*args, **kwargs):
  """length(swig_int_ptr v) -> size_t"""
  return _pmt_swig.length(*args, **kwargs)

def assq(*args, **kwargs):
  """assq(swig_int_ptr obj, swig_int_ptr alist) -> swig_int_ptr"""
  return _pmt_swig.assq(*args, **kwargs)

def assv(*args, **kwargs):
  """assv(swig_int_ptr obj, swig_int_ptr alist) -> swig_int_ptr"""
  return _pmt_swig.assv(*args, **kwargs)

def assoc(*args, **kwargs):
  """assoc(swig_int_ptr obj, swig_int_ptr alist) -> swig_int_ptr"""
  return _pmt_swig.assoc(*args, **kwargs)

def map(*args, **kwargs):
  """map(pmt::pmt_t (*)(pmt::pmt_t const &) proc, swig_int_ptr list) -> swig_int_ptr"""
  return _pmt_swig.map(*args, **kwargs)

def reverse(*args, **kwargs):
  """reverse(swig_int_ptr list) -> swig_int_ptr"""
  return _pmt_swig.reverse(*args, **kwargs)

def reverse_x(*args, **kwargs):
  """reverse_x(swig_int_ptr list) -> swig_int_ptr"""
  return _pmt_swig.reverse_x(*args, **kwargs)

def acons(*args, **kwargs):
  """acons(swig_int_ptr x, swig_int_ptr y, swig_int_ptr a) -> swig_int_ptr"""
  return _pmt_swig.acons(*args, **kwargs)

def nth(*args, **kwargs):
  """nth(size_t n, swig_int_ptr list) -> swig_int_ptr"""
  return _pmt_swig.nth(*args, **kwargs)

def nthcdr(*args, **kwargs):
  """nthcdr(size_t n, swig_int_ptr list) -> swig_int_ptr"""
  return _pmt_swig.nthcdr(*args, **kwargs)

def memq(*args, **kwargs):
  """memq(swig_int_ptr obj, swig_int_ptr list) -> swig_int_ptr"""
  return _pmt_swig.memq(*args, **kwargs)

def memv(*args, **kwargs):
  """memv(swig_int_ptr obj, swig_int_ptr list) -> swig_int_ptr"""
  return _pmt_swig.memv(*args, **kwargs)

def member(*args, **kwargs):
  """member(swig_int_ptr obj, swig_int_ptr list) -> swig_int_ptr"""
  return _pmt_swig.member(*args, **kwargs)

def subsetp(*args, **kwargs):
  """subsetp(swig_int_ptr list1, swig_int_ptr list2) -> bool"""
  return _pmt_swig.subsetp(*args, **kwargs)

def list1(*args, **kwargs):
  """list1(swig_int_ptr x1) -> swig_int_ptr"""
  return _pmt_swig.list1(*args, **kwargs)

def list2(*args, **kwargs):
  """list2(swig_int_ptr x1, swig_int_ptr x2) -> swig_int_ptr"""
  return _pmt_swig.list2(*args, **kwargs)

def list3(*args, **kwargs):
  """list3(swig_int_ptr x1, swig_int_ptr x2, swig_int_ptr x3) -> swig_int_ptr"""
  return _pmt_swig.list3(*args, **kwargs)

def list4(*args, **kwargs):
  """list4(swig_int_ptr x1, swig_int_ptr x2, swig_int_ptr x3, swig_int_ptr x4) -> swig_int_ptr"""
  return _pmt_swig.list4(*args, **kwargs)

def list5(*args, **kwargs):
  """list5(swig_int_ptr x1, swig_int_ptr x2, swig_int_ptr x3, swig_int_ptr x4, swig_int_ptr x5) -> swig_int_ptr"""
  return _pmt_swig.list5(*args, **kwargs)

def list6(*args, **kwargs):
  """
    list6(swig_int_ptr x1, swig_int_ptr x2, swig_int_ptr x3, swig_int_ptr x4, swig_int_ptr x5, 
        swig_int_ptr x6) -> swig_int_ptr
    """
  return _pmt_swig.list6(*args, **kwargs)

def list_add(*args, **kwargs):
  """list_add(swig_int_ptr list, swig_int_ptr item) -> swig_int_ptr"""
  return _pmt_swig.list_add(*args, **kwargs)

def list_rm(*args, **kwargs):
  """list_rm(swig_int_ptr list, swig_int_ptr item) -> swig_int_ptr"""
  return _pmt_swig.list_rm(*args, **kwargs)

def list_has(*args, **kwargs):
  """list_has(swig_int_ptr list, swig_int_ptr item) -> bool"""
  return _pmt_swig.list_has(*args, **kwargs)

def is_eof_object(*args, **kwargs):
  """is_eof_object(swig_int_ptr obj) -> bool"""
  return _pmt_swig.is_eof_object(*args, **kwargs)

def read(*args, **kwargs):
  """read(std::istream & port) -> swig_int_ptr"""
  return _pmt_swig.read(*args, **kwargs)

def write(*args, **kwargs):
  """write(swig_int_ptr obj, std::ostream & port)"""
  return _pmt_swig.write(*args, **kwargs)

def write_string(*args, **kwargs):
  """write_string(swig_int_ptr obj) -> std::string"""
  return _pmt_swig.write_string(*args, **kwargs)

def serialize(*args, **kwargs):
  """serialize(swig_int_ptr obj, std::streambuf & sink) -> bool"""
  return _pmt_swig.serialize(*args, **kwargs)

def deserialize(*args, **kwargs):
  """deserialize(std::streambuf & source) -> swig_int_ptr"""
  return _pmt_swig.deserialize(*args, **kwargs)

def dump_sizeof():
  """dump_sizeof()"""
  return _pmt_swig.dump_sizeof()

def serialize_str(*args, **kwargs):
  """serialize_str(swig_int_ptr obj) -> std::string"""
  return _pmt_swig.serialize_str(*args, **kwargs)

def deserialize_str(*args, **kwargs):
  """deserialize_str(std::string str) -> swig_int_ptr"""
  return _pmt_swig.deserialize_str(*args, **kwargs)

cvar = _pmt_swig.cvar
PMT_T = cvar.PMT_T
PMT_F = cvar.PMT_F
PMT_EOF = cvar.PMT_EOF

