WIP: Feature/interpolate by jhamman · Pull Request #1640 · pydata/xarray

jhamman · 2017-10-20T00:26:25Z

Closes Resample / upsample behavior diverges from pandas #1631
Tests added / passed
Passes git diff upstream/master | flake8 --diff
Fully documented, including whats-new.rst for all changes and api.rst for new API

Rough draft of interpolate method for filling of arbitrary nans.

fujiisoup · 2017-10-20T01:16:31Z

+        raise ValueError("Index must be monotonicly increasing")
+
+    # TODO: consider using the np_interp_wrapper for linear method
+    out = np.apply_along_axis(scipy_interp_wrapper, axis, arr, index,


I think scipy.interpolate.interp1d can interpolate a multiple dimensional array along one axis, though scipy is an optional requirement.
(But I did not check it is certainly faster.)

I think scipy.interpolate.interp1d can interpolate a multiple dimensional array along one axis, though scipy is an optional requirement.
(But I did not check it is certainly faster.)

EDIT:
I noticed that I did not understand correctly.
The multi-dimensional interpolation does not work for filling the missing values which are distributed randomly.

So ignore my comment.

yes, exactly. For 1 and 2d arrays, this should behave identically to the pandas interpolate method.

Maybe apply_ufunc with vectorize=True would work here? I guess it would reorder dimensions in a non-desired way.

That is on my list of things to try today. Getting things to behave like pandas required a bit of dancing and I've saved the obvious optimizations for later. Specifically, I want to get some more tests written first.

shoyer · 2017-10-20T06:36:51Z

+        raise ValueError("Index must be monotonicly increasing")
+
+    # TODO: consider using the np_interp_wrapper for linear method
+    out = np.apply_along_axis(scipy_interp_wrapper, axis, arr, index,


Maybe apply_ufunc with vectorize=True would work here? I guess it would reorder dimensions in a non-desired way.

shoyer · 2017-10-20T06:38:11Z

@@ -0,0 +1,95 @@
+"""Define core operations for xarray objects.
+
+TODO(shoyer): rewrite this module, making use of xarray.core.computation,


This TODO note doesn't belong here :)

shoyer · 2017-10-20T06:41:02Z

        out = ops.fillna(self, value)
        return out

+    def interpolate(self, dim=None, method='linear', inplace=False):


I like calling the interpolate_na rather than interpolate to make it clear what this method does. See here for the related pandas discussion: pandas-dev/pandas#9340

jhamman · 2017-11-04T18:48:57Z

+                       output_core_dims=[[dim]],
+                       dask='forbidden',
+                       vectorize=True,
+                       keep_attrs=True).transpose(*arr.dims)


@shoyer - can you take a look at this? About half of my tests are passing but I suspect I'm still missing something in the apply_ufunc call.

I'm getting a few errors that look like this:

ValueError: inconsistent size for core dimension 'dim0': 1 vs 6

I think the problem here is that you are treating your interpolator as an argument to vectorize over. This might technically work (by interpreting interpolator as a scalar), but was certainly was not intended.

Possibly we should have a more informative error message here.

There are various ways you can fix this (using either a class or function returned by a function), but either way probably want the way you use apply_ufunc to be something more like apply_ufunc(wrap_interpolator(interpolator), index, arr, ...).

dcherian · 2017-11-04T20:10:47Z

@jhamman Would it be possible to have a limit option like pandas?

Quoting http://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.interpolate.html

limit : int, default None.

    Maximum number of consecutive NaNs to fill. Must be greater than 0.

I suspect that a lot of the time, users want to fill in "small" gaps but not "large" ones. It is what I usually do.

jhamman · 2017-11-04T20:15:41Z

@dcherian - Yes, we can do that. Just haven't gotten there yet.

shoyer · 2017-11-05T19:28:05Z

+            self._right = yi[-1]
+        elif isinstance(fill_value, Iterable):
+            self._left = fill_value[0]
+            self._right = fill_value[1]


If this only works for a pair of values, let's restrict this to isintance(fill_value, tuple) and explicitly check that it has length 2.

shoyer · 2017-11-05T19:29:36Z

+
+        if fill_value is None:
+            self._left = np.nan
+            self._right = yi[-1]


This is a little surprising to me -- I would expect both to default to NaN.

Agreed. I'm not sure if this is a Pandas bug or an intention feature.

Would it make sense to have them both default to NaN in Xarray?

+1 let's use NaN here.

shoyer · 2017-11-05T19:30:45Z

+def get_clean_interp_args(arr, method, dim, **kwargs):
+    '''normalize interolation arguments and choose which index to use
+
+    provides compatability with pandas interolation methods


interolation -> interpolation

shoyer · 2017-11-05T19:31:13Z

+    elif method == 'time':
+        index = arr.get_index(dim)
+        method = 'linear'
+        assert isinstance(index, pd.DatetimeIndex)


Should probably raise ValueError instead

shoyer · 2017-11-05T19:46:44Z

+            specify and order (int) e.g. da.interpolate_na(method='polynomial', order=4)
+
+        # TODO: Pandas also support: scipy wrappers of 'krogh',
+        #       'piecewise_polynomial', 'spline', and 'pchip'


Personally, I find this interface from pandas a little confusing. It combines two separate choices in one argument:

Choosing the points at which interpolation is done.

How to interpolate between these points.

I would slightly rather that we had two separate arguments. Maybe:

points='coordinate' vs points='equal_spacing' or a boolean use_coordinate=True/use_coordinate=False

method='nearest', method='linear', method='quadratic', etc, for indicating how to interpolate.

The downside is that this would be inconsistent with pandas. But in the existing interface, it is not at all obvious to me whether a method like 'polynomial' uses coordinate points or equally spaced points.

I totally agree. As I've been working on this I've been thinking we can improve on the Pandas interface and this would be the obvious way to do that.

shoyer · 2017-11-05T19:48:40Z

+            elif method == 'spline':
+                return SplineInterpolator
+        except ImportError:
+            pass


It would probably be more useful to raise an error about how scipy is needed for the given interpolator rather than a generic error message.

shoyer · 2017-11-05T19:56:46Z

+                       output_core_dims=[[dim]],
+                       dask='forbidden',
+                       vectorize=True,
+                       keep_attrs=True).transpose(*arr.dims)


I think the problem here is that you are treating your interpolator as an argument to vectorize over. This might technically work (by interpreting interpolator as a scalar), but was certainly was not intended.

Possibly we should have a more informative error message here.

There are various ways you can fix this (using either a class or function returned by a function), but either way probably want the way you use apply_ufunc to be something more like apply_ufunc(wrap_interpolator(interpolator), index, arr, ...).

shoyer · 2017-11-05T19:57:23Z

+                       input_core_dims=[[], [dim], [dim]],
+                       output_core_dims=[[dim]],
+                       dask='forbidden',
+                       vectorize=True,


Note that the scipy.interpolate.interp1d is already vectorized in the right way:
https://docs.scipy.org/doc/scipy-0.19.1/reference/generated/scipy.interpolate.interp1d.html

I think we can only use interp1d on 1D slices. The key point here is that we should be able to interpolate at different index positions for different slices. I don't think interp1d will let us do that.

Ah, good point. That would be useful for the interpolate_at variant.

shoyer · 2017-11-08T01:51:48Z

+                       input_core_dims=[[], [dim], [dim]],
+                       output_core_dims=[[dim]],
+                       dask='forbidden',
+                       vectorize=True,


Ah, good point. That would be useful for the interpolate_at variant.

shoyer · 2017-11-08T01:52:11Z

+                       interpolator, index, arr, kwargs=kwargs,
+                       input_core_dims=[[], [dim], [dim]],
+                       output_core_dims=[[dim]],
+                       dask='forbidden',


I think dask='parallelized' would work here -- I tested it with vectorize=True.

first working version of interpolate method/module pep8 after merge master update interpolate, more pandas compat tests add interpolate_na to api encoding fix for py2 in dataarray.py working... checkin, roughed in interpolator classes move tests and some mods to apply_ufunc usage in interp_na add method to kwargs fixes for scipy and some docs cleanup scipy vs numpy interpolator selection cleanups add limit to interpolate_na bfill/ffill parallelized new interface with use_coordinate kwarg use partial function to wrap interpolate class a few fixes for ffill/bfill, placeholder for interpolate_at method add some tests fix test

jhamman · 2017-11-11T08:23:08Z

+                      output_sizes=dict(zip(arr.dims, arr.shape)),
+                      dask='parallelized',
+                      vectorize=True,
+                      keep_attrs=True).transpose(*arr.dims)


@shoyer - I finally got the apply_ufunc to work. Turns out I just had a bug in wrap_interpolator Nonetheless, I am now using a partial function to simplify this call.

jhamman · 2017-11-11T08:24:11Z

+        raise NotImplementedError('dim is a required argument')
+
+    if limit is not None:
+        valids = _get_valid_fill_mask(arr, dim, limit)


@dcherian - the limit option is now supported.

Awesome. Thanks!

shoyer · 2017-11-12T06:05:47Z

+            order given both 'polynomial' and 'spline' require that you also
+            specify and order (int) e.g. da.interpolate_na(method='polynomial',
+            order=4)
+        use_coordinate : boolean, default True


needs a description.

shoyer · 2017-11-12T06:07:13Z

+            Specifies the dimension along which to interpolate.
+        method : {'linear', 'time', 'index', 'values', 'nearest'}
+            'linear': ignore the index and treat the values as equally
+                      spaced. default


This is a minor point, but can we format this a little more consistently?

The compat arg on the Dataset constructor gets formatted nicely into a list by Sphinx and is still pretty readable as plain text:

xarray/xarray/core/dataset.py

Lines 342 to 350 in 0818a36

compat : {'broadcast_equals', 'equals', 'identical'}, optional

String indicating how to compare variables of the same name for

potential conflicts when initializing this dataset:

- 'broadcast_equals': all values must be equal when variables are

broadcast against each other to ensure common dimensions.

- 'equals': all values and dimensions must be the same.

- 'identical': all values, dimensions and attributes must be the

same.

shoyer · 2017-11-12T06:07:34Z

+            specify and order (int) e.g. da.interpolate_na(method='polynomial',
+            order=4)
+        use_coordinate : boolean, default True
+        limit : limit : int, default None


limit : is repeated twice

shoyer · 2017-11-12T06:07:55Z

+            order=4)
+        use_coordinate : boolean, default True
+        limit : limit : int, default None
+            Maximum number of consecutive NaNs to fill. Must be greater than 0.


add "or None for no limit"

shoyer · 2017-11-12T06:10:15Z

+                       limit=None, **kwargs):
+        # this is just here so I remember the signature we discussed
+        # dim: the dimension along which to interpolate
+        # locs: a broadcastable boolean mask describing where interpolation


boolean mask? I'm not quite sure how that would make sense. My immediate thought would be that locs should be a 1d array of coordinate values.

shoyer · 2017-11-12T06:13:01Z

+                      keep_attrs=True).transpose(*self.dims)
+
+    if limit is not None:
+        print(valids)


shoyer · 2017-11-12T06:18:25Z

+
+    result = da.ffill('time', limit=1)
+    expected = DataArray(
+        [0, 0, np.nan, np.nan, np.nan, 3, 4, 5, 5, 6, 7], dims='time')


It would be nice to add a couple of tests using dask.

…olate

jhamman · 2017-11-13T16:10:42Z

+    '''inverse of ffill'''
+    import bottleneck as bn
+
+    arr = np.flip(arr, axis=axis)


this requires numpy 0.12 or later so I'll need to add a compat function.

this was done in 19d21b8

Maybe npcompat.flip?
And then numpy=1.11 is also supported?

jhamman · 2017-11-14T00:48:24Z

This is ready for some more reviews. I'm seeing some failing tests on the py27-min build that I'm struggling to detangle at the moment but I'm pretty sure they're just pytest related.

cc @darothen - I'd particularly appreciate your thoughts on the interpolators.

fujiisoup

This feature addition is quite great :)

Can we have interpolate_na, ffill, bfil also for xr.Dataset?
drop_na is in Dataset.

fujiisoup · 2017-11-18T07:27:33Z

+        ----------
+        dim : str
+            Specifies the dimension along which to interpolate.
+        method : {'linear', 'time', 'index', 'values', 'nearest'}, optional


Should probably some explanation about method='time' option is necessary here.

good catch. we actually dropped the time/index/values methods in favor of a more explicit interface that uses use_coordinate.

fujiisoup · 2017-11-18T07:35:55Z

+        from scipy.interpolate import UnivariateSpline
+
+        if kind is None:
+            raise ValueError('kind is a required argument')


what should be passed as kind?

fujiisoup · 2017-11-18T07:39:42Z

+        if isinstance(index, pd.DatetimeIndex):
+            index = index.values.astype(np.float64)
+        # check index sorting now so we can skip it later
+        if not (np.diff(index) > 0).all():


If we require a monotonically-increasing index, can we pass assume_sorted=True to ScipyInterpolator?

fujiisoup · 2017-11-18T07:49:37Z

+        if use_coordinate is True:
+            index = arr.get_index(dim)
+        else:
+            index = arr.coords[use_coordinate]


Do we need to check arr.coords[use_coordinate] is certainly 1-dimensional?

Maybe we can also raise an appropriate error if coordinate is MultiIndex

@fujiisoup - do we have a handy way to tell if an coordinate is a xarray DataArray/Multindex? Its not a subset of pd.Multindex but I need something like:

isinstance(index, (pd.MultiIndex, xr.MultiIndexCoordinate))

Probably the cleanest and most comprehensive thing to do is to try to always cast the interpolation index to float64, while catching any error messages (to replace them with something more informative). When a MultiIndex is cast to numpy array it ends up with object dtype.

fujiisoup

Some more comment :)

fujiisoup · 2017-11-19T07:42:14Z

+        Parameters
+        ----------
+        dim : str
+            Specifies the dimension along which to propogate values when


propogate -> propagate?

fujiisoup · 2017-11-19T08:01:58Z

+                 **kwargs):
+        from scipy.interpolate import UnivariateSpline
+
+        if method is not 'spline':


if method is not 'spline': -> if method != 'spline':

fujiisoup · 2017-11-19T08:09:28Z

+        DataArray
+        '''
+        from .missing import bfill
+        return bfill(self, dim, limit=limit)


Do we need bottleneck installed to use bfill or ffill? Maybe it should be noted in docstrings.

fujiisoup · 2017-11-19T08:18:18Z

+@pytest.mark.parametrize('frac_nan', [0, 0.5, 1])
+@pytest.mark.parametrize('method', ['time', 'index', 'values', 'linear',
+                                    'nearest', 'zero', 'slinear',
+                                    'quadratic', 'cubic'])


Do we need to test also for 'barycentric', 'krog', 'pchip', 'spline' methods?

fujiisoup · 2017-11-19T08:20:44Z

+            Specifies the dimension along which to interpolate.
+        method : {'linear', 'nearest', 'zero', 'slinear', 'quadratic', 'cubic',
+                  'polynomial', 'barycentric', 'krog', 'pchip',
+                  'spline'}, optional


Pandas seems to support Akima.
Maybe we can also add this?
Scipy provides the similar interface.

fujiisoup · 2017-11-19T08:26:25Z

+                  'spline'}, optional
+            String indicating which method to use for interpolation:
+
+            - 'linear': linear interpolation (Default). Additional keyword


I noticed pandas.interpolate(method='linear') behaves differently.
Though I think our definition is more natural, we can note this here?

Are you referring to which values Pandas uses for the index?

Yes.

pandas' docstring says

‘linear’: ignore the index and treat the values as equally spaced.
‘index’: use the actual numerical values of the index.

the difference of which may correspond to our use_coordinate option [False/True].

Our linear option means a linear interpolation.
I've just thought the same name with different meanings is sometimes confusing.
It is a very trivial point (and maybe a kind of overconcern).

fujiisoup · 2017-11-19T08:27:24Z

+        if use_coordinate is True:
+            index = arr.get_index(dim)
+        else:
+            index = arr.coords[use_coordinate]


Maybe we can also raise an appropriate error if coordinate is MultiIndex

jhamman · 2017-12-18T17:19:59Z

@fujiisoup - care to take another pass here? I think this is done but would appreciate a few more reviews.

fujiisoup

Few more comments.
Maybe I miss something but we require numpy=1.12 because of np.flip?

fujiisoup · 2017-12-19T13:44:13Z

+.. ipython:: python
+
+    x = xr.DataArray([0, 1, np.nan, np.nan, 2], dims=['x'],
+                     coords={'xx': [0, 1, 1.1, 1.9, 3]})


I think here is a typo. Maybe

x = xr.DataArray([0, 1, np.nan, np.nan, 2], dims=['x'], coords={'xx': ('x', [0, 1, 1.1, 1.9, 3])})

or

x = xr.DataArray([0, 1, np.nan, np.nan, 2], dims=['x'], coords={'x': [0, 1, 1.1, 1.9, 3]})

?

This was intentional.

Really?
I got
ValueError: coordinate xx has dimensions ('xx',), but these are not a subset of the DataArray dimensions ['x']
from this script.

You were right. I was missing the Variable constructor.

fujiisoup · 2017-12-19T13:51:58Z

+    '''inverse of ffill'''
+    import bottleneck as bn
+
+    arr = np.flip(arr, axis=axis)


Maybe npcompat.flip?
And then numpy=1.11 is also supported?

…olate

fujiisoup · 2017-12-21T08:05:10Z

This looks good to me.
Thanks for the great work :)

I will merge it in this weekend if there are no further comments.

max-sixty · 2017-12-21T17:34:13Z

+                         use_coordinate=use_coordinate, **kwargs)
+
+    def ffill(self, dim, limit=None):
+        '''Fill NaN values by propogating values forward


no need to change now, but FYI PEP8 is """ on its own line IIRC

max-sixty · 2017-12-21T17:35:04Z

        out = ops.fillna(self, value)
        return out

+    def interpolate_na(self, dim=None, method='linear', limit=None,


Probably too late to be helpful - but are we sure about the name here? We don't generally add _na onto methods (bfill_na?), and pandas is interpolate only

See comment from @shoyer above: #1640 (comment)

max-sixty · 2017-12-21T17:44:45Z

+        self.f = UnivariateSpline(xi, yi, k=order, **self.cons_kwargs)
+
+
+def _apply_over_vars_with_dim(func, self, dim=None, **kwargs):


This looks good! Could we use this elsewhere in the future? Or even put it on Dataset?

Yes, certainly. I'm not 100% convinced we don't already have something like this but I didn't seem to find it. @shoyer, do you have thoughts on this?

max-sixty · 2017-12-21T17:46:01Z

+    '''wrapper for datasets'''
+    from .dataset import Dataset
+
+    ds = Dataset(coords=self.coords, attrs=self.attrs)


If people are subclassing Dataset (we do internally), this will void their subclass. I think generally we should use type(self) or self.__class__

max-sixty · 2017-12-21T17:47:11Z

+    axis = arr.get_axis_num(dim)
+
+    # work around for bottleneck 178
+    _limit = limit if limit is not None else arr.shape[axis]


max-sixty · 2017-12-21T17:49:30Z

+        for dim in ['time', 'x']:
+            actual = da.interpolate_na(method=method, dim=dim)
+            expected = df.interpolate(method=method, axis=da.get_axis_num(dim))
+            np.testing.assert_allclose(actual.values, expected.values)


Perennial note for future tests: xarray.tests.assert_close

expected is a Pandas.DataFrame so I don't think this will work with xarray.tests.assert_close

ghost · 2017-12-21T17:50:19Z

+def test_interpolate_pd_compat_non_uniform_index():
+    shapes = [(8, 8), (1, 20), (20, 1), (100, 100)]
+    frac_nans = [0, 0.5, 1]
+    methods = ['time', 'index', 'values']


obv don't change but for future tests: pytest handles these parameterizations v well

@maxim-lian - I was using the pytest parameterizations here but they weren't playing nice with the @requires_foo decorators.

I can have a look. Do you remember what the setup was that didn't work? No stress if not

I think skipped tests are returned as functions without arguments. The parameterizations then were passed to functions that didn't take arguments and that obviously didn't work.

So:

@parameterize('foo', [1, 2]) @skip def bar(foo): pass

becomes

@parameterize('foo', [1, 2]) def bar(): pass

when skipped.

I think we should use pytest.importorskip - while @jreback is right that it doesn't allow as much control as writing a function ourselves, and @WillAyd gives some more benefits , we're not using anything that the standard pytest function can't do, in any of our functions.

If people agree, I could add a note to this function: https://github.com/pydata/xarray/pull/1640/files/48505a51e69d6b3663783db414962f3011e94aa1#diff-e84d0339b6da4d18c02f6b2d54fbd5bdR47

I recall we had some difficulty with decorators based on pytest and subclass methods, but that doesn't apply here.

ghost · 2017-12-21T17:53:43Z

This is great! While I left some comments, I don't think any warrant changes now, as long as ppl are good with the interpolate_na name

…olate

ghost · 2017-12-21T22:42:01Z

+
+        if fill_value is None:
+            self._left = np.nan
+            self._right = yi[-1]


+1 let's use NaN here.

ghost · 2017-12-21T22:43:39Z

+    def bfill(self, dim, limit=None):
+        '''Fill NaN values by propogating values backward
+
+        *Requires bottleneck and Numpy v1.12.0 or later.*


I don't think NumPy 1.12 is still required with our flip backport

ghost · 2017-12-21T22:43:50Z

+    def bfill(self, dim, limit=None):
+        '''Fill NaN values by propogating values backward
+
+        *Requires bottleneck and Numpy v1.12.0 or later.*


as above: numpy 1.12 is not required with our backport.

ghost · 2017-12-21T22:46:54Z

+def test_interpolate_pd_compat_non_uniform_index():
+    shapes = [(8, 8), (1, 20), (20, 1), (100, 100)]
+    frac_nans = [0, 0.5, 1]
+    methods = ['time', 'index', 'values']


I recall we had some difficulty with decorators based on pytest and subclass methods, but that doesn't apply here.

…match pandas -- adjusted tests and docs to reflect this change

…olate

ghost · 2017-12-30T06:19:15Z

ready to go?

ghost · 2017-12-30T06:22:21Z

Thanks for this great work!

fujiisoup reviewed Oct 20, 2017

View reviewed changes

shoyer reviewed Oct 20, 2017

View reviewed changes

jhamman mentioned this pull request Oct 24, 2017

ENH: Forward & back fill methods #1651

Closed

jhamman commented Nov 4, 2017

View reviewed changes

shoyer reviewed Nov 5, 2017

View reviewed changes

shoyer reviewed Nov 8, 2017

View reviewed changes

shoyer mentioned this pull request Nov 8, 2017

ffill & bfill methods #1696

Closed

4 tasks

Joe Hamman added 2 commits November 10, 2017 23:25

fix to interpolate wrapper function

ab727e7

jhamman commented Nov 11, 2017

View reviewed changes

Joe Hamman and others added 2 commits November 11, 2017 00:27

remove duplicate limit handling in ffill/bfill

95006c4

tests are passing

4a4f6eb

shoyer reviewed Nov 12, 2017

View reviewed changes

Joe Hamman added 2 commits November 12, 2017 19:24

more docs, more tests

42d63ef

Merge branch 'master' of github.com:pydata/xarray into feature/interp…

263ec98

…olate

jhamman commented Nov 13, 2017

View reviewed changes

Joe Hamman added 4 commits November 13, 2017 14:38

backward compat and add benchmarks

19d21b8

skip tests for numpy versions before 1.12

f937c07

test fixes for py27 fixture

8717e38

try reording decorators

3d5c1b1

minor reorg of travis to make the flake8 check useful

1864e8f

fujiisoup reviewed Nov 18, 2017

View reviewed changes

cleanup following @fujiisoup's comments

f58d464

fujiisoup reviewed Nov 19, 2017

View reviewed changes

This was referenced Nov 21, 2017

Rank function #1731

Closed

Rank Methods #1733

Merged

Joseph Hamman added 2 commits December 15, 2017 21:11

workaround for parameterized tests that are skipped in missing.py module

dd9fa8c

requires_np112 for dataset interpolate test

88d1569

fujiisoup reviewed Dec 19, 2017

View reviewed changes

Joseph Hamman added 4 commits December 20, 2017 16:04

Merge branch 'master' of github.com:pydata/xarray into feature/interp…

3fb9261

…olate

remove req for np 112

37882b7

fix typo in docs

a04e83e

@requires_np112 for methods that use apply_ufunc in missing.py

48505a5

max-sixty reviewed Dec 21, 2017

View reviewed changes

Joseph Hamman added 2 commits December 21, 2017 10:33

Merge branch 'master' of github.com:pydata/xarray into feature/interp…

20f957d

…olate

reuse type in apply over vars with dim

282bb65

max-sixty mentioned this pull request Dec 21, 2017

TST: make _skip_if into pytest decorators pandas-dev/pandas#18190

Closed

16 tasks

shoyer reviewed Dec 21, 2017

View reviewed changes

Joseph Hamman added 3 commits December 22, 2017 11:12

rework the fill value convention for linear interpolation, no longer …

a6fcb7f

…match pandas -- adjusted tests and docs to reflect this change

flake8

2b0d9e1

Merge branch 'master' of github.com:pydata/xarray into feature/interp…

d3220f3

…olate

fujiisoup merged commit 783b527 into pydata:master Dec 30, 2017

jhamman deleted the feature/interpolate branch December 30, 2017 06:58

max-sixty mentioned this pull request Jan 13, 2018

Testing deprecations #1825

Closed

etienneschalk mentioned this pull request Feb 18, 2024

DataArrayResample.interpolate and passing kwargs #8762

Closed

		@@ -0,0 +1,95 @@
		"""Define core operations for xarray objects.

		TODO(shoyer): rewrite this module, making use of xarray.core.computation,

	compat : {'broadcast_equals', 'equals', 'identical'}, optional
	String indicating how to compare variables of the same name for
	potential conflicts when initializing this dataset:

	- 'broadcast_equals': all values must be equal when variables are
	broadcast against each other to ensure common dimensions.
	- 'equals': all values and dimensions must be the same.
	- 'identical': all values, dimensions and attributes must be the
	same.

		self.f = UnivariateSpline(xi, yi, k=order, **self.cons_kwargs)


		def _apply_over_vars_with_dim(func, self, dim=None, **kwargs):

Uh oh!

Uh oh!

Conversation

jhamman commented Oct 20, 2017 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

dcherian commented Nov 4, 2017

Uh oh!

jhamman commented Nov 4, 2017

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jhamman commented Oct 20, 2017 •

edited

Loading