Multiply.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::expressions
{
 
//==============================================================================
template <size_t extent, class SrcAType, class SrcBType>
class MultiplyVectors : ExpressionTemplateBase
{
private:
    static auto op (const ValueType<SrcAType>& a, const ValueType<SrcBType>& b) { return a * b; }
 
public:
    using value_type = CommonVecExpressionType<ValueType<SrcAType>, ValueType<SrcBType>, op>;
 
    VCTR_COMMON_BINARY_VEC_VEC_EXPRESSION_MEMBERS (MultiplyVectors, srcA, srcB)
 
    VCTR_FORCEDINLINE constexpr auto operator[] (size_t i) const
    {
        return srcA[i] * srcB[i];
    }
 
    VCTR_FORCEDINLINE const value_type* evalNextVectorOpInExpressionChain (value_type* dst) const
    requires is::suitableForAccelerateRealOrComplexComplexFloatBinaryVectorOp<SrcAType, SrcBType, value_type, detail::dontPreferIfIppAndAccelerateAreAvailable>
    {
        Expression::Accelerate::mul (srcA.evalNextVectorOpInExpressionChain (dst), srcB.evalNextVectorOpInExpressionChain (dst), dst, size());
        return dst;
    }
 
    VCTR_FORCEDINLINE const value_type* evalNextVectorOpInExpressionChain (value_type* dst) const
    requires is::suitableForIppRealOrComplexComplexFloatBinaryVectorOp<SrcAType, SrcBType, value_type, detail::preferIfIppAndAccelerateAreAvailable>
    {
        Expression::IPP::mul (srcA.evalNextVectorOpInExpressionChain (dst), srcB.evalNextVectorOpInExpressionChain (dst), dst, sizeToInt (size()));
        return dst;
    }
 
 
    VCTR_FORCEDINLINE void evalVectorOpMultiplyAccumulate (value_type* dst) const
    requires is::suitableForAccelerateRealOrComplexComplexFloatBinaryVectorOp<SrcAType, SrcBType, value_type, detail::dontPreferIfIppAndAccelerateAreAvailable> && is::anyVctr<SrcAType> && is::anyVctr<SrcBType>
    {
        Expression::Accelerate::multiplyAdd (srcA.data(), srcB.data(), dst, dst, size());
    }
 
    VCTR_FORCEDINLINE void evalVectorOpMultiplyAccumulate (value_type* dst) const
    requires is::suitableForIppRealOrComplexComplexFloatBinaryVectorOp<SrcAType, SrcBType, value_type, detail::preferIfIppAndAccelerateAreAvailable> && is::anyVctr<SrcAType> && is::anyVctr<SrcBType>
    {
        Expression::IPP::multiplyAccumulate (srcA.data(), srcB.data(), dst, sizeToInt (size()));
    }
 
    //==============================================================================
    VCTR_FORWARD_PREPARE_SIMD_EVALUATION_BINARY_EXPRESSION_MEMBER_FUNCTIONS (srcA, srcB)
 
    // AVX Implementation
    VCTR_FORCEDINLINE VCTR_TARGET ("fma") AVXRegister<value_type> getAVX (size_t i) const
    requires (archX64 && has::getAVX<SrcAType> && has::getAVX<SrcBType> && Expression::allElementTypesSame && Expression::CommonElement::isRealFloat)
    {
        return Expression::AVX::mul (srcA.getAVX (i), srcB.getAVX (i));
    }
 
    //==============================================================================
    // NEON Implementation
    NeonRegister<value_type> getNeon (size_t i) const
    requires (archARM && has::getNeon<SrcAType> && has::getNeon<SrcBType> && Expression::allElementTypesSame && ! (Expression::CommonElement::isInt64 || Expression::CommonElement::isUint64))
    {
        return Expression::Neon::mul (srcA.getNeon (i), srcB.getNeon (i));
    }
};
 
//==============================================================================
template <size_t extent, class SrcType>
class MultiplyVecBySingle : ExpressionTemplateBase
{
public:
    using value_type = ValueType<SrcType>;
 
    VCTR_COMMON_BINARY_SINGLE_VEC_EXPRESSION_MEMBERS (MultiplyVecBySingle, src, single)
 
    VCTR_FORCEDINLINE constexpr value_type operator[] (size_t i) const
    {
        return single * src[i];
    }
 
    VCTR_FORCEDINLINE const value_type* evalNextVectorOpInExpressionChain (value_type* dst) const
    requires is::suitableForAccelerateRealFloatVectorOp<SrcType, value_type, detail::dontPreferIfIppAndAccelerateAreAvailable>
    {
        Expression::Accelerate::mul (src.evalNextVectorOpInExpressionChain (dst), single, dst, size());
        return dst;
    }
 
    VCTR_FORCEDINLINE const value_type* evalNextVectorOpInExpressionChain (value_type* dst) const
    requires is::suitableForIppRealOrComplexFloatVectorOp<SrcType, value_type, detail::preferIfIppAndAccelerateAreAvailable>
    {
        Expression::IPP::mul (src.evalNextVectorOpInExpressionChain (dst), single, dst, sizeToInt (size()));
        return dst;
    }
 
    VCTR_FORCEDINLINE void evalVectorOpMultiplyAccumulate (value_type* dst) const
    requires is::suitableForAccelerateRealFloatVectorOp<SrcType, value_type, detail::dontPreferIfIppAndAccelerateAreAvailable> && is::anyVctr<SrcType>
    {
        Expression::Accelerate::multiplyAdd (src.data(), single, dst, dst, size());
    }
 
    VCTR_FORCEDINLINE void evalVectorOpMultiplyAccumulate (value_type* dst) const
    requires is::suitableForIppRealFloatVectorOp<SrcType, value_type, detail::preferIfIppAndAccelerateAreAvailable> && is::anyVctr<SrcType>
    {
        Expression::IPP::multiplyAccumulate (src.data(), single, dst, sizeToInt (size()));
    }
 
    //==============================================================================
    // AVX Implementation
    VCTR_FORCEDINLINE VCTR_TARGET ("avx") void prepareAVXEvaluation() const
    requires has::prepareAVXEvaluation<SrcType>
    {
        src.prepareAVXEvaluation();
        singleSIMD.avx = Expression::AVX::broadcast (single);
    }
 
    VCTR_FORCEDINLINE VCTR_TARGET ("fma") AVXRegister<value_type> getAVX (size_t i) const
    requires (archX64 && has::getAVX<SrcType> && Expression::allElementTypesSame && Expression::CommonElement::isRealFloat)
    {
        return Expression::AVX::mul (singleSIMD.avx, src.getAVX (i));
    }
 
    // SSE Implementation
    VCTR_FORCEDINLINE VCTR_TARGET ("sse4.1") void prepareSSEEvaluation() const
    requires has::prepareSSEEvaluation<SrcType>
    {
        src.prepareSSEEvaluation();
        singleSIMD.sse = Expression::SSE::broadcast (single);
    }
 
    VCTR_FORCEDINLINE VCTR_TARGET ("sse4.1") SSERegister<value_type> getSSE (size_t i) const
    requires (archX64 && has::getSSE<SrcType> && Expression::allElementTypesSame && Expression::CommonElement::isRealFloat)
    {
        return Expression::SSE::mul (singleSIMD.sse, src.getSSE (i));
    }
private:
    mutable SIMDRegisterUnion<Expression> singleSIMD {};
};
 
//==============================================================================
template <size_t extent, class SrcType, is::constant ConstantType>
class MultiplyVecByConstant : ExpressionTemplateBase
{
public:
    using value_type = ValueType<SrcType>;
 
    static constexpr auto constant = value_type (ConstantType::value);
 
    VCTR_COMMON_UNARY_EXPRESSION_MEMBERS (MultiplyVecByConstant, src)
 
    VCTR_FORCEDINLINE constexpr value_type operator[] (size_t i) const
    {
        return constant * src[i];
    }
 
    VCTR_FORCEDINLINE const value_type* evalNextVectorOpInExpressionChain (value_type* dst) const
    requires is::suitableForAccelerateRealFloatVectorOp<SrcType, value_type, detail::dontPreferIfIppAndAccelerateAreAvailable>
    {
        Expression::Accelerate::mul (src.evalNextVectorOpInExpressionChain (dst), constant, dst, size());
        return dst;
    }
 
    VCTR_FORCEDINLINE const value_type* evalNextVectorOpInExpressionChain (value_type* dst) const
    requires is::suitableForIppRealOrComplexFloatVectorOp<SrcType, value_type, detail::preferIfIppAndAccelerateAreAvailable>
    {
        Expression::IPP::mul (src.evalNextVectorOpInExpressionChain (dst), constant, dst, sizeToInt (size()));
        return dst;
    }
 
    VCTR_FORCEDINLINE void evalVectorOpMultiplyAccumulate (value_type* dst) const
    requires is::suitableForAccelerateRealFloatVectorOp<SrcType, value_type, detail::dontPreferIfIppAndAccelerateAreAvailable> && is::anyVctr<SrcType>
    {
        Expression::Accelerate::multiplyAdd (src.data(), constant, dst, dst, size());
    }
 
    VCTR_FORCEDINLINE void evalVectorOpMultiplyAccumulate (value_type* dst) const
    requires is::suitableForIppRealFloatVectorOp<SrcType, value_type, detail::preferIfIppAndAccelerateAreAvailable> && is::anyVctr<SrcType>
    {
        Expression::IPP::multiplyAccumulate (src.data(), constant, dst, sizeToInt (size()));
    }
 
    //==============================================================================
    // NEON Implementation
    VCTR_FORCEDINLINE void prepareNeonEvaluation() const
    requires has::prepareNeonEvaluation<SrcType>
    {
        src.prepareNeonEvaluation();
        constantSIMD.neon = Expression::Neon::broadcast (constant);
    }
 
    VCTR_FORCEDINLINE NeonRegister<value_type> getNeon (size_t i) const
    requires (archARM && has::getNeon<SrcType> && Expression::allElementTypesSame && Expression::CommonElement::isRealFloat)
    {
        return Expression::Neon::mul (constantSIMD.neon, src.getNeon (i));
    }
 
    // AVX Implementation
    VCTR_FORCEDINLINE VCTR_TARGET ("avx") void prepareAVXEvaluation() const
    requires has::prepareAVXEvaluation<SrcType>
    {
        src.prepareAVXEvaluation();
        constantSIMD.avx = Expression::AVX::broadcast (constant);
    }
 
    VCTR_FORCEDINLINE VCTR_TARGET ("fma") AVXRegister<value_type> getAVX (size_t i) const
    requires (archX64 && has::getAVX<SrcType> && Expression::allElementTypesSame && Expression::CommonElement::isRealFloat)
    {
        return Expression::AVX::mul (constantSIMD.avx, src.getAVX (i));
    }
 
    // SSE Implementation
    VCTR_FORCEDINLINE VCTR_TARGET ("sse4.1") void prepareSSEEvaluation() const
    requires has::prepareSSEEvaluation<SrcType>
    {
        src.prepareSSEEvaluation();
        constantSIMD.sse = Expression::SSE::broadcast (constant);
    }
 
    VCTR_FORCEDINLINE VCTR_TARGET ("sse4.1") SSERegister<value_type> getSSE (size_t i) const
    requires (archX64 && has::getSSE<SrcType> && Expression::allElementTypesSame && Expression::CommonElement::isRealFloat)
    {
        return Expression::SSE::mul (constantSIMD.sse, src.getSSE (i));
    }
 
private:
    mutable SIMDRegisterUnion<Expression> constantSIMD {};
};
 
} // namespace vctr::expressions
 
namespace vctr::detail
{
template <class T>
struct IsMultiplicationExpression : std::false_type {};
 
template <size_t e, class A, class B>
struct IsMultiplicationExpression<expressions::MultiplyVectors<e, A, B>> : std::true_type {};
 
template <size_t e, class A>
struct IsMultiplicationExpression<expressions::MultiplyVecBySingle<e, A>> : std::true_type {};
} // namespace vctr::detail
 
namespace vctr
{
 
template <class SrcAType, class SrcBType>
requires (is::anyVctrOrExpression<std::remove_cvref_t<SrcAType>> &&
          is::anyVctrOrExpression<std::remove_cvref_t<SrcBType>>)
constexpr auto operator* (SrcAType&& a, SrcBType&& b)
{
    assertCommonSize (a, b);
    constexpr auto extent = getCommonExtent<SrcAType, SrcBType>();
 
    return expressions::MultiplyVectors<extent, SrcAType, SrcBType> (std::forward<SrcAType> (a), std::forward<SrcBType> (b));
}
 
template <class Src>
requires is::anyVctrOrExpression<Src>
constexpr auto operator* (typename std::remove_cvref_t<Src>::value_type single, Src&& vec)
{
    return expressions::MultiplyVecBySingle<extentOf<Src>, Src> (single, std::forward<Src> (vec));
}
 
template <class Src>
requires is::anyVctrOrExpression<Src>
constexpr auto operator* (Src&& vec, typename std::remove_cvref_t<Src>::value_type single)
{
    return expressions::MultiplyVecBySingle<extentOf<Src>, Src> (single, std::forward<Src> (vec));
}
 
 
template <auto constantValue>
constexpr inline ExpressionChainBuilder<expressions::MultiplyVecByConstant, Constant<constantValue>> multiplyByConstant;
} // namespace vctr