NdArrayIterators.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <iterator>
 
#include "NumCpp/Core/Types.hpp"
 
namespace nc
{
    //================================================================================
    // Class Description:
    template<typename dtype, typename PointerType, typename DifferenceType>
    class NdArrayConstIterator
    {
    private:
        using self_type = NdArrayConstIterator<dtype, PointerType, DifferenceType>;
 
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type        = dtype;
        using pointer           = PointerType;
        using reference         = const value_type&;
        using difference_type   = DifferenceType;
 
        //============================================================================
        // Method Description:
        NdArrayConstIterator() = default;
 
        //============================================================================
        // Method Description:
        explicit NdArrayConstIterator(pointer ptr) noexcept :
            ptr_(ptr)
        {
        }
        explicit NdArrayConstIterator(pointer ptr) noexcept : {…}
 
        //============================================================================
        // Method Description:
        reference operator*() const noexcept
        {
            return *ptr_;
        }
        reference operator*() const noexcept {…}
 
        //============================================================================
        // Method Description:
        pointer operator->() const noexcept
        {
            return ptr_;
        }
        pointer operator->() const noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type& operator++() noexcept
        {
            ++ptr_;
            return *this;
        }
        self_type& operator++() noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type operator++(int) noexcept
        {
            self_type tmp = *this;
            ++*this;
            return tmp;
        }
        self_type operator++(int) noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type& operator--() noexcept
        {
            --ptr_;
            return *this;
        }
        self_type& operator--() noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type operator--(int) noexcept
        {
            self_type tmp = *this;
            --*this;
            return tmp;
        }
        self_type operator--(int) noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type& operator+=(const difference_type offset) noexcept
        {
            ptr_ += offset;
            return *this;
        }
        self_type& operator+=(const difference_type offset) noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type operator+(const difference_type offset) const noexcept
        {
            self_type tmp = *this;
            return tmp += offset;
        }
        self_type operator+(const difference_type offset) const noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type& operator-=(const difference_type offset) noexcept
        {
            return *this += -offset;
        }
        self_type& operator-=(const difference_type offset) noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type operator-(const difference_type offset) const noexcept
        {
            self_type tmp = *this;
            return tmp -= offset;
        }
        self_type operator-(const difference_type offset) const noexcept {…}
 
        //============================================================================
        // Method Description:
        difference_type operator-(const self_type& rhs) const noexcept
        {
            return ptr_ - rhs.ptr_;
        }
        difference_type operator-(const self_type& rhs) const noexcept {…}
 
        //============================================================================
        // Method Description:
        reference operator[](const difference_type offset) const noexcept
        {
            return *(*this + offset);
        }
        reference operator[](const difference_type offset) const noexcept {…}
 
        //============================================================================
        // Method Description:
        bool operator==(const self_type& rhs) const noexcept
        {
            return ptr_ == rhs.ptr_;
        }
        bool operator==(const self_type& rhs) const noexcept {…}
 
        //============================================================================
        // Method Description:
        bool operator!=(const self_type& rhs) const noexcept
        {
            return !(*this == rhs);
        }
        bool operator!=(const self_type& rhs) const noexcept {…}
 
        //============================================================================
        // Method Description:
        bool operator<(const self_type& rhs) const noexcept
        {
            return ptr_ < rhs.ptr_;
        }
        bool operator<(const self_type& rhs) const noexcept {…}
 
        //============================================================================
        // Method Description:
        bool operator>(const self_type& rhs) const noexcept
        {
            return rhs < *this;
        }
        bool operator>(const self_type& rhs) const noexcept {…}
 
        //============================================================================
        // Method Description:
        bool operator<=(const self_type& rhs) const noexcept
        {
            return !(rhs < *this);
        }
        bool operator<=(const self_type& rhs) const noexcept {…}
 
        //============================================================================
        // Method Description:
        bool operator>=(const self_type& rhs) const noexcept
        {
            return !(*this < rhs);
        }
        bool operator>=(const self_type& rhs) const noexcept {…}
 
    private:
        pointer ptr_{ nullptr };
    };
    class NdArrayConstIterator {…};
 
    //============================================================================
    // Method Description:
    template<class dtype, typename PointerType, typename DifferenceType>
    NdArrayConstIterator<dtype, PointerType, DifferenceType>
        operator+(typename NdArrayConstIterator<dtype, PointerType, DifferenceType>::difference_type offset,
                  NdArrayConstIterator<dtype, PointerType, DifferenceType>                           next) noexcept
    {
        return next += offset;
    }
        operator+(typename NdArrayConstIterator<dtype, PointerType, DifferenceType>::difference_type offset, {…}
 
    //================================================================================
    // Class Description:
    template<typename dtype, typename PointerType, typename DifferenceType>
    class NdArrayIterator : public NdArrayConstIterator<dtype, PointerType, DifferenceType>
    {
    private:
        using MyBase    = NdArrayConstIterator<dtype, PointerType, DifferenceType>;
        using self_type = NdArrayIterator<dtype, PointerType, DifferenceType>;
 
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type        = dtype;
        using pointer           = PointerType;
        using reference         = value_type&;
        using difference_type   = DifferenceType;
 
        using MyBase::MyBase;
 
        //============================================================================
        // Method Description:
        reference operator*() const noexcept
        {
            return const_cast<reference>(MyBase::operator*());
        }
        reference operator*() const noexcept {…}
 
        //============================================================================
        // Method Description:
        pointer operator->() const noexcept
        {
            return const_cast<pointer>(MyBase::operator->());
        }
        pointer operator->() const noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type& operator++() noexcept
        {
            MyBase::operator++();
            return *this;
        }
        self_type& operator++() noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type operator++(int) noexcept
        {
            self_type tmp = *this;
            MyBase::operator++();
            return tmp;
        }
        self_type operator++(int) noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type& operator--() noexcept
        {
            MyBase::operator--();
            return *this;
        }
        self_type& operator--() noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type operator--(int) noexcept
        {
            self_type tmp = *this;
            MyBase::operator--();
            return tmp;
        }
        self_type operator--(int) noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type& operator+=(const difference_type offset) noexcept
        {
            MyBase::operator+=(offset);
            return *this;
        }
        self_type& operator+=(const difference_type offset) noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type operator+(const difference_type offset) const noexcept
        {
            self_type tmp = *this;
            return tmp += offset;
        }
        self_type operator+(const difference_type offset) const noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type& operator-=(const difference_type offset) noexcept
        {
            MyBase::operator-=(offset);
            return *this;
        }
        self_type& operator-=(const difference_type offset) noexcept {…}
 
        using MyBase::operator-;
 
        //============================================================================
        // Method Description:
        self_type operator-(const difference_type offset) const noexcept
        {
            self_type tmp = *this;
            return tmp -= offset;
        }
        self_type operator-(const difference_type offset) const noexcept {…}
 
        //============================================================================
        // Method Description:
        reference operator[](const difference_type offset) const noexcept
        {
            return const_cast<reference>(MyBase::operator[](offset));
        }
        reference operator[](const difference_type offset) const noexcept {…}
    };
    class NdArrayIterator : public NdArrayConstIterator<dtype, PointerType, DifferenceType> {…};
 
    //============================================================================
    // Method Description:
    template<class dtype, typename PointerType, typename DifferenceType>
    NdArrayIterator<dtype, PointerType, DifferenceType>
        operator+(typename NdArrayIterator<dtype, PointerType, DifferenceType>::difference_type offset,
                  NdArrayIterator<dtype, PointerType, DifferenceType>                           next) noexcept
    {
        return next += offset;
    }
        operator+(typename NdArrayIterator<dtype, PointerType, DifferenceType>::difference_type offset, {…}
 
    //================================================================================
    // Class Description:
    template<typename dtype, typename SizeType, typename PointerType, typename DifferenceType>
    class NdArrayConstColumnIterator
    {
    private:
        using self_type = NdArrayConstColumnIterator<dtype, SizeType, PointerType, DifferenceType>;
 
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type        = dtype;
        using size_type         = SizeType;
        using pointer           = PointerType;
        using reference         = const value_type&;
        using difference_type   = DifferenceType;
 
        //============================================================================
        // Method Description:
        NdArrayConstColumnIterator() = default;
 
        //============================================================================
        // Method Description:
        NdArrayConstColumnIterator(pointer ptr, SizeType numRows, SizeType numCols) noexcept :
            ptr_(ptr),
            currPtr_(ptr),
            numRows_(static_cast<difference_type>(numRows)),
            numCols_(static_cast<difference_type>(numCols)),
            size_(numRows_ * numCols_)
        {
        }
        NdArrayConstColumnIterator(pointer ptr, SizeType numRows, SizeType numCols) noexcept : {…}
 
        //============================================================================
        // Method Description:
        reference operator*() const noexcept
        {
            return *currPtr_;
        }
        reference operator*() const noexcept {…}
 
        //============================================================================
        // Method Description:
        pointer operator->() const noexcept
        {
            return currPtr_;
        }
        pointer operator->() const noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type& operator++() noexcept
        {
            return *this += 1;
        }
        self_type& operator++() noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type operator++(int) noexcept
        {
            self_type tmp = *this;
            ++*this;
            return tmp;
        }
        self_type operator++(int) noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type& operator--() noexcept
        {
            return *this -= 1;
        }
        self_type& operator--() noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type operator--(int) noexcept
        {
            self_type tmp = *this;
            --*this;
            return tmp;
        }
        self_type operator--(int) noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type& operator+=(const difference_type offset) noexcept
        {
            currPtr_ = colIdx2Ptr(ptr2ColIdx(currPtr_) + offset);
            return *this;
        }
        self_type& operator+=(const difference_type offset) noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type operator+(const difference_type offset) const noexcept
        {
            self_type tmp = *this;
            return tmp += offset;
        }
        self_type operator+(const difference_type offset) const noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type& operator-=(const difference_type offset) noexcept
        {
            return *this += -offset;
        }
        self_type& operator-=(const difference_type offset) noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type operator-(const difference_type offset) const noexcept
        {
            self_type tmp = *this;
            return tmp -= offset;
        }
        self_type operator-(const difference_type offset) const noexcept {…}
 
        //============================================================================
        // Method Description:
        difference_type operator-(const self_type& rhs) const noexcept
        {
            return ptr2ColIdx(currPtr_) - ptr2ColIdx(rhs.currPtr_);
        }
        difference_type operator-(const self_type& rhs) const noexcept {…}
 
        //============================================================================
        // Method Description:
        reference operator[](const difference_type offset) const noexcept
        {
            return *(*this + offset);
        }
        reference operator[](const difference_type offset) const noexcept {…}
 
        //============================================================================
        // Method Description:
        bool operator==(const self_type& rhs) const noexcept
        {
            return currPtr_ == rhs.currPtr_;
        }
        bool operator==(const self_type& rhs) const noexcept {…}
 
        //============================================================================
        // Method Description:
        bool operator!=(const self_type& rhs) const noexcept
        {
            return !(*this == rhs);
        }
        bool operator!=(const self_type& rhs) const noexcept {…}
 
        //============================================================================
        // Method Description:
        bool operator<(const self_type& rhs) const noexcept
        {
            return *this - rhs < 0;
        }
        bool operator<(const self_type& rhs) const noexcept {…}
 
        //============================================================================
        // Method Description:
        bool operator>(const self_type& rhs) const noexcept
        {
            return *this - rhs > 0;
        }
        bool operator>(const self_type& rhs) const noexcept {…}
 
        //============================================================================
        // Method Description:
        bool operator<=(const self_type& rhs) const noexcept
        {
            return !(rhs < *this);
        }
        bool operator<=(const self_type& rhs) const noexcept {…}
 
        //============================================================================
        // Method Description:
        bool operator>=(const self_type& rhs) const noexcept
        {
            return !(*this < rhs);
        }
        bool operator>=(const self_type& rhs) const noexcept {…}
 
    private:
        pointer         ptr_{};
        pointer         currPtr_{};
        difference_type numRows_{ 0 };
        difference_type numCols_{ 0 };
        difference_type size_{ 0 };
 
        //============================================================================
        // Method Description:
        difference_type ptr2ColIdx(pointer ptr) const noexcept
        {
            if (ptr == nullptr)
            {
                return size_;
            }
 
            const auto rowIdx = ptr - ptr_;
            if (rowIdx >= size_)
            {
                return size_;
            }
 
            const auto row = rowIdx / numCols_;
            const auto col = rowIdx % numCols_;
            return row + col * numRows_;
        }
 
        //============================================================================
        // Method Description:
        pointer colIdx2Ptr(difference_type colIdx) const noexcept
        {
            if (colIdx >= size_)
            {
                return nullptr;
            }
 
            const auto row    = colIdx % numRows_;
            const auto col    = colIdx / numRows_;
            const auto rowIdx = col + row * numCols_;
            return ptr_ + rowIdx;
        }
    };
    class NdArrayConstColumnIterator {…};
 
    //============================================================================
    // Method Description:
    template<class dtype, typename SizeType, typename PointerType, typename DifferenceType>
    NdArrayConstColumnIterator<dtype, SizeType, PointerType, DifferenceType> operator+(
        typename NdArrayConstColumnIterator<dtype, SizeType, PointerType, DifferenceType>::difference_type offset,
        NdArrayConstColumnIterator<dtype, SizeType, PointerType, DifferenceType> next) noexcept
    {
        return next += offset;
    }
    NdArrayConstColumnIterator<dtype, SizeType, PointerType, DifferenceType> operator+( {…}
 
    //================================================================================
    // Class Description:
    template<typename dtype, typename SizeType, typename PointerType, typename DifferenceType>
    class NdArrayColumnIterator : public NdArrayConstColumnIterator<dtype, SizeType, PointerType, DifferenceType>
    {
    private:
        using MyBase    = NdArrayConstColumnIterator<dtype, SizeType, PointerType, DifferenceType>;
        using self_type = NdArrayColumnIterator<dtype, SizeType, PointerType, DifferenceType>;
 
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type        = dtype;
        using size_type         = SizeType;
        using pointer           = PointerType;
        using reference         = value_type&;
        using difference_type   = DifferenceType;
 
        using MyBase::MyBase;
 
        //============================================================================
        // Method Description:
        reference operator*() const noexcept
        {
            return const_cast<reference>(MyBase::operator*());
        }
        reference operator*() const noexcept {…}
 
        //============================================================================
        // Method Description:
        pointer operator->() const noexcept
        {
            return const_cast<pointer>(MyBase::operator->());
        }
        pointer operator->() const noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type& operator++() noexcept
        {
            MyBase::operator++();
            return *this;
        }
        self_type& operator++() noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type operator++(int) noexcept
        {
            self_type tmp = *this;
            MyBase::operator++();
            return tmp;
        }
        self_type operator++(int) noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type& operator--() noexcept
        {
            MyBase::operator--();
            return *this;
        }
        self_type& operator--() noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type operator--(int) noexcept
        {
            self_type tmp = *this;
            MyBase::operator--();
            return tmp;
        }
        self_type operator--(int) noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type& operator+=(const difference_type offset) noexcept
        {
            MyBase::operator+=(offset);
            return *this;
        }
        self_type& operator+=(const difference_type offset) noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type operator+(const difference_type offset) const noexcept
        {
            self_type tmp = *this;
            return tmp += offset;
        }
        self_type operator+(const difference_type offset) const noexcept {…}
 
        //============================================================================
        // Method Description:
        self_type& operator-=(const difference_type offset) noexcept
        {
            MyBase::operator-=(offset);
            return *this;
        }
        self_type& operator-=(const difference_type offset) noexcept {…}
 
        using MyBase::operator-;
 
        //============================================================================
        // Method Description:
        self_type operator-(const difference_type offset) const noexcept
        {
            self_type tmp = *this;
            return tmp -= offset;
        }
        self_type operator-(const difference_type offset) const noexcept {…}
 
        //============================================================================
        // Method Description:
        reference operator[](const difference_type offset) const noexcept
        {
            return const_cast<reference>(MyBase::operator[](offset));
        }
        reference operator[](const difference_type offset) const noexcept {…}
    };
    class NdArrayColumnIterator : public NdArrayConstColumnIterator<dtype, SizeType, PointerType, DifferenceType> {…};
 
    //============================================================================
    // Method Description:
    template<class dtype, typename SizeType, typename PointerType, typename DifferenceType>
    NdArrayColumnIterator<dtype, SizeType, PointerType, DifferenceType>
        operator+(typename NdArrayColumnIterator<dtype, SizeType, PointerType, DifferenceType>::difference_type offset,
                  NdArrayColumnIterator<dtype, SizeType, PointerType, DifferenceType> next) noexcept
    {
        return next += offset;
    }
        operator+(typename NdArrayColumnIterator<dtype, SizeType, PointerType, DifferenceType>::difference_type offset, {…}
} // namespace nc