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



from sys import version_info
if version_info >= (3,0,0):
    new_instancemethod = lambda func, inst, cls: _assoTests.SWIG_PyInstanceMethod_New(func)
else:
    from new import instancemethod as new_instancemethod
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_assoTests', [dirname(__file__)])
        except ImportError:
            import _assoTests
            return _assoTests
        if fp is not None:
            try:
                _mod = imp.load_module('_assoTests', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _assoTests = swig_import_helper()
    del swig_import_helper
else:
    import _assoTests
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

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

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


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



def my_error_handler(*args, **kwargs):
  return _assoTests.my_error_handler(*args, **kwargs)
my_error_handler = _assoTests.my_error_handler

def gsl_initialize():
  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.pop = new_instancemethod(_assoTests.vectors_pop,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.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.clear = new_instancemethod(_assoTests.vectors_clear,None,vectors)
vectors.swap = new_instancemethod(_assoTests.vectors_swap,None,vectors)
vectors.get_allocator = new_instancemethod(_assoTests.vectors_get_allocator,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.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.pop = new_instancemethod(_assoTests.vectorf_pop,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.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.clear = new_instancemethod(_assoTests.vectorf_clear,None,vectorf)
vectorf.swap = new_instancemethod(_assoTests.vectorf_swap,None,vectorf)
vectorf.get_allocator = new_instancemethod(_assoTests.vectorf_get_allocator,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.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.pop = new_instancemethod(_assoTests.vectori_pop,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.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.clear = new_instancemethod(_assoTests.vectori_clear,None,vectori)
vectori.swap = new_instancemethod(_assoTests.vectori_swap,None,vectori)
vectori.get_allocator = new_instancemethod(_assoTests.vectori_get_allocator,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.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.pop = new_instancemethod(_assoTests.matrixi_pop,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.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.clear = new_instancemethod(_assoTests.matrixi_clear,None,matrixi)
matrixi.swap = new_instancemethod(_assoTests.matrixi_swap,None,matrixi)
matrixi.get_allocator = new_instancemethod(_assoTests.matrixi_get_allocator,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.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.pop = new_instancemethod(_assoTests.matrixf_pop,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.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.clear = new_instancemethod(_assoTests.matrixf_clear,None,matrixf)
matrixf.swap = new_instancemethod(_assoTests.matrixf_swap,None,matrixf)
matrixf.get_allocator = new_instancemethod(_assoTests.matrixf_get_allocator,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.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.pop = new_instancemethod(_assoTests.vectora_pop,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.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.clear = new_instancemethod(_assoTests.vectora_clear,None,vectora)
vectora.swap = new_instancemethod(_assoTests.vectora_swap,None,vectora)
vectora.get_allocator = new_instancemethod(_assoTests.vectora_get_allocator,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.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(*args, **kwargs):
  return _assoTests.fEqual(*args, **kwargs)
fEqual = _assoTests.fEqual

def fRound(*args, **kwargs):
  return _assoTests.fRound(*args, **kwargs)
fRound = _assoTests.fRound

def Mann_Whitneyu(*args, **kwargs):
  return _assoTests.Mann_Whitneyu(*args, **kwargs)
Mann_Whitneyu = _assoTests.Mann_Whitneyu

def chisq2X2stat(*args, **kwargs):
  return _assoTests.chisq2X2stat(*args, **kwargs)
chisq2X2stat = _assoTests.chisq2X2stat

def dnhyper(*args, **kwargs):
  return _assoTests.dnhyper(*args, **kwargs)
dnhyper = _assoTests.dnhyper

def mnhyper(*args, **kwargs):
  return _assoTests.mnhyper(*args, **kwargs)
mnhyper = _assoTests.mnhyper

def pnhyper(*args, **kwargs):
  return _assoTests.pnhyper(*args, **kwargs)
pnhyper = _assoTests.pnhyper

def fexact2x2(*args, **kwargs):
  return _assoTests.fexact2x2(*args, **kwargs)
fexact2x2 = _assoTests.fexact2x2

def calculateInbreedingCoef(*args, **kwargs):
  return _assoTests.calculateInbreedingCoef(*args, **kwargs)
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():
  return _assoTests.initialize()
initialize = _assoTests.initialize

def pyAssoDataObj(*args, **kwargs):
  return _assoTests.pyAssoDataObj(*args, **kwargs)
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, *args, **kwargs): 
        _assoTests.BrowningWeight_swiginit(self,_assoTests.new_BrowningWeight(*args, **kwargs))
    __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, method="maf"): 
        _assoTests.FillGMissing_swiginit(self,_assoTests.new_FillGMissing(method))
    __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, *args, **kwargs): 
        _assoTests.WeightByInfo_swiginit(self,_assoTests.new_WeightByInfo(*args, **kwargs))
    __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=1.0, lower=0.0, use_mac=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=True, method=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=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=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, *args, **kwargs): 
        _assoTests.Fisher2X2_swiginit(self,_assoTests.new_Fisher2X2(*args, **kwargs))
    __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=1, store=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, *args, **kwargs): 
        _assoTests.WSSPvalue_swiginit(self,_assoTests.new_WSSPvalue(*args, **kwargs))
    __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=1, weightOnly=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=1, weightOnly=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=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, *args, **kwargs): 
        _assoTests.VTFisher_swiginit(self,_assoTests.new_VTFisher(*args, **kwargs))
    __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=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=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, *args, **kwargs): 
        _assoTests.PyAction_swiginit(self,_assoTests.new_PyAction(*args, **kwargs))
    __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, *args, **kwargs): 
        _assoTests.WeightedGenotypeTester_swiginit(self,_assoTests.new_WeightedGenotypeTester(*args, **kwargs))
    __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, *args, **kwargs): 
        _assoTests.OptimalWeightTester_swiginit(self,_assoTests.new_OptimalWeightTester(*args, **kwargs))
    __swig_destroy__ = _assoTests.delete_OptimalWeightTester
OptimalWeightTester_swigregister = _assoTests.OptimalWeightTester_swigregister
OptimalWeightTester_swigregister(OptimalWeightTester)

class Exception(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, *args, **kwargs): 
        _assoTests.Exception_swiginit(self,_assoTests.new_Exception(*args, **kwargs))
    __swig_destroy__ = _assoTests.delete_Exception
Exception.message = new_instancemethod(_assoTests.Exception_message,None,Exception)
Exception_swigregister = _assoTests.Exception_swigregister
Exception_swigregister(Exception)

class StopIteration(Exception):
    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.StopIteration_swiginit(self,_assoTests.new_StopIteration(*args, **kwargs))
    __swig_destroy__ = _assoTests.delete_StopIteration
StopIteration_swigregister = _assoTests.StopIteration_swigregister
StopIteration_swigregister(StopIteration)

class IndexError(Exception):
    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.IndexError_swiginit(self,_assoTests.new_IndexError(*args, **kwargs))
    __swig_destroy__ = _assoTests.delete_IndexError
IndexError_swigregister = _assoTests.IndexError_swigregister
IndexError_swigregister(IndexError)

class ValueError(Exception):
    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.ValueError_swiginit(self,_assoTests.new_ValueError(*args, **kwargs))
    __swig_destroy__ = _assoTests.delete_ValueError
ValueError_swigregister = _assoTests.ValueError_swigregister
ValueError_swigregister(ValueError)

class SystemError(Exception):
    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.SystemError_swiginit(self,_assoTests.new_SystemError(*args, **kwargs))
    __swig_destroy__ = _assoTests.delete_SystemError
SystemError_swigregister = _assoTests.SystemError_swigregister
SystemError_swigregister(SystemError)

class RuntimeError(Exception):
    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.RuntimeError_swiginit(self,_assoTests.new_RuntimeError(*args, **kwargs))
    __swig_destroy__ = _assoTests.delete_RuntimeError
RuntimeError_swigregister = _assoTests.RuntimeError_swigregister
RuntimeError_swigregister(RuntimeError)


def gsl_cdf_gaussian_P(*args, **kwargs):
  return _assoTests.gsl_cdf_gaussian_P(*args, **kwargs)
gsl_cdf_gaussian_P = _assoTests.gsl_cdf_gaussian_P

def gsl_cdf_gaussian_Q(*args, **kwargs):
  return _assoTests.gsl_cdf_gaussian_Q(*args, **kwargs)
gsl_cdf_gaussian_Q = _assoTests.gsl_cdf_gaussian_Q

def gsl_cdf_gaussian_Pinv(*args, **kwargs):
  return _assoTests.gsl_cdf_gaussian_Pinv(*args, **kwargs)
gsl_cdf_gaussian_Pinv = _assoTests.gsl_cdf_gaussian_Pinv

def gsl_cdf_gaussian_Qinv(*args, **kwargs):
  return _assoTests.gsl_cdf_gaussian_Qinv(*args, **kwargs)
gsl_cdf_gaussian_Qinv = _assoTests.gsl_cdf_gaussian_Qinv

def gsl_cdf_ugaussian_P(*args, **kwargs):
  return _assoTests.gsl_cdf_ugaussian_P(*args, **kwargs)
gsl_cdf_ugaussian_P = _assoTests.gsl_cdf_ugaussian_P

def gsl_cdf_ugaussian_Q(*args, **kwargs):
  return _assoTests.gsl_cdf_ugaussian_Q(*args, **kwargs)
gsl_cdf_ugaussian_Q = _assoTests.gsl_cdf_ugaussian_Q

def gsl_cdf_ugaussian_Pinv(*args, **kwargs):
  return _assoTests.gsl_cdf_ugaussian_Pinv(*args, **kwargs)
gsl_cdf_ugaussian_Pinv = _assoTests.gsl_cdf_ugaussian_Pinv

def gsl_cdf_ugaussian_Qinv(*args, **kwargs):
  return _assoTests.gsl_cdf_ugaussian_Qinv(*args, **kwargs)
gsl_cdf_ugaussian_Qinv = _assoTests.gsl_cdf_ugaussian_Qinv


