MAINT,ENH: Smaller reorgs/maint and use sorted=False for `unique_va…

…lues`
numpy · seberg · Feb 27, 2025 · Mar 14, 2024 · Mar 14, 2024 · Mar 15, 2024
commit f96411aa89949d1394647e849d9170890923bb32
diff --git a/doc/release/upcoming_changes/26018.change.rst b/doc/release/upcoming_changes/26018.change.rst
@@ -0,0 +1,7 @@
+``unique_values`` may return unsorted data
+------------------------------------------
+The relatively new function (added in NumPy 2.0) ``unique_values`` may now
+return unsorted results.  Just as ``unique_counts`` and ``unique_all``
+these never guaranteed a sorted result, however, the result
+was sorted until now.  In cases where these do return a sorted result, this
+may change in future releases to improve performance.
diff --git a/numpy/_core/src/multiarray/multiarraymodule.c b/numpy/_core/src/multiarray/multiarraymodule.c
@@ -4565,7 +4565,7 @@ static struct PyMethodDef array_module_methods[] = {
     {"from_dlpack", (PyCFunction)from_dlpack,
         METH_FASTCALL | METH_KEYWORDS, NULL},
     {"_unique_hash",  (PyCFunction)array__unique_hash,
-        METH_VARARGS, "Collect unique values via a hash map."},
+        METH_O, "Collect unique values via a hash map."},
     {NULL, NULL, 0, NULL}                /* sentinel */
 };
 

diff --git a/numpy/_core/src/multiarray/unique.cpp b/numpy/_core/src/multiarray/unique.cpp
@@ -39,33 +39,29 @@ unique(PyArrayObject *self)
     custom or complicated dtypes or string values.
     */
     NPY_ALLOW_C_API_DEF;
-    NpyIter* iter;
-    NpyIter_IterNextFunc *iternext;
-    char** dataptr;
-    npy_intp* strideptr,* innersizeptr;
     std::unordered_set<T> hashset;
 
-    iter = NpyIter_New(self, NPY_ITER_READONLY |
-                             NPY_ITER_EXTERNAL_LOOP |
-                             NPY_ITER_REFS_OK |
-                             NPY_ITER_ZEROSIZE_OK |
-                             NPY_ITER_GROWINNER,
-                        NPY_KEEPORDER, NPY_NO_CASTING,
-                        NULL);
+    NpyIter *iter = NpyIter_New(self, NPY_ITER_READONLY |
+                                      NPY_ITER_EXTERNAL_LOOP |
+                                      NPY_ITER_REFS_OK |
+                                      NPY_ITER_ZEROSIZE_OK |
+                                      NPY_ITER_GROWINNER,
+                                NPY_KEEPORDER, NPY_NO_CASTING,
+                                NULL);
     // Making sure the iterator is deallocated when the function returns, with
     // or w/o an exception
     auto iter_dealloc = finally([&]() { NpyIter_Deallocate(iter); });
     if (iter == NULL) {
         return NULL;
     }
 
-    iternext = NpyIter_GetIterNext(iter, NULL);
+    NpyIter_IterNextFunc *iternext = NpyIter_GetIterNext(iter, NULL);
     if (iternext == NULL) {
         return NULL;
     }
-    dataptr = NpyIter_GetDataPtrArray(iter);
-    strideptr = NpyIter_GetInnerStrideArray(iter);
-    innersizeptr = NpyIter_GetInnerLoopSizePtr(iter);
+    char **dataptr = NpyIter_GetDataPtrArray(iter);
+    npy_intp *strideptr = NpyIter_GetInnerStrideArray(iter);
+    npy_intp *innersizeptr = NpyIter_GetInnerLoopSizePtr(iter);
 
     // release the GIL
     PyThreadState *_save;
@@ -85,15 +81,16 @@ unique(PyArrayObject *self)
         }
     } while(iternext(iter));
 
-    npy_intp dims[1] = {(npy_intp)hashset.size()};
-    PyArray_Descr *descr = PyArray_DESCR(self);
+    npy_intp length = hashset.size();
+
     NPY_ALLOW_C_API;
+    PyArray_Descr *descr = PyArray_DESCR(self);
     Py_INCREF(descr);
     PyObject *res_obj = PyArray_NewFromDescr(
         &PyArray_Type,
         descr,
         1, // ndim
-        dims, // shape
+        &length, // shape
         NULL, // strides
         NULL, // data
         // This flag is needed to be able to call .sort on it.
@@ -143,46 +140,34 @@ std::unordered_map<int, function_type> unique_funcs = {
 };
 
 
+/**
+ * Python exposed implementation of `_unique_hash`.
+ *
+ * This is a C only function wrapping code that may cause C++ exceptions into
+ * try/catch.
+ *
+ * @param arr NumPy array to find the unique values of.
+ * @return Base-class NumPy array with unique values, `NotImplemented` if the
+ * type is unsupported or `NULL` with an error set.
+ */
 extern "C" NPY_NO_EXPORT PyObject *
-array__unique_hash(PyObject *NPY_UNUSED(dummy), PyObject *args)
+array__unique_hash(PyObject *NPY_UNUSED(module), PyObject *arr_obj)
 {
-    /* This is called from Python space, and expects a single numpy array as input.
-
-    It then returns a numpy array containing the unique values of the input array.
-
-    If the input array is not supported, it returns None.
-    */
-    // this is to allow grabbing the GIL before raising a python exception.
-
-
-    PyArrayObject *self = NULL;
-    PyObject *res = NULL;
-    if (!PyArg_ParseTuple(args, "O&", PyArray_Converter, &self)) {
+    if (!PyArray_Check(arr_obj)) {
+        PyErr_SetString(PyExc_TypeError,
+                "_unique_hash() requires a NumPy array input.");
         return NULL;
     }
-    // Making sure the DECREF is called when the function returns, with
-    // or w/o an exception
-    auto self_decref = finally([&]() { Py_XDECREF(self); });
+    PyArrayObject *arr = (PyArrayObject *)arr_obj;
 
     try {
-        /* Handle zero-sized arrays specially */
-        if (PyArray_SIZE(self) == 0) {
-            return PyArray_NewLikeArray(
-                self,
-                NPY_ANYORDER,
-                NULL, // descr (use prototype's descr)
-                0 // subok (function always returns base-class)
-            );
-        }
-
-        auto type = PyArray_TYPE(self);
+        auto type = PyArray_TYPE(arr);
         // we only support data types present in our unique_funcs map
         if (unique_funcs.find(type) == unique_funcs.end()) {
             Py_RETURN_NOTIMPLEMENTED;
         }
 
-        res = unique_funcs[type](self);
-        return res;
+        return unique_funcs[type](arr);
     }
     catch (const std::bad_alloc &e) {
         PyErr_NoMemory();

diff --git a/numpy/lib/_arraysetops_impl.py b/numpy/lib/_arraysetops_impl.py
@@ -15,7 +15,6 @@
 
 """
 import functools
-from types import NotImplementedType
 import warnings
 from typing import NamedTuple
 
@@ -375,7 +374,7 @@ def _unique1d(ar, return_index=False, return_inverse=False,
         conv = _array_converter(ar)
         ar_, = conv
 
-        if type(hash_unique := _unique_hash(ar_)) != NotImplementedType:
+        if (hash_unique := _unique_hash(ar_)) is not NotImplemented:
             if sorted:
                 hash_unique.sort()
             # We wrap the result back in case it was a subclass of numpy.ndarray.
@@ -492,7 +491,7 @@ def unique_all(x):
         return_index=True,
         return_inverse=True,
         return_counts=True,
-        equal_nan=False
+        equal_nan=False,
     )
     return UniqueAllResult(*result)
 
@@ -544,7 +543,7 @@ def unique_counts(x):
         return_index=False,
         return_inverse=False,
         return_counts=True,
-        equal_nan=False
+        equal_nan=False,
     )
     return UniqueCountsResult(*result)
 
@@ -597,7 +596,7 @@ def unique_inverse(x):
         return_index=False,
         return_inverse=True,
         return_counts=False,
-        equal_nan=False
+        equal_nan=False,
     )
     return UniqueInverseResult(*result)
 
@@ -641,7 +640,8 @@ def unique_values(x):
         return_index=False,
         return_inverse=False,
         return_counts=False,
-        equal_nan=False
+        equal_nan=False,
+        sorted=False,
     )