CSparseMatrixTemplate.h

Go to the documentation of this file.

/* +---------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)               |
   |                          http://www.mrpt.org/                             |
   |                                                                           |
   | Copyright (c) 2005-2017, Individual contributors, see AUTHORS file        |
   | See: http://www.mrpt.org/Authors - All rights reserved.                   |
   | Released under BSD License. See details in http://www.mrpt.org/License    |
   +---------------------------------------------------------------------------+ */
#ifndef CSparseMatrixTemplate_H
#define CSparseMatrixTemplate_H

#include <mrpt/utils/utils_defs.h>
#include <map>

namespace mrpt  {
namespace math  {

    /** A sparse matrix container (with cells of any type), with iterators.
      *  This class stores only those elements created by assigning them a value, for example: "M(2,3)=8;".
      *
      *  This class doesn't implement math operations since it's a generic sparse container, but it can be
      *   used to initialize the contents of a CSparse library-based matrix of type mrpt::math::CSparseMatrix.
      *
      *  Note that reading non-existing cell elements will return the default value (0 for numbers)
      *   and that cell will remain non-created in the matrix.
      *
      *  There is an additional method "exists(i,j)" to check whether a given element exists in the matrix.
      *
      *  \sa mrpt::math::MatrixBlockSparseCols, mrpt::math::CSparseMatrix, CSparseSymmetricalMatrix
      *  \note Methods marked as "Doesn't check bounds" mean that if an access to an element out of the matrix size is tried, an empty element will be assumed, but this will not raise any invalid memory access.
      * \ingroup mrpt_base_grp
      */
        template<class T>
        class CSparseMatrixTemplate     {
                //Public typedefs
        public:
                /**
                  * Internal map type, used to store the actual matrix.
                  */
                typedef typename std::map<std::pair<size_t,size_t>,T> SparseMatrixMap;
                /**
                  * Const iterator to move through the matrix.
                  * \sa CSparseMatrixTemplate::const_reverse_iterator
                  */
                typedef typename SparseMatrixMap::const_iterator const_iterator;
                /**
                  * Const reverse iterator to move through the matrix.
                  * \sa CSparseMatrixTemplate::const_iterator
                  */
                typedef typename SparseMatrixMap::const_reverse_iterator const_reverse_iterator;
        protected:
                /**
                  * Size of the matrix.
                  */
                size_t mRows,mColumns;
                /**
                  * Actual matrix.
                  */
                SparseMatrixMap objectList;
        public:
                /**
                  * Basic constructor with no data. Size is set to (0,0).
                  */
                CSparseMatrixTemplate():mRows(0),mColumns(0)    {}
                /**
                  * Constructor with default size.
                  */
                CSparseMatrixTemplate(size_t nR,size_t nC):mRows(nR),mColumns(nC)       {}
                /**
                  * Element access operator. Doesn't check bounds.
                  */
                inline T operator()(size_t r,size_t c) const    {
                        const_iterator it=objectList.find(std::make_pair(r,c));
                        if (it==objectList.end()) return T();
                        else return it->second;
                }

                /** Element access operator. Checks bounds.
                  */
                inline bool exists(size_t r,size_t c) const     {
#if defined(_DEBUG) || (MRPT_ALWAYS_CHECKS_DEBUG_MATRICES)
                        if (r>=mRows||c>=mColumns) throw std::logic_error("Out of range");
#endif
                        return (objectList.find(std::make_pair(r,c)) != objectList.end());
                }

                /**
                  * Reference access operator. Checks for bounds.
                  */
                inline T& operator()(size_t r,size_t c) { //-V659
#if defined(_DEBUG) || (MRPT_ALWAYS_CHECKS_DEBUG_MATRICES)
                        if (r>=mRows||c>=mColumns) throw std::logic_error("Out of range");
#endif
                        return objectList[std::make_pair(r,c)];
                }
                /**
                  * Returns the amount of rows in this matrix.
                  * \sa getColCount,getRow
                  */
                inline size_t getRowCount() const       {
                        return mRows;
                }
                /**
                  * Returns the amount of columns in this matrix.
                  * \sa getRowCount
                  */
                inline size_t getColCount() const       {
                        return mColumns;
                }
                /**
                  * Extracts a full row from the matrix.
                  * \sa getRowCount,getColumn,setRow
                  * \throw std::logic_error on out of range.
                  */
                void getRow(size_t nRow,std::vector<T> &vec) const      {
#if defined(_DEBUG) || (MRPT_ALWAYS_CHECKS_DEBUG_MATRICES)
                        if (nRow>=mRows) throw std::logic_error("Out of range");
#endif
                        vec.resize(mColumns);
                        size_t nextIndex=0;
                        for (typename SparseMatrixMap::const_iterator it=objectList.begin();it!=objectList.end();++it)  {
                                const std::pair<size_t,size_t> &index=it->first;
                                if (index.first<nRow) continue;
                                else if (index.first==nRow)     {
                                        for (size_t i=nextIndex;i<index.second;i++) vec[i]=T();
                                        vec[index.second]=it->second;
                                        nextIndex=index.second+1;
                                }       else    {
                                        for (size_t i=nextIndex;i<mColumns;i++) vec[i]=T();
                                        break;
                                }
                        }
                }
                /**
                  * Extracts a full column from the matrix.
                  * \sa getColCount,getRow,setColumn
                  * \throw std::logic_error on out of range.
                  */
                void getColumn(size_t nCol,std::vector<T> &vec) const   {
#if defined(_DEBUG) || (MRPT_ALWAYS_CHECKS_DEBUG_MATRICES)
                        if (nCol>=mColumns) throw std::logic_error("Out of range");
#endif
                        vec.resize(mRows);
                        size_t nextIndex=0;
                        for (typename SparseMatrixMap::const_iterator it=objectList.begin();it!=objectList.end();++it)  {
                                const std::pair<size_t,size_t> &index=it->first;
                                if (index.second==nCol) {
                                        for (size_t i=nextIndex;i<index.first;i++) vec[i]=T();
                                        vec[index.first]=it->second;
                                        nextIndex=index.first+1;
                                }
                        }
                        for (size_t i=nextIndex;i<mRows;i++) vec[i]=T();
                }
                /**
                  * Inserts an element into the matrix.
                  * \sa operator()(size_t,size_t)
                  */
                inline void insert(size_t row,size_t column,const T& obj)       {
                        operator()(row,column)=obj;
                }

                /** Inserts submatrix at a given location */
                template <class MATRIX_LIKE>
                inline void insertMatrix(size_t row,size_t column,const MATRIX_LIKE& mat)
                {
                        for (size_t nr=0;nr<mat.getRowCount();nr++)
                                for (size_t nc=0;nc<mat.getColCount();nc++)
                                        operator()(row+nr,column+nc)=mat(nr,nc);
                }

                //Public interface only supports const iterators. This way, no user of this class will be able to freely modify it contents.
                /**
                  * Returns an iterator which points to the starting point of the matrix. It's a const_iterator, so that the usar isn't able to modify the matrix content into an invalid state.
                  * \sa end,rbegin,rend
                  */
                inline const_iterator begin() const     {
                        return objectList.begin();
                }
                /**
                  * Returns an iterator which points to the end of the matrix. It's a const_iterator, so that the usar isn't able to modify the matrix content into an invalid state.
                  * \sa begin,rbegin,rend
                  */
                inline const_iterator end() const       {
                        return objectList.end();
                }
                /**
                  * Returns an iterator which points to the end of the matrix, and can be used to move backwards. It's a const_reverse_iterator, so that the usar isn't able to modify the matrix content into an invalid state.
                  * \sa begin,end,rend
                  */
                inline const_reverse_iterator rbegin() const    {
                        return objectList.rbegin();
                }
                /**
                  * Returns an iterator which points to the starting point of the matrix, although it's the upper limit of the matrix since it's a reverse iterator. Also, it's a const_reverse_iterator, so that the usar isn't able to modify the matrix content into an invalid state.
                  * \sa begin,end,rbegin
                  */
                inline const_reverse_iterator rend() const      {
                        return objectList.rend();
                }
                /**
                  * Inserts a full row into the matrix. The third argument is used to specify a null object (which won't be inserted, since the matrix is sparse).
                  * \sa getRow
                  * \throw std::logic_error on out of range or wrong sized vector.
                  */
                void setRow(size_t nRow,const std::vector<T> &vec,const T& nullObject=T())      {
#if defined(_DEBUG) || (MRPT_ALWAYS_CHECKS_DEBUG_MATRICES)
                        if (nRow>=mRows) throw std::logic_error("Out of range");
#endif
                        size_t N=vec.size();
                        if (N!=mColumns) throw std::logic_error("Wrong-sized vector");
                        for (size_t i=0;i<N;i++)        {
                                const T &obj=vec[i];
                                std::pair<size_t,size_t> index=std::make_pair(nRow,i);
                                if (obj==nullObject) objectList.erase(index);
                                else objectList[index]=obj;
                        }
                }
                /**
                  * Inserts a full column into the matrix. The third argument is used to specify a null object (which won't be inserted, since the matrix is sparse).
                  * \sa getColumn
                  * \throw std::logic_error on out of range or wrong sized vector.
                  */
                void setColumn(size_t nCol,const std::vector<T> &vec,const T& nullObject=T())   {
#if defined(_DEBUG) || (MRPT_ALWAYS_CHECKS_DEBUG_MATRICES)
                        if (nCol>=mColumns) throw std::logic_error("Out of range");
#endif
                        size_t N=vec.size();
                        if (N!=mRows) throw std::logic_error("Wrong-sized vector");
                        for (size_t i=0;i<N;i++)        {
                                const T &obj=vec[i];
                                std::pair<size_t,size_t> index=std::make_pair(i,nCol);
                                if (obj==nullObject) objectList.erase(index);
                                else objectList[index]=obj;
                        }
                }
                /**
                  * Changes the size of the matrix.
                  */
                void resize(size_t nRows,size_t nCols)  {
                        // if (mRows<0||mColumns<0) throw std::logic_error("Invalid range"); // This case never happens!
                        if (mRows==nRows && mColumns==nCols) return;
                        mRows=nRows;
                        mColumns=nCols;
                        std::vector<std::pair<size_t,size_t> > toErase;
                        for (const_iterator it=objectList.begin();it!=objectList.end();++it)    {
                                const std::pair<size_t,size_t> &i=it->first;
                                if (i.first>=nRows||i.second>=nCols) toErase.push_back(it->first);
                        }
                        for (std::vector<std::pair<size_t,size_t> >::const_iterator it=toErase.begin();it!=toErase.end();++it) objectList.erase(*it);
                }
                /**
                  * Extracts a submatrix form the matrix.
                  * \sa operator()(size_t,size_t)
                  * \throw std::logic_error on invalid bounds.
                  */
                CSparseMatrixTemplate<T> operator()(size_t firstRow,size_t lastRow,size_t firstColumn,size_t lastColumn) const  {
#if defined(_DEBUG) || (MRPT_ALWAYS_CHECKS_DEBUG_MATRICES)
                        if (lastRow>=mRows||lastColumn>=mColumns) throw std::logic_error("Out of range");
                        if (firstRow>lastRow||firstColumn>lastColumn) throw std::logic_error("Invalid size");
#endif
                        CSparseMatrixTemplate<T> res=CSparseMatrixTemplate<T>(lastRow+1-firstRow,lastColumn+1-firstColumn);
                        for (typename SparseMatrixMap::const_iterator it=begin();it!=end();++it)        {
                                const std::pair<size_t,size_t> &i=it->first;
                                if (i.first>=firstRow&&i.first<=lastRow&&i.second>=firstColumn&&i.second<=lastColumn) res(i.first-firstRow,i.second-firstColumn)=it->second;
                        }
                        return res;
                }
                /**
                  * Gets a vector containing all the elements of the matrix, ignoring their position.
                  */
                void getAsVector(std::vector<T> &vec) const     {
                        size_t N=objectList.size();
                        vec.resize(0);
                        vec.reserve(N);
                        for (const_iterator it=objectList.begin();it!=objectList.end();++it) vec.push_back(it->second);
                }
                /**
                  * Gets the amount of non-null elements inside the matrix.
                  * \sa getNullElements,isNull,isNotNull
                  */
                inline size_t getNonNullElements() const        {
                        return objectList.size();
                }
                /** Are there no elements set to !=0 ?
                  * \sa getNullElements,isNull,isNotNull
                  */
                inline bool empty() const       { return objectList.empty(); }

                /**
                  * Gets the amount of null elements inside the matrix.
                  * \sa getNonNullElements,isNull,isNotNull
                  */
                inline size_t getNullElements() const   {
                        return mRows*mColumns-getNonNullElements();
                }
                /**
                  * Checks whether an element of the matrix is the default object.
                  * \sa getNonNullElements,getNullElements,isNotNull
                  * \throw std::logic_error on out of range
                  */
                inline bool isNull(size_t nRow,size_t nCol) const       {
                        if (nRow>=mRows||nCol>=mColumns) throw std::logic_error("Out of range");
                        return objectList.count(std::make_pair(nRow,nCol))==0;
                }
                /**
                  * Checks whether an element of the matrix is not the default object.
                  * \sa getNonNullElements,getNullElements,isNull
                  */
                inline bool isNotNull(size_t nRow,size_t nCol) const    {
                        if (nRow>=mRows||nCol>=mColumns) throw std::logic_error("Out of range");
                        return objectList.count(std::make_pair(nRow,nCol))>0;
                }
                /**
                  * Completely removes all elements, although maintaining the matrix's size.
                  */
                inline void clear()     {
                        objectList.clear();
                }
                /**
                  * Checks each non-null elements against the basic objects, erasing unnecesary references to it.
                  */
                void purge(T nullObject=T())    {
                        std::vector<std::pair<size_t,size_t> > nulls;
                        for (const_iterator it=begin();it!=end();++it) if (it->second==nullObject) nulls.push_back(it->first);
                        for (std::vector<std::pair<size_t,size_t> >::const_iterator it=nulls.begin();it!=nulls.end();++it) objectList.erase(*it);
                }
        }; // end of sparse matrix

    /** A sparse matrix container for square symmetrical content around the main diagonal.
      *  This class saves half of the space with respect to CSparseMatrixTemplate since only those entries (c,r) such as c>=r are really stored,
      *   but both (c,r) and (r,c) can be retrieved or set and both redirect to the same internal cell container.
      *  \sa CSparseMatrixTemplate
      */
        template<class T>
        class CSparseSymmetricalMatrix : public CSparseMatrixTemplate<T> {
                public:
                CSparseSymmetricalMatrix() : CSparseMatrixTemplate<T>() { }
                explicit CSparseSymmetricalMatrix(const CSparseSymmetricalMatrix &o) : CSparseMatrixTemplate<T>(o) { }
                explicit CSparseSymmetricalMatrix(const CSparseMatrixTemplate<T> &o) : CSparseMatrixTemplate<T>(o) { }
                virtual ~CSparseSymmetricalMatrix() { }

                void resize(size_t matrixSize) {
                        CSparseMatrixTemplate<T>::resize(matrixSize,matrixSize);
                }

                inline T operator()(size_t r,size_t c) const    {
                        if (c<r) std::swap(r,c); // Symmetrical matrix
                        typename CSparseMatrixTemplate<T>::const_iterator it=CSparseMatrixTemplate<T>::objectList.find(std::make_pair(r,c));
                        if (it==CSparseMatrixTemplate<T>::objectList.end()) return T();
                        else return it->second;
                }
                inline T& operator()(size_t r,size_t c) { //-V659
                        if (c<r) std::swap(r,c); // Symmetrical matrix
                        if (r>=CSparseMatrixTemplate<T>::mRows||c>=CSparseMatrixTemplate<T>::mColumns) throw std::logic_error("Out of range");
                        return CSparseMatrixTemplate<T>::objectList[std::make_pair(r,c)];
                }

        }; // end of CSparseSymmetricalMatrix

}
}
#endif