refactor: rename _array/_scalar suffixes to match numpy API names

numpy.hypot / arctan2 / maximum / minimum have no suffix — C++ public
API should mirror numpy exactly. Replace with overloads:

  hypot_array   → hypot(a, b, dst, n)
  arctan2_array → arctan2(a, b, dst, n)
  arctan2_scalar→ arctan2(src, dst, n, scalar)   [overload]
  maximum_array → maximum(a, b, dst, n)
  maximum_scalar→ maximum(src, dst, n, scalar)   [overload]
  minimum_array → minimum(a, b, dst, n)
  minimum_scalar→ minimum(src, dst, n, scalar)   [overload]

All 792 tests pass.

Author: peng.li24

numpy/core.h

@@ -452,40 +452,40 @@ inline void isfinite(const T* src, bool* dst, size_t n) {
 // Binary element-wise — 2 arrays T in → T out
 // ============================================================================
 
-/// numpy.hypot(x1, x2, /, out=None, *, where=True, ...) — array-array
+/// numpy.hypot(x1, x2, /, out=None, *, where=True, ...)
 template<typename T>
-inline void hypot_array(const T* a, const T* b, T* dst, size_t n) {
+inline void hypot(const T* a, const T* b, T* dst, size_t n) {
     NUMPY_UNROLL4(i, dst[i] = detail::hypot(a[i], b[i]));
 }
 
 /// numpy.arctan2(x1, x2, /, out=None, *, where=True, ...) — array-array
 template<typename T>
-inline void arctan2_array(const T* a, const T* b, T* dst, size_t n) {
+inline void arctan2(const T* a, const T* b, T* dst, size_t n) {
     NUMPY_UNROLL4(i, dst[i] = detail::atan2(a[i], b[i]));
 }
 /// numpy.arctan2(x1, x2, /, out=None, *, where=True, ...) — array-scalar
 template<typename T>
-inline void arctan2_scalar(const T* src, T* dst, size_t n, T b) {
+inline void arctan2(const T* src, T* dst, size_t n, T b) {
     NUMPY_UNROLL4(i, dst[i] = detail::atan2(src[i], b));
 }
 /// numpy.maximum(x1, x2, /, out=None, *, where=True, ...) — array-array
 template<typename T>
-inline void maximum_array(const T* a, const T* b, T* dst, size_t n) {
+inline void maximum(const T* a, const T* b, T* dst, size_t n) {
     NUMPY_UNROLL4(i, dst[i] = std::max(a[i], b[i]));
 }
-/// numpy.maximum(x1, x2, /, out=None, *, where=True, ...) — scalar variant
+/// numpy.maximum(x1, x2, /, out=None, *, where=True, ...) — array-scalar
 template<typename T>
-inline void maximum_scalar(const T* src, T* dst, size_t n, T b) {
+inline void maximum(const T* src, T* dst, size_t n, T b) {
     NUMPY_UNROLL4(i, dst[i] = std::max(src[i], b));
 }
 /// numpy.minimum(x1, x2, /, out=None, *, where=True, ...) — array-array
 template<typename T>
-inline void minimum_array(const T* a, const T* b, T* dst, size_t n) {
+inline void minimum(const T* a, const T* b, T* dst, size_t n) {
     NUMPY_UNROLL4(i, dst[i] = std::min(a[i], b[i]));
 }
-/// numpy.minimum(x1, x2, /, out=None, *, where=True, ...) — scalar variant
+/// numpy.minimum(x1, x2, /, out=None, *, where=True, ...) — array-scalar
 template<typename T>
-inline void minimum_scalar(const T* src, T* dst, size_t n, T b) {
+inline void minimum(const T* src, T* dst, size_t n, T b) {
     NUMPY_UNROLL4(i, dst[i] = std::min(src[i], b));
 }
 

pycpp/core_py.h

@@ -767,7 +767,7 @@ template<typename T>
 py::array_t<T> hypot(const py::array_t<T>& a, const py::array_t<T>& b) {
     auto ba = a.request(), bb = b.request();
     py::array_t<T> result(ba.shape);
-    hypot_array(static_cast<const T*>(ba.ptr),
+    hypot(static_cast<const T*>(ba.ptr),
                         static_cast<const T*>(bb.ptr),
                         static_cast<T*>(result.request().ptr),
                         std::min(ba.size, bb.size));
@@ -779,7 +779,7 @@ template<typename T>
 py::array_t<T> arctan2(const py::array_t<T>& a, const py::array_t<T>& b) {
     auto ba = a.request(), bb = b.request();
     py::array_t<T> result(ba.shape);
-    arctan2_array(static_cast<const T*>(ba.ptr),
+    arctan2(static_cast<const T*>(ba.ptr),
                           static_cast<const T*>(bb.ptr),
                           static_cast<T*>(result.request().ptr),
                           std::min(ba.size, bb.size));
@@ -791,7 +791,7 @@ template<typename T>
 py::array_t<T> arctan2(const py::array_t<T>& a, T b) {
     auto buf = a.request();
     py::array_t<T> result(buf.shape);
-    arctan2_scalar(static_cast<const T*>(buf.ptr),
+    arctan2(static_cast<const T*>(buf.ptr),
                            static_cast<T*>(result.request().ptr), buf.size, b);
     return result;
 }
@@ -801,7 +801,7 @@ template<typename T>
 py::array_t<T> maximum(const py::array_t<T>& a, const py::array_t<T>& b) {
     auto ba = a.request(), bb = b.request();
     py::array_t<T> result(ba.shape);
-    maximum_array(static_cast<const T*>(ba.ptr),
+    maximum(static_cast<const T*>(ba.ptr),
                           static_cast<const T*>(bb.ptr),
                           static_cast<T*>(result.request().ptr),
                           std::min(ba.size, bb.size));
@@ -813,7 +813,7 @@ template<typename T>
 py::array_t<T> maximum(const py::array_t<T>& a, T b) {
     auto buf = a.request();
     py::array_t<T> result(buf.shape);
-    maximum_scalar(static_cast<const T*>(buf.ptr),
+    maximum(static_cast<const T*>(buf.ptr),
                            static_cast<T*>(result.request().ptr), buf.size, b);
     return result;
 }
@@ -823,7 +823,7 @@ template<typename T>
 py::array_t<T> minimum(const py::array_t<T>& a, const py::array_t<T>& b) {
     auto ba = a.request(), bb = b.request();
     py::array_t<T> result(ba.shape);
-    minimum_array(static_cast<const T*>(ba.ptr),
+    minimum(static_cast<const T*>(ba.ptr),
                           static_cast<const T*>(bb.ptr),
                           static_cast<T*>(result.request().ptr),
                           std::min(ba.size, bb.size));
@@ -835,7 +835,7 @@ template<typename T>
 py::array_t<T> minimum(const py::array_t<T>& a, T b) {
     auto buf = a.request();
     py::array_t<T> result(buf.shape);
-    minimum_scalar(static_cast<const T*>(buf.ptr),
+    minimum(static_cast<const T*>(buf.ptr),
                            static_cast<T*>(result.request().ptr), buf.size, b);
     return result;
 }