Iterators.h

Go to the documentation of this file.

/*
 * Expression Template Matrix Library
 *
 * Copyright (C) 2004 - 2006 Ricky Lung <mtlung@users.sourceforge.net>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */


#ifdef _MSC_VER
#   pragma once
#   pragma warning( push )
#   pragma warning( disable : 4786 )
#endif  // _MSC_VER

#ifndef _EXMAT_ITERATORS_H
#define _EXMAT_ITERATORS_H

#include <iterator>
#include "PlatformSpec.h"

namespace exmat {

template<   typename Iterator_Type, typename Value_Type,
            typename Reference_Type, typename Pointer_Type, typename Difference_Type>
class stride_iterator
{
public:
    typedef std::random_access_iterator_tag iterator_category;
    typedef Iterator_Type                   iterator_type;
    typedef Value_Type                      value_type;
    typedef Reference_Type                  reference;
    typedef Pointer_Type                    pointer;
    typedef Difference_Type                 difference_type;
    typedef stride_iterator<Iterator_Type,Value_Type,
        Reference_Type,Pointer_Type,Difference_Type> self_type;

    EXMAT_INLINE2 stride_iterator()
        : current_(0), stride_(0) {}
    EXMAT_INLINE2 stride_iterator(iterator_type current)
        : current_(current), stride_(1) {}  
    EXMAT_INLINE2 stride_iterator(iterator_type current, difference_type stride)
        : current_(current), stride_(stride) {}
    EXMAT_INLINE2 stride_iterator(const self_type& rhs)
        : current_(rhs.current()),stride_(rhs.stride()) {}
    EXMAT_INLINE2 stride_iterator& operator=(const self_type& rhs) {
        current_ = rhs.current();
        stride_ = rhs.stride();
        return *this;
    }

    EXMAT_INLINE2 reference operator*() const {
        return *current_;
    }
    EXMAT_INLINE2 pointer operator->() const {
        return  current_;
    }
    EXMAT_INLINE2 reference operator[](difference_type n) const {
        return current_[n * stride_];
    }

    EXMAT_INLINE2 stride_iterator& operator++() {
        current_ += stride_;
        return *this;
    }
    EXMAT_INLINE2 const stride_iterator operator++(int) {
        stride_iterator tmp = *this;
        ++*this; return tmp;
    }
    EXMAT_INLINE2 stride_iterator& operator--() {
        current_ -= stride_;
        return *this;
    }
    EXMAT_INLINE2 const stride_iterator operator--(int) {
        stride_iterator tmp = *this;
        --*this; return tmp;
    }
    EXMAT_INLINE2 stride_iterator operator+(difference_type n) {
        return stride_iterator(current_ + n * stride_, stride_);
    }
    EXMAT_INLINE2 const stride_iterator operator+(difference_type n) const {
        return stride_iterator(current_ + n * stride_, stride_);
    }
    EXMAT_INLINE2 stride_iterator& operator+=(difference_type n) {
        current_ += n * stride_;
        return *this;
    }
    EXMAT_INLINE2 stride_iterator operator-(difference_type n) {
        return stride_iterator(current_ - n * stride_, stride_);
    }
    EXMAT_INLINE2 const stride_iterator operator-(difference_type n) const {
        return stride_iterator(current_ - n * stride_, stride_);
    }
    EXMAT_INLINE2 stride_iterator& operator-=(difference_type n) {
        current_ -= n * stride_;
        return *this;
    }

    EXMAT_INLINE2 difference_type operator-(const stride_iterator& itr) const {
        return (current_ - itr.current_)/stride_;
    }

    EXMAT_INLINE2 iterator_type current() const {
        return current_;
    }

    EXMAT_INLINE2 difference_type stride() const {
        return stride_;
    }

private:
    iterator_type           current_;
    const difference_type   stride_;
};

template<class Iter, class Val, class Ref, class Ptr, class Diff> EXMAT_INLINE2
const stride_iterator<Iter,Val,Ref,Ptr,Diff> operator+(
    Diff n, const stride_iterator<Iter,Val,Ref,Ptr,Diff> itr) 
{
    return itr + n;
}

template<class Iter, class Val, class Ref, class Ptr, class Diff> EXMAT_INLINE2
bool operator<( const stride_iterator<Iter,Val,Ref,Ptr,Diff>& itr1, 
                const stride_iterator<Iter,Val,Ref,Ptr,Diff>& itr2)
{
    return itr1.operator->() < itr2.operator->();
}
template<class Iter, class Val, class Ref, class Ptr, class Diff> EXMAT_INLINE2
bool operator<=(const stride_iterator<Iter,Val,Ref,Ptr,Diff>& itr1, 
                const stride_iterator<Iter,Val,Ref,Ptr,Diff>& itr2)
{
    return itr1.operator->() <= itr2.operator->();
}
template<class Iter, class Val, class Ref, class Ptr, class Diff> EXMAT_INLINE2
bool operator>( const stride_iterator<Iter,Val,Ref,Ptr,Diff>& itr1, 
                const stride_iterator<Iter,Val,Ref,Ptr,Diff>& itr2)
{
    return itr1.operator->() > itr2.operator->();
}
template<class Iter, class Val, class Ref, class Ptr, class Diff> EXMAT_INLINE2
bool operator>=(const stride_iterator<Iter,Val,Ref,Ptr,Diff>& itr1, 
                const stride_iterator<Iter,Val,Ref,Ptr,Diff>& itr2)
{
    return itr1.operator->() >= itr2.operator->();
}
template<class Iter, class Val, class Ref, class Ptr, class Diff> EXMAT_INLINE2
bool operator==(const stride_iterator<Iter,Val,Ref,Ptr,Diff>& itr1, 
                const stride_iterator<Iter,Val,Ref,Ptr,Diff>& itr2)
{
    return itr1.operator->() == itr2.operator->();
}
template<class Iter, class Val, class Ref, class Ptr, class Diff> EXMAT_INLINE2
bool operator!=(const stride_iterator<Iter,Val,Ref,Ptr,Diff>& itr1, 
                const stride_iterator<Iter,Val,Ref,Ptr,Diff>& itr2)
{
    return itr1.operator->() != itr2.operator->();
}

template<class MAT>
class mat_iterator
{
public:
    typedef std::random_access_iterator_tag iterator_category;
    typedef typename MAT::value_type        value_type;
    typedef typename MAT::reference         reference;
    typedef value_type*                     pointer;
    typedef ptrdiff_t                       difference_type;
    typedef mat_iterator<MAT>               self_type;

    EXMAT_INLINE2 mat_iterator(MAT& m, size_t r, size_t c)
        : mat_(m), r_(r), c_(c) {}

    EXMAT_INLINE2 reference operator*() const {
        return mat_.setAt(r_, c_);
    }
    EXMAT_INLINE2 pointer operator->() const {
        return &(mat_.setAt(r_, c_));
    }

    EXMAT_INLINE2 mat_iterator& operator++() {
        c_ = ++c_ >= mat_.cols() ? 0 : c_;
        r_ = c_ == 0 ? r_+1 : r_;
        return *this;
    }
    EXMAT_INLINE2 const mat_iterator operator++(int) {
        mat_iterator tmp = *this;
        ++*this; return tmp;
    }
    EXMAT_INLINE2 mat_iterator& operator--() {
        size_t c = mat_.cols()-1;
        c_ = c_ == 0 ? c : c_-1;
        r_ = c_ == c ? r_-1 : r_;
        return *this;
    }
    EXMAT_INLINE2 const mat_iterator operator--(int) {
        mat_iterator tmp = *this;
        --*this; return tmp;
    }
    EXMAT_INLINE2 mat_iterator operator+(difference_type n) {
        size_t abspos = r_ * mat_.cols() + c_ + n;
        return mat_iterator(mat_, abspos/mat_.rows(), abspos%mat_.cols());
    }
    EXMAT_INLINE2 const mat_iterator operator+(difference_type n) const {
        size_t abspos = r_ * mat_.cols() + c_ + n;
        return mat_iterator(mat_, abspos/mat_.rows(), abspos%mat_.cols());
    }
    EXMAT_INLINE2 mat_iterator& operator+=(difference_type n) {
        size_t abspos = r_ * mat_.cols() + c_ + n;
        r_ = abspos/mat_.rows();
        c_ = abspos%mat_.cols();
        return *this;
    }
    EXMAT_INLINE2 mat_iterator operator-(difference_type n) {
        size_t abspos = r_ * mat_.cols() + c_ - n;
        return mat_iterator(mat_, abspos/mat_.rows(), abspos%mat_.cols());
    }
    EXMAT_INLINE2 const mat_iterator operator-(difference_type n) const {
        size_t abspos = r_ * mat_.cols() + c_ - n;
        return mat_iterator(mat_, abspos/mat_.rows(), abspos%mat_.cols());
    }
    EXMAT_INLINE2 mat_iterator& operator-=(difference_type n) {
        size_t abspos = r_ * mat_.cols() + c_ - n;
        r_ = abspos/mat_.rows();
        c_ = abspos%mat_.cols();
        return *this;
    }

    EXMAT_INLINE2 difference_type operator-(const mat_iterator& itr) const {
        size_t abspos = r_ * mat_.cols() + c_;
        size_t abspos2 = itr.r_ * mat_.cols() + itr.c_;
        return abspos - abspos2;
    }

    EXMAT_INLINE2 size_t row() const
    {   return r_;  }
    EXMAT_INLINE2 size_t col() const
    {   return c_;  }

    EXMAT_INLINE2 size_t rows() const
    {   return mat_.rows(); }
    EXMAT_INLINE2 size_t cols() const
    {   return mat_.cols(); }

private:
    mutable MAT&    mat_;
    size_t          r_;
    size_t          c_;
};

template<class MAT, typename Diff>
EXMAT_INLINE2 const mat_iterator<MAT>
operator+(Diff n, const mat_iterator<MAT>& itr) {
    return itr + n;
}

template<class MAT> EXMAT_INLINE2
bool operator==(const mat_iterator<MAT>& itr1, 
                const mat_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        == itr2.row() * itr2.cols() + itr2.col());
}
template<class MAT> EXMAT_INLINE2
bool operator!=(const mat_iterator<MAT>& itr1, 
                const mat_iterator<MAT>& itr2)
{
    return !(itr1 == itr2);
}
template<class MAT> EXMAT_INLINE2
bool operator<( const mat_iterator<MAT>& itr1, 
                const mat_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        < itr2.row() * itr2.cols() + itr2.col());
}
template<class MAT> EXMAT_INLINE2
bool operator<=(const mat_iterator<MAT>& itr1, 
                const mat_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        <= itr2.row() * itr2.cols() + itr2.col());
}
template<class MAT> EXMAT_INLINE2
bool operator>( const mat_iterator<MAT>& itr1, 
                const mat_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        > itr2.row() * itr2.cols() + itr2.col());
}
template<class MAT> EXMAT_INLINE2
bool operator>=(const mat_iterator<MAT>& itr1, 
                const mat_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        >= itr2.row() * itr2.cols() + itr2.col());
}

template<class MAT>
class const_mat_iterator
{
public:
    typedef std::random_access_iterator_tag iterator_category;
    typedef typename MAT::value_type        value_type;
    typedef typename MAT::const_reference   reference;
    typedef const value_type*               pointer;
    typedef ptrdiff_t                       difference_type;
    typedef const_mat_iterator<MAT>         self_type;

    EXMAT_INLINE2 const_mat_iterator(MAT& m, size_t r, size_t c)
        : mat_(m), r_(r), c_(c) {}

    EXMAT_INLINE2 reference operator*() const {
        return mat_.data[r_][c_];
    }
    EXMAT_INLINE2 pointer operator->() const {
        return &(mat_.data[r_][c_]);
    }

    EXMAT_INLINE2 const_mat_iterator& operator++() {
        c_ = ++c_ >= mat_.cols() ? 0 : c_;
        r_ = c_ == 0 ? r_+1 : r_;
        return *this;
    }
    EXMAT_INLINE2 const const_mat_iterator operator++(int) {
        const_mat_iterator tmp = *this;
        ++*this; return tmp;
    }
    EXMAT_INLINE2 const_mat_iterator& operator--() {
        size_t c = mat_.cols()-1;
        c_ = c_ == 0 ? c : c_-1;
        r_ = c_ == c ? r_-1 : r_;
        return *this;
    }
    EXMAT_INLINE2 const const_mat_iterator operator--(int) {
        const_mat_iterator tmp = *this;
        --*this; return tmp;
    }
    EXMAT_INLINE2 const_mat_iterator operator+(difference_type n) {
        size_t abspos = r_ * mat_.cols() + c_ + n;
        return const_mat_iterator(mat_, abspos/mat_.rows(), abspos%mat_.cols());
    }
    EXMAT_INLINE2 const const_mat_iterator operator+(difference_type n) const {
        size_t abspos = r_ * mat_.cols() + c_ + n;
        return const_mat_iterator(mat_, abspos/mat_.rows(), abspos%mat_.cols());
    }
    EXMAT_INLINE2 const_mat_iterator& operator+=(difference_type n) {
        size_t abspos = r_ * mat_.cols() + c_ + n;
        r_ = abspos/mat_.rows();
        c_ = abspos%mat_.cols();
        return *this;
    }
    EXMAT_INLINE2 const_mat_iterator operator-(difference_type n) {
        size_t abspos = r_ * mat_.cols() + c_ - n;
        return const_mat_iterator(mat_, abspos/mat_.rows(), abspos%mat_.cols());
    }
    EXMAT_INLINE2 const const_mat_iterator operator-(difference_type n) const {
        size_t abspos = r_ * mat_.cols() + c_ - n;
        return const_mat_iterator(mat_, abspos/mat_.rows(), abspos%mat_.cols());
    }
    EXMAT_INLINE2 const_mat_iterator& operator-=(difference_type n) {
        size_t abspos = r_ * mat_.cols() + c_ - n;
        r_ = abspos/mat_.rows();
        c_ = abspos%mat_.cols();
        return *this;
    }

    EXMAT_INLINE2 difference_type operator-(const const_mat_iterator& itr) const {
        size_t abspos = r_ * mat_.cols() + c_;
        size_t abspos2 = itr.r_ * mat_.cols() + itr.c_;
        return abspos - abspos2;
    }

    EXMAT_INLINE2 size_t row() const
    {   return r_;  }
    EXMAT_INLINE2 size_t col() const
    {   return c_;  }

    EXMAT_INLINE2 size_t rows() const
    {   return mat_.rows(); }
    EXMAT_INLINE2 size_t cols() const
    {   return mat_.cols(); }

private:
    mutable MAT&    mat_;
    size_t          r_;
    size_t          c_;
};

template<class MAT, typename Diff>
EXMAT_INLINE2 const const_mat_iterator<MAT>
operator+(Diff n, const const_mat_iterator<MAT>& itr) {
    return itr + n;
}

template<class MAT> EXMAT_INLINE2
bool operator==(const const_mat_iterator<MAT>& itr1, 
                const const_mat_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        == itr2.row() * itr2.cols() + itr2.col());
}
template<class MAT> EXMAT_INLINE2
bool operator!=(const const_mat_iterator<MAT>& itr1, 
                const const_mat_iterator<MAT>& itr2)
{
    return !(itr1 == itr2);
}
template<class MAT> EXMAT_INLINE2
bool operator<( const const_mat_iterator<MAT>& itr1, 
                const const_mat_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        < itr2.row() * itr2.cols() + itr2.col());
}
template<class MAT> EXMAT_INLINE2
bool operator<=(const const_mat_iterator<MAT>& itr1, 
                const const_mat_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        <= itr2.row() * itr2.cols() + itr2.col());
}
template<class MAT> EXMAT_INLINE2
bool operator>( const const_mat_iterator<MAT>& itr1, 
                const const_mat_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        > itr2.row() * itr2.cols() + itr2.col());
}
template<class MAT> EXMAT_INLINE2
bool operator>=(const const_mat_iterator<MAT>& itr1, 
                const const_mat_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        >= itr2.row() * itr2.cols() + itr2.col());
}

//  Used exclusively in DynamicSizeCon
template<class MAT>
class mat_ctg_iterator
{
public:
    typedef std::random_access_iterator_tag iterator_category;
    typedef typename MAT::value_type        value_type;
    typedef typename MAT::reference         reference;
    typedef value_type*                     pointer;
    typedef ptrdiff_t                       difference_type;
    typedef mat_ctg_iterator<MAT>           self_type;

    EXMAT_INLINE2 mat_ctg_iterator(MAT& m, size_t r, size_t c)
        : mat_(m), r_(r), c_(c) {}

    EXMAT_INLINE2 reference operator*() const {
        return mat_.data[r_*mat_.CCOLS+c_];
    }
    EXMAT_INLINE2 pointer operator->() const {
        return &(mat_.data[r_*mat_.CCOLS+c_]);
    }

    EXMAT_INLINE2 mat_ctg_iterator& operator++() {
        c_ = ++c_ >= mat_.cols() ? 0 : c_;
        r_ = c_ == 0 ? r_+1 : r_;
        return *this;
    }
    EXMAT_INLINE2 const mat_ctg_iterator operator++(int) {
        mat_ctg_iterator tmp = *this;
        ++*this; return tmp;
    }
    EXMAT_INLINE2 mat_ctg_iterator& operator--() {
        size_t c = mat_.cols()-1;
        c_ = c_ == 0 ? c : c_-1;
        r_ = c_ == c ? r_-1 : r_;
        return *this;
    }
    EXMAT_INLINE2 const mat_ctg_iterator operator--(int) {
        mat_ctg_iterator tmp = *this;
        --*this; return tmp;
    }
    EXMAT_INLINE2 mat_ctg_iterator operator+(difference_type n) {
        size_t abspos = r_ * mat_.cols() + c_ + n;
        return mat_ctg_iterator(mat_, abspos/mat_.rows(), abspos%mat_.cols());
    }
    EXMAT_INLINE2 const mat_ctg_iterator operator+(difference_type n) const {
        size_t abspos = r_ * mat_.cols() + c_ + n;
        return mat_ctg_iterator(mat_, abspos/mat_.rows(), abspos%mat_.cols());
    }
    EXMAT_INLINE2 mat_ctg_iterator& operator+=(difference_type n) {
        size_t abspos = r_ * mat_.cols() + c_ + n;
        r_ = abspos/mat_.rows();
        c_ = abspos%mat_.cols();
        return *this;
    }
    EXMAT_INLINE2 mat_ctg_iterator operator-(difference_type n) {
        size_t abspos = r_ * mat_.cols() + c_ - n;
        return mat_ctg_iterator(mat_, abspos/mat_.rows(), abspos%mat_.cols());
    }
    EXMAT_INLINE2 const mat_ctg_iterator operator-(difference_type n) const {
        size_t abspos = r_ * mat_.cols() + c_ - n;
        return mat_ctg_iterator(mat_, abspos/mat_.rows(), abspos%mat_.cols());
    }
    EXMAT_INLINE2 mat_ctg_iterator& operator-=(difference_type n) {
        size_t abspos = r_ * mat_.cols() + c_ - n;
        r_ = abspos/mat_.rows();
        c_ = abspos%mat_.cols();
        return *this;
    }

    EXMAT_INLINE2 difference_type operator-(const mat_ctg_iterator& itr) const {
        size_t abspos = r_ * mat_.cols() + c_;
        size_t abspos2 = itr.r_ * mat_.cols() + itr.c_;
        return abspos - abspos2;
    }

    EXMAT_INLINE2 size_t row() const
    {   return r_;  }
    EXMAT_INLINE2 size_t col() const
    {   return c_;  }

    EXMAT_INLINE2 size_t rows() const
    {   return mat_.rows(); }
    EXMAT_INLINE2 size_t cols() const
    {   return mat_.cols(); }

private:
    mutable MAT&    mat_;
    size_t          r_;
    size_t          c_;
};

template<class MAT, typename Diff>
EXMAT_INLINE2 const mat_ctg_iterator<MAT>
operator+(Diff n, const mat_ctg_iterator<MAT>& itr) {
    return itr + n;
}

template<class MAT> EXMAT_INLINE2
bool operator==(const mat_ctg_iterator<MAT>& itr1, 
                const mat_ctg_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        == itr2.row() * itr2.cols() + itr2.col());
}
template<class MAT> EXMAT_INLINE2
bool operator!=(const mat_ctg_iterator<MAT>& itr1, 
                const mat_ctg_iterator<MAT>& itr2)
{
    return !(itr1 == itr2);
}
template<class MAT> EXMAT_INLINE2
bool operator<( const mat_ctg_iterator<MAT>& itr1, 
                const mat_ctg_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        < itr2.row() * itr2.cols() + itr2.col());
}
template<class MAT> EXMAT_INLINE2
bool operator<=(const mat_ctg_iterator<MAT>& itr1, 
                const mat_ctg_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        <= itr2.row() * itr2.cols() + itr2.col());
}
template<class MAT> EXMAT_INLINE2
bool operator>( const mat_ctg_iterator<MAT>& itr1, 
                const mat_ctg_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        > itr2.row() * itr2.cols() + itr2.col());
}
template<class MAT> EXMAT_INLINE2
bool operator>=(const mat_ctg_iterator<MAT>& itr1, 
                const mat_ctg_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        >= itr2.row() * itr2.cols() + itr2.col());
}

//  Used exclusively in DynamicSizeCon
template<class MAT>
class const_mat_ctg_iterator
{
public:
    typedef std::random_access_iterator_tag iterator_category;
    typedef typename MAT::value_type        value_type;
    typedef typename MAT::const_reference   reference;
    typedef const value_type*               pointer;
    typedef ptrdiff_t                       difference_type;
    typedef const_mat_ctg_iterator<MAT>     self_type;

    EXMAT_INLINE2 const_mat_ctg_iterator(MAT& m, size_t r, size_t c)
        : mat_(m), r_(r), c_(c) {}

    EXMAT_INLINE2 reference operator*() const {
        return mat_.data[r_*mat_.CCOLS+c_];
    }
    EXMAT_INLINE2 pointer operator->() const {
        return &(mat_.data[r_*mat_.CCOLS+c_]);
    }

    EXMAT_INLINE2 const_mat_ctg_iterator& operator++() {
        c_ = ++c_ >= mat_.cols() ? 0 : c_;
        r_ = c_ == 0 ? r_+1 : r_;
        return *this;
    }
    EXMAT_INLINE2 const const_mat_ctg_iterator operator++(int) {
        const_mat_ctg_iterator tmp = *this;
        ++*this; return tmp;
    }
    EXMAT_INLINE2 const_mat_ctg_iterator& operator--() {
        size_t c = mat_.cols()-1;
        c_ = c_ == 0 ? c : c_-1;
        r_ = c_ == c ? r_-1 : r_;
        return *this;
    }
    EXMAT_INLINE2 const const_mat_ctg_iterator operator--(int) {
        const_mat_ctg_iterator tmp = *this;
        --*this; return tmp;
    }
    EXMAT_INLINE2 const_mat_ctg_iterator operator+(difference_type n) {
        size_t abspos = r_ * mat_.cols() + c_ + n;
        return const_mat_ctg_iterator(mat_, abspos/mat_.rows(), abspos%mat_.cols());
    }
    EXMAT_INLINE2 const const_mat_ctg_iterator operator+(difference_type n) const {
        size_t abspos = r_ * mat_.cols() + c_ + n;
        return const_mat_ctg_iterator(mat_, abspos/mat_.rows(), abspos%mat_.cols());
    }
    EXMAT_INLINE2 const_mat_ctg_iterator& operator+=(difference_type n) {
        size_t abspos = r_ * mat_.cols() + c_ + n;
        r_ = abspos/mat_.rows();
        c_ = abspos%mat_.cols();
        return *this;
    }
    EXMAT_INLINE2 const_mat_ctg_iterator operator-(difference_type n) {
        size_t abspos = r_ * mat_.cols() + c_ - n;
        return const_mat_ctg_iterator(mat_, abspos/mat_.rows(), abspos%mat_.cols());
    }
    EXMAT_INLINE2 const const_mat_ctg_iterator operator-(difference_type n) const {
        size_t abspos = r_ * mat_.cols() + c_ - n;
        return const_mat_ctg_iterator(mat_, abspos/mat_.rows(), abspos%mat_.cols());
    }
    EXMAT_INLINE2 const_mat_ctg_iterator& operator-=(difference_type n) {
        size_t abspos = r_ * mat_.cols() + c_ - n;
        r_ = abspos/mat_.rows();
        c_ = abspos%mat_.cols();
        return *this;
    }

    EXMAT_INLINE2 difference_type operator-(const const_mat_ctg_iterator& itr) const {
        size_t abspos = r_ * mat_.cols() + c_;
        size_t abspos2 = itr.r_ * mat_.cols() + itr.c_;
        return abspos - abspos2;
    }

    EXMAT_INLINE2 size_t row() const
    {   return r_;  }
    EXMAT_INLINE2 size_t col() const
    {   return c_;  }

    EXMAT_INLINE2 size_t rows() const
    {   return mat_.rows(); }
    EXMAT_INLINE2 size_t cols() const
    {   return mat_.cols(); }

private:
    mutable MAT&    mat_;
    size_t          r_;
    size_t          c_;
};

template<class MAT, typename Diff>
EXMAT_INLINE2 const const_mat_ctg_iterator<MAT>
operator+(Diff n, const const_mat_ctg_iterator<MAT>& itr) {
    return itr + n;
}

template<class MAT> EXMAT_INLINE2
bool operator==(const const_mat_ctg_iterator<MAT>& itr1, 
                const const_mat_ctg_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        == itr2.row() * itr2.cols() + itr2.col());
}
template<class MAT> EXMAT_INLINE2
bool operator!=(const const_mat_ctg_iterator<MAT>& itr1, 
                const const_mat_ctg_iterator<MAT>& itr2)
{
    return !(itr1 == itr2);
}
template<class MAT> EXMAT_INLINE2
bool operator<( const const_mat_ctg_iterator<MAT>& itr1, 
                const const_mat_ctg_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        < itr2.row() * itr2.cols() + itr2.col());
}
template<class MAT> EXMAT_INLINE2
bool operator<=(const const_mat_ctg_iterator<MAT>& itr1, 
                const const_mat_ctg_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        <= itr2.row() * itr2.cols() + itr2.col());
}
template<class MAT> EXMAT_INLINE2
bool operator>( const const_mat_ctg_iterator<MAT>& itr1, 
                const const_mat_ctg_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        > itr2.row() * itr2.cols() + itr2.col());
}
template<class MAT> EXMAT_INLINE2
bool operator>=(const const_mat_ctg_iterator<MAT>& itr1, 
                const const_mat_ctg_iterator<MAT>& itr2)
{
    return (itr1.row() * itr1.cols() + itr1.col()
        >= itr2.row() * itr2.cols() + itr2.col());
}

}   // namespace exmat

#ifdef _MSC_VER
#   pragma warning( pop )
#endif  // _MSC_VER

#endif  // _EXMAT_ITERATORS_H

---