matrix_adaptors.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 mrpt_matrix_adaptors_H
#define mrpt_matrix_adaptors_H
 
#include <mrpt/utils/utils_defs.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:
        typedef CMatrixTemplateObjects<U> MatrixType;
};
template <typename U>
class MatrixWrapper<U, false>
{
   public:
        typedef CMatrixTemplate<U> MatrixType;
};
 
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
{
/** 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:
        typedef std::random_access_iterator_tag iterator_category;
        typedef T value_type;
        typedef int difference_type;
        typedef T* pointer;
        typedef T& reference;
 
        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:
        typedef std::random_access_iterator_tag iterator_category;
        typedef T value_type;
        typedef int difference_type;
        typedef T* pointer;
        typedef T& reference;
 
        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));
        }
};
}  // End of detail namespace
 
/** 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:
        typedef typename MAT::Scalar value_type;
        typedef CMatrixRowAccessor<MAT> mrpt_autotype;
        inline CMatrixRowAccessor(MAT& mat, size_t rowIdx)
                : m_mat(&mat), m_rowInd(rowIdx)
        {
                ASSERT_(rowIdx < mat.getRowCount())
        }
        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);
        }
        typedef detail::AccessorIterator<CMatrixRowAccessor<MAT>, value_type>
                iterator;
        typedef detail::AccessorIterator<const CMatrixRowAccessor<MAT>,
                                                                         const value_type>
                const_iterator;
        typedef detail::ReverseAccessorIterator<CMatrixRowAccessor<MAT>, value_type>
                reverse_iterator;
        typedef detail::ReverseAccessorIterator<const CMatrixRowAccessor<MAT>,
                                                                                        const value_type>
                const_reverse_iterator;
        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->getColCount()); }
        inline const_iterator end() const
        {
                return const_iterator(*this, m_mat->getColCount());
        }
        inline reverse_iterator rbegin()
        {
                return reverse_iterator(*this, m_mat->getColCount() - 1);
        }
        inline const_reverse_iterator rbegin() const
        {
                return const_reverse_iterator(*this, m_mat->getColCount() - 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->getColCount(); }
        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:
        typedef typename MAT::Scalar value_type;
        typedef CMatrixRowAccessorExtended<MAT> mrpt_autotype;
        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.getRowCount());
                howMany = (mat.getColCount() - 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));
        }
        typedef detail::AccessorIterator<CMatrixRowAccessorExtended<MAT>,
                                                                         value_type>
                iterator;
        typedef detail::AccessorIterator<const CMatrixRowAccessorExtended<MAT>,
                                                                         const value_type>
                const_iterator;
        typedef detail::ReverseAccessorIterator<CMatrixRowAccessorExtended<MAT>,
                                                                                        value_type>
                reverse_iterator;
        typedef detail::ReverseAccessorIterator<
                const CMatrixRowAccessorExtended<MAT>, const value_type>
                const_reverse_iterator;
        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:
        typedef typename MAT::Scalar value_type;
        typedef CConstMatrixRowAccessor<MAT> mrpt_autotype;
        inline CConstMatrixRowAccessor(const MAT& mat, size_t row)
                : m_mat(&mat), m_rowInd(row)
        {
                ASSERT_(row < mat.getRowCount());
        }
        inline CConstMatrixRowAccessor() {}
        inline value_type operator[](size_t i) const
        {
                return (*m_mat)(m_rowInd, i);
        }
        typedef detail::AccessorIterator<const CConstMatrixRowAccessor<MAT>,
                                                                         const value_type>
                const_iterator;
        typedef detail::ReverseAccessorIterator<const CConstMatrixRowAccessor<MAT>,
                                                                                        const value_type>
                const_reverse_iterator;
        inline const_iterator begin() const { return const_iterator(*this, 0); }
        inline const_iterator end() const
        {
                return const_iterator(*this, m_mat->getColCount());
        }
        inline const_reverse_iterator rbegin() const
        {
                return const_reverse_iterator(*this, m_mat->getColCount() - 1);
        }
        inline const_reverse_iterator rend() const
        {
                return const_reverse_iterator(*this, -1);
        }
        inline size_t size() const { return m_mat->getColCount(); }
        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:
        typedef typename MAT::Scalar value_type;
        typedef CConstMatrixRowAccessorExtended<MAT> mrpt_autotype;
        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.getRowCount());
                howMany = (mat.getColCount() - m_colOffset) / m_elementsSpace;
        }
        inline CConstMatrixRowAccessorExtended() {}
        inline value_type operator[](size_t i) const
        {
                return (*m_mat)(m_rowInd, m_colOffset + (i * m_elementsSpace));
        }
        typedef detail::AccessorIterator<const CConstMatrixRowAccessorExtended<MAT>,
                                                                         const value_type>
                const_iterator;
        typedef detail::ReverseAccessorIterator<
                const CConstMatrixRowAccessorExtended<MAT>, const value_type>
                const_reverse_iterator;
        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:
        typedef typename MAT::Scalar value_type;
        typedef CMatrixColumnAccessor<MAT> mrpt_autotype;
        inline CMatrixColumnAccessor(MAT& mat, size_t colIdx)
                : m_mat(&mat), m_colInd(colIdx)
        {
                ASSERT_(colIdx < mat.getColCount())
        }
        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);
        }
        typedef detail::AccessorIterator<CMatrixColumnAccessor<MAT>, value_type>
                iterator;
        typedef detail::AccessorIterator<const CMatrixColumnAccessor<MAT>,
                                                                         const value_type>
                const_iterator;
        typedef detail::ReverseAccessorIterator<CMatrixColumnAccessor<MAT>,
                                                                                        value_type>
                reverse_iterator;
        typedef detail::ReverseAccessorIterator<const CMatrixColumnAccessor<MAT>,
                                                                                        const value_type>
                const_reverse_iterator;
        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->getRowCount()); }
        inline const_iterator end() const
        {
                return const_iterator(*this, m_mat->getRowCount());
        }
        inline reverse_iterator rbegin()
        {
                return reverse_iterator(*this, m_mat->getRowCount() - 1);
        }
        inline const_reverse_iterator rbegin() const
        {
                return const_reverse_iterator(*this, m_mat->getRowCount() - 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->getRowCount(); }
        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:
        typedef typename MAT::Scalar value_type;
        typedef CMatrixColumnAccessorExtended<MAT> mrpt_autotype;
        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.getColCount());
                howMany = (mat.getRowCount() - 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);
        }
        typedef detail::AccessorIterator<CMatrixColumnAccessorExtended<MAT>,
                                                                         value_type>
                iterator;
        typedef detail::AccessorIterator<const CMatrixColumnAccessorExtended<MAT>,
                                                                         const value_type>
                const_iterator;
        typedef detail::ReverseAccessorIterator<CMatrixColumnAccessorExtended<MAT>,
                                                                                        value_type>
                reverse_iterator;
        typedef detail::ReverseAccessorIterator<
                const CMatrixColumnAccessorExtended<MAT>, const value_type>
                const_reverse_iterator;
        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:
        typedef typename MAT::Scalar value_type;
        typedef CConstMatrixColumnAccessor<MAT> mrpt_autotype;
        inline CConstMatrixColumnAccessor(const MAT& mat, size_t colIdx)
                : m_mat(&mat), m_colInd(colIdx)
        {
                ASSERT_(colIdx < mat.getColCount());
        }
        inline CConstMatrixColumnAccessor() {}
        inline value_type operator[](size_t i) const
        {
                return (*m_mat)(i, m_colInd);
        }
        typedef detail::AccessorIterator<const CConstMatrixColumnAccessor<MAT>,
                                                                         const value_type>
                const_iterator;
        typedef detail::ReverseAccessorIterator<
                const CConstMatrixColumnAccessor<MAT>, const value_type>
                const_reverse_iterator;
        inline const_iterator begin() const { return const_iterator(*this, 0); }
        inline const_iterator end() const
        {
                return const_iterator(*this, m_mat->getRowCount());
        }
        inline const_reverse_iterator rbegin() const
        {
                return const_reverse_iterator(*this, m_mat->getRowCount() - 1);
        }
        inline const_reverse_iterator rend() const
        {
                return const_reverse_iterator(*this, -1);
        }
        inline size_t size() const { return m_mat->getRowCount(); }
        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:
        typedef typename MAT::Scalar value_type;
        typedef CMatrixColumnAccessorExtended<MAT> mrpt_autotype;
        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.getColCount());
                howMany = (mat.getRowCount() - m_rowOffset) / m_elementsSpace;
        }
        inline CConstMatrixColumnAccessorExtended() {}
        inline value_type operator[](size_t i) const
        {
                return (*m_mat)(m_rowOffset + (i * m_elementsSpace), m_colInd);
        }
        typedef detail::AccessorIterator<
                const CConstMatrixColumnAccessorExtended<MAT>, const value_type>
                const_iterator;
        typedef detail::ReverseAccessorIterator<
                const CConstMatrixColumnAccessorExtended<MAT>, const value_type>
                const_reverse_iterator;
        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);
}
 
}  // End of namespace
}  // End of namespace
 
#endif