view.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef pRC_TENSOR_TRAIN_TENSOR_VIEWS_VIEW_H
#define pRC_TENSOR_TRAIN_TENSOR_VIEWS_VIEW_H
 
#include <prc/core/basic/crtp.hpp>
#include <prc/core/basic/sequence.hpp>
#include <prc/core/container/subscripts.hpp>
#include <prc/core/tensor/declarations.hpp>
#include <prc/tensor_train/tensor/declarations.hpp>
 
namespace pRC::TensorTrain::TensorViews
{
    template<class T, Size... Ns, Size... Rs, class F>
        requires IsDefined<Tensor<T, Sizes<Ns...>, Sizes<Rs...>>>
    class View<T, Sizes<Ns...>, Sizes<Rs...>, F> : public CRTP<F>
    {
    public:
        using N = pRC::Sizes<Ns...>;
        using L = N;
        using Sizes = N;
 
        using SubscriptsN = pRC::Subscripts<Ns...>;
        using SubscriptsL = SubscriptsN;
        using Subscripts = SubscriptsN;
 
        static constexpr auto Dimension = N::Dimension;
 
        using Ranks = pRC::Sizes<Rs...>;
        template<class S>
            requires(S::Dimension == Ranks::Dimension)
        using ChangeRanks = Tensor<T, N, S>;
 
        template<Index C>
        using Cores = pRC::Tensor<T, pRC::Sizes<1, Rs..., 1>::size(C),
            N::size(C), pRC::Sizes<1, Rs..., 1>::size(C + 1)>;
 
        using Type = T;
        template<class C>
        using ChangeType = Tensor<C, N, Ranks>;
 
        static constexpr auto n()
            requires requires { N::size(); }
        {
            return N::size();
        }
 
        static constexpr auto n(Index const dimension)
        {
            return N::size(dimension);
        }
 
        static constexpr auto size()
            requires requires { Sizes::size(); }
        {
            return Sizes::size();
        }
 
        static constexpr auto size(Index const dimension)
        {
            return Sizes::size(dimension);
        }
 
        template<class X, IsConvertible<Index>... Is>
            requires IsConstructible<T, X> && (sizeof...(Is) == Dimension)
        static constexpr auto Single(X &&value, Is const... indices)
        {
            return Tensor<T, N, Ranks>::Single(forward<X>(value), indices...);
        }
 
        template<class X>
            requires IsConstructible<T, X>
        static constexpr auto Single(X &&value, Subscripts const &subscripts)
        {
            return Tensor<T, N, Ranks>::Single(forward<X>(value), subscripts);
        }
 
    public:
        template<Index C>
        constexpr decltype(auto) core()
        {
            return this->self().template core<C>();
        }
 
        template<Index C>
        constexpr decltype(auto) core() const
        {
            return this->self().template core<C>();
        }
 
        template<IsConvertible<Index>... Is>
            requires(sizeof...(Is) == Dimension)
        constexpr auto operator()(Is const... indices)
        {
            return expand(makeSeries<Index, Dimension>(),
                [this, &indices...](auto const... seq)
                {
                    return fold<Mul, true, Direction::Backwards>(
                        chip<1>(this->template core<seq>(), indices)...)(0, 0);
                });
        }
 
        template<IsConvertible<Index>... Is>
            requires(sizeof...(Is) == Dimension)
        constexpr auto operator()(Is const... indices) const
        {
            return expand(makeSeries<Index, Dimension>(),
                [this, &indices...](auto const... seq)
                {
                    return fold<Mul, true, Direction::Backwards>(
                        chip<1>(this->template core<seq>(), indices)...)(0, 0);
                });
        }
 
        constexpr decltype(auto) operator()(Subscripts const &subscripts)
        {
            return expand(makeSeries<Index, Dimension>(),
                [this, &subscripts](auto const... seq) -> decltype(auto)
                {
                    return (*this)(subscripts[seq]...);
                });
        }
 
        constexpr decltype(auto) operator()(Subscripts const &subscripts) const
        {
            return expand(makeSeries<Index, Dimension>(),
                [this, &subscripts](auto const... seq) -> decltype(auto)
                {
                    return (*this)(subscripts[seq]...);
                });
        }
 
        template<class X>
            requires requires { typename pRC::Tensor<T, Ns...>; } &&
            IsSame<X, pRC::Tensor<T, Ns...>>
        explicit constexpr operator X()
        {
            pRC::Tensor<T, Ns...> full;
 
            range<Sizes>(
                [this, &full](auto const... indices)
                {
                    full(indices...) = (*this)(indices...);
                });
 
            return full;
        }
 
        template<class X>
            requires requires { typename pRC::Tensor<T, Ns...>; } &&
            IsSame<X, pRC::Tensor<T, Ns...>>
        explicit constexpr operator X() const
        {
            pRC::Tensor<T, Ns...> full;
 
            range<Sizes>(
                [this, &full](auto const... indices)
                {
                    full(indices...) = (*this)(indices...);
                });
 
            return full;
        }
 
    protected:
        ~View() = default;
        constexpr View(View const &) = default;
        constexpr View(View &&) = default;
        constexpr View &operator=(View const &) = delete;
        constexpr View &operator=(View &&) = delete;
        constexpr View() = default;
    };
}
 
namespace pRC
{
    template<class T, Size... Ns, class R, class F>
    Tensor(TensorTrain::TensorViews::View<T, Sizes<Ns...>, R, F> const &)
        -> Tensor<T, Ns...>;
}
#endif // pRC_TENSOR_TRAIN_TENSOR_VIEWS_VIEW_H