def interp(self, coords=None, method='linear', assume_sorted=False,
               kwargs={}, **coords_kwargs):
        """ Multidimensional interpolation of Dataset.

        Parameters
        ----------
        coords : dict, optional
            Mapping from dimension names to the new coordinates.
            New coordinate can be a scalar, array-like or DataArray.
            If DataArrays are passed as new coordates, their dimensions are
            used for the broadcasting.
        method: string, optional.
            {'linear', 'nearest'} for multidimensional array,
            {'linear', 'nearest', 'zero', 'slinear', 'quadratic', 'cubic'}
            for 1-dimensional array. 'linear' is used by default.
        assume_sorted: boolean, optional
            If False, values of coordinates that are interpolated over can be
            in any order and they are sorted first. If True, interpolated
            coordinates are assumed to be an array of monotonically increasing
            values.
        kwargs: dictionary, optional
            Additional keyword passed to scipy's interpolator.
        **coords_kwarg : {dim: coordinate, ...}, optional
            The keyword arguments form of ``coords``.
            One of coords or coords_kwargs must be provided.

        Returns
        -------
        interpolated: xr.Dataset
            New dataset on the new coordinates.

        Notes
        -----
        scipy is required.

        See Also
        --------
        scipy.interpolate.interp1d
        scipy.interpolate.interpn
        """
        from . import missing

        coords = either_dict_or_kwargs(coords, coords_kwargs, 'interp')
        indexers = OrderedDict(self._validate_indexers(coords))

        obj = self if assume_sorted else self.sortby([k for k in coords])

        def maybe_variable(obj, k):
            # workaround to get variable for dimension without coordinate.
            try:
                return obj._variables[k]
            except KeyError:
                return as_variable((k, range(obj.dims[k])))

        def _validate_interp_indexer(x, new_x):
            # In the case of datetimes, the restrictions placed on indexers
            # used with interp are stronger than those which are placed on
            # isel, so we need an additional check after _validate_indexers.
            if (_contains_datetime_like_objects(x) and
                    not _contains_datetime_like_objects(new_x)):
                raise TypeError('When interpolating over a datetime-like '
                                'coordinate, the coordinates to '
                                'interpolate to must be either datetime '
                                'strings or datetimes. '
                                'Instead got\n{}'.format(new_x))
            else:
                return (x, new_x)

        variables = OrderedDict()
        for name, var in obj._variables.items():
            if name not in indexers:
                if var.dtype.kind in 'uifc':
                    var_indexers = {
                        k: _validate_interp_indexer(maybe_variable(obj, k), v)
                        for k, v in indexers.items()
                        if k in var.dims
                    }
                    variables[name] = missing.interp(
                        var, var_indexers, method, **kwargs)
                elif all(d not in indexers for d in var.dims):
                    # keep unrelated object array
                    variables[name] = var

        coord_names = set(variables).intersection(obj._coord_names)
        indexes = OrderedDict(
            (k, v) for k, v in obj.indexes.items() if k not in indexers)
        selected = self._replace_with_new_dims(
            variables.copy(), coord_names, indexes=indexes)

        # attach indexer as coordinate
        variables.update(indexers)
        indexes.update(
            (k, v.to_index()) for k, v in indexers.items() if v.dims == (k,)
        )

        # Extract coordinates from indexers
        coord_vars, new_indexes = (
            selected._get_indexers_coords_and_indexes(coords))
        variables.update(coord_vars)
        indexes.update(new_indexes)

        coord_names = (set(variables)
                       .intersection(obj._coord_names)
                       .union(coord_vars))
        return self._replace_with_new_dims(
            variables, coord_names, indexes=indexes)
Multidimensional interpolation of Dataset.

        Parameters
        ----------
        coords : dict, optional
            Mapping from dimension names to the new coordinates.
            New coordinate can be a scalar, array-like or DataArray.
            If DataArrays are passed as new coordates, their dimensions are
            used for the broadcasting.
        method: string, optional.
            {'linear', 'nearest'} for multidimensional array,
            {'linear', 'nearest', 'zero', 'slinear', 'quadratic', 'cubic'}
            for 1-dimensional array. 'linear' is used by default.
        assume_sorted: boolean, optional
            If False, values of coordinates that are interpolated over can be
            in any order and they are sorted first. If True, interpolated
            coordinates are assumed to be an array of monotonically increasing
            values.
        kwargs: dictionary, optional
            Additional keyword passed to scipy's interpolator.
        **coords_kwarg : {dim: coordinate, ...}, optional
            The keyword arguments form of ``coords``.
            One of coords or coords_kwargs must be provided.

        Returns
        -------
        interpolated: xr.Dataset
            New dataset on the new coordinates.

        Notes
        -----
        scipy is required.

        See Also
        --------
        scipy.interpolate.interp1d
        scipy.interpolate.interpn