tensor.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef pRC_CORE_TENSOR_TENSOR_H
#define pRC_CORE_TENSOR_TENSOR_H
 
#include <prc/core/basic/sequence.hpp>
#include <prc/core/complex/complex.hpp>
#include <prc/core/container/array.hpp>
#include <prc/core/functors/add.hpp>
#include <prc/core/functors/div.hpp>
#include <prc/core/functors/logical_and.hpp>
#include <prc/core/functors/mul.hpp>
#include <prc/core/functors/sub.hpp>
#include <prc/core/tensor/declarations.hpp>
#include <prc/core/tensor/views/reference.hpp>
#include <prc/core/tensor/views/single.hpp>
#include <prc/core/value/value.hpp>
 
namespace pRC
{
    template<class T, Size... Ns>
        requires(IsValue<T> || IsComplex<T> || IsBool<T>) &&
        requires { Sizes<Ns...>::size(); }
    class Tensor
    {
    public:
        using Type = T;
        template<class C>
        using ChangeType = Tensor<C, Ns...>;
 
        using Sizes = pRC::Sizes<Ns...>;
        template<Size... Ss>
        using ChangeSizes = Tensor<T, Ss...>;
 
        using Subscripts = pRC::Subscripts<Ns...>;
 
        static constexpr auto Dimension = Sizes::Dimension;
 
        static constexpr auto 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)
        {
            return TensorViews::Single<T, Sizes>(forward<X>(value), subscripts);
        }
 
    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, Sizes>, X>
        constexpr Tensor(X &&other)
        {
            *this = forward<X>(other);
        }
 
        template<class X>
            requires IsAssignable<TensorViews::Reference<T, Sizes>, X>
        constexpr auto &operator=(X &&rhs) &
        {
            view(*this) = forward<X>(rhs);
            return *this;
        }
 
        template<IsConvertible<Index>... Is>
            requires(sizeof...(Is) == Dimension)
        constexpr decltype(auto) operator()(Is const... indices) &&
        {
            return move(mData)(indices...);
        }
 
        template<IsConvertible<Index>... Is>
            requires(sizeof...(Is) == Dimension)
        constexpr decltype(auto) operator()(Is const... indices) const &&
        {
            return move(mData)(indices...);
        }
 
        template<IsConvertible<Index>... Is>
            requires(sizeof...(Is) == Dimension)
        constexpr decltype(auto) operator()(Is const... indices) &
        {
            return mData(indices...);
        }
 
        template<IsConvertible<Index>... Is>
            requires(sizeof...(Is) == Dimension)
        constexpr decltype(auto) operator()(Is const... indices) const &
        {
            return mData(indices...);
        }
 
        constexpr decltype(auto) operator()(Subscripts const &subscripts) &&
        {
            return move(mData)(subscripts);
        }
 
        constexpr decltype(auto) operator()(
            Subscripts const &subscripts) const &&
        {
            return move(mData)(subscripts);
        }
 
        constexpr decltype(auto) operator()(Subscripts const &subscripts) &
        {
            return mData(subscripts);
        }
 
        constexpr decltype(auto) operator()(
            Subscripts const &subscripts) const &
        {
            return mData(subscripts);
        }
 
        constexpr decltype(auto) operator[](Index const index) &&
        {
            return move(mData)[index];
        }
 
        constexpr decltype(auto) operator[](Index const index) const &&
        {
            return move(mData)[index];
        }
 
        constexpr decltype(auto) operator[](Index const index) &
        {
            return mData[index];
        }
 
        constexpr decltype(auto) operator[](Index const index) const &
        {
            return mData[index];
        }
 
        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);
        }
 
        explicit constexpr operator T() const
            requires(Dimension == 0)
        {
            return operator()();
        }
 
        explicit constexpr operator Bool() const
            requires IsSame<T, Bool> && (Dimension > 0)
        {
            return reduce<LogicalAnd>(*this)();
        }
 
    private:
        BEGIN_IGNORE_DIAGNOSTIC_GCC("-Wpedantic")
        Array<T, Ns...> mData;
        END_IGNORE_DIAGNOSTIC_GCC
    };
 
    template<class F, class T, Size... Ns>
    Tensor(TensorViews::View<T, Sizes<Ns...>, F> const &) -> Tensor<T, Ns...>;
}
#endif // pRC_CORE_TENSOR_TENSOR_H