added replicated functionality for standard header methods in utility files

include/ck/utility/is_detected.hpp

@@ -3,20 +3,22 @@
 
 #pragma once
 
+#include "ck/utility/integral_constant.hpp"
+
 namespace ck {
 
 namespace detail {
 template <class Default, class AlwaysVoid, template <class...> class Op, class... Args>
 struct detector
 {
-    using value_t = std::false_type;
+    using value_t = integral_constant<bool, false>;
     using type    = Default;
 };
 
 template <class Default, template <class...> class Op, class... Args>
-struct detector<Default, std::void_t<Op<Args...>>, Op, Args...>
+struct detector<Default, ck::void_t<Op<Args...>>, Op, Args...>
 {
-    using value_t = std::true_type;
+    using value_t = integral_constant<bool, true>;
     using type    = Op<Args...>;
 };
 } // namespace detail
@@ -32,12 +34,12 @@ template <template <class...> class Op, class... Args>
 using is_detected = typename detail::detector<nonesuch, void, Op, Args...>::value_t;
 
 template <typename T>
-using is_pack2_invocable_t = decltype(std::declval<T&>().is_pack2_invocable);
+using is_pack2_invocable_t = decltype(ck::declval<T&>().is_pack2_invocable);
 
 template <typename T>
-using is_pack4_invocable_t = decltype(std::declval<T&>().is_pack4_invocable);
+using is_pack4_invocable_t = decltype(ck::declval<T&>().is_pack4_invocable);
 
 template <typename T>
-using is_pack8_invocable_t = decltype(std::declval<T&>().is_pack8_invocable);
+using is_pack8_invocable_t = decltype(ck::declval<T&>().is_pack8_invocable);
 
 } // namespace ck

include/ck/utility/statically_indexed_array_multi_index.hpp

@@ -35,10 +35,9 @@ __host__ __device__ constexpr auto to_multi_index(const T& x)
 // is the alias of the latter. This is because compiler cannot infer the NSize if
 // using MultiIndex<NSize>
 // TODO: how to fix this?
-template <
-    typename... Ys,
+template <typename... Ys,
           typename X,
-    enable_if_t<!std::is_integral<X>::value && !std::is_floating_point<X>::value, bool> = false>
+          enable_if_t<!ck::is_integral<X>::value && !ck::is_floating_point<X>::value, bool> = false>
 __host__ __device__ constexpr auto operator+=(Tuple<Ys...>& y, const X& x)
 {
     static_assert(X::Size() == sizeof...(Ys), "wrong! size not the same");
@@ -47,10 +46,9 @@ __host__ __device__ constexpr auto operator+=(Tuple<Ys...>& y, const X& x)
     return y;
 }
 
-template <
-    typename... Ys,
+template <typename... Ys,
           typename X,
-    enable_if_t<!std::is_integral<X>::value && !std::is_floating_point<X>::value, bool> = false>
+          enable_if_t<!ck::is_integral<X>::value && !ck::is_floating_point<X>::value, bool> = false>
 __host__ __device__ constexpr auto operator-=(Tuple<Ys...>& y, const X& x)
 {
     static_assert(X::Size() == sizeof...(Ys), "wrong! size not the same");
@@ -59,10 +57,9 @@ __host__ __device__ constexpr auto operator-=(Tuple<Ys...>& y, const X& x)
     return y;
 }
 
-template <
-    typename... Xs,
+template <typename... Xs,
           typename Y,
-    enable_if_t<!std::is_integral<Y>::value && !std::is_floating_point<Y>::value, bool> = false>
+          enable_if_t<!ck::is_integral<Y>::value && !ck::is_floating_point<Y>::value, bool> = false>
 __host__ __device__ constexpr auto operator+(const Tuple<Xs...>& x, const Y& y)
 {
     static_assert(Y::Size() == sizeof...(Xs), "wrong! size not the same");
@@ -73,10 +70,9 @@ __host__ __device__ constexpr auto operator+(const Tuple<Xs...>& x, const Y& y)
     return r;
 }
 
-template <
-    typename... Xs,
+template <typename... Xs,
           typename Y,
-    enable_if_t<!std::is_integral<Y>::value && !std::is_floating_point<Y>::value, bool> = false>
+          enable_if_t<!ck::is_integral<Y>::value && !ck::is_floating_point<Y>::value, bool> = false>
 __host__ __device__ constexpr auto operator-(const Tuple<Xs...>& x, const Y& y)
 {
     static_assert(Y::Size() == sizeof...(Xs), "wrong! size not the same");
@@ -87,10 +83,9 @@ __host__ __device__ constexpr auto operator-(const Tuple<Xs...>& x, const Y& y)
     return r;
 }
 
-template <
-    typename... Xs,
+template <typename... Xs,
           typename Y,
-    enable_if_t<!std::is_integral<Y>::value && !std::is_floating_point<Y>::value, bool> = false>
+          enable_if_t<!ck::is_integral<Y>::value && !ck::is_floating_point<Y>::value, bool> = false>
 __host__ __device__ constexpr auto operator*(const Tuple<Xs...>& x, const Y& y)
 {
     static_assert(Y::Size() == sizeof...(Xs), "wrong! size not the same");
@@ -104,7 +99,7 @@ __host__ __device__ constexpr auto operator*(const Tuple<Xs...>& x, const Y& y)
 // MultiIndex = scalar * MultiIndex
 template <typename... Xs,
           typename Y,
-          enable_if_t<std::is_integral<Y>::value || std::is_floating_point<Y>::value, bool> = false>
+          enable_if_t<ck::is_integral<Y>::value || ck::is_floating_point<Y>::value, bool> = false>
 __host__ __device__ constexpr auto operator*(Y a, const Tuple<Xs...>& x)
 {
     constexpr index_t NSize = sizeof...(Xs);
@@ -117,7 +112,7 @@ __host__ __device__ constexpr auto operator*(Y a, const Tuple<Xs...>& x)
 // MultiIndex = MultiIndex * scalar
 template <typename... Xs,
           typename Y,
-          enable_if_t<std::is_integral<Y>::value || std::is_floating_point<Y>::value, bool> = false>
+          enable_if_t<ck::is_integral<Y>::value || ck::is_floating_point<Y>::value, bool> = false>
 __host__ __device__ constexpr auto operator*(const Tuple<Xs...>& x, Y a)
 {
     return a * x;

include/ck/utility/tuple_helper.hpp

@@ -161,7 +161,7 @@ __host__ __device__ constexpr auto TupleReduce(F&& f, const Tuple<Ts...>& tuple)
 
 #ifndef CK_CODE_GEN_RTC
 template <typename T>
-using is_tuple = decltype(std::declval<T&>().IsTuple());
+using is_tuple = decltype(ck::declval<T&>().IsTuple());
 #endif
 
 template <typename... Ts>

include/ck/utility/type.hpp

@@ -119,6 +119,9 @@ constexpr T&& forward(typename remove_reference<T>::type&& t_) noexcept
 
 template <typename T>
 T&& declval() noexcept;
+
+template <typename... Ts>
+using void_t = void;
 #else
 #include <utility>
 #include <type_traits>
@@ -134,6 +137,7 @@ using std::remove_const;
 using std::remove_cv;
 using std::remove_pointer;
 using std::remove_reference;
+using std::void_t;
 #endif
 
 template <typename X, typename Y>
@@ -156,6 +160,106 @@ struct is_const<const X> : public integral_constant<bool, true>
 {
 };
 
+template <typename X>
+struct is_floating_point : public integral_constant<bool, false>
+{
+};
+
+template <>
+struct is_floating_point<float> : public integral_constant<bool, true>
+{
+};
+
+template <>
+struct is_floating_point<double> : public integral_constant<bool, true>
+{
+};
+
+template <>
+struct is_floating_point<long double> : public integral_constant<bool, true>
+{
+};
+
+template <typename X>
+struct is_integral : public integral_constant<bool, false>
+{
+};
+
+template <>
+struct is_integral<int> : public integral_constant<bool, true>
+{
+};
+
+template <>
+struct is_integral<unsigned int> : public integral_constant<bool, true>
+{
+};
+
+template <>
+struct is_integral<long> : public integral_constant<bool, true>
+{
+};
+
+template <>
+struct is_integral<unsigned long> : public integral_constant<bool, true>
+{
+};
+
+template <>
+struct is_integral<short> : public integral_constant<bool, true>
+{
+};
+
+template <>
+struct is_integral<unsigned short> : public integral_constant<bool, true>
+{
+};
+
+template <>
+struct is_integral<long long> : public integral_constant<bool, true>
+{
+};
+
+template <>
+struct is_integral<unsigned long long> : public integral_constant<bool, true>
+{
+};
+
+template <>
+struct is_integral<char> : public integral_constant<bool, true>
+{
+};
+
+template <>
+struct is_integral<signed char> : public integral_constant<bool, true>
+{
+};
+
+template <>
+struct is_integral<unsigned char> : public integral_constant<bool, true>
+{
+};
+
+template <>
+struct is_integral<wchar_t> : public integral_constant<bool, true>
+{
+};
+
+template <>
+struct is_integral<char16_t> : public integral_constant<bool, true>
+{
+};
+
+template <>
+struct is_integral<char32_t> : public integral_constant<bool, true>
+{
+};
+
+template <>
+struct is_integral<bool> : public integral_constant<bool, true>
+{
+};
+
 template <typename T>
 inline constexpr bool is_reference_v = is_reference<T>::value;