CMatrixTemplateNumeric.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 CMatrixTemplateNumeric_H
#define CMatrixTemplateNumeric_H

#include <mrpt/utils/core_defs.h>
#include <mrpt/utils/types_math.h>
#include <mrpt/utils/TTypeName.h>
#include <mrpt/math/point_poses2vectors.h> // MRPT_MATRIX_CONSTRUCTORS_FROM_POSES()

namespace mrpt
{
        namespace math
        {
                /**  A matrix of dynamic size.
                  *   Basically, this class is a wrapper on Eigen::Matrix<T,Dynamic,Dynamic>, but
                  *   with a RowMajor element memory layout (except for column vectors).
                  *
                  * \note This class exists for backward compatibility of ancient times when MRPT didn't rely on Eigen, feel free to directly use Eigen::Matrix<> types instead.
                  *
                  * \sa CMatrixTemplate (a non Eigen lib-based  class, which can hold arbitrary objects, not only numerical types).
                 * \note For a complete introduction to Matrices and vectors in MRPT, see: http://www.mrpt.org/Matrices_vectors_arrays_and_Linear_Algebra_MRPT_and_Eigen_classes
                 * \ingroup mrpt_base_grp
                  */
                template <class T>
                class CMatrixTemplateNumeric :
                        public Eigen::Matrix<
                                T,
                                Eigen::Dynamic,
                                Eigen::Dynamic,
                                // Use row major storage for backward compatibility with MRPT matrices in all cases (even in column vectors!)
                                Eigen::AutoAlign | Eigen::RowMajor
                                >
                {
                public:
                        typedef Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic,Eigen::AutoAlign|Eigen::RowMajor> Base;
                        typedef CMatrixTemplateNumeric<T> mrpt_autotype;

                        MRPT_MATRIX_CONSTRUCTORS_FROM_POSES(CMatrixTemplateNumeric)

                        /** Default constructor, builds a 1x1 matrix */
                        inline CMatrixTemplateNumeric() : Base(1,1) { Base::setZero(); }

                        /** Constructor that builds a 0x0 matrix (that is, uninitialized), for usage in places where efficiency is a priority.
                          *  Use as:
                          *   \code
                          *     CMatrixTemplateNumeric<double>  M( UNINITIALIZED_MATRIX);
                          *   \endcode
                          */
                        inline CMatrixTemplateNumeric(TConstructorFlags_Matrices ) : Base( 0,0 ) { }

                        /** Constructor, creates a matrix of the given size, filled with zeros. */
                        inline CMatrixTemplateNumeric(size_t row, size_t col) : Base(row,col) { Base::setZero(); }

                        MRPT_EIGEN_DERIVED_CLASS_CTOR_OPERATOR_EQUAL(CMatrixTemplateNumeric) // Implements ctor and "operator =" for any other Eigen class

                        /** Assignment operator of other types
                        */
                        template <class R>
                        inline CMatrixTemplateNumeric<T>& operator = (const CMatrixTemplate<R>& m)
                        {
                                Base::resize( m.getRowCount(), m.getColCount() );

                                for (size_t i=0; i < CMatrixTemplate<T>::getRowCount(); i++)
                                        for (size_t j=0; j < CMatrixTemplate<T>::getColCount(); j++)
                                                Base::coeffRef(i,j) = static_cast<T>(m.get_unsafe(i,j));
                                return *this;
                        }

                        /** Assignment from any Eigen matrix/vector */
                        template <typename Derived>
                        inline CMatrixTemplateNumeric<T>& operator =(const Eigen::MatrixBase<Derived>& m) const
                        {
                                Base::operator =(m);
                                return *this;
                        }


                        /** Constructor from a given size and a C array. The array length must match cols x row.
                          * \code
                          *  const double numbers[] = {
                          *    1,2,3,
                          *    4,5,6 };
                          *      CMatrixDouble   M(3,2, numbers);
                          * \endcode
                          */
                        template <typename V, size_t N>
                        inline CMatrixTemplateNumeric(size_t row, size_t col, V (&theArray)[N] ) : Base(row,col)
                        {
                                ASSERT_EQUAL_(row*col,N)
                                ASSERT_EQUAL_(sizeof(theArray[0]),sizeof(T))
                                ::memcpy(Base::data(),&theArray[0],sizeof(T)*N); // Remember, row-major order!
                        }

                        /** Destructor
                          */
                        inline ~CMatrixTemplateNumeric() { }

                        /** == comparison of two matrices; it differs from default Eigen operator in that returns false if matrices are of different sizes instead of raising an assert. */
                        template <typename Derived>
                        inline bool operator ==(const Eigen::MatrixBase<Derived>& m2) const
                        {
                                return Base::cols()==m2.cols() &&
                                           Base::rows()==m2.rows() &&
                                           Base::cwiseEqual(m2).all();
                        }
                        /** != comparison of two matrices; it differs from default Eigen operator in that returns true if matrices are of different sizes instead of raising an assert. */
                        template <typename Derived>
                        inline bool operator !=(const Eigen::MatrixBase<Derived>& m2)  const{ return !((*this)==m2); }

                }; // end of class definition


                /** Declares a matrix of float numbers (non serializable).
                  *  For a serializable version, use math::CMatrix
                  *  \sa CMatrixDouble, CMatrix, CMatrixD
                  */
                typedef CMatrixTemplateNumeric<float> CMatrixFloat;

                /** Declares a matrix of double numbers (non serializable).
                  *  For a serializable version, use math::CMatrixD
                  *  \sa CMatrixFloat, CMatrix, CMatrixD
                  */
                typedef CMatrixTemplateNumeric<double> CMatrixDouble;

                /** Declares a matrix of unsigned ints (non serializable).
                  *  \sa CMatrixDouble, CMatrixFloat
                  */
                typedef CMatrixTemplateNumeric<unsigned int> CMatrixUInt;

#ifdef HAVE_LONG_DOUBLE
                /** Declares a matrix of "long doubles" (non serializable), or of "doubles" if the compiler does not support "long double".
                  *  \sa CMatrixDouble, CMatrixFloat
                  */
                typedef CMatrixTemplateNumeric<long double> CMatrixLongDouble;
#else
                /** Declares a matrix of "long doubles" (non serializable), or of "doubles" if the compiler does not support "long double".
                  *  \sa CMatrixDouble, CMatrixFloat
                  */
                typedef CMatrixTemplateNumeric<double> CMatrixLongDouble;
#endif


                namespace detail
                {
                        /**
                          * Vicinity traits class specialization for fixed size matrices.
                          */
                        template<typename T> class VicinityTraits<CMatrixTemplateNumeric<T> >   {
                        public:
                                inline static void initialize(CMatrixTemplateNumeric<T> &mat,size_t N)  {
                                        mat.setSize(N,N);
                                        mat.fill(0);
                                }
                                inline static void insertInContainer(CMatrixTemplateNumeric<T> &mat,size_t r,size_t c,const T &t)       {
                                        mat.get_unsafe(r,c)=t;
                                }
                        };
                }       //End of detail namespace.

        } // End of namespace


        namespace utils
        {
                // Extensions to mrpt::utils::TTypeName for matrices:
                template<typename T> struct TTypeName <mrpt::math::CMatrixTemplateNumeric<T> > {
                        static std::string get() { return std::string("CMatrixTemplateNumeric<")+ std::string( TTypeName<T>::get() )+std::string(">"); }
                };
        }

} // End of namespace


#endif