changed wording

Author: pavelkomarov

LICENSE.txt

@@ -1,7 +1,8 @@
 The MIT License (MIT)
 
-Copyright (c) 2021
+Copyright (c) 2025
 Floris van Breugel, The University of Nevada, Reno, Mechanical Engineering Department
+Pavel Komarov, Univerity of Washington Electrical and Computer Engineering
 Yuying Liu, The University of Washington Applied Math Department
 
 Permission is hereby granted, free of charge, to any person obtaining a copy

docs/source/LICENSE.rst

@@ -1,12 +1,12 @@
 License
-==============
+=======
 
 The MIT License (MIT)
 
-Copyright (c) 2021
+Copyright (c) 2025
 Floris van Breugel, The University of Nevada, Reno, Mechanical Engineering Department
-Yuying Liu, The University of Washington Applied Math Department
 Pavel Komarov, Univerity of Washington Electrical and Computer Engineering
+Yuying Liu, The University of Washington Applied Math Department
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

docs/source/conf.py

@@ -20,8 +20,8 @@
 # -- Project information -----------------------------------------------------
 
 project = 'PyNumDiff'
-copyright = '2025, Floris van Breugel, Yuying Liu, Pavel Komarov'
-author = 'Floris van Breugel, Yuying Liu, Pavel Komarov'
+copyright = '2025, Floris van Breugel, Pavel Komarov, Yuying Liu'
+author = 'Floris van Breugel, Pavel Komarov, Yuying Liu'
 
 # The full version, including alpha/beta/rc tags
 release = '0.1.2'

docs/source/contact.rst

@@ -4,4 +4,5 @@ Contact
 Feel free to contact the author for any information.
 
 - Floris van Breugel: fvanbreugel@unr.edu
+- Pavel Komarov: pvlkmrv@uw.edu
 - Yuying Liu: liuyuyingufo@gmail.com

pynumdiff/kalman_smooth/_kalman_smooth.py

@@ -8,7 +8,7 @@ def kalman_filter(y, _t, xhat0, P0, A, Q, C, R, B=None, u=None, save_P=True):
 
     :param np.array y: series of measurements, stacked along axis 0.
     :param float or array[float] _t: This function supports variable step size. This parameter is either the constant
-        dt if given as a single float, or sample locations if given as an array of same length as :code:`x`.
+        step size if given as a single float, or sample locations if given as an array of same length as :code:`x`.
     :param np.array xhat0: a priori guess of initial state at the time of the first measurement
     :param np.array P0: a priori guess of state covariance at the time of first measurement (often identity matrix)
     :param np.array A: state transition matrix, in discrete time if constant dt, in continuous time if variable dt
@@ -77,7 +77,7 @@ def rts_smooth(_t, A, xhat_pre, xhat_post, P_pre, P_post, compute_P_smooth=True)
     """Perform Rauch-Tung-Striebel smoothing, using information from forward Kalman filtering.
 
     :param float or array[float] _t: This function supports variable step size. This parameter is either the constant
-        dt if given as a single float, or sample locations if given as an array of same length as the state histories.
+        step size if given as a single float, or sample locations if given as an array of same length as the state histories.
     :param np.array A: state transition matrix, in discrete time if constant dt, in continuous time if variable dt
     :param list[np.array] xhat_pre: a priori estimates of xhat from a kalman_filter forward pass
     :param list[np.array] xhat_post: a posteriori estimates of xhat from a kalman_filter forward pass
@@ -110,7 +110,7 @@ def rtsdiff(x, _t, order, qr_ratio, forwardbackward):
 
     :param np.array[float] x: data series to differentiate
     :param float or array[float] _t: This function supports variable step size. This parameter is either the constant
-        dt if given as a single float, or data locations if given as an array of same length as :code:`x`.
+        step size if given as a single float, or data locations if given as an array of same length as :code:`x`.
     :param int order: which derivative to stabilize in the constant-derivative model
     :param qr_ratio: the process noise level of the divided by the measurement noise level, because,
         per `our analysis <https://github.com/florisvb/PyNumDiff/issues/139>`_, the mean result is

pynumdiff/linear_model/_linear_model.py

@@ -231,16 +231,17 @@ def spectraldiff(x, dt, params=None, options=None, high_freq_cutoff=None, even_e
 
 
 def rbfdiff(x, _t, sigma=1, lmbd=0.01):
-    """Find smoothed function and derivative estimates by fitting noisy data against a radial-basis-function-filled
-    kernel (naively NxN but made sparse by truncating tiny values). This function uses a Gaussian kernel, thereby
-    assuming the signal is generated from a Gaussian process, effectively the same assumption the Kalman filter makes.
-    It can handle variable step size just as easily as uniform step size.
+    """Find smoothed function and derivative estimates by fitting noisy data with radial-basis-functions. Naively,
+    fill a matrix with basis function samples, similar to the implicit inverse problem of spectral methods, but
+    truncate tiny values to make columns sparse. Each basis function "hill" is topped with a "tower" of height
+    :code:`lmbd` to reach noisy data samples, and the final smoothed reconstruction is found by razing these and only
+    keeping the hills.
 
     :param np.array[float] x: data to differentiate
     :param float or array[float] _t: This function supports variable step size. This parameter is either the constant
         :math:`\\Delta t` if given as a single float, or data locations if given as an array of same length as :code:`x`.
-    :param float sigma: controls width of radial basis function
-    :param float lmbd: controls strength of bias toward data
+    :param float sigma: controls width of radial basis functions
+    :param float lmbd: controls smoothness
 
     :return: tuple[np.array, np.array] of\n
              - **x_hat** -- estimated (smoothed) x
@@ -255,10 +256,10 @@ def rbfdiff(x, _t, sigma=1, lmbd=0.01):
     # The below does the approximate equivalent of this code, but sparsely in O(N sigma^2), since the rbf falls off rapidly
     # t_i, t_j = np.meshgrid(t,t)
     # r = t_j - t_i # radius
-    # rbf = np.exp(-(r**2) / (2 * sigma**2)) # radial basis function kernel
+    # rbf = np.exp(-(r**2) / (2 * sigma**2)) # radial basis function kernel, O(N^2) entries
     # drbfdt = -(r / sigma**2) * rbf # derivative of kernel
     # rbf_regularized = rbf + lmbd*np.eye(len(t))
-    # alpha = np.linalg.solve(rbf_regularized, x)
+    # alpha = np.linalg.solve(rbf_regularized, x) # O(N^3)
 
     cutoff = np.sqrt(-2 * sigma**2 * np.log(1e-4))
     rows, cols, vals, dvals = [], [], [], []
@@ -272,9 +273,9 @@ def rbfdiff(x, _t, sigma=1, lmbd=0.01):
             dv = -radius / sigma**2 * v
             rows.append(n); cols.append(j); vals.append(v); dvals.append(dv)
 
-    rbf = sparse.csr_matrix((vals, (rows, cols)), shape=(len(t), len(t))) # Build sparse kernels
+    rbf = sparse.csr_matrix((vals, (rows, cols)), shape=(len(t), len(t))) # Build sparse kernels, O(N sigma) entries
     drbfdt = sparse.csr_matrix((dvals, (rows, cols)), shape=(len(t), len(t)))
-    rbf_regularized = rbf + lmbd*sparse.eye(len(t), format="csr")
-    alpha = sparse.linalg.spsolve(rbf_regularized, x) # solve sparse system
+    rbf_regularized = rbf + lmbd*sparse.eye(len(t), format="csr") # identity matrix gives a little extra height at the centers
+    alpha = sparse.linalg.spsolve(rbf_regularized, x) # solve sparse system targeting the noisy data, O(N sigma^2)
 
-    return rbf @ alpha, drbfdt @ alpha
+    return rbf @ alpha, drbfdt @ alpha # find samples of reconstructions using the smooth bases

pynumdiff/utils/utility.py

@@ -101,7 +101,7 @@ def integrate_dxdt_hat(dxdt_hat, _t):
     """Wrapper for scipy.integrate.cumulative_trapezoid
 
     :param np.array[float] dxdt_hat: estimate derivative of timeseries
-    :param float _t: stepsize if given as a scalar or a vector of sample locations
+    :param float _t: step size if given as a scalar or a vector of sample locations
 
     :return: **x_hat** (np.array[float]) -- integral of dxdt_hat
     """

pyproject.toml

@@ -10,8 +10,8 @@ readme = "README.md"
 license = {text = "MIT"}
 maintainers = [
   {name = "Floris van Breugel", email = "fvanbreugel@unr.edu"},
-  {name = "Yuying Liu", email = "yliu814@uw.edu"},
-  {name = "Pavel Komarov", email = "pvlkmrv@uw.edu"}
+  {name = "Pavel Komarov", email = "pvlkmrv@uw.edu"},
+  {name = "Yuying Liu", email = "yliu814@uw.edu"}
 ]
 keywords = ["derivative", "smoothing", "curve fitting", "optimization", "total variation"]
 classifiers = [