enumerate.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef pRC_TENSOR_TRAIN_COMMON_FUNCTIONS_ENUMERATE_H
#define pRC_TENSOR_TRAIN_COMMON_FUNCTIONS_ENUMERATE_H
 
#include <prc/core/functors/view.hpp>
#include <prc/tensor_train/operator/views/enumerate.hpp>
#include <prc/tensor_train/tensor/views/enumerate.hpp>
 
namespace pRC
{
    template<class F, class... Xs>
        requires((TensorTrain::IsTensorish<RemoveReference<Xs>> ||
                     TensorTrain::IsOperatorish<RemoveReference<Xs>>) &&
                    ...) &&
        (sizeof...(Xs) > 0) && (isSame(RemoveReference<Xs>::Dimension...)) &&
        requires {
            declval<F>().template operator()<0>(
                declval<Xs>().template core<0>()...);
        }
    static inline constexpr auto enumerate(F &&f, Xs &&...args)
    {
        if constexpr((IsInvocable<View, Xs> && ...))
        {
            constexpr auto Dimension =
                Common<Constant<Size, RemoveReference<Xs>::Dimension>...>()();
            return expand(makeSeries<Index, Dimension>(),
                [&f, &args...](auto const... seq)
                {
                    auto core = [&f, &args...]<Index N>()
                    {
                        return forward<F>(f).template operator()<N>(
                            forward<Xs>(args).template core<N>()...);
                    };
 
                    using T =
                        Common<typename decltype(core.template
                                                 operator()<seq>())::Type...>;
 
                    if constexpr(Common<Constant<Size,
                                     decltype(core.template operator()<
                                              seq>())::Dimension>...>() == 3)
                    {
                        using Ranks =
                            Common<decltype(chip<0>(
                                       Sizes<decltype(core.template operator()<
                                                      seq>())::size(0)...>())),
                                decltype(chip<Dimension - 1>(
                                    Sizes<decltype(core.template operator()<
                                                   seq>())::size(2)...>()))>;
 
                        using N =
                            pRC::Sizes<decltype(core.template
                                                operator()<seq>())::size(1)...>;
 
                        return TensorTrain::TensorViews::Enumerate<T, N, Ranks,
                            F,
                            RemoveReference<decltype(view(
                                forward<Xs>(args)))>...>(forward<F>(f),
                            view(forward<Xs>(args))...);
                    }
                    if constexpr(Common<Constant<Size,
                                     decltype(core.template operator()<
                                              seq>())::Dimension>...>() == 4)
                    {
                        using Ranks =
                            Common<decltype(chip<0>(
                                       Sizes<decltype(core.template operator()<
                                                      seq>())::size(0)...>())),
                                decltype(chip<Dimension - 1>(
                                    Sizes<decltype(core.template operator()<
                                                   seq>())::size(3)...>()))>;
 
                        using M =
                            Sizes<decltype(core.template
                                           operator()<seq>())::size(1)...>;
 
                        using N =
                            Sizes<decltype(core.template
                                           operator()<seq>())::size(2)...>;
 
                        return TensorTrain::OperatorViews::Enumerate<T, M, N,
                            Ranks, F,
                            RemoveReference<decltype(view(
                                forward<Xs>(args)))>...>(forward<F>(f),
                            view(forward<Xs>(args))...);
                    }
                });
        }
        else
        {
            return eval(enumerate(forward<F>(f), args...));
        }
    }
 
    template<class F, class... Xs>
        requires((TensorTrain::IsTensorish<RemoveReference<Xs>> ||
                     TensorTrain::IsOperatorish<RemoveReference<Xs>>) &&
                    ...) &&
        requires { enumerate(declval<F>(), declval<Xs>()...); }
    static inline constexpr auto enumerate(Xs &&...args)
    {
        return enumerate(F(), forward<Xs>(args)...);
    }
}
#endif // pRC_TENSOR_TRAIN_COMMON_FUNCTIONS_ENUMERATE_H