PySDKit 0.4.17__tar.gz → 0.4.19__tar.gz

{pysdkit-0.4.17 → pysdkit-0.4.19}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: PySDKit
-Version: 0.4.17
+Version: 0.4.19
 Summary: A Python library for signal decomposition algorithms with a unified interface.
 Home-page: https://github.com/wwhenxuan/PySDKit
-Author: whenxuan
+Author: whenxuan, changewam, josefinez
 Author-email: wwhenxuan@gmail.com
 Keywords: signal decomposition,signal processing,machine learning
 Classifier: Development Status :: 3 - Alpha
@@ -32,6 +32,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary

{pysdkit-0.4.17 → pysdkit-0.4.19}/PySDKit.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: PySDKit
-Version: 0.4.17
+Version: 0.4.19
 Summary: A Python library for signal decomposition algorithms with a unified interface.
 Home-page: https://github.com/wwhenxuan/PySDKit
-Author: whenxuan
+Author: whenxuan, changewam, josefinez
 Author-email: wwhenxuan@gmail.com
 Keywords: signal decomposition,signal processing,machine learning
 Classifier: Development Status :: 3 - Alpha
@@ -32,6 +32,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary

{pysdkit-0.4.17 → pysdkit-0.4.19}/PySDKit.egg-info/SOURCES.txt

@@ -22,6 +22,9 @@ pysdkit/_emd2d/__init__.py
 pysdkit/_emd2d/bemd.py
 pysdkit/_emd2d/bmemd.py
 pysdkit/_emd2d/emd2d.py
+pysdkit/_emd/hht/__init__.py
+pysdkit/_emd/hht/frequency.py
+pysdkit/_emd/hht/hht.py
 pysdkit/_esmd/__init__.py
 pysdkit/_esmd/esmd.py
 pysdkit/_ewt/__init__.py
@@ -64,7 +67,7 @@ pysdkit/_vmd2d/__init__.py
 pysdkit/_vmd2d/cvmd2d.py
 pysdkit/_vmd2d/vmd2d.py
 pysdkit/_vncmd/__init__.py
-pysdkit/_vncmd/anvcmd.py
+pysdkit/_vncmd/avncmd.py
 pysdkit/_vncmd/incmd.py
 pysdkit/_vncmd/mncmd.py
 pysdkit/_vncmd/vncmd.py
@@ -79,8 +82,6 @@ pysdkit/entropy/__init__.py
 pysdkit/entropy/_approxiamte_entropy.py
 pysdkit/entropy/_permutation_entropy.py
 pysdkit/entropy/_sample_entropy.py
-pysdkit/hht/__init__.py
-pysdkit/hht/hht.py
 pysdkit/plot/__init__.py
 pysdkit/plot/_fourier_spectra.py
 pysdkit/plot/_functions.py
@@ -98,7 +99,9 @@ pysdkit/tests/test_faemd3d.py
 pysdkit/tests/test_generator_cube.py
 pysdkit/tests/test_generator_image.py
 pysdkit/tests/test_generator_signal.py
+pysdkit/tests/test_lmd.py
 pysdkit/tests/test_moving_decomp.py
+pysdkit/tests/test_rlmd.py
 pysdkit/tests/test_vmd.py
 pysdkit/tests/test_vmd2d.py
 pysdkit/tsa/__init__.py

{pysdkit-0.4.17 → pysdkit-0.4.19}/pysdkit/__init__.py

@@ -2,43 +2,7 @@
 A Python library for signal decomposition algorithms.
 """
 
-__version__ = "0.4.16"
-
-__all__ = [
-    "EMD",
-    "EEMD",
-    "CEEMDAN",
-    "REMD",
-    "MEMD",
-    "TVF_EMD",
-    "EFD",
-    "FAEMD",
-    "EMD2D",
-    "HVD",
-    "ITD",
-    "LMD",
-    "RLMD",
-    "SSA",
-    "vmd",
-    "VMD",
-    "ACMD",
-    "MVMD",
-    "VME",
-    "CVMD2D",
-    "VNCMD",
-    "INCMD",
-    "ewt",
-    "EWT",
-    "JMD",
-    "Moving_Decomp",
-    "data",
-    "entropy",
-    "hht",
-    "plot",
-    "tsa",
-    "utils",
-    "__version__",
-]
+__version__ = "0.4.19"
 
 # Empirical Mode Decomposition
 from ._emd import EMD
@@ -79,16 +43,16 @@ from ._lmd import LMD
 # Robust Local Mean Decomposition
 from ._lmd import RLMD
 
-# Singular Spectral Analysis (SSA) algorithm
+# Singular Spectral Analysis
 from ._ssa import SSA
 
-# Variational mode decomposition
+# Variational Mode Decomposition
 from ._vmd import vmd, VMD
 
 # Adaptive Chirp Mode Decomposition
 from ._vmd import ACMD
 
-# Multivariate Variational mode decomposition
+# Multivariate Variational Mode Decomposition
 from ._vmd import MVMD
 
 # Variational Mode Extraction, to extract a specific mode from the signal
@@ -103,7 +67,7 @@ from ._vmd2d import CVMD2D
 # Variational Nonlinear Chirp Mode Decomposition
 from ._vncmd import VNCMD
 
-# Iterative nonlinear chirp mode decomposition
+# Iterative Nonlinear Chirp Mode Decomposition
 from ._vncmd import INCMD
 
 # Empirical Wavelet Transform
@@ -112,9 +76,12 @@ from ._ewt import ewt, EWT
 # Jump Plus AM-FM Mode Decomposition
 from ._jmd import JMD
 
-# Moving Average decomposition
+# Moving Average Decomposition
 from .tsa import Moving_Decomp
 
+# Hilbert-Huang Transform
+from ._emd import HHT
+
 
 def greet():
     print(
@@ -130,3 +97,80 @@ A Python library for signal decomposition algorithms.
 https://github.com/wwhenxuan/PySDKit
 """
     )
+
+
+def print_functions():
+    """"""
+    print(
+        """
+_______________________________________________________________
+Algorithm Name                                  | Abbreviation
+_______________________________________________________________
+Empirical Mode Decomposition                    |    EMD
+Ensemble Empirical Mode Decomposition           |    EEMD     
+Complete Ensemble EMD with Adaptive Noise       |    CEEMDAN
+Robust Empirical Mode Decomposition             |    REMD
+Multivariate Empirical Mode Decomposition       |    MEMD
+Time Varying Filter based EMD                   |    TVF_EMD
+Empirical Fourier Decomposition                 |    EFD
+Fast and Adaptive Empirical Mode Decomposition  |    FAEMD
+Empirical Mode Decomposition 2D for images      |    EMD2D
+Hilbert Vibration Decomposition                 |    HVD
+Intrinsic Time-Scale Decomposition              |    ITD
+Local Mean Decomposition                        |    LMD
+Robust Local Mean Decomposition                 |    RLMD
+Singular Spectral Analysis                      |    SSA
+Variational Mode Decomposition                  |    VMD
+Multivariate Variational Mode Decomposition     |    MVMD
+Variational Mode Extraction                     |    VME
+Variational Mode Decomposition for 2D Image     |    VMD2D
+Compact VMD for 2D Image                        |    CVMD2D
+Variational Nonlinear Chirp Mode Decomposition  |    VNCMD
+Iterative Nonlinear Chirp Mode Decomposition    |    INCMD
+Empirical Wavelet Transform                     |    EWT
+Jump Plus AM-FM Mode Decomposition              |    JMD
+Moving Average Decomposition                    |    Moving
+Hilbert-Huang Transform                         |    HHT
+_______________________________________________________________
+"""
+    )
+
+
+__all__ = [
+    "EMD",
+    "EEMD",
+    "CEEMDAN",
+    "REMD",
+    "MEMD",
+    "TVF_EMD",
+    "EFD",
+    "FAEMD",
+    "EMD2D",
+    "HVD",
+    "ITD",
+    "LMD",
+    "RLMD",
+    "SSA",
+    "vmd",
+    "VMD",
+    "ACMD",
+    "MVMD",
+    "VME",
+    "VMD2D",
+    "CVMD2D",
+    "VNCMD",
+    "INCMD",
+    "ewt",
+    "EWT",
+    "JMD",
+    "Moving_Decomp",
+    "data",
+    "entropy",
+    "HHT",
+    "plot",
+    "tsa",
+    "utils",
+    "greet",
+    "print_functions",
+    "__version__",
+]

{pysdkit-0.4.17 → pysdkit-0.4.19}/pysdkit/_emd/__init__.py

@@ -23,3 +23,5 @@ from .memd import MEMD
 from .tvf_emd import TVF_EMD
 
 from .efd import EFD
+
+from .hht import HHT

{pysdkit-0.4.17 → pysdkit-0.4.19}/pysdkit/_emd/ceemdan.py

@@ -71,24 +71,24 @@ class CEEMDAN(object):
         :param max_iter: maximum number of decomposition iterations
         :param random_seed: create a random seed for the random number generator
         """
-        # EMD算法的固定配置
+        # Fixed configuration of the EMD algorithm
         self.max_imfs = max_imfs
         self.trials = trials
         self.epsilon = epsilon
         self.max_iter = max_iter
 
-        # 与多进程相关的配置参数
+        # Configuration parameters related to multi-process
         self.parallel = parallel
         self.processes = processes
 
-        # 创建噪声的参数
+        # Parameters for creating noise
         self.noise_scale = noise_scale
         self.noise_kind = noise_kind
         self.noise_list = ["normal", "uniform"]
-        # 是否对分解的噪声进行标准化
+        # Whether to normalize the decomposed noise
         self.beta_progress = beta_progress
 
-        # 与算法停止有关的阈值
+        # Thresholds related to algorithm stopping
         self.range_thr = range_thr
         self.total_power_thr = total_power_thr
 
@@ -99,16 +99,17 @@ class CEEMDAN(object):
             else ext_EMD
         )
 
-        # 创建随机数生成器
+        # Creating a random number generator
+        self.random_seed = random_seed
         self.rng = np.random.RandomState(seed=random_seed)
 
-        # 生成的噪声序列
+        # Generated noise sequence
         self.all_noises = None
 
-        # 存放用于分解的噪声的列表
+        # List of noises to be decomposed
         self.all_noise_EMD = []
 
-        # 记录本次算法分解的结果
+        # Record the results of this algorithm decomposition
         self.imfs = None
         self.residue = None
 
@@ -119,7 +120,7 @@ class CEEMDAN(object):
         self,
         signal: np.ndarray,
         time: Optional[np.ndarray] = None,
-        max_imfs: Optional[int] = -1,
+        max_imfs: Optional[int] = None,
         progress: bool = False,
     ) -> np.ndarray:
         """allow instances to be called like functions"""
@@ -131,7 +132,13 @@ class CEEMDAN(object):
         """Get the full name and abbreviation of the algorithm"""
         return "Complete Ensemble Empirical Mode Decomposition with Adaptive Noise (CEEMDAN)"
 
-    def generate_noise(
+    def update_random_seed(self, random_seed: int) -> None:
+        """Update the random seed for random number generator to generate noise"""
+        self.random_seed = random_seed
+        # Create the random state generate
+        self.rng = np.random.RandomState(seed=random_seed)
+
+    def _generate_noise(
         self, scale: float, size: Union[int, Sequence[int]]
     ) -> np.ndarray:
         """
@@ -177,7 +184,7 @@ class CEEMDAN(object):
         self,
         signal: np.ndarray,
         time: Optional[np.ndarray] = None,
-        max_imfs: Optional[int] = -1,
+        max_imfs: Optional[int] = None,
         progress: Optional[bool] = True,
     ) -> np.ndarray:
         """Perform the specified EEMD algorithm to obtain the corresponding signal decomposition results."""
@@ -231,20 +238,26 @@ class CEEMDAN(object):
         noise = self.epsilon * self.all_noise_EMD[trial][0]
 
         # Return the result of a single EMD execution
-        return self.emd(self._signal + noise, self._time, self.max_imfs)
+        return self._run_emd(self._signal + noise, self._time, self.max_imfs)
 
-    def emd(
+    def _run_emd(
         self,
         signal: np.ndarray,
         time: Optional[np.ndarray] = None,
-        max_imfs: Optional[int] = -1,
+        max_imfs: Optional[int] = None,
     ) -> np.ndarray:
         """
-        Vanilla Empirical Mode Decomposition method
+        Vanilla Empirical Mode Decomposition method.
 
-        Perform the specified EMD algorithm to obtain the corresponding signal decomposition results.
+        :param signal: the input 1D ndarray signal.
+        :param time: the time array.
+        :param max_imfs: the maximum number of IMFs to be decomposed.
+        :return: the decomposed IMFs of the input signal.
         """
-        return self.EMD.fit_transform(signal=signal, time=time, max_imfs=max_imfs)
+        # Perform the specified EMD algorithm to obtain the corresponding signal decomposition results.
+        imfs = self.EMD.fit_transform(signal=signal, time=time, max_imfs=max_imfs)
+
+        return imfs
 
     def get_imfs_and_residue(self) -> Tuple[np.ndarray, np.ndarray]:
         """
@@ -277,6 +290,7 @@ class CEEMDAN(object):
 
         # Get the intrinsic mode function and residual respectively
         imfs, residue = self.get_imfs_and_residue()
+
         if np.allclose(residue, 0):
             return imfs[:-1].copy(), imfs[-1].copy()
         else:
@@ -304,12 +318,13 @@ class CEEMDAN(object):
 
         # Compute the Empirical Mode Decomposition (EMD) for the residue
         R = signal - np.sum(cIMFs, axis=0)
-        _test_imfs = self.emd(signal=R, time=None, max_imfs=1)
-
-        # Check if the residue is an IMF or has no extrema
-        if _test_imfs.shape[0] == 1:
-            print("Not enough extrema")
-            return True
+        # _test_imfs = self._emd(signal=R, time=None, max_imfs=2)
+        # print("test imfs", _test_imfs.shape)
+        #
+        # # Check if the residue is an IMF or has no extrema
+        # if _test_imfs.shape[0] == 1:
+        #     print("Not enough extrema")
+        #     return True
 
         # Check for range threshold
         if np.max(R) - np.min(R) < self.range_thr:
@@ -328,7 +343,7 @@ class CEEMDAN(object):
         self,
         signal: np.ndarray,
         time: Optional[np.ndarray] = None,
-        max_imfs: Optional[int] = -1,
+        max_imfs: Optional[int] = None,
         progress: bool = False,
     ) -> np.ndarray:
         """
@@ -344,11 +359,12 @@ class CEEMDAN(object):
         scale_s = np.std(signal)
         signal = signal / scale_s
 
-        if max_imfs is not None:
-            self.max_imfs = max_imfs
+        # Begin executing the specific decomposition algorithm
+        max_imfs = self.max_imfs if max_imfs is None else max_imfs
+        total = (max_imfs - 1) if max_imfs != -1 else None
 
         # Define the noise sequences to be added
-        self.all_noises = self.generate_noise(
+        self.all_noises = self._generate_noise(
             self.noise_scale, size=(self.trials, signal.size)
         )
 
@@ -357,13 +373,10 @@ class CEEMDAN(object):
 
         # Create the first IMF
         last_imf = self._run_eemd(signal, time, max_imfs=1, progress=progress)[0]
-        res = np.empty(signal.size)
 
         all_cimfs = last_imf.reshape((-1, last_imf.size))
         prev_res = signal - last_imf
 
-        # Begin executing the specific decomposition algorithm
-        total = (max_imfs - 1) if max_imfs != -1 else None
         # Create an iterator object for signal decomposition
         it = (
             iter
@@ -372,8 +385,7 @@ class CEEMDAN(object):
         )
 
         # Begin the algorithm's iteration
-        for _ in it(range(self.max_imfs)):
-
+        for _ in it(range(max_imfs - 1)):
             # Number of IMFs currently decomposed
             imf_number = all_cimfs.shape[0]
 
@@ -385,31 +397,35 @@ class CEEMDAN(object):
                 # Skip if noise[trial] didn't have k'th mode
                 noise_imf = self.all_noise_EMD[trial]
                 res = prev_res.copy()
+
+                # add noise for every imf to be decomposed.
                 if len(noise_imf) > imf_number:
                     res += beta * noise_imf[imf_number]
 
                 # Extract the local mean, which is at the 2nd position
-                imfs = self.emd(res, time, max_imfs=1)
+                imfs = self._run_emd(res, time, max_imfs=1)
                 local_mean += imfs[-1] / self.trials
 
             # Record the results of this decomposition
             last_imf = prev_res - local_mean
+            # vstack the new imf
             all_cimfs = np.vstack((all_cimfs, last_imf))
             prev_res = local_mean.copy()
 
             # Determine whether the decomposition algorithm should stop iterating
-            if self.end_condition(
-                signal=signal, cIMFs=all_cimfs, max_imf=self.max_imfs
-            ):
+            if self.end_condition(signal=signal, cIMFs=all_cimfs, max_imf=max_imfs):
                 # Reached the stopping condition
-                print("End Decomposition")
+                # print("End Decomposition")
                 break
 
         # Clear all IMF noise
+        # The noise will be initialized for the new input signal
         del self.all_noise_EMD[:]
 
         # Record the results of this decomposition
         self.imfs = all_cimfs
+
+        # Calculate the remaining residual components
         self.residue = signal * scale_s - np.sum(self.imfs, axis=0)
 
         return all_cimfs

{pysdkit-0.4.17 → pysdkit-0.4.19}/pysdkit/_emd/efd.py

@@ -89,7 +89,7 @@ class EFD(object):
         imfs = np.zeros(shape=(number, len(signal)))
 
         # The results are stored in the frequency domain
-        ft = np.zeros([number, len(ff)])
+        ft = np.zeros([number, len(ff)], dtype=complex)
 
         # We define an ideal functions and extract components
         for k in range(0, number):

{pysdkit-0.4.17 → pysdkit-0.4.19}/pysdkit/_emd/emd.py

@@ -510,7 +510,8 @@ class EMD(object):
                         if f1 and f2:
                             break
 
-                else:  # Less than 2 ext, i.e. trend
+                else:
+                    # Less than 2 ext, i.e. trend
                     finished = True
                     break
 
@@ -535,3 +536,17 @@ class EMD(object):
             IMF = np.vstack((IMF, self.residue))
 
         return IMF
+
+
+if __name__ == "__main__":
+    from pysdkit.data import test_hht, test_univariate_signal
+    from matplotlib import pyplot as plt
+    from pysdkit.plot import plot_IMFs
+
+    time, signal = test_univariate_signal(case=1)
+    emd = EMD(max_imfs=5)
+    imfs = emd.fit_transform(signal, max_imfs=6)
+    print(imfs.shape)
+
+    plot_IMFs(signal, imfs)
+    plt.show()

{pysdkit-0.4.17/pysdkit → pysdkit-0.4.19/pysdkit/_emd}/hht/__init__.py

@@ -4,3 +4,4 @@ Created on 2025/02/06 10:28:59
 @author: Whenxuan Wang
 @email: wwhenxuan@gmail.com
 """
+from .hht import HHT

pysdkit-0.4.19/pysdkit/_emd/hht/frequency.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+"""
+Created on 2025/02/06 10:30:01
+@author: Whenxuan Wang
+@email: wwhenxuan@gmail.com
+Hilbert-transform for demodulation
+"""
+import numpy as np
+from pysdkit.utils import fft, ifft
+
+
+def hilbert(signal: np.ndarray) -> np.ndarray:
+    """
+    Perform Hilbert transform along the last axis of input signal.
+
+    :param signal: The Hilbert transform is performed along last dimension.
+
+    :return: A complex tensor with the same shape of the input signal, representing its analytic signal.
+    """
+    signal = np.asarray(signal, dtype=np.float64)
+
+    # Get the length of input signal
+    N = signal.shape[-1]
+
+    # Perform a Fast Fourier Transform
+    Xf = fft(signal)
+
+    # Get the spectrum of the analytical signal
+    if N % 2 == 0:
+        Xf[..., 1 : N // 2] *= 2
+        Xf[..., N // 2 + 1 :] = 0
+    else:
+        Xf[..., 1 : (N + 1) // 2] *= 2
+        Xf[..., (N + 1) // 2 :] = 0
+    return ifft(Xf)
+
+
+def get_envelope_frequency(signal: np.ndarray, fs: float, ret_analytic: bool = False):
+    """
+    Compute the envelope and instantaneous frequency function of the given signal using Hilbert transform.
+    The transformation is done along the last axis.
+
+    Parameters:
+    -------------
+    x : array_like
+        Signal data. The last dimension of `x` is considered the temporal dimension.
+    fs : float
+        Sampling frequency in Hz.
+    ret_analytic : bool, optional
+        Whether to return the analytic signal. (Default: False)
+
+    Returns:
+    -------------
+    (envelope, freq)             if `ret_analytic` is False
+    (envelope, freq, analytic)   if `ret_analytic` is True
+
+    envelope : ndarray
+        The envelope function with the same shape as `x`.
+    freq : ndarray
+        The instantaneous frequency function in Hz with the same shape as `x`.
+    analytic : ndarray
+        The analytic (complex) signal with the same shape as `x`.
+    :param signal: Signal data. The last dimension is considered the temporal dimension.
+    :param fs: Sampling frequency in Hz.
+    :param ret_analytic: Whether to return the analytic signal. (Default: False)
+
+    :return: (envelope, freq) if `ret_analytic` is False
+             (envelope, freq, analytic)   if `ret_analytic` is True
+             - envelope : ndarray, the envelope function with the same shape as `x`.
+    freq : ndarray
+        The instantaneous frequency function in Hz with the same shape as `x`.
+    analytic : ndarray
+        The analytic (complex) signal with the same shape as `x`.
+    """
+    signal = np.asarray(signal, dtype=np.float64)
+    analytic = hilbert(signal)  # Scipy's hilbert returns analytic signal
+
+    envelope = np.abs(analytic)
+
+    # Compute sub (discrete derivative with edge extension)
+    sub = np.empty_like(analytic)
+    diff = np.diff(analytic, axis=-1)
+    sub[..., :-1] = diff
+    # Handle last element (repeat last difference)
+    sub[..., -1] = (
+        analytic[..., -1] - analytic[..., -2] if analytic.shape[-1] >= 2 else 0.0
+    )
+
+    # Compute add (discrete sum with edge extension)
+    add = np.empty_like(analytic)
+    summed = analytic[..., 1:] + analytic[..., :-1]
+    add[..., :-1] = summed
+    # Handle last element (2 * last value)
+    add[..., -1] = 2 * analytic[..., -1]
+
+    # Calculate instantaneous frequency (handle division safely)
+    with np.errstate(divide="ignore", invalid="ignore"):
+        freq = 2 * fs * np.imag(sub / add)
+    freq[np.isinf(freq)] = 0  # Replace infs
+    freq /= 2 * np.pi  # Convert to Hz
+
+    if ret_analytic:
+        return envelope, freq, analytic
+    else:
+        return envelope, freq