# 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.

"""OpenMEEG bindings for python"""


from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (3, 0, 0):
    new_instancemethod = lambda func, inst, cls: _openmeeg.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, '_openmeeg')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_openmeeg')
    _openmeeg = 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('_openmeeg', [dirname(__file__)])
        except ImportError:
            import _openmeeg
            return _openmeeg
        try:
            _mod = imp.load_module('_openmeeg', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _openmeeg = swig_import_helper()
    del swig_import_helper
else:
    import _openmeeg
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


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__ = _openmeeg.delete_SwigPyIterator
    def __iter__(self):
        return self
SwigPyIterator.value = new_instancemethod(_openmeeg.SwigPyIterator_value, None, SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_openmeeg.SwigPyIterator_incr, None, SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_openmeeg.SwigPyIterator_decr, None, SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_openmeeg.SwigPyIterator_distance, None, SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_openmeeg.SwigPyIterator_equal, None, SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_openmeeg.SwigPyIterator_copy, None, SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_openmeeg.SwigPyIterator_next, None, SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_openmeeg.SwigPyIterator___next__, None, SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_openmeeg.SwigPyIterator_previous, None, SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_openmeeg.SwigPyIterator_advance, None, SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_openmeeg.SwigPyIterator___eq__, None, SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_openmeeg.SwigPyIterator___ne__, None, SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_openmeeg.SwigPyIterator___iadd__, None, SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_openmeeg.SwigPyIterator___isub__, None, SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_openmeeg.SwigPyIterator___add__, None, SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_openmeeg.SwigPyIterator___sub__, None, SwigPyIterator)
SwigPyIterator_swigregister = _openmeeg.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)


def loadmat(fname):
    try:
        from scipy import io
        io.loadmat(fname)['linop']
    except:
        import h5py
        return h5py.File(fname)['linop'].value.T

class vector_int(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):
        _openmeeg.vector_int_swiginit(self, _openmeeg.new_vector_int(*args))
    __swig_destroy__ = _openmeeg.delete_vector_int
vector_int.iterator = new_instancemethod(_openmeeg.vector_int_iterator, None, vector_int)
vector_int.__nonzero__ = new_instancemethod(_openmeeg.vector_int___nonzero__, None, vector_int)
vector_int.__bool__ = new_instancemethod(_openmeeg.vector_int___bool__, None, vector_int)
vector_int.__len__ = new_instancemethod(_openmeeg.vector_int___len__, None, vector_int)
vector_int.__getslice__ = new_instancemethod(_openmeeg.vector_int___getslice__, None, vector_int)
vector_int.__setslice__ = new_instancemethod(_openmeeg.vector_int___setslice__, None, vector_int)
vector_int.__delslice__ = new_instancemethod(_openmeeg.vector_int___delslice__, None, vector_int)
vector_int.__delitem__ = new_instancemethod(_openmeeg.vector_int___delitem__, None, vector_int)
vector_int.__getitem__ = new_instancemethod(_openmeeg.vector_int___getitem__, None, vector_int)
vector_int.__setitem__ = new_instancemethod(_openmeeg.vector_int___setitem__, None, vector_int)
vector_int.pop = new_instancemethod(_openmeeg.vector_int_pop, None, vector_int)
vector_int.append = new_instancemethod(_openmeeg.vector_int_append, None, vector_int)
vector_int.empty = new_instancemethod(_openmeeg.vector_int_empty, None, vector_int)
vector_int.size = new_instancemethod(_openmeeg.vector_int_size, None, vector_int)
vector_int.swap = new_instancemethod(_openmeeg.vector_int_swap, None, vector_int)
vector_int.begin = new_instancemethod(_openmeeg.vector_int_begin, None, vector_int)
vector_int.end = new_instancemethod(_openmeeg.vector_int_end, None, vector_int)
vector_int.rbegin = new_instancemethod(_openmeeg.vector_int_rbegin, None, vector_int)
vector_int.rend = new_instancemethod(_openmeeg.vector_int_rend, None, vector_int)
vector_int.clear = new_instancemethod(_openmeeg.vector_int_clear, None, vector_int)
vector_int.get_allocator = new_instancemethod(_openmeeg.vector_int_get_allocator, None, vector_int)
vector_int.pop_back = new_instancemethod(_openmeeg.vector_int_pop_back, None, vector_int)
vector_int.erase = new_instancemethod(_openmeeg.vector_int_erase, None, vector_int)
vector_int.push_back = new_instancemethod(_openmeeg.vector_int_push_back, None, vector_int)
vector_int.front = new_instancemethod(_openmeeg.vector_int_front, None, vector_int)
vector_int.back = new_instancemethod(_openmeeg.vector_int_back, None, vector_int)
vector_int.assign = new_instancemethod(_openmeeg.vector_int_assign, None, vector_int)
vector_int.resize = new_instancemethod(_openmeeg.vector_int_resize, None, vector_int)
vector_int.insert = new_instancemethod(_openmeeg.vector_int_insert, None, vector_int)
vector_int.reserve = new_instancemethod(_openmeeg.vector_int_reserve, None, vector_int)
vector_int.capacity = new_instancemethod(_openmeeg.vector_int_capacity, None, vector_int)
vector_int_swigregister = _openmeeg.vector_int_swigregister
vector_int_swigregister(vector_int)

class vector_unsigned(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):
        _openmeeg.vector_unsigned_swiginit(self, _openmeeg.new_vector_unsigned(*args))
    __swig_destroy__ = _openmeeg.delete_vector_unsigned
vector_unsigned.iterator = new_instancemethod(_openmeeg.vector_unsigned_iterator, None, vector_unsigned)
vector_unsigned.__nonzero__ = new_instancemethod(_openmeeg.vector_unsigned___nonzero__, None, vector_unsigned)
vector_unsigned.__bool__ = new_instancemethod(_openmeeg.vector_unsigned___bool__, None, vector_unsigned)
vector_unsigned.__len__ = new_instancemethod(_openmeeg.vector_unsigned___len__, None, vector_unsigned)
vector_unsigned.__getslice__ = new_instancemethod(_openmeeg.vector_unsigned___getslice__, None, vector_unsigned)
vector_unsigned.__setslice__ = new_instancemethod(_openmeeg.vector_unsigned___setslice__, None, vector_unsigned)
vector_unsigned.__delslice__ = new_instancemethod(_openmeeg.vector_unsigned___delslice__, None, vector_unsigned)
vector_unsigned.__delitem__ = new_instancemethod(_openmeeg.vector_unsigned___delitem__, None, vector_unsigned)
vector_unsigned.__getitem__ = new_instancemethod(_openmeeg.vector_unsigned___getitem__, None, vector_unsigned)
vector_unsigned.__setitem__ = new_instancemethod(_openmeeg.vector_unsigned___setitem__, None, vector_unsigned)
vector_unsigned.pop = new_instancemethod(_openmeeg.vector_unsigned_pop, None, vector_unsigned)
vector_unsigned.append = new_instancemethod(_openmeeg.vector_unsigned_append, None, vector_unsigned)
vector_unsigned.empty = new_instancemethod(_openmeeg.vector_unsigned_empty, None, vector_unsigned)
vector_unsigned.size = new_instancemethod(_openmeeg.vector_unsigned_size, None, vector_unsigned)
vector_unsigned.swap = new_instancemethod(_openmeeg.vector_unsigned_swap, None, vector_unsigned)
vector_unsigned.begin = new_instancemethod(_openmeeg.vector_unsigned_begin, None, vector_unsigned)
vector_unsigned.end = new_instancemethod(_openmeeg.vector_unsigned_end, None, vector_unsigned)
vector_unsigned.rbegin = new_instancemethod(_openmeeg.vector_unsigned_rbegin, None, vector_unsigned)
vector_unsigned.rend = new_instancemethod(_openmeeg.vector_unsigned_rend, None, vector_unsigned)
vector_unsigned.clear = new_instancemethod(_openmeeg.vector_unsigned_clear, None, vector_unsigned)
vector_unsigned.get_allocator = new_instancemethod(_openmeeg.vector_unsigned_get_allocator, None, vector_unsigned)
vector_unsigned.pop_back = new_instancemethod(_openmeeg.vector_unsigned_pop_back, None, vector_unsigned)
vector_unsigned.erase = new_instancemethod(_openmeeg.vector_unsigned_erase, None, vector_unsigned)
vector_unsigned.push_back = new_instancemethod(_openmeeg.vector_unsigned_push_back, None, vector_unsigned)
vector_unsigned.front = new_instancemethod(_openmeeg.vector_unsigned_front, None, vector_unsigned)
vector_unsigned.back = new_instancemethod(_openmeeg.vector_unsigned_back, None, vector_unsigned)
vector_unsigned.assign = new_instancemethod(_openmeeg.vector_unsigned_assign, None, vector_unsigned)
vector_unsigned.resize = new_instancemethod(_openmeeg.vector_unsigned_resize, None, vector_unsigned)
vector_unsigned.insert = new_instancemethod(_openmeeg.vector_unsigned_insert, None, vector_unsigned)
vector_unsigned.reserve = new_instancemethod(_openmeeg.vector_unsigned_reserve, None, vector_unsigned)
vector_unsigned.capacity = new_instancemethod(_openmeeg.vector_unsigned_capacity, None, vector_unsigned)
vector_unsigned_swigregister = _openmeeg.vector_unsigned_swigregister
vector_unsigned_swigregister(vector_unsigned)

class vector_double(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):
        _openmeeg.vector_double_swiginit(self, _openmeeg.new_vector_double(*args))
    __swig_destroy__ = _openmeeg.delete_vector_double
vector_double.iterator = new_instancemethod(_openmeeg.vector_double_iterator, None, vector_double)
vector_double.__nonzero__ = new_instancemethod(_openmeeg.vector_double___nonzero__, None, vector_double)
vector_double.__bool__ = new_instancemethod(_openmeeg.vector_double___bool__, None, vector_double)
vector_double.__len__ = new_instancemethod(_openmeeg.vector_double___len__, None, vector_double)
vector_double.__getslice__ = new_instancemethod(_openmeeg.vector_double___getslice__, None, vector_double)
vector_double.__setslice__ = new_instancemethod(_openmeeg.vector_double___setslice__, None, vector_double)
vector_double.__delslice__ = new_instancemethod(_openmeeg.vector_double___delslice__, None, vector_double)
vector_double.__delitem__ = new_instancemethod(_openmeeg.vector_double___delitem__, None, vector_double)
vector_double.__getitem__ = new_instancemethod(_openmeeg.vector_double___getitem__, None, vector_double)
vector_double.__setitem__ = new_instancemethod(_openmeeg.vector_double___setitem__, None, vector_double)
vector_double.pop = new_instancemethod(_openmeeg.vector_double_pop, None, vector_double)
vector_double.append = new_instancemethod(_openmeeg.vector_double_append, None, vector_double)
vector_double.empty = new_instancemethod(_openmeeg.vector_double_empty, None, vector_double)
vector_double.size = new_instancemethod(_openmeeg.vector_double_size, None, vector_double)
vector_double.swap = new_instancemethod(_openmeeg.vector_double_swap, None, vector_double)
vector_double.begin = new_instancemethod(_openmeeg.vector_double_begin, None, vector_double)
vector_double.end = new_instancemethod(_openmeeg.vector_double_end, None, vector_double)
vector_double.rbegin = new_instancemethod(_openmeeg.vector_double_rbegin, None, vector_double)
vector_double.rend = new_instancemethod(_openmeeg.vector_double_rend, None, vector_double)
vector_double.clear = new_instancemethod(_openmeeg.vector_double_clear, None, vector_double)
vector_double.get_allocator = new_instancemethod(_openmeeg.vector_double_get_allocator, None, vector_double)
vector_double.pop_back = new_instancemethod(_openmeeg.vector_double_pop_back, None, vector_double)
vector_double.erase = new_instancemethod(_openmeeg.vector_double_erase, None, vector_double)
vector_double.push_back = new_instancemethod(_openmeeg.vector_double_push_back, None, vector_double)
vector_double.front = new_instancemethod(_openmeeg.vector_double_front, None, vector_double)
vector_double.back = new_instancemethod(_openmeeg.vector_double_back, None, vector_double)
vector_double.assign = new_instancemethod(_openmeeg.vector_double_assign, None, vector_double)
vector_double.resize = new_instancemethod(_openmeeg.vector_double_resize, None, vector_double)
vector_double.insert = new_instancemethod(_openmeeg.vector_double_insert, None, vector_double)
vector_double.reserve = new_instancemethod(_openmeeg.vector_double_reserve, None, vector_double)
vector_double.capacity = new_instancemethod(_openmeeg.vector_double_capacity, None, vector_double)
vector_double_swigregister = _openmeeg.vector_double_swigregister
vector_double_swigregister(vector_double)

class vector_vertex(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):
        _openmeeg.vector_vertex_swiginit(self, _openmeeg.new_vector_vertex(*args))
    __swig_destroy__ = _openmeeg.delete_vector_vertex
vector_vertex.iterator = new_instancemethod(_openmeeg.vector_vertex_iterator, None, vector_vertex)
vector_vertex.__nonzero__ = new_instancemethod(_openmeeg.vector_vertex___nonzero__, None, vector_vertex)
vector_vertex.__bool__ = new_instancemethod(_openmeeg.vector_vertex___bool__, None, vector_vertex)
vector_vertex.__len__ = new_instancemethod(_openmeeg.vector_vertex___len__, None, vector_vertex)
vector_vertex.__getslice__ = new_instancemethod(_openmeeg.vector_vertex___getslice__, None, vector_vertex)
vector_vertex.__setslice__ = new_instancemethod(_openmeeg.vector_vertex___setslice__, None, vector_vertex)
vector_vertex.__delslice__ = new_instancemethod(_openmeeg.vector_vertex___delslice__, None, vector_vertex)
vector_vertex.__delitem__ = new_instancemethod(_openmeeg.vector_vertex___delitem__, None, vector_vertex)
vector_vertex.__getitem__ = new_instancemethod(_openmeeg.vector_vertex___getitem__, None, vector_vertex)
vector_vertex.__setitem__ = new_instancemethod(_openmeeg.vector_vertex___setitem__, None, vector_vertex)
vector_vertex.pop = new_instancemethod(_openmeeg.vector_vertex_pop, None, vector_vertex)
vector_vertex.append = new_instancemethod(_openmeeg.vector_vertex_append, None, vector_vertex)
vector_vertex.empty = new_instancemethod(_openmeeg.vector_vertex_empty, None, vector_vertex)
vector_vertex.size = new_instancemethod(_openmeeg.vector_vertex_size, None, vector_vertex)
vector_vertex.swap = new_instancemethod(_openmeeg.vector_vertex_swap, None, vector_vertex)
vector_vertex.begin = new_instancemethod(_openmeeg.vector_vertex_begin, None, vector_vertex)
vector_vertex.end = new_instancemethod(_openmeeg.vector_vertex_end, None, vector_vertex)
vector_vertex.rbegin = new_instancemethod(_openmeeg.vector_vertex_rbegin, None, vector_vertex)
vector_vertex.rend = new_instancemethod(_openmeeg.vector_vertex_rend, None, vector_vertex)
vector_vertex.clear = new_instancemethod(_openmeeg.vector_vertex_clear, None, vector_vertex)
vector_vertex.get_allocator = new_instancemethod(_openmeeg.vector_vertex_get_allocator, None, vector_vertex)
vector_vertex.pop_back = new_instancemethod(_openmeeg.vector_vertex_pop_back, None, vector_vertex)
vector_vertex.erase = new_instancemethod(_openmeeg.vector_vertex_erase, None, vector_vertex)
vector_vertex.push_back = new_instancemethod(_openmeeg.vector_vertex_push_back, None, vector_vertex)
vector_vertex.front = new_instancemethod(_openmeeg.vector_vertex_front, None, vector_vertex)
vector_vertex.back = new_instancemethod(_openmeeg.vector_vertex_back, None, vector_vertex)
vector_vertex.assign = new_instancemethod(_openmeeg.vector_vertex_assign, None, vector_vertex)
vector_vertex.resize = new_instancemethod(_openmeeg.vector_vertex_resize, None, vector_vertex)
vector_vertex.insert = new_instancemethod(_openmeeg.vector_vertex_insert, None, vector_vertex)
vector_vertex.reserve = new_instancemethod(_openmeeg.vector_vertex_reserve, None, vector_vertex)
vector_vertex.capacity = new_instancemethod(_openmeeg.vector_vertex_capacity, None, vector_vertex)
vector_vertex_swigregister = _openmeeg.vector_vertex_swigregister
vector_vertex_swigregister(vector_vertex)

class vector_pvertex(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):
        _openmeeg.vector_pvertex_swiginit(self, _openmeeg.new_vector_pvertex(*args))
    __swig_destroy__ = _openmeeg.delete_vector_pvertex
vector_pvertex.iterator = new_instancemethod(_openmeeg.vector_pvertex_iterator, None, vector_pvertex)
vector_pvertex.__nonzero__ = new_instancemethod(_openmeeg.vector_pvertex___nonzero__, None, vector_pvertex)
vector_pvertex.__bool__ = new_instancemethod(_openmeeg.vector_pvertex___bool__, None, vector_pvertex)
vector_pvertex.__len__ = new_instancemethod(_openmeeg.vector_pvertex___len__, None, vector_pvertex)
vector_pvertex.__getslice__ = new_instancemethod(_openmeeg.vector_pvertex___getslice__, None, vector_pvertex)
vector_pvertex.__setslice__ = new_instancemethod(_openmeeg.vector_pvertex___setslice__, None, vector_pvertex)
vector_pvertex.__delslice__ = new_instancemethod(_openmeeg.vector_pvertex___delslice__, None, vector_pvertex)
vector_pvertex.__delitem__ = new_instancemethod(_openmeeg.vector_pvertex___delitem__, None, vector_pvertex)
vector_pvertex.__getitem__ = new_instancemethod(_openmeeg.vector_pvertex___getitem__, None, vector_pvertex)
vector_pvertex.__setitem__ = new_instancemethod(_openmeeg.vector_pvertex___setitem__, None, vector_pvertex)
vector_pvertex.pop = new_instancemethod(_openmeeg.vector_pvertex_pop, None, vector_pvertex)
vector_pvertex.append = new_instancemethod(_openmeeg.vector_pvertex_append, None, vector_pvertex)
vector_pvertex.empty = new_instancemethod(_openmeeg.vector_pvertex_empty, None, vector_pvertex)
vector_pvertex.size = new_instancemethod(_openmeeg.vector_pvertex_size, None, vector_pvertex)
vector_pvertex.swap = new_instancemethod(_openmeeg.vector_pvertex_swap, None, vector_pvertex)
vector_pvertex.begin = new_instancemethod(_openmeeg.vector_pvertex_begin, None, vector_pvertex)
vector_pvertex.end = new_instancemethod(_openmeeg.vector_pvertex_end, None, vector_pvertex)
vector_pvertex.rbegin = new_instancemethod(_openmeeg.vector_pvertex_rbegin, None, vector_pvertex)
vector_pvertex.rend = new_instancemethod(_openmeeg.vector_pvertex_rend, None, vector_pvertex)
vector_pvertex.clear = new_instancemethod(_openmeeg.vector_pvertex_clear, None, vector_pvertex)
vector_pvertex.get_allocator = new_instancemethod(_openmeeg.vector_pvertex_get_allocator, None, vector_pvertex)
vector_pvertex.pop_back = new_instancemethod(_openmeeg.vector_pvertex_pop_back, None, vector_pvertex)
vector_pvertex.erase = new_instancemethod(_openmeeg.vector_pvertex_erase, None, vector_pvertex)
vector_pvertex.push_back = new_instancemethod(_openmeeg.vector_pvertex_push_back, None, vector_pvertex)
vector_pvertex.front = new_instancemethod(_openmeeg.vector_pvertex_front, None, vector_pvertex)
vector_pvertex.back = new_instancemethod(_openmeeg.vector_pvertex_back, None, vector_pvertex)
vector_pvertex.assign = new_instancemethod(_openmeeg.vector_pvertex_assign, None, vector_pvertex)
vector_pvertex.resize = new_instancemethod(_openmeeg.vector_pvertex_resize, None, vector_pvertex)
vector_pvertex.insert = new_instancemethod(_openmeeg.vector_pvertex_insert, None, vector_pvertex)
vector_pvertex.reserve = new_instancemethod(_openmeeg.vector_pvertex_reserve, None, vector_pvertex)
vector_pvertex.capacity = new_instancemethod(_openmeeg.vector_pvertex_capacity, None, vector_pvertex)
vector_pvertex_swigregister = _openmeeg.vector_pvertex_swigregister
vector_pvertex_swigregister(vector_pvertex)

class vector_triangle(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):
        _openmeeg.vector_triangle_swiginit(self, _openmeeg.new_vector_triangle(*args))
    __swig_destroy__ = _openmeeg.delete_vector_triangle
vector_triangle.iterator = new_instancemethod(_openmeeg.vector_triangle_iterator, None, vector_triangle)
vector_triangle.__nonzero__ = new_instancemethod(_openmeeg.vector_triangle___nonzero__, None, vector_triangle)
vector_triangle.__bool__ = new_instancemethod(_openmeeg.vector_triangle___bool__, None, vector_triangle)
vector_triangle.__len__ = new_instancemethod(_openmeeg.vector_triangle___len__, None, vector_triangle)
vector_triangle.__getslice__ = new_instancemethod(_openmeeg.vector_triangle___getslice__, None, vector_triangle)
vector_triangle.__setslice__ = new_instancemethod(_openmeeg.vector_triangle___setslice__, None, vector_triangle)
vector_triangle.__delslice__ = new_instancemethod(_openmeeg.vector_triangle___delslice__, None, vector_triangle)
vector_triangle.__delitem__ = new_instancemethod(_openmeeg.vector_triangle___delitem__, None, vector_triangle)
vector_triangle.__getitem__ = new_instancemethod(_openmeeg.vector_triangle___getitem__, None, vector_triangle)
vector_triangle.__setitem__ = new_instancemethod(_openmeeg.vector_triangle___setitem__, None, vector_triangle)
vector_triangle.pop = new_instancemethod(_openmeeg.vector_triangle_pop, None, vector_triangle)
vector_triangle.append = new_instancemethod(_openmeeg.vector_triangle_append, None, vector_triangle)
vector_triangle.empty = new_instancemethod(_openmeeg.vector_triangle_empty, None, vector_triangle)
vector_triangle.size = new_instancemethod(_openmeeg.vector_triangle_size, None, vector_triangle)
vector_triangle.swap = new_instancemethod(_openmeeg.vector_triangle_swap, None, vector_triangle)
vector_triangle.begin = new_instancemethod(_openmeeg.vector_triangle_begin, None, vector_triangle)
vector_triangle.end = new_instancemethod(_openmeeg.vector_triangle_end, None, vector_triangle)
vector_triangle.rbegin = new_instancemethod(_openmeeg.vector_triangle_rbegin, None, vector_triangle)
vector_triangle.rend = new_instancemethod(_openmeeg.vector_triangle_rend, None, vector_triangle)
vector_triangle.clear = new_instancemethod(_openmeeg.vector_triangle_clear, None, vector_triangle)
vector_triangle.get_allocator = new_instancemethod(_openmeeg.vector_triangle_get_allocator, None, vector_triangle)
vector_triangle.pop_back = new_instancemethod(_openmeeg.vector_triangle_pop_back, None, vector_triangle)
vector_triangle.erase = new_instancemethod(_openmeeg.vector_triangle_erase, None, vector_triangle)
vector_triangle.push_back = new_instancemethod(_openmeeg.vector_triangle_push_back, None, vector_triangle)
vector_triangle.front = new_instancemethod(_openmeeg.vector_triangle_front, None, vector_triangle)
vector_triangle.back = new_instancemethod(_openmeeg.vector_triangle_back, None, vector_triangle)
vector_triangle.assign = new_instancemethod(_openmeeg.vector_triangle_assign, None, vector_triangle)
vector_triangle.resize = new_instancemethod(_openmeeg.vector_triangle_resize, None, vector_triangle)
vector_triangle.insert = new_instancemethod(_openmeeg.vector_triangle_insert, None, vector_triangle)
vector_triangle.reserve = new_instancemethod(_openmeeg.vector_triangle_reserve, None, vector_triangle)
vector_triangle.capacity = new_instancemethod(_openmeeg.vector_triangle_capacity, None, vector_triangle)
vector_triangle_swigregister = _openmeeg.vector_triangle_swigregister
vector_triangle_swigregister(vector_triangle)

class vector_mesh(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):
        _openmeeg.vector_mesh_swiginit(self, _openmeeg.new_vector_mesh(*args))
    __swig_destroy__ = _openmeeg.delete_vector_mesh
vector_mesh.iterator = new_instancemethod(_openmeeg.vector_mesh_iterator, None, vector_mesh)
vector_mesh.__nonzero__ = new_instancemethod(_openmeeg.vector_mesh___nonzero__, None, vector_mesh)
vector_mesh.__bool__ = new_instancemethod(_openmeeg.vector_mesh___bool__, None, vector_mesh)
vector_mesh.__len__ = new_instancemethod(_openmeeg.vector_mesh___len__, None, vector_mesh)
vector_mesh.__getslice__ = new_instancemethod(_openmeeg.vector_mesh___getslice__, None, vector_mesh)
vector_mesh.__setslice__ = new_instancemethod(_openmeeg.vector_mesh___setslice__, None, vector_mesh)
vector_mesh.__delslice__ = new_instancemethod(_openmeeg.vector_mesh___delslice__, None, vector_mesh)
vector_mesh.__delitem__ = new_instancemethod(_openmeeg.vector_mesh___delitem__, None, vector_mesh)
vector_mesh.__getitem__ = new_instancemethod(_openmeeg.vector_mesh___getitem__, None, vector_mesh)
vector_mesh.__setitem__ = new_instancemethod(_openmeeg.vector_mesh___setitem__, None, vector_mesh)
vector_mesh.pop = new_instancemethod(_openmeeg.vector_mesh_pop, None, vector_mesh)
vector_mesh.append = new_instancemethod(_openmeeg.vector_mesh_append, None, vector_mesh)
vector_mesh.empty = new_instancemethod(_openmeeg.vector_mesh_empty, None, vector_mesh)
vector_mesh.size = new_instancemethod(_openmeeg.vector_mesh_size, None, vector_mesh)
vector_mesh.swap = new_instancemethod(_openmeeg.vector_mesh_swap, None, vector_mesh)
vector_mesh.begin = new_instancemethod(_openmeeg.vector_mesh_begin, None, vector_mesh)
vector_mesh.end = new_instancemethod(_openmeeg.vector_mesh_end, None, vector_mesh)
vector_mesh.rbegin = new_instancemethod(_openmeeg.vector_mesh_rbegin, None, vector_mesh)
vector_mesh.rend = new_instancemethod(_openmeeg.vector_mesh_rend, None, vector_mesh)
vector_mesh.clear = new_instancemethod(_openmeeg.vector_mesh_clear, None, vector_mesh)
vector_mesh.get_allocator = new_instancemethod(_openmeeg.vector_mesh_get_allocator, None, vector_mesh)
vector_mesh.pop_back = new_instancemethod(_openmeeg.vector_mesh_pop_back, None, vector_mesh)
vector_mesh.erase = new_instancemethod(_openmeeg.vector_mesh_erase, None, vector_mesh)
vector_mesh.push_back = new_instancemethod(_openmeeg.vector_mesh_push_back, None, vector_mesh)
vector_mesh.front = new_instancemethod(_openmeeg.vector_mesh_front, None, vector_mesh)
vector_mesh.back = new_instancemethod(_openmeeg.vector_mesh_back, None, vector_mesh)
vector_mesh.assign = new_instancemethod(_openmeeg.vector_mesh_assign, None, vector_mesh)
vector_mesh.resize = new_instancemethod(_openmeeg.vector_mesh_resize, None, vector_mesh)
vector_mesh.insert = new_instancemethod(_openmeeg.vector_mesh_insert, None, vector_mesh)
vector_mesh.reserve = new_instancemethod(_openmeeg.vector_mesh_reserve, None, vector_mesh)
vector_mesh.capacity = new_instancemethod(_openmeeg.vector_mesh_capacity, None, vector_mesh)
vector_mesh_swigregister = _openmeeg.vector_mesh_swigregister
vector_mesh_swigregister(vector_mesh)

class vector_string(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):
        _openmeeg.vector_string_swiginit(self, _openmeeg.new_vector_string(*args))
    __swig_destroy__ = _openmeeg.delete_vector_string
vector_string.iterator = new_instancemethod(_openmeeg.vector_string_iterator, None, vector_string)
vector_string.__nonzero__ = new_instancemethod(_openmeeg.vector_string___nonzero__, None, vector_string)
vector_string.__bool__ = new_instancemethod(_openmeeg.vector_string___bool__, None, vector_string)
vector_string.__len__ = new_instancemethod(_openmeeg.vector_string___len__, None, vector_string)
vector_string.__getslice__ = new_instancemethod(_openmeeg.vector_string___getslice__, None, vector_string)
vector_string.__setslice__ = new_instancemethod(_openmeeg.vector_string___setslice__, None, vector_string)
vector_string.__delslice__ = new_instancemethod(_openmeeg.vector_string___delslice__, None, vector_string)
vector_string.__delitem__ = new_instancemethod(_openmeeg.vector_string___delitem__, None, vector_string)
vector_string.__getitem__ = new_instancemethod(_openmeeg.vector_string___getitem__, None, vector_string)
vector_string.__setitem__ = new_instancemethod(_openmeeg.vector_string___setitem__, None, vector_string)
vector_string.pop = new_instancemethod(_openmeeg.vector_string_pop, None, vector_string)
vector_string.append = new_instancemethod(_openmeeg.vector_string_append, None, vector_string)
vector_string.empty = new_instancemethod(_openmeeg.vector_string_empty, None, vector_string)
vector_string.size = new_instancemethod(_openmeeg.vector_string_size, None, vector_string)
vector_string.swap = new_instancemethod(_openmeeg.vector_string_swap, None, vector_string)
vector_string.begin = new_instancemethod(_openmeeg.vector_string_begin, None, vector_string)
vector_string.end = new_instancemethod(_openmeeg.vector_string_end, None, vector_string)
vector_string.rbegin = new_instancemethod(_openmeeg.vector_string_rbegin, None, vector_string)
vector_string.rend = new_instancemethod(_openmeeg.vector_string_rend, None, vector_string)
vector_string.clear = new_instancemethod(_openmeeg.vector_string_clear, None, vector_string)
vector_string.get_allocator = new_instancemethod(_openmeeg.vector_string_get_allocator, None, vector_string)
vector_string.pop_back = new_instancemethod(_openmeeg.vector_string_pop_back, None, vector_string)
vector_string.erase = new_instancemethod(_openmeeg.vector_string_erase, None, vector_string)
vector_string.push_back = new_instancemethod(_openmeeg.vector_string_push_back, None, vector_string)
vector_string.front = new_instancemethod(_openmeeg.vector_string_front, None, vector_string)
vector_string.back = new_instancemethod(_openmeeg.vector_string_back, None, vector_string)
vector_string.assign = new_instancemethod(_openmeeg.vector_string_assign, None, vector_string)
vector_string.resize = new_instancemethod(_openmeeg.vector_string_resize, None, vector_string)
vector_string.insert = new_instancemethod(_openmeeg.vector_string_insert, None, vector_string)
vector_string.reserve = new_instancemethod(_openmeeg.vector_string_reserve, None, vector_string)
vector_string.capacity = new_instancemethod(_openmeeg.vector_string_capacity, None, vector_string)
vector_string_swigregister = _openmeeg.vector_string_swigregister
vector_string_swigregister(vector_string)

class vector_interface(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):
        _openmeeg.vector_interface_swiginit(self, _openmeeg.new_vector_interface(*args))
    __swig_destroy__ = _openmeeg.delete_vector_interface
vector_interface.iterator = new_instancemethod(_openmeeg.vector_interface_iterator, None, vector_interface)
vector_interface.__nonzero__ = new_instancemethod(_openmeeg.vector_interface___nonzero__, None, vector_interface)
vector_interface.__bool__ = new_instancemethod(_openmeeg.vector_interface___bool__, None, vector_interface)
vector_interface.__len__ = new_instancemethod(_openmeeg.vector_interface___len__, None, vector_interface)
vector_interface.__getslice__ = new_instancemethod(_openmeeg.vector_interface___getslice__, None, vector_interface)
vector_interface.__setslice__ = new_instancemethod(_openmeeg.vector_interface___setslice__, None, vector_interface)
vector_interface.__delslice__ = new_instancemethod(_openmeeg.vector_interface___delslice__, None, vector_interface)
vector_interface.__delitem__ = new_instancemethod(_openmeeg.vector_interface___delitem__, None, vector_interface)
vector_interface.__getitem__ = new_instancemethod(_openmeeg.vector_interface___getitem__, None, vector_interface)
vector_interface.__setitem__ = new_instancemethod(_openmeeg.vector_interface___setitem__, None, vector_interface)
vector_interface.pop = new_instancemethod(_openmeeg.vector_interface_pop, None, vector_interface)
vector_interface.append = new_instancemethod(_openmeeg.vector_interface_append, None, vector_interface)
vector_interface.empty = new_instancemethod(_openmeeg.vector_interface_empty, None, vector_interface)
vector_interface.size = new_instancemethod(_openmeeg.vector_interface_size, None, vector_interface)
vector_interface.swap = new_instancemethod(_openmeeg.vector_interface_swap, None, vector_interface)
vector_interface.begin = new_instancemethod(_openmeeg.vector_interface_begin, None, vector_interface)
vector_interface.end = new_instancemethod(_openmeeg.vector_interface_end, None, vector_interface)
vector_interface.rbegin = new_instancemethod(_openmeeg.vector_interface_rbegin, None, vector_interface)
vector_interface.rend = new_instancemethod(_openmeeg.vector_interface_rend, None, vector_interface)
vector_interface.clear = new_instancemethod(_openmeeg.vector_interface_clear, None, vector_interface)
vector_interface.get_allocator = new_instancemethod(_openmeeg.vector_interface_get_allocator, None, vector_interface)
vector_interface.pop_back = new_instancemethod(_openmeeg.vector_interface_pop_back, None, vector_interface)
vector_interface.erase = new_instancemethod(_openmeeg.vector_interface_erase, None, vector_interface)
vector_interface.push_back = new_instancemethod(_openmeeg.vector_interface_push_back, None, vector_interface)
vector_interface.front = new_instancemethod(_openmeeg.vector_interface_front, None, vector_interface)
vector_interface.back = new_instancemethod(_openmeeg.vector_interface_back, None, vector_interface)
vector_interface.assign = new_instancemethod(_openmeeg.vector_interface_assign, None, vector_interface)
vector_interface.resize = new_instancemethod(_openmeeg.vector_interface_resize, None, vector_interface)
vector_interface.insert = new_instancemethod(_openmeeg.vector_interface_insert, None, vector_interface)
vector_interface.reserve = new_instancemethod(_openmeeg.vector_interface_reserve, None, vector_interface)
vector_interface.capacity = new_instancemethod(_openmeeg.vector_interface_capacity, None, vector_interface)
vector_interface_swigregister = _openmeeg.vector_interface_swigregister
vector_interface_swigregister(vector_interface)

class Vect3(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__ = _openmeeg.delete_Vect3

    def __init__(self, *args):
        _openmeeg.Vect3_swiginit(self, _openmeeg.new_Vect3(*args))

    def __itruediv__(self, *args):
        return _openmeeg.Vect3___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __truediv__(self, *args):
        return _openmeeg.Vect3___truediv__(self, *args)
    __div__ = __truediv__


Vect3.x = new_instancemethod(_openmeeg.Vect3_x, None, Vect3)
Vect3.y = new_instancemethod(_openmeeg.Vect3_y, None, Vect3)
Vect3.z = new_instancemethod(_openmeeg.Vect3_z, None, Vect3)
Vect3.__lt__ = new_instancemethod(_openmeeg.Vect3___lt__, None, Vect3)
Vect3.norm = new_instancemethod(_openmeeg.Vect3_norm, None, Vect3)
Vect3.norm2 = new_instancemethod(_openmeeg.Vect3_norm2, None, Vect3)
Vect3.__eq__ = new_instancemethod(_openmeeg.Vect3___eq__, None, Vect3)
Vect3.__ne__ = new_instancemethod(_openmeeg.Vect3___ne__, None, Vect3)
Vect3.__iadd__ = new_instancemethod(_openmeeg.Vect3___iadd__, None, Vect3)
Vect3.__isub__ = new_instancemethod(_openmeeg.Vect3___isub__, None, Vect3)
Vect3.__imul__ = new_instancemethod(_openmeeg.Vect3___imul__, None, Vect3)
Vect3.multadd = new_instancemethod(_openmeeg.Vect3_multadd, None, Vect3)
Vect3.__add__ = new_instancemethod(_openmeeg.Vect3___add__, None, Vect3)
Vect3.__sub__ = new_instancemethod(_openmeeg.Vect3___sub__, None, Vect3)
Vect3.__xor__ = new_instancemethod(_openmeeg.Vect3___xor__, None, Vect3)
Vect3.__mul__ = new_instancemethod(_openmeeg.Vect3___mul__, None, Vect3)
Vect3.__call__ = new_instancemethod(_openmeeg.Vect3___call__, None, Vect3)
Vect3.__neg__ = new_instancemethod(_openmeeg.Vect3___neg__, None, Vect3)
Vect3.det = new_instancemethod(_openmeeg.Vect3_det, None, Vect3)
Vect3.solangl = new_instancemethod(_openmeeg.Vect3_solangl, None, Vect3)
Vect3.normalize = new_instancemethod(_openmeeg.Vect3_normalize, None, Vect3)
Vect3_swigregister = _openmeeg.Vect3_swigregister
Vect3_swigregister(Vect3)

class Vertex(Vect3):
    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):
        _openmeeg.Vertex_swiginit(self, _openmeeg.new_Vertex(*args))
    __swig_destroy__ = _openmeeg.delete_Vertex
Vertex.index = new_instancemethod(_openmeeg.Vertex_index, None, Vertex)
Vertex.getindex = new_instancemethod(_openmeeg.Vertex_getindex, None, Vertex)
Vertex_swigregister = _openmeeg.Vertex_swigregister
Vertex_swigregister(Vertex)

class Triangle(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):
        _openmeeg.Triangle_swiginit(self, _openmeeg.new_Triangle(*args))
    __swig_destroy__ = _openmeeg.delete_Triangle
Triangle.__call__ = new_instancemethod(_openmeeg.Triangle___call__, None, Triangle)
Triangle.__eq__ = new_instancemethod(_openmeeg.Triangle___eq__, None, Triangle)
Triangle.vertex = new_instancemethod(_openmeeg.Triangle_vertex, None, Triangle)
Triangle.begin = new_instancemethod(_openmeeg.Triangle_begin, None, Triangle)
Triangle.end = new_instancemethod(_openmeeg.Triangle_end, None, Triangle)
Triangle.s1 = new_instancemethod(_openmeeg.Triangle_s1, None, Triangle)
Triangle.s2 = new_instancemethod(_openmeeg.Triangle_s2, None, Triangle)
Triangle.s3 = new_instancemethod(_openmeeg.Triangle_s3, None, Triangle)
Triangle.normal = new_instancemethod(_openmeeg.Triangle_normal, None, Triangle)
Triangle.area = new_instancemethod(_openmeeg.Triangle_area, None, Triangle)
Triangle.index = new_instancemethod(_openmeeg.Triangle_index, None, Triangle)
Triangle.prev = new_instancemethod(_openmeeg.Triangle_prev, None, Triangle)
Triangle.next = new_instancemethod(_openmeeg.Triangle_next, None, Triangle)
Triangle.center = new_instancemethod(_openmeeg.Triangle_center, None, Triangle)
Triangle.contains = new_instancemethod(_openmeeg.Triangle_contains, None, Triangle)
Triangle.flip = new_instancemethod(_openmeeg.Triangle_flip, None, Triangle)
Triangle.getindex = new_instancemethod(_openmeeg.Triangle_getindex, None, Triangle)
Triangle_swigregister = _openmeeg.Triangle_swigregister
Triangle_swigregister(Triangle)


def sizet_to_int(num):
    return _openmeeg.sizet_to_int(num)
sizet_to_int = _openmeeg.sizet_to_int
class LinOpInfo(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    FULL = _openmeeg.LinOpInfo_FULL
    SYMMETRIC = _openmeeg.LinOpInfo_SYMMETRIC
    SPARSE = _openmeeg.LinOpInfo_SPARSE

    def __init__(self, *args):
        _openmeeg.LinOpInfo_swiginit(self, _openmeeg.new_LinOpInfo(*args))
    __swig_destroy__ = _openmeeg.delete_LinOpInfo
LinOpInfo.nlin = new_instancemethod(_openmeeg.LinOpInfo_nlin, None, LinOpInfo)
LinOpInfo.ncol = new_instancemethod(_openmeeg.LinOpInfo_ncol, None, LinOpInfo)
LinOpInfo.storageType = new_instancemethod(_openmeeg.LinOpInfo_storageType, None, LinOpInfo)
LinOpInfo.dimension = new_instancemethod(_openmeeg.LinOpInfo_dimension, None, LinOpInfo)
LinOpInfo.default_io = new_instancemethod(_openmeeg.LinOpInfo_default_io, None, LinOpInfo)
LinOpInfo_swigregister = _openmeeg.LinOpInfo_swigregister
LinOpInfo_swigregister(LinOpInfo)

class LinOp(LinOpInfo):
    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__ = _openmeeg.delete_LinOp
LinOp.size = new_instancemethod(_openmeeg.LinOp_size, None, LinOp)
LinOp.info = new_instancemethod(_openmeeg.LinOp_info, None, LinOp)
LinOp_swigregister = _openmeeg.LinOp_swigregister
LinOp_swigregister(LinOp)

DEEP_COPY = _openmeeg.DEEP_COPY
class LinOpValue(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    data = _swig_property(_openmeeg.LinOpValue_data_get, _openmeeg.LinOpValue_data_set)

    def __init__(self, *args):
        _openmeeg.LinOpValue_swiginit(self, _openmeeg.new_LinOpValue(*args))
    __swig_destroy__ = _openmeeg.delete_LinOpValue
LinOpValue.init = new_instancemethod(_openmeeg.LinOpValue_init, None, LinOpValue)
LinOpValue.empty = new_instancemethod(_openmeeg.LinOpValue_empty, None, LinOpValue)
LinOpValue_swigregister = _openmeeg.LinOpValue_swigregister
LinOpValue_swigregister(LinOpValue)

class Vector(LinOp):
    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):
        _openmeeg.Vector_swiginit(self, _openmeeg.new_Vector(*args))

    def __itruediv__(self, *args):
        return _openmeeg.Vector___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __truediv__(self, *args):
        return _openmeeg.Vector___truediv__(self, *args)
    __div__ = __truediv__


    __swig_destroy__ = _openmeeg.delete_Vector
Vector.alloc_data = new_instancemethod(_openmeeg.Vector_alloc_data, None, Vector)
Vector.reference_data = new_instancemethod(_openmeeg.Vector_reference_data, None, Vector)
Vector.empty = new_instancemethod(_openmeeg.Vector_empty, None, Vector)
Vector.data = new_instancemethod(_openmeeg.Vector_data, None, Vector)
Vector.__call__ = new_instancemethod(_openmeeg.Vector___call__, None, Vector)
Vector.subvect = new_instancemethod(_openmeeg.Vector_subvect, None, Vector)
Vector.__iadd__ = new_instancemethod(_openmeeg.Vector___iadd__, None, Vector)
Vector.__isub__ = new_instancemethod(_openmeeg.Vector___isub__, None, Vector)
Vector.__imul__ = new_instancemethod(_openmeeg.Vector___imul__, None, Vector)
Vector.__add__ = new_instancemethod(_openmeeg.Vector___add__, None, Vector)
Vector.__sub__ = new_instancemethod(_openmeeg.Vector___sub__, None, Vector)
Vector.__mul__ = new_instancemethod(_openmeeg.Vector___mul__, None, Vector)
Vector.kmult = new_instancemethod(_openmeeg.Vector_kmult, None, Vector)
Vector.outer_product = new_instancemethod(_openmeeg.Vector_outer_product, None, Vector)
Vector.norm = new_instancemethod(_openmeeg.Vector_norm, None, Vector)
Vector.sum = new_instancemethod(_openmeeg.Vector_sum, None, Vector)
Vector.mean = new_instancemethod(_openmeeg.Vector_mean, None, Vector)
Vector.set = new_instancemethod(_openmeeg.Vector_set, None, Vector)
Vector.save = new_instancemethod(_openmeeg.Vector_save, None, Vector)
Vector.load = new_instancemethod(_openmeeg.Vector_load, None, Vector)
Vector.setvalue = new_instancemethod(_openmeeg.Vector_setvalue, None, Vector)
Vector_swigregister = _openmeeg.Vector_swigregister
Vector_swigregister(Vector)


def __mul__(*args):
    return _openmeeg.__mul__(*args)
__mul__ = _openmeeg.__mul__

def __rshift__(*args):
    return _openmeeg.__rshift__(*args)
__rshift__ = _openmeeg.__rshift__
class Matrix(LinOp):
    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):
        _openmeeg.Matrix_swiginit(self, _openmeeg.new_Matrix(*args))

    def __truediv__(self, *args):
        return _openmeeg.Matrix___truediv__(self, *args)
    __div__ = __truediv__



    def __itruediv__(self, *args):
        return _openmeeg.Matrix___itruediv__(self, *args)
    __idiv__ = __itruediv__


    __swig_destroy__ = _openmeeg.delete_Matrix
Matrix.alloc_data = new_instancemethod(_openmeeg.Matrix_alloc_data, None, Matrix)
Matrix.reference_data = new_instancemethod(_openmeeg.Matrix_reference_data, None, Matrix)
Matrix.empty = new_instancemethod(_openmeeg.Matrix_empty, None, Matrix)
Matrix.data = new_instancemethod(_openmeeg.Matrix_data, None, Matrix)
Matrix.__call__ = new_instancemethod(_openmeeg.Matrix___call__, None, Matrix)
Matrix.submat = new_instancemethod(_openmeeg.Matrix_submat, None, Matrix)
Matrix.insertmat = new_instancemethod(_openmeeg.Matrix_insertmat, None, Matrix)
Matrix.getcol = new_instancemethod(_openmeeg.Matrix_getcol, None, Matrix)
Matrix.setcol = new_instancemethod(_openmeeg.Matrix_setcol, None, Matrix)
Matrix.getlin = new_instancemethod(_openmeeg.Matrix_getlin, None, Matrix)
Matrix.setlin = new_instancemethod(_openmeeg.Matrix_setlin, None, Matrix)
Matrix.set = new_instancemethod(_openmeeg.Matrix_set, None, Matrix)
Matrix.__add__ = new_instancemethod(_openmeeg.Matrix___add__, None, Matrix)
Matrix.__sub__ = new_instancemethod(_openmeeg.Matrix___sub__, None, Matrix)
Matrix.__iadd__ = new_instancemethod(_openmeeg.Matrix___iadd__, None, Matrix)
Matrix.__isub__ = new_instancemethod(_openmeeg.Matrix___isub__, None, Matrix)
Matrix.__imul__ = new_instancemethod(_openmeeg.Matrix___imul__, None, Matrix)
Matrix.__mul__ = new_instancemethod(_openmeeg.Matrix___mul__, None, Matrix)
Matrix.tmult = new_instancemethod(_openmeeg.Matrix_tmult, None, Matrix)
Matrix.multt = new_instancemethod(_openmeeg.Matrix_multt, None, Matrix)
Matrix.tmultt = new_instancemethod(_openmeeg.Matrix_tmultt, None, Matrix)
Matrix.mean = new_instancemethod(_openmeeg.Matrix_mean, None, Matrix)
Matrix.tmean = new_instancemethod(_openmeeg.Matrix_tmean, None, Matrix)
Matrix.transpose = new_instancemethod(_openmeeg.Matrix_transpose, None, Matrix)
Matrix.inverse = new_instancemethod(_openmeeg.Matrix_inverse, None, Matrix)
Matrix.pinverse = new_instancemethod(_openmeeg.Matrix_pinverse, None, Matrix)
Matrix.svd = new_instancemethod(_openmeeg.Matrix_svd, None, Matrix)
Matrix.frobenius_norm = new_instancemethod(_openmeeg.Matrix_frobenius_norm, None, Matrix)
Matrix.dot = new_instancemethod(_openmeeg.Matrix_dot, None, Matrix)
Matrix.save = new_instancemethod(_openmeeg.Matrix_save, None, Matrix)
Matrix.load = new_instancemethod(_openmeeg.Matrix_load, None, Matrix)
Matrix.setvalue = new_instancemethod(_openmeeg.Matrix_setvalue, None, Matrix)
Matrix_swigregister = _openmeeg.Matrix_swigregister
Matrix_swigregister(Matrix)

class SymMatrix(LinOp):
    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):
        _openmeeg.SymMatrix_swiginit(self, _openmeeg.new_SymMatrix(*args))

    def __truediv__(self, *args):
        return _openmeeg.SymMatrix___truediv__(self, *args)
    __div__ = __truediv__



    def __itruediv__(self, *args):
        return _openmeeg.SymMatrix___itruediv__(self, *args)
    __idiv__ = __itruediv__


    __swig_destroy__ = _openmeeg.delete_SymMatrix
SymMatrix.ncol = new_instancemethod(_openmeeg.SymMatrix_ncol, None, SymMatrix)
SymMatrix.alloc_data = new_instancemethod(_openmeeg.SymMatrix_alloc_data, None, SymMatrix)
SymMatrix.reference_data = new_instancemethod(_openmeeg.SymMatrix_reference_data, None, SymMatrix)
SymMatrix.empty = new_instancemethod(_openmeeg.SymMatrix_empty, None, SymMatrix)
SymMatrix.set = new_instancemethod(_openmeeg.SymMatrix_set, None, SymMatrix)
SymMatrix.data = new_instancemethod(_openmeeg.SymMatrix_data, None, SymMatrix)
SymMatrix.__call__ = new_instancemethod(_openmeeg.SymMatrix___call__, None, SymMatrix)
SymMatrix.submat = new_instancemethod(_openmeeg.SymMatrix_submat, None, SymMatrix)
SymMatrix.getlin = new_instancemethod(_openmeeg.SymMatrix_getlin, None, SymMatrix)
SymMatrix.setlin = new_instancemethod(_openmeeg.SymMatrix_setlin, None, SymMatrix)
SymMatrix.solveLin = new_instancemethod(_openmeeg.SymMatrix_solveLin, None, SymMatrix)
SymMatrix.__add__ = new_instancemethod(_openmeeg.SymMatrix___add__, None, SymMatrix)
SymMatrix.__sub__ = new_instancemethod(_openmeeg.SymMatrix___sub__, None, SymMatrix)
SymMatrix.__mul__ = new_instancemethod(_openmeeg.SymMatrix___mul__, None, SymMatrix)
SymMatrix.__iadd__ = new_instancemethod(_openmeeg.SymMatrix___iadd__, None, SymMatrix)
SymMatrix.__isub__ = new_instancemethod(_openmeeg.SymMatrix___isub__, None, SymMatrix)
SymMatrix.__imul__ = new_instancemethod(_openmeeg.SymMatrix___imul__, None, SymMatrix)
SymMatrix.inverse = new_instancemethod(_openmeeg.SymMatrix_inverse, None, SymMatrix)
SymMatrix.invert = new_instancemethod(_openmeeg.SymMatrix_invert, None, SymMatrix)
SymMatrix.posdefinverse = new_instancemethod(_openmeeg.SymMatrix_posdefinverse, None, SymMatrix)
SymMatrix.det = new_instancemethod(_openmeeg.SymMatrix_det, None, SymMatrix)
SymMatrix.save = new_instancemethod(_openmeeg.SymMatrix_save, None, SymMatrix)
SymMatrix.load = new_instancemethod(_openmeeg.SymMatrix_load, None, SymMatrix)
SymMatrix_swigregister = _openmeeg.SymMatrix_swigregister
SymMatrix_swigregister(SymMatrix)

class SparseMatrix(LinOp):
    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):
        _openmeeg.SparseMatrix_swiginit(self, _openmeeg.new_SparseMatrix(*args))
    __swig_destroy__ = _openmeeg.delete_SparseMatrix
SparseMatrix.__call__ = new_instancemethod(_openmeeg.SparseMatrix___call__, None, SparseMatrix)
SparseMatrix.begin = new_instancemethod(_openmeeg.SparseMatrix_begin, None, SparseMatrix)
SparseMatrix.end = new_instancemethod(_openmeeg.SparseMatrix_end, None, SparseMatrix)
SparseMatrix.transpose = new_instancemethod(_openmeeg.SparseMatrix_transpose, None, SparseMatrix)
SparseMatrix.tank = new_instancemethod(_openmeeg.SparseMatrix_tank, None, SparseMatrix)
SparseMatrix.set = new_instancemethod(_openmeeg.SparseMatrix_set, None, SparseMatrix)
SparseMatrix.getlin = new_instancemethod(_openmeeg.SparseMatrix_getlin, None, SparseMatrix)
SparseMatrix.setlin = new_instancemethod(_openmeeg.SparseMatrix_setlin, None, SparseMatrix)
SparseMatrix.save = new_instancemethod(_openmeeg.SparseMatrix_save, None, SparseMatrix)
SparseMatrix.load = new_instancemethod(_openmeeg.SparseMatrix_load, None, SparseMatrix)
SparseMatrix.frobenius_norm = new_instancemethod(_openmeeg.SparseMatrix_frobenius_norm, None, SparseMatrix)
SparseMatrix.__mul__ = new_instancemethod(_openmeeg.SparseMatrix___mul__, None, SparseMatrix)
SparseMatrix.__add__ = new_instancemethod(_openmeeg.SparseMatrix___add__, None, SparseMatrix)
SparseMatrix_swigregister = _openmeeg.SparseMatrix_swigregister
SparseMatrix_swigregister(SparseMatrix)

class FastSparseMatrix(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):
        _openmeeg.FastSparseMatrix_swiginit(self, _openmeeg.new_FastSparseMatrix(*args))
    __swig_destroy__ = _openmeeg.delete_FastSparseMatrix
FastSparseMatrix.nlin = new_instancemethod(_openmeeg.FastSparseMatrix_nlin, None, FastSparseMatrix)
FastSparseMatrix.ncol = new_instancemethod(_openmeeg.FastSparseMatrix_ncol, None, FastSparseMatrix)
FastSparseMatrix.write = new_instancemethod(_openmeeg.FastSparseMatrix_write, None, FastSparseMatrix)
FastSparseMatrix.read = new_instancemethod(_openmeeg.FastSparseMatrix_read, None, FastSparseMatrix)
FastSparseMatrix.__call__ = new_instancemethod(_openmeeg.FastSparseMatrix___call__, None, FastSparseMatrix)
FastSparseMatrix.__mul__ = new_instancemethod(_openmeeg.FastSparseMatrix___mul__, None, FastSparseMatrix)
FastSparseMatrix.info = new_instancemethod(_openmeeg.FastSparseMatrix_info, None, FastSparseMatrix)
FastSparseMatrix_swigregister = _openmeeg.FastSparseMatrix_swigregister
FastSparseMatrix_swigregister(FastSparseMatrix)


def __lshift__(*args):
    return _openmeeg.__lshift__(*args)
__lshift__ = _openmeeg.__lshift__
class Geometry(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    UNKNOWN_VERSION = _openmeeg.Geometry_UNKNOWN_VERSION
    VERSION10 = _openmeeg.Geometry_VERSION10
    VERSION11 = _openmeeg.Geometry_VERSION11

    def __init__(self, *args):
        _openmeeg.Geometry_swiginit(self, _openmeeg.new_Geometry(*args))
    __swig_destroy__ = _openmeeg.delete_Geometry
Geometry.version = new_instancemethod(_openmeeg.Geometry_version, None, Geometry)
Geometry.begin = new_instancemethod(_openmeeg.Geometry_begin, None, Geometry)
Geometry.end = new_instancemethod(_openmeeg.Geometry_end, None, Geometry)
Geometry.vertex_begin = new_instancemethod(_openmeeg.Geometry_vertex_begin, None, Geometry)
Geometry.vertex_end = new_instancemethod(_openmeeg.Geometry_vertex_end, None, Geometry)
Geometry.domain_begin = new_instancemethod(_openmeeg.Geometry_domain_begin, None, Geometry)
Geometry.domain_end = new_instancemethod(_openmeeg.Geometry_domain_end, None, Geometry)
Geometry.info = new_instancemethod(_openmeeg.Geometry_info, None, Geometry)
Geometry.has_cond = new_instancemethod(_openmeeg.Geometry_has_cond, None, Geometry)
Geometry.is_nested = new_instancemethod(_openmeeg.Geometry_is_nested, None, Geometry)
Geometry.selfCheck = new_instancemethod(_openmeeg.Geometry_selfCheck, None, Geometry)
Geometry.check = new_instancemethod(_openmeeg.Geometry_check, None, Geometry)
Geometry.vertices = new_instancemethod(_openmeeg.Geometry_vertices, None, Geometry)
Geometry.meshes = new_instancemethod(_openmeeg.Geometry_meshes, None, Geometry)
Geometry.domains = new_instancemethod(_openmeeg.Geometry_domains, None, Geometry)
Geometry.size = new_instancemethod(_openmeeg.Geometry_size, None, Geometry)
Geometry.nb_vertices = new_instancemethod(_openmeeg.Geometry_nb_vertices, None, Geometry)
Geometry.nb_triangles = new_instancemethod(_openmeeg.Geometry_nb_triangles, None, Geometry)
Geometry.nb_domains = new_instancemethod(_openmeeg.Geometry_nb_domains, None, Geometry)
Geometry.nb_meshes = new_instancemethod(_openmeeg.Geometry_nb_meshes, None, Geometry)
Geometry.outermost_interface = new_instancemethod(_openmeeg.Geometry_outermost_interface, None, Geometry)
Geometry.innermost_interface = new_instancemethod(_openmeeg.Geometry_innermost_interface, None, Geometry)
Geometry.interface = new_instancemethod(_openmeeg.Geometry_interface, None, Geometry)
Geometry.domain = new_instancemethod(_openmeeg.Geometry_domain, None, Geometry)
Geometry.import_meshes = new_instancemethod(_openmeeg.Geometry_import_meshes, None, Geometry)
Geometry.sigma_inv = new_instancemethod(_openmeeg.Geometry_sigma_inv, None, Geometry)
Geometry.indicator = new_instancemethod(_openmeeg.Geometry_indicator, None, Geometry)
Geometry.sigma_diff = new_instancemethod(_openmeeg.Geometry_sigma_diff, None, Geometry)
Geometry.sigma = new_instancemethod(_openmeeg.Geometry_sigma, None, Geometry)
Geometry.oriented = new_instancemethod(_openmeeg.Geometry_oriented, None, Geometry)
Geometry.read = new_instancemethod(_openmeeg.Geometry_read, None, Geometry)
Geometry.load_vtp = new_instancemethod(_openmeeg.Geometry_load_vtp, None, Geometry)
Geometry.write_vtp = new_instancemethod(_openmeeg.Geometry_write_vtp, None, Geometry)
Geometry.nb_current_barrier_triangles = new_instancemethod(_openmeeg.Geometry_nb_current_barrier_triangles, None, Geometry)
Geometry.nb_invalid_vertices = new_instancemethod(_openmeeg.Geometry_nb_invalid_vertices, None, Geometry)
Geometry.geo_group = new_instancemethod(_openmeeg.Geometry_geo_group, None, Geometry)
Geometry.mark_current_barrier = new_instancemethod(_openmeeg.Geometry_mark_current_barrier, None, Geometry)
Geometry.mesh = new_instancemethod(_openmeeg.Geometry_mesh, None, Geometry)
Geometry_swigregister = _openmeeg.Geometry_swigregister
Geometry_swigregister(Geometry)

class Sensors(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):
        _openmeeg.Sensors_swiginit(self, _openmeeg.new_Sensors(*args))
    __swig_destroy__ = _openmeeg.delete_Sensors
Sensors.load = new_instancemethod(_openmeeg.Sensors_load, None, Sensors)
Sensors.save = new_instancemethod(_openmeeg.Sensors_save, None, Sensors)
Sensors.getNumberOfSensors = new_instancemethod(_openmeeg.Sensors_getNumberOfSensors, None, Sensors)
Sensors.getNumberOfPositions = new_instancemethod(_openmeeg.Sensors_getNumberOfPositions, None, Sensors)
Sensors.getPositions = new_instancemethod(_openmeeg.Sensors_getPositions, None, Sensors)
Sensors.getOrientations = new_instancemethod(_openmeeg.Sensors_getOrientations, None, Sensors)
Sensors.getNames = new_instancemethod(_openmeeg.Sensors_getNames, None, Sensors)
Sensors.hasRadii = new_instancemethod(_openmeeg.Sensors_hasRadii, None, Sensors)
Sensors.hasOrientations = new_instancemethod(_openmeeg.Sensors_hasOrientations, None, Sensors)
Sensors.hasNames = new_instancemethod(_openmeeg.Sensors_hasNames, None, Sensors)
Sensors.getPosition = new_instancemethod(_openmeeg.Sensors_getPosition, None, Sensors)
Sensors.getOrientation = new_instancemethod(_openmeeg.Sensors_getOrientation, None, Sensors)
Sensors.getName = new_instancemethod(_openmeeg.Sensors_getName, None, Sensors)
Sensors.setPosition = new_instancemethod(_openmeeg.Sensors_setPosition, None, Sensors)
Sensors.setOrientation = new_instancemethod(_openmeeg.Sensors_setOrientation, None, Sensors)
Sensors.hasSensor = new_instancemethod(_openmeeg.Sensors_hasSensor, None, Sensors)
Sensors.getSensorIdx = new_instancemethod(_openmeeg.Sensors_getSensorIdx, None, Sensors)
Sensors.getInjectionTriangles = new_instancemethod(_openmeeg.Sensors_getInjectionTriangles, None, Sensors)
Sensors.getRadii = new_instancemethod(_openmeeg.Sensors_getRadii, None, Sensors)
Sensors.getWeights = new_instancemethod(_openmeeg.Sensors_getWeights, None, Sensors)
Sensors.getWeightsMatrix = new_instancemethod(_openmeeg.Sensors_getWeightsMatrix, None, Sensors)
Sensors.isEmpty = new_instancemethod(_openmeeg.Sensors_isEmpty, None, Sensors)
Sensors.info = new_instancemethod(_openmeeg.Sensors_info, None, Sensors)
Sensors_swigregister = _openmeeg.Sensors_swigregister
Sensors_swigregister(Sensors)

VTK = _openmeeg.VTK
TRI = _openmeeg.TRI
BND = _openmeeg.BND
MESH = _openmeeg.MESH
OFF = _openmeeg.OFF
GIFTI = _openmeeg.GIFTI
class Mesh(vector_triangle):
    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):
        _openmeeg.Mesh_swiginit(self, _openmeeg.new_Mesh(*args))
    __swig_destroy__ = _openmeeg.delete_Mesh
Mesh.vertex_size = new_instancemethod(_openmeeg.Mesh_vertex_size, None, Mesh)
Mesh.vertex_begin = new_instancemethod(_openmeeg.Mesh_vertex_begin, None, Mesh)
Mesh.vertex_end = new_instancemethod(_openmeeg.Mesh_vertex_end, None, Mesh)
Mesh.vertex_rbegin = new_instancemethod(_openmeeg.Mesh_vertex_rbegin, None, Mesh)
Mesh.vertex_rend = new_instancemethod(_openmeeg.Mesh_vertex_rend, None, Mesh)
Mesh.name = new_instancemethod(_openmeeg.Mesh_name, None, Mesh)
Mesh.vertices = new_instancemethod(_openmeeg.Mesh_vertices, None, Mesh)
Mesh.nb_vertices = new_instancemethod(_openmeeg.Mesh_nb_vertices, None, Mesh)
Mesh.nb_triangles = new_instancemethod(_openmeeg.Mesh_nb_triangles, None, Mesh)
Mesh.all_vertices = new_instancemethod(_openmeeg.Mesh_all_vertices, None, Mesh)
Mesh.nb_all_vertices = new_instancemethod(_openmeeg.Mesh_nb_all_vertices, None, Mesh)
Mesh.add_vertex = new_instancemethod(_openmeeg.Mesh_add_vertex, None, Mesh)
Mesh.info = new_instancemethod(_openmeeg.Mesh_info, None, Mesh)
Mesh.has_self_intersection = new_instancemethod(_openmeeg.Mesh_has_self_intersection, None, Mesh)
Mesh.intersection = new_instancemethod(_openmeeg.Mesh_intersection, None, Mesh)
Mesh.has_correct_orientation = new_instancemethod(_openmeeg.Mesh_has_correct_orientation, None, Mesh)
Mesh.build_mesh_vertices = new_instancemethod(_openmeeg.Mesh_build_mesh_vertices, None, Mesh)
Mesh.generate_indices = new_instancemethod(_openmeeg.Mesh_generate_indices, None, Mesh)
Mesh.update = new_instancemethod(_openmeeg.Mesh_update, None, Mesh)
Mesh.merge = new_instancemethod(_openmeeg.Mesh_merge, None, Mesh)
Mesh.flip_triangles = new_instancemethod(_openmeeg.Mesh_flip_triangles, None, Mesh)
Mesh.correct_local_orientation = new_instancemethod(_openmeeg.Mesh_correct_local_orientation, None, Mesh)
Mesh.correct_global_orientation = new_instancemethod(_openmeeg.Mesh_correct_global_orientation, None, Mesh)
Mesh.compute_solid_angle = new_instancemethod(_openmeeg.Mesh_compute_solid_angle, None, Mesh)
Mesh.get_triangles_for_vertex = new_instancemethod(_openmeeg.Mesh_get_triangles_for_vertex, None, Mesh)
Mesh.adjacent_triangles = new_instancemethod(_openmeeg.Mesh_adjacent_triangles, None, Mesh)
Mesh.normal = new_instancemethod(_openmeeg.Mesh_normal, None, Mesh)
Mesh.laplacian = new_instancemethod(_openmeeg.Mesh_laplacian, None, Mesh)
Mesh.outermost = new_instancemethod(_openmeeg.Mesh_outermost, None, Mesh)
Mesh.smooth = new_instancemethod(_openmeeg.Mesh_smooth, None, Mesh)
Mesh.gradient_norm2 = new_instancemethod(_openmeeg.Mesh_gradient_norm2, None, Mesh)
Mesh.load = new_instancemethod(_openmeeg.Mesh_load, None, Mesh)
Mesh.load_tri = new_instancemethod(_openmeeg.Mesh_load_tri, None, Mesh)
Mesh.load_bnd = new_instancemethod(_openmeeg.Mesh_load_bnd, None, Mesh)
Mesh.load_off = new_instancemethod(_openmeeg.Mesh_load_off, None, Mesh)
Mesh.load_mesh = new_instancemethod(_openmeeg.Mesh_load_mesh, None, Mesh)
Mesh.save = new_instancemethod(_openmeeg.Mesh_save, None, Mesh)
Mesh.save_vtk = new_instancemethod(_openmeeg.Mesh_save_vtk, None, Mesh)
Mesh.save_bnd = new_instancemethod(_openmeeg.Mesh_save_bnd, None, Mesh)
Mesh.save_tri = new_instancemethod(_openmeeg.Mesh_save_tri, None, Mesh)
Mesh.save_off = new_instancemethod(_openmeeg.Mesh_save_off, None, Mesh)
Mesh.save_mesh = new_instancemethod(_openmeeg.Mesh_save_mesh, None, Mesh)
Mesh.current_barrier = new_instancemethod(_openmeeg.Mesh_current_barrier, None, Mesh)
Mesh.isolated = new_instancemethod(_openmeeg.Mesh_isolated, None, Mesh)
Mesh.__str__ = new_instancemethod(_openmeeg.Mesh___str__, None, Mesh)
Mesh_swigregister = _openmeeg.Mesh_swigregister
Mesh_swigregister(Mesh)

class OrientedMesh(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):
        _openmeeg.OrientedMesh_swiginit(self, _openmeeg.new_OrientedMesh(*args))
    __swig_destroy__ = _openmeeg.delete_OrientedMesh
OrientedMesh.mesh = new_instancemethod(_openmeeg.OrientedMesh_mesh, None, OrientedMesh)
OrientedMesh.orientation = new_instancemethod(_openmeeg.OrientedMesh_orientation, None, OrientedMesh)
OrientedMesh_swigregister = _openmeeg.OrientedMesh_swigregister
OrientedMesh_swigregister(OrientedMesh)

class Interface(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):
        _openmeeg.Interface_swiginit(self, _openmeeg.new_Interface(*args))
    __swig_destroy__ = _openmeeg.delete_Interface
Interface.name = new_instancemethod(_openmeeg.Interface_name, None, Interface)
Interface.outermost = new_instancemethod(_openmeeg.Interface_outermost, None, Interface)
Interface.set_to_outermost = new_instancemethod(_openmeeg.Interface_set_to_outermost, None, Interface)
Interface.contains_point = new_instancemethod(_openmeeg.Interface_contains_point, None, Interface)
Interface.check = new_instancemethod(_openmeeg.Interface_check, None, Interface)
Interface.nb_vertices = new_instancemethod(_openmeeg.Interface_nb_vertices, None, Interface)
Interface.nb_triangles = new_instancemethod(_openmeeg.Interface_nb_triangles, None, Interface)
Interface.adjacent_triangles = new_instancemethod(_openmeeg.Interface_adjacent_triangles, None, Interface)
Interface_swigregister = _openmeeg.Interface_swigregister
Interface_swigregister(Interface)

class HalfSpace(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):
        _openmeeg.HalfSpace_swiginit(self, _openmeeg.new_HalfSpace(*args))
    __swig_destroy__ = _openmeeg.delete_HalfSpace
HalfSpace.interface = new_instancemethod(_openmeeg.HalfSpace_interface, None, HalfSpace)
HalfSpace.inside = new_instancemethod(_openmeeg.HalfSpace_inside, None, HalfSpace)
HalfSpace_swigregister = _openmeeg.HalfSpace_swigregister
HalfSpace_swigregister(HalfSpace)

class Domain(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):
        _openmeeg.Domain_swiginit(self, _openmeeg.new_Domain())
    __swig_destroy__ = _openmeeg.delete_Domain
Domain.name = new_instancemethod(_openmeeg.Domain_name, None, Domain)
Domain.sigma = new_instancemethod(_openmeeg.Domain_sigma, None, Domain)
Domain.outermost = new_instancemethod(_openmeeg.Domain_outermost, None, Domain)
Domain.info = new_instancemethod(_openmeeg.Domain_info, None, Domain)
Domain.contains_point = new_instancemethod(_openmeeg.Domain_contains_point, None, Domain)
Domain.mesh_orientation = new_instancemethod(_openmeeg.Domain_mesh_orientation, None, Domain)
Domain_swigregister = _openmeeg.Domain_swigregister
Domain_swigregister(Domain)

class HeadMat(SymMatrix):
    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, geo, gauss_order=3):
        _openmeeg.HeadMat_swiginit(self, _openmeeg.new_HeadMat(geo, gauss_order))
    __swig_destroy__ = _openmeeg.delete_HeadMat
HeadMat_swigregister = _openmeeg.HeadMat_swigregister
HeadMat_swigregister(HeadMat)

class SurfSourceMat(Matrix):
    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, geo, sources, gauss_order=3):
        _openmeeg.SurfSourceMat_swiginit(self, _openmeeg.new_SurfSourceMat(geo, sources, gauss_order))
    __swig_destroy__ = _openmeeg.delete_SurfSourceMat
SurfSourceMat_swigregister = _openmeeg.SurfSourceMat_swigregister
SurfSourceMat_swigregister(SurfSourceMat)

class DipSourceMat(Matrix):
    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):
        _openmeeg.DipSourceMat_swiginit(self, _openmeeg.new_DipSourceMat(*args))
    __swig_destroy__ = _openmeeg.delete_DipSourceMat
DipSourceMat_swigregister = _openmeeg.DipSourceMat_swigregister
DipSourceMat_swigregister(DipSourceMat)

class EITSourceMat(Matrix):
    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, geo, electrodes, gauss_order=3):
        _openmeeg.EITSourceMat_swiginit(self, _openmeeg.new_EITSourceMat(geo, electrodes, gauss_order))
    __swig_destroy__ = _openmeeg.delete_EITSourceMat
EITSourceMat_swigregister = _openmeeg.EITSourceMat_swigregister
EITSourceMat_swigregister(EITSourceMat)

class Surf2VolMat(Matrix):
    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, geo, points):
        _openmeeg.Surf2VolMat_swiginit(self, _openmeeg.new_Surf2VolMat(geo, points))
    __swig_destroy__ = _openmeeg.delete_Surf2VolMat
Surf2VolMat_swigregister = _openmeeg.Surf2VolMat_swigregister
Surf2VolMat_swigregister(Surf2VolMat)

class Head2EEGMat(SparseMatrix):
    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, geo, electrodes):
        _openmeeg.Head2EEGMat_swiginit(self, _openmeeg.new_Head2EEGMat(geo, electrodes))
    __swig_destroy__ = _openmeeg.delete_Head2EEGMat
Head2EEGMat_swigregister = _openmeeg.Head2EEGMat_swigregister
Head2EEGMat_swigregister(Head2EEGMat)

class Head2ECoGMat(SparseMatrix):
    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):
        _openmeeg.Head2ECoGMat_swiginit(self, _openmeeg.new_Head2ECoGMat(*args))
    __swig_destroy__ = _openmeeg.delete_Head2ECoGMat
Head2ECoGMat_swigregister = _openmeeg.Head2ECoGMat_swigregister
Head2ECoGMat_swigregister(Head2ECoGMat)

class Head2MEGMat(Matrix):
    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, geo, sensors):
        _openmeeg.Head2MEGMat_swiginit(self, _openmeeg.new_Head2MEGMat(geo, sensors))
    __swig_destroy__ = _openmeeg.delete_Head2MEGMat
Head2MEGMat_swigregister = _openmeeg.Head2MEGMat_swigregister
Head2MEGMat_swigregister(Head2MEGMat)

class SurfSource2MEGMat(Matrix):
    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, sources, sensors):
        _openmeeg.SurfSource2MEGMat_swiginit(self, _openmeeg.new_SurfSource2MEGMat(sources, sensors))
    __swig_destroy__ = _openmeeg.delete_SurfSource2MEGMat
SurfSource2MEGMat_swigregister = _openmeeg.SurfSource2MEGMat_swigregister
SurfSource2MEGMat_swigregister(SurfSource2MEGMat)

class DipSource2MEGMat(Matrix):
    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, dipoles, sensors):
        _openmeeg.DipSource2MEGMat_swiginit(self, _openmeeg.new_DipSource2MEGMat(dipoles, sensors))
    __swig_destroy__ = _openmeeg.delete_DipSource2MEGMat
DipSource2MEGMat_swigregister = _openmeeg.DipSource2MEGMat_swigregister
DipSource2MEGMat_swigregister(DipSource2MEGMat)

class DipSource2InternalPotMat(Matrix):
    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):
        _openmeeg.DipSource2InternalPotMat_swiginit(self, _openmeeg.new_DipSource2InternalPotMat(*args))
    __swig_destroy__ = _openmeeg.delete_DipSource2InternalPotMat
DipSource2InternalPotMat_swigregister = _openmeeg.DipSource2InternalPotMat_swigregister
DipSource2InternalPotMat_swigregister(DipSource2InternalPotMat)

class CorticalMat(Matrix):
    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):
        _openmeeg.CorticalMat_swiginit(self, _openmeeg.new_CorticalMat(*args))
    __swig_destroy__ = _openmeeg.delete_CorticalMat
CorticalMat_swigregister = _openmeeg.CorticalMat_swigregister
CorticalMat_swigregister(CorticalMat)

class CorticalMat2(Matrix):
    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):
        _openmeeg.CorticalMat2_swiginit(self, _openmeeg.new_CorticalMat2(*args))
    __swig_destroy__ = _openmeeg.delete_CorticalMat2
CorticalMat2_swigregister = _openmeeg.CorticalMat2_swigregister
CorticalMat2_swigregister(CorticalMat2)

USE_GMRES = _openmeeg.USE_GMRES
class GainMEG(Matrix):
    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):
        _openmeeg.GainMEG_swiginit(self, _openmeeg.new_GainMEG(*args))
    __swig_destroy__ = _openmeeg.delete_GainMEG
GainMEG_swigregister = _openmeeg.GainMEG_swigregister
GainMEG_swigregister(GainMEG)

class GainEEG(Matrix):
    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):
        _openmeeg.GainEEG_swiginit(self, _openmeeg.new_GainEEG(*args))
    __swig_destroy__ = _openmeeg.delete_GainEEG
GainEEG_swigregister = _openmeeg.GainEEG_swigregister
GainEEG_swigregister(GainEEG)

class GainEEGadjoint(Matrix):
    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, geo, dipoles, HeadMat, Head2EEGMat):
        _openmeeg.GainEEGadjoint_swiginit(self, _openmeeg.new_GainEEGadjoint(geo, dipoles, HeadMat, Head2EEGMat))
    __swig_destroy__ = _openmeeg.delete_GainEEGadjoint
GainEEGadjoint_swigregister = _openmeeg.GainEEGadjoint_swigregister
GainEEGadjoint_swigregister(GainEEGadjoint)

class GainMEGadjoint(Matrix):
    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, geo, dipoles, HeadMat, Head2MEGMat, Source2MEGMat):
        _openmeeg.GainMEGadjoint_swiginit(self, _openmeeg.new_GainMEGadjoint(geo, dipoles, HeadMat, Head2MEGMat, Source2MEGMat))
    __swig_destroy__ = _openmeeg.delete_GainMEGadjoint
GainMEGadjoint_swigregister = _openmeeg.GainMEGadjoint_swigregister
GainMEGadjoint_swigregister(GainMEGadjoint)

class GainEEGMEGadjoint(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, geo, dipoles, HeadMat, Head2EEGMat, Head2MEGMat, Source2MEGMat):
        _openmeeg.GainEEGMEGadjoint_swiginit(self, _openmeeg.new_GainEEGMEGadjoint(geo, dipoles, HeadMat, Head2EEGMat, Head2MEGMat, Source2MEGMat))
    __swig_destroy__ = _openmeeg.delete_GainEEGMEGadjoint
GainEEGMEGadjoint.saveEEG = new_instancemethod(_openmeeg.GainEEGMEGadjoint_saveEEG, None, GainEEGMEGadjoint)
GainEEGMEGadjoint.saveMEG = new_instancemethod(_openmeeg.GainEEGMEGadjoint_saveMEG, None, GainEEGMEGadjoint)
GainEEGMEGadjoint_swigregister = _openmeeg.GainEEGMEGadjoint_swigregister
GainEEGMEGadjoint_swigregister(GainEEGMEGadjoint)

class GainInternalPot(Matrix):
    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, HeadMatInv, SourceMat, Head2IPMat, Source2IPMat):
        _openmeeg.GainInternalPot_swiginit(self, _openmeeg.new_GainInternalPot(HeadMatInv, SourceMat, Head2IPMat, Source2IPMat))
    __swig_destroy__ = _openmeeg.delete_GainInternalPot
GainInternalPot_swigregister = _openmeeg.GainInternalPot_swigregister
GainInternalPot_swigregister(GainInternalPot)

class GainEITInternalPot(Matrix):
    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, HeadMatInv, SourceMat, Head2IPMat):
        _openmeeg.GainEITInternalPot_swiginit(self, _openmeeg.new_GainEITInternalPot(HeadMatInv, SourceMat, Head2IPMat))
    __swig_destroy__ = _openmeeg.delete_GainEITInternalPot
GainEITInternalPot_swigregister = _openmeeg.GainEITInternalPot_swigregister
GainEITInternalPot_swigregister(GainEITInternalPot)

class Forward(Matrix):
    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, GainMatrix, RealSourcesData, NoiseLevel):
        _openmeeg.Forward_swiginit(self, _openmeeg.new_Forward(GainMatrix, RealSourcesData, NoiseLevel))
    __swig_destroy__ = _openmeeg.delete_Forward
Forward_swigregister = _openmeeg.Forward_swigregister
Forward_swigregister(Forward)


def compute_forward(SimulatedData, GainMatrix, RealSourcesData, NoiseLevel):
    return _openmeeg.compute_forward(SimulatedData, GainMatrix, RealSourcesData, NoiseLevel)
compute_forward = _openmeeg.compute_forward

def asarray(*args):
    return _openmeeg.asarray(*args)
asarray = _openmeeg.asarray

def fromarray(_mat):
    return _openmeeg.fromarray(_mat)
fromarray = _openmeeg.fromarray


