# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# 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 >= (3, 0, 0):
    new_instancemethod = lambda func, inst, cls: _assoTests.SWIG_PyInstanceMethod_New(
        func)
else:
    from new import instancemethod as new_instancemethod
if _swig_python_version_info >= (2, 7, 0):

    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_assoTests')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_assoTests')

    _assoTests = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):

    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_assoTests',
                                                        [dirname(__file__)])
        except ImportError:
            import _assoTests
            return _assoTests
        try:
            _mod = imp.load_module('_assoTests', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod

    _assoTests = swig_import_helper()
    del swig_import_helper
else:
    import _assoTests
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__


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


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


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" %
                         (class_type.__name__, name))


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_method(set):

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

    return set_attr


def my_error_handler(reason: 'char const *', file: 'char const *', line: 'int',
                     gsl_errno: 'int') -> "void":
    return _assoTests.my_error_handler(reason, file, line, gsl_errno)


my_error_handler = _assoTests.my_error_handler


def gsl_initialize() -> "int":
    return _assoTests.gsl_initialize()


gsl_initialize = _assoTests.gsl_initialize


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

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

    __repr__ = _swig_repr
    __swig_destroy__ = _assoTests.delete_SwigPyIterator

    def __iter__(self):
        return self


SwigPyIterator.value = new_instancemethod(_assoTests.SwigPyIterator_value, None,
                                          SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_assoTests.SwigPyIterator_incr, None,
                                         SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_assoTests.SwigPyIterator_decr, None,
                                         SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_assoTests.SwigPyIterator_distance,
                                             None, SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_assoTests.SwigPyIterator_equal, None,
                                          SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_assoTests.SwigPyIterator_copy, None,
                                         SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_assoTests.SwigPyIterator_next, None,
                                         SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_assoTests.SwigPyIterator___next__,
                                             None, SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_assoTests.SwigPyIterator_previous,
                                             None, SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_assoTests.SwigPyIterator_advance,
                                            None, SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_assoTests.SwigPyIterator___eq__,
                                           None, SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_assoTests.SwigPyIterator___ne__,
                                           None, SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_assoTests.SwigPyIterator___iadd__,
                                             None, SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_assoTests.SwigPyIterator___isub__,
                                             None, SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_assoTests.SwigPyIterator___add__,
                                            None, SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_assoTests.SwigPyIterator___sub__,
                                            None, SwigPyIterator)
SwigPyIterator_swigregister = _assoTests.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)


class vectors(object):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

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

    def __init__(self, *args):
        _assoTests.vectors_swiginit(self, _assoTests.new_vectors(*args))

    __swig_destroy__ = _assoTests.delete_vectors


vectors.iterator = new_instancemethod(_assoTests.vectors_iterator, None,
                                      vectors)
vectors.__nonzero__ = new_instancemethod(_assoTests.vectors___nonzero__, None,
                                         vectors)
vectors.__bool__ = new_instancemethod(_assoTests.vectors___bool__, None,
                                      vectors)
vectors.__len__ = new_instancemethod(_assoTests.vectors___len__, None, vectors)
vectors.__getslice__ = new_instancemethod(_assoTests.vectors___getslice__, None,
                                          vectors)
vectors.__setslice__ = new_instancemethod(_assoTests.vectors___setslice__, None,
                                          vectors)
vectors.__delslice__ = new_instancemethod(_assoTests.vectors___delslice__, None,
                                          vectors)
vectors.__delitem__ = new_instancemethod(_assoTests.vectors___delitem__, None,
                                         vectors)
vectors.__getitem__ = new_instancemethod(_assoTests.vectors___getitem__, None,
                                         vectors)
vectors.__setitem__ = new_instancemethod(_assoTests.vectors___setitem__, None,
                                         vectors)
vectors.pop = new_instancemethod(_assoTests.vectors_pop, None, vectors)
vectors.append = new_instancemethod(_assoTests.vectors_append, None, vectors)
vectors.empty = new_instancemethod(_assoTests.vectors_empty, None, vectors)
vectors.size = new_instancemethod(_assoTests.vectors_size, None, vectors)
vectors.swap = new_instancemethod(_assoTests.vectors_swap, None, vectors)
vectors.begin = new_instancemethod(_assoTests.vectors_begin, None, vectors)
vectors.end = new_instancemethod(_assoTests.vectors_end, None, vectors)
vectors.rbegin = new_instancemethod(_assoTests.vectors_rbegin, None, vectors)
vectors.rend = new_instancemethod(_assoTests.vectors_rend, None, vectors)
vectors.clear = new_instancemethod(_assoTests.vectors_clear, None, vectors)
vectors.get_allocator = new_instancemethod(_assoTests.vectors_get_allocator,
                                           None, vectors)
vectors.pop_back = new_instancemethod(_assoTests.vectors_pop_back, None,
                                      vectors)
vectors.erase = new_instancemethod(_assoTests.vectors_erase, None, vectors)
vectors.push_back = new_instancemethod(_assoTests.vectors_push_back, None,
                                       vectors)
vectors.front = new_instancemethod(_assoTests.vectors_front, None, vectors)
vectors.back = new_instancemethod(_assoTests.vectors_back, None, vectors)
vectors.assign = new_instancemethod(_assoTests.vectors_assign, None, vectors)
vectors.resize = new_instancemethod(_assoTests.vectors_resize, None, vectors)
vectors.insert = new_instancemethod(_assoTests.vectors_insert, None, vectors)
vectors.reserve = new_instancemethod(_assoTests.vectors_reserve, None, vectors)
vectors.capacity = new_instancemethod(_assoTests.vectors_capacity, None,
                                      vectors)
vectors_swigregister = _assoTests.vectors_swigregister
vectors_swigregister(vectors)


class vectorf(object):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

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

    def __init__(self, *args):
        _assoTests.vectorf_swiginit(self, _assoTests.new_vectorf(*args))

    __swig_destroy__ = _assoTests.delete_vectorf


vectorf.iterator = new_instancemethod(_assoTests.vectorf_iterator, None,
                                      vectorf)
vectorf.__nonzero__ = new_instancemethod(_assoTests.vectorf___nonzero__, None,
                                         vectorf)
vectorf.__bool__ = new_instancemethod(_assoTests.vectorf___bool__, None,
                                      vectorf)
vectorf.__len__ = new_instancemethod(_assoTests.vectorf___len__, None, vectorf)
vectorf.__getslice__ = new_instancemethod(_assoTests.vectorf___getslice__, None,
                                          vectorf)
vectorf.__setslice__ = new_instancemethod(_assoTests.vectorf___setslice__, None,
                                          vectorf)
vectorf.__delslice__ = new_instancemethod(_assoTests.vectorf___delslice__, None,
                                          vectorf)
vectorf.__delitem__ = new_instancemethod(_assoTests.vectorf___delitem__, None,
                                         vectorf)
vectorf.__getitem__ = new_instancemethod(_assoTests.vectorf___getitem__, None,
                                         vectorf)
vectorf.__setitem__ = new_instancemethod(_assoTests.vectorf___setitem__, None,
                                         vectorf)
vectorf.pop = new_instancemethod(_assoTests.vectorf_pop, None, vectorf)
vectorf.append = new_instancemethod(_assoTests.vectorf_append, None, vectorf)
vectorf.empty = new_instancemethod(_assoTests.vectorf_empty, None, vectorf)
vectorf.size = new_instancemethod(_assoTests.vectorf_size, None, vectorf)
vectorf.swap = new_instancemethod(_assoTests.vectorf_swap, None, vectorf)
vectorf.begin = new_instancemethod(_assoTests.vectorf_begin, None, vectorf)
vectorf.end = new_instancemethod(_assoTests.vectorf_end, None, vectorf)
vectorf.rbegin = new_instancemethod(_assoTests.vectorf_rbegin, None, vectorf)
vectorf.rend = new_instancemethod(_assoTests.vectorf_rend, None, vectorf)
vectorf.clear = new_instancemethod(_assoTests.vectorf_clear, None, vectorf)
vectorf.get_allocator = new_instancemethod(_assoTests.vectorf_get_allocator,
                                           None, vectorf)
vectorf.pop_back = new_instancemethod(_assoTests.vectorf_pop_back, None,
                                      vectorf)
vectorf.erase = new_instancemethod(_assoTests.vectorf_erase, None, vectorf)
vectorf.push_back = new_instancemethod(_assoTests.vectorf_push_back, None,
                                       vectorf)
vectorf.front = new_instancemethod(_assoTests.vectorf_front, None, vectorf)
vectorf.back = new_instancemethod(_assoTests.vectorf_back, None, vectorf)
vectorf.assign = new_instancemethod(_assoTests.vectorf_assign, None, vectorf)
vectorf.resize = new_instancemethod(_assoTests.vectorf_resize, None, vectorf)
vectorf.insert = new_instancemethod(_assoTests.vectorf_insert, None, vectorf)
vectorf.reserve = new_instancemethod(_assoTests.vectorf_reserve, None, vectorf)
vectorf.capacity = new_instancemethod(_assoTests.vectorf_capacity, None,
                                      vectorf)
vectorf_swigregister = _assoTests.vectorf_swigregister
vectorf_swigregister(vectorf)


class vectori(object):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

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

    def __init__(self, *args):
        _assoTests.vectori_swiginit(self, _assoTests.new_vectori(*args))

    __swig_destroy__ = _assoTests.delete_vectori


vectori.iterator = new_instancemethod(_assoTests.vectori_iterator, None,
                                      vectori)
vectori.__nonzero__ = new_instancemethod(_assoTests.vectori___nonzero__, None,
                                         vectori)
vectori.__bool__ = new_instancemethod(_assoTests.vectori___bool__, None,
                                      vectori)
vectori.__len__ = new_instancemethod(_assoTests.vectori___len__, None, vectori)
vectori.__getslice__ = new_instancemethod(_assoTests.vectori___getslice__, None,
                                          vectori)
vectori.__setslice__ = new_instancemethod(_assoTests.vectori___setslice__, None,
                                          vectori)
vectori.__delslice__ = new_instancemethod(_assoTests.vectori___delslice__, None,
                                          vectori)
vectori.__delitem__ = new_instancemethod(_assoTests.vectori___delitem__, None,
                                         vectori)
vectori.__getitem__ = new_instancemethod(_assoTests.vectori___getitem__, None,
                                         vectori)
vectori.__setitem__ = new_instancemethod(_assoTests.vectori___setitem__, None,
                                         vectori)
vectori.pop = new_instancemethod(_assoTests.vectori_pop, None, vectori)
vectori.append = new_instancemethod(_assoTests.vectori_append, None, vectori)
vectori.empty = new_instancemethod(_assoTests.vectori_empty, None, vectori)
vectori.size = new_instancemethod(_assoTests.vectori_size, None, vectori)
vectori.swap = new_instancemethod(_assoTests.vectori_swap, None, vectori)
vectori.begin = new_instancemethod(_assoTests.vectori_begin, None, vectori)
vectori.end = new_instancemethod(_assoTests.vectori_end, None, vectori)
vectori.rbegin = new_instancemethod(_assoTests.vectori_rbegin, None, vectori)
vectori.rend = new_instancemethod(_assoTests.vectori_rend, None, vectori)
vectori.clear = new_instancemethod(_assoTests.vectori_clear, None, vectori)
vectori.get_allocator = new_instancemethod(_assoTests.vectori_get_allocator,
                                           None, vectori)
vectori.pop_back = new_instancemethod(_assoTests.vectori_pop_back, None,
                                      vectori)
vectori.erase = new_instancemethod(_assoTests.vectori_erase, None, vectori)
vectori.push_back = new_instancemethod(_assoTests.vectori_push_back, None,
                                       vectori)
vectori.front = new_instancemethod(_assoTests.vectori_front, None, vectori)
vectori.back = new_instancemethod(_assoTests.vectori_back, None, vectori)
vectori.assign = new_instancemethod(_assoTests.vectori_assign, None, vectori)
vectori.resize = new_instancemethod(_assoTests.vectori_resize, None, vectori)
vectori.insert = new_instancemethod(_assoTests.vectori_insert, None, vectori)
vectori.reserve = new_instancemethod(_assoTests.vectori_reserve, None, vectori)
vectori.capacity = new_instancemethod(_assoTests.vectori_capacity, None,
                                      vectori)
vectori_swigregister = _assoTests.vectori_swigregister
vectori_swigregister(vectori)


class matrixi(object):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

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

    def __init__(self, *args):
        _assoTests.matrixi_swiginit(self, _assoTests.new_matrixi(*args))

    __swig_destroy__ = _assoTests.delete_matrixi


matrixi.iterator = new_instancemethod(_assoTests.matrixi_iterator, None,
                                      matrixi)
matrixi.__nonzero__ = new_instancemethod(_assoTests.matrixi___nonzero__, None,
                                         matrixi)
matrixi.__bool__ = new_instancemethod(_assoTests.matrixi___bool__, None,
                                      matrixi)
matrixi.__len__ = new_instancemethod(_assoTests.matrixi___len__, None, matrixi)
matrixi.__getslice__ = new_instancemethod(_assoTests.matrixi___getslice__, None,
                                          matrixi)
matrixi.__setslice__ = new_instancemethod(_assoTests.matrixi___setslice__, None,
                                          matrixi)
matrixi.__delslice__ = new_instancemethod(_assoTests.matrixi___delslice__, None,
                                          matrixi)
matrixi.__delitem__ = new_instancemethod(_assoTests.matrixi___delitem__, None,
                                         matrixi)
matrixi.__getitem__ = new_instancemethod(_assoTests.matrixi___getitem__, None,
                                         matrixi)
matrixi.__setitem__ = new_instancemethod(_assoTests.matrixi___setitem__, None,
                                         matrixi)
matrixi.pop = new_instancemethod(_assoTests.matrixi_pop, None, matrixi)
matrixi.append = new_instancemethod(_assoTests.matrixi_append, None, matrixi)
matrixi.empty = new_instancemethod(_assoTests.matrixi_empty, None, matrixi)
matrixi.size = new_instancemethod(_assoTests.matrixi_size, None, matrixi)
matrixi.swap = new_instancemethod(_assoTests.matrixi_swap, None, matrixi)
matrixi.begin = new_instancemethod(_assoTests.matrixi_begin, None, matrixi)
matrixi.end = new_instancemethod(_assoTests.matrixi_end, None, matrixi)
matrixi.rbegin = new_instancemethod(_assoTests.matrixi_rbegin, None, matrixi)
matrixi.rend = new_instancemethod(_assoTests.matrixi_rend, None, matrixi)
matrixi.clear = new_instancemethod(_assoTests.matrixi_clear, None, matrixi)
matrixi.get_allocator = new_instancemethod(_assoTests.matrixi_get_allocator,
                                           None, matrixi)
matrixi.pop_back = new_instancemethod(_assoTests.matrixi_pop_back, None,
                                      matrixi)
matrixi.erase = new_instancemethod(_assoTests.matrixi_erase, None, matrixi)
matrixi.push_back = new_instancemethod(_assoTests.matrixi_push_back, None,
                                       matrixi)
matrixi.front = new_instancemethod(_assoTests.matrixi_front, None, matrixi)
matrixi.back = new_instancemethod(_assoTests.matrixi_back, None, matrixi)
matrixi.assign = new_instancemethod(_assoTests.matrixi_assign, None, matrixi)
matrixi.resize = new_instancemethod(_assoTests.matrixi_resize, None, matrixi)
matrixi.insert = new_instancemethod(_assoTests.matrixi_insert, None, matrixi)
matrixi.reserve = new_instancemethod(_assoTests.matrixi_reserve, None, matrixi)
matrixi.capacity = new_instancemethod(_assoTests.matrixi_capacity, None,
                                      matrixi)
matrixi_swigregister = _assoTests.matrixi_swigregister
matrixi_swigregister(matrixi)


class matrixf(object):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

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

    def __init__(self, *args):
        _assoTests.matrixf_swiginit(self, _assoTests.new_matrixf(*args))

    __swig_destroy__ = _assoTests.delete_matrixf


matrixf.iterator = new_instancemethod(_assoTests.matrixf_iterator, None,
                                      matrixf)
matrixf.__nonzero__ = new_instancemethod(_assoTests.matrixf___nonzero__, None,
                                         matrixf)
matrixf.__bool__ = new_instancemethod(_assoTests.matrixf___bool__, None,
                                      matrixf)
matrixf.__len__ = new_instancemethod(_assoTests.matrixf___len__, None, matrixf)
matrixf.__getslice__ = new_instancemethod(_assoTests.matrixf___getslice__, None,
                                          matrixf)
matrixf.__setslice__ = new_instancemethod(_assoTests.matrixf___setslice__, None,
                                          matrixf)
matrixf.__delslice__ = new_instancemethod(_assoTests.matrixf___delslice__, None,
                                          matrixf)
matrixf.__delitem__ = new_instancemethod(_assoTests.matrixf___delitem__, None,
                                         matrixf)
matrixf.__getitem__ = new_instancemethod(_assoTests.matrixf___getitem__, None,
                                         matrixf)
matrixf.__setitem__ = new_instancemethod(_assoTests.matrixf___setitem__, None,
                                         matrixf)
matrixf.pop = new_instancemethod(_assoTests.matrixf_pop, None, matrixf)
matrixf.append = new_instancemethod(_assoTests.matrixf_append, None, matrixf)
matrixf.empty = new_instancemethod(_assoTests.matrixf_empty, None, matrixf)
matrixf.size = new_instancemethod(_assoTests.matrixf_size, None, matrixf)
matrixf.swap = new_instancemethod(_assoTests.matrixf_swap, None, matrixf)
matrixf.begin = new_instancemethod(_assoTests.matrixf_begin, None, matrixf)
matrixf.end = new_instancemethod(_assoTests.matrixf_end, None, matrixf)
matrixf.rbegin = new_instancemethod(_assoTests.matrixf_rbegin, None, matrixf)
matrixf.rend = new_instancemethod(_assoTests.matrixf_rend, None, matrixf)
matrixf.clear = new_instancemethod(_assoTests.matrixf_clear, None, matrixf)
matrixf.get_allocator = new_instancemethod(_assoTests.matrixf_get_allocator,
                                           None, matrixf)
matrixf.pop_back = new_instancemethod(_assoTests.matrixf_pop_back, None,
                                      matrixf)
matrixf.erase = new_instancemethod(_assoTests.matrixf_erase, None, matrixf)
matrixf.push_back = new_instancemethod(_assoTests.matrixf_push_back, None,
                                       matrixf)
matrixf.front = new_instancemethod(_assoTests.matrixf_front, None, matrixf)
matrixf.back = new_instancemethod(_assoTests.matrixf_back, None, matrixf)
matrixf.assign = new_instancemethod(_assoTests.matrixf_assign, None, matrixf)
matrixf.resize = new_instancemethod(_assoTests.matrixf_resize, None, matrixf)
matrixf.insert = new_instancemethod(_assoTests.matrixf_insert, None, matrixf)
matrixf.reserve = new_instancemethod(_assoTests.matrixf_reserve, None, matrixf)
matrixf.capacity = new_instancemethod(_assoTests.matrixf_capacity, None,
                                      matrixf)
matrixf_swigregister = _assoTests.matrixf_swigregister
matrixf_swigregister(matrixf)


class vectora(object):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

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

    def __init__(self, *args):
        _assoTests.vectora_swiginit(self, _assoTests.new_vectora(*args))

    __swig_destroy__ = _assoTests.delete_vectora


vectora.iterator = new_instancemethod(_assoTests.vectora_iterator, None,
                                      vectora)
vectora.__nonzero__ = new_instancemethod(_assoTests.vectora___nonzero__, None,
                                         vectora)
vectora.__bool__ = new_instancemethod(_assoTests.vectora___bool__, None,
                                      vectora)
vectora.__len__ = new_instancemethod(_assoTests.vectora___len__, None, vectora)
vectora.__getslice__ = new_instancemethod(_assoTests.vectora___getslice__, None,
                                          vectora)
vectora.__setslice__ = new_instancemethod(_assoTests.vectora___setslice__, None,
                                          vectora)
vectora.__delslice__ = new_instancemethod(_assoTests.vectora___delslice__, None,
                                          vectora)
vectora.__delitem__ = new_instancemethod(_assoTests.vectora___delitem__, None,
                                         vectora)
vectora.__getitem__ = new_instancemethod(_assoTests.vectora___getitem__, None,
                                         vectora)
vectora.__setitem__ = new_instancemethod(_assoTests.vectora___setitem__, None,
                                         vectora)
vectora.pop = new_instancemethod(_assoTests.vectora_pop, None, vectora)
vectora.append = new_instancemethod(_assoTests.vectora_append, None, vectora)
vectora.empty = new_instancemethod(_assoTests.vectora_empty, None, vectora)
vectora.size = new_instancemethod(_assoTests.vectora_size, None, vectora)
vectora.swap = new_instancemethod(_assoTests.vectora_swap, None, vectora)
vectora.begin = new_instancemethod(_assoTests.vectora_begin, None, vectora)
vectora.end = new_instancemethod(_assoTests.vectora_end, None, vectora)
vectora.rbegin = new_instancemethod(_assoTests.vectora_rbegin, None, vectora)
vectora.rend = new_instancemethod(_assoTests.vectora_rend, None, vectora)
vectora.clear = new_instancemethod(_assoTests.vectora_clear, None, vectora)
vectora.get_allocator = new_instancemethod(_assoTests.vectora_get_allocator,
                                           None, vectora)
vectora.pop_back = new_instancemethod(_assoTests.vectora_pop_back, None,
                                      vectora)
vectora.erase = new_instancemethod(_assoTests.vectora_erase, None, vectora)
vectora.push_back = new_instancemethod(_assoTests.vectora_push_back, None,
                                       vectora)
vectora.front = new_instancemethod(_assoTests.vectora_front, None, vectora)
vectora.back = new_instancemethod(_assoTests.vectora_back, None, vectora)
vectora.assign = new_instancemethod(_assoTests.vectora_assign, None, vectora)
vectora.resize = new_instancemethod(_assoTests.vectora_resize, None, vectora)
vectora.insert = new_instancemethod(_assoTests.vectora_insert, None, vectora)
vectora.reserve = new_instancemethod(_assoTests.vectora_reserve, None, vectora)
vectora.capacity = new_instancemethod(_assoTests.vectora_capacity, None,
                                      vectora)
vectora_swigregister = _assoTests.vectora_swigregister
vectora_swigregister(vectora)


def fEqual(a: 'double', b: 'double') -> "bool":
    return _assoTests.fEqual(a, b)


fEqual = _assoTests.fEqual


def fRound(myValue: 'double &', PRECISION: 'double') -> "void":
    return _assoTests.fRound(myValue, PRECISION)


fRound = _assoTests.fRound


def Mann_Whitneyu(x: 'vectorf', y: 'vectorf') -> "double":
    return _assoTests.Mann_Whitneyu(x, y)


Mann_Whitneyu = _assoTests.Mann_Whitneyu


def chisq2X2stat(regressors: 'vectorf', responses: 'vectorf') -> "double":
    return _assoTests.chisq2X2stat(regressors, responses)


chisq2X2stat = _assoTests.chisq2X2stat


def dnhyper(m: 'double', n: 'double', k: 'double',
            ncp: 'double') -> "std::vector< double,std::allocator< double > >":
    return _assoTests.dnhyper(m, n, k, ncp)


dnhyper = _assoTests.dnhyper


def mnhyper(m: 'double', n: 'double', k: 'double', ncp: 'double') -> "double":
    return _assoTests.mnhyper(m, n, k, ncp)


mnhyper = _assoTests.mnhyper


def pnhyper(q: 'double',
            m: 'double',
            n: 'double',
            k: 'double',
            ncp: 'double' = 1.0,
            upper_tail: 'bool' = False) -> "double":
    return _assoTests.pnhyper(q, m, n, k, ncp, upper_tail)


pnhyper = _assoTests.pnhyper


def fexact2x2(*args, **kwargs) -> "double":
    return _assoTests.fexact2x2(*args, **kwargs)


fexact2x2 = _assoTests.fexact2x2


def calculateInbreedingCoef(gt: 'vectori', maf: 'vectorf') -> "double":
    return _assoTests.calculateInbreedingCoef(gt, maf)


calculateInbreedingCoef = _assoTests.calculateInbreedingCoef


class RunningStat(object):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _assoTests.RunningStat_swiginit(self, _assoTests.new_RunningStat())

    __swig_destroy__ = _assoTests.delete_RunningStat


RunningStat.Clear = new_instancemethod(_assoTests.RunningStat_Clear, None,
                                       RunningStat)
RunningStat.Push = new_instancemethod(_assoTests.RunningStat_Push, None,
                                      RunningStat)
RunningStat.NumDataValues = new_instancemethod(
    _assoTests.RunningStat_NumDataValues, None, RunningStat)
RunningStat.Mean = new_instancemethod(_assoTests.RunningStat_Mean, None,
                                      RunningStat)
RunningStat.Variance = new_instancemethod(_assoTests.RunningStat_Variance, None,
                                          RunningStat)
RunningStat.StandardDeviation = new_instancemethod(
    _assoTests.RunningStat_StandardDeviation, None, RunningStat)
RunningStat_swigregister = _assoTests.RunningStat_swigregister
RunningStat_swigregister(RunningStat)


class VPlus(object):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _assoTests.VPlus_swiginit(self, _assoTests.new_VPlus())

    __swig_destroy__ = _assoTests.delete_VPlus


VPlus_swigregister = _assoTests.VPlus_swigregister
VPlus_swigregister(VPlus)


class RNG(object):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _assoTests.RNG_swiginit(self, _assoTests.new_RNG())

    __swig_destroy__ = _assoTests.delete_RNG


RNG.get = new_instancemethod(_assoTests.RNG_get, None, RNG)
RNG_swigregister = _assoTests.RNG_swigregister
RNG_swigregister(RNG)


def initialize() -> "void":
    return _assoTests.initialize()


initialize = _assoTests.initialize


def pyAssoDataObj(p: 'void *') -> "PyObject *":
    return _assoTests.pyAssoDataObj(p)


pyAssoDataObj = _assoTests.pyAssoDataObj


class LMData(object):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _assoTests.delete_LMData

    def __init__(self, *args):
        _assoTests.LMData_swiginit(self, _assoTests.new_LMData(*args))


LMData.clone = new_instancemethod(_assoTests.LMData_clone, None, LMData)
LMData.clear = new_instancemethod(_assoTests.LMData_clear, None, LMData)
LMData.setX = new_instancemethod(_assoTests.LMData_setX, None, LMData)
LMData.setY = new_instancemethod(_assoTests.LMData_setY, None, LMData)
LMData.getX = new_instancemethod(_assoTests.LMData_getX, None, LMData)
LMData.replaceColumn = new_instancemethod(_assoTests.LMData_replaceColumn, None,
                                          LMData)
LMData.setBeta = new_instancemethod(_assoTests.LMData_setBeta, None, LMData)
LMData.setSEBeta = new_instancemethod(_assoTests.LMData_setSEBeta, None, LMData)
LMData.getBeta = new_instancemethod(_assoTests.LMData_getBeta, None, LMData)
LMData.getSEBeta = new_instancemethod(_assoTests.LMData_getSEBeta, None, LMData)
LMData.x = new_instancemethod(_assoTests.LMData_x, None, LMData)
LMData.y = new_instancemethod(_assoTests.LMData_y, None, LMData)
LMData_swigregister = _assoTests.LMData_swigregister
LMData_swigregister(LMData)


class BaseLM(object):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _assoTests.delete_BaseLM

    def __init__(self, *args):
        _assoTests.BaseLM_swiginit(self, _assoTests.new_BaseLM(*args))


BaseLM.clone = new_instancemethod(_assoTests.BaseLM_clone, None, BaseLM)
BaseLM.fit = new_instancemethod(_assoTests.BaseLM_fit, None, BaseLM)
BaseLM.evalSE = new_instancemethod(_assoTests.BaseLM_evalSE, None, BaseLM)
BaseLM_swigregister = _assoTests.BaseLM_swigregister
BaseLM_swigregister(BaseLM)


class LinearM(BaseLM):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _assoTests.delete_LinearM

    def __init__(self, *args):
        _assoTests.LinearM_swiginit(self, _assoTests.new_LinearM(*args))


LinearM_swigregister = _assoTests.LinearM_swigregister
LinearM_swigregister(LinearM)


class LogisticM(BaseLM):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _assoTests.delete_LogisticM

    def __init__(self, *args):
        _assoTests.LogisticM_swiginit(self, _assoTests.new_LogisticM(*args))


LogisticM.niterations = new_instancemethod(_assoTests.LogisticM_niterations,
                                           None, LogisticM)
LogisticM_swigregister = _assoTests.LogisticM_swigregister
LogisticM_swigregister(LogisticM)


class AssoData(object):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _assoTests.AssoData_swiginit(self, _assoTests.new_AssoData())

    __swig_destroy__ = _assoTests.delete_AssoData


AssoData.clone = new_instancemethod(_assoTests.AssoData_clone, None, AssoData)
AssoData.setGenotype = new_instancemethod(_assoTests.AssoData_setGenotype, None,
                                          AssoData)
AssoData.setMOI = new_instancemethod(_assoTests.AssoData_setMOI, None, AssoData)
AssoData.setX = new_instancemethod(_assoTests.AssoData_setX, None, AssoData)
AssoData.setGenotypeId = new_instancemethod(_assoTests.AssoData_setGenotypeId,
                                            None, AssoData)
AssoData.setPhenotype = new_instancemethod(_assoTests.AssoData_setPhenotype,
                                           None, AssoData)
AssoData.isYBinary = new_instancemethod(_assoTests.AssoData_isYBinary, None,
                                        AssoData)
AssoData.countCaseCtrl = new_instancemethod(_assoTests.AssoData_countCaseCtrl,
                                            None, AssoData)
AssoData.phenotype = new_instancemethod(_assoTests.AssoData_phenotype, None,
                                        AssoData)
AssoData.getPhenotype = new_instancemethod(_assoTests.AssoData_getPhenotype,
                                           None, AssoData)
AssoData.genotype = new_instancemethod(_assoTests.AssoData_genotype, None,
                                       AssoData)
AssoData.getGenotype = new_instancemethod(_assoTests.AssoData_getGenotype, None,
                                          AssoData)
AssoData.genotype_id = new_instancemethod(_assoTests.AssoData_genotype_id, None,
                                          AssoData)
AssoData.raw_genotype = new_instancemethod(_assoTests.AssoData_raw_genotype,
                                           None, AssoData)
AssoData.getRawGenotype = new_instancemethod(_assoTests.AssoData_getRawGenotype,
                                             None, AssoData)
AssoData.covariates = new_instancemethod(_assoTests.AssoData_covariates, None,
                                         AssoData)
AssoData.getCovariates = new_instancemethod(_assoTests.AssoData_getCovariates,
                                            None, AssoData)
AssoData.modeldata = new_instancemethod(_assoTests.AssoData_modeldata, None,
                                        AssoData)
AssoData.samplecounts = new_instancemethod(_assoTests.AssoData_samplecounts,
                                           None, AssoData)
AssoData.locicounts = new_instancemethod(_assoTests.AssoData_locicounts, None,
                                         AssoData)
AssoData.allelecounts = new_instancemethod(_assoTests.AssoData_allelecounts,
                                           None, AssoData)
AssoData.pvalue = new_instancemethod(_assoTests.AssoData_pvalue, None, AssoData)
AssoData.statistic = new_instancemethod(_assoTests.AssoData_statistic, None,
                                        AssoData)
AssoData.se = new_instancemethod(_assoTests.AssoData_se, None, AssoData)
AssoData.setPvalue = new_instancemethod(_assoTests.AssoData_setPvalue, None,
                                        AssoData)
AssoData.setStatistic = new_instancemethod(_assoTests.AssoData_setStatistic,
                                           None, AssoData)
AssoData.setSE = new_instancemethod(_assoTests.AssoData_setSE, None, AssoData)
AssoData.permuteY = new_instancemethod(_assoTests.AssoData_permuteY, None,
                                       AssoData)
AssoData.permuteRawX = new_instancemethod(_assoTests.AssoData_permuteRawX, None,
                                          AssoData)
AssoData.permuteAllX = new_instancemethod(_assoTests.AssoData_permuteAllX, None,
                                          AssoData)
AssoData.permuteX = new_instancemethod(_assoTests.AssoData_permuteX, None,
                                       AssoData)
AssoData.weightX = new_instancemethod(_assoTests.AssoData_weightX, None,
                                      AssoData)
AssoData.setVar = new_instancemethod(_assoTests.AssoData_setVar, None, AssoData)
AssoData.hasVar = new_instancemethod(_assoTests.AssoData_hasVar, None, AssoData)
AssoData.getDoubleVar = new_instancemethod(_assoTests.AssoData_getDoubleVar,
                                           None, AssoData)
AssoData.getIntVar = new_instancemethod(_assoTests.AssoData_getIntVar, None,
                                        AssoData)
AssoData.getArrayVar = new_instancemethod(_assoTests.AssoData_getArrayVar, None,
                                          AssoData)
AssoData.getIntArrayVar = new_instancemethod(_assoTests.AssoData_getIntArrayVar,
                                             None, AssoData)
AssoData.getMatrixVar = new_instancemethod(_assoTests.AssoData_getMatrixVar,
                                           None, AssoData)
AssoData.getStringVar = new_instancemethod(_assoTests.AssoData_getStringVar,
                                           None, AssoData)
AssoData_swigregister = _assoTests.AssoData_swigregister
AssoData_swigregister(AssoData)


class BaseAction(object):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _assoTests.BaseAction_swiginit(self, _assoTests.new_BaseAction())

    __swig_destroy__ = _assoTests.delete_BaseAction


BaseAction.clone = new_instancemethod(_assoTests.BaseAction_clone, None,
                                      BaseAction)
BaseAction.apply = new_instancemethod(_assoTests.BaseAction_apply, None,
                                      BaseAction)
BaseAction.name = new_instancemethod(_assoTests.BaseAction_name, None,
                                     BaseAction)
BaseAction_swigregister = _assoTests.BaseAction_swigregister
BaseAction_swigregister(BaseAction)


class SumToX(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _assoTests.SumToX_swiginit(self, _assoTests.new_SumToX())

    __swig_destroy__ = _assoTests.delete_SumToX


SumToX_swigregister = _assoTests.SumToX_swigregister
SumToX_swigregister(SumToX)


class BinToX(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _assoTests.BinToX_swiginit(self, _assoTests.new_BinToX())

    __swig_destroy__ = _assoTests.delete_BinToX


BinToX_swigregister = _assoTests.BinToX_swigregister
BinToX_swigregister(BinToX)


class PermuteX(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _assoTests.PermuteX_swiginit(self, _assoTests.new_PermuteX())

    __swig_destroy__ = _assoTests.delete_PermuteX


PermuteX_swigregister = _assoTests.PermuteX_swigregister
PermuteX_swigregister(PermuteX)


class PermuteRawX(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _assoTests.PermuteRawX_swiginit(self, _assoTests.new_PermuteRawX())

    __swig_destroy__ = _assoTests.delete_PermuteRawX


PermuteRawX_swigregister = _assoTests.PermuteRawX_swigregister
PermuteRawX_swigregister(PermuteRawX)


class PermuteAllX(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _assoTests.PermuteAllX_swiginit(self, _assoTests.new_PermuteAllX())

    __swig_destroy__ = _assoTests.delete_PermuteAllX


PermuteAllX_swigregister = _assoTests.PermuteAllX_swigregister
PermuteAllX_swigregister(PermuteAllX)


class PermuteY(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _assoTests.PermuteY_swiginit(self, _assoTests.new_PermuteY())

    __swig_destroy__ = _assoTests.delete_PermuteY


PermuteY_swigregister = _assoTests.PermuteY_swigregister
PermuteY_swigregister(PermuteY)


class SetMaf(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _assoTests.SetMaf_swiginit(self, _assoTests.new_SetMaf())

    __swig_destroy__ = _assoTests.delete_SetMaf


SetMaf_swigregister = _assoTests.SetMaf_swigregister
SetMaf_swigregister(SetMaf)


class BrowningWeight(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, model: 'unsigned int'):
        _assoTests.BrowningWeight_swiginit(self,
                                           _assoTests.new_BrowningWeight(model))

    __swig_destroy__ = _assoTests.delete_BrowningWeight


BrowningWeight_swigregister = _assoTests.BrowningWeight_swigregister
BrowningWeight_swigregister(BrowningWeight)


class FillGMissing(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        _assoTests.FillGMissing_swiginit(
            self, _assoTests.new_FillGMissing(*args, **kwargs))

    __swig_destroy__ = _assoTests.delete_FillGMissing


FillGMissing_swigregister = _assoTests.FillGMissing_swigregister
FillGMissing_swigregister(FillGMissing)


class WeightByInfo(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, info: 'vectors'):
        _assoTests.WeightByInfo_swiginit(self,
                                         _assoTests.new_WeightByInfo(info))

    __swig_destroy__ = _assoTests.delete_WeightByInfo


WeightByInfo_swigregister = _assoTests.WeightByInfo_swigregister
WeightByInfo_swigregister(WeightByInfo)


class SetSites(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self,
                 upper: 'double' = 1.0,
                 lower: 'double' = 0.0,
                 use_mac: 'bool' = False):
        _assoTests.SetSites_swiginit(
            self, _assoTests.new_SetSites(upper, lower, use_mac))

    __swig_destroy__ = _assoTests.delete_SetSites


SetSites_swigregister = _assoTests.SetSites_swigregister
SetSites_swigregister(SetSites)


class CodeXByMOI(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _assoTests.CodeXByMOI_swiginit(self, _assoTests.new_CodeXByMOI())

    __swig_destroy__ = _assoTests.delete_CodeXByMOI


CodeXByMOI_swigregister = _assoTests.CodeXByMOI_swigregister
CodeXByMOI_swigregister(CodeXByMOI)


class SimpleLinearRegression(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _assoTests.SimpleLinearRegression_swiginit(
            self, _assoTests.new_SimpleLinearRegression())

    __swig_destroy__ = _assoTests.delete_SimpleLinearRegression


SimpleLinearRegression_swigregister = _assoTests.SimpleLinearRegression_swigregister
SimpleLinearRegression_swigregister(SimpleLinearRegression)


class SimpleLogisticRegression(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _assoTests.SimpleLogisticRegression_swiginit(
            self, _assoTests.new_SimpleLogisticRegression())

    __swig_destroy__ = _assoTests.delete_SimpleLogisticRegression


SimpleLogisticRegression_swigregister = _assoTests.SimpleLogisticRegression_swigregister
SimpleLogisticRegression_swigregister(SimpleLogisticRegression)


class MultipleRegression(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, iSE: 'bool' = True, method: 'unsigned int' = 0):
        _assoTests.MultipleRegression_swiginit(
            self, _assoTests.new_MultipleRegression(iSE, method))

    __swig_destroy__ = _assoTests.delete_MultipleRegression


MultipleRegression_swigregister = _assoTests.MultipleRegression_swigregister
MultipleRegression_swigregister(MultipleRegression)


class GaussianPval(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, sided: 'unsigned int' = 1):
        _assoTests.GaussianPval_swiginit(self,
                                         _assoTests.new_GaussianPval(sided))

    __swig_destroy__ = _assoTests.delete_GaussianPval


GaussianPval_swigregister = _assoTests.GaussianPval_swigregister
GaussianPval_swigregister(GaussianPval)


class StudentPval(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, sided: 'unsigned int' = 1):
        _assoTests.StudentPval_swiginit(self, _assoTests.new_StudentPval(sided))

    __swig_destroy__ = _assoTests.delete_StudentPval


StudentPval_swigregister = _assoTests.StudentPval_swigregister
StudentPval_swigregister(StudentPval)


class Fisher2X2(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, alternative: 'unsigned int', midp: 'bool' = False):
        _assoTests.Fisher2X2_swiginit(
            self, _assoTests.new_Fisher2X2(alternative, midp))

    __swig_destroy__ = _assoTests.delete_Fisher2X2


Fisher2X2_swigregister = _assoTests.Fisher2X2_swigregister
Fisher2X2_swigregister(Fisher2X2)


class MannWhitneyu(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, alternative: 'unsigned int' = 1, store: 'bool' = False):
        _assoTests.MannWhitneyu_swiginit(
            self, _assoTests.new_MannWhitneyu(alternative, store))

    __swig_destroy__ = _assoTests.delete_MannWhitneyu


MannWhitneyu_swigregister = _assoTests.MannWhitneyu_swigregister
MannWhitneyu_swigregister(MannWhitneyu)


class WSSPvalue(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, alternative: 'unsigned int'):
        _assoTests.WSSPvalue_swiginit(self,
                                      _assoTests.new_WSSPvalue(alternative))

    __swig_destroy__ = _assoTests.delete_WSSPvalue


WSSPvalue_swigregister = _assoTests.WSSPvalue_swigregister
WSSPvalue_swigregister(WSSPvalue)


class FindGenotypePattern(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _assoTests.FindGenotypePattern_swiginit(
            self, _assoTests.new_FindGenotypePattern())

    __swig_destroy__ = _assoTests.delete_FindGenotypePattern


FindGenotypePattern_swigregister = _assoTests.FindGenotypePattern_swigregister
FindGenotypePattern_swigregister(FindGenotypePattern)


class KBACtest(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self,
                 alternative: 'unsigned int' = 1,
                 weightOnly: 'bool' = False):
        _assoTests.KBACtest_swiginit(
            self, _assoTests.new_KBACtest(alternative, weightOnly))

    __swig_destroy__ = _assoTests.delete_KBACtest


KBACtest_swigregister = _assoTests.KBACtest_swigregister
KBACtest_swigregister(KBACtest)


class RBTtest(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self,
                 alternative: 'unsigned int' = 1,
                 weightOnly: 'bool' = False):
        _assoTests.RBTtest_swiginit(
            self, _assoTests.new_RBTtest(alternative, weightOnly))

    __swig_destroy__ = _assoTests.delete_RBTtest


RBTtest_swigregister = _assoTests.RBTtest_swigregister
RBTtest_swigregister(RBTtest)


class AdaptiveRvSum(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _assoTests.AdaptiveRvSum_swiginit(self, _assoTests.new_AdaptiveRvSum())

    __swig_destroy__ = _assoTests.delete_AdaptiveRvSum


AdaptiveRvSum_swigregister = _assoTests.AdaptiveRvSum_swigregister
AdaptiveRvSum_swigregister(AdaptiveRvSum)


class FindVariantPattern(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _assoTests.FindVariantPattern_swiginit(
            self, _assoTests.new_FindVariantPattern())

    __swig_destroy__ = _assoTests.delete_FindVariantPattern


FindVariantPattern_swigregister = _assoTests.FindVariantPattern_swigregister
FindVariantPattern_swigregister(FindVariantPattern)


class VTTest(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, alternative: 'unsigned int' = 1):
        _assoTests.VTTest_swiginit(self, _assoTests.new_VTTest(alternative))

    __swig_destroy__ = _assoTests.delete_VTTest


VTTest_swigregister = _assoTests.VTTest_swigregister
VTTest_swigregister(VTTest)


class VTFisher(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self,
                 alpha: 'double',
                 alternative: 'unsigned int' = 1,
                 midp: 'bool' = False):
        _assoTests.VTFisher_swiginit(
            self, _assoTests.new_VTFisher(alpha, alternative, midp))

    __swig_destroy__ = _assoTests.delete_VTFisher


VTFisher_swigregister = _assoTests.VTFisher_swigregister
VTFisher_swigregister(VTFisher)


class CalphaTest(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, permutation: 'bool' = False):
        _assoTests.CalphaTest_swiginit(self,
                                       _assoTests.new_CalphaTest(permutation))

    __swig_destroy__ = _assoTests.delete_CalphaTest


CalphaTest_swigregister = _assoTests.CalphaTest_swigregister
CalphaTest_swigregister(CalphaTest)


class RareCoverTest(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, difQ: 'double' = 0.5):
        _assoTests.RareCoverTest_swiginit(self,
                                          _assoTests.new_RareCoverTest(difQ))

    __swig_destroy__ = _assoTests.delete_RareCoverTest


RareCoverTest_swigregister = _assoTests.RareCoverTest_swigregister
RareCoverTest_swigregister(RareCoverTest)


class BasePermutator(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _assoTests.delete_BasePermutator

    def __init__(self, *args):
        _assoTests.BasePermutator_swiginit(self,
                                           _assoTests.new_BasePermutator(*args))


BasePermutator.append = new_instancemethod(_assoTests.BasePermutator_append,
                                           None, BasePermutator)
BasePermutator.extend = new_instancemethod(_assoTests.BasePermutator_extend,
                                           None, BasePermutator)
BasePermutator.check = new_instancemethod(_assoTests.BasePermutator_check, None,
                                          BasePermutator)
BasePermutator.getP = new_instancemethod(_assoTests.BasePermutator_getP, None,
                                         BasePermutator)
BasePermutator_swigregister = _assoTests.BasePermutator_swigregister
BasePermutator_swigregister(BasePermutator)


class PyAction(BaseAction):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, func: 'PyObject *'):
        _assoTests.PyAction_swiginit(self, _assoTests.new_PyAction(func))

    __swig_destroy__ = _assoTests.delete_PyAction


PyAction_swigregister = _assoTests.PyAction_swigregister
PyAction_swigregister(PyAction)


class AssoAlgorithm(BasePermutator):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _assoTests.AssoAlgorithm_swiginit(self,
                                          _assoTests.new_AssoAlgorithm(*args))

    __swig_destroy__ = _assoTests.delete_AssoAlgorithm


AssoAlgorithm_swigregister = _assoTests.AssoAlgorithm_swigregister
AssoAlgorithm_swigregister(AssoAlgorithm)


class FixedPermutator(BasePermutator):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _assoTests.delete_FixedPermutator

    def __init__(self, *args):
        _assoTests.FixedPermutator_swiginit(
            self, _assoTests.new_FixedPermutator(*args))


FixedPermutator_swigregister = _assoTests.FixedPermutator_swigregister
FixedPermutator_swigregister(FixedPermutator)


class VariablePermutator(BasePermutator):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _assoTests.delete_VariablePermutator

    def __init__(self, *args):
        _assoTests.VariablePermutator_swiginit(
            self, _assoTests.new_VariablePermutator(*args))


VariablePermutator_swigregister = _assoTests.VariablePermutator_swigregister
VariablePermutator_swigregister(VariablePermutator)


class StackingPermutator(BasePermutator):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _assoTests.delete_StackingPermutator

    def __init__(self, *args):
        _assoTests.StackingPermutator_swiginit(
            self, _assoTests.new_StackingPermutator(*args))


StackingPermutator_swigregister = _assoTests.StackingPermutator_swigregister
StackingPermutator_swigregister(StackingPermutator)


class WeightedGenotypeTester(BasePermutator):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, alternative: 'unsigned int', info: 'vectors',
                 actions: 'vectora'):
        _assoTests.WeightedGenotypeTester_swiginit(
            self,
            _assoTests.new_WeightedGenotypeTester(alternative, info, actions))

    __swig_destroy__ = _assoTests.delete_WeightedGenotypeTester


WeightedGenotypeTester_swigregister = _assoTests.WeightedGenotypeTester_swigregister
WeightedGenotypeTester_swigregister(WeightedGenotypeTester)


class OptimalWeightTester(BasePermutator):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, info: 'vectors', actions: 'vectora'):
        _assoTests.OptimalWeightTester_swiginit(
            self, _assoTests.new_OptimalWeightTester(info, actions))

    __swig_destroy__ = _assoTests.delete_OptimalWeightTester


OptimalWeightTester_swigregister = _assoTests.OptimalWeightTester_swigregister
OptimalWeightTester_swigregister(OptimalWeightTester)


class StopIteration(object):
    thisown = _swig_property(
        lambda x: x.this.own(),
        lambda x, v: x.this.own(v),
        doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, msg: 'string const'):
        _assoTests.StopIteration_swiginit(self,
                                          _assoTests.new_StopIteration(msg))

    __swig_destroy__ = _assoTests.delete_StopIteration


StopIteration_swigregister = _assoTests.StopIteration_swigregister
StopIteration_swigregister(StopIteration)


def gsl_cdf_gaussian_P(x: 'double', sigma: 'double') -> "double":
    return _assoTests.gsl_cdf_gaussian_P(x, sigma)


gsl_cdf_gaussian_P = _assoTests.gsl_cdf_gaussian_P


def gsl_cdf_gaussian_Q(x: 'double', sigma: 'double') -> "double":
    return _assoTests.gsl_cdf_gaussian_Q(x, sigma)


gsl_cdf_gaussian_Q = _assoTests.gsl_cdf_gaussian_Q


def gsl_cdf_gaussian_Pinv(P: 'double', sigma: 'double') -> "double":
    return _assoTests.gsl_cdf_gaussian_Pinv(P, sigma)


gsl_cdf_gaussian_Pinv = _assoTests.gsl_cdf_gaussian_Pinv


def gsl_cdf_gaussian_Qinv(Q: 'double', sigma: 'double') -> "double":
    return _assoTests.gsl_cdf_gaussian_Qinv(Q, sigma)


gsl_cdf_gaussian_Qinv = _assoTests.gsl_cdf_gaussian_Qinv


def gsl_cdf_ugaussian_P(x: 'double') -> "double":
    return _assoTests.gsl_cdf_ugaussian_P(x)


gsl_cdf_ugaussian_P = _assoTests.gsl_cdf_ugaussian_P


def gsl_cdf_ugaussian_Q(x: 'double') -> "double":
    return _assoTests.gsl_cdf_ugaussian_Q(x)


gsl_cdf_ugaussian_Q = _assoTests.gsl_cdf_ugaussian_Q


def gsl_cdf_ugaussian_Pinv(P: 'double') -> "double":
    return _assoTests.gsl_cdf_ugaussian_Pinv(P)


gsl_cdf_ugaussian_Pinv = _assoTests.gsl_cdf_ugaussian_Pinv


def gsl_cdf_ugaussian_Qinv(Q: 'double') -> "double":
    return _assoTests.gsl_cdf_ugaussian_Qinv(Q)


gsl_cdf_ugaussian_Qinv = _assoTests.gsl_cdf_ugaussian_Qinv
