Modify benches, restore old files

.gitignore

@@ -9,4 +9,4 @@ MANIFEST
 .*.swp
 *~
 \#*#
-bottleneck/src/bn_config.h
+bottleneck/src/bn_config.h

bottleneck/benchmark/bench.py

@@ -198,6 +198,8 @@ def getsetups(setup, shapes, nans, axes, dtype, order):
         run = {}
         run["name"] = func
         run["statements"] = ["bn_func(a, w, 1, axis)", "sw_func(a, w, 1, axis)"]
+        if func == "move_quantile":
+            run["statements"] = ["bn_func(a, w, 1, axis, q=0.25)", "sw_func(a, w, 1, axis, q=0.25)"]   
         setup = """
             from bottleneck.slow.move import %s as sw_func
             from bottleneck import %s as bn_func

bottleneck/benchmark/bench_detailed.py

@@ -79,7 +79,6 @@ def benchsuite(function, fraction_nan):
         # avoid all-nan slice warnings from np.median and np.nanmedian
         if "%s" == "median": from bottleneck.slow import median as sl_fn
         if "%s" == "nanmedian": from bottleneck.slow import nanmedian as sl_fn
-        if "%s" == "move_quantile": from bottleneck.slow import move_median as sl_fn
 
         from numpy import array, nan
         from numpy.random import RandomState
@@ -95,12 +94,14 @@ def benchsuite(function, fraction_nan):
         index = 0
     elif function in ["rankdata", "nanrankdata"]:
         index = 0
-    elif function in bn.get_functions("move", as_string=True):
+    elif function in bn.get_functions("move", as_string=True) and function != "move_quantile":
         index = 1
     elif function in ["partition", "argpartition", "push"]:
         index = 2
     elif function == "replace":
         index = 3
+    elif function == "move_quantile":
+        index = 4
     else:
         raise ValueError("`function` (%s) not recognized" % function)
 
@@ -117,7 +118,7 @@ def benchsuite(function, fraction_nan):
         run = {}
         run["name"] = [f + signature, array]
         run["statements"] = ["bn_fn" + signature, "sl_fn" + signature]
-        run["setup"] = setup % (f, f, f, f, f, f, array, fraction_nan, fraction_nan)
+        run["setup"] = setup % (f, f, f, f, f, array, fraction_nan, fraction_nan)
         run["repeat"] = repeat
         suite.append(run)
 
@@ -134,30 +135,32 @@ def get_instructions():
             "(a, 1)",  # move
             "(a, 0)",  # (arg)partition
             "(a, np.nan, 0)",  # replace
+            "(a, 1, q=0.25)",  # move_quantile
             10,
         ),
-        ("rand(10)", "(a)", "(a, 2)", "(a, 2)", "(a, np.nan, 0)", 10),
-        ("rand(100)", "(a)", "(a, 20)", "(a, 20)", "(a, np.nan, 0)", 6),
-        ("rand(1000)", "(a)", "(a, 200)", "(a, 200)", "(a, np.nan, 0)", 3),
-        ("rand(1000000)", "(a)", "(a, 200)", "(a, 200)", "(a, np.nan, 0)", 2),
+        ("rand(10)", "(a)", "(a, 2)", "(a, 2)", "(a, np.nan, 0)", "(a, 2, q=0.25)", 10),
+        ("rand(100)", "(a)", "(a, 20)", "(a, 20)", "(a, np.nan, 0)", "(a, 20, q=0.25)", 6),
+        ("rand(1000)", "(a)", "(a, 200)", "(a, 200)", "(a, np.nan, 0)", "(a, 200, q=0.25)", 3),
+        ("rand(1000000)", "(a)", "(a, 200)", "(a, 200)", "(a, np.nan, 0)", None, 2),
         # 2d input array
-        ("rand(10, 10)", "(a)", "(a, 2)", "(a, 2)", "(a, np.nan, 0)", 6),
-        ("rand(100, 100)", "(a)", "(a, 20)", "(a, 20)", "(a, np.nan, 0)", 3),
-        ("rand(1000, 1000)", "(a)", "(a, 200)", "(a, 200)", "(a, np.nan, 0)", 2),
-        ("rand(10, 10)", "(a, 1)", None, None, None, 6),
-        ("rand(100, 100)", "(a, 1)", None, None, None, 3),
-        ("rand(1000, 1000)", "(a, 1)", None, None, None, 2),
-        ("rand(100000, 2)", "(a, 1)", "(a, 1)", "(a, 1)", None, 2),
-        ("rand(10, 10)", "(a, 0)", None, None, None, 6),
-        ("rand(100, 100)", "(a, 0)", "(a, 20, axis=0)", None, None, 3),
-        ("rand(1000, 1000)", "(a, 0)", "(a, 200, axis=0)", None, None, 2),
+        ("rand(10, 10)", "(a)", "(a, 2)", "(a, 2)", "(a, np.nan, 0)", "(a, 2, q=0.25)", 6),
+        ("rand(100, 100)", "(a)", "(a, 20)", "(a, 20)", "(a, np.nan, 0)", "(a, 20, q=0.25)", 3),
+        ("rand(1000, 1000)", "(a)", "(a, 200)", "(a, 200)", "(a, np.nan, 0)", None ,2),
+        ("rand(10, 10)", "(a, 1)", None, None, None, None, 6),
+        ("rand(100, 100)", "(a, 1)", None, None, None, None, 3),
+        ("rand(1000, 1000)", "(a, 1)", None, None, None, None, 2),
+        ("rand(100000, 2)", "(a, 1)", "(a, 1)", "(a, 1)", None, None, 2),
+        ("rand(10, 10)", "(a, 0)", None, None, None, None, 6),
+        ("rand(100, 100)", "(a, 0)", "(a, 20, axis=0)", None, None, None, 3),
+        ("rand(1000, 1000)", "(a, 0)", "(a, 200, axis=0)", None, None, None, 2),
         # 3d input array
         (
             "rand(100, 100, 100)",
             "(a, 0)",
             "(a, 20, axis=0)",
             "(a, 20, axis=0)",
             None,
+            "(a, 20, axis=0, q=0.25)",
             2,
         ),
         (
@@ -166,6 +169,7 @@ def get_instructions():
             "(a, 20, axis=1)",
             "(a, 20, axis=1)",
             None,
+            "(a, 20, axis=1, q=0.25)",
             2,
         ),
         (
@@ -174,10 +178,11 @@ def get_instructions():
             "(a, 20, axis=2)",
             "(a, 20, axis=2)",
             "(a, np.nan, 0)",
+            "(a, 20, axis=2, q=0.25)",
             2,
         ),
         # 0d input array
-        ("array(1.0)", "(a)", None, None, "(a, 0, 2)", 10),
+        ("array(1.0)", "(a)", None, None, "(a, 0, 2)", None, 10),
     ]
 
     return instructions

bottleneck/slow/move.py

@@ -107,36 +107,38 @@ def move_median(a, window, min_count=None, axis=-1, **kwargs):
     "Slow move_median for unaccelerated dtype"
     return move_func(np.nanmedian, a, window, min_count, axis=axis)
 
-def move_quantile(a, window, min_count=None, axis=-1, q=0.5):
-    "Slow move_quantile for unaccelerated dtype"
-    return move_func(np_nanquantile_infs, a, window, min_count, axis=axis, q=q)
-
-def move_rank(a, window, min_count=None, axis=-1):
-    "Slow move_rank for unaccelerated dtype"
-    return move_func(lastrank, a, window, min_count, axis=axis)
 
-# function for handling infs in np.nanquantile
 # keyword argument for interpolation method in np.nanquantile was changed in 1.22.0
 from packaging import version
 if version.parse(np.__version__) > version.parse("1.22.0"):
     METHOD_KEYWORD = "method"
 else:
     METHOD_KEYWORD = "interpolation"
 
-def np_nanquantile_infs(a, **kwargs):                
+def move_quantile(a, window, min_count=None, axis=-1, q=0.5, **kwargs):
+    "Slow move_quantile for unaccelerated dtype"
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
         if not np.isinf(a).any():
             kwargs[METHOD_KEYWORD] = 'midpoint'
-            return np.nanquantile(a, **kwargs)
+            return move_func(np.nanquantile, a, window, min_count, axis=axis, q=q, **kwargs)
         else:
-            kwargs[METHOD_KEYWORD] = 'lower'
-            lower_nanquantile = np.nanquantile(a, **kwargs)
-            kwargs[METHOD_KEYWORD] = 'higher'
-            higher_nanquantile = np.nanquantile(a, **kwargs)
-
-            midpoint_nanquantile = (lower_nanquantile + higher_nanquantile) / 2
-            return midpoint_nanquantile
+            return move_func(np_nanquantile_infs, a, window, min_count, axis=axis, q=q, **kwargs)
+
+def move_rank(a, window, min_count=None, axis=-1):
+    "Slow move_rank for unaccelerated dtype"
+    return move_func(lastrank, a, window, min_count, axis=axis)
+
+
+# function for handling infs in np.nanquantile    
+def np_nanquantile_infs(a, **kwargs):                
+    kwargs[METHOD_KEYWORD] = 'lower'
+    lower_nanquantile = np.nanquantile(a, **kwargs)
+    kwargs[METHOD_KEYWORD] = 'higher'
+    higher_nanquantile = np.nanquantile(a, **kwargs)
+
+    midpoint_nanquantile = (lower_nanquantile + higher_nanquantile) / 2
+    return midpoint_nanquantile
 
 # magic utility functions ---------------------------------------------------
 

bottleneck/src/move_median/move_median_debug.c

@@ -1,6 +1,6 @@
 #include "move_median.h"
 
-ai_t *mm_move_median(ai_t *a, idx_t length, idx_t window, idx_t min_count, double quantile);
+ai_t *mm_move_median(ai_t *a, idx_t length, idx_t window, idx_t min_count);
 int mm_assert_equal(ai_t *actual, ai_t *desired, ai_t *input, idx_t length,
                     char *err_msg);
 int mm_unit_test(void);
@@ -19,7 +19,7 @@ int main(void) {
 
 
 /* moving window median of 1d arrays returns output array */
-ai_t *mm_move_median(ai_t *a, idx_t length, idx_t window, idx_t min_count, double quantile) {
+ai_t *mm_move_median(ai_t *a, idx_t length, idx_t window, idx_t min_count) {
     mm_handle *mm;
     ai_t *out;
     idx_t i;
@@ -84,14 +84,13 @@ int mm_unit_test(void) {
     int length;
     char *err_msg;
     int failed;
-    double quantile = 0.5;
 
     length = sizeof(arr_input) / sizeof(*arr_input);
     err_msg = malloc(1024 * sizeof *err_msg);
     sprintf(err_msg, "move_median failed with window=%d, min_count=%d",
             window, min_count);
 
-    actual = mm_move_median(arr_input, length, window, min_count, quantile);
+    actual = mm_move_median(arr_input, length, window, min_count);
     failed = mm_assert_equal(actual, desired, arr_input, length, err_msg);
 
     free(actual);