Merge pull request #118 from static-frame/116/ascending-slice

Author: flexatone

performance/__main__.py

@@ -27,6 +27,7 @@
 from performance.reference.util import get_new_indexers_and_screen_ref
 from performance.reference.util import split_after_count as split_after_count_ref
 from performance.reference.util import count_iteration as count_iteration_ref
+from performance.reference.util import slice_to_ascending_slice as slice_to_ascending_slice_ref
 
 from performance.reference.array_go import ArrayGO as ArrayGOREF
 
@@ -45,6 +46,7 @@
 from arraykit import isna_element as isna_element_ak
 from arraykit import split_after_count as split_after_count_ak
 from arraykit import count_iteration as count_iteration_ak
+from arraykit import slice_to_ascending_slice as slice_to_ascending_slice_ak
 
 from arraykit import ArrayGO as ArrayGOAK
 
@@ -735,6 +737,22 @@ class CountIterationsREF(CountIterations):
     entry = staticmethod(count_iteration_ref)
 
 
+#-------------------------------------------------------------------------------
+class SliceToAscending(Perf):
+    NUMBER = 1_000_000
+
+    def __init__(self):
+        self.slc = slice(100, 1, -3)
+
+    def main(self):
+        _ = self.entry(self.slc, 101)
+
+class SliceToAscendingAK(SliceToAscending):
+    entry = staticmethod(slice_to_ascending_slice_ak)
+
+class SliceToAscendingREF(SliceToAscending):
+    entry = staticmethod(slice_to_ascending_slice_ref)
+
 #-------------------------------------------------------------------------------
 
 def get_arg_parser():

performance/reference/util.py

@@ -25,6 +25,8 @@
 DTYPES_BOOL = (DTYPE_BOOL,)
 DTYPES_INEXACT = (DTYPE_FLOAT_DEFAULT, DTYPE_COMPLEX_DEFAULT)
 
+EMPTY_SLICE = slice(0, 0) # gathers nothing
+
 
 def mloc(array: np.ndarray) -> int:
     '''Return the memory location of an array.
@@ -261,5 +263,44 @@ def count_iteration(iterable: tp.Iterable):
     return count
 
 
+def slice_to_ascending_slice(
+        key: slice,
+        size: int
+        ) -> slice:
+    '''
+    Given a slice, return a slice that, with ascending integers, covers the same values.
+
+    Args:
+        size: the length of the container on this axis
+    '''
+    key_step = key.step
+    key_start = key.start
+    key_stop = key.stop
+
+    if key_step is None or key_step > 0:
+        return key
+
+    # will get rid of all negative values greater than the size; but will replace None with an appropriate number for usage in range
+    norm_key_start, norm_key_stop, norm_key_step = key.indices(size)
+
+    # everything else should be descending, but we might have non-descending start, stop
+    if key_start is not None and key_stop is not None:
+        if norm_key_start <= norm_key_stop: # an ascending range
+            return EMPTY_SLICE
+
+    norm_range = range(norm_key_start, norm_key_stop, norm_key_step)
+
+    # derive stop
+    if key_start is None:
+        stop = None
+    else:
+        stop = norm_range[0] + 1
+
+    if key_step == -1:
+        # gets last realized value, not last range value
+        return slice(None if key_stop is None else norm_range[-1], stop, 1)
+
+    return slice(norm_range[-1], stop, key_step * -1)
+
 
 

src/__init__.py

@@ -26,3 +26,4 @@
 from ._arraykit import count_iteration as count_iteration
 from ._arraykit import first_true_1d as first_true_1d
 from ._arraykit import first_true_2d as first_true_2d
+from ._arraykit import slice_to_ascending_slice as slice_to_ascending_slice

src/__init__.pyi

@@ -102,3 +102,4 @@ def get_new_indexers_and_screen(indexers: np.ndarray, positions: np.ndarray) ->
 
 def first_true_1d(__array: np.ndarray, *, forward: bool) -> int: ...
 def first_true_2d(__array: np.ndarray, *, forward: bool, axis: int) -> np.ndarray: ...
+def slice_to_ascending_slice(__slice: slice, __size: int) -> slice: ...

src/_arraykit.c

@@ -16,10 +16,11 @@
 
 //------------------------------------------------------------------------------
 // Given a PyObject, raise if not an array.
-# define AK_CHECK_NUMPY_ARRAY(O)                                              \
-    if (!PyArray_Check(O)) {                                                  \
-        return PyErr_Format(PyExc_TypeError, "Expected NumPy array (got %s)", \
-                            Py_TYPE(O)->tp_name);                             \
+# define AK_CHECK_NUMPY_ARRAY(O)                 \
+    if (!PyArray_Check(O)) {                     \
+        return PyErr_Format(PyExc_TypeError,     \
+                "Expected NumPy array, not %s.", \
+                Py_TYPE(O)->tp_name);            \
     }
 
 // Given a PyObject, raise if not an array or is not one or two dimensional.
@@ -29,7 +30,7 @@
         int ndim = PyArray_NDIM((PyArrayObject *)O);      \
         if (ndim != 1 && ndim != 2) {                     \
             return PyErr_Format(PyExc_NotImplementedError,\
-                    "expected 1D or 2D array (got %i)",   \
+                    "Expected 1D or 2D array, not %i.",   \
                     ndim);                                \
         }                                                 \
     } while (0)
@@ -3322,6 +3323,53 @@ row_1d_filter(PyObject *Py_UNUSED(m), PyObject *a)
     return a;
 }
 
+
+// Convert any slice to an ascending slice that covers the same values.
+static PyObject *
+slice_to_ascending_slice(PyObject *Py_UNUSED(m), PyObject *args) {
+
+    PyObject* slice;
+    PyObject* size;
+    if (!PyArg_ParseTuple(args,
+            "O!O!:slice_to_ascending_slice",
+            &PySlice_Type, &slice,
+            &PyLong_Type, &size)) {
+        return NULL;
+    }
+
+    Py_ssize_t step_count = -1;
+    Py_ssize_t start = 0;
+    Py_ssize_t stop = 0;
+    Py_ssize_t step = 0;
+
+    if (PySlice_Unpack(slice, &start, &stop, &step)) {
+        return NULL;
+    }
+    if (step > 0) {
+        Py_INCREF(slice);
+        return slice;
+    }
+    step_count = PySlice_AdjustIndices(
+            PyLong_AsSsize_t(size),
+            &start,
+            &stop,
+            step);
+
+    PyObject* asc_stop = PyLong_FromSsize_t(start + 1);
+    // step will be negative; shift original start value down to find new start
+    PyObject* asc_start = PyLong_FromSsize_t(start + (step * (step_count - 1)));
+    PyObject* asc_step = PyLong_FromSsize_t(-step);
+
+    // might be NULL, let return
+    PyObject* asc = PySlice_New(asc_start, asc_stop, asc_step);
+
+    Py_DECREF(asc_start);
+    Py_DECREF(asc_stop);
+    Py_DECREF(asc_step);
+
+    return asc;
+}
+
 //------------------------------------------------------------------------------
 // array utility
 
@@ -5348,6 +5396,7 @@ static PyMethodDef arraykit_methods[] =  {
     {"column_2d_filter", column_2d_filter, METH_O, NULL},
     {"column_1d_filter", column_1d_filter, METH_O, NULL},
     {"row_1d_filter", row_1d_filter, METH_O, NULL},
+    {"slice_to_ascending_slice", slice_to_ascending_slice, METH_VARARGS, NULL},
     {"array_deepcopy",
             (PyCFunction)array_deepcopy,
             METH_VARARGS | METH_KEYWORDS,

test/test_util.py

@@ -18,15 +18,16 @@
 from arraykit import array_deepcopy
 from arraykit import isna_element
 from arraykit import dtype_from_element
-from arraykit import split_after_count
 from arraykit import count_iteration
 from arraykit import first_true_1d
 from arraykit import first_true_2d
+from arraykit import slice_to_ascending_slice
 
 from performance.reference.util import get_new_indexers_and_screen_ak as get_new_indexers_and_screen_full
 from arraykit import get_new_indexers_and_screen
 
 from performance.reference.util import mloc as mloc_ref
+from performance.reference.util import slice_to_ascending_slice as slice_to_ascending_slice_ref
 
 
 class TestUnit(unittest.TestCase):
@@ -703,8 +704,45 @@ def test_first_true_2d_h(self) -> None:
                 [1, 0, 2, 1])
 
 
+    #---------------------------------------------------------------------------
+    def test_slice_to_ascending_slice_a(self) -> None:
+        self.assertEqual(slice_to_ascending_slice(
+                slice(5, 2, -1), 6),
+                slice(3, 6, 1),
+                )
+
+    def test_slice_to_ascending_slice_b(self) -> None:
+        self.assertEqual(slice_to_ascending_slice(
+                slice(2, 5, 1), 6),
+                slice(2, 5, 1),
+                )
+
+    def test_slice_to_ascending_slice_c(self) -> None:
+        with self.assertRaises(TypeError):
+            _ = slice_to_ascending_slice('a', 6)
 
+        with self.assertRaises(TypeError):
+            _ = slice_to_ascending_slice(slice(1, 4), 'x')
 
+    def test_slice_to_ascending_slice_d(self) -> None:
+        self.assertEqual(slice_to_ascending_slice(
+                slice(10, 2, -2), 12),
+                slice(4, 11, 2),
+                )
+
+    def test_slice_to_ascending_slice_e(self) -> None:
+        for slc, size in (
+                (slice(10, 2, -2), 12),
+                (slice(12, 2, -3), 12),
+                (slice(12, None, -4), 12),
+                (slice(76, 12, -8), 100),
+                (slice(81, 33, -12), 100),
+                (slice(97, 6, -7), 101),
+                ):
+            self.assertEqual(
+                slice_to_ascending_slice(slc, size),
+                slice_to_ascending_slice_ref(slc, size),
+                )
 
 
 if __name__ == '__main__':