ContainerAndExpressionConcepts.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::detail
{
 
// clang-format off
template <class T>
struct AnyVctr : std::false_type {};
 
template <class T, template <class> class A>
struct AnyVctr<Vector<T, A>> : std::true_type {};
 
template <class T>
struct AnyVctr<OwnedVector<T>> : std::true_type {};
 
template <class T, size_t e, size_t s>
struct AnyVctr<Array<T, e, s>> : std::true_type {};
 
template <class T, size_t e>
struct AnyVctr<OwnedArray<T, e>> : std::true_type {};
 
template <class T, size_t n, class S>
struct AnyVctr<Span<T, n, S>> : std::true_type {};
 
template <class E, class S, size_t e, class I>
struct AnyVctr<VctrBase<E, S, e, I>> : std::true_type {};
 
template <class T>
struct IsSpan : std::false_type {};
 
template <class T, size_t n, class S>
struct IsSpan<Span<T, n, S>> : std::true_type {};
 
template <class T>
struct IsStdArray : std::false_type {};
 
template <class T, size_t e>
struct IsStdArray<std::array<T, e>> : std::true_type {};
 
template <class T>
struct IsStdSpan : std::false_type {};
 
template <class T, size_t e>
struct IsStdSpan<std::span<T, e>> : std::true_type {};
 
template <class T>
struct IsExpressionChainBuilder : std::false_type {};
 
template <template <size_t, class...> class ExpressionType, class RuntimeArgs, class... AdditionalParameters>
struct IsExpressionChainBuilder<ExpressionChainBuilderWithRuntimeArgs<ExpressionType, RuntimeArgs, AdditionalParameters...>> : std::true_type {};
// clang-format on
 
} // namespace vctr::detail
 
namespace vctr::has
{
 
template <class T>
concept prepareNeonEvaluation = requires (const T& t) { t.prepareNeonEvaluation(); };
 
template <class T>
concept getNeon = requires (const T& t, size_t i) { t.getNeon (i); };
 
template <class T>
concept prepareAVXEvaluation = requires (const T& t) { t.prepareAVXEvaluation(); };
 
template <class T>
concept getAVX = requires (const T& t, size_t i) { t.getAVX (i); };
 
template <class T>
concept prepareSSEEvaluation = requires (const T& t) { t.prepareSSEEvaluation(); };
 
template <class T>
concept getSSE = requires (const T& t, size_t i) { t.getSSE (i); };
 
template <class T>
concept indexOperator = requires (T& t) { t[size_t()]; };
 
template <class T>
concept constIndexOperator = requires (const T& t) { t[size_t()]; };
 
template <class T, class DstType>
concept evalNextVectorOpInExpressionChain = requires (const T& t, DstType* d) { t.evalNextVectorOpInExpressionChain (d); } && std::same_as<DstType, typename std::remove_cvref_t<T>::value_type>;
 
template <class T, class ValueType>
concept reduceElementWise = requires (const T&t, ValueType& v) { t.reduceElementWise (v, size_t()); };
 
template <class T, class DstType>
concept reduceVectorOp = requires (const T& t) { { t.reduceVectorOp() } -> std::same_as<DstType>; };
 
template <class T, class SrcDstType>
concept reduceNeonRegisterWise = requires (const T& t, NeonRegister<SrcDstType>& sd, size_t s) { t.reduceNeonRegisterWise (sd, s); };
 
template <class T, class SrcDstType>
concept reduceAVXRegisterWise = requires (const T& t, AVXRegister<SrcDstType>& sd, size_t s) { t.reduceAVXRegisterWise (sd, s); };
 
template <class T, class SrcDstType>
concept reduceSSERegisterWise = requires (const T& t, SSERegister<SrcDstType>& sd, size_t s) { t.reduceSSERegisterWise (sd, s); };
 
template <class T>
concept data = requires (const T& t) { t.data(); };
 
template <class T, class ElementType>
concept dataWithElementType = requires (const T& t) { { t.data() } -> std::convertible_to<const ElementType*>; };
 
template <class T>
concept size = requires (const T& t, size_t i) { i = t.size(); };
 
template <class T>
concept sizeAndData = size<T> && data<T>;
 
template <class T, class ElementType>
concept sizeAndDataWithElementType = size<T> && dataWithElementType<T, ElementType>;
 
template <class T>
concept begin = requires (T& t) { *t.begin(); } || requires (const T& t) { *t.begin(); };
 
template <class T>
concept end = requires (T& t) { *t.end(); } || requires (const T& t) { *t.begin(); };
 
template <class T>
concept resize = requires (T& t, size_t n) { t.resize (n); };
 
template <class T>
concept getStorageInfo = requires (const T& t) { t.getStorageInfo(); };
 
template <class T>
concept isNotAliased = requires (const T& t, bool r, const void* o) { r = t.isNotAliased (o); };
 
template <class T, size_t i, class RuntimeArgs>
concept iterateOverRuntimeArgChain = requires (T& t, const RuntimeArgs& r) { t.template iterateOverRuntimeArgChain<i, RuntimeArgs> (r); };
 
template <class T, class... Args>
concept applyRuntimeArgs = requires (T& t, const Args&... args) { t.applyRuntimeArgs (args...); };
 
} // namespace vctr::has
 
namespace vctr::detail
{
enum PlatformVectorOpPreference
{
    dontPreferIfIppAndAccelerateAreAvailable,
    preferIfIppAndAccelerateAreAvailable
};
 
template <PlatformVectorOpPreference pref>
concept isPreferredVectorOp = (Config::hasIPP && Config::platformApple && (pref == preferIfIppAndAccelerateAreAvailable)) ||
                              ((! (Config::hasIPP && Config::platformApple)) && (pref == dontPreferIfIppAndAccelerateAreAvailable));
} // namespace vctr::detail
 
namespace vctr::is
{
 
// clang-format off
 
template <class T>
concept anyVctr = detail::AnyVctr<std::remove_cvref_t<T>>::value;
 
template <class T, class V>
concept anyVctrWithValueType = anyVctr<T> && std::same_as<typename std::remove_cvref_t<T>::value_type, V>;
 
template <class T>
concept expression = has::getStorageInfo<T> && has::size<T> && has::isNotAliased<T> && ! anyVctr<T>;
 
template <class T, class V>
concept expressionWithValueType = expression<T> && std::same_as<typename std::remove_cvref_t<T>::value_type, V>;
 
template <class T>
concept expressionChainBuilder = detail::IsExpressionChainBuilder<std::remove_cvref_t<T>>::value;
 
template <class T>
concept anyVctrOrExpression = expression<std::remove_cvref_t<T>> || anyVctr<std::remove_cvref_t<T>>;
 
template <class T>
concept stdArray = detail::IsStdArray<T>::value;
 
template <class T>
concept stdSpan = detail::IsStdSpan<T>::value;
 
template <class T>
concept view = detail::IsSpan<T>::value || detail::IsStdSpan<T>::value;
 
//==============================================================================
template <class T, class DstType>
concept expressionWithEvalVectorOp = expression<T> && has::evalNextVectorOpInExpressionChain<T, DstType>;
 
//==============================================================================
template <class DstType, class... Sources>
concept suitableForAccelerateSSEOp = Config::platformApple && Config::archX64 && std::same_as<float, DstType> && (has::getSSE<Sources> && ...);
 
template <class DstType, class... Sources>
concept suitableForAccelerateNeonOp = Config::platformApple && Config::archARM && std::same_as<float, DstType> && (has::getNeon<Sources> && ...);
 
template <class Src, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForAccelerateRealFloatVectorOp = detail::isPreferredVectorOp<pref> && Config::platformApple && has::evalNextVectorOpInExpressionChain<Src, DstType> && realFloatNumber<DstType>;
 
template <class Src, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForAccelerateComplexFloatVectorOp = detail::isPreferredVectorOp<pref> && Config::platformApple && has::evalNextVectorOpInExpressionChain<Src, DstType> && complexFloatNumber<DstType>;
 
template <class Src, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForAccelerateRealOrComplexFloatVectorOp = detail::isPreferredVectorOp<pref> && Config::platformApple && has::evalNextVectorOpInExpressionChain<Src, DstType> && (realFloatNumber<DstType> || complexFloatNumber<DstType>);
 
template <class Src, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForAccelerateComplexToRealFloatVectorOp = detail::isPreferredVectorOp<pref> && Config::platformApple && anyVctr<Src> && complexFloatNumber<typename std::remove_cvref_t<Src>::value_type> && realFloatNumber<DstType>;
 
template <class Src, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForAccelerateRealIntToFloatVectorOp = detail::isPreferredVectorOp<pref> && Config::platformApple && has::evalNextVectorOpInExpressionChain<Src, typename std::remove_cvref_t<Src>::value_type> && realFloatNumber<DstType> && intNumber<typename std::remove_cvref_t<Src>::value_type>;
 
template <class Src, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForAccelerateRealFloatVectorReductionOp = detail::isPreferredVectorOp<pref> && Config::platformApple && has::data<Src> && realFloatNumber<DstType>;
//==============================================================================
template <class Src, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForIppRealFloatVectorOp = detail::isPreferredVectorOp<pref> && Config::hasIPP && has::evalNextVectorOpInExpressionChain<Src, DstType> && realFloatNumber<DstType>;
 
template <class Src, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForIppRealSingedInt32VectorOp = detail::isPreferredVectorOp<pref> && Config::hasIPP && has::evalNextVectorOpInExpressionChain<Src, DstType> && std::same_as<int32_t, DstType>;
 
template <class Src, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForIppComplexFloatVectorOp = detail::isPreferredVectorOp<pref> && Config::hasIPP && has::evalNextVectorOpInExpressionChain<Src, DstType> && complexFloatNumber<DstType>;
 
template <class Src, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForIppRealOrComplexFloatVectorOp = detail::isPreferredVectorOp<pref> && Config::hasIPP && has::evalNextVectorOpInExpressionChain<Src, DstType> && (realFloatNumber<DstType> || complexFloatNumber<DstType>);
 
template <class Src, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForIppComplexToRealFloatVectorOp = detail::isPreferredVectorOp<pref> && Config::hasIPP && anyVctr<Src> && complexFloatNumber<typename std::remove_cvref_t<Src>::value_type> && realFloatNumber<DstType>;
 
template <class Src, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForIppRealFloatVectorReductionOp = detail::isPreferredVectorOp<pref> && Config::hasIPP && has::data<Src> && realFloatNumber<DstType>;
 
template <class Src, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForIppRealOrComplexFloatVectorReductionOp = detail::isPreferredVectorOp<pref> && Config::hasIPP && has::data<Src> && (realFloatNumber<DstType> || complexFloatNumber<DstType>);
 
//==============================================================================
template <class SrcA, class SrcB, class DstType>
concept suitableForBinaryVectorOp = ((expressionWithEvalVectorOp < SrcA, DstType > && anyVctr < SrcB >) ||
                                     (anyVctr<SrcA> && expressionWithEvalVectorOp < SrcB, DstType >) ||
                                     (anyVctr<SrcA> && anyVctr<SrcB>)) &&
                                    std::same_as<typename std::remove_cvref_t<SrcA>::value_type, typename std::remove_cvref_t<SrcB>::value_type>;
 
//==============================================================================
template <class SrcA, class SrcB, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForAccelerateRealFloatBinaryVectorOp = detail::isPreferredVectorOp<pref> && Config::platformApple && suitableForBinaryVectorOp<SrcA, SrcB, DstType> && realFloatNumber<DstType>;
 
template <class SrcA, class SrcB, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForAccelerateComplexFloatBinaryVectorOp = detail::isPreferredVectorOp<pref> && Config::platformApple && suitableForBinaryVectorOp<SrcA, SrcB, DstType> && complexFloatNumber<DstType>;
 
template <class SrcA, class SrcB, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForAccelerateRealOrComplexComplexFloatBinaryVectorOp = detail::isPreferredVectorOp<pref> && Config::platformApple && suitableForBinaryVectorOp<SrcA, SrcB, DstType> && (realFloatNumber<DstType> || complexFloatNumber<DstType>);
 
//==============================================================================
template <class SrcA, class SrcB, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForIppRealFloatBinaryVectorOp = detail::isPreferredVectorOp<pref> && Config::hasIPP && suitableForBinaryVectorOp<SrcA, SrcB, DstType> && realFloatNumber<DstType>;
 
template <class SrcA, class SrcB, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForIppComplexFloatBinaryVectorOp = detail::isPreferredVectorOp<pref> && Config::hasIPP && suitableForBinaryVectorOp<SrcA, SrcB, DstType> && complexFloatNumber<DstType>;
 
template <class SrcA, class SrcB, class DstType, detail::PlatformVectorOpPreference pref = detail::preferIfIppAndAccelerateAreAvailable>
concept suitableForIppRealOrComplexComplexFloatBinaryVectorOp = detail::isPreferredVectorOp<pref> && Config::hasIPP && suitableForBinaryVectorOp<SrcA, SrcB, DstType> && (realFloatNumber<DstType> || complexFloatNumber<DstType>);
 
//==============================================================================
template <class T>
concept triviallyCopyableWithDataAndSize = has::sizeAndDataWithElementType<T, typename T::value_type> && has::constIndexOperator<T> && triviallyCopyable<typename T::value_type>;
 
template <class T>
concept iteratorCopyable = has::begin<T> && has::end<T> && ! triviallyCopyableWithDataAndSize<T>;
 
template <class T, class ElementType>
concept suitableInitializerForElementType = std::constructible_from<ElementType, std::remove_cvref_t<T>> && ! expression<T>;
 
template <class T>
concept suitableInitializerFunction = std::invocable<T, size_t> && ! std::same_as<void, std::invoke_result_t<T, size_t>>;
 
template <class T, class ElementType>
concept suitableInitializerFunctionForElementType = suitableInitializerFunction<T> && std::constructible_from<ElementType, std::invoke_result_t<T, size_t>>;
 
template <class T, class ElementType>
concept inputIteratorToConstructValuesOfType = std::input_iterator<T> && std::constructible_from<ElementType, std::iter_value_t<T>>;
 
template <class T, class ElementType>
concept contiguousIteratorWithValueTypeSameAs = std::contiguous_iterator<T> && std::same_as<ElementType, std::iter_value_t<T>>;
 
template <class T>
concept storageInfo = requires (const T& info, size_t a, bool b) { a = T::memberAlignment; b = info.dataIsSIMDAligned; b = info.hasSIMDExtendedStorage; };
 
template <class T>
concept reductionExpression = requires (const T& t, typename T::value_type v, size_t i) { v = T::reductionResultInitValue; t.reduceElementWise (v, i); };
 
// clang-format on
 
} // namespace vctr::is
 
namespace vctr::are
{
 
template <class... T>
concept noExpressionTemplates = (! is::expression<T> && ...);
 
} // namespace vctr::are