# 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


