diff --git a/dpctl/tensor/_type_utils.py b/dpctl/tensor/_type_utils.py
index bebb1889f4..890af46339 100644
--- a/dpctl/tensor/_type_utils.py
+++ b/dpctl/tensor/_type_utils.py
@@ -140,11 +140,9 @@ def _acceptance_fn_default_unary(arg_dtype, ret_buf_dt, res_dt, sycl_dev):
 
 
 def _acceptance_fn_reciprocal(arg_dtype, buf_dt, res_dt, sycl_dev):
-    # if the kind of result is different from
-    # the kind of input, use the default data
-    # we use default dtype for the resulting kind.
-    # This guarantees alignment of reciprocal and
-    # divide output types.
+    # if the kind of result is different from the kind of input, we use the
+    # default floating-point dtype for the resulting kind. This guarantees
+    # alignment of reciprocal and divide output types.
     if buf_dt.kind != arg_dtype.kind:
         default_dt = _get_device_default_dtype(res_dt.kind, sycl_dev)
         if res_dt == default_dt:
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/abs.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/abs.hpp
index 5de9024b6f..411040bada 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/abs.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/abs.hpp
@@ -102,8 +102,7 @@ using AbsContigFunctor =
 
 template <typename T> struct AbsOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, bool>,
         td_ns::TypeMapResultEntry<T, std::uint8_t>,
         td_ns::TypeMapResultEntry<T, std::uint16_t>,
@@ -119,6 +118,8 @@ template <typename T> struct AbsOutputType
         td_ns::TypeMapResultEntry<T, std::complex<float>, float>,
         td_ns::TypeMapResultEntry<T, std::complex<double>, double>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -140,9 +141,7 @@ template <typename fnT, typename T> struct AbsContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AbsOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!AbsOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -191,9 +190,7 @@ template <typename fnT, typename T> struct AbsStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AbsOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!AbsOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/acos.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/acos.hpp
index a9bf000a20..a90f4e699f 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/acos.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/acos.hpp
@@ -145,14 +145,15 @@ using AcosStridedFunctor = elementwise_common::
 
 template <typename T> struct AcosOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half>,
         td_ns::TypeMapResultEntry<T, float>,
         td_ns::TypeMapResultEntry<T, double>,
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -174,9 +175,7 @@ template <typename fnT, typename T> struct AcosContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AcosOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!AcosOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -222,9 +221,7 @@ template <typename fnT, typename T> struct AcosStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AcosOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!AcosOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/acosh.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/acosh.hpp
index 94c9c5e56e..8af3708427 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/acosh.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/acosh.hpp
@@ -172,14 +172,15 @@ using AcoshStridedFunctor = elementwise_common::
 
 template <typename T> struct AcoshOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half>,
         td_ns::TypeMapResultEntry<T, float>,
         td_ns::TypeMapResultEntry<T, double>,
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -201,9 +202,7 @@ template <typename fnT, typename T> struct AcoshContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AcoshOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!AcoshOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -249,9 +248,7 @@ template <typename fnT, typename T> struct AcoshStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AcoshOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!AcoshOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/add.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/add.hpp
index e77068b5e1..c06e98f3e5 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/add.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/add.hpp
@@ -132,8 +132,7 @@ using AddStridedFunctor =
 
 template <typename T1, typename T2> struct AddOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1, bool, T2, bool, bool>,
         td_ns::BinaryTypeMapResultEntry<T1,
                                         std::uint8_t,
@@ -193,6 +192,8 @@ template <typename T1, typename T2> struct AddOutputType
                                         std::complex<double>,
                                         std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -223,9 +224,7 @@ template <typename fnT, typename T1, typename T2> struct AddContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AddOutputType<T1, T2>::value_type,
-                                     void>)
-        {
+        if constexpr (!AddOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -273,9 +272,7 @@ template <typename fnT, typename T1, typename T2> struct AddStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AddOutputType<T1, T2>::value_type,
-                                     void>)
-        {
+        if constexpr (!AddOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -324,12 +321,12 @@ struct AddContigMatrixContigRowBroadcastFactory
 {
     fnT get()
     {
-        using resT = typename AddOutputType<T1, T2>::value_type;
-        if constexpr (std::is_same_v<resT, void>) {
+        if constexpr (!AddOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
         else {
+            using resT = typename AddOutputType<T1, T2>::value_type;
             if constexpr (dpctl::tensor::type_utils::is_complex<T1>::value ||
                           dpctl::tensor::type_utils::is_complex<T2>::value ||
                           dpctl::tensor::type_utils::is_complex<resT>::value)
@@ -371,12 +368,12 @@ struct AddContigRowContigMatrixBroadcastFactory
 {
     fnT get()
     {
-        using resT = typename AddOutputType<T1, T2>::value_type;
-        if constexpr (std::is_same_v<resT, void>) {
+        if constexpr (!AddOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
         else {
+            using resT = typename AddOutputType<T1, T2>::value_type;
             if constexpr (dpctl::tensor::type_utils::is_complex<T1>::value ||
                           dpctl::tensor::type_utils::is_complex<T2>::value ||
                           dpctl::tensor::type_utils::is_complex<resT>::value)
@@ -438,6 +435,50 @@ template <typename argT,
           unsigned int n_vecs>
 class add_inplace_contig_kernel;
 
+/* @brief Types supported by in-place add */
+template <typename argTy, typename resTy> struct AddInplaceTypePairSupport
+{
+    /* value if true a kernel for <argTy, resTy> must be instantiated  */
+    static constexpr bool is_defined = std::disjunction<
+        td_ns::TypePairDefinedEntry<argTy, bool, resTy, bool>,
+        td_ns::TypePairDefinedEntry<argTy, std::int8_t, resTy, std::int8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint8_t, resTy, std::uint8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int16_t, resTy, std::int16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint16_t, resTy, std::uint16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int32_t, resTy, std::int32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint32_t, resTy, std::uint32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int64_t, resTy, std::int64_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint64_t, resTy, std::uint64_t>,
+        td_ns::TypePairDefinedEntry<argTy, sycl::half, resTy, sycl::half>,
+        td_ns::TypePairDefinedEntry<argTy, float, resTy, float>,
+        td_ns::TypePairDefinedEntry<argTy, double, resTy, double>,
+        td_ns::TypePairDefinedEntry<argTy,
+                                    std::complex<float>,
+                                    resTy,
+                                    std::complex<float>>,
+        td_ns::TypePairDefinedEntry<argTy,
+                                    std::complex<double>,
+                                    resTy,
+                                    std::complex<double>>,
+        // fall-through
+        td_ns::NotDefinedEntry>::is_defined;
+};
+
+template <typename fnT, typename argT, typename resT>
+struct AddInplaceTypeMapFactory
+{
+    /*! @brief get typeid for output type of x += y */
+    std::enable_if_t<std::is_same<fnT, int>::value, int> get()
+    {
+        if constexpr (AddInplaceTypePairSupport<argT, resT>::is_defined) {
+            return td_ns::GetTypeid<resT>{}.get();
+        }
+        else {
+            return td_ns::GetTypeid<void>{}.get();
+        }
+    }
+};
+
 template <typename argTy, typename resTy>
 sycl::event
 add_inplace_contig_impl(sycl::queue &exec_q,
@@ -457,9 +498,7 @@ template <typename fnT, typename T1, typename T2> struct AddInplaceContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AddOutputType<T1, T2>::value_type,
-                                     void>)
-        {
+        if constexpr (!AddInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -497,9 +536,7 @@ struct AddInplaceStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AddOutputType<T1, T2>::value_type,
-                                     void>)
-        {
+        if constexpr (!AddInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -544,8 +581,7 @@ struct AddInplaceRowMatrixBroadcastFactory
 {
     fnT get()
     {
-        using resT = typename AddOutputType<T1, T2>::value_type;
-        if constexpr (!std::is_same_v<resT, T2>) {
+        if constexpr (!AddInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/angle.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/angle.hpp
index 9622a7a207..034b71438f 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/angle.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/angle.hpp
@@ -91,11 +91,12 @@ using AngleStridedFunctor = elementwise_common::
 
 template <typename T> struct AngleOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, std::complex<float>, float>,
         td_ns::TypeMapResultEntry<T, std::complex<double>, double>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -117,9 +118,7 @@ template <typename fnT, typename T> struct AngleContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AngleOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!AngleOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -165,9 +164,7 @@ template <typename fnT, typename T> struct AngleStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AngleOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!AngleOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/asin.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/asin.hpp
index 3a0d6efecf..35c381aa84 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/asin.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/asin.hpp
@@ -165,14 +165,15 @@ using AsinStridedFunctor = elementwise_common::
 
 template <typename T> struct AsinOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half>,
         td_ns::TypeMapResultEntry<T, float>,
         td_ns::TypeMapResultEntry<T, double>,
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -194,9 +195,7 @@ template <typename fnT, typename T> struct AsinContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AsinOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!AsinOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -242,9 +241,7 @@ template <typename fnT, typename T> struct AsinStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AsinOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!AsinOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/asinh.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/asinh.hpp
index d64f3f0233..7373dc39d5 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/asinh.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/asinh.hpp
@@ -148,14 +148,15 @@ using AsinhStridedFunctor = elementwise_common::
 
 template <typename T> struct AsinhOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half>,
         td_ns::TypeMapResultEntry<T, float>,
         td_ns::TypeMapResultEntry<T, double>,
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -177,9 +178,7 @@ template <typename fnT, typename T> struct AsinhContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AsinhOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!AsinhOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -225,9 +224,7 @@ template <typename fnT, typename T> struct AsinhStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AsinhOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!AsinhOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/atan.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/atan.hpp
index 64cd3c316f..fbba3fc436 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/atan.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/atan.hpp
@@ -155,14 +155,15 @@ using AtanStridedFunctor = elementwise_common::
 
 template <typename T> struct AtanOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half>,
         td_ns::TypeMapResultEntry<T, float>,
         td_ns::TypeMapResultEntry<T, double>,
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -184,9 +185,7 @@ template <typename fnT, typename T> struct AtanContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AtanOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!AtanOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -232,9 +231,7 @@ template <typename fnT, typename T> struct AtanStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AtanOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!AtanOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/atan2.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/atan2.hpp
index f5cacb9178..1a694527dd 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/atan2.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/atan2.hpp
@@ -90,8 +90,7 @@ using Atan2StridedFunctor =
 
 template <typename T1, typename T2> struct Atan2OutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1,
                                         sycl::half,
                                         T2,
@@ -100,6 +99,8 @@ template <typename T1, typename T2> struct Atan2OutputType
         td_ns::BinaryTypeMapResultEntry<T1, float, T2, float, float>,
         td_ns::BinaryTypeMapResultEntry<T1, double, T2, double, double>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -130,9 +131,7 @@ template <typename fnT, typename T1, typename T2> struct Atan2ContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename Atan2OutputType<T1, T2>::value_type, void>)
-        {
+        if constexpr (!Atan2OutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -149,7 +148,6 @@ template <typename fnT, typename T1, typename T2> struct Atan2TypeMapFactory
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename Atan2OutputType<T1, T2>::value_type;
-        ;
         return td_ns::GetTypeid<rT>{}.get();
     }
 };
@@ -183,9 +181,7 @@ template <typename fnT, typename T1, typename T2> struct Atan2StridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename Atan2OutputType<T1, T2>::value_type, void>)
-        {
+        if constexpr (!Atan2OutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/atanh.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/atanh.hpp
index 5002a18b19..340e72b11c 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/atanh.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/atanh.hpp
@@ -149,14 +149,15 @@ using AtanhStridedFunctor = elementwise_common::
 
 template <typename T> struct AtanhOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half>,
         td_ns::TypeMapResultEntry<T, float>,
         td_ns::TypeMapResultEntry<T, double>,
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -178,9 +179,7 @@ template <typename fnT, typename T> struct AtanhContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AtanhOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!AtanhOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -226,9 +225,7 @@ template <typename fnT, typename T> struct AtanhStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename AtanhOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!AtanhOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_and.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_and.hpp
index ffe80f622e..da32b17183 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_and.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_and.hpp
@@ -113,9 +113,7 @@ using BitwiseAndStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct BitwiseAndOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by
-                                                  // DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1, bool, T2, bool, bool>,
         td_ns::BinaryTypeMapResultEntry<T1,
                                         std::uint8_t,
@@ -158,6 +156,8 @@ template <typename T1, typename T2> struct BitwiseAndOutputType
                                         std::int64_t,
                                         std::int64_t>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -189,10 +189,7 @@ template <typename fnT, typename T1, typename T2> struct BitwiseAndContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename BitwiseAndOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!BitwiseAndOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -245,10 +242,7 @@ struct BitwiseAndStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename BitwiseAndOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!BitwiseAndOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -322,6 +316,41 @@ template <typename argT,
           unsigned int n_vecs>
 class bitwise_and_inplace_contig_kernel;
 
+/* @brief Types supported by in-place bitwise AND */
+template <typename argTy, typename resTy>
+struct BitwiseAndInplaceTypePairSupport
+{
+    /* value if true a kernel for <argTy, resTy> must be instantiated  */
+    static constexpr bool is_defined = std::disjunction<
+        td_ns::TypePairDefinedEntry<argTy, bool, resTy, bool>,
+        td_ns::TypePairDefinedEntry<argTy, std::int8_t, resTy, std::int8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint8_t, resTy, std::uint8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int16_t, resTy, std::int16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint16_t, resTy, std::uint16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int32_t, resTy, std::int32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint32_t, resTy, std::uint32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int64_t, resTy, std::int64_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint64_t, resTy, std::uint64_t>,
+        // fall-through
+        td_ns::NotDefinedEntry>::is_defined;
+};
+
+template <typename fnT, typename argT, typename resT>
+struct BitwiseAndInplaceTypeMapFactory
+{
+    /*! @brief get typeid for output type of x &= y */
+    std::enable_if_t<std::is_same<fnT, int>::value, int> get()
+    {
+        if constexpr (BitwiseAndInplaceTypePairSupport<argT, resT>::is_defined)
+        {
+            return td_ns::GetTypeid<resT>{}.get();
+        }
+        else {
+            return td_ns::GetTypeid<void>{}.get();
+        }
+    }
+};
+
 template <typename argTy, typename resTy>
 sycl::event
 bitwise_and_inplace_contig_impl(sycl::queue &exec_q,
@@ -343,10 +372,7 @@ struct BitwiseAndInplaceContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename BitwiseAndOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!BitwiseAndInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -385,10 +411,7 @@ struct BitwiseAndInplaceStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename BitwiseAndOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!BitwiseAndInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_invert.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_invert.hpp
index 6def3a511c..d6c1bc72db 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_invert.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_invert.hpp
@@ -100,8 +100,7 @@ using BitwiseInvertStridedFunctor =
 
 template <typename argTy> struct BitwiseInvertOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<argTy, bool>,
         td_ns::TypeMapResultEntry<argTy, std::uint8_t>,
         td_ns::TypeMapResultEntry<argTy, std::uint16_t>,
@@ -112,6 +111,8 @@ template <typename argTy> struct BitwiseInvertOutputType
         td_ns::TypeMapResultEntry<argTy, std::int32_t>,
         td_ns::TypeMapResultEntry<argTy, std::int64_t>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -135,10 +136,7 @@ template <typename fnT, typename T> struct BitwiseInvertContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename BitwiseInvertOutputType<T>::value_type,
-                          void>)
-        {
+        if constexpr (!BitwiseInvertOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -186,10 +184,7 @@ template <typename fnT, typename T> struct BitwiseInvertStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename BitwiseInvertOutputType<T>::value_type,
-                          void>)
-        {
+        if constexpr (!BitwiseInvertOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_left_shift.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_left_shift.hpp
index 18a87e5287..a987c8d604 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_left_shift.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_left_shift.hpp
@@ -123,9 +123,7 @@ using BitwiseLeftShiftStridedFunctor = elementwise_common::BinaryStridedFunctor<
 template <typename T1, typename T2> struct BitwiseLeftShiftOutputType
 {
     using ResT = T1;
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by
-                                                  // DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1,
                                         std::int8_t,
                                         T2,
@@ -167,6 +165,8 @@ template <typename T1, typename T2> struct BitwiseLeftShiftOutputType
                                         std::uint64_t,
                                         std::uint64_t>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -200,10 +200,7 @@ struct BitwiseLeftShiftContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename BitwiseLeftShiftOutputType<
-                                         T1, T2>::value_type,
-                                     void>)
-        {
+        if constexpr (!BitwiseLeftShiftOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -256,10 +253,7 @@ struct BitwiseLeftShiftStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename BitwiseLeftShiftOutputType<
-                                         T1, T2>::value_type,
-                                     void>)
-        {
+        if constexpr (!BitwiseLeftShiftOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -336,6 +330,41 @@ template <typename argT,
           unsigned int n_vecs>
 class bitwise_left_shift_inplace_contig_kernel;
 
+/* @brief Types supported by in-place bitwise left shift */
+template <typename argTy, typename resTy>
+struct BitwiseLeftShiftInplaceTypePairSupport
+{
+    /* value if true a kernel for <argTy, resTy> must be instantiated  */
+    static constexpr bool is_defined = std::disjunction<
+        td_ns::TypePairDefinedEntry<argTy, std::int8_t, resTy, std::int8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint8_t, resTy, std::uint8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int16_t, resTy, std::int16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint16_t, resTy, std::uint16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int32_t, resTy, std::int32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint32_t, resTy, std::uint32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int64_t, resTy, std::int64_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint64_t, resTy, std::uint64_t>,
+        // fall-through
+        td_ns::NotDefinedEntry>::is_defined;
+};
+
+template <typename fnT, typename argT, typename resT>
+struct BitwiseLeftShiftInplaceTypeMapFactory
+{
+    /*! @brief get typeid for output type of x <<= y */
+    std::enable_if_t<std::is_same<fnT, int>::value, int> get()
+    {
+        if constexpr (BitwiseLeftShiftInplaceTypePairSupport<argT,
+                                                             resT>::is_defined)
+        {
+            return td_ns::GetTypeid<resT>{}.get();
+        }
+        else {
+            return td_ns::GetTypeid<void>{}.get();
+        }
+    }
+};
+
 template <typename argTy, typename resTy>
 sycl::event bitwise_left_shift_inplace_contig_impl(
     sycl::queue &exec_q,
@@ -357,9 +386,8 @@ struct BitwiseLeftShiftInplaceContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename BitwiseLeftShiftOutputType<
-                                         T1, T2>::value_type,
-                                     void>)
+        if constexpr (!BitwiseLeftShiftInplaceTypePairSupport<T1,
+                                                              T2>::is_defined)
         {
             fnT fn = nullptr;
             return fn;
@@ -399,9 +427,8 @@ struct BitwiseLeftShiftInplaceStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename BitwiseLeftShiftOutputType<
-                                         T1, T2>::value_type,
-                                     void>)
+        if constexpr (!BitwiseLeftShiftInplaceTypePairSupport<T1,
+                                                              T2>::is_defined)
         {
             fnT fn = nullptr;
             return fn;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_or.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_or.hpp
index aad31aae95..71f3e809d9 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_or.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_or.hpp
@@ -112,9 +112,7 @@ using BitwiseOrStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct BitwiseOrOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by
-                                                  // DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1, bool, T2, bool, bool>,
         td_ns::BinaryTypeMapResultEntry<T1,
                                         std::uint8_t,
@@ -157,6 +155,8 @@ template <typename T1, typename T2> struct BitwiseOrOutputType
                                         std::int64_t,
                                         std::int64_t>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -187,10 +187,7 @@ template <typename fnT, typename T1, typename T2> struct BitwiseOrContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename BitwiseOrOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!BitwiseOrOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -241,10 +238,7 @@ template <typename fnT, typename T1, typename T2> struct BitwiseOrStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename BitwiseOrOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!BitwiseOrOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -318,6 +312,39 @@ template <typename argT,
           unsigned int n_vecs>
 class bitwise_or_inplace_contig_kernel;
 
+/* @brief Types supported by in-place bitwise OR */
+template <typename argTy, typename resTy> struct BitwiseOrInplaceTypePairSupport
+{
+    /* value if true a kernel for <argTy, resTy> must be instantiated  */
+    static constexpr bool is_defined = std::disjunction<
+        td_ns::TypePairDefinedEntry<argTy, bool, resTy, bool>,
+        td_ns::TypePairDefinedEntry<argTy, std::int8_t, resTy, std::int8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint8_t, resTy, std::uint8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int16_t, resTy, std::int16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint16_t, resTy, std::uint16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int32_t, resTy, std::int32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint32_t, resTy, std::uint32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int64_t, resTy, std::int64_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint64_t, resTy, std::uint64_t>,
+        // fall-through
+        td_ns::NotDefinedEntry>::is_defined;
+};
+
+template <typename fnT, typename argT, typename resT>
+struct BitwiseOrInplaceTypeMapFactory
+{
+    /*! @brief get typeid for output type of x |= y */
+    std::enable_if_t<std::is_same<fnT, int>::value, int> get()
+    {
+        if constexpr (BitwiseOrInplaceTypePairSupport<argT, resT>::is_defined) {
+            return td_ns::GetTypeid<resT>{}.get();
+        }
+        else {
+            return td_ns::GetTypeid<void>{}.get();
+        }
+    }
+};
+
 template <typename argTy, typename resTy>
 sycl::event
 bitwise_or_inplace_contig_impl(sycl::queue &exec_q,
@@ -339,10 +366,7 @@ struct BitwiseOrInplaceContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename BitwiseOrOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!BitwiseOrInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -381,10 +405,7 @@ struct BitwiseOrInplaceStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename BitwiseOrOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!BitwiseOrInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_right_shift.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_right_shift.hpp
index 2fbee2e49d..e4dfee2ed6 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_right_shift.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_right_shift.hpp
@@ -125,9 +125,7 @@ using BitwiseRightShiftStridedFunctor =
 template <typename T1, typename T2> struct BitwiseRightShiftOutputType
 {
     using ResT = T1;
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by
-                                                  // DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1,
                                         std::int8_t,
                                         T2,
@@ -169,6 +167,8 @@ template <typename T1, typename T2> struct BitwiseRightShiftOutputType
                                         std::uint64_t,
                                         std::uint64_t>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -202,10 +202,7 @@ struct BitwiseRightShiftContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename BitwiseRightShiftOutputType<
-                                         T1, T2>::value_type,
-                                     void>)
-        {
+        if constexpr (!BitwiseRightShiftOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -258,10 +255,7 @@ struct BitwiseRightShiftStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename BitwiseRightShiftOutputType<
-                                         T1, T2>::value_type,
-                                     void>)
-        {
+        if constexpr (!BitwiseRightShiftOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -340,6 +334,41 @@ template <typename argT,
           unsigned int n_vecs>
 class bitwise_right_shift_inplace_contig_kernel;
 
+/* @brief Types supported by in-place bitwise right shift */
+template <typename argTy, typename resTy>
+struct BitwiseRightShiftInplaceTypePairSupport
+{
+    /* value if true a kernel for <argTy, resTy> must be instantiated  */
+    static constexpr bool is_defined = std::disjunction<
+        td_ns::TypePairDefinedEntry<argTy, std::int8_t, resTy, std::int8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint8_t, resTy, std::uint8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int16_t, resTy, std::int16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint16_t, resTy, std::uint16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int32_t, resTy, std::int32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint32_t, resTy, std::uint32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int64_t, resTy, std::int64_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint64_t, resTy, std::uint64_t>,
+        // fall-through
+        td_ns::NotDefinedEntry>::is_defined;
+};
+
+template <typename fnT, typename argT, typename resT>
+struct BitwiseRightShiftInplaceTypeMapFactory
+{
+    /*! @brief get typeid for output type of x >>= y */
+    std::enable_if_t<std::is_same<fnT, int>::value, int> get()
+    {
+        if constexpr (BitwiseRightShiftInplaceTypePairSupport<argT,
+                                                              resT>::is_defined)
+        {
+            return td_ns::GetTypeid<resT>{}.get();
+        }
+        else {
+            return td_ns::GetTypeid<void>{}.get();
+        }
+    }
+};
+
 template <typename argTy, typename resTy>
 sycl::event bitwise_right_shift_inplace_contig_impl(
     sycl::queue &exec_q,
@@ -361,9 +390,8 @@ struct BitwiseRightShiftInplaceContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename BitwiseRightShiftOutputType<
-                                         T1, T2>::value_type,
-                                     void>)
+        if constexpr (!BitwiseRightShiftInplaceTypePairSupport<T1,
+                                                               T2>::is_defined)
         {
             fnT fn = nullptr;
             return fn;
@@ -403,9 +431,8 @@ struct BitwiseRightShiftInplaceStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename BitwiseRightShiftOutputType<
-                                         T1, T2>::value_type,
-                                     void>)
+        if constexpr (!BitwiseRightShiftInplaceTypePairSupport<T1,
+                                                               T2>::is_defined)
         {
             fnT fn = nullptr;
             return fn;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_xor.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_xor.hpp
index fd0ca880c9..d035b31170 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_xor.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/bitwise_xor.hpp
@@ -113,9 +113,7 @@ using BitwiseXorStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct BitwiseXorOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by
-                                                  // DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1, bool, T2, bool, bool>,
         td_ns::BinaryTypeMapResultEntry<T1,
                                         std::uint8_t,
@@ -158,6 +156,8 @@ template <typename T1, typename T2> struct BitwiseXorOutputType
                                         std::int64_t,
                                         std::int64_t>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -189,10 +189,7 @@ template <typename fnT, typename T1, typename T2> struct BitwiseXorContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename BitwiseXorOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!BitwiseXorOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -245,10 +242,7 @@ struct BitwiseXorStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename BitwiseXorOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!BitwiseXorOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -322,6 +316,41 @@ template <typename argT,
           unsigned int n_vecs>
 class bitwise_xor_inplace_contig_kernel;
 
+/* @brief Types supported by in-place bitwise XOR */
+template <typename argTy, typename resTy>
+struct BitwiseXorInplaceTypePairSupport
+{
+    /* value if true a kernel for <argTy, resTy> must be instantiated  */
+    static constexpr bool is_defined = std::disjunction<
+        td_ns::TypePairDefinedEntry<argTy, bool, resTy, bool>,
+        td_ns::TypePairDefinedEntry<argTy, std::int8_t, resTy, std::int8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint8_t, resTy, std::uint8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int16_t, resTy, std::int16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint16_t, resTy, std::uint16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int32_t, resTy, std::int32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint32_t, resTy, std::uint32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int64_t, resTy, std::int64_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint64_t, resTy, std::uint64_t>,
+        // fall-through
+        td_ns::NotDefinedEntry>::is_defined;
+};
+
+template <typename fnT, typename argT, typename resT>
+struct BitwiseXorInplaceTypeMapFactory
+{
+    /*! @brief get typeid for output type of x ^= y */
+    std::enable_if_t<std::is_same<fnT, int>::value, int> get()
+    {
+        if constexpr (BitwiseXorInplaceTypePairSupport<argT, resT>::is_defined)
+        {
+            return td_ns::GetTypeid<resT>{}.get();
+        }
+        else {
+            return td_ns::GetTypeid<void>{}.get();
+        }
+    }
+};
+
 template <typename argTy, typename resTy>
 sycl::event
 bitwise_xor_inplace_contig_impl(sycl::queue &exec_q,
@@ -343,10 +372,7 @@ struct BitwiseXorInplaceContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename BitwiseXorOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!BitwiseXorInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -385,10 +411,7 @@ struct BitwiseXorInplaceStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename BitwiseXorOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!BitwiseXorInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/cbrt.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/cbrt.hpp
index 083b7bee9d..4f2634f17a 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/cbrt.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/cbrt.hpp
@@ -82,12 +82,13 @@ using CbrtStridedFunctor = elementwise_common::
 
 template <typename T> struct CbrtOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half, sycl::half>,
         td_ns::TypeMapResultEntry<T, float, float>,
         td_ns::TypeMapResultEntry<T, double, double>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -109,9 +110,7 @@ template <typename fnT, typename T> struct CbrtContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename CbrtOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!CbrtOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -157,9 +156,7 @@ template <typename fnT, typename T> struct CbrtStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename CbrtOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!CbrtOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/ceil.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/ceil.hpp
index 3cb90df632..59bc630720 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/ceil.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/ceil.hpp
@@ -95,20 +95,21 @@ using CeilStridedFunctor = elementwise_common::
 
 template <typename T> struct CeilOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
-        td_ns::TypeMapResultEntry<T, std::uint8_t>,
-        td_ns::TypeMapResultEntry<T, std::uint16_t>,
-        td_ns::TypeMapResultEntry<T, std::uint32_t>,
-        td_ns::TypeMapResultEntry<T, std::uint64_t>,
-        td_ns::TypeMapResultEntry<T, std::int8_t>,
-        td_ns::TypeMapResultEntry<T, std::int16_t>,
-        td_ns::TypeMapResultEntry<T, std::int32_t>,
-        td_ns::TypeMapResultEntry<T, std::int64_t>,
-        td_ns::TypeMapResultEntry<T, sycl::half>,
-        td_ns::TypeMapResultEntry<T, float>,
-        td_ns::TypeMapResultEntry<T, double>,
-        td_ns::DefaultResultEntry<void>>::result_type;
+    using value_type =
+        typename std::disjunction<td_ns::TypeMapResultEntry<T, std::uint8_t>,
+                                  td_ns::TypeMapResultEntry<T, std::uint16_t>,
+                                  td_ns::TypeMapResultEntry<T, std::uint32_t>,
+                                  td_ns::TypeMapResultEntry<T, std::uint64_t>,
+                                  td_ns::TypeMapResultEntry<T, std::int8_t>,
+                                  td_ns::TypeMapResultEntry<T, std::int16_t>,
+                                  td_ns::TypeMapResultEntry<T, std::int32_t>,
+                                  td_ns::TypeMapResultEntry<T, std::int64_t>,
+                                  td_ns::TypeMapResultEntry<T, sycl::half>,
+                                  td_ns::TypeMapResultEntry<T, float>,
+                                  td_ns::TypeMapResultEntry<T, double>,
+                                  td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -130,9 +131,7 @@ template <typename fnT, typename T> struct CeilContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename CeilOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!CeilOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -178,9 +177,7 @@ template <typename fnT, typename T> struct CeilStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename CeilOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!CeilOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/conj.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/conj.hpp
index 5348173856..4953feedb2 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/conj.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/conj.hpp
@@ -99,8 +99,7 @@ using ConjStridedFunctor = elementwise_common::
 
 template <typename T> struct ConjOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, bool, int8_t>,
         td_ns::TypeMapResultEntry<T, std::uint8_t>,
         td_ns::TypeMapResultEntry<T, std::uint16_t>,
@@ -116,6 +115,8 @@ template <typename T> struct ConjOutputType
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -137,9 +138,7 @@ template <typename fnT, typename T> struct ConjContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename ConjOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!ConjOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -185,9 +184,7 @@ template <typename fnT, typename T> struct ConjStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename ConjOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!ConjOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/copysign.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/copysign.hpp
index d226422494..92997b572b 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/copysign.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/copysign.hpp
@@ -104,8 +104,7 @@ using CopysignStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct CopysignOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1,
                                         sycl::half,
                                         T2,
@@ -114,6 +113,8 @@ template <typename T1, typename T2> struct CopysignOutputType
         td_ns::BinaryTypeMapResultEntry<T1, float, T2, float, float>,
         td_ns::BinaryTypeMapResultEntry<T1, double, T2, double, double>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -144,10 +145,7 @@ template <typename fnT, typename T1, typename T2> struct CopysignContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename CopysignOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!CopysignOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -197,10 +195,7 @@ template <typename fnT, typename T1, typename T2> struct CopysignStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename CopysignOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!CopysignOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/cos.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/cos.hpp
index 14b2345788..8b6b0c5fbe 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/cos.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/cos.hpp
@@ -180,8 +180,7 @@ using CosStridedFunctor = elementwise_common::
 
 template <typename T> struct CosOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half, sycl::half>,
         td_ns::TypeMapResultEntry<T, float, float>,
         td_ns::TypeMapResultEntry<T, double, double>,
@@ -189,6 +188,8 @@ template <typename T> struct CosOutputType
         td_ns::
             TypeMapResultEntry<T, std::complex<double>, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -210,9 +211,7 @@ template <typename fnT, typename T> struct CosContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename CosOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!CosOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -257,9 +256,7 @@ template <typename fnT, typename T> struct CosStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename CosOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!CosOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/cosh.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/cosh.hpp
index 866bd2731d..cff1038ed9 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/cosh.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/cosh.hpp
@@ -170,14 +170,15 @@ using CoshStridedFunctor = elementwise_common::
 
 template <typename T> struct CoshOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half>,
         td_ns::TypeMapResultEntry<T, float>,
         td_ns::TypeMapResultEntry<T, double>,
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -199,9 +200,7 @@ template <typename fnT, typename T> struct CoshContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename CoshOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!CoshOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -247,9 +246,7 @@ template <typename fnT, typename T> struct CoshStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename CoshOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!CoshOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/equal.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/equal.hpp
index 5086a89cec..d368658afc 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/equal.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/equal.hpp
@@ -141,8 +141,7 @@ using EqualStridedFunctor =
 
 template <typename T1, typename T2> struct EqualOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1, bool, T2, bool, bool>,
         td_ns::
             BinaryTypeMapResultEntry<T1, std::uint8_t, T2, std::uint8_t, bool>,
@@ -186,6 +185,8 @@ template <typename T1, typename T2> struct EqualOutputType
                                         std::complex<double>,
                                         bool>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -216,9 +217,7 @@ template <typename fnT, typename T1, typename T2> struct EqualContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename EqualOutputType<T1, T2>::value_type, void>)
-        {
+        if constexpr (!EqualOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -268,9 +267,7 @@ template <typename fnT, typename T1, typename T2> struct EqualStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename EqualOutputType<T1, T2>::value_type, void>)
-        {
+        if constexpr (!EqualOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/exp.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/exp.hpp
index 38abed80cb..7e613c9731 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/exp.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/exp.hpp
@@ -139,14 +139,15 @@ using ExpStridedFunctor = elementwise_common::
 
 template <typename T> struct ExpOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half>,
         td_ns::TypeMapResultEntry<T, float>,
         td_ns::TypeMapResultEntry<T, double>,
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -168,9 +169,7 @@ template <typename fnT, typename T> struct ExpContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename ExpOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!ExpOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -215,9 +214,7 @@ template <typename fnT, typename T> struct ExpStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename ExpOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!ExpOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/exp2.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/exp2.hpp
index 9d244a0375..b436bb3855 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/exp2.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/exp2.hpp
@@ -141,14 +141,15 @@ using Exp2StridedFunctor = elementwise_common::
 
 template <typename T> struct Exp2OutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half>,
         td_ns::TypeMapResultEntry<T, float>,
         td_ns::TypeMapResultEntry<T, double>,
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -170,9 +171,7 @@ template <typename fnT, typename T> struct Exp2ContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename Exp2OutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!Exp2OutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -218,9 +217,7 @@ template <typename fnT, typename T> struct Exp2StridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename Exp2OutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!Exp2OutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/expm1.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/expm1.hpp
index 2ab077ab76..9a9d0a1562 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/expm1.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/expm1.hpp
@@ -153,8 +153,7 @@ using Expm1StridedFunctor = elementwise_common::
 
 template <typename T> struct Expm1OutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half, sycl::half>,
         td_ns::TypeMapResultEntry<T, float, float>,
         td_ns::TypeMapResultEntry<T, double, double>,
@@ -162,6 +161,8 @@ template <typename T> struct Expm1OutputType
         td_ns::
             TypeMapResultEntry<T, std::complex<double>, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -183,9 +184,7 @@ template <typename fnT, typename T> struct Expm1ContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename Expm1OutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!Expm1OutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -202,7 +201,6 @@ template <typename fnT, typename T> struct Expm1TypeMapFactory
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename Expm1OutputType<T>::value_type;
-        ;
         return td_ns::GetTypeid<rT>{}.get();
     }
 };
@@ -232,9 +230,7 @@ template <typename fnT, typename T> struct Expm1StridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename Expm1OutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!Expm1OutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/floor.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/floor.hpp
index 90e6941bdd..530dd3d9aa 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/floor.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/floor.hpp
@@ -95,20 +95,21 @@ using FloorStridedFunctor = elementwise_common::
 
 template <typename T> struct FloorOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
-        td_ns::TypeMapResultEntry<T, std::uint8_t>,
-        td_ns::TypeMapResultEntry<T, std::uint16_t>,
-        td_ns::TypeMapResultEntry<T, std::uint32_t>,
-        td_ns::TypeMapResultEntry<T, std::uint64_t>,
-        td_ns::TypeMapResultEntry<T, std::int8_t>,
-        td_ns::TypeMapResultEntry<T, std::int16_t>,
-        td_ns::TypeMapResultEntry<T, std::int32_t>,
-        td_ns::TypeMapResultEntry<T, std::int64_t>,
-        td_ns::TypeMapResultEntry<T, sycl::half>,
-        td_ns::TypeMapResultEntry<T, float>,
-        td_ns::TypeMapResultEntry<T, double>,
-        td_ns::DefaultResultEntry<void>>::result_type;
+    using value_type =
+        typename std::disjunction<td_ns::TypeMapResultEntry<T, std::uint8_t>,
+                                  td_ns::TypeMapResultEntry<T, std::uint16_t>,
+                                  td_ns::TypeMapResultEntry<T, std::uint32_t>,
+                                  td_ns::TypeMapResultEntry<T, std::uint64_t>,
+                                  td_ns::TypeMapResultEntry<T, std::int8_t>,
+                                  td_ns::TypeMapResultEntry<T, std::int16_t>,
+                                  td_ns::TypeMapResultEntry<T, std::int32_t>,
+                                  td_ns::TypeMapResultEntry<T, std::int64_t>,
+                                  td_ns::TypeMapResultEntry<T, sycl::half>,
+                                  td_ns::TypeMapResultEntry<T, float>,
+                                  td_ns::TypeMapResultEntry<T, double>,
+                                  td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -130,9 +131,7 @@ template <typename fnT, typename T> struct FloorContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename FloorOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!FloorOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -178,9 +177,7 @@ template <typename fnT, typename T> struct FloorStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename FloorOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!FloorOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/floor_divide.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/floor_divide.hpp
index ce89b0778f..72ee3a789a 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/floor_divide.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/floor_divide.hpp
@@ -148,8 +148,7 @@ using FloorDivideStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct FloorDivideOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1,
                                         std::uint8_t,
                                         T2,
@@ -198,6 +197,8 @@ template <typename T1, typename T2> struct FloorDivideOutputType
         td_ns::BinaryTypeMapResultEntry<T1, float, T2, float, float>,
         td_ns::BinaryTypeMapResultEntry<T1, double, T2, double, double>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -230,10 +231,7 @@ struct FloorDivideContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename FloorDivideOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!FloorDivideOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -285,10 +283,7 @@ struct FloorDivideStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename FloorDivideOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!FloorDivideOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -398,6 +393,43 @@ template <typename argT,
           unsigned int n_vecs>
 class floor_divide_inplace_contig_kernel;
 
+/* @brief Types supported by in-place floor division */
+template <typename argTy, typename resTy>
+struct FloorDivideInplaceTypePairSupport
+{
+    /* value if true a kernel for <argTy, resTy> must be instantiated  */
+    static constexpr bool is_defined = std::disjunction<
+        td_ns::TypePairDefinedEntry<argTy, std::int8_t, resTy, std::int8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint8_t, resTy, std::uint8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int16_t, resTy, std::int16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint16_t, resTy, std::uint16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int32_t, resTy, std::int32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint32_t, resTy, std::uint32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int64_t, resTy, std::int64_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint64_t, resTy, std::uint64_t>,
+        td_ns::TypePairDefinedEntry<argTy, sycl::half, resTy, sycl::half>,
+        td_ns::TypePairDefinedEntry<argTy, float, resTy, float>,
+        td_ns::TypePairDefinedEntry<argTy, double, resTy, double>,
+        // fall-through
+        td_ns::NotDefinedEntry>::is_defined;
+};
+
+template <typename fnT, typename argT, typename resT>
+struct FloorDivideInplaceTypeMapFactory
+{
+    /*! @brief get typeid for output type of x //= y */
+    std::enable_if_t<std::is_same<fnT, int>::value, int> get()
+    {
+        if constexpr (FloorDivideInplaceTypePairSupport<argT, resT>::is_defined)
+        {
+            return td_ns::GetTypeid<resT>{}.get();
+        }
+        else {
+            return td_ns::GetTypeid<void>{}.get();
+        }
+    }
+};
+
 template <typename argTy, typename resTy>
 sycl::event
 floor_divide_inplace_contig_impl(sycl::queue &exec_q,
@@ -419,10 +451,7 @@ struct FloorDivideInplaceContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename FloorDivideOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!FloorDivideInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -461,10 +490,7 @@ struct FloorDivideInplaceStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename FloorDivideOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!FloorDivideInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/greater.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/greater.hpp
index ea53d575ba..05c2a36b0c 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/greater.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/greater.hpp
@@ -142,8 +142,7 @@ using GreaterStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct GreaterOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1, bool, T2, bool, bool>,
         td_ns::
             BinaryTypeMapResultEntry<T1, std::uint8_t, T2, std::uint8_t, bool>,
@@ -187,6 +186,8 @@ template <typename T1, typename T2> struct GreaterOutputType
                                         std::complex<double>,
                                         bool>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -217,9 +218,7 @@ template <typename fnT, typename T1, typename T2> struct GreaterContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename GreaterOutputType<T1, T2>::value_type, void>)
-        {
+        if constexpr (!GreaterOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -269,9 +268,7 @@ template <typename fnT, typename T1, typename T2> struct GreaterStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename GreaterOutputType<T1, T2>::value_type, void>)
-        {
+        if constexpr (!GreaterOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/greater_equal.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/greater_equal.hpp
index b429a3d00c..43e4e98db1 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/greater_equal.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/greater_equal.hpp
@@ -143,8 +143,7 @@ using GreaterEqualStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct GreaterEqualOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1, bool, T2, bool, bool>,
         td_ns::
             BinaryTypeMapResultEntry<T1, std::uint8_t, T2, std::uint8_t, bool>,
@@ -188,6 +187,8 @@ template <typename T1, typename T2> struct GreaterEqualOutputType
                                         std::complex<double>,
                                         bool>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -221,10 +222,7 @@ struct GreaterEqualContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename GreaterEqualOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!GreaterEqualOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -276,10 +274,7 @@ struct GreaterEqualStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename GreaterEqualOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!GreaterEqualOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/hypot.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/hypot.hpp
index 52498f76d5..c5b68644a9 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/hypot.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/hypot.hpp
@@ -106,8 +106,7 @@ using HypotStridedFunctor =
 
 template <typename T1, typename T2> struct HypotOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1,
                                         sycl::half,
                                         T2,
@@ -116,6 +115,8 @@ template <typename T1, typename T2> struct HypotOutputType
         td_ns::BinaryTypeMapResultEntry<T1, float, T2, float, float>,
         td_ns::BinaryTypeMapResultEntry<T1, double, T2, double, double>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -146,9 +147,7 @@ template <typename fnT, typename T1, typename T2> struct HypotContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename HypotOutputType<T1, T2>::value_type, void>)
-        {
+        if constexpr (!HypotOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -165,7 +164,6 @@ template <typename fnT, typename T1, typename T2> struct HypotTypeMapFactory
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename HypotOutputType<T1, T2>::value_type;
-        ;
         return td_ns::GetTypeid<rT>{}.get();
     }
 };
@@ -199,9 +197,7 @@ template <typename fnT, typename T1, typename T2> struct HypotStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename HypotOutputType<T1, T2>::value_type, void>)
-        {
+        if constexpr (!HypotOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/imag.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/imag.hpp
index 6b937b3071..e918bc0ac7 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/imag.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/imag.hpp
@@ -95,8 +95,7 @@ using ImagStridedFunctor = elementwise_common::
 
 template <typename T> struct ImagOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, bool>,
         td_ns::TypeMapResultEntry<T, std::uint8_t>,
         td_ns::TypeMapResultEntry<T, std::uint16_t>,
@@ -112,6 +111,8 @@ template <typename T> struct ImagOutputType
         td_ns::TypeMapResultEntry<T, std::complex<float>, float>,
         td_ns::TypeMapResultEntry<T, std::complex<double>, double>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -133,9 +134,7 @@ template <typename fnT, typename T> struct ImagContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename ImagOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!ImagOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -181,9 +180,7 @@ template <typename fnT, typename T> struct ImagStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename ImagOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!ImagOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/less.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/less.hpp
index 88d0e6e19f..0b26342563 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/less.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/less.hpp
@@ -140,8 +140,7 @@ using LessStridedFunctor =
 
 template <typename T1, typename T2> struct LessOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1, bool, T2, bool, bool>,
         td_ns::
             BinaryTypeMapResultEntry<T1, std::uint8_t, T2, std::uint8_t, bool>,
@@ -185,6 +184,8 @@ template <typename T1, typename T2> struct LessOutputType
                                         std::complex<double>,
                                         bool>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -215,9 +216,7 @@ template <typename fnT, typename T1, typename T2> struct LessContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename LessOutputType<T1, T2>::value_type, void>)
-        {
+        if constexpr (!LessOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -267,9 +266,7 @@ template <typename fnT, typename T1, typename T2> struct LessStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename LessOutputType<T1, T2>::value_type, void>)
-        {
+        if constexpr (!LessOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/less_equal.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/less_equal.hpp
index 97400aa475..01289ae98f 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/less_equal.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/less_equal.hpp
@@ -141,8 +141,7 @@ using LessEqualStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct LessEqualOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1, bool, T2, bool, bool>,
         td_ns::
             BinaryTypeMapResultEntry<T1, std::uint8_t, T2, std::uint8_t, bool>,
@@ -186,6 +185,8 @@ template <typename T1, typename T2> struct LessEqualOutputType
                                         std::complex<double>,
                                         bool>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -216,10 +217,7 @@ template <typename fnT, typename T1, typename T2> struct LessEqualContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename LessEqualOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!LessEqualOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -269,10 +267,7 @@ template <typename fnT, typename T1, typename T2> struct LessEqualStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename LessEqualOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!LessEqualOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log.hpp
index 6a4fd4e34e..a3e28ef5d7 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log.hpp
@@ -95,8 +95,7 @@ using LogStridedFunctor = elementwise_common::
 
 template <typename T> struct LogOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half, sycl::half>,
         td_ns::TypeMapResultEntry<T, float, float>,
         td_ns::TypeMapResultEntry<T, double, double>,
@@ -104,6 +103,8 @@ template <typename T> struct LogOutputType
         td_ns::
             TypeMapResultEntry<T, std::complex<double>, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -125,9 +126,7 @@ template <typename fnT, typename T> struct LogContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename LogOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!LogOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -144,7 +143,6 @@ template <typename fnT, typename T> struct LogTypeMapFactory
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename LogOutputType<T>::value_type;
-        ;
         return td_ns::GetTypeid<rT>{}.get();
     }
 };
@@ -173,9 +171,7 @@ template <typename fnT, typename T> struct LogStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename LogOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!LogOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log10.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log10.hpp
index af2ad072c5..793b910f69 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log10.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log10.hpp
@@ -114,8 +114,7 @@ using Log10StridedFunctor = elementwise_common::
 
 template <typename T> struct Log10OutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half, sycl::half>,
         td_ns::TypeMapResultEntry<T, float, float>,
         td_ns::TypeMapResultEntry<T, double, double>,
@@ -123,6 +122,8 @@ template <typename T> struct Log10OutputType
         td_ns::
             TypeMapResultEntry<T, std::complex<double>, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -144,9 +145,7 @@ template <typename fnT, typename T> struct Log10ContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename Log10OutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!Log10OutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -163,7 +162,6 @@ template <typename fnT, typename T> struct Log10TypeMapFactory
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename Log10OutputType<T>::value_type;
-        ;
         return td_ns::GetTypeid<rT>{}.get();
     }
 };
@@ -193,9 +191,7 @@ template <typename fnT, typename T> struct Log10StridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename Log10OutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!Log10OutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log1p.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log1p.hpp
index fe08dc805f..19238e7e37 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log1p.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log1p.hpp
@@ -119,8 +119,7 @@ using Log1pStridedFunctor = elementwise_common::
 
 template <typename T> struct Log1pOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half, sycl::half>,
         td_ns::TypeMapResultEntry<T, float, float>,
         td_ns::TypeMapResultEntry<T, double, double>,
@@ -128,6 +127,8 @@ template <typename T> struct Log1pOutputType
         td_ns::
             TypeMapResultEntry<T, std::complex<double>, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -149,9 +150,7 @@ template <typename fnT, typename T> struct Log1pContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename Log1pOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!Log1pOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -168,7 +167,6 @@ template <typename fnT, typename T> struct Log1pTypeMapFactory
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename Log1pOutputType<T>::value_type;
-        ;
         return td_ns::GetTypeid<rT>{}.get();
     }
 };
@@ -198,9 +196,7 @@ template <typename fnT, typename T> struct Log1pStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename Log1pOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!Log1pOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log2.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log2.hpp
index d4ea0aca47..69d0022c72 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log2.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log2.hpp
@@ -115,8 +115,7 @@ using Log2StridedFunctor = elementwise_common::
 
 template <typename T> struct Log2OutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half, sycl::half>,
         td_ns::TypeMapResultEntry<T, float, float>,
         td_ns::TypeMapResultEntry<T, double, double>,
@@ -124,6 +123,8 @@ template <typename T> struct Log2OutputType
         td_ns::
             TypeMapResultEntry<T, std::complex<double>, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -145,9 +146,7 @@ template <typename fnT, typename T> struct Log2ContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename Log2OutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!Log2OutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -164,7 +163,6 @@ template <typename fnT, typename T> struct Log2TypeMapFactory
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename Log2OutputType<T>::value_type;
-        ;
         return td_ns::GetTypeid<rT>{}.get();
     }
 };
@@ -194,9 +192,7 @@ template <typename fnT, typename T> struct Log2StridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename Log2OutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!Log2OutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/logaddexp.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/logaddexp.hpp
index d94724edc6..b0be45ea54 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/logaddexp.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/logaddexp.hpp
@@ -121,8 +121,7 @@ using LogAddExpStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct LogAddExpOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1,
                                         sycl::half,
                                         T2,
@@ -131,6 +130,8 @@ template <typename T1, typename T2> struct LogAddExpOutputType
         td_ns::BinaryTypeMapResultEntry<T1, float, T2, float, float>,
         td_ns::BinaryTypeMapResultEntry<T1, double, T2, double, double>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -161,10 +162,7 @@ template <typename fnT, typename T1, typename T2> struct LogAddExpContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename LogAddExpOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!LogAddExpOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -181,7 +179,6 @@ template <typename fnT, typename T1, typename T2> struct LogAddExpTypeMapFactory
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename LogAddExpOutputType<T1, T2>::value_type;
-        ;
         return td_ns::GetTypeid<rT>{}.get();
     }
 };
@@ -215,10 +212,7 @@ template <typename fnT, typename T1, typename T2> struct LogAddExpStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename LogAddExpOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!LogAddExpOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/logical_and.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/logical_and.hpp
index 403a8a2799..f15caa02e6 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/logical_and.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/logical_and.hpp
@@ -115,9 +115,7 @@ using LogicalAndStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct LogicalAndOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by
-                                                  // DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1, bool, T2, bool, bool>,
         td_ns::
             BinaryTypeMapResultEntry<T1, std::uint8_t, T2, std::uint8_t, bool>,
@@ -157,6 +155,8 @@ template <typename T1, typename T2> struct LogicalAndOutputType
                                         std::complex<double>,
                                         bool>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -188,10 +188,7 @@ template <typename fnT, typename T1, typename T2> struct LogicalAndContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename LogicalAndOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!LogicalAndOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -244,10 +241,7 @@ struct LogicalAndStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename LogicalAndOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!LogicalAndOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/logical_or.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/logical_or.hpp
index 4706c7936c..43e02f2102 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/logical_or.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/logical_or.hpp
@@ -114,9 +114,7 @@ using LogicalOrStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct LogicalOrOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by
-                                                  // DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1, bool, T2, bool, bool>,
         td_ns::
             BinaryTypeMapResultEntry<T1, std::uint8_t, T2, std::uint8_t, bool>,
@@ -156,6 +154,8 @@ template <typename T1, typename T2> struct LogicalOrOutputType
                                         std::complex<double>,
                                         bool>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -186,10 +186,7 @@ template <typename fnT, typename T1, typename T2> struct LogicalOrContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename LogicalOrOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!LogicalOrOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -240,10 +237,7 @@ template <typename fnT, typename T1, typename T2> struct LogicalOrStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename LogicalOrOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!LogicalOrOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/logical_xor.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/logical_xor.hpp
index a444bc5395..dc41760985 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/logical_xor.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/logical_xor.hpp
@@ -116,9 +116,7 @@ using LogicalXorStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct LogicalXorOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by
-                                                  // DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1, bool, T2, bool, bool>,
         td_ns::
             BinaryTypeMapResultEntry<T1, std::uint8_t, T2, std::uint8_t, bool>,
@@ -158,6 +156,8 @@ template <typename T1, typename T2> struct LogicalXorOutputType
                                         std::complex<double>,
                                         bool>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -189,10 +189,7 @@ template <typename fnT, typename T1, typename T2> struct LogicalXorContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename LogicalXorOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!LogicalXorOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -245,10 +242,7 @@ struct LogicalXorStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename LogicalXorOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!LogicalXorOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/maximum.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/maximum.hpp
index 9081cd1c6a..e73704bad8 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/maximum.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/maximum.hpp
@@ -118,8 +118,7 @@ using MaximumStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct MaximumOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1, bool, T2, bool, bool>,
         td_ns::BinaryTypeMapResultEntry<T1,
                                         std::uint8_t,
@@ -179,6 +178,8 @@ template <typename T1, typename T2> struct MaximumOutputType
                                         std::complex<double>,
                                         std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -209,9 +210,7 @@ template <typename fnT, typename T1, typename T2> struct MaximumContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename MaximumOutputType<T1, T2>::value_type, void>)
-        {
+        if constexpr (!MaximumOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -228,7 +227,6 @@ template <typename fnT, typename T1, typename T2> struct MaximumTypeMapFactory
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename MaximumOutputType<T1, T2>::value_type;
-        ;
         return td_ns::GetTypeid<rT>{}.get();
     }
 };
@@ -262,9 +260,7 @@ template <typename fnT, typename T1, typename T2> struct MaximumStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename MaximumOutputType<T1, T2>::value_type, void>)
-        {
+        if constexpr (!MaximumOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/minimum.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/minimum.hpp
index f736697997..590c0b6486 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/minimum.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/minimum.hpp
@@ -118,8 +118,7 @@ using MinimumStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct MinimumOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1, bool, T2, bool, bool>,
         td_ns::BinaryTypeMapResultEntry<T1,
                                         std::uint8_t,
@@ -179,6 +178,8 @@ template <typename T1, typename T2> struct MinimumOutputType
                                         std::complex<double>,
                                         std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -209,9 +210,7 @@ template <typename fnT, typename T1, typename T2> struct MinimumContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename MinimumOutputType<T1, T2>::value_type, void>)
-        {
+        if constexpr (!MinimumOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -228,7 +227,6 @@ template <typename fnT, typename T1, typename T2> struct MinimumTypeMapFactory
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename MinimumOutputType<T1, T2>::value_type;
-        ;
         return td_ns::GetTypeid<rT>{}.get();
     }
 };
@@ -262,9 +260,7 @@ template <typename fnT, typename T1, typename T2> struct MinimumStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename MinimumOutputType<T1, T2>::value_type, void>)
-        {
+        if constexpr (!MinimumOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/multiply.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/multiply.hpp
index 147f62f53e..1af284f55b 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/multiply.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/multiply.hpp
@@ -120,8 +120,7 @@ using MultiplyStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct MultiplyOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1, bool, T2, bool, bool>,
         td_ns::BinaryTypeMapResultEntry<T1,
                                         std::uint8_t,
@@ -181,6 +180,8 @@ template <typename T1, typename T2> struct MultiplyOutputType
                                         std::complex<double>,
                                         std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -211,10 +212,7 @@ template <typename fnT, typename T1, typename T2> struct MultiplyContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename MultiplyOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!MultiplyOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -231,7 +229,6 @@ template <typename fnT, typename T1, typename T2> struct MultiplyTypeMapFactory
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename MultiplyOutputType<T1, T2>::value_type;
-        ;
         return td_ns::GetTypeid<rT>{}.get();
     }
 };
@@ -265,10 +262,7 @@ template <typename fnT, typename T1, typename T2> struct MultiplyStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename MultiplyOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!MultiplyOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -317,12 +311,12 @@ struct MultiplyContigMatrixContigRowBroadcastFactory
 {
     fnT get()
     {
-        using resT = typename MultiplyOutputType<T1, T2>::value_type;
-        if constexpr (std::is_same_v<resT, void>) {
+        if constexpr (!MultiplyOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
         else {
+            using resT = typename MultiplyOutputType<T1, T2>::value_type;
             if constexpr (dpctl::tensor::type_utils::is_complex<T1>::value ||
                           dpctl::tensor::type_utils::is_complex<T2>::value ||
                           dpctl::tensor::type_utils::is_complex<resT>::value)
@@ -365,12 +359,12 @@ struct MultiplyContigRowContigMatrixBroadcastFactory
 {
     fnT get()
     {
-        using resT = typename MultiplyOutputType<T1, T2>::value_type;
-        if constexpr (std::is_same_v<resT, void>) {
+        if constexpr (!MultiplyOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
         else {
+            using resT = typename MultiplyOutputType<T1, T2>::value_type;
             if constexpr (dpctl::tensor::type_utils::is_complex<T1>::value ||
                           dpctl::tensor::type_utils::is_complex<T2>::value ||
                           dpctl::tensor::type_utils::is_complex<resT>::value)
@@ -434,6 +428,50 @@ template <typename argT,
           unsigned int n_vecs>
 class multiply_inplace_contig_kernel;
 
+/* @brief Types supported by in-place multiplication */
+template <typename argTy, typename resTy> struct MultiplyInplaceTypePairSupport
+{
+    /* value if true a kernel for <argTy, resTy> must be instantiated  */
+    static constexpr bool is_defined = std::disjunction<
+        td_ns::TypePairDefinedEntry<argTy, bool, resTy, bool>,
+        td_ns::TypePairDefinedEntry<argTy, std::int8_t, resTy, std::int8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint8_t, resTy, std::uint8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int16_t, resTy, std::int16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint16_t, resTy, std::uint16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int32_t, resTy, std::int32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint32_t, resTy, std::uint32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int64_t, resTy, std::int64_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint64_t, resTy, std::uint64_t>,
+        td_ns::TypePairDefinedEntry<argTy, sycl::half, resTy, sycl::half>,
+        td_ns::TypePairDefinedEntry<argTy, float, resTy, float>,
+        td_ns::TypePairDefinedEntry<argTy, double, resTy, double>,
+        td_ns::TypePairDefinedEntry<argTy,
+                                    std::complex<float>,
+                                    resTy,
+                                    std::complex<float>>,
+        td_ns::TypePairDefinedEntry<argTy,
+                                    std::complex<double>,
+                                    resTy,
+                                    std::complex<double>>,
+        // fall-through
+        td_ns::NotDefinedEntry>::is_defined;
+};
+
+template <typename fnT, typename argT, typename resT>
+struct MultiplyInplaceTypeMapFactory
+{
+    /*! @brief get typeid for output type of x *= y */
+    std::enable_if_t<std::is_same<fnT, int>::value, int> get()
+    {
+        if constexpr (MultiplyInplaceTypePairSupport<argT, resT>::is_defined) {
+            return td_ns::GetTypeid<resT>{}.get();
+        }
+        else {
+            return td_ns::GetTypeid<void>{}.get();
+        }
+    }
+};
+
 template <typename argTy, typename resTy>
 sycl::event
 multiply_inplace_contig_impl(sycl::queue &exec_q,
@@ -455,10 +493,7 @@ struct MultiplyInplaceContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename MultiplyOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!MultiplyInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -497,10 +532,7 @@ struct MultiplyInplaceStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename MultiplyOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!MultiplyInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -545,8 +577,7 @@ struct MultiplyInplaceRowMatrixBroadcastFactory
 {
     fnT get()
     {
-        using resT = typename MultiplyOutputType<T1, T2>::value_type;
-        if constexpr (!std::is_same_v<resT, T2>) {
+        if constexpr (!MultiplyInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/negative.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/negative.hpp
index d52c2f33ee..83f17dd47b 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/negative.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/negative.hpp
@@ -78,8 +78,7 @@ using NegativeContigFunctor =
 
 template <typename T> struct NegativeOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, std::uint8_t>,
         td_ns::TypeMapResultEntry<T, std::uint16_t>,
         td_ns::TypeMapResultEntry<T, std::uint32_t>,
@@ -94,6 +93,8 @@ template <typename T> struct NegativeOutputType
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -116,9 +117,7 @@ template <typename fnT, typename T> struct NegativeContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename NegativeOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!NegativeOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -135,7 +134,6 @@ template <typename fnT, typename T> struct NegativeTypeMapFactory
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename NegativeOutputType<T>::value_type;
-        ;
         return td_ns::GetTypeid<rT>{}.get();
     }
 };
@@ -170,9 +168,7 @@ template <typename fnT, typename T> struct NegativeStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename NegativeOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!NegativeOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/nextafter.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/nextafter.hpp
index d5137f0c6d..5dc9ea40b3 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/nextafter.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/nextafter.hpp
@@ -104,8 +104,7 @@ using NextafterStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct NextafterOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1,
                                         sycl::half,
                                         T2,
@@ -114,6 +113,8 @@ template <typename T1, typename T2> struct NextafterOutputType
         td_ns::BinaryTypeMapResultEntry<T1, float, T2, float, float>,
         td_ns::BinaryTypeMapResultEntry<T1, double, T2, double, double>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -144,10 +145,7 @@ template <typename fnT, typename T1, typename T2> struct NextafterContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename NextafterOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!NextafterOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -164,7 +162,6 @@ template <typename fnT, typename T1, typename T2> struct NextafterTypeMapFactory
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename NextafterOutputType<T1, T2>::value_type;
-        ;
         return td_ns::GetTypeid<rT>{}.get();
     }
 };
@@ -198,10 +195,7 @@ template <typename fnT, typename T1, typename T2> struct NextafterStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename NextafterOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!NextafterOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/not_equal.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/not_equal.hpp
index 437ceb2da8..c1b920193b 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/not_equal.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/not_equal.hpp
@@ -125,8 +125,7 @@ using NotEqualStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct NotEqualOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1, bool, T2, bool, bool>,
         td_ns::
             BinaryTypeMapResultEntry<T1, std::uint8_t, T2, std::uint8_t, bool>,
@@ -170,6 +169,8 @@ template <typename T1, typename T2> struct NotEqualOutputType
                                         std::complex<double>,
                                         bool>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -200,10 +201,7 @@ template <typename fnT, typename T1, typename T2> struct NotEqualContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename NotEqualOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!NotEqualOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -253,10 +251,7 @@ template <typename fnT, typename T1, typename T2> struct NotEqualStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename NotEqualOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!NotEqualOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/positive.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/positive.hpp
index 92eaf3c0d2..ae2711ed0e 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/positive.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/positive.hpp
@@ -93,8 +93,7 @@ using PositiveContigFunctor =
 
 template <typename T> struct PositiveOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, std::uint8_t>,
         td_ns::TypeMapResultEntry<T, std::uint16_t>,
         td_ns::TypeMapResultEntry<T, std::uint32_t>,
@@ -109,6 +108,8 @@ template <typename T> struct PositiveOutputType
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -131,9 +132,7 @@ template <typename fnT, typename T> struct PositiveContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename PositiveOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!PositiveOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -150,7 +149,6 @@ template <typename fnT, typename T> struct PositiveTypeMapFactory
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename PositiveOutputType<T>::value_type;
-        ;
         return td_ns::GetTypeid<rT>{}.get();
     }
 };
@@ -185,9 +183,7 @@ template <typename fnT, typename T> struct PositiveStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename PositiveOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!PositiveOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/pow.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/pow.hpp
index a21b2d4318..bb462dceae 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/pow.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/pow.hpp
@@ -173,8 +173,7 @@ using PowStridedFunctor =
 
 template <typename T1, typename T2> struct PowOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1,
                                         std::uint8_t,
                                         T2,
@@ -233,6 +232,8 @@ template <typename T1, typename T2> struct PowOutputType
                                         std::complex<double>,
                                         std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -263,9 +264,7 @@ template <typename fnT, typename T1, typename T2> struct PowContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename PowOutputType<T1, T2>::value_type,
-                                     void>)
-        {
+        if constexpr (!PowOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -282,7 +281,6 @@ template <typename fnT, typename T1, typename T2> struct PowTypeMapFactory
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename PowOutputType<T1, T2>::value_type;
-        ;
         return td_ns::GetTypeid<rT>{}.get();
     }
 };
@@ -314,9 +312,7 @@ template <typename fnT, typename T1, typename T2> struct PowStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename PowOutputType<T1, T2>::value_type,
-                                     void>)
-        {
+        if constexpr (!PowOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -446,6 +442,49 @@ template <typename argT,
           unsigned int n_vecs>
 class pow_inplace_contig_kernel;
 
+/* @brief Types supported by in-place pow */
+template <typename argTy, typename resTy> struct PowInplaceTypePairSupport
+{
+    /* value if true a kernel for <argTy, resTy> must be instantiated  */
+    static constexpr bool is_defined = std::disjunction<
+        td_ns::TypePairDefinedEntry<argTy, std::int8_t, resTy, std::int8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint8_t, resTy, std::uint8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int16_t, resTy, std::int16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint16_t, resTy, std::uint16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int32_t, resTy, std::int32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint32_t, resTy, std::uint32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int64_t, resTy, std::int64_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint64_t, resTy, std::uint64_t>,
+        td_ns::TypePairDefinedEntry<argTy, sycl::half, resTy, sycl::half>,
+        td_ns::TypePairDefinedEntry<argTy, float, resTy, float>,
+        td_ns::TypePairDefinedEntry<argTy, double, resTy, double>,
+        td_ns::TypePairDefinedEntry<argTy,
+                                    std::complex<float>,
+                                    resTy,
+                                    std::complex<float>>,
+        td_ns::TypePairDefinedEntry<argTy,
+                                    std::complex<double>,
+                                    resTy,
+                                    std::complex<double>>,
+        // fall-through
+        td_ns::NotDefinedEntry>::is_defined;
+};
+
+template <typename fnT, typename argT, typename resT>
+struct PowInplaceTypeMapFactory
+{
+    /*! @brief get typeid for output type of x **= y */
+    std::enable_if_t<std::is_same<fnT, int>::value, int> get()
+    {
+        if constexpr (PowInplaceTypePairSupport<argT, resT>::is_defined) {
+            return td_ns::GetTypeid<resT>{}.get();
+        }
+        else {
+            return td_ns::GetTypeid<void>{}.get();
+        }
+    }
+};
+
 template <typename argTy, typename resTy>
 sycl::event
 pow_inplace_contig_impl(sycl::queue &exec_q,
@@ -465,9 +504,7 @@ template <typename fnT, typename T1, typename T2> struct PowInplaceContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename PowOutputType<T1, T2>::value_type,
-                                     void>)
-        {
+        if constexpr (!PowInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -505,9 +542,7 @@ struct PowInplaceStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename PowOutputType<T1, T2>::value_type,
-                                     void>)
-        {
+        if constexpr (!PowInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/proj.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/proj.hpp
index 92a8535309..2c3dce0c9c 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/proj.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/proj.hpp
@@ -108,11 +108,12 @@ using ProjStridedFunctor = elementwise_common::
 
 template <typename T> struct ProjOutputType
 {
-    // disjunction is C++17 feature, supported by DPC++
     using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -134,9 +135,7 @@ template <typename fnT, typename T> struct ProjContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename ProjOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!ProjOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -188,9 +187,7 @@ template <typename fnT, typename T> struct ProjStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename ProjOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!ProjOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/real.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/real.hpp
index 8949a79955..c66e4003cb 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/real.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/real.hpp
@@ -95,8 +95,7 @@ using RealStridedFunctor = elementwise_common::
 
 template <typename T> struct RealOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, bool>,
         td_ns::TypeMapResultEntry<T, std::uint8_t>,
         td_ns::TypeMapResultEntry<T, std::uint16_t>,
@@ -112,6 +111,8 @@ template <typename T> struct RealOutputType
         td_ns::TypeMapResultEntry<T, std::complex<float>, float>,
         td_ns::TypeMapResultEntry<T, std::complex<double>, double>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -133,9 +134,7 @@ template <typename fnT, typename T> struct RealContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename RealOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!RealOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -181,9 +180,7 @@ template <typename fnT, typename T> struct RealStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename RealOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!RealOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/reciprocal.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/reciprocal.hpp
index 76c48e173c..4d4b70fd4f 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/reciprocal.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/reciprocal.hpp
@@ -101,14 +101,15 @@ using ReciprocalStridedFunctor =
 
 template <typename T> struct ReciprocalOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half>,
         td_ns::TypeMapResultEntry<T, float>,
         td_ns::TypeMapResultEntry<T, double>,
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -131,9 +132,7 @@ template <typename fnT, typename T> struct ReciprocalContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename ReciprocalOutputType<T>::value_type, void>)
-        {
+        if constexpr (!ReciprocalOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -181,9 +180,7 @@ template <typename fnT, typename T> struct ReciprocalStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename ReciprocalOutputType<T>::value_type, void>)
-        {
+        if constexpr (!ReciprocalOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/remainder.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/remainder.hpp
index 585d1c6d7f..7bb070cc00 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/remainder.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/remainder.hpp
@@ -166,8 +166,7 @@ using RemainderStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct RemainderOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1,
                                         std::uint8_t,
                                         T2,
@@ -216,6 +215,8 @@ template <typename T1, typename T2> struct RemainderOutputType
         td_ns::BinaryTypeMapResultEntry<T1, float, T2, float, float>,
         td_ns::BinaryTypeMapResultEntry<T1, double, T2, double, double>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -246,10 +247,7 @@ template <typename fnT, typename T1, typename T2> struct RemainderContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename RemainderOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!RemainderOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -299,10 +297,7 @@ template <typename fnT, typename T1, typename T2> struct RemainderStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename RemainderOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!RemainderOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -424,6 +419,41 @@ template <typename argT,
           unsigned int n_vecs>
 class remainder_inplace_contig_kernel;
 
+/* @brief Types supported by in-place remainder */
+template <typename argTy, typename resTy> struct RemainderInplaceTypePairSupport
+{
+    /* value if true a kernel for <argTy, resTy> must be instantiated  */
+    static constexpr bool is_defined = std::disjunction<
+        td_ns::TypePairDefinedEntry<argTy, std::int8_t, resTy, std::int8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint8_t, resTy, std::uint8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int16_t, resTy, std::int16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint16_t, resTy, std::uint16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int32_t, resTy, std::int32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint32_t, resTy, std::uint32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int64_t, resTy, std::int64_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint64_t, resTy, std::uint64_t>,
+        td_ns::TypePairDefinedEntry<argTy, sycl::half, resTy, sycl::half>,
+        td_ns::TypePairDefinedEntry<argTy, float, resTy, float>,
+        td_ns::TypePairDefinedEntry<argTy, double, resTy, double>,
+        // fall-through
+        td_ns::NotDefinedEntry>::is_defined;
+};
+
+template <typename fnT, typename argT, typename resT>
+struct RemainderInplaceTypeMapFactory
+{
+    /*! @brief get typeid for output type of x %= y */
+    std::enable_if_t<std::is_same<fnT, int>::value, int> get()
+    {
+        if constexpr (RemainderInplaceTypePairSupport<argT, resT>::is_defined) {
+            return td_ns::GetTypeid<resT>{}.get();
+        }
+        else {
+            return td_ns::GetTypeid<void>{}.get();
+        }
+    }
+};
+
 template <typename argTy, typename resTy>
 sycl::event
 remainder_inplace_contig_impl(sycl::queue &exec_q,
@@ -445,10 +475,7 @@ struct RemainderInplaceContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename RemainderOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!RemainderInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -487,10 +514,7 @@ struct RemainderInplaceStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename RemainderOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!RemainderInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/round.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/round.hpp
index 49cbbf682c..241f75c1bb 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/round.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/round.hpp
@@ -104,8 +104,7 @@ using RoundStridedFunctor = elementwise_common::
 
 template <typename T> struct RoundOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, std::uint8_t>,
         td_ns::TypeMapResultEntry<T, std::uint16_t>,
         td_ns::TypeMapResultEntry<T, std::uint32_t>,
@@ -120,6 +119,8 @@ template <typename T> struct RoundOutputType
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -141,9 +142,7 @@ template <typename fnT, typename T> struct RoundContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename RoundOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!RoundOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -189,9 +188,7 @@ template <typename fnT, typename T> struct RoundStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename RoundOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!RoundOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/rsqrt.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/rsqrt.hpp
index 541b036931..61aafb13d9 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/rsqrt.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/rsqrt.hpp
@@ -85,12 +85,13 @@ using RsqrtStridedFunctor = elementwise_common::
 
 template <typename T> struct RsqrtOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half, sycl::half>,
         td_ns::TypeMapResultEntry<T, float, float>,
         td_ns::TypeMapResultEntry<T, double, double>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -112,9 +113,7 @@ template <typename fnT, typename T> struct RsqrtContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename RsqrtOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!RsqrtOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -160,9 +159,7 @@ template <typename fnT, typename T> struct RsqrtStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename RsqrtOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!RsqrtOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sign.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sign.hpp
index 554398ae56..651f7d5d9a 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sign.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sign.hpp
@@ -116,8 +116,7 @@ using SignContigFunctor =
 
 template <typename T> struct SignOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, std::uint8_t>,
         td_ns::TypeMapResultEntry<T, std::uint16_t>,
         td_ns::TypeMapResultEntry<T, std::uint32_t>,
@@ -132,6 +131,8 @@ template <typename T> struct SignOutputType
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -153,9 +154,7 @@ template <typename fnT, typename T> struct SignContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename SignOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!SignOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -172,7 +171,6 @@ template <typename fnT, typename T> struct SignTypeMapFactory
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename SignOutputType<T>::value_type;
-        ;
         return td_ns::GetTypeid<rT>{}.get();
     }
 };
@@ -206,9 +204,7 @@ template <typename fnT, typename T> struct SignStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename SignOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!SignOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/signbit.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/signbit.hpp
index ee4a97d9b6..e8ac7709ad 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/signbit.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/signbit.hpp
@@ -91,12 +91,13 @@ using SignbitStridedFunctor = elementwise_common::
 
 template <typename argTy> struct SignbitOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<argTy, sycl::half, bool>,
         td_ns::TypeMapResultEntry<argTy, float, bool>,
         td_ns::TypeMapResultEntry<argTy, double, bool>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -118,9 +119,7 @@ template <typename fnT, typename T> struct SignbitContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename SignbitOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!SignbitOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -167,9 +166,7 @@ template <typename fnT, typename T> struct SignbitStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename SignbitOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!SignbitOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sin.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sin.hpp
index ba46affae6..8bc12097a8 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sin.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sin.hpp
@@ -203,14 +203,15 @@ using SinStridedFunctor = elementwise_common::
 
 template <typename T> struct SinOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half>,
         td_ns::TypeMapResultEntry<T, float>,
         td_ns::TypeMapResultEntry<T, double>,
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -232,9 +233,7 @@ template <typename fnT, typename T> struct SinContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename SinOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!SinOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -279,9 +278,7 @@ template <typename fnT, typename T> struct SinStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename SinOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!SinOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sinh.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sinh.hpp
index 01a87d923f..e83626e56d 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sinh.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sinh.hpp
@@ -172,14 +172,15 @@ using SinhStridedFunctor = elementwise_common::
 
 template <typename T> struct SinhOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half>,
         td_ns::TypeMapResultEntry<T, float>,
         td_ns::TypeMapResultEntry<T, double>,
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -201,9 +202,7 @@ template <typename fnT, typename T> struct SinhContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename SinhOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!SinhOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -249,9 +248,7 @@ template <typename fnT, typename T> struct SinhStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename SinhOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!SinhOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sqrt.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sqrt.hpp
index 6b63f74fe7..5adb41b20d 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sqrt.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sqrt.hpp
@@ -97,8 +97,7 @@ using SqrtStridedFunctor = elementwise_common::
 
 template <typename T> struct SqrtOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half, sycl::half>,
         td_ns::TypeMapResultEntry<T, float, float>,
         td_ns::TypeMapResultEntry<T, double, double>,
@@ -106,6 +105,8 @@ template <typename T> struct SqrtOutputType
         td_ns::
             TypeMapResultEntry<T, std::complex<double>, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -127,9 +128,7 @@ template <typename fnT, typename T> struct SqrtContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename SqrtOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!SqrtOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -175,9 +174,7 @@ template <typename fnT, typename T> struct SqrtStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename SqrtOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!SqrtOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/square.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/square.hpp
index 72f3bda389..4b096cc291 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/square.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/square.hpp
@@ -114,8 +114,7 @@ using SquareStridedFunctor = elementwise_common::
 
 template <typename T> struct SquareOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, bool, std::int8_t>,
         td_ns::TypeMapResultEntry<T, std::uint8_t>,
         td_ns::TypeMapResultEntry<T, std::uint16_t>,
@@ -131,6 +130,8 @@ template <typename T> struct SquareOutputType
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -152,9 +153,7 @@ template <typename fnT, typename T> struct SquareContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename SquareOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!SquareOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -200,9 +199,7 @@ template <typename fnT, typename T> struct SquareStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename SquareOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!SquareOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/subtract.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/subtract.hpp
index 4a8cfb50a7..4ee3ae089b 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/subtract.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/subtract.hpp
@@ -107,8 +107,7 @@ using SubtractStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct SubtractOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1,
                                         std::uint8_t,
                                         T2,
@@ -167,6 +166,8 @@ template <typename T1, typename T2> struct SubtractOutputType
                                         std::complex<double>,
                                         std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -197,10 +198,7 @@ template <typename fnT, typename T1, typename T2> struct SubtractContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename SubtractOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!SubtractOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -250,10 +248,7 @@ template <typename fnT, typename T1, typename T2> struct SubtractStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename SubtractOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!SubtractOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -313,10 +308,7 @@ struct SubtractContigMatrixContigRowBroadcastFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename SubtractOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!SubtractOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -366,12 +358,12 @@ struct SubtractContigRowContigMatrixBroadcastFactory
 {
     fnT get()
     {
-        using resT = typename SubtractOutputType<T1, T2>::value_type;
-        if constexpr (std::is_same_v<resT, void>) {
+        if constexpr (!SubtractOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
         else {
+            using resT = typename SubtractOutputType<T1, T2>::value_type;
             if constexpr (dpctl::tensor::type_utils::is_complex<T1>::value ||
                           dpctl::tensor::type_utils::is_complex<T2>::value ||
                           dpctl::tensor::type_utils::is_complex<resT>::value)
@@ -435,6 +427,49 @@ template <typename argT,
           unsigned int n_vecs>
 class subtract_inplace_contig_kernel;
 
+/* @brief Types supported by in-place subtraction */
+template <typename argTy, typename resTy> struct SubtractInplaceTypePairSupport
+{
+    /* value if true a kernel for <argTy, resTy> must be instantiated  */
+    static constexpr bool is_defined = std::disjunction<
+        td_ns::TypePairDefinedEntry<argTy, std::int8_t, resTy, std::int8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint8_t, resTy, std::uint8_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int16_t, resTy, std::int16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint16_t, resTy, std::uint16_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int32_t, resTy, std::int32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint32_t, resTy, std::uint32_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::int64_t, resTy, std::int64_t>,
+        td_ns::TypePairDefinedEntry<argTy, std::uint64_t, resTy, std::uint64_t>,
+        td_ns::TypePairDefinedEntry<argTy, sycl::half, resTy, sycl::half>,
+        td_ns::TypePairDefinedEntry<argTy, float, resTy, float>,
+        td_ns::TypePairDefinedEntry<argTy, double, resTy, double>,
+        td_ns::TypePairDefinedEntry<argTy,
+                                    std::complex<float>,
+                                    resTy,
+                                    std::complex<float>>,
+        td_ns::TypePairDefinedEntry<argTy,
+                                    std::complex<double>,
+                                    resTy,
+                                    std::complex<double>>,
+        // fall-through
+        td_ns::NotDefinedEntry>::is_defined;
+};
+
+template <typename fnT, typename argT, typename resT>
+struct SubtractInplaceTypeMapFactory
+{
+    /*! @brief get typeid for output type of x -= y */
+    std::enable_if_t<std::is_same<fnT, int>::value, int> get()
+    {
+        if constexpr (SubtractInplaceTypePairSupport<argT, resT>::is_defined) {
+            return td_ns::GetTypeid<resT>{}.get();
+        }
+        else {
+            return td_ns::GetTypeid<void>{}.get();
+        }
+    }
+};
+
 template <typename argTy, typename resTy>
 sycl::event
 subtract_inplace_contig_impl(sycl::queue &exec_q,
@@ -456,10 +491,7 @@ struct SubtractInplaceContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename SubtractOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!SubtractInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -498,10 +530,7 @@ struct SubtractInplaceStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename SubtractOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!SubtractInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -546,8 +575,7 @@ struct SubtractInplaceRowMatrixBroadcastFactory
 {
     fnT get()
     {
-        using resT = typename SubtractOutputType<T1, T2>::value_type;
-        if constexpr (!std::is_same_v<resT, T2>) {
+        if constexpr (!SubtractInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/tan.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/tan.hpp
index c745bc011b..4364d81fb7 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/tan.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/tan.hpp
@@ -147,14 +147,15 @@ using TanStridedFunctor = elementwise_common::
 
 template <typename T> struct TanOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half>,
         td_ns::TypeMapResultEntry<T, float>,
         td_ns::TypeMapResultEntry<T, double>,
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -176,9 +177,7 @@ template <typename fnT, typename T> struct TanContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename TanOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!TanOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -223,9 +222,7 @@ template <typename fnT, typename T> struct TanStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename TanOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!TanOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/tanh.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/tanh.hpp
index 2e23e46f4a..0af4e4e628 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/tanh.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/tanh.hpp
@@ -141,14 +141,15 @@ using TanhStridedFunctor = elementwise_common::
 
 template <typename T> struct TanhOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::TypeMapResultEntry<T, sycl::half>,
         td_ns::TypeMapResultEntry<T, float>,
         td_ns::TypeMapResultEntry<T, double>,
         td_ns::TypeMapResultEntry<T, std::complex<float>>,
         td_ns::TypeMapResultEntry<T, std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -170,9 +171,7 @@ template <typename fnT, typename T> struct TanhContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename TanhOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!TanhOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -218,9 +217,7 @@ template <typename fnT, typename T> struct TanhStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename TanhOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!TanhOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/true_divide.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/true_divide.hpp
index 396e5c995e..53db1e163c 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/true_divide.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/true_divide.hpp
@@ -134,8 +134,7 @@ using TrueDivideStridedFunctor = elementwise_common::BinaryStridedFunctor<
 
 template <typename T1, typename T2> struct TrueDivideOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1,
                                         sycl::half,
                                         T2,
@@ -174,6 +173,8 @@ template <typename T1, typename T2> struct TrueDivideOutputType
                                         double,
                                         std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename argT1,
@@ -205,10 +206,7 @@ template <typename fnT, typename T1, typename T2> struct TrueDivideContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename TrueDivideOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!TrueDivideOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -260,10 +258,7 @@ struct TrueDivideStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename TrueDivideOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!TrueDivideOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -323,10 +318,7 @@ struct TrueDivideContigMatrixContigRowBroadcastFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<
-                          typename TrueDivideOutputType<T1, T2>::value_type,
-                          void>)
-        {
+        if constexpr (!TrueDivideOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -376,12 +368,12 @@ struct TrueDivideContigRowContigMatrixBroadcastFactory
 {
     fnT get()
     {
-        using resT = typename TrueDivideOutputType<T1, T2>::value_type;
-        if constexpr (std::is_same_v<resT, void>) {
+        if constexpr (!TrueDivideOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
         else {
+            using resT = typename TrueDivideOutputType<T1, T2>::value_type;
             if constexpr (dpctl::tensor::type_utils::is_complex<T1>::value ||
                           dpctl::tensor::type_utils::is_complex<T2>::value ||
                           dpctl::tensor::type_utils::is_complex<resT>::value)
@@ -439,52 +431,43 @@ template <typename argT, typename resT> struct TrueDivideInplaceFunctor
     }
 };
 
-// cannot use the out of place table, as it permits real lhs and complex rhs
-// T1 corresponds to the type of the rhs, while T2 corresponds to the lhs
-// the type of the result must be the same as T2
-template <typename T1, typename T2> struct TrueDivideInplaceOutputType
+/* @brief Types supported by in-place divide */
+template <typename argTy, typename resTy>
+struct TrueDivideInplaceTypePairSupport
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
-        td_ns::BinaryTypeMapResultEntry<T1,
-                                        sycl::half,
-                                        T2,
-                                        sycl::half,
-                                        sycl::half>,
-        td_ns::BinaryTypeMapResultEntry<T1, float, T2, float, float>,
-        td_ns::BinaryTypeMapResultEntry<T1, double, T2, double, double>,
-        td_ns::BinaryTypeMapResultEntry<T1,
-                                        std::complex<float>,
-                                        T2,
-                                        std::complex<float>,
-                                        std::complex<float>>,
-        td_ns::BinaryTypeMapResultEntry<T1,
-                                        float,
-                                        T2,
-                                        std::complex<float>,
-                                        std::complex<float>>,
-        td_ns::BinaryTypeMapResultEntry<T1,
-                                        std::complex<double>,
-                                        T2,
-                                        std::complex<double>,
-                                        std::complex<double>>,
-        td_ns::BinaryTypeMapResultEntry<T1,
-                                        double,
-                                        T2,
-                                        std::complex<double>,
-                                        std::complex<double>>,
-        td_ns::DefaultResultEntry<void>>::result_type;
+
+    /* value if true a kernel for <argTy, resTy> must be instantiated  */
+    static constexpr bool is_defined = std::disjunction<
+        td_ns::TypePairDefinedEntry<argTy, sycl::half, resTy, sycl::half>,
+        td_ns::TypePairDefinedEntry<argTy, float, resTy, float>,
+        td_ns::TypePairDefinedEntry<argTy, double, resTy, double>,
+        td_ns::TypePairDefinedEntry<argTy, float, resTy, std::complex<float>>,
+        td_ns::TypePairDefinedEntry<argTy,
+                                    std::complex<float>,
+                                    resTy,
+                                    std::complex<float>>,
+        td_ns::TypePairDefinedEntry<argTy, double, resTy, std::complex<double>>,
+        td_ns::TypePairDefinedEntry<argTy,
+                                    std::complex<double>,
+                                    resTy,
+                                    std::complex<double>>,
+        // fall-through
+        td_ns::NotDefinedEntry>::is_defined;
 };
 
-template <typename fnT, typename T1, typename T2>
+template <typename fnT, typename argT, typename resT>
 struct TrueDivideInplaceTypeMapFactory
 {
     /*! @brief get typeid for output type of divide(T1 x, T2 y) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
-        using rT = typename TrueDivideInplaceOutputType<T1, T2>::value_type;
-        static_assert(std::is_same_v<rT, T2> || std::is_same_v<rT, void>);
-        return td_ns::GetTypeid<rT>{}.get();
+        if constexpr (TrueDivideInplaceTypePairSupport<argT, resT>::is_defined)
+        {
+            return td_ns::GetTypeid<resT>{}.get();
+        }
+        else {
+            return td_ns::GetTypeid<void>{}.get();
+        }
     }
 };
 
@@ -537,10 +520,7 @@ struct TrueDivideInplaceContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename TrueDivideInplaceOutputType<
-                                         T1, T2>::value_type,
-                                     void>)
-        {
+        if constexpr (!TrueDivideInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -579,10 +559,7 @@ struct TrueDivideInplaceStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename TrueDivideInplaceOutputType<
-                                         T1, T2>::value_type,
-                                     void>)
-        {
+        if constexpr (!TrueDivideInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -627,8 +604,7 @@ struct TrueDivideInplaceRowMatrixBroadcastFactory
 {
     fnT get()
     {
-        using resT = typename TrueDivideInplaceOutputType<T1, T2>::value_type;
-        if constexpr (!std::is_same_v<resT, T2>) {
+        if constexpr (!TrueDivideInplaceTypePairSupport<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/trunc.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/trunc.hpp
index 5740bc0ef2..55c8493880 100644
--- a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/trunc.hpp
+++ b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/trunc.hpp
@@ -92,20 +92,21 @@ using TruncStridedFunctor = elementwise_common::
 
 template <typename T> struct TruncOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
-        td_ns::TypeMapResultEntry<T, std::uint8_t>,
-        td_ns::TypeMapResultEntry<T, std::uint16_t>,
-        td_ns::TypeMapResultEntry<T, std::uint32_t>,
-        td_ns::TypeMapResultEntry<T, std::uint64_t>,
-        td_ns::TypeMapResultEntry<T, std::int8_t>,
-        td_ns::TypeMapResultEntry<T, std::int16_t>,
-        td_ns::TypeMapResultEntry<T, std::int32_t>,
-        td_ns::TypeMapResultEntry<T, std::int64_t>,
-        td_ns::TypeMapResultEntry<T, sycl::half>,
-        td_ns::TypeMapResultEntry<T, float>,
-        td_ns::TypeMapResultEntry<T, double>,
-        td_ns::DefaultResultEntry<void>>::result_type;
+    using value_type =
+        typename std::disjunction<td_ns::TypeMapResultEntry<T, std::uint8_t>,
+                                  td_ns::TypeMapResultEntry<T, std::uint16_t>,
+                                  td_ns::TypeMapResultEntry<T, std::uint32_t>,
+                                  td_ns::TypeMapResultEntry<T, std::uint64_t>,
+                                  td_ns::TypeMapResultEntry<T, std::int8_t>,
+                                  td_ns::TypeMapResultEntry<T, std::int16_t>,
+                                  td_ns::TypeMapResultEntry<T, std::int32_t>,
+                                  td_ns::TypeMapResultEntry<T, std::int64_t>,
+                                  td_ns::TypeMapResultEntry<T, sycl::half>,
+                                  td_ns::TypeMapResultEntry<T, float>,
+                                  td_ns::TypeMapResultEntry<T, double>,
+                                  td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename T1, typename T2, unsigned int vec_sz, unsigned int n_vecs>
@@ -127,9 +128,7 @@ template <typename fnT, typename T> struct TruncContigFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename TruncOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!TruncOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
@@ -175,9 +174,7 @@ template <typename fnT, typename T> struct TruncStridedFactory
 {
     fnT get()
     {
-        if constexpr (std::is_same_v<typename TruncOutputType<T>::value_type,
-                                     void>)
-        {
+        if constexpr (!TruncOutputType<T>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/source/accumulators/cumulative_logsumexp.cpp b/dpctl/tensor/libtensor/source/accumulators/cumulative_logsumexp.cpp
index 4cf2ec6fe9..f9d62f3e4b 100644
--- a/dpctl/tensor/libtensor/source/accumulators/cumulative_logsumexp.cpp
+++ b/dpctl/tensor/libtensor/source/accumulators/cumulative_logsumexp.cpp
@@ -70,7 +70,6 @@ template <typename argTy, typename outTy>
 struct TypePairSupportDataForLogSumExpAccumulation
 {
     static constexpr bool is_defined = std::disjunction<
-        // disjunction is C++17 feature, supported by DPC++ input bool
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, sycl::half>,
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, float>,
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, double>,
diff --git a/dpctl/tensor/libtensor/source/accumulators/cumulative_prod.cpp b/dpctl/tensor/libtensor/source/accumulators/cumulative_prod.cpp
index 7982e0ff41..6880069fe5 100644
--- a/dpctl/tensor/libtensor/source/accumulators/cumulative_prod.cpp
+++ b/dpctl/tensor/libtensor/source/accumulators/cumulative_prod.cpp
@@ -69,8 +69,6 @@ static accumulate_strided_impl_fn_ptr_t
 template <typename argTy, typename outTy>
 struct TypePairSupportDataForProdAccumulation
 {
-
-    // disjunction is C++17 feature, supported by DPC++ input bool
     static constexpr bool is_defined = std::disjunction<
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, std::int32_t>,
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, std::int64_t>,
diff --git a/dpctl/tensor/libtensor/source/accumulators/cumulative_sum.cpp b/dpctl/tensor/libtensor/source/accumulators/cumulative_sum.cpp
index 59e5830fe6..f023833982 100644
--- a/dpctl/tensor/libtensor/source/accumulators/cumulative_sum.cpp
+++ b/dpctl/tensor/libtensor/source/accumulators/cumulative_sum.cpp
@@ -69,8 +69,6 @@ static accumulate_strided_impl_fn_ptr_t
 template <typename argTy, typename outTy>
 struct TypePairSupportDataForSumAccumulation
 {
-
-    // disjunction is C++17 feature, supported by DPC++ input bool
     static constexpr bool is_defined = std::disjunction<
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, std::int32_t>,
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, std::int64_t>,
diff --git a/dpctl/tensor/libtensor/source/elementwise_functions/add.cpp b/dpctl/tensor/libtensor/source/elementwise_functions/add.cpp
index 0cce42cdb5..823647aefd 100644
--- a/dpctl/tensor/libtensor/source/elementwise_functions/add.cpp
+++ b/dpctl/tensor/libtensor/source/elementwise_functions/add.cpp
@@ -67,7 +67,9 @@ namespace add_fn_ns = dpctl::tensor::kernels::add;
 
 static binary_contig_impl_fn_ptr_t add_contig_dispatch_table[td_ns::num_types]
                                                             [td_ns::num_types];
+
 static int add_output_id_table[td_ns::num_types][td_ns::num_types];
+static int add_inplace_output_id_table[td_ns::num_types][td_ns::num_types];
 
 static binary_strided_impl_fn_ptr_t
     add_strided_dispatch_table[td_ns::num_types][td_ns::num_types];
@@ -154,6 +156,11 @@ void populate_add_dispatch_tables(void)
                          AddInplaceRowMatrixBroadcastFactory, num_types>
         dtb8;
     dtb8.populate_dispatch_table(add_inplace_row_matrix_dispatch_table);
+
+    // which types are supported by the in-place kernels
+    using fn_ns::AddInplaceTypeMapFactory;
+    DispatchTableBuilder<int, AddInplaceTypeMapFactory, num_types> dtb9;
+    dtb9.populate_dispatch_table(add_inplace_output_id_table);
 };
 
 } // namespace impl
@@ -199,6 +206,7 @@ void init_add(py::module_ m)
         m.def("_add_result_type", add_result_type_pyapi, "");
 
         using impl::add_inplace_contig_dispatch_table;
+        using impl::add_inplace_output_id_table;
         using impl::add_inplace_row_matrix_dispatch_table;
         using impl::add_inplace_strided_dispatch_table;
 
@@ -206,7 +214,7 @@ void init_add(py::module_ m)
                                      sycl::queue &exec_q,
                                      const event_vecT &depends = {}) {
             return py_binary_inplace_ufunc(
-                src, dst, exec_q, depends, add_output_id_table,
+                src, dst, exec_q, depends, add_inplace_output_id_table,
                 // function pointers to handle inplace operation on
                 // contiguous arrays (pointers may be nullptr)
                 add_inplace_contig_dispatch_table,
diff --git a/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_and.cpp b/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_and.cpp
index afd7ffe469..15ccf22ea2 100644
--- a/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_and.cpp
+++ b/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_and.cpp
@@ -66,7 +66,10 @@ namespace bitwise_and_fn_ns = dpctl::tensor::kernels::bitwise_and;
 
 static binary_contig_impl_fn_ptr_t
     bitwise_and_contig_dispatch_table[td_ns::num_types][td_ns::num_types];
+
 static int bitwise_and_output_id_table[td_ns::num_types][td_ns::num_types];
+static int bitwise_and_inplace_output_id_table[td_ns::num_types]
+                                              [td_ns::num_types];
 
 static binary_strided_impl_fn_ptr_t
     bitwise_and_strided_dispatch_table[td_ns::num_types][td_ns::num_types];
@@ -115,6 +118,11 @@ void populate_bitwise_and_dispatch_tables(void)
                          BitwiseAndInplaceContigFactory, num_types>
         dtb5;
     dtb5.populate_dispatch_table(bitwise_and_inplace_contig_dispatch_table);
+
+    // which types are supported by the in-place kernels
+    using fn_ns::BitwiseAndInplaceTypeMapFactory;
+    DispatchTableBuilder<int, BitwiseAndInplaceTypeMapFactory, num_types> dtb6;
+    dtb6.populate_dispatch_table(bitwise_and_inplace_output_id_table);
 };
 
 } // namespace impl
@@ -160,25 +168,27 @@ void init_bitwise_and(py::module_ m)
         m.def("_bitwise_and_result_type", bitwise_and_result_type_pyapi, "");
 
         using impl::bitwise_and_inplace_contig_dispatch_table;
+        using impl::bitwise_and_inplace_output_id_table;
         using impl::bitwise_and_inplace_strided_dispatch_table;
 
-        auto bitwise_and_inplace_pyapi =
-            [&](const arrayT &src, const arrayT &dst, sycl::queue &exec_q,
-                const event_vecT &depends = {}) {
-                return py_binary_inplace_ufunc(
-                    src, dst, exec_q, depends, bitwise_and_output_id_table,
-                    // function pointers to handle inplace operation on
-                    // contiguous arrays (pointers may be nullptr)
-                    bitwise_and_inplace_contig_dispatch_table,
-                    // function pointers to handle inplace operation on strided
-                    // arrays (most general case)
-                    bitwise_and_inplace_strided_dispatch_table,
-                    // function pointers to handle inplace operation on
-                    // c-contig matrix with c-contig row with broadcasting
-                    // (may be nullptr)
-                    td_ns::NullPtrTable<
-                        binary_inplace_row_matrix_broadcast_impl_fn_ptr_t>{});
-            };
+        auto bitwise_and_inplace_pyapi = [&](const arrayT &src,
+                                             const arrayT &dst,
+                                             sycl::queue &exec_q,
+                                             const event_vecT &depends = {}) {
+            return py_binary_inplace_ufunc(
+                src, dst, exec_q, depends, bitwise_and_inplace_output_id_table,
+                // function pointers to handle inplace operation on
+                // contiguous arrays (pointers may be nullptr)
+                bitwise_and_inplace_contig_dispatch_table,
+                // function pointers to handle inplace operation on strided
+                // arrays (most general case)
+                bitwise_and_inplace_strided_dispatch_table,
+                // function pointers to handle inplace operation on
+                // c-contig matrix with c-contig row with broadcasting
+                // (may be nullptr)
+                td_ns::NullPtrTable<
+                    binary_inplace_row_matrix_broadcast_impl_fn_ptr_t>{});
+        };
         m.def("_bitwise_and_inplace", bitwise_and_inplace_pyapi, "",
               py::arg("lhs"), py::arg("rhs"), py::arg("sycl_queue"),
               py::arg("depends") = py::list());
diff --git a/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_left_shift.cpp b/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_left_shift.cpp
index 777573a738..833b78e697 100644
--- a/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_left_shift.cpp
+++ b/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_left_shift.cpp
@@ -67,8 +67,11 @@ namespace bitwise_left_shift_fn_ns = dpctl::tensor::kernels::bitwise_left_shift;
 static binary_contig_impl_fn_ptr_t
     bitwise_left_shift_contig_dispatch_table[td_ns::num_types]
                                             [td_ns::num_types];
+
 static int bitwise_left_shift_output_id_table[td_ns::num_types]
                                              [td_ns::num_types];
+static int bitwise_left_shift_inplace_output_id_table[td_ns::num_types]
+                                                     [td_ns::num_types];
 
 static binary_strided_impl_fn_ptr_t
     bitwise_left_shift_strided_dispatch_table[td_ns::num_types]
@@ -120,6 +123,12 @@ void populate_bitwise_left_shift_dispatch_tables(void)
         dtb5;
     dtb5.populate_dispatch_table(
         bitwise_left_shift_inplace_contig_dispatch_table);
+
+    // which types are supported by the in-place kernels
+    using fn_ns::BitwiseLeftShiftInplaceTypeMapFactory;
+    DispatchTableBuilder<int, BitwiseLeftShiftInplaceTypeMapFactory, num_types>
+        dtb6;
+    dtb6.populate_dispatch_table(bitwise_left_shift_inplace_output_id_table);
 };
 
 } // namespace impl
@@ -169,6 +178,7 @@ void init_bitwise_left_shift(py::module_ m)
               bitwise_left_shift_result_type_pyapi, "");
 
         using impl::bitwise_left_shift_inplace_contig_dispatch_table;
+        using impl::bitwise_left_shift_inplace_output_id_table;
         using impl::bitwise_left_shift_inplace_strided_dispatch_table;
 
         auto bitwise_left_shift_inplace_pyapi =
@@ -176,7 +186,7 @@ void init_bitwise_left_shift(py::module_ m)
                 const event_vecT &depends = {}) {
                 return py_binary_inplace_ufunc(
                     src, dst, exec_q, depends,
-                    bitwise_left_shift_output_id_table,
+                    bitwise_left_shift_inplace_output_id_table,
                     // function pointers to handle inplace operation on
                     // contiguous arrays (pointers may be nullptr)
                     bitwise_left_shift_inplace_contig_dispatch_table,
diff --git a/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_or.cpp b/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_or.cpp
index 468d887392..ecdaeb6577 100644
--- a/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_or.cpp
+++ b/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_or.cpp
@@ -66,7 +66,10 @@ namespace bitwise_or_fn_ns = dpctl::tensor::kernels::bitwise_or;
 
 static binary_contig_impl_fn_ptr_t
     bitwise_or_contig_dispatch_table[td_ns::num_types][td_ns::num_types];
+
 static int bitwise_or_output_id_table[td_ns::num_types][td_ns::num_types];
+static int bitwise_or_inplace_output_id_table[td_ns::num_types]
+                                             [td_ns::num_types];
 
 static binary_strided_impl_fn_ptr_t
     bitwise_or_strided_dispatch_table[td_ns::num_types][td_ns::num_types];
@@ -115,6 +118,11 @@ void populate_bitwise_or_dispatch_tables(void)
                          BitwiseOrInplaceContigFactory, num_types>
         dtb5;
     dtb5.populate_dispatch_table(bitwise_or_inplace_contig_dispatch_table);
+
+    // which types are supported by the in-place kernels
+    using fn_ns::BitwiseOrInplaceTypeMapFactory;
+    DispatchTableBuilder<int, BitwiseOrInplaceTypeMapFactory, num_types> dtb6;
+    dtb6.populate_dispatch_table(bitwise_or_inplace_output_id_table);
 };
 
 } // namespace impl
@@ -160,25 +168,27 @@ void init_bitwise_or(py::module_ m)
         m.def("_bitwise_or_result_type", bitwise_or_result_type_pyapi, "");
 
         using impl::bitwise_or_inplace_contig_dispatch_table;
+        using impl::bitwise_or_inplace_output_id_table;
         using impl::bitwise_or_inplace_strided_dispatch_table;
 
-        auto bitwise_or_inplace_pyapi =
-            [&](const arrayT &src, const arrayT &dst, sycl::queue &exec_q,
-                const event_vecT &depends = {}) {
-                return py_binary_inplace_ufunc(
-                    src, dst, exec_q, depends, bitwise_or_output_id_table,
-                    // function pointers to handle inplace operation on
-                    // contiguous arrays (pointers may be nullptr)
-                    bitwise_or_inplace_contig_dispatch_table,
-                    // function pointers to handle inplace operation on strided
-                    // arrays (most general case)
-                    bitwise_or_inplace_strided_dispatch_table,
-                    // function pointers to handle inplace operation on
-                    // c-contig matrix with c-contig row with broadcasting
-                    // (may be nullptr)
-                    td_ns::NullPtrTable<
-                        binary_inplace_row_matrix_broadcast_impl_fn_ptr_t>{});
-            };
+        auto bitwise_or_inplace_pyapi = [&](const arrayT &src,
+                                            const arrayT &dst,
+                                            sycl::queue &exec_q,
+                                            const event_vecT &depends = {}) {
+            return py_binary_inplace_ufunc(
+                src, dst, exec_q, depends, bitwise_or_inplace_output_id_table,
+                // function pointers to handle inplace operation on
+                // contiguous arrays (pointers may be nullptr)
+                bitwise_or_inplace_contig_dispatch_table,
+                // function pointers to handle inplace operation on strided
+                // arrays (most general case)
+                bitwise_or_inplace_strided_dispatch_table,
+                // function pointers to handle inplace operation on
+                // c-contig matrix with c-contig row with broadcasting
+                // (may be nullptr)
+                td_ns::NullPtrTable<
+                    binary_inplace_row_matrix_broadcast_impl_fn_ptr_t>{});
+        };
         m.def("_bitwise_or_inplace", bitwise_or_inplace_pyapi, "",
               py::arg("lhs"), py::arg("rhs"), py::arg("sycl_queue"),
               py::arg("depends") = py::list());
diff --git a/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_right_shift.cpp b/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_right_shift.cpp
index 85fc7b99a9..9f74037f41 100644
--- a/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_right_shift.cpp
+++ b/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_right_shift.cpp
@@ -68,8 +68,11 @@ namespace bitwise_right_shift_fn_ns =
 static binary_contig_impl_fn_ptr_t
     bitwise_right_shift_contig_dispatch_table[td_ns::num_types]
                                              [td_ns::num_types];
+
 static int bitwise_right_shift_output_id_table[td_ns::num_types]
                                               [td_ns::num_types];
+static int bitwise_right_shift_inplace_output_id_table[td_ns::num_types]
+                                                      [td_ns::num_types];
 
 static binary_strided_impl_fn_ptr_t
     bitwise_right_shift_strided_dispatch_table[td_ns::num_types]
@@ -121,6 +124,12 @@ void populate_bitwise_right_shift_dispatch_tables(void)
         dtb5;
     dtb5.populate_dispatch_table(
         bitwise_right_shift_inplace_contig_dispatch_table);
+
+    // which types are supported by the in-place kernels
+    using fn_ns::BitwiseRightShiftInplaceTypeMapFactory;
+    DispatchTableBuilder<int, BitwiseRightShiftInplaceTypeMapFactory, num_types>
+        dtb6;
+    dtb6.populate_dispatch_table(bitwise_right_shift_inplace_output_id_table);
 };
 
 } // namespace impl
@@ -170,6 +179,7 @@ void init_bitwise_right_shift(py::module_ m)
               bitwise_right_shift_result_type_pyapi, "");
 
         using impl::bitwise_right_shift_inplace_contig_dispatch_table;
+        using impl::bitwise_right_shift_inplace_output_id_table;
         using impl::bitwise_right_shift_inplace_strided_dispatch_table;
 
         auto bitwise_right_shift_inplace_pyapi =
@@ -177,7 +187,7 @@ void init_bitwise_right_shift(py::module_ m)
                 const event_vecT &depends = {}) {
                 return py_binary_inplace_ufunc(
                     src, dst, exec_q, depends,
-                    bitwise_right_shift_output_id_table,
+                    bitwise_right_shift_inplace_output_id_table,
                     // function pointers to handle inplace operation on
                     // contiguous arrays (pointers may be nullptr)
                     bitwise_right_shift_inplace_contig_dispatch_table,
diff --git a/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_xor.cpp b/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_xor.cpp
index 18e9fb695e..6124f305e0 100644
--- a/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_xor.cpp
+++ b/dpctl/tensor/libtensor/source/elementwise_functions/bitwise_xor.cpp
@@ -66,7 +66,10 @@ namespace bitwise_xor_fn_ns = dpctl::tensor::kernels::bitwise_xor;
 
 static binary_contig_impl_fn_ptr_t
     bitwise_xor_contig_dispatch_table[td_ns::num_types][td_ns::num_types];
+
 static int bitwise_xor_output_id_table[td_ns::num_types][td_ns::num_types];
+static int bitwise_xor_inplace_output_id_table[td_ns::num_types]
+                                              [td_ns::num_types];
 
 static binary_strided_impl_fn_ptr_t
     bitwise_xor_strided_dispatch_table[td_ns::num_types][td_ns::num_types];
@@ -115,6 +118,11 @@ void populate_bitwise_xor_dispatch_tables(void)
                          BitwiseXorInplaceContigFactory, num_types>
         dtb5;
     dtb5.populate_dispatch_table(bitwise_xor_inplace_contig_dispatch_table);
+
+    // which types are supported by the in-place kernels
+    using fn_ns::BitwiseXorInplaceTypeMapFactory;
+    DispatchTableBuilder<int, BitwiseXorInplaceTypeMapFactory, num_types> dtb6;
+    dtb6.populate_dispatch_table(bitwise_xor_inplace_output_id_table);
 };
 
 } // namespace impl
@@ -160,25 +168,27 @@ void init_bitwise_xor(py::module_ m)
         m.def("_bitwise_xor_result_type", bitwise_xor_result_type_pyapi, "");
 
         using impl::bitwise_xor_inplace_contig_dispatch_table;
+        using impl::bitwise_xor_inplace_output_id_table;
         using impl::bitwise_xor_inplace_strided_dispatch_table;
 
-        auto bitwise_xor_inplace_pyapi =
-            [&](const arrayT &src, const arrayT &dst, sycl::queue &exec_q,
-                const event_vecT &depends = {}) {
-                return py_binary_inplace_ufunc(
-                    src, dst, exec_q, depends, bitwise_xor_output_id_table,
-                    // function pointers to handle inplace operation on
-                    // contiguous arrays (pointers may be nullptr)
-                    bitwise_xor_inplace_contig_dispatch_table,
-                    // function pointers to handle inplace operation on strided
-                    // arrays (most general case)
-                    bitwise_xor_inplace_strided_dispatch_table,
-                    // function pointers to handle inplace operation on
-                    // c-contig matrix with c-contig row with broadcasting
-                    // (may be nullptr)
-                    td_ns::NullPtrTable<
-                        binary_inplace_row_matrix_broadcast_impl_fn_ptr_t>{});
-            };
+        auto bitwise_xor_inplace_pyapi = [&](const arrayT &src,
+                                             const arrayT &dst,
+                                             sycl::queue &exec_q,
+                                             const event_vecT &depends = {}) {
+            return py_binary_inplace_ufunc(
+                src, dst, exec_q, depends, bitwise_xor_inplace_output_id_table,
+                // function pointers to handle inplace operation on
+                // contiguous arrays (pointers may be nullptr)
+                bitwise_xor_inplace_contig_dispatch_table,
+                // function pointers to handle inplace operation on strided
+                // arrays (most general case)
+                bitwise_xor_inplace_strided_dispatch_table,
+                // function pointers to handle inplace operation on
+                // c-contig matrix with c-contig row with broadcasting
+                // (may be nullptr)
+                td_ns::NullPtrTable<
+                    binary_inplace_row_matrix_broadcast_impl_fn_ptr_t>{});
+        };
         m.def("_bitwise_xor_inplace", bitwise_xor_inplace_pyapi, "",
               py::arg("lhs"), py::arg("rhs"), py::arg("sycl_queue"),
               py::arg("depends") = py::list());
diff --git a/dpctl/tensor/libtensor/source/elementwise_functions/floor_divide.cpp b/dpctl/tensor/libtensor/source/elementwise_functions/floor_divide.cpp
index fdbffbb3be..921b494fd1 100644
--- a/dpctl/tensor/libtensor/source/elementwise_functions/floor_divide.cpp
+++ b/dpctl/tensor/libtensor/source/elementwise_functions/floor_divide.cpp
@@ -66,7 +66,10 @@ namespace floor_divide_fn_ns = dpctl::tensor::kernels::floor_divide;
 
 static binary_contig_impl_fn_ptr_t
     floor_divide_contig_dispatch_table[td_ns::num_types][td_ns::num_types];
+
 static int floor_divide_output_id_table[td_ns::num_types][td_ns::num_types];
+static int floor_divide_inplace_output_id_table[td_ns::num_types]
+                                               [td_ns::num_types];
 
 static binary_strided_impl_fn_ptr_t
     floor_divide_strided_dispatch_table[td_ns::num_types][td_ns::num_types];
@@ -115,6 +118,11 @@ void populate_floor_divide_dispatch_tables(void)
                          FloorDivideInplaceContigFactory, num_types>
         dtb5;
     dtb5.populate_dispatch_table(floor_divide_inplace_contig_dispatch_table);
+
+    // which types are supported by the in-place kernels
+    using fn_ns::FloorDivideInplaceTypeMapFactory;
+    DispatchTableBuilder<int, FloorDivideInplaceTypeMapFactory, num_types> dtb6;
+    dtb6.populate_dispatch_table(floor_divide_inplace_output_id_table);
 };
 
 } // namespace impl
@@ -160,25 +168,27 @@ void init_floor_divide(py::module_ m)
         m.def("_floor_divide_result_type", floor_divide_result_type_pyapi, "");
 
         using impl::floor_divide_inplace_contig_dispatch_table;
+        using impl::floor_divide_inplace_output_id_table;
         using impl::floor_divide_inplace_strided_dispatch_table;
 
-        auto floor_divide_inplace_pyapi =
-            [&](const arrayT &src, const arrayT &dst, sycl::queue &exec_q,
-                const event_vecT &depends = {}) {
-                return py_binary_inplace_ufunc(
-                    src, dst, exec_q, depends, floor_divide_output_id_table,
-                    // function pointers to handle inplace operation on
-                    // contiguous arrays (pointers may be nullptr)
-                    floor_divide_inplace_contig_dispatch_table,
-                    // function pointers to handle inplace operation on strided
-                    // arrays (most general case)
-                    floor_divide_inplace_strided_dispatch_table,
-                    // function pointers to handle inplace operation on
-                    // c-contig matrix with c-contig row with broadcasting
-                    // (may be nullptr)
-                    td_ns::NullPtrTable<
-                        binary_inplace_row_matrix_broadcast_impl_fn_ptr_t>{});
-            };
+        auto floor_divide_inplace_pyapi = [&](const arrayT &src,
+                                              const arrayT &dst,
+                                              sycl::queue &exec_q,
+                                              const event_vecT &depends = {}) {
+            return py_binary_inplace_ufunc(
+                src, dst, exec_q, depends, floor_divide_inplace_output_id_table,
+                // function pointers to handle inplace operation on
+                // contiguous arrays (pointers may be nullptr)
+                floor_divide_inplace_contig_dispatch_table,
+                // function pointers to handle inplace operation on strided
+                // arrays (most general case)
+                floor_divide_inplace_strided_dispatch_table,
+                // function pointers to handle inplace operation on
+                // c-contig matrix with c-contig row with broadcasting
+                // (may be nullptr)
+                td_ns::NullPtrTable<
+                    binary_inplace_row_matrix_broadcast_impl_fn_ptr_t>{});
+        };
         m.def("_floor_divide_inplace", floor_divide_inplace_pyapi, "",
               py::arg("lhs"), py::arg("rhs"), py::arg("sycl_queue"),
               py::arg("depends") = py::list());
diff --git a/dpctl/tensor/libtensor/source/elementwise_functions/multiply.cpp b/dpctl/tensor/libtensor/source/elementwise_functions/multiply.cpp
index 75438e1031..22fc293c98 100644
--- a/dpctl/tensor/libtensor/source/elementwise_functions/multiply.cpp
+++ b/dpctl/tensor/libtensor/source/elementwise_functions/multiply.cpp
@@ -67,7 +67,9 @@ namespace multiply_fn_ns = dpctl::tensor::kernels::multiply;
 
 static binary_contig_impl_fn_ptr_t
     multiply_contig_dispatch_table[td_ns::num_types][td_ns::num_types];
+
 static int multiply_output_id_table[td_ns::num_types][td_ns::num_types];
+static int multiply_inplace_output_id_table[td_ns::num_types][td_ns::num_types];
 
 static binary_strided_impl_fn_ptr_t
     multiply_strided_dispatch_table[td_ns::num_types][td_ns::num_types];
@@ -155,6 +157,11 @@ void populate_multiply_dispatch_tables(void)
                          MultiplyInplaceRowMatrixBroadcastFactory, num_types>
         dtb8;
     dtb8.populate_dispatch_table(multiply_inplace_row_matrix_dispatch_table);
+
+    // which types are supported by the in-place kernels
+    using fn_ns::MultiplyInplaceTypeMapFactory;
+    DispatchTableBuilder<int, MultiplyInplaceTypeMapFactory, num_types> dtb9;
+    dtb9.populate_dispatch_table(multiply_inplace_output_id_table);
 };
 
 } // namespace impl
@@ -200,6 +207,7 @@ void init_multiply(py::module_ m)
         m.def("_multiply_result_type", multiply_result_type_pyapi, "");
 
         using impl::multiply_inplace_contig_dispatch_table;
+        using impl::multiply_inplace_output_id_table;
         using impl::multiply_inplace_row_matrix_dispatch_table;
         using impl::multiply_inplace_strided_dispatch_table;
 
@@ -207,7 +215,7 @@ void init_multiply(py::module_ m)
                                           sycl::queue &exec_q,
                                           const event_vecT &depends = {}) {
             return py_binary_inplace_ufunc(
-                src, dst, exec_q, depends, multiply_output_id_table,
+                src, dst, exec_q, depends, multiply_inplace_output_id_table,
                 // function pointers to handle inplace operation on
                 // contiguous arrays (pointers may be nullptr)
                 multiply_inplace_contig_dispatch_table,
diff --git a/dpctl/tensor/libtensor/source/elementwise_functions/pow.cpp b/dpctl/tensor/libtensor/source/elementwise_functions/pow.cpp
index 347b3e298a..25e96eee7f 100644
--- a/dpctl/tensor/libtensor/source/elementwise_functions/pow.cpp
+++ b/dpctl/tensor/libtensor/source/elementwise_functions/pow.cpp
@@ -67,7 +67,9 @@ namespace pow_fn_ns = dpctl::tensor::kernels::pow;
 
 static binary_contig_impl_fn_ptr_t pow_contig_dispatch_table[td_ns::num_types]
                                                             [td_ns::num_types];
+
 static int pow_output_id_table[td_ns::num_types][td_ns::num_types];
+static int pow_inplace_output_id_table[td_ns::num_types][td_ns::num_types];
 
 static binary_strided_impl_fn_ptr_t
     pow_strided_dispatch_table[td_ns::num_types][td_ns::num_types];
@@ -114,6 +116,11 @@ void populate_pow_dispatch_tables(void)
                          PowInplaceContigFactory, num_types>
         dtb5;
     dtb5.populate_dispatch_table(pow_inplace_contig_dispatch_table);
+
+    // which types are supported by the in-place kernels
+    using fn_ns::PowInplaceTypeMapFactory;
+    DispatchTableBuilder<int, PowInplaceTypeMapFactory, num_types> dtb6;
+    dtb6.populate_dispatch_table(pow_inplace_output_id_table);
 };
 
 } // namespace impl
@@ -159,13 +166,14 @@ void init_pow(py::module_ m)
         m.def("_pow_result_type", pow_result_type_pyapi, "");
 
         using impl::pow_inplace_contig_dispatch_table;
+        using impl::pow_inplace_output_id_table;
         using impl::pow_inplace_strided_dispatch_table;
 
         auto pow_inplace_pyapi = [&](const arrayT &src, const arrayT &dst,
                                      sycl::queue &exec_q,
                                      const event_vecT &depends = {}) {
             return py_binary_inplace_ufunc(
-                src, dst, exec_q, depends, pow_output_id_table,
+                src, dst, exec_q, depends, pow_inplace_output_id_table,
                 // function pointers to handle inplace operation on
                 // contiguous arrays (pointers may be nullptr)
                 pow_inplace_contig_dispatch_table,
diff --git a/dpctl/tensor/libtensor/source/elementwise_functions/remainder.cpp b/dpctl/tensor/libtensor/source/elementwise_functions/remainder.cpp
index d08c7ebda8..a2d3f48099 100644
--- a/dpctl/tensor/libtensor/source/elementwise_functions/remainder.cpp
+++ b/dpctl/tensor/libtensor/source/elementwise_functions/remainder.cpp
@@ -67,7 +67,10 @@ namespace remainder_fn_ns = dpctl::tensor::kernels::remainder;
 
 static binary_contig_impl_fn_ptr_t
     remainder_contig_dispatch_table[td_ns::num_types][td_ns::num_types];
+
 static int remainder_output_id_table[td_ns::num_types][td_ns::num_types];
+static int remainder_inplace_output_id_table[td_ns::num_types]
+                                            [td_ns::num_types];
 
 static binary_strided_impl_fn_ptr_t
     remainder_strided_dispatch_table[td_ns::num_types][td_ns::num_types];
@@ -115,6 +118,11 @@ void populate_remainder_dispatch_tables(void)
                          RemainderInplaceContigFactory, num_types>
         dtb5;
     dtb5.populate_dispatch_table(remainder_inplace_contig_dispatch_table);
+
+    // which types are supported by the in-place kernels
+    using fn_ns::RemainderInplaceTypeMapFactory;
+    DispatchTableBuilder<int, RemainderInplaceTypeMapFactory, num_types> dtb6;
+    dtb6.populate_dispatch_table(remainder_inplace_output_id_table);
 }
 
 } // namespace impl
@@ -160,13 +168,14 @@ void init_remainder(py::module_ m)
         m.def("_remainder_result_type", remainder_result_type_pyapi, "");
 
         using impl::remainder_inplace_contig_dispatch_table;
+        using impl::remainder_inplace_output_id_table;
         using impl::remainder_inplace_strided_dispatch_table;
 
         auto remainder_inplace_pyapi = [&](const arrayT &src, const arrayT &dst,
                                            sycl::queue &exec_q,
                                            const event_vecT &depends = {}) {
             return py_binary_inplace_ufunc(
-                src, dst, exec_q, depends, remainder_output_id_table,
+                src, dst, exec_q, depends, remainder_inplace_output_id_table,
                 // function pointers to handle inplace operation on
                 // contiguous arrays (pointers may be nullptr)
                 remainder_inplace_contig_dispatch_table,
diff --git a/dpctl/tensor/libtensor/source/elementwise_functions/subtract.cpp b/dpctl/tensor/libtensor/source/elementwise_functions/subtract.cpp
index 0c81ace53e..f1c1324a58 100644
--- a/dpctl/tensor/libtensor/source/elementwise_functions/subtract.cpp
+++ b/dpctl/tensor/libtensor/source/elementwise_functions/subtract.cpp
@@ -66,7 +66,9 @@ namespace subtract_fn_ns = dpctl::tensor::kernels::subtract;
 
 static binary_contig_impl_fn_ptr_t
     subtract_contig_dispatch_table[td_ns::num_types][td_ns::num_types];
+
 static int subtract_output_id_table[td_ns::num_types][td_ns::num_types];
+static int subtract_inplace_output_id_table[td_ns::num_types][td_ns::num_types];
 
 static binary_strided_impl_fn_ptr_t
     subtract_strided_dispatch_table[td_ns::num_types][td_ns::num_types];
@@ -154,6 +156,11 @@ void populate_subtract_dispatch_tables(void)
                          SubtractInplaceRowMatrixBroadcastFactory, num_types>
         dtb8;
     dtb8.populate_dispatch_table(subtract_inplace_row_matrix_dispatch_table);
+
+    // which types are supported by the in-place kernels
+    using fn_ns::SubtractInplaceTypeMapFactory;
+    DispatchTableBuilder<int, SubtractInplaceTypeMapFactory, num_types> dtb9;
+    dtb9.populate_dispatch_table(subtract_inplace_output_id_table);
 };
 
 } // namespace impl
@@ -199,6 +206,7 @@ void init_subtract(py::module_ m)
         m.def("_subtract_result_type", subtract_result_type_pyapi, "");
 
         using impl::subtract_inplace_contig_dispatch_table;
+        using impl::subtract_inplace_output_id_table;
         using impl::subtract_inplace_row_matrix_dispatch_table;
         using impl::subtract_inplace_strided_dispatch_table;
 
@@ -206,7 +214,7 @@ void init_subtract(py::module_ m)
                                           sycl::queue &exec_q,
                                           const event_vecT &depends = {}) {
             return py_binary_inplace_ufunc(
-                src, dst, exec_q, depends, subtract_output_id_table,
+                src, dst, exec_q, depends, subtract_inplace_output_id_table,
                 // function pointers to handle inplace operation on
                 // contiguous arrays (pointers may be nullptr)
                 subtract_inplace_contig_dispatch_table,
diff --git a/dpctl/tensor/libtensor/source/elementwise_functions/true_divide.cpp b/dpctl/tensor/libtensor/source/elementwise_functions/true_divide.cpp
index f78c428152..ffb2afc3ea 100644
--- a/dpctl/tensor/libtensor/source/elementwise_functions/true_divide.cpp
+++ b/dpctl/tensor/libtensor/source/elementwise_functions/true_divide.cpp
@@ -137,7 +137,7 @@ void populate_true_divide_dispatch_tables(void)
     dtb5.populate_dispatch_table(
         true_divide_contig_row_contig_matrix_broadcast_dispatch_table);
 
-    // which input types are supported, and what is the type of the result
+    // which types are supported by the in-place kernels
     using fn_ns::TrueDivideInplaceTypeMapFactory;
     DispatchTableBuilder<int, TrueDivideInplaceTypeMapFactory, num_types> dtb6;
     dtb6.populate_dispatch_table(true_divide_inplace_output_id_table);
diff --git a/dpctl/tensor/libtensor/source/linalg_functions/dot_dispatch.hpp b/dpctl/tensor/libtensor/source/linalg_functions/dot_dispatch.hpp
index 3ce0ae1264..35d2ada54a 100644
--- a/dpctl/tensor/libtensor/source/linalg_functions/dot_dispatch.hpp
+++ b/dpctl/tensor/libtensor/source/linalg_functions/dot_dispatch.hpp
@@ -43,8 +43,7 @@ namespace td_ns = dpctl::tensor::type_dispatch;
 
 template <typename T1, typename T2> struct DotAtomicOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1,
                                         std::uint32_t,
                                         T2,
@@ -79,14 +78,15 @@ template <typename T1, typename T2> struct DotAtomicOutputType
         td_ns::BinaryTypeMapResultEntry<T1, float, T2, float, double>,
         td_ns::BinaryTypeMapResultEntry<T1, double, T2, double, double>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 // add separate type support lists for atomic vs. temps
 // gemm, gevm, and dot product share output type struct
 template <typename T1, typename T2> struct DotNoAtomicOutputType
 {
-    using value_type = typename std::disjunction< // disjunction is C++17
-                                                  // feature, supported by DPC++
+    using value_type = typename std::disjunction<
         td_ns::BinaryTypeMapResultEntry<T1, bool, T2, bool, bool>,
         td_ns::BinaryTypeMapResultEntry<T1,
                                         std::uint8_t,
@@ -161,6 +161,8 @@ template <typename T1, typename T2> struct DotNoAtomicOutputType
                                         std::complex<double>,
                                         std::complex<double>>,
         td_ns::DefaultResultEntry<void>>::result_type;
+
+    static constexpr bool is_defined = !std::is_same_v<value_type, void>;
 };
 
 template <typename fnT, typename T1, typename T2> struct DotTypeMapFactory
@@ -179,13 +181,13 @@ template <typename fnT, typename T1, typename T2> struct GemmBatchAtomicFactory
 {
     fnT get()
     {
-        using T3 = typename DotAtomicOutputType<T1, T2>::value_type;
-        if constexpr (std::is_same_v<T3, void>) {
+        if constexpr (!DotAtomicOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
         else {
             using dpctl::tensor::kernels::gemm_batch_impl;
+            using T3 = typename DotAtomicOutputType<T1, T2>::value_type;
             fnT fn = gemm_batch_impl<T1, T2, T3>;
             return fn;
         }
@@ -197,13 +199,13 @@ struct GemmBatchContigAtomicFactory
 {
     fnT get()
     {
-        using T3 = typename DotAtomicOutputType<T1, T2>::value_type;
-        if constexpr (std::is_same_v<T3, void>) {
+        if constexpr (!DotAtomicOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
         else {
             using dpctl::tensor::kernels::gemm_batch_contig_impl;
+            using T3 = typename DotAtomicOutputType<T1, T2>::value_type;
             fnT fn = gemm_batch_contig_impl<T1, T2, T3>;
             return fn;
         }
@@ -214,13 +216,13 @@ template <typename fnT, typename T1, typename T2> struct GemmAtomicFactory
 {
     fnT get()
     {
-        using T3 = typename DotAtomicOutputType<T1, T2>::value_type;
-        if constexpr (std::is_same_v<T3, void>) {
+        if constexpr (!DotAtomicOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
         else {
             using dpctl::tensor::kernels::gemm_impl;
+            using T3 = typename DotAtomicOutputType<T1, T2>::value_type;
             fnT fn = gemm_impl<T1, T2, T3>;
             return fn;
         }
@@ -231,13 +233,13 @@ template <typename fnT, typename T1, typename T2> struct GemmContigAtomicFactory
 {
     fnT get()
     {
-        using T3 = typename DotAtomicOutputType<T1, T2>::value_type;
-        if constexpr (std::is_same_v<T3, void>) {
+        if constexpr (!DotAtomicOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
         else {
             using dpctl::tensor::kernels::gemm_contig_impl;
+            using T3 = typename DotAtomicOutputType<T1, T2>::value_type;
             fnT fn = gemm_contig_impl<T1, T2, T3>;
             return fn;
         }
@@ -248,13 +250,13 @@ template <typename fnT, typename T1, typename T2> struct GemmTempsFactory
 {
     fnT get()
     {
-        using T3 = typename DotNoAtomicOutputType<T1, T2>::value_type;
-        if constexpr (std::is_same_v<T3, void>) {
+        if constexpr (!DotNoAtomicOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
         else {
             using dpctl::tensor::kernels::gemm_tree_impl;
+            using T3 = typename DotNoAtomicOutputType<T1, T2>::value_type;
             fnT fn = gemm_tree_impl<T1, T2, T3>;
             return fn;
         }
@@ -265,13 +267,13 @@ template <typename fnT, typename T1, typename T2> struct GemmContigTempsFactory
 {
     fnT get()
     {
-        using T3 = typename DotNoAtomicOutputType<T1, T2>::value_type;
-        if constexpr (std::is_same_v<T3, void>) {
+        if constexpr (!DotNoAtomicOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
         else {
             using dpctl::tensor::kernels::gemm_contig_tree_impl;
+            using T3 = typename DotNoAtomicOutputType<T1, T2>::value_type;
             fnT fn = gemm_contig_tree_impl<T1, T2, T3>;
             return fn;
         }
@@ -282,13 +284,13 @@ template <typename fnT, typename T1, typename T2> struct GemmBatchTempsFactory
 {
     fnT get()
     {
-        using T3 = typename DotNoAtomicOutputType<T1, T2>::value_type;
-        if constexpr (std::is_same_v<T3, void>) {
+        if constexpr (!DotNoAtomicOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
         else {
             using dpctl::tensor::kernels::gemm_batch_tree_impl;
+            using T3 = typename DotNoAtomicOutputType<T1, T2>::value_type;
             fnT fn = gemm_batch_tree_impl<T1, T2, T3>;
             return fn;
         }
@@ -300,13 +302,13 @@ struct GemmBatchContigTempsFactory
 {
     fnT get()
     {
-        using T3 = typename DotNoAtomicOutputType<T1, T2>::value_type;
-        if constexpr (std::is_same_v<T3, void>) {
+        if constexpr (!DotNoAtomicOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
         else {
             using dpctl::tensor::kernels::gemm_batch_contig_tree_impl;
+            using T3 = typename DotNoAtomicOutputType<T1, T2>::value_type;
             fnT fn = gemm_batch_contig_tree_impl<T1, T2, T3>;
             return fn;
         }
@@ -317,13 +319,13 @@ template <typename fnT, typename T1, typename T2> struct DotProductAtomicFactory
 {
     fnT get()
     {
-        using T3 = typename DotAtomicOutputType<T1, T2>::value_type;
-        if constexpr (std::is_same_v<T3, void>) {
+        if constexpr (!DotAtomicOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
         else {
             using dpctl::tensor::kernels::dot_product_impl;
+            using T3 = typename DotAtomicOutputType<T1, T2>::value_type;
             fnT fn = dot_product_impl<T1, T2, T3>;
             return fn;
         }
@@ -335,13 +337,13 @@ struct DotProductNoAtomicFactory
 {
     fnT get()
     {
-        using T3 = typename DotNoAtomicOutputType<T1, T2>::value_type;
-        if constexpr (std::is_same_v<T3, void>) {
+        if constexpr (!DotNoAtomicOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
         else {
             using dpctl::tensor::kernels::dot_product_tree_impl;
+            using T3 = typename DotNoAtomicOutputType<T1, T2>::value_type;
             fnT fn = dot_product_tree_impl<T1, T2, T3>;
             return fn;
         }
@@ -353,13 +355,13 @@ struct DotProductContigAtomicFactory
 {
     fnT get()
     {
-        using T3 = typename DotAtomicOutputType<T1, T2>::value_type;
-        if constexpr (std::is_same_v<T3, void>) {
+        if constexpr (!DotAtomicOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
         else {
             using dpctl::tensor::kernels::dot_product_contig_impl;
+            using T3 = typename DotAtomicOutputType<T1, T2>::value_type;
             fnT fn = dot_product_contig_impl<T1, T2, T3>;
             return fn;
         }
@@ -371,13 +373,13 @@ struct DotProductContigNoAtomicFactory
 {
     fnT get()
     {
-        using T3 = typename DotNoAtomicOutputType<T1, T2>::value_type;
-        if constexpr (std::is_same_v<T3, void>) {
+        if constexpr (!DotNoAtomicOutputType<T1, T2>::is_defined) {
             fnT fn = nullptr;
             return fn;
         }
         else {
             using dpctl::tensor::kernels::dot_product_contig_tree_impl;
+            using T3 = typename DotNoAtomicOutputType<T1, T2>::value_type;
             fnT fn = dot_product_contig_tree_impl<T1, T2, T3>;
             return fn;
         }
diff --git a/dpctl/tensor/libtensor/source/reductions/argmax.cpp b/dpctl/tensor/libtensor/source/reductions/argmax.cpp
index acfeb95087..90977307e8 100644
--- a/dpctl/tensor/libtensor/source/reductions/argmax.cpp
+++ b/dpctl/tensor/libtensor/source/reductions/argmax.cpp
@@ -68,9 +68,7 @@ template <typename argTy, typename outTy>
 struct TypePairSupportForArgmaxReductionTemps
 {
 
-    static constexpr bool is_defined = std::disjunction< // disjunction is C++17
-                                                         // feature, supported
-                                                         // by DPC++ input bool
+    static constexpr bool is_defined = std::disjunction<
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, std::int64_t>,
         // input int8_t
         td_ns::TypePairDefinedEntry<argTy, std::int8_t, outTy, std::int64_t>,
diff --git a/dpctl/tensor/libtensor/source/reductions/argmin.cpp b/dpctl/tensor/libtensor/source/reductions/argmin.cpp
index 8e9c0106ac..342298936f 100644
--- a/dpctl/tensor/libtensor/source/reductions/argmin.cpp
+++ b/dpctl/tensor/libtensor/source/reductions/argmin.cpp
@@ -69,9 +69,7 @@ template <typename argTy, typename outTy>
 struct TypePairSupportForArgminReductionTemps
 {
 
-    static constexpr bool is_defined = std::disjunction< // disjunction is C++17
-                                                         // feature, supported
-                                                         // by DPC++ input bool
+    static constexpr bool is_defined = std::disjunction<
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, std::int64_t>,
         // input int8_t
         td_ns::TypePairDefinedEntry<argTy, std::int8_t, outTy, std::int64_t>,
diff --git a/dpctl/tensor/libtensor/source/reductions/logsumexp.cpp b/dpctl/tensor/libtensor/source/reductions/logsumexp.cpp
index d36b715f32..5037f8f00f 100644
--- a/dpctl/tensor/libtensor/source/reductions/logsumexp.cpp
+++ b/dpctl/tensor/libtensor/source/reductions/logsumexp.cpp
@@ -67,9 +67,7 @@ template <typename argTy, typename outTy>
 struct TypePairSupportDataForLogSumExpReductionTemps
 {
 
-    static constexpr bool is_defined = std::disjunction< // disjunction is C++17
-                                                         // feature, supported
-                                                         // by DPC++ input bool
+    static constexpr bool is_defined = std::disjunction<
 #if 1
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, sycl::half>,
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, float>,
diff --git a/dpctl/tensor/libtensor/source/reductions/max.cpp b/dpctl/tensor/libtensor/source/reductions/max.cpp
index 8036d873aa..896191c1dd 100644
--- a/dpctl/tensor/libtensor/source/reductions/max.cpp
+++ b/dpctl/tensor/libtensor/source/reductions/max.cpp
@@ -78,10 +78,8 @@ static reduction_contig_impl_fn_ptr
 template <typename argTy, typename outTy>
 struct TypePairSupportDataForMaxReductionAtomic
 {
-
     /* value is true if a kernel for <argTy, outTy> must be instantiated, false
      * otherwise */
-    // disjunction is C++17 feature, supported by DPC++
     static constexpr bool is_defined = std::disjunction<
         // input int32
         td_ns::TypePairDefinedEntry<argTy, std::int32_t, outTy, std::int32_t>,
@@ -102,8 +100,6 @@ struct TypePairSupportDataForMaxReductionAtomic
 template <typename argTy, typename outTy>
 struct TypePairSupportDataForMaxReductionTemps
 {
-
-    // disjunction is C++17 feature, supported by DPC++
     static constexpr bool is_defined = std::disjunction<
         // input bool
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, bool>,
diff --git a/dpctl/tensor/libtensor/source/reductions/min.cpp b/dpctl/tensor/libtensor/source/reductions/min.cpp
index e612e59b8f..24e71794b4 100644
--- a/dpctl/tensor/libtensor/source/reductions/min.cpp
+++ b/dpctl/tensor/libtensor/source/reductions/min.cpp
@@ -78,10 +78,8 @@ static reduction_contig_impl_fn_ptr
 template <typename argTy, typename outTy>
 struct TypePairSupportDataForMinReductionAtomic
 {
-
     /* value is true if a kernel for <argTy, outTy> must be instantiated, false
      * otherwise */
-    // disjunction is C++17 feature, supported by DPC++
     static constexpr bool is_defined = std::disjunction<
         // input int32
         td_ns::TypePairDefinedEntry<argTy, std::int32_t, outTy, std::int32_t>,
@@ -102,8 +100,6 @@ struct TypePairSupportDataForMinReductionAtomic
 template <typename argTy, typename outTy>
 struct TypePairSupportDataForMinReductionTemps
 {
-
-    // disjunction is C++17 feature, supported by DPC++
     static constexpr bool is_defined = std::disjunction<
         // input bool
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, bool>,
diff --git a/dpctl/tensor/libtensor/source/reductions/prod.cpp b/dpctl/tensor/libtensor/source/reductions/prod.cpp
index 9b8df53a01..5299ae83b8 100644
--- a/dpctl/tensor/libtensor/source/reductions/prod.cpp
+++ b/dpctl/tensor/libtensor/source/reductions/prod.cpp
@@ -79,9 +79,7 @@ struct TypePairSupportDataForProductReductionAtomic
 
     /* value if true a kernel for <argTy, outTy> must be instantiated, false
      * otherwise */
-    static constexpr bool is_defined = std::disjunction< // disjunction is C++17
-                                                         // feature, supported
-                                                         // by DPC++ input bool
+    static constexpr bool is_defined = std::disjunction<
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, std::int32_t>,
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, std::uint32_t>,
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, std::int64_t>,
@@ -121,9 +119,7 @@ template <typename argTy, typename outTy>
 struct TypePairSupportDataForProductReductionTemps
 {
 
-    static constexpr bool is_defined = std::disjunction< // disjunction is C++17
-                                                         // feature, supported
-                                                         // by DPC++ input bool
+    static constexpr bool is_defined = std::disjunction<
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, std::int8_t>,
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, std::uint8_t>,
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, std::int16_t>,
diff --git a/dpctl/tensor/libtensor/source/reductions/reduce_hypot.cpp b/dpctl/tensor/libtensor/source/reductions/reduce_hypot.cpp
index 159b992307..1b9aeeff50 100644
--- a/dpctl/tensor/libtensor/source/reductions/reduce_hypot.cpp
+++ b/dpctl/tensor/libtensor/source/reductions/reduce_hypot.cpp
@@ -67,9 +67,7 @@ template <typename argTy, typename outTy>
 struct TypePairSupportDataForHypotReductionTemps
 {
 
-    static constexpr bool is_defined = std::disjunction< // disjunction is C++17
-                                                         // feature, supported
-                                                         // by DPC++ input bool
+    static constexpr bool is_defined = std::disjunction<
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, sycl::half>,
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, float>,
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, double>,
diff --git a/dpctl/tensor/libtensor/source/reductions/sum.cpp b/dpctl/tensor/libtensor/source/reductions/sum.cpp
index bb24da9287..0221abce67 100644
--- a/dpctl/tensor/libtensor/source/reductions/sum.cpp
+++ b/dpctl/tensor/libtensor/source/reductions/sum.cpp
@@ -79,9 +79,7 @@ struct TypePairSupportDataForSumReductionAtomic
 
     /* value if true a kernel for <argTy, outTy> must be instantiated, false
      * otherwise */
-    static constexpr bool is_defined = std::disjunction< // disjunction is C++17
-                                                         // feature, supported
-                                                         // by DPC++ input bool
+    static constexpr bool is_defined = std::disjunction<
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, std::int32_t>,
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, std::uint32_t>,
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, std::int64_t>,
@@ -121,9 +119,7 @@ template <typename argTy, typename outTy>
 struct TypePairSupportDataForSumReductionTemps
 {
 
-    static constexpr bool is_defined = std::disjunction< // disjunction is C++17
-                                                         // feature, supported
-                                                         // by DPC++ input bool
+    static constexpr bool is_defined = std::disjunction<
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, std::int8_t>,
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, std::uint8_t>,
         td_ns::TypePairDefinedEntry<argTy, bool, outTy, std::int16_t>,