backward compat and add benchmarks

Author: Joe Hamman

.travis.yml

@@ -89,9 +89,9 @@ install:
   - python xarray/util/print_versions.py
 
 script:
+  - git diff upstream/master **/*py | flake8 --diff --exit-zero || true
   - python -OO -c "import xarray"
   - py.test xarray --cov=xarray --cov-config ci/.coveragerc --cov-report term-missing --verbose $EXTRA_FLAGS
-  - git diff upstream/master **/*py | flake8 --diff --exit-zero || true
 
 after_success:
   - coveralls

asv_bench/benchmarks/dataarray_missing.py

@@ -0,0 +1,74 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import pandas as pd
+
+try:
+    import dask
+    import dask.multiprocessing
+except ImportError:
+    pass
+
+import xarray as xr
+
+from . import randn, requires_dask
+
+
+def make_bench_data(shape, frac_nan, chunks):
+    vals = randn(shape, frac_nan)
+    coords = {'time': pd.date_range('2000-01-01', freq='D',
+              periods=shape[0])}
+    da = xr.DataArray(vals, dims=('time', 'x', 'y'), coords=coords)
+
+    if chunks is not None:
+        da = da.chunk(chunks)
+
+    return da
+
+
+def time_interpolate_na(shape, chunks, method, limit):
+    if chunks is not None:
+        requires_dask()
+    da = make_bench_data(shape, 0.1, chunks=chunks)
+    actual = da.interpolate_na(dim='time', method='linear', limit=limit)
+
+    if chunks is not None:
+        actual = actual.compute()
+
+
+time_interpolate_na.param_names = ['shape', 'chunks', 'method', 'limit']
+time_interpolate_na.params = ([(3650, 200, 400), (100, 25, 25)],
+                              [None, {'x': 25, 'y': 25}],
+                              ['linear', 'spline', 'quadratic', 'cubic'],
+                              [None, 3])
+
+
+def time_ffill(shape, chunks, limit):
+
+    da = make_bench_data(shape, 0.1, chunks=chunks)
+    actual = da.ffill(dim='time', limit=limit)
+
+    if chunks is not None:
+        actual = actual.compute()
+
+
+time_ffill.param_names = ['shape', 'chunks', 'limit']
+time_ffill.params = ([(3650, 200, 400), (100, 25, 25)],
+                     [None, {'x': 25, 'y': 25}],
+                     [None, 3])
+
+
+def time_bfill(shape, chunks, limit):
+
+    da = make_bench_data(shape, 0.1, chunks=chunks)
+    actual = da.bfill(dim='time', limit=limit)
+
+    if chunks is not None:
+        actual = actual.compute()
+
+
+time_bfill.param_names = ['shape', 'chunks', 'limit']
+time_bfill.params = ([(3650, 200, 400), (100, 25, 25)],
+                     [None, {'x': 25, 'y': 25}],
+                     [None, 3])

xarray/core/npcompat.py

@@ -4,7 +4,7 @@
 import numpy as np
 
 try:
-    from numpy import nancumsum, nancumprod
+    from numpy import nancumsum, nancumprod, flip
 except ImportError:  # pragma: no cover
     # Code copied from newer versions of NumPy (v1.12).
     # Used under the terms of NumPy's license, see licenses/NUMPY_LICENSE.
@@ -174,3 +174,74 @@ def nancumprod(a, axis=None, dtype=None, out=None):
         """
         a, mask = _replace_nan(a, 1)
         return np.cumprod(a, axis=axis, dtype=dtype, out=out)
+
+    def flip(m, axis):
+        """
+        Reverse the order of elements in an array along the given axis.
+
+        The shape of the array is preserved, but the elements are reordered.
+
+        .. versionadded:: 1.12.0
+
+        Parameters
+        ----------
+        m : array_like
+            Input array.
+        axis : integer
+            Axis in array, which entries are reversed.
+
+
+        Returns
+        -------
+        out : array_like
+            A view of `m` with the entries of axis reversed.  Since a view is
+            returned, this operation is done in constant time.
+
+        See Also
+        --------
+        flipud : Flip an array vertically (axis=0).
+        fliplr : Flip an array horizontally (axis=1).
+
+        Notes
+        -----
+        flip(m, 0) is equivalent to flipud(m).
+        flip(m, 1) is equivalent to fliplr(m).
+        flip(m, n) corresponds to ``m[...,::-1,...]`` with ``::-1`` at position n.
+
+        Examples
+        --------
+        >>> A = np.arange(8).reshape((2,2,2))
+        >>> A
+        array([[[0, 1],
+                [2, 3]],
+
+               [[4, 5],
+                [6, 7]]])
+
+        >>> flip(A, 0)
+        array([[[4, 5],
+                [6, 7]],
+
+               [[0, 1],
+                [2, 3]]])
+
+        >>> flip(A, 1)
+        array([[[2, 3],
+                [0, 1]],
+
+               [[6, 7],
+                [4, 5]]])
+
+        >>> A = np.random.randn(3,4,5)
+        >>> np.all(flip(A,2) == A[:,:,::-1,...])
+        True
+        """
+        if not hasattr(m, 'ndim'):
+            m = np.asarray(m)
+        indexer = [slice(None)] * m.ndim
+        try:
+            indexer[axis] = slice(None, None, -1)
+        except IndexError:
+            raise ValueError("axis=%i is invalid for the %i-dimensional "
+                             "input array" % (axis, m.ndim))
+        return m[tuple(indexer)]