* Removing struct pairs from algos as it's no longer being

  used
* Since rolling min/max used to implicitly convert the
  return type to float, but now supports returning the
  same type as the original value, added an as_float argument
  to the min/max functions so that users of the API can
  obtain the original return type by passing as_float=False
* Enhanced the unit test for the new as_float parameter
* Changed the private _roll_min_max function to be declared
  as cdef instead of def

Author: joshuastorck

pandas/algos.pyx

@@ -1625,10 +1625,6 @@ def roll_median_c(ndarray[float64_t] arg, int win, int minp):
 # of its Simplified BSD license
 # https://github.com/kwgoodman/bottleneck
 
-cdef struct pairs:
-    double value
-    int death
-
 from libc cimport stdlib
 
 @cython.boundscheck(False)
@@ -1645,7 +1641,7 @@ def roll_min(ndarray[numeric] a, int window, int minp):
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def _roll_min_max(ndarray[numeric] a, int window, int minp, bint is_max):
+cdef _roll_min_max(ndarray[numeric] a, int window, int minp, bint is_max):
     "Moving min/max of 1d array of any numeric type along axis=0 ignoring NaNs."
     cdef numeric ai, aold
     cdef Py_ssize_t count

pandas/core/window.py

@@ -144,15 +144,15 @@ def _shallow_copy(self, obj=None, **kwargs):
                 kwargs[attr] = getattr(self, attr)
         return self._constructor(obj, **kwargs)
 
-    def _prep_values(self, values=None, kill_inf=True, how=None):
+    def _prep_values(self, values=None, kill_inf=True, how=None, as_float=True):
 
         if values is None:
             values = getattr(self._selected_obj, 'values', self._selected_obj)
 
         # coerce dtypes as appropriate
         if com.is_float_dtype(values.dtype):
             pass
-        elif com.is_integer_dtype(values.dtype):
+        elif com.is_integer_dtype(values.dtype) and as_float:
             values = values.astype(float)
         elif com.is_timedelta64_dtype(values.dtype):
             values = values.view('i8').astype(float)
@@ -198,6 +198,7 @@ def _wrap_results(self, results, blocks, obj):
         results : list of ndarrays
         blocks : list of blocks
         obj : conformed data (may be resampled)
+        as_float: bool, cast results to float
         """
 
         final = []
@@ -408,7 +409,7 @@ def _constructor(self):
         return Rolling
 
     def _apply(self, func, window=None, center=None, check_minp=None, how=None,
-               **kwargs):
+               as_float=True, **kwargs):
         """
         Rolling statistical measure using supplied function. Designed to be
         used with passed-in Cython array-based functions.
@@ -421,6 +422,8 @@ def _apply(self, func, window=None, center=None, check_minp=None, how=None,
         check_minp : function, default to _use_window
         how : string, default to None (DEPRECATED)
             how to resample
+        as_float: bool, default to True
+            Cast result to float, otherwise return as original type
 
         Returns
         -------
@@ -438,7 +441,7 @@ def _apply(self, func, window=None, center=None, check_minp=None, how=None,
         results = []
         for b in blocks:
             try:
-                values = self._prep_values(b.values)
+                values = self._prep_values(b.values, as_float=as_float)
             except TypeError:
                 results.append(b.values.copy())
                 continue
@@ -535,25 +538,29 @@ def sum(self, **kwargs):
     Parameters
     ----------
     how : string, default 'max' (DEPRECATED)
-        Method for down- or re-sampling""")
+        Method for down- or re-sampling
+    as_float : bool, default True
+        Cast to float, otherwise return as original type""")
 
-    def max(self, how=None, **kwargs):
+    def max(self, how=None, as_float=True, **kwargs):
         if self.freq is not None and how is None:
             how = 'max'
-        return self._apply('roll_max', how=how, **kwargs)
+        return self._apply('roll_max', how=how, as_float=as_float, **kwargs)
 
     _shared_docs['min'] = dedent("""
     %(name)s minimum
 
     Parameters
     ----------
     how : string, default 'min' (DEPRECATED)
-        Method for down- or re-sampling""")
+        Method for down- or re-sampling
+    as_float : bool, default True
+        Cast to float, otherwise return as original type""")
 
-    def min(self, how=None, **kwargs):
+    def min(self, how=None, as_float=True, **kwargs):
         if self.freq is not None and how is None:
             how = 'min'
-        return self._apply('roll_min', how=how, **kwargs)
+        return self._apply('roll_min', how=how, as_float=as_float, **kwargs)
 
     def mean(self, **kwargs):
         return self._apply('roll_mean', **kwargs)

pandas/tests/test_window.py

@@ -2439,7 +2439,18 @@ def test_rolling_min_max_numeric_types(self):
         types_test.extend([np.dtype("{}{}".format(sign, width))
                            for width in [1, 2, 4, 8] for sign in "ui"])
         for data_type in types_test:
-            # Just testing that these don't throw exceptions. Other tests will
-            # cover quantitative correctness
-            DataFrame(np.arange(20, dtype=data_type)).rolling(window=5).max()
-            DataFrame(np.arange(20, dtype=data_type)).rolling(window=5).min()
+            # Just testing that these don't throw exceptions and that the types match. 
+            # Other tests will cover quantitative correctness
+            for convert_to_float in [True]:
+                if data_type.kind == 'f' or not convert_to_float:
+                    # Floating point values are left as-is when convert_to_float is True.
+                    # We compare to the original floating point type instead
+                    expected_type = data_type
+                else:
+                    expected_type = np.dtype(float)
+                result = DataFrame(np.arange(20, dtype=data_type)).rolling(window=5).max(as_float=convert_to_float)
+                self.assertEqual(result.dtypes[0], expected_type)
+                result = DataFrame(np.arange(20, dtype=data_type)).rolling(window=5).min(as_float=convert_to_float)
+                self.assertEqual(result.dtypes[0], expected_type)
+
+