CArrayNumeric.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/types_math.h>  // Eigen
#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
{
/** CArrayNumeric is an array for numeric types supporting several mathematical
 * operations (actually, just a wrapper on Eigen::Matrix<T,N,1>)
  * \sa CArrayFloat, CArrayDouble, CArray
  */
template <typename T, std::size_t N>
class CArrayNumeric : public Eigen::Matrix<T, N, 1>
{
   public:
        using value_type = T;
        using Base = Eigen::Matrix<T, N, 1>;
 
        /** Default constructor */
        CArrayNumeric() {}
        /** Constructor from initial values ptr[0]-ptr[N-1] */
        CArrayNumeric(const T* ptr) : Eigen::Matrix<T, N, 1>(ptr) {}
        /** Initialization from a vector-like source, that is, anything implementing
         * operator[]. */
        template <class Derived>
        explicit CArrayNumeric(const Eigen::MatrixBase<Derived>& obj)
                : Eigen::Matrix<T, N, 1>(obj)
        {
        }
 
        MRPT_MATRIX_CONSTRUCTORS_FROM_POSES(CArrayNumeric)
 
        template <typename OtherDerived>
        inline CArrayNumeric<T, N>& operator=(
                const Eigen::MatrixBase<OtherDerived>& other)
        {
                Base::operator=(other);
                return *this;
        }
};
 
// --------------  Partial specializations of CArrayNumeric -----------
 
/** A partial specialization of CArrayNumeric for float numbers.
* \sa CArrayNumeric, CArray */
template <std::size_t N>
using CArrayFloat = CArrayNumeric<float, N>;
 
/** A partial specialization of CArrayNumeric for double numbers.
  * \sa CArrayNumeric, CArray */
template <std::size_t N>
using CArrayDouble = CArrayNumeric<double, N>;
 
/** A partial specialization of CArrayNumeric for int numbers.
  * \sa CArrayNumeric, CArray */
template <std::size_t N>
using CArrayInt = CArrayNumeric<int, N>;
 
/** A partial specialization of CArrayNumeric for unsigned int numbers.
  * \sa CArrayNumeric, CArray */
template <std::size_t N>
using CArrayUInt = CArrayNumeric<unsigned int, N>;
}
 
namespace typemeta
{
// Extensions to mrpt::typemeta::TTypeName for matrices:
template <typename T, size_t N>
struct TTypeName<mrpt::math::CArrayNumeric<T, N>>
{
        constexpr static auto get()
        {
                return literal("CArrayNumeric<") + TTypeName<T>::get() + literal(",") +
                           literal(num_to_string<N>::value) + literal(">");
        }
};
template <size_t N>
struct TTypeName<mrpt::math::CArrayDouble<N>>
{
        constexpr static auto get()
        {
                return literal("CArrayDouble<") + literal(num_to_string<N>::value) +
                           literal(">");
        }
};
template <size_t N>
struct TTypeName<mrpt::math::CArrayFloat<N>>
{
        constexpr static auto get()
        {
                return literal("CArrayFloat<") + literal(num_to_string<N>::value) +
                           literal(">");
        }
};
}
}  // End of namespace