xarray.hpp

/***************************************************************************
 * Copyright (c) Johan Mabille, Sylvain Corlay and Wolf Vollprecht          *
 * Copyright (c) QuantStack                                                 *
 *                                                                          *
 * Distributed under the terms of the BSD 3-Clause License.                 *
 *                                                                          *
 * The full license is in the file LICENSE, distributed with this software. *
 ****************************************************************************/
 
#ifndef XTENSOR_ARRAY_HPP
#define XTENSOR_ARRAY_HPP
 
#include <algorithm>
#include <initializer_list>
#include <utility>
 
#include <xtl/xsequence.hpp>
 
#include "xbuffer_adaptor.hpp"
#include "xcontainer.hpp"
#include "xsemantic.hpp"
 
namespace xt
{
 
    /********************************
     * xarray_container declaration *
     ********************************/
 
    namespace extension
    {
        template <class EC, layout_type L, class SC, class Tag>
        struct xarray_container_base;
 
        template <class EC, layout_type L, class SC>
        struct xarray_container_base<EC, L, SC, xtensor_expression_tag>
        {
            using type = xtensor_empty_base;
        };
 
        template <class EC, layout_type L, class SC, class Tag>
        using xarray_container_base_t = typename xarray_container_base<EC, L, SC, Tag>::type;
    }
 
    template <class EC, layout_type L, class SC, class Tag>
    struct xcontainer_inner_types<xarray_container<EC, L, SC, Tag>>
    {
        using storage_type = EC;
        using reference = inner_reference_t<storage_type>;
        using const_reference = typename storage_type::const_reference;
        using size_type = typename storage_type::size_type;
        using shape_type = SC;
        using strides_type = get_strides_t<shape_type>;
        using backstrides_type = get_strides_t<shape_type>;
        using inner_shape_type = shape_type;
        using inner_strides_type = strides_type;
        using inner_backstrides_type = backstrides_type;
        using temporary_type = xarray_container<EC, L, SC, Tag>;
        static constexpr layout_type layout = L;
    };
 
    template <class EC, layout_type L, class SC, class Tag>
    struct xiterable_inner_types<xarray_container<EC, L, SC, Tag>>
        : xcontainer_iterable_types<xarray_container<EC, L, SC, Tag>>
    {
    };

    template <class EC, layout_type L, class SC, class Tag>
    class xarray_container : public xstrided_container<xarray_container<EC, L, SC, Tag>>,
                             public xcontainer_semantic<xarray_container<EC, L, SC, Tag>>,
                             public extension::xarray_container_base_t<EC, L, SC, Tag>
    {
    public:
 
        using self_type = xarray_container<EC, L, SC, Tag>;
        using base_type = xstrided_container<self_type>;
        using semantic_base = xcontainer_semantic<self_type>;
        using extension_base = extension::xarray_container_base_t<EC, L, SC, Tag>;
        using storage_type = typename base_type::storage_type;
        using allocator_type = typename base_type::allocator_type;
        using value_type = typename base_type::value_type;
        using reference = typename base_type::reference;
        using const_reference = typename base_type::const_reference;
        using pointer = typename base_type::pointer;
        using const_pointer = typename base_type::const_pointer;
        using shape_type = typename base_type::shape_type;
        using inner_shape_type = typename base_type::inner_shape_type;
        using strides_type = typename base_type::strides_type;
        using backstrides_type = typename base_type::backstrides_type;
        using inner_strides_type = typename base_type::inner_strides_type;
        using inner_backstrides_type = typename base_type::inner_backstrides_type;
        using temporary_type = typename semantic_base::temporary_type;
        using expression_tag = Tag;
        static constexpr std::size_t rank = SIZE_MAX;
 
        xarray_container();
        explicit xarray_container(const shape_type& shape, layout_type l = L);
        explicit xarray_container(const shape_type& shape, const_reference value, layout_type l = L);
        explicit xarray_container(const shape_type& shape, const strides_type& strides);
        explicit xarray_container(const shape_type& shape, const strides_type& strides, const_reference value);
        explicit xarray_container(storage_type&& storage, inner_shape_type&& shape, inner_strides_type&& strides);
 
        xarray_container(const value_type& t);
        xarray_container(nested_initializer_list_t<value_type, 1> t);
        xarray_container(nested_initializer_list_t<value_type, 2> t);
        xarray_container(nested_initializer_list_t<value_type, 3> t);
        xarray_container(nested_initializer_list_t<value_type, 4> t);
        xarray_container(nested_initializer_list_t<value_type, 5> t);
 
        template <class S = shape_type>
        static xarray_container from_shape(S&& s);
 
        ~xarray_container() = default;
 
        xarray_container(const xarray_container&) = default;
        xarray_container& operator=(const xarray_container&) = default;
 
        xarray_container(xarray_container&&) = default;
        xarray_container& operator=(xarray_container&&) = default;
 
        template <std::size_t N>
        explicit xarray_container(xtensor_container<EC, N, L, Tag>&& rhs);
        template <std::size_t N>
        xarray_container& operator=(xtensor_container<EC, N, L, Tag>&& rhs);
 
        template <class E>
        xarray_container(const xexpression<E>& e);
 
        template <class E>
        xarray_container& operator=(const xexpression<E>& e);
 
    private:
 
        storage_type m_storage;
 
        storage_type& storage_impl() noexcept;
        const storage_type& storage_impl() const noexcept;
 
        friend class xcontainer<xarray_container<EC, L, SC, Tag>>;
    };
 
    /******************************
     * xarray_adaptor declaration *
     ******************************/
 
    namespace extension
    {
        template <class EC, layout_type L, class SC, class Tag>
        struct xarray_adaptor_base;
 
        template <class EC, layout_type L, class SC>
        struct xarray_adaptor_base<EC, L, SC, xtensor_expression_tag>
        {
            using type = xtensor_empty_base;
        };
 
        template <class EC, layout_type L, class SC, class Tag>
        using xarray_adaptor_base_t = typename xarray_adaptor_base<EC, L, SC, Tag>::type;
    }
 
    template <class EC, layout_type L, class SC, class Tag>
    struct xcontainer_inner_types<xarray_adaptor<EC, L, SC, Tag>>
    {
        using storage_type = std::remove_reference_t<EC>;
        using reference = inner_reference_t<storage_type>;
        using const_reference = typename storage_type::const_reference;
        using size_type = typename storage_type::size_type;
        using shape_type = SC;
        using strides_type = get_strides_t<shape_type>;
        using backstrides_type = get_strides_t<shape_type>;
        using inner_shape_type = shape_type;
        using inner_strides_type = strides_type;
        using inner_backstrides_type = backstrides_type;
        using temporary_type = xarray_container<temporary_container_t<storage_type>, L, SC, Tag>;
        static constexpr layout_type layout = L;
    };
 
    template <class EC, layout_type L, class SC, class Tag>
    struct xiterable_inner_types<xarray_adaptor<EC, L, SC, Tag>>
        : xcontainer_iterable_types<xarray_adaptor<EC, L, SC, Tag>>
    {
    };

    template <class EC, layout_type L, class SC, class Tag>
    class xarray_adaptor : public xstrided_container<xarray_adaptor<EC, L, SC, Tag>>,
                           public xcontainer_semantic<xarray_adaptor<EC, L, SC, Tag>>,
                           public extension::xarray_adaptor_base_t<EC, L, SC, Tag>
    {
    public:
 
        using container_closure_type = EC;
 
        using self_type = xarray_adaptor<EC, L, SC, Tag>;
        using base_type = xstrided_container<self_type>;
        using semantic_base = xcontainer_semantic<self_type>;
        using extension_base = extension::xarray_adaptor_base_t<EC, L, SC, Tag>;
        using storage_type = typename base_type::storage_type;
        using allocator_type = typename base_type::allocator_type;
        using shape_type = typename base_type::shape_type;
        using strides_type = typename base_type::strides_type;
        using backstrides_type = typename base_type::backstrides_type;
        using temporary_type = typename semantic_base::temporary_type;
        using expression_tag = Tag;
        static constexpr std::size_t rank = SIZE_MAX;
 
        xarray_adaptor(storage_type&& storage);
        xarray_adaptor(const storage_type& storage);
 
        template <class D>
        xarray_adaptor(D&& storage, const shape_type& shape, layout_type l = L);
 
        template <class D>
        xarray_adaptor(D&& storage, const shape_type& shape, const strides_type& strides);
 
        ~xarray_adaptor() = default;
 
        xarray_adaptor(const xarray_adaptor&) = default;
        xarray_adaptor& operator=(const xarray_adaptor&);
 
        xarray_adaptor(xarray_adaptor&&) = default;
        xarray_adaptor& operator=(xarray_adaptor&&);
        xarray_adaptor& operator=(temporary_type&&);
 
        template <class E>
        xarray_adaptor& operator=(const xexpression<E>& e);
 
        template <class P, class S>
        void reset_buffer(P&& pointer, S&& size);
 
    private:
 
        container_closure_type m_storage;
 
        storage_type& storage_impl() noexcept;
        const storage_type& storage_impl() const noexcept;
 
        friend class xcontainer<xarray_adaptor<EC, L, SC, Tag>>;
    };
 
    /***********************************
     * xarray_container implementation *
     ***********************************/


    template <class EC, layout_type L, class SC, class Tag>
    inline xarray_container<EC, L, SC, Tag>::xarray_container()
        : base_type()
        , m_storage(1, value_type())
    {
    }

    template <class EC, layout_type L, class SC, class Tag>
    inline xarray_container<EC, L, SC, Tag>::xarray_container(const shape_type& shape, layout_type l)
        : base_type()
    {
        base_type::resize(shape, l);
    }

    template <class EC, layout_type L, class SC, class Tag>
    inline xarray_container<EC, L, SC, Tag>::xarray_container(
        const shape_type& shape,
        const_reference value,
        layout_type l
    )
        : base_type()
    {
        base_type::resize(shape, l);
        std::fill(m_storage.begin(), m_storage.end(), value);
    }

    template <class EC, layout_type L, class SC, class Tag>
    inline xarray_container<EC, L, SC, Tag>::xarray_container(const shape_type& shape, const strides_type& strides)
        : base_type()
    {
        base_type::resize(shape, strides);
    }

    template <class EC, layout_type L, class SC, class Tag>
    inline xarray_container<EC, L, SC, Tag>::xarray_container(
        const shape_type& shape,
        const strides_type& strides,
        const_reference value
    )
        : base_type()
    {
        base_type::resize(shape, strides);
        std::fill(m_storage.begin(), m_storage.end(), value);
    }

    template <class EC, layout_type L, class SC, class Tag>
    inline xarray_container<EC, L, SC, Tag>::xarray_container(const value_type& t)
        : base_type()
    {
        base_type::resize(xt::shape<shape_type>(t), true);
        nested_copy(m_storage.begin(), t);
    }

    template <class EC, layout_type L, class SC, class Tag>
    inline xarray_container<EC, L, SC, Tag>::xarray_container(
        storage_type&& storage,
        inner_shape_type&& shape,
        inner_strides_type&& strides
    )
        : base_type(std::move(shape), std::move(strides))
        , m_storage(std::move(storage))
    {
    }



    template <class EC, layout_type L, class SC, class Tag>
    inline xarray_container<EC, L, SC, Tag>::xarray_container(nested_initializer_list_t<value_type, 1> t)
        : base_type()
    {
        base_type::resize(xt::shape<shape_type>(t));
        constexpr auto tmp = layout_type::row_major;
        L == tmp ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<tmp>(), t);
    }

    template <class EC, layout_type L, class SC, class Tag>
    inline xarray_container<EC, L, SC, Tag>::xarray_container(nested_initializer_list_t<value_type, 2> t)
        : base_type()
    {
        base_type::resize(xt::shape<shape_type>(t));
        constexpr auto tmp = layout_type::row_major;
        L == tmp ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<tmp>(), t);
    }

    template <class EC, layout_type L, class SC, class Tag>
    inline xarray_container<EC, L, SC, Tag>::xarray_container(nested_initializer_list_t<value_type, 3> t)
        : base_type()
    {
        base_type::resize(xt::shape<shape_type>(t));
        constexpr auto tmp = layout_type::row_major;
        L == tmp ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<tmp>(), t);
    }

    template <class EC, layout_type L, class SC, class Tag>
    inline xarray_container<EC, L, SC, Tag>::xarray_container(nested_initializer_list_t<value_type, 4> t)
        : base_type()
    {
        base_type::resize(xt::shape<shape_type>(t));
        constexpr auto tmp = layout_type::row_major;
        L == tmp ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<tmp>(), t);
    }

    template <class EC, layout_type L, class SC, class Tag>
    inline xarray_container<EC, L, SC, Tag>::xarray_container(nested_initializer_list_t<value_type, 5> t)
        : base_type()
    {
        base_type::resize(xt::shape<shape_type>(t));
        constexpr auto tmp = layout_type::row_major;
        L == tmp ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<tmp>(), t);
    }


    template <class EC, layout_type L, class SC, class Tag>
    template <class S>
    inline xarray_container<EC, L, SC, Tag> xarray_container<EC, L, SC, Tag>::from_shape(S&& s)
    {
        shape_type shape = xtl::forward_sequence<shape_type, S>(s);
        return self_type(shape);
    }
 
    template <class EC, layout_type L, class SC, class Tag>
    template <std::size_t N>
    inline xarray_container<EC, L, SC, Tag>::xarray_container(xtensor_container<EC, N, L, Tag>&& rhs)
        : base_type(
            inner_shape_type(rhs.shape().cbegin(), rhs.shape().cend()),
            inner_strides_type(rhs.strides().cbegin(), rhs.strides().cend()),
            inner_backstrides_type(rhs.backstrides().cbegin(), rhs.backstrides().cend()),
            std::move(rhs.layout())
        )
        , m_storage(std::move(rhs.storage()))
    {
    }
 
    template <class EC, layout_type L, class SC, class Tag>
    template <std::size_t N>
    inline xarray_container<EC, L, SC, Tag>&
    xarray_container<EC, L, SC, Tag>::operator=(xtensor_container<EC, N, L, Tag>&& rhs)
    {
        this->shape_impl().assign(rhs.shape().cbegin(), rhs.shape().cend());
        this->strides_impl().assign(rhs.strides().cbegin(), rhs.strides().cend());
        this->backstrides_impl().assign(rhs.backstrides().cbegin(), rhs.backstrides().cend());
        this->mutable_layout() = rhs.layout();
        m_storage = std::move(rhs.storage());
        return *this;
    }


    template <class EC, layout_type L, class SC, class Tag>
    template <class E>
    inline xarray_container<EC, L, SC, Tag>::xarray_container(const xexpression<E>& e)
        : base_type()
    {
        // Avoids unintialized data because of (m_shape == shape) condition
        // in resize (called by assign), which is always true when dimension == 0.
        if (e.derived_cast().dimension() == 0)
        {
            detail::resize_data_container(m_storage, std::size_t(1));
        }
        semantic_base::assign(e);
    }

    template <class EC, layout_type L, class SC, class Tag>
    template <class E>
    inline auto xarray_container<EC, L, SC, Tag>::operator=(const xexpression<E>& e) -> self_type&
    {
        return semantic_base::operator=(e);
    }

 
    template <class EC, layout_type L, class SC, class Tag>
    inline auto xarray_container<EC, L, SC, Tag>::storage_impl() noexcept -> storage_type&
    {
        return m_storage;
    }
 
    template <class EC, layout_type L, class SC, class Tag>
    inline auto xarray_container<EC, L, SC, Tag>::storage_impl() const noexcept -> const storage_type&
    {
        return m_storage;
    }
 
    /******************
     * xarray_adaptor *
     ******************/


    template <class EC, layout_type L, class SC, class Tag>
    inline xarray_adaptor<EC, L, SC, Tag>::xarray_adaptor(storage_type&& storage)
        : base_type()
        , m_storage(std::move(storage))
    {
    }

    template <class EC, layout_type L, class SC, class Tag>
    inline xarray_adaptor<EC, L, SC, Tag>::xarray_adaptor(const storage_type& storage)
        : base_type()
        , m_storage(storage)
    {
    }

    template <class EC, layout_type L, class SC, class Tag>
    template <class D>
    inline xarray_adaptor<EC, L, SC, Tag>::xarray_adaptor(D&& storage, const shape_type& shape, layout_type l)
        : base_type()
        , m_storage(std::forward<D>(storage))
    {
        base_type::resize(shape, l);
    }

    template <class EC, layout_type L, class SC, class Tag>
    template <class D>
    inline xarray_adaptor<EC, L, SC, Tag>::xarray_adaptor(
        D&& storage,
        const shape_type& shape,
        const strides_type& strides
    )
        : base_type()
        , m_storage(std::forward<D>(storage))
    {
        base_type::resize(shape, strides);
    }

 
    template <class EC, layout_type L, class SC, class Tag>
    inline auto xarray_adaptor<EC, L, SC, Tag>::operator=(const xarray_adaptor& rhs) -> self_type&
    {
        base_type::operator=(rhs);
        m_storage = rhs.m_storage;
        return *this;
    }
 
    template <class EC, layout_type L, class SC, class Tag>
    inline auto xarray_adaptor<EC, L, SC, Tag>::operator=(xarray_adaptor&& rhs) -> self_type&
    {
        base_type::operator=(std::move(rhs));
        m_storage = rhs.m_storage;
        return *this;
    }
 
    template <class EC, layout_type L, class SC, class Tag>
    inline auto xarray_adaptor<EC, L, SC, Tag>::operator=(temporary_type&& rhs) -> self_type&
    {
        base_type::shape_impl() = std::move(const_cast<shape_type&>(rhs.shape()));
        base_type::strides_impl() = std::move(const_cast<strides_type&>(rhs.strides()));
        base_type::backstrides_impl() = std::move(const_cast<backstrides_type&>(rhs.backstrides()));
        m_storage = std::move(rhs.storage());
        return *this;
    }


    template <class EC, layout_type L, class SC, class Tag>
    template <class E>
    inline auto xarray_adaptor<EC, L, SC, Tag>::operator=(const xexpression<E>& e) -> self_type&
    {
        return semantic_base::operator=(e);
    }

 
    template <class EC, layout_type L, class SC, class Tag>
    inline auto xarray_adaptor<EC, L, SC, Tag>::storage_impl() noexcept -> storage_type&
    {
        return m_storage;
    }
 
    template <class EC, layout_type L, class SC, class Tag>
    inline auto xarray_adaptor<EC, L, SC, Tag>::storage_impl() const noexcept -> const storage_type&
    {
        return m_storage;
    }
 
    template <class EC, layout_type L, class SC, class Tag>
    template <class P, class S>
    inline void xarray_adaptor<EC, L, SC, Tag>::reset_buffer(P&& pointer, S&& size)
    {
        return m_storage.reset_data(std::forward<P>(pointer), std::forward<S>(size));
    }
}
 
#endif