Adds math_utils.hpp with complex comparison functions

Author: ndgrigorian

dpctl/tensor/libtensor/include/utils/math_utils.hpp

@@ -0,0 +1,124 @@
+//===------- math_utils.hpp - Implementation of math utils  -------*-C++-*/===//
+//
+//                      Data Parallel Control (dpctl)
+//
+// Copyright 2020-2023 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines math utility functions.
+//===----------------------------------------------------------------------===//
+
+#pragma once
+#include <cmath>
+#include <complex>
+
+namespace dpctl
+{
+namespace tensor
+{
+namespace math_utils
+{
+
+template <T>
+bool less_complex(const std::complex<T> &x1, const std::complex<T> &x2)
+{
+    T real1 = std::real(x1);
+    T real2 = std::real(x2);
+    T imag1 = std::imag(x1);
+    T imag2 = std::imag(x2);
+
+    return (real1 == real2)
+               ? (imag1 < imag2)
+               : (real1 < real2 && !std::isnan(imag1) && !std::isnan(imag2));
+}
+
+template <T>
+bool greater_complex(const std::complex<T> &x1, const std::complex<T> &x2)
+{
+    T real1 = std::real(x1);
+    T real2 = std::real(x2);
+    T imag1 = std::imag(x1);
+    T imag2 = std::imag(x2);
+
+    return (real1 == real2)
+               ? (imag1 > imag2)
+               : (real1 > real2 && !std::isnan(imag1) && !std::isnan(imag2));
+}
+
+template <T>
+bool less_equal_complex(const std::complex<T> &x1, const std::complex<T> &x2)
+{
+    T real1 = std::real(x1);
+    T real2 = std::real(x2);
+    T imag1 = std::imag(x1);
+    T imag2 = std::imag(x2);
+
+    return (real1 == real2)
+               ? (imag1 <= imag2)
+               : (real1 < real2 && !std::isnan(imag1) && !std::isnan(imag2));
+}
+
+template <T>
+bool greater_equal_complex(const std::complex<T> &x1, const std::complex<T> &x2)
+{
+    T real1 = std::real(x1);
+    T real2 = std::real(x2);
+    T imag1 = std::imag(x1);
+    T imag2 = std::imag(x2);
+
+    return (real1 == real2)
+               ? (imag1 >= imag2)
+               : (real1 > real2 && !std::isnan(imag1) && !std::isnan(imag2));
+}
+
+template <T>
+std::complex<T> max_complex(const std::complex<T> &x1,
+                            const std::complex<T> &x2)
+{
+    T real1 = std::real(x1);
+    T real2 = std::real(x2);
+    T imag1 = std::imag(x1);
+    T imag2 = std::imag(x2);
+
+    bool isnan_imag2 = std::isnan(imag2);
+    bool gt = (real1 == real2) ? (imag1 > imag2)
+              : (real1 > real2 && !std::isnan(imag1) &&
+                 !isnan_imag2) return (std::isnan(real1) || isnan_imag2 || gt)
+                  ? x1
+                  : x2;
+}
+
+template <T>
+std::complex<T> min_complex(const std::complex<T> &x1,
+                            const std::complex<T> &x2)
+{
+    T real1 = std::real(x1);
+    T real2 = std::real(x2);
+    T imag1 = std::imag(x1);
+    T imag2 = std::imag(x2);
+
+    bool isnan_imag2 = std::isnan(imag2);
+    bool lt = (real1 == real2) ? (imag1 < imag2)
+              : (real1 < real2 && !std::isnan(imag1) &&
+                 !isnan_imag2) return (std::isnan(real1) || isnan_imag2 || lt)
+                  ? x1
+                  : x2;
+}
+
+} // namespace math_utils
+} // namespace tensor
+} // namespace dpctl