commit 8bce4e966727f5d396ca9bc8e198129078124cdc parent 6f56a0586076f41f86aef4450c38b78fa265e9d9 Author: [email protected] <[email protected]> Date: Thu, 3 Nov 2022 11:07:09 +0000 Fix cometa ambiguities Diffstat:
34 files changed, 305 insertions(+), 273 deletions(-)
diff --git a/include/kfr/base/basic_expressions.hpp b/include/kfr/base/basic_expressions.hpp @@ -1000,7 +1000,8 @@ struct expression_trace : public expression_with_traits<E> axis_params<VecAxis, N> sh) { const vec<value_type, N> in = get_elements(self.first(), index, sh); - println("[", fmt<'s', 16>(as_string(index)), "] = ", in); + println("[", fmt<'s', 16>(array_to_string(dims, index.data(), INT_MAX, INT_MAX, ",", "", "")), + "] = ", in); return in; } }; diff --git a/include/kfr/base/conversion.hpp b/include/kfr/base/conversion.hpp @@ -172,14 +172,14 @@ struct audio_sample_traits<f64> }; template <typename Tout, typename Tin, typename Tout_traits = audio_sample_traits<Tout>, - typename Tin_traits = audio_sample_traits<Tin>, KFR_ENABLE_IF(is_same<Tin, Tout>)> + typename Tin_traits = audio_sample_traits<Tin>, KFR_ENABLE_IF(std::is_same_v<Tin, Tout>)> inline Tout convert_sample(const Tin& in) { return in; } template <typename Tout, typename Tin, typename Tout_traits = audio_sample_traits<Tout>, - typename Tin_traits = audio_sample_traits<Tin>, KFR_ENABLE_IF(!is_same<Tin, Tout>)> + typename Tin_traits = audio_sample_traits<Tin>, KFR_ENABLE_IF(!std::is_same_v<Tin, Tout>)> inline Tout convert_sample(const Tin& in) { constexpr auto scale = Tout_traits::scale / Tin_traits::scale; diff --git a/include/kfr/base/expression.hpp b/include/kfr/base/expression.hpp @@ -756,9 +756,9 @@ static auto process(Out&& out, In&& in, shape<outdims> start = shape<outdims>(0) } template <typename Fn, typename... Args> -KFR_FUNCTION expression_function<decay<Fn>, Args...> bind_expression(Fn&& fn, Args&&... args) +KFR_FUNCTION expression_function<std::decay_t<Fn>, Args...> bind_expression(Fn&& fn, Args&&... args) { - return expression_function<decay<Fn>, Args...>(std::forward<Fn>(fn), std::forward<Args>(args)...); + return expression_function<std::decay_t<Fn>, Args...>(std::forward<Fn>(fn), std::forward<Args>(args)...); } /** * @brief Construct a new expression using the same function as in @c e and new arguments diff --git a/include/kfr/base/handle.hpp b/include/kfr/base/handle.hpp @@ -170,7 +170,7 @@ private: template <typename E> KFR_INTRINSIC std::shared_ptr<expression_resource> make_resource(E&& e) { - using T = expression_resource_impl<decay<E>>; + using T = expression_resource_impl<std::decay_t<E>>; return std::static_pointer_cast<expression_resource>(std::shared_ptr<T>( new (aligned_allocate<T>()) T(std::move(e)), [](T* pi) { aligned_deallocate<T>(pi); })); } @@ -273,7 +273,7 @@ namespace internal template <typename T, index_t Dims, typename E> KFR_INTRINSIC expression_vtable<T, Dims>* make_expression_vtable() { - static expression_vtable<T, Dims> vtable{ ctype_t<decay<E>>{} }; + static expression_vtable<T, Dims> vtable{ ctype_t<std::decay_t<E>>{} }; return &vtable; } } // namespace internal diff --git a/include/kfr/base/random.hpp b/include/kfr/base/random.hpp @@ -34,19 +34,19 @@ namespace kfr inline namespace CMT_ARCH_NAME { -template <typename T, size_t N, KFR_ENABLE_IF(is_integral<T>)> +template <typename T, size_t N, KFR_ENABLE_IF(std::is_integral_v<T>)> KFR_INTRINSIC vec<T, N> random_uniform(random_state& state) { return bitcast<T>(random_bits<N * sizeof(T)>(state)); } -template <typename T, size_t N, KFR_ENABLE_IF(is_same<T, f32>)> +template <typename T, size_t N, KFR_ENABLE_IF(std::is_same_v<T, f32>)> KFR_INTRINSIC vec<f32, N> randommantissa(random_state& state) { return bitcast<f32>((random_uniform<u32, N>(state) & u32(0x7FFFFFu)) | u32(0x3f800000u)) + 0.0f; } -template <typename T, size_t N, KFR_ENABLE_IF(is_same<T, f64>)> +template <typename T, size_t N, KFR_ENABLE_IF(std::is_same_v<T, f64>)> KFR_INTRINSIC vec<f64, N> randommantissa(random_state& state) { return bitcast<f64>((random_uniform<u64, N>(state) & u64(0x000FFFFFFFFFFFFFull)) | diff --git a/include/kfr/base/reduce.hpp b/include/kfr/base/reduce.hpp @@ -52,12 +52,12 @@ KFR_INTRINSIC T final_rootmean(T value, size_t size) } KFR_FN(final_rootmean) -template <typename FinalFn, typename T, KFR_ENABLE_IF(is_callable<FinalFn, T, size_t>)> +template <typename FinalFn, typename T, KFR_ENABLE_IF(std::is_invocable_v<FinalFn, T, size_t>)> KFR_INTRINSIC auto reduce_call_final(FinalFn&& finalfn, size_t size, T value) { return finalfn(value, size); } -template <typename FinalFn, typename T, KFR_ENABLE_IF(!is_callable<FinalFn, T, size_t>)> +template <typename FinalFn, typename T, KFR_ENABLE_IF(std::is_invocable_v<FinalFn, size_t>)> KFR_INTRINSIC auto reduce_call_final(FinalFn&& finalfn, size_t, T value) { return finalfn(value); @@ -121,17 +121,17 @@ protected: template <typename ReduceFn, typename TransformFn = fn_generic::pass_through, typename FinalFn = fn_generic::pass_through, typename E1, typename Tin = expression_value_type<E1>, - typename Twork = decay<decltype(std::declval<TransformFn>()(std::declval<Tin>()))>, - typename Tout = decay<decltype(reduce_call_final(std::declval<FinalFn>(), std::declval<size_t>(), - std::declval<Twork>()))>, + typename Twork = std::decay_t<decltype(std::declval<TransformFn>()(std::declval<Tin>()))>, + typename Tout = std::decay_t<decltype(reduce_call_final( + std::declval<FinalFn>(), std::declval<size_t>(), std::declval<Twork>()))>, KFR_ENABLE_IF(is_input_expression<E1>)> KFR_INTRINSIC Tout reduce(const E1& e1, ReduceFn&& reducefn, TransformFn&& transformfn = fn_generic::pass_through(), FinalFn&& finalfn = fn_generic::pass_through()) { static_assert(!is_infinite<E1>, "e1 must be a sized expression (use slice())"); - using reducer_t = expression_reduce<Tout, expression_dims<E1>, Twork, Tin, decay<ReduceFn>, - decay<TransformFn>, decay<FinalFn>>; + using reducer_t = expression_reduce<Tout, expression_dims<E1>, Twork, Tin, std::decay_t<ReduceFn>, + std::decay_t<TransformFn>, std::decay_t<FinalFn>>; reducer_t red(std::forward<ReduceFn>(reducefn), std::forward<TransformFn>(transformfn), std::forward<FinalFn>(finalfn)); process(red, e1); @@ -141,9 +141,9 @@ KFR_INTRINSIC Tout reduce(const E1& e1, ReduceFn&& reducefn, template <typename ReduceFn, typename TransformFn = fn_generic::pass_through, typename FinalFn = fn_generic::pass_through, typename E1, typename Tin = expression_value_type<E1>, - typename Twork = decay<decltype(std::declval<TransformFn>()(std::declval<Tin>()))>, - typename Tout = decay<decltype(reduce_call_final(std::declval<FinalFn>(), std::declval<size_t>(), - std::declval<Twork>()))>, + typename Twork = std::decay_t<decltype(std::declval<TransformFn>()(std::declval<Tin>()))>, + typename Tout = std::decay_t<decltype(reduce_call_final( + std::declval<FinalFn>(), std::declval<size_t>(), std::declval<Twork>()))>, KFR_ENABLE_IF(!is_input_expression<E1>)> KFR_INTRINSIC Tout reduce(const E1& e1, ReduceFn&& reducefn, TransformFn&& transformfn = fn_generic::pass_through(), diff --git a/include/kfr/base/univector.hpp b/include/kfr/base/univector.hpp @@ -56,9 +56,9 @@ struct abstract_vector : std::array<T, Size> }; template <typename T> -struct abstract_vector<T, tag_dynamic_vector> : std::vector<T, allocator<T>> +struct abstract_vector<T, tag_dynamic_vector> : std::vector<T, data_allocator<T>> { - using std::vector<T, allocator<T>>::vector; + using std::vector<T, data_allocator<T>>::vector; }; template <typename T> @@ -324,7 +324,7 @@ struct alignas(platform<>::maximum_vector_alignment) univector constexpr static bool is_array_ref = false; constexpr static bool is_vector = false; constexpr static bool is_aligned = true; - constexpr static bool is_pod = kfr::is_pod<T>; + constexpr static bool is_pod_like = kfr::is_pod_like<T>; using value_type = T; value_type get(size_t index, value_type fallback_value) const CMT_NOEXCEPT @@ -359,15 +359,18 @@ struct univector<T, tag_array_ref> : array_ref<T>, constexpr univector(univector<T, Tag>& other) : array_ref<T>(other.data(), other.size()) { } - template <typename U, univector_tag Tag, KFR_ENABLE_IF(is_same<remove_const<T>, U>&& is_const<T>)> + template <typename U, univector_tag Tag, + KFR_ENABLE_IF(std::is_same_v<std::remove_const_t<T>, U>&& std::is_const_v<T>)> constexpr univector(const univector<U, Tag>& other) : array_ref<T>(other.data(), other.size()) { } - template <typename U, univector_tag Tag, KFR_ENABLE_IF(is_same<remove_const<T>, U>&& is_const<T>)> + template <typename U, univector_tag Tag, + KFR_ENABLE_IF(std::is_same_v<std::remove_const_t<T>, U>&& std::is_const_v<T>)> constexpr univector(univector<U, Tag>& other) : array_ref<T>(other.data(), other.size()) { } - template <typename U, univector_tag Tag, KFR_ENABLE_IF(is_same<remove_const<T>, U>&& is_const<T>)> + template <typename U, univector_tag Tag, + KFR_ENABLE_IF(std::is_same_v<std::remove_const_t<T>, U>&& std::is_const_v<T>)> constexpr univector(univector<U, Tag>&& other) : array_ref<T>(other.data(), other.size()) { } @@ -377,7 +380,7 @@ struct univector<T, tag_array_ref> : array_ref<T>, constexpr static bool is_array_ref = true; constexpr static bool is_vector = false; constexpr static bool is_aligned = false; - using value_type = remove_const<T>; + using value_type = std::remove_const_t<T>; value_type get(size_t index, value_type fallback_value) const CMT_NOEXCEPT { @@ -390,10 +393,11 @@ struct univector<T, tag_array_ref> : array_ref<T>, template <typename T> struct univector<T, tag_dynamic_vector> - : std::vector<T, allocator<T>>, univector_base<T, univector<T, tag_dynamic_vector>, is_vec_element<T>> + : std::vector<T, data_allocator<T>>, + univector_base<T, univector<T, tag_dynamic_vector>, is_vec_element<T>> { - using std::vector<T, allocator<T>>::size; - using std::vector<T, allocator<T>>::vector; + using std::vector<T, data_allocator<T>>::size; + using std::vector<T, data_allocator<T>>::vector; using size_type = size_t; #if !defined CMT_COMPILER_MSVC || defined CMT_COMPILER_CLANG univector(univector& v) : univector(const_cast<const univector&>(v)) {} @@ -412,16 +416,21 @@ struct univector<T, tag_dynamic_vector> } this->assign_expr(std::forward<Input>(input)); } - constexpr univector() CMT_NOEXCEPT_SPEC(noexcept(std::vector<T, allocator<T>>())) = default; - constexpr univector(const std::vector<T, allocator<T>>& other) : std::vector<T, allocator<T>>(other) {} - constexpr univector(std::vector<T, allocator<T>>&& other) : std::vector<T, allocator<T>>(std::move(other)) + constexpr univector() CMT_NOEXCEPT_SPEC(noexcept(std::vector<T, data_allocator<T>>())) = default; + constexpr univector(const std::vector<T, data_allocator<T>>& other) + : std::vector<T, data_allocator<T>>(other) { } - constexpr univector(const array_ref<T>& other) : std::vector<T, allocator<T>>(other.begin(), other.end()) + constexpr univector(std::vector<T, data_allocator<T>>&& other) + : std::vector<T, data_allocator<T>>(std::move(other)) + { + } + constexpr univector(const array_ref<T>& other) + : std::vector<T, data_allocator<T>>(other.begin(), other.end()) { } constexpr univector(const array_ref<const T>& other) - : std::vector<T, allocator<T>>(other.begin(), other.end()) + : std::vector<T, data_allocator<T>>(other.begin(), other.end()) { } template <typename Allocator> diff --git a/include/kfr/cometa.hpp b/include/kfr/cometa.hpp @@ -31,8 +31,6 @@ namespace cometa using std::ptrdiff_t; using std::size_t; -#if __cplusplus >= 201103L || CMT_MSC_VER >= 1900 || CMT_HAS_FEATURE(cxx_constexpr) - template <typename T, size_t N> constexpr CMT_INTRINSIC static size_t arraysize(const T (&)[N]) CMT_NOEXCEPT { @@ -45,24 +43,13 @@ constexpr CMT_INTRINSIC static std::integral_constant<size_t, N> carraysize(cons return {}; } -#define CMT_ARRAYSIZE(arr) decltype(carraysize(arr))::value -#elif CMT_COMPILER_MSVC -#define CMT_ARRAYSIZE(arr) _countof(arr) -#elif __cplusplus >= 199711L && \ - (defined(__INTEL_COMPILER) || defined(__clang__) || \ - (defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)))) -template <typename T, size_t N> -char (&COUNTOF_REQUIRES_ARRAY_ARGUMENT(T (&)[N]))[N]; -#define CMT_ARRAYSIZE(x) sizeof(COUNTOF_REQUIRES_ARRAY_ARGUMENT(x)) -#else -#define CMT_ARRAYSIZE(arr) sizeof(arr) / sizeof(arr[0]) -#endif - using pvoid = void*; using pconstvoid = const void*; +#ifdef CMT_CPP17_DEFINITIONS template <typename...> using void_t = void; +#endif namespace details { @@ -81,12 +68,13 @@ constexpr CMT_INTRINSIC bool args_and(bool x, Ts... rest) } template <typename T, typename Enable = void> -struct is_pod_impl : std::false_type +struct is_pod_like_impl : std::false_type { }; template <typename T> -struct is_pod_impl<T, void_t<decltype(T::is_pod)>> : std::integral_constant<bool, T::is_pod> +struct is_pod_like_impl<T, std::void_t<decltype(T::is_pod_like)>> + : std::integral_constant<bool, T::is_pod_like> { }; @@ -114,6 +102,7 @@ struct and_t_impl<T, Ts...> : std::integral_constant<bool, T::value && and_t_imp constexpr size_t max_size_t = size_t(-1); +#ifdef CMT_CPP17_DEFINITIONS template <typename... T> using common_type = typename std::common_type<T...>::type; @@ -149,12 +138,6 @@ using remove_const = typename std::remove_const<T>::type; template <typename T> using underlying_type = typename std::underlying_type<T>::type; -template <typename T1, typename T2> -using or_type = std::conditional_t<std::is_same_v<T1, void>, T2, T1>; - -template <typename T> -constexpr inline bool is_pod = std::is_pod<T>::value || details::is_pod_impl<T>::value; - template <typename T> constexpr inline bool is_class = std::is_class<T>::value; @@ -203,10 +186,18 @@ constexpr inline bool is_template_arg = std::is_integral<T>::value || std::is_en template <typename T> using decay = typename std::decay<T>::type; +#endif + +template <typename T1, typename T2> +using or_type = std::conditional_t<std::is_same_v<T1, void>, T2, T1>; + +template <typename T> +constexpr inline bool is_pod_like = std::is_pod_v<T> || details::is_pod_like_impl<T>::value; + template <typename T1, typename T2 = void, typename... Ts> constexpr size_t typeindex() { - return is_same<T1, T2>() ? 0 : 1 + typeindex<T1, Ts...>(); + return std::is_same_v<T1, T2>() ? 0 : 1 + typeindex<T1, Ts...>(); } template <typename T> @@ -235,11 +226,11 @@ constexpr size_t widthof(T) template <typename T> constexpr size_t widthof() { - return compound_type_traits<decay<T>>::width; + return compound_type_traits<std::decay_t<T>>::width; } template <typename T> -constexpr inline bool is_compound = !compound_type_traits<decay<T>>::is_scalar; +constexpr inline bool is_compound_type = !compound_type_traits<std::decay_t<T>>::is_scalar; template <typename T> using subtype = typename compound_type_traits<T>::subtype; @@ -247,13 +238,6 @@ using subtype = typename compound_type_traits<T>::subtype; template <typename T> using deep_subtype = typename compound_type_traits<T>::deep_subtype; -/*template <typename T, typename SubType> -using rebind_subtype = typename compound_type_traits<T>::template rebind<SubType>; - -template <typename T, typename SubType> -using deep_rebind = typename compound_type_traits<T>::template deep_rebind<SubType>; - */ - template <typename T> struct compound_type_traits<std::pair<T, T>> { @@ -328,7 +312,7 @@ struct is_inheritable_impl : std::false_type }; template <typename T> -struct is_inheritable_impl<T, void_t<inherit<T>>> : std::true_type +struct is_inheritable_impl<T, std::void_t<inherit<T>>> : std::true_type { }; @@ -578,6 +562,7 @@ struct concat_impl<T1, T2, T3, Ts...> using type = typename concat_impl<typename concat_impl<T1, T2>::type, T3, Ts...>::type; }; +#ifdef CMT_CPP17_DEFINITIONS template <typename Fn, typename Args, typename enable = void> struct is_invocable_impl : std::false_type { @@ -598,12 +583,14 @@ template <typename Ret, typename Fn, typename... Args> struct is_invocable_r_impl<Ret, Fn, ctypes_t<Args...>, void_t<decltype(std::declval<Fn>()(std::declval<Args>()...))>> { - static constexpr bool value = is_convertible<decltype(std::declval<Fn>()(std::declval<Args>()...)), Ret>; + static constexpr bool value = + std::is_convertible_v<decltype(std::declval<Fn>()(std::declval<Args>()...)), Ret>; }; +#endif } // namespace details template <typename T1, typename... Ts> -using concat_lists = typename details::concat_impl<decay<T1>, decay<Ts>...>::type; +using concat_lists = typename details::concat_impl<std::decay_t<T1>, std::decay_t<Ts>...>::type; template <typename T1, typename... Ts> constexpr CMT_INTRINSIC concat_lists<T1, Ts...> cconcat(T1, Ts...) @@ -611,6 +598,7 @@ constexpr CMT_INTRINSIC concat_lists<T1, Ts...> cconcat(T1, Ts...) return {}; } +#ifdef CMT_CPP17_DEFINITIONS #ifdef __cpp_lib_is_invocable template <typename Fn, typename... Args> constexpr inline bool is_invocable = std::is_invocable<Fn, Args...>::value; @@ -624,6 +612,7 @@ constexpr inline bool is_invocable = details::is_invocable_impl<Fn, ctypes_t<Arg template <typename Ret, typename Fn, typename... Args> constexpr inline bool is_invocable_r = details::is_invocable_r_impl<Ret, Fn, ctypes_t<Args...>>::value; #endif +#endif namespace details { @@ -665,7 +654,7 @@ template <typename T, T value, T... values, bool flag, bool... flags> struct filter_impl<cvals_t<T, value, values...>, cvals_t<bool, flag, flags...>> { using filtered = typename filter_impl<cvals_t<T, values...>, cvals_t<bool, flags...>>::type; - using type = conditional<flag, concat_lists<cvals_t<T, value>, filtered>, filtered>; + using type = std::conditional_t<flag, concat_lists<cvals_t<T, value>, filtered>, filtered>; }; } // namespace details @@ -676,7 +665,7 @@ template <typename Fn> using function_result = typename details::function_arguments_impl<decltype(&Fn::operator())>::result; template <typename T1, typename T2> -using cfilter_t = typename details::filter_impl<decay<T1>, decay<T2>>::type; +using cfilter_t = typename details::filter_impl<std::decay_t<T1>, std::decay_t<T2>>::type; template <typename T, T... vals, bool... flags, typename Ret = cfilter_t<cvals_t<T, vals...>, cvals_t<bool, flags...>>> @@ -818,34 +807,35 @@ constexpr CMT_INTRINSIC auto scale() CMT_NOEXCEPT namespace details { -template <typename Ret, typename T, typename enable = void_t<>> +template <typename Ret, typename T, typename enable = std::void_t<>> struct is_returning_type_impl : std::false_type { }; template <typename Ret, typename Fn, typename... Args> -struct is_returning_type_impl<Ret, Fn(Args...), void_t<invoke_result<Fn, Args...>>> - : std::is_same<Ret, invoke_result<Fn, Args...>> +struct is_returning_type_impl<Ret, Fn(Args...), std::void_t<std::invoke_result_t<Fn, Args...>>> + : std::is_same<Ret, std::invoke_result_t<Fn, Args...>> { }; -template <typename Fn, typename Args, typename enable = void_t<>> +template <typename Fn, typename Args, typename enable = std::void_t<>> struct is_callable_impl : std::false_type { }; template <typename Fn, typename... Args> -struct is_callable_impl<Fn, ctypes_t<Args...>, void_t<invoke_result<Fn, Args...>>> : std::true_type +struct is_callable_impl<Fn, ctypes_t<Args...>, std::void_t<std::invoke_result_t<Fn, Args...>>> + : std::true_type { }; -template <typename T, typename enable = void_t<>> +template <typename T, typename enable = std::void_t<>> struct is_enabled_impl : std::true_type { }; template <typename Fn> -struct is_enabled_impl<Fn, void_t<decltype(Fn::disabled)>> : std::integral_constant<bool, !Fn::disabled> +struct is_enabled_impl<Fn, std::void_t<decltype(Fn::disabled)>> : std::integral_constant<bool, !Fn::disabled> { }; @@ -876,21 +866,25 @@ struct unique_enum_impl template <typename T> constexpr inline bool is_enabled = details::is_enabled_impl<T>::value; +#ifdef CMT_CPP17_DEFINITIONS + template <typename Fn, typename... Args> constexpr inline bool is_callable = details::is_callable_impl<Fn, ctypes_t<Args...>>::value; template <typename Ret, typename T> constexpr inline bool is_returning_type = details::is_returning_type_impl<Ret, T>::value; +#endif + namespace details { -template <typename Fn, CMT_ENABLE_IF(is_callable<Fn()>)> +template <typename Fn, CMT_ENABLE_IF(std::is_invocable_v<Fn>)> CMT_INTRINSIC auto call_if_callable(Fn&& fn) { return fn(); } -template <typename Fn, CMT_ENABLE_IF(!is_callable<Fn()>)> +template <typename Fn, CMT_ENABLE_IF(!std::is_invocable_v<Fn>)> CMT_INTRINSIC auto call_if_callable(Fn&& fn) { return std::forward<Fn>(fn); @@ -1004,9 +998,9 @@ namespace details { template <typename T> -constexpr inline char typekind = is_floating_point<T> ? 'f' - : is_integral<T> ? (is_unsigned<T> ? 'u' : 'i') - : '?'; +constexpr inline char typekind = std::is_floating_point_v<T> ? 'f' + : std::is_integral_v<T> ? (std::is_unsigned_v<T> ? 'u' : 'i') + : '?'; template <char kind, size_t bits> struct bits_to_type_impl; @@ -1079,8 +1073,9 @@ struct findinttype_impl template <int64_t min, int64_t max, typename T, typename... Types> struct findinttype_impl<min, max, T, Types...> { - using type = conditional<(std::numeric_limits<T>::min() <= min && std::numeric_limits<T>::max() >= max), - T, typename findinttype_impl<min, max, Types...>::type>; + using type = + std::conditional_t<(std::numeric_limits<T>::min() <= min && std::numeric_limits<T>::max() >= max), T, + typename findinttype_impl<min, max, Types...>::type>; }; template <int64_t min, int64_t max> struct findinttype_impl<min, max> @@ -1106,10 +1101,10 @@ using findinttype = typename details::findinttype_impl<min, max, uint8_t, int8_t int32_t, uint64_t, int64_t>::type; template <typename T> -constexpr inline bool is_number = details::is_number_impl<decay<T>>::value; +constexpr inline bool is_number = details::is_number_impl<std::decay_t<T>>::value; template <typename... Ts> -constexpr inline bool is_numbers = (details::is_number_impl<decay<Ts>>::value && ...); +constexpr inline bool is_numbers = (details::is_number_impl<std::decay_t<Ts>>::value && ...); /// @brief Check if the type argument is a number or a vector of numbers template <typename T> @@ -1162,7 +1157,7 @@ struct carray<T, 1> CMT_MEM_INTRINSIC constexpr carray() CMT_NOEXCEPT = default; CMT_MEM_INTRINSIC constexpr carray(T val) CMT_NOEXCEPT : val(val) {} - template <typename Fn, size_t index = 0, CMT_ENABLE_IF(is_callable<Fn, csize_t<index>>)> + template <typename Fn, size_t index = 0, CMT_ENABLE_IF(std::is_invocable_v<Fn, csize_t<index>>)> CMT_MEM_INTRINSIC constexpr carray(Fn&& fn, csize_t<index> = csize_t<index>{}) CMT_NOEXCEPT : val(static_cast<T>(fn(csize_t<index>()))) { @@ -1401,7 +1396,8 @@ struct has_begin_end_impl : std::false_type }; template <typename T> -struct has_begin_end_impl<T, void_t<decltype(std::declval<T>().begin()), decltype(std::declval<T>().end())>> +struct has_begin_end_impl<T, + std::void_t<decltype(std::declval<T>().begin()), decltype(std::declval<T>().end())>> : std::true_type { }; @@ -1412,7 +1408,7 @@ struct has_value_type_impl : std::false_type }; template <typename T> -struct has_value_type_impl<T, void_t<typename T::value_type>> : std::true_type +struct has_value_type_impl<T, std::void_t<typename T::value_type>> : std::true_type { }; @@ -1422,7 +1418,8 @@ struct has_data_size_impl : std::false_type }; template <typename T> -struct has_data_size_impl<T, void_t<decltype(std::declval<T>().size()), decltype(std::declval<T>().data())>> +struct has_data_size_impl<T, + std::void_t<decltype(std::declval<T>().size()), decltype(std::declval<T>().data())>> : std::true_type { }; @@ -1434,20 +1431,20 @@ struct value_type_impl }; template <typename T, typename Fallback> -struct value_type_impl<T, Fallback, void_t<typename T::value_type>> +struct value_type_impl<T, Fallback, std::void_t<typename T::value_type>> { using type = typename T::value_type; }; } // namespace details template <typename T> -constexpr inline bool has_begin_end = details::has_begin_end_impl<decay<T>>::value; +constexpr inline bool has_begin_end = details::has_begin_end_impl<std::decay_t<T>>::value; template <typename T> -constexpr inline bool has_data_size = details::has_data_size_impl<decay<T>>::value; +constexpr inline bool has_data_size = details::has_data_size_impl<std::decay_t<T>>::value; template <typename T> -using value_type_of = typename decay<T>::value_type; +using value_type_of = typename std::decay_t<T>::value_type; #ifndef CMT_COMPILER_CLANG namespace details @@ -1633,7 +1630,7 @@ template <typename T, typename Fn1, typename Fn2, typename... Fns> CMT_INTRINSIC decltype(auto) cmatch_impl(T&& value, Fn1&& first, Fn2&& second, Fns&&... rest) { using first_arg = typename function_arguments<Fn1>::template nth<0>; - constexpr bool is_same = cometa::is_same<decay<T>, decay<first_arg>>; + constexpr bool is_same = std::is_same_v<std::decay_t<T>, std::decay_t<first_arg>>; return cmatch_impl2(cbool_t<is_same>(), std::forward<T>(value), std::forward<Fn1>(first), std::forward<Fn2>(second), std::forward<Fns>(rest)...); } @@ -1665,7 +1662,7 @@ CMT_INTRINSIC size_t cfind(cvals_t<T, values...>, identity<T> value) } template <typename Fn, typename... Args> -CMT_UNUSED CMT_NOINLINE static invoke_result<Fn, Args...> noinline(Fn&& fn, Args&&... args) +CMT_UNUSED CMT_NOINLINE static std::invoke_result_t<Fn, Args...> noinline(Fn&& fn, Args&&... args) { return fn(std::forward<Args>(args)...); } @@ -1674,7 +1671,7 @@ template <typename Fn> struct fn_noinline { template <typename... Args> - CMT_MEM_INTRINSIC invoke_result<Fn, Args...> operator()(Args&&... args) const + CMT_MEM_INTRINSIC std::invoke_result_t<Fn, Args...> operator()(Args&&... args) const { return noinline(Fn{}, std::forward<Args>(args)...); } @@ -1706,12 +1703,12 @@ constexpr CMT_INTRINSIC T choose_const_fallback(C1 c1) * CHECK( choose_const<f64>( 32.0f, 64.0 ) == 64.0 ); * @endcode */ -template <typename T, typename C1, typename... Cs, CMT_ENABLE_IF(is_same<T, C1>)> +template <typename T, typename C1, typename... Cs, CMT_ENABLE_IF(std::is_same_v<T, C1>)> constexpr CMT_INTRINSIC T choose_const(C1 c1, Cs...) { return static_cast<T>(c1); } -template <typename T, typename C1, typename... Cs, CMT_ENABLE_IF(!is_same<T, C1>)> +template <typename T, typename C1, typename... Cs, CMT_ENABLE_IF(!std::is_same_v<T, C1>)> constexpr CMT_INTRINSIC T choose_const(C1, Cs... constants) { return choose_const<T>(constants...); @@ -1720,7 +1717,7 @@ constexpr CMT_INTRINSIC T choose_const(C1, Cs... constants) template <typename T, typename C1, typename... Cs> constexpr CMT_INTRINSIC T choose_const_fallback(C1 c1, Cs... constants) { - return is_same<T, C1> ? static_cast<T>(c1) : choose_const_fallback<T>(constants...); + return std::is_same_v<T, C1> ? static_cast<T>(c1) : choose_const_fallback<T>(constants...); } template <typename Tfrom> @@ -1750,7 +1747,7 @@ struct signed_type_impl using type = T; }; template <typename T> -struct signed_type_impl<T, void_t<enable_if<is_unsigned<T>>>> +struct signed_type_impl<T, std::void_t<std::enable_if_t<std::is_unsigned_v<T>>>> { using type = findinttype<std::numeric_limits<T>::min(), std::numeric_limits<T>::max()>; }; diff --git a/include/kfr/cometa/array.hpp b/include/kfr/cometa/array.hpp @@ -102,14 +102,14 @@ inline array_ref<T> make_array_ref(T* data, std::size_t size) } template <typename Container, CMT_ENABLE_IF(has_data_size<Container>), - typename T = remove_pointer<decltype(std::declval<Container>().data())>> + typename T = std::remove_pointer_t<decltype(std::declval<Container>().data())>> inline array_ref<T> make_array_ref(Container& cont) { return array_ref<T>(cont.data(), cont.size()); } template <typename Container, CMT_ENABLE_IF(has_data_size<Container>), - typename T = remove_pointer<decltype(std::declval<Container>().data())>> + typename T = std::remove_pointer_t<decltype(std::declval<Container>().data())>> inline array_ref<const T> make_array_ref(const Container& cont) { return array_ref<const T>(cont.data(), cont.size()); diff --git a/include/kfr/cometa/function.hpp b/include/kfr/cometa/function.hpp @@ -94,9 +94,9 @@ struct function<R(Args...)> function(std::nullptr_t) noexcept {} - template <typename Fn, - typename = enable_if<is_invocable_r<R, Fn, Args...> && !is_same<decay<Fn>, function>>> - function(Fn fn) : impl(new details::function_impl<decay<Fn>, R, Args...>(std::move(fn))) + template <typename Fn, typename = std::enable_if_t<std::is_invocable_r_v<R, Fn, Args...> && + !std::is_same_v<std::decay_t<Fn>, function>>> + function(Fn fn) : impl(new details::function_impl<std::decay_t<Fn>, R, Args...>(std::move(fn))) { } diff --git a/include/kfr/cometa/memory.hpp b/include/kfr/cometa/memory.hpp @@ -188,13 +188,13 @@ struct autofree #ifdef KFR_USE_STD_ALLOCATION template <typename T> -using allocator = std::allocator<T>; +using data_allocator = std::allocator<T>; #else /// @brief Aligned allocator template <typename T> -struct allocator +struct data_allocator { using value_type = T; using pointer = T*; @@ -207,12 +207,12 @@ struct allocator template <typename U> struct rebind { - using other = allocator<U>; + using other = data_allocator<U>; }; - constexpr allocator() CMT_NOEXCEPT = default; - constexpr allocator(const allocator&) CMT_NOEXCEPT = default; + constexpr data_allocator() CMT_NOEXCEPT = default; + constexpr data_allocator(const data_allocator&) CMT_NOEXCEPT = default; template <typename U> - constexpr allocator(const allocator<U>&) CMT_NOEXCEPT + constexpr data_allocator(const data_allocator<U>&) CMT_NOEXCEPT { } pointer allocate(size_type n) const @@ -226,12 +226,12 @@ struct allocator }; template <typename T1, typename T2> -constexpr inline bool operator==(const allocator<T1>&, const allocator<T2>&) CMT_NOEXCEPT +constexpr inline bool operator==(const data_allocator<T1>&, const data_allocator<T2>&) CMT_NOEXCEPT { return true; } template <typename T1, typename T2> -constexpr inline bool operator!=(const allocator<T1>&, const allocator<T2>&) CMT_NOEXCEPT +constexpr inline bool operator!=(const data_allocator<T1>&, const data_allocator<T2>&) CMT_NOEXCEPT { return false; } @@ -269,4 +269,4 @@ public: \ private: \ mutable std::atomic_uintptr_t m_refcount = ATOMIC_VAR_INIT(0); -} // namespace cometa -\ No newline at end of file +} // namespace cometa diff --git a/include/kfr/cometa/numeric.hpp b/include/kfr/cometa/numeric.hpp @@ -113,21 +113,21 @@ enum class datatype : int constexpr inline datatype operator|(datatype x, datatype y) { - using type = underlying_type<datatype>; + using type = std::underlying_type_t<datatype>; return static_cast<datatype>(static_cast<type>(x) | static_cast<type>(y)); } constexpr inline datatype operator&(datatype x, datatype y) { - using type = underlying_type<datatype>; + using type = std::underlying_type_t<datatype>; return static_cast<datatype>(static_cast<type>(x) & static_cast<type>(y)); } template <typename T> constexpr inline datatype typeclass = - is_floating_point<typename compound_type_traits<T>::subtype> ? datatype::f - : is_integral<typename compound_type_traits<T>::subtype> - ? (is_unsigned<typename compound_type_traits<T>::subtype> ? datatype::u : datatype::i) + std::is_floating_point_v<typename compound_type_traits<T>::subtype> ? datatype::f + : std::is_integral_v<typename compound_type_traits<T>::subtype> + ? (std::is_unsigned_v<typename compound_type_traits<T>::subtype> ? datatype::u : datatype::i) : datatype(); template <typename T> @@ -156,7 +156,7 @@ using utype = typename compound_type_traits<T>::template deep_rebind<unsigned_type<typebits<deep_subtype<T>>::bits>>; template <typename T> -using uitype = conditional<is_i_class<deep_subtype<T>>, T, utype<T>>; +using uitype = std::conditional_t<is_i_class<deep_subtype<T>>, T, utype<T>>; template <typename T> using fsubtype = ftype<subtype<T>>; @@ -169,7 +169,7 @@ namespace details template <typename T> struct flt_type_impl { - using type = conditional<sizeof(T) <= 2, float, fbase>; + using type = std::conditional_t<sizeof(T) <= 2, float, fbase>; }; template <> diff --git a/include/kfr/cometa/string.hpp b/include/kfr/cometa/string.hpp @@ -237,7 +237,7 @@ CMT_INLINE const std::string& build_fmt(const std::string& str, ctypes_t<>) { re template <typename Arg, typename... Args> CMT_INLINE auto build_fmt(const std::string& str, ctypes_t<Arg, Args...>) { - constexpr auto fmt = value_fmt(ctype_t<decay<Arg>>()); + constexpr auto fmt = value_fmt(ctype_t<std::decay_t<Arg>>()); return build_fmt(replace_one(str, "{}", std::string(fmt.data())), ctypes_t<Args...>()); } } // namespace details @@ -270,7 +270,7 @@ constexpr auto build_fmt_str(cchars_t<>, ctypes_t<>) { return make_cstring(""); template <char... chars, typename Arg, typename... Args> constexpr auto build_fmt_str(cchars_t<'@', chars...>, ctypes_t<Arg, Args...>) { - return concat_cstring(details::value_fmt(ctype_t<decay<Arg>>()), + return concat_cstring(details::value_fmt(ctype_t<std::decay_t<Arg>>()), build_fmt_str(cchars_t<chars...>(), ctypes_t<Args...>())); } @@ -372,7 +372,7 @@ namespace details template <typename T> constexpr auto get_value_fmt() { - return details::value_fmt(ctype_t<decay<repr_type<T>>>()); + return details::value_fmt(ctype_t<std::decay_t<repr_type<T>>>()); } } // namespace details diff --git a/include/kfr/dft/impl/dft-impl.hpp b/include/kfr/dft/impl/dft-impl.hpp @@ -477,9 +477,9 @@ void prepare_dft_stage(dft_plan<T>* self, size_t radix, size_t iterations, size_ dft_radices, radix, [self, iterations, blocks](auto radix) CMT_INLINE_LAMBDA { - add_stage<conditional<is_final, intrinsics::dft_stage_fixed_final_impl<T, val_of(radix)>, - intrinsics::dft_stage_fixed_impl<T, val_of(radix)>>>(self, radix, - iterations, blocks); + add_stage<std::conditional_t<is_final, intrinsics::dft_stage_fixed_final_impl<T, val_of(radix)>, + intrinsics::dft_stage_fixed_impl<T, val_of(radix)>>>( + self, radix, iterations, blocks); }, [self, radix, iterations, blocks]() { add_stage<intrinsics::dft_stage_generic_impl<T, is_final>>(self, radix, iterations, blocks); }); diff --git a/include/kfr/dft/impl/fft-impl.hpp b/include/kfr/dft/impl/fft-impl.hpp @@ -515,7 +515,7 @@ struct fft_final_stage_impl : dft_stage<T> final_stage<inverse>(csize<size>, 1, cbool<splitin>, out, in, twiddle); } - template <bool inverse, typename U = T, KFR_ENABLE_IF(is_same<U, float>)> + template <bool inverse, typename U = T, KFR_ENABLE_IF(std::is_same_v<U, float>)> KFR_MEM_INTRINSIC void final_stage(csize_t<32>, size_t invN, cfalse_t, complex<T>* out, const complex<T>*, const complex<T>*& twiddle) { @@ -523,7 +523,7 @@ struct fft_final_stage_impl : dft_stage<T> cbool_t<prefetch>(), cbool_t<inverse>(), cbool_t<aligned>(), out, out, twiddle); } - template <bool inverse, typename U = T, KFR_ENABLE_IF(is_same<U, float>)> + template <bool inverse, typename U = T, KFR_ENABLE_IF(std::is_same_v<U, float>)> KFR_MEM_INTRINSIC void final_stage(csize_t<16>, size_t invN, cfalse_t, complex<T>* out, const complex<T>*, const complex<T>*& twiddle) { diff --git a/include/kfr/dsp/biquad.hpp b/include/kfr/dsp/biquad.hpp @@ -62,9 +62,9 @@ struct biquad_params b2(static_cast<T>(bq.b2)) { } - constexpr static bool is_pod = true; + constexpr static bool is_pod_like = true; - static_assert(is_floating_point<T>, "T must be a floating point type"); + static_assert(std::is_floating_point_v<T>, "T must be a floating point type"); constexpr biquad_params() CMT_NOEXCEPT : a0(1), a1(0), a2(0), b0(1), b1(0), b2(0) {} constexpr biquad_params(T a0, T a1, T a2, T b0, T b1, T b2) CMT_NOEXCEPT : a0(a0), a1(a1), diff --git a/include/kfr/graphics/color.hpp b/include/kfr/graphics/color.hpp @@ -40,7 +40,8 @@ struct color using vec_type = vec<T, 4>; - static_assert(is_floating_point<T> || is_same<T, uint8_t> || is_same<T, uint16_t>, "Incorrect type"); + static_assert(std::is_floating_point_v<T> || std::is_same_v<T, uint8_t> || std::is_same_v<T, uint16_t>, + "Incorrect type"); constexpr color(int) = delete; constexpr explicit color(T grey, T alpha = maximum) : v(grey, grey, grey, alpha) {} @@ -78,7 +79,7 @@ struct color constexpr T lightness() const { - using Tcommon = conditional<is_floating_point<T>, T, findinttype<min * 3, max * 3>>; + using Tcommon = std::conditional_t<std::is_floating_point_v<T>, T, findinttype<min * 3, max * 3>>; return (Tcommon(r) + g + b) / 3; } diff --git a/include/kfr/io/file.hpp b/include/kfr/io/file.hpp @@ -126,7 +126,10 @@ struct abstract_reader : abstract_stream<T> this->read(result); return result; } - bool read(conditional<is_void<T>, internal_generic::empty, T>& data) { return read(&data, 1) == 1; } + bool read(std::conditional_t<std::is_void_v<T>, internal_generic::empty, T>& data) + { + return read(&data, 1) == 1; + } }; /// @brief Base class for all typed writers @@ -141,7 +144,7 @@ struct abstract_writer : abstract_stream<T> return write(data.data(), data.size()); } size_t write(univector_ref<const T>&& data) { return write(data.data(), data.size()); } - bool write(const conditional<is_void<T>, internal_generic::empty, T>& data) + bool write(const std::conditional_t<std::is_void_v<T>, internal_generic::empty, T>& data) { return write(&data, 1) == 1; } diff --git a/include/kfr/io/python_plot.hpp b/include/kfr/io/python_plot.hpp @@ -69,12 +69,12 @@ void python(const std::string& name, const std::string& code) } CMT_PRAGMA_GNU(GCC diagnostic pop) -template <typename T, KFR_ENABLE_IF(is_floating_point<T>)> +template <typename T, KFR_ENABLE_IF(std::is_floating_point_v<T>)> inline T flush_to_zero(T value) { return std::isfinite(value) ? value : 0; } -template <typename T, KFR_ENABLE_IF(!is_floating_point<T>)> +template <typename T, KFR_ENABLE_IF(!std::is_floating_point_v<T>)> inline T flush_to_zero(T value) { return static_cast<double>(value); diff --git a/include/kfr/simd/complex.hpp b/include/kfr/simd/complex.hpp @@ -212,7 +212,7 @@ constexpr inline vec<T, 2> vcomplex(const complex<T>& v) template <typename T> constexpr inline simd<T, 2> vvcomplex(const complex<T>& v) { - return intrinsics::simd_make(ctype<T>, v.real(), v.imag()); + return intrinsics::simd_make(cometa::ctype<T>, v.real(), v.imag()); } } // namespace intrinsics @@ -326,8 +326,8 @@ struct is_complex_impl<complex<T>> : std::true_type template <typename To, typename From, size_t N, conv_t conv> struct conversion<1, 1, vec<complex<To>, N>, vec<complex<From>, N>, conv> { - static_assert(!is_compound<To>, ""); - static_assert(!is_compound<From>, ""); + static_assert(!is_compound_type<To>, ""); + static_assert(!is_compound_type<From>, ""); static vec<complex<To>, N> cast(const vec<complex<From>, N>& value) { return vec<To, N * 2>(value.flatten()).v; @@ -338,8 +338,8 @@ struct conversion<1, 1, vec<complex<To>, N>, vec<complex<From>, N>, conv> template <typename To, typename From, size_t N, conv_t conv> struct conversion<1, 1, vec<complex<To>, N>, vec<From, N>, conv> { - static_assert(!is_compound<To>, ""); - static_assert(!is_compound<From>, ""); + static_assert(!is_compound_type<To>, ""); + static_assert(!is_compound_type<From>, ""); static vec<complex<To>, N> cast(const vec<From, N>& value) { const vec<To, N> casted = static_cast<vec<To, N>>(value); diff --git a/include/kfr/simd/complex_type.hpp b/include/kfr/simd/complex_type.hpp @@ -50,8 +50,8 @@ template <typename T> struct complex { static_assert(is_simd_type<T>, "Incorrect type for complex"); - constexpr static bool is_pod = true; - constexpr complex() CMT_NOEXCEPT = default; + constexpr static bool is_pod_like = true; + constexpr complex() CMT_NOEXCEPT = default; KFR_MEM_INTRINSIC constexpr complex(T re) CMT_NOEXCEPT : re(re), im(0) {} KFR_MEM_INTRINSIC constexpr complex(T re, T im) CMT_NOEXCEPT : re(re), im(im) {} constexpr complex(const complex&) CMT_NOEXCEPT = default; diff --git a/include/kfr/simd/impl/backend_generic.hpp b/include/kfr/simd/impl/backend_generic.hpp @@ -1144,7 +1144,7 @@ KFR_INTRINSIC simd<Tout, N> simd_allones() CMT_NOEXCEPT template <typename Tout, typename Tin, size_t N, size_t Nout = (sizeof(Tin) * N / sizeof(Tout)) #ifdef _MSC_VER , - KFR_ENABLE_IF((Nout == 1 || N == 1) && !is_same<Tout, Tin>) + KFR_ENABLE_IF((Nout == 1 || N == 1) && !std::is_same_v<Tout, Tin>) #else , KFR_ENABLE_IF(Nout == 1 || N == 1) @@ -1160,7 +1160,7 @@ KFR_INTRINSIC simd<Tout, Nout> simd_bitcast(simd_cvt_t<Tout, Tin, N>, const simd template <typename Tout, typename Tin, size_t N, size_t Nout = (sizeof(Tin) * N / sizeof(Tout)) #ifdef _MSC_VER , - KFR_ENABLE_IF(Nout > 1 && N > 1 && !is_same<Tout, Tin>) + KFR_ENABLE_IF(Nout > 1 && N > 1 && !std::is_same_v<Tout, Tin>) #else , KFR_ENABLE_IF(Nout > 1 && N > 1) @@ -1220,7 +1220,8 @@ KFR_INTRINSIC const simd<T, N2>& simd_shuffle(simd2_t<T, N1, N2>, const simd<T, // concat() template <typename T, size_t N, - KFR_ENABLE_IF(is_poweroftwo(N) && is_same<simd<T, N + N>, simd_halves<unwrap_bit<T>, N + N>>)> + KFR_ENABLE_IF(is_poweroftwo(N) && + std::is_same_v<simd<T, N + N>, simd_halves<unwrap_bit<T>, N + N>>)> KFR_INTRINSIC simd<T, N + N> simd_shuffle(simd2_t<T, N, N>, const simd<T, N>& x, const simd<T, N>& y, csizeseq_t<N + N>, overload_priority<8>) CMT_NOEXCEPT { @@ -1241,7 +1242,7 @@ KFR_INTRINSIC simd<T, N> simd_broadcast(simd_t<T, N>, identity<T> value) CMT_NOE } template <typename T, size_t N, - KFR_ENABLE_IF(is_poweroftwo(N) && is_same<simd<T, N>, simd_halves<unwrap_bit<T>, N>>)> + KFR_ENABLE_IF(is_poweroftwo(N) && std::is_same_v<simd<T, N>, simd_halves<unwrap_bit<T>, N>>)> KFR_INTRINSIC simd<T, N / 2> simd_shuffle(simd_t<T, N>, const simd<T, N>& x, csizeseq_t<N / 2>, overload_priority<7>) CMT_NOEXCEPT { @@ -1249,7 +1250,7 @@ KFR_INTRINSIC simd<T, N / 2> simd_shuffle(simd_t<T, N>, const simd<T, N>& x, csi } template <typename T, size_t N, - KFR_ENABLE_IF(is_poweroftwo(N) && is_same<simd<T, N>, simd_halves<unwrap_bit<T>, N>>)> + KFR_ENABLE_IF(is_poweroftwo(N) && std::is_same_v<simd<T, N>, simd_halves<unwrap_bit<T>, N>>)> KFR_INTRINSIC simd<T, N / 2> simd_shuffle(simd_t<T, N>, const simd<T, N>& x, csizeseq_t<N / 2, N / 2>, overload_priority<7>) CMT_NOEXCEPT { diff --git a/include/kfr/simd/impl/function.hpp b/include/kfr/simd/impl/function.hpp @@ -317,7 +317,7 @@ KFR_INTRINSIC void intrin(vec<T, N>& result, const T& a, const vec<T, N>& b, Fn& } template <typename T> -using vec1 = conditional<is_vec<T>, T, vec<T, 1>>; +using vec1 = std::conditional_t<is_vec<T>, T, vec<T, 1>>; template <typename T> inline const T& to_scalar(const T& value) CMT_NOEXCEPT diff --git a/include/kfr/simd/impl/saturation.hpp b/include/kfr/simd/impl/saturation.hpp @@ -180,7 +180,7 @@ KFR_INTRINSIC vec<T, N> satadd(const vec<T, N>& a, const vec<T, N>& b) { return saturated_signed_add(a, b); } -template <typename T, size_t N, KFR_ENABLE_IF(is_unsigned<T>)> +template <typename T, size_t N, KFR_ENABLE_IF(std::is_unsigned_v<T>)> KFR_INTRINSIC vec<T, N> satadd(const vec<T, N>& a, const vec<T, N>& b) { return saturated_unsigned_add(a, b); @@ -190,7 +190,7 @@ KFR_INTRINSIC vec<T, N> satsub(const vec<T, N>& a, const vec<T, N>& b) { return saturated_signed_sub(a, b); } -template <typename T, size_t N, KFR_ENABLE_IF(is_unsigned<T>)> +template <typename T, size_t N, KFR_ENABLE_IF(std::is_unsigned_v<T>)> KFR_INTRINSIC vec<T, N> satsub(const vec<T, N>& a, const vec<T, N>& b) { return saturated_unsigned_sub(a, b); diff --git a/include/kfr/simd/operators.hpp b/include/kfr/simd/operators.hpp @@ -575,7 +575,7 @@ KFR_FN(horner_odd) template <typename T> constexpr KFR_INTRINSIC T reciprocal(const T& x) { - static_assert(is_floating_point<subtype<T>>, "T must be floating point type"); + static_assert(std::is_floating_point_v<subtype<T>>, "T must be floating point type"); return subtype<T>(1) / x; } KFR_FN(reciprocal) diff --git a/include/kfr/simd/types.hpp b/include/kfr/simd/types.hpp @@ -64,7 +64,7 @@ struct common_type_impl }; template <typename... T> -using decay_common = decay<common_type_impl<T...>>; +using decay_common = std::decay_t<common_type_impl<T...>>; template <typename T1, typename T2, template <typename TT> class result_type, typename = void> struct common_type_from_subtypes @@ -72,7 +72,7 @@ struct common_type_from_subtypes }; template <typename T1, typename T2, template <typename TT> class result_type> -struct common_type_from_subtypes<T1, T2, result_type, void_t<typename common_type_impl<T1, T2>::type>> +struct common_type_from_subtypes<T1, T2, result_type, std::void_t<typename common_type_impl<T1, T2>::type>> { using type = result_type<typename common_type_impl<T1, T2>::type>; }; @@ -80,7 +80,7 @@ struct common_type_from_subtypes<T1, T2, result_type, void_t<typename common_typ template <typename T> struct common_type_impl<T> { - using type = decay<T>; + using type = std::decay_t<T>; }; template <typename T1, typename T2> @@ -92,12 +92,12 @@ struct common_type_2_default }; template <typename T1, typename T2> -struct common_type_2_default<T1, T2, void_t<common_for_two<T1, T2>>> +struct common_type_2_default<T1, T2, std::void_t<common_for_two<T1, T2>>> { using type = std::decay_t<common_for_two<T1, T2>>; }; -template <typename T1, typename T2, typename D1 = decay<T1>, typename D2 = decay<T2>> +template <typename T1, typename T2, typename D1 = std::decay_t<T1>, typename D2 = std::decay_t<T2>> struct common_type_2_impl : common_type_impl<D1, D2> { }; @@ -118,7 +118,7 @@ struct common_type_multi_impl }; template <typename T1, typename T2, typename... R> -struct common_type_multi_impl<void_t<typename common_type_impl<T1, T2>::type>, T1, T2, R...> +struct common_type_multi_impl<std::void_t<typename common_type_impl<T1, T2>::type>, T1, T2, R...> : common_type_impl<typename common_type_impl<T1, T2>::type, R...> { }; @@ -248,8 +248,9 @@ struct f16 template <size_t bits> struct bitmask { - using type = conditional<(bits > 32), uint64_t, - conditional<(bits > 16), uint32_t, conditional<(bits > 8), uint16_t, uint8_t>>>; + using type = std::conditional_t< + (bits > 32), uint64_t, + std::conditional_t<(bits > 16), uint32_t, std::conditional_t<(bits > 8), uint16_t, uint8_t>>>; bitmask(type val) : value(val) {} @@ -401,18 +402,20 @@ struct initialvalue template <typename T> constexpr inline bool is_simd_type = - is_same<T, float> || is_same<T, double> || is_same<T, signed char> || is_same<T, unsigned char> || - is_same<T, short> || is_same<T, unsigned short> || is_same<T, int> || is_same<T, unsigned int> || - is_same<T, long> || is_same<T, unsigned long> || is_same<T, long long> || is_same<T, unsigned long long>; + std::is_same_v<T, float> || std::is_same_v<T, double> || std::is_same_v<T, signed char> || + std::is_same_v<T, unsigned char> || std::is_same_v<T, short> || std::is_same_v<T, unsigned short> || + std::is_same_v<T, int> || std::is_same_v<T, unsigned int> || std::is_same_v<T, long> || + std::is_same_v<T, unsigned long> || std::is_same_v<T, long long> || std::is_same_v<T, unsigned long long>; template <typename T> -constexpr inline bool is_simd_float_type = is_same<T, float> || is_same<T, double>; +constexpr inline bool is_simd_float_type = std::is_same_v<T, float> || std::is_same_v<T, double>; template <typename T> constexpr inline bool is_simd_int_type = - is_same<T, signed char> || is_same<T, unsigned char> || is_same<T, short> || is_same<T, unsigned short> || - is_same<T, int> || is_same<T, unsigned int> || is_same<T, long> || is_same<T, unsigned long> || - is_same<T, long long> || is_same<T, unsigned long long>; + std::is_same_v<T, signed char> || std::is_same_v<T, unsigned char> || std::is_same_v<T, short> || + std::is_same_v<T, unsigned short> || std::is_same_v<T, int> || std::is_same_v<T, unsigned int> || + std::is_same_v<T, long> || std::is_same_v<T, unsigned long> || std::is_same_v<T, long long> || + std::is_same_v<T, unsigned long long>; template <typename T> constexpr inline bool is_simd_type<bit<T>> = is_simd_type<T>; diff --git a/include/kfr/simd/vec.hpp b/include/kfr/simd/vec.hpp @@ -167,7 +167,7 @@ struct conversion template <typename To, typename From, conv_t conv> struct conversion<0, 0, To, From, conv> { - static_assert(is_convertible<From, To>); + static_assert(std::is_convertible_v<From, To>); static To cast(const From& value) { return value; } }; @@ -235,10 +235,10 @@ struct alignas(internal::vec_alignment<T, N_>) vec using simd_type = intrinsics::simd<ST, SN>; using uvalue_type = utype<T>; - using iuvalue_type = conditional<is_i_class<T>, T, uvalue_type>; + using iuvalue_type = std::conditional_t<is_i_class<T>, T, uvalue_type>; using uscalar_type = utype<ST>; - using iuscalar_type = conditional<is_i_class<ST>, ST, uscalar_type>; + using iuscalar_type = std::conditional_t<is_i_class<ST>, ST, uscalar_type>; using usimd_type = intrinsics::simd<uscalar_type, SN>; using iusimd_type = intrinsics::simd<iuscalar_type, SN>; @@ -279,14 +279,16 @@ struct alignas(internal::vec_alignment<T, N_>) vec #endif // from scalar - template <typename U, KFR_ENABLE_IF(is_convertible<U, value_type>&& compound_type_traits<T>::is_scalar)> + template <typename U, + KFR_ENABLE_IF(std::is_convertible_v<U, value_type>&& compound_type_traits<T>::is_scalar)> KFR_MEM_INTRINSIC vec(const U& s) CMT_NOEXCEPT : v(intrinsics::simd_broadcast(intrinsics::simd_t<unwrap_bit<ST>, SN>{}, static_cast<unwrap_bit<ST>>(static_cast<ST>(s)))) { } - template <typename U, KFR_ENABLE_IF(is_convertible<U, value_type> && !compound_type_traits<T>::is_scalar)> + template <typename U, + KFR_ENABLE_IF(std::is_convertible_v<U, value_type> && !compound_type_traits<T>::is_scalar)> KFR_MEM_INTRINSIC vec(const U& s) CMT_NOEXCEPT : v(intrinsics::simd_shuffle(intrinsics::simd_t<unwrap_bit<ST>, SW>{}, internal::compoundcast<T>::to_flat(static_cast<T>(s)).v, @@ -310,7 +312,7 @@ struct alignas(internal::vec_alignment<T, N_>) vec } // from vector of another type - template <typename U, KFR_ENABLE_IF(is_convertible<U, value_type> && + template <typename U, KFR_ENABLE_IF(std::is_convertible_v<U, value_type> && (compound_type_traits<T>::is_scalar && !is_bit<U>))> KFR_MEM_INTRINSIC vec(const vec<U, N>& x) CMT_NOEXCEPT : v(intrinsics::simd_convert( @@ -329,7 +331,7 @@ struct alignas(internal::vec_alignment<T, N_>) vec } } - template <typename U, KFR_ENABLE_IF(is_convertible<U, value_type> && + template <typename U, KFR_ENABLE_IF(std::is_convertible_v<U, value_type> && !(compound_type_traits<T>::is_scalar && !is_bit<U>))> KFR_MEM_INTRINSIC vec(const vec<U, N>& x) CMT_NOEXCEPT : v(internal::conversion<vec_rank<T> + 1, vec_rank<U> + 1, vec<T, N>, vec<U, N>, @@ -339,7 +341,7 @@ struct alignas(internal::vec_alignment<T, N_>) vec } // from list of vectors - template <size_t... Ns, typename = enable_if<csum<size_t, Ns...>() == N>> + template <size_t... Ns, typename = std::enable_if_t<csum<size_t, Ns...>() == N>> KFR_MEM_INTRINSIC vec(const vec<T, Ns>&... vs) CMT_NOEXCEPT : v(intrinsics::simd_concat<ST, (SW * Ns)...>(vs.v...)) { @@ -577,7 +579,7 @@ template <typename... T> vec(T&&...) -> vec<std::common_type_t<T...>, sizeof...(T)>; template <typename T> -constexpr inline bool is_vec_element = is_simd_type<deep_subtype<remove_const<T>>>; +constexpr inline bool is_vec_element = is_simd_type<deep_subtype<std::remove_const_t<T>>>; template <typename T, size_t N, size_t... indices> KFR_INTRINSIC vec<T, sizeof...(indices)> shufflevector(const vec<T, N>& x, @@ -635,8 +637,8 @@ template <typename To, typename From, size_t N, size_t N2, conv_t conv> struct conversion<1, 1, vec<To, N>, vec<From, N2>, conv> { static_assert(N == N2, ""); - static_assert(!is_compound<To>, ""); - static_assert(!is_compound<From>, ""); + static_assert(!is_compound_type<To>, ""); + static_assert(!is_compound_type<From>, ""); static vec<To, N> cast(const vec<From, N>& value) { return vec<To, N>(value); } }; @@ -645,7 +647,7 @@ struct conversion<1, 1, vec<To, N>, vec<From, N2>, conv> template <typename To, typename From, size_t N, conv_t conv> struct conversion<1, 0, vec<To, N>, From, conv> { - static_assert(is_convertible<From, To>, ""); + static_assert(std::is_convertible_v<From, To>, ""); static vec<To, N> cast(const From& value) { return broadcast<N>(static_cast<To>(value)); } }; @@ -671,25 +673,25 @@ constexpr KFR_INTRINSIC Tout cast(const From& value) CMT_NOEXCEPT return static_cast<Tout>(value); } -template <typename Tout, typename Tin, size_t N, KFR_ENABLE_IF(!is_same<Tin, Tout>)> +template <typename Tout, typename Tin, size_t N, KFR_ENABLE_IF(!std::is_same_v<Tin, Tout>)> constexpr KFR_INTRINSIC vec<Tout, N> cast(const vec<Tin, N>& value) CMT_NOEXCEPT { return vec<Tout, N>(value); } -template <typename Tout, typename Tin, size_t N1, size_t N2, KFR_ENABLE_IF(!is_same<Tin, Tout>)> +template <typename Tout, typename Tin, size_t N1, size_t N2, KFR_ENABLE_IF(!std::is_same_v<Tin, Tout>)> constexpr KFR_INTRINSIC vec<vec<Tout, N1>, N2> cast(const vec<vec<Tin, N1>, N2>& value) CMT_NOEXCEPT { return vec<vec<Tout, N1>, N2>(value); } -template <typename Tout, typename Tin, size_t N, KFR_ENABLE_IF(is_same<Tin, Tout>)> +template <typename Tout, typename Tin, size_t N, KFR_ENABLE_IF(std::is_same_v<Tin, Tout>)> constexpr KFR_INTRINSIC const vec<Tin, N>& cast(const vec<Tin, N>& value) CMT_NOEXCEPT { return value; } -template <typename Tout, typename Tin, size_t N1, size_t N2, KFR_ENABLE_IF(is_same<Tin, Tout>)> +template <typename Tout, typename Tin, size_t N1, size_t N2, KFR_ENABLE_IF(std::is_same_v<Tin, Tout>)> constexpr KFR_INTRINSIC const vec<vec<Tin, N1>, N2>& cast(const vec<vec<Tin, N1>, N2>& value) CMT_NOEXCEPT { return value; @@ -704,27 +706,27 @@ constexpr KFR_INTRINSIC Tout broadcastto(const From& value) CMT_NOEXCEPT return static_cast<Tout>(value); } -template <typename Tout, typename Tin, size_t N, KFR_ENABLE_IF(!is_same<Tin, Tout>)> +template <typename Tout, typename Tin, size_t N, KFR_ENABLE_IF(!std::is_same_v<Tin, Tout>)> constexpr KFR_INTRINSIC vec<Tout, N> broadcastto(const vec<Tin, N>& value) CMT_NOEXCEPT { return internal::conversion<vec_rank<Tout> + 1, 1, vec<Tout, N>, vec<Tin, N>, internal::conv_t::broadcast>::cast(value); } -template <typename Tout, typename Tin, size_t N1, size_t N2, KFR_ENABLE_IF(!is_same<Tin, Tout>)> +template <typename Tout, typename Tin, size_t N1, size_t N2, KFR_ENABLE_IF(!std::is_same_v<Tin, Tout>)> constexpr KFR_INTRINSIC vec<vec<Tout, N1>, N2> broadcastto(const vec<vec<Tin, N1>, N2>& value) CMT_NOEXCEPT { return internal::conversion<vec_rank<Tout> + 2, 2, vec<vec<Tout, N1>, N2>, vec<vec<Tin, N1>, N2>, internal::conv_t::broadcast>::cast(value); } -template <typename Tout, typename Tin, size_t N, KFR_ENABLE_IF(is_same<Tin, Tout>)> +template <typename Tout, typename Tin, size_t N, KFR_ENABLE_IF(std::is_same_v<Tin, Tout>)> constexpr KFR_INTRINSIC const vec<Tin, N>& broadcastto(const vec<Tin, N>& value) CMT_NOEXCEPT { return value; } -template <typename Tout, typename Tin, size_t N1, size_t N2, KFR_ENABLE_IF(is_same<Tin, Tout>)> +template <typename Tout, typename Tin, size_t N1, size_t N2, KFR_ENABLE_IF(std::is_same_v<Tin, Tout>)> constexpr KFR_INTRINSIC const vec<vec<Tin, N1>, N2>& broadcastto(const vec<vec<Tin, N1>, N2>& value) CMT_NOEXCEPT { @@ -776,25 +778,25 @@ CMT_GNU_CONSTEXPR KFR_INTRINSIC vec<To, Nout> bitcast(const vec<From, N>& value) return vec<To, Nout>::frombits(value); } -template <typename From, typename To = utype<From>, KFR_ENABLE_IF(!is_compound<From>)> +template <typename From, typename To = utype<From>, KFR_ENABLE_IF(!is_compound_type<From>)> constexpr KFR_INTRINSIC To ubitcast(const From& value) CMT_NOEXCEPT { return bitcast<To>(value); } -template <typename From, typename To = itype<From>, KFR_ENABLE_IF(!is_compound<From>)> +template <typename From, typename To = itype<From>, KFR_ENABLE_IF(!is_compound_type<From>)> constexpr KFR_INTRINSIC To ibitcast(const From& value) CMT_NOEXCEPT { return bitcast<To>(value); } -template <typename From, typename To = ftype<From>, KFR_ENABLE_IF(!is_compound<From>)> +template <typename From, typename To = ftype<From>, KFR_ENABLE_IF(!is_compound_type<From>)> constexpr KFR_INTRINSIC To fbitcast(const From& value) CMT_NOEXCEPT { return bitcast<To>(value); } -template <typename From, typename To = uitype<From>, KFR_ENABLE_IF(!is_compound<From>)> +template <typename From, typename To = uitype<From>, KFR_ENABLE_IF(!is_compound_type<From>)> constexpr KFR_INTRINSIC To uibitcast(const From& value) CMT_NOEXCEPT { return bitcast<To>(value); @@ -898,7 +900,7 @@ struct conditional_common<false, Tfallback, Args...> /// @endcode template <typename Type = void, typename Arg, typename... Args, size_t N = (sizeof...(Args) + 1), typename SubType = - fix_type<typename internal::conditional_common<is_void<Type>, Type, Arg, Args...>::type>> + fix_type<typename internal::conditional_common<std::is_void_v<Type>, Type, Arg, Args...>::type>> constexpr KFR_INTRINSIC vec<SubType, N> make_vector(const Arg& x, const Args&... rest) { return internal::make_vector_impl<SubType>(cvalseq_t<size_t, N>(), static_cast<SubType>(x), @@ -917,9 +919,10 @@ constexpr KFR_INTRINSIC vec<T, N> make_vector(cvals_t<T, Values...>) return make_vector<T>(Values...); } -template <typename Type = void, typename Arg, typename... Args, size_t N = (sizeof...(Args) + 1), - typename SubType = fix_type<conditional<is_void<Type>, common_type<Arg, Args...>, Type>>, - KFR_ENABLE_IF(is_number<subtype<SubType>>)> +template < + typename Type = void, typename Arg, typename... Args, size_t N = (sizeof...(Args) + 1), + typename SubType = fix_type<std::conditional_t<std::is_void_v<Type>, common_type<Arg, Args...>, Type>>, + KFR_ENABLE_IF(is_number<subtype<SubType>>)> constexpr KFR_INTRINSIC vec<SubType, N> pack(const Arg& x, const Args&... rest) { return internal::make_vector_impl<SubType>(csizeseq<N>, static_cast<SubType>(x), @@ -1085,14 +1088,14 @@ namespace internal { template <size_t Index, typename T, size_t N, typename Fn, typename... Args, - typename Tout = invoke_result<Fn, subtype<decay<Args>>...>> + typename Tout = std::invoke_result_t<Fn, subtype<std::decay_t<Args>>...>> constexpr KFR_INTRINSIC Tout applyfn_helper(Fn&& fn, Args&&... args) { return fn(args[Index]...); } template <typename T, size_t N, typename Fn, typename... Args, - typename Tout = invoke_result<Fn, subtype<decay<Args>>...>, size_t... Indices> + typename Tout = std::invoke_result_t<Fn, subtype<std::decay_t<Args>>...>, size_t... Indices> constexpr KFR_INTRINSIC vec<Tout, N> apply_helper(Fn&& fn, csizes_t<Indices...>, Args&&... args) { return make_vector(applyfn_helper<Indices, T, N>(std::forward<Fn>(fn), std::forward<Args>(args)...)...); @@ -1106,20 +1109,21 @@ constexpr KFR_INTRINSIC vec<T, N> apply0_helper(Fn&& fn, csizes_t<Indices...>) } // namespace internal template <typename T, size_t N, typename Fn, typename... Args, - typename Tout = invoke_result<Fn, T, subtype<decay<Args>>...>> + typename Tout = std::invoke_result_t<Fn, T, subtype<std::decay_t<Args>>...>> constexpr KFR_INTRINSIC vec<Tout, N> apply(Fn&& fn, const vec<T, N>& arg, Args&&... args) { return internal::apply_helper<T, N>(std::forward<Fn>(fn), csizeseq<N>, arg, std::forward<Args>(args)...); } -template <typename T, typename Fn, typename... Args, typename Tout = invoke_result<Fn, T, decay<Args>...>, - KFR_ENABLE_IF(is_same<T, subtype<T>>)> +template <typename T, typename Fn, typename... Args, + typename Tout = std::invoke_result_t<Fn, T, std::decay_t<Args>...>, + KFR_ENABLE_IF(std::is_same_v<T, subtype<T>>)> constexpr KFR_INTRINSIC Tout apply(Fn&& fn, const T& arg, Args&&... args) { return fn(arg, args...); } -template <size_t N, typename Fn, typename T = invoke_result<Fn>> +template <size_t N, typename Fn, typename T = std::invoke_result_t<Fn>> constexpr KFR_INTRINSIC vec<T, N> apply(Fn&& fn) { return internal::apply0_helper<T, N>(std::forward<Fn>(fn), csizeseq<N>); @@ -1227,27 +1231,27 @@ vec<T, N> test_enumerate(vec_shape<T, N>, csizes_t<indices...>, double start = 0 template <int Cat, typename Fn, typename RefFn, typename IsApplicable = fn_return_constant<bool, true>> void test_function1(cint_t<Cat> cat, Fn&& fn, RefFn&& reffn, IsApplicable&& isapplicable = IsApplicable{}) { - testo::matrix( - named("value") = special_values(), named("type") = test_catogories::types(cat), - [&](special_value value, auto type) - { - using T = typename decltype(type)::type; - if (isapplicable(ctype<T>, value)) - { - const T x(value); + testo::matrix(named("value") = special_values(), named("type") = test_catogories::types(cat), + [&](special_value value, auto type) + { + using T = typename decltype(type)::type; + if (isapplicable(ctype<T>, value)) + { + const T x(value); #if !defined(_MSC_VER) || defined(__clang__) - // Supress ICE in MSVC - using RefFnTy = decltype(std::declval<RefFn>()(std::declval<subtype<T>>())); - CHECK(is_same<decltype(fn(x)), typename compound_type_traits<T>::template rebind<RefFnTy>>); + // Supress ICE in MSVC + using RefFnTy = decltype(std::declval<RefFn>()(std::declval<subtype<T>>())); + CHECK(std::is_same_v<decltype(fn(x)), + typename compound_type_traits<T>::template rebind<RefFnTy>>); #endif - const auto fn_x = fn(x); - const auto ref_x = apply(reffn, x); - ::testo::active_test()->check(testo::deep_is_equal(ref_x, fn_x), - as_string(fn_x, " == ", ref_x), "fn(x) == apply(reffn, x)", - __FILE__, __LINE__); - // CHECK(fn(x) == apply(reffn, x)); - } - }); + const auto fn_x = fn(x); + const auto ref_x = apply(reffn, x); + ::testo::active_test()->check(testo::deep_is_equal(ref_x, fn_x), + as_string(fn_x, " == ", ref_x), + "fn(x) == apply(reffn, x)", __FILE__, __LINE__); + // CHECK(fn(x) == apply(reffn, x)); + } + }); testo::matrix(named("type") = test_catogories::types(cint<Cat & ~1>), [&](auto type) @@ -1265,24 +1269,25 @@ void test_function2(cint_t<Cat> cat, Fn&& fn, RefFn&& reffn, IsApplicable&& isap { constexpr IsDefined isdefined{}; - testo::matrix(named("value1") = special_values(), // - named("value2") = special_values(), named("type") = test_catogories::types(cat), - [&](special_value value1, special_value value2, auto type) - { - using T = typename decltype(type)::type; - if constexpr (isdefined(ctype<T>)) - { - const T x1(value1); - const T x2(value2); - if (isapplicable(ctype<T>, value1, value2)) - { - CHECK(is_same<decltype(fn(x1, x2)), - typename compound_type_traits<T>::template rebind<decltype(reffn( - std::declval<subtype<T>>(), std::declval<subtype<T>>()))>>); - CHECK(fn(x1, x2) == apply(reffn, x1, x2)); - } - } - }); + testo::matrix( + named("value1") = special_values(), // + named("value2") = special_values(), named("type") = test_catogories::types(cat), + [&](special_value value1, special_value value2, auto type) + { + using T = typename decltype(type)::type; + if constexpr (isdefined(ctype<T>)) + { + const T x1(value1); + const T x2(value2); + if (isapplicable(ctype<T>, value1, value2)) + { + CHECK(std::is_same_v<decltype(fn(x1, x2)), + typename compound_type_traits<T>::template rebind<decltype(reffn( + std::declval<subtype<T>>(), std::declval<subtype<T>>()))>>); + CHECK(fn(x1, x2) == apply(reffn, x1, x2)); + } + } + }); testo::matrix(named("type") = test_catogories::types(cint<Cat & ~1>), [&](auto type) @@ -1317,8 +1322,8 @@ template <typename To, typename From, size_t N1, size_t N2, size_t Ns1> struct conversion<2, 1, vec<vec<To, N1>, N2>, vec<From, Ns1>, conv_t::broadcast> { static_assert(N1 == Ns1, ""); - static_assert(!is_compound<To>, ""); - static_assert(!is_compound<From>, ""); + static_assert(!is_compound_type<To>, ""); + static_assert(!is_compound_type<From>, ""); static vec<vec<To, N1>, N2> cast(const vec<From, N1>& value) { @@ -1333,8 +1338,8 @@ template <typename To, typename From, size_t N1, size_t N2, size_t Ns1> struct conversion<2, 1, vec<vec<To, N1>, N2>, vec<From, Ns1>, conv_t::promote> { static_assert(N2 == Ns1, ""); - static_assert(!is_compound<To>, ""); - static_assert(!is_compound<From>, ""); + static_assert(!is_compound_type<To>, ""); + static_assert(!is_compound_type<From>, ""); static vec<vec<To, N1>, N2> cast(const vec<From, N2>& value) { @@ -1351,8 +1356,8 @@ struct conversion<2, 2, vec<vec<To, N1>, N2>, vec<vec<From, NN1>, NN2>, conv> { static_assert(N1 == NN1, ""); static_assert(N2 == NN2, ""); - static_assert(!is_compound<To>, ""); - static_assert(!is_compound<From>, ""); + static_assert(!is_compound_type<To>, ""); + static_assert(!is_compound_type<From>, ""); static vec<vec<To, N1>, N2> cast(const vec<vec<From, N1>, N2>& value) { diff --git a/include/kfr/testo/testo.hpp b/include/kfr/testo/testo.hpp @@ -405,12 +405,12 @@ CMT_UNUSED static int run_all(const std::string& name = std::string(), bool show template <typename T1, typename T2> void assert_is_same() { - static_assert(std::is_same<T1, T2>::value, ""); + static_assert(std::is_same_v<T1, T2>, ""); } template <typename T1, typename T2> void assert_is_same_decay() { - static_assert(std::is_same<cometa::decay<T1>, cometa::decay<T2>>::value, ""); + static_assert(std::is_same_v<std::decay_t<T1>, std::decay_t<T2>>, ""); } template <typename T, size_t NArgs> diff --git a/sources.cmake b/sources.cmake @@ -500,6 +500,7 @@ set( ${PROJECT_SOURCE_DIR}/tests/unit/base/random.cpp ${PROJECT_SOURCE_DIR}/tests/unit/base/reduce.cpp ${PROJECT_SOURCE_DIR}/tests/unit/base/shape.cpp + ${PROJECT_SOURCE_DIR}/tests/unit/base/std_ambiguities.cpp ${PROJECT_SOURCE_DIR}/tests/unit/base/tensor.cpp ${PROJECT_SOURCE_DIR}/tests/unit/dsp/biquad.cpp ${PROJECT_SOURCE_DIR}/tests/unit/dsp/biquad_design.cpp diff --git a/tests/unit/base/basic_expressions.cpp b/tests/unit/base/basic_expressions.cpp @@ -37,7 +37,7 @@ TEST(counter_shape) TEST(pack) { - static_assert(is_same<vec<f32x2, 1>, invoke_result<fn::reverse, vec<f32x2, 1>>>); + static_assert(std::is_same_v<vec<f32x2, 1>, std::invoke_result_t<fn::reverse, vec<f32x2, 1>>>); const univector<float, 21> v1 = 1 + counter(); const univector<float, 21> v2 = v1 * 11; diff --git a/tests/unit/base/std_ambiguities.cpp b/tests/unit/base/std_ambiguities.cpp @@ -0,0 +1,12 @@ +/** + * KFR (http://kfrlib.com) + * Copyright (C) 2016-2022 Fractalium Ltd + * See LICENSE.txt for details + */ + +#include <type_traits> +#include <utility> + +using namespace std; + +#include <kfr/all.hpp> diff --git a/tests/unit/dsp/biquad.cpp b/tests/unit/dsp/biquad.cpp @@ -22,7 +22,7 @@ inline const univector<T, Tag>& choose_array(const univector<T, Tag>& array, con return array; } -template <typename T, typename T2, typename... Ts, univector_tag Tag, KFR_ENABLE_IF(!is_same<T, T2>)> +template <typename T, typename T2, typename... Ts, univector_tag Tag, KFR_ENABLE_IF(!std::is_same_v<T, T2>)> inline const univector<T, Tag>& choose_array(const univector<T2, Tag>&, const univector<Ts, Tag>&... arrays) { return choose_array<T>(arrays...); diff --git a/tests/unit/simd/min_max.cpp b/tests/unit/simd/min_max.cpp @@ -31,7 +31,7 @@ struct IsNotMinInt template <typename T> bool operator()(ctype_t<T>, identity<T> x, identity<T> y) const { - return is_floating_point<T> || is_unsigned<T> || + return std::is_floating_point_v<T> || std::is_unsigned_v<T> || (x != std::numeric_limits<T>::min() && y != std::numeric_limits<T>::min()); } template <typename T, size_t N> diff --git a/tests/unit/simd/vec.cpp b/tests/unit/simd/vec.cpp @@ -63,30 +63,30 @@ TEST(cast) vec<float, 4>{ 1.f, 2.f, 3.f, 4.f }, vec<float, 4>{ 11.f, 22.f, 33.f, 44.f } }) == vec<vec<double, 4>, 2>{ vec<double, 4>{ 1., 2., 3., 4. }, vec<double, 4>{ 11., 22., 33., 44. } }); - static_assert(is_convertible<float, f32x4>, ""); - static_assert(is_convertible<float, f64x8>, ""); - static_assert(is_convertible<float, u8x3>, ""); + static_assert(std::is_convertible_v<float, f32x4>, ""); + static_assert(std::is_convertible_v<float, f64x8>, ""); + static_assert(std::is_convertible_v<float, u8x3>, ""); - static_assert(is_convertible<u16x4, i32x4>, ""); - static_assert(!is_convertible<u16x4, i32x3>, ""); - static_assert(!is_convertible<u16x1, u16x16>, ""); + static_assert(std::is_convertible_v<u16x4, i32x4>, ""); + static_assert(!std::is_convertible_v<u16x4, i32x3>, ""); + static_assert(!std::is_convertible_v<u16x1, u16x16>, ""); - static_assert(is_convertible<float, vecx<float, 2>>, ""); - static_assert(is_convertible<float, vecx<float, 2, 2>>, ""); + static_assert(std::is_convertible_v<float, vecx<float, 2>>, ""); + static_assert(std::is_convertible_v<float, vecx<float, 2, 2>>, ""); - static_assert(is_same<decltype(broadcastto<f64>(f32x4x4(1))), f64x4x4>, ""); - static_assert(is_same<decltype(broadcastto<f64>(f32x4(1))), f64x4>, ""); - static_assert(is_same<decltype(broadcastto<f64>(f32(1))), f64>, ""); + static_assert(std::is_same_v<decltype(broadcastto<f64>(f32x4x4(1))), f64x4x4>, ""); + static_assert(std::is_same_v<decltype(broadcastto<f64>(f32x4(1))), f64x4>, ""); + static_assert(std::is_same_v<decltype(broadcastto<f64>(f32(1))), f64>, ""); - // N/A static_assert(is_same<decltype(broadcastto<f64x4>(f32x4x4(1))), f64x4x4>, ""); - static_assert(is_same<decltype(broadcastto<f64x4>(f32x4(1))), f64x4x4>, ""); - static_assert(is_same<decltype(broadcastto<f64x4>(f32(1))), f64x4>, ""); + // N/A static_assert(std::is_same_v<decltype(broadcastto<f64x4>(f32x4x4(1))), f64x4x4>, ""); + static_assert(std::is_same_v<decltype(broadcastto<f64x4>(f32x4(1))), f64x4x4>, ""); + static_assert(std::is_same_v<decltype(broadcastto<f64x4>(f32(1))), f64x4>, ""); - // N/A static_assert(is_same<decltype(promoteto<f64>(f32x4x4(1))), f64x4>, ""); - static_assert(is_same<decltype(promoteto<f64>(f32x4(1))), f64x4>, ""); + // N/A static_assert(std::is_same_v<decltype(promoteto<f64>(f32x4x4(1))), f64x4>, ""); + static_assert(std::is_same_v<decltype(promoteto<f64>(f32x4(1))), f64x4>, ""); - static_assert(is_same<decltype(promoteto<f64x4>(f32x4x4(1))), f64x4x4>, ""); - static_assert(is_same<decltype(promoteto<f64x4>(f32x4(1))), f64x4x4>, ""); + static_assert(std::is_same_v<decltype(promoteto<f64x4>(f32x4x4(1))), f64x4x4>, ""); + static_assert(std::is_same_v<decltype(promoteto<f64x4>(f32x4(1))), f64x4x4>, ""); CHECK(cast<vecx<float, 2, 2>>(123.f) == vec{ vec{ 123.f, 123.f }, vec{ 123.f, 123.f } });