Numpy or SciPy Derivative function for non-uniform spacing?

Question

I was wondering if numpy or scipy had a method in their libraries to find the numerical derivative of a list of values with non-uniform spacing. The idea is to feed in the timestamps that correspond to the values and then for it to use the timestamps to find the numerical derivative.

Answer 1

You can create your own functions using numpy. For the derivatives using forward differences (edit thanks to @EOL, but note that NumPy's diff() is not a differentiate function):

def diff_fwd(x, y): 
    return np.diff(y)/np.diff(x)

"central" differences (it is not necessarily central, depending on your data spacing):

def diff_central(x, y):
    x0 = x[:-2]
    x1 = x[1:-1]
    x2 = x[2:]
    y0 = y[:-2]
    y1 = y[1:-1]
    y2 = y[2:]
    f = (x2 - x1)/(x2 - x0)
    return (1-f)*(y2 - y1)/(x2 - x1) + f*(y1 - y0)/(x1 - x0)

where y contains the function evaluations and x the corresponding "times", such that you can use an arbitrary interval.

Answer 2

This is a little bit late, but found @dllahr's answer to be very useful and easy to implement with numpy:

>>> import numpy as np
>>> y = [1, 2, 3, 4, 5]
>>> dy = np.gradient(y)
>>> x = [1, 2, 4, 8, 10]
>>> dx = np.gradient(x)
>>> dy/dx
array([1., 0.66666667, 0.33333333, 0.33333333, 0.5])

Answer 3

This is probably not provided because what you can do instead is take the derivative of your dependent variable (y-values), take the derivative of your independent variable (in your specific case, the timestamps), and then divide the first vector by second.

The definition of the derivative is:

f' = dy / dx

or in your case:

f'(t) = dy / dt

You can use the diff function to calculate each of your numerical dy, the diff function to calculate your numerical dt, and then element divide these arrays to determine f'(t) at each point.

Answer 4

Scipy's UnivariateSpline.derivative is a simple way to find the derivative of any data set (x-axis must be ordered such that it is increasing).

x  = [1, 3, 8, 10]
y  = [0, 8, 12, 4]
z  = scipy.interpolate.UnivariateSpline.derivative(x,y)
dz = z.derivative(n)

where n is the order of the derivative

ref: https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.interpolate.UnivariateSpline.derivative.html

Note that the default order of UnivariateSpline is 3 and equivalent scipy.interpolate.CubicSpline

Answer 5

Since the newest NumPy release (1.13), numpy.gradient has this feature implemented (documentation):

>>> #only numpy 1.13 and above
>>> import numpy as np
>>> y = [1, 3, 4, 6, 11]
>>> x = [0, 1, 5, 10, 11]
>>> np.gradient(y, x)
array([ 2.        ,  1.65      ,  0.31666667,  4.23333333,  5.        ])

Here the values in x mark the x-coordinates of the y-values in y.