added window_size as a parameter to jerk_sliding, because that makes more sense

Author: pavelkomarov

pynumdiff/tests/conftest.py

@@ -12,6 +12,7 @@ def store_plots(request):
     request.config.plots = defaultdict(lambda: pyplot.subplots(6, 2, figsize=(12,7))) # 6 is len(test_funcs_and_derivs)
 
 def pytest_sessionfinish(session, exitstatus):
+    if not hasattr(session.config, 'plots'): return
     for method,(fig,axes) in session.config.plots.items():
         axes[-1,-1].legend()
         fig.suptitle(method.__name__)

pynumdiff/tests/test_diff_methods.py

@@ -11,12 +11,11 @@
 # Function aliases for testing cases where parameters change the behavior in a big way
 def iterated_first_order(*args, **kwargs): return first_order(*args, **kwargs)
 
+dt = 0.1
 t = np.linspace(0, 3, 31) # sample locations, including the endpoint
 tt = np.linspace(0, 3) # full domain, for visualizing denser plots
-ttt = np.linspace(0, 3, 201) # for testing jerk_sliding, which requires more points
 np.random.seed(7) # for repeatability of the test, so we don't get random failures
 noise = 0.05*np.random.randn(*t.shape)
-long_noise = 0.05*np.random.randn(*ttt.shape)
 
 # Analytic (function, derivative) pairs on which to test differentiation methods.
 test_funcs_and_derivs = [
@@ -53,7 +52,7 @@ def iterated_first_order(*args, **kwargs): return first_order(*args, **kwargs)
     (jerk, {'gamma':10}), (jerk, [10]),
     (iterative_velocity, {'num_iterations':5, 'gamma':0.05}), (iterative_velocity, [5, 0.05]),
     (smooth_acceleration, {'gamma':2, 'window_size':5}), (smooth_acceleration, [2, 5]),
-    (jerk_sliding, {'gamma':1e2, 'solver':'CLARABEL'}), (jerk_sliding, [1e2], {'solver':'CLARABEL'})
+    (jerk_sliding, {'gamma':1, 'window_size':15}), (jerk_sliding, [1], {'window_size':15})
     ]
 
 # All the testing methodology follows the exact same pattern; the only thing that changes is the
@@ -186,11 +185,11 @@ def iterated_first_order(*args, **kwargs): return first_order(*args, **kwargs)
                           [(0, 0), (1, 0), (0, -1), (1, 0)],
                           [(1, 1), (2, 2), (1, 1), (2, 2)],
                           [(1, 1), (3, 3), (1, 1), (3, 3)]],
-    jerk_sliding: [[(-13, -14), (-12, -13), (0, -1), (1, 0)],
-                   [(-12, -13), (-12, -12), (0, -1), (0, 0)],
-                   [(-13, -14), (-12, -13), (0, -1), (0, 0)],
-                   [(-1, -2), (0, 0), (0, -1), (1, 0)],
-                   [(0, 0), (2, 1), (0, 0), (2, 1)],
+    jerk_sliding: [[(-15, -15), (-16, -17), (0, -1), (1, 0)],
+                   [(-14, -14), (-14, -14), (0, -1), (0, 0)],
+                   [(-14, -14), (-14, -14), (0, -1), (0, 0)],
+                   [(-1, -1), (0, 0), (0, -1), (0, 0)],
+                   [(0, 0), (2, 2), (0, 0), (2, 2)],
                    [(1, 1), (3, 3), (1, 1), (3, 3)]]
 }
 
@@ -210,16 +209,9 @@ def test_diff_method(diff_method_and_params, test_func_and_deriv, request): # re
         except: warn(f"Cannot import cvxpy, skipping {diff_method} test."); return
 
     # sample the true function and make noisy samples, and sample true derivative
-    if diff_method != jerk_sliding:
-        x = f(t)
-        x_noisy = x + noise
-        dxdt = df(t)
-        dt = t[1] - t[0]
-    else: # different density for jerk_sliding
-        x = f(ttt)
-        x_noisy = x + long_noise
-        dxdt = df(ttt)
-        dt = ttt[1] - ttt[0]
+    x = f(t)
+    x_noisy = x + noise
+    dxdt = df(t)
 
     # differentiate without and with noise, accounting for new and old styles of calling functions
     x_hat, dxdt_hat = diff_method(x, dt, **params) if isinstance(params, dict) \

pynumdiff/total_variation_regularization/_total_variation_regularization.py

@@ -229,7 +229,7 @@ def smooth_acceleration(x, dt, params=None, options=None, gamma=None, window_siz
     return x_hat, dxdt_hat
 
 
-def jerk_sliding(x, dt, params=None, options=None, gamma=None, solver=None):
+def jerk_sliding(x, dt, params=None, options=None, gamma=None, solver=None, window_size=101):
     """Use convex optimization (cvxpy) to solve for the jerk total variation regularized derivative.
 
     :param np.array[float] x: data to differentiate
@@ -239,6 +239,7 @@ def jerk_sliding(x, dt, params=None, options=None, gamma=None, solver=None):
     :param float gamma: the regularization parameter
     :param str solver: the solver CVXPY should use, 'MOSEK', 'CVXOPT', 'CLARABEL', 'ECOS', etc.
                 In testing, 'MOSEK' was the most robust. If not given, fall back to CVXPY's default.
+    :param int window_size: how wide to make the kernel
 
     :return: tuple[np.array, np.array] of\n
              - **x_hat** -- estimated (smoothed) x
@@ -250,12 +251,16 @@ def jerk_sliding(x, dt, params=None, options=None, gamma=None, solver=None):
         gamma = params[0] if isinstance(params, list) else params
         if options != None:
             if 'solver' in options: solver = options['solver']
+            if 'window_size' in options: window_size = options['window_size']
     elif gamma == None:
         raise ValueError("`gamma` must be given.")
 
-    if len(x) <= 100:
-        warn("len(x) <= 1000, calling standard jerk() without sliding")
+    if len(x) < window_size:
+        warn("len(x) <= window_size, calling standard jerk() without sliding")
         return _total_variation_regularized_derivative(x, dt, 3, gamma, solver=solver)
 
-    kernel = np.hstack((np.arange(1, 21)/20, np.ones(60), (np.arange(0, 21)/20)[::-1]))
-    return utility.slide_function(_total_variation_regularized_derivative, x, dt, kernel, 3, gamma, stride=20, solver=solver)
+    ramp = window_size//5
+    kernel = np.hstack((np.arange(1, ramp+1)/ramp, np.ones(window_size - 2*ramp), (np.arange(1, ramp+1)/ramp)[::-1]))
+    return utility.slide_function(_total_variation_regularized_derivative, x, dt, kernel, 3, gamma, stride=ramp, solver=solver)
+
+