# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# 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__)


BIORBD_VERSION = _biorbd.BIORBD_VERSION
EIGEN3 = _biorbd.EIGEN3
CASADI = _biorbd.CASADI

def currentLinearAlgebraBackend():
    return _biorbd.currentLinearAlgebraBackend()
M_PI = _biorbd.M_PI
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 VecStdString(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.VecStdString_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.VecStdString_swiginit(self, _biorbd.new_VecStdString(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.VecStdString_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecStdString

# Register VecStdString in _biorbd:
_biorbd.VecStdString_swigregister(VecStdString)

class VecBiorbdString(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.VecBiorbdString_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.VecBiorbdString_swiginit(self, _biorbd.new_VecBiorbdString(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.VecBiorbdString_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecBiorbdString

# Register VecBiorbdString in _biorbd:
_biorbd.VecBiorbdString_swigregister(VecBiorbdString)

class PairBiorbdString(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.PairBiorbdString_swiginit(self, _biorbd.new_PairBiorbdString(*args))
    first = property(_biorbd.PairBiorbdString_first_get, _biorbd.PairBiorbdString_first_set)
    second = property(_biorbd.PairBiorbdString_second_get, _biorbd.PairBiorbdString_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _biorbd.delete_PairBiorbdString

# Register PairBiorbdString in _biorbd:
_biorbd.PairBiorbdString_swigregister(PairBiorbdString)

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 VecBiorbdSpatialVector(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.VecBiorbdSpatialVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.VecBiorbdSpatialVector_swiginit(self, _biorbd.new_VecBiorbdSpatialVector(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.VecBiorbdSpatialVector_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecBiorbdSpatialVector

# Register VecBiorbdSpatialVector in _biorbd:
_biorbd.VecBiorbdSpatialVector_swigregister(VecBiorbdSpatialVector)

class MatBiorbdMatrix(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.MatBiorbdMatrix_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.MatBiorbdMatrix_swiginit(self, _biorbd.new_MatBiorbdMatrix(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.MatBiorbdMatrix_capacity(self)
    __swig_destroy__ = _biorbd.delete_MatBiorbdMatrix

# Register MatBiorbdMatrix in _biorbd:
_biorbd.MatBiorbdMatrix_swigregister(MatBiorbdMatrix)

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 VecBiorbdRototation(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.VecBiorbdRototation_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.VecBiorbdRototation_swiginit(self, _biorbd.new_VecBiorbdRototation(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.VecBiorbdRototation_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecBiorbdRototation

# Register VecBiorbdRototation in _biorbd:
_biorbd.VecBiorbdRototation_swigregister(VecBiorbdRototation)

class MatBiorbdRototation(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.MatBiorbdRototation_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.MatBiorbdRototation_swiginit(self, _biorbd.new_MatBiorbdRototation(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.MatBiorbdRototation_capacity(self)
    __swig_destroy__ = _biorbd.delete_MatBiorbdRototation

# Register MatBiorbdRototation in _biorbd:
_biorbd.MatBiorbdRototation_swigregister(MatBiorbdRototation)

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)

class VecBiorbdRange(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.VecBiorbdRange_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.VecBiorbdRange_swiginit(self, _biorbd.new_VecBiorbdRange(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.VecBiorbdRange_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecBiorbdRange

# Register VecBiorbdRange in _biorbd:
_biorbd.VecBiorbdRange_swigregister(VecBiorbdRange)

class MatBiorbdRange(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.MatBiorbdRange_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.MatBiorbdRange_swiginit(self, _biorbd.new_MatBiorbdRange(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.MatBiorbdRange_capacity(self)
    __swig_destroy__ = _biorbd.delete_MatBiorbdRange

# Register MatBiorbdRange in _biorbd:
_biorbd.MatBiorbdRange_swigregister(MatBiorbdRange)

VECTOR3D = _biorbd.VECTOR3D
BONE_POINT = _biorbd.BONE_POINT
ROTOTRANS = _biorbd.ROTOTRANS
SEGMENT = _biorbd.SEGMENT
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

    @staticmethod
    def removeTrailing(origin, trailTag):
        return _biorbd.String_removeTrailing(origin, trailTag)

    def to_string(self, *args):
        return _biorbd.String_to_string(self, *args)

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

def String_removeTrailing(origin, trailTag):
    return _biorbd.String_removeTrailing(origin, trailTag)

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(path):
        return _biorbd.Path_isFileExist(path)

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

    @staticmethod
    def isFolderExist(path):
        return _biorbd.Path_isFolderExist(path)

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

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

    def relativePath(self):
        return _biorbd.Path_relativePath(self)

    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 setFilename(self, name):
        return _biorbd.Path_setFilename(self, name)

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

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

    def extension(self):
        return _biorbd.Path_extension(self)
    __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(path):
    return _biorbd.Path_isFileExist(path)

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

def Path_currentDir():
    return _biorbd.Path_currentDir()

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

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

class Scalar(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.Scalar_swiginit(self, _biorbd.new_Scalar(*args))

    def to_mx(self):
        return _biorbd.Scalar_to_mx(self)
    __swig_destroy__ = _biorbd.delete_Scalar

# Register Scalar in _biorbd:
_biorbd.Scalar_swigregister(Scalar)

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 to_mx(self):
        return _biorbd.Vector_to_mx(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 to_mx(self):
        return _biorbd.Matrix_to_mx(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 setKStab(self, newKStab):
        return _biorbd.Quaternion_setKStab(self, newKStab)

    def kStab(self):
        return _biorbd.Quaternion_kStab(self)

    def __mul__(self, *args):
        return _biorbd.Quaternion___mul__(self, *args)

    def __add__(self, other):
        return _biorbd.Quaternion___add__(self, other)

    def __sub__(self, other):
        return _biorbd.Quaternion___sub__(self, other)

    @staticmethod
    def fromGLRotate(angle, x, y, z, kStab=1):
        return _biorbd.Quaternion_fromGLRotate(angle, x, y, z, kStab)

    @staticmethod
    def fromAxisAngle(angle, axis, kStab=1):
        return _biorbd.Quaternion_fromAxisAngle(angle, axis, kStab)

    @staticmethod
    def fromMatrix(*args):
        return _biorbd.Quaternion_fromMatrix(*args)

    @staticmethod
    def fromZYXAngles(zyx_angles, kStab=1):
        return _biorbd.Quaternion_fromZYXAngles(zyx_angles, kStab)

    @staticmethod
    def fromYXZAngles(yxz_angles, kStab=1):
        return _biorbd.Quaternion_fromYXZAngles(yxz_angles, kStab)

    @staticmethod
    def fromXYZAngles(xyz_angles, kStab=1):
        return _biorbd.Quaternion_fromXYZAngles(xyz_angles, kStab)

    def toMatrix(self, skipAsserts=False):
        return _biorbd.Quaternion_toMatrix(self, skipAsserts)

    def conjugate(self):
        return _biorbd.Quaternion_conjugate(self)

    def timeStep(self, omega, dt):
        return _biorbd.Quaternion_timeStep(self, omega, dt)

    def rotate(self, vec):
        return _biorbd.Quaternion_rotate(self, vec)

    def omegaToQDot(self, omega):
        return _biorbd.Quaternion_omegaToQDot(self, omega)

    def eulerDotToOmega(self, eulerDot, euler, seq):
        return _biorbd.Quaternion_eulerDotToOmega(self, eulerDot, euler, seq)

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

    def normalize(self):
        return _biorbd.Quaternion_normalize(self)

    def to_mx(self):
        return _biorbd.Quaternion_to_mx(self)
    __swig_destroy__ = _biorbd.delete_Quaternion

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

def Quaternion_fromGLRotate(angle, x, y, z, kStab=1):
    return _biorbd.Quaternion_fromGLRotate(angle, x, y, z, kStab)

def Quaternion_fromAxisAngle(angle, axis, kStab=1):
    return _biorbd.Quaternion_fromAxisAngle(angle, axis, kStab)

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

def Quaternion_fromZYXAngles(zyx_angles, kStab=1):
    return _biorbd.Quaternion_fromZYXAngles(zyx_angles, kStab)

def Quaternion_fromYXZAngles(yxz_angles, kStab=1):
    return _biorbd.Quaternion_fromYXZAngles(yxz_angles, kStab)

def Quaternion_fromXYZAngles(xyz_angles, kStab=1):
    return _biorbd.Quaternion_fromXYZAngles(xyz_angles, kStab)

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 setName(self, name):
        return _biorbd.Node_setName(self, name)

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

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

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

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

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

class Vector3d(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.Vector3d_swiginit(self, _biorbd.new_Vector3d(*args))

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

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

    def setPosition(self, v):
        return _biorbd.Vector3d_setPosition(self, v)

    def to_mx(self):
        return _biorbd.Vector3d_to_mx(self)
    __swig_destroy__ = _biorbd.delete_Vector3d

# Register Vector3d in _biorbd:
_biorbd.Vector3d_swigregister(Vector3d)

class SpatialVector(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.SpatialVector_swiginit(self, _biorbd.new_SpatialVector(*args))

    def to_mx(self):
        return _biorbd.SpatialVector_to_mx(self)
    __swig_destroy__ = _biorbd.delete_SpatialVector

# Register SpatialVector in _biorbd:
_biorbd.SpatialVector_swigregister(SpatialVector)

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))

    @staticmethod
    def fromMarkers(origin, axis1markers, axis2markers, axesNames, axisToRecalculate):
        return _biorbd.RotoTrans_fromMarkers(origin, axis1markers, axis2markers, axesNames, axisToRecalculate)

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

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

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

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

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

    @staticmethod
    def fromSpatialTransform(st):
        return _biorbd.RotoTrans_fromSpatialTransform(st)

    @staticmethod
    def fromEulerAngles(rot, trans, seq):
        return _biorbd.RotoTrans_fromEulerAngles(rot, trans, seq)

    @staticmethod
    def toEulerAngles(rt, seq):
        return _biorbd.RotoTrans_toEulerAngles(rt, seq)

    def to_mx(self):
        return _biorbd.RotoTrans_to_mx(self)
    __swig_destroy__ = _biorbd.delete_RotoTrans

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

def RotoTrans_fromMarkers(origin, axis1markers, axis2markers, axesNames, axisToRecalculate):
    return _biorbd.RotoTrans_fromMarkers(origin, axis1markers, axis2markers, axesNames, axisToRecalculate)

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

def RotoTrans_fromSpatialTransform(st):
    return _biorbd.RotoTrans_fromSpatialTransform(st)

def RotoTrans_fromEulerAngles(rot, trans, seq):
    return _biorbd.RotoTrans_fromEulerAngles(rot, trans, seq)

def RotoTrans_toEulerAngles(rt, seq):
    return _biorbd.RotoTrans_toEulerAngles(rt, seq)

class Rotation(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.Rotation_swiginit(self, _biorbd.new_Rotation(*args))

    def axe(self, idx):
        return _biorbd.Rotation_axe(self, idx)

    @staticmethod
    def fromSpatialTransform(st):
        return _biorbd.Rotation_fromSpatialTransform(st)

    @staticmethod
    def fromEulerAngles(rot, seq):
        return _biorbd.Rotation_fromEulerAngles(rot, seq)

    @staticmethod
    def fromMarkersNonNormalized(axis1markers, axis2markers, axesNames, axisToRecalculate):
        return _biorbd.Rotation_fromMarkersNonNormalized(axis1markers, axis2markers, axesNames, axisToRecalculate)

    @staticmethod
    def fromMarkers(axis1markers, axis2markers, axesNames, axisToRecalculate):
        return _biorbd.Rotation_fromMarkers(axis1markers, axis2markers, axesNames, axisToRecalculate)

    @staticmethod
    def toEulerAngles(r, seq):
        return _biorbd.Rotation_toEulerAngles(r, seq)

    def to_mx(self):
        return _biorbd.Rotation_to_mx(self)

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

    def __mul__(self, other):
        return _biorbd.Rotation___mul__(self, other)
    __swig_destroy__ = _biorbd.delete_Rotation

# Register Rotation in _biorbd:
_biorbd.Rotation_swigregister(Rotation)

def Rotation_fromSpatialTransform(st):
    return _biorbd.Rotation_fromSpatialTransform(st)

def Rotation_fromEulerAngles(rot, seq):
    return _biorbd.Rotation_fromEulerAngles(rot, seq)

def Rotation_fromMarkersNonNormalized(axis1markers, axis2markers, axesNames, axisToRecalculate):
    return _biorbd.Rotation_fromMarkersNonNormalized(axis1markers, axis2markers, axesNames, axisToRecalculate)

def Rotation_fromMarkers(axis1markers, axis2markers, axesNames, axisToRecalculate):
    return _biorbd.Rotation_fromMarkers(axis1markers, axis2markers, axesNames, axisToRecalculate)

def Rotation_toEulerAngles(r, seq):
    return _biorbd.Rotation_toEulerAngles(r, seq)

class Range(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, min=-3.14159265358979323846, max=3.14159265358979323846):
        _biorbd.Range_swiginit(self, _biorbd.new_Range(min, max))

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

    def setMin(self, min):
        return _biorbd.Range_setMin(self, min)

    def min(self):
        return _biorbd.Range_min(self)

    def setMax(self, max):
        return _biorbd.Range_setMax(self, max)

    def max(self):
        return _biorbd.Range_max(self)
    __swig_destroy__ = _biorbd.delete_Range

# Register Range in _biorbd:
_biorbd.Range_swigregister(Range)

class RotoTransNode(RotoTrans, 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.RotoTransNode_swiginit(self, _biorbd.new_RotoTransNode(*args))

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

    def __mul__(self, other):
        return _biorbd.RotoTransNode___mul__(self, other)
    __swig_destroy__ = _biorbd.delete_RotoTransNode

# Register RotoTransNode in _biorbd:
_biorbd.RotoTransNode_swigregister(RotoTransNode)


def __mul__(other, me):
    return _biorbd.__mul__(other, me)
class Timer(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, startNow=False):
        _biorbd.Timer_swiginit(self, _biorbd.new_Timer(startNow))

    def start(self):
        return _biorbd.Timer_start(self)

    def isStarted(self):
        return _biorbd.Timer_isStarted(self)

    def pause(self):
        return _biorbd.Timer_pause(self)

    def resume(self):
        return _biorbd.Timer_resume(self)

    def getLap(self):
        return _biorbd.Timer_getLap(self)

    def stop(self):
        return _biorbd.Timer_stop(self)
    __swig_destroy__ = _biorbd.delete_Timer

# Register Timer in _biorbd:
_biorbd.Timer_swigregister(Timer)

class Benchmark(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.Benchmark_swiginit(self, _biorbd.new_Benchmark())

    def startTimer(self, name, force=False):
        return _biorbd.Benchmark_startTimer(self, name, force)

    def pauseTimer(self, name):
        return _biorbd.Benchmark_pauseTimer(self, name)

    def resumeTimer(self, name):
        return _biorbd.Benchmark_resumeTimer(self, name)

    def getLap(self, name):
        return _biorbd.Benchmark_getLap(self, name)

    def stopTimer(self, name):
        return _biorbd.Benchmark_stopTimer(self, name)

    @staticmethod
    def wasteTime(timeInSec):
        return _biorbd.Benchmark_wasteTime(timeInSec)

    def addTimer(self, name):
        return _biorbd.Benchmark_addTimer(self, name)

    def getTimerIdx(self, name):
        return _biorbd.Benchmark_getTimerIdx(self, name)
    __swig_destroy__ = _biorbd.delete_Benchmark

# Register Benchmark in _biorbd:
_biorbd.Benchmark_swigregister(Benchmark)

def Benchmark_wasteTime(timeInSec):
    return _biorbd.Benchmark_wasteTime(timeInSec)

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 PairBiorbdGeneralizedTorque(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.PairBiorbdGeneralizedTorque_swiginit(self, _biorbd.new_PairBiorbdGeneralizedTorque(*args))
    first = property(_biorbd.PairBiorbdGeneralizedTorque_first_get, _biorbd.PairBiorbdGeneralizedTorque_first_set)
    second = property(_biorbd.PairBiorbdGeneralizedTorque_second_get, _biorbd.PairBiorbdGeneralizedTorque_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _biorbd.delete_PairBiorbdGeneralizedTorque

# Register PairBiorbdGeneralizedTorque in _biorbd:
_biorbd.PairBiorbdGeneralizedTorque_swigregister(PairBiorbdGeneralizedTorque)

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 VecBiorbdGeneralizedVelocity(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.VecBiorbdGeneralizedVelocity_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.VecBiorbdGeneralizedVelocity_swiginit(self, _biorbd.new_VecBiorbdGeneralizedVelocity(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.VecBiorbdGeneralizedVelocity_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecBiorbdGeneralizedVelocity

# Register VecBiorbdGeneralizedVelocity in _biorbd:
_biorbd.VecBiorbdGeneralizedVelocity_swigregister(VecBiorbdGeneralizedVelocity)

class MatBiorbdGeneralizedVelocity(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.MatBiorbdGeneralizedVelocity_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.MatBiorbdGeneralizedVelocity_swiginit(self, _biorbd.new_MatBiorbdGeneralizedVelocity(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.MatBiorbdGeneralizedVelocity_capacity(self)
    __swig_destroy__ = _biorbd.delete_MatBiorbdGeneralizedVelocity

# Register MatBiorbdGeneralizedVelocity in _biorbd:
_biorbd.MatBiorbdGeneralizedVelocity_swigregister(MatBiorbdGeneralizedVelocity)

class VecBiorbdGeneralizedAcceleration(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.VecBiorbdGeneralizedAcceleration_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.VecBiorbdGeneralizedAcceleration_swiginit(self, _biorbd.new_VecBiorbdGeneralizedAcceleration(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.VecBiorbdGeneralizedAcceleration_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecBiorbdGeneralizedAcceleration

# Register VecBiorbdGeneralizedAcceleration in _biorbd:
_biorbd.VecBiorbdGeneralizedAcceleration_swigregister(VecBiorbdGeneralizedAcceleration)

class MatBiorbdGeneralizedAcceleration(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.MatBiorbdGeneralizedAcceleration_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.MatBiorbdGeneralizedAcceleration_swiginit(self, _biorbd.new_MatBiorbdGeneralizedAcceleration(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.MatBiorbdGeneralizedAcceleration_capacity(self)
    __swig_destroy__ = _biorbd.delete_MatBiorbdGeneralizedAcceleration

# Register MatBiorbdGeneralizedAcceleration in _biorbd:
_biorbd.MatBiorbdGeneralizedAcceleration_swigregister(MatBiorbdGeneralizedAcceleration)

class VecBiorbdNodeSegment(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.VecBiorbdNodeSegment_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.VecBiorbdNodeSegment_swiginit(self, _biorbd.new_VecBiorbdNodeSegment(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.VecBiorbdNodeSegment_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecBiorbdNodeSegment

# Register VecBiorbdNodeSegment in _biorbd:
_biorbd.VecBiorbdNodeSegment_swigregister(VecBiorbdNodeSegment)

class MatBiorbdNodeSegment(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.MatBiorbdNodeSegment_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.MatBiorbdNodeSegment_swiginit(self, _biorbd.new_MatBiorbdNodeSegment(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.MatBiorbdNodeSegment_capacity(self)
    __swig_destroy__ = _biorbd.delete_MatBiorbdNodeSegment

# Register MatBiorbdNodeSegment in _biorbd:
_biorbd.MatBiorbdNodeSegment_swigregister(MatBiorbdNodeSegment)

class VecBiorbdMeshFace(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.VecBiorbdMeshFace_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.VecBiorbdMeshFace_swiginit(self, _biorbd.new_VecBiorbdMeshFace(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.VecBiorbdMeshFace_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecBiorbdMeshFace

# Register VecBiorbdMeshFace in _biorbd:
_biorbd.VecBiorbdMeshFace_swigregister(VecBiorbdMeshFace)

class MatBiorbdMeshFace(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.MatBiorbdMeshFace_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.MatBiorbdMeshFace_swiginit(self, _biorbd.new_MatBiorbdMeshFace(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.MatBiorbdMeshFace_capacity(self)
    __swig_destroy__ = _biorbd.delete_MatBiorbdMeshFace

# Register MatBiorbdMeshFace in _biorbd:
_biorbd.MatBiorbdMeshFace_swigregister(MatBiorbdMeshFace)

class PairBiorbdNodeSegment(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.PairBiorbdNodeSegment_swiginit(self, _biorbd.new_PairBiorbdNodeSegment(*args))
    first = property(_biorbd.PairBiorbdNodeSegment_first_get, _biorbd.PairBiorbdNodeSegment_first_set)
    second = property(_biorbd.PairBiorbdNodeSegment_second_get, _biorbd.PairBiorbdNodeSegment_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _biorbd.delete_PairBiorbdNodeSegment

# Register PairBiorbdNodeSegment in _biorbd:
_biorbd.PairBiorbdNodeSegment_swigregister(PairBiorbdNodeSegment)

class VecBiorbdIMU(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.VecBiorbdIMU_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.VecBiorbdIMU_swiginit(self, _biorbd.new_VecBiorbdIMU(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.VecBiorbdIMU_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecBiorbdIMU

# Register VecBiorbdIMU in _biorbd:
_biorbd.VecBiorbdIMU_swigregister(VecBiorbdIMU)

class MatBiorbdIMU(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.MatBiorbdIMU_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.MatBiorbdIMU_swiginit(self, _biorbd.new_MatBiorbdIMU(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.MatBiorbdIMU_capacity(self)
    __swig_destroy__ = _biorbd.delete_MatBiorbdIMU

# Register MatBiorbdIMU in _biorbd:
_biorbd.MatBiorbdIMU_swigregister(MatBiorbdIMU)

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 AddSegment(self, *args):
        return _biorbd.Joints_AddSegment(self, *args)

    def getGravity(self):
        return _biorbd.Joints_getGravity(self)

    def setGravity(self, newGravity):
        return _biorbd.Joints_setGravity(self, newGravity)

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

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

    def nbSegment(self):
        return _biorbd.Joints_nbSegment(self)

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

    def getDofIndex(self, SegmentName, dofName):
        return _biorbd.Joints_getDofIndex(self, SegmentName, 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 updateSegmentCharacteristics(self, idx, characteristics):
        return _biorbd.Joints_updateSegmentCharacteristics(self, idx, characteristics)

    def segment(self, *args):
        return _biorbd.Joints_segment(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 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 CoMbySegmentInMatrix(self, Q, updateKin=True):
        return _biorbd.Joints_CoMbySegmentInMatrix(self, Q, updateKin)

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

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

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

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

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

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

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

    def meshPointsInMatrix(self, Q, updateKin=True):
        return _biorbd.Joints_meshPointsInMatrix(self, Q, updateKin)

    def meshFaces(self, *args):
        return _biorbd.Joints_meshFaces(self, *args)

    def mesh(self, *args):
        return _biorbd.Joints_mesh(self, *args)

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

    def massMatrix(self, Q, updateKin=True):
        return _biorbd.Joints_massMatrix(self, Q, 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, segmentIdx, rotation, G, updateKin):
        return _biorbd.Joints_CalcMatRotJacobian(self, Q, segmentIdx, rotation, G, updateKin)

    def computeQdot(self, Q, QDot, k_stab=1):
        return _biorbd.Joints_computeQdot(self, Q, QDot, k_stab)

    def InverseDynamics(self, Q, QDot, QDDot, f_ext=None):
        return _biorbd.Joints_InverseDynamics(self, Q, QDot, QDDot, f_ext)

    def ForwardDynamics(self, Q, QDot, Tau, f_ext=None):
        return _biorbd.Joints_ForwardDynamics(self, Q, QDot, Tau, f_ext)

    def ContactForcesFromForwardDynamicsConstraintsDirect(self, Q, QDot, Tau, f_ext=None):
        return _biorbd.Joints_ContactForcesFromForwardDynamicsConstraintsDirect(self, Q, QDot, Tau, f_ext)

    def ForwardDynamicsConstraintsDirect(self, *args):
        return _biorbd.Joints_ForwardDynamicsConstraintsDirect(self, *args)

    def ComputeConstraintImpulsesDirect(self, Q, QDotPre):
        return _biorbd.Joints_ComputeConstraintImpulsesDirect(self, Q, QDotPre)

    def checkGeneralizedDimensions(self, Q=None, Qdot=None, Qddot=None, torque=None):
        return _biorbd.Joints_checkGeneralizedDimensions(self, Q, Qdot, Qddot, torque)

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

class Segment(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.Segment_swiginit(self, _biorbd.new_Segment(*args))

    def DeepCopy(self, *args):
        return _biorbd.Segment_DeepCopy(self, *args)
    __swig_destroy__ = _biorbd.delete_Segment

    def id(self):
        return _biorbd.Segment_id(self)

    def platformIdx(self):
        return _biorbd.Segment_platformIdx(self)

    def seqT(self):
        return _biorbd.Segment_seqT(self)

    def seqR(self):
        return _biorbd.Segment_seqR(self)

    def QRanges(self):
        return _biorbd.Segment_QRanges(self)

    def QDotRanges(self):
        return _biorbd.Segment_QDotRanges(self)

    def QDDotRanges(self):
        return _biorbd.Segment_QDDotRanges(self)

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

    def nbDofTrans(self):
        return _biorbd.Segment_nbDofTrans(self)

    def nbDofRot(self):
        return _biorbd.Segment_nbDofRot(self)

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

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

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

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

    def getDofIdx(self, dofName):
        return _biorbd.Segment_getDofIdx(self, dofName)

    def nameDof(self, i):
        return _biorbd.Segment_nameDof(self, i)

    def localJCS(self):
        return _biorbd.Segment_localJCS(self)

    def updateCharacteristics(self, model, characteristics):
        return _biorbd.Segment_updateCharacteristics(self, model, characteristics)

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

    def isRotationAQuaternion(self):
        return _biorbd.Segment_isRotationAQuaternion(self)

# Register Segment in _biorbd:
_biorbd.Segment_swigregister(Segment)

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 GeneralizedVelocity(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.GeneralizedVelocity_swiginit(self, _biorbd.new_GeneralizedVelocity(*args))
    __swig_destroy__ = _biorbd.delete_GeneralizedVelocity

# Register GeneralizedVelocity in _biorbd:
_biorbd.GeneralizedVelocity_swigregister(GeneralizedVelocity)

class GeneralizedAcceleration(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.GeneralizedAcceleration_swiginit(self, _biorbd.new_GeneralizedAcceleration(*args))
    __swig_destroy__ = _biorbd.delete_GeneralizedAcceleration

# Register GeneralizedAcceleration in _biorbd:
_biorbd.GeneralizedAcceleration_swigregister(GeneralizedAcceleration)

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, Q, Qdot, idx, removeAxis=True, updateKin=True):
        return _biorbd.Markers_markerVelocity(self, Q, Qdot, idx, removeAxis, updateKin)

    def markersVelocity(self, Q, Qdot, removeAxis=True, updateKin=True):
        return _biorbd.Markers_markersVelocity(self, Q, Qdot, removeAxis, updateKin)

    def markerAcceleration(self, *args):
        return _biorbd.Markers_markerAcceleration(self, *args)

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

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

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

    def nbMarkers(self, *args):
        return _biorbd.Markers_nbMarkers(self, *args)

    def nbTechnicalMarkers(self, *args):
        return _biorbd.Markers_nbTechnicalMarkers(self, *args)

    def nbAnatomicalMarkers(self):
        return _biorbd.Markers_nbAnatomicalMarkers(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 NodeSegment(Vector3d):
    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.NodeSegment_swiginit(self, _biorbd.new_NodeSegment(*args))

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

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

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

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

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

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

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

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

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

    def nbAxesToRemove(self):
        return _biorbd.NodeSegment_nbAxesToRemove(self)
    __swig_destroy__ = _biorbd.delete_NodeSegment

# Register NodeSegment in _biorbd:
_biorbd.NodeSegment_swigregister(NodeSegment)

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 nbContacts(self):
        return _biorbd.Contacts_nbContacts(self)

    def contactNames(self):
        return _biorbd.Contacts_contactNames(self)

    def contactName(self, i):
        return _biorbd.Contacts_contactName(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 Mesh(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.Mesh_swiginit(self, _biorbd.new_Mesh(*args))

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

    def addPoint(self, node):
        return _biorbd.Mesh_addPoint(self, node)

    def point(self, idx):
        return _biorbd.Mesh_point(self, idx)

    def nbVertex(self):
        return _biorbd.Mesh_nbVertex(self)

    def addFace(self, *args):
        return _biorbd.Mesh_addFace(self, *args)

    def faces(self):
        return _biorbd.Mesh_faces(self)

    def face(self, idx):
        return _biorbd.Mesh_face(self, idx)

    def nbFaces(self):
        return _biorbd.Mesh_nbFaces(self)

    def setPath(self, path):
        return _biorbd.Mesh_setPath(self, path)

    def path(self):
        return _biorbd.Mesh_path(self)
    __swig_destroy__ = _biorbd.delete_Mesh

# Register Mesh in _biorbd:
_biorbd.Mesh_swigregister(Mesh)

class MeshFace(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.MeshFace_swiginit(self, _biorbd.new_MeshFace(*args))

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

    def __call__(self, idx):
        return _biorbd.MeshFace___call__(self, idx)

    def setFace(self, *args):
        return _biorbd.MeshFace_setFace(self, *args)

    def faceAsDouble(self):
        return _biorbd.MeshFace_faceAsDouble(self)

    def face(self):
        return _biorbd.MeshFace_face(self)
    __swig_destroy__ = _biorbd.delete_MeshFace

# Register MeshFace in _biorbd:
_biorbd.MeshFace_swigregister(MeshFace)

class IMU(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.IMU_swiginit(self, _biorbd.new_IMU(*args))

    def __mul__(self, other):
        return _biorbd.IMU___mul__(self, other)

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

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

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

    def to_mx(self):
        return _biorbd.IMU_to_mx(self)
    __swig_destroy__ = _biorbd.delete_IMU

# Register IMU in _biorbd:
_biorbd.IMU_swigregister(IMU)

class IMUs(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.IMUs_swiginit(self, _biorbd.new_IMUs(*args))
    __swig_destroy__ = _biorbd.delete_IMUs

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

    def addIMU(self, *args):
        return _biorbd.IMUs_addIMU(self, *args)

    def nbIMUs(self):
        return _biorbd.IMUs_nbIMUs(self)

    def IMUsNames(self):
        return _biorbd.IMUs_IMUsNames(self)

    def technicalIMUsNames(self):
        return _biorbd.IMUs_technicalIMUsNames(self)

    def anatomicalIMUsNames(self):
        return _biorbd.IMUs_anatomicalIMUsNames(self)

    def IMU(self, *args):
        return _biorbd.IMUs_IMU(self, *args)

    def segmentIMU(self, Q, idx, updateKin=True):
        return _biorbd.IMUs_segmentIMU(self, Q, idx, updateKin)

    def nbTechIMUs(self):
        return _biorbd.IMUs_nbTechIMUs(self)

    def nbAnatIMUs(self):
        return _biorbd.IMUs_nbAnatIMUs(self)

    def technicalIMU(self, *args):
        return _biorbd.IMUs_technicalIMU(self, *args)

    def anatomicalIMU(self, *args):
        return _biorbd.IMUs_anatomicalIMU(self, *args)

    def IMUJacobian(self, Q, updateKin=True):
        return _biorbd.IMUs_IMUJacobian(self, Q, updateKin)

    def TechnicalIMUJacobian(self, Q, updateKin=True):
        return _biorbd.IMUs_TechnicalIMUJacobian(self, Q, updateKin)

# Register IMUs in _biorbd:
_biorbd.IMUs_swigregister(IMUs)

class RotoTransNodes(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.RotoTransNodes_swiginit(self, _biorbd.new_RotoTransNodes(*args))
    __swig_destroy__ = _biorbd.delete_RotoTransNodes

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

    def addRT(self, *args):
        return _biorbd.RotoTransNodes_addRT(self, *args)

    def nbRTs(self):
        return _biorbd.RotoTransNodes_nbRTs(self)

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

    def RTsNames(self):
        return _biorbd.RotoTransNodes_RTsNames(self)

    def RTs(self, *args):
        return _biorbd.RotoTransNodes_RTs(self, *args)

    def RT(self, *args):
        return _biorbd.RotoTransNodes_RT(self, *args)

    def segmentRTs(self, Q, idx, updateKin=True):
        return _biorbd.RotoTransNodes_segmentRTs(self, Q, idx, updateKin)

    def RTsJacobian(self, Q, updateKin=True):
        return _biorbd.RotoTransNodes_RTsJacobian(self, Q, updateKin)

# Register RotoTransNodes in _biorbd:
_biorbd.RotoTransNodes_swigregister(RotoTransNodes)

class SegmentCharacteristics(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.SegmentCharacteristics_swiginit(self, _biorbd.new_SegmentCharacteristics(*args))

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

    def setLength(self, val):
        return _biorbd.SegmentCharacteristics_setLength(self, val)

    def length(self):
        return _biorbd.SegmentCharacteristics_length(self)

    def setMass(self, newMass):
        return _biorbd.SegmentCharacteristics_setMass(self, newMass)

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

    def CoM(self):
        return _biorbd.SegmentCharacteristics_CoM(self)

    def setCoM(self, com):
        return _biorbd.SegmentCharacteristics_setCoM(self, com)

    def mesh(self):
        return _biorbd.SegmentCharacteristics_mesh(self)

    def inertia(self):
        return _biorbd.SegmentCharacteristics_inertia(self)
    __swig_destroy__ = _biorbd.delete_SegmentCharacteristics

# Register SegmentCharacteristics in _biorbd:
_biorbd.SegmentCharacteristics_swigregister(SegmentCharacteristics)

CONSTANT = _biorbd.CONSTANT
LINEAR = _biorbd.LINEAR
GAUSS3P = _biorbd.GAUSS3P
GAUSS6P = _biorbd.GAUSS6P
NO_TYPE = _biorbd.NO_TYPE
SIGMOIDGAUSS3P = _biorbd.SIGMOIDGAUSS3P

def TYPE_toStr(type):
    return _biorbd.TYPE_toStr(type)
class Actuator(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_Actuator

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

    def index(self):
        return _biorbd.Actuator_index(self)

    def direction(self):
        return _biorbd.Actuator_direction(self)

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

    def torqueMax(self):
        return _biorbd.Actuator_torqueMax(self)

# Register Actuator in _biorbd:
_biorbd.Actuator_swigregister(Actuator)

class Actuators(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.Actuators_swiginit(self, _biorbd.new_Actuators(*args))
    __swig_destroy__ = _biorbd.delete_Actuators

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

    def addActuator(self, a):
        return _biorbd.Actuators_addActuator(self, a)

    def closeActuator(self):
        return _biorbd.Actuators_closeActuator(self)

    def torqueMax(self, *args):
        return _biorbd.Actuators_torqueMax(self, *args)

    def torque(self, activation, Q, Qdot):
        return _biorbd.Actuators_torque(self, activation, Q, Qdot)

    def actuator(self, *args):
        return _biorbd.Actuators_actuator(self, *args)

    def nbActuators(self):
        return _biorbd.Actuators_nbActuators(self)

# Register Actuators in _biorbd:
_biorbd.Actuators_swigregister(Actuators)

class ActuatorConstant(Actuator):
    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.ActuatorConstant_swiginit(self, _biorbd.new_ActuatorConstant(*args))

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

    def torqueMax(self):
        return _biorbd.ActuatorConstant_torqueMax(self)
    __swig_destroy__ = _biorbd.delete_ActuatorConstant

# Register ActuatorConstant in _biorbd:
_biorbd.ActuatorConstant_swigregister(ActuatorConstant)

class ActuatorLinear(Actuator):
    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.ActuatorLinear_swiginit(self, _biorbd.new_ActuatorLinear(*args))
    __swig_destroy__ = _biorbd.delete_ActuatorLinear

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

    def torqueMax(self, *args):
        return _biorbd.ActuatorLinear_torqueMax(self, *args)

# Register ActuatorLinear in _biorbd:
_biorbd.ActuatorLinear_swigregister(ActuatorLinear)

class ActuatorGauss3p(Actuator):
    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.ActuatorGauss3p_swiginit(self, _biorbd.new_ActuatorGauss3p(*args))
    __swig_destroy__ = _biorbd.delete_ActuatorGauss3p

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

    def torqueMax(self, *args):
        return _biorbd.ActuatorGauss3p_torqueMax(self, *args)

# Register ActuatorGauss3p in _biorbd:
_biorbd.ActuatorGauss3p_swigregister(ActuatorGauss3p)

class ActuatorGauss6p(Actuator):
    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.ActuatorGauss6p_swiginit(self, _biorbd.new_ActuatorGauss6p(*args))
    __swig_destroy__ = _biorbd.delete_ActuatorGauss6p

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

    def torqueMax(self, *args):
        return _biorbd.ActuatorGauss6p_torqueMax(self, *args)

# Register ActuatorGauss6p in _biorbd:
_biorbd.ActuatorGauss6p_swigregister(ActuatorGauss6p)

class ActuatorSigmoidGauss3p(Actuator):
    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.ActuatorSigmoidGauss3p_swiginit(self, _biorbd.new_ActuatorSigmoidGauss3p(*args))
    __swig_destroy__ = _biorbd.delete_ActuatorSigmoidGauss3p

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

    def torqueMax(self, *args):
        return _biorbd.ActuatorSigmoidGauss3p_torqueMax(self, *args)

# Register ActuatorSigmoidGauss3p in _biorbd:
_biorbd.ActuatorSigmoidGauss3p_swigregister(ActuatorSigmoidGauss3p)

class VecBiorbdMuscleGroup(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.VecBiorbdMuscleGroup_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.VecBiorbdMuscleGroup_swiginit(self, _biorbd.new_VecBiorbdMuscleGroup(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.VecBiorbdMuscleGroup_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecBiorbdMuscleGroup

# Register VecBiorbdMuscleGroup in _biorbd:
_biorbd.VecBiorbdMuscleGroup_swigregister(VecBiorbdMuscleGroup)

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 VecSharedBiorbdMuscle(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.VecSharedBiorbdMuscle_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.VecSharedBiorbdMuscle_swiginit(self, _biorbd.new_VecSharedBiorbdMuscle(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.VecSharedBiorbdMuscle_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecSharedBiorbdMuscle

# Register VecSharedBiorbdMuscle in _biorbd:
_biorbd.VecSharedBiorbdMuscle_swigregister(VecSharedBiorbdMuscle)

class VecBiorbdMuscleState(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.VecBiorbdMuscleState_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.VecBiorbdMuscleState_swiginit(self, _biorbd.new_VecBiorbdMuscleState(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.VecBiorbdMuscleState_capacity(self)
    __swig_destroy__ = _biorbd.delete_VecBiorbdMuscleState

# Register VecBiorbdMuscleState in _biorbd:
_biorbd.VecBiorbdMuscleState_swigregister(VecBiorbdMuscleState)

class MatBiorbdMuscleState(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.MatBiorbdMuscleState_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _biorbd.MatBiorbdMuscleState_swiginit(self, _biorbd.new_MatBiorbdMuscleState(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _biorbd.MatBiorbdMuscleState_capacity(self)
    __swig_destroy__ = _biorbd.delete_MatBiorbdMuscleState

# Register MatBiorbdMuscleState in _biorbd:
_biorbd.MatBiorbdMuscleState_swigregister(MatBiorbdMuscleState)

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
DE_GROOTE = _biorbd.DE_GROOTE
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 setName(self, name):
        return _biorbd.Compound_setName(self, name)

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

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

    def pathModifier(self):
        return _biorbd.Compound_pathModifier(self)

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

    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 setPosition(self, positions):
        return _biorbd.Muscle_setPosition(self, positions)

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

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

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

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

    def setForceIsoMax(self, forceMax):
        return _biorbd.Muscle_setForceIsoMax(self, forceMax)

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

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

    def activationDot(self, state, alreadyNormalized=False):
        return _biorbd.Muscle_activationDot(self, state, alreadyNormalized)

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

class FatigueModel(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_FatigueModel

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

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

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

# Register FatigueModel in _biorbd:
_biorbd.FatigueModel_swigregister(FatigueModel)

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, FatigueModel):
    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 muscles(self):
        return _biorbd.Muscles_muscles(self)

    def muscle(self, idx):
        return _biorbd.Muscles_muscle(self, idx)

    def muscleNames(self):
        return _biorbd.Muscles_muscleNames(self)

    def muscleGroups(self, *args):
        return _biorbd.Muscles_muscleGroups(self, *args)

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

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

    def stateSet(self):
        return _biorbd.Muscles_stateSet(self)

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

    def activationDot(self, states, areadyNormalized=True):
        return _biorbd.Muscles_activationDot(self, states, areadyNormalized)

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

    def muscleForces(self, *args):
        return _biorbd.Muscles_muscleForces(self, *args)

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

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

    def nbMuscles(self):
        return _biorbd.Muscles_nbMuscles(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, muscle):
        return _biorbd.MuscleGroup_addMuscle(self, muscle)

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

    def muscles(self, *args):
        return _biorbd.MuscleGroup_muscles(self, *args)

    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 name(self):
        return _biorbd.MuscleGroup_name(self)

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

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

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

    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 setOptimalLength(self, val):
        return _biorbd.Characteristics_setOptimalLength(self, val)

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

    def setForceIsoMax(self, val):
        return _biorbd.Characteristics_setForceIsoMax(self, val)

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

    def setTendonSlackLength(self, val):
        return _biorbd.Characteristics_setTendonSlackLength(self, val)

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

    def setPennationAngle(self, val):
        return _biorbd.Characteristics_setPennationAngle(self, val)

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

    def setPCSA(self, val):
        return _biorbd.Characteristics_setPCSA(self, val)

    def PCSA(self):
        return _biorbd.Characteristics_PCSA(self)

    def setMinActivation(self, val):
        return _biorbd.Characteristics_setMinActivation(self, val)

    def minActivation(self):
        return _biorbd.Characteristics_minActivation(self)

    def setTorqueActivation(self, val):
        return _biorbd.Characteristics_setTorqueActivation(self, val)

    def torqueActivation(self):
        return _biorbd.Characteristics_torqueActivation(self)

    def setTorqueDeactivation(self, val):
        return _biorbd.Characteristics_setTorqueDeactivation(self, val)

    def torqueDeactivation(self):
        return _biorbd.Characteristics_torqueDeactivation(self)

    def setStateMax(self, emgMax):
        return _biorbd.Characteristics_setStateMax(self, emgMax)

    def stateMax(self):
        return _biorbd.Characteristics_stateMax(self)

    def setFatigueParameters(self, fatigueParameters):
        return _biorbd.Characteristics_setFatigueParameters(self, fatigueParameters)

    def fatigueParameters(self):
        return _biorbd.Characteristics_fatigueParameters(self)

# 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 setFatigueRate(self, fatigueRate):
        return _biorbd.FatigueParameters_setFatigueRate(self, fatigueRate)

    def fatigueRate(self):
        return _biorbd.FatigueParameters_fatigueRate(self)

    def setRecoveryRate(self, recoveryRate):
        return _biorbd.FatigueParameters_setRecoveryRate(self, recoveryRate)

    def recoveryRate(self):
        return _biorbd.FatigueParameters_recoveryRate(self)

    def setDevelopFactor(self, developFactor):
        return _biorbd.FatigueParameters_setDevelopFactor(self, developFactor)

    def developFactor(self):
        return _biorbd.FatigueParameters_developFactor(self)

    def setRecoveryFactor(self, recoveryFactor):
        return _biorbd.FatigueParameters_setRecoveryFactor(self, recoveryFactor)

    def recoveryFactor(self):
        return _biorbd.FatigueParameters_recoveryFactor(self)
    __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 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 setOrigin(self, position):
        return _biorbd.Geometry_setOrigin(self, position)

    def originInLocal(self):
        return _biorbd.Geometry_originInLocal(self)

    def setInsertionInLocal(self, position):
        return _biorbd.Geometry_setInsertionInLocal(self, position)

    def insertionInLocal(self):
        return _biorbd.Geometry_insertionInLocal(self)

    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 PathModifiers(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.PathModifiers_swiginit(self, _biorbd.new_PathModifiers())

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

    def addPathChanger(self, object):
        return _biorbd.PathModifiers_addPathChanger(self, object)

    def nbWraps(self):
        return _biorbd.PathModifiers_nbWraps(self)

    def nbVia(self):
        return _biorbd.PathModifiers_nbVia(self)

    def nbObjects(self):
        return _biorbd.PathModifiers_nbObjects(self)

    def object(self, *args):
        return _biorbd.PathModifiers_object(self, *args)
    __swig_destroy__ = _biorbd.delete_PathModifiers

# Register PathModifiers in _biorbd:
_biorbd.PathModifiers_swigregister(PathModifiers)

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, turnOffWarnings=False):
        return _biorbd.State_setExcitation(self, val, turnOffWarnings)

    def excitation(self):
        return _biorbd.State_excitation(self)

    def normalizeExcitation(self, emgMax, turnOffWarnings=False):
        return _biorbd.State_normalizeExcitation(self, emgMax, turnOffWarnings)

    def setExcitationNorm(self, val):
        return _biorbd.State_setExcitationNorm(self, val)

    def excitationNorm(self):
        return _biorbd.State_excitationNorm(self)

    def setActivation(self, val, turnOffWarnings=False):
        return _biorbd.State_setActivation(self, val, turnOffWarnings)

    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, turnOffWarnings=False):
        return _biorbd.StateDynamics_setExcitation(self, val, turnOffWarnings)

    def previousExcitation(self):
        return _biorbd.StateDynamics_previousExcitation(self)

    def setActivation(self, val, turnOffWarnings=False):
        return _biorbd.StateDynamics_setActivation(self, val, turnOffWarnings)

    def previousActivation(self):
        return _biorbd.StateDynamics_previousActivation(self)

    def timeDerivativeActivation(self, *args):
        return _biorbd.StateDynamics_timeDerivativeActivation(self, *args)

# Register StateDynamics in _biorbd:
_biorbd.StateDynamics_swigregister(StateDynamics)

class StateDynamicsBuchanan(StateDynamics):
    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.StateDynamicsBuchanan_swiginit(self, _biorbd.new_StateDynamicsBuchanan(*args))
    __swig_destroy__ = _biorbd.delete_StateDynamicsBuchanan

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

    def timeDerivativeExcitation(self, characteristics, alreadyNormalized):
        return _biorbd.StateDynamicsBuchanan_timeDerivativeExcitation(self, characteristics, alreadyNormalized)

    def setExcitation(self, val, turnOffWarnings=False):
        return _biorbd.StateDynamicsBuchanan_setExcitation(self, val, turnOffWarnings)

    def setNeuralCommand(self, val):
        return _biorbd.StateDynamicsBuchanan_setNeuralCommand(self, val)

    def shapeFactor(self, *args):
        return _biorbd.StateDynamicsBuchanan_shapeFactor(self, *args)

    def setActivation(self, notUsed, turnOffWarnings=False):
        return _biorbd.StateDynamicsBuchanan_setActivation(self, notUsed, turnOffWarnings)

# Register StateDynamicsBuchanan in _biorbd:
_biorbd.StateDynamicsBuchanan_swigregister(StateDynamicsBuchanan)


def getVersion():
    return _biorbd.getVersion()
class Model(Joints, Markers, IMUs, RotoTransNodes, Contacts, Actuators, Muscles):
    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.Model_swiginit(self, _biorbd.new_Model(*args))

    def path(self):
        return _biorbd.Model_path(self)
    __swig_destroy__ = _biorbd.delete_Model

# Register Model in _biorbd:
_biorbd.Model_swigregister(Model)

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

    @staticmethod
    def readModelFile(*args):
        return _biorbd.Reader_readModelFile(*args)

    @staticmethod
    def readMarkerDataFile(path):
        return _biorbd.Reader_readMarkerDataFile(path)

    @staticmethod
    def readQDataFile(path):
        return _biorbd.Reader_readQDataFile(path)

    @staticmethod
    def readActivationDataFile(path):
        return _biorbd.Reader_readActivationDataFile(path)

    @staticmethod
    def readTorqueDataFile(path):
        return _biorbd.Reader_readTorqueDataFile(path)

    @staticmethod
    def readGroundReactionForceDataFile(path):
        return _biorbd.Reader_readGroundReactionForceDataFile(path)

    @staticmethod
    def readViconForceFile(*args):
        return _biorbd.Reader_readViconForceFile(*args)

    @staticmethod
    def readViconMarkerFile(*args):
        return _biorbd.Reader_readViconMarkerFile(*args)

    @staticmethod
    def readMeshFileBiorbdSegments(path):
        return _biorbd.Reader_readMeshFileBiorbdSegments(path)

    @staticmethod
    def readMeshFilePly(path):
        return _biorbd.Reader_readMeshFilePly(path)

    @staticmethod
    def readMeshFileObj(path):
        return _biorbd.Reader_readMeshFileObj(path)

    @staticmethod
    def readMeshFileVtp(path):
        return _biorbd.Reader_readMeshFileVtp(path)

    def __init__(self):
        _biorbd.Reader_swiginit(self, _biorbd.new_Reader())
    __swig_destroy__ = _biorbd.delete_Reader

# Register Reader in _biorbd:
_biorbd.Reader_swigregister(Reader)

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

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

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

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

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

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

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

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

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

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

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

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

class Writer(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.Writer_swiginit(self, _biorbd.new_Writer())
    __swig_destroy__ = _biorbd.delete_Writer

# Register Writer in _biorbd:
_biorbd.Writer_swigregister(Writer)



