ndarray_view.h

Go to the documentation of this file.

#ifndef MF_NDARRAY_VIEW_H_
#define MF_NDARRAY_VIEW_H_

#include "../common.h"
#include "ndcoord.h"
#include "ndarray_iterator.h"
#include "ndspan.h"
#include "../utility/misc.h"
#include "../elem.h"
#include <type_traits>
#include <utility>
#include <memory>

namespace mf {

template<std::size_t Dim, typename T> class ndarray_view;

namespace detail {
    template<std::size_t Dim, typename T>
    ndarray_view<Dim - 1, T> get_subscript(const ndarray_view<Dim, T>& array, std::ptrdiff_t c) {
        return array.slice(c, 0);
    }
    
    template<typename T>
    T& get_subscript(const ndarray_view<1, T>& array, std::ptrdiff_t c) {
        return array.at({c});
    }
    
    template<std::size_t Dim, typename T, std::ptrdiff_t I>
    class ndarray_view_fcall;
}



template<std::size_t Dim, typename T>
class ndarray_view {
    static_assert(Dim >= 1, "ndarray_view dimension must be >= 1");

public:
    using value_type = T;
    using pointer = T*;
    using reference = T&;
    using index_type = std::ptrdiff_t;
    using coordinates_type = ndptrdiff<Dim>;
    using shape_type = ndsize<Dim>;
    using strides_type = ndptrdiff<Dim>;
    using span_type = ndspan<Dim>;
    
    using iterator = ndarray_iterator<ndarray_view>;

    constexpr static std::size_t dimension = Dim;

protected:
    pointer start_;
    shape_type shape_;
    strides_type strides_;
    
    std::ptrdiff_t contiguous_length_;
    
    ndarray_view section_(std::ptrdiff_t dim, std::ptrdiff_t start, std::ptrdiff_t end, std::ptrdiff_t step) const;
    std::ptrdiff_t fix_coordinate_(std::ptrdiff_t c, std::ptrdiff_t dim) const;
            
public:

    static strides_type default_strides(const shape_type&, std::size_t padding = 0);
    

    bool has_default_strides(std::size_t minimal_dimension = 0) const noexcept;
    

    std::size_t default_strides_padding(std::size_t minimal_dimension = 0) const;

    ndarray_view() : ndarray_view(nullptr, shape_type()) { }
    
    ndarray_view(pointer start, const shape_type&, const strides_type&);
    
    ndarray_view(pointer start, const shape_type& shape);
    

    ndarray_view(const ndarray_view<Dim, std::remove_const_t<T>>& arr) :
        ndarray_view(arr.start(), arr.shape(), arr.strides()) { }
    
    static ndarray_view null() { return ndarray_view(); }
    bool is_null() const noexcept { return (start_ == nullptr); }
    explicit operator bool () const noexcept { return ! is_null(); }

    void reset(const ndarray_view& other) noexcept;
    void reset() noexcept { reset(ndarray_view()); }
    void reset(pointer start, const shape_type& shape, const strides_type& strides)
        { reset(ndarray_view(start, shape, strides)); }
    void reset(pointer start, const shape_type& shape)
        { reset(ndarray_view(start, shape)); }
        
    template<typename Arg> const ndarray_view& operator=(Arg&& arg) const
        { assign(std::forward<Arg>(arg)); return *this; }
    const ndarray_view& operator=(const ndarray_view& other) const
        { assign(other); return *this; }
        
    coordinates_type index_to_coordinates(const index_type&) const;
    index_type coordinates_to_index(const coordinates_type&) const;
    pointer coordinates_to_pointer(const coordinates_type&) const;
    

    ndarray_view section(
        const coordinates_type& start,
        const coordinates_type& end,
        const strides_type& steps = strides_type(1)
    ) const;
    
    ndarray_view section(const span_type& span, const strides_type& steps = strides_type(1)) const {
        return section(span.start_pos(), span.end_pos(), steps);
    }
    
    ndarray_view<Dim - 1, T> slice(std::ptrdiff_t c, std::ptrdiff_t dimension) const;
    

    decltype(auto) operator[](std::ptrdiff_t c) const {
        return detail::get_subscript(*this, c);
    }
    
    using fcall_result = detail::ndarray_view_fcall<Dim, T, 1>;
    fcall_result operator()(std::ptrdiff_t start, std::ptrdiff_t end, std::ptrdiff_t step = 1) const {
        return section_(0, start, end, step);
    }
    fcall_result operator()(std::ptrdiff_t c) const {
        return section_(0, c, c + 1, 1);
    }
    fcall_result operator()() const {
        return *this;
    }
    
    reference at(const coordinates_type&) const;
            
    iterator begin() const;
    iterator end() const;
    
    template<typename T2> void assign(const ndarray_view<Dim, T2>&) const;
    void assign(const ndarray_view<Dim, const T>& other) const { assign<const T>(other); }
    
    template<typename T2> bool compare(const ndarray_view<Dim, T2>&) const;
    bool compare(const ndarray_view<Dim, const T>& other) const { return compare<const T>(other); }
        
    template<typename Arg> bool operator==(Arg&& arg) const { return compare(std::forward<Arg>(arg)); }
    template<typename Arg> bool operator!=(Arg&& arg) const { return ! compare(std::forward<Arg>(arg)); }
        
    friend bool same(const ndarray_view& a, const ndarray_view& b) noexcept {
        if(a.is_null() && b.is_null()) return true;
        else return (a.start_ == b.start_) && (a.shape_ == b.shape_) && (a.strides_ == b.strides_);
    }
    
    std::size_t size() const { return shape().product(); }
    
    pointer start() const noexcept { return start_; }
    const shape_type& shape() const noexcept { return shape_; }
    const strides_type& strides() const noexcept { return strides_; }
    std::ptrdiff_t contiguous_length() const noexcept { return contiguous_length_; }
    
    span_type full_span() const noexcept { return span_type(0, shape_); }
    
    template<std::size_t New_dim>
    ndarray_view<New_dim, T> reshape(const ndsize<New_dim>&) const;
    
    ndarray_view<1 + Dim, T> add_front_axis() const;
    
    ndarray_view swapaxis(std::size_t axis1, std::size_t axis2) const;
};


template<typename T>
ndarray_view<2, T> flip(const ndarray_view<2, T>& vw) {
    return vw.swapaxis(0, 1);
}


}

#include "ndarray_view.tcc"

#endif