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

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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


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

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

    def value(self):
        return _libgeoda.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _libgeoda.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _libgeoda.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _libgeoda.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _libgeoda.SwigPyIterator_equal(self, x)

    def copy(self):
        return _libgeoda.SwigPyIterator_copy(self)

    def next(self):
        return _libgeoda.SwigPyIterator_next(self)

    def __next__(self):
        return _libgeoda.SwigPyIterator___next__(self)

    def previous(self):
        return _libgeoda.SwigPyIterator_previous(self)

    def advance(self, n):
        return _libgeoda.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _libgeoda.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _libgeoda.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _libgeoda.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _libgeoda.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _libgeoda.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _libgeoda.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _libgeoda:
_libgeoda.SwigPyIterator_swigregister(SwigPyIterator)

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

    def iterator(self):
        return _libgeoda.VecVoid_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libgeoda.VecVoid___nonzero__(self)

    def __bool__(self):
        return _libgeoda.VecVoid___bool__(self)

    def __len__(self):
        return _libgeoda.VecVoid___len__(self)

    def __getslice__(self, i, j):
        return _libgeoda.VecVoid___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libgeoda.VecVoid___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libgeoda.VecVoid___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libgeoda.VecVoid___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libgeoda.VecVoid___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libgeoda.VecVoid___setitem__(self, *args)

    def pop(self):
        return _libgeoda.VecVoid_pop(self)

    def append(self, x):
        return _libgeoda.VecVoid_append(self, x)

    def empty(self):
        return _libgeoda.VecVoid_empty(self)

    def size(self):
        return _libgeoda.VecVoid_size(self)

    def swap(self, v):
        return _libgeoda.VecVoid_swap(self, v)

    def begin(self):
        return _libgeoda.VecVoid_begin(self)

    def end(self):
        return _libgeoda.VecVoid_end(self)

    def rbegin(self):
        return _libgeoda.VecVoid_rbegin(self)

    def rend(self):
        return _libgeoda.VecVoid_rend(self)

    def clear(self):
        return _libgeoda.VecVoid_clear(self)

    def get_allocator(self):
        return _libgeoda.VecVoid_get_allocator(self)

    def pop_back(self):
        return _libgeoda.VecVoid_pop_back(self)

    def erase(self, *args):
        return _libgeoda.VecVoid_erase(self, *args)

    def __init__(self, *args):
        _libgeoda.VecVoid_swiginit(self, _libgeoda.new_VecVoid(*args))

    def push_back(self, x):
        return _libgeoda.VecVoid_push_back(self, x)

    def front(self):
        return _libgeoda.VecVoid_front(self)

    def back(self):
        return _libgeoda.VecVoid_back(self)

    def assign(self, n, x):
        return _libgeoda.VecVoid_assign(self, n, x)

    def resize(self, *args):
        return _libgeoda.VecVoid_resize(self, *args)

    def insert(self, *args):
        return _libgeoda.VecVoid_insert(self, *args)

    def reserve(self, n):
        return _libgeoda.VecVoid_reserve(self, n)

    def capacity(self):
        return _libgeoda.VecVoid_capacity(self)
    __swig_destroy__ = _libgeoda.delete_VecVoid

# Register VecVoid in _libgeoda:
_libgeoda.VecVoid_swigregister(VecVoid)

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

    def iterator(self):
        return _libgeoda.VecFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libgeoda.VecFloat___nonzero__(self)

    def __bool__(self):
        return _libgeoda.VecFloat___bool__(self)

    def __len__(self):
        return _libgeoda.VecFloat___len__(self)

    def __getslice__(self, i, j):
        return _libgeoda.VecFloat___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libgeoda.VecFloat___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libgeoda.VecFloat___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libgeoda.VecFloat___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libgeoda.VecFloat___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libgeoda.VecFloat___setitem__(self, *args)

    def pop(self):
        return _libgeoda.VecFloat_pop(self)

    def append(self, x):
        return _libgeoda.VecFloat_append(self, x)

    def empty(self):
        return _libgeoda.VecFloat_empty(self)

    def size(self):
        return _libgeoda.VecFloat_size(self)

    def swap(self, v):
        return _libgeoda.VecFloat_swap(self, v)

    def begin(self):
        return _libgeoda.VecFloat_begin(self)

    def end(self):
        return _libgeoda.VecFloat_end(self)

    def rbegin(self):
        return _libgeoda.VecFloat_rbegin(self)

    def rend(self):
        return _libgeoda.VecFloat_rend(self)

    def clear(self):
        return _libgeoda.VecFloat_clear(self)

    def get_allocator(self):
        return _libgeoda.VecFloat_get_allocator(self)

    def pop_back(self):
        return _libgeoda.VecFloat_pop_back(self)

    def erase(self, *args):
        return _libgeoda.VecFloat_erase(self, *args)

    def __init__(self, *args):
        _libgeoda.VecFloat_swiginit(self, _libgeoda.new_VecFloat(*args))

    def push_back(self, x):
        return _libgeoda.VecFloat_push_back(self, x)

    def front(self):
        return _libgeoda.VecFloat_front(self)

    def back(self):
        return _libgeoda.VecFloat_back(self)

    def assign(self, n, x):
        return _libgeoda.VecFloat_assign(self, n, x)

    def resize(self, *args):
        return _libgeoda.VecFloat_resize(self, *args)

    def insert(self, *args):
        return _libgeoda.VecFloat_insert(self, *args)

    def reserve(self, n):
        return _libgeoda.VecFloat_reserve(self, n)

    def capacity(self):
        return _libgeoda.VecFloat_capacity(self)
    __swig_destroy__ = _libgeoda.delete_VecFloat

# Register VecFloat in _libgeoda:
_libgeoda.VecFloat_swigregister(VecFloat)

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

    def iterator(self):
        return _libgeoda.VecString_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libgeoda.VecString___nonzero__(self)

    def __bool__(self):
        return _libgeoda.VecString___bool__(self)

    def __len__(self):
        return _libgeoda.VecString___len__(self)

    def __getslice__(self, i, j):
        return _libgeoda.VecString___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libgeoda.VecString___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libgeoda.VecString___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libgeoda.VecString___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libgeoda.VecString___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libgeoda.VecString___setitem__(self, *args)

    def pop(self):
        return _libgeoda.VecString_pop(self)

    def append(self, x):
        return _libgeoda.VecString_append(self, x)

    def empty(self):
        return _libgeoda.VecString_empty(self)

    def size(self):
        return _libgeoda.VecString_size(self)

    def swap(self, v):
        return _libgeoda.VecString_swap(self, v)

    def begin(self):
        return _libgeoda.VecString_begin(self)

    def end(self):
        return _libgeoda.VecString_end(self)

    def rbegin(self):
        return _libgeoda.VecString_rbegin(self)

    def rend(self):
        return _libgeoda.VecString_rend(self)

    def clear(self):
        return _libgeoda.VecString_clear(self)

    def get_allocator(self):
        return _libgeoda.VecString_get_allocator(self)

    def pop_back(self):
        return _libgeoda.VecString_pop_back(self)

    def erase(self, *args):
        return _libgeoda.VecString_erase(self, *args)

    def __init__(self, *args):
        _libgeoda.VecString_swiginit(self, _libgeoda.new_VecString(*args))

    def push_back(self, x):
        return _libgeoda.VecString_push_back(self, x)

    def front(self):
        return _libgeoda.VecString_front(self)

    def back(self):
        return _libgeoda.VecString_back(self)

    def assign(self, n, x):
        return _libgeoda.VecString_assign(self, n, x)

    def resize(self, *args):
        return _libgeoda.VecString_resize(self, *args)

    def insert(self, *args):
        return _libgeoda.VecString_insert(self, *args)

    def reserve(self, n):
        return _libgeoda.VecString_reserve(self, n)

    def capacity(self):
        return _libgeoda.VecString_capacity(self)
    __swig_destroy__ = _libgeoda.delete_VecString

# Register VecString in _libgeoda:
_libgeoda.VecString_swigregister(VecString)

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

    def iterator(self):
        return _libgeoda.VecDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libgeoda.VecDouble___nonzero__(self)

    def __bool__(self):
        return _libgeoda.VecDouble___bool__(self)

    def __len__(self):
        return _libgeoda.VecDouble___len__(self)

    def __getslice__(self, i, j):
        return _libgeoda.VecDouble___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libgeoda.VecDouble___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libgeoda.VecDouble___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libgeoda.VecDouble___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libgeoda.VecDouble___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libgeoda.VecDouble___setitem__(self, *args)

    def pop(self):
        return _libgeoda.VecDouble_pop(self)

    def append(self, x):
        return _libgeoda.VecDouble_append(self, x)

    def empty(self):
        return _libgeoda.VecDouble_empty(self)

    def size(self):
        return _libgeoda.VecDouble_size(self)

    def swap(self, v):
        return _libgeoda.VecDouble_swap(self, v)

    def begin(self):
        return _libgeoda.VecDouble_begin(self)

    def end(self):
        return _libgeoda.VecDouble_end(self)

    def rbegin(self):
        return _libgeoda.VecDouble_rbegin(self)

    def rend(self):
        return _libgeoda.VecDouble_rend(self)

    def clear(self):
        return _libgeoda.VecDouble_clear(self)

    def get_allocator(self):
        return _libgeoda.VecDouble_get_allocator(self)

    def pop_back(self):
        return _libgeoda.VecDouble_pop_back(self)

    def erase(self, *args):
        return _libgeoda.VecDouble_erase(self, *args)

    def __init__(self, *args):
        _libgeoda.VecDouble_swiginit(self, _libgeoda.new_VecDouble(*args))

    def push_back(self, x):
        return _libgeoda.VecDouble_push_back(self, x)

    def front(self):
        return _libgeoda.VecDouble_front(self)

    def back(self):
        return _libgeoda.VecDouble_back(self)

    def assign(self, n, x):
        return _libgeoda.VecDouble_assign(self, n, x)

    def resize(self, *args):
        return _libgeoda.VecDouble_resize(self, *args)

    def insert(self, *args):
        return _libgeoda.VecDouble_insert(self, *args)

    def reserve(self, n):
        return _libgeoda.VecDouble_reserve(self, n)

    def capacity(self):
        return _libgeoda.VecDouble_capacity(self)
    __swig_destroy__ = _libgeoda.delete_VecDouble

# Register VecDouble in _libgeoda:
_libgeoda.VecDouble_swigregister(VecDouble)

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

    def iterator(self):
        return _libgeoda.VecChar_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libgeoda.VecChar___nonzero__(self)

    def __bool__(self):
        return _libgeoda.VecChar___bool__(self)

    def __len__(self):
        return _libgeoda.VecChar___len__(self)

    def __getslice__(self, i, j):
        return _libgeoda.VecChar___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libgeoda.VecChar___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libgeoda.VecChar___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libgeoda.VecChar___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libgeoda.VecChar___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libgeoda.VecChar___setitem__(self, *args)

    def pop(self):
        return _libgeoda.VecChar_pop(self)

    def append(self, x):
        return _libgeoda.VecChar_append(self, x)

    def empty(self):
        return _libgeoda.VecChar_empty(self)

    def size(self):
        return _libgeoda.VecChar_size(self)

    def swap(self, v):
        return _libgeoda.VecChar_swap(self, v)

    def begin(self):
        return _libgeoda.VecChar_begin(self)

    def end(self):
        return _libgeoda.VecChar_end(self)

    def rbegin(self):
        return _libgeoda.VecChar_rbegin(self)

    def rend(self):
        return _libgeoda.VecChar_rend(self)

    def clear(self):
        return _libgeoda.VecChar_clear(self)

    def get_allocator(self):
        return _libgeoda.VecChar_get_allocator(self)

    def pop_back(self):
        return _libgeoda.VecChar_pop_back(self)

    def erase(self, *args):
        return _libgeoda.VecChar_erase(self, *args)

    def __init__(self, *args):
        _libgeoda.VecChar_swiginit(self, _libgeoda.new_VecChar(*args))

    def push_back(self, x):
        return _libgeoda.VecChar_push_back(self, x)

    def front(self):
        return _libgeoda.VecChar_front(self)

    def back(self):
        return _libgeoda.VecChar_back(self)

    def assign(self, n, x):
        return _libgeoda.VecChar_assign(self, n, x)

    def resize(self, *args):
        return _libgeoda.VecChar_resize(self, *args)

    def insert(self, *args):
        return _libgeoda.VecChar_insert(self, *args)

    def reserve(self, n):
        return _libgeoda.VecChar_reserve(self, n)

    def capacity(self):
        return _libgeoda.VecChar_capacity(self)
    __swig_destroy__ = _libgeoda.delete_VecChar

# Register VecChar in _libgeoda:
_libgeoda.VecChar_swigregister(VecChar)

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

    def iterator(self):
        return _libgeoda.VecCharPointer_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libgeoda.VecCharPointer___nonzero__(self)

    def __bool__(self):
        return _libgeoda.VecCharPointer___bool__(self)

    def __len__(self):
        return _libgeoda.VecCharPointer___len__(self)

    def __getslice__(self, i, j):
        return _libgeoda.VecCharPointer___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libgeoda.VecCharPointer___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libgeoda.VecCharPointer___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libgeoda.VecCharPointer___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libgeoda.VecCharPointer___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libgeoda.VecCharPointer___setitem__(self, *args)

    def pop(self):
        return _libgeoda.VecCharPointer_pop(self)

    def append(self, x):
        return _libgeoda.VecCharPointer_append(self, x)

    def empty(self):
        return _libgeoda.VecCharPointer_empty(self)

    def size(self):
        return _libgeoda.VecCharPointer_size(self)

    def swap(self, v):
        return _libgeoda.VecCharPointer_swap(self, v)

    def begin(self):
        return _libgeoda.VecCharPointer_begin(self)

    def end(self):
        return _libgeoda.VecCharPointer_end(self)

    def rbegin(self):
        return _libgeoda.VecCharPointer_rbegin(self)

    def rend(self):
        return _libgeoda.VecCharPointer_rend(self)

    def clear(self):
        return _libgeoda.VecCharPointer_clear(self)

    def get_allocator(self):
        return _libgeoda.VecCharPointer_get_allocator(self)

    def pop_back(self):
        return _libgeoda.VecCharPointer_pop_back(self)

    def erase(self, *args):
        return _libgeoda.VecCharPointer_erase(self, *args)

    def __init__(self, *args):
        _libgeoda.VecCharPointer_swiginit(self, _libgeoda.new_VecCharPointer(*args))

    def push_back(self, x):
        return _libgeoda.VecCharPointer_push_back(self, x)

    def front(self):
        return _libgeoda.VecCharPointer_front(self)

    def back(self):
        return _libgeoda.VecCharPointer_back(self)

    def assign(self, n, x):
        return _libgeoda.VecCharPointer_assign(self, n, x)

    def resize(self, *args):
        return _libgeoda.VecCharPointer_resize(self, *args)

    def insert(self, *args):
        return _libgeoda.VecCharPointer_insert(self, *args)

    def reserve(self, n):
        return _libgeoda.VecCharPointer_reserve(self, n)

    def capacity(self):
        return _libgeoda.VecCharPointer_capacity(self)
    __swig_destroy__ = _libgeoda.delete_VecCharPointer

# Register VecCharPointer in _libgeoda:
_libgeoda.VecCharPointer_swigregister(VecCharPointer)

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

    def iterator(self):
        return _libgeoda.VecVecDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libgeoda.VecVecDouble___nonzero__(self)

    def __bool__(self):
        return _libgeoda.VecVecDouble___bool__(self)

    def __len__(self):
        return _libgeoda.VecVecDouble___len__(self)

    def __getslice__(self, i, j):
        return _libgeoda.VecVecDouble___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libgeoda.VecVecDouble___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libgeoda.VecVecDouble___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libgeoda.VecVecDouble___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libgeoda.VecVecDouble___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libgeoda.VecVecDouble___setitem__(self, *args)

    def pop(self):
        return _libgeoda.VecVecDouble_pop(self)

    def append(self, x):
        return _libgeoda.VecVecDouble_append(self, x)

    def empty(self):
        return _libgeoda.VecVecDouble_empty(self)

    def size(self):
        return _libgeoda.VecVecDouble_size(self)

    def swap(self, v):
        return _libgeoda.VecVecDouble_swap(self, v)

    def begin(self):
        return _libgeoda.VecVecDouble_begin(self)

    def end(self):
        return _libgeoda.VecVecDouble_end(self)

    def rbegin(self):
        return _libgeoda.VecVecDouble_rbegin(self)

    def rend(self):
        return _libgeoda.VecVecDouble_rend(self)

    def clear(self):
        return _libgeoda.VecVecDouble_clear(self)

    def get_allocator(self):
        return _libgeoda.VecVecDouble_get_allocator(self)

    def pop_back(self):
        return _libgeoda.VecVecDouble_pop_back(self)

    def erase(self, *args):
        return _libgeoda.VecVecDouble_erase(self, *args)

    def __init__(self, *args):
        _libgeoda.VecVecDouble_swiginit(self, _libgeoda.new_VecVecDouble(*args))

    def push_back(self, x):
        return _libgeoda.VecVecDouble_push_back(self, x)

    def front(self):
        return _libgeoda.VecVecDouble_front(self)

    def back(self):
        return _libgeoda.VecVecDouble_back(self)

    def assign(self, n, x):
        return _libgeoda.VecVecDouble_assign(self, n, x)

    def resize(self, *args):
        return _libgeoda.VecVecDouble_resize(self, *args)

    def insert(self, *args):
        return _libgeoda.VecVecDouble_insert(self, *args)

    def reserve(self, n):
        return _libgeoda.VecVecDouble_reserve(self, n)

    def capacity(self):
        return _libgeoda.VecVecDouble_capacity(self)
    __swig_destroy__ = _libgeoda.delete_VecVecDouble

# Register VecVecDouble in _libgeoda:
_libgeoda.VecVecDouble_swigregister(VecVecDouble)

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

    def iterator(self):
        return _libgeoda.VecInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libgeoda.VecInt___nonzero__(self)

    def __bool__(self):
        return _libgeoda.VecInt___bool__(self)

    def __len__(self):
        return _libgeoda.VecInt___len__(self)

    def __getslice__(self, i, j):
        return _libgeoda.VecInt___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libgeoda.VecInt___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libgeoda.VecInt___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libgeoda.VecInt___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libgeoda.VecInt___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libgeoda.VecInt___setitem__(self, *args)

    def pop(self):
        return _libgeoda.VecInt_pop(self)

    def append(self, x):
        return _libgeoda.VecInt_append(self, x)

    def empty(self):
        return _libgeoda.VecInt_empty(self)

    def size(self):
        return _libgeoda.VecInt_size(self)

    def swap(self, v):
        return _libgeoda.VecInt_swap(self, v)

    def begin(self):
        return _libgeoda.VecInt_begin(self)

    def end(self):
        return _libgeoda.VecInt_end(self)

    def rbegin(self):
        return _libgeoda.VecInt_rbegin(self)

    def rend(self):
        return _libgeoda.VecInt_rend(self)

    def clear(self):
        return _libgeoda.VecInt_clear(self)

    def get_allocator(self):
        return _libgeoda.VecInt_get_allocator(self)

    def pop_back(self):
        return _libgeoda.VecInt_pop_back(self)

    def erase(self, *args):
        return _libgeoda.VecInt_erase(self, *args)

    def __init__(self, *args):
        _libgeoda.VecInt_swiginit(self, _libgeoda.new_VecInt(*args))

    def push_back(self, x):
        return _libgeoda.VecInt_push_back(self, x)

    def front(self):
        return _libgeoda.VecInt_front(self)

    def back(self):
        return _libgeoda.VecInt_back(self)

    def assign(self, n, x):
        return _libgeoda.VecInt_assign(self, n, x)

    def resize(self, *args):
        return _libgeoda.VecInt_resize(self, *args)

    def insert(self, *args):
        return _libgeoda.VecInt_insert(self, *args)

    def reserve(self, n):
        return _libgeoda.VecInt_reserve(self, n)

    def capacity(self):
        return _libgeoda.VecInt_capacity(self)
    __swig_destroy__ = _libgeoda.delete_VecInt

# Register VecInt in _libgeoda:
_libgeoda.VecInt_swigregister(VecInt)

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

    def iterator(self):
        return _libgeoda.VecBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libgeoda.VecBool___nonzero__(self)

    def __bool__(self):
        return _libgeoda.VecBool___bool__(self)

    def __len__(self):
        return _libgeoda.VecBool___len__(self)

    def __getslice__(self, i, j):
        return _libgeoda.VecBool___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libgeoda.VecBool___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libgeoda.VecBool___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libgeoda.VecBool___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libgeoda.VecBool___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libgeoda.VecBool___setitem__(self, *args)

    def pop(self):
        return _libgeoda.VecBool_pop(self)

    def append(self, x):
        return _libgeoda.VecBool_append(self, x)

    def empty(self):
        return _libgeoda.VecBool_empty(self)

    def size(self):
        return _libgeoda.VecBool_size(self)

    def swap(self, v):
        return _libgeoda.VecBool_swap(self, v)

    def begin(self):
        return _libgeoda.VecBool_begin(self)

    def end(self):
        return _libgeoda.VecBool_end(self)

    def rbegin(self):
        return _libgeoda.VecBool_rbegin(self)

    def rend(self):
        return _libgeoda.VecBool_rend(self)

    def clear(self):
        return _libgeoda.VecBool_clear(self)

    def get_allocator(self):
        return _libgeoda.VecBool_get_allocator(self)

    def pop_back(self):
        return _libgeoda.VecBool_pop_back(self)

    def erase(self, *args):
        return _libgeoda.VecBool_erase(self, *args)

    def __init__(self, *args):
        _libgeoda.VecBool_swiginit(self, _libgeoda.new_VecBool(*args))

    def push_back(self, x):
        return _libgeoda.VecBool_push_back(self, x)

    def front(self):
        return _libgeoda.VecBool_front(self)

    def back(self):
        return _libgeoda.VecBool_back(self)

    def assign(self, n, x):
        return _libgeoda.VecBool_assign(self, n, x)

    def resize(self, *args):
        return _libgeoda.VecBool_resize(self, *args)

    def insert(self, *args):
        return _libgeoda.VecBool_insert(self, *args)

    def reserve(self, n):
        return _libgeoda.VecBool_reserve(self, n)

    def capacity(self):
        return _libgeoda.VecBool_capacity(self)
    __swig_destroy__ = _libgeoda.delete_VecBool

# Register VecBool in _libgeoda:
_libgeoda.VecBool_swigregister(VecBool)

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

    def iterator(self):
        return _libgeoda.VecVecBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libgeoda.VecVecBool___nonzero__(self)

    def __bool__(self):
        return _libgeoda.VecVecBool___bool__(self)

    def __len__(self):
        return _libgeoda.VecVecBool___len__(self)

    def __getslice__(self, i, j):
        return _libgeoda.VecVecBool___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libgeoda.VecVecBool___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libgeoda.VecVecBool___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libgeoda.VecVecBool___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libgeoda.VecVecBool___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libgeoda.VecVecBool___setitem__(self, *args)

    def pop(self):
        return _libgeoda.VecVecBool_pop(self)

    def append(self, x):
        return _libgeoda.VecVecBool_append(self, x)

    def empty(self):
        return _libgeoda.VecVecBool_empty(self)

    def size(self):
        return _libgeoda.VecVecBool_size(self)

    def swap(self, v):
        return _libgeoda.VecVecBool_swap(self, v)

    def begin(self):
        return _libgeoda.VecVecBool_begin(self)

    def end(self):
        return _libgeoda.VecVecBool_end(self)

    def rbegin(self):
        return _libgeoda.VecVecBool_rbegin(self)

    def rend(self):
        return _libgeoda.VecVecBool_rend(self)

    def clear(self):
        return _libgeoda.VecVecBool_clear(self)

    def get_allocator(self):
        return _libgeoda.VecVecBool_get_allocator(self)

    def pop_back(self):
        return _libgeoda.VecVecBool_pop_back(self)

    def erase(self, *args):
        return _libgeoda.VecVecBool_erase(self, *args)

    def __init__(self, *args):
        _libgeoda.VecVecBool_swiginit(self, _libgeoda.new_VecVecBool(*args))

    def push_back(self, x):
        return _libgeoda.VecVecBool_push_back(self, x)

    def front(self):
        return _libgeoda.VecVecBool_front(self)

    def back(self):
        return _libgeoda.VecVecBool_back(self)

    def assign(self, n, x):
        return _libgeoda.VecVecBool_assign(self, n, x)

    def resize(self, *args):
        return _libgeoda.VecVecBool_resize(self, *args)

    def insert(self, *args):
        return _libgeoda.VecVecBool_insert(self, *args)

    def reserve(self, n):
        return _libgeoda.VecVecBool_reserve(self, n)

    def capacity(self):
        return _libgeoda.VecVecBool_capacity(self)
    __swig_destroy__ = _libgeoda.delete_VecVecBool

# Register VecVecBool in _libgeoda:
_libgeoda.VecVecBool_swigregister(VecVecBool)

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

    def iterator(self):
        return _libgeoda.VecLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libgeoda.VecLong___nonzero__(self)

    def __bool__(self):
        return _libgeoda.VecLong___bool__(self)

    def __len__(self):
        return _libgeoda.VecLong___len__(self)

    def __getslice__(self, i, j):
        return _libgeoda.VecLong___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libgeoda.VecLong___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libgeoda.VecLong___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libgeoda.VecLong___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libgeoda.VecLong___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libgeoda.VecLong___setitem__(self, *args)

    def pop(self):
        return _libgeoda.VecLong_pop(self)

    def append(self, x):
        return _libgeoda.VecLong_append(self, x)

    def empty(self):
        return _libgeoda.VecLong_empty(self)

    def size(self):
        return _libgeoda.VecLong_size(self)

    def swap(self, v):
        return _libgeoda.VecLong_swap(self, v)

    def begin(self):
        return _libgeoda.VecLong_begin(self)

    def end(self):
        return _libgeoda.VecLong_end(self)

    def rbegin(self):
        return _libgeoda.VecLong_rbegin(self)

    def rend(self):
        return _libgeoda.VecLong_rend(self)

    def clear(self):
        return _libgeoda.VecLong_clear(self)

    def get_allocator(self):
        return _libgeoda.VecLong_get_allocator(self)

    def pop_back(self):
        return _libgeoda.VecLong_pop_back(self)

    def erase(self, *args):
        return _libgeoda.VecLong_erase(self, *args)

    def __init__(self, *args):
        _libgeoda.VecLong_swiginit(self, _libgeoda.new_VecLong(*args))

    def push_back(self, x):
        return _libgeoda.VecLong_push_back(self, x)

    def front(self):
        return _libgeoda.VecLong_front(self)

    def back(self):
        return _libgeoda.VecLong_back(self)

    def assign(self, n, x):
        return _libgeoda.VecLong_assign(self, n, x)

    def resize(self, *args):
        return _libgeoda.VecLong_resize(self, *args)

    def insert(self, *args):
        return _libgeoda.VecLong_insert(self, *args)

    def reserve(self, n):
        return _libgeoda.VecLong_reserve(self, n)

    def capacity(self):
        return _libgeoda.VecLong_capacity(self)
    __swig_destroy__ = _libgeoda.delete_VecLong

# Register VecLong in _libgeoda:
_libgeoda.VecLong_swigregister(VecLong)

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

    def iterator(self):
        return _libgeoda.VecInt64_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libgeoda.VecInt64___nonzero__(self)

    def __bool__(self):
        return _libgeoda.VecInt64___bool__(self)

    def __len__(self):
        return _libgeoda.VecInt64___len__(self)

    def __getslice__(self, i, j):
        return _libgeoda.VecInt64___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libgeoda.VecInt64___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libgeoda.VecInt64___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libgeoda.VecInt64___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libgeoda.VecInt64___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libgeoda.VecInt64___setitem__(self, *args)

    def pop(self):
        return _libgeoda.VecInt64_pop(self)

    def append(self, x):
        return _libgeoda.VecInt64_append(self, x)

    def empty(self):
        return _libgeoda.VecInt64_empty(self)

    def size(self):
        return _libgeoda.VecInt64_size(self)

    def swap(self, v):
        return _libgeoda.VecInt64_swap(self, v)

    def begin(self):
        return _libgeoda.VecInt64_begin(self)

    def end(self):
        return _libgeoda.VecInt64_end(self)

    def rbegin(self):
        return _libgeoda.VecInt64_rbegin(self)

    def rend(self):
        return _libgeoda.VecInt64_rend(self)

    def clear(self):
        return _libgeoda.VecInt64_clear(self)

    def get_allocator(self):
        return _libgeoda.VecInt64_get_allocator(self)

    def pop_back(self):
        return _libgeoda.VecInt64_pop_back(self)

    def erase(self, *args):
        return _libgeoda.VecInt64_erase(self, *args)

    def __init__(self, *args):
        _libgeoda.VecInt64_swiginit(self, _libgeoda.new_VecInt64(*args))

    def push_back(self, x):
        return _libgeoda.VecInt64_push_back(self, x)

    def front(self):
        return _libgeoda.VecInt64_front(self)

    def back(self):
        return _libgeoda.VecInt64_back(self)

    def assign(self, n, x):
        return _libgeoda.VecInt64_assign(self, n, x)

    def resize(self, *args):
        return _libgeoda.VecInt64_resize(self, *args)

    def insert(self, *args):
        return _libgeoda.VecInt64_insert(self, *args)

    def reserve(self, n):
        return _libgeoda.VecInt64_reserve(self, n)

    def capacity(self):
        return _libgeoda.VecInt64_capacity(self)
    __swig_destroy__ = _libgeoda.delete_VecInt64

# Register VecInt64 in _libgeoda:
_libgeoda.VecInt64_swigregister(VecInt64)

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

    def iterator(self):
        return _libgeoda.VecVecInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libgeoda.VecVecInt___nonzero__(self)

    def __bool__(self):
        return _libgeoda.VecVecInt___bool__(self)

    def __len__(self):
        return _libgeoda.VecVecInt___len__(self)

    def __getslice__(self, i, j):
        return _libgeoda.VecVecInt___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libgeoda.VecVecInt___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libgeoda.VecVecInt___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libgeoda.VecVecInt___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libgeoda.VecVecInt___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libgeoda.VecVecInt___setitem__(self, *args)

    def pop(self):
        return _libgeoda.VecVecInt_pop(self)

    def append(self, x):
        return _libgeoda.VecVecInt_append(self, x)

    def empty(self):
        return _libgeoda.VecVecInt_empty(self)

    def size(self):
        return _libgeoda.VecVecInt_size(self)

    def swap(self, v):
        return _libgeoda.VecVecInt_swap(self, v)

    def begin(self):
        return _libgeoda.VecVecInt_begin(self)

    def end(self):
        return _libgeoda.VecVecInt_end(self)

    def rbegin(self):
        return _libgeoda.VecVecInt_rbegin(self)

    def rend(self):
        return _libgeoda.VecVecInt_rend(self)

    def clear(self):
        return _libgeoda.VecVecInt_clear(self)

    def get_allocator(self):
        return _libgeoda.VecVecInt_get_allocator(self)

    def pop_back(self):
        return _libgeoda.VecVecInt_pop_back(self)

    def erase(self, *args):
        return _libgeoda.VecVecInt_erase(self, *args)

    def __init__(self, *args):
        _libgeoda.VecVecInt_swiginit(self, _libgeoda.new_VecVecInt(*args))

    def push_back(self, x):
        return _libgeoda.VecVecInt_push_back(self, x)

    def front(self):
        return _libgeoda.VecVecInt_front(self)

    def back(self):
        return _libgeoda.VecVecInt_back(self)

    def assign(self, n, x):
        return _libgeoda.VecVecInt_assign(self, n, x)

    def resize(self, *args):
        return _libgeoda.VecVecInt_resize(self, *args)

    def insert(self, *args):
        return _libgeoda.VecVecInt_insert(self, *args)

    def reserve(self, n):
        return _libgeoda.VecVecInt_reserve(self, n)

    def capacity(self):
        return _libgeoda.VecVecInt_capacity(self)
    __swig_destroy__ = _libgeoda.delete_VecVecInt

# Register VecVecInt in _libgeoda:
_libgeoda.VecVecInt_swigregister(VecVecInt)

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

    def iterator(self):
        return _libgeoda.VecUINT8_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libgeoda.VecUINT8___nonzero__(self)

    def __bool__(self):
        return _libgeoda.VecUINT8___bool__(self)

    def __len__(self):
        return _libgeoda.VecUINT8___len__(self)

    def __getslice__(self, i, j):
        return _libgeoda.VecUINT8___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libgeoda.VecUINT8___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libgeoda.VecUINT8___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libgeoda.VecUINT8___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libgeoda.VecUINT8___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libgeoda.VecUINT8___setitem__(self, *args)

    def pop(self):
        return _libgeoda.VecUINT8_pop(self)

    def append(self, x):
        return _libgeoda.VecUINT8_append(self, x)

    def empty(self):
        return _libgeoda.VecUINT8_empty(self)

    def size(self):
        return _libgeoda.VecUINT8_size(self)

    def swap(self, v):
        return _libgeoda.VecUINT8_swap(self, v)

    def begin(self):
        return _libgeoda.VecUINT8_begin(self)

    def end(self):
        return _libgeoda.VecUINT8_end(self)

    def rbegin(self):
        return _libgeoda.VecUINT8_rbegin(self)

    def rend(self):
        return _libgeoda.VecUINT8_rend(self)

    def clear(self):
        return _libgeoda.VecUINT8_clear(self)

    def get_allocator(self):
        return _libgeoda.VecUINT8_get_allocator(self)

    def pop_back(self):
        return _libgeoda.VecUINT8_pop_back(self)

    def erase(self, *args):
        return _libgeoda.VecUINT8_erase(self, *args)

    def __init__(self, *args):
        _libgeoda.VecUINT8_swiginit(self, _libgeoda.new_VecUINT8(*args))

    def push_back(self, x):
        return _libgeoda.VecUINT8_push_back(self, x)

    def front(self):
        return _libgeoda.VecUINT8_front(self)

    def back(self):
        return _libgeoda.VecUINT8_back(self)

    def assign(self, n, x):
        return _libgeoda.VecUINT8_assign(self, n, x)

    def resize(self, *args):
        return _libgeoda.VecUINT8_resize(self, *args)

    def insert(self, *args):
        return _libgeoda.VecUINT8_insert(self, *args)

    def reserve(self, n):
        return _libgeoda.VecUINT8_reserve(self, n)

    def capacity(self):
        return _libgeoda.VecUINT8_capacity(self)
    __swig_destroy__ = _libgeoda.delete_VecUINT8

# Register VecUINT8 in _libgeoda:
_libgeoda.VecUINT8_swigregister(VecUINT8)

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

    def iterator(self):
        return _libgeoda.VecVecUINT8_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libgeoda.VecVecUINT8___nonzero__(self)

    def __bool__(self):
        return _libgeoda.VecVecUINT8___bool__(self)

    def __len__(self):
        return _libgeoda.VecVecUINT8___len__(self)

    def __getslice__(self, i, j):
        return _libgeoda.VecVecUINT8___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libgeoda.VecVecUINT8___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libgeoda.VecVecUINT8___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libgeoda.VecVecUINT8___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libgeoda.VecVecUINT8___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libgeoda.VecVecUINT8___setitem__(self, *args)

    def pop(self):
        return _libgeoda.VecVecUINT8_pop(self)

    def append(self, x):
        return _libgeoda.VecVecUINT8_append(self, x)

    def empty(self):
        return _libgeoda.VecVecUINT8_empty(self)

    def size(self):
        return _libgeoda.VecVecUINT8_size(self)

    def swap(self, v):
        return _libgeoda.VecVecUINT8_swap(self, v)

    def begin(self):
        return _libgeoda.VecVecUINT8_begin(self)

    def end(self):
        return _libgeoda.VecVecUINT8_end(self)

    def rbegin(self):
        return _libgeoda.VecVecUINT8_rbegin(self)

    def rend(self):
        return _libgeoda.VecVecUINT8_rend(self)

    def clear(self):
        return _libgeoda.VecVecUINT8_clear(self)

    def get_allocator(self):
        return _libgeoda.VecVecUINT8_get_allocator(self)

    def pop_back(self):
        return _libgeoda.VecVecUINT8_pop_back(self)

    def erase(self, *args):
        return _libgeoda.VecVecUINT8_erase(self, *args)

    def __init__(self, *args):
        _libgeoda.VecVecUINT8_swiginit(self, _libgeoda.new_VecVecUINT8(*args))

    def push_back(self, x):
        return _libgeoda.VecVecUINT8_push_back(self, x)

    def front(self):
        return _libgeoda.VecVecUINT8_front(self)

    def back(self):
        return _libgeoda.VecVecUINT8_back(self)

    def assign(self, n, x):
        return _libgeoda.VecVecUINT8_assign(self, n, x)

    def resize(self, *args):
        return _libgeoda.VecVecUINT8_resize(self, *args)

    def insert(self, *args):
        return _libgeoda.VecVecUINT8_insert(self, *args)

    def reserve(self, n):
        return _libgeoda.VecVecUINT8_reserve(self, n)

    def capacity(self):
        return _libgeoda.VecVecUINT8_capacity(self)
    __swig_destroy__ = _libgeoda.delete_VecVecUINT8

# Register VecVecUINT8 in _libgeoda:
_libgeoda.VecVecUINT8_swigregister(VecVecUINT8)

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

    def iterator(self):
        return _libgeoda.VecVecChar_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libgeoda.VecVecChar___nonzero__(self)

    def __bool__(self):
        return _libgeoda.VecVecChar___bool__(self)

    def __len__(self):
        return _libgeoda.VecVecChar___len__(self)

    def __getslice__(self, i, j):
        return _libgeoda.VecVecChar___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libgeoda.VecVecChar___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libgeoda.VecVecChar___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libgeoda.VecVecChar___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libgeoda.VecVecChar___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libgeoda.VecVecChar___setitem__(self, *args)

    def pop(self):
        return _libgeoda.VecVecChar_pop(self)

    def append(self, x):
        return _libgeoda.VecVecChar_append(self, x)

    def empty(self):
        return _libgeoda.VecVecChar_empty(self)

    def size(self):
        return _libgeoda.VecVecChar_size(self)

    def swap(self, v):
        return _libgeoda.VecVecChar_swap(self, v)

    def begin(self):
        return _libgeoda.VecVecChar_begin(self)

    def end(self):
        return _libgeoda.VecVecChar_end(self)

    def rbegin(self):
        return _libgeoda.VecVecChar_rbegin(self)

    def rend(self):
        return _libgeoda.VecVecChar_rend(self)

    def clear(self):
        return _libgeoda.VecVecChar_clear(self)

    def get_allocator(self):
        return _libgeoda.VecVecChar_get_allocator(self)

    def pop_back(self):
        return _libgeoda.VecVecChar_pop_back(self)

    def erase(self, *args):
        return _libgeoda.VecVecChar_erase(self, *args)

    def __init__(self, *args):
        _libgeoda.VecVecChar_swiginit(self, _libgeoda.new_VecVecChar(*args))

    def push_back(self, x):
        return _libgeoda.VecVecChar_push_back(self, x)

    def front(self):
        return _libgeoda.VecVecChar_front(self)

    def back(self):
        return _libgeoda.VecVecChar_back(self)

    def assign(self, n, x):
        return _libgeoda.VecVecChar_assign(self, n, x)

    def resize(self, *args):
        return _libgeoda.VecVecChar_resize(self, *args)

    def insert(self, *args):
        return _libgeoda.VecVecChar_insert(self, *args)

    def reserve(self, n):
        return _libgeoda.VecVecChar_reserve(self, n)

    def capacity(self):
        return _libgeoda.VecVecChar_capacity(self)
    __swig_destroy__ = _libgeoda.delete_VecVecChar

# Register VecVecChar in _libgeoda:
_libgeoda.VecVecChar_swigregister(VecVecChar)

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

    def __init__(self, *args):
        _libgeoda.Pair_swiginit(self, _libgeoda.new_Pair(*args))
    first = property(_libgeoda.Pair_first_get, _libgeoda.Pair_first_set)
    second = property(_libgeoda.Pair_second_get, _libgeoda.Pair_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _libgeoda.delete_Pair

# Register Pair in _libgeoda:
_libgeoda.Pair_swigregister(Pair)

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

    def iterator(self):
        return _libgeoda.VecPair_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libgeoda.VecPair___nonzero__(self)

    def __bool__(self):
        return _libgeoda.VecPair___bool__(self)

    def __len__(self):
        return _libgeoda.VecPair___len__(self)

    def __getslice__(self, i, j):
        return _libgeoda.VecPair___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libgeoda.VecPair___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libgeoda.VecPair___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libgeoda.VecPair___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libgeoda.VecPair___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libgeoda.VecPair___setitem__(self, *args)

    def pop(self):
        return _libgeoda.VecPair_pop(self)

    def append(self, x):
        return _libgeoda.VecPair_append(self, x)

    def empty(self):
        return _libgeoda.VecPair_empty(self)

    def size(self):
        return _libgeoda.VecPair_size(self)

    def swap(self, v):
        return _libgeoda.VecPair_swap(self, v)

    def begin(self):
        return _libgeoda.VecPair_begin(self)

    def end(self):
        return _libgeoda.VecPair_end(self)

    def rbegin(self):
        return _libgeoda.VecPair_rbegin(self)

    def rend(self):
        return _libgeoda.VecPair_rend(self)

    def clear(self):
        return _libgeoda.VecPair_clear(self)

    def get_allocator(self):
        return _libgeoda.VecPair_get_allocator(self)

    def pop_back(self):
        return _libgeoda.VecPair_pop_back(self)

    def erase(self, *args):
        return _libgeoda.VecPair_erase(self, *args)

    def __init__(self, *args):
        _libgeoda.VecPair_swiginit(self, _libgeoda.new_VecPair(*args))

    def push_back(self, x):
        return _libgeoda.VecPair_push_back(self, x)

    def front(self):
        return _libgeoda.VecPair_front(self)

    def back(self):
        return _libgeoda.VecPair_back(self)

    def assign(self, n, x):
        return _libgeoda.VecPair_assign(self, n, x)

    def resize(self, *args):
        return _libgeoda.VecPair_resize(self, *args)

    def insert(self, *args):
        return _libgeoda.VecPair_insert(self, *args)

    def reserve(self, n):
        return _libgeoda.VecPair_reserve(self, n)

    def capacity(self):
        return _libgeoda.VecPair_capacity(self)
    __swig_destroy__ = _libgeoda.delete_VecPair

# Register VecPair in _libgeoda:
_libgeoda.VecPair_swigregister(VecPair)

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

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

    def CheckNeighbor(self, obs_idx, nbr_idx):
        return _libgeoda.GeoDaWeight_CheckNeighbor(self, obs_idx, nbr_idx)

    def GetNeighbors(self, obs_idx):
        return _libgeoda.GeoDaWeight_GetNeighbors(self, obs_idx)

    def GetNeighborWeights(self, obs_idx):
        return _libgeoda.GeoDaWeight_GetNeighborWeights(self, obs_idx)

    def Update(self, undefs):
        return _libgeoda.GeoDaWeight_Update(self, undefs)

    def HasIsolates(self):
        return _libgeoda.GeoDaWeight_HasIsolates(self)

    def GetNbrStats(self):
        return _libgeoda.GeoDaWeight_GetNbrStats(self)

    def GetNbrSize(self, obs_idx):
        return _libgeoda.GeoDaWeight_GetNbrSize(self, obs_idx)

    def SpatialLag(self, obs_idx, data):
        return _libgeoda.GeoDaWeight_SpatialLag(self, obs_idx, data)

    def Save(self, *args):
        return _libgeoda.GeoDaWeight_Save(self, *args)

    def IsSymmetric(self):
        return _libgeoda.GeoDaWeight_IsSymmetric(self)

    def GetSparsity(self):
        return _libgeoda.GeoDaWeight_GetSparsity(self)

    def GetMinNbrs(self):
        return _libgeoda.GeoDaWeight_GetMinNbrs(self)

    def GetMaxNbrs(self):
        return _libgeoda.GeoDaWeight_GetMaxNbrs(self)

    def GetMeanNbrs(self):
        return _libgeoda.GeoDaWeight_GetMeanNbrs(self)

    def GetMedianNbrs(self):
        return _libgeoda.GeoDaWeight_GetMedianNbrs(self)

    def GetNumObs(self):
        return _libgeoda.GeoDaWeight_GetNumObs(self)

    def IsInternalUse(self):
        return _libgeoda.GeoDaWeight_IsInternalUse(self)

    def GetTitle(self):
        return _libgeoda.GeoDaWeight_GetTitle(self)

    def GetIDName(self):
        return _libgeoda.GeoDaWeight_GetIDName(self)

    def GetUID(self):
        return _libgeoda.GeoDaWeight_GetUID(self)
    gal_type = _libgeoda.GeoDaWeight_gal_type
    gwt_type = _libgeoda.GeoDaWeight_gwt_type
    weight_type = property(_libgeoda.GeoDaWeight_weight_type_get, _libgeoda.GeoDaWeight_weight_type_set)
    wflnm = property(_libgeoda.GeoDaWeight_wflnm_get, _libgeoda.GeoDaWeight_wflnm_set)
    id_field = property(_libgeoda.GeoDaWeight_id_field_get, _libgeoda.GeoDaWeight_id_field_set)
    title = property(_libgeoda.GeoDaWeight_title_get, _libgeoda.GeoDaWeight_title_set)
    symmetry_checked = property(_libgeoda.GeoDaWeight_symmetry_checked_get, _libgeoda.GeoDaWeight_symmetry_checked_set)
    is_symmetric = property(_libgeoda.GeoDaWeight_is_symmetric_get, _libgeoda.GeoDaWeight_is_symmetric_set)
    num_obs = property(_libgeoda.GeoDaWeight_num_obs_get, _libgeoda.GeoDaWeight_num_obs_set)
    sparsity = property(_libgeoda.GeoDaWeight_sparsity_get, _libgeoda.GeoDaWeight_sparsity_set)
    min_nbrs = property(_libgeoda.GeoDaWeight_min_nbrs_get, _libgeoda.GeoDaWeight_min_nbrs_set)
    max_nbrs = property(_libgeoda.GeoDaWeight_max_nbrs_get, _libgeoda.GeoDaWeight_max_nbrs_set)
    mean_nbrs = property(_libgeoda.GeoDaWeight_mean_nbrs_get, _libgeoda.GeoDaWeight_mean_nbrs_set)
    median_nbrs = property(_libgeoda.GeoDaWeight_median_nbrs_get, _libgeoda.GeoDaWeight_median_nbrs_set)
    is_internal_use = property(_libgeoda.GeoDaWeight_is_internal_use_get, _libgeoda.GeoDaWeight_is_internal_use_set)
    uid = property(_libgeoda.GeoDaWeight_uid_get, _libgeoda.GeoDaWeight_uid_set)

# Register GeoDaWeight in _libgeoda:
_libgeoda.GeoDaWeight_swigregister(GeoDaWeight)


def WeightsIntersection(ws):
    return _libgeoda.WeightsIntersection(ws)

def ReadIdField(w_fname):
    return _libgeoda.ReadIdField(w_fname)
class LISA(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def ComputeLoalSA(self):
        return _libgeoda.LISA_ComputeLoalSA(self)

    def CalcPseudoP(self):
        return _libgeoda.LISA_CalcPseudoP(self)

    def CalcPseudoP_threaded(self):
        return _libgeoda.LISA_CalcPseudoP_threaded(self)

    def CalcPseudoP_range(self, obs_start, obs_end, seed_start):
        return _libgeoda.LISA_CalcPseudoP_range(self, obs_start, obs_end, seed_start)

    def PermCreateTable_threaded(self):
        return _libgeoda.LISA_PermCreateTable_threaded(self)

    def PermCreateRange(self, perm_start, perm_end, max_neighbor, seed_start):
        return _libgeoda.LISA_PermCreateRange(self, perm_start, perm_end, max_neighbor, seed_start)

    def PermCalcPseudoP_threaded(self):
        return _libgeoda.LISA_PermCalcPseudoP_threaded(self)

    def PermCalcPseudoP_range(self, obs_start, obs_end, seed_start):
        return _libgeoda.LISA_PermCalcPseudoP_range(self, obs_start, obs_end, seed_start)

    def PermLocalSA(self, *args):
        return _libgeoda.LISA_PermLocalSA(self, *args)

    def CountLargerSA(self, cnt, permutedSA):
        return _libgeoda.LISA_CountLargerSA(self, cnt, permutedSA)

    def Run(self):
        return _libgeoda.LISA_Run(self)

    def SetSignificanceFilter(self, filter_id):
        return _libgeoda.LISA_SetSignificanceFilter(self, filter_id)

    def GetSignificanceFilter(self):
        return _libgeoda.LISA_GetSignificanceFilter(self)

    def GetSignificanceCutoff(self):
        return _libgeoda.LISA_GetSignificanceCutoff(self)

    def SetSignificanceCutoff(self, val):
        return _libgeoda.LISA_SetSignificanceCutoff(self, val)

    def GetUserCutoff(self):
        return _libgeoda.LISA_GetUserCutoff(self)

    def SetUserCutoff(self, val):
        return _libgeoda.LISA_SetUserCutoff(self, val)

    def GetBO(self, current_p):
        return _libgeoda.LISA_GetBO(self, current_p)

    def GetFDR(self, current_p):
        return _libgeoda.LISA_GetFDR(self, current_p)

    def GetNumPermutations(self):
        return _libgeoda.LISA_GetNumPermutations(self)

    def SetNumPermutations(self, val):
        return _libgeoda.LISA_SetNumPermutations(self, val)

    def GetLastUsedSeed(self):
        return _libgeoda.LISA_GetLastUsedSeed(self)

    def SetLastUsedSeed(self, seed):
        return _libgeoda.LISA_SetLastUsedSeed(self, seed)

    def IsReuseLastSeed(self):
        return _libgeoda.LISA_IsReuseLastSeed(self)

    def SetReuseLastSeed(self, reuse):
        return _libgeoda.LISA_SetReuseLastSeed(self, reuse)

    def GetHasIsolates(self):
        return _libgeoda.LISA_GetHasIsolates(self)

    def GetHasUndefined(self):
        return _libgeoda.LISA_GetHasUndefined(self)

    def GetDefaultCategories(self):
        return _libgeoda.LISA_GetDefaultCategories(self)

    def GetDefaultCutoffs(self):
        return _libgeoda.LISA_GetDefaultCutoffs(self)

    def GetLocalSignificanceValues(self):
        return _libgeoda.LISA_GetLocalSignificanceValues(self)

    def GetClusterIndicators(self):
        return _libgeoda.LISA_GetClusterIndicators(self)

    def GetSigCatIndicators(self):
        return _libgeoda.LISA_GetSigCatIndicators(self)

    def GetNumNeighbors(self):
        return _libgeoda.LISA_GetNumNeighbors(self)

    def GetSpatialLagValues(self):
        return _libgeoda.LISA_GetSpatialLagValues(self)

    def GetLISAValues(self):
        return _libgeoda.LISA_GetLISAValues(self)

    def IsRowStandardize(self):
        return _libgeoda.LISA_IsRowStandardize(self)

    def SetRowStandardize(self, rowStandardize):
        return _libgeoda.LISA_SetRowStandardize(self, rowStandardize)

    def GetNumThreads(self):
        return _libgeoda.LISA_GetNumThreads(self)

    def SetNumThreads(self, n_threads):
        return _libgeoda.LISA_SetNumThreads(self, n_threads)

    def GetLabels(self):
        return _libgeoda.LISA_GetLabels(self)

    def GetColors(self):
        return _libgeoda.LISA_GetColors(self)

# Register LISA in _libgeoda:
_libgeoda.LISA_swigregister(LISA)

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

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

    def ComputeLoalSA(self):
        return _libgeoda.BatchLISA_ComputeLoalSA(self)

    def CalcPseudoP(self):
        return _libgeoda.BatchLISA_CalcPseudoP(self)

    def CalcPseudoP_threaded(self):
        return _libgeoda.BatchLISA_CalcPseudoP_threaded(self)

    def CalcPseudoP_range(self, obs_start, obs_end, seed_start):
        return _libgeoda.BatchLISA_CalcPseudoP_range(self, obs_start, obs_end, seed_start)

    def PermLocalSA(self, cnt, perm, permNeighbors, permutedSA):
        return _libgeoda.BatchLISA_PermLocalSA(self, cnt, perm, permNeighbors, permutedSA)

    def CountLargerSA(self, cnt, permutedSA):
        return _libgeoda.BatchLISA_CountLargerSA(self, cnt, permutedSA)

    def Run(self):
        return _libgeoda.BatchLISA_Run(self)

    def SetSignificanceFilter(self, filter_id):
        return _libgeoda.BatchLISA_SetSignificanceFilter(self, filter_id)

    def GetSignificanceFilter(self):
        return _libgeoda.BatchLISA_GetSignificanceFilter(self)

    def GetSignificanceCutoff(self):
        return _libgeoda.BatchLISA_GetSignificanceCutoff(self)

    def SetSignificanceCutoff(self, val):
        return _libgeoda.BatchLISA_SetSignificanceCutoff(self, val)

    def GetUserCutoff(self):
        return _libgeoda.BatchLISA_GetUserCutoff(self)

    def SetUserCutoff(self, val):
        return _libgeoda.BatchLISA_SetUserCutoff(self, val)

    def GetBO(self, current_p):
        return _libgeoda.BatchLISA_GetBO(self, current_p)

    def GetFDR(self, current_p, idx):
        return _libgeoda.BatchLISA_GetFDR(self, current_p, idx)

    def GetNumPermutations(self):
        return _libgeoda.BatchLISA_GetNumPermutations(self)

    def SetNumPermutations(self, val):
        return _libgeoda.BatchLISA_SetNumPermutations(self, val)

    def GetLastUsedSeed(self):
        return _libgeoda.BatchLISA_GetLastUsedSeed(self)

    def SetLastUsedSeed(self, seed):
        return _libgeoda.BatchLISA_SetLastUsedSeed(self, seed)

    def IsReuseLastSeed(self):
        return _libgeoda.BatchLISA_IsReuseLastSeed(self)

    def SetReuseLastSeed(self, reuse):
        return _libgeoda.BatchLISA_SetReuseLastSeed(self, reuse)

    def GetHasIsolates(self):
        return _libgeoda.BatchLISA_GetHasIsolates(self)

    def GetHasUndefined(self):
        return _libgeoda.BatchLISA_GetHasUndefined(self)

    def GetDefaultCategories(self):
        return _libgeoda.BatchLISA_GetDefaultCategories(self)

    def GetDefaultCutoffs(self):
        return _libgeoda.BatchLISA_GetDefaultCutoffs(self)

    def GetLocalSignificanceValues(self, idx):
        return _libgeoda.BatchLISA_GetLocalSignificanceValues(self, idx)

    def GetClusterIndicators(self, idx):
        return _libgeoda.BatchLISA_GetClusterIndicators(self, idx)

    def GetSigCatIndicators(self, idx):
        return _libgeoda.BatchLISA_GetSigCatIndicators(self, idx)

    def GetNumNeighbors(self):
        return _libgeoda.BatchLISA_GetNumNeighbors(self)

    def GetSpatialLagValues(self, idx):
        return _libgeoda.BatchLISA_GetSpatialLagValues(self, idx)

    def GetLISAValues(self, idx):
        return _libgeoda.BatchLISA_GetLISAValues(self, idx)

    def IsRowStandardize(self):
        return _libgeoda.BatchLISA_IsRowStandardize(self)

    def SetRowStandardize(self, rowStandardize):
        return _libgeoda.BatchLISA_SetRowStandardize(self, rowStandardize)

    def GetNumThreads(self):
        return _libgeoda.BatchLISA_GetNumThreads(self)

    def SetNumThreads(self, n_threads):
        return _libgeoda.BatchLISA_SetNumThreads(self, n_threads)

    def GetLabels(self):
        return _libgeoda.BatchLISA_GetLabels(self)

    def GetColors(self):
        return _libgeoda.BatchLISA_GetColors(self)

# Register BatchLISA in _libgeoda:
_libgeoda.BatchLISA_swigregister(BatchLISA)

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

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

    def GetNumObs(self):
        return _libgeoda.AbstractGeoDa_GetNumObs(self)

    def GetCentroids(self):
        return _libgeoda.AbstractGeoDa_GetCentroids(self)

    def GetMapType(self):
        return _libgeoda.AbstractGeoDa_GetMapType(self)

    def GetMapTypeName(self):
        return _libgeoda.AbstractGeoDa_GetMapTypeName(self)

    def GetMainMap(self):
        return _libgeoda.AbstractGeoDa_GetMainMap(self)

# Register AbstractGeoDa in _libgeoda:
_libgeoda.AbstractGeoDa_swigregister(AbstractGeoDa)

class GeoDaColumn(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    integer_type = _libgeoda.GeoDaColumn_integer_type
    string_type = _libgeoda.GeoDaColumn_string_type
    real_type = _libgeoda.GeoDaColumn_real_type
    name = property(_libgeoda.GeoDaColumn_name_get, _libgeoda.GeoDaColumn_name_set)
    field_type = property(_libgeoda.GeoDaColumn_field_type_get, _libgeoda.GeoDaColumn_field_type_set)
    field_length = property(_libgeoda.GeoDaColumn_field_length_get, _libgeoda.GeoDaColumn_field_length_set)
    field_decimals = property(_libgeoda.GeoDaColumn_field_decimals_get, _libgeoda.GeoDaColumn_field_decimals_set)
    undefs = property(_libgeoda.GeoDaColumn_undefs_get, _libgeoda.GeoDaColumn_undefs_set)

    def __init__(self, nm, ft, flen, fdec):
        _libgeoda.GeoDaColumn_swiginit(self, _libgeoda.new_GeoDaColumn(nm, ft, flen, fdec))
    __swig_destroy__ = _libgeoda.delete_GeoDaColumn

# Register GeoDaColumn in _libgeoda:
_libgeoda.GeoDaColumn_swigregister(GeoDaColumn)

class GeoDaIntColumn(GeoDaColumn):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    data = property(_libgeoda.GeoDaIntColumn_data_get, _libgeoda.GeoDaIntColumn_data_set)

    def GetData(self):
        return _libgeoda.GeoDaIntColumn_GetData(self)

    def SetData(self, vals):
        return _libgeoda.GeoDaIntColumn_SetData(self, vals)

    def __init__(self, nm, vals):
        _libgeoda.GeoDaIntColumn_swiginit(self, _libgeoda.new_GeoDaIntColumn(nm, vals))
    __swig_destroy__ = _libgeoda.delete_GeoDaIntColumn

# Register GeoDaIntColumn in _libgeoda:
_libgeoda.GeoDaIntColumn_swigregister(GeoDaIntColumn)

class GeoDaStringColumn(GeoDaColumn):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    data = property(_libgeoda.GeoDaStringColumn_data_get, _libgeoda.GeoDaStringColumn_data_set)

    def GetData(self):
        return _libgeoda.GeoDaStringColumn_GetData(self)

    def SetData(self, vals):
        return _libgeoda.GeoDaStringColumn_SetData(self, vals)

    def __init__(self, nm, vals):
        _libgeoda.GeoDaStringColumn_swiginit(self, _libgeoda.new_GeoDaStringColumn(nm, vals))
    __swig_destroy__ = _libgeoda.delete_GeoDaStringColumn

# Register GeoDaStringColumn in _libgeoda:
_libgeoda.GeoDaStringColumn_swigregister(GeoDaStringColumn)

class GeoDaRealColumn(GeoDaColumn):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    data = property(_libgeoda.GeoDaRealColumn_data_get, _libgeoda.GeoDaRealColumn_data_set)

    def GetData(self):
        return _libgeoda.GeoDaRealColumn_GetData(self)

    def SetData(self, vals):
        return _libgeoda.GeoDaRealColumn_SetData(self, vals)

    def __init__(self, nm, vals):
        _libgeoda.GeoDaRealColumn_swiginit(self, _libgeoda.new_GeoDaRealColumn(nm, vals))
    __swig_destroy__ = _libgeoda.delete_GeoDaRealColumn

# Register GeoDaRealColumn in _libgeoda:
_libgeoda.GeoDaRealColumn_swigregister(GeoDaRealColumn)

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

    def __init__(self):
        _libgeoda.GeoDaTable_swiginit(self, _libgeoda.new_GeoDaTable())
    __swig_destroy__ = _libgeoda.delete_GeoDaTable

    def AddIntColumn(self, *args):
        return _libgeoda.GeoDaTable_AddIntColumn(self, *args)

    def AddStringColumn(self, *args):
        return _libgeoda.GeoDaTable_AddStringColumn(self, *args)

    def AddRealColumn(self, *args):
        return _libgeoda.GeoDaTable_AddRealColumn(self, *args)

    def GetColumn(self, *args):
        return _libgeoda.GeoDaTable_GetColumn(self, *args)

    def GetNumCols(self):
        return _libgeoda.GeoDaTable_GetNumCols(self)

# Register GeoDaTable in _libgeoda:
_libgeoda.GeoDaTable_swigregister(GeoDaTable)

class GeoDa(AbstractGeoDa):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    point_type = _libgeoda.GeoDa_point_type
    polygon_type = _libgeoda.GeoDa_polygon_type
    line_type = _libgeoda.GeoDa_line_type
    unknown_type = _libgeoda.GeoDa_unknown_type

    def __init__(self, *args):
        _libgeoda.GeoDa_swiginit(self, _libgeoda.new_GeoDa(*args))
    __swig_destroy__ = _libgeoda.delete_GeoDa

    def GetNumObs(self):
        return _libgeoda.GeoDa_GetNumObs(self)

    def GetCentroids(self):
        return _libgeoda.GeoDa_GetCentroids(self)

    def GetMapType(self):
        return _libgeoda.GeoDa_GetMapType(self)

    def GetMapTypeName(self):
        return _libgeoda.GeoDa_GetMapTypeName(self)

    def GetMainMap(self):
        return _libgeoda.GeoDa_GetMainMap(self)

    def GetNumCols(self):
        return _libgeoda.GeoDa_GetNumCols(self)

    def GetFieldTypes(self):
        return _libgeoda.GeoDa_GetFieldTypes(self)

    def GetFieldNames(self):
        return _libgeoda.GeoDa_GetFieldNames(self)

    def GetNumericCol(self, col_name):
        return _libgeoda.GeoDa_GetNumericCol(self, col_name)

    def GetIntegerCol(self, col_name):
        return _libgeoda.GeoDa_GetIntegerCol(self, col_name)

    def GetStringCol(self, col_name):
        return _libgeoda.GeoDa_GetStringCol(self, col_name)

    def GetNullValues(self, col_name):
        return _libgeoda.GeoDa_GetNullValues(self, col_name)

# Register GeoDa in _libgeoda:
_libgeoda.GeoDa_swigregister(GeoDa)


def test():
    return _libgeoda.test()

def ToGeoDaColumn(*args):
    return _libgeoda.ToGeoDaColumn(*args)

def CreateGeoDaFromGPD(layer_name, map_type, wkbs, wkb_bytes_len):
    return _libgeoda.CreateGeoDaFromGPD(layer_name, map_type, wkbs, wkb_bytes_len)

def CreateGeoDaFromSHP(pDsPath, layer_name=None):
    return _libgeoda.CreateGeoDaFromSHP(pDsPath, layer_name)

def gda_localmoran(w, data, undefs, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used):
    return _libgeoda.gda_localmoran(w, data, undefs, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used)

def gda_localmoran_eb(w, event_data, base_data, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used):
    return _libgeoda.gda_localmoran_eb(w, event_data, base_data, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used)

def gda_batchlocalmoran(w, data, undefs, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used):
    return _libgeoda.gda_batchlocalmoran(w, data, undefs, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used)

def gda_localgeary(w, data, undefs, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used):
    return _libgeoda.gda_localgeary(w, data, undefs, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used)

def gda_localmultigeary(w, data, undefs, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used):
    return _libgeoda.gda_localmultigeary(w, data, undefs, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used)

def gda_localjoincount(w, data, undefs, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used):
    return _libgeoda.gda_localjoincount(w, data, undefs, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used)

def gda_localmultijoincount(w, data, undefs, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used):
    return _libgeoda.gda_localmultijoincount(w, data, undefs, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used)

def gda_localg(w, data, undefs, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used):
    return _libgeoda.gda_localg(w, data, undefs, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used)

def gda_localgstar(w, data, undefs, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used):
    return _libgeoda.gda_localgstar(w, data, undefs, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used)

def gda_quantilelisa(w, k, quantile, data, undefs, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used):
    return _libgeoda.gda_quantilelisa(w, k, quantile, data, undefs, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used)

def gda_multiquantilelisa(w, k_s, quantile_s, data_s, undefs_s, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used):
    return _libgeoda.gda_multiquantilelisa(w, k_s, quantile_s, data_s, undefs_s, significance_cutoff, nCPUs, permutations, permutation_method, last_seed_used)

def gda_fdr(lisa, current_p):
    return _libgeoda.gda_fdr(lisa, current_p)

def gda_bo(lisa, current_p):
    return _libgeoda.gda_bo(lisa, current_p)

def gda_neighbor_match_test(geoda, k, power, is_inverse, is_arc, is_mile, data, scale_method, dist_type):
    return _libgeoda.gda_neighbor_match_test(geoda, k, power, is_inverse, is_arc, is_mile, data, scale_method, dist_type)

def gda_demean(data):
    return _libgeoda.gda_demean(data)

def gda_standardize(data):
    return _libgeoda.gda_standardize(data)

def gda_standardize_mad(data):
    return _libgeoda.gda_standardize_mad(data)

def gda_naturalbreaks(k, data, undefs):
    return _libgeoda.gda_naturalbreaks(k, data, undefs)

def gda_quantilebreaks(k, data, undefs):
    return _libgeoda.gda_quantilebreaks(k, data, undefs)

def gda_hinge15breaks(data, undefs):
    return _libgeoda.gda_hinge15breaks(data, undefs)

def gda_hinge30breaks(data, undefs):
    return _libgeoda.gda_hinge30breaks(data, undefs)

def gda_percentilebreaks(data, undefs):
    return _libgeoda.gda_percentilebreaks(data, undefs)

def gda_stddevbreaks(data, undefs):
    return _libgeoda.gda_stddevbreaks(data, undefs)

def gda_transform_inplace(vals, method):
    return _libgeoda.gda_transform_inplace(vals, method)

def gda_rateStandardizeEB(P, E, results, undefined):
    return _libgeoda.gda_rateStandardizeEB(P, E, results, undefined)

def gda_queen_weights(geoda, order, include_lower_order, precision_threshold):
    return _libgeoda.gda_queen_weights(geoda, order, include_lower_order, precision_threshold)

def gda_rook_weights(geoda, order, include_lower_order, precision_threshold):
    return _libgeoda.gda_rook_weights(geoda, order, include_lower_order, precision_threshold)

def gda_knn_weights(geoda, k, power, is_inverse, is_arc, is_mile, kernel, bandwidth, adaptive_bandwidth, use_kernel_diagnals, polyid):
    return _libgeoda.gda_knn_weights(geoda, k, power, is_inverse, is_arc, is_mile, kernel, bandwidth, adaptive_bandwidth, use_kernel_diagnals, polyid)

def gda_min_distthreshold(geoda, is_arc, is_mile):
    return _libgeoda.gda_min_distthreshold(geoda, is_arc, is_mile)

def gda_distance_weights(geoda, dist_thres, polyid, power, is_inverse, is_arc, is_mile, kernel, use_kernel_diagonals):
    return _libgeoda.gda_distance_weights(geoda, dist_thres, polyid, power, is_inverse, is_arc, is_mile, kernel, use_kernel_diagonals)

def gda_load_weights(weights_path):
    return _libgeoda.gda_load_weights(weights_path)

def gda_azp_greedy(p, w, _data, scale_method, inits, min_bounds, max_bounds, init_regions, distance_method, rnd_seed):
    return _libgeoda.gda_azp_greedy(p, w, _data, scale_method, inits, min_bounds, max_bounds, init_regions, distance_method, rnd_seed)

def gda_azp_sa(p, w, _data, scale_method, inits, cooling_rate, sa_maxit, min_bounds, max_bounds, init_regions, distance_method, rnd_seed):
    return _libgeoda.gda_azp_sa(p, w, _data, scale_method, inits, cooling_rate, sa_maxit, min_bounds, max_bounds, init_regions, distance_method, rnd_seed)

def gda_azp_tabu(p, w, _data, scale_method, inits, tabu_length, conv_tabu, min_bounds, max_bounds, init_regions, distance_method, rnd_seed):
    return _libgeoda.gda_azp_tabu(p, w, _data, scale_method, inits, tabu_length, conv_tabu, min_bounds, max_bounds, init_regions, distance_method, rnd_seed)

def gda_maxp_greedy(w, _data, scale_method, iterations, min_bounds, max_bounds, init_regions, distance_method, rnd_seed, cpu_threads):
    return _libgeoda.gda_maxp_greedy(w, _data, scale_method, iterations, min_bounds, max_bounds, init_regions, distance_method, rnd_seed, cpu_threads)

def gda_maxp_sa(w, _data, scale_method, iterations, cooling_rate, sa_maxit, min_bounds, max_bounds, init_regions, distance_method, rnd_seed, cpu_threads):
    return _libgeoda.gda_maxp_sa(w, _data, scale_method, iterations, cooling_rate, sa_maxit, min_bounds, max_bounds, init_regions, distance_method, rnd_seed, cpu_threads)

def gda_maxp_tabu(w, _data, scale_method, iterations, tabu_length, conv_tabu, min_bounds, max_bounds, init_regions, distance_method, rnd_seed, cpu_threads):
    return _libgeoda.gda_maxp_tabu(w, _data, scale_method, iterations, tabu_length, conv_tabu, min_bounds, max_bounds, init_regions, distance_method, rnd_seed, cpu_threads)

def gda_redcap(k, w, _data, scale_method, redcap_method, distance_method, bound_vals, min_bound, rand_seed, cpu_threads):
    return _libgeoda.gda_redcap(k, w, _data, scale_method, redcap_method, distance_method, bound_vals, min_bound, rand_seed, cpu_threads)

def gda_skater(k, w, _data, scale_method, distance_method, bound_vals, min_bound, rand_seed, cpu_threads):
    return _libgeoda.gda_skater(k, w, _data, scale_method, distance_method, bound_vals, min_bound, rand_seed, cpu_threads)

def gda_schc(k, w, _data, scale_method, linkage_method, distance_method, bound_vals, min_bound):
    return _libgeoda.gda_schc(k, w, _data, scale_method, linkage_method, distance_method, bound_vals, min_bound)

def gda_sumofsquares(vals):
    return _libgeoda.gda_sumofsquares(vals)

def gda_totalsumofsquare(vals):
    return _libgeoda.gda_totalsumofsquare(vals)

def gda_withinsumofsquare(solution, vals):
    return _libgeoda.gda_withinsumofsquare(solution, vals)

def gda_betweensumofsquare(solution, data):
    return _libgeoda.gda_betweensumofsquare(solution, data)

def utf8_strlen(str):
    return _libgeoda.utf8_strlen(str)

def SuggestDoubleParams(length, decimals, suggest_len, suggest_dec):
    return _libgeoda.SuggestDoubleParams(length, decimals, suggest_len, suggest_dec)

def GetMaxDouble(length, decimals, suggest_len=None, suggest_dec=None):
    return _libgeoda.GetMaxDouble(length, decimals, suggest_len, suggest_dec)

def GetMaxDoubleString(length, decimals):
    return _libgeoda.GetMaxDoubleString(length, decimals)

def GetMinDouble(length, decimals, suggest_len=None, suggest_dec=None):
    return _libgeoda.GetMinDouble(length, decimals, suggest_len, suggest_dec)

def GetMinDoubleString(length, decimals):
    return _libgeoda.GetMinDoubleString(length, decimals)

def GetMaxInt(length):
    return _libgeoda.GetMaxInt(length)

def GetMaxIntString(length):
    return _libgeoda.GetMaxIntString(length)

def GetMinInt(length):
    return _libgeoda.GetMinInt(length)

def GetMinIntString(length):
    return _libgeoda.GetMinIntString(length)

def ThomasWangHashUInt64(key):
    return _libgeoda.ThomasWangHashUInt64(key)

def ThomasWangHashDouble(key):
    return _libgeoda.ThomasWangHashDouble(key)

def ThomasWangDouble(key):
    return _libgeoda.ThomasWangDouble(key)

def IsNaN(x):
    return _libgeoda.IsNaN(x)

def IsFinite(x):
    return _libgeoda.IsFinite(x)

def factorial(n):
    return _libgeoda.factorial(n)

def combinatorial(n, r):
    return _libgeoda.combinatorial(n, r)

def CreateUUID(nSize):
    return _libgeoda.CreateUUID(nSize)

def dbl_int_pair_cmp_less(ind1, ind2):
    return _libgeoda.dbl_int_pair_cmp_less(ind1, ind2)

def dbl_int_pair_cmp_greater(ind1, ind2):
    return _libgeoda.dbl_int_pair_cmp_greater(ind1, ind2)

def dbl_int_pair_cmp_second_less(ind1, ind2):
    return _libgeoda.dbl_int_pair_cmp_second_less(ind1, ind2)

def dbl_int_pair_cmp_second_greater(ind1, ind2):
    return _libgeoda.dbl_int_pair_cmp_second_greater(ind1, ind2)

def percentile(*args):
    return _libgeoda.percentile(*args)
class HingeStats(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _libgeoda.HingeStats_swiginit(self, _libgeoda.new_HingeStats())

    def CalculateHingeStats(self, *args):
        return _libgeoda.HingeStats_CalculateHingeStats(self, *args)
    num_obs = property(_libgeoda.HingeStats_num_obs_get, _libgeoda.HingeStats_num_obs_set)
    min_val = property(_libgeoda.HingeStats_min_val_get, _libgeoda.HingeStats_min_val_set)
    max_val = property(_libgeoda.HingeStats_max_val_get, _libgeoda.HingeStats_max_val_set)
    is_even_num_obs = property(_libgeoda.HingeStats_is_even_num_obs_get, _libgeoda.HingeStats_is_even_num_obs_set)
    Q1 = property(_libgeoda.HingeStats_Q1_get, _libgeoda.HingeStats_Q1_set)
    Q1_ind = property(_libgeoda.HingeStats_Q1_ind_get, _libgeoda.HingeStats_Q1_ind_set)
    Q2 = property(_libgeoda.HingeStats_Q2_get, _libgeoda.HingeStats_Q2_set)
    Q2_ind = property(_libgeoda.HingeStats_Q2_ind_get, _libgeoda.HingeStats_Q2_ind_set)
    Q3 = property(_libgeoda.HingeStats_Q3_get, _libgeoda.HingeStats_Q3_set)
    Q3_ind = property(_libgeoda.HingeStats_Q3_ind_get, _libgeoda.HingeStats_Q3_ind_set)
    min_IQR_ind = property(_libgeoda.HingeStats_min_IQR_ind_get, _libgeoda.HingeStats_min_IQR_ind_set)
    max_IQR_ind = property(_libgeoda.HingeStats_max_IQR_ind_get, _libgeoda.HingeStats_max_IQR_ind_set)
    IQR = property(_libgeoda.HingeStats_IQR_get, _libgeoda.HingeStats_IQR_set)
    extreme_lower_val_15 = property(_libgeoda.HingeStats_extreme_lower_val_15_get, _libgeoda.HingeStats_extreme_lower_val_15_set)
    extreme_lower_val_30 = property(_libgeoda.HingeStats_extreme_lower_val_30_get, _libgeoda.HingeStats_extreme_lower_val_30_set)
    extreme_upper_val_15 = property(_libgeoda.HingeStats_extreme_upper_val_15_get, _libgeoda.HingeStats_extreme_upper_val_15_set)
    extreme_upper_val_30 = property(_libgeoda.HingeStats_extreme_upper_val_30_get, _libgeoda.HingeStats_extreme_upper_val_30_set)
    __swig_destroy__ = _libgeoda.delete_HingeStats

# Register HingeStats in _libgeoda:
_libgeoda.HingeStats_swigregister(HingeStats)

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

    def __init__(self, *args):
        _libgeoda.SampleStatistics_swiginit(self, _libgeoda.new_SampleStatistics(*args))

    def CalculateFromSample(self, *args):
        return _libgeoda.SampleStatistics_CalculateFromSample(self, *args)

    def ToString(self):
        return _libgeoda.SampleStatistics_ToString(self)
    sample_size = property(_libgeoda.SampleStatistics_sample_size_get, _libgeoda.SampleStatistics_sample_size_set)
    min = property(_libgeoda.SampleStatistics_min_get, _libgeoda.SampleStatistics_min_set)
    max = property(_libgeoda.SampleStatistics_max_get, _libgeoda.SampleStatistics_max_set)
    mean = property(_libgeoda.SampleStatistics_mean_get, _libgeoda.SampleStatistics_mean_set)
    var_with_bessel = property(_libgeoda.SampleStatistics_var_with_bessel_get, _libgeoda.SampleStatistics_var_with_bessel_set)
    var_without_bessel = property(_libgeoda.SampleStatistics_var_without_bessel_get, _libgeoda.SampleStatistics_var_without_bessel_set)
    sd_with_bessel = property(_libgeoda.SampleStatistics_sd_with_bessel_get, _libgeoda.SampleStatistics_sd_with_bessel_set)
    sd_without_bessel = property(_libgeoda.SampleStatistics_sd_without_bessel_get, _libgeoda.SampleStatistics_sd_without_bessel_set)

    @staticmethod
    def CalcMin(data):
        return _libgeoda.SampleStatistics_CalcMin(data)

    @staticmethod
    def CalcMax(data):
        return _libgeoda.SampleStatistics_CalcMax(data)

    @staticmethod
    def CalcMinMax(data, min, max):
        return _libgeoda.SampleStatistics_CalcMinMax(data, min, max)

    @staticmethod
    def CalcMean(*args):
        return _libgeoda.SampleStatistics_CalcMean(*args)
    __swig_destroy__ = _libgeoda.delete_SampleStatistics

# Register SampleStatistics in _libgeoda:
_libgeoda.SampleStatistics_swigregister(SampleStatistics)

def SampleStatistics_CalcMin(data):
    return _libgeoda.SampleStatistics_CalcMin(data)

def SampleStatistics_CalcMax(data):
    return _libgeoda.SampleStatistics_CalcMax(data)

def SampleStatistics_CalcMinMax(data, min, max):
    return _libgeoda.SampleStatistics_CalcMinMax(data, min, max)

def SampleStatistics_CalcMean(*args):
    return _libgeoda.SampleStatistics_CalcMean(*args)

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

    def __init__(self, *args):
        _libgeoda.SimpleLinearRegression_swiginit(self, _libgeoda.new_SimpleLinearRegression(*args))

    def CalculateRegression(self, X, Y, meanX, meanY, varX, varY):
        return _libgeoda.SimpleLinearRegression_CalculateRegression(self, X, Y, meanX, meanY, varX, varY)

    @staticmethod
    def TScoreTo2SidedPValue(tscore, df):
        return _libgeoda.SimpleLinearRegression_TScoreTo2SidedPValue(tscore, df)

    def ToString(self):
        return _libgeoda.SimpleLinearRegression_ToString(self)
    n = property(_libgeoda.SimpleLinearRegression_n_get, _libgeoda.SimpleLinearRegression_n_set)
    covariance = property(_libgeoda.SimpleLinearRegression_covariance_get, _libgeoda.SimpleLinearRegression_covariance_set)
    correlation = property(_libgeoda.SimpleLinearRegression_correlation_get, _libgeoda.SimpleLinearRegression_correlation_set)
    alpha = property(_libgeoda.SimpleLinearRegression_alpha_get, _libgeoda.SimpleLinearRegression_alpha_set)
    beta = property(_libgeoda.SimpleLinearRegression_beta_get, _libgeoda.SimpleLinearRegression_beta_set)
    r_squared = property(_libgeoda.SimpleLinearRegression_r_squared_get, _libgeoda.SimpleLinearRegression_r_squared_set)
    std_err_of_estimate = property(_libgeoda.SimpleLinearRegression_std_err_of_estimate_get, _libgeoda.SimpleLinearRegression_std_err_of_estimate_set)
    std_err_of_beta = property(_libgeoda.SimpleLinearRegression_std_err_of_beta_get, _libgeoda.SimpleLinearRegression_std_err_of_beta_set)
    std_err_of_alpha = property(_libgeoda.SimpleLinearRegression_std_err_of_alpha_get, _libgeoda.SimpleLinearRegression_std_err_of_alpha_set)
    t_score_alpha = property(_libgeoda.SimpleLinearRegression_t_score_alpha_get, _libgeoda.SimpleLinearRegression_t_score_alpha_set)
    t_score_beta = property(_libgeoda.SimpleLinearRegression_t_score_beta_get, _libgeoda.SimpleLinearRegression_t_score_beta_set)
    p_value_alpha = property(_libgeoda.SimpleLinearRegression_p_value_alpha_get, _libgeoda.SimpleLinearRegression_p_value_alpha_set)
    p_value_beta = property(_libgeoda.SimpleLinearRegression_p_value_beta_get, _libgeoda.SimpleLinearRegression_p_value_beta_set)
    valid = property(_libgeoda.SimpleLinearRegression_valid_get, _libgeoda.SimpleLinearRegression_valid_set)
    valid_correlation = property(_libgeoda.SimpleLinearRegression_valid_correlation_get, _libgeoda.SimpleLinearRegression_valid_correlation_set)
    valid_std_err = property(_libgeoda.SimpleLinearRegression_valid_std_err_get, _libgeoda.SimpleLinearRegression_valid_std_err_set)
    error_sum_squares = property(_libgeoda.SimpleLinearRegression_error_sum_squares_get, _libgeoda.SimpleLinearRegression_error_sum_squares_set)
    __swig_destroy__ = _libgeoda.delete_SimpleLinearRegression

# Register SimpleLinearRegression in _libgeoda:
_libgeoda.SimpleLinearRegression_swigregister(SimpleLinearRegression)

def SimpleLinearRegression_TScoreTo2SidedPValue(tscore, df):
    return _libgeoda.SimpleLinearRegression_TScoreTo2SidedPValue(tscore, df)

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

    def __init__(self, *args):
        _libgeoda.AxisScale_swiginit(self, _libgeoda.new_AxisScale(*args))

    def CalculateScale(self, data_min_s, data_max_s, ticks=5):
        return _libgeoda.AxisScale_CalculateScale(self, data_min_s, data_max_s, ticks)

    def SkipEvenTics(self):
        return _libgeoda.AxisScale_SkipEvenTics(self)

    def ShowAllTics(self):
        return _libgeoda.AxisScale_ShowAllTics(self)

    def ToString(self):
        return _libgeoda.AxisScale_ToString(self)
    data_min = property(_libgeoda.AxisScale_data_min_get, _libgeoda.AxisScale_data_min_set)
    data_max = property(_libgeoda.AxisScale_data_max_get, _libgeoda.AxisScale_data_max_set)
    scale_min = property(_libgeoda.AxisScale_scale_min_get, _libgeoda.AxisScale_scale_min_set)
    scale_max = property(_libgeoda.AxisScale_scale_max_get, _libgeoda.AxisScale_scale_max_set)
    scale_range = property(_libgeoda.AxisScale_scale_range_get, _libgeoda.AxisScale_scale_range_set)
    tic_inc = property(_libgeoda.AxisScale_tic_inc_get, _libgeoda.AxisScale_tic_inc_set)
    lbl_precision = property(_libgeoda.AxisScale_lbl_precision_get, _libgeoda.AxisScale_lbl_precision_set)
    lbl_prec_fixed_point = property(_libgeoda.AxisScale_lbl_prec_fixed_point_get, _libgeoda.AxisScale_lbl_prec_fixed_point_set)
    ticks = property(_libgeoda.AxisScale_ticks_get, _libgeoda.AxisScale_ticks_set)
    p = property(_libgeoda.AxisScale_p_get, _libgeoda.AxisScale_p_set)
    tics = property(_libgeoda.AxisScale_tics_get, _libgeoda.AxisScale_tics_set)
    tics_str = property(_libgeoda.AxisScale_tics_str_get, _libgeoda.AxisScale_tics_str_set)
    tics_str_show = property(_libgeoda.AxisScale_tics_str_show_get, _libgeoda.AxisScale_tics_str_show_set)
    __swig_destroy__ = _libgeoda.delete_AxisScale

# Register AxisScale in _libgeoda:
_libgeoda.AxisScale_swigregister(AxisScale)


def flat_2dclusters(n, clusters):
    return _libgeoda.flat_2dclusters(n, clusters)

def BoolToStr(b):
    return _libgeoda.BoolToStr(b)

def StrToBool(s):
    return _libgeoda.StrToBool(s)

def Pad(s, width, pad_left=True):
    return _libgeoda.Pad(s, width, pad_left)

def PadTrim(s, width, pad_left=True):
    return _libgeoda.PadTrim(s, width, pad_left)

def DblToStr(x, precision=3, fixed_point=False):
    return _libgeoda.DblToStr(x, precision, fixed_point)

def IntToStr(x, precision=0):
    return _libgeoda.IntToStr(x, precision)

def Transformation(trans_type, data, undef):
    return _libgeoda.Transformation(trans_type, data, undef)

def MeanAbsoluteDeviation(*args):
    return _libgeoda.MeanAbsoluteDeviation(*args)

def DeviationFromMean(*args):
    return _libgeoda.DeviationFromMean(*args)

def Sum(data):
    return _libgeoda.Sum(data)

def SumOfSquares(data):
    return _libgeoda.SumOfSquares(data)

def Median(data):
    return _libgeoda.Median(data)

def StandardizeData(*args):
    return _libgeoda.StandardizeData(*args)

def RangeAdjust(*args):
    return _libgeoda.RangeAdjust(*args)

def RangeStandardize(*args):
    return _libgeoda.RangeStandardize(*args)

def NaturalBreaks(k, data, undef):
    return _libgeoda.NaturalBreaks(k, data, undef)

def QuantileBreaks(k, data, undef):
    return _libgeoda.QuantileBreaks(k, data, undef)

def Hinge15Breaks(data, undef):
    return _libgeoda.Hinge15Breaks(data, undef)

def Hinge30Breaks(data, undef):
    return _libgeoda.Hinge30Breaks(data, undef)

def PercentileBreaks(data, undef):
    return _libgeoda.PercentileBreaks(data, undef)

def StddevBreaks(data, undef):
    return _libgeoda.StddevBreaks(data, undef)

def Correlation(x, y):
    return _libgeoda.Correlation(x, y)

def GetVariance(data):
    return _libgeoda.GetVariance(data)

def Reverse(val):
    return _libgeoda.Reverse(val)

def ReverseInt(val):
    return _libgeoda.ReverseInt(val)

def SkipTillNumber(s):
    return _libgeoda.SkipTillNumber(s)

def longToString(d, Id, base):
    return _libgeoda.longToString(d, Id, base)

def doubleToString(val, precision):
    return _libgeoda.doubleToString(val, precision)

def strToInt64(*args):
    return _libgeoda.strToInt64(*args)

def validInt(*args):
    return _libgeoda.validInt(*args)

def isEmptyOrSpaces(*args):
    return _libgeoda.isEmptyOrSpaces(*args)

def FindLongestSubString(strings, case_sensitive=False):
    return _libgeoda.FindLongestSubString(strings, case_sensitive)

def less_vectors(a, b):
    return _libgeoda.less_vectors(a, b)
class VecGeoDaColumn(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _libgeoda.VecGeoDaColumn_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libgeoda.VecGeoDaColumn___nonzero__(self)

    def __bool__(self):
        return _libgeoda.VecGeoDaColumn___bool__(self)

    def __len__(self):
        return _libgeoda.VecGeoDaColumn___len__(self)

    def __getslice__(self, i, j):
        return _libgeoda.VecGeoDaColumn___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libgeoda.VecGeoDaColumn___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libgeoda.VecGeoDaColumn___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libgeoda.VecGeoDaColumn___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libgeoda.VecGeoDaColumn___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libgeoda.VecGeoDaColumn___setitem__(self, *args)

    def pop(self):
        return _libgeoda.VecGeoDaColumn_pop(self)

    def append(self, x):
        return _libgeoda.VecGeoDaColumn_append(self, x)

    def empty(self):
        return _libgeoda.VecGeoDaColumn_empty(self)

    def size(self):
        return _libgeoda.VecGeoDaColumn_size(self)

    def swap(self, v):
        return _libgeoda.VecGeoDaColumn_swap(self, v)

    def begin(self):
        return _libgeoda.VecGeoDaColumn_begin(self)

    def end(self):
        return _libgeoda.VecGeoDaColumn_end(self)

    def rbegin(self):
        return _libgeoda.VecGeoDaColumn_rbegin(self)

    def rend(self):
        return _libgeoda.VecGeoDaColumn_rend(self)

    def clear(self):
        return _libgeoda.VecGeoDaColumn_clear(self)

    def get_allocator(self):
        return _libgeoda.VecGeoDaColumn_get_allocator(self)

    def pop_back(self):
        return _libgeoda.VecGeoDaColumn_pop_back(self)

    def erase(self, *args):
        return _libgeoda.VecGeoDaColumn_erase(self, *args)

    def __init__(self, *args):
        _libgeoda.VecGeoDaColumn_swiginit(self, _libgeoda.new_VecGeoDaColumn(*args))

    def push_back(self, x):
        return _libgeoda.VecGeoDaColumn_push_back(self, x)

    def front(self):
        return _libgeoda.VecGeoDaColumn_front(self)

    def back(self):
        return _libgeoda.VecGeoDaColumn_back(self)

    def assign(self, n, x):
        return _libgeoda.VecGeoDaColumn_assign(self, n, x)

    def resize(self, *args):
        return _libgeoda.VecGeoDaColumn_resize(self, *args)

    def insert(self, *args):
        return _libgeoda.VecGeoDaColumn_insert(self, *args)

    def reserve(self, n):
        return _libgeoda.VecGeoDaColumn_reserve(self, n)

    def capacity(self):
        return _libgeoda.VecGeoDaColumn_capacity(self)
    __swig_destroy__ = _libgeoda.delete_VecGeoDaColumn

# Register VecGeoDaColumn in _libgeoda:
_libgeoda.VecGeoDaColumn_swigregister(VecGeoDaColumn)



