CMatrixFixedNumeric.h

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, 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 |
   +------------------------------------------------------------------------+ */
#pragma once
 
#include <mrpt/math/math_frwds.h>  // Forward declarations
#include <mrpt/math/eigen_frwds.h>
#include <mrpt/math/types_math.h>
#include <mrpt/serialization/CSerializable.h>
#include <mrpt/typemeta/TTypeName.h>
#include <mrpt/typemeta/num_to_string.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_math_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:
    using Base = Eigen::Matrix<
        T, NROWS, NCOLS,
        Eigen::AutoAlign |
            ((NCOLS == 1 && NROWS != 1) ? Eigen::ColMajor : Eigen::RowMajor)>;
    using mrpt_autotype = CMatrixFixedNumeric<T, NROWS, NCOLS>;
    MRPT_MATRIX_CONSTRUCTORS_FROM_POSES(CMatrixFixedNumeric)
    MRPT_EIGEN_DERIVED_CLASS_CTOR_OPERATOR_EQUAL(
        CMatrixFixedNumeric)  // Implements ctor and "operator =" for any other
    // Eigen class
 
    /** 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;
    }
};
}  // namespace detail
 
}  // namespace math
 
namespace typemeta
{
// Extensions to mrpt::typemeta::TTypeName for matrices:
template <typename T, size_t N, size_t M>
struct TTypeName<mrpt::math::CMatrixFixedNumeric<T, N, M>>
{
    constexpr static auto get()
    {
        return literal("CMatrixFixedNumeric<") + TTypeName<T>::get() +
               literal(",") + literal(num_to_string<N>::value) + literal(",") +
               literal(num_to_string<M>::value) + literal(">");
    }
};
}  // namespace typemeta
 
}  // namespace mrpt