xsmatrix.h

Go to the documentation of this file.

 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
#ifndef XSMATRIX_H
#define XSMATRIX_H
 
#include "xsmath.h"
#include <math.h>
#include <stddef.h>
 
struct XsMatrix;
struct XsEuler;
struct XsQuaternion;
 
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __cplusplus
#define XSMATRIX_INITIALIZER    { NULL, 0, 0, 0, XSDF_Managed }
typedef struct XsMatrix XsMatrix;
#endif
 
XSTYPES_DLL_API void XsMatrix_ref(XsMatrix* thisPtr, XsSize rows, XsSize cols, XsSize stride, XsReal* buffer, XsDataFlags flags);
XSTYPES_DLL_API void XsMatrix_construct(XsMatrix* thisPtr, XsSize rows, XsSize cols, XsSize stride, const XsReal* src, XsSize srcStride);
XSTYPES_DLL_API void XsMatrix_assign(XsMatrix* thisPtr, XsSize rows, XsSize cols, XsSize stride, const XsReal* src, XsSize srcStride);
XSTYPES_DLL_API void XsMatrix_destruct(XsMatrix* thisPtr);
XSTYPES_DLL_API void XsMatrix_copy(XsMatrix* copy, XsMatrix const* src);
XSTYPES_DLL_API void XsMatrix_setZero(XsMatrix* thisPtr);
XSTYPES_DLL_API int XsMatrix_empty(const XsMatrix* thisPtr);
XSTYPES_DLL_API void XsMatrix_multiplyScalar(const XsMatrix* thisPtr, XsReal scalar, XsMatrix* dest);
XSTYPES_DLL_API XsSize XsMatrix_offset(const XsMatrix* thisPtr, XsSize row, XsSize column);
XSTYPES_DLL_API XsReal XsMatrix_value(const XsMatrix* thisPtr, XsSize row, XsSize column);
XSTYPES_DLL_API void XsMatrix_setValue(XsMatrix* thisPtr, XsSize row, XsSize column, XsReal value);
XSTYPES_DLL_API int XsMatrix_dimensionsMatch(const XsMatrix* thisPtr, XsSize rows, XsSize columns);
XSTYPES_DLL_API void XsMatrix_fromQuaternion(XsMatrix* thisPtr, const struct XsQuaternion* quat);
XSTYPES_DLL_API void XsMatrix_swap(XsMatrix* a, XsMatrix* b);
 
#define XsMatrix_offsetM(thisPtr, row, column)                  (thisPtr->m_stride*row + column)
 
#ifdef __cplusplus
} // extern "C"
#endif
#ifndef XSENS_NO_PACK
        #pragma pack(push, 1)
#endif
struct XsMatrix
{
        XSCPPPROTECTED
        XsReal* const m_data;           
        const XsSize m_rows;            
        const XsSize m_cols;            
        const XsSize m_stride;          
        const XsSize m_flags;                   
 
#ifdef __cplusplus
 
#ifdef __ICCARM__
#pragma diag_suppress=Pa039
#endif
 
        inline XsSize flags() const
        {
                return m_flags;
        }
public:
        inline explicit XsMatrix(XsSize rows = 0, XsSize cols = 0, XsSize strde = 0, const XsReal* dat = 0)
                : m_data(0)
                , m_rows(0)
                , m_cols(0)
                , m_stride(0)
                , m_flags(0)
        {
                if (rows && cols)
                        XsMatrix_construct(this, rows, cols, strde ? strde : cols, dat, 0);
        }
 
        inline XsMatrix(const XsMatrix& other)
                : m_data(0)
                , m_rows(0)
                , m_cols(0)
                , m_stride(0)
                , m_flags(0)
        {
                XsMatrix_copy(this, &other);
        }
 
#if !defined(SWIG) && !defined(__ADSP21000__) && !defined(__AVR32__)
 
        inline XsMatrix(XsMatrix&& other)
                : m_data(0)
                , m_rows(0)
                , m_cols(0)
                , m_stride(0)
                , m_flags(0)
        {
                if (!(other.m_flags & XSDF_Managed))
                        XsMatrix_copy(this, &other);
                else
                        XsMatrix_swap(this, &other);
        }
#endif
 
        inline explicit XsMatrix(XsReal* ref, XsSize rows, XsSize cols, XsSize stride, XsDataFlags flags /* = XSDF_None */)
                : m_data(ref)
                , m_rows(rows)
                , m_cols(cols)
                , m_stride(stride)
                , m_flags((XsSize) flags)
        {
        }
 
        inline explicit XsMatrix(const XsMatrix& other, XsReal* ref, XsSize rows, XsSize cols, XsSize stride, XsDataFlags flags /* = XSDF_None */)
                : m_data(ref)
                , m_rows(rows)
                , m_cols(cols)
                , m_stride(stride)
                , m_flags((XsSize) flags)
        {
                XsMatrix_copy(this, &other);
        }
 
        inline explicit XsMatrix(const XsQuaternion& quat)
                : m_data(0)
                , m_rows(0)
                , m_cols(0)
                , m_stride(0)
                , m_flags(0)
        {
                XsMatrix_fromQuaternion(this, &quat);
        }
 
        inline ~XsMatrix()
        {
                XsMatrix_destruct(this);
        }
 
        inline void setSize(XsSize rows, XsSize cols, XsSize stride = 0)
        {
                XsMatrix_assign(this, rows, cols, stride, 0, 0);
        }
 
        inline XsMatrix& operator=(const XsMatrix& other)
        {
                XsMatrix_copy(this, &other);
                return *this;
        }
 
        inline bool empty() const
        {
                return 0 != XsMatrix_empty(this);
        }
 
        inline void setZero()
        {
                XsMatrix_setZero(this);
        }
 
        inline XsSize offset(XsSize row, XsSize column) const
        {
                return XsMatrix_offset(this, row, column);
        }
 
        inline XsReal value(XsSize row, XsSize column) const
        {
                return m_data[XsMatrix_offset(this, row, column)];
        }
 
        inline void setValue(XsSize row, XsSize column, XsReal value)
        {
                m_data[XsMatrix_offsetM(this, row, column)] = value;
        }
 
        inline const XsReal* operator[](XsSize row) const
        {
                return &m_data[XsMatrix_offsetM(this, row, 0)];
        }
 
        inline XsReal* operator[](XsSize row)
        {
                return &m_data[XsMatrix_offsetM(this, row, 0)];
        }
 
        inline XsMatrix operator*(XsReal scalar) const
        {
                XsMatrix tmp(m_rows, m_cols);
                XsMatrix_multiplyScalar(this, scalar, &tmp);
                return tmp;
        }
 
        inline XsMatrix& fromQuaternion(const XsQuaternion& quat)
        {
                XsMatrix_fromQuaternion(this, &quat);
                return *this;
        }
 
        inline void zero()
        {
                for (XsSize r = 0; r < m_rows; ++r)
                        for (XsSize c = 0; c < m_cols; ++c)
                                m_data[XsMatrix_offsetM(this, r, c)] = XsMath_zero;
        }
 
        inline XsSize rows() const
        {
                return m_rows;
        }
 
        inline XsSize cols() const
        {
                return m_cols;
        }
 
        inline XsSize stride() const
        {
                return m_stride;
        }
 
        inline const XsReal* data() const
        {
                return m_data;
        }
 
        inline bool operator ==(const XsMatrix& other) const
        {
                if (this == &other)
                        return true;
                if (m_rows != other.m_rows || m_cols != other.m_cols)
                        return false;
                for (XsSize r = 0; r < m_rows; ++r)
                        for (XsSize c = 0; c < m_cols; ++c)
                                if (m_data[XsMatrix_offsetM(this, r, c)] != other.m_data[XsMatrix_offsetM((&other), r, c)])
                                        return false;
                return true;
        }
 
        inline bool isEqual(const XsMatrix& other, XsReal tolerance) const
        {
                if (this == &other)
                        return true;
                if (m_rows != other.m_rows || m_cols != other.m_cols)
                        return false;
                for (XsSize r = 0; r < m_rows; ++r)
                        for (XsSize c = 0; c < m_cols; ++c)
                                if (fabs(m_data[XsMatrix_offsetM(this, r, c)] - other.m_data[XsMatrix_offsetM((&other), r, c)]) > tolerance)
                                        return false;
                return true;
        }
 
        inline void swap(XsMatrix& b)
        {
                XsMatrix_swap(this, &b);
        }
 
        friend void swap(XsMatrix& first, XsMatrix& second)
        {
                first.swap(second);
        }
 
#ifdef __ICCARM__
#pragma diag_default=Pa039
#endif
 
#endif
};
#ifndef XSENS_NO_PACK
        #pragma pack(pop)
#endif
 
#ifdef __cplusplus
inline XsMatrix operator *(XsReal scalar, const XsMatrix& m)
{
        return (m * scalar);
}
#endif
 
#endif