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

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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __nonzero__(self):
        return _biorbd.VecBiorbdVector___nonzero__(self)

    def __bool__(self):
        return _biorbd.VecBiorbdVector___bool__(self)

    def __len__(self):
        return _biorbd.VecBiorbdVector___len__(self)

    def __getslice__(self, i, j):
        return _biorbd.VecBiorbdVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _biorbd.VecBiorbdVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _biorbd.VecBiorbdVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _biorbd.VecBiorbdVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _biorbd.VecBiorbdVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _biorbd.VecBiorbdVector___setitem__(self, *args)

    def pop(self):
        return _biorbd.VecBiorbdVector_pop(self)

    def append(self, x):
        return _biorbd.VecBiorbdVector_append(self, x)

    def empty(self):
        return _biorbd.VecBiorbdVector_empty(self)

    def size(self):
        return _biorbd.VecBiorbdVector_size(self)

    def swap(self, v):
        return _biorbd.VecBiorbdVector_swap(self, v)

    def begin(self):
        return _biorbd.VecBiorbdVector_begin(self)

    def end(self):
        return _biorbd.VecBiorbdVector_end(self)

    def rbegin(self):
        return _biorbd.VecBiorbdVector_rbegin(self)

    def rend(self):
        return _biorbd.VecBiorbdVector_rend(self)

    def clear(self):
        return _biorbd.VecBiorbdVector_clear(self)

    def get_allocator(self):
        return _biorbd.VecBiorbdVector_get_allocator(self)

    def pop_back(self):
        return _biorbd.VecBiorbdVector_pop_back(self)

    def erase(self, *args):
        return _biorbd.VecBiorbdVector_erase(self, *args)

    def __init__(self, *args):
        _biorbd.VecBiorbdVector_swiginit(self, _biorbd.new_VecBiorbdVector(*args))

    def push_back(self, x):
        return _biorbd.VecBiorbdVector_push_back(self, x)

    def front(self):
        return _biorbd.VecBiorbdVector_front(self)

    def back(self):
        return _biorbd.VecBiorbdVector_back(self)

    def assign(self, n, x):
        return _biorbd.VecBiorbdVector_assign(self, n, x)

    def resize(self, *args):
        return _biorbd.VecBiorbdVector_resize(self, *args)

    def insert(self, *args):
        return _biorbd.VecBiorbdVector_insert(self, *args)

    def reserve(self, n):
        return _biorbd.VecBiorbdVector_reserve(self, n)

    def capacity(self):
        return _biorbd.VecBiorbdVector_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecBiorbdVector

# Register VecBiorbdVector in _biorbd:
_biorbd.VecBiorbdVector_swigregister(VecBiorbdVector)

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

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

    def __nonzero__(self):
        return _biorbd.MatBiorbdVector___nonzero__(self)

    def __bool__(self):
        return _biorbd.MatBiorbdVector___bool__(self)

    def __len__(self):
        return _biorbd.MatBiorbdVector___len__(self)

    def __getslice__(self, i, j):
        return _biorbd.MatBiorbdVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _biorbd.MatBiorbdVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _biorbd.MatBiorbdVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _biorbd.MatBiorbdVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _biorbd.MatBiorbdVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _biorbd.MatBiorbdVector___setitem__(self, *args)

    def pop(self):
        return _biorbd.MatBiorbdVector_pop(self)

    def append(self, x):
        return _biorbd.MatBiorbdVector_append(self, x)

    def empty(self):
        return _biorbd.MatBiorbdVector_empty(self)

    def size(self):
        return _biorbd.MatBiorbdVector_size(self)

    def swap(self, v):
        return _biorbd.MatBiorbdVector_swap(self, v)

    def begin(self):
        return _biorbd.MatBiorbdVector_begin(self)

    def end(self):
        return _biorbd.MatBiorbdVector_end(self)

    def rbegin(self):
        return _biorbd.MatBiorbdVector_rbegin(self)

    def rend(self):
        return _biorbd.MatBiorbdVector_rend(self)

    def clear(self):
        return _biorbd.MatBiorbdVector_clear(self)

    def get_allocator(self):
        return _biorbd.MatBiorbdVector_get_allocator(self)

    def pop_back(self):
        return _biorbd.MatBiorbdVector_pop_back(self)

    def erase(self, *args):
        return _biorbd.MatBiorbdVector_erase(self, *args)

    def __init__(self, *args):
        _biorbd.MatBiorbdVector_swiginit(self, _biorbd.new_MatBiorbdVector(*args))

    def push_back(self, x):
        return _biorbd.MatBiorbdVector_push_back(self, x)

    def front(self):
        return _biorbd.MatBiorbdVector_front(self)

    def back(self):
        return _biorbd.MatBiorbdVector_back(self)

    def assign(self, n, x):
        return _biorbd.MatBiorbdVector_assign(self, n, x)

    def resize(self, *args):
        return _biorbd.MatBiorbdVector_resize(self, *args)

    def insert(self, *args):
        return _biorbd.MatBiorbdVector_insert(self, *args)

    def reserve(self, n):
        return _biorbd.MatBiorbdVector_reserve(self, n)

    def capacity(self):
        return _biorbd.MatBiorbdVector_capacity(self)
    __swig_destroy__ = _biorbd.delete_MatBiorbdVector

# Register MatBiorbdVector in _biorbd:
_biorbd.MatBiorbdVector_swigregister(MatBiorbdVector)

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

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

    def __nonzero__(self):
        return _biorbd.VecBiorbdRotoTrans___nonzero__(self)

    def __bool__(self):
        return _biorbd.VecBiorbdRotoTrans___bool__(self)

    def __len__(self):
        return _biorbd.VecBiorbdRotoTrans___len__(self)

    def __getslice__(self, i, j):
        return _biorbd.VecBiorbdRotoTrans___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _biorbd.VecBiorbdRotoTrans___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _biorbd.VecBiorbdRotoTrans___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _biorbd.VecBiorbdRotoTrans___delitem__(self, *args)

    def __getitem__(self, *args):
        return _biorbd.VecBiorbdRotoTrans___getitem__(self, *args)

    def __setitem__(self, *args):
        return _biorbd.VecBiorbdRotoTrans___setitem__(self, *args)

    def pop(self):
        return _biorbd.VecBiorbdRotoTrans_pop(self)

    def append(self, x):
        return _biorbd.VecBiorbdRotoTrans_append(self, x)

    def empty(self):
        return _biorbd.VecBiorbdRotoTrans_empty(self)

    def size(self):
        return _biorbd.VecBiorbdRotoTrans_size(self)

    def swap(self, v):
        return _biorbd.VecBiorbdRotoTrans_swap(self, v)

    def begin(self):
        return _biorbd.VecBiorbdRotoTrans_begin(self)

    def end(self):
        return _biorbd.VecBiorbdRotoTrans_end(self)

    def rbegin(self):
        return _biorbd.VecBiorbdRotoTrans_rbegin(self)

    def rend(self):
        return _biorbd.VecBiorbdRotoTrans_rend(self)

    def clear(self):
        return _biorbd.VecBiorbdRotoTrans_clear(self)

    def get_allocator(self):
        return _biorbd.VecBiorbdRotoTrans_get_allocator(self)

    def pop_back(self):
        return _biorbd.VecBiorbdRotoTrans_pop_back(self)

    def erase(self, *args):
        return _biorbd.VecBiorbdRotoTrans_erase(self, *args)

    def __init__(self, *args):
        _biorbd.VecBiorbdRotoTrans_swiginit(self, _biorbd.new_VecBiorbdRotoTrans(*args))

    def push_back(self, x):
        return _biorbd.VecBiorbdRotoTrans_push_back(self, x)

    def front(self):
        return _biorbd.VecBiorbdRotoTrans_front(self)

    def back(self):
        return _biorbd.VecBiorbdRotoTrans_back(self)

    def assign(self, n, x):
        return _biorbd.VecBiorbdRotoTrans_assign(self, n, x)

    def resize(self, *args):
        return _biorbd.VecBiorbdRotoTrans_resize(self, *args)

    def insert(self, *args):
        return _biorbd.VecBiorbdRotoTrans_insert(self, *args)

    def reserve(self, n):
        return _biorbd.VecBiorbdRotoTrans_reserve(self, n)

    def capacity(self):
        return _biorbd.VecBiorbdRotoTrans_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecBiorbdRotoTrans

# Register VecBiorbdRotoTrans in _biorbd:
_biorbd.VecBiorbdRotoTrans_swigregister(VecBiorbdRotoTrans)

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

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

    def __nonzero__(self):
        return _biorbd.MatBiorbdRotoTrans___nonzero__(self)

    def __bool__(self):
        return _biorbd.MatBiorbdRotoTrans___bool__(self)

    def __len__(self):
        return _biorbd.MatBiorbdRotoTrans___len__(self)

    def __getslice__(self, i, j):
        return _biorbd.MatBiorbdRotoTrans___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _biorbd.MatBiorbdRotoTrans___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _biorbd.MatBiorbdRotoTrans___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _biorbd.MatBiorbdRotoTrans___delitem__(self, *args)

    def __getitem__(self, *args):
        return _biorbd.MatBiorbdRotoTrans___getitem__(self, *args)

    def __setitem__(self, *args):
        return _biorbd.MatBiorbdRotoTrans___setitem__(self, *args)

    def pop(self):
        return _biorbd.MatBiorbdRotoTrans_pop(self)

    def append(self, x):
        return _biorbd.MatBiorbdRotoTrans_append(self, x)

    def empty(self):
        return _biorbd.MatBiorbdRotoTrans_empty(self)

    def size(self):
        return _biorbd.MatBiorbdRotoTrans_size(self)

    def swap(self, v):
        return _biorbd.MatBiorbdRotoTrans_swap(self, v)

    def begin(self):
        return _biorbd.MatBiorbdRotoTrans_begin(self)

    def end(self):
        return _biorbd.MatBiorbdRotoTrans_end(self)

    def rbegin(self):
        return _biorbd.MatBiorbdRotoTrans_rbegin(self)

    def rend(self):
        return _biorbd.MatBiorbdRotoTrans_rend(self)

    def clear(self):
        return _biorbd.MatBiorbdRotoTrans_clear(self)

    def get_allocator(self):
        return _biorbd.MatBiorbdRotoTrans_get_allocator(self)

    def pop_back(self):
        return _biorbd.MatBiorbdRotoTrans_pop_back(self)

    def erase(self, *args):
        return _biorbd.MatBiorbdRotoTrans_erase(self, *args)

    def __init__(self, *args):
        _biorbd.MatBiorbdRotoTrans_swiginit(self, _biorbd.new_MatBiorbdRotoTrans(*args))

    def push_back(self, x):
        return _biorbd.MatBiorbdRotoTrans_push_back(self, x)

    def front(self):
        return _biorbd.MatBiorbdRotoTrans_front(self)

    def back(self):
        return _biorbd.MatBiorbdRotoTrans_back(self)

    def assign(self, n, x):
        return _biorbd.MatBiorbdRotoTrans_assign(self, n, x)

    def resize(self, *args):
        return _biorbd.MatBiorbdRotoTrans_resize(self, *args)

    def insert(self, *args):
        return _biorbd.MatBiorbdRotoTrans_insert(self, *args)

    def reserve(self, n):
        return _biorbd.MatBiorbdRotoTrans_reserve(self, n)

    def capacity(self):
        return _biorbd.MatBiorbdRotoTrans_capacity(self)
    __swig_destroy__ = _biorbd.delete_MatBiorbdRotoTrans

# Register MatBiorbdRotoTrans in _biorbd:
_biorbd.MatBiorbdRotoTrans_swigregister(MatBiorbdRotoTrans)

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

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

    def __nonzero__(self):
        return _biorbd.VecBiorbdNode___nonzero__(self)

    def __bool__(self):
        return _biorbd.VecBiorbdNode___bool__(self)

    def __len__(self):
        return _biorbd.VecBiorbdNode___len__(self)

    def __getslice__(self, i, j):
        return _biorbd.VecBiorbdNode___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _biorbd.VecBiorbdNode___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _biorbd.VecBiorbdNode___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _biorbd.VecBiorbdNode___delitem__(self, *args)

    def __getitem__(self, *args):
        return _biorbd.VecBiorbdNode___getitem__(self, *args)

    def __setitem__(self, *args):
        return _biorbd.VecBiorbdNode___setitem__(self, *args)

    def pop(self):
        return _biorbd.VecBiorbdNode_pop(self)

    def append(self, x):
        return _biorbd.VecBiorbdNode_append(self, x)

    def empty(self):
        return _biorbd.VecBiorbdNode_empty(self)

    def size(self):
        return _biorbd.VecBiorbdNode_size(self)

    def swap(self, v):
        return _biorbd.VecBiorbdNode_swap(self, v)

    def begin(self):
        return _biorbd.VecBiorbdNode_begin(self)

    def end(self):
        return _biorbd.VecBiorbdNode_end(self)

    def rbegin(self):
        return _biorbd.VecBiorbdNode_rbegin(self)

    def rend(self):
        return _biorbd.VecBiorbdNode_rend(self)

    def clear(self):
        return _biorbd.VecBiorbdNode_clear(self)

    def get_allocator(self):
        return _biorbd.VecBiorbdNode_get_allocator(self)

    def pop_back(self):
        return _biorbd.VecBiorbdNode_pop_back(self)

    def erase(self, *args):
        return _biorbd.VecBiorbdNode_erase(self, *args)

    def __init__(self, *args):
        _biorbd.VecBiorbdNode_swiginit(self, _biorbd.new_VecBiorbdNode(*args))

    def push_back(self, x):
        return _biorbd.VecBiorbdNode_push_back(self, x)

    def front(self):
        return _biorbd.VecBiorbdNode_front(self)

    def back(self):
        return _biorbd.VecBiorbdNode_back(self)

    def assign(self, n, x):
        return _biorbd.VecBiorbdNode_assign(self, n, x)

    def resize(self, *args):
        return _biorbd.VecBiorbdNode_resize(self, *args)

    def insert(self, *args):
        return _biorbd.VecBiorbdNode_insert(self, *args)

    def reserve(self, n):
        return _biorbd.VecBiorbdNode_reserve(self, n)

    def capacity(self):
        return _biorbd.VecBiorbdNode_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecBiorbdNode

# Register VecBiorbdNode in _biorbd:
_biorbd.VecBiorbdNode_swigregister(VecBiorbdNode)

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

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

    def __nonzero__(self):
        return _biorbd.MatBiorbdNode___nonzero__(self)

    def __bool__(self):
        return _biorbd.MatBiorbdNode___bool__(self)

    def __len__(self):
        return _biorbd.MatBiorbdNode___len__(self)

    def __getslice__(self, i, j):
        return _biorbd.MatBiorbdNode___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _biorbd.MatBiorbdNode___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _biorbd.MatBiorbdNode___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _biorbd.MatBiorbdNode___delitem__(self, *args)

    def __getitem__(self, *args):
        return _biorbd.MatBiorbdNode___getitem__(self, *args)

    def __setitem__(self, *args):
        return _biorbd.MatBiorbdNode___setitem__(self, *args)

    def pop(self):
        return _biorbd.MatBiorbdNode_pop(self)

    def append(self, x):
        return _biorbd.MatBiorbdNode_append(self, x)

    def empty(self):
        return _biorbd.MatBiorbdNode_empty(self)

    def size(self):
        return _biorbd.MatBiorbdNode_size(self)

    def swap(self, v):
        return _biorbd.MatBiorbdNode_swap(self, v)

    def begin(self):
        return _biorbd.MatBiorbdNode_begin(self)

    def end(self):
        return _biorbd.MatBiorbdNode_end(self)

    def rbegin(self):
        return _biorbd.MatBiorbdNode_rbegin(self)

    def rend(self):
        return _biorbd.MatBiorbdNode_rend(self)

    def clear(self):
        return _biorbd.MatBiorbdNode_clear(self)

    def get_allocator(self):
        return _biorbd.MatBiorbdNode_get_allocator(self)

    def pop_back(self):
        return _biorbd.MatBiorbdNode_pop_back(self)

    def erase(self, *args):
        return _biorbd.MatBiorbdNode_erase(self, *args)

    def __init__(self, *args):
        _biorbd.MatBiorbdNode_swiginit(self, _biorbd.new_MatBiorbdNode(*args))

    def push_back(self, x):
        return _biorbd.MatBiorbdNode_push_back(self, x)

    def front(self):
        return _biorbd.MatBiorbdNode_front(self)

    def back(self):
        return _biorbd.MatBiorbdNode_back(self)

    def assign(self, n, x):
        return _biorbd.MatBiorbdNode_assign(self, n, x)

    def resize(self, *args):
        return _biorbd.MatBiorbdNode_resize(self, *args)

    def insert(self, *args):
        return _biorbd.MatBiorbdNode_insert(self, *args)

    def reserve(self, n):
        return _biorbd.MatBiorbdNode_reserve(self, n)

    def capacity(self):
        return _biorbd.MatBiorbdNode_capacity(self)
    __swig_destroy__ = _biorbd.delete_MatBiorbdNode

# Register MatBiorbdNode in _biorbd:
_biorbd.MatBiorbdNode_swigregister(MatBiorbdNode)

NODE3D = _biorbd.NODE3D
BONE_POINT = _biorbd.BONE_POINT
ROTOTRANS = _biorbd.ROTOTRANS
BONE = _biorbd.BONE
WRAPPING_OBJECT = _biorbd.WRAPPING_OBJECT
WRAPPING_CYLINDER = _biorbd.WRAPPING_CYLINDER
WRAPPING_SPHERE = _biorbd.WRAPPING_SPHERE
VIA_POINT = _biorbd.VIA_POINT
NO_NODE_TYPE = _biorbd.NO_NODE_TYPE

def NODE_TYPE_toStr(type):
    return _biorbd.NODE_TYPE_toStr(type)
class String(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _biorbd.String_swiginit(self, _biorbd.new_String(*args))

    def __add__(self, *args):
        return _biorbd.String___add__(self, *args)

    def __call__(self, *args):
        return _biorbd.String___call__(self, *args)
    __swig_destroy__ = _biorbd.delete_String

    def tolower(self, *args):
        return _biorbd.String_tolower(self, *args)

    def toupper(self, *args):
        return _biorbd.String_toupper(self, *args)

    def getString(self):
        return _biorbd.String_getString(self)

# Register String in _biorbd:
_biorbd.String_swigregister(String)

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

    def __init__(self, *args):
        _biorbd.Path_swiginit(self, _biorbd.new_Path(*args))

    def DeepCopy(self, *args):
        return _biorbd.Path_DeepCopy(self, *args)

    @staticmethod
    def parseFileName(path, folder, filename, ext):
        return _biorbd.Path_parseFileName(path, folder, filename, ext)

    @staticmethod
    def isFileExist(*args):
        return _biorbd.Path_isFileExist(*args)

    def isFileReadable(self):
        return _biorbd.Path_isFileReadable(self)

    @staticmethod
    def isFolderExist(*args):
        return _biorbd.Path_isFolderExist(*args)

    def createFolder(self):
        return _biorbd.Path_createFolder(self)

    @staticmethod
    def currentDir():
        return _biorbd.Path_currentDir()

    @staticmethod
    def relativePath(*args):
        return _biorbd.Path_relativePath(*args)

    def absoluteFolder(self, *args):
        return _biorbd.Path_absoluteFolder(self, *args)

    def absolutePath(self):
        return _biorbd.Path_absolutePath(self)

    @staticmethod
    def toUnixFormat(path):
        return _biorbd.Path_toUnixFormat(path)

    @staticmethod
    def toWindowsFormat(path):
        return _biorbd.Path_toWindowsFormat(path)

    def originalPath(self):
        return _biorbd.Path_originalPath(self)

    def folder(self):
        return _biorbd.Path_folder(self)

    def filename(self):
        return _biorbd.Path_filename(self)

    def setFilename(self, name):
        return _biorbd.Path_setFilename(self, name)

    def extension(self):
        return _biorbd.Path_extension(self)

    def setExtension(self, ext):
        return _biorbd.Path_setExtension(self, ext)
    __swig_destroy__ = _biorbd.delete_Path

# Register Path in _biorbd:
_biorbd.Path_swigregister(Path)

def Path_parseFileName(path, folder, filename, ext):
    return _biorbd.Path_parseFileName(path, folder, filename, ext)

def Path_isFileExist(*args):
    return _biorbd.Path_isFileExist(*args)

def Path_isFolderExist(*args):
    return _biorbd.Path_isFolderExist(*args)

def Path_currentDir():
    return _biorbd.Path_currentDir()

def Path_relativePath(*args):
    return _biorbd.Path_relativePath(*args)

def Path_toUnixFormat(path):
    return _biorbd.Path_toUnixFormat(path)

def Path_toWindowsFormat(path):
    return _biorbd.Path_toWindowsFormat(path)

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

    def __init__(self, *args):
        _biorbd.Vector_swiginit(self, _biorbd.new_Vector(*args))

    def norm(self, p=2, skipRoot=False):
        return _biorbd.Vector_norm(self, p, skipRoot)

    def normGradient(self, p=2, skipRoot=False):
        return _biorbd.Vector_normGradient(self, p, skipRoot)

    def get_array(self):
        return _biorbd.Vector_get_array(self)
    __swig_destroy__ = _biorbd.delete_Vector

# Register Vector in _biorbd:
_biorbd.Vector_swigregister(Vector)

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

    def __init__(self, *args):
        _biorbd.Matrix_swiginit(self, _biorbd.new_Matrix(*args))

    def get_array(self):
        return _biorbd.Matrix_get_array(self)
    __swig_destroy__ = _biorbd.delete_Matrix

# Register Matrix in _biorbd:
_biorbd.Matrix_swigregister(Matrix)

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

    def __init__(self, *args):
        _biorbd.Quaternion_swiginit(self, _biorbd.new_Quaternion(*args))

    def w(self):
        return _biorbd.Quaternion_w(self)

    def x(self):
        return _biorbd.Quaternion_x(self)

    def y(self):
        return _biorbd.Quaternion_y(self)

    def z(self):
        return _biorbd.Quaternion_z(self)

    def derivate(self, w):
        return _biorbd.Quaternion_derivate(self, w)
    __swig_destroy__ = _biorbd.delete_Quaternion

# Register Quaternion in _biorbd:
_biorbd.Quaternion_swigregister(Quaternion)

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

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

    def DeepCopy(self, other):
        return _biorbd.Node_DeepCopy(self, other)

    def name(self):
        return _biorbd.Node_name(self)

    def setName(self, name):
        return _biorbd.Node_setName(self, name)

    def parent(self):
        return _biorbd.Node_parent(self)

    def setParent(self, parentName):
        return _biorbd.Node_setParent(self, parentName)

    def typeOfNode(self):
        return _biorbd.Node_typeOfNode(self)

# Register Node in _biorbd:
_biorbd.Node_swigregister(Node)

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

    def __init__(self, *args):
        _biorbd.Node3d_swiginit(self, _biorbd.new_Node3d(*args))

    def DeepCopy(self, *args):
        return _biorbd.Node3d_DeepCopy(self, *args)

    def applyRT(self, *args):
        return _biorbd.Node3d_applyRT(self, *args)

    def get_array(self):
        return _biorbd.Node3d_get_array(self)
    __swig_destroy__ = _biorbd.delete_Node3d

# Register Node3d in _biorbd:
_biorbd.Node3d_swigregister(Node3d)

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

    def __init__(self, *args):
        _biorbd.RotoTrans_swiginit(self, _biorbd.new_RotoTrans(*args))

    def axe(self, arg2):
        return _biorbd.RotoTrans_axe(self, arg2)

    def transpose(self):
        return _biorbd.RotoTrans_transpose(self)

    def trans(self):
        return _biorbd.RotoTrans_trans(self)

    def rot(self):
        return _biorbd.RotoTrans_rot(self)

    def SpatialTransform2RotoTrans(self, st):
        return _biorbd.RotoTrans_SpatialTransform2RotoTrans(self, st)

    def combineRotAndTrans(self, rot, trans):
        return _biorbd.RotoTrans_combineRotAndTrans(self, rot, trans)

    def transformCardanToMatrix(self, rot, trans, seq):
        return _biorbd.RotoTrans_transformCardanToMatrix(self, rot, trans, seq)

    @staticmethod
    def transformMatrixToCardan(arg1, seq):
        return _biorbd.RotoTrans_transformMatrixToCardan(arg1, seq)

    @staticmethod
    def mean(arg1):
        return _biorbd.RotoTrans_mean(arg1)

    def get_array(self):
        return _biorbd.RotoTrans_get_array(self)
    __swig_destroy__ = _biorbd.delete_RotoTrans

# Register RotoTrans in _biorbd:
_biorbd.RotoTrans_swigregister(RotoTrans)

def RotoTrans_transformMatrixToCardan(arg1, seq):
    return _biorbd.RotoTrans_transformMatrixToCardan(arg1, seq)

def RotoTrans_mean(arg1):
    return _biorbd.RotoTrans_mean(arg1)

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

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

    def __nonzero__(self):
        return _biorbd.VecBiorbdGeneralizedTorque___nonzero__(self)

    def __bool__(self):
        return _biorbd.VecBiorbdGeneralizedTorque___bool__(self)

    def __len__(self):
        return _biorbd.VecBiorbdGeneralizedTorque___len__(self)

    def __getslice__(self, i, j):
        return _biorbd.VecBiorbdGeneralizedTorque___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _biorbd.VecBiorbdGeneralizedTorque___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _biorbd.VecBiorbdGeneralizedTorque___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _biorbd.VecBiorbdGeneralizedTorque___delitem__(self, *args)

    def __getitem__(self, *args):
        return _biorbd.VecBiorbdGeneralizedTorque___getitem__(self, *args)

    def __setitem__(self, *args):
        return _biorbd.VecBiorbdGeneralizedTorque___setitem__(self, *args)

    def pop(self):
        return _biorbd.VecBiorbdGeneralizedTorque_pop(self)

    def append(self, x):
        return _biorbd.VecBiorbdGeneralizedTorque_append(self, x)

    def empty(self):
        return _biorbd.VecBiorbdGeneralizedTorque_empty(self)

    def size(self):
        return _biorbd.VecBiorbdGeneralizedTorque_size(self)

    def swap(self, v):
        return _biorbd.VecBiorbdGeneralizedTorque_swap(self, v)

    def begin(self):
        return _biorbd.VecBiorbdGeneralizedTorque_begin(self)

    def end(self):
        return _biorbd.VecBiorbdGeneralizedTorque_end(self)

    def rbegin(self):
        return _biorbd.VecBiorbdGeneralizedTorque_rbegin(self)

    def rend(self):
        return _biorbd.VecBiorbdGeneralizedTorque_rend(self)

    def clear(self):
        return _biorbd.VecBiorbdGeneralizedTorque_clear(self)

    def get_allocator(self):
        return _biorbd.VecBiorbdGeneralizedTorque_get_allocator(self)

    def pop_back(self):
        return _biorbd.VecBiorbdGeneralizedTorque_pop_back(self)

    def erase(self, *args):
        return _biorbd.VecBiorbdGeneralizedTorque_erase(self, *args)

    def __init__(self, *args):
        _biorbd.VecBiorbdGeneralizedTorque_swiginit(self, _biorbd.new_VecBiorbdGeneralizedTorque(*args))

    def push_back(self, x):
        return _biorbd.VecBiorbdGeneralizedTorque_push_back(self, x)

    def front(self):
        return _biorbd.VecBiorbdGeneralizedTorque_front(self)

    def back(self):
        return _biorbd.VecBiorbdGeneralizedTorque_back(self)

    def assign(self, n, x):
        return _biorbd.VecBiorbdGeneralizedTorque_assign(self, n, x)

    def resize(self, *args):
        return _biorbd.VecBiorbdGeneralizedTorque_resize(self, *args)

    def insert(self, *args):
        return _biorbd.VecBiorbdGeneralizedTorque_insert(self, *args)

    def reserve(self, n):
        return _biorbd.VecBiorbdGeneralizedTorque_reserve(self, n)

    def capacity(self):
        return _biorbd.VecBiorbdGeneralizedTorque_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecBiorbdGeneralizedTorque

# Register VecBiorbdGeneralizedTorque in _biorbd:
_biorbd.VecBiorbdGeneralizedTorque_swigregister(VecBiorbdGeneralizedTorque)

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

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

    def __nonzero__(self):
        return _biorbd.MatBiorbdGeneralizedTorque___nonzero__(self)

    def __bool__(self):
        return _biorbd.MatBiorbdGeneralizedTorque___bool__(self)

    def __len__(self):
        return _biorbd.MatBiorbdGeneralizedTorque___len__(self)

    def __getslice__(self, i, j):
        return _biorbd.MatBiorbdGeneralizedTorque___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _biorbd.MatBiorbdGeneralizedTorque___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _biorbd.MatBiorbdGeneralizedTorque___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _biorbd.MatBiorbdGeneralizedTorque___delitem__(self, *args)

    def __getitem__(self, *args):
        return _biorbd.MatBiorbdGeneralizedTorque___getitem__(self, *args)

    def __setitem__(self, *args):
        return _biorbd.MatBiorbdGeneralizedTorque___setitem__(self, *args)

    def pop(self):
        return _biorbd.MatBiorbdGeneralizedTorque_pop(self)

    def append(self, x):
        return _biorbd.MatBiorbdGeneralizedTorque_append(self, x)

    def empty(self):
        return _biorbd.MatBiorbdGeneralizedTorque_empty(self)

    def size(self):
        return _biorbd.MatBiorbdGeneralizedTorque_size(self)

    def swap(self, v):
        return _biorbd.MatBiorbdGeneralizedTorque_swap(self, v)

    def begin(self):
        return _biorbd.MatBiorbdGeneralizedTorque_begin(self)

    def end(self):
        return _biorbd.MatBiorbdGeneralizedTorque_end(self)

    def rbegin(self):
        return _biorbd.MatBiorbdGeneralizedTorque_rbegin(self)

    def rend(self):
        return _biorbd.MatBiorbdGeneralizedTorque_rend(self)

    def clear(self):
        return _biorbd.MatBiorbdGeneralizedTorque_clear(self)

    def get_allocator(self):
        return _biorbd.MatBiorbdGeneralizedTorque_get_allocator(self)

    def pop_back(self):
        return _biorbd.MatBiorbdGeneralizedTorque_pop_back(self)

    def erase(self, *args):
        return _biorbd.MatBiorbdGeneralizedTorque_erase(self, *args)

    def __init__(self, *args):
        _biorbd.MatBiorbdGeneralizedTorque_swiginit(self, _biorbd.new_MatBiorbdGeneralizedTorque(*args))

    def push_back(self, x):
        return _biorbd.MatBiorbdGeneralizedTorque_push_back(self, x)

    def front(self):
        return _biorbd.MatBiorbdGeneralizedTorque_front(self)

    def back(self):
        return _biorbd.MatBiorbdGeneralizedTorque_back(self)

    def assign(self, n, x):
        return _biorbd.MatBiorbdGeneralizedTorque_assign(self, n, x)

    def resize(self, *args):
        return _biorbd.MatBiorbdGeneralizedTorque_resize(self, *args)

    def insert(self, *args):
        return _biorbd.MatBiorbdGeneralizedTorque_insert(self, *args)

    def reserve(self, n):
        return _biorbd.MatBiorbdGeneralizedTorque_reserve(self, n)

    def capacity(self):
        return _biorbd.MatBiorbdGeneralizedTorque_capacity(self)
    __swig_destroy__ = _biorbd.delete_MatBiorbdGeneralizedTorque

# Register MatBiorbdGeneralizedTorque in _biorbd:
_biorbd.MatBiorbdGeneralizedTorque_swigregister(MatBiorbdGeneralizedTorque)

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

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

    def __nonzero__(self):
        return _biorbd.VecBiorbdGeneralizedCoordinates___nonzero__(self)

    def __bool__(self):
        return _biorbd.VecBiorbdGeneralizedCoordinates___bool__(self)

    def __len__(self):
        return _biorbd.VecBiorbdGeneralizedCoordinates___len__(self)

    def __getslice__(self, i, j):
        return _biorbd.VecBiorbdGeneralizedCoordinates___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _biorbd.VecBiorbdGeneralizedCoordinates___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _biorbd.VecBiorbdGeneralizedCoordinates___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _biorbd.VecBiorbdGeneralizedCoordinates___delitem__(self, *args)

    def __getitem__(self, *args):
        return _biorbd.VecBiorbdGeneralizedCoordinates___getitem__(self, *args)

    def __setitem__(self, *args):
        return _biorbd.VecBiorbdGeneralizedCoordinates___setitem__(self, *args)

    def pop(self):
        return _biorbd.VecBiorbdGeneralizedCoordinates_pop(self)

    def append(self, x):
        return _biorbd.VecBiorbdGeneralizedCoordinates_append(self, x)

    def empty(self):
        return _biorbd.VecBiorbdGeneralizedCoordinates_empty(self)

    def size(self):
        return _biorbd.VecBiorbdGeneralizedCoordinates_size(self)

    def swap(self, v):
        return _biorbd.VecBiorbdGeneralizedCoordinates_swap(self, v)

    def begin(self):
        return _biorbd.VecBiorbdGeneralizedCoordinates_begin(self)

    def end(self):
        return _biorbd.VecBiorbdGeneralizedCoordinates_end(self)

    def rbegin(self):
        return _biorbd.VecBiorbdGeneralizedCoordinates_rbegin(self)

    def rend(self):
        return _biorbd.VecBiorbdGeneralizedCoordinates_rend(self)

    def clear(self):
        return _biorbd.VecBiorbdGeneralizedCoordinates_clear(self)

    def get_allocator(self):
        return _biorbd.VecBiorbdGeneralizedCoordinates_get_allocator(self)

    def pop_back(self):
        return _biorbd.VecBiorbdGeneralizedCoordinates_pop_back(self)

    def erase(self, *args):
        return _biorbd.VecBiorbdGeneralizedCoordinates_erase(self, *args)

    def __init__(self, *args):
        _biorbd.VecBiorbdGeneralizedCoordinates_swiginit(self, _biorbd.new_VecBiorbdGeneralizedCoordinates(*args))

    def push_back(self, x):
        return _biorbd.VecBiorbdGeneralizedCoordinates_push_back(self, x)

    def front(self):
        return _biorbd.VecBiorbdGeneralizedCoordinates_front(self)

    def back(self):
        return _biorbd.VecBiorbdGeneralizedCoordinates_back(self)

    def assign(self, n, x):
        return _biorbd.VecBiorbdGeneralizedCoordinates_assign(self, n, x)

    def resize(self, *args):
        return _biorbd.VecBiorbdGeneralizedCoordinates_resize(self, *args)

    def insert(self, *args):
        return _biorbd.VecBiorbdGeneralizedCoordinates_insert(self, *args)

    def reserve(self, n):
        return _biorbd.VecBiorbdGeneralizedCoordinates_reserve(self, n)

    def capacity(self):
        return _biorbd.VecBiorbdGeneralizedCoordinates_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecBiorbdGeneralizedCoordinates

# Register VecBiorbdGeneralizedCoordinates in _biorbd:
_biorbd.VecBiorbdGeneralizedCoordinates_swigregister(VecBiorbdGeneralizedCoordinates)

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

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

    def __nonzero__(self):
        return _biorbd.MatBiorbdGeneralizedCoordinates___nonzero__(self)

    def __bool__(self):
        return _biorbd.MatBiorbdGeneralizedCoordinates___bool__(self)

    def __len__(self):
        return _biorbd.MatBiorbdGeneralizedCoordinates___len__(self)

    def __getslice__(self, i, j):
        return _biorbd.MatBiorbdGeneralizedCoordinates___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _biorbd.MatBiorbdGeneralizedCoordinates___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _biorbd.MatBiorbdGeneralizedCoordinates___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _biorbd.MatBiorbdGeneralizedCoordinates___delitem__(self, *args)

    def __getitem__(self, *args):
        return _biorbd.MatBiorbdGeneralizedCoordinates___getitem__(self, *args)

    def __setitem__(self, *args):
        return _biorbd.MatBiorbdGeneralizedCoordinates___setitem__(self, *args)

    def pop(self):
        return _biorbd.MatBiorbdGeneralizedCoordinates_pop(self)

    def append(self, x):
        return _biorbd.MatBiorbdGeneralizedCoordinates_append(self, x)

    def empty(self):
        return _biorbd.MatBiorbdGeneralizedCoordinates_empty(self)

    def size(self):
        return _biorbd.MatBiorbdGeneralizedCoordinates_size(self)

    def swap(self, v):
        return _biorbd.MatBiorbdGeneralizedCoordinates_swap(self, v)

    def begin(self):
        return _biorbd.MatBiorbdGeneralizedCoordinates_begin(self)

    def end(self):
        return _biorbd.MatBiorbdGeneralizedCoordinates_end(self)

    def rbegin(self):
        return _biorbd.MatBiorbdGeneralizedCoordinates_rbegin(self)

    def rend(self):
        return _biorbd.MatBiorbdGeneralizedCoordinates_rend(self)

    def clear(self):
        return _biorbd.MatBiorbdGeneralizedCoordinates_clear(self)

    def get_allocator(self):
        return _biorbd.MatBiorbdGeneralizedCoordinates_get_allocator(self)

    def pop_back(self):
        return _biorbd.MatBiorbdGeneralizedCoordinates_pop_back(self)

    def erase(self, *args):
        return _biorbd.MatBiorbdGeneralizedCoordinates_erase(self, *args)

    def __init__(self, *args):
        _biorbd.MatBiorbdGeneralizedCoordinates_swiginit(self, _biorbd.new_MatBiorbdGeneralizedCoordinates(*args))

    def push_back(self, x):
        return _biorbd.MatBiorbdGeneralizedCoordinates_push_back(self, x)

    def front(self):
        return _biorbd.MatBiorbdGeneralizedCoordinates_front(self)

    def back(self):
        return _biorbd.MatBiorbdGeneralizedCoordinates_back(self)

    def assign(self, n, x):
        return _biorbd.MatBiorbdGeneralizedCoordinates_assign(self, n, x)

    def resize(self, *args):
        return _biorbd.MatBiorbdGeneralizedCoordinates_resize(self, *args)

    def insert(self, *args):
        return _biorbd.MatBiorbdGeneralizedCoordinates_insert(self, *args)

    def reserve(self, n):
        return _biorbd.MatBiorbdGeneralizedCoordinates_reserve(self, n)

    def capacity(self):
        return _biorbd.MatBiorbdGeneralizedCoordinates_capacity(self)
    __swig_destroy__ = _biorbd.delete_MatBiorbdGeneralizedCoordinates

# Register MatBiorbdGeneralizedCoordinates in _biorbd:
_biorbd.MatBiorbdGeneralizedCoordinates_swigregister(MatBiorbdGeneralizedCoordinates)

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

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

    def __nonzero__(self):
        return _biorbd.VecBiorbdNodeBone___nonzero__(self)

    def __bool__(self):
        return _biorbd.VecBiorbdNodeBone___bool__(self)

    def __len__(self):
        return _biorbd.VecBiorbdNodeBone___len__(self)

    def __getslice__(self, i, j):
        return _biorbd.VecBiorbdNodeBone___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _biorbd.VecBiorbdNodeBone___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _biorbd.VecBiorbdNodeBone___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _biorbd.VecBiorbdNodeBone___delitem__(self, *args)

    def __getitem__(self, *args):
        return _biorbd.VecBiorbdNodeBone___getitem__(self, *args)

    def __setitem__(self, *args):
        return _biorbd.VecBiorbdNodeBone___setitem__(self, *args)

    def pop(self):
        return _biorbd.VecBiorbdNodeBone_pop(self)

    def append(self, x):
        return _biorbd.VecBiorbdNodeBone_append(self, x)

    def empty(self):
        return _biorbd.VecBiorbdNodeBone_empty(self)

    def size(self):
        return _biorbd.VecBiorbdNodeBone_size(self)

    def swap(self, v):
        return _biorbd.VecBiorbdNodeBone_swap(self, v)

    def begin(self):
        return _biorbd.VecBiorbdNodeBone_begin(self)

    def end(self):
        return _biorbd.VecBiorbdNodeBone_end(self)

    def rbegin(self):
        return _biorbd.VecBiorbdNodeBone_rbegin(self)

    def rend(self):
        return _biorbd.VecBiorbdNodeBone_rend(self)

    def clear(self):
        return _biorbd.VecBiorbdNodeBone_clear(self)

    def get_allocator(self):
        return _biorbd.VecBiorbdNodeBone_get_allocator(self)

    def pop_back(self):
        return _biorbd.VecBiorbdNodeBone_pop_back(self)

    def erase(self, *args):
        return _biorbd.VecBiorbdNodeBone_erase(self, *args)

    def __init__(self, *args):
        _biorbd.VecBiorbdNodeBone_swiginit(self, _biorbd.new_VecBiorbdNodeBone(*args))

    def push_back(self, x):
        return _biorbd.VecBiorbdNodeBone_push_back(self, x)

    def front(self):
        return _biorbd.VecBiorbdNodeBone_front(self)

    def back(self):
        return _biorbd.VecBiorbdNodeBone_back(self)

    def assign(self, n, x):
        return _biorbd.VecBiorbdNodeBone_assign(self, n, x)

    def resize(self, *args):
        return _biorbd.VecBiorbdNodeBone_resize(self, *args)

    def insert(self, *args):
        return _biorbd.VecBiorbdNodeBone_insert(self, *args)

    def reserve(self, n):
        return _biorbd.VecBiorbdNodeBone_reserve(self, n)

    def capacity(self):
        return _biorbd.VecBiorbdNodeBone_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecBiorbdNodeBone

# Register VecBiorbdNodeBone in _biorbd:
_biorbd.VecBiorbdNodeBone_swigregister(VecBiorbdNodeBone)

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

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

    def __nonzero__(self):
        return _biorbd.MatBiorbdNodeBone___nonzero__(self)

    def __bool__(self):
        return _biorbd.MatBiorbdNodeBone___bool__(self)

    def __len__(self):
        return _biorbd.MatBiorbdNodeBone___len__(self)

    def __getslice__(self, i, j):
        return _biorbd.MatBiorbdNodeBone___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _biorbd.MatBiorbdNodeBone___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _biorbd.MatBiorbdNodeBone___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _biorbd.MatBiorbdNodeBone___delitem__(self, *args)

    def __getitem__(self, *args):
        return _biorbd.MatBiorbdNodeBone___getitem__(self, *args)

    def __setitem__(self, *args):
        return _biorbd.MatBiorbdNodeBone___setitem__(self, *args)

    def pop(self):
        return _biorbd.MatBiorbdNodeBone_pop(self)

    def append(self, x):
        return _biorbd.MatBiorbdNodeBone_append(self, x)

    def empty(self):
        return _biorbd.MatBiorbdNodeBone_empty(self)

    def size(self):
        return _biorbd.MatBiorbdNodeBone_size(self)

    def swap(self, v):
        return _biorbd.MatBiorbdNodeBone_swap(self, v)

    def begin(self):
        return _biorbd.MatBiorbdNodeBone_begin(self)

    def end(self):
        return _biorbd.MatBiorbdNodeBone_end(self)

    def rbegin(self):
        return _biorbd.MatBiorbdNodeBone_rbegin(self)

    def rend(self):
        return _biorbd.MatBiorbdNodeBone_rend(self)

    def clear(self):
        return _biorbd.MatBiorbdNodeBone_clear(self)

    def get_allocator(self):
        return _biorbd.MatBiorbdNodeBone_get_allocator(self)

    def pop_back(self):
        return _biorbd.MatBiorbdNodeBone_pop_back(self)

    def erase(self, *args):
        return _biorbd.MatBiorbdNodeBone_erase(self, *args)

    def __init__(self, *args):
        _biorbd.MatBiorbdNodeBone_swiginit(self, _biorbd.new_MatBiorbdNodeBone(*args))

    def push_back(self, x):
        return _biorbd.MatBiorbdNodeBone_push_back(self, x)

    def front(self):
        return _biorbd.MatBiorbdNodeBone_front(self)

    def back(self):
        return _biorbd.MatBiorbdNodeBone_back(self)

    def assign(self, n, x):
        return _biorbd.MatBiorbdNodeBone_assign(self, n, x)

    def resize(self, *args):
        return _biorbd.MatBiorbdNodeBone_resize(self, *args)

    def insert(self, *args):
        return _biorbd.MatBiorbdNodeBone_insert(self, *args)

    def reserve(self, n):
        return _biorbd.MatBiorbdNodeBone_reserve(self, n)

    def capacity(self):
        return _biorbd.MatBiorbdNodeBone_capacity(self)
    __swig_destroy__ = _biorbd.delete_MatBiorbdNodeBone

# Register MatBiorbdNodeBone in _biorbd:
_biorbd.MatBiorbdNodeBone_swigregister(MatBiorbdNodeBone)

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

    def __init__(self, *args):
        _biorbd.Joints_swiginit(self, _biorbd.new_Joints(*args))
    __swig_destroy__ = _biorbd.delete_Joints

    def DeepCopy(self, *args):
        return _biorbd.Joints_DeepCopy(self, *args)

    def AddBone(self, *args):
        return _biorbd.Joints_AddBone(self, *args)

    def GetBodyBiorbdId(self, segmentName):
        return _biorbd.Joints_GetBodyBiorbdId(self, segmentName)

    def nbGeneralizedTorque(self):
        return _biorbd.Joints_nbGeneralizedTorque(self)

    def nbBone(self):
        return _biorbd.Joints_nbBone(self)

    def nbDof(self):
        return _biorbd.Joints_nbDof(self)

    def getDofIndex(self, boneName, dofName):
        return _biorbd.Joints_getDofIndex(self, boneName, dofName)

    def nameDof(self):
        return _biorbd.Joints_nameDof(self)

    def nbQ(self):
        return _biorbd.Joints_nbQ(self)

    def nbQdot(self):
        return _biorbd.Joints_nbQdot(self)

    def nbQddot(self):
        return _biorbd.Joints_nbQddot(self)

    def nbRoot(self):
        return _biorbd.Joints_nbRoot(self)

    def nbQuat(self):
        return _biorbd.Joints_nbQuat(self)

    def setIsRootActuated(self, a):
        return _biorbd.Joints_setIsRootActuated(self, a)

    def isRootActuated(self):
        return _biorbd.Joints_isRootActuated(self)

    def setHasExternalForces(self, f):
        return _biorbd.Joints_setHasExternalForces(self, f)

    def hasExternalForces(self):
        return _biorbd.Joints_hasExternalForces(self)

    def bone(self, *args):
        return _biorbd.Joints_bone(self, *args)

    def dispatchedForce(self, *args):
        return _biorbd.Joints_dispatchedForce(self, *args)

    def UpdateKinematicsCustom(self, Q=None, Qdot=None, Qddot=None):
        return _biorbd.Joints_UpdateKinematicsCustom(self, Q, Qdot, Qddot)

    def integrateKinematics(self, Q, QDot, GeneralizedTorque):
        return _biorbd.Joints_integrateKinematics(self, Q, QDot, GeneralizedTorque)

    def getIntegratedKinematics(self, step, Q, Qdot):
        return _biorbd.Joints_getIntegratedKinematics(self, step, Q, Qdot)

    def nbInterationStep(self):
        return _biorbd.Joints_nbInterationStep(self)

    def allGlobalJCS(self, *args):
        return _biorbd.Joints_allGlobalJCS(self, *args)

    def globalJCS(self, *args):
        return _biorbd.Joints_globalJCS(self, *args)

    def localJCS(self, *args):
        return _biorbd.Joints_localJCS(self, *args)

    def projectPoint(self, *args):
        return _biorbd.Joints_projectPoint(self, *args)

    def projectPointJacobian(self, *args):
        return _biorbd.Joints_projectPointJacobian(self, *args)

    def mass(self):
        return _biorbd.Joints_mass(self)

    def CoM(self, Q, updateKin=True):
        return _biorbd.Joints_CoM(self, Q, updateKin)

    def CoMbySegment(self, *args):
        return _biorbd.Joints_CoMbySegment(self, *args)

    def CoMdot(self, Q, Qdot):
        return _biorbd.Joints_CoMdot(self, Q, Qdot)

    def CoMddot(self, Q, Qdot, Qddot):
        return _biorbd.Joints_CoMddot(self, Q, Qdot, Qddot)

    def CoMdotBySegment(self, *args):
        return _biorbd.Joints_CoMdotBySegment(self, *args)

    def CoMddotBySegment(self, *args):
        return _biorbd.Joints_CoMddotBySegment(self, *args)

    def CoMJacobian(self, Q):
        return _biorbd.Joints_CoMJacobian(self, Q)

    def meshPoints(self, *args):
        return _biorbd.Joints_meshPoints(self, *args)

    def meshPatch(self, *args):
        return _biorbd.Joints_meshPatch(self, *args)

    def boneMesh(self, *args):
        return _biorbd.Joints_boneMesh(self, *args)

    def angularMomentum(self, Q, Qdot, updateKin=True):
        return _biorbd.Joints_angularMomentum(self, Q, Qdot, updateKin)

    def CalcAngularMomentum(self, *args):
        return _biorbd.Joints_CalcAngularMomentum(self, *args)

    def CalcSegmentsAngularMomentum(self, *args):
        return _biorbd.Joints_CalcSegmentsAngularMomentum(self, *args)

    def CalcMatRotJacobian(self, Q, body_id, rotation, G, update_kinematics):
        return _biorbd.Joints_CalcMatRotJacobian(self, Q, body_id, rotation, G, update_kinematics)

    def ForwardDynamicsContactsLagrangian(self, Q, QDot, GeneralizedTorque, CS, QDDot):
        return _biorbd.Joints_ForwardDynamicsContactsLagrangian(self, Q, QDot, GeneralizedTorque, CS, QDDot)

    def computeQdot(self, Q, QDot, QDotOut):
        return _biorbd.Joints_computeQdot(self, Q, QDot, QDotOut)

# Register Joints in _biorbd:
_biorbd.Joints_swigregister(Joints)

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

    def __init__(self, *args):
        _biorbd.GeneralizedCoordinates_swiginit(self, _biorbd.new_GeneralizedCoordinates(*args))
    __swig_destroy__ = _biorbd.delete_GeneralizedCoordinates

# Register GeneralizedCoordinates in _biorbd:
_biorbd.GeneralizedCoordinates_swigregister(GeneralizedCoordinates)

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

    def __init__(self, *args):
        _biorbd.GeneralizedTorque_swiginit(self, _biorbd.new_GeneralizedTorque(*args))
    __swig_destroy__ = _biorbd.delete_GeneralizedTorque

# Register GeneralizedTorque in _biorbd:
_biorbd.GeneralizedTorque_swigregister(GeneralizedTorque)

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

    def __init__(self, *args):
        _biorbd.Markers_swiginit(self, _biorbd.new_Markers(*args))
    __swig_destroy__ = _biorbd.delete_Markers

    def DeepCopy(self, *args):
        return _biorbd.Markers_DeepCopy(self, *args)

    def addMarker(self, pos, name, parentName, technical, anatomical, axesToRemove, id=-1):
        return _biorbd.Markers_addMarker(self, pos, name, parentName, technical, anatomical, axesToRemove, id)

    def markerNames(self):
        return _biorbd.Markers_markerNames(self)

    def technicalMarkerNames(self):
        return _biorbd.Markers_technicalMarkerNames(self)

    def anatomicalMarkerNames(self):
        return _biorbd.Markers_anatomicalMarkerNames(self)

    def marker(self, *args):
        return _biorbd.Markers_marker(self, *args)

    def markers(self, *args):
        return _biorbd.Markers_markers(self, *args)

    def markerVelocity(self, *args):
        return _biorbd.Markers_markerVelocity(self, *args)

    def technicalMarkers(self, *args):
        return _biorbd.Markers_technicalMarkers(self, *args)

    def anatomicalMarkers(self, *args):
        return _biorbd.Markers_anatomicalMarkers(self, *args)

    def TechnicalMarkersInLocal(self, removeAxis=True):
        return _biorbd.Markers_TechnicalMarkersInLocal(self, removeAxis)

    def AnatomicalMarkersInLocal(self, removeAxis=True):
        return _biorbd.Markers_AnatomicalMarkersInLocal(self, removeAxis)

    def segmentMarkers(self, Q, idx, removeAxis=True, updateKin=True):
        return _biorbd.Markers_segmentMarkers(self, Q, idx, removeAxis, updateKin)

    def nMarkers(self, *args):
        return _biorbd.Markers_nMarkers(self, *args)

    def nTechnicalMarkers(self, *args):
        return _biorbd.Markers_nTechnicalMarkers(self, *args)

    def nAnatomicalMarkers(self):
        return _biorbd.Markers_nAnatomicalMarkers(self)

    def TechnicalMarkersJacobian(self, Q, removeAxis=True, updateKin=True):
        return _biorbd.Markers_TechnicalMarkersJacobian(self, Q, removeAxis, updateKin)

    def markersJacobian(self, *args):
        return _biorbd.Markers_markersJacobian(self, *args)

# Register Markers in _biorbd:
_biorbd.Markers_swigregister(Markers)

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

    def __init__(self, *args):
        _biorbd.NodeBone_swiginit(self, _biorbd.new_NodeBone(*args))

    def DeepCopy(self, *args):
        return _biorbd.NodeBone_DeepCopy(self, *args)

    def isTechnical(self):
        return _biorbd.NodeBone_isTechnical(self)

    def isAnatomical(self):
        return _biorbd.NodeBone_isAnatomical(self)

    def parentId(self):
        return _biorbd.NodeBone_parentId(self)

    def removeAxes(self):
        return _biorbd.NodeBone_removeAxes(self)

    def isAxisRemoved(self, arg2):
        return _biorbd.NodeBone_isAxisRemoved(self, arg2)

    def isAxisKept(self, arg2):
        return _biorbd.NodeBone_isAxisKept(self, arg2)

    def addAxesToRemove(self, *args):
        return _biorbd.NodeBone_addAxesToRemove(self, *args)

    def axesToRemove(self):
        return _biorbd.NodeBone_axesToRemove(self)

    def nAxesToRemove(self):
        return _biorbd.NodeBone_nAxesToRemove(self)
    __swig_destroy__ = _biorbd.delete_NodeBone

# Register NodeBone in _biorbd:
_biorbd.NodeBone_swigregister(NodeBone)

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

    def __init__(self):
        _biorbd.Contacts_swiginit(self, _biorbd.new_Contacts())

    def DeepCopy(self, *args):
        return _biorbd.Contacts_DeepCopy(self, *args)

    def AddConstraint(self, *args):
        return _biorbd.Contacts_AddConstraint(self, *args)

    def AddLoopConstraint(self, body_id_predecessor, body_id_successor, X_predecessor, X_successor, axis, name, enableStabilization=False, stabilizationParam=0.1):
        return _biorbd.Contacts_AddLoopConstraint(self, body_id_predecessor, body_id_successor, X_predecessor, X_successor, axis, name, enableStabilization, stabilizationParam)
    __swig_destroy__ = _biorbd.delete_Contacts

    def getConstraints(self):
        return _biorbd.Contacts_getConstraints(self)

    def hasContacts(self):
        return _biorbd.Contacts_hasContacts(self)

    def nContacts(self):
        return _biorbd.Contacts_nContacts(self)

    def name(self, i):
        return _biorbd.Contacts_name(self, i)

    def constraintsInGlobal(self, Q, updateKin):
        return _biorbd.Contacts_constraintsInGlobal(self, Q, updateKin)

    def getForce(self):
        return _biorbd.Contacts_getForce(self)

# Register Contacts in _biorbd:
_biorbd.Contacts_swigregister(Contacts)

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

    def __init__(self, *args):
        _biorbd.KalmanReconsMarkers_swiginit(self, _biorbd.new_KalmanReconsMarkers(*args))

    def DeepCopy(self, *args):
        return _biorbd.KalmanReconsMarkers_DeepCopy(self, *args)

    def reconstructFrame(self, *args):
        return _biorbd.KalmanReconsMarkers_reconstructFrame(self, *args)

    def first(self):
        return _biorbd.KalmanReconsMarkers_first(self)
    __swig_destroy__ = _biorbd.delete_KalmanReconsMarkers

# Register KalmanReconsMarkers in _biorbd:
_biorbd.KalmanReconsMarkers_swigregister(KalmanReconsMarkers)

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

    def __init__(self):
        _biorbd.SharedBiorbdMuscle_swiginit(self, _biorbd.new_SharedBiorbdMuscle())
    __swig_destroy__ = _biorbd.delete_SharedBiorbdMuscle

# Register SharedBiorbdMuscle in _biorbd:
_biorbd.SharedBiorbdMuscle_swigregister(SharedBiorbdMuscle)

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

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

    def __nonzero__(self):
        return _biorbd.VecBiorbdMuscleStateDynamics___nonzero__(self)

    def __bool__(self):
        return _biorbd.VecBiorbdMuscleStateDynamics___bool__(self)

    def __len__(self):
        return _biorbd.VecBiorbdMuscleStateDynamics___len__(self)

    def __getslice__(self, i, j):
        return _biorbd.VecBiorbdMuscleStateDynamics___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _biorbd.VecBiorbdMuscleStateDynamics___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _biorbd.VecBiorbdMuscleStateDynamics___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _biorbd.VecBiorbdMuscleStateDynamics___delitem__(self, *args)

    def __getitem__(self, *args):
        return _biorbd.VecBiorbdMuscleStateDynamics___getitem__(self, *args)

    def __setitem__(self, *args):
        return _biorbd.VecBiorbdMuscleStateDynamics___setitem__(self, *args)

    def pop(self):
        return _biorbd.VecBiorbdMuscleStateDynamics_pop(self)

    def append(self, x):
        return _biorbd.VecBiorbdMuscleStateDynamics_append(self, x)

    def empty(self):
        return _biorbd.VecBiorbdMuscleStateDynamics_empty(self)

    def size(self):
        return _biorbd.VecBiorbdMuscleStateDynamics_size(self)

    def swap(self, v):
        return _biorbd.VecBiorbdMuscleStateDynamics_swap(self, v)

    def begin(self):
        return _biorbd.VecBiorbdMuscleStateDynamics_begin(self)

    def end(self):
        return _biorbd.VecBiorbdMuscleStateDynamics_end(self)

    def rbegin(self):
        return _biorbd.VecBiorbdMuscleStateDynamics_rbegin(self)

    def rend(self):
        return _biorbd.VecBiorbdMuscleStateDynamics_rend(self)

    def clear(self):
        return _biorbd.VecBiorbdMuscleStateDynamics_clear(self)

    def get_allocator(self):
        return _biorbd.VecBiorbdMuscleStateDynamics_get_allocator(self)

    def pop_back(self):
        return _biorbd.VecBiorbdMuscleStateDynamics_pop_back(self)

    def erase(self, *args):
        return _biorbd.VecBiorbdMuscleStateDynamics_erase(self, *args)

    def __init__(self, *args):
        _biorbd.VecBiorbdMuscleStateDynamics_swiginit(self, _biorbd.new_VecBiorbdMuscleStateDynamics(*args))

    def push_back(self, x):
        return _biorbd.VecBiorbdMuscleStateDynamics_push_back(self, x)

    def front(self):
        return _biorbd.VecBiorbdMuscleStateDynamics_front(self)

    def back(self):
        return _biorbd.VecBiorbdMuscleStateDynamics_back(self)

    def assign(self, n, x):
        return _biorbd.VecBiorbdMuscleStateDynamics_assign(self, n, x)

    def resize(self, *args):
        return _biorbd.VecBiorbdMuscleStateDynamics_resize(self, *args)

    def insert(self, *args):
        return _biorbd.VecBiorbdMuscleStateDynamics_insert(self, *args)

    def reserve(self, n):
        return _biorbd.VecBiorbdMuscleStateDynamics_reserve(self, n)

    def capacity(self):
        return _biorbd.VecBiorbdMuscleStateDynamics_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecBiorbdMuscleStateDynamics

# Register VecBiorbdMuscleStateDynamics in _biorbd:
_biorbd.VecBiorbdMuscleStateDynamics_swigregister(VecBiorbdMuscleStateDynamics)

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

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

    def __nonzero__(self):
        return _biorbd.MatBiorbdMuscleStateDynamics___nonzero__(self)

    def __bool__(self):
        return _biorbd.MatBiorbdMuscleStateDynamics___bool__(self)

    def __len__(self):
        return _biorbd.MatBiorbdMuscleStateDynamics___len__(self)

    def __getslice__(self, i, j):
        return _biorbd.MatBiorbdMuscleStateDynamics___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _biorbd.MatBiorbdMuscleStateDynamics___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _biorbd.MatBiorbdMuscleStateDynamics___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _biorbd.MatBiorbdMuscleStateDynamics___delitem__(self, *args)

    def __getitem__(self, *args):
        return _biorbd.MatBiorbdMuscleStateDynamics___getitem__(self, *args)

    def __setitem__(self, *args):
        return _biorbd.MatBiorbdMuscleStateDynamics___setitem__(self, *args)

    def pop(self):
        return _biorbd.MatBiorbdMuscleStateDynamics_pop(self)

    def append(self, x):
        return _biorbd.MatBiorbdMuscleStateDynamics_append(self, x)

    def empty(self):
        return _biorbd.MatBiorbdMuscleStateDynamics_empty(self)

    def size(self):
        return _biorbd.MatBiorbdMuscleStateDynamics_size(self)

    def swap(self, v):
        return _biorbd.MatBiorbdMuscleStateDynamics_swap(self, v)

    def begin(self):
        return _biorbd.MatBiorbdMuscleStateDynamics_begin(self)

    def end(self):
        return _biorbd.MatBiorbdMuscleStateDynamics_end(self)

    def rbegin(self):
        return _biorbd.MatBiorbdMuscleStateDynamics_rbegin(self)

    def rend(self):
        return _biorbd.MatBiorbdMuscleStateDynamics_rend(self)

    def clear(self):
        return _biorbd.MatBiorbdMuscleStateDynamics_clear(self)

    def get_allocator(self):
        return _biorbd.MatBiorbdMuscleStateDynamics_get_allocator(self)

    def pop_back(self):
        return _biorbd.MatBiorbdMuscleStateDynamics_pop_back(self)

    def erase(self, *args):
        return _biorbd.MatBiorbdMuscleStateDynamics_erase(self, *args)

    def __init__(self, *args):
        _biorbd.MatBiorbdMuscleStateDynamics_swiginit(self, _biorbd.new_MatBiorbdMuscleStateDynamics(*args))

    def push_back(self, x):
        return _biorbd.MatBiorbdMuscleStateDynamics_push_back(self, x)

    def front(self):
        return _biorbd.MatBiorbdMuscleStateDynamics_front(self)

    def back(self):
        return _biorbd.MatBiorbdMuscleStateDynamics_back(self)

    def assign(self, n, x):
        return _biorbd.MatBiorbdMuscleStateDynamics_assign(self, n, x)

    def resize(self, *args):
        return _biorbd.MatBiorbdMuscleStateDynamics_resize(self, *args)

    def insert(self, *args):
        return _biorbd.MatBiorbdMuscleStateDynamics_insert(self, *args)

    def reserve(self, n):
        return _biorbd.MatBiorbdMuscleStateDynamics_reserve(self, n)

    def capacity(self):
        return _biorbd.MatBiorbdMuscleStateDynamics_capacity(self)
    __swig_destroy__ = _biorbd.delete_MatBiorbdMuscleStateDynamics

# Register MatBiorbdMuscleStateDynamics in _biorbd:
_biorbd.MatBiorbdMuscleStateDynamics_swigregister(MatBiorbdMuscleStateDynamics)

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

    def __init__(self):
        _biorbd.SharedBiorbdMuscleFatigueState_swiginit(self, _biorbd.new_SharedBiorbdMuscleFatigueState())
    __swig_destroy__ = _biorbd.delete_SharedBiorbdMuscleFatigueState

# Register SharedBiorbdMuscleFatigueState in _biorbd:
_biorbd.SharedBiorbdMuscleFatigueState_swigregister(SharedBiorbdMuscleFatigueState)

IDEALIZED_ACTUATOR = _biorbd.IDEALIZED_ACTUATOR
HILL = _biorbd.HILL
HILL_THELEN = _biorbd.HILL_THELEN
HILL_THELEN_FATIGABLE = _biorbd.HILL_THELEN_FATIGABLE
NO_MUSCLE_TYPE = _biorbd.NO_MUSCLE_TYPE

def MUSCLE_TYPE_toStr(type):
    return _biorbd.MUSCLE_TYPE_toStr(type)
SIMPLE_STATE = _biorbd.SIMPLE_STATE
DYNAMIC = _biorbd.DYNAMIC
BUCHANAN = _biorbd.BUCHANAN
NO_STATE_TYPE = _biorbd.NO_STATE_TYPE

def STATE_TYPE_toStr(type):
    return _biorbd.STATE_TYPE_toStr(type)
SIMPLE_STATE_FATIGUE = _biorbd.SIMPLE_STATE_FATIGUE
DYNAMIC_XIA = _biorbd.DYNAMIC_XIA
NO_FATIGUE_STATE_TYPE = _biorbd.NO_FATIGUE_STATE_TYPE

def STATE_FATIGUE_TYPE_toStr(type):
    return _biorbd.STATE_FATIGUE_TYPE_toStr(type)
class Compound(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def DeepCopy(self, other):
        return _biorbd.Compound_DeepCopy(self, other)

    def name(self):
        return _biorbd.Compound_name(self)

    def setName(self, name):
        return _biorbd.Compound_setName(self, name)

    def type(self):
        return _biorbd.Compound_type(self)

    def pathChanger(self):
        return _biorbd.Compound_pathChanger(self)

    def addPathObject(self, w):
        return _biorbd.Compound_addPathObject(self, w)

    def force(self, *args):
        return _biorbd.Compound_force(self, *args)

# Register Compound in _biorbd:
_biorbd.Compound_swigregister(Compound)

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

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

    def DeepCopy(self, other):
        return _biorbd.Muscle_DeepCopy(self, other)

    def length(self, model, Q, updateKin=2):
        return _biorbd.Muscle_length(self, model, Q, updateKin)

    def musculoTendonLength(self, model, Q, updateKin=2):
        return _biorbd.Muscle_musculoTendonLength(self, model, Q, updateKin)

    def velocity(self, model, Q, Qdot, updateKin=True):
        return _biorbd.Muscle_velocity(self, model, Q, Qdot, updateKin)

    def updateOrientations(self, *args):
        return _biorbd.Muscle_updateOrientations(self, *args)

    def position(self):
        return _biorbd.Muscle_position(self)

    def characteristics(self):
        return _biorbd.Muscle_characteristics(self)

    def setPosition(self, val):
        return _biorbd.Muscle_setPosition(self, val)

    def setCharacteristics(self, val):
        return _biorbd.Muscle_setCharacteristics(self, val)

    def musclesPointsInGlobal(self, *args):
        return _biorbd.Muscle_musclesPointsInGlobal(self, *args)

    def forceIsoMax(self, arg2):
        return _biorbd.Muscle_forceIsoMax(self, arg2)

    def setState(self, s):
        return _biorbd.Muscle_setState(self, s)

    def state(self, *args):
        return _biorbd.Muscle_state(self, *args)

    def activationDot(self, s, arg3=False):
        return _biorbd.Muscle_activationDot(self, s, arg3)

# Register Muscle in _biorbd:
_biorbd.Muscle_swigregister(Muscle)

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

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

    def DeepCopy(self, other):
        return _biorbd.Fatigable_DeepCopy(self, other)

    def computeTimeDerivativeState(self, emg):
        return _biorbd.Fatigable_computeTimeDerivativeState(self, emg)

    def fatigueState(self, *args):
        return _biorbd.Fatigable_fatigueState(self, *args)

# Register Fatigable in _biorbd:
_biorbd.Fatigable_swigregister(Fatigable)

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

    def __init__(self, *args):
        _biorbd.HillType_swiginit(self, _biorbd.new_HillType(*args))

    def force(self, *args):
        return _biorbd.HillType_force(self, *args)

    def FlCE(self, EMG):
        return _biorbd.HillType_FlCE(self, EMG)

    def FlPE(self):
        return _biorbd.HillType_FlPE(self)

    def FvCE(self):
        return _biorbd.HillType_FvCE(self)

    def damping(self):
        return _biorbd.HillType_damping(self)

    @staticmethod
    def DeepCopy(*args):
        return _biorbd.HillType_DeepCopy(*args)
    __swig_destroy__ = _biorbd.delete_HillType

# Register HillType in _biorbd:
_biorbd.HillType_swigregister(HillType)

def HillType_DeepCopy(*args):
    return _biorbd.HillType_DeepCopy(*args)

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

    def __init__(self, *args):
        _biorbd.HillThelenType_swiginit(self, _biorbd.new_HillThelenType(*args))

    def computeFlPE(self):
        return _biorbd.HillThelenType_computeFlPE(self)

    def computeFlCE(self, emg):
        return _biorbd.HillThelenType_computeFlCE(self, emg)

    @staticmethod
    def DeepCopy(*args):
        return _biorbd.HillThelenType_DeepCopy(*args)
    __swig_destroy__ = _biorbd.delete_HillThelenType

# Register HillThelenType in _biorbd:
_biorbd.HillThelenType_swigregister(HillThelenType)

def HillThelenType_DeepCopy(*args):
    return _biorbd.HillThelenType_DeepCopy(*args)

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

    def __init__(self, *args):
        _biorbd.HillThelenTypeFatigable_swiginit(self, _biorbd.new_HillThelenTypeFatigable(*args))

    def computeFlCE(self, EMG):
        return _biorbd.HillThelenTypeFatigable_computeFlCE(self, EMG)

    @staticmethod
    def DeepCopy(*args):
        return _biorbd.HillThelenTypeFatigable_DeepCopy(*args)
    __swig_destroy__ = _biorbd.delete_HillThelenTypeFatigable

# Register HillThelenTypeFatigable in _biorbd:
_biorbd.HillThelenTypeFatigable_swigregister(HillThelenTypeFatigable)

def HillThelenTypeFatigable_DeepCopy(*args):
    return _biorbd.HillThelenTypeFatigable_DeepCopy(*args)

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

    def __init__(self, *args):
        _biorbd.IdealizedActuator_swiginit(self, _biorbd.new_IdealizedActuator(*args))

    def force(self, *args):
        return _biorbd.IdealizedActuator_force(self, *args)

    @staticmethod
    def DeepCopy(*args):
        return _biorbd.IdealizedActuator_DeepCopy(*args)
    __swig_destroy__ = _biorbd.delete_IdealizedActuator

# Register IdealizedActuator in _biorbd:
_biorbd.IdealizedActuator_swigregister(IdealizedActuator)

def IdealizedActuator_DeepCopy(*args):
    return _biorbd.IdealizedActuator_DeepCopy(*args)

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

    def __init__(self, *args):
        _biorbd.Muscles_swiginit(self, _biorbd.new_Muscles(*args))
    __swig_destroy__ = _biorbd.delete_Muscles

    def DeepCopy(self, *args):
        return _biorbd.Muscles_DeepCopy(self, *args)

    def addMuscleGroup(self, name, originName, insertionName):
        return _biorbd.Muscles_addMuscleGroup(self, name, originName, insertionName)

    def getGroupId(self, name):
        return _biorbd.Muscles_getGroupId(self, name)

    def muscleGroup(self, *args):
        return _biorbd.Muscles_muscleGroup(self, *args)

    def updateMuscles(self, *args):
        return _biorbd.Muscles_updateMuscles(self, *args)

    def muscularJointTorque(self, *args):
        return _biorbd.Muscles_muscularJointTorque(self, *args)

    def musclesLengthJacobian(self, *args):
        return _biorbd.Muscles_musclesLengthJacobian(self, *args)

    def musclesForces(self, state, updateKin=True, Q=None, QDot=None):
        return _biorbd.Muscles_musclesForces(self, state, updateKin, Q, QDot)

    def nbMuscleGroups(self):
        return _biorbd.Muscles_nbMuscleGroups(self)

    def nbMuscleTotal(self):
        return _biorbd.Muscles_nbMuscleTotal(self)

# Register Muscles in _biorbd:
_biorbd.Muscles_swigregister(Muscles)

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

    def __init__(self, *args):
        _biorbd.MuscleGroup_swiginit(self, _biorbd.new_MuscleGroup(*args))
    __swig_destroy__ = _biorbd.delete_MuscleGroup

    def DeepCopy(self, *args):
        return _biorbd.MuscleGroup_DeepCopy(self, *args)

    def addMuscle(self, *args):
        return _biorbd.MuscleGroup_addMuscle(self, *args)

    def nbMuscles(self):
        return _biorbd.MuscleGroup_nbMuscles(self)

    def muscle(self, *args):
        return _biorbd.MuscleGroup_muscle(self, *args)

    def muscleID(self, name):
        return _biorbd.MuscleGroup_muscleID(self, name)

    def setName(self, name):
        return _biorbd.MuscleGroup_setName(self, name)

    def setOrigin(self, name):
        return _biorbd.MuscleGroup_setOrigin(self, name)

    def setInsertion(self, name):
        return _biorbd.MuscleGroup_setInsertion(self, name)

    def name(self):
        return _biorbd.MuscleGroup_name(self)

    def origin(self):
        return _biorbd.MuscleGroup_origin(self)

    def insertion(self):
        return _biorbd.MuscleGroup_insertion(self)

# Register MuscleGroup in _biorbd:
_biorbd.MuscleGroup_swigregister(MuscleGroup)

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

    def __init__(self, *args):
        _biorbd.Characteristics_swiginit(self, _biorbd.new_Characteristics(*args))
    __swig_destroy__ = _biorbd.delete_Characteristics

    def DeepCopy(self, *args):
        return _biorbd.Characteristics_DeepCopy(self, *args)

    def optimalLength(self):
        return _biorbd.Characteristics_optimalLength(self)

    def forceIsoMax(self):
        return _biorbd.Characteristics_forceIsoMax(self)

    def tendonSlackLength(self):
        return _biorbd.Characteristics_tendonSlackLength(self)

    def pennationAngle(self):
        return _biorbd.Characteristics_pennationAngle(self)

    def minActivation(self, *args):
        return _biorbd.Characteristics_minActivation(self, *args)

    def GeneralizedTorqueActivation(self, *args):
        return _biorbd.Characteristics_GeneralizedTorqueActivation(self, *args)

    def GeneralizedTorqueDeactivation(self, *args):
        return _biorbd.Characteristics_GeneralizedTorqueDeactivation(self, *args)

    def setOptimalLength(self, val):
        return _biorbd.Characteristics_setOptimalLength(self, val)

    def setForceIsoMax(self, val):
        return _biorbd.Characteristics_setForceIsoMax(self, val)

    def PCSA(self, *args):
        return _biorbd.Characteristics_PCSA(self, *args)

    def setTendonSlackLength(self, val):
        return _biorbd.Characteristics_setTendonSlackLength(self, val)

    def setPennationAngle(self, val):
        return _biorbd.Characteristics_setPennationAngle(self, val)

    def setStateMax(self, stateMax):
        return _biorbd.Characteristics_setStateMax(self, stateMax)

    def stateMax(self):
        return _biorbd.Characteristics_stateMax(self)

    def fatigueParameters(self, *args):
        return _biorbd.Characteristics_fatigueParameters(self, *args)

# Register Characteristics in _biorbd:
_biorbd.Characteristics_swigregister(Characteristics)

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

    def __init__(self, fatigueRate=0, recoveryRate=0, developFactor=0, recoveryFactor=0):
        _biorbd.FatigueParameters_swiginit(self, _biorbd.new_FatigueParameters(fatigueRate, recoveryRate, developFactor, recoveryFactor))

    def DeepCopy(self, *args):
        return _biorbd.FatigueParameters_DeepCopy(self, *args)

    def fatigueRate(self, *args):
        return _biorbd.FatigueParameters_fatigueRate(self, *args)

    def recoveryRate(self, *args):
        return _biorbd.FatigueParameters_recoveryRate(self, *args)

    def developFactor(self, *args):
        return _biorbd.FatigueParameters_developFactor(self, *args)

    def recoveryFactor(self, *args):
        return _biorbd.FatigueParameters_recoveryFactor(self, *args)
    __swig_destroy__ = _biorbd.delete_FatigueParameters

# Register FatigueParameters in _biorbd:
_biorbd.FatigueParameters_swigregister(FatigueParameters)

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

    def __init__(self, *args):
        _biorbd.FatigueState_swiginit(self, _biorbd.new_FatigueState(*args))
    __swig_destroy__ = _biorbd.delete_FatigueState

    def DeepCopy(self, *args):
        return _biorbd.FatigueState_DeepCopy(self, *args)

    def setState(self, active, fatigued, resting):
        return _biorbd.FatigueState_setState(self, active, fatigued, resting)

    def activeFibers(self):
        return _biorbd.FatigueState_activeFibers(self)

    def fatiguedFibers(self):
        return _biorbd.FatigueState_fatiguedFibers(self)

    def restingFibers(self):
        return _biorbd.FatigueState_restingFibers(self)

    def getType(self):
        return _biorbd.FatigueState_getType(self)

# Register FatigueState in _biorbd:
_biorbd.FatigueState_swigregister(FatigueState)

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

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

    def DeepCopy(self, other):
        return _biorbd.FatigueDynamicState_DeepCopy(self, other)

    def activeFibersDot(self):
        return _biorbd.FatigueDynamicState_activeFibersDot(self)

    def fatiguedFibersDot(self):
        return _biorbd.FatigueDynamicState_fatiguedFibersDot(self)

    def restingFibersDot(self):
        return _biorbd.FatigueDynamicState_restingFibersDot(self)

    def timeDerivativeState(self, emg, characteristics):
        return _biorbd.FatigueDynamicState_timeDerivativeState(self, emg, characteristics)
    __swig_destroy__ = _biorbd.delete_FatigueDynamicState

# Register FatigueDynamicState in _biorbd:
_biorbd.FatigueDynamicState_swigregister(FatigueDynamicState)

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

    def __init__(self, *args):
        _biorbd.FatigueDynamicStateXia_swiginit(self, _biorbd.new_FatigueDynamicStateXia(*args))

    def timeDerivativeState(self, emg, characteristics):
        return _biorbd.FatigueDynamicStateXia_timeDerivativeState(self, emg, characteristics)

    @staticmethod
    def DeepCopy(*args):
        return _biorbd.FatigueDynamicStateXia_DeepCopy(*args)
    __swig_destroy__ = _biorbd.delete_FatigueDynamicStateXia

# Register FatigueDynamicStateXia in _biorbd:
_biorbd.FatigueDynamicStateXia_swigregister(FatigueDynamicStateXia)

def FatigueDynamicStateXia_DeepCopy(*args):
    return _biorbd.FatigueDynamicStateXia_DeepCopy(*args)

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

    def __init__(self, *args):
        _biorbd.Geometry_swiginit(self, _biorbd.new_Geometry(*args))

    def DeepCopy(self, *args):
        return _biorbd.Geometry_DeepCopy(self, *args)

    def updateKinematics(self, *args):
        return _biorbd.Geometry_updateKinematics(self, *args)

    def originInLocal(self):
        return _biorbd.Geometry_originInLocal(self)

    def setOriginInLocal(self, val):
        return _biorbd.Geometry_setOriginInLocal(self, val)

    def insertionInLocal(self):
        return _biorbd.Geometry_insertionInLocal(self)

    def setInsertionInLocal(self, val):
        return _biorbd.Geometry_setInsertionInLocal(self, val)

    def originInGlobal(self):
        return _biorbd.Geometry_originInGlobal(self)

    def insertionInGlobal(self):
        return _biorbd.Geometry_insertionInGlobal(self)

    def musclesPointsInGlobal(self):
        return _biorbd.Geometry_musclesPointsInGlobal(self)

    def length(self):
        return _biorbd.Geometry_length(self)

    def musculoTendonLength(self):
        return _biorbd.Geometry_musculoTendonLength(self)

    def velocity(self):
        return _biorbd.Geometry_velocity(self)

    def jacobianOrigin(self):
        return _biorbd.Geometry_jacobianOrigin(self)

    def jacobianInsertion(self):
        return _biorbd.Geometry_jacobianInsertion(self)

    def jacobian(self, *args):
        return _biorbd.Geometry_jacobian(self, *args)

    def jacobianLength(self):
        return _biorbd.Geometry_jacobianLength(self)
    __swig_destroy__ = _biorbd.delete_Geometry

# Register Geometry in _biorbd:
_biorbd.Geometry_swigregister(Geometry)

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

    def __init__(self, *args):
        _biorbd.State_swiginit(self, _biorbd.new_State(*args))
    __swig_destroy__ = _biorbd.delete_State

    def DeepCopy(self, *args):
        return _biorbd.State_DeepCopy(self, *args)

    def setExcitation(self, val):
        return _biorbd.State_setExcitation(self, val)

    def setActivation(self, val):
        return _biorbd.State_setActivation(self, val)

    def excitation(self):
        return _biorbd.State_excitation(self)

    def activation(self):
        return _biorbd.State_activation(self)

    def type(self):
        return _biorbd.State_type(self)

# Register State in _biorbd:
_biorbd.State_swigregister(State)

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

    def __init__(self, *args):
        _biorbd.StateDynamics_swiginit(self, _biorbd.new_StateDynamics(*args))
    __swig_destroy__ = _biorbd.delete_StateDynamics

    def DeepCopy(self, *args):
        return _biorbd.StateDynamics_DeepCopy(self, *args)

    def setExcitation(self, val):
        return _biorbd.StateDynamics_setExcitation(self, val)

    def setActivation(self, val):
        return _biorbd.StateDynamics_setActivation(self, val)

    def excitationNorm(self, *args):
        return _biorbd.StateDynamics_excitationNorm(self, *args)

    def setExcitationNorm(self, val):
        return _biorbd.StateDynamics_setExcitationNorm(self, val)

    def previousActivation(self):
        return _biorbd.StateDynamics_previousActivation(self)

    def previousExcitation(self):
        return _biorbd.StateDynamics_previousExcitation(self)

    def timeDerivativeActivation(self, *args):
        return _biorbd.StateDynamics_timeDerivativeActivation(self, *args)

# Register StateDynamics in _biorbd:
_biorbd.StateDynamics_swigregister(StateDynamics)

class Model(Joints, Markers, Contacts, Muscles):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _biorbd.delete_Model

    def __init__(self, *args):
        _biorbd.Model_swiginit(self, _biorbd.new_Model(*args))

    def InverseKinematics(self, Mark, Qinit, Q, removeAxes=True):
        return _biorbd.Model_InverseKinematics(self, Mark, Qinit, Q, removeAxes)

    def InverseDynamics(self, Q, QDot, QDDot):
        return _biorbd.Model_InverseDynamics(self, Q, QDot, QDDot)

    def ForwardDynamics(self, Q, QDot, GeneralizedTorque):
        return _biorbd.Model_ForwardDynamics(self, Q, QDot, GeneralizedTorque)

    def ForwardDynamicsLagrangian(self, Q, QDot, GeneralizedTorque):
        return _biorbd.Model_ForwardDynamicsLagrangian(self, Q, QDot, GeneralizedTorque)

    def ForwardDynamicsConstraintsDirect(self, *args):
        return _biorbd.Model_ForwardDynamicsConstraintsDirect(self, *args)

    def muscularJointTorque(self, state, Q, QDot):
        return _biorbd.Model_muscularJointTorque(self, state, Q, QDot)

# Register Model in _biorbd:
_biorbd.Model_swigregister(Model)



