PySDKit 0.4.44__tar.gz → 0.4.45__tar.gz

{pysdkit-0.4.44 → pysdkit-0.4.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySDKit
-Version: 0.4.44
+Version: 0.4.45
 Summary: A Python library for signal decomposition algorithms with a unified interface.
 Author: Whenxuan Wang, RuiZhe Wang, Rongkun Zhu, Kai Wu, Lei Wang, josefinez, Deeksha Manjunath, Yuan Feng, WenTong Zhao, JacktheFowler
 Maintainer-email: Whenxuan Wang <wwhenxuan@gmail.com>, RuiZhe Wang <3133986068@qq.com>
@@ -51,10 +51,10 @@ Requires-Dist: tqdm>=4.66.5
 Requires-Dist: requests>=2.32.3
 Dynamic: license-file
 
-# PySDKit: signal decomposition in Python
-
 <div align="center">
 
+# PySDKit: signal decomposition in Python
+
 [![PyPI version](https://badge.fury.io/py/PySDKit.svg)](https://pypi.org/project/PySDKit/) 
 ![License](https://img.shields.io/github/license/wwhenxuan/PySDKit)
 [![Python](https://img.shields.io/badge/python-3.8+-blue?logo=python)](https://www.python.org/)
@@ -91,50 +91,57 @@ This project integrates simple signal processing methods, signal decomposition a
 4. Visualize and analyze the original signal and the intrinsic mode functions IMFs obtained by decomposition.
 
 ~~~python
+import numpy as np
 from pysdkit import EMD
-from pysdkit.data import test_emd
 from pysdkit.plot import plot_IMFs
 
-t, signal = test_emd()
+t = np.linspace(0, 1, 1000)
+signal = np.sin(2 * np.pi * 5 * t) + 0.7 * np.sin(2 * np.pi * 25 * t) + 0.45 * np.sin(2 * np.pi * 80 * t)
 
-# create an instance for signal decomposition
 emd = EMD()
-# implement signal decomposition
-IMFs = emd.fit_transform(signal, max_imfs=2)
-plot_IMFs(signal, IMFs)
+IMFs = emd.fit_transform(signal, max_imfs=3)
+plot_IMFs(signal, IMFs, view="2d_freq", fs=1000, freq_max=150)
 ~~~
 
-![example](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/example.jpg)
+![example](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/decomposition_demo.jpg)
 
 The EMD in the above example is the most classic [`empirical mode decomposition`](https://www.mathworks.com/help/signal/ref/emd.html) algorithm in signal decomposition. For more complex signals, you can try other algorithms such as variational mode decomposition ([`VMD`](https://ieeexplore.ieee.org/abstract/document/6655981)).
 
 ~~~python
-import numpy as np
 from pysdkit import VMD
+from pysdkit.data import test_vmd
+from pysdkit.plot import plot_IMFs
 
-# load new signal
-signal = np.load("./example/example.npy")
-
-# use variational mode decomposition
-vmd = VMD(alpha=500, K=3, tau=0.0, tol=1e-9)
-IMFs = vmd.fit_transform(signal=signal)
-print(IMFs.shape)
+t, signal, fs = test_vmd()
 
-vmd.plot_IMFs(save_figure=True)
+vmd = VMD(alpha=2000, K=4, tau=0.0, tol=1e-7)
+IMFs = vmd.fit_transform(signal)
+plot_IMFs(signal, IMFs, view="2d_freq", fs=fs, freq_max=fs / 2)
 ~~~
 
 ![vmd_example](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/vmd_example.jpg)
 
-Better observe the characteristics of the decomposed intrinsic mode function in the frequency domain.
+For multichannel recordings, algorithms such as multivariate VMD ([`MVMD`](https://doi.org/10.1109/TSP.2019.2951223)) keep shared oscillations **mode-aligned** across channels:
 
 ~~~python
-from pysdkit.plot import plot_IMFs_amplitude_spectra
+import numpy as np
+from pysdkit import MVMD
+from pysdkit.plot import plot_IMFs
 
-# frequency domain visualization
-plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
+t = np.arange(0, 1, 0.001)
+# ch1: 2+36 Hz, ch2: 24+36 Hz, ch3: 80+36 Hz (36 Hz shared)
+signal = np.vstack([
+    np.cos(2*np.pi*2*t) + np.cos(2*np.pi*36*t),
+    np.cos(2*np.pi*24*t) + np.cos(2*np.pi*36*t),
+    np.cos(2*np.pi*80*t) + np.cos(2*np.pi*36*t),
+])
+
+mvmd = MVMD(alpha=2000, K=4, tau=0.0, init="uniform")
+IMFs = mvmd.fit_transform(signal)   # shape: (K, T, C)
+plot_IMFs(signal, IMFs)             # per-channel panels
 ~~~
 
-![frequency_example](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/frequency_example.jpg)
+![mvmd_example](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/mvmd_example.jpg)
 
 ## Target 🎯 <a id="Target"></a>
 

{pysdkit-0.4.44 → pysdkit-0.4.45}/PySDKit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySDKit
-Version: 0.4.44
+Version: 0.4.45
 Summary: A Python library for signal decomposition algorithms with a unified interface.
 Author: Whenxuan Wang, RuiZhe Wang, Rongkun Zhu, Kai Wu, Lei Wang, josefinez, Deeksha Manjunath, Yuan Feng, WenTong Zhao, JacktheFowler
 Maintainer-email: Whenxuan Wang <wwhenxuan@gmail.com>, RuiZhe Wang <3133986068@qq.com>
@@ -51,10 +51,10 @@ Requires-Dist: tqdm>=4.66.5
 Requires-Dist: requests>=2.32.3
 Dynamic: license-file
 
-# PySDKit: signal decomposition in Python
-
 <div align="center">
 
+# PySDKit: signal decomposition in Python
+
 [![PyPI version](https://badge.fury.io/py/PySDKit.svg)](https://pypi.org/project/PySDKit/) 
 ![License](https://img.shields.io/github/license/wwhenxuan/PySDKit)
 [![Python](https://img.shields.io/badge/python-3.8+-blue?logo=python)](https://www.python.org/)
@@ -91,50 +91,57 @@ This project integrates simple signal processing methods, signal decomposition a
 4. Visualize and analyze the original signal and the intrinsic mode functions IMFs obtained by decomposition.
 
 ~~~python
+import numpy as np
 from pysdkit import EMD
-from pysdkit.data import test_emd
 from pysdkit.plot import plot_IMFs
 
-t, signal = test_emd()
+t = np.linspace(0, 1, 1000)
+signal = np.sin(2 * np.pi * 5 * t) + 0.7 * np.sin(2 * np.pi * 25 * t) + 0.45 * np.sin(2 * np.pi * 80 * t)
 
-# create an instance for signal decomposition
 emd = EMD()
-# implement signal decomposition
-IMFs = emd.fit_transform(signal, max_imfs=2)
-plot_IMFs(signal, IMFs)
+IMFs = emd.fit_transform(signal, max_imfs=3)
+plot_IMFs(signal, IMFs, view="2d_freq", fs=1000, freq_max=150)
 ~~~
 
-![example](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/example.jpg)
+![example](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/decomposition_demo.jpg)
 
 The EMD in the above example is the most classic [`empirical mode decomposition`](https://www.mathworks.com/help/signal/ref/emd.html) algorithm in signal decomposition. For more complex signals, you can try other algorithms such as variational mode decomposition ([`VMD`](https://ieeexplore.ieee.org/abstract/document/6655981)).
 
 ~~~python
-import numpy as np
 from pysdkit import VMD
+from pysdkit.data import test_vmd
+from pysdkit.plot import plot_IMFs
 
-# load new signal
-signal = np.load("./example/example.npy")
-
-# use variational mode decomposition
-vmd = VMD(alpha=500, K=3, tau=0.0, tol=1e-9)
-IMFs = vmd.fit_transform(signal=signal)
-print(IMFs.shape)
+t, signal, fs = test_vmd()
 
-vmd.plot_IMFs(save_figure=True)
+vmd = VMD(alpha=2000, K=4, tau=0.0, tol=1e-7)
+IMFs = vmd.fit_transform(signal)
+plot_IMFs(signal, IMFs, view="2d_freq", fs=fs, freq_max=fs / 2)
 ~~~
 
 ![vmd_example](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/vmd_example.jpg)
 
-Better observe the characteristics of the decomposed intrinsic mode function in the frequency domain.
+For multichannel recordings, algorithms such as multivariate VMD ([`MVMD`](https://doi.org/10.1109/TSP.2019.2951223)) keep shared oscillations **mode-aligned** across channels:
 
 ~~~python
-from pysdkit.plot import plot_IMFs_amplitude_spectra
+import numpy as np
+from pysdkit import MVMD
+from pysdkit.plot import plot_IMFs
 
-# frequency domain visualization
-plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
+t = np.arange(0, 1, 0.001)
+# ch1: 2+36 Hz, ch2: 24+36 Hz, ch3: 80+36 Hz (36 Hz shared)
+signal = np.vstack([
+    np.cos(2*np.pi*2*t) + np.cos(2*np.pi*36*t),
+    np.cos(2*np.pi*24*t) + np.cos(2*np.pi*36*t),
+    np.cos(2*np.pi*80*t) + np.cos(2*np.pi*36*t),
+])
+
+mvmd = MVMD(alpha=2000, K=4, tau=0.0, init="uniform")
+IMFs = mvmd.fit_transform(signal)   # shape: (K, T, C)
+plot_IMFs(signal, IMFs)             # per-channel panels
 ~~~
 
-![frequency_example](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/frequency_example.jpg)
+![mvmd_example](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/mvmd_example.jpg)
 
 ## Target 🎯 <a id="Target"></a>
 

{pysdkit-0.4.44 → pysdkit-0.4.45}/PySDKit.egg-info/SOURCES.txt

@@ -97,6 +97,7 @@ pysdkit/data/_test_univariate.py
 pysdkit/data/_time_series.py
 pysdkit/data/fmd_demo.npy
 pysdkit/data/texture.txt
+pysdkit/data/vmd_example.npy
 pysdkit/entropy/__init__.py
 pysdkit/entropy/_approxiamte_entropy.py
 pysdkit/entropy/_permutation_entropy.py

{pysdkit-0.4.44 → pysdkit-0.4.45}/README.md

@@ -1,7 +1,7 @@
-# PySDKit: signal decomposition in Python
-
 <div align="center">
 
+# PySDKit: signal decomposition in Python
+
 [![PyPI version](https://badge.fury.io/py/PySDKit.svg)](https://pypi.org/project/PySDKit/) 
 ![License](https://img.shields.io/github/license/wwhenxuan/PySDKit)
 [![Python](https://img.shields.io/badge/python-3.8+-blue?logo=python)](https://www.python.org/)
@@ -38,50 +38,57 @@ This project integrates simple signal processing methods, signal decomposition a
 4. Visualize and analyze the original signal and the intrinsic mode functions IMFs obtained by decomposition.
 
 ~~~python
+import numpy as np
 from pysdkit import EMD
-from pysdkit.data import test_emd
 from pysdkit.plot import plot_IMFs
 
-t, signal = test_emd()
+t = np.linspace(0, 1, 1000)
+signal = np.sin(2 * np.pi * 5 * t) + 0.7 * np.sin(2 * np.pi * 25 * t) + 0.45 * np.sin(2 * np.pi * 80 * t)
 
-# create an instance for signal decomposition
 emd = EMD()
-# implement signal decomposition
-IMFs = emd.fit_transform(signal, max_imfs=2)
-plot_IMFs(signal, IMFs)
+IMFs = emd.fit_transform(signal, max_imfs=3)
+plot_IMFs(signal, IMFs, view="2d_freq", fs=1000, freq_max=150)
 ~~~
 
-![example](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/example.jpg)
+![example](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/decomposition_demo.jpg)
 
 The EMD in the above example is the most classic [`empirical mode decomposition`](https://www.mathworks.com/help/signal/ref/emd.html) algorithm in signal decomposition. For more complex signals, you can try other algorithms such as variational mode decomposition ([`VMD`](https://ieeexplore.ieee.org/abstract/document/6655981)).
 
 ~~~python
-import numpy as np
 from pysdkit import VMD
+from pysdkit.data import test_vmd
+from pysdkit.plot import plot_IMFs
 
-# load new signal
-signal = np.load("./example/example.npy")
-
-# use variational mode decomposition
-vmd = VMD(alpha=500, K=3, tau=0.0, tol=1e-9)
-IMFs = vmd.fit_transform(signal=signal)
-print(IMFs.shape)
+t, signal, fs = test_vmd()
 
-vmd.plot_IMFs(save_figure=True)
+vmd = VMD(alpha=2000, K=4, tau=0.0, tol=1e-7)
+IMFs = vmd.fit_transform(signal)
+plot_IMFs(signal, IMFs, view="2d_freq", fs=fs, freq_max=fs / 2)
 ~~~
 
 ![vmd_example](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/vmd_example.jpg)
 
-Better observe the characteristics of the decomposed intrinsic mode function in the frequency domain.
+For multichannel recordings, algorithms such as multivariate VMD ([`MVMD`](https://doi.org/10.1109/TSP.2019.2951223)) keep shared oscillations **mode-aligned** across channels:
 
 ~~~python
-from pysdkit.plot import plot_IMFs_amplitude_spectra
+import numpy as np
+from pysdkit import MVMD
+from pysdkit.plot import plot_IMFs
 
-# frequency domain visualization
-plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
+t = np.arange(0, 1, 0.001)
+# ch1: 2+36 Hz, ch2: 24+36 Hz, ch3: 80+36 Hz (36 Hz shared)
+signal = np.vstack([
+    np.cos(2*np.pi*2*t) + np.cos(2*np.pi*36*t),
+    np.cos(2*np.pi*24*t) + np.cos(2*np.pi*36*t),
+    np.cos(2*np.pi*80*t) + np.cos(2*np.pi*36*t),
+])
+
+mvmd = MVMD(alpha=2000, K=4, tau=0.0, init="uniform")
+IMFs = mvmd.fit_transform(signal)   # shape: (K, T, C)
+plot_IMFs(signal, IMFs)             # per-channel panels
 ~~~
 
-![frequency_example](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/frequency_example.jpg)
+![mvmd_example](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/mvmd_example.jpg)
 
 ## Target 🎯 <a id="Target"></a>
 

{pysdkit-0.4.44 → pysdkit-0.4.45}/pysdkit/__init__.py

@@ -2,7 +2,7 @@
 A Python library for signal decomposition algorithms.
 """
 
-__version__ = "0.4.44"
+__version__ = "0.4.45"
 
 # Empirical Mode Decomposition
 from ._emd import EMD

{pysdkit-0.4.44 → pysdkit-0.4.45}/pysdkit/_vmd/vmd_c.py

@@ -14,8 +14,8 @@ class VMD(Base):
     """
     Variational mode decomposition, object-oriented interface.
 
-    Original paper: Dragomiretskiy, K. and Zosso, D. (2014) ‘Variational Mode Decomposition’,
-    IEEE Transactions on Signal Processing, 62(3), pp. 531–544. doi: 10.1109/TSP.2013.2288675.
+    Original paper: Dragomiretskiy, K. and Zosso, D. (2014) "Variational Mode Decomposition",
+    IEEE Transactions on Signal Processing, 62(3), pp. 531-544. doi: 10.1109/TSP.2013.2288675.
 
     The goal of VMD is to decompose the input signal into a series of modes with sparse characteristics.
     The sparse characteristics here refer to the fact that all modes are narrowband signals concentrated near their respective center frequencies.
@@ -50,6 +50,7 @@ class VMD(Base):
         DC: bool = False,
         max_iter: int = 500,
         tol: float = 1e-6,
+        store_history: bool = True,
     ) -> None:
         """
         :param alpha: the balancing parameter of the data-fidelity constraint
@@ -61,6 +62,12 @@ class VMD(Base):
         :param DC: true if the first mode is put and kept at DC (0-freq)
         :param max_iter: Maximum number of iterations
         :param tol: tolerance of convergence criterion; typically around 1e-6
+        :param store_history: If True (default), keep spectral iterates for every
+            ADMM step with shape ``(max_iter, T, K)``. If False, keep only the
+            previous / current spectral buffers (``O(T * K)`` memory). Use
+            ``store_history=False`` for long signals to avoid large allocations.
+            Center-frequency history ``omega`` is always retained (cheap).
+            Decomposition quality is unchanged; only peak memory differs.
         """
         super().__init__()
         # parameters of VMD signal decomposition algorithm
@@ -71,6 +78,7 @@ class VMD(Base):
         self.DC = DC
         self.max_iter = max_iter
         self.tol = tol
+        self.store_history = bool(store_history)
 
         # The last input original signal
         self.signal = None
@@ -109,18 +117,22 @@ class VMD(Base):
     def plot_IMFs(
         self,
         max_imf: int = -1,
+        view: str = "2d",
         colors: Optional[List] = None,
         save_figure: bool = False,
         return_figure: bool = False,
-        dpi: int = 500,
+        dpi: int = 256,
         spine_width: float = 2,
         labelpad: float = 10,
         save_name: Optional[str] = None,
+        fs: Optional[float] = None,
+        freq_max: Optional[float] = None,
     ) -> None:
         """
         An easy way to visualize signal decomposition results
 
         :param max_imf: The number of decomposition modes to be plotted
+        :param view: ``\"2d\"`` / ``\"3d\"`` / ``\"2d_freq\"``
         :param colors: List of color strings for plotting
         :param save_figure: Whether to save the figure as an image
         :param return_figure: Whether to return the figure object
@@ -128,13 +140,17 @@ class VMD(Base):
         :param spine_width: The width of the visible axes spines
         :param labelpad: Controls the filling distance of the y-axis coordinate
         :param save_name: The name of the saved image file
+        :param fs: sampling frequency for ``view=\"2d_freq\"``
+        :param freq_max: spectrum x-limit for ``view=\"2d_freq\"``
+
         :return: The figure object for the plot
         """
         if self.u is not None and self.signal is not None:
-            plot_IMFs(
+            return plot_IMFs(
                 signal=self.signal,
                 IMFs=self.u,
                 max_imfs=max_imf,
+                view=view,
                 colors=colors,
                 save_figure=save_figure,
                 return_figure=return_figure,
@@ -142,6 +158,8 @@ class VMD(Base):
                 spine_width=spine_width,
                 labelpad=labelpad,
                 save_name=save_name,
+                fs=fs,
+                freq_max=freq_max,
             )
         else:
             raise ValueError
@@ -182,70 +200,118 @@ class VMD(Base):
 
         # For future generalizations: individual alpha for each mode
         alpha = np.ones(self.K) * self.alpha
-        # matrix keeping track of every iterant // could be discarded for mem
-        u_hat_plus = np.zeros([self.max_iter, len(freqs), self.K], dtype=complex)
-        # Initialization of omega_k
+        # Initialization of omega_k (always keep full history; it is cheap)
         omega_plus = self.__init_omega(fs=fs)
         if self.DC:
             omega_plus[0, 0] = 0
-        # start with empty dual variables
-        lambda_hat = np.zeros(shape=[self.max_iter, len(freqs)], dtype=complex)
 
         sum_uk = 0  # accumulator
         convergence = (
             np.spacing(1) + self.tol
         )  # Determine whether the algorithm converges
+        n = 0
 
-        # Main loop for iterative updates
-        for n in range(0, self.max_iter - 1):
-            # update spectrum of first mode through Wiener filter of residuals
-            sum_uk = u_hat_plus[n, :, self.K - 1] + sum_uk - u_hat_plus[n, :, 0]
-            u_hat_plus[n + 1, :, 0] = (f_hat_plus - sum_uk - lambda_hat[n, :] / 2) / (
-                1.0 + alpha[0] * (freqs - omega_plus[n, 0]) ** 2
-            )
+        if self.store_history:
+            # Full spectral history: O(max_iter * T * K) memory
+            u_hat_plus = np.zeros([self.max_iter, len(freqs), self.K], dtype=complex)
+            lambda_hat = np.zeros(shape=[self.max_iter, len(freqs)], dtype=complex)
 
-            # update first omega if not held at 0
-            if not self.DC:
-                omega_plus[n + 1, 0] = np.dot(
-                    freqs[T // 2 : T], (abs(u_hat_plus[n + 1, T // 2 : T, 0]) ** 2)
-                ) / np.sum(abs(u_hat_plus[n + 1, T // 2 : T, 0]) ** 2)
-
-            # update of any other mode
-            for k in range(1, self.K):
-                # mode spectrum
-                sum_uk = u_hat_plus[n + 1, :, k - 1] + sum_uk - u_hat_plus[n, :, k]
-                u_hat_plus[n + 1, :, k] = (
+            for n in range(0, self.max_iter - 1):
+                sum_uk = u_hat_plus[n, :, self.K - 1] + sum_uk - u_hat_plus[n, :, 0]
+                u_hat_plus[n + 1, :, 0] = (
                     f_hat_plus - sum_uk - lambda_hat[n, :] / 2
-                ) / (1 + alpha[k] * (freqs - omega_plus[n, k]) ** 2)
-                # center frequencies
-                omega_plus[n + 1, k] = np.dot(
-                    freqs[T // 2 : T], (abs(u_hat_plus[n + 1, T // 2 : T, k]) ** 2)
-                ) / np.sum(abs(u_hat_plus[n + 1, T // 2 : T, k]) ** 2)
-
-            # Update Lagrange multipliers
-            lambda_hat[n + 1, :] = lambda_hat[n, :] + self.tau * (
-                np.sum(u_hat_plus[n + 1, :, :], axis=1) - f_hat_plus
-            )
+                ) / (1.0 + alpha[0] * (freqs - omega_plus[n, 0]) ** 2)
+
+                if not self.DC:
+                    omega_plus[n + 1, 0] = np.dot(
+                        freqs[T // 2 : T],
+                        (abs(u_hat_plus[n + 1, T // 2 : T, 0]) ** 2),
+                    ) / np.sum(abs(u_hat_plus[n + 1, T // 2 : T, 0]) ** 2)
+
+                for k in range(1, self.K):
+                    sum_uk = u_hat_plus[n + 1, :, k - 1] + sum_uk - u_hat_plus[n, :, k]
+                    u_hat_plus[n + 1, :, k] = (
+                        f_hat_plus - sum_uk - lambda_hat[n, :] / 2
+                    ) / (1 + alpha[k] * (freqs - omega_plus[n, k]) ** 2)
+                    omega_plus[n + 1, k] = np.dot(
+                        freqs[T // 2 : T],
+                        (abs(u_hat_plus[n + 1, T // 2 : T, k]) ** 2),
+                    ) / np.sum(abs(u_hat_plus[n + 1, T // 2 : T, k]) ** 2)
+
+                lambda_hat[n + 1, :] = lambda_hat[n, :] + self.tau * (
+                    np.sum(u_hat_plus[n + 1, :, :], axis=1) - f_hat_plus
+                )
 
-            # Determine whether the algorithm has converged
-            for i in range(self.K):
-                convergence = convergence + (1 / T) * np.dot(
-                    (u_hat_plus[n, :, i] - u_hat_plus[n - 1, :, i]),
-                    np.conj((u_hat_plus[n, :, i] - u_hat_plus[n - 1, :, i])),
+                for i in range(self.K):
+                    convergence = convergence + (1 / T) * np.dot(
+                        (u_hat_plus[n, :, i] - u_hat_plus[n - 1, :, i]),
+                        np.conj((u_hat_plus[n, :, i] - u_hat_plus[n - 1, :, i])),
+                    )
+                convergence = np.abs(convergence)
+                if convergence <= self.tol:
+                    break
+
+            niter = np.min([self.max_iter, n])
+            omega = omega_plus[:niter, :]
+            u_spec = u_hat_plus[niter - 1]
+
+        else:
+            # Low-memory path: only previous / current spectral buffers
+            # Memory: O(T * K) instead of O(max_iter * T * K)
+            u_old = np.zeros([len(freqs), self.K], dtype=complex)
+            u_new = np.zeros([len(freqs), self.K], dtype=complex)
+            lambda_hat = np.zeros(len(freqs), dtype=complex)
+            u_spec = u_old
+
+            for n in range(0, self.max_iter - 1):
+                sum_uk = u_old[:, self.K - 1] + sum_uk - u_old[:, 0]
+                u_new[:, 0] = (f_hat_plus - sum_uk - lambda_hat / 2) / (
+                    1.0 + alpha[0] * (freqs - omega_plus[n, 0]) ** 2
+                )
+
+                if not self.DC:
+                    omega_plus[n + 1, 0] = np.dot(
+                        freqs[T // 2 : T],
+                        (abs(u_new[T // 2 : T, 0]) ** 2),
+                    ) / np.sum(abs(u_new[T // 2 : T, 0]) ** 2)
+
+                for k in range(1, self.K):
+                    sum_uk = u_new[:, k - 1] + sum_uk - u_old[:, k]
+                    u_new[:, k] = (f_hat_plus - sum_uk - lambda_hat / 2) / (
+                        1 + alpha[k] * (freqs - omega_plus[n, k]) ** 2
+                    )
+                    omega_plus[n + 1, k] = np.dot(
+                        freqs[T // 2 : T],
+                        (abs(u_new[T // 2 : T, k]) ** 2),
+                    ) / np.sum(abs(u_new[T // 2 : T, k]) ** 2)
+
+                lambda_hat = lambda_hat + self.tau * (
+                    np.sum(u_new, axis=1) - f_hat_plus
                 )
-            convergence = np.abs(convergence)
-            if convergence <= self.tol:
-                break
 
-        # discard empty space if converged early
-        niter = np.min([self.max_iter, n])
-        omega = omega_plus[:niter, :]
+                # Per-iteration residual between consecutive spectral iterates
+                convergence = np.spacing(1)
+                for i in range(self.K):
+                    delta = u_new[:, i] - u_old[:, i]
+                    convergence = convergence + (1 / T) * np.dot(delta, np.conj(delta))
+                convergence = np.abs(convergence)
+                u_spec = u_new
+
+                if convergence <= self.tol:
+                    break
+
+                # Roll buffers for the next iteration
+                u_old, u_new = u_new, u_old
+
+            niter = np.min([self.max_iter, n + 1])
+            omega = omega_plus[:niter, :]
+
         idxs = np.flip(np.arange(1, T // 2 + 1), axis=0)
 
         # signal reconstruction
         u_hat = np.zeros([T, self.K], dtype=complex)
-        u_hat[T // 2 : T, :] = u_hat_plus[niter - 1, T // 2 : T, :]
-        u_hat[idxs, :] = np.conj(u_hat_plus[niter - 1, T // 2 : T, :])
+        u_hat[T // 2 : T, :] = u_spec[T // 2 : T, :]
+        u_hat[idxs, :] = np.conj(u_spec[T // 2 : T, :])
         u_hat[0, :] = np.conj(u_hat[-1, :])
 
         u = np.zeros([self.K, len(t)])