matrix_adaptors.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 |
   +------------------------------------------------------------------------+ */
#ifndef mrpt_matrix_adaptors_H
#define mrpt_matrix_adaptors_H

#include <mrpt/math/math_frwds.h>  // forward declarations

namespace mrpt
{
namespace math
{
/** Internal classes not to be directly used by the user. */
// Forward declarations:
template <typename T, typename U, bool UIsObject>
class CBinaryRelation;
namespace detail
{
/**
 * This template is a trick to switch the type of a variable using a boolean
 * variable in the template. It's easy to extend its functionality to several
 * types, using a unsigned char instead of a bool.
 */
template <typename U, bool B>
class MatrixWrapper;

// partial specializations:
template <typename U>
class MatrixWrapper<U, true>
{
   public:
    using MatrixType = CMatrixTemplateObjects<U>;
};
template <typename U>
class MatrixWrapper<U, false>
{
   public:
    using MatrixType = CMatrixTemplate<U>;
};

template <typename T, typename U, bool UIsObject, typename FunctionType>
inline void applyFunction(
    CBinaryRelation<T, U, UIsObject>& o, FunctionType fun, size_t e1, size_t e2,
    const T& T1, const T& T2);
}  // namespace detail

namespace detail
{
/** Template class for matrix accessor's iterators.
 * \sa CMatrixRowAccessor,CMatrixColumnAccessor
 */
template <typename A, typename T>
class AccessorIterator
{
   protected:
    A* base;
    int pos;

   public:
    // typedefs for iterator_traits:
    using iterator_category = std::random_access_iterator_tag;
    using value_type = T;
    using difference_type = int;
    using pointer = T*;
    using reference = T&;

    inline AccessorIterator(A& obj, size_t N) : base(&obj), pos(N) {}
    inline T& operator*() const { return (*base)[pos]; }
    inline AccessorIterator<A, T>& operator++()
    {
        ++pos;
        return *this;
    }
    inline AccessorIterator<A, T> operator++(int)
    {
        AccessorIterator<A, T> it = *this;
        ++*this;
        return it;
    }
    inline AccessorIterator<A, T>& operator--()
    {
        --pos;
        return *this;
    }
    inline AccessorIterator<A, T> operator--(int)
    {
        AccessorIterator<A, T> it = *this;
        --*this;
        return it;
    }
    inline AccessorIterator<A, T>& operator+=(int off)
    {
        pos += off;
        return *this;
    }
    inline AccessorIterator<A, T> operator+(int off) const
    {
        AccessorIterator<A, T> it = *this;
        it += off;
        return it;
    }
    inline AccessorIterator<A, T>& operator-=(int off)
    {
        pos -= off;
        return *this;
    }
    inline AccessorIterator<A, T> operator-(int off) const
    {
        AccessorIterator<A, T> it = *this;
        it -= off;
        return it;
    }
    inline int operator-(const AccessorIterator<A, T>& it) const
    {
        return pos - it.pos;
    }
    inline T& operator[](int off) const { return (*base)[pos + off]; }
    inline bool operator==(const AccessorIterator<A, T>& it) const
    {
        return (pos == it.pos) && (base == it.base);
    }
    inline bool operator!=(const AccessorIterator<A, T>& it) const
    {
        return !(operator==(it));
    }
};

/** Template class for matrix accessor's iterators.
 * \sa CMatrixRowAccessor,CMatrixColumnAccessor
 */
template <typename A, typename T>
class ReverseAccessorIterator
{
   protected:
    A* base;
    int pos;

   public:
    // typedefs for iterator_traits:
    using iterator_category = std::random_access_iterator_tag;
    using value_type = T;
    using difference_type = int;
    using pointer = T*;
    using reference = T&;

    inline ReverseAccessorIterator(A& obj, size_t N) : base(&obj), pos(N) {}
    inline T& operator*() const { return (*base)[pos]; }
    inline ReverseAccessorIterator<A, T>& operator++()
    {
        --pos;
        return *this;
    }
    inline ReverseAccessorIterator<A, T> operator++(int)
    {
        ReverseAccessorIterator<A, T> it = *this;
        ++*this;  // Yes, that's right.
        return it;
    }
    inline ReverseAccessorIterator<A, T>& operator--()
    {
        ++pos;
        return *this;
    }
    inline ReverseAccessorIterator<A, T> operator--(int)
    {
        ReverseAccessorIterator<A, T> it = *this;
        --*this;  // Yes, that's right.
        return it;
    }
    inline ReverseAccessorIterator<A, T>& operator+=(int off)
    {
        pos -= off;
        return *this;
    }
    inline ReverseAccessorIterator<A, T> operator+(int off) const
    {
        ReverseAccessorIterator<A, T> it = *this;
        it += off;  // Yes, that's right.
        return it;
    }
    inline AccessorIterator<A, T>& operator-=(int off)
    {
        pos += off;
        return *this;
    }
    inline AccessorIterator<A, T> operator-(int off) const
    {
        ReverseAccessorIterator<A, T> it = *this;
        it -= off;  // Yes, that's right
        return it;
    }
    inline int operator-(const ReverseAccessorIterator<A, T>& it) const
    {
        return it.pos - pos;
    }
    inline T& operator[](int off) const { return (*base)[pos - off]; }
    inline bool operator==(const ReverseAccessorIterator<A, T>& it) const
    {
        return (pos == it.pos) && (&base == &it.base);
    }
    inline bool operator!=(const ReverseAccessorIterator<A, T>& it) const
    {
        return !(operator==(it));
    }
};
}  // namespace detail

/** A vector-like wrapper for a Matrix for accessing the elements of a given row
 * with a [] operator.
 *  For usage with MRPT's CMatrixTemplate only (for MRPT numeric matrices, use
 * Eigen methods)
 * \sa
 * CMatrixColumnAccessor,CMatrixRowAccessorExtended,CConstMatrixRowAccessor,CConstMatrixRowAccessorExtended
 */
template <typename MAT>
class CMatrixRowAccessor
{
   protected:
    MAT* m_mat;
    size_t m_rowInd;

   public:
    using value_type = typename MAT::Scalar;
    using mrpt_autotype = CMatrixRowAccessor<MAT>;
    inline CMatrixRowAccessor(MAT& mat, size_t rowIdx)
        : m_mat(&mat), m_rowInd(rowIdx)
    {
        ASSERT_(rowIdx < mat.rows();
    }
    inline CMatrixRowAccessor() {}
    inline value_type& operator[](const size_t i)
    {
        return (*m_mat)(m_rowInd, i);
    }
    inline value_type operator[](const size_t i) const
    {
        return (*m_mat)(m_rowInd, i);
    }
    using iterator =
        detail::AccessorIterator<CMatrixRowAccessor<MAT>, value_type>;
    using const_iterator = detail::AccessorIterator<
        const CMatrixRowAccessor<MAT>, const value_type>;
    using reverse_iterator =
        detail::ReverseAccessorIterator<CMatrixRowAccessor<MAT>, value_type>;
    using const_reverse_iterator = detail::ReverseAccessorIterator<
        const CMatrixRowAccessor<MAT>, const value_type>;
    inline iterator begin() { return iterator(*this, 0); }
    inline const_iterator begin() const { return const_iterator(*this, 0); }
    inline iterator end() { return iterator(*this, m_mat->cols()); }
    inline const_iterator end() const
    {
        return const_iterator(*this, m_mat->cols());
    }
    inline reverse_iterator rbegin()
    {
        return reverse_iterator(*this, m_mat->cols() - 1);
    }
    inline const_reverse_iterator rbegin() const
    {
        return const_reverse_iterator(*this, m_mat->cols() - 1);
    }
    inline reverse_iterator rend() { return reverse_iterator(*this, -1); }
    inline const_reverse_iterator rend() const
    {
        return const_reverse_iterator(*this, -1);
    }
    inline size_t size() const { return m_mat->cols(); }
    inline void resize(size_t N)
    {
        if (N != size())
            throw std::logic_error("Tried to resize a fixed-size vector");
    }
};
template <typename MAT>
inline CMatrixRowAccessor<MAT> getRowAccessor(MAT& m, size_t rowIdx)
{
    return CMatrixRowAccessor<MAT>(m, rowIdx);
}

/** A vector-like wrapper for a Matrix for accessing the elements of a given row
 * with a [] operator, with offset and custom spacing.
 *  For usage with MRPT's CMatrixTemplate only (for MRPT numeric matrices, use
 * Eigen methods)
 * \sa
 * CMatrixColumnAccessorExtended,CMatrixRowAccessor,CConstMatrixRowAccessor,CConstMatrixRowAccessorExtended
 */
template <class MAT>
class CMatrixRowAccessorExtended
{
   protected:
    MAT* m_mat;
    size_t m_rowInd;
    size_t m_colOffset;
    size_t m_elementsSpace;
    size_t howMany;

   public:
    using value_type = typename MAT::Scalar;
    using mrpt_autotype = CMatrixRowAccessorExtended<MAT>;
    inline CMatrixRowAccessorExtended(
        MAT& mat, size_t row, size_t offset, size_t space)
        : m_mat(&mat),
          m_rowInd(row),
          m_colOffset(offset),
          m_elementsSpace(space)
    {
        ASSERT_(row < mat.rows());
        howMany = (mat.cols() - m_colOffset) / m_elementsSpace;
    }
    inline CMatrixRowAccessorExtended() {}
    inline value_type& operator[](size_t i)
    {
        return (*m_mat)(m_rowInd, m_colOffset + (i * m_elementsSpace));
    }
    inline value_type operator[](size_t i) const
    {
        return (*m_mat)(m_rowInd, m_colOffset + (i * m_elementsSpace));
    }
    using iterator =
        detail::AccessorIterator<CMatrixRowAccessorExtended<MAT>, value_type>;
    using const_iterator = detail::AccessorIterator<
        const CMatrixRowAccessorExtended<MAT>, const value_type>;
    using reverse_iterator = detail::ReverseAccessorIterator<
        CMatrixRowAccessorExtended<MAT>, value_type>;
    using const_reverse_iterator = detail::ReverseAccessorIterator<
        const CMatrixRowAccessorExtended<MAT>, const value_type>;
    inline iterator begin() { return iterator(*this, 0); }
    inline const_iterator begin() const { return const_iterator(*this, 0); }
    inline iterator end() { return iterator(*this, howMany); }
    inline const_iterator end() const { return const_iterator(*this, howMany); }
    inline reverse_iterator rbegin()
    {
        return reverse_iterator(*this, howMany - 1);
    }
    inline const_reverse_iterator rbegin() const
    {
        return const_reverse_iterator(*this, howMany - 1);
    }
    inline reverse_iterator rend() { return reverse_iterator(*this, -1); }
    inline const_reverse_iterator rend() const
    {
        return const_reverse_iterator(*this, -1);
    }
    inline size_t size() const { return howMany; }
    inline void resize(size_t N)
    {
        if (N != size())
            throw std::logic_error("Tried to resize a fixed-size vector");
    }
};
template <typename MAT>
inline CMatrixRowAccessorExtended<MAT> getRowAccessor(
    MAT& m, size_t rowIdx, size_t offset, size_t space = 1)
{
    return CMatrixRowAccessor<MAT>(m, rowIdx, offset, space);
}

/** A vector-like wrapper for a const Matrix for accessing the elements of a
 * given row with a [] operator.
 *  For usage with MRPT's CMatrixTemplate only (for MRPT numeric matrices, use
 * Eigen methods)
 * \sa
 * CConstMatrixColumnAccessor,CMatrixRowAccessorExtended,CMatrixRowAccessor,CConstMatrixRowAccessorExtended
 */
template <class MAT>
class CConstMatrixRowAccessor
{
   protected:
    const MAT* m_mat;
    size_t m_rowInd;

   public:
    using value_type = typename MAT::Scalar;
    using mrpt_autotype = CConstMatrixRowAccessor<MAT>;
    inline CConstMatrixRowAccessor(const MAT& mat, size_t row)
        : m_mat(&mat), m_rowInd(row)
    {
        ASSERT_(row < mat.rows());
    }
    inline CConstMatrixRowAccessor() {}
    inline value_type operator[](size_t i) const
    {
        return (*m_mat)(m_rowInd, i);
    }
    using const_iterator = detail::AccessorIterator<
        const CConstMatrixRowAccessor<MAT>, const value_type>;
    using const_reverse_iterator = detail::ReverseAccessorIterator<
        const CConstMatrixRowAccessor<MAT>, const value_type>;
    inline const_iterator begin() const { return const_iterator(*this, 0); }
    inline const_iterator end() const
    {
        return const_iterator(*this, m_mat->cols());
    }
    inline const_reverse_iterator rbegin() const
    {
        return const_reverse_iterator(*this, m_mat->cols() - 1);
    }
    inline const_reverse_iterator rend() const
    {
        return const_reverse_iterator(*this, -1);
    }
    inline size_t size() const { return m_mat->cols(); }
    inline void resize(size_t N)
    {
        if (N != size())
            throw std::logic_error("Tried to resize a fixed-size vector");
    }
};
template <typename MAT>
inline CConstMatrixRowAccessor<MAT> getRowAccessor(const MAT& m, size_t rowIdx)
{
    return CMatrixRowAccessor<MAT>(m, rowIdx);
}

/** A vector-like wrapper for a const Matrix for accessing the elements of a
 * given row with a [] operator, with offset and custom spacing.
 *  For usage with MRPT's CMatrixTemplate only (for MRPT numeric matrices, use
 * Eigen methods)
 * \sa
 * CConstMatrixColumnAccessorExtended,CMatrixRowAccessor,CConstMatrixRowAccessor,CMatrixRowAccessorExtended
 */
template <class MAT>
class CConstMatrixRowAccessorExtended
{
   protected:
    const MAT* m_mat;
    size_t m_rowInd;
    size_t m_colOffset;
    size_t m_elementsSpace;
    size_t howMany;

   public:
    using value_type = typename MAT::Scalar;
    using mrpt_autotype = CConstMatrixRowAccessorExtended<MAT>;
    inline CConstMatrixRowAccessorExtended(
        const MAT& mat, size_t row, size_t offset, size_t space)
        : m_mat(&mat),
          m_rowInd(row),
          m_colOffset(offset),
          m_elementsSpace(space)
    {
        ASSERT_(row < mat.rows());
        howMany = (mat.cols() - m_colOffset) / m_elementsSpace;
    }
    inline CConstMatrixRowAccessorExtended() {}
    inline value_type operator[](size_t i) const
    {
        return (*m_mat)(m_rowInd, m_colOffset + (i * m_elementsSpace));
    }
    using const_iterator = detail::AccessorIterator<
        const CConstMatrixRowAccessorExtended<MAT>, const value_type>;
    using const_reverse_iterator = detail::ReverseAccessorIterator<
        const CConstMatrixRowAccessorExtended<MAT>, const value_type>;
    inline const_iterator begin() const { return const_iterator(*this, 0); }
    inline const_iterator end() const { return const_iterator(*this, howMany); }
    inline const_reverse_iterator rbegin() const
    {
        return const_reverse_iterator(*this, howMany - 1);
    }
    inline const_reverse_iterator rend() const
    {
        return const_reverse_iterator(*this, -1);
    }
    inline size_t size() const { return howMany; }
    inline void resize(size_t N)
    {
        if (N != size())
            throw std::logic_error("Tried to resize a fixed-size vector");
    }
};
template <typename MAT>
inline CConstMatrixRowAccessorExtended<MAT> getRowAccessor(
    const MAT& m, size_t rowIdx, size_t offset, size_t space = 1)
{
    return CConstMatrixRowAccessorExtended<MAT>(m, rowIdx, offset, space);
}

/** A vector-like wrapper for a Matrix for accessing the elements of a given
 * column with a [] operator.
 * \sa
 * CMatrixRowAccessor,CMatrixColumnAccessorExtended,CConstMatrixColumnAccessor,CConstMatrixColumnAccessorExtended
 */
template <typename MAT>
class CMatrixColumnAccessor
{
   protected:
    MAT* m_mat;
    size_t m_colInd;

   public:
    using value_type = typename MAT::Scalar;
    using mrpt_autotype = CMatrixColumnAccessor<MAT>;
    inline CMatrixColumnAccessor(MAT& mat, size_t colIdx)
        : m_mat(&mat), m_colInd(colIdx)
    {
        ASSERT_(colIdx < mat.cols();
    }
    inline CMatrixColumnAccessor() {}
    inline value_type& operator[](const size_t i)
    {
        return (*m_mat)(i, m_colInd);
    }
    inline value_type operator[](const size_t i) const
    {
        return (*m_mat)(i, m_colInd);
    }
    using iterator =
        detail::AccessorIterator<CMatrixColumnAccessor<MAT>, value_type>;
    using const_iterator = detail::AccessorIterator<
        const CMatrixColumnAccessor<MAT>, const value_type>;
    using reverse_iterator =
        detail::ReverseAccessorIterator<CMatrixColumnAccessor<MAT>, value_type>;
    using const_reverse_iterator = detail::ReverseAccessorIterator<
        const CMatrixColumnAccessor<MAT>, const value_type>;
    inline iterator begin() { return iterator(*this, 0); }
    inline const_iterator begin() const { return const_iterator(*this, 0); }
    inline iterator end() { return iterator(*this, m_mat->rows()); }
    inline const_iterator end() const
    {
        return const_iterator(*this, m_mat->rows());
    }
    inline reverse_iterator rbegin()
    {
        return reverse_iterator(*this, m_mat->rows() - 1);
    }
    inline const_reverse_iterator rbegin() const
    {
        return const_reverse_iterator(*this, m_mat->rows() - 1);
    }
    inline reverse_iterator rend() { return reverse_iterator(*this, -1); }
    inline const_reverse_iterator rend() const
    {
        return const_reverse_iterator(*this, -1);
    }
    inline size_t size() const { return m_mat->rows(); }
    inline void resize(size_t N)
    {
        if (N != size())
            throw std::logic_error("Tried to resize a fixed-size vector");
    }
};
template <typename MAT>
inline CMatrixColumnAccessor<MAT> getColumnAccessor(MAT& m, size_t colIdx)
{
    return CMatrixColumnAccessor<MAT>(m, colIdx);
}

/** A vector-like wrapper for a Matrix for accessing the elements of a given
 * column with a [] operator, with offset and custom spacing.
 * \sa
 * CMatrixRowAccessorExtended,CMatrixColumnAccessor,CConstMatrixColumnAccessor,CConstMatrixColumnAccessorExtended
 */
template <typename MAT>
class CMatrixColumnAccessorExtended
{
   protected:
    MAT* m_mat;
    size_t m_colInd;
    size_t m_rowOffset;
    size_t m_elementsSpace;
    size_t howMany;

   public:
    using value_type = typename MAT::Scalar;
    using mrpt_autotype = CMatrixColumnAccessorExtended<MAT>;
    inline CMatrixColumnAccessorExtended(
        MAT& mat, size_t col, size_t offset, size_t space)
        : m_mat(&mat),
          m_colInd(col),
          m_rowOffset(offset),
          m_elementsSpace(space)
    {
        ASSERT_(col < mat.cols());
        howMany = (mat.rows() - m_rowOffset) / m_elementsSpace;
    }
    inline CMatrixColumnAccessorExtended() {}
    inline value_type& operator[](size_t i)
    {
        return (*m_mat)(m_rowOffset + (i * m_elementsSpace), m_colInd);
    }
    inline value_type operator[](size_t i) const
    {
        return (*m_mat)(m_rowOffset + (i * m_elementsSpace), m_colInd);
    }
    using iterator = detail::AccessorIterator<
        CMatrixColumnAccessorExtended<MAT>, value_type>;
    using const_iterator = detail::AccessorIterator<
        const CMatrixColumnAccessorExtended<MAT>, const value_type>;
    using reverse_iterator = detail::ReverseAccessorIterator<
        CMatrixColumnAccessorExtended<MAT>, value_type>;
    using const_reverse_iterator = detail::ReverseAccessorIterator<
        const CMatrixColumnAccessorExtended<MAT>, const value_type>;
    inline iterator begin() { return iterator(*this, 0); }
    inline const_iterator begin() const { return const_iterator(*this, 0); }
    inline iterator end() { return iterator(*this, howMany); }
    inline const_iterator end() const { return const_iterator(*this, howMany); }
    inline reverse_iterator rbegin()
    {
        return reverse_iterator(*this, howMany - 1);
    }
    inline const_reverse_iterator rbegin() const
    {
        return const_reverse_iterator(*this, howMany - 1);
    }
    inline reverse_iterator rend() { return reverse_iterator(*this, -1); }
    inline const_reverse_iterator rend() const
    {
        return const_reverse_iterator(*this, -1);
    }
    inline size_t size() const { return howMany; }
    inline void resize(size_t N)
    {
        if (N != size())
            throw std::logic_error("Tried to resize a fixed-size vector");
    }
};
template <typename MAT>
inline CMatrixColumnAccessorExtended<MAT> getColumnAccessor(
    MAT& m, size_t colIdx, size_t offset, size_t space = 1)
{
    return CMatrixColumnAccessorExtended<MAT>(m, colIdx, offset, space);
}

/** A vector-like wrapper for a const Matrix for accessing the elements of a
 * given column with a [] operator.
 * \sa
 * CConstMatrixRowAccessor,CMatrixColumnAccessorExtended,CMatrixColumnAccessor,CConstMatrixColumnAccessorExtended
 */
template <class MAT>
class CConstMatrixColumnAccessor
{
   protected:
    const MAT* m_mat;
    size_t m_colInd;

   public:
    using value_type = typename MAT::Scalar;
    using mrpt_autotype = CConstMatrixColumnAccessor<MAT>;
    inline CConstMatrixColumnAccessor(const MAT& mat, size_t colIdx)
        : m_mat(&mat), m_colInd(colIdx)
    {
        ASSERT_(colIdx < mat.cols());
    }
    inline CConstMatrixColumnAccessor() {}
    inline value_type operator[](size_t i) const
    {
        return (*m_mat)(i, m_colInd);
    }
    using const_iterator = detail::AccessorIterator<
        const CConstMatrixColumnAccessor<MAT>, const value_type>;
    using const_reverse_iterator = detail::ReverseAccessorIterator<
        const CConstMatrixColumnAccessor<MAT>, const value_type>;
    inline const_iterator begin() const { return const_iterator(*this, 0); }
    inline const_iterator end() const
    {
        return const_iterator(*this, m_mat->rows());
    }
    inline const_reverse_iterator rbegin() const
    {
        return const_reverse_iterator(*this, m_mat->rows() - 1);
    }
    inline const_reverse_iterator rend() const
    {
        return const_reverse_iterator(*this, -1);
    }
    inline size_t size() const { return m_mat->rows(); }
    inline void resize(size_t N)
    {
        if (N != size())
            throw std::logic_error("Tried to resize a fixed-size vector");
    }
};
template <typename MAT>
inline CConstMatrixColumnAccessor<MAT> getColumnAccessor(
    const MAT& m, size_t colIdx)
{
    return CConstMatrixColumnAccessor<MAT>(m, colIdx);
}

/** A vector-like wrapper for a const Matrix for accessing the elements of a
 * given column with a [] operator, with offset and custom spacing.
 * \sa
 * CConstMatrixRowAccessorExtended,CMatrixColumnAccessor,CConstMatrixColumnAccessor,CMatrixColumnAccessorExtended
 */
template <typename MAT>
class CConstMatrixColumnAccessorExtended
{
   protected:
    const MAT* m_mat;
    size_t m_colInd;
    size_t m_rowOffset;
    size_t m_elementsSpace;
    size_t howMany;

   public:
    using value_type = typename MAT::Scalar;
    using mrpt_autotype = CMatrixColumnAccessorExtended<MAT>;
    inline CConstMatrixColumnAccessorExtended(
        const MAT& mat, size_t col, size_t offset, size_t space)
        : m_mat(&mat),
          m_colInd(col),
          m_rowOffset(offset),
          m_elementsSpace(space)
    {
        ASSERT_(col < mat.cols());
        howMany = (mat.rows() - m_rowOffset) / m_elementsSpace;
    }
    inline CConstMatrixColumnAccessorExtended() {}
    inline value_type operator[](size_t i) const
    {
        return (*m_mat)(m_rowOffset + (i * m_elementsSpace), m_colInd);
    }
    using const_iterator = detail::AccessorIterator<
        const CConstMatrixColumnAccessorExtended<MAT>, const value_type>;
    using const_reverse_iterator = detail::ReverseAccessorIterator<
        const CConstMatrixColumnAccessorExtended<MAT>, const value_type>;
    inline const_iterator begin() const { return const_iterator(*this, 0); }
    inline const_iterator end() const { return const_iterator(*this, howMany); }
    inline const_reverse_iterator rbegin() const
    {
        return const_reverse_iterator(*this, howMany - 1);
    }
    inline const_reverse_iterator rend() const
    {
        return const_reverse_iterator(*this, -1);
    }
    inline size_t size() const { return howMany; }
    inline void resize(size_t N)
    {
        if (N != size())
            throw std::logic_error("Tried to resize a fixed-size vector");
    }
};
template <typename MAT>
inline CConstMatrixColumnAccessorExtended<MAT> getColumnAccessor(
    const MAT& m, size_t colIdx, size_t offset, size_t space = 1)
{
    return CConstMatrixColumnAccessorExtended<MAT>(m, colIdx, offset, space);
}

}  // namespace math
}  // namespace mrpt

#endif