otMatrix.h

Go to the documentation of this file.

#ifndef _ot_Matrix_h
#define _ot_Matrix_h

#include "otdefs.h"

#define MATRIX_DYNAMIC  1








class otMatrix
{
public:
        typedef enum 
    {
        InitMatWithZero,    
        NoInitMatZero           
    } InitZero;                         
        
        otMatrix();
        
        otMatrix(const S16 _i16row, const S16 _i16col, InitZero _init = InitMatWithZero);
        
        otMatrix(const S16 _i16row, const S16 _i16col, F32 * initData);
        
        void    create(const S16 _i16row, const S16 _i16col, InitZero _init = InitMatWithZero);
        
        void    create(const S16 _i16row, const S16 _i16col, F32 * initData);
        
        // Ref: https://stackoverflow.com/questions/6969881/operator-overload ******
    // *************************************************************************
    
        class Proxy 
    {
    public:
        Proxy(F32 * _array, S16 _maxColumn) : _array(_array) 
        { 
            this->_maxColumn = _maxColumn; 
        }

        /* Modify to be lvalue modifiable, ref:
         * https://stackoverflow.com/questions/6969881/operator-overload#comment30831582_6969904
         * (I know this is so dirty, but it makes the code so FABULOUS :D)
         */
        F32 & operator[](S16 _column) 
        {
            return _array[_column];
        }
        
    private:
        F32     * _array;
        S16     _maxColumn;
    };
    
    Proxy operator[](S16 _row) 
    {
        return Proxy(f32data[_row], this->i16col);      // Parsing column index for bound checking
    }
    
    // *************************************************************************
        
        void    close();
        
        bool    isValid();
        
        bool    isSquare();
        
        S16     getRow();
        
        S16     getCol();
        
        bool    operator == (otMatrix _compare);
        
        otMatrix operator + (otMatrix _matAdd);
        
        otMatrix operator - (otMatrix _matSub);
        
        otMatrix        operator - (void);
        
        otMatrix operator * (otMatrix _matMul);
        
        otMatrix operator=(otMatrix _mat);
        
        void    vSetHomogen(const F32 _val);
        
        void    vRoundingElementToZero(const S16 _i, const S16 _j);
        
        otMatrix        RoundingMatrixToZero();
        
        void            vSetToZero();
        
        void            vSetRandom(const S32 _maxRand, const S32 _minRand);
        
        void            vSetDiag(const F32 _val);
        
        void            vSetIdentity();
        
        void            Copy(otMatrix & _outp);
        
    otMatrix    InsertVector(otMatrix _Vector, const S16 _posColumn);
        
    otMatrix    InsertSubMatrix(otMatrix _subMatrix, const S16 _posRow, const S16 _posColumn);
        
    otMatrix    InsertSubMatrix(otMatrix _subMatrix, const S16 _posRow, const S16 _posColumn, const S16 _lenRow, const S16 _lenColumn);
        
    otMatrix    InsertSubMatrix(otMatrix _subMatrix, const S16 _posRow, const S16 _posColumn, const S16 _posRowSub, const S16 _posColumnSub, const S16 _lenRow, const S16 _lenColumn);
        
    otMatrix    Transpose();
        
    bool                bNormVector();
        
    otMatrix    Invers();
        
    bool                bMatrixIsPositiveDefinite(bool checkPosSemidefinite = false);
        
    otMatrix    GetDiagonalEntries(void);
        
    otMatrix    CholeskyDec();
        
    otMatrix    HouseholderTransformQR(const S16 _rowTransform, const S16 _columnTransform);
        
    bool                QRDec(otMatrix & Qt, otMatrix & R);
        
    otMatrix    BackSubtitution(otMatrix & A, otMatrix & B);
        
    otMatrix    ForwardSubtitution(otMatrix & A, otMatrix & B);
        
        static void     garbageClean(U32 start = 0);
        
        static void             addGarbage(otMatrix * mat);
        
        static U32              garbageCount();
        
private:
        void    init();
#ifdef MATRIX_DYNAMIC
        static  otMatrix  ** _garbage;
        static  U32     _garbageCount;
    F32     ** f32data;
#else
        F32             f32data[6][6];
#endif
    bool    _isValid;
    S16     i16row, i16col;
};

otMatrix operator + (const F32 _scalar, otMatrix _mat);
otMatrix operator - (const F32 _scalar, otMatrix _mat);
otMatrix operator * (const F32 _scalar, otMatrix _mat);
otMatrix operator + (otMatrix _mat, const F32 _scalar);
otMatrix operator - (otMatrix _mat, const F32 _scalar);
otMatrix operator * (otMatrix _mat, const F32 _scalar);
otMatrix operator / (otMatrix _mat, const F32 _scalar);


#endif

otStudio - Library Reference - (C) 2020-21 Officina Turini, All Rights Reserved
Document built with Doxygen 1.4.0