tensor.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef pRC_TENSOR_TRAIN_TENSOR_TENSOR_H
#define pRC_TENSOR_TRAIN_TENSOR_TENSOR_H
 
#include <prc/core/basic/sequence.hpp>
#include <prc/core/container/subscripts.hpp>
#include <prc/core/tensor/tensor.hpp>
#include <prc/tensor_train/tensor/declarations.hpp>
#include <prc/tensor_train/tensor/views/enumerate.hpp>
#include <prc/tensor_train/tensor/views/reference.hpp>
 
namespace pRC::TensorTrain
{
    template<class T, Size... Ns, Size... Rs>
        requires(IsValue<T> || IsComplex<T>) &&
        (Sizes<Ns...>::Dimension - 1 == Sizes<Rs...>::Dimension)
    class Tensor<T, Sizes<Ns...>, Sizes<Rs...>>
    {
    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 Single(forward<X>(value), Subscripts(indices...));
        }
 
        template<class X>
            requires IsConstructible<T, X>
        static constexpr auto Single(X &&value, Subscripts const &subscripts)
        {
            auto const f = [subscripts, value = T(forward<X>(value))]<Index C>()
            {
                if constexpr(C == 0)
                {
                    return Cores<C>::Single(value, 0, subscripts[C], 0);
                }
                else
                {
                    return Cores<C>::Single(identity<T>(), 0, subscripts[C], 0);
                }
            };
            using F = RemoveConstReference<decltype(f)>;
            return TensorTrain::TensorViews::Enumerate<T, N, Ranks, F>(f);
        }
 
    public:
        ~Tensor() = default;
        constexpr Tensor(Tensor const &) = default;
        constexpr Tensor(Tensor &&) = default;
        constexpr Tensor &operator=(Tensor const &) & = default;
        constexpr Tensor &operator=(Tensor &&) & = default;
        constexpr Tensor() = default;
 
        template<class X>
            requires IsAssignable<TensorViews::Reference<T, N, Ranks>, X>
        constexpr Tensor(X &&other)
        {
            *this = forward<X>(other);
        }
 
        template<class X>
            requires IsAssignable<TensorViews::Reference<T, N, Ranks>, X>
        constexpr auto &operator=(X &&rhs) &
        {
            view(*this) = forward<X>(rhs);
            return *this;
        }
 
        template<Index C>
        constexpr decltype(auto) core() &&
        {
            return get<C>(move(mCores));
        }
 
        template<Index C>
        constexpr decltype(auto) core() const &&
        {
            return get<C>(move(mCores));
        }
 
        template<Index C>
        constexpr decltype(auto) core() &
        {
            return get<C>(mCores);
        }
 
        template<Index C>
        constexpr decltype(auto) core() const &
        {
            return get<C>(mCores);
        }
 
        template<IsConvertible<Index>... Is>
            requires(sizeof...(Is) == Dimension)
        constexpr decltype(auto) operator()(Is const... indices) const
        {
            return view(*this)(indices...);
        }
 
        constexpr decltype(auto) operator()(Subscripts const &subscripts) const
        {
            return view(*this)(subscripts);
        }
 
        template<class X>
            requires IsInvocable<Add, Tensor &, X>
        constexpr auto &operator+=(X &&rhs) &
        {
            return *this = *this + forward<X>(rhs);
        }
 
        template<class X>
            requires IsInvocable<Sub, Tensor &, X>
        constexpr auto &operator-=(X &&rhs) &
        {
            return *this = *this - forward<X>(rhs);
        }
 
        template<class X>
            requires IsInvocable<Mul, X, Tensor &>
        constexpr auto &applyOnTheLeft(X &&lhs) &
        {
            view(*this).applyOnTheLeft(forward<X>(lhs));
            return *this;
        }
 
        template<class X>
            requires IsInvocable<Mul, Tensor &, X>
        constexpr auto &applyOnTheRight(X &&rhs) &
        {
            view(*this).applyOnTheRight(forward<X>(rhs));
            return *this;
        }
 
        template<class X>
            requires IsInvocable<Mul, Tensor &, X>
        constexpr auto &operator*=(X &&rhs) &
        {
            view(*this) *= forward<X>(rhs);
            return *this;
        }
 
        template<class X>
            requires IsInvocable<Div, Tensor &, X>
        constexpr auto &operator/=(X &&rhs) &
        {
            return *this = *this / forward<X>(rhs);
        }
 
        template<class X>
            requires requires { typename pRC::Tensor<T, Ns...>; } &&
            IsSame<X, pRC::Tensor<T, Ns...>>
        explicit constexpr operator X() const
        {
            return pRC::Tensor(view(*this));
        }
 
    private:
        template<Index... seq>
        static constexpr auto coreTypes(Sequence<Index, seq...>)
        {
            return Tuple<Cores<seq>...>{};
        }
 
        using CoreTypes = decltype(coreTypes(makeSeries<Index, Dimension>()));
 
    private:
        CoreTypes mCores;
    };
 
    template<class T, class N, class Ranks, class F>
    Tensor(TensorViews::View<T, N, Ranks, F> const &) -> Tensor<T, N, Ranks>;
}
 
namespace pRC
{
    template<class T, Size... Ns, class R>
    Tensor(TensorTrain::Tensor<T, Sizes<Ns...>, R> const &) -> Tensor<T, Ns...>;
}
#endif // pRC_TENSOR_TRAIN_TENSOR_TENSOR_H