address reviewer's comments

Author: vtavana

dpctl/tensor/_elementwise_funcs.py

@@ -959,7 +959,8 @@
 _round_docstring = """
 round(x, out=None, order='K')
 
-Computes cosine for each element `x_i` for input array `x`.
+Rounds each element `x_i` of the input array `x` to
+the nearest integer-valued number.
 
 Args:
     x (usm_ndarray):

dpctl/tensor/libtensor/include/kernels/elementwise_functions/round.hpp

@@ -65,46 +65,35 @@ template <typename argT, typename resT> struct RoundFunctor
 
     resT operator()(const argT &in)
     {
+
         if constexpr (std::is_integral_v<argT>) {
             return in;
         }
         else if constexpr (is_complex<argT>::value) {
             using realT = typename argT::value_type;
+            return resT{round_func<realT>(std::real(in)),
+                        round_func<realT>(std::imag(in))};
+        }
+        else {
+            return round_func<argT>(in);
+        }
+    }
 
-            const realT x = std::real(in);
-            const realT y = std::imag(in);
-            realT x_round, y_round;
-            if (std::abs(x - std::floor(x)) == std::abs(x - std::ceil(x))) {
-                x_round = static_cast<int>(std::ceil(x)) % 2 == 0
-                              ? std::ceil(x)
-                              : std::floor(x);
-            }
-            else {
-                x_round = std::round(x);
-            }
-            if (std::abs(y - std::floor(y)) == std::abs(y - std::ceil(y))) {
-                y_round = static_cast<int>(std::ceil(y)) % 2 == 0
-                              ? std::ceil(y)
-                              : std::floor(y);
-            }
-            else {
-                y_round = std::round(y);
-            }
-            return resT{x_round, y_round};
+private:
+    template <typename T> T round_func(T input) const
+    {
+        if (input == 0) {
+            return input;
+        }
+        else if (std::abs(input - std::floor(input)) ==
+                 std::abs(input - std::ceil(input)))
+        {
+            return static_cast<int>(std::ceil(input)) % 2 == 0
+                       ? std::ceil(input)
+                       : std::floor(input);
         }
         else {
-            if (in == 0) {
-                return in;
-            }
-            else if (std::abs(in - std::floor(in)) ==
-                     std::abs(in - std::ceil(in))) {
-                return static_cast<int>(std::ceil(in)) % 2 == 0
-                           ? std::ceil(in)
-                           : std::floor(in);
-            }
-            else {
-                return std::round(in);
-            }
+            return std::round(input);
         }
     }
 };