renamed param to degree since any mention of polynomials in the parameter is kind of redundant for methods in the polynomial_fit module

Author: pavelkomarov

examples/1_basic_tutorial.ipynb

@@ -24,15 +24,15 @@
                   {'high_freq_cutoff': (1e-5, 1-1e-5)}),
     polydiff: ({'step_size': [1, 2, 5],
                 'kernel': {'friedrichs', 'gaussian'}, # categorical
-                'poly_deg': [2, 3, 5, 7],
+                'degree': [2, 3, 5, 7],
                 'window_size': [11, 31, 51, 91, 131]},
                {'step_size': (1, 100),
-                'poly_deg': (1, 8),
+                'degree': (1, 8),
                 'window_size': (10, 1000)}),
-    savgoldiff: ({'poly_deg': [2, 3, 5, 7, 10],
+    savgoldiff: ({'degree': [2, 3, 5, 7, 10],
                   'window_size': [3, 10, 30, 50, 90, 130, 200, 300],
                   'smoothing_win': [3, 10, 30, 50, 90, 130, 200, 300]},
-                 {'poly_deg': (1, 12),
+                 {'degree': (1, 12),
                   'window_size': (3, 1000),
                   'smoothing_win': (3, 1000)}),
     lineardiff: ({'kernel': 'gaussian',
@@ -56,7 +56,7 @@
                   'num_iterations': [1, 5, 10]},
                  {'cutoff_freq': (1e-4, 1-1e-2),
                   'num_iterations': (1, 1000)}),
-    splinediff: ({'deg': {3, 4, 5}, # categorical, because degree is whole number, and there aren't many choices
+    splinediff: ({'degree': {3, 4, 5}, # categorical, because degree is whole number, and there aren't many choices
                   's': [0.5, 0.9, 0.95, 1, 10, 100],
                   'num_iterations': [1, 5, 10]},
                  {'s': (1e-2, 1e6),

examples/2a_optimizing_parameters_with_dxdt_known.ipynb

@@ -5,15 +5,15 @@
 from pynumdiff.utils import utility
 
 
-def splinediff(x, dt, params=None, options={}, deg=3, s=None, num_iterations=1):
+def splinediff(x, dt, params=None, options={}, degree=3, s=None, num_iterations=1):
     """Find smoothed data and derivative estimates by fitting a smoothing spline to the data with
     scipy.interpolate.UnivariateSpline.
 
     :param np.array[float] x: data to differentiate
     :param float dt: step size
-    :param list params: (**deprecated**, prefer :code:`deg`, :code:`cutoff_freq`, and :code:`num_iterations`)
+    :param list params: (**deprecated**, prefer :code:`degree`, :code:`cutoff_freq`, and :code:`num_iterations`)
     :param dict options: (**deprecated**, prefer :code:`num_iterations`) an empty dictionary or {'iterate': (bool)}
-    :param int deg: polynomial degree of the spline. A kth degree spline can be differentiated k times.
+    :param int degree: polynomial degree of the spline. A kth degree spline can be differentiated k times.
     :param float s: positive smoothing factor used to choose the number of knots. Number of knots will be increased
         until the smoothing condition is satisfied: :math:`\\sum_t (x[t] - \\text{spline}[t])^2 \\leq s`
     :param int num_iterations: how many times to apply smoothing
@@ -25,15 +25,15 @@ def splinediff(x, dt, params=None, options={}, deg=3, s=None, num_iterations=1):
     if params != None: # Warning to support old interface for a while. Remove these lines along with params in a future release.
         warn("`params` and `options` parameters will be removed in a future version. Use `order`, `s`, and " +
             "`num_iterations` instead.", DeprecationWarning)
-        deg, s = params[0:2]
+        degree, s = params[0:2]
         if 'iterate' in options and options['iterate']:
             num_iterations = params[2]
 
     t = np.arange(len(x))*dt
 
     x_hat = x
     for _ in range(num_iterations):
-        spline = scipy.interpolate.UnivariateSpline(t, x_hat, k=deg, s=s)
+        spline = scipy.interpolate.UnivariateSpline(t, x_hat, k=degree, s=s)
         x_hat = spline(t)
 
     dspline = spline.derivative()
@@ -42,16 +42,16 @@ def splinediff(x, dt, params=None, options={}, deg=3, s=None, num_iterations=1):
     return x_hat, dxdt_hat
 
 
-def polydiff(x, dt, params=None, options=None, poly_deg=None, window_size=None, step_size=1,
+def polydiff(x, dt, params=None, options=None, degree=None, window_size=None, step_size=1,
     kernel='friedrichs'):
     """Fit polynomials to the data, and differentiate the polynomials.
 
     :param np.array[float] x: data to differentiate
     :param float dt: step size
-    :param list[int] params: (**deprecated**, prefer :code:`poly_deg` and :code:`window_size`)
+    :param list[int] params: (**deprecated**, prefer :code:`degree` and :code:`window_size`)
     :param dict options: (**deprecated**, prefer :code:`step_size` and :code:`kernel`)
             a dictionary consisting of {'sliding': (bool), 'step_size': (int), 'kernel_name': (str)}
-    :param int poly_deg: degree of the polynomial
+    :param int degree: degree of the polynomial
     :param int window_size: size of the sliding window, if not given no sliding
     :param int step_size: step size for sliding
     :param str kernel: name of kernel to use for weighting and smoothing windows ('gaussian' or 'friedrichs')
@@ -61,27 +61,27 @@ def polydiff(x, dt, params=None, options=None, poly_deg=None, window_size=None,
              - **dxdt_hat** -- estimated derivative of x
     """
     if params != None:
-        warn("`params` and `options` parameters will be removed in a future version. Use `poly_deg` " +
+        warn("`params` and `options` parameters will be removed in a future version. Use `degree` " +
             "and `window_size` instead.", DeprecationWarning)
-        poly_deg = params[0]
+        degree = params[0]
         if len(params) > 1: window_size = params[1]
         if options != None:
             if 'sliding' in options and not options['sliding']: window_size = None
             if 'step_size' in options: step_size = options['step_size']
             if 'kernel_name' in options: kernel = options['kernel_name']
-    elif poly_deg == None or window_size == None:
-        raise ValueError("`poly_deg` and `window_size` must be given.")
+    elif degree == None or window_size == None:
+        raise ValueError("`degree` and `window_size` must be given.")
 
-    if window_size < poly_deg*3:
-        window_size = poly_deg*3+1
+    if window_size < degree*3:
+        window_size = degree*3+1
     if window_size % 2 == 0:
         window_size += 1
         warn("Kernel window size should be odd. Added 1 to length.")
 
-    def _polydiff(x, dt, poly_deg, weights=None):
+    def _polydiff(x, dt, degree, weights=None):
         t = np.arange(len(x))*dt
 
-        r = np.polyfit(t, x, poly_deg, w=weights) # polyfit returns highest order first
+        r = np.polyfit(t, x, degree, w=weights) # polyfit returns highest order first
         dr = np.polyder(r) # power rule already implemented for us
 
         dxdt_hat = np.polyval(dr, t) # evaluate the derivative and original polynomials at points t
@@ -90,22 +90,22 @@ def _polydiff(x, dt, poly_deg, weights=None):
         return x_hat, dxdt_hat
 
     if not window_size:
-        return _polydiff(x, dt, poly_deg)
+        return _polydiff(x, dt, degree)
 
     kernel = {'gaussian':utility.gaussian_kernel, 'friedrichs':utility.friedrichs_kernel}[kernel](window_size)
-    return utility.slide_function(_polydiff, x, dt, kernel, poly_deg, stride=step_size, pass_weights=True)
+    return utility.slide_function(_polydiff, x, dt, kernel, degree, stride=step_size, pass_weights=True)
 
 
-def savgoldiff(x, dt, params=None, options=None, poly_deg=None, window_size=None, smoothing_win=None):
+def savgoldiff(x, dt, params=None, options=None, degree=None, window_size=None, smoothing_win=None):
     """Use the Savitzky-Golay to smooth the data and calculate the first derivative. It uses
     scipy.signal.savgol_filter. The Savitzky-Golay is very similar to the sliding polynomial fit,
     but slightly noisier, and much faster.
 
     :param np.array[float] x: data to differentiate
     :param float dt: step size
-    :param list params: (**deprecated**, prefer :code:`poly_deg`, :code:`window_size`, and :code:`smoothing_win`)
+    :param list params: (**deprecated**, prefer :code:`degree`, :code:`window_size`, and :code:`smoothing_win`)
     :param dict options: (**deprecated**)
-    :param int poly_deg: degree of the polynomial
+    :param int degree: degree of the polynomial
     :param int window_size: size of the sliding window, must be odd (if not, 1 is added)
     :param int smoothing_win: size of the window used for gaussian smoothing, a good default is
         window_size, but smaller for high frequnecy data
@@ -115,19 +115,19 @@ def savgoldiff(x, dt, params=None, options=None, poly_deg=None, window_size=None
              - **dxdt_hat** -- estimated derivative of x
     """
     if params != None: # Warning to support old interface for a while. Remove these lines along with params in a future release.
-        warn("`params` and `options` parameters will be removed in a future version. Use `poly_deg`, " +
+        warn("`params` and `options` parameters will be removed in a future version. Use `degree`, " +
             "`window_size`, and `smoothing_win` instead.", DeprecationWarning)
-        poly_deg, window_size, smoothing_win = params
-    elif poly_deg == None or window_size == None or smoothing_win == None:
-        raise ValueError("`poly_deg`, `window_size`, and `smoothing_win` must be given.")
+        degree, window_size, smoothing_win = params
+    elif degree == None or window_size == None or smoothing_win == None:
+        raise ValueError("`degree`, `window_size`, and `smoothing_win` must be given.")
 
-    window_size = np.clip(window_size, poly_deg + 1, len(x)-1)
+    window_size = np.clip(window_size, degree + 1, len(x)-1)
     if window_size % 2 == 0:
         window_size += 1 # window_size needs to be odd
         warn("Kernel window size should be odd. Added 1 to length.")
     smoothing_win = min(smoothing_win, len(x)-1)
 
-    dxdt_hat = scipy.signal.savgol_filter(x, window_size, poly_deg, deriv=1)/dt
+    dxdt_hat = scipy.signal.savgol_filter(x, window_size, degree, deriv=1)/dt
 
     kernel = utility.gaussian_kernel(smoothing_win)
     dxdt_hat = utility.convolutional_smoother(dxdt_hat, kernel)

examples/2b_optimizing_parameters_with_dxdt_unknown.ipynb

@@ -34,15 +34,15 @@ def iterated_fourth_order(*args, **kwargs): return fourth_order(*args, **kwargs)
     (first_order, {}), (second_order, {}), (fourth_order, {}), # empty dictionary for the case of no parameters
     (iterated_second_order, {'num_iterations':5}), (iterated_fourth_order, {'num_iterations':10}),
     (lineardiff, {'order':3, 'gamma':5, 'window_size':11, 'solver':'CLARABEL'}), (lineardiff, [3, 5, 11], {'solver':'CLARABEL'}),
-    (polydiff, {'poly_deg':2, 'window_size':3}), (polydiff, [2, 3]),
-    (savgoldiff, {'poly_deg':2, 'window_size':5, 'smoothing_win':5}), (savgoldiff, [2, 5, 5]),
+    (polydiff, {'degree':2, 'window_size':3}), (polydiff, [2, 3]),
+    (savgoldiff, {'degree':2, 'window_size':5, 'smoothing_win':5}), (savgoldiff, [2, 5, 5]),
     (spectraldiff, {'high_freq_cutoff':0.2}), (spectraldiff, [0.2]),
     (mediandiff, {'window_size':3, 'num_iterations':2}), (mediandiff, [3, 2], {'iterate':True}),
     (meandiff, {'window_size':3, 'num_iterations':2}), (meandiff, [3, 2], {'iterate':True}),
     (gaussiandiff, {'window_size':5}), (gaussiandiff, [5]),
     (friedrichsdiff, {'window_size':5}), (friedrichsdiff, [5]),
     (butterdiff, {'filter_order':3, 'cutoff_freq':0.074}), (butterdiff, [3, 0.074]),
-    (splinediff, {'deg':5, 's':2}), (splinediff, [5, 2]),
+    (splinediff, {'degree':5, 's':2}), (splinediff, [5, 2]),
     (constant_velocity, {'r':1e-4, 'q':1e-2}), (constant_velocity, [1e-4, 1e-2]),
     (constant_acceleration, {'r':1e-4, 'q':1e-1}), (constant_acceleration, [1e-4, 1e-1]),
     (constant_jerk, {'r':1e-4, 'q':10}), (constant_jerk, [1e-4, 10]),

pynumdiff/optimize/_optimize.py

@@ -78,8 +78,8 @@ def test_acceleration():
 def test_savgoldiff():
     params1, val1 = optimize(savgoldiff, x, dt, dxdt_truth=dxdt_truth, padding='auto')
     params2, val2 = optimize(savgoldiff, x, dt, tvgamma=tvgamma, padding='auto')
-    assert (params1['poly_deg'], params1['window_size'], params1['smoothing_win']) == (7, 41, 3)
-    assert (params2['poly_deg'], params2['window_size'], params2['smoothing_win']) == (3, 3, 5)
+    assert (params1['degree'], params1['window_size'], params1['smoothing_win']) == (7, 41, 3)
+    assert (params2['degree'], params2['window_size'], params2['smoothing_win']) == (3, 3, 5)
 
 def test_spectraldiff():
     params1, val1 = optimize(spectraldiff, x, dt, dxdt_truth=dxdt_truth, padding='auto')
@@ -90,5 +90,5 @@ def test_spectraldiff():
 def test_polydiff():
     params1, val1 = optimize(polydiff, x, dt, dxdt_truth=dxdt_truth, search_space_updates={'step_size':1}, padding='auto')
     params2, val2 = optimize(polydiff, x, dt, tvgamma=tvgamma, search_space_updates={'step_size':1}, padding='auto')
-    assert (params1['poly_deg'], params1['window_size'], params1['kernel']) == (6, 50, 'friedrichs')
-    assert (params2['poly_deg'], params2['window_size'], params2['kernel']) == (3, 10, 'gaussian')
+    assert (params1['degree'], params1['window_size'], params1['kernel']) == (6, 50, 'friedrichs')
+    assert (params2['degree'], params2['window_size'], params2['kernel']) == (3, 10, 'gaussian')