Replaced remaining uses of std::cos, std::exp, etc.

oleksandr-pavlyk · oleksandr-pavlyk · commit 163bd3c8819c · 2024-06-09T08:56:12.000-05:00
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/cosh.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/cosh.hpp
@@ -213,7 +213,7 @@ template <typename fnT, typename T> struct CoshContigFactory
 
 template <typename fnT, typename T> struct CoshTypeMapFactory
 {
-    /*! @brief get typeid for output type of std::cosh(T x) */
+    /*! @brief get typeid for output type of sycl::cosh(T x) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename CoshOutputType<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
@@ -104,7 +104,7 @@ template <typename argT, typename resT> struct ExpFunctor
                 }
                 else { /* x is -inf */
                     if (std::isfinite(y)) {
-                        realT exp_x = std::exp(x);
+                        realT exp_x = sycl::exp(x);
                         return resT{exp_x * sycl::cos(y), exp_x * sycl::sin(y)};
                     }
                     else {
@@ -182,7 +182,7 @@ template <typename fnT, typename T> struct ExpContigFactory
 
 template <typename fnT, typename T> struct ExpTypeMapFactory
 {
-    /*! @brief get typeid for output type of std::exp(T x) */
+    /*! @brief get typeid for output type of sycl::exp(T x) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename ExpOutputType<T>::value_type;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/exp2.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/exp2.hpp
@@ -106,7 +106,7 @@ template <typename argT, typename resT> struct Exp2Functor
                 }
                 else { /* x is -inf */
                     if (std::isfinite(y)) {
-                        realT exp_x = std::exp(x);
+                        realT exp_x = sycl::exp(x);
                         return resT{exp_x * sycl::cos(y), exp_x * sycl::sin(y)};
                     }
                     else {
@@ -184,7 +184,7 @@ template <typename fnT, typename T> struct Exp2ContigFactory
 
 template <typename fnT, typename T> struct Exp2TypeMapFactory
 {
-    /*! @brief get typeid for output type of std::exp2(T x) */
+    /*! @brief get typeid for output type of sycl::exp2(T x) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename Exp2OutputType<T>::value_type;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/expm1.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/expm1.hpp
@@ -84,8 +84,8 @@ template <typename argT, typename resT> struct Expm1Functor
                         return in;
                     }
                     else {
-                        return (resT{sycl::copysign(x, std::cos(y)),
-                                     sycl::copysign(x, std::sin(y))});
+                        return (resT{sycl::copysign(x, sycl::cos(y)),
+                                     sycl::copysign(x, sycl::sin(y))});
                     }
                 }
                 else {
@@ -97,7 +97,7 @@ template <typename argT, typename resT> struct Expm1Functor
                     }
                     else {
                         return resT{realT(-1),
-                                    sycl::copysign(realT(0), std::sin(y))};
+                                    sycl::copysign(realT(0), sycl::sin(y))};
                     }
                 }
             }
@@ -113,13 +113,13 @@ template <typename argT, typename resT> struct Expm1Functor
             }
 
             // x, y finite numbers
-            const realT cosY_val = std::cos(y);
-            const realT sinY_val = (y == 0) ? y : std::sin(y);
-            const realT sinhalfY_val = (y == 0) ? y : std::sin(y / 2);
+            const realT cosY_val = sycl::cos(y);
+            const realT sinY_val = (y == 0) ? y : sycl::sin(y);
+            const realT sinhalfY_val = (y == 0) ? y : sycl::sin(y / 2);
 
             const realT res_re =
-                std::expm1(x) * cosY_val - 2 * sinhalfY_val * sinhalfY_val;
-            realT res_im = std::exp(x) * sinY_val;
+                sycl::expm1(x) * cosY_val - 2 * sinhalfY_val * sinhalfY_val;
+            realT res_im = sycl::exp(x) * sinY_val;
             return resT{res_re, res_im};
         }
         else {
@@ -129,7 +129,7 @@ template <typename argT, typename resT> struct Expm1Functor
             if (in == 0) {
                 return in;
             }
-            return std::expm1(in);
+            return sycl::expm1(in);
         }
     }
 };
@@ -197,7 +197,7 @@ template <typename fnT, typename T> struct Expm1ContigFactory
 
 template <typename fnT, typename T> struct Expm1TypeMapFactory
 {
-    /*! @brief get typeid for output type of std::expm1(T x) */
+    /*! @brief get typeid for output type of sycl::expm1(T x) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename Expm1OutputType<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
@@ -91,8 +91,8 @@ template <typename argT1, typename argT2, typename resT> struct LogAddExpFunctor
 private:
     template <typename T> T impl_finite(T const &in) const
     {
-        return (in > 0) ? (in + std::log1p(std::exp(-in)))
-                        : std::log1p(std::exp(in));
+        return (in > 0) ? (in + sycl::log1p(sycl::exp(-in)))
+                        : sycl::log1p(sycl::exp(in));
     }
 };
 
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sin.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sin.hpp
@@ -158,7 +158,7 @@ template <typename argT, typename resT> struct SinFunctor
                 }
                 const realT sinh_re = x * sycl::cos(y);
                 const realT sinh_im =
-                    std::numeric_limits<realT>::infinity() * std::sin(y);
+                    std::numeric_limits<realT>::infinity() * sycl::sin(y);
                 return resT{sinh_im, -sinh_re};
             }
 
@@ -246,7 +246,7 @@ template <typename fnT, typename T> struct SinContigFactory
 
 template <typename fnT, typename T> struct SinTypeMapFactory
 {
-    /*! @brief get typeid for output type of std::sin(T x) */
+    /*! @brief get typeid for output type of sycl::sin(T x) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename SinOutputType<T>::value_type;
diff --git a/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sinh.hpp b/dpctl/tensor/libtensor/include/kernels/elementwise_functions/sinh.hpp
@@ -215,7 +215,7 @@ template <typename fnT, typename T> struct SinhContigFactory
 
 template <typename fnT, typename T> struct SinhTypeMapFactory
 {
-    /*! @brief get typeid for output type of std::sinh(T x) */
+    /*! @brief get typeid for output type of sycl::sinh(T x) */
     std::enable_if_t<std::is_same<fnT, int>::value, int> get()
     {
         using rT = typename SinhOutputType<T>::value_type;
diff --git a/dpctl/tensor/libtensor/include/utils/math_utils.hpp b/dpctl/tensor/libtensor/include/utils/math_utils.hpp
@@ -118,16 +118,16 @@ template <typename T> T min_complex(const T &x1, const T &x2)
 template <typename T> T logaddexp(T x, T y)
 {
     if (x == y) { // handle signed infinities
-        const T log2 = std::log(T(2));
+        const T log2 = sycl::log(T(2));
         return x + log2;
     }
     else {
         const T tmp = x - y;
         if (tmp > 0) {
-            return x + std::log1p(std::exp(-tmp));
+            return x + sycl::log1p(sycl::exp(-tmp));
         }
         else if (tmp <= 0) {
-            return y + std::log1p(std::exp(tmp));
+            return y + sycl::log1p(sycl::exp(tmp));
         }
         else {
             return std::numeric_limits<T>::quiet_NaN();

Original file line number	Diff line number	Diff line change
`@@ -213,7 +213,7 @@ template <typename fnT, typename T> struct CoshContigFactory`
`213`	`213`
`214`	`214`	`template <typename fnT, typename T> struct CoshTypeMapFactory`
`215`	`215`	`{`
`216`		`- /! @brief get typeid for output type of std::cosh(T x) /`
	`216`	`+ /! @brief get typeid for output type of sycl::cosh(T x) /`
`217`	`217`	`std::enable_if_t<std::is_same<fnT, int>::value, int> get()`
`218`	`218`	`{`
`219`	`219`	`using rT = typename CoshOutputType<T>::value_type;`
Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ template <typename argT, typename resT> struct ExpFunctor`
`104`	`104`	`}`
`105`	`105`	`else { /* x is -inf */`
`106`	`106`	`if (std::isfinite(y)) {`
`107`		`- realT exp_x = std::exp(x);`
	`107`	`+ realT exp_x = sycl::exp(x);`
`108`	`108`	`return resT{exp_x * sycl::cos(y), exp_x * sycl::sin(y)};`
`109`	`109`	`}`
`110`	`110`	`else {`
`@@ -182,7 +182,7 @@ template <typename fnT, typename T> struct ExpContigFactory`
`182`	`182`
`183`	`183`	`template <typename fnT, typename T> struct ExpTypeMapFactory`
`184`	`184`	`{`
`185`		`- /! @brief get typeid for output type of std::exp(T x) /`
	`185`	`+ /! @brief get typeid for output type of sycl::exp(T x) /`
`186`	`186`	`std::enable_if_t<std::is_same<fnT, int>::value, int> get()`
`187`	`187`	`{`
`188`	`188`	`using rT = typename ExpOutputType<T>::value_type;`
Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ template <typename argT, typename resT> struct Exp2Functor`
`106`	`106`	`}`
`107`	`107`	`else { /* x is -inf */`
`108`	`108`	`if (std::isfinite(y)) {`
`109`		`- realT exp_x = std::exp(x);`
	`109`	`+ realT exp_x = sycl::exp(x);`
`110`	`110`	`return resT{exp_x * sycl::cos(y), exp_x * sycl::sin(y)};`
`111`	`111`	`}`
`112`	`112`	`else {`
`@@ -184,7 +184,7 @@ template <typename fnT, typename T> struct Exp2ContigFactory`
`184`	`184`
`185`	`185`	`template <typename fnT, typename T> struct Exp2TypeMapFactory`
`186`	`186`	`{`
`187`		`- /! @brief get typeid for output type of std::exp2(T x) /`
	`187`	`+ /! @brief get typeid for output type of sycl::exp2(T x) /`
`188`	`188`	`std::enable_if_t<std::is_same<fnT, int>::value, int> get()`
`189`	`189`	`{`
`190`	`190`	`using rT = typename Exp2OutputType<T>::value_type;`
Original file line number	Diff line number	Diff line change
`@@ -84,8 +84,8 @@ template <typename argT, typename resT> struct Expm1Functor`
`84`	`84`	`return in;`
`85`	`85`	`}`
`86`	`86`	`else {`
`87`		`- return (resT{sycl::copysign(x, std::cos(y)),`
`88`		`- sycl::copysign(x, std::sin(y))});`
	`87`	`+ return (resT{sycl::copysign(x, sycl::cos(y)),`
	`88`	`+ sycl::copysign(x, sycl::sin(y))});`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`	`else {`
`@@ -97,7 +97,7 @@ template <typename argT, typename resT> struct Expm1Functor`
`97`	`97`	`}`
`98`	`98`	`else {`
`99`	`99`	`return resT{realT(-1),`
`100`		`- sycl::copysign(realT(0), std::sin(y))};`
	`100`	`+ sycl::copysign(realT(0), sycl::sin(y))};`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`	`}`
`@@ -113,13 +113,13 @@ template <typename argT, typename resT> struct Expm1Functor`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`// x, y finite numbers`
`116`		`- const realT cosY_val = std::cos(y);`
`117`		`- const realT sinY_val = (y == 0) ? y : std::sin(y);`
`118`		`- const realT sinhalfY_val = (y == 0) ? y : std::sin(y / 2);`
	`116`	`+ const realT cosY_val = sycl::cos(y);`
	`117`	`+ const realT sinY_val = (y == 0) ? y : sycl::sin(y);`
	`118`	`+ const realT sinhalfY_val = (y == 0) ? y : sycl::sin(y / 2);`
`119`	`119`
`120`	`120`	`const realT res_re =`
`121`		`- std::expm1(x) * cosY_val - 2 * sinhalfY_val * sinhalfY_val;`
`122`		`- realT res_im = std::exp(x) * sinY_val;`
	`121`	`+ sycl::expm1(x) * cosY_val - 2 * sinhalfY_val * sinhalfY_val;`
	`122`	`+ realT res_im = sycl::exp(x) * sinY_val;`
`123`	`123`	`return resT{res_re, res_im};`
`124`	`124`	`}`
`125`	`125`	`else {`
`@@ -129,7 +129,7 @@ template <typename argT, typename resT> struct Expm1Functor`
`129`	`129`	`if (in == 0) {`
`130`	`130`	`return in;`
`131`	`131`	`}`
`132`		`- return std::expm1(in);`
	`132`	`+ return sycl::expm1(in);`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`	`};`
`@@ -197,7 +197,7 @@ template <typename fnT, typename T> struct Expm1ContigFactory`
`197`	`197`
`198`	`198`	`template <typename fnT, typename T> struct Expm1TypeMapFactory`
`199`	`199`	`{`
`200`		`- /! @brief get typeid for output type of std::expm1(T x) /`
	`200`	`+ /! @brief get typeid for output type of sycl::expm1(T x) /`
`201`	`201`	`std::enable_if_t<std::is_same<fnT, int>::value, int> get()`
`202`	`202`	`{`
`203`	`203`	`using rT = typename Expm1OutputType<T>::value_type;`
Original file line number	Diff line number	Diff line change
`@@ -91,8 +91,8 @@ template <typename argT1, typename argT2, typename resT> struct LogAddExpFunctor`
`91`	`91`	`private:`
`92`	`92`	`template <typename T> T impl_finite(T const &in) const`
`93`	`93`	`{`
`94`		`- return (in > 0) ? (in + std::log1p(std::exp(-in)))`
`95`		`- : std::log1p(std::exp(in));`
	`94`	`+ return (in > 0) ? (in + sycl::log1p(sycl::exp(-in)))`
	`95`	`+ : sycl::log1p(sycl::exp(in));`
`96`	`96`	`}`
`97`	`97`	`};`
`98`	`98`
Original file line number	Diff line number	Diff line change
`@@ -158,7 +158,7 @@ template <typename argT, typename resT> struct SinFunctor`
`158`	`158`	`}`
`159`	`159`	`const realT sinh_re = x * sycl::cos(y);`
`160`	`160`	`const realT sinh_im =`
`161`		`- std::numeric_limits<realT>::infinity() * std::sin(y);`
	`161`	`+ std::numeric_limits<realT>::infinity() * sycl::sin(y);`
`162`	`162`	`return resT{sinh_im, -sinh_re};`
`163`	`163`	`}`
`164`	`164`
`@@ -246,7 +246,7 @@ template <typename fnT, typename T> struct SinContigFactory`
`246`	`246`
`247`	`247`	`template <typename fnT, typename T> struct SinTypeMapFactory`
`248`	`248`	`{`
`249`		`- /! @brief get typeid for output type of std::sin(T x) /`
	`249`	`+ /! @brief get typeid for output type of sycl::sin(T x) /`
`250`	`250`	`std::enable_if_t<std::is_same<fnT, int>::value, int> get()`
`251`	`251`	`{`
`252`	`252`	`using rT = typename SinOutputType<T>::value_type;`
Original file line number	Diff line number	Diff line change
`@@ -215,7 +215,7 @@ template <typename fnT, typename T> struct SinhContigFactory`
`215`	`215`
`216`	`216`	`template <typename fnT, typename T> struct SinhTypeMapFactory`
`217`	`217`	`{`
`218`		`- /! @brief get typeid for output type of std::sinh(T x) /`
	`218`	`+ /! @brief get typeid for output type of sycl::sinh(T x) /`
`219`	`219`	`std::enable_if_t<std::is_same<fnT, int>::value, int> get()`
`220`	`220`	`{`
`221`	`221`	`using rT = typename SinhOutputType<T>::value_type;`
Original file line number	Diff line number	Diff line change
`@@ -118,16 +118,16 @@ template <typename T> T min_complex(const T &x1, const T &x2)`
`118`	`118`	`template <typename T> T logaddexp(T x, T y)`
`119`	`119`	`{`
`120`	`120`	`if (x == y) { // handle signed infinities`
`121`		`- const T log2 = std::log(T(2));`
	`121`	`+ const T log2 = sycl::log(T(2));`
`122`	`122`	`return x + log2;`
`123`	`123`	`}`
`124`	`124`	`else {`
`125`	`125`	`const T tmp = x - y;`
`126`	`126`	`if (tmp > 0) {`
`127`		`- return x + std::log1p(std::exp(-tmp));`
	`127`	`+ return x + sycl::log1p(sycl::exp(-tmp));`
`128`	`128`	`}`
`129`	`129`	`else if (tmp <= 0) {`
`130`		`- return y + std::log1p(std::exp(tmp));`
	`130`	`+ return y + sycl::log1p(sycl::exp(tmp));`
`131`	`131`	`}`
`132`	`132`	`else {`
`133`	`133`	`return std::numeric_limits<T>::quiet_NaN();`