Matrix.hpp

Go to the documentation of this file.

#pragma once

#include <etk/types.hpp>
#include <etk/math/Vector2D.hpp>
#include <vector>

namespace etk {
    template <typename T> class Matrix {
        private:
            uivec2 m_size; 
            std::vector<T> m_data; 
        public:
            Matrix(const ivec2& _size, T* _defaultVal=nullptr) :
              m_size(_size),
              etk::Vector2D<T>(_size.x()* _size.y()) {
                if (defaultVal == nullptr) {
                    clear();
                    return;
                }
                // copy all the elements
                for(size_t iii = 0;
                    iii <= m_size.x()*m_size.y();
                    ++iii) {
                    // cast and set value : 
                    m_data[iii] = T(_defaultVal++);
                }
            }
            Matrix(int32_t _width=0, int32_t _heigh=0, T* _defaultVal=nullptr) :
              m_size(_width, _heigh),
              etk::Vector2D<T>(_width*_heigh) {
                if (_defaultVal == nullptr) {
                    clear();
                    return;
                }
                // copy all the elements
                for(size_t iii = 0;
                    iii <= m_size.x()*m_size.y();
                    ++iii) {
                    // cast and set value : 
                    m_data[iii] = T(_defaultVal++);
                }
            }
            template<class ETK_TYPE_MATRIX_2>
            Matrix(const Matrix<ETK_TYPE_MATRIX_2>& _obj) :
              m_size(_obj.m_size),
              etk::Vector2D<T>(_obj.m_size.x()* _obj.m_size.y()) {
                // copy all the elements
                for(size_t iii = 0;
                    iii <= m_size.x()*m_size.y();
                    ++iii) {
                    // cast and set value : 
                    m_data[iii] = T(_obj.m_data[iii]);
                }
            }
            virtual ~Matrix() = default;
            
            const Matrix<T>& operator= (const Matrix<T>& _obj ) {
                // check if it was the same pointer
                if (this == &_obj ) {
                    return *this;
                }
                // copy data :
                m_size = _obj.m_size;
                m_data = _obj.m_data;
                return *this;
            }
            const Matrix<T>& operator= (T& _value) {
                // set data :
                for(size_t iii = 0;
                    iii <= m_size.x()*m_size.y();
                    ++iii) {
                    m_data = _value;
                }
                return *this;
            }
            bool operator== (const Matrix<T>& _obj) const {
                return (m_data == _obj.m_data);
            }
            bool operator!= (const Matrix<T>& _obj) const {
                return (m_data != _obj.m_data);
            }
            const Matrix<T>& operator+= (const Matrix<T>& _obj) {
                if (m_size != _obj.m_size) {
                    //TK_CRITICAL("add 2 Matrix with différent size ... ==> generate the max size of all the 2 matrix");
                    etk::Matrix<T> tmpMatrix(std::max(m_size.x(),_obj.m_size.x()), std::max(m_size.y(),_obj.m_size.y()));
                    for (int32_t jjj=0; jjj< m_size.y(); jjj++) {
                        T* tmpPointer = tmpMatrix[jjj];
                        T* tmpPointerIn = (*this)[jjj];
                        for (int32_t iii=0; iii< m_size.x(); iii++) {
                            tmpPointer[iii] = tmpPointerIn[iii];
                        }
                    }
                    for (int32_t jjj=0; jjj< _obj.m_size.y(); jjj++) {
                        T* tmpPointer = tmpMatrix[jjj];
                        T* tmpPointerIn = _obj[jjj];
                        for (int32_t iii=0; iii< _obj.m_size.x(); iii++) {
                            tmpPointer[iii] += tmpPointerIn[iii];
                        }
                    }
                    // copy in local :
                    m_size = tmpMatrix.m_size;
                    m_data = tmpMatrix.m_data;
                } else {
                    // copy data for the same size:
                    for (int32_t iii=0; iii< m_data.size(); iii++) {
                        m_data[iii] += _obj.m_data[iii];
                    }
                }
                return *this;
            }
            Matrix<T> operator+ (const Matrix<T>& _obj) {
                Matrix<T> tmpp(*this);
                tmpp += _obj;
                return tmpp;
            }
            const Matrix<T>& operator-= (const Matrix<T>& _obj) {
                if (m_size != _obj.m_size) {
                    //TK_CRITICAL("less 2 Matrix with different size ... ==> generate the max size of all the 2 matrix");
                    etk::Matrix<T> tmpMatrix(std::max(m_size.x(),_obj.m_size.x()), std::max(m_size.y(),_obj.m_size.y()));
                    for (int32_t jjj=0; jjj< m_size.y; jjj++) {
                        T* tmpPointer = tmpMatrix[jjj];
                        T* tmpPointerIn = (*this)[jjj];
                        for (int32_t iii=0; iii< m_size.x(); iii++) {
                            tmpPointer[iii] = tmpPointerIn[iii];
                        }
                    }
                    for (int32_t jjj=0; jjj< _obj.m_size.y(); jjj++) {
                        T* tmpPointer = tmpMatrix[jjj];
                        T* tmpPointerIn = _obj[jjj];
                        for (int32_t iii=0; iii< _obj.m_size.x(); iii++) {
                            tmpPointer[iii] -= tmpPointerIn[iii];
                        }
                    }
                    // copy in local :
                    m_size = tmpMatrix.m_size;
                    m_data = tmpMatrix.m_data;
                } else {
                    // copy data for the same size :
                    for (int32_t iii=0; iii< m_data.size(); iii++) {
                        m_data[iii] -= _obj.m_data[iii];
                    }
                }
                return *this;
            };
            Matrix<T> operator- (const Matrix<T>& _obj) {
                Matrix<T> tmpp(*this);
                tmpp += _obj;
                return tmpp;
            }
            const Matrix<T>& operator*= (const Matrix<T>& _obj) {
                if(    m_size.x() != _obj.m_size.y()
                    || m_size.y() != _obj.m_size.x()) {
                    //TK_CRITICAL("Error while multipliying 2 matrix with different size ==> impossible case ...");
                    return *this;
                }
                etk::Matrix<T> tmpMatrix(m_size);
                for (int32_t jjj=0; jjj< _obj.m_size.y(); jjj++) {
                    for (int32_t iii=0; iii< _obj.m_size.x(); iii++) {
                        T tmpVal = 0;
                        for (int32_t kkk=0; kkk< _obj.m_size.x(); kkk++) {
                            tmpVal += (*this)[jjj][iii+kkk] * _obj[jjj+kkk][iii];
                        }
                        tmpMatrix[jjj][iii] = tmpVal;
                    }
                }
                // copy in local :
                m_data = tmpMatrix.m_data;
                return *this;
            };
            Matrix<T> operator* (const Matrix<T>& _obj) {
                Matrix tmpp(*this);
                tmpp *= _obj;
                return tmpp;
            }
            // TODO : Check if is possible to do elemntValue = mayMatrix[xxx, yyy]
            const T* operator[] (int32_t _yyy) const {
                return &m_data[_yyy*m_size.x()];
            }
            T* operator[] (int32_t _yyy) {
                return &m_data[_yyy*m_size.x()];
            }
            const T& operator[] (const ivec2& _pos) const {
                return m_data[_pos.y()*m_size.x() + _pos.x()];
            }
            T& operator[] (const ivec2& _pos) {
                return m_data[_pos.y()*m_size.x() + _pos.x()];
            }
            T& operator () (size_t _xxx, size_t _yyy) {
                return m_data[_yyy*m_size.x() + _xxx];
            }
            Matrix<T> operator- () const {
                Matrix<T> tmp(m_size);
                for (int32_t iii=0; iii<m_data.Size(); iii++) {
                    tmp.m_data[iii] = -m_data[iii];
                }
                return tmp;
            }
            Matrix<T> transpose() const {
                // create a matrix with the inverted size
                Matrix<T> tmpMatrix(m_size);
                for (int32_t jjj=0; jjj< m_size.y(); jjj++) {
                    for (int32_t iii=0; iii< m_size.x(); iii++) {
                        tmpMatrix(jjj,iii) = (*this)(iii,jjj);
                    }
                }
                return tmpMatrix;
            }
            Matrix<T> convolution(Matrix<T>& _obj) const {
                Matrix<T> tmppp(1,1);
                // TODO : ...
                return tmppp;
            }
            Matrix<T> fix(int32_t _decalage) const {
                Matrix<T> tmppp(m_size);
                T tmpVal = 0;
                for(int32_t iii=0; iii<m_data.size(); iii++) {
                    tmpVal = m_data[iii];
                    if (tmpVal < 0 && (tmpVal & ~(~0 << _decalage))) {
                        tmpVal = tmpVal >> _decalage;
                        tmpVal++;
                    } else {
                        tmpVal = tmpVal >> _decalage;
                    }
                    tmppp.m_data[iii] = tmpVal;
                }
                return tmppp;
            };
            Matrix<T> round(int32_t _decalage) const {
                Matrix<T> tmppp(m_size);
                for(int32_t iii=0; iii<m_data.size(); iii++) {
                    tmppp.m_data[iii] = ( m_data[iii]+(1<<(_decalage-1)) ) >> _decalage;
                }
                return tmppp;
            };
            Matrix<T> resize(etk::Vector2D<int32_t> _size) const {
                Matrix<T> tmppp(_size);
                for(int32_t iii=0; iii<m_data.m_size.x() && iii<tmppp.m_size.x(); iii++) {
                    for(int32_t jjj=0; jjj<m_data.m_size.y() && jjj<tmppp.m_size.y(); jjj++) {
                        tmppp(iii,jjj) = (*this)(iii,jjj);
                    }
                }
                return tmppp;
            };
            Matrix<T> select(int32_t _np, int32_t* _p, int32_t _nq, int32_t* _q) const {
                if (_np < 1 || _nq < 1) {
                    TK_WARNING("bad index array sizes");
                }
                Matrix<T> tmppp(_np, _nq);
                for (int32_t iii=0; iii<_np; iii++) {
                    for (int32_t jjj=0; jjj<_nq; jjj++) {
                        if(    _p[i] < 0
                            || _p[i] >= m_size.x()
                            || _q[i] < 0
                            || _q[i] >= m_size.y()) {
                            TK_WARNING("bad index arrays");
                        }
                        tmppp(iii,jjj) = (*this)(_p[i],_q[j]);
                    }
                }
                return tmppp;
            }
            void clearUpperTriangle() {
                if (m_size.x() != m_size.y()) {
                    TK_WARNING("better to do with square Matrix");
                }
                for (int32_t iii=0; iii<m_size.x(); iii++) {
                    for (int32_t jjj=iii+1; jjj<m_size.y(); jjj++)
                        m_data[iii*m_size.x() + jjj] = 0;
                    }
                }
            };
            void clearLowerTriangle() {
                if (m_size.x() != m_size.y()) {
                    TK_WARNING("better to do with square Matrix");
                }
                for (int32_t iii=0; iii<m_size.x(); iii++) {
                    for (int32_t jjj=0; jjj<m_size.y() && jjj<iii; jjj++)
                        m_data[iii*m_size.x() + jjj] = 0;
                    }
                }
            };
            void makeRandom(float _range) {
                for(int32_t iii=0; iii<m_data.size(); iii++) {
                    m_data[iii] = (T)etk::tool::frand(-_range, _range);
                }
            };
            T maxDifference(const Matrix<T>& _input) const {
                if (m_size != _input.m_size) {
                    TK_WARNING("better to do with same size Matrix");
                }
                T max = 0;
                for(int32_t iii = 0;
                    iii < m_data.size() && iii < _input.m_data.size();
                    ++iii) {
                    T diff = m_data[iii] - _input.m_data[iii];
                    if (diff<0) {
                        diff = -diff;
                    }
                    if (diff > max) {
                        max = diff;
                    }
                }
                return max;
            }
            void clear() {
                // copy data for the same size :
                for (int32_t iii=0; iii< m_size.x()*m_size.y(); iii++) {
                    m_data[iii] = (T)0;
                }
            };
            void identity() {
                // copy data for the same size :
                for (int32_t iii=0; iii< std::mim(m_size.x(), m_size.y()); iii++) {
                    (*this)(iii,iii) = (T)1;
                }
            };
            void eye() {
                clear();
                identity();
            };
            const uivec2& size() const {
                return m_size;
            };
    };
}

// To siplify the writing of the code ==> this is not compatible with GLSL ...
using dmat = etk::Matrix<double>; 
using mat = etk::Matrix<float>; 
using imat = etk::Matrix<int32_t>; 
using uimat = etk::Matrix<uint32_t>;