PySDKit 0.4.24__tar.gz → 0.4.26__tar.gz

{pysdkit-0.4.24 → pysdkit-0.4.26}/PKG-INFO

@@ -1,20 +1,47 @@
 Metadata-Version: 2.4
 Name: PySDKit
-Version: 0.4.24
+Version: 0.4.26
 Summary: A Python library for signal decomposition algorithms with a unified interface.
-Home-page: https://github.com/wwhenxuan/PySDKit
-Author: whenxuan, changewam, josefinez, Yuan Feng, Wentong Zhao, JacktheFowler, Deeksha Manjunath
-Author-email: wwhenxuan@gmail.com
+Author: josefinez, Deeksha Manjunath, Yuan Feng, JacktheFowler
+Author-email: Whenxuan Wang <wwhenxuan@gmail.com>, RuiZhe Wang <3133986068@qq.com>, WenTong Zhao <23049200290@stu.xidian.edu.cn>
+Maintainer-email: Whenxuan Wang <wwhenxuan@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2019 Whenxuan Wang
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/wwhenxuan/PySDKit
+Project-URL: Repository, https://github.com/wwhenxuan/PySDKit
+Project-URL: Issues, https://github.com/wwhenxuan/PySDKit/issues
 Keywords: signal decomposition,signal processing,machine learning
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -23,17 +50,7 @@ Requires-Dist: scipy>=1.11.1
 Requires-Dist: matplotlib>=3.7.2
 Requires-Dist: tqdm>=4.66.5
 Requires-Dist: requests>=2.32.3
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: keywords
 Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 # PySDKit: signal decomposition in Python
 

{pysdkit-0.4.24 → pysdkit-0.4.26}/PySDKit.egg-info/PKG-INFO

@@ -1,20 +1,47 @@
 Metadata-Version: 2.4
 Name: PySDKit
-Version: 0.4.24
+Version: 0.4.26
 Summary: A Python library for signal decomposition algorithms with a unified interface.
-Home-page: https://github.com/wwhenxuan/PySDKit
-Author: whenxuan, changewam, josefinez, Yuan Feng, Wentong Zhao, JacktheFowler, Deeksha Manjunath
-Author-email: wwhenxuan@gmail.com
+Author: josefinez, Deeksha Manjunath, Yuan Feng, JacktheFowler
+Author-email: Whenxuan Wang <wwhenxuan@gmail.com>, RuiZhe Wang <3133986068@qq.com>, WenTong Zhao <23049200290@stu.xidian.edu.cn>
+Maintainer-email: Whenxuan Wang <wwhenxuan@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2019 Whenxuan Wang
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/wwhenxuan/PySDKit
+Project-URL: Repository, https://github.com/wwhenxuan/PySDKit
+Project-URL: Issues, https://github.com/wwhenxuan/PySDKit/issues
 Keywords: signal decomposition,signal processing,machine learning
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -23,17 +50,7 @@ Requires-Dist: scipy>=1.11.1
 Requires-Dist: matplotlib>=3.7.2
 Requires-Dist: tqdm>=4.66.5
 Requires-Dist: requests>=2.32.3
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: keywords
 Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 # PySDKit: signal decomposition in Python
 

{pysdkit-0.4.24 → pysdkit-0.4.26}/PySDKit.egg-info/SOURCES.txt

@@ -1,6 +1,6 @@
 LICENSE
 README.md
-setup.py
+pyproject.toml
 PySDKit.egg-info/PKG-INFO
 PySDKit.egg-info/SOURCES.txt
 PySDKit.egg-info/dependency_links.txt
@@ -96,13 +96,15 @@ pysdkit/plot/_plot_images.py
 pysdkit/plot/_plot_imfs.py
 pysdkit/plot/_plot_signal.py
 pysdkit/tests/__init__.py
-pysdkit/tests/test_all.py
+pysdkit/tests/run_all.py
+pysdkit/tests/test_avncmd.py
 pysdkit/tests/test_ceemdan.py
 pysdkit/tests/test_emd.py
 pysdkit/tests/test_ewt.py
 pysdkit/tests/test_faemd.py
 pysdkit/tests/test_faemd2d.py
 pysdkit/tests/test_faemd3d.py
+pysdkit/tests/test_itd.py
 pysdkit/tests/test_lmd.py
 pysdkit/tests/test_moving_decomp.py
 pysdkit/tests/test_rlmd.py

pysdkit-0.4.26/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "PySDKit"
+dynamic = ["version"]
+description = "A Python library for signal decomposition algorithms with a unified interface."
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.8"
+authors = [
+    { name = "Whenxuan Wang", email = "wwhenxuan@gmail.com" },
+    { name = "RuiZhe Wang", email = "3133986068@qq.com" },
+    { name = "josefinez" },
+    { name = "Deeksha Manjunath" },
+    { name = "Yuan Feng" },
+    { name = "WenTong Zhao", email = "23049200290@stu.xidian.edu.cn" },
+    { name = "JacktheFowler" },
+]
+maintainers = [
+    { name = "Whenxuan Wang", email = "wwhenxuan@gmail.com" },
+]
+keywords = [
+    "signal decomposition",
+    "signal processing",
+    "machine learning",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "numpy>=1.24.3",
+    "scipy>=1.11.1",
+    "matplotlib>=3.7.2",
+    "tqdm>=4.66.5",
+    "requests>=2.32.3",
+]
+
+[project.urls]
+Homepage = "https://github.com/wwhenxuan/PySDKit"
+Repository = "https://github.com/wwhenxuan/PySDKit"
+Issues = "https://github.com/wwhenxuan/PySDKit/issues"
+
+[tool.setuptools.dynamic]
+version = { attr = "pysdkit.__version__" }
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["pysdkit*"]
+
+[tool.setuptools.package-data]
+"*" = ["*.txt"]

{pysdkit-0.4.24 → pysdkit-0.4.26}/pysdkit/__init__.py

@@ -2,7 +2,7 @@
 A Python library for signal decomposition algorithms.
 """
 
-__version__ = "0.4.24"
+__version__ = "0.4.26"
 
 # Empirical Mode Decomposition
 from ._emd import EMD
@@ -70,6 +70,9 @@ from ._vncmd import VNCMD
 # Iterative Nonlinear Chirp Mode Decomposition
 from ._vncmd import INCMD
 
+# Adaptive Variational Nonlinear Chirp Mode Decomposition
+from ._vncmd import AVNCMD
+
 # Empirical Wavelet Transform
 from ._ewt import ewt, EWT
 
@@ -91,7 +94,7 @@ from ._emd import HHT
 
 def greet():
     print(
-        """
+        r"""
  ____          ____   ____   _  __ _  _   
 |  _ \  _   _ / ___| |  _ \ | |/ /(_)| |_ 
 | |_) || | | |\___ \ | | | || ' / | || __|
@@ -168,6 +171,7 @@ __all__ = [
     "CVMD2D",
     "VNCMD",
     "INCMD",
+    "AVNCMD",
     "ewt",
     "EWT",
     "JMD",

{pysdkit-0.4.24 → pysdkit-0.4.26}/pysdkit/_emd/emd.py

@@ -9,7 +9,7 @@ Code taken from https://github.com/laszukdawid/PyEMD/blob/master/PyEMD/EMD.py
 import numpy as np
 from numpy import ndarray
 from scipy.interpolate import interp1d
-from typing import Optional, Tuple, Union
+from typing import Optional, Tuple, Union, List
 
 from pysdkit._emd import akima, cubic, pchip, cubic_hermite, cubic_spline_3pts
 from pysdkit._emd import find_extrema_parabol, find_extrema_simple
@@ -231,7 +231,7 @@ class EMD(object):
 
     def extract_max_min_spline(
         self, time: np.ndarray, signal: np.ndarray
-    ) -> Union[list[int], tuple[ndarray, ndarray, ndarray, ndarray]]:
+    ) -> Union[List[int], Tuple[ndarray, ndarray, ndarray, ndarray]]:
         """
         Extracts top and bottom envelopes based on the signal,
         which are constructed based on maxima and minima, respectively.

{pysdkit-0.4.24 → pysdkit-0.4.26}/pysdkit/_emd/hht/hht.py

@@ -7,7 +7,7 @@ Created on 2025/02/06 10:29:05
 import numpy as np
 from matplotlib import pyplot as plt
 
-from typing import Optional, Tuple, Any, Union
+from typing import Optional, Tuple, Any, Union, List
 
 from pysdkit.plot import plot_IMFs, plot_HilbertSpectrum
 from pysdkit.utils import (
@@ -164,7 +164,7 @@ class HHT(object):
         imfs_env: Optional[np.ndarray] = None,
         imfs_freq: Optional[np.ndarray] = None,
         fs: Optional[float] = None,
-        freq_lim: Optional[tuple[float, float]] = None,
+        freq_lim: Optional[Tuple[float, float]] = None,
         freq_res: Optional[float] = None,
         time_scale: int = 1,
     ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
@@ -204,10 +204,10 @@ class HHT(object):
         imfs_env: Optional[np.ndarray] = None,
         imfs_freq: Optional[np.ndarray] = None,
         fs: Optional[float] = None,
-        freq_lim: Optional[tuple[float, float]] = None,
+        freq_lim: Optional[Tuple[float, float]] = None,
         freq_res: Optional[float] = None,
         time_scale: int = 1,
-    ) -> Union[tuple[Union[list[Any], Any], list[Any]], list[Any], Any]:
+    ) -> Union[Tuple[Union[List[Any], Any], List[Any]], List[Any], Any]:
         """
         Obtaining and visualizing the Hilbert spectrum.
 

{pysdkit-0.4.24 → pysdkit-0.4.26}/pysdkit/_faemd/faemd.py

@@ -154,7 +154,7 @@ class FAEMD(object):
         L = len(signal)
 
         # Ensure that the processed signal is always a column vector
-        signal = np.reshape(signal, newshape=[L, 1])
+        signal = np.reshape(signal, [L, 1])
 
         r = int((window_size - 1) / 2)
 
@@ -186,7 +186,7 @@ class FAEMD(object):
         f_signal = y[r:-r]
 
         # Restoring Signal size
-        f_signal = np.reshape(f_signal, newshape=shape)
+        f_signal = np.reshape(f_signal, shape)
 
         return f_signal
 

pysdkit-0.4.26/pysdkit/_itd/itd.py

@@ -0,0 +1,189 @@
+# -*- coding: utf-8 -*-
+"""
+Created on 2025/01/12 12:24:54
+@author: Whenxuan Wang
+@email: wwhenxuan@gmail.com
+"""
+import numpy as np
+
+from scipy.signal import find_peaks
+from scipy.interpolate import interp1d
+
+
+class ITD(object):
+    """
+    ITD: Intrinsic Time-Scale Decomposition
+
+    H=_itd(x); returns the returns proper rotation components(PRC) and residual signal corresponding to the ITD of X
+    Frei, M. G., & Osorio, I. (2007, February).
+    Intrinsic time-scale decomposition: time-frequency-energy analysis and real-time filtering of non-stationary signals.
+    In Proceedings of the Royal Society of London A: Mathematical, Physical and  Engineering Sciences
+    (Vol. 463, No. 2078, pp. 321-342). The Royal Society.
+    MATLAB Link: https://www.mathworks.com/matlabcentral/fileexchange/69380-intrinsic-time-scale-decomposition-itd
+    """
+
+    def __init__(self, N_max: int = 10):
+        self.N_max = N_max
+
+    def __call__(self, signal: np.ndarray) -> np.ndarray:
+        """allow instances to be called like functions"""
+        return self.fit_transform(signal=signal)
+
+    def __str__(self) -> str:
+        """Get the full name and abbreviation of the algorithm"""
+        return "Intrinsic Time-Scale Decomposition (ITD)"
+
+    def stop_iter(self, x, counter, E_x):
+        """Determine whether the ITD iteration should stop.
+
+        :param x: current residual signal
+        :param counter: number of iterations completed
+        :param E_x: energy of the original input signal
+        :return: True if decomposition should stop
+        """
+        if counter > self.N_max:
+            return True
+
+        Exx = np.sum(x**2)
+        if Exx <= 0.01 * E_x:
+            return True
+
+        pks1, _ = find_peaks(x)
+        pks2, _ = find_peaks(-x)
+        pks = np.union1d(pks1, pks2)
+
+        if len(pks) <= 7:
+            return True
+
+        return False
+
+    @staticmethod
+    def itd_baseline_extract(x):
+        """
+        Calculate the baseline L of the signal x using the ITD algorithm.
+
+        The baseline is constructed by computing control points (LK) at each
+        extremum as a weighted average (alpha=0.5) of the signal value and the
+        interpolated opposite envelope, then piecewise-linearly interpolating
+        between consecutive extrema using signal-value-based slopes.
+
+        :param x: input 1D signal array
+        :return: tuple (L, H) where L is the baseline and H = x - L is the
+                 proper rotation component
+        """
+        length = len(x)
+        t = np.arange(length)
+        alpha = 0.5
+
+        idx_max, _ = find_peaks(x)
+        val_max = x[idx_max]
+
+        idx_min, _ = find_peaks(-x)
+        val_min = x[idx_min]
+
+        if len(idx_max) == 0 or len(idx_min) == 0:
+            return x.copy(), np.zeros_like(x)
+
+        idx_cb = np.union1d(idx_max, idx_min)
+
+        # Pad boundary so that idx_max and idx_min span the same index range.
+        # When the first (or last) extremum on one side has no counterpart,
+        # mirror the opposite extremum's position with the signal value there.
+        if idx_max[0] < idx_min[0]:
+            idx_min = np.concatenate(([idx_max[0]], idx_min))
+            val_min = np.concatenate(([x[idx_max[0]]], val_min))
+        elif idx_min[0] < idx_max[0]:
+            idx_max = np.concatenate(([idx_min[0]], idx_max))
+            val_max = np.concatenate(([x[idx_min[0]]], val_max))
+
+        if idx_max[-1] > idx_min[-1]:
+            idx_min = np.concatenate((idx_min, [idx_max[-1]]))
+            val_min = np.concatenate((val_min, [x[idx_max[-1]]]))
+        elif idx_min[-1] > idx_max[-1]:
+            idx_max = np.concatenate((idx_max, [idx_min[-1]]))
+            val_max = np.concatenate((val_max, [x[idx_min[-1]]]))
+
+        Max_line_interp = interp1d(
+            idx_max, val_max, kind="linear", fill_value="extrapolate"
+        )
+        Min_line_interp = interp1d(
+            idx_min, val_min, kind="linear", fill_value="extrapolate"
+        )
+
+        Max_line = Max_line_interp(t)
+        Min_line = Min_line_interp(t)
+
+        # LK control points: weighted average at each extremum
+        LK1_vals = alpha * Max_line[idx_min] + (1 - alpha) * val_min
+        LK2_vals = alpha * Min_line[idx_max] + (1 - alpha) * val_max
+
+        # Build (position, value) pairs and merge
+        LK1_pts = np.column_stack((idx_min, LK1_vals))
+        LK2_pts = np.column_stack((idx_max, LK2_vals))
+        LK = np.vstack((LK1_pts, LK2_pts))
+
+        # Sort by position and remove duplicates at the boundaries
+        order = np.argsort(LK[:, 0])
+        LK = LK[order]
+
+        # Remove the padded boundary duplicates (first and last are mirrors)
+        if len(LK) > 2:
+            LK = LK[1:-1]
+
+        # Clamp to signal boundaries
+        LK = np.vstack(
+            (
+                [0, LK[0, 1]],
+                LK,
+                [length - 1, LK[-1, 1]],
+            )
+        )
+
+        # Compute baseline by piecewise-linear interpolation between extrema
+        idx_Xk = np.concatenate(([0], idx_cb, [length - 1])).astype(int)
+
+        L = np.zeros(length)
+        for i in range(len(idx_Xk) - 1):
+            denom = x[idx_Xk[i + 1]] - x[idx_Xk[i]]
+            kij = (LK[i + 1, 1] - LK[i, 1]) / denom if denom != 0 else 0.0
+            for j in range(idx_Xk[i], idx_Xk[i + 1]):
+                L[j] = LK[i, 1] + kij * (x[j] - x[idx_Xk[i]])
+
+        L[length - 1] = LK[-1, 1]
+
+        H = x - L
+        return L, H
+
+    def fit_transform(self, signal: np.ndarray) -> np.ndarray:
+        """Input x is a 1D numpy signal and return the decomposition results."""
+        H = []
+        E_x = np.sum(signal**2)
+        counter = 0
+
+        while True:
+            counter = counter + 1
+            L1, H1 = self.itd_baseline_extract(signal)
+            H.append(H1)
+            STOP = self.stop_iter(signal, counter, E_x)
+            if STOP is True:
+                H.append(L1)
+                break
+            signal = L1
+
+        H = np.vstack(H)
+
+        return H
+
+
+if __name__ == "__main__":
+    from pysdkit.data import test_univariate_signal
+    from pysdkit.plot import plot_IMFs
+
+    time, signal = test_univariate_signal()
+
+    print(signal.shape)
+
+    itd = ITD()
+    imfs = itd.fit_transform(signal=signal)
+
+    plot_IMFs(signal, IMFs=imfs)

{pysdkit-0.4.24 → pysdkit-0.4.26}/pysdkit/_vncmd/__init__.py

@@ -7,3 +7,5 @@ Created on Sat Mar 8 21:45:02 2024
 from .vncmd import VNCMD
 
 from .incmd import INCMD
+
+from .avncmd import AVNCMD