regdiff 3.6.1__tar.gz → 3.7__tar.gz

{regdiff-3.6.1 → regdiff-3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: regdiff
-Version: 3.6.1
+Version: 3.7
 Summary: Regularized differentiation of time-series as numpy ndarrays
 Requires-Dist: numpy>=2.5.4
 Requires-Dist: scipy>=1.18.1

{regdiff-3.6.1 → regdiff-3.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "regdiff"
-version = "3.6.1"
+version = "3.7"
 description = "Regularized differentiation of time-series as numpy ndarrays"
 requires-python = ">=3.14"
 dependencies = [

{regdiff-3.6.1 → regdiff-3.7}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "regdiff"
-version = "3.6.1"
+version = "3.7"
 description = "Regularized differentiation of time-series as numpy ndarrays"
 requires-python = ">=3.14"
 dependencies = [

regdiff-3.7/src/regdiff/__init__.py

@@ -0,0 +1 @@
+from .regdiff import matrix_anti_diff, matrix_diff, reg_diff  # noqa: F401

{regdiff-3.6.1 → regdiff-3.7}/src/regdiff/regdiff.py

@@ -4,16 +4,6 @@ import scipy as sp
 
 # NOTE - all matrix/vector operations are called using np.matvel/np.subtract, etc. Only scalars should multiply ndarrays.
 
-
-def finite_diff(x):
-    """take the finite difference of the input vector. Performs no validation.
-    :param np.ndarray(x): data to take the finite difference of -- 1-dimensional array of length n
-
-    :return: diff(x) -- 1 dimensional array of length n-1
-    """
-    return np.subtract(x[1:], x[:-1])
-
-
 def matrix_diff(n, dx=1.0):
     """return the matrix representations of the first-order central finite first difference, first-order central second
     finite difference, and simple finite difference for a specified size and delta x increment.
@@ -80,6 +70,7 @@ def reg_diff(
     delta_cost_tol=1e-6,
     delta_norm_tol=1e-6,
     ep=1e-8,
+    skip_first_deriv=False,
     diag=False,
 ):
     """differentation function that takes a vector of position data and returns the first and second derivatives, evaluated using TV-regularized differentiation.
@@ -87,12 +78,13 @@ def reg_diff(
     :param alpha: the regularization coefficient for the first derivative
     :param alpha2: the regularization coeffiient for the second derivative. If left blank only the first derivative will be calculated.
     :param dx: the time step for the data
-    :param u0: an initial guess for the derivative(s) as an ndarray or list of ndarrays
+    :param u0: an initial guess for the derivative(s) as an ndarray
     :param min_iter: minimal number of iterations to calculate before returning. Default value 5.
     :param max_iter: maximum number of iterations to calculate before returning. Default value is 1000000.
     :param delta_cost_tol: relative delta cost to reach iteratively before returning (applies to both derivatives). Default value is 1e-6.
     :param delta_norm_tol: relative delta norm of step to reach iteratively before returning (applies to both derivatives). Default value is 1e-6.
     :param ep: epsilon to use to smooth the absolute value function. Devault value is 1e-8
+    :param skip_first_deriv: if True, use the value of u0 for the first derivative and do not calculate it
     :param diag: if True, prints diagnostic information during execution. Default False.
 
     :return:    u -- the first derivative
@@ -120,23 +112,25 @@ def reg_diff(
     # bunch of code for handling an input u0
     u = None
     v = None
+    if u0 is None and skip_first_deriv:
+        raise RuntimeError("If first derivative should be skipped, one should be provided")
     if u0 is not None:
-        if isinstance(u0, list):
-            if len(u0) == n:
-                u = np.asarray(u0, copy=True) * dx / data_st_dev
-            elif len(u0) == 2 * n:
-                u = np.asarray(u0[:n], copy=True) * dx / data_st_dev
-                v = np.asarray(u0[n:], copy=True) * (dx**2) / data_st_dev
-            elif len(u0) == 2 and len(u0[0]) == n and len(u0[1]) == n:
-                u = np.asarray(u0[0], copy=True) * dx / data_st_dev
-                v = np.asarray(u0[1], copy=True) * (dx**2) / data_st_dev
-        elif isinstance(u0, np.ndarray):
-            if u0.shape[0] == 2 and u0.shape[1] == n:
-                u = np.asarray(u0[0, :], copy=True) * dx / data_st_dev
-                v = np.asarray(u0[1, :], copy=True) * (dx**2) / data_st_dev
+        if isinstance(u0, np.ndarray):
+            if u0.ndim == 1:
+                if len(u0) == n:
+                    u = u0 * dx / data_st_dev
+                else:
+                    raise ValueError("Expected a first-derivative u0 tensor that is the same size as the data tensor")
+            elif u0.shape[0] == 2 and u0.shape[1] == n:
+                u = u0[0] * dx / data_st_dev
+                v = u0[1] * (dx**2) / data_st_dev
             elif u0.shape[1] == 2 and u0.shape[0] == n:
-                u = np.asarray(u0[:, 0], copy=True) * dx / data_st_dev
-                v = np.asarray(u0[:, 1], copy=True) * (dx**2) / data_st_dev
+                u = u0[:, 0] * dx / data_st_dev
+                v = u0[:, 1] * (dx**2) / data_st_dev
+            else:
+                raise ValueError("Bad u0 tensor size")
+        else:
+            raise ValueError("u0 should be an ndarray")
     if not isinstance(u, np.ndarray):
         u = np.matvec(diff, data)
     if not isinstance(v, np.ndarray) and second_deriv:
@@ -144,43 +138,44 @@ def reg_diff(
 
     # start calculating u
     ofst_1 = data[0]
-    data_comp = data[1:] - ofst_1
-    a_tp_b = np.matvec(a_tp, data_comp)
-    if diag:
-        u_cost = [
-            npl.norm(np.subtract(sp.integrate.cumulative_trapezoid(u), data_comp))
-            + alpha * npl.norm(finite_diff(u), ord=1)
-        ]
-    prev_cost = None
-    for iter in range(max_iter):
-        c = np.reciprocal(np.sqrt(np.power(finite_diff(u), 2) + ep))
-        En = np.diag(c)
-        Ln = np.matmul(np.matmul(d_tp, En), d)
-        gn = np.add(np.subtract(np.matvec(a_tp_a, u), a_tp_b), alpha * np.matvec(Ln, u))
-        Hn = np.add(a_tp_a, alpha * Ln)
-        s = npl.solve(Hn, gn)
-        u = np.subtract(u, s)
-        cost_n = npl.norm(
-            np.subtract(sp.integrate.cumulative_trapezoid(u), data_comp)
-        ) + alpha * npl.norm(finite_diff(u), ord=1)
+    if not skip_first_deriv:
+        data_comp = data[1:] - ofst_1
+        a_tp_b = np.matvec(a_tp, data_comp)
         if diag:
-            print(
-                f"u, iteration {iter + 1}: cost: {cost_n}, relative change: {npl.norm(s) / npl.norm(u)}"
-            )
-            u_cost.append(cost_n)
-        if iter >= min_iter and npl.norm(s) / npl.norm(u) < delta_norm_tol:
-            if diag:
-                print("u, delta norm tolerance reached")
-            break
-        if (
-            prev_cost
-            and iter >= min_iter
-            and (prev_cost - cost_n) / prev_cost < delta_cost_tol
-        ):
+            u_cost = [
+                npl.norm(np.subtract(sp.integrate.cumulative_trapezoid(u), data_comp))
+                + alpha * npl.norm(np.diff(u), ord=1)
+            ]
+        prev_cost = None
+        for iter in range(max_iter):
+            c = np.reciprocal(np.sqrt(np.power(np.diff(u), 2) + ep))
+            En = np.diag(c)
+            Ln = np.matmul(np.matmul(d_tp, En), d)
+            gn = np.add(np.subtract(np.matvec(a_tp_a, u), a_tp_b), alpha * np.matvec(Ln, u))
+            Hn = np.add(a_tp_a, alpha * Ln)
+            s = npl.solve(Hn, gn)
+            u = np.subtract(u, s)
+            cost_n = npl.norm(
+                np.subtract(sp.integrate.cumulative_trapezoid(u), data_comp)
+            ) + alpha * npl.norm(np.diff(u), ord=1)
             if diag:
-                print("u, relative cost tolerance reached")
-            break
-        prev_cost = cost_n
+                print(
+                    f"u, iteration {iter + 1}: cost: {cost_n}, relative change: {npl.norm(s) / npl.norm(u)}"
+                )
+                u_cost.append(cost_n)
+            if iter >= min_iter and npl.norm(s) / npl.norm(u) < delta_norm_tol:
+                if diag:
+                    print("u, delta norm tolerance reached")
+                break
+            if (
+                prev_cost
+                and iter >= min_iter
+                and (prev_cost - cost_n) / prev_cost < delta_cost_tol
+            ):
+                if diag:
+                    print("u, relative cost tolerance reached")
+                break
+            prev_cost = cost_n
 
     if second_deriv:
         ofst_2 = u[0]
@@ -196,11 +191,11 @@ def reg_diff(
                         data_comp,
                     )
                 )
-                + alpha2 * npl.norm(finite_diff(v), ord=1)
+                + alpha2 * npl.norm(np.diff(v), ord=1)
             ]
         prev_cost = None
         for iter in range(max_iter):
-            c = np.reciprocal(np.sqrt(np.power(finite_diff(v), 2) + ep))
+            c = np.reciprocal(np.sqrt(np.power(np.diff(v), 2) + ep))
             En = np.diag(c)
             Ln = np.matmul(np.matmul(d_tp, En), d)
             gn = np.add(
@@ -216,7 +211,7 @@ def reg_diff(
                     ),
                     data_comp,
                 )
-            ) + alpha2 * npl.norm(finite_diff(v), ord=1)
+            ) + alpha2 * npl.norm(np.diff(v), ord=1)
             if diag:
                 print(
                     f"v, iteration {iter + 1}: cost: {cost_n}, relative change: {npl.norm(s) / npl.norm(v)}"
@@ -236,5 +231,10 @@ def reg_diff(
                 break
             prev_cost = cost_n
         v = v * data_st_dev / (dx**2)
-    u = u * data_st_dev / dx
-    return u, v
+    returns = []
+    if not skip_first_deriv:
+        u = u * data_st_dev / dx
+        returns.append(u)
+    if second_deriv:
+        returns.append(v)
+    return (*returns,)

regdiff-3.6.1/src/regdiff/__init__.py

@@ -1 +0,0 @@
-from .regdiff import finite_diff, matrix_anti_diff, matrix_diff, reg_diff  # noqa: F401