# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.5
#
# 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):
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


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


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

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


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

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



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


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, x):
        """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _pmt_swig.SwigPyIterator_distance(self, x)


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


    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, n):
        """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pmt_swig.SwigPyIterator_advance(self, n)


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


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


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


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


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


    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, i, j):
        """__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, i, j)


    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)"""
        return _pmt_swig.pmt_vector_int8___setslice__(self, *args, **kwargs)


    def __delslice__(self, i, j):
        """__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, i, j)


    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, x):
        """append(pmt_vector_int8 self, std::vector< signed char >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int8_append(self, x)


    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, v):
        """swap(pmt_vector_int8 self, pmt_vector_int8 v)"""
        return _pmt_swig.pmt_vector_int8_swap(self, v)


    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, x):
        """push_back(pmt_vector_int8 self, std::vector< signed char >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int8_push_back(self, x)


    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, n, x):
        """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, n, x)


    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, n):
        """reserve(pmt_vector_int8 self, std::vector< signed char >::size_type n)"""
        return _pmt_swig.pmt_vector_int8_reserve(self, n)


    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, i, j):
        """__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, i, j)


    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)"""
        return _pmt_swig.pmt_vector_uint8___setslice__(self, *args, **kwargs)


    def __delslice__(self, i, j):
        """__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, i, j)


    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, x):
        """append(pmt_vector_uint8 self, std::vector< unsigned char >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint8_append(self, x)


    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, v):
        """swap(pmt_vector_uint8 self, pmt_vector_uint8 v)"""
        return _pmt_swig.pmt_vector_uint8_swap(self, v)


    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, x):
        """push_back(pmt_vector_uint8 self, std::vector< unsigned char >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint8_push_back(self, x)


    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, n, x):
        """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, n, x)


    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, n):
        """reserve(pmt_vector_uint8 self, std::vector< unsigned char >::size_type n)"""
        return _pmt_swig.pmt_vector_uint8_reserve(self, n)


    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, i, j):
        """__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, i, j)


    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)"""
        return _pmt_swig.pmt_vector_int16___setslice__(self, *args, **kwargs)


    def __delslice__(self, i, j):
        """__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, i, j)


    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, x):
        """append(pmt_vector_int16 self, std::vector< short >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int16_append(self, x)


    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, v):
        """swap(pmt_vector_int16 self, pmt_vector_int16 v)"""
        return _pmt_swig.pmt_vector_int16_swap(self, v)


    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, x):
        """push_back(pmt_vector_int16 self, std::vector< short >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int16_push_back(self, x)


    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, n, x):
        """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, n, x)


    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, n):
        """reserve(pmt_vector_int16 self, std::vector< short >::size_type n)"""
        return _pmt_swig.pmt_vector_int16_reserve(self, n)


    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, i, j):
        """__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, i, j)


    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)"""
        return _pmt_swig.pmt_vector_uint16___setslice__(self, *args, **kwargs)


    def __delslice__(self, i, j):
        """__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, i, j)


    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, x):
        """append(pmt_vector_uint16 self, std::vector< unsigned short >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint16_append(self, x)


    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, v):
        """swap(pmt_vector_uint16 self, pmt_vector_uint16 v)"""
        return _pmt_swig.pmt_vector_uint16_swap(self, v)


    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, x):
        """push_back(pmt_vector_uint16 self, std::vector< unsigned short >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint16_push_back(self, x)


    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, n, x):
        """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, n, x)


    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, n):
        """reserve(pmt_vector_uint16 self, std::vector< unsigned short >::size_type n)"""
        return _pmt_swig.pmt_vector_uint16_reserve(self, n)


    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, i, j):
        """__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, i, j)


    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)"""
        return _pmt_swig.pmt_vector_int32___setslice__(self, *args, **kwargs)


    def __delslice__(self, i, j):
        """__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, i, j)


    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, x):
        """append(pmt_vector_int32 self, std::vector< int >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int32_append(self, x)


    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, v):
        """swap(pmt_vector_int32 self, pmt_vector_int32 v)"""
        return _pmt_swig.pmt_vector_int32_swap(self, v)


    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, x):
        """push_back(pmt_vector_int32 self, std::vector< int >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int32_push_back(self, x)


    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, n, x):
        """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, n, x)


    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, n):
        """reserve(pmt_vector_int32 self, std::vector< int >::size_type n)"""
        return _pmt_swig.pmt_vector_int32_reserve(self, n)


    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, i, j):
        """__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, i, j)


    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)"""
        return _pmt_swig.pmt_vector_uint32___setslice__(self, *args, **kwargs)


    def __delslice__(self, i, j):
        """__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, i, j)


    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, x):
        """append(pmt_vector_uint32 self, std::vector< unsigned int >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint32_append(self, x)


    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, v):
        """swap(pmt_vector_uint32 self, pmt_vector_uint32 v)"""
        return _pmt_swig.pmt_vector_uint32_swap(self, v)


    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, x):
        """push_back(pmt_vector_uint32 self, std::vector< unsigned int >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint32_push_back(self, x)


    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, n, x):
        """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, n, x)


    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, n):
        """reserve(pmt_vector_uint32 self, std::vector< unsigned int >::size_type n)"""
        return _pmt_swig.pmt_vector_uint32_reserve(self, n)


    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, i, j):
        """__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, i, j)


    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)"""
        return _pmt_swig.pmt_vector_float___setslice__(self, *args, **kwargs)


    def __delslice__(self, i, j):
        """__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, i, j)


    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, x):
        """append(pmt_vector_float self, std::vector< float >::value_type const & x)"""
        return _pmt_swig.pmt_vector_float_append(self, x)


    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, v):
        """swap(pmt_vector_float self, pmt_vector_float v)"""
        return _pmt_swig.pmt_vector_float_swap(self, v)


    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, x):
        """push_back(pmt_vector_float self, std::vector< float >::value_type const & x)"""
        return _pmt_swig.pmt_vector_float_push_back(self, x)


    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, n, x):
        """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, n, x)


    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, n):
        """reserve(pmt_vector_float self, std::vector< float >::size_type n)"""
        return _pmt_swig.pmt_vector_float_reserve(self, n)


    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, i, j):
        """__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, i, j)


    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)"""
        return _pmt_swig.pmt_vector_double___setslice__(self, *args, **kwargs)


    def __delslice__(self, i, j):
        """__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, i, j)


    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, x):
        """append(pmt_vector_double self, std::vector< double >::value_type const & x)"""
        return _pmt_swig.pmt_vector_double_append(self, x)


    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, v):
        """swap(pmt_vector_double self, pmt_vector_double v)"""
        return _pmt_swig.pmt_vector_double_swap(self, v)


    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, x):
        """push_back(pmt_vector_double self, std::vector< double >::value_type const & x)"""
        return _pmt_swig.pmt_vector_double_push_back(self, x)


    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, n, x):
        """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, n, x)


    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, n):
        """reserve(pmt_vector_double self, std::vector< double >::size_type n)"""
        return _pmt_swig.pmt_vector_double_reserve(self, n)


    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, i, j):
        """__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, i, j)


    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)"""
        return _pmt_swig.pmt_vector_cfloat___setslice__(self, *args, **kwargs)


    def __delslice__(self, i, j):
        """__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, i, j)


    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, x):
        """append(pmt_vector_cfloat self, std::vector< std::complex< float > >::value_type const & x)"""
        return _pmt_swig.pmt_vector_cfloat_append(self, x)


    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, v):
        """swap(pmt_vector_cfloat self, pmt_vector_cfloat v)"""
        return _pmt_swig.pmt_vector_cfloat_swap(self, v)


    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, x):
        """push_back(pmt_vector_cfloat self, std::vector< std::complex< float > >::value_type const & x)"""
        return _pmt_swig.pmt_vector_cfloat_push_back(self, x)


    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, n, x):
        """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, n, x)


    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, n):
        """reserve(pmt_vector_cfloat self, std::vector< std::complex< float > >::size_type n)"""
        return _pmt_swig.pmt_vector_cfloat_reserve(self, n)


    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, i, j):
        """__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, i, j)


    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)"""
        return _pmt_swig.pmt_vector_cdouble___setslice__(self, *args, **kwargs)


    def __delslice__(self, i, j):
        """__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, i, j)


    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, x):
        """append(pmt_vector_cdouble self, std::vector< std::complex< double > >::value_type const & x)"""
        return _pmt_swig.pmt_vector_cdouble_append(self, x)


    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, v):
        """swap(pmt_vector_cdouble self, pmt_vector_cdouble v)"""
        return _pmt_swig.pmt_vector_cdouble_swap(self, v)


    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, x):
        """push_back(pmt_vector_cdouble self, std::vector< std::complex< double > >::value_type const & x)"""
        return _pmt_swig.pmt_vector_cdouble_push_back(self, x)


    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, n, x):
        """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, n, x)


    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, n):
        """reserve(pmt_vector_cdouble self, std::vector< std::complex< double > >::size_type n)"""
        return _pmt_swig.pmt_vector_cdouble_reserve(self, n)


    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 get_PMT_T():
    """get_PMT_T() -> swig_int_ptr"""
    return _pmt_swig.get_PMT_T()

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

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

def is_bool(obj):
    """is_bool(swig_int_ptr obj) -> bool"""
    return _pmt_swig.is_bool(obj)

def is_true(obj):
    """is_true(swig_int_ptr obj) -> bool"""
    return _pmt_swig.is_true(obj)

def is_false(obj):
    """is_false(swig_int_ptr obj) -> bool"""
    return _pmt_swig.is_false(obj)

def from_bool(val):
    """from_bool(bool val) -> swig_int_ptr"""
    return _pmt_swig.from_bool(val)

def to_bool(val):
    """to_bool(swig_int_ptr val) -> bool"""
    return _pmt_swig.to_bool(val)

def is_symbol(obj):
    """is_symbol(swig_int_ptr obj) -> bool"""
    return _pmt_swig.is_symbol(obj)

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

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

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

def is_number(obj):
    """is_number(swig_int_ptr obj) -> bool"""
    return _pmt_swig.is_number(obj)

def is_integer(x):
    """is_integer(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_integer(x)

def from_long(x):
    """from_long(long x) -> swig_int_ptr"""
    return _pmt_swig.from_long(x)

def to_long(x):
    """to_long(swig_int_ptr x) -> long"""
    return _pmt_swig.to_long(x)

def is_uint64(x):
    """is_uint64(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_uint64(x)

def from_uint64(x):
    """from_uint64(uint64_t x) -> swig_int_ptr"""
    return _pmt_swig.from_uint64(x)

def to_uint64(x):
    """to_uint64(swig_int_ptr x) -> uint64_t"""
    return _pmt_swig.to_uint64(x)

def is_real(obj):
    """is_real(swig_int_ptr obj) -> bool"""
    return _pmt_swig.is_real(obj)

def from_double(x):
    """from_double(double x) -> swig_int_ptr"""
    return _pmt_swig.from_double(x)

def to_double(x):
    """to_double(swig_int_ptr x) -> double"""
    return _pmt_swig.to_double(x)

def from_float(x):
    """from_float(double x) -> swig_int_ptr"""
    return _pmt_swig.from_float(x)

def to_float(x):
    """to_float(swig_int_ptr x) -> double"""
    return _pmt_swig.to_float(x)

def is_complex(obj):
    """is_complex(swig_int_ptr obj) -> bool"""
    return _pmt_swig.is_complex(obj)

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

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

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

def is_null(x):
    """is_null(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_null(x)

def is_pair(obj):
    """is_pair(swig_int_ptr obj) -> bool"""
    return _pmt_swig.is_pair(obj)

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

def car(pair):
    """car(swig_int_ptr pair) -> swig_int_ptr"""
    return _pmt_swig.car(pair)

def cdr(pair):
    """cdr(swig_int_ptr pair) -> swig_int_ptr"""
    return _pmt_swig.cdr(pair)

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

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

def caar(pair):
    """caar(swig_int_ptr pair) -> swig_int_ptr"""
    return _pmt_swig.caar(pair)

def cadr(pair):
    """cadr(swig_int_ptr pair) -> swig_int_ptr"""
    return _pmt_swig.cadr(pair)

def cdar(pair):
    """cdar(swig_int_ptr pair) -> swig_int_ptr"""
    return _pmt_swig.cdar(pair)

def cddr(pair):
    """cddr(swig_int_ptr pair) -> swig_int_ptr"""
    return _pmt_swig.cddr(pair)

def caddr(pair):
    """caddr(swig_int_ptr pair) -> swig_int_ptr"""
    return _pmt_swig.caddr(pair)

def cadddr(pair):
    """cadddr(swig_int_ptr pair) -> swig_int_ptr"""
    return _pmt_swig.cadddr(pair)

def is_tuple(x):
    """is_tuple(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_tuple(x)

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(x):
    """to_tuple(swig_int_ptr x) -> swig_int_ptr"""
    return _pmt_swig.to_tuple(x)

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

def is_vector(x):
    """is_vector(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_vector(x)

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

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

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

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

def is_blob(x):
    """is_blob(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_blob(x)

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

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

def blob_length(blob):
    """blob_length(swig_int_ptr blob) -> size_t"""
    return _pmt_swig.blob_length(blob)

def is_uniform_vector(x):
    """is_uniform_vector(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_uniform_vector(x)

def is_u8vector(x):
    """is_u8vector(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_u8vector(x)

def is_s8vector(x):
    """is_s8vector(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_s8vector(x)

def is_u16vector(x):
    """is_u16vector(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_u16vector(x)

def is_s16vector(x):
    """is_s16vector(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_s16vector(x)

def is_u32vector(x):
    """is_u32vector(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_u32vector(x)

def is_s32vector(x):
    """is_s32vector(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_s32vector(x)

def is_u64vector(x):
    """is_u64vector(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_u64vector(x)

def is_s64vector(x):
    """is_s64vector(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_s64vector(x)

def is_f32vector(x):
    """is_f32vector(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_f32vector(x)

def is_f64vector(x):
    """is_f64vector(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_f64vector(x)

def is_c32vector(x):
    """is_c32vector(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_c32vector(x)

def is_c64vector(x):
    """is_c64vector(swig_int_ptr x) -> bool"""
    return _pmt_swig.is_c64vector(x)

def uniform_vector_itemsize(x):
    """uniform_vector_itemsize(swig_int_ptr x) -> size_t"""
    return _pmt_swig.uniform_vector_itemsize(x)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def u8vector_elements(v):
    """u8vector_elements(swig_int_ptr v) -> pmt_vector_uint8"""
    return _pmt_swig.u8vector_elements(v)

def s8vector_elements(v):
    """s8vector_elements(swig_int_ptr v) -> pmt_vector_int8"""
    return _pmt_swig.s8vector_elements(v)

def u16vector_elements(v):
    """u16vector_elements(swig_int_ptr v) -> pmt_vector_uint16"""
    return _pmt_swig.u16vector_elements(v)

def s16vector_elements(v):
    """s16vector_elements(swig_int_ptr v) -> pmt_vector_int16"""
    return _pmt_swig.s16vector_elements(v)

def u32vector_elements(v):
    """u32vector_elements(swig_int_ptr v) -> pmt_vector_uint32"""
    return _pmt_swig.u32vector_elements(v)

def s32vector_elements(v):
    """s32vector_elements(swig_int_ptr v) -> pmt_vector_int32"""
    return _pmt_swig.s32vector_elements(v)

def f32vector_elements(v):
    """f32vector_elements(swig_int_ptr v) -> pmt_vector_float"""
    return _pmt_swig.f32vector_elements(v)

def f64vector_elements(v):
    """f64vector_elements(swig_int_ptr v) -> pmt_vector_double"""
    return _pmt_swig.f64vector_elements(v)

def c32vector_elements(v):
    """c32vector_elements(swig_int_ptr v) -> pmt_vector_cfloat"""
    return _pmt_swig.c32vector_elements(v)

def c64vector_elements(v):
    """c64vector_elements(swig_int_ptr v) -> pmt_vector_cdouble"""
    return _pmt_swig.c64vector_elements(v)

def is_dict(obj):
    """is_dict(swig_int_ptr obj) -> bool"""
    return _pmt_swig.is_dict(obj)

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

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

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

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

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

def dict_items(dict):
    """dict_items(swig_int_ptr dict) -> swig_int_ptr"""
    return _pmt_swig.dict_items(dict)

def dict_keys(dict):
    """dict_keys(swig_int_ptr dict) -> swig_int_ptr"""
    return _pmt_swig.dict_keys(dict)

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

def dict_values(dict):
    """dict_values(swig_int_ptr dict) -> swig_int_ptr"""
    return _pmt_swig.dict_values(dict)

def is_any(obj):
    """is_any(swig_int_ptr obj) -> bool"""
    return _pmt_swig.is_any(obj)

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

def any_ref(obj):
    """any_ref(swig_int_ptr obj) -> boost::any"""
    return _pmt_swig.any_ref(obj)

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

def is_msg_accepter(obj):
    """is_msg_accepter(swig_int_ptr obj) -> bool"""
    return _pmt_swig.is_msg_accepter(obj)

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

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

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

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

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

def length(v):
    """length(swig_int_ptr v) -> size_t"""
    return _pmt_swig.length(v)

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

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

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

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

def reverse(list):
    """reverse(swig_int_ptr list) -> swig_int_ptr"""
    return _pmt_swig.reverse(list)

def reverse_x(list):
    """reverse_x(swig_int_ptr list) -> swig_int_ptr"""
    return _pmt_swig.reverse_x(list)

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

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

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

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

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

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

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

def list1(x1):
    """list1(swig_int_ptr x1) -> swig_int_ptr"""
    return _pmt_swig.list1(x1)

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

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

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

def list5(x1, x2, x3, x4, x5):
    """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(x1, x2, x3, x4, x5)

def list6(x1, x2, x3, x4, x5, x6):
    """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(x1, x2, x3, x4, x5, x6)

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

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

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

def is_eof_object(obj):
    """is_eof_object(swig_int_ptr obj) -> bool"""
    return _pmt_swig.is_eof_object(obj)

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

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

def write_string(obj):
    """write_string(swig_int_ptr obj) -> std::string"""
    return _pmt_swig.write_string(obj)

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

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

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

def serialize_str(obj):
    """serialize_str(swig_int_ptr obj) -> std::string"""
    return _pmt_swig.serialize_str(obj)

def deserialize_str(str):
    """deserialize_str(std::string str) -> swig_int_ptr"""
    return _pmt_swig.deserialize_str(str)


