implement interp() (#2104)

* Start working

* interp1d for numpy backed array.

* interp1d for dask backed array.

* Support scalar interpolation.

* more docs

* flake8. Remove an unnecessary file.

* Remove non-unicode characters

* refactoring...

* flake8. whats new

* Make tests skip if scipy is not installed

* skipif -> skip

* move skip into every function

* remove reuires_scipy

* refactoring exceptions.

* assert_equal -> assert_allclose

* Remove unintended word.

* More tests. More docs.

* More docs.

* Added a benchmark

* doc. Remove *.png file.

* add .load to benchmark with dask.

* add assume_sorted kwarg.

* Support dimension without coordinate

* flake8

* More docs. test for attrs.

* Updates based on comments

* rename test

* update docs

* Add transpose for python 2

* More strict ordering

* Cleanup

* Update doc

* Add skipif in tests

* minor grammar/language edits in docs

* Support dict arguments for interp.

* update based on comments

* Remove unused if-block

* ValueError -> NotImpletedError. Doc improvement

* Using OrderedSet

* Drop object array after interpolation.

* flake8

* Add keep_attrs keyword

* flake8 (reverted from commit 6e00999)

* flake8

* Remove keep_attrs keywords

* Returns copy for not-interpolated variable.

* Fix docs

Author: fujiisoup

asv_bench/benchmarks/interp.py

@@ -0,0 +1,54 @@
+from __future__ import absolute_import, division, print_function
+
+import numpy as np
+import pandas as pd
+
+import xarray as xr
+
+from . import parameterized, randn, requires_dask
+
+nx = 3000
+long_nx = 30000000
+ny = 2000
+nt = 1000
+window = 20
+
+randn_xy = randn((nx, ny), frac_nan=0.1)
+randn_xt = randn((nx, nt))
+randn_t = randn((nt, ))
+randn_long = randn((long_nx, ), frac_nan=0.1)
+
+
+new_x_short = np.linspace(0.3 * nx, 0.7 * nx, 100)
+new_x_long = np.linspace(0.3 * nx, 0.7 * nx, 1000)
+new_y_long = np.linspace(0.1, 0.9, 1000)
+
+
+class Interpolation(object):
+    def setup(self, *args, **kwargs):
+        self.ds = xr.Dataset(
+            {'var1': (('x', 'y'), randn_xy),
+             'var2': (('x', 't'), randn_xt),
+             'var3': (('t', ), randn_t)},
+            coords={'x': np.arange(nx),
+                    'y': np.linspace(0, 1, ny),
+                    't': pd.date_range('1970-01-01', periods=nt, freq='D'),
+                    'x_coords': ('x', np.linspace(1.1, 2.1, nx))})
+
+    @parameterized(['method', 'is_short'],
+                   (['linear', 'cubic'], [True, False]))
+    def time_interpolation(self, method, is_short):
+        new_x = new_x_short if is_short else new_x_long
+        self.ds.interp(x=new_x, method=method).load()
+
+    @parameterized(['method'],
+                   (['linear', 'nearest']))
+    def time_interpolation_2d(self, method):
+        self.ds.interp(x=new_x_long, y=new_y_long, method=method).load()
+
+
+class InterpolationDask(Interpolation):
+    def setup(self, *args, **kwargs):
+        requires_dask()
+        super(InterpolationDask, self).setup(**kwargs)
+        self.ds = self.ds.chunk({'t': 50})