Remove mlab.slopes, mlab.stineman_interp

dstansby · dstansby · commit fb07c4280be7 · 2018-09-29T11:05:06.000+01:00
diff --git a/doc/api/next_api_changes/2018-09-18-DS.rst b/doc/api/next_api_changes/2018-09-18-DS.rst
@@ -23,4 +23,6 @@ in Matplotlib 2.2 has been removed. See below for a list:
 - `mlab.dist_point_to_segment`
 - `mlab.griddata` (use scipy.interpolate.griddata)
 - `mlab.less_simple_linear_interpolation` (use numpy.interp)
+- `mlab.slopes`
+- `mlab.stineman_interp`
 - `mlab.donothing_callback`
diff --git a/lib/matplotlib/mlab.py b/lib/matplotlib/mlab.py
@@ -2556,145 +2556,6 @@ def newfunc(val, mask, mval):
         fh.close()
 
 
-##################################################
-# Linear interpolation algorithms
-##################################################
-@cbook.deprecated("2.2")
-def slopes(x, y):
-    """
-    :func:`slopes` calculates the slope *y*'(*x*)
-
-    The slope is estimated using the slope obtained from that of a
-    parabola through any three consecutive points.
-
-    This method should be superior to that described in the appendix
-    of A CONSISTENTLY WELL BEHAVED METHOD OF INTERPOLATION by Russel
-    W. Stineman (Creative Computing July 1980) in at least one aspect:
-
-      Circles for interpolation demand a known aspect ratio between
-      *x*- and *y*-values.  For many functions, however, the abscissa
-      are given in different dimensions, so an aspect ratio is
-      completely arbitrary.
-
-    The parabola method gives very similar results to the circle
-    method for most regular cases but behaves much better in special
-    cases.
-
-    Norbert Nemec, Institute of Theoretical Physics, University or
-    Regensburg, April 2006 Norbert.Nemec at physik.uni-regensburg.de
-
-    (inspired by a original implementation by Halldor Bjornsson,
-    Icelandic Meteorological Office, March 2006 halldor at vedur.is)
-    """
-    # Cast key variables as float.
-    x = np.asarray(x, float)
-    y = np.asarray(y, float)
-
-    yp = np.zeros(y.shape, float)
-
-    dx = x[1:] - x[:-1]
-    dy = y[1:] - y[:-1]
-    dydx = dy/dx
-    yp[1:-1] = (dydx[:-1] * dx[1:] + dydx[1:] * dx[:-1])/(dx[1:] + dx[:-1])
-    yp[0] = 2.0 * dy[0]/dx[0] - yp[1]
-    yp[-1] = 2.0 * dy[-1]/dx[-1] - yp[-2]
-    return yp
-
-
-@cbook.deprecated("2.2")
-def stineman_interp(xi, x, y, yp=None):
-    """
-    Given data vectors *x* and *y*, the slope vector *yp* and a new
-    abscissa vector *xi*, the function :func:`stineman_interp` uses
-    Stineman interpolation to calculate a vector *yi* corresponding to
-    *xi*.
-
-    Here's an example that generates a coarse sine curve, then
-    interpolates over a finer abscissa::
-
-      x = linspace(0,2*pi,20);  y = sin(x); yp = cos(x)
-      xi = linspace(0,2*pi,40);
-      yi = stineman_interp(xi,x,y,yp);
-      plot(x,y,'o',xi,yi)
-
-    The interpolation method is described in the article A
-    CONSISTENTLY WELL BEHAVED METHOD OF INTERPOLATION by Russell
-    W. Stineman. The article appeared in the July 1980 issue of
-    Creative Computing with a note from the editor stating that while
-    they were:
-
-      not an academic journal but once in a while something serious
-      and original comes in adding that this was
-      "apparently a real solution" to a well known problem.
-
-    For *yp* = *None*, the routine automatically determines the slopes
-    using the :func:`slopes` routine.
-
-    *x* is assumed to be sorted in increasing order.
-
-    For values ``xi[j] < x[0]`` or ``xi[j] > x[-1]``, the routine
-    tries an extrapolation.  The relevance of the data obtained from
-    this, of course, is questionable...
-
-    Original implementation by Halldor Bjornsson, Icelandic
-    Meteorolocial Office, March 2006 halldor at vedur.is
-
-    Completely reworked and optimized for Python by Norbert Nemec,
-    Institute of Theoretical Physics, University or Regensburg, April
-    2006 Norbert.Nemec at physik.uni-regensburg.de
-    """
-
-    # Cast key variables as float.
-    x = np.asarray(x, float)
-    y = np.asarray(y, float)
-    if x.shape != y.shape:
-        raise ValueError("'x' and 'y' must be of same shape")
-
-    if yp is None:
-        yp = slopes(x, y)
-    else:
-        yp = np.asarray(yp, float)
-
-    xi = np.asarray(xi, float)
-
-    # calculate linear slopes
-    dx = x[1:] - x[:-1]
-    dy = y[1:] - y[:-1]
-    s = dy/dx  # note length of s is N-1 so last element is #N-2
-
-    # find the segment each xi is in
-    # this line actually is the key to the efficiency of this implementation
-    idx = np.searchsorted(x[1:-1], xi)
-
-    # now we have generally: x[idx[j]] <= xi[j] <= x[idx[j]+1]
-    # except at the boundaries, where it may be that xi[j] < x[0] or
-    # xi[j] > x[-1]
-
-    # the y-values that would come out from a linear interpolation:
-    sidx = s.take(idx)
-    xidx = x.take(idx)
-    yidx = y.take(idx)
-    xidxp1 = x.take(idx+1)
-    yo = yidx + sidx * (xi - xidx)
-
-    # the difference that comes when using the slopes given in yp
-    # using the yp slope of the left point
-    dy1 = (yp.take(idx) - sidx) * (xi - xidx)
-    # using the yp slope of the right point
-    dy2 = (yp.take(idx+1)-sidx) * (xi - xidxp1)
-
-    dy1dy2 = dy1*dy2
-    # The following is optimized for Python. The solution actually
-    # does more calculations than necessary but exploiting the power
-    # of numpy, this is far more efficient than coding a loop by hand
-    # in Python
-    yi = yo + dy1dy2 * np.choose(np.array(np.sign(dy1dy2), np.int32)+1,
-                                 ((2*xi-xidx-xidxp1)/((dy1-dy2)*(xidxp1-xidx)),
-                                  0.0,
-                                  1/(dy1+dy2),))
-    return yi
-
-
 class GaussianKDE(object):
     """
     Representation of a kernel-density estimate using Gaussian kernels.
diff --git a/lib/matplotlib/pylab.py b/lib/matplotlib/pylab.py
@@ -237,7 +237,7 @@
     l2norm, log2, movavg, norm_flat,
     path_length, poly_below, poly_between,
     rec2csv, rec_append_fields, rec_drop_fields, rec_join, rms_flat,
-    segments_intersect, slopes, stineman_interp, vector_lengths,
+    segments_intersect, vector_lengths,
     window_hanning, window_none)
 
 from matplotlib import cbook, mlab, pyplot as plt
