almathswig.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.7
#
# 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):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

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

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

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


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, *args):
        """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _almathswig.SwigPyIterator_distance(self, *args)

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

    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, *args):
        """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _almathswig.SwigPyIterator_advance(self, *args)

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

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

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

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

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

    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 pop(self):
        """pop(vectorFloat self) -> std::vector< float >::value_type"""
        return _almathswig.vectorFloat_pop(self)

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

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

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

    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 append(self, *args):
        """append(vectorFloat self, std::vector< float >::value_type const & x)"""
        return _almathswig.vectorFloat_append(self, *args)

    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 clear(self):
        """clear(vectorFloat self)"""
        return _almathswig.vectorFloat_clear(self)

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

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

    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 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: self.this = this
    def push_back(self, *args):
        """push_back(vectorFloat self, std::vector< float >::value_type const & x)"""
        return _almathswig.vectorFloat_push_back(self, *args)

    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, *args):
        """assign(vectorFloat self, std::vector< float >::size_type n, std::vector< float >::value_type const & x)"""
        return _almathswig.vectorFloat_assign(self, *args)

    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, *args):
        """reserve(vectorFloat self, std::vector< float >::size_type n)"""
        return _almathswig.vectorFloat_reserve(self, *args)

    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 pop(self):
        """pop(vectorPosition2D self) -> Position2D"""
        return _almathswig.vectorPosition2D_pop(self)

    def __getslice__(self, *args):
        """__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, *args)

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

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

    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 append(self, *args):
        """append(vectorPosition2D self, Position2D x)"""
        return _almathswig.vectorPosition2D_append(self, *args)

    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 clear(self):
        """clear(vectorPosition2D self)"""
        return _almathswig.vectorPosition2D_clear(self)

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

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

    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 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: self.this = this
    def push_back(self, *args):
        """push_back(vectorPosition2D self, Position2D x)"""
        return _almathswig.vectorPosition2D_push_back(self, *args)

    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, *args):
        """assign(vectorPosition2D self, std::vector< AL::Math::Position2D >::size_type n, Position2D x)"""
        return _almathswig.vectorPosition2D_assign(self, *args)

    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, *args):
        """reserve(vectorPosition2D self, std::vector< AL::Math::Position2D >::size_type n)"""
        return _almathswig.vectorPosition2D_reserve(self, *args)

    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 pop(self):
        """pop(vectorPose2D self) -> Pose2D"""
        return _almathswig.vectorPose2D_pop(self)

    def __getslice__(self, *args):
        """__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, *args)

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

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

    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 append(self, *args):
        """append(vectorPose2D self, Pose2D x)"""
        return _almathswig.vectorPose2D_append(self, *args)

    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 clear(self):
        """clear(vectorPose2D self)"""
        return _almathswig.vectorPose2D_clear(self)

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

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

    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 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: self.this = this
    def push_back(self, *args):
        """push_back(vectorPose2D self, Pose2D x)"""
        return _almathswig.vectorPose2D_push_back(self, *args)

    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, *args):
        """assign(vectorPose2D self, std::vector< AL::Math::Pose2D >::size_type n, Pose2D x)"""
        return _almathswig.vectorPose2D_assign(self, *args)

    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, *args):
        """reserve(vectorPose2D self, std::vector< AL::Math::Pose2D >::size_type n)"""
        return _almathswig.vectorPose2D_reserve(self, *args)

    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 pop(self):
        """pop(vectorPosition6D self) -> Position6D"""
        return _almathswig.vectorPosition6D_pop(self)

    def __getslice__(self, *args):
        """__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, *args)

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

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

    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 append(self, *args):
        """append(vectorPosition6D self, Position6D x)"""
        return _almathswig.vectorPosition6D_append(self, *args)

    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 clear(self):
        """clear(vectorPosition6D self)"""
        return _almathswig.vectorPosition6D_clear(self)

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

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

    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 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: self.this = this
    def push_back(self, *args):
        """push_back(vectorPosition6D self, Position6D x)"""
        return _almathswig.vectorPosition6D_push_back(self, *args)

    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, *args):
        """assign(vectorPosition6D self, std::vector< AL::Math::Position6D >::size_type n, Position6D x)"""
        return _almathswig.vectorPosition6D_assign(self, *args)

    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, *args):
        """reserve(vectorPosition6D self, std::vector< AL::Math::Position6D >::size_type n)"""
        return _almathswig.vectorPosition6D_reserve(self, *args)

    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)

class DigitalFilter(_object):
    """Proxy of C++ AL::Math::DSP::DigitalFilter class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DigitalFilter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DigitalFilter, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(AL::Math::DSP::DigitalFilter self) -> DigitalFilter"""
        this = _almathswig.new_DigitalFilter()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _almathswig.delete_DigitalFilter
    __del__ = lambda self : None;
    def configureFilter(self, *args):
        """configureFilter(DigitalFilter self, unsigned int pOrder, vectorFloat pWeightsIn, vectorFloat pWeightsOut, float pDcGain)"""
        return _almathswig.DigitalFilter_configureFilter(self, *args)

    def resetFilter(self):
        """resetFilter(DigitalFilter self)"""
        return _almathswig.DigitalFilter_resetFilter(self)

    def processFilter(self, *args):
        """processFilter(DigitalFilter self, float pInputData) -> float"""
        return _almathswig.DigitalFilter_processFilter(self, *args)

DigitalFilter_swigregister = _almathswig.DigitalFilter_swigregister
DigitalFilter_swigregister(DigitalFilter)

class PIDController(_object):
    """Proxy of C++ AL::Math::DSP::PIDController class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PIDController, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PIDController, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(AL::Math::DSP::PIDController self) -> PIDController
        __init__(AL::Math::DSP::PIDController self, float pKp, float pKv, float pKi, float pThreshold, float pStaticOffset, float pPeriod) -> PIDController
        """
        this = _almathswig.new_PIDController(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _almathswig.delete_PIDController
    __del__ = lambda self : None;
    def initialize(self, *args):
        """
        initialize(PIDController self)
        initialize(PIDController self, float pKp, float pKv, float pKi, float pThreshold, float pStaticOffset, float pPeriod)
        """
        return _almathswig.PIDController_initialize(self, *args)

    def computeFeedback(self, *args):
        """
        computeFeedback(PIDController self, float pCommand, float pSensor, float pPeriod=-1.0) -> float
        computeFeedback(PIDController self, float pCommand, float pSensor) -> float
        """
        return _almathswig.PIDController_computeFeedback(self, *args)

    def computeFeedbackAbsolute(self, *args):
        """computeFeedbackAbsolute(PIDController self, float pAbsoluteErr) -> float"""
        return _almathswig.PIDController_computeFeedbackAbsolute(self, *args)

PIDController_swigregister = _almathswig.PIDController_swigregister
PIDController_swigregister(PIDController)


def isAxisMask(*args):
  """isAxisMask(int const pAxisMask) -> bool"""
  return _almathswig.isAxisMask(*args)
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: self.this = this
    def fromPolarCoordinates(*args):
        """fromPolarCoordinates(float const pRadius, float const pAngle) -> Pose2D"""
        return _almathswig.Pose2D_fromPolarCoordinates(*args)

    if _newclass:fromPolarCoordinates = staticmethod(fromPolarCoordinates)
    __swig_getmethods__["fromPolarCoordinates"] = lambda x: fromPolarCoordinates
    def __add__(self, *args):
        """__add__(Pose2D self, Pose2D pPos2) -> Pose2D"""
        return _almathswig.Pose2D___add__(self, *args)

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

    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, *args):
        """__iadd__(Pose2D self, Pose2D pPos2) -> Pose2D"""
        return _almathswig.Pose2D___iadd__(self, *args)

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

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

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

    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, *args):
        """__div__(Pose2D self, float pVal) -> Pose2D"""
        return _almathswig.Pose2D___div__(self, *args)

    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, *args):
        """__idiv__(Pose2D self, float pVal) -> Pose2D"""
        return _almathswig.Pose2D___idiv__(self, *args)

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

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

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

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

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

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

    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, *args):
        """__rmul__(Pose2D self, float const lhs) -> Pose2D"""
        return _almathswig.Pose2D___rmul__(self, *args)

    __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

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


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

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

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: self.this = this
    def fromPolarCoordinates(*args):
        """fromPolarCoordinates(float const pRadius, float const pAngle) -> Position2D"""
        return _almathswig.Position2D_fromPolarCoordinates(*args)

    if _newclass:fromPolarCoordinates = staticmethod(fromPolarCoordinates)
    __swig_getmethods__["fromPolarCoordinates"] = lambda x: fromPolarCoordinates
    def __add__(self, *args):
        """__add__(Position2D self, Position2D pPos2) -> Position2D"""
        return _almathswig.Position2D___add__(self, *args)

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

    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, *args):
        """__iadd__(Position2D self, Position2D pPos2) -> Position2D"""
        return _almathswig.Position2D___iadd__(self, *args)

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

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

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

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

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

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

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

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

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

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

    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, *args):
        """dotProduct(Position2D self, Position2D pPos2) -> float"""
        return _almathswig.Position2D_dotProduct(self, *args)

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

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

    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, *args):
        """__rmul__(Position2D self, float const lhs) -> Position2D"""
        return _almathswig.Position2D___rmul__(self, *args)

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

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

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: self.this = this
    def __add__(self, *args):
        """__add__(Position3D self, Position3D pPos2) -> Position3D"""
        return _almathswig.Position3D___add__(self, *args)

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

    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, *args):
        """__iadd__(Position3D self, Position3D pPos2) -> Position3D"""
        return _almathswig.Position3D___iadd__(self, *args)

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

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

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

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

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

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

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

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

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

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

    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, *args):
        """dotProduct(Position3D self, Position3D pPos2) -> float"""
        return _almathswig.Position3D_dotProduct(self, *args)

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

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

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

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

    __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)
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: self.this = this
    def __add__(self, *args):
        """__add__(Position6D self, Position6D pPos2) -> Position6D"""
        return _almathswig.Position6D___add__(self, *args)

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

    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, *args):
        """__iadd__(Position6D self, Position6D pPos2) -> Position6D"""
        return _almathswig.Position6D___iadd__(self, *args)

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

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

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

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

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

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

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

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

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

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

    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 __repr__(self):
        """__repr__(Position6D self) -> char *"""
        return _almathswig.Position6D___repr__(self)

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

    __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: self.this = this
    def isNear(self, *args):
        """
        isNear(PositionAndVelocity self, PositionAndVelocity pDat2, float const & pEpsilon=0.0001) -> bool
        isNear(PositionAndVelocity self, PositionAndVelocity pDat2) -> bool
        """
        return _almathswig.PositionAndVelocity_isNear(self, *args)

    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: self.this = this
    def __eq__(self, *args):
        """__eq__(Quaternion self, Quaternion pQua2) -> bool"""
        return _almathswig.Quaternion___eq__(self, *args)

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

    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, *args):
        """__div__(Quaternion self, float pVal) -> Quaternion"""
        return _almathswig.Quaternion___div__(self, *args)

    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, *args):
        """__idiv__(Quaternion self, float pVal) -> Quaternion"""
        return _almathswig.Quaternion___idiv__(self, *args)

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

    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(*args):
        """fromAngleAndAxisRotation(float const pAngle, float const pAxisX, float const pAxisY, float const pAxisZ) -> Quaternion"""
        return _almathswig.Quaternion_fromAngleAndAxisRotation(*args)

    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(*args):
  """Quaternion_fromAngleAndAxisRotation(float const pAngle, float const pAxisX, float const pAxisY, float const pAxisZ) -> Quaternion"""
  return _almathswig.Quaternion_fromAngleAndAxisRotation(*args)


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

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

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=AL::Math::Quaternion()) -> Displacement
        __init__(AL::Math::Displacement self, Position3D pos3d) -> Displacement
        """
        this = _almathswig.new_Displacement(*args)
        try: self.this.append(this)
        except: self.this = this
    def __imul__(self, *args):
        """__imul__(Displacement self, Displacement pDisp) -> Displacement"""
        return _almathswig.Displacement___imul__(self, *args)

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

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

    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: self.this = this
    def __imul__(self, *args):
        """__imul__(Rotation self, Rotation pRot2) -> Rotation"""
        return _almathswig.Rotation___imul__(self, *args)

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

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

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

    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(*args):
        """fromQuaternion(float const pA, float const pB, float const pC, float const pD) -> Rotation"""
        return _almathswig.Rotation_fromQuaternion(*args)

    if _newclass:fromQuaternion = staticmethod(fromQuaternion)
    __swig_getmethods__["fromQuaternion"] = lambda x: fromQuaternion
    def fromAngleDirection(*args):
        """fromAngleDirection(float const pAngle, float const pX, float const pY, float const pZ) -> Rotation"""
        return _almathswig.Rotation_fromAngleDirection(*args)

    if _newclass:fromAngleDirection = staticmethod(fromAngleDirection)
    __swig_getmethods__["fromAngleDirection"] = lambda x: fromAngleDirection
    def fromRotX(*args):
        """fromRotX(float const pRotX) -> Rotation"""
        return _almathswig.Rotation_fromRotX(*args)

    if _newclass:fromRotX = staticmethod(fromRotX)
    __swig_getmethods__["fromRotX"] = lambda x: fromRotX
    def fromRotY(*args):
        """fromRotY(float const pRotY) -> Rotation"""
        return _almathswig.Rotation_fromRotY(*args)

    if _newclass:fromRotY = staticmethod(fromRotY)
    __swig_getmethods__["fromRotY"] = lambda x: fromRotY
    def fromRotZ(*args):
        """fromRotZ(float const pRotZ) -> Rotation"""
        return _almathswig.Rotation_fromRotZ(*args)

    if _newclass:fromRotZ = staticmethod(fromRotZ)
    __swig_getmethods__["fromRotZ"] = lambda x: fromRotZ
    def from3DRotation(*args):
        """from3DRotation(float const & pWX, float const & pWY, float const & pWZ) -> Rotation"""
        return _almathswig.Rotation_from3DRotation(*args)

    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(*args):
  """Rotation_fromQuaternion(float const pA, float const pB, float const pC, float const pD) -> Rotation"""
  return _almathswig.Rotation_fromQuaternion(*args)

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

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

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

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

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


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

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

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

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

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

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

def rotationFrom3DRotation(*args):
  """rotationFrom3DRotation(float const & pWX, float const & pWY, float const & pWZ) -> Rotation"""
  return _almathswig.rotationFrom3DRotation(*args)
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: self.this = this
    def __add__(self, *args):
        """__add__(Rotation3D self, Rotation3D pRot2) -> Rotation3D"""
        return _almathswig.Rotation3D___add__(self, *args)

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

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

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

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

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

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

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

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

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

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

    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: self.this = this
    def __imul__(self, *args):
        """__imul__(Transform self, Transform pT2) -> Transform"""
        return _almathswig.Transform___imul__(self, *args)

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

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

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

    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(*args):
        """fromRotX(float const pRotX) -> Transform"""
        return _almathswig.Transform_fromRotX(*args)

    if _newclass:fromRotX = staticmethod(fromRotX)
    __swig_getmethods__["fromRotX"] = lambda x: fromRotX
    def fromRotY(*args):
        """fromRotY(float const pRotY) -> Transform"""
        return _almathswig.Transform_fromRotY(*args)

    if _newclass:fromRotY = staticmethod(fromRotY)
    __swig_getmethods__["fromRotY"] = lambda x: fromRotY
    def fromRotZ(*args):
        """fromRotZ(float const pRotZ) -> Transform"""
        return _almathswig.Transform_fromRotZ(*args)

    if _newclass:fromRotZ = staticmethod(fromRotZ)
    __swig_getmethods__["fromRotZ"] = lambda x: fromRotZ
    def from3DRotation(*args):
        """from3DRotation(float const & pWX, float const & pWY, float const & pWZ) -> Transform"""
        return _almathswig.Transform_from3DRotation(*args)

    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, *args):
        """diff(Transform self, Transform pT2) -> Transform"""
        return _almathswig.Transform_diff(self, *args)

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

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

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

    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(*args):
  """Transform_fromRotX(float const pRotX) -> Transform"""
  return _almathswig.Transform_fromRotX(*args)

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

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

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

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(*args):
  """transformPreMultiply(Transform pT, Transform pTOut)"""
  return _almathswig.transformPreMultiply(*args)

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

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(*args):
  """transformFromRotX(float const pRotX) -> Transform"""
  return _almathswig.transformFromRotX(*args)

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

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

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

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(*args):
  """transformInvertInPlace(Transform pT)"""
  return _almathswig.transformInvertInPlace(*args)

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

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

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

def transformDistance(*args):
  """transformDistance(Transform pT1, Transform pT2) -> float"""
  return _almathswig.transformDistance(*args)
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: self.this = this
    def __add__(self, *args):
        """__add__(Velocity3D self, Velocity3D pVel2) -> Velocity3D"""
        return _almathswig.Velocity3D___add__(self, *args)

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

    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, *args):
        """__iadd__(Velocity3D self, Velocity3D pVel2) -> Velocity3D"""
        return _almathswig.Velocity3D___iadd__(self, *args)

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

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

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

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

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

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

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

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

    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 __repr__(self):
        """__repr__(Velocity3D self) -> char *"""
        return _almathswig.Velocity3D___repr__(self)

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

    __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: self.this = this
    def __add__(self, *args):
        """__add__(Velocity6D self, Velocity6D pVel2) -> Velocity6D"""
        return _almathswig.Velocity6D___add__(self, *args)

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

    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, *args):
        """__mul__(Velocity6D self, float const pVal) -> Velocity6D"""
        return _almathswig.Velocity6D___mul__(self, *args)

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

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

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

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

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

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

    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 __repr__(self):
        """__repr__(Velocity6D self) -> char *"""
        return _almathswig.Velocity6D___repr__(self)

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

    __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: self.this = this
    def isNear(self, *args):
        """
        isNear(TransformAndVelocity6D self, TransformAndVelocity6D pTV2, float const & pEpsilon=0.0001) -> bool
        isNear(TransformAndVelocity6D self, TransformAndVelocity6D pTV2) -> bool
        """
        return _almathswig.TransformAndVelocity6D_isNear(self, *args)

    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(*args):
  """getDubinsSolutions(Pose2D pTargetPose, float const pCircleRadius) -> vectorPose2D"""
  return _almathswig.getDubinsSolutions(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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(*args):
  """transformFromPosition3DInPlace(Position3D pPosition, Transform pTransform)"""
  return _almathswig.transformFromPosition3DInPlace(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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(*args):
  """transformFromQuaternion(Quaternion pQua) -> Transform"""
  return _almathswig.transformFromQuaternion(*args)

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

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

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

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

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

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(*args):
  """changeReferencePose2D(float const & pTheta, Pose2D pPosIn, Pose2D pPosOut)"""
  return _almathswig.changeReferencePose2D(*args)

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

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

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

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

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

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(*args):
  """position6DFromPose2DInPlace(Pose2D pPose2D, Position6D pPosition6D)"""
  return _almathswig.position6DFromPose2DInPlace(*args)

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

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

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

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

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

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

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

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__(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(*args):
  """quaternionPosition3DFromPosition6D(Position6D pPos6D, Quaternion pQua, Position3D pPos3D)"""
  return _almathswig.quaternionPosition3DFromPosition6D(*args)
# 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