docs: def quantile(self, q, dim=None, interpolation='linear'):
          """Compute the qth quantile of the data along the specified dimension.
  
          Returns the qth quantiles(s) of the array elements.
  
          Parameters
          ----------
          q : float in range of [0,1] (or sequence of floats)
              Quantile to compute, which must be between 0 and 1
              inclusive.
          dim : str or sequence of str, optional
              Dimension(s) over which to apply quantile.
          interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
              This optional parameter specifies the interpolation method to
              use when the desired quantile lies between two data points
              ``i < j``:
                  * linear: ``i + (j - i) * fraction``, where ``fraction`` is
                    the fractional part of the index surrounded by ``i`` and
                    ``j``.
                  * lower: ``i``.
                  * higher: ``j``.
                  * nearest: ``i`` or ``j``, whichever is nearest.
                  * midpoint: ``(i + j) / 2``.
  
          Returns
          -------
          quantiles : Variable
              If `q` is a single quantile, then the result
              is a scalar. If multiple percentiles are given, first axis of
              the result corresponds to the quantile and a quantile dimension
              is added to the return array. The other dimensions are the
               dimensions that remain after the reduction of the array.
  
          See Also
          --------
          numpy.nanpercentile, pandas.Series.quantile, Dataset.quantile,
          DataArray.quantile
          """
          if isinstance(self.data, dask_array_type):
              raise TypeError("quantile does not work for arrays stored as dask "
                              "arrays. Load the data via .compute() or .load() "
                              "prior to calling this method.")
  
          q = np.asarray(q, dtype=np.float64)
  
          new_dims = list(self.dims)
          if dim is not None:
              axis = self.get_axis_num(dim)
              if utils.is_scalar(dim):
                  new_dims.remove(dim)
              else:
                  for d in dim:
                      new_dims.remove(d)
          else:
              axis = None
              new_dims = []
  
          # only add the quantile dimension if q is array like
          if q.ndim != 0:
              new_dims = ['quantile'] + new_dims
  
          qs = np.nanpercentile(self.data, q * 100., axis=axis,
                                interpolation=interpolation)
          return Variable(new_dims, qs)