Iteration over tensor

[marty1885]

To match numpy's behavior, we should make the Tensor object iteratable. And iterates over the first dim by default.

Ex:

a = ones({4, 4});
for(auto s : a)
    a += 1; 

etc...

[marty1885]

This turns out to be quite of a problem. Since views are generated on the fly; the C++ iterator architecture is fitting badly.

//Iterator
struct ETALER_EXPORT iterator
{
    iterator(Tensor& t) : t_(&t) {}
    Tensor operator*() { return t_->view({curr_}); } // Can't return ref here
    Tensor* operator->() {/*real? How am I going to return a pointer from a local variable*/}

    bool operator==(iterator rhs) { return curr_ == rhs.curr_ && t_ == rhs.t_; }
    bool operator!=(iterator rhs) { !(*this == rhs); }
    iterator& operator++() {curr_ += 1; return *this;}
        iterator operator++(int) {iterator retval = *this; ++(*this); return retval;}
    Tensor* t_; // Using a pointer because Tensor is a incomplete type within the type itself
    intmax_t curr_ = 0;
};

[marty1885]

This is the best I can do

template <typename T>
struct ETALER_EXPORT TensorIterator
{
    // Iterator properties
    using iterator_category = std::bidirectional_iterator_tag;
    using value_type = T;
    using raw_value_type = std::remove_const_t<value_type>; // extra
    using difference_type = intmax_t;
    using pointer = std::unique_ptr<raw_value_type>;
    using reference = T&;

    using ThisIterator = TensorIterator<T>;
    TensorIterator() = default;
    TensorIterator(reference t, intmax_t offset = 0) : t_(&t), offset_(offset)
    {static_assert(std::is_same_v<raw_value_type, Tensor>); }
    value_type operator*() { return t_->view({offset_}); }
    // Unfortunatelly returning a pointer is not doable
    pointer operator->() { return std::make_unique<raw_value_type>(*(*this)); }
    bool operator==(ThisIterator rhs) const { return offset_ == rhs.offset_ && t_ == rhs.t_; }
    bool operator!=(ThisIterator rhs) const { return !(*this == rhs); }
    ThisIterator& operator++() {offset_ += 1; return *this;}
    ThisIterator operator++(int) {ThisIterator retval = *this; ++(*this); return retval;}
    ThisIterator& operator--() {offset_ -= 1; return *this;}
    ThisIterator operator--(int) {ThisIterator retval = *this; --(*this); return retval;}
    value_type* t_ = nullptr; // Using a pointer because Tensor is a incomplete type here
    intmax_t offset_ = 0;
};

It works 90% of the time and have few caveats

• operator* should return a reference
• operator-> should return a pointer
• swap() (not in the shown code` should accept references, not values

[marty1885]

121 implements a bidirectional iterator. It should be enough for most use cases.

Feel free to reopen the issue if we need a random access iterator