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





from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_almathswig', [dirname(__file__)])
        except ImportError:
            import _almathswig
            return _almathswig
        if fp is not None:
            try:
                _mod = imp.load_module('_almathswig', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _almathswig = swig_import_helper()
    del swig_import_helper
else:
    import _almathswig
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


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


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

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


class SwigPyIterator(_object):
    """Proxy of C++ swig::SwigPyIterator class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

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

    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _almathswig.SwigPyIterator_value(self)


    def incr(self, n=1):
        """
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        incr(SwigPyIterator self) -> SwigPyIterator
        """
        return _almathswig.SwigPyIterator_incr(self, n)


    def decr(self, n=1):
        """
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        decr(SwigPyIterator self) -> SwigPyIterator
        """
        return _almathswig.SwigPyIterator_decr(self, n)


    def distance(self, x):
        """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _almathswig.SwigPyIterator_distance(self, x)


    def equal(self, x):
        """equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _almathswig.SwigPyIterator_equal(self, x)


    def copy(self):
        """copy(SwigPyIterator self) -> SwigPyIterator"""
        return _almathswig.SwigPyIterator_copy(self)


    def next(self):
        """next(SwigPyIterator self) -> PyObject *"""
        return _almathswig.SwigPyIterator_next(self)


    def __next__(self):
        """__next__(SwigPyIterator self) -> PyObject *"""
        return _almathswig.SwigPyIterator___next__(self)


    def previous(self):
        """previous(SwigPyIterator self) -> PyObject *"""
        return _almathswig.SwigPyIterator_previous(self)


    def advance(self, n):
        """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _almathswig.SwigPyIterator_advance(self, n)


    def __eq__(self, x):
        """__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _almathswig.SwigPyIterator___eq__(self, x)


    def __ne__(self, x):
        """__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _almathswig.SwigPyIterator___ne__(self, x)


    def __iadd__(self, n):
        """__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _almathswig.SwigPyIterator___iadd__(self, n)


    def __isub__(self, n):
        """__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _almathswig.SwigPyIterator___isub__(self, n)


    def __add__(self, n):
        """__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _almathswig.SwigPyIterator___add__(self, n)


    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _almathswig.SwigPyIterator___sub__(self, *args)

    def __iter__(self):
        return self
SwigPyIterator_swigregister = _almathswig.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class vectorFloat(_object):
    """Proxy of C++ std::vector<(float)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vectorFloat, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vectorFloat, name)

    def iterator(self):
        """iterator(vectorFloat self) -> SwigPyIterator"""
        return _almathswig.vectorFloat_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(vectorFloat self) -> bool"""
        return _almathswig.vectorFloat___nonzero__(self)


    def __bool__(self):
        """__bool__(vectorFloat self) -> bool"""
        return _almathswig.vectorFloat___bool__(self)


    def __len__(self):
        """__len__(vectorFloat self) -> std::vector< float >::size_type"""
        return _almathswig.vectorFloat___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vectorFloat self, std::vector< float >::difference_type i, std::vector< float >::difference_type j) -> vectorFloat"""
        return _almathswig.vectorFloat___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vectorFloat self, std::vector< float >::difference_type i, std::vector< float >::difference_type j)
        __setslice__(vectorFloat self, std::vector< float >::difference_type i, std::vector< float >::difference_type j, vectorFloat v)
        """
        return _almathswig.vectorFloat___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vectorFloat self, std::vector< float >::difference_type i, std::vector< float >::difference_type j)"""
        return _almathswig.vectorFloat___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vectorFloat self, std::vector< float >::difference_type i)
        __delitem__(vectorFloat self, PySliceObject * slice)
        """
        return _almathswig.vectorFloat___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vectorFloat self, PySliceObject * slice) -> vectorFloat
        __getitem__(vectorFloat self, std::vector< float >::difference_type i) -> std::vector< float >::value_type const &
        """
        return _almathswig.vectorFloat___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vectorFloat self, PySliceObject * slice, vectorFloat v)
        __setitem__(vectorFloat self, PySliceObject * slice)
        __setitem__(vectorFloat self, std::vector< float >::difference_type i, std::vector< float >::value_type const & x)
        """
        return _almathswig.vectorFloat___setitem__(self, *args)


    def pop(self):
        """pop(vectorFloat self) -> std::vector< float >::value_type"""
        return _almathswig.vectorFloat_pop(self)


    def append(self, x):
        """append(vectorFloat self, std::vector< float >::value_type const & x)"""
        return _almathswig.vectorFloat_append(self, x)


    def empty(self):
        """empty(vectorFloat self) -> bool"""
        return _almathswig.vectorFloat_empty(self)


    def size(self):
        """size(vectorFloat self) -> std::vector< float >::size_type"""
        return _almathswig.vectorFloat_size(self)


    def swap(self, v):
        """swap(vectorFloat self, vectorFloat v)"""
        return _almathswig.vectorFloat_swap(self, v)


    def begin(self):
        """begin(vectorFloat self) -> std::vector< float >::iterator"""
        return _almathswig.vectorFloat_begin(self)


    def end(self):
        """end(vectorFloat self) -> std::vector< float >::iterator"""
        return _almathswig.vectorFloat_end(self)


    def rbegin(self):
        """rbegin(vectorFloat self) -> std::vector< float >::reverse_iterator"""
        return _almathswig.vectorFloat_rbegin(self)


    def rend(self):
        """rend(vectorFloat self) -> std::vector< float >::reverse_iterator"""
        return _almathswig.vectorFloat_rend(self)


    def clear(self):
        """clear(vectorFloat self)"""
        return _almathswig.vectorFloat_clear(self)


    def get_allocator(self):
        """get_allocator(vectorFloat self) -> std::vector< float >::allocator_type"""
        return _almathswig.vectorFloat_get_allocator(self)


    def pop_back(self):
        """pop_back(vectorFloat self)"""
        return _almathswig.vectorFloat_pop_back(self)


    def erase(self, *args):
        """
        erase(vectorFloat self, std::vector< float >::iterator pos) -> std::vector< float >::iterator
        erase(vectorFloat self, std::vector< float >::iterator first, std::vector< float >::iterator last) -> std::vector< float >::iterator
        """
        return _almathswig.vectorFloat_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(float)> self) -> vectorFloat
        __init__(std::vector<(float)> self, vectorFloat arg2) -> vectorFloat
        __init__(std::vector<(float)> self, std::vector< float >::size_type size) -> vectorFloat
        __init__(std::vector<(float)> self, std::vector< float >::size_type size, std::vector< float >::value_type const & value) -> vectorFloat
        """
        this = _almathswig.new_vectorFloat(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vectorFloat self, std::vector< float >::value_type const & x)"""
        return _almathswig.vectorFloat_push_back(self, x)


    def front(self):
        """front(vectorFloat self) -> std::vector< float >::value_type const &"""
        return _almathswig.vectorFloat_front(self)


    def back(self):
        """back(vectorFloat self) -> std::vector< float >::value_type const &"""
        return _almathswig.vectorFloat_back(self)


    def assign(self, n, x):
        """assign(vectorFloat self, std::vector< float >::size_type n, std::vector< float >::value_type const & x)"""
        return _almathswig.vectorFloat_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vectorFloat self, std::vector< float >::size_type new_size)
        resize(vectorFloat self, std::vector< float >::size_type new_size, std::vector< float >::value_type const & x)
        """
        return _almathswig.vectorFloat_resize(self, *args)


    def insert(self, *args):
        """
        insert(vectorFloat self, std::vector< float >::iterator pos, std::vector< float >::value_type const & x) -> std::vector< float >::iterator
        insert(vectorFloat self, std::vector< float >::iterator pos, std::vector< float >::size_type n, std::vector< float >::value_type const & x)
        """
        return _almathswig.vectorFloat_insert(self, *args)


    def reserve(self, n):
        """reserve(vectorFloat self, std::vector< float >::size_type n)"""
        return _almathswig.vectorFloat_reserve(self, n)


    def capacity(self):
        """capacity(vectorFloat self) -> std::vector< float >::size_type"""
        return _almathswig.vectorFloat_capacity(self)


    def __repr__(self):
        """__repr__(vectorFloat self) -> std::string"""
        return _almathswig.vectorFloat___repr__(self)

    __swig_destroy__ = _almathswig.delete_vectorFloat
    __del__ = lambda self: None
vectorFloat_swigregister = _almathswig.vectorFloat_swigregister
vectorFloat_swigregister(vectorFloat)

class vectorPosition2D(_object):
    """Proxy of C++ std::vector<(AL::Math::Position2D)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vectorPosition2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vectorPosition2D, name)

    def iterator(self):
        """iterator(vectorPosition2D self) -> SwigPyIterator"""
        return _almathswig.vectorPosition2D_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(vectorPosition2D self) -> bool"""
        return _almathswig.vectorPosition2D___nonzero__(self)


    def __bool__(self):
        """__bool__(vectorPosition2D self) -> bool"""
        return _almathswig.vectorPosition2D___bool__(self)


    def __len__(self):
        """__len__(vectorPosition2D self) -> std::vector< AL::Math::Position2D >::size_type"""
        return _almathswig.vectorPosition2D___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vectorPosition2D self, std::vector< AL::Math::Position2D >::difference_type i, std::vector< AL::Math::Position2D >::difference_type j) -> vectorPosition2D"""
        return _almathswig.vectorPosition2D___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vectorPosition2D self, std::vector< AL::Math::Position2D >::difference_type i, std::vector< AL::Math::Position2D >::difference_type j)
        __setslice__(vectorPosition2D self, std::vector< AL::Math::Position2D >::difference_type i, std::vector< AL::Math::Position2D >::difference_type j, vectorPosition2D v)
        """
        return _almathswig.vectorPosition2D___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vectorPosition2D self, std::vector< AL::Math::Position2D >::difference_type i, std::vector< AL::Math::Position2D >::difference_type j)"""
        return _almathswig.vectorPosition2D___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vectorPosition2D self, std::vector< AL::Math::Position2D >::difference_type i)
        __delitem__(vectorPosition2D self, PySliceObject * slice)
        """
        return _almathswig.vectorPosition2D___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vectorPosition2D self, PySliceObject * slice) -> vectorPosition2D
        __getitem__(vectorPosition2D self, std::vector< AL::Math::Position2D >::difference_type i) -> Position2D
        """
        return _almathswig.vectorPosition2D___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vectorPosition2D self, PySliceObject * slice, vectorPosition2D v)
        __setitem__(vectorPosition2D self, PySliceObject * slice)
        __setitem__(vectorPosition2D self, std::vector< AL::Math::Position2D >::difference_type i, Position2D x)
        """
        return _almathswig.vectorPosition2D___setitem__(self, *args)


    def pop(self):
        """pop(vectorPosition2D self) -> Position2D"""
        return _almathswig.vectorPosition2D_pop(self)


    def append(self, x):
        """append(vectorPosition2D self, Position2D x)"""
        return _almathswig.vectorPosition2D_append(self, x)


    def empty(self):
        """empty(vectorPosition2D self) -> bool"""
        return _almathswig.vectorPosition2D_empty(self)


    def size(self):
        """size(vectorPosition2D self) -> std::vector< AL::Math::Position2D >::size_type"""
        return _almathswig.vectorPosition2D_size(self)


    def swap(self, v):
        """swap(vectorPosition2D self, vectorPosition2D v)"""
        return _almathswig.vectorPosition2D_swap(self, v)


    def begin(self):
        """begin(vectorPosition2D self) -> std::vector< AL::Math::Position2D >::iterator"""
        return _almathswig.vectorPosition2D_begin(self)


    def end(self):
        """end(vectorPosition2D self) -> std::vector< AL::Math::Position2D >::iterator"""
        return _almathswig.vectorPosition2D_end(self)


    def rbegin(self):
        """rbegin(vectorPosition2D self) -> std::vector< AL::Math::Position2D >::reverse_iterator"""
        return _almathswig.vectorPosition2D_rbegin(self)


    def rend(self):
        """rend(vectorPosition2D self) -> std::vector< AL::Math::Position2D >::reverse_iterator"""
        return _almathswig.vectorPosition2D_rend(self)


    def clear(self):
        """clear(vectorPosition2D self)"""
        return _almathswig.vectorPosition2D_clear(self)


    def get_allocator(self):
        """get_allocator(vectorPosition2D self) -> std::vector< AL::Math::Position2D >::allocator_type"""
        return _almathswig.vectorPosition2D_get_allocator(self)


    def pop_back(self):
        """pop_back(vectorPosition2D self)"""
        return _almathswig.vectorPosition2D_pop_back(self)


    def erase(self, *args):
        """
        erase(vectorPosition2D self, std::vector< AL::Math::Position2D >::iterator pos) -> std::vector< AL::Math::Position2D >::iterator
        erase(vectorPosition2D self, std::vector< AL::Math::Position2D >::iterator first, std::vector< AL::Math::Position2D >::iterator last) -> std::vector< AL::Math::Position2D >::iterator
        """
        return _almathswig.vectorPosition2D_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(AL::Math::Position2D)> self) -> vectorPosition2D
        __init__(std::vector<(AL::Math::Position2D)> self, vectorPosition2D arg2) -> vectorPosition2D
        __init__(std::vector<(AL::Math::Position2D)> self, std::vector< AL::Math::Position2D >::size_type size) -> vectorPosition2D
        __init__(std::vector<(AL::Math::Position2D)> self, std::vector< AL::Math::Position2D >::size_type size, Position2D value) -> vectorPosition2D
        """
        this = _almathswig.new_vectorPosition2D(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vectorPosition2D self, Position2D x)"""
        return _almathswig.vectorPosition2D_push_back(self, x)


    def front(self):
        """front(vectorPosition2D self) -> Position2D"""
        return _almathswig.vectorPosition2D_front(self)


    def back(self):
        """back(vectorPosition2D self) -> Position2D"""
        return _almathswig.vectorPosition2D_back(self)


    def assign(self, n, x):
        """assign(vectorPosition2D self, std::vector< AL::Math::Position2D >::size_type n, Position2D x)"""
        return _almathswig.vectorPosition2D_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vectorPosition2D self, std::vector< AL::Math::Position2D >::size_type new_size)
        resize(vectorPosition2D self, std::vector< AL::Math::Position2D >::size_type new_size, Position2D x)
        """
        return _almathswig.vectorPosition2D_resize(self, *args)


    def insert(self, *args):
        """
        insert(vectorPosition2D self, std::vector< AL::Math::Position2D >::iterator pos, Position2D x) -> std::vector< AL::Math::Position2D >::iterator
        insert(vectorPosition2D self, std::vector< AL::Math::Position2D >::iterator pos, std::vector< AL::Math::Position2D >::size_type n, Position2D x)
        """
        return _almathswig.vectorPosition2D_insert(self, *args)


    def reserve(self, n):
        """reserve(vectorPosition2D self, std::vector< AL::Math::Position2D >::size_type n)"""
        return _almathswig.vectorPosition2D_reserve(self, n)


    def capacity(self):
        """capacity(vectorPosition2D self) -> std::vector< AL::Math::Position2D >::size_type"""
        return _almathswig.vectorPosition2D_capacity(self)


    def __repr__(self):
        """__repr__(vectorPosition2D self) -> std::string"""
        return _almathswig.vectorPosition2D___repr__(self)

    __swig_destroy__ = _almathswig.delete_vectorPosition2D
    __del__ = lambda self: None
vectorPosition2D_swigregister = _almathswig.vectorPosition2D_swigregister
vectorPosition2D_swigregister(vectorPosition2D)

class vectorPose2D(_object):
    """Proxy of C++ std::vector<(AL::Math::Pose2D)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vectorPose2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vectorPose2D, name)

    def iterator(self):
        """iterator(vectorPose2D self) -> SwigPyIterator"""
        return _almathswig.vectorPose2D_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(vectorPose2D self) -> bool"""
        return _almathswig.vectorPose2D___nonzero__(self)


    def __bool__(self):
        """__bool__(vectorPose2D self) -> bool"""
        return _almathswig.vectorPose2D___bool__(self)


    def __len__(self):
        """__len__(vectorPose2D self) -> std::vector< AL::Math::Pose2D >::size_type"""
        return _almathswig.vectorPose2D___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vectorPose2D self, std::vector< AL::Math::Pose2D >::difference_type i, std::vector< AL::Math::Pose2D >::difference_type j) -> vectorPose2D"""
        return _almathswig.vectorPose2D___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vectorPose2D self, std::vector< AL::Math::Pose2D >::difference_type i, std::vector< AL::Math::Pose2D >::difference_type j)
        __setslice__(vectorPose2D self, std::vector< AL::Math::Pose2D >::difference_type i, std::vector< AL::Math::Pose2D >::difference_type j, vectorPose2D v)
        """
        return _almathswig.vectorPose2D___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vectorPose2D self, std::vector< AL::Math::Pose2D >::difference_type i, std::vector< AL::Math::Pose2D >::difference_type j)"""
        return _almathswig.vectorPose2D___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vectorPose2D self, std::vector< AL::Math::Pose2D >::difference_type i)
        __delitem__(vectorPose2D self, PySliceObject * slice)
        """
        return _almathswig.vectorPose2D___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vectorPose2D self, PySliceObject * slice) -> vectorPose2D
        __getitem__(vectorPose2D self, std::vector< AL::Math::Pose2D >::difference_type i) -> Pose2D
        """
        return _almathswig.vectorPose2D___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vectorPose2D self, PySliceObject * slice, vectorPose2D v)
        __setitem__(vectorPose2D self, PySliceObject * slice)
        __setitem__(vectorPose2D self, std::vector< AL::Math::Pose2D >::difference_type i, Pose2D x)
        """
        return _almathswig.vectorPose2D___setitem__(self, *args)


    def pop(self):
        """pop(vectorPose2D self) -> Pose2D"""
        return _almathswig.vectorPose2D_pop(self)


    def append(self, x):
        """append(vectorPose2D self, Pose2D x)"""
        return _almathswig.vectorPose2D_append(self, x)


    def empty(self):
        """empty(vectorPose2D self) -> bool"""
        return _almathswig.vectorPose2D_empty(self)


    def size(self):
        """size(vectorPose2D self) -> std::vector< AL::Math::Pose2D >::size_type"""
        return _almathswig.vectorPose2D_size(self)


    def swap(self, v):
        """swap(vectorPose2D self, vectorPose2D v)"""
        return _almathswig.vectorPose2D_swap(self, v)


    def begin(self):
        """begin(vectorPose2D self) -> std::vector< AL::Math::Pose2D >::iterator"""
        return _almathswig.vectorPose2D_begin(self)


    def end(self):
        """end(vectorPose2D self) -> std::vector< AL::Math::Pose2D >::iterator"""
        return _almathswig.vectorPose2D_end(self)


    def rbegin(self):
        """rbegin(vectorPose2D self) -> std::vector< AL::Math::Pose2D >::reverse_iterator"""
        return _almathswig.vectorPose2D_rbegin(self)


    def rend(self):
        """rend(vectorPose2D self) -> std::vector< AL::Math::Pose2D >::reverse_iterator"""
        return _almathswig.vectorPose2D_rend(self)


    def clear(self):
        """clear(vectorPose2D self)"""
        return _almathswig.vectorPose2D_clear(self)


    def get_allocator(self):
        """get_allocator(vectorPose2D self) -> std::vector< AL::Math::Pose2D >::allocator_type"""
        return _almathswig.vectorPose2D_get_allocator(self)


    def pop_back(self):
        """pop_back(vectorPose2D self)"""
        return _almathswig.vectorPose2D_pop_back(self)


    def erase(self, *args):
        """
        erase(vectorPose2D self, std::vector< AL::Math::Pose2D >::iterator pos) -> std::vector< AL::Math::Pose2D >::iterator
        erase(vectorPose2D self, std::vector< AL::Math::Pose2D >::iterator first, std::vector< AL::Math::Pose2D >::iterator last) -> std::vector< AL::Math::Pose2D >::iterator
        """
        return _almathswig.vectorPose2D_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(AL::Math::Pose2D)> self) -> vectorPose2D
        __init__(std::vector<(AL::Math::Pose2D)> self, vectorPose2D arg2) -> vectorPose2D
        __init__(std::vector<(AL::Math::Pose2D)> self, std::vector< AL::Math::Pose2D >::size_type size) -> vectorPose2D
        __init__(std::vector<(AL::Math::Pose2D)> self, std::vector< AL::Math::Pose2D >::size_type size, Pose2D value) -> vectorPose2D
        """
        this = _almathswig.new_vectorPose2D(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vectorPose2D self, Pose2D x)"""
        return _almathswig.vectorPose2D_push_back(self, x)


    def front(self):
        """front(vectorPose2D self) -> Pose2D"""
        return _almathswig.vectorPose2D_front(self)


    def back(self):
        """back(vectorPose2D self) -> Pose2D"""
        return _almathswig.vectorPose2D_back(self)


    def assign(self, n, x):
        """assign(vectorPose2D self, std::vector< AL::Math::Pose2D >::size_type n, Pose2D x)"""
        return _almathswig.vectorPose2D_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vectorPose2D self, std::vector< AL::Math::Pose2D >::size_type new_size)
        resize(vectorPose2D self, std::vector< AL::Math::Pose2D >::size_type new_size, Pose2D x)
        """
        return _almathswig.vectorPose2D_resize(self, *args)


    def insert(self, *args):
        """
        insert(vectorPose2D self, std::vector< AL::Math::Pose2D >::iterator pos, Pose2D x) -> std::vector< AL::Math::Pose2D >::iterator
        insert(vectorPose2D self, std::vector< AL::Math::Pose2D >::iterator pos, std::vector< AL::Math::Pose2D >::size_type n, Pose2D x)
        """
        return _almathswig.vectorPose2D_insert(self, *args)


    def reserve(self, n):
        """reserve(vectorPose2D self, std::vector< AL::Math::Pose2D >::size_type n)"""
        return _almathswig.vectorPose2D_reserve(self, n)


    def capacity(self):
        """capacity(vectorPose2D self) -> std::vector< AL::Math::Pose2D >::size_type"""
        return _almathswig.vectorPose2D_capacity(self)


    def __repr__(self):
        """__repr__(vectorPose2D self) -> std::string"""
        return _almathswig.vectorPose2D___repr__(self)

    __swig_destroy__ = _almathswig.delete_vectorPose2D
    __del__ = lambda self: None
vectorPose2D_swigregister = _almathswig.vectorPose2D_swigregister
vectorPose2D_swigregister(vectorPose2D)

class vectorPosition6D(_object):
    """Proxy of C++ std::vector<(AL::Math::Position6D)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vectorPosition6D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vectorPosition6D, name)

    def iterator(self):
        """iterator(vectorPosition6D self) -> SwigPyIterator"""
        return _almathswig.vectorPosition6D_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(vectorPosition6D self) -> bool"""
        return _almathswig.vectorPosition6D___nonzero__(self)


    def __bool__(self):
        """__bool__(vectorPosition6D self) -> bool"""
        return _almathswig.vectorPosition6D___bool__(self)


    def __len__(self):
        """__len__(vectorPosition6D self) -> std::vector< AL::Math::Position6D >::size_type"""
        return _almathswig.vectorPosition6D___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vectorPosition6D self, std::vector< AL::Math::Position6D >::difference_type i, std::vector< AL::Math::Position6D >::difference_type j) -> vectorPosition6D"""
        return _almathswig.vectorPosition6D___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vectorPosition6D self, std::vector< AL::Math::Position6D >::difference_type i, std::vector< AL::Math::Position6D >::difference_type j)
        __setslice__(vectorPosition6D self, std::vector< AL::Math::Position6D >::difference_type i, std::vector< AL::Math::Position6D >::difference_type j, vectorPosition6D v)
        """
        return _almathswig.vectorPosition6D___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vectorPosition6D self, std::vector< AL::Math::Position6D >::difference_type i, std::vector< AL::Math::Position6D >::difference_type j)"""
        return _almathswig.vectorPosition6D___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vectorPosition6D self, std::vector< AL::Math::Position6D >::difference_type i)
        __delitem__(vectorPosition6D self, PySliceObject * slice)
        """
        return _almathswig.vectorPosition6D___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vectorPosition6D self, PySliceObject * slice) -> vectorPosition6D
        __getitem__(vectorPosition6D self, std::vector< AL::Math::Position6D >::difference_type i) -> Position6D
        """
        return _almathswig.vectorPosition6D___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vectorPosition6D self, PySliceObject * slice, vectorPosition6D v)
        __setitem__(vectorPosition6D self, PySliceObject * slice)
        __setitem__(vectorPosition6D self, std::vector< AL::Math::Position6D >::difference_type i, Position6D x)
        """
        return _almathswig.vectorPosition6D___setitem__(self, *args)


    def pop(self):
        """pop(vectorPosition6D self) -> Position6D"""
        return _almathswig.vectorPosition6D_pop(self)


    def append(self, x):
        """append(vectorPosition6D self, Position6D x)"""
        return _almathswig.vectorPosition6D_append(self, x)


    def empty(self):
        """empty(vectorPosition6D self) -> bool"""
        return _almathswig.vectorPosition6D_empty(self)


    def size(self):
        """size(vectorPosition6D self) -> std::vector< AL::Math::Position6D >::size_type"""
        return _almathswig.vectorPosition6D_size(self)


    def swap(self, v):
        """swap(vectorPosition6D self, vectorPosition6D v)"""
        return _almathswig.vectorPosition6D_swap(self, v)


    def begin(self):
        """begin(vectorPosition6D self) -> std::vector< AL::Math::Position6D >::iterator"""
        return _almathswig.vectorPosition6D_begin(self)


    def end(self):
        """end(vectorPosition6D self) -> std::vector< AL::Math::Position6D >::iterator"""
        return _almathswig.vectorPosition6D_end(self)


    def rbegin(self):
        """rbegin(vectorPosition6D self) -> std::vector< AL::Math::Position6D >::reverse_iterator"""
        return _almathswig.vectorPosition6D_rbegin(self)


    def rend(self):
        """rend(vectorPosition6D self) -> std::vector< AL::Math::Position6D >::reverse_iterator"""
        return _almathswig.vectorPosition6D_rend(self)


    def clear(self):
        """clear(vectorPosition6D self)"""
        return _almathswig.vectorPosition6D_clear(self)


    def get_allocator(self):
        """get_allocator(vectorPosition6D self) -> std::vector< AL::Math::Position6D >::allocator_type"""
        return _almathswig.vectorPosition6D_get_allocator(self)


    def pop_back(self):
        """pop_back(vectorPosition6D self)"""
        return _almathswig.vectorPosition6D_pop_back(self)


    def erase(self, *args):
        """
        erase(vectorPosition6D self, std::vector< AL::Math::Position6D >::iterator pos) -> std::vector< AL::Math::Position6D >::iterator
        erase(vectorPosition6D self, std::vector< AL::Math::Position6D >::iterator first, std::vector< AL::Math::Position6D >::iterator last) -> std::vector< AL::Math::Position6D >::iterator
        """
        return _almathswig.vectorPosition6D_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(AL::Math::Position6D)> self) -> vectorPosition6D
        __init__(std::vector<(AL::Math::Position6D)> self, vectorPosition6D arg2) -> vectorPosition6D
        __init__(std::vector<(AL::Math::Position6D)> self, std::vector< AL::Math::Position6D >::size_type size) -> vectorPosition6D
        __init__(std::vector<(AL::Math::Position6D)> self, std::vector< AL::Math::Position6D >::size_type size, Position6D value) -> vectorPosition6D
        """
        this = _almathswig.new_vectorPosition6D(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vectorPosition6D self, Position6D x)"""
        return _almathswig.vectorPosition6D_push_back(self, x)


    def front(self):
        """front(vectorPosition6D self) -> Position6D"""
        return _almathswig.vectorPosition6D_front(self)


    def back(self):
        """back(vectorPosition6D self) -> Position6D"""
        return _almathswig.vectorPosition6D_back(self)


    def assign(self, n, x):
        """assign(vectorPosition6D self, std::vector< AL::Math::Position6D >::size_type n, Position6D x)"""
        return _almathswig.vectorPosition6D_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vectorPosition6D self, std::vector< AL::Math::Position6D >::size_type new_size)
        resize(vectorPosition6D self, std::vector< AL::Math::Position6D >::size_type new_size, Position6D x)
        """
        return _almathswig.vectorPosition6D_resize(self, *args)


    def insert(self, *args):
        """
        insert(vectorPosition6D self, std::vector< AL::Math::Position6D >::iterator pos, Position6D x) -> std::vector< AL::Math::Position6D >::iterator
        insert(vectorPosition6D self, std::vector< AL::Math::Position6D >::iterator pos, std::vector< AL::Math::Position6D >::size_type n, Position6D x)
        """
        return _almathswig.vectorPosition6D_insert(self, *args)


    def reserve(self, n):
        """reserve(vectorPosition6D self, std::vector< AL::Math::Position6D >::size_type n)"""
        return _almathswig.vectorPosition6D_reserve(self, n)


    def capacity(self):
        """capacity(vectorPosition6D self) -> std::vector< AL::Math::Position6D >::size_type"""
        return _almathswig.vectorPosition6D_capacity(self)


    def __repr__(self):
        """__repr__(vectorPosition6D self) -> std::string"""
        return _almathswig.vectorPosition6D___repr__(self)

    __swig_destroy__ = _almathswig.delete_vectorPosition6D
    __del__ = lambda self: None
vectorPosition6D_swigregister = _almathswig.vectorPosition6D_swigregister
vectorPosition6D_swigregister(vectorPosition6D)


def isAxisMask(pAxisMask):
    """isAxisMask(int const pAxisMask) -> bool"""
    return _almathswig.isAxisMask(pAxisMask)
class Pose2D(_object):
    """Proxy of C++ AL::Math::Pose2D class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pose2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Pose2D, name)
    __swig_setmethods__["x"] = _almathswig.Pose2D_x_set
    __swig_getmethods__["x"] = _almathswig.Pose2D_x_get
    if _newclass:
        x = _swig_property(_almathswig.Pose2D_x_get, _almathswig.Pose2D_x_set)
    __swig_setmethods__["y"] = _almathswig.Pose2D_y_set
    __swig_getmethods__["y"] = _almathswig.Pose2D_y_get
    if _newclass:
        y = _swig_property(_almathswig.Pose2D_y_get, _almathswig.Pose2D_y_set)
    __swig_setmethods__["theta"] = _almathswig.Pose2D_theta_set
    __swig_getmethods__["theta"] = _almathswig.Pose2D_theta_get
    if _newclass:
        theta = _swig_property(_almathswig.Pose2D_theta_get, _almathswig.Pose2D_theta_set)

    def __init__(self, *args):
        """
        __init__(AL::Math::Pose2D self) -> Pose2D
        __init__(AL::Math::Pose2D self, float pInit) -> Pose2D
        __init__(AL::Math::Pose2D self, float pX, float pY, float pTheta) -> Pose2D
        __init__(AL::Math::Pose2D self, vectorFloat pFloats) -> Pose2D
        """
        this = _almathswig.new_Pose2D(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def fromPolarCoordinates(pRadius, pAngle):
        """fromPolarCoordinates(float const pRadius, float const pAngle) -> Pose2D"""
        return _almathswig.Pose2D_fromPolarCoordinates(pRadius, pAngle)

    if _newclass:
        fromPolarCoordinates = staticmethod(fromPolarCoordinates)
    __swig_getmethods__["fromPolarCoordinates"] = lambda x: fromPolarCoordinates

    def __add__(self, pPos2):
        """__add__(Pose2D self, Pose2D pPos2) -> Pose2D"""
        return _almathswig.Pose2D___add__(self, pPos2)


    def __sub__(self, pPos2):
        """__sub__(Pose2D self, Pose2D pPos2) -> Pose2D"""
        return _almathswig.Pose2D___sub__(self, pPos2)


    def __pos__(self):
        """__pos__(Pose2D self) -> Pose2D"""
        return _almathswig.Pose2D___pos__(self)


    def __neg__(self):
        """__neg__(Pose2D self) -> Pose2D"""
        return _almathswig.Pose2D___neg__(self)


    def __iadd__(self, pPos2):
        """__iadd__(Pose2D self, Pose2D pPos2) -> Pose2D"""
        return _almathswig.Pose2D___iadd__(self, pPos2)


    def __isub__(self, pPos2):
        """__isub__(Pose2D self, Pose2D pPos2) -> Pose2D"""
        return _almathswig.Pose2D___isub__(self, pPos2)


    def __eq__(self, pPos2):
        """__eq__(Pose2D self, Pose2D pPos2) -> bool"""
        return _almathswig.Pose2D___eq__(self, pPos2)


    def __ne__(self, pPos2):
        """__ne__(Pose2D self, Pose2D pPos2) -> bool"""
        return _almathswig.Pose2D___ne__(self, pPos2)


    def __mul__(self, *args):
        """
        __mul__(Pose2D self, Pose2D pPos2) -> Pose2D
        __mul__(Pose2D self, float pVal) -> Pose2D
        """
        return _almathswig.Pose2D___mul__(self, *args)


    def __div__(self, pVal):
        """__div__(Pose2D self, float pVal) -> Pose2D"""
        return _almathswig.Pose2D___div__(self, pVal)


    def __imul__(self, *args):
        """
        __imul__(Pose2D self, Pose2D pPos2) -> Pose2D
        __imul__(Pose2D self, float pVal) -> Pose2D
        """
        return _almathswig.Pose2D___imul__(self, *args)


    def __idiv__(self, pVal):
        """__idiv__(Pose2D self, float pVal) -> Pose2D"""
        return _almathswig.Pose2D___idiv__(self, pVal)


    def distanceSquared(self, pPos2):
        """distanceSquared(Pose2D self, Pose2D pPos2) -> float"""
        return _almathswig.Pose2D_distanceSquared(self, pPos2)


    def distance(self, pPos2):
        """distance(Pose2D self, Pose2D pPos2) -> float"""
        return _almathswig.Pose2D_distance(self, pPos2)


    def inverse(self):
        """inverse(Pose2D self) -> Pose2D"""
        return _almathswig.Pose2D_inverse(self)


    def diff(self, pPos2):
        """diff(Pose2D self, Pose2D pPos2) -> Pose2D"""
        return _almathswig.Pose2D_diff(self, pPos2)


    def isNear(self, pPos2, pEpsilon=0.0001):
        """
        isNear(Pose2D self, Pose2D pPos2, float const & pEpsilon=0.0001) -> bool
        isNear(Pose2D self, Pose2D pPos2) -> bool
        """
        return _almathswig.Pose2D_isNear(self, pPos2, pEpsilon)


    def toVector(self, *args):
        """
        toVector(Pose2D self, vectorFloat pReturnVector)
        toVector(Pose2D self) -> vectorFloat
        """
        return _almathswig.Pose2D_toVector(self, *args)


    def writeToVector(self, pIt):
        """writeToVector(Pose2D self, std::vector< float,std::allocator< float > >::iterator & pIt)"""
        return _almathswig.Pose2D_writeToVector(self, pIt)


    def norm(self):
        """norm(Pose2D self) -> float"""
        return _almathswig.Pose2D_norm(self)


    def normalize(self):
        """normalize(Pose2D self) -> Pose2D"""
        return _almathswig.Pose2D_normalize(self)


    def getAngle(self):
        """getAngle(Pose2D self) -> float"""
        return _almathswig.Pose2D_getAngle(self)


    def __repr__(self):
        """__repr__(Pose2D self) -> char *"""
        return _almathswig.Pose2D___repr__(self)


    def __rmul__(self, lhs):
        """__rmul__(Pose2D self, float const lhs) -> Pose2D"""
        return _almathswig.Pose2D___rmul__(self, lhs)

    __swig_destroy__ = _almathswig.delete_Pose2D
    __del__ = lambda self: None
Pose2D_swigregister = _almathswig.Pose2D_swigregister
Pose2D_swigregister(Pose2D)
cvar = _almathswig.cvar
AXIS_MASK_X = cvar.AXIS_MASK_X
AXIS_MASK_Y = cvar.AXIS_MASK_Y
AXIS_MASK_XY = cvar.AXIS_MASK_XY
AXIS_MASK_Z = cvar.AXIS_MASK_Z
AXIS_MASK_WX = cvar.AXIS_MASK_WX
AXIS_MASK_WY = cvar.AXIS_MASK_WY
AXIS_MASK_WZ = cvar.AXIS_MASK_WZ
AXIS_MASK_WYWZ = cvar.AXIS_MASK_WYWZ
AXIS_MASK_ALL = cvar.AXIS_MASK_ALL
AXIS_MASK_VEL = cvar.AXIS_MASK_VEL
AXIS_MASK_ROT = cvar.AXIS_MASK_ROT
AXIS_MASK_NONE = cvar.AXIS_MASK_NONE
AXIS_MASK_PLANEZ = cvar.AXIS_MASK_PLANEZ

def Pose2D_fromPolarCoordinates(pRadius, pAngle):
    """Pose2D_fromPolarCoordinates(float const pRadius, float const pAngle) -> Pose2D"""
    return _almathswig.Pose2D_fromPolarCoordinates(pRadius, pAngle)


def pose2dInvertInPlace(pPos):
    """pose2dInvertInPlace(Pose2D pPos)"""
    return _almathswig.pose2dInvertInPlace(pPos)

def pose2dDiff(pPos1, pPos2):
    """pose2dDiff(Pose2D pPos1, Pose2D pPos2) -> Pose2D"""
    return _almathswig.pose2dDiff(pPos1, pPos2)

def pose2DInverse(*args):
    """
    pose2DInverse(Pose2D pPos) -> Pose2D
    pose2DInverse(Pose2D pPos, Pose2D pRes)
    """
    return _almathswig.pose2DInverse(*args)
class Position2D(_object):
    """Proxy of C++ AL::Math::Position2D class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Position2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Position2D, name)
    __swig_setmethods__["x"] = _almathswig.Position2D_x_set
    __swig_getmethods__["x"] = _almathswig.Position2D_x_get
    if _newclass:
        x = _swig_property(_almathswig.Position2D_x_get, _almathswig.Position2D_x_set)
    __swig_setmethods__["y"] = _almathswig.Position2D_y_set
    __swig_getmethods__["y"] = _almathswig.Position2D_y_get
    if _newclass:
        y = _swig_property(_almathswig.Position2D_y_get, _almathswig.Position2D_y_set)

    def __init__(self, *args):
        """
        __init__(AL::Math::Position2D self) -> Position2D
        __init__(AL::Math::Position2D self, float pInit) -> Position2D
        __init__(AL::Math::Position2D self, float pX, float pY) -> Position2D
        __init__(AL::Math::Position2D self, vectorFloat pFloats) -> Position2D
        """
        this = _almathswig.new_Position2D(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def fromPolarCoordinates(pRadius, pAngle):
        """fromPolarCoordinates(float const pRadius, float const pAngle) -> Position2D"""
        return _almathswig.Position2D_fromPolarCoordinates(pRadius, pAngle)

    if _newclass:
        fromPolarCoordinates = staticmethod(fromPolarCoordinates)
    __swig_getmethods__["fromPolarCoordinates"] = lambda x: fromPolarCoordinates

    def __add__(self, pPos2):
        """__add__(Position2D self, Position2D pPos2) -> Position2D"""
        return _almathswig.Position2D___add__(self, pPos2)


    def __sub__(self, pPos2):
        """__sub__(Position2D self, Position2D pPos2) -> Position2D"""
        return _almathswig.Position2D___sub__(self, pPos2)


    def __pos__(self):
        """__pos__(Position2D self) -> Position2D"""
        return _almathswig.Position2D___pos__(self)


    def __neg__(self):
        """__neg__(Position2D self) -> Position2D"""
        return _almathswig.Position2D___neg__(self)


    def __iadd__(self, pPos2):
        """__iadd__(Position2D self, Position2D pPos2) -> Position2D"""
        return _almathswig.Position2D___iadd__(self, pPos2)


    def __isub__(self, pPos2):
        """__isub__(Position2D self, Position2D pPos2) -> Position2D"""
        return _almathswig.Position2D___isub__(self, pPos2)


    def __eq__(self, pPos2):
        """__eq__(Position2D self, Position2D pPos2) -> bool"""
        return _almathswig.Position2D___eq__(self, pPos2)


    def __ne__(self, pPos2):
        """__ne__(Position2D self, Position2D pPos2) -> bool"""
        return _almathswig.Position2D___ne__(self, pPos2)


    def __mul__(self, pVal):
        """__mul__(Position2D self, float pVal) -> Position2D"""
        return _almathswig.Position2D___mul__(self, pVal)


    def __div__(self, pVal):
        """__div__(Position2D self, float pVal) -> Position2D"""
        return _almathswig.Position2D___div__(self, pVal)


    def __imul__(self, pVal):
        """__imul__(Position2D self, float pVal) -> Position2D"""
        return _almathswig.Position2D___imul__(self, pVal)


    def __idiv__(self, pVal):
        """__idiv__(Position2D self, float pVal) -> Position2D"""
        return _almathswig.Position2D___idiv__(self, pVal)


    def distanceSquared(self, pPos2):
        """distanceSquared(Position2D self, Position2D pPos2) -> float"""
        return _almathswig.Position2D_distanceSquared(self, pPos2)


    def distance(self, pPos2):
        """distance(Position2D self, Position2D pPos2) -> float"""
        return _almathswig.Position2D_distance(self, pPos2)


    def isNear(self, pPos2, pEpsilon=0.0001):
        """
        isNear(Position2D self, Position2D pPos2, float const & pEpsilon=0.0001) -> bool
        isNear(Position2D self, Position2D pPos2) -> bool
        """
        return _almathswig.Position2D_isNear(self, pPos2, pEpsilon)


    def norm(self):
        """norm(Position2D self) -> float"""
        return _almathswig.Position2D_norm(self)


    def normalize(self):
        """normalize(Position2D self) -> Position2D"""
        return _almathswig.Position2D_normalize(self)


    def dotProduct(self, pPos2):
        """dotProduct(Position2D self, Position2D pPos2) -> float"""
        return _almathswig.Position2D_dotProduct(self, pPos2)


    def crossProduct(self, pPos2):
        """crossProduct(Position2D self, Position2D pPos2) -> float"""
        return _almathswig.Position2D_crossProduct(self, pPos2)


    def toVector(self, *args):
        """
        toVector(Position2D self, vectorFloat pReturnVector)
        toVector(Position2D self) -> vectorFloat
        """
        return _almathswig.Position2D_toVector(self, *args)


    def writeToVector(self, pIt):
        """writeToVector(Position2D self, std::vector< float,std::allocator< float > >::iterator & pIt)"""
        return _almathswig.Position2D_writeToVector(self, pIt)


    def getAngle(self):
        """getAngle(Position2D self) -> float"""
        return _almathswig.Position2D_getAngle(self)


    def __repr__(self):
        """__repr__(Position2D self) -> char *"""
        return _almathswig.Position2D___repr__(self)


    def __rmul__(self, lhs):
        """__rmul__(Position2D self, float const lhs) -> Position2D"""
        return _almathswig.Position2D___rmul__(self, lhs)

    __swig_destroy__ = _almathswig.delete_Position2D
    __del__ = lambda self: None
Position2D_swigregister = _almathswig.Position2D_swigregister
Position2D_swigregister(Position2D)

def Position2D_fromPolarCoordinates(pRadius, pAngle):
    """Position2D_fromPolarCoordinates(float const pRadius, float const pAngle) -> Position2D"""
    return _almathswig.Position2D_fromPolarCoordinates(pRadius, pAngle)

class Position3D(_object):
    """Proxy of C++ AL::Math::Position3D class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Position3D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Position3D, name)
    __swig_setmethods__["x"] = _almathswig.Position3D_x_set
    __swig_getmethods__["x"] = _almathswig.Position3D_x_get
    if _newclass:
        x = _swig_property(_almathswig.Position3D_x_get, _almathswig.Position3D_x_set)
    __swig_setmethods__["y"] = _almathswig.Position3D_y_set
    __swig_getmethods__["y"] = _almathswig.Position3D_y_get
    if _newclass:
        y = _swig_property(_almathswig.Position3D_y_get, _almathswig.Position3D_y_set)
    __swig_setmethods__["z"] = _almathswig.Position3D_z_set
    __swig_getmethods__["z"] = _almathswig.Position3D_z_get
    if _newclass:
        z = _swig_property(_almathswig.Position3D_z_get, _almathswig.Position3D_z_set)

    def __init__(self, *args):
        """
        __init__(AL::Math::Position3D self) -> Position3D
        __init__(AL::Math::Position3D self, float pInit) -> Position3D
        __init__(AL::Math::Position3D self, float pX, float pY, float pZ) -> Position3D
        __init__(AL::Math::Position3D self, vectorFloat pFloats) -> Position3D
        """
        this = _almathswig.new_Position3D(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __add__(self, pPos2):
        """__add__(Position3D self, Position3D pPos2) -> Position3D"""
        return _almathswig.Position3D___add__(self, pPos2)


    def __sub__(self, pPos2):
        """__sub__(Position3D self, Position3D pPos2) -> Position3D"""
        return _almathswig.Position3D___sub__(self, pPos2)


    def __pos__(self):
        """__pos__(Position3D self) -> Position3D"""
        return _almathswig.Position3D___pos__(self)


    def __neg__(self):
        """__neg__(Position3D self) -> Position3D"""
        return _almathswig.Position3D___neg__(self)


    def __iadd__(self, pPos2):
        """__iadd__(Position3D self, Position3D pPos2) -> Position3D"""
        return _almathswig.Position3D___iadd__(self, pPos2)


    def __isub__(self, pPos2):
        """__isub__(Position3D self, Position3D pPos2) -> Position3D"""
        return _almathswig.Position3D___isub__(self, pPos2)


    def __eq__(self, pPos2):
        """__eq__(Position3D self, Position3D pPos2) -> bool"""
        return _almathswig.Position3D___eq__(self, pPos2)


    def __ne__(self, pPos2):
        """__ne__(Position3D self, Position3D pPos2) -> bool"""
        return _almathswig.Position3D___ne__(self, pPos2)


    def __mul__(self, pVal):
        """__mul__(Position3D self, float pVal) -> Position3D"""
        return _almathswig.Position3D___mul__(self, pVal)


    def __div__(self, pVal):
        """__div__(Position3D self, float pVal) -> Position3D"""
        return _almathswig.Position3D___div__(self, pVal)


    def __imul__(self, pVal):
        """__imul__(Position3D self, float pVal) -> Position3D"""
        return _almathswig.Position3D___imul__(self, pVal)


    def __idiv__(self, pVal):
        """__idiv__(Position3D self, float pVal) -> Position3D"""
        return _almathswig.Position3D___idiv__(self, pVal)


    def distanceSquared(self, pPos2):
        """distanceSquared(Position3D self, Position3D pPos2) -> float"""
        return _almathswig.Position3D_distanceSquared(self, pPos2)


    def distance(self, pPos2):
        """distance(Position3D self, Position3D pPos2) -> float"""
        return _almathswig.Position3D_distance(self, pPos2)


    def isNear(self, pPos2, pEpsilon=0.0001):
        """
        isNear(Position3D self, Position3D pPos2, float const & pEpsilon=0.0001) -> bool
        isNear(Position3D self, Position3D pPos2) -> bool
        """
        return _almathswig.Position3D_isNear(self, pPos2, pEpsilon)


    def norm(self):
        """norm(Position3D self) -> float"""
        return _almathswig.Position3D_norm(self)


    def normalize(self):
        """normalize(Position3D self) -> Position3D"""
        return _almathswig.Position3D_normalize(self)


    def dotProduct(self, pPos2):
        """dotProduct(Position3D self, Position3D pPos2) -> float"""
        return _almathswig.Position3D_dotProduct(self, pPos2)


    def crossProduct(self, pPos2):
        """crossProduct(Position3D self, Position3D pPos2) -> Position3D"""
        return _almathswig.Position3D_crossProduct(self, pPos2)


    def toVector(self, *args):
        """
        toVector(Position3D self, vectorFloat pReturnVector)
        toVector(Position3D self) -> vectorFloat
        """
        return _almathswig.Position3D_toVector(self, *args)


    def writeToVector(self, pIt):
        """writeToVector(Position3D self, std::vector< float,std::allocator< float > >::iterator & pIt)"""
        return _almathswig.Position3D_writeToVector(self, pIt)


    def isUnitVector(self, pEpsilon=0.0001):
        """
        isUnitVector(Position3D self, float const & pEpsilon=0.0001) -> bool
        isUnitVector(Position3D self) -> bool
        """
        return _almathswig.Position3D_isUnitVector(self, pEpsilon)


    def isOrthogonal(self, pPos, pEpsilon=0.0001):
        """
        isOrthogonal(Position3D self, Position3D pPos, float const & pEpsilon=0.0001) -> bool
        isOrthogonal(Position3D self, Position3D pPos) -> bool
        """
        return _almathswig.Position3D_isOrthogonal(self, pPos, pEpsilon)


    def __repr__(self):
        """__repr__(Position3D self) -> char *"""
        return _almathswig.Position3D___repr__(self)


    def __rmul__(self, lhs):
        """__rmul__(Position3D self, float const lhs) -> Position3D"""
        return _almathswig.Position3D___rmul__(self, lhs)

    __swig_destroy__ = _almathswig.delete_Position3D
    __del__ = lambda self: None
Position3D_swigregister = _almathswig.Position3D_swigregister
Position3D_swigregister(Position3D)


def dotProduct(*args):
    """
    dotProduct(Position2D pPos1, Position2D pPos2) -> float
    dotProduct(Position3D pPos1, Position3D pPos2) -> float
    """
    return _almathswig.dotProduct(*args)

def crossProduct(*args):
    """
    crossProduct(Position2D pPos1, Position2D pPos2) -> float
    crossProduct(Position2D pPos1, Position2D pPos2, float & pRes)
    crossProduct(Position3D pPos1, Position3D pPos2) -> Position3D
    crossProduct(Position3D pPos1, Position3D pPos2, Position3D pRes)
    """
    return _almathswig.crossProduct(*args)

def isUnitVector(pPos, pEpsilon=0.0001):
    """
    isUnitVector(Position3D pPos, float const & pEpsilon=0.0001) -> bool
    isUnitVector(Position3D pPos) -> bool
    """
    return _almathswig.isUnitVector(pPos, pEpsilon)

def isOrthogonal(pPos1, pPos2, pEpsilon=0.0001):
    """
    isOrthogonal(Position3D pPos1, Position3D pPos2, float const & pEpsilon=0.0001) -> bool
    isOrthogonal(Position3D pPos1, Position3D pPos2) -> bool
    """
    return _almathswig.isOrthogonal(pPos1, pPos2, pEpsilon)
class Position6D(_object):
    """Proxy of C++ AL::Math::Position6D class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Position6D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Position6D, name)
    __swig_setmethods__["x"] = _almathswig.Position6D_x_set
    __swig_getmethods__["x"] = _almathswig.Position6D_x_get
    if _newclass:
        x = _swig_property(_almathswig.Position6D_x_get, _almathswig.Position6D_x_set)
    __swig_setmethods__["y"] = _almathswig.Position6D_y_set
    __swig_getmethods__["y"] = _almathswig.Position6D_y_get
    if _newclass:
        y = _swig_property(_almathswig.Position6D_y_get, _almathswig.Position6D_y_set)
    __swig_setmethods__["z"] = _almathswig.Position6D_z_set
    __swig_getmethods__["z"] = _almathswig.Position6D_z_get
    if _newclass:
        z = _swig_property(_almathswig.Position6D_z_get, _almathswig.Position6D_z_set)
    __swig_setmethods__["wx"] = _almathswig.Position6D_wx_set
    __swig_getmethods__["wx"] = _almathswig.Position6D_wx_get
    if _newclass:
        wx = _swig_property(_almathswig.Position6D_wx_get, _almathswig.Position6D_wx_set)
    __swig_setmethods__["wy"] = _almathswig.Position6D_wy_set
    __swig_getmethods__["wy"] = _almathswig.Position6D_wy_get
    if _newclass:
        wy = _swig_property(_almathswig.Position6D_wy_get, _almathswig.Position6D_wy_set)
    __swig_setmethods__["wz"] = _almathswig.Position6D_wz_set
    __swig_getmethods__["wz"] = _almathswig.Position6D_wz_get
    if _newclass:
        wz = _swig_property(_almathswig.Position6D_wz_get, _almathswig.Position6D_wz_set)

    def __init__(self, *args):
        """
        __init__(AL::Math::Position6D self) -> Position6D
        __init__(AL::Math::Position6D self, float pInit) -> Position6D
        __init__(AL::Math::Position6D self, float pX, float pY, float pZ, float pWx, float pWy, float pWz) -> Position6D
        __init__(AL::Math::Position6D self, vectorFloat pFloats) -> Position6D
        """
        this = _almathswig.new_Position6D(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __add__(self, pPos2):
        """__add__(Position6D self, Position6D pPos2) -> Position6D"""
        return _almathswig.Position6D___add__(self, pPos2)


    def __sub__(self, pPos2):
        """__sub__(Position6D self, Position6D pPos2) -> Position6D"""
        return _almathswig.Position6D___sub__(self, pPos2)


    def __pos__(self):
        """__pos__(Position6D self) -> Position6D"""
        return _almathswig.Position6D___pos__(self)


    def __neg__(self):
        """__neg__(Position6D self) -> Position6D"""
        return _almathswig.Position6D___neg__(self)


    def __iadd__(self, pPos2):
        """__iadd__(Position6D self, Position6D pPos2) -> Position6D"""
        return _almathswig.Position6D___iadd__(self, pPos2)


    def __isub__(self, pPos2):
        """__isub__(Position6D self, Position6D pPos2) -> Position6D"""
        return _almathswig.Position6D___isub__(self, pPos2)


    def __eq__(self, pPos2):
        """__eq__(Position6D self, Position6D pPos2) -> bool"""
        return _almathswig.Position6D___eq__(self, pPos2)


    def __ne__(self, pPos2):
        """__ne__(Position6D self, Position6D pPos2) -> bool"""
        return _almathswig.Position6D___ne__(self, pPos2)


    def __mul__(self, pVal):
        """__mul__(Position6D self, float pVal) -> Position6D"""
        return _almathswig.Position6D___mul__(self, pVal)


    def __div__(self, pVal):
        """__div__(Position6D self, float pVal) -> Position6D"""
        return _almathswig.Position6D___div__(self, pVal)


    def __imul__(self, pVal):
        """__imul__(Position6D self, float pVal) -> Position6D"""
        return _almathswig.Position6D___imul__(self, pVal)


    def __idiv__(self, pVal):
        """__idiv__(Position6D self, float pVal) -> Position6D"""
        return _almathswig.Position6D___idiv__(self, pVal)


    def isNear(self, pPos2, pEpsilon=0.0001):
        """
        isNear(Position6D self, Position6D pPos2, float const & pEpsilon=0.0001) -> bool
        isNear(Position6D self, Position6D pPos2) -> bool
        """
        return _almathswig.Position6D_isNear(self, pPos2, pEpsilon)


    def distanceSquared(self, pPos2):
        """distanceSquared(Position6D self, Position6D pPos2) -> float"""
        return _almathswig.Position6D_distanceSquared(self, pPos2)


    def distance(self, pPos2):
        """distance(Position6D self, Position6D pPos2) -> float"""
        return _almathswig.Position6D_distance(self, pPos2)


    def norm(self):
        """norm(Position6D self) -> float"""
        return _almathswig.Position6D_norm(self)


    def toVector(self, *args):
        """
        toVector(Position6D self, vectorFloat pReturnVector)
        toVector(Position6D self) -> vectorFloat
        """
        return _almathswig.Position6D_toVector(self, *args)


    def writeToVector(self, pIt):
        """writeToVector(Position6D self, std::vector< float,std::allocator< float > >::iterator & pIt)"""
        return _almathswig.Position6D_writeToVector(self, pIt)


    def __repr__(self):
        """__repr__(Position6D self) -> char *"""
        return _almathswig.Position6D___repr__(self)


    def __rmul__(self, lhs):
        """__rmul__(Position6D self, float const lhs) -> Position6D"""
        return _almathswig.Position6D___rmul__(self, lhs)

    __swig_destroy__ = _almathswig.delete_Position6D
    __del__ = lambda self: None
Position6D_swigregister = _almathswig.Position6D_swigregister
Position6D_swigregister(Position6D)


def distanceSquared(*args):
    """
    distanceSquared(Pose2D pPos1, Pose2D pPos2) -> float
    distanceSquared(Position2D pPos1, Position2D pPos2) -> float
    distanceSquared(Position3D pPos1, Position3D pPos2) -> float
    distanceSquared(Position6D pPos1, Position6D pPos2) -> float
    """
    return _almathswig.distanceSquared(*args)

def distance(*args):
    """
    distance(Pose2D pPos1, Pose2D pPos2) -> float
    distance(Position2D pPos1, Position2D pPos2) -> float
    distance(Position3D pPos1, Position3D pPos2) -> float
    distance(Position6D pPos1, Position6D pPos2) -> float
    """
    return _almathswig.distance(*args)
class PositionAndVelocity(_object):
    """Proxy of C++ AL::Math::PositionAndVelocity class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PositionAndVelocity, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PositionAndVelocity, name)
    __swig_setmethods__["q"] = _almathswig.PositionAndVelocity_q_set
    __swig_getmethods__["q"] = _almathswig.PositionAndVelocity_q_get
    if _newclass:
        q = _swig_property(_almathswig.PositionAndVelocity_q_get, _almathswig.PositionAndVelocity_q_set)
    __swig_setmethods__["dq"] = _almathswig.PositionAndVelocity_dq_set
    __swig_getmethods__["dq"] = _almathswig.PositionAndVelocity_dq_get
    if _newclass:
        dq = _swig_property(_almathswig.PositionAndVelocity_dq_get, _almathswig.PositionAndVelocity_dq_set)

    def __init__(self, pq=0.0, pdq=0.0):
        """
        __init__(AL::Math::PositionAndVelocity self, float const pq=0.0, float const pdq=0.0) -> PositionAndVelocity
        __init__(AL::Math::PositionAndVelocity self, float const pq=0.0) -> PositionAndVelocity
        __init__(AL::Math::PositionAndVelocity self) -> PositionAndVelocity
        """
        this = _almathswig.new_PositionAndVelocity(pq, pdq)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def isNear(self, pDat2, pEpsilon=0.0001):
        """
        isNear(PositionAndVelocity self, PositionAndVelocity pDat2, float const & pEpsilon=0.0001) -> bool
        isNear(PositionAndVelocity self, PositionAndVelocity pDat2) -> bool
        """
        return _almathswig.PositionAndVelocity_isNear(self, pDat2, pEpsilon)


    def toVector(self, *args):
        """
        toVector(PositionAndVelocity self, vectorFloat pReturnVector)
        toVector(PositionAndVelocity self) -> vectorFloat
        """
        return _almathswig.PositionAndVelocity_toVector(self, *args)


    def __repr__(self):
        """__repr__(PositionAndVelocity self) -> char *"""
        return _almathswig.PositionAndVelocity___repr__(self)

    __swig_destroy__ = _almathswig.delete_PositionAndVelocity
    __del__ = lambda self: None
PositionAndVelocity_swigregister = _almathswig.PositionAndVelocity_swigregister
PositionAndVelocity_swigregister(PositionAndVelocity)

class Quaternion(_object):
    """Proxy of C++ AL::Math::Quaternion class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Quaternion, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Quaternion, name)
    __swig_setmethods__["w"] = _almathswig.Quaternion_w_set
    __swig_getmethods__["w"] = _almathswig.Quaternion_w_get
    if _newclass:
        w = _swig_property(_almathswig.Quaternion_w_get, _almathswig.Quaternion_w_set)
    __swig_setmethods__["x"] = _almathswig.Quaternion_x_set
    __swig_getmethods__["x"] = _almathswig.Quaternion_x_get
    if _newclass:
        x = _swig_property(_almathswig.Quaternion_x_get, _almathswig.Quaternion_x_set)
    __swig_setmethods__["y"] = _almathswig.Quaternion_y_set
    __swig_getmethods__["y"] = _almathswig.Quaternion_y_get
    if _newclass:
        y = _swig_property(_almathswig.Quaternion_y_get, _almathswig.Quaternion_y_set)
    __swig_setmethods__["z"] = _almathswig.Quaternion_z_set
    __swig_getmethods__["z"] = _almathswig.Quaternion_z_get
    if _newclass:
        z = _swig_property(_almathswig.Quaternion_z_get, _almathswig.Quaternion_z_set)

    def __init__(self, *args):
        """
        __init__(AL::Math::Quaternion self) -> Quaternion
        __init__(AL::Math::Quaternion self, float pW, float pX, float pY, float pZ) -> Quaternion
        __init__(AL::Math::Quaternion self, vectorFloat pFloats) -> Quaternion
        """
        this = _almathswig.new_Quaternion(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __eq__(self, pQua2):
        """__eq__(Quaternion self, Quaternion pQua2) -> bool"""
        return _almathswig.Quaternion___eq__(self, pQua2)


    def __ne__(self, pQua2):
        """__ne__(Quaternion self, Quaternion pQua2) -> bool"""
        return _almathswig.Quaternion___ne__(self, pQua2)


    def __mul__(self, *args):
        """
        __mul__(Quaternion self, Quaternion pQua2) -> Quaternion
        __mul__(Quaternion self, float pVal) -> Quaternion
        """
        return _almathswig.Quaternion___mul__(self, *args)


    def __div__(self, pVal):
        """__div__(Quaternion self, float pVal) -> Quaternion"""
        return _almathswig.Quaternion___div__(self, pVal)


    def __imul__(self, *args):
        """
        __imul__(Quaternion self, Quaternion pQua2) -> Quaternion
        __imul__(Quaternion self, float pVal) -> Quaternion
        """
        return _almathswig.Quaternion___imul__(self, *args)


    def __idiv__(self, pVal):
        """__idiv__(Quaternion self, float pVal) -> Quaternion"""
        return _almathswig.Quaternion___idiv__(self, pVal)


    def isNear(self, pQua2, pEpsilon=0.0001):
        """
        isNear(Quaternion self, Quaternion pQua2, float const & pEpsilon=0.0001) -> bool
        isNear(Quaternion self, Quaternion pQua2) -> bool
        """
        return _almathswig.Quaternion_isNear(self, pQua2, pEpsilon)


    def norm(self):
        """norm(Quaternion self) -> float"""
        return _almathswig.Quaternion_norm(self)


    def normalize(self):
        """normalize(Quaternion self) -> Quaternion"""
        return _almathswig.Quaternion_normalize(self)


    def inverse(self):
        """inverse(Quaternion self) -> Quaternion"""
        return _almathswig.Quaternion_inverse(self)


    def fromAngleAndAxisRotation(pAngle, pAxisX, pAxisY, pAxisZ):
        """fromAngleAndAxisRotation(float const pAngle, float const pAxisX, float const pAxisY, float const pAxisZ) -> Quaternion"""
        return _almathswig.Quaternion_fromAngleAndAxisRotation(pAngle, pAxisX, pAxisY, pAxisZ)

    if _newclass:
        fromAngleAndAxisRotation = staticmethod(fromAngleAndAxisRotation)
    __swig_getmethods__["fromAngleAndAxisRotation"] = lambda x: fromAngleAndAxisRotation

    def toVector(self, *args):
        """
        toVector(Quaternion self, vectorFloat pReturnVector)
        toVector(Quaternion self) -> vectorFloat
        """
        return _almathswig.Quaternion_toVector(self, *args)


    def __repr__(self):
        """__repr__(Quaternion self) -> char *"""
        return _almathswig.Quaternion___repr__(self)

    __swig_destroy__ = _almathswig.delete_Quaternion
    __del__ = lambda self: None
Quaternion_swigregister = _almathswig.Quaternion_swigregister
Quaternion_swigregister(Quaternion)

def Quaternion_fromAngleAndAxisRotation(pAngle, pAxisX, pAxisY, pAxisZ):
    """Quaternion_fromAngleAndAxisRotation(float const pAngle, float const pAxisX, float const pAxisY, float const pAxisZ) -> Quaternion"""
    return _almathswig.Quaternion_fromAngleAndAxisRotation(pAngle, pAxisX, pAxisY, pAxisZ)


def quaternionInverse(*args):
    """
    quaternionInverse(Quaternion pQua, Quaternion pQuaOut)
    quaternionInverse(Quaternion pQua) -> Quaternion
    """
    return _almathswig.quaternionInverse(*args)

def quaternionFromAngleAndAxisRotation(pAngle, pAxisX, pAxisY, pAxisZ):
    """quaternionFromAngleAndAxisRotation(float const pAngle, float const pAxisX, float const pAxisY, float const pAxisZ) -> Quaternion"""
    return _almathswig.quaternionFromAngleAndAxisRotation(pAngle, pAxisX, pAxisY, pAxisZ)

def angleAndAxisRotationFromQuaternion(*args):
    """
    angleAndAxisRotationFromQuaternion(Quaternion pQuaternion, float & pAngle, float & pAxisX, float & pAxisY, float & pAxisZ)
    angleAndAxisRotationFromQuaternion(Quaternion pQuaternion) -> vectorFloat
    """
    return _almathswig.angleAndAxisRotationFromQuaternion(*args)
class Displacement(_object):
    """Proxy of C++ AL::Math::Displacement class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Displacement, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Displacement, name)
    __swig_setmethods__["P"] = _almathswig.Displacement_P_set
    __swig_getmethods__["P"] = _almathswig.Displacement_P_get
    if _newclass:
        P = _swig_property(_almathswig.Displacement_P_get, _almathswig.Displacement_P_set)
    __swig_setmethods__["Q"] = _almathswig.Displacement_Q_set
    __swig_getmethods__["Q"] = _almathswig.Displacement_Q_get
    if _newclass:
        Q = _swig_property(_almathswig.Displacement_Q_get, _almathswig.Displacement_Q_set)

    def __init__(self, *args):
        """
        __init__(AL::Math::Displacement self) -> Displacement
        __init__(AL::Math::Displacement self, Position3D pos3d, Quaternion quat) -> Displacement
        __init__(AL::Math::Displacement self, Position3D pos3d) -> Displacement
        """
        this = _almathswig.new_Displacement(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __imul__(self, pDisp):
        """__imul__(Displacement self, Displacement pDisp) -> Displacement"""
        return _almathswig.Displacement___imul__(self, pDisp)


    def __mul__(self, pDisp):
        """__mul__(Displacement self, Displacement pDisp) -> Displacement"""
        return _almathswig.Displacement___mul__(self, pDisp)


    def isNear(self, pDisp2, pEpsilon=0.0001):
        """
        isNear(Displacement self, Displacement pDisp2, float const pEpsilon=0.0001) -> bool
        isNear(Displacement self, Displacement pDisp2) -> bool
        """
        return _almathswig.Displacement_isNear(self, pDisp2, pEpsilon)


    def __repr__(self):
        """__repr__(Displacement self) -> char *"""
        return _almathswig.Displacement___repr__(self)

    __swig_destroy__ = _almathswig.delete_Displacement
    __del__ = lambda self: None
Displacement_swigregister = _almathswig.Displacement_swigregister
Displacement_swigregister(Displacement)

class Rotation(_object):
    """Proxy of C++ AL::Math::Rotation class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Rotation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Rotation, name)
    __swig_setmethods__["r1_c1"] = _almathswig.Rotation_r1_c1_set
    __swig_getmethods__["r1_c1"] = _almathswig.Rotation_r1_c1_get
    if _newclass:
        r1_c1 = _swig_property(_almathswig.Rotation_r1_c1_get, _almathswig.Rotation_r1_c1_set)
    __swig_setmethods__["r1_c2"] = _almathswig.Rotation_r1_c2_set
    __swig_getmethods__["r1_c2"] = _almathswig.Rotation_r1_c2_get
    if _newclass:
        r1_c2 = _swig_property(_almathswig.Rotation_r1_c2_get, _almathswig.Rotation_r1_c2_set)
    __swig_setmethods__["r1_c3"] = _almathswig.Rotation_r1_c3_set
    __swig_getmethods__["r1_c3"] = _almathswig.Rotation_r1_c3_get
    if _newclass:
        r1_c3 = _swig_property(_almathswig.Rotation_r1_c3_get, _almathswig.Rotation_r1_c3_set)
    __swig_setmethods__["r2_c1"] = _almathswig.Rotation_r2_c1_set
    __swig_getmethods__["r2_c1"] = _almathswig.Rotation_r2_c1_get
    if _newclass:
        r2_c1 = _swig_property(_almathswig.Rotation_r2_c1_get, _almathswig.Rotation_r2_c1_set)
    __swig_setmethods__["r2_c2"] = _almathswig.Rotation_r2_c2_set
    __swig_getmethods__["r2_c2"] = _almathswig.Rotation_r2_c2_get
    if _newclass:
        r2_c2 = _swig_property(_almathswig.Rotation_r2_c2_get, _almathswig.Rotation_r2_c2_set)
    __swig_setmethods__["r2_c3"] = _almathswig.Rotation_r2_c3_set
    __swig_getmethods__["r2_c3"] = _almathswig.Rotation_r2_c3_get
    if _newclass:
        r2_c3 = _swig_property(_almathswig.Rotation_r2_c3_get, _almathswig.Rotation_r2_c3_set)
    __swig_setmethods__["r3_c1"] = _almathswig.Rotation_r3_c1_set
    __swig_getmethods__["r3_c1"] = _almathswig.Rotation_r3_c1_get
    if _newclass:
        r3_c1 = _swig_property(_almathswig.Rotation_r3_c1_get, _almathswig.Rotation_r3_c1_set)
    __swig_setmethods__["r3_c2"] = _almathswig.Rotation_r3_c2_set
    __swig_getmethods__["r3_c2"] = _almathswig.Rotation_r3_c2_get
    if _newclass:
        r3_c2 = _swig_property(_almathswig.Rotation_r3_c2_get, _almathswig.Rotation_r3_c2_set)
    __swig_setmethods__["r3_c3"] = _almathswig.Rotation_r3_c3_set
    __swig_getmethods__["r3_c3"] = _almathswig.Rotation_r3_c3_get
    if _newclass:
        r3_c3 = _swig_property(_almathswig.Rotation_r3_c3_get, _almathswig.Rotation_r3_c3_set)

    def __init__(self, *args):
        """
        __init__(AL::Math::Rotation self) -> Rotation
        __init__(AL::Math::Rotation self, vectorFloat pFloats) -> Rotation
        """
        this = _almathswig.new_Rotation(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __imul__(self, pRot2):
        """__imul__(Rotation self, Rotation pRot2) -> Rotation"""
        return _almathswig.Rotation___imul__(self, pRot2)


    def __eq__(self, pRot2):
        """__eq__(Rotation self, Rotation pRot2) -> bool"""
        return _almathswig.Rotation___eq__(self, pRot2)


    def __ne__(self, pRot2):
        """__ne__(Rotation self, Rotation pRot2) -> bool"""
        return _almathswig.Rotation___ne__(self, pRot2)


    def isNear(self, pRot2, pEpsilon=0.0001):
        """
        isNear(Rotation self, Rotation pRot2, float const & pEpsilon=0.0001) -> bool
        isNear(Rotation self, Rotation pRot2) -> bool
        """
        return _almathswig.Rotation_isNear(self, pRot2, pEpsilon)


    def normalizeRotation(self):
        """normalizeRotation(Rotation self)"""
        return _almathswig.Rotation_normalizeRotation(self)


    def isRotation(self, pEpsilon=0.0001):
        """
        isRotation(Rotation self, float const & pEpsilon=0.0001) -> bool
        isRotation(Rotation self) -> bool
        """
        return _almathswig.Rotation_isRotation(self, pEpsilon)


    def transpose(self):
        """transpose(Rotation self) -> Rotation"""
        return _almathswig.Rotation_transpose(self)


    def determinant(self):
        """determinant(Rotation self) -> float"""
        return _almathswig.Rotation_determinant(self)


    def fromQuaternion(pA, pB, pC, pD):
        """fromQuaternion(float const pA, float const pB, float const pC, float const pD) -> Rotation"""
        return _almathswig.Rotation_fromQuaternion(pA, pB, pC, pD)

    if _newclass:
        fromQuaternion = staticmethod(fromQuaternion)
    __swig_getmethods__["fromQuaternion"] = lambda x: fromQuaternion

    def fromAngleDirection(pAngle, pX, pY, pZ):
        """fromAngleDirection(float const pAngle, float const pX, float const pY, float const pZ) -> Rotation"""
        return _almathswig.Rotation_fromAngleDirection(pAngle, pX, pY, pZ)

    if _newclass:
        fromAngleDirection = staticmethod(fromAngleDirection)
    __swig_getmethods__["fromAngleDirection"] = lambda x: fromAngleDirection

    def fromRotX(pRotX):
        """fromRotX(float const pRotX) -> Rotation"""
        return _almathswig.Rotation_fromRotX(pRotX)

    if _newclass:
        fromRotX = staticmethod(fromRotX)
    __swig_getmethods__["fromRotX"] = lambda x: fromRotX

    def fromRotXPi():
        """fromRotXPi() -> Rotation"""
        return _almathswig.Rotation_fromRotXPi()

    if _newclass:
        fromRotXPi = staticmethod(fromRotXPi)
    __swig_getmethods__["fromRotXPi"] = lambda x: fromRotXPi

    def fromRotY(pRotY):
        """fromRotY(float const pRotY) -> Rotation"""
        return _almathswig.Rotation_fromRotY(pRotY)

    if _newclass:
        fromRotY = staticmethod(fromRotY)
    __swig_getmethods__["fromRotY"] = lambda x: fromRotY

    def fromRotYPi():
        """fromRotYPi() -> Rotation"""
        return _almathswig.Rotation_fromRotYPi()

    if _newclass:
        fromRotYPi = staticmethod(fromRotYPi)
    __swig_getmethods__["fromRotYPi"] = lambda x: fromRotYPi

    def fromRotZ(pRotZ):
        """fromRotZ(float const pRotZ) -> Rotation"""
        return _almathswig.Rotation_fromRotZ(pRotZ)

    if _newclass:
        fromRotZ = staticmethod(fromRotZ)
    __swig_getmethods__["fromRotZ"] = lambda x: fromRotZ

    def fromRotZPi():
        """fromRotZPi() -> Rotation"""
        return _almathswig.Rotation_fromRotZPi()

    if _newclass:
        fromRotZPi = staticmethod(fromRotZPi)
    __swig_getmethods__["fromRotZPi"] = lambda x: fromRotZPi

    def fromRotZHalfPi():
        """fromRotZHalfPi() -> Rotation"""
        return _almathswig.Rotation_fromRotZHalfPi()

    if _newclass:
        fromRotZHalfPi = staticmethod(fromRotZHalfPi)
    __swig_getmethods__["fromRotZHalfPi"] = lambda x: fromRotZHalfPi

    def from3DRotation(pWX, pWY, pWZ):
        """from3DRotation(float const & pWX, float const & pWY, float const & pWZ) -> Rotation"""
        return _almathswig.Rotation_from3DRotation(pWX, pWY, pWZ)

    if _newclass:
        from3DRotation = staticmethod(from3DRotation)
    __swig_getmethods__["from3DRotation"] = lambda x: from3DRotation

    def toVector(self, *args):
        """
        toVector(Rotation self, vectorFloat pReturnValue)
        toVector(Rotation self) -> vectorFloat
        """
        return _almathswig.Rotation_toVector(self, *args)


    def __str__(self):
        """__str__(Rotation self) -> char *"""
        return _almathswig.Rotation___str__(self)


    def __repr__(self):
        """__repr__(Rotation self) -> char *"""
        return _almathswig.Rotation___repr__(self)


    def __mul__(self, *args):
        """
        __mul__(Rotation self, Rotation pRot2) -> Rotation
        __mul__(Rotation self, Position3D rhs) -> Position3D
        """
        return _almathswig.Rotation___mul__(self, *args)

    __swig_destroy__ = _almathswig.delete_Rotation
    __del__ = lambda self: None
Rotation_swigregister = _almathswig.Rotation_swigregister
Rotation_swigregister(Rotation)

def Rotation_fromQuaternion(pA, pB, pC, pD):
    """Rotation_fromQuaternion(float const pA, float const pB, float const pC, float const pD) -> Rotation"""
    return _almathswig.Rotation_fromQuaternion(pA, pB, pC, pD)

def Rotation_fromAngleDirection(pAngle, pX, pY, pZ):
    """Rotation_fromAngleDirection(float const pAngle, float const pX, float const pY, float const pZ) -> Rotation"""
    return _almathswig.Rotation_fromAngleDirection(pAngle, pX, pY, pZ)

def Rotation_fromRotX(pRotX):
    """Rotation_fromRotX(float const pRotX) -> Rotation"""
    return _almathswig.Rotation_fromRotX(pRotX)

def Rotation_fromRotXPi():
    """Rotation_fromRotXPi() -> Rotation"""
    return _almathswig.Rotation_fromRotXPi()

def Rotation_fromRotY(pRotY):
    """Rotation_fromRotY(float const pRotY) -> Rotation"""
    return _almathswig.Rotation_fromRotY(pRotY)

def Rotation_fromRotYPi():
    """Rotation_fromRotYPi() -> Rotation"""
    return _almathswig.Rotation_fromRotYPi()

def Rotation_fromRotZ(pRotZ):
    """Rotation_fromRotZ(float const pRotZ) -> Rotation"""
    return _almathswig.Rotation_fromRotZ(pRotZ)

def Rotation_fromRotZPi():
    """Rotation_fromRotZPi() -> Rotation"""
    return _almathswig.Rotation_fromRotZPi()

def Rotation_fromRotZHalfPi():
    """Rotation_fromRotZHalfPi() -> Rotation"""
    return _almathswig.Rotation_fromRotZHalfPi()

def Rotation_from3DRotation(pWX, pWY, pWZ):
    """Rotation_from3DRotation(float const & pWX, float const & pWY, float const & pWZ) -> Rotation"""
    return _almathswig.Rotation_from3DRotation(pWX, pWY, pWZ)


def transpose(pRot):
    """transpose(Rotation pRot) -> Rotation"""
    return _almathswig.transpose(pRot)

def normalizeRotation(pRot):
    """normalizeRotation(Rotation pRot)"""
    return _almathswig.normalizeRotation(pRot)

def applyRotation(pRot, pX, pY, pZ):
    """applyRotation(Rotation pRot, float & pX, float & pY, float & pZ)"""
    return _almathswig.applyRotation(pRot, pX, pY, pZ)

def rotationFromRotX(pRotX):
    """rotationFromRotX(float const pRotX) -> Rotation"""
    return _almathswig.rotationFromRotX(pRotX)

def rotationFromRotY(pRotY):
    """rotationFromRotY(float const pRotY) -> Rotation"""
    return _almathswig.rotationFromRotY(pRotY)

def rotationFromRotZ(pRotZ):
    """rotationFromRotZ(float const pRotZ) -> Rotation"""
    return _almathswig.rotationFromRotZ(pRotZ)

def rotationFrom3DRotation(pWX, pWY, pWZ):
    """rotationFrom3DRotation(float const & pWX, float const & pWY, float const & pWZ) -> Rotation"""
    return _almathswig.rotationFrom3DRotation(pWX, pWY, pWZ)
class Rotation3D(_object):
    """Proxy of C++ AL::Math::Rotation3D class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Rotation3D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Rotation3D, name)
    __swig_setmethods__["wx"] = _almathswig.Rotation3D_wx_set
    __swig_getmethods__["wx"] = _almathswig.Rotation3D_wx_get
    if _newclass:
        wx = _swig_property(_almathswig.Rotation3D_wx_get, _almathswig.Rotation3D_wx_set)
    __swig_setmethods__["wy"] = _almathswig.Rotation3D_wy_set
    __swig_getmethods__["wy"] = _almathswig.Rotation3D_wy_get
    if _newclass:
        wy = _swig_property(_almathswig.Rotation3D_wy_get, _almathswig.Rotation3D_wy_set)
    __swig_setmethods__["wz"] = _almathswig.Rotation3D_wz_set
    __swig_getmethods__["wz"] = _almathswig.Rotation3D_wz_get
    if _newclass:
        wz = _swig_property(_almathswig.Rotation3D_wz_get, _almathswig.Rotation3D_wz_set)

    def __init__(self, *args):
        """
        __init__(AL::Math::Rotation3D self) -> Rotation3D
        __init__(AL::Math::Rotation3D self, float pInit) -> Rotation3D
        __init__(AL::Math::Rotation3D self, float pWx, float pWy, float pWz) -> Rotation3D
        __init__(AL::Math::Rotation3D self, vectorFloat pFloats) -> Rotation3D
        """
        this = _almathswig.new_Rotation3D(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __add__(self, pRot2):
        """__add__(Rotation3D self, Rotation3D pRot2) -> Rotation3D"""
        return _almathswig.Rotation3D___add__(self, pRot2)


    def __sub__(self, pRot2):
        """__sub__(Rotation3D self, Rotation3D pRot2) -> Rotation3D"""
        return _almathswig.Rotation3D___sub__(self, pRot2)


    def __iadd__(self, pRot2):
        """__iadd__(Rotation3D self, Rotation3D pRot2) -> Rotation3D"""
        return _almathswig.Rotation3D___iadd__(self, pRot2)


    def __isub__(self, pRot2):
        """__isub__(Rotation3D self, Rotation3D pRot2) -> Rotation3D"""
        return _almathswig.Rotation3D___isub__(self, pRot2)


    def __eq__(self, pRot2):
        """__eq__(Rotation3D self, Rotation3D pRot2) -> bool"""
        return _almathswig.Rotation3D___eq__(self, pRot2)


    def __ne__(self, pRot2):
        """__ne__(Rotation3D self, Rotation3D pRot2) -> bool"""
        return _almathswig.Rotation3D___ne__(self, pRot2)


    def __mul__(self, pVal):
        """__mul__(Rotation3D self, float const pVal) -> Rotation3D"""
        return _almathswig.Rotation3D___mul__(self, pVal)


    def __div__(self, pVal):
        """__div__(Rotation3D self, float const pVal) -> Rotation3D"""
        return _almathswig.Rotation3D___div__(self, pVal)


    def __imul__(self, pVal):
        """__imul__(Rotation3D self, float const pVal) -> Rotation3D"""
        return _almathswig.Rotation3D___imul__(self, pVal)


    def __idiv__(self, pVal):
        """__idiv__(Rotation3D self, float const pVal) -> Rotation3D"""
        return _almathswig.Rotation3D___idiv__(self, pVal)


    def isNear(self, pRot2, pEpsilon=0.0001):
        """
        isNear(Rotation3D self, Rotation3D pRot2, float const & pEpsilon=0.0001) -> bool
        isNear(Rotation3D self, Rotation3D pRot2) -> bool
        """
        return _almathswig.Rotation3D_isNear(self, pRot2, pEpsilon)


    def norm(self):
        """norm(Rotation3D self) -> float"""
        return _almathswig.Rotation3D_norm(self)


    def toVector(self, *args):
        """
        toVector(Rotation3D self, vectorFloat pReturnVector)
        toVector(Rotation3D self) -> vectorFloat
        """
        return _almathswig.Rotation3D_toVector(self, *args)


    def __repr__(self):
        """__repr__(Rotation3D self) -> char *"""
        return _almathswig.Rotation3D___repr__(self)

    __swig_destroy__ = _almathswig.delete_Rotation3D
    __del__ = lambda self: None
Rotation3D_swigregister = _almathswig.Rotation3D_swigregister
Rotation3D_swigregister(Rotation3D)

class Transform(_object):
    """Proxy of C++ AL::Math::Transform class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Transform, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Transform, name)
    __swig_setmethods__["r1_c1"] = _almathswig.Transform_r1_c1_set
    __swig_getmethods__["r1_c1"] = _almathswig.Transform_r1_c1_get
    if _newclass:
        r1_c1 = _swig_property(_almathswig.Transform_r1_c1_get, _almathswig.Transform_r1_c1_set)
    __swig_setmethods__["r1_c2"] = _almathswig.Transform_r1_c2_set
    __swig_getmethods__["r1_c2"] = _almathswig.Transform_r1_c2_get
    if _newclass:
        r1_c2 = _swig_property(_almathswig.Transform_r1_c2_get, _almathswig.Transform_r1_c2_set)
    __swig_setmethods__["r1_c3"] = _almathswig.Transform_r1_c3_set
    __swig_getmethods__["r1_c3"] = _almathswig.Transform_r1_c3_get
    if _newclass:
        r1_c3 = _swig_property(_almathswig.Transform_r1_c3_get, _almathswig.Transform_r1_c3_set)
    __swig_setmethods__["r1_c4"] = _almathswig.Transform_r1_c4_set
    __swig_getmethods__["r1_c4"] = _almathswig.Transform_r1_c4_get
    if _newclass:
        r1_c4 = _swig_property(_almathswig.Transform_r1_c4_get, _almathswig.Transform_r1_c4_set)
    __swig_setmethods__["r2_c1"] = _almathswig.Transform_r2_c1_set
    __swig_getmethods__["r2_c1"] = _almathswig.Transform_r2_c1_get
    if _newclass:
        r2_c1 = _swig_property(_almathswig.Transform_r2_c1_get, _almathswig.Transform_r2_c1_set)
    __swig_setmethods__["r2_c2"] = _almathswig.Transform_r2_c2_set
    __swig_getmethods__["r2_c2"] = _almathswig.Transform_r2_c2_get
    if _newclass:
        r2_c2 = _swig_property(_almathswig.Transform_r2_c2_get, _almathswig.Transform_r2_c2_set)
    __swig_setmethods__["r2_c3"] = _almathswig.Transform_r2_c3_set
    __swig_getmethods__["r2_c3"] = _almathswig.Transform_r2_c3_get
    if _newclass:
        r2_c3 = _swig_property(_almathswig.Transform_r2_c3_get, _almathswig.Transform_r2_c3_set)
    __swig_setmethods__["r2_c4"] = _almathswig.Transform_r2_c4_set
    __swig_getmethods__["r2_c4"] = _almathswig.Transform_r2_c4_get
    if _newclass:
        r2_c4 = _swig_property(_almathswig.Transform_r2_c4_get, _almathswig.Transform_r2_c4_set)
    __swig_setmethods__["r3_c1"] = _almathswig.Transform_r3_c1_set
    __swig_getmethods__["r3_c1"] = _almathswig.Transform_r3_c1_get
    if _newclass:
        r3_c1 = _swig_property(_almathswig.Transform_r3_c1_get, _almathswig.Transform_r3_c1_set)
    __swig_setmethods__["r3_c2"] = _almathswig.Transform_r3_c2_set
    __swig_getmethods__["r3_c2"] = _almathswig.Transform_r3_c2_get
    if _newclass:
        r3_c2 = _swig_property(_almathswig.Transform_r3_c2_get, _almathswig.Transform_r3_c2_set)
    __swig_setmethods__["r3_c3"] = _almathswig.Transform_r3_c3_set
    __swig_getmethods__["r3_c3"] = _almathswig.Transform_r3_c3_get
    if _newclass:
        r3_c3 = _swig_property(_almathswig.Transform_r3_c3_get, _almathswig.Transform_r3_c3_set)
    __swig_setmethods__["r3_c4"] = _almathswig.Transform_r3_c4_set
    __swig_getmethods__["r3_c4"] = _almathswig.Transform_r3_c4_get
    if _newclass:
        r3_c4 = _swig_property(_almathswig.Transform_r3_c4_get, _almathswig.Transform_r3_c4_set)

    def __init__(self, *args):
        """
        __init__(AL::Math::Transform self) -> Transform
        __init__(AL::Math::Transform self, vectorFloat pFloats) -> Transform
        __init__(AL::Math::Transform self, float const & pPosX, float const & pPosY, float const & pPosZ) -> Transform
        """
        this = _almathswig.new_Transform(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __imul__(self, pT2):
        """__imul__(Transform self, Transform pT2) -> Transform"""
        return _almathswig.Transform___imul__(self, pT2)


    def __eq__(self, pT2):
        """__eq__(Transform self, Transform pT2) -> bool"""
        return _almathswig.Transform___eq__(self, pT2)


    def __ne__(self, pT2):
        """__ne__(Transform self, Transform pT2) -> bool"""
        return _almathswig.Transform___ne__(self, pT2)


    def isNear(self, pT2, pEpsilon=0.0001):
        """
        isNear(Transform self, Transform pT2, float const & pEpsilon=0.0001) -> bool
        isNear(Transform self, Transform pT2) -> bool
        """
        return _almathswig.Transform_isNear(self, pT2, pEpsilon)


    def isTransform(self, pEpsilon=0.0001):
        """
        isTransform(Transform self, float const & pEpsilon=0.0001) -> bool
        isTransform(Transform self) -> bool
        """
        return _almathswig.Transform_isTransform(self, pEpsilon)


    def normalizeTransform(self):
        """normalizeTransform(Transform self)"""
        return _almathswig.Transform_normalizeTransform(self)


    def norm(self):
        """norm(Transform self) -> float"""
        return _almathswig.Transform_norm(self)


    def determinant(self):
        """determinant(Transform self) -> float"""
        return _almathswig.Transform_determinant(self)


    def inverse(self):
        """inverse(Transform self) -> Transform"""
        return _almathswig.Transform_inverse(self)


    def fromRotX(pRotX):
        """fromRotX(float const pRotX) -> Transform"""
        return _almathswig.Transform_fromRotX(pRotX)

    if _newclass:
        fromRotX = staticmethod(fromRotX)
    __swig_getmethods__["fromRotX"] = lambda x: fromRotX

    def fromRotY(pRotY):
        """fromRotY(float const pRotY) -> Transform"""
        return _almathswig.Transform_fromRotY(pRotY)

    if _newclass:
        fromRotY = staticmethod(fromRotY)
    __swig_getmethods__["fromRotY"] = lambda x: fromRotY

    def fromRotZ(pRotZ):
        """fromRotZ(float const pRotZ) -> Transform"""
        return _almathswig.Transform_fromRotZ(pRotZ)

    if _newclass:
        fromRotZ = staticmethod(fromRotZ)
    __swig_getmethods__["fromRotZ"] = lambda x: fromRotZ

    def from3DRotation(pWX, pWY, pWZ):
        """from3DRotation(float const & pWX, float const & pWY, float const & pWZ) -> Transform"""
        return _almathswig.Transform_from3DRotation(pWX, pWY, pWZ)

    if _newclass:
        from3DRotation = staticmethod(from3DRotation)
    __swig_getmethods__["from3DRotation"] = lambda x: from3DRotation

    def fromPosition(*args):
        """
        fromPosition(float const pX, float const pY, float const pZ) -> Transform
        fromPosition(float const & pX, float const & pY, float const & pZ, float const & pWX, float const & pWY, float const & pWZ) -> Transform
        """
        return _almathswig.Transform_fromPosition(*args)

    if _newclass:
        fromPosition = staticmethod(fromPosition)
    __swig_getmethods__["fromPosition"] = lambda x: fromPosition

    def diff(self, pT2):
        """diff(Transform self, Transform pT2) -> Transform"""
        return _almathswig.Transform_diff(self, pT2)


    def distanceSquared(self, pT2):
        """distanceSquared(Transform self, Transform pT2) -> float"""
        return _almathswig.Transform_distanceSquared(self, pT2)


    def distance(self, pT2):
        """distance(Transform self, Transform pT2) -> float"""
        return _almathswig.Transform_distance(self, pT2)


    def toVector(self, *args):
        """
        toVector(Transform self, vectorFloat pReturnVector)
        toVector(Transform self) -> vectorFloat
        """
        return _almathswig.Transform_toVector(self, *args)


    def writeToVector(self, pIt):
        """writeToVector(Transform self, std::vector< float,std::allocator< float > >::iterator & pIt)"""
        return _almathswig.Transform_writeToVector(self, pIt)


    def __str__(self):
        """__str__(Transform self) -> char *"""
        return _almathswig.Transform___str__(self)


    def __repr__(self):
        """__repr__(Transform self) -> char *"""
        return _almathswig.Transform___repr__(self)


    def __mul__(self, *args):
        """
        __mul__(Transform self, Transform pT2) -> Transform
        __mul__(Transform self, Position3D rhs) -> Position3D
        """
        return _almathswig.Transform___mul__(self, *args)

    __swig_destroy__ = _almathswig.delete_Transform
    __del__ = lambda self: None
Transform_swigregister = _almathswig.Transform_swigregister
Transform_swigregister(Transform)

def Transform_fromRotX(pRotX):
    """Transform_fromRotX(float const pRotX) -> Transform"""
    return _almathswig.Transform_fromRotX(pRotX)

def Transform_fromRotY(pRotY):
    """Transform_fromRotY(float const pRotY) -> Transform"""
    return _almathswig.Transform_fromRotY(pRotY)

def Transform_fromRotZ(pRotZ):
    """Transform_fromRotZ(float const pRotZ) -> Transform"""
    return _almathswig.Transform_fromRotZ(pRotZ)

def Transform_from3DRotation(pWX, pWY, pWZ):
    """Transform_from3DRotation(float const & pWX, float const & pWY, float const & pWZ) -> Transform"""
    return _almathswig.Transform_from3DRotation(pWX, pWY, pWZ)

def Transform_fromPosition(*args):
    """
    fromPosition(float const pX, float const pY, float const pZ) -> Transform
    Transform_fromPosition(float const & pX, float const & pY, float const & pZ, float const & pWX, float const & pWY, float const & pWZ) -> Transform
    """
    return _almathswig.Transform_fromPosition(*args)


def transformPreMultiply(pT, pTOut):
    """transformPreMultiply(Transform pT, Transform pTOut)"""
    return _almathswig.transformPreMultiply(pT, pTOut)

def normalizeTransform(pT):
    """normalizeTransform(Transform pT)"""
    return _almathswig.normalizeTransform(pT)

def transformToFloatVector(*args):
    """
    transformToFloatVector(Transform pT, vectorFloat pTOut)
    transformToFloatVector(Transform pT) -> vectorFloat
    """
    return _almathswig.transformToFloatVector(*args)

def determinant(*args):
    """
    determinant(Rotation pRot) -> float
    determinant(Transform pT) -> float
    determinant(vectorFloat pFloats) -> float
    """
    return _almathswig.determinant(*args)

def transformInverse(*args):
    """
    transformInverse(Transform pT, Transform pTOut)
    transformInverse(Transform pT) -> Transform
    """
    return _almathswig.transformInverse(*args)

def transformFromRotX(pRotX):
    """transformFromRotX(float const pRotX) -> Transform"""
    return _almathswig.transformFromRotX(pRotX)

def transformFromRotY(pRotY):
    """transformFromRotY(float const pRotY) -> Transform"""
    return _almathswig.transformFromRotY(pRotY)

def transformFromRotZ(pRotZ):
    """transformFromRotZ(float const pRotZ) -> Transform"""
    return _almathswig.transformFromRotZ(pRotZ)

def transformFrom3DRotation(pWX, pWY, pWZ):
    """transformFrom3DRotation(float const & pWX, float const & pWY, float const & pWZ) -> Transform"""
    return _almathswig.transformFrom3DRotation(pWX, pWY, pWZ)

def transformFromPosition(*args):
    """
    transformFromPosition(float const & pX, float const & pY, float const & pZ) -> Transform
    transformFromPosition(float const & pX, float const & pY, float const & pZ, float const & pWX, float const & pWY, float const & pWZ) -> Transform
    """
    return _almathswig.transformFromPosition(*args)

def transformInvertInPlace(pT):
    """transformInvertInPlace(Transform pT)"""
    return _almathswig.transformInvertInPlace(pT)

def pinv(*args):
    """
    pinv(Pose2D pPos) -> Pose2D
    pinv(Transform pT) -> Transform
    """
    return _almathswig.pinv(*args)

def transformDiff(pT1, pT2):
    """transformDiff(Transform pT1, Transform pT2) -> Transform"""
    return _almathswig.transformDiff(pT1, pT2)

def transformDistanceSquared(pT1, pT2):
    """transformDistanceSquared(Transform pT1, Transform pT2) -> float"""
    return _almathswig.transformDistanceSquared(pT1, pT2)

def transformDistance(pT1, pT2):
    """transformDistance(Transform pT1, Transform pT2) -> float"""
    return _almathswig.transformDistance(pT1, pT2)
class Velocity3D(_object):
    """Proxy of C++ AL::Math::Velocity3D class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Velocity3D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Velocity3D, name)
    __swig_setmethods__["xd"] = _almathswig.Velocity3D_xd_set
    __swig_getmethods__["xd"] = _almathswig.Velocity3D_xd_get
    if _newclass:
        xd = _swig_property(_almathswig.Velocity3D_xd_get, _almathswig.Velocity3D_xd_set)
    __swig_setmethods__["yd"] = _almathswig.Velocity3D_yd_set
    __swig_getmethods__["yd"] = _almathswig.Velocity3D_yd_get
    if _newclass:
        yd = _swig_property(_almathswig.Velocity3D_yd_get, _almathswig.Velocity3D_yd_set)
    __swig_setmethods__["zd"] = _almathswig.Velocity3D_zd_set
    __swig_getmethods__["zd"] = _almathswig.Velocity3D_zd_get
    if _newclass:
        zd = _swig_property(_almathswig.Velocity3D_zd_get, _almathswig.Velocity3D_zd_set)

    def __init__(self, *args):
        """
        __init__(AL::Math::Velocity3D self) -> Velocity3D
        __init__(AL::Math::Velocity3D self, float pInit) -> Velocity3D
        __init__(AL::Math::Velocity3D self, float pXd, float pYd, float pZd) -> Velocity3D
        __init__(AL::Math::Velocity3D self, vectorFloat pFloats) -> Velocity3D
        """
        this = _almathswig.new_Velocity3D(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __add__(self, pVel2):
        """__add__(Velocity3D self, Velocity3D pVel2) -> Velocity3D"""
        return _almathswig.Velocity3D___add__(self, pVel2)


    def __sub__(self, pVel2):
        """__sub__(Velocity3D self, Velocity3D pVel2) -> Velocity3D"""
        return _almathswig.Velocity3D___sub__(self, pVel2)


    def __pos__(self):
        """__pos__(Velocity3D self) -> Velocity3D"""
        return _almathswig.Velocity3D___pos__(self)


    def __neg__(self):
        """__neg__(Velocity3D self) -> Velocity3D"""
        return _almathswig.Velocity3D___neg__(self)


    def __iadd__(self, pVel2):
        """__iadd__(Velocity3D self, Velocity3D pVel2) -> Velocity3D"""
        return _almathswig.Velocity3D___iadd__(self, pVel2)


    def __isub__(self, pVel2):
        """__isub__(Velocity3D self, Velocity3D pVel2) -> Velocity3D"""
        return _almathswig.Velocity3D___isub__(self, pVel2)


    def __eq__(self, pVel2):
        """__eq__(Velocity3D self, Velocity3D pVel2) -> bool"""
        return _almathswig.Velocity3D___eq__(self, pVel2)


    def __ne__(self, pVel2):
        """__ne__(Velocity3D self, Velocity3D pVel2) -> bool"""
        return _almathswig.Velocity3D___ne__(self, pVel2)


    def __mul__(self, pVal):
        """__mul__(Velocity3D self, float const pVal) -> Velocity3D"""
        return _almathswig.Velocity3D___mul__(self, pVal)


    def __div__(self, pVal):
        """__div__(Velocity3D self, float const pVal) -> Velocity3D"""
        return _almathswig.Velocity3D___div__(self, pVal)


    def __imul__(self, pVal):
        """__imul__(Velocity3D self, float const pVal) -> Velocity3D"""
        return _almathswig.Velocity3D___imul__(self, pVal)


    def __idiv__(self, pVal):
        """__idiv__(Velocity3D self, float const pVal) -> Velocity3D"""
        return _almathswig.Velocity3D___idiv__(self, pVal)


    def isNear(self, pVel2, pEpsilon=0.0001):
        """
        isNear(Velocity3D self, Velocity3D pVel2, float const & pEpsilon=0.0001) -> bool
        isNear(Velocity3D self, Velocity3D pVel2) -> bool
        """
        return _almathswig.Velocity3D_isNear(self, pVel2, pEpsilon)


    def norm(self):
        """norm(Velocity3D self) -> float"""
        return _almathswig.Velocity3D_norm(self)


    def normalize(self):
        """normalize(Velocity3D self) -> Velocity3D"""
        return _almathswig.Velocity3D_normalize(self)


    def toVector(self, *args):
        """
        toVector(Velocity3D self, vectorFloat pReturnValue)
        toVector(Velocity3D self) -> vectorFloat
        """
        return _almathswig.Velocity3D_toVector(self, *args)


    def writeToVector(self, pIt):
        """writeToVector(Velocity3D self, std::vector< float,std::allocator< float > >::iterator & pIt)"""
        return _almathswig.Velocity3D_writeToVector(self, pIt)


    def __repr__(self):
        """__repr__(Velocity3D self) -> char *"""
        return _almathswig.Velocity3D___repr__(self)


    def __rmul__(self, lhs):
        """__rmul__(Velocity3D self, float const lhs) -> Velocity3D"""
        return _almathswig.Velocity3D___rmul__(self, lhs)

    __swig_destroy__ = _almathswig.delete_Velocity3D
    __del__ = lambda self: None
Velocity3D_swigregister = _almathswig.Velocity3D_swigregister
Velocity3D_swigregister(Velocity3D)

class Velocity6D(_object):
    """Proxy of C++ AL::Math::Velocity6D class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Velocity6D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Velocity6D, name)
    __swig_setmethods__["xd"] = _almathswig.Velocity6D_xd_set
    __swig_getmethods__["xd"] = _almathswig.Velocity6D_xd_get
    if _newclass:
        xd = _swig_property(_almathswig.Velocity6D_xd_get, _almathswig.Velocity6D_xd_set)
    __swig_setmethods__["yd"] = _almathswig.Velocity6D_yd_set
    __swig_getmethods__["yd"] = _almathswig.Velocity6D_yd_get
    if _newclass:
        yd = _swig_property(_almathswig.Velocity6D_yd_get, _almathswig.Velocity6D_yd_set)
    __swig_setmethods__["zd"] = _almathswig.Velocity6D_zd_set
    __swig_getmethods__["zd"] = _almathswig.Velocity6D_zd_get
    if _newclass:
        zd = _swig_property(_almathswig.Velocity6D_zd_get, _almathswig.Velocity6D_zd_set)
    __swig_setmethods__["wxd"] = _almathswig.Velocity6D_wxd_set
    __swig_getmethods__["wxd"] = _almathswig.Velocity6D_wxd_get
    if _newclass:
        wxd = _swig_property(_almathswig.Velocity6D_wxd_get, _almathswig.Velocity6D_wxd_set)
    __swig_setmethods__["wyd"] = _almathswig.Velocity6D_wyd_set
    __swig_getmethods__["wyd"] = _almathswig.Velocity6D_wyd_get
    if _newclass:
        wyd = _swig_property(_almathswig.Velocity6D_wyd_get, _almathswig.Velocity6D_wyd_set)
    __swig_setmethods__["wzd"] = _almathswig.Velocity6D_wzd_set
    __swig_getmethods__["wzd"] = _almathswig.Velocity6D_wzd_get
    if _newclass:
        wzd = _swig_property(_almathswig.Velocity6D_wzd_get, _almathswig.Velocity6D_wzd_set)

    def __init__(self, *args):
        """
        __init__(AL::Math::Velocity6D self) -> Velocity6D
        __init__(AL::Math::Velocity6D self, float pInit) -> Velocity6D
        __init__(AL::Math::Velocity6D self, float pXd, float pYd, float pZd, float pWxd, float pWyd, float pWzd) -> Velocity6D
        __init__(AL::Math::Velocity6D self, vectorFloat pFloats) -> Velocity6D
        """
        this = _almathswig.new_Velocity6D(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __add__(self, pVel2):
        """__add__(Velocity6D self, Velocity6D pVel2) -> Velocity6D"""
        return _almathswig.Velocity6D___add__(self, pVel2)


    def __sub__(self, pVel2):
        """__sub__(Velocity6D self, Velocity6D pVel2) -> Velocity6D"""
        return _almathswig.Velocity6D___sub__(self, pVel2)


    def __pos__(self):
        """__pos__(Velocity6D self) -> Velocity6D"""
        return _almathswig.Velocity6D___pos__(self)


    def __neg__(self):
        """__neg__(Velocity6D self) -> Velocity6D"""
        return _almathswig.Velocity6D___neg__(self)


    def __mul__(self, pVal):
        """__mul__(Velocity6D self, float const pVal) -> Velocity6D"""
        return _almathswig.Velocity6D___mul__(self, pVal)


    def __div__(self, pVal):
        """__div__(Velocity6D self, float const pVal) -> Velocity6D"""
        return _almathswig.Velocity6D___div__(self, pVal)


    def __eq__(self, pVel2):
        """__eq__(Velocity6D self, Velocity6D pVel2) -> bool"""
        return _almathswig.Velocity6D___eq__(self, pVel2)


    def __ne__(self, pVel2):
        """__ne__(Velocity6D self, Velocity6D pVel2) -> bool"""
        return _almathswig.Velocity6D___ne__(self, pVel2)


    def __imul__(self, pVal):
        """__imul__(Velocity6D self, float const pVal) -> Velocity6D"""
        return _almathswig.Velocity6D___imul__(self, pVal)


    def __idiv__(self, pVal):
        """__idiv__(Velocity6D self, float const pVal) -> Velocity6D"""
        return _almathswig.Velocity6D___idiv__(self, pVal)


    def isNear(self, pVel2, pEpsilon=0.0001):
        """
        isNear(Velocity6D self, Velocity6D pVel2, float const & pEpsilon=0.0001) -> bool
        isNear(Velocity6D self, Velocity6D pVel2) -> bool
        """
        return _almathswig.Velocity6D_isNear(self, pVel2, pEpsilon)


    def norm(self):
        """norm(Velocity6D self) -> float"""
        return _almathswig.Velocity6D_norm(self)


    def normalize(self):
        """normalize(Velocity6D self) -> Velocity6D"""
        return _almathswig.Velocity6D_normalize(self)


    def toVector(self, *args):
        """
        toVector(Velocity6D self, vectorFloat pReturnVector)
        toVector(Velocity6D self) -> vectorFloat
        """
        return _almathswig.Velocity6D_toVector(self, *args)


    def writeToVector(self, pIt):
        """writeToVector(Velocity6D self, std::vector< float,std::allocator< float > >::iterator & pIt)"""
        return _almathswig.Velocity6D_writeToVector(self, pIt)


    def __repr__(self):
        """__repr__(Velocity6D self) -> char *"""
        return _almathswig.Velocity6D___repr__(self)


    def __rmul__(self, lhs):
        """__rmul__(Velocity6D self, float const lhs) -> Velocity6D"""
        return _almathswig.Velocity6D___rmul__(self, lhs)

    __swig_destroy__ = _almathswig.delete_Velocity6D
    __del__ = lambda self: None
Velocity6D_swigregister = _almathswig.Velocity6D_swigregister
Velocity6D_swigregister(Velocity6D)


def norm(*args):
    """
    norm(Position2D pPos) -> float
    norm(Position3D pPos) -> float
    norm(Position6D pPos) -> float
    norm(Quaternion pQua) -> float
    norm(Rotation3D pRot) -> float
    norm(Transform pT) -> float
    norm(Velocity3D pVel) -> float
    norm(Velocity6D pVel) -> float
    """
    return _almathswig.norm(*args)

def normalize(*args):
    """
    normalize(Position2D pPos) -> Position2D
    normalize(Position3D pPos) -> Position3D
    normalize(Position6D pPos) -> Position6D
    normalize(Quaternion pQua) -> Quaternion
    normalize(Velocity3D pVel) -> Velocity3D
    normalize(Velocity6D pVel) -> Velocity6D
    """
    return _almathswig.normalize(*args)
class TransformAndVelocity6D(_object):
    """Proxy of C++ AL::Math::TransformAndVelocity6D class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TransformAndVelocity6D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TransformAndVelocity6D, name)
    __swig_setmethods__["T"] = _almathswig.TransformAndVelocity6D_T_set
    __swig_getmethods__["T"] = _almathswig.TransformAndVelocity6D_T_get
    if _newclass:
        T = _swig_property(_almathswig.TransformAndVelocity6D_T_get, _almathswig.TransformAndVelocity6D_T_set)
    __swig_setmethods__["V"] = _almathswig.TransformAndVelocity6D_V_set
    __swig_getmethods__["V"] = _almathswig.TransformAndVelocity6D_V_get
    if _newclass:
        V = _swig_property(_almathswig.TransformAndVelocity6D_V_get, _almathswig.TransformAndVelocity6D_V_set)

    def __init__(self, *args):
        """
        __init__(AL::Math::TransformAndVelocity6D self) -> TransformAndVelocity6D
        __init__(AL::Math::TransformAndVelocity6D self, Transform pT, Velocity6D pV) -> TransformAndVelocity6D
        """
        this = _almathswig.new_TransformAndVelocity6D(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def isNear(self, pTV2, pEpsilon=0.0001):
        """
        isNear(TransformAndVelocity6D self, TransformAndVelocity6D pTV2, float const & pEpsilon=0.0001) -> bool
        isNear(TransformAndVelocity6D self, TransformAndVelocity6D pTV2) -> bool
        """
        return _almathswig.TransformAndVelocity6D_isNear(self, pTV2, pEpsilon)


    def __repr__(self):
        """__repr__(TransformAndVelocity6D self) -> char *"""
        return _almathswig.TransformAndVelocity6D___repr__(self)

    __swig_destroy__ = _almathswig.delete_TransformAndVelocity6D
    __del__ = lambda self: None
TransformAndVelocity6D_swigregister = _almathswig.TransformAndVelocity6D_swigregister
TransformAndVelocity6D_swigregister(TransformAndVelocity6D)


def getDubinsSolutions(pTargetPose, pCircleRadius):
    """getDubinsSolutions(Pose2D pTargetPose, float const pCircleRadius) -> vectorPose2D"""
    return _almathswig.getDubinsSolutions(pTargetPose, pCircleRadius)

def avoidFootCollision(pLFootBoundingBox, pRFootBoundingBox, pIsLeftSupport, pMove):
    """avoidFootCollision(vectorPosition2D pLFootBoundingBox, vectorPosition2D pRFootBoundingBox, bool const & pIsLeftSupport, Pose2D pMove) -> bool const"""
    return _almathswig.avoidFootCollision(pLFootBoundingBox, pRFootBoundingBox, pIsLeftSupport, pMove)

def clipFootWithEllipse(pMaxFootX, pMaxFootY, pMove):
    """clipFootWithEllipse(float const & pMaxFootX, float const & pMaxFootY, Pose2D pMove) -> bool const"""
    return _almathswig.clipFootWithEllipse(pMaxFootX, pMaxFootY, pMove)

def areTwoBoxesInCollision(pBoxA, pBoxB):
    """areTwoBoxesInCollision(vectorPosition2D pBoxA, vectorPosition2D pBoxB) -> bool const"""
    return _almathswig.areTwoBoxesInCollision(pBoxA, pBoxB)

def computeBox(pInitBox, pMove, pMovedBox):
    """computeBox(vectorPosition2D pInitBox, Pose2D pMove, vectorPosition2D pMovedBox)"""
    return _almathswig.computeBox(pInitBox, pMove, pMovedBox)

def dichotomie(pFixedBox, pMovingBox, pMove):
    """dichotomie(vectorPosition2D pFixedBox, vectorPosition2D pMovingBox, Pose2D pMove) -> void const"""
    return _almathswig.dichotomie(pFixedBox, pMovingBox, pMove)

def intersectionSegment2D(pA1, pA2, pB1, pB2, pC):
    """intersectionSegment2D(Position2D pA1, Position2D pA2, Position2D pB1, Position2D pB2, Position2D pC) -> bool"""
    return _almathswig.intersectionSegment2D(pA1, pA2, pB1, pB2, pC)

def transformLogarithmInPlace(pT, pVel):
    """transformLogarithmInPlace(Transform pT, Velocity6D pVel)"""
    return _almathswig.transformLogarithmInPlace(pT, pVel)

def transformLogarithm(pT):
    """transformLogarithm(Transform pT) -> Velocity6D"""
    return _almathswig.transformLogarithm(pT)

def velocityExponential(pVel):
    """velocityExponential(Velocity6D pVel) -> Transform"""
    return _almathswig.velocityExponential(pVel)

def velocityExponentialInPlace(pVel, pT):
    """velocityExponentialInPlace(Velocity6D pVel, Transform pT)"""
    return _almathswig.velocityExponentialInPlace(pVel, pT)

def changeReferenceVelocity6D(pT, pVelIn, pVelOut):
    """changeReferenceVelocity6D(Transform pT, Velocity6D pVelIn, Velocity6D pVelOut)"""
    return _almathswig.changeReferenceVelocity6D(pT, pVelIn, pVelOut)

def changeReferencePosition6D(pT, pPosIn, pPosOut):
    """changeReferencePosition6D(Transform pT, Position6D pPosIn, Position6D pPosOut)"""
    return _almathswig.changeReferencePosition6D(pT, pPosIn, pPosOut)

def changeReferencePosition3DInPlace(pT, pPosOut):
    """changeReferencePosition3DInPlace(Transform pT, Position3D pPosOut)"""
    return _almathswig.changeReferencePosition3DInPlace(pT, pPosOut)

def changeReferenceTransposePosition3DInPlace(pT, pPosOut):
    """changeReferenceTransposePosition3DInPlace(Transform pT, Position3D pPosOut)"""
    return _almathswig.changeReferenceTransposePosition3DInPlace(pT, pPosOut)

def changeReferencePosition3D(pT, pPosIn, pPosOut):
    """changeReferencePosition3D(Transform pT, Position3D pPosIn, Position3D pPosOut)"""
    return _almathswig.changeReferencePosition3D(pT, pPosIn, pPosOut)

def changeReferenceTransposePosition3D(pT, pPosIn, pPosOut):
    """changeReferenceTransposePosition3D(Transform pT, Position3D pPosIn, Position3D pPosOut)"""
    return _almathswig.changeReferenceTransposePosition3D(pT, pPosIn, pPosOut)

def changeReferenceTransform(pT, pTIn, pTOut):
    """changeReferenceTransform(Transform pT, Transform pTIn, Transform pTOut)"""
    return _almathswig.changeReferenceTransform(pT, pTIn, pTOut)

def changeReferenceTransposeTransform(pT, pTIn, pTOut):
    """changeReferenceTransposeTransform(Transform pT, Transform pTIn, Transform pTOut)"""
    return _almathswig.changeReferenceTransposeTransform(pT, pTIn, pTOut)

def changeReferenceTransposeVelocity6D(pT, pVelIn, pVelOut):
    """changeReferenceTransposeVelocity6D(Transform pT, Velocity6D pVelIn, Velocity6D pVelOut)"""
    return _almathswig.changeReferenceTransposeVelocity6D(pT, pVelIn, pVelOut)

def changeReferenceTransposePosition6D(pT, pPosIn, pPosOut):
    """changeReferenceTransposePosition6D(Transform pT, Position6D pPosIn, Position6D pPosOut)"""
    return _almathswig.changeReferenceTransposePosition6D(pT, pPosIn, pPosOut)

def transformMeanInPlace(pTIn1, pTIn2, pVal, pTOut):
    """transformMeanInPlace(Transform pTIn1, Transform pTIn2, float const & pVal, Transform pTOut)"""
    return _almathswig.transformMeanInPlace(pTIn1, pTIn2, pVal, pTOut)

def transformMean(pTIn1, pTIn2, pVal=0.5):
    """
    transformMean(Transform pTIn1, Transform pTIn2, float const & pVal=0.5) -> Transform
    transformMean(Transform pTIn1, Transform pTIn2) -> Transform
    """
    return _almathswig.transformMean(pTIn1, pTIn2, pVal)

def transformFromRotationPosition3D(*args):
    """
    transformFromRotationPosition3D(Rotation pRot, float const & pX, float const & pY, float const & pZ) -> Transform
    transformFromRotationPosition3D(Rotation pRot, Position3D pPos) -> Transform
    """
    return _almathswig.transformFromRotationPosition3D(*args)

def transformFromPosition3DInPlace(pPosition, pTransform):
    """transformFromPosition3DInPlace(Position3D pPosition, Transform pTransform)"""
    return _almathswig.transformFromPosition3DInPlace(pPosition, pTransform)

def transformFromPosition3D(pPosition):
    """transformFromPosition3D(Position3D pPosition) -> Transform"""
    return _almathswig.transformFromPosition3D(pPosition)

def transformFromRotationInPlace(pRotation, pTransform):
    """transformFromRotationInPlace(Rotation pRotation, Transform pTransform)"""
    return _almathswig.transformFromRotationInPlace(pRotation, pTransform)

def transformFromRotation(pRotation):
    """transformFromRotation(Rotation pRotation) -> Transform"""
    return _almathswig.transformFromRotation(pRotation)

def rotationFromTransformInPlace(pTransform, pRotation):
    """rotationFromTransformInPlace(Transform pTransform, Rotation pRotation)"""
    return _almathswig.rotationFromTransformInPlace(pTransform, pRotation)

def rotationFromTransform(pTransform):
    """rotationFromTransform(Transform pTransform) -> Rotation"""
    return _almathswig.rotationFromTransform(pTransform)

def rotation3DFromRotation(pRotation):
    """rotation3DFromRotation(Rotation pRotation) -> Rotation3D"""
    return _almathswig.rotation3DFromRotation(pRotation)

def rotationFromAxesXY(pX, pY):
    """rotationFromAxesXY(Position3D pX, Position3D pY) -> Rotation"""
    return _almathswig.rotationFromAxesXY(pX, pY)

def rotationFromAxesXZ(pX, pZ):
    """rotationFromAxesXZ(Position3D pX, Position3D pZ) -> Rotation"""
    return _almathswig.rotationFromAxesXZ(pX, pZ)

def rotationFromAxesYZ(pY, pZ):
    """rotationFromAxesYZ(Position3D pY, Position3D pZ) -> Rotation"""
    return _almathswig.rotationFromAxesYZ(pY, pZ)

def rotationFromAxesXYZ(pX, pY, pZ):
    """rotationFromAxesXYZ(Position3D pX, Position3D pY, Position3D pZ) -> Rotation"""
    return _almathswig.rotationFromAxesXYZ(pX, pY, pZ)

def position6DFromTransformInPlace(pT, pPos):
    """position6DFromTransformInPlace(Transform pT, Position6D pPos)"""
    return _almathswig.position6DFromTransformInPlace(pT, pPos)

def position6DFromTransform(pT):
    """position6DFromTransform(Transform pT) -> Position6D"""
    return _almathswig.position6DFromTransform(pT)

def transformFromPose2DInPlace(pPose, pT):
    """transformFromPose2DInPlace(Pose2D pPose, Transform pT)"""
    return _almathswig.transformFromPose2DInPlace(pPose, pT)

def transformFromPose2D(pPose):
    """transformFromPose2D(Pose2D pPose) -> Transform"""
    return _almathswig.transformFromPose2D(pPose)

def pose2DFromTransformInPlace(pT, pPos):
    """pose2DFromTransformInPlace(Transform pT, Pose2D pPos)"""
    return _almathswig.pose2DFromTransformInPlace(pT, pPos)

def pose2DFromTransform(pT):
    """pose2DFromTransform(Transform pT) -> Pose2D"""
    return _almathswig.pose2DFromTransform(pT)

def position2DFromTransformInPlace(pT, pPos):
    """position2DFromTransformInPlace(Transform pT, Position2D pPos)"""
    return _almathswig.position2DFromTransformInPlace(pT, pPos)

def position2DFromTransform(pT):
    """position2DFromTransform(Transform pT) -> Position2D"""
    return _almathswig.position2DFromTransform(pT)

def transformFromRotation3D(pRotation):
    """transformFromRotation3D(Rotation3D pRotation) -> Transform"""
    return _almathswig.transformFromRotation3D(pRotation)

def transformFromPosition6D(pPosition6D):
    """transformFromPosition6D(Position6D pPosition6D) -> Transform"""
    return _almathswig.transformFromPosition6D(pPosition6D)

def position6DFromTransformDiffInPlace(pCurrent, pTarget, result):
    """position6DFromTransformDiffInPlace(Transform pCurrent, Transform pTarget, Position6D result)"""
    return _almathswig.position6DFromTransformDiffInPlace(pCurrent, pTarget, result)

def position6DFromTransformDiff(pCurrent, pTarget):
    """position6DFromTransformDiff(Transform pCurrent, Transform pTarget) -> Position6D"""
    return _almathswig.position6DFromTransformDiff(pCurrent, pTarget)

def position3DFromTransformInPlace(pT, pPos):
    """position3DFromTransformInPlace(Transform pT, Position3D pPos)"""
    return _almathswig.position3DFromTransformInPlace(pT, pPos)

def position3DFromTransform(pT):
    """position3DFromTransform(Transform pT) -> Position3D"""
    return _almathswig.position3DFromTransform(pT)

def rotation3DFromTransform(pT):
    """rotation3DFromTransform(Transform pT) -> Rotation3D"""
    return _almathswig.rotation3DFromTransform(pT)

def transformFromRotVecInPlace(*args):
    """
    transformFromRotVecInPlace(int const pAxis, float const pTheta, Position3D pPos, Transform pT)
    transformFromRotVecInPlace(Position3D pPos, Transform pT)
    """
    return _almathswig.transformFromRotVecInPlace(*args)

def transformFromRotVec(*args):
    """
    transformFromRotVec(int const pAxis, float const pTheta, Position3D pPos) -> Transform
    transformFromRotVec(Position3D pPos) -> Transform
    transformFromRotVec(int const & pAxis, float const & pTheta) -> Transform
    """
    return _almathswig.transformFromRotVec(*args)

def axisRotationProjection(*args):
    """
    axisRotationProjection(Position3D pAxis, Transform pT) -> Transform
    axisRotationProjection(Position3D pAxis, Rotation pRot) -> Rotation
    """
    return _almathswig.axisRotationProjection(*args)

def axisRotationProjectionInPlace(*args):
    """
    axisRotationProjectionInPlace(Position3D pAxis, Transform pT)
    axisRotationProjectionInPlace(Position3D pAxis, Rotation pRot)
    """
    return _almathswig.axisRotationProjectionInPlace(*args)

def orthogonalSpace(*args):
    """
    orthogonalSpace(Position3D pPos, Transform pTf)
    orthogonalSpace(Position3D pPos) -> Transform
    """
    return _almathswig.orthogonalSpace(*args)

def transformFromQuaternion(pQua):
    """transformFromQuaternion(Quaternion pQua) -> Transform"""
    return _almathswig.transformFromQuaternion(pQua)

def quaternionFromTransform(pT):
    """quaternionFromTransform(Transform pT) -> Quaternion"""
    return _almathswig.quaternionFromTransform(pT)

def transformFromDisplacement(pDisp):
    """transformFromDisplacement(Displacement pDisp) -> Transform"""
    return _almathswig.transformFromDisplacement(pDisp)

def displacementFromTransform(pTrans):
    """displacementFromTransform(Transform pTrans) -> Displacement"""
    return _almathswig.displacementFromTransform(pTrans)

def modulo2PIInPlace(pAngle):
    """modulo2PIInPlace(float & pAngle)"""
    return _almathswig.modulo2PIInPlace(pAngle)

def modulo2PI(pAngle):
    """modulo2PI(float pAngle) -> float"""
    return _almathswig.modulo2PI(pAngle)

def meanAngle(pAngles):
    """meanAngle(vectorFloat pAngles) -> float"""
    return _almathswig.meanAngle(pAngles)

def weightedMeanAngle(pAngles, pWeights):
    """weightedMeanAngle(vectorFloat pAngles, vectorFloat pWeights) -> float"""
    return _almathswig.weightedMeanAngle(pAngles, pWeights)

def clipData(*args):
    """
    clipData(float const & pMin, float const & pMax, float & pData) -> bool
    clipData(float const & pMin, float const & pMax, vectorFloat pData) -> bool
    clipData(float const & pMin, float const & pMax, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > & pData) -> bool
    """
    return _almathswig.clipData(*args)

def changeReferencePose2D(pTheta, pPosIn, pPosOut):
    """changeReferencePose2D(float const & pTheta, Pose2D pPosIn, Pose2D pPosOut)"""
    return _almathswig.changeReferencePose2D(pTheta, pPosIn, pPosOut)

def changeReferencePose2DInPlace(pTheta, pPosOut):
    """changeReferencePose2DInPlace(float const & pTheta, Pose2D pPosOut)"""
    return _almathswig.changeReferencePose2DInPlace(pTheta, pPosOut)

def position6DFromVelocity6D(pVel):
    """position6DFromVelocity6D(Velocity6D pVel) -> Position6D"""
    return _almathswig.position6DFromVelocity6D(pVel)

def position2DFromPose2DInPlace(pPose2D, pPosition2D):
    """position2DFromPose2DInPlace(Pose2D pPose2D, Position2D pPosition2D)"""
    return _almathswig.position2DFromPose2DInPlace(pPose2D, pPosition2D)

def position2DFromPose2D(pPose2D):
    """position2DFromPose2D(Pose2D pPose2D) -> Position2D"""
    return _almathswig.position2DFromPose2D(pPose2D)

def position3DFromPosition6D(pPosition6D):
    """position3DFromPosition6D(Position6D pPosition6D) -> Position3D"""
    return _almathswig.position3DFromPosition6D(pPosition6D)

def rotationFromAngleDirection(*args):
    """
    rotationFromAngleDirection(float const pAngle, float const pX, float const pY, float const pZ) -> Rotation
    rotationFromAngleDirection(float const & pTheta, Position3D pPos) -> Rotation
    """
    return _almathswig.rotationFromAngleDirection(*args)

def position6DFromPose2DInPlace(pPose2D, pPosition6D):
    """position6DFromPose2DInPlace(Pose2D pPose2D, Position6D pPosition6D)"""
    return _almathswig.position6DFromPose2DInPlace(pPose2D, pPosition6D)

def position6DFromPose2D(pPose2D):
    """position6DFromPose2D(Pose2D pPose2D) -> Position6D"""
    return _almathswig.position6DFromPose2D(pPose2D)

def position6DFromPosition3DInPlace(pPosition3D, pPosition6D):
    """position6DFromPosition3DInPlace(Position3D pPosition3D, Position6D pPosition6D)"""
    return _almathswig.position6DFromPosition3DInPlace(pPosition3D, pPosition6D)

def position6DFromPosition3D(pPosition3D):
    """position6DFromPosition3D(Position3D pPosition3D) -> Position6D"""
    return _almathswig.position6DFromPosition3D(pPosition3D)

def pose2DFromPosition6DInPlace(pPosition6D, pPose2D):
    """pose2DFromPosition6DInPlace(Position6D pPosition6D, Pose2D pPose2D)"""
    return _almathswig.pose2DFromPosition6DInPlace(pPosition6D, pPose2D)

def pose2DFromPosition6D(pPosition6D):
    """pose2DFromPosition6D(Position6D pPosition6D) -> Pose2D"""
    return _almathswig.pose2DFromPosition6D(pPosition6D)

def pose2DFromPosition2DInPlace(pPosition2D, pAngle, pPose2D):
    """pose2DFromPosition2DInPlace(Position2D pPosition2D, float const pAngle, Pose2D pPose2D)"""
    return _almathswig.pose2DFromPosition2DInPlace(pPosition2D, pAngle, pPose2D)

def pose2DFromPosition2D(pPosition2D, pAngle=0.0):
    """
    pose2DFromPosition2D(Position2D pPosition2D, float const pAngle=0.0) -> Pose2D
    pose2DFromPosition2D(Position2D pPosition2D) -> Pose2D
    """
    return _almathswig.pose2DFromPosition2D(pPosition2D, pAngle)

def __mul__(*args):
    """
    __mul__(float const pM, Position2D pPos1) -> Position2D
    __mul__(float const pM, Velocity3D pVel1) -> Velocity3D
    __mul__(float const pVal, Velocity6D pVel) -> Velocity6D
    __mul__(Transform pT, Position2D pPos) -> Position3D
    __mul__(Transform pT, Position3D pPos) -> Position3D
    __mul__(Rotation pRot, Position3D pPos) -> Position3D
    __mul__(Quaternion pQuat, Position3D pPos) -> Position3D
    __mul__(float const pVal, Position6D pPos) -> Velocity6D
    __mul__(float const pVal, Position3D pPos) -> Velocity3D
    __mul__(Rotation pRot, Velocity3D pVel) -> Velocity3D
    __mul__(Pose2D pVal, Position2D pPos) -> Position2D
    """
    return _almathswig.__mul__(*args)

def quaternionFromRotation3D(*args):
    """
    quaternionFromRotation3D(Rotation3D pRot3D, Quaternion pQuaternion)
    quaternionFromRotation3D(Rotation3D pRot3D) -> Quaternion
    """
    return _almathswig.quaternionFromRotation3D(*args)

def rotationFromQuaternion(*args):
    """
    rotationFromQuaternion(float const pA, float const pB, float const pC, float const pD) -> Rotation
    rotationFromQuaternion(Quaternion pQua, Rotation pRot)
    rotationFromQuaternion(Quaternion pQua) -> Rotation
    """
    return _almathswig.rotationFromQuaternion(*args)

def rotation3DFromQuaternion(*args):
    """
    rotation3DFromQuaternion(Quaternion pQuaterion, Rotation3D pRot3D)
    rotation3DFromQuaternion(Quaternion pQuaternion) -> Rotation3D
    """
    return _almathswig.rotation3DFromQuaternion(*args)

def quaternionPosition3DFromPosition6D(pPos6D, pQua, pPos3D):
    """quaternionPosition3DFromPosition6D(Position6D pPos6D, Quaternion pQua, Position3D pPos3D)"""
    return _almathswig.quaternionPosition3DFromPosition6D(pPos6D, pQua, pPos3D)

def pointMassRotationalInertia(pMass, pPos, pInertia):
    """pointMassRotationalInertia(float pMass, Position3D pPos, vectorFloat pInertia)"""
    return _almathswig.pointMassRotationalInertia(pMass, pPos, pInertia)
# This file is compatible with both classic and new-style classes.

_4_PI_ = cvar._4_PI_
_2_PI_ = cvar._2_PI_
PI = cvar.PI
PI_2 = cvar.PI_2
PI_4 = cvar.PI_4
TO_RAD = cvar.TO_RAD
TO_DEG = cvar.TO_DEG

