Replace remaining std namespace transcendental functions

ndgrigorian · ndgrigorian · commit 6ea1120edce2 · 2024-06-09T21:40:21.000Z
A few stray instances of `signbit`, `atan`,  `log`, and `exp` as well as `atan2` and `hypot`
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/acos.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/acos.hpp
@@ -188,7 +188,7 @@ template <typename fnT, typename T> struct AcosContigFactory
 
 template <typename fnT, typename T> struct AcosTypeMapFactory
 {
-    /*! @brief get typeid for output type of std::acos(T x) */
+    /*! @brief get typeid for output type of sycl::acos(T x) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename AcosOutputType<T>::value_type;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/acosh.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/acosh.hpp
@@ -215,7 +215,7 @@ template <typename fnT, typename T> struct AcoshContigFactory
 
 template <typename fnT, typename T> struct AcoshTypeMapFactory
 {
-    /*! @brief get typeid for output type of std::acosh(T x) */
+    /*! @brief get typeid for output type of sycl::acosh(T x) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename AcoshOutputType<T>::value_type;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/asin.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/asin.hpp
@@ -136,7 +136,7 @@ template <typename argT, typename resT> struct AsinFunctor
             }
             /* ordinary cases */
             return exprm_ns::asin(
-                exprm_ns::complex<realT>(in)); // std::asin(in);
+                exprm_ns::complex<realT>(in)); // sycl::asin(in);
         }
         else {
             static_assert(std::is_floating_point_v<argT> ||
@@ -208,7 +208,7 @@ template <typename fnT, typename T> struct AsinContigFactory
 
 template <typename fnT, typename T> struct AsinTypeMapFactory
 {
-    /*! @brief get typeid for output type of std::asin(T x) */
+    /*! @brief get typeid for output type of sycl::asin(T x) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename AsinOutputType<T>::value_type;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/asinh.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/asinh.hpp
@@ -191,7 +191,7 @@ template <typename fnT, typename T> struct AsinhContigFactory
 
 template <typename fnT, typename T> struct AsinhTypeMapFactory
 {
-    /*! @brief get typeid for output type of std::asinh(T x) */
+    /*! @brief get typeid for output type of sycl::asinh(T x) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename AsinhOutputType<T>::value_type;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/atan.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/atan.hpp
@@ -198,7 +198,7 @@ template <typename fnT, typename T> struct AtanContigFactory
 
 template <typename fnT, typename T> struct AtanTypeMapFactory
 {
-    /*! @brief get typeid for output type of std::atan(T x) */
+    /*! @brief get typeid for output type of sycl::atan(T x) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename AtanOutputType<T>::value_type;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/atan2.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/atan2.hpp
@@ -56,12 +56,12 @@ template <typename argT1, typename argT2, typename resT> struct Atan2Functor
 
     resT operator()(const argT1 &in1, const argT2 &in2) const
     {
-        if (std::isinf(in2) && !std::signbit(in2)) {
+        if (std::isinf(in2) && !sycl::signbit(in2)) {
             if (std::isfinite(in1)) {
                 return sycl::copysign(resT(0), in1);
             }
         }
-        return std::atan2(in1, in2);
+        return sycl::atan2(in1, in2);
     }
 };
 
@@ -145,7 +145,7 @@ template <typename fnT, typename T1, typename T2> struct Atan2ContigFactory
 
 template <typename fnT, typename T1, typename T2> struct Atan2TypeMapFactory
 {
-    /*! @brief get typeid for output type of std::hypot(T1 x, T2 y) */
+    /*! @brief get typeid for output type of sycl::atan2(T1 x, T2 y) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename Atan2OutputType<T1, T2>::value_type;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/atanh.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/atanh.hpp
@@ -76,7 +76,7 @@ template <typename argT, typename resT> struct AtanhFunctor
             if (std::isnan(x)) {
                 /* atanh(NaN + I*+-Inf) = sign(NaN)0 + I*+-PI/2 */
                 if (std::isinf(y)) {
-                    const realT pi_half = std::atan(realT(1)) * 2;
+                    const realT pi_half = sycl::atan(realT(1)) * 2;
 
                     const realT res_re = sycl::copysign(realT(0), x);
                     const realT res_im = sycl::copysign(pi_half, y);
@@ -113,7 +113,7 @@ template <typename argT, typename resT> struct AtanhFunctor
                 realT(1) / std::numeric_limits<realT>::epsilon();
             if (sycl::fabs(x) > RECIP_EPSILON || sycl::fabs(y) > RECIP_EPSILON)
             {
-                const realT pi_half = std::atan(realT(1)) * 2;
+                const realT pi_half = sycl::atan(realT(1)) * 2;
 
                 const realT res_re = realT(0);
                 const realT res_im = sycl::copysign(pi_half, y);
@@ -192,7 +192,7 @@ template <typename fnT, typename T> struct AtanhContigFactory
 
 template <typename fnT, typename T> struct AtanhTypeMapFactory
 {
-    /*! @brief get typeid for output type of std::atanh(T x) */
+    /*! @brief get typeid for output type of sycl::atanh(T x) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename AtanhOutputType<T>::value_type;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/exp.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/exp.hpp
@@ -90,7 +90,7 @@ template <typename argT, typename resT> struct ExpFunctor
                 }
             }
             else {
-                if (!std::signbit(x)) { /* x is +inf */
+                if (!sycl::signbit(x)) { /* x is +inf */
                     if (y == realT(0)) {
                         return resT{x, y};
                     }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/exp2.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/exp2.hpp
@@ -68,7 +68,7 @@ template <typename argT, typename resT> struct Exp2Functor
         if constexpr (is_complex<argT>::value) {
             using realT = typename argT::value_type;
 
-            const argT tmp = in * std::log(realT(2));
+            const argT tmp = in * sycl::log(realT(2));
 
             constexpr realT q_nan = std::numeric_limits<realT>::quiet_NaN();
 
@@ -92,7 +92,7 @@ template <typename argT, typename resT> struct Exp2Functor
                 }
             }
             else {
-                if (!std::signbit(x)) { /* x is +inf */
+                if (!sycl::signbit(x)) { /* x is +inf */
                     if (y == realT(0)) {
                         return resT{x, y};
                     }
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/hypot.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/hypot.hpp
@@ -58,7 +58,7 @@ template <typename argT1, typename argT2, typename resT> struct HypotFunctor
 
     resT operator()(const argT1 &in1, const argT2 &in2) const
     {
-        return std::hypot(in1, in2);
+        return sycl::hypot(in1, in2);
     }
 
     template <int vec_sz>
@@ -160,7 +160,7 @@ template <typename fnT, typename T1, typename T2> struct HypotContigFactory
 
 template <typename fnT, typename T1, typename T2> struct HypotTypeMapFactory
 {
-    /*! @brief get typeid for output type of std::hypot(T1 x, T2 y) */
+    /*! @brief get typeid for output type of sycl::hypot(T1 x, T2 y) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename HypotOutputType<T1, T2>::value_type;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log.hpp
@@ -139,7 +139,7 @@ template <typename fnT, typename T> struct LogContigFactory
 
 template <typename fnT, typename T> struct LogTypeMapFactory
 {
-    /*! @brief get typeid for output type of std::log(T x) */
+    /*! @brief get typeid for output type of sycl::log(T x) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename LogOutputType<T>::value_type;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log10.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log10.hpp
@@ -73,7 +73,7 @@ template <typename argT, typename resT> struct Log10Functor
             using realT = typename argT::value_type;
             // return (log(in) / log(realT{10}));
             return exprm_ns::log(exprm_ns::complex<realT>(in)) /
-                   std::log(realT{10});
+                   sycl::log(realT{10});
         }
         else {
             return sycl::log10(in);
@@ -158,7 +158,7 @@ template <typename fnT, typename T> struct Log10ContigFactory
 
 template <typename fnT, typename T> struct Log10TypeMapFactory
 {
-    /*! @brief get typeid for output type of std::log10(T x) */
+    /*! @brief get typeid for output type of sycl::log10(T x) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename Log10OutputType<T>::value_type;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log1p.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log1p.hpp
@@ -79,23 +79,23 @@ template <typename argT, typename resT> struct Log1pFunctor
             const realT y = std::imag(in);
 
             // imaginary part of result
-            const realT res_im = std::atan2(y, x + 1);
+            const realT res_im = sycl::atan2(y, x + 1);
 
             if (std::max(sycl::fabs(x), sycl::fabs(y)) < realT{.1}) {
                 const realT v = x * (2 + x) + y * y;
-                return resT{std::log1p(v) / 2, res_im};
+                return resT{sycl::log1p(v) / 2, res_im};
             }
             else {
                 // when not close to zero,
                 // prevent overflow
-                const realT m = std::hypot(x + 1, y);
-                return resT{std::log(m), res_im};
+                const realT m = sycl::hypot(x + 1, y);
+                return resT{sycl::log(m), res_im};
             }
         }
         else {
             static_assert(std::is_floating_point_v<argT> ||
                           std::is_same_v<argT, sycl::half>);
-            return std::log1p(in);
+            return sycl::log1p(in);
         }
     }
 };
@@ -163,7 +163,7 @@ template <typename fnT, typename T> struct Log1pContigFactory
 
 template <typename fnT, typename T> struct Log1pTypeMapFactory
 {
-    /*! @brief get typeid for output type of std::log1p(T x) */
+    /*! @brief get typeid for output type of sycl::log1p(T x) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename Log1pOutputType<T>::value_type;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log2.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/log2.hpp
@@ -159,7 +159,7 @@ template <typename fnT, typename T> struct Log2ContigFactory
 
 template <typename fnT, typename T> struct Log2TypeMapFactory
 {
-    /*! @brief get typeid for output type of std::log2(T x) */
+    /*! @brief get typeid for output type of sycl::log2(T x) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename Log2OutputType<T>::value_type;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/logaddexp.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/logaddexp.hpp
@@ -177,7 +177,7 @@ template <typename fnT, typename T1, typename T2> struct LogAddExpContigFactory
 
 template <typename fnT, typename T1, typename T2> struct LogAddExpTypeMapFactory
 {
-    /*! @brief get typeid for output type of std::logaddexp(T1 x, T2 y) */
+    /*! @brief get typeid for output type of logaddexp(T1 x, T2 y) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename LogAddExpOutputType<T1, T2>::value_type;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/tan.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/tan.hpp
@@ -190,7 +190,7 @@ template <typename fnT, typename T> struct TanContigFactory
 
 template <typename fnT, typename T> struct TanTypeMapFactory
 {
-    /*! @brief get typeid for output type of std::tan(T x) */
+    /*! @brief get typeid for output type of sycl::tan(T x) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename TanOutputType<T>::value_type;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/tanh.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/tanh.hpp
@@ -184,7 +184,7 @@ template <typename fnT, typename T> struct TanhContigFactory
 
 template <typename fnT, typename T> struct TanhTypeMapFactory
 {
-    /*! @brief get typeid for output type of std::tanh(T x) */
+    /*! @brief get typeid for output type of sycl::tanh(T x) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename TanhOutputType<T>::value_type;

Original file line number	Diff line number	Diff line change
`@@ -188,7 +188,7 @@ template <typename fnT, typename T> struct AcosContigFactory`
`188`	`188`
`189`	`189`	`template <typename fnT, typename T> struct AcosTypeMapFactory`
`190`	`190`	`{`
`191`		`- /! @brief get typeid for output type of std::acos(T x) /`
	`191`	`+ /! @brief get typeid for output type of sycl::acos(T x) /`
`192`	`192`	`std::enable_if_t<std::is_same<fnT, int>::value, int> get()`
`193`	`193`	`{`
`194`	`194`	`using rT = typename AcosOutputType<T>::value_type;`
Original file line number	Diff line number	Diff line change
`@@ -215,7 +215,7 @@ template <typename fnT, typename T> struct AcoshContigFactory`
`215`	`215`
`216`	`216`	`template <typename fnT, typename T> struct AcoshTypeMapFactory`
`217`	`217`	`{`
`218`		`- /! @brief get typeid for output type of std::acosh(T x) /`
	`218`	`+ /! @brief get typeid for output type of sycl::acosh(T x) /`
`219`	`219`	`std::enable_if_t<std::is_same<fnT, int>::value, int> get()`
`220`	`220`	`{`
`221`	`221`	`using rT = typename AcoshOutputType<T>::value_type;`
Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ template <typename argT, typename resT> struct AsinFunctor`
`136`	`136`	`}`
`137`	`137`	`/* ordinary cases */`
`138`	`138`	`return exprm_ns::asin(`
`139`		`- exprm_ns::complex<realT>(in)); // std::asin(in);`
	`139`	`+ exprm_ns::complex<realT>(in)); // sycl::asin(in);`
`140`	`140`	`}`
`141`	`141`	`else {`
`142`	`142`	`static_assert(std::is_floating_point_v<argT> \|\|`
`@@ -208,7 +208,7 @@ template <typename fnT, typename T> struct AsinContigFactory`
`208`	`208`
`209`	`209`	`template <typename fnT, typename T> struct AsinTypeMapFactory`
`210`	`210`	`{`
`211`		`- /! @brief get typeid for output type of std::asin(T x) /`
	`211`	`+ /! @brief get typeid for output type of sycl::asin(T x) /`
`212`	`212`	`std::enable_if_t<std::is_same<fnT, int>::value, int> get()`
`213`	`213`	`{`
`214`	`214`	`using rT = typename AsinOutputType<T>::value_type;`
Original file line number	Diff line number	Diff line change
`@@ -191,7 +191,7 @@ template <typename fnT, typename T> struct AsinhContigFactory`
`191`	`191`
`192`	`192`	`template <typename fnT, typename T> struct AsinhTypeMapFactory`
`193`	`193`	`{`
`194`		`- /! @brief get typeid for output type of std::asinh(T x) /`
	`194`	`+ /! @brief get typeid for output type of sycl::asinh(T x) /`
`195`	`195`	`std::enable_if_t<std::is_same<fnT, int>::value, int> get()`
`196`	`196`	`{`
`197`	`197`	`using rT = typename AsinhOutputType<T>::value_type;`
Original file line number	Diff line number	Diff line change
`@@ -198,7 +198,7 @@ template <typename fnT, typename T> struct AtanContigFactory`
`198`	`198`
`199`	`199`	`template <typename fnT, typename T> struct AtanTypeMapFactory`
`200`	`200`	`{`
`201`		`- /! @brief get typeid for output type of std::atan(T x) /`
	`201`	`+ /! @brief get typeid for output type of sycl::atan(T x) /`
`202`	`202`	`std::enable_if_t<std::is_same<fnT, int>::value, int> get()`
`203`	`203`	`{`
`204`	`204`	`using rT = typename AtanOutputType<T>::value_type;`
Original file line number	Diff line number	Diff line change
`@@ -56,12 +56,12 @@ template <typename argT1, typename argT2, typename resT> struct Atan2Functor`
`56`	`56`
`57`	`57`	`resT operator()(const argT1 &in1, const argT2 &in2) const`
`58`	`58`	`{`
`59`		`- if (std::isinf(in2) && !std::signbit(in2)) {`
	`59`	`+ if (std::isinf(in2) && !sycl::signbit(in2)) {`
`60`	`60`	`if (std::isfinite(in1)) {`
`61`	`61`	`return sycl::copysign(resT(0), in1);`
`62`	`62`	`}`
`63`	`63`	`}`
`64`		`- return std::atan2(in1, in2);`
	`64`	`+ return sycl::atan2(in1, in2);`
`65`	`65`	`}`
`66`	`66`	`};`
`67`	`67`
`@@ -145,7 +145,7 @@ template <typename fnT, typename T1, typename T2> struct Atan2ContigFactory`
`145`	`145`
`146`	`146`	`template <typename fnT, typename T1, typename T2> struct Atan2TypeMapFactory`
`147`	`147`	`{`
`148`		`- /! @brief get typeid for output type of std::hypot(T1 x, T2 y) /`
	`148`	`+ /! @brief get typeid for output type of sycl::atan2(T1 x, T2 y) /`
`149`	`149`	`std::enable_if_t<std::is_same<fnT, int>::value, int> get()`
`150`	`150`	`{`
`151`	`151`	`using rT = typename Atan2OutputType<T1, T2>::value_type;`
Original file line number	Diff line number	Diff line change
`@@ -90,7 +90,7 @@ template <typename argT, typename resT> struct ExpFunctor`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`	`else {`
`93`		`- if (!std::signbit(x)) { /* x is +inf */`
	`93`	`+ if (!sycl::signbit(x)) { /* x is +inf */`
`94`	`94`	`if (y == realT(0)) {`
`95`	`95`	`return resT{x, y};`
`96`	`96`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ template <typename argT, typename resT> struct Exp2Functor`
`68`	`68`	`if constexpr (is_complex<argT>::value) {`
`69`	`69`	`using realT = typename argT::value_type;`
`70`	`70`
`71`		`- const argT tmp = in * std::log(realT(2));`
	`71`	`+ const argT tmp = in * sycl::log(realT(2));`
`72`	`72`
`73`	`73`	`constexpr realT q_nan = std::numeric_limits<realT>::quiet_NaN();`
`74`	`74`
`@@ -92,7 +92,7 @@ template <typename argT, typename resT> struct Exp2Functor`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`	`else {`
`95`		`- if (!std::signbit(x)) { /* x is +inf */`
	`95`	`+ if (!sycl::signbit(x)) { /* x is +inf */`
`96`	`96`	`if (y == realT(0)) {`
`97`	`97`	`return resT{x, y};`
`98`	`98`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ template <typename argT1, typename argT2, typename resT> struct HypotFunctor`
`58`	`58`
`59`	`59`	`resT operator()(const argT1 &in1, const argT2 &in2) const`
`60`	`60`	`{`
`61`		`- return std::hypot(in1, in2);`
	`61`	`+ return sycl::hypot(in1, in2);`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`template <int vec_sz>`
`@@ -160,7 +160,7 @@ template <typename fnT, typename T1, typename T2> struct HypotContigFactory`
`160`	`160`
`161`	`161`	`template <typename fnT, typename T1, typename T2> struct HypotTypeMapFactory`
`162`	`162`	`{`
`163`		`- /! @brief get typeid for output type of std::hypot(T1 x, T2 y) /`
	`163`	`+ /! @brief get typeid for output type of sycl::hypot(T1 x, T2 y) /`
`164`	`164`	`std::enable_if_t<std::is_same<fnT, int>::value, int> get()`
`165`	`165`	`{`
`166`	`166`	`using rT = typename HypotOutputType<T1, T2>::value_type;`