Add move_quantile function

asv_bench/benchmarks/move.py

@@ -40,6 +40,9 @@ def time_move_argmax(self, dtype, shape, window):
     def time_move_median(self, dtype, shape, window):
         bn.move_median(self.arr, window)
 
+    def time_move_quantile(self, dtype, shape, window):
+        bn.move_quantile(self.arr, window, q=0.25)
+
     def time_move_rank(self, dtype, shape, window):
         bn.move_rank(self.arr, window)
 
@@ -83,6 +86,9 @@ def time_move_argmax(self, dtype, shape, order, axis, window):
 
     def time_move_median(self, dtype, shape, order, axis, window):
         bn.move_median(self.arr, window, axis=axis)
+
+    def time_move_quantile(self, dtype, shape, order, axis, window):
+        bn.move_quantile(self.arr, window, axis=axis, q=0.25)
 
     def time_move_rank(self, dtype, shape, order, axis, window):
         bn.move_rank(self.arr, window, axis=axis)

bottleneck/__init__.py

@@ -5,7 +5,10 @@
 from . import slow
 from ._pytesttester import PytestTester
 from .move import (move_argmax, move_argmin, move_max, move_mean, move_median,
-                   move_min, move_rank, move_std, move_sum, move_var)
+                    move_min, move_rank, move_std, move_sum, move_var)
+
+from .src.move_quantile import move_quantile
+
 from .nonreduce import replace
 from .nonreduce_axis import (argpartition, nanrankdata, partition, push,
                              rankdata)

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

@@ -94,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)
 
@@ -133,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,
         ),
         (
@@ -165,6 +169,7 @@ def get_instructions():
             "(a, 20, axis=1)",
             "(a, 20, axis=1)",
             None,
+            "(a, 20, axis=1, q=0.25)",
             2,
         ),
         (
@@ -173,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

@@ -14,6 +14,7 @@
     "move_argmin",
     "move_argmax",
     "move_median",
+    "move_quantile",
     "move_rank",
 ]
 
@@ -37,13 +38,15 @@ def move_var(a, window, min_count=None, axis=-1, ddof=0):
     "Slow move_var for unaccelerated dtype"
     return move_func(np.nanvar, a, window, min_count, axis=axis, ddof=ddof)
 
-
-def move_min(a, window, min_count=None, axis=-1):
+# move_min, move_max, and move_median from bn.slow can be called
+# from bn.move_quantile in case of byte swapped input array,
+# and so can take `q` argument, hence add **kwargs to these functions
+def move_min(a, window, min_count=None, axis=-1, **kwargs):
     "Slow move_min for unaccelerated dtype"
     return move_func(np.nanmin, a, window, min_count, axis=axis)
 
 
-def move_max(a, window, min_count=None, axis=-1):
+def move_max(a, window, min_count=None, axis=-1, **kwargs):
     "Slow move_max for unaccelerated dtype"
     return move_func(np.nanmax, a, window, min_count, axis=axis)
 
@@ -100,16 +103,43 @@ def argmax(a, axis):
     return move_func(argmax, a, window, min_count, axis=axis)
 
 
-def move_median(a, window, min_count=None, axis=-1):
+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)
 
 
+# keyword argument for interpolation method in np.nanquantile was changed in 1.22.0
+import pkg_resources
+if pkg_resources.parse_version(np.__version__) >= pkg_resources.parse_version("1.22.0"):
+    METHOD_KEYWORD = "method"
+else:
+    METHOD_KEYWORD = "interpolation"
+
+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 move_func(np.nanquantile, a, window, min_count, axis=axis, q=q, **kwargs)
+        else:
+            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 ---------------------------------------------------