CMatrixFixedNumeric.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 CMatrixFixedNumeric_H
#define CMatrixFixedNumeric_H

#include <mrpt/math/math_frwds.h>  // Forward declarations
#include <mrpt/math/eigen_frwds.h>
#include <mrpt/utils/types_math.h>
#include <mrpt/utils/CSerializable.h>
#include <mrpt/math/point_poses2vectors.h>  // MRPT_MATRIX_CONSTRUCTORS_FROM_POSES()

namespace mrpt
{
namespace math
{
/**  A numeric matrix of compile-time fixed size.
 *   Basically, this class is a wrapper on Eigen::Matrix<T,NROWS,NCOLS>, but
 *   with a RowMajor element memory layout (except for column vectors).
 *
 *  These matrices also have iterators to access all the elements in the matrix
 * as a sequence, starting from the element (0,0), then row by row, from left to
 * right.
 *
 * \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 CMatrixTemplateNumeric (for dynamic-size matrices)
 * \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 <typename T, size_t NROWS, size_t NCOLS>
class CMatrixFixedNumeric
        : public Eigen::Matrix<
                  T, NROWS, NCOLS,
                  // Use row major storage for backward compatibility with MRPT matrices
                  // in all cases, except in column vectors:
                  Eigen::AutoAlign |
                          ((NCOLS == 1 && NROWS != 1) ? Eigen::ColMajor : Eigen::RowMajor)>
{
   public:
        typedef Eigen::Matrix<T, NROWS, NCOLS,
                                                  Eigen::AutoAlign |
                                                          ((NCOLS == 1 && NROWS != 1) ? Eigen::ColMajor
                                                                                                                  : Eigen::RowMajor)>
                Base;
        typedef CMatrixFixedNumeric<T, NROWS, NCOLS> mrpt_autotype;

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

        /** Default constructor, initializes all elements to zero */
        inline CMatrixFixedNumeric() : Base() { Base::setZero(); }
        /** Constructor from an array in row major */
        inline CMatrixFixedNumeric(const T* vals) : Base(vals) {}
        /** Constructor which leaves the matrix uninitialized.
          *  Example of usage: CMatrixFixedNumeric<double,3,2>
         * M(mrpt::math::UNINITIALIZED_MATRIX);
          */
        inline CMatrixFixedNumeric(TConstructorFlags_Matrices) : Base() {}
        template <size_t N, typename ReturnType>
        inline ReturnType getVicinity(size_t c, size_t r) const
        {
                return detail::getVicinity<CMatrixFixedNumeric<T, NROWS, NCOLS>, T,
                                                                   ReturnType, N>::get(c, r, *this);
        }

        inline void loadFromArray(const T* vals)
        {
                Base b(vals);
                *this = b;
        }

        /** == 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 ------------------------------

namespace detail
{
/**
  * Vicinity traits class specialization for fixed size matrices.
  */
template <typename T, size_t D>
class VicinityTraits<CMatrixFixedNumeric<T, D, D>>
{
   public:
        inline static void initialize(CMatrixFixedNumeric<T, D, D>& mat, size_t N)
        {
                UNUSED(mat);
                ASSERT_(N == D);
        }
        inline static void insertInContainer(
                CMatrixFixedNumeric<T, D, D>& 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, size_t N, size_t M>
struct TTypeName<mrpt::math::CMatrixFixedNumeric<T, N, M>>
{
        static std::string get()
        {
                return mrpt::format(
                        "CMatrixFixedNumeric<%s,%u,%u>", TTypeName<T>::get().c_str(),
                        (unsigned int)N, (unsigned int)M);
        }
};
}

}  // End of namespace

#endif