assignable.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef pRC_TENSOR_TRAIN_OPERATOR_VIEWS_ASSIGNABLE_H
#define pRC_TENSOR_TRAIN_OPERATOR_VIEWS_ASSIGNABLE_H
 
#include <prc/core/basic/range.hpp>
#include <prc/tensor_train/operator/declarations.hpp>
 
namespace pRC::TensorTrain::OperatorViews
{
    template<class T, class SM, class SN, class SR, class F>
    class Assignable : public View<T, SM, SN, SR, F>
    {
    private:
        using Base = View<T, SM, SN, SR, F>;
 
    public:
        constexpr auto &operator=(Zero<> const)
        {
            return *this = zero<F>();
        }
 
        constexpr auto &operator=(Unit<> const)
        {
            return *this = unit<F>();
        }
 
        constexpr auto &operator=(Identity<> const)
        {
            return *this = identity<F>();
        }
 
        template<class X, IsOperatorish R = RemoveReference<X>>
            requires IsSame<typename Base::Sizes, typename R::Sizes> &&
            IsSame<typename Base::Ranks, typename R::Ranks> &&
            IsAssignable<T &, typename R::Type>
        constexpr auto &operator=(X &&rhs)
        {
            range<Context::CompileTime, Base::Dimension>(
                [this, &rhs](auto const i)
                {
                    this->self().template core<i>() =
                        forward<X>(rhs).template core<i>();
                });
            return this->self();
        }
 
        template<class X, IsOperatorish R = RemoveReference<X>>
            requires IsSame<typename Base::Sizes, typename R::Sizes> &&
            (!IsSame<typename Base::Ranks, typename R::Ranks>) &&
            IsSame<typename Base::Ranks,
                typename decltype(round<typename Base::Ranks>(
                    declval<X>()))::Ranks> &&
            IsAssignable<T &, typename R::Type>
        constexpr auto &operator=(X &&rhs)
        {
            this->self() = round<typename Base::Ranks>(forward<X>(rhs));
            return this->self();
        }
 
        template<class X>
            requires IsInvocable<Add, F, X>
        constexpr auto operator+=(X &&rhs)
        {
            this->self() = this->self() + forward<X>(rhs);
            return this->self();
        }
 
        template<class X>
            requires IsInvocable<Sub, F, X>
        constexpr auto operator-=(X &&rhs)
        {
            this->self() = this->self() - forward<X>(rhs);
            return this->self();
        }
 
        template<class X>
            requires IsInvocable<Mul, X, F>
        constexpr auto applyOnTheLeft(X &&lhs)
        {
            this->self() = eval(forward<X>(lhs) * this->self());
            return this->self();
        }
 
        template<class X>
            requires IsInvocable<Mul, F, X>
        constexpr auto applyOnTheRight(X &&rhs)
        {
            this->self() = eval(this->self() * forward<X>(rhs));
            return this->self();
        }
 
        template<class X>
            requires IsInvocable<Mul, F, X>
        constexpr auto operator*=(X &&rhs)
        {
            return applyOnTheRight(forward<X>(rhs));
        }
 
        template<class X>
            requires IsInvocable<Div, F, X>
        constexpr auto operator/=(X &&rhs)
        {
            this->self() = this->self() / forward<X>(rhs);
            return this->self();
        }
 
    protected:
        ~Assignable() = default;
        constexpr Assignable(Assignable const &) = default;
        constexpr Assignable(Assignable &&) = default;
        constexpr Assignable &operator=(Assignable const &) = delete;
        constexpr Assignable &operator=(Assignable &&) = delete;
        constexpr Assignable() = default;
    };
}
#endif // pRC_TENSOR_TRAIN_OPERATOR_VIEWS_ASSIGNABLE_H