ExpressionTemplate.h

/*
  ==============================================================================
    DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
    Copyright 2022- by sonible GmbH.
 
    This file is part of VCTR - Versatile Container Templates Reconceptualized.
 
    VCTR is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License version 3
    only, as published by the Free Software Foundation.
 
    VCTR is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License version 3 for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    version 3 along with VCTR.  If not, see <https://www.gnu.org/licenses/>.
  ==============================================================================
*/
 
namespace vctr
{
 
struct ExpressionTemplateBase : Config
{
    template <class ReturnElementType, class... SrcTypes>
    struct ExpressionTypes
    {
        template <class T>
        struct ElementTraits
        {
            using Type = T;
 
            static constexpr auto isRealFloat = is::realFloatNumber<Type>;
 
            static constexpr auto isSigned = std::is_signed_v<Type>;
 
            static constexpr auto isUnsigned = std::is_unsigned_v<Type>;
 
            static constexpr auto isInt = std::is_integral_v<Type>;
 
            static constexpr auto isSignedInt = isSigned & isInt;
 
            static constexpr auto isComplexFloat = is::complexFloatNumber<Type>;
 
            static constexpr auto isInt32 = std::same_as<int32_t, Type>;
 
            static constexpr auto isUint32 = std::same_as<uint32_t, Type>;
 
            static constexpr auto isInt64 = std::same_as<int64_t, Type>;
 
            static constexpr auto isUint64 = std::same_as<uint64_t, Type>;
 
            static constexpr auto isFloat = std::same_as<float, Type>;
 
            static constexpr auto isDouble = std::same_as<double, Type>;
        };
 
        using CommonSrcElement = ElementTraits<std::common_type_t<std::remove_const_t<ValueType<SrcTypes>>...>>;
 
        using CommonElement = ElementTraits<std::common_type_t<ReturnElementType, typename CommonSrcElement::Type>>;
 
        static constexpr auto allElementTypesSame = are::same<ReturnElementType, std::remove_const_t<ValueType<SrcTypes>>...>;
 
        //==============================================================================
        using Neon = NeonRegister<typename CommonElement::Type>;
 
        using NeonSrc = NeonRegister<typename CommonSrcElement::Type>;
 
        using NeonRet = NeonRegister<ReturnElementType>;
 
        //==============================================================================
        using AVX = AVXRegister<typename CommonElement::Type>;
 
        using AVXSrc = AVXRegister<typename CommonSrcElement::Type>;
 
        using AVXRet = AVXRegister<ReturnElementType>;
 
        //==============================================================================
        using SSE = SSERegister<typename CommonElement::Type>;
 
        using SSESrc = SSERegister<typename CommonSrcElement::Type>;
 
        using SSERet = SSERegister<ReturnElementType>;
 
        //==============================================================================
        using Accelerate = PlatformVectorOps::AppleAccelerate<typename CommonElement::Type>;
 
        using IPP = PlatformVectorOps::IntelIPP<typename CommonElement::Type>;
    };
};
 
namespace detail
{
 
template <size_t i, class RuntimeArgs, is::expression Expression>
constexpr void tryApplyingRuntimeArgsToThisExpression (const RuntimeArgs& args, Expression& e)
{
    if constexpr (RuntimeArgs::template hasValue<i>())
    {
        std::apply ([&] (const auto&... args)
                    {
                        static_assert (has::applyRuntimeArgs<Expression, decltype (args)...>,
                                       "The expression does not implement a applyRuntimeArgs overload that matches the argument types passed.");
                        e.applyRuntimeArgs (args...);
                    }, args.template get<i>());
    }
    else if constexpr (has::applyRuntimeArgs<Expression>)
    {
        // Some expressions need to initialize runtime values that depend on their source before every
        // evaluation rather than being injected as external arguments (see e.g. NormalizeSum).
        e.applyRuntimeArgs();
    }
}
 
template <size_t i, class RuntimeArgs, is::anyVctrOrExpression Src>
constexpr void tryApplyingRuntimeArgsToSrc (const RuntimeArgs& args, Src& src)
{
    if constexpr (has::iterateOverRuntimeArgChain<Src, i, RuntimeArgs> && i < RuntimeArgs::size())
        src.template iterateOverRuntimeArgChain<i> (args);
}
 
} // namespace detail
 
} // namespace vctr
 
// clang-format off
#define VCTR_COMMON_UNARY_EXPRESSION_MEMBERS(ExpressionName, srcName)                              \
private:                                                                                           \
    using Expression = ExpressionTypes<value_type, SrcType>;                                       \
    SrcType srcName;                                                                               \
public:                                                                                            \
                                                                                                   \
    template <class Src>                                                                           \
    constexpr ExpressionName (Src&& s) : srcName (std::forward<Src> (s)) {}                        \
                                                                                                   \
    constexpr const auto& getStorageInfo() const { return srcName.getStorageInfo(); }              \
                                                                                                   \
    constexpr size_t size () const { return srcName.size (); }                                     \
                                                                                                   \
    constexpr bool isNotAliased (const void* other) const { return srcName.isNotAliased (other); } \
                                                                                                   \
    template <size_t i, class RuntimeArgs>                                                         \
    constexpr void iterateOverRuntimeArgChain (const RuntimeArgs& rtArgs)                          \
    {                                                                                              \
        tryApplyingRuntimeArgsToThisExpression<i> (rtArgs, *this);                                 \
        tryApplyingRuntimeArgsToSrc<i + 1> (rtArgs, srcName);                                      \
    }
 
#define VCTR_COMMON_BINARY_VEC_VEC_EXPRESSION_MEMBERS(ExpressionName, srcAName, srcBName)                                      \
private:                                                                                                                       \
    using Expression = ExpressionTypes<value_type, SrcAType, SrcBType>;                                                        \
    using SrcAStorageInfoType = std::invoke_result_t<decltype (&std::remove_cvref_t<SrcAType>::getStorageInfo), SrcAType>;     \
    using SrcBStorageInfoType = std::invoke_result_t<decltype (&std::remove_cvref_t<SrcBType>::getStorageInfo), SrcBType>;     \
                                                                                                                               \
    SrcAType srcAName;                                                                                                         \
    SrcBType srcBName;                                                                                                         \
    const CombinedStorageInfo<std::remove_cvref_t<SrcAStorageInfoType>, std::remove_cvref_t<SrcBStorageInfoType>> storageInfo; \
                                                                                                                               \
public:                                                                                                                        \
    template <class SrcA, class SrcB>                                                                                          \
    constexpr ExpressionName (SrcA&& a, SrcB&& b)                                                                              \
      : srcAName (std::forward<SrcA> (a)),                                                                                     \
        srcBName (std::forward<SrcB> (b)),                                                                                     \
        storageInfo (srcAName.getStorageInfo(), srcBName.getStorageInfo())                                                     \
    {}                                                                                                                         \
                                                                                                                               \
    constexpr const auto& getStorageInfo() const { return storageInfo; }                                                       \
                                                                                                                               \
    constexpr size_t size() const { return srcAName.size(); }                                                                  \
                                                                                                                               \
    constexpr bool isNotAliased (const void* dst) const                                                                        \
    {                                                                                                                          \
        if constexpr (is::expression<SrcAType> && is::anyVctr<SrcBType>)                                                       \
        {                                                                                                                      \
            return dst != srcBName.data();                                                                                     \
        }                                                                                                                      \
                                                                                                                               \
        if constexpr (is::anyVctr<SrcAType> && is::expression<SrcBType>)                                                       \
        {                                                                                                                      \
            return dst != srcAName.data();                                                                                     \
        }                                                                                                                      \
                                                                                                                               \
        return true;                                                                                                           \
    }
 
#define VCTR_COMMON_BINARY_SINGLE_VEC_EXPRESSION_MEMBERS(ExpressionName, srcVecName, srcSingleName)   \
private:                                                                                              \
    using Expression = ExpressionTypes<value_type, SrcType>;                                          \
                                                                                                      \
    SrcType srcVecName;                                                                               \
    typename Expression::CommonSrcElement::Type srcSingleName;                                        \
    const typename Expression::SSESrc srcSingleName##AsSSE;                                           \
    const typename Expression::NeonSrc srcSingleName##AsNeon;                                         \
public:                                                                                               \
                                                                                                      \
    template <class Src>                                                                              \
    constexpr ExpressionName (typename Expression::CommonSrcElement::Type a, Src&& b)                 \
        : srcVecName (std::forward<Src> (b)),                                                         \
          srcSingleName (a),                                                                          \
          srcSingleName##AsSSE (Expression::SSESrc::broadcast (a)),                                   \
          srcSingleName##AsNeon (Expression::NeonSrc::broadcast (a))                                  \
    {}                                                                                                \
                                                                                                      \
    constexpr const auto& getStorageInfo() const { return srcVecName.getStorageInfo(); }              \
                                                                                                      \
    constexpr size_t size() const { return srcVecName.size(); }                                       \
    constexpr bool isNotAliased (const void* other) const { return srcVecName.isNotAliased (other); }
// clang-format on