Modal-Decomposition 0.1.2__tar.gz → 0.1.3__tar.gz

{modal_decomposition-0.1.2 → modal_decomposition-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Modal-Decomposition
-Version: 0.1.2
+Version: 0.1.3
 Summary: a package for modal decomposition
 Author-email: Mao_HaoChuan <2215269365@qq.com>
 License: Apache-2.0
@@ -55,7 +55,7 @@ All entrance of functions or class are stored in `Modal_Decomposition/__init__.p
 | EFD      | Empirical Fourier Decomposition                                             |   `Function.EFD(signal)`    |                                                                                                                        [10.1016/j.ymssp.2021.108155](https://www.sciencedirect.com/science/article/abs/pii/S0888327021005355?via%3Dihub)                                                                                                                        |
 | EMD      | Empirical Mode Decomposition                                                |   `Function.EMD(signal)`    |                                                                                              [10.1098/rspa.1998.0193](https://www.semanticscholar.org/paper/The-empirical-mode-decomposition-and-the-Hilbert-Huang-Shen/3842d81b0375dae8ae92734aa2a5d4aeed7a91d1)                                                                                               |
 | EWT      | Empirical Wavelet Transform                                                 |   `Function.EWT(signal)`    |                                                                                                                                                  [10.48550/arXiv.2304.06274](https://arxiv.org/abs/2304.06274)                                                                                                                                                  |
-| FMD      | Filtered Mode Decomposition                                                 |   `Function.MEMD(signal)`   |                                                                                                                                            [10.1109/TIE.2022.3156156](https://ieeexplore.ieee.org/document/9732251)                                                                                                                                             |
+| FMD      | Filtered Mode Decomposition                                                 |   `Function.FMD(signal)`    |                                                                                                                                            [10.1109/TIE.2022.3156156](https://ieeexplore.ieee.org/document/9732251)                                                                                                                                             |
 | ICEEMDAN | Improved Complete Ensemble Empirical Mode Decomposition with Adaptive Noise | `Function.ICEEMDAN(signal)` |                                                                                                                                [10.1007/s10470-021-01901-3](https://link.springer.com/article/10.1007/s10470-021-01901-3#citeas)                                                                                                                                |
 | LMD      | Local Mean Decomposition                                                    |   `Function.LMD(signal)`    |                                                                                                                                     [10.1098/rsif.2005.0058](https://royalsocietypublishing.org/doi/10.1098/rsif.2005.0058)                                                                                                                                     |
 | MEMD     | Multivariate Empirical Mode Decomposition                                   |   `Function.MEMD(signal)`   |                                                                                                                                                  [10.48550/arXiv.2206.00926](https://arxiv.org/abs/2206.00926)                                                                                                                                                  |
@@ -79,42 +79,18 @@ pip install -r requirements.txt
 pip install Modal-Decomposition
 ```
 
-*Well, some libs should be installed by yourself, don't use `pip install -r requirements.txt`, because `Triton` need installed by GitHub.*
-
-*`Triton` please visite this url: https://github.com/woct0rdho/triton-windows/releases*
-
 ## Dependence
 
 This lib's dependence are:
 
 ***Python: 3.10***
 
-- [antropy](https://github.com/raphaelvallat/antropy)
-- [colorama](https://github.com/tartley/colorama)
-- [einops](https://github.com/arogozhnikov/einops)
 - [EMD-signal](https://github.com/laszukdawid/PyEMD)
 - [ewtpy](https://github.com/vrcarva/ewtpy)
-- [numba](https://github.com/numba/numba)
-- [numpy](https://github.com/numpy/numpy)
-- [scipy](https://github.com/scipy/scipy)
 - [vmdpy](https://github.com/vrcarva/vmdpy)
-- [psutil](https://github.com/giampaolo/psutil)
 
 *Other dependence please read "requirements.txt"*
 
-## Codes Resource
-
-All codes from :
-
-- Github:
-  - EMD-signal -> EMD, CEEFD, CEEMDAN, EEMD
-  - ewtpy -> EWT
-  - vmdpy -> VMD
-
-
-- Myself:
-  - CEEMD, EFD, FMD, ICEEMDAN, LMD, MEMD, RPSEMD, SSA, SVMD
-
 ## Url
 
 This lib's url is: https://github.com/a-raining-day/Modal-Decomposition

{modal_decomposition-0.1.2 → modal_decomposition-0.1.3}/README.md

@@ -23,7 +23,7 @@ All entrance of functions or class are stored in `Modal_Decomposition/__init__.p
 | EFD      | Empirical Fourier Decomposition                                             |   `Function.EFD(signal)`    |                                                                                                                        [10.1016/j.ymssp.2021.108155](https://www.sciencedirect.com/science/article/abs/pii/S0888327021005355?via%3Dihub)                                                                                                                        |
 | EMD      | Empirical Mode Decomposition                                                |   `Function.EMD(signal)`    |                                                                                              [10.1098/rspa.1998.0193](https://www.semanticscholar.org/paper/The-empirical-mode-decomposition-and-the-Hilbert-Huang-Shen/3842d81b0375dae8ae92734aa2a5d4aeed7a91d1)                                                                                               |
 | EWT      | Empirical Wavelet Transform                                                 |   `Function.EWT(signal)`    |                                                                                                                                                  [10.48550/arXiv.2304.06274](https://arxiv.org/abs/2304.06274)                                                                                                                                                  |
-| FMD      | Filtered Mode Decomposition                                                 |   `Function.MEMD(signal)`   |                                                                                                                                            [10.1109/TIE.2022.3156156](https://ieeexplore.ieee.org/document/9732251)                                                                                                                                             |
+| FMD      | Filtered Mode Decomposition                                                 |   `Function.FMD(signal)`    |                                                                                                                                            [10.1109/TIE.2022.3156156](https://ieeexplore.ieee.org/document/9732251)                                                                                                                                             |
 | ICEEMDAN | Improved Complete Ensemble Empirical Mode Decomposition with Adaptive Noise | `Function.ICEEMDAN(signal)` |                                                                                                                                [10.1007/s10470-021-01901-3](https://link.springer.com/article/10.1007/s10470-021-01901-3#citeas)                                                                                                                                |
 | LMD      | Local Mean Decomposition                                                    |   `Function.LMD(signal)`    |                                                                                                                                     [10.1098/rsif.2005.0058](https://royalsocietypublishing.org/doi/10.1098/rsif.2005.0058)                                                                                                                                     |
 | MEMD     | Multivariate Empirical Mode Decomposition                                   |   `Function.MEMD(signal)`   |                                                                                                                                                  [10.48550/arXiv.2206.00926](https://arxiv.org/abs/2206.00926)                                                                                                                                                  |
@@ -47,42 +47,18 @@ pip install -r requirements.txt
 pip install Modal-Decomposition
 ```
 
-*Well, some libs should be installed by yourself, don't use `pip install -r requirements.txt`, because `Triton` need installed by GitHub.*
-
-*`Triton` please visite this url: https://github.com/woct0rdho/triton-windows/releases*
-
 ## Dependence
 
 This lib's dependence are:
 
 ***Python: 3.10***
 
-- [antropy](https://github.com/raphaelvallat/antropy)
-- [colorama](https://github.com/tartley/colorama)
-- [einops](https://github.com/arogozhnikov/einops)
 - [EMD-signal](https://github.com/laszukdawid/PyEMD)
 - [ewtpy](https://github.com/vrcarva/ewtpy)
-- [numba](https://github.com/numba/numba)
-- [numpy](https://github.com/numpy/numpy)
-- [scipy](https://github.com/scipy/scipy)
 - [vmdpy](https://github.com/vrcarva/vmdpy)
-- [psutil](https://github.com/giampaolo/psutil)
 
 *Other dependence please read "requirements.txt"*
 
-## Codes Resource
-
-All codes from :
-
-- Github:
-  - EMD-signal -> EMD, CEEFD, CEEMDAN, EEMD
-  - ewtpy -> EWT
-  - vmdpy -> VMD
-
-
-- Myself:
-  - CEEMD, EFD, FMD, ICEEMDAN, LMD, MEMD, RPSEMD, SSA, SVMD
-
 ## Url
 
 This lib's url is: https://github.com/a-raining-day/Modal-Decomposition

{modal_decomposition-0.1.2 → modal_decomposition-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "Modal-Decomposition"
-version = "0.1.2"
+version = "0.1.3"
 requires-python = ">=3.8"
 
 authors = [

modal_decomposition-0.1.3/src/Modal_Decomposition/EEMD.py

@@ -0,0 +1,64 @@
+"""
+Python version:  (must)
+    3.10.11
+
+Lib and Version:  (if None write None)
+    EMD-S - 1.9.0
+
+Only accessed by:  (must)
+    Only __init__.py
+
+Description: (if None write None)
+    Realize the EEMD.
+
+Modify:  (must)
+    2026.3.25 - Create.
+    2026.3.27 - Change the EEMD class' usage. EEMD(parallel=True) (default) -> EEMD(parallel=False). Now, it will not use parallel default.
+    2026.4.2  - Finish the Optimization of the EEMD. Correct the logic.
+    2026.5.1  - Fix: use PyEMD.EEMD to ensure standard algorithm.
+"""
+
+import numpy as np
+from typing import Union, Tuple, Optional
+
+def eemd(
+    S: Union[list, np.ndarray],
+    T: Optional[Union[list, np.ndarray]] = None,
+    trials: int = 100,
+    noise_width: float = 0.05,
+    max_imf: int = -1,
+    **kwargs
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    EEMD: Ensemble Empirical Mode Decomposition
+    (Standard implementation via PyEMD)
+
+    :param S: Signal (1-dim)
+    :param T: Time axis (1-dim). Default uniform.
+    :param trials: Number of white noise realizations (ensemble size).
+    :param noise_width: Standard deviation of added white noise relative to signal std.
+    :param max_imf: Max number of IMFs to extract. -1 for all.
+    :param kwargs: Additional parameters passed to PyEMD.EEMD.
+    :return: IMFs (n_IMFs, N), Res (N,)
+    """
+    from PyEMD import EEMD
+
+    if not isinstance(S, np.ndarray):
+        S = np.array(S, dtype=np.float64).ravel()
+    else:
+        S = S.ravel().astype(np.float64)
+
+    N = len(S)
+
+    if T is None:
+        T = np.arange(N, dtype=np.float64)
+    else:
+        T = np.asarray(T, dtype=np.float64)
+
+    decomposer = EEMD(trials=trials, noise_width=noise_width, **kwargs)
+    result = decomposer.eemd(S, T, max_imf=max_imf)
+
+    IMFs = result[:-1, :]   # shape [n_imfs, N]
+    Res  = result[-1, :]    # shape [N,]
+
+    return IMFs, Res

{modal_decomposition-0.1.2 → modal_decomposition-0.1.3}/src/Modal_Decomposition/EFD.py

@@ -17,6 +17,7 @@ Description: (if None write None)
 Modify:  (must)
     2026.3.25 - Create
     2026.4.2  - Finish the Optimization of the EFD. Del the origin efd function.
+    2026.4.7  - Correct the error of the use of the np.concentrate and the construction of the wn.
 """
 
 import numpy as np
@@ -24,13 +25,14 @@ from .COLOR import printc
 from typing import Union, Tuple
 
 
-def efd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, max_IMFs: int=-1) -> Tuple[np.ndarray, np.ndarray]:
+def efd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, max_IMFs: int=-1, verbose: bool=False) -> Tuple[np.ndarray, np.ndarray]:
     """
     EFD: Empirical Fourier Decomposition
 
     :param S: Signal (1-dim)
     :param T: Time axis (1-dim)
     :param max_IMFs: the num of the IMFs. -1 means return all IMFs
+    :param verbose: if print the info?
     :return: IMFs (n_IMFs, N), Res: (N,)
     """
 
@@ -60,7 +62,8 @@ def efd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, max_IMFs: i
 
     if T is None:  # if T is None, default generate uniform T-axis.
         T = np.arange(N)  # default fs = 1
-        print(f"Warn: T is None，default T = [0, 1, 2, ..., {N - 1}]")
+        if verbose:
+            print(f"Warn: T is None，default T = [0, 1, 2, ..., {N - 1}]")
 
     else:
         if not isinstance(T, np.ndarray):
@@ -86,14 +89,13 @@ def efd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, max_IMFs: i
     uniform_freq = np.linspace(0, np.pi, N // 2)
     freq_N = len(uniform_freq)
 
-    local_maximum_points = argrelmax(edge_magnitude)
+    local_maximum_points_tuple = argrelmax(edge_magnitude)
+    local_maximum_points = local_maximum_points_tuple[0]
     local_maximum = edge_magnitude[local_maximum_points]
 
     if max_IMFs != -1:
         local_maximum_zip = [(point, value) for point, value in zip(local_maximum_points, local_maximum)]
-
         local_maximum_zip = sorted(local_maximum_zip, reverse=True, key=lambda x: x[1])
-
         local_maximum_points = list(map(lambda x: x[0], local_maximum_zip[:max_IMFs]))
 
     local_maximum_points = np.concatenate(([0], local_maximum_points, [freq_N - 1]))
@@ -112,7 +114,7 @@ def efd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, max_IMFs: i
         else:
             # wn.append(np.argmin(edge_magnitude[current_point:next_point + 1]))
             wn.append(current_point + np.argmin(edge_magnitude[current_point:next_point + 1]))
-    wn = np.concatenate(([0], wn, freq_N - 1))
+    wn = np.concatenate(([0], wn, [freq_N - 1]))
 
     filters_arr = []
     for edge in range(1, len(wn)):

{modal_decomposition-0.1.2 → modal_decomposition-0.1.3}/src/Modal_Decomposition/EMD.py

@@ -18,7 +18,6 @@ Modify:  (must)
 
 from PyEMD import EMD
 import numpy as np
-from .COLOR.colorful_print import printc
 from typing import Tuple, Union
 
 

modal_decomposition-0.1.3/src/Modal_Decomposition/Error/RealizationError.py

@@ -0,0 +1,2 @@
+class RealizationError(Exception):
+    pass

modal_decomposition-0.1.3/src/Modal_Decomposition/LMD.py

@@ -0,0 +1,243 @@
+"""
+Python version:  (must)
+    3.10.11
+
+Lib and Version:  (if None write None)
+    numpy - 2.2.6
+	scipy - 1.15.3
+
+Only accessed by:  (must)
+    Only __init__.py
+
+Modify:  (must)
+    2026.3.25
+
+Description: (if None write None)
+    Realize the LMD
+
+Modify:
+    2026.3.25 - Optimize the use of scipy
+    2026.4.3  - Finish the Optimization of the LMD.
+    2026.4.7  - LMD can support the decompose completely now.
+    2026.4.9  - Change some hardcode parameters to args.
+    2026.5.1  - Fix the dependence of "help_function.py".
+"""
+
+import numpy as np
+from .Utils import is_monotonic
+from typing import Union, Tuple
+
+
+def lmd(
+    S: Union[list, np.ndarray],
+    max_pf: Union[int, None] = None,
+    max_iter: int = 37,
+    eps: float = 0.05,
+    eps_stable: float = 1e-12,
+    min_amp: float = 1e-12,
+    max_amp: float = 1e12,
+    converge_mean: float = 1e-3,
+    smooth_window: int = 5
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    LMD: Local mean decomposition
+
+    :param S: Signal (1-dim)
+    :param max_pf: the max num of the PFs. Default log2(N), -1 means decompose completely.
+    :param max_iter: max iteration for each iter of decomposing the PFs. Default 37, according the paper.
+    :param eps: Envelope convergence threshold
+    :param eps_stable:
+    :param min_amp:
+    :param max_amp:
+    :param converge_mean:
+    :param smooth_window:
+
+    Returns:
+        PFs: (n_pf, N), Res: (N,)
+    """
+    from scipy.signal import argrelextrema, savgol_filter
+
+    if S.ndim == 0:
+        raise ValueError("The dim of the S must be 1-dim, not 0")
+
+    elif S.ndim > 1:
+        if 1 in S.shape:
+            S = S.reshape(-1)
+
+        else:
+            raise ValueError(f"The dim of S must be 1-dim, not {S.ndim}")
+
+    if not isinstance(S, np.ndarray):
+        S = np.asarray(S, dtype=np.float64).ravel()
+    n_samples = S.size
+
+    if n_samples < 8:
+        raise ValueError("LMD requires signal length ≥ 8 (Smith 2005 standard)")
+
+    t = np.arange(n_samples, dtype=np.float64)
+    max_pf = int(np.log2(n_samples)) if max_pf is None else max_pf
+    residue = S.copy()
+    PFs: list[np.ndarray] = []
+
+    if max_pf != -1:
+        for _ in range(max_pf):
+            h = residue.copy()
+            a_total = np.ones(n_samples, dtype=np.float64)
+            converged = False
+
+            for __ in range(max_iter):
+                max_loc = argrelextrema(h, np.greater)[0]
+                min_loc = argrelextrema(h, np.less)[0]
+                ext_idx = np.unique(np.concatenate([max_loc, min_loc]))
+
+                if len(ext_idx) < 3:
+                    break
+
+                ext_idx, ext_vals = _mirror_extend_real(h, ext_idx, n_samples)
+                ext_idx = np.sort(ext_idx)
+
+                t_mid = (ext_idx[:-1] + ext_idx[1:]) / 2.0
+                m_vals = (ext_vals[:-1] + ext_vals[1:]) / 2.0
+                a_vals = np.abs(ext_vals[:-1] - ext_vals[1:]) / 2.0
+
+                m_t = _safe_interpolate(t_mid, m_vals, t)
+                a_t = _safe_interpolate(t_mid, a_vals, t)
+
+                a_t = np.clip(a_t, min_amp, max_amp)
+                a_t = savgol_filter(a_t, smooth_window, 2)
+
+                if _check_convergence(m_t, a_t, eps, converge_mean):
+                    converged = True
+                    break
+
+                s_new = (h - m_t) / a_t
+                a_total = np.clip(a_total * a_t, min_amp, max_amp)
+                h = s_new
+
+            if not converged:
+                break
+
+            current_pf = np.clip(a_total * s_new, -max_amp, max_amp)
+
+            if np.any(np.isnan(current_pf)) or np.any(np.isinf(current_pf)):
+                break
+
+            if np.sum(current_pf ** 2) < eps_stable:
+                break
+
+            PFs.append(current_pf)
+            residue -= current_pf
+
+            if (
+                    is_monotonic(residue) or
+                    np.sum(residue ** 2) < eps_stable or
+                    len(argrelextrema(residue, np.greater)[0]) + len(argrelextrema(residue, np.less)[0]) <= 2
+            ):
+                break
+
+    else:
+        while True:
+            h = residue.copy()
+            a_total = np.ones(n_samples, dtype=np.float64)
+            converged = False
+
+            for __ in range(max_iter):
+                max_loc = argrelextrema(h, np.greater)[0]
+                min_loc = argrelextrema(h, np.less)[0]
+                ext_idx = np.unique(np.concatenate([max_loc, min_loc]))
+
+                if len(ext_idx) < 3:
+                    break
+
+                ext_idx, ext_vals = _mirror_extend_real(h, ext_idx, n_samples)
+                ext_idx = np.sort(ext_idx)
+
+                t_mid = (ext_idx[:-1] + ext_idx[1:]) / 2.0
+                m_vals = (ext_vals[:-1] + ext_vals[1:]) / 2.0
+                a_vals = np.abs(ext_vals[:-1] - ext_vals[1:]) / 2.0
+
+                m_t = _safe_interpolate(t_mid, m_vals, t)
+                a_t = _safe_interpolate(t_mid, a_vals, t)
+
+                a_t = np.clip(a_t, min_amp, max_amp)
+                a_t = savgol_filter(a_t, smooth_window, 2)
+
+                if _check_convergence(m_t, a_t, eps, converge_mean):
+                    converged = True
+                    break
+
+                s_new = (h - m_t) / a_t
+                a_total = np.clip(a_total * a_t, min_amp, max_amp)
+                h = s_new
+
+            if not converged:
+                break
+
+            current_pf = np.clip(a_total * s_new, -max_amp, max_amp)
+
+            if np.any(np.isnan(current_pf)) or np.any(np.isinf(current_pf)):
+                break
+
+            if np.sum(current_pf ** 2) < eps_stable:
+                break
+
+            PFs.append(current_pf)
+            residue -= current_pf
+
+            if (is_increasing(residue) or is_increasing(-residue) or
+                    np.sum(residue ** 2) < eps_stable or
+                    len(argrelextrema(residue, np.greater)[0]) + len(argrelextrema(residue, np.less)[0]) <= 2):
+                break
+
+    del h, a_total, t
+    return np.array(PFs, dtype=np.float64), residue
+
+def _mirror_extend_real(signal: np.ndarray, ext_idx: np.ndarray, n_samples: int) -> Tuple[np.ndarray, np.ndarray]:
+    ext = ext_idx.copy()
+    vals = signal[ext].copy()
+    last_idx = n_samples - 1
+
+    if ext[0] > 0:
+        mirror_pos = 0
+        mirror_val = 2 * signal[0] - vals[0]
+        ext = np.insert(ext, 0, mirror_pos)
+        vals = np.insert(vals, 0, mirror_val)
+
+    if ext[-1] < last_idx:
+        mirror_pos = last_idx
+        mirror_val = 2 * signal[-1] - vals[-1]
+        ext = np.append(ext, mirror_pos)
+        vals = np.append(vals, mirror_val)
+
+    return ext, vals
+
+def _safe_interpolate(x: np.ndarray, y: np.ndarray, x_new: np.ndarray) -> np.ndarray:
+    from scipy import interpolate
+
+    try:
+        interp = interpolate.CubicSpline(x, y, bc_type="natural")
+        res = interp(x_new)
+    except:
+        res = np.interp(x_new, x, y)
+
+    left_mask = x_new < x[0]
+    right_mask = x_new > x[-1]
+    if np.any(left_mask):
+        slope = (y[1] - y[0]) / (x[1] - x[0])
+        res[left_mask] = y[0] + slope * (x_new[left_mask] - x[0])
+    if np.any(right_mask):
+        slope = (y[-1] - y[-2]) / (x[-1] - x[-2])
+        res[right_mask] = y[-1] + slope * (x_new[right_mask] - x[-1])
+
+    return res
+
+def _check_convergence(m_t: np.ndarray, a_t: np.ndarray, eps: float, converge_mean) -> bool:
+    mean_ok = np.max(np.abs(m_t)) < converge_mean
+    envelope_ok = np.max(np.abs(a_t - 1.0)) < eps
+    return mean_ok and envelope_ok
+
+def compute_envelope(signal: Union[list, np.ndarray]) -> np.ndarray:
+    from scipy.linalg import hilbert
+
+    signal = np.asarray(signal, dtype=np.float64).ravel()
+    return np.abs(hilbert(signal))

{modal_decomposition-0.1.2 → modal_decomposition-0.1.3}/src/Modal_Decomposition/MEMD.py

@@ -9,20 +9,21 @@ Lib and Version:  (if None write None)
 Only accessed by:  (must)
     Only __init__.py
 
-Modify:  (must)
-    2026.3.25
-
 Description: (if None write None)
     Realize the MEMD
+
+Modify:  (must)
+    2026.3.25 - Create.
+    2026.5.1  - Fix the problem when calculating projections.
 """
 
 import numpy as np
 from typing import Union, Tuple
 
 
-def memd(S: Union[list, np.ndarray], d=None, k=None, max_imf=None, sd_thresh=0.2, max_iter=10) -> Tuple[np.ndarray, np.ndarray]:
+def memd(S: Union[list, np.ndarray], d=None, k=None, max_imf=None, sd_thresh=0.2, max_iter=10, spline_kind: str="linear") -> Tuple[np.ndarray, np.ndarray]:
     """
-    MEMD: Multimodal Experience Modeling Decomposition
+    MEMD: Multimodal Empirical Mode Decomposition
 
     :param S: Signal (2-dim), (d, N) | d -> channels,N -> time points
     :param d: channels or dimensions
@@ -30,7 +31,8 @@ def memd(S: Union[list, np.ndarray], d=None, k=None, max_imf=None, sd_thresh=0.2
     :param max_imf: max num of IMFs
     :param sd_thresh: therahold
     :param max_iter: max iterations of each IMF
-    :return: IMFs (d, N), Res (2-dim)
+    :param spline_kind: spline kind.
+    :return: IMFs (IMFs_num, d, N), Res (2-dim)
     """
 
     if not isinstance(S, np.ndarray):
@@ -56,7 +58,7 @@ def memd(S: Union[list, np.ndarray], d=None, k=None, max_imf=None, sd_thresh=0.2
 
     vectors = generate_hammersley_points(k, d)  # dhape: (d, k)
 
-    projections = np.dot(S.T, vectors)  # shape: (N, k)
+    # projections = np.dot(S.T, vectors)  # shape: (N, k)
 
     imfs = []
     residue = S.copy()
@@ -66,7 +68,7 @@ def memd(S: Union[list, np.ndarray], d=None, k=None, max_imf=None, sd_thresh=0.2
 
         for iter_num in range(max_iter):
             h_old = h
-            mean_envelope = compute_local_mean(h, vectors, projections, T)
+            mean_envelope = compute_local_mean(h, vectors, T, spline_kind=spline_kind)
 
             h_new = h - mean_envelope
             sd = np.sum((h_old - h_new) ** 2) / np.sum(h_old ** 2)
@@ -153,7 +155,7 @@ def generate_primes(n):
     return primes
 
 
-def compute_local_mean(signal, vectors, T):
+def compute_local_mean(signal, vectors, T, spline_kind: str="linear"):
     """
     S: now S (d, N)
     vectors: directional vector (d, k)
@@ -196,7 +198,7 @@ def compute_local_mean(signal, vectors, T):
             max_values = signal[ch, max_indices]
             if len(max_indices) >= 4:
                 try:
-                    max_spline = interp1d(max_indices, max_values, kind='cubic',fill_value='extrapolate')
+                    max_spline = interp1d(max_indices, max_values, kind=spline_kind,fill_value='extrapolate')
                     max_env = max_spline(T)
                 except:
                     max_env = np.interp(T, max_indices, max_values)
@@ -206,7 +208,7 @@ def compute_local_mean(signal, vectors, T):
             min_values = signal[ch, min_indices]
             if len(min_indices) >= 4:
                 try:
-                    min_spline = interp1d(min_indices, min_values, kind='cubic',fill_value='extrapolate')
+                    min_spline = interp1d(min_indices, min_values, kind=spline_kind,fill_value='extrapolate')
                     min_env = min_spline(T)
                 except:
                     min_env = np.interp(T, min_indices, min_values)

{modal_decomposition-0.1.2 → modal_decomposition-0.1.3}/src/Modal_Decomposition/SSA.py

@@ -15,7 +15,7 @@ Description: (if None write None)
 
 Modify:  (must)
     2026.3.25 - Create.
-    2026.3.29 - Optimize the SSA.decompose function, it's faster now. Please use SSA() which means SSA.decompose_fast().
+    2026.3.29 - Optimize the SSA.decompose function, it's use_JIT now. Please use SSA() which means SSA.decompose_fast().
 """
 
 import numpy as np
@@ -165,7 +165,7 @@ class SSA:
         :param S: Signal (1-dim)
         :param L:
         :param groups: group information, such as: [[0], [1,2], [3,4]] means which components will be merged. If None, return all
-        :param faster: if you choose True, function will be faster with wasting memory.
+        :param faster: if you choose True, function will be use_JIT with wasting memory.
         :return: IMFs (2-dim)
         """
 

{modal_decomposition-0.1.2 → modal_decomposition-0.1.3}/src/Modal_Decomposition/SVMD.py

@@ -15,6 +15,7 @@ Description: (if None write None)
 Modify:  (must)
     2026.3.25 - Create.
     2026.4.3  - Finish the Optimization of the SVMD. Give two kind of SVMD.
+    2026.5.1  - The decomposition with JIT is Error.
 """
 
 import numpy as np
@@ -134,6 +135,9 @@ class SVMD:
         return modes, residual
 
 def give_svmd_JIT():
+    from .Error.RealizationError import RealizationError
+    raise RealizationError("this method' realization is error.")
+
     from scipy.fft import fft, ifft, fftfreq
     from numba import jit, prange, complex128, float64
     import numba as nb
@@ -204,7 +208,7 @@ def give_svmd_JIT():
             for n in range(N):
                 re = np.real(sum_modes_hat[n]) - prev_recon[n]
                 recon_error += re * re
-                sig_norm += signal_hat[n].real * signal_hat[n].real
+                sig_norm += np.sum(np.abs(signal_hat)**2) / N
 
             if it > 1 and np.sqrt(recon_error) / (np.sqrt(sig_norm) + eps) < tol:
                 break
@@ -225,6 +229,7 @@ def give_svmd_JIT():
             residual[n] = np.real(signal_hat[n]) - recon_val
 
         return modes, residual
+
     class NumbaSVMD(SVMD):
 
         def decompose(self, signal: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
@@ -254,7 +259,7 @@ def give_svmd_JIT():
 def svmd \
     (
         S: Union[list, np.ndarray],
-        faster: bool = False,
+        use_JIT: bool = False,
         num_modes: int = 3,
         alpha: float = 2000,
         tau: float = 0.0,
@@ -264,7 +269,7 @@ def svmd \
     """
 
     :param S: Signal (N,)
-    :param faster: if True, use Numba version.
+    :param use_JIT: if True, use Numba version.
     :param num_modes: the num of modes
     :param alpha:
     :param tau:
@@ -273,7 +278,7 @@ def svmd \
     :return: IMFs(num_modes, N), Res(N,)
     """
 
-    if not faster:
+    if not use_JIT:
         Cls = SVMD(num_modes=num_modes, alpha=alpha, tau=tau, tol=tol, max_iter=max_iter)
         IMFs, Res = Cls(S)
 

{modal_decomposition-0.1.2 → modal_decomposition-0.1.3}/src/Modal_Decomposition/__init__.py

@@ -1,6 +1,6 @@
 """
 Modal Decomposition:
-    LMD、CEEMDAN、EFD、CEEFD、VMD、EEMD、FMD、EWT、SSA、RPSEMD、CEEMD、MEMD、ICEEMDAN、EMD
+    LMD, CEEMDAN, EFD, CEEFD, VMD, EEMD, FMD, EWT, SSA, RPSEMD, CEEMD, MEMD, ICEEMDAN, EMD
 
 GitHub url: https://github.com/a-raining-day/Modal-Decomposition
 
@@ -17,9 +17,6 @@ Lib and Version:  (if None write None)
 Only accessed by:  (must)
     All
 
-Modify:  (must)
-    2026.3.25
-
 Description: (if None write None)
     As the entrance of the lib
 
@@ -43,12 +40,14 @@ Modify:
     2026.4.3  - Finish the Optimization of the modal decomposition method. Except the MEMD method.
     2026.4.4  - Add the parameter to describe lib.
     2026.4.6  - Change the position of the entrance of importing 'threading'. Try to reduce the cost of the import.
+    2026.4.9  - Fix the import error of Class.VMD. From "vmdpy.EWT1D" to "vmdpy.VMD".
+    2026.5.1  - Delete the "help_function.py". Stop use decomposition with JIT in "SVMD.py". EEMD use PyEMD now. Fix the MEMD.
 """
 
 
-__version__ = "0.1.1"
+__version__ = "0.1.3"
 __author__ = "a-raining-day(Mao)"
-__email__ = "None, Only QQ email."
+__email__ = "2215269365@qq.com"
 __license__ = "Apache 2.0"
 __url__ = "https://github.com/a-raining-day/Modal-Decomposition"
 __description__ = "A comprehensive modal decomposition library"
@@ -72,11 +71,6 @@ from .SSA import SSA, ssa
 from .SVMD import svmd
 from .VMD import vmd
 
-
-import warnings
-warnings.warn("The MEMD is rebuilding...")
-
-
 __all__ = \
     [
         "Function", "Class",
@@ -129,7 +123,7 @@ class Class:
     def VMD(cls, **kwargs):
         if "EWT1D" not in cls.__cache:
             try:
-                Module = import_module("vmdpy").EWT1D
+                Module = import_module("vmdpy").VMD
                 cls.__cache["VMD"] = Module
                 return Module(**kwargs)
             except ImportError:
@@ -139,9 +133,8 @@ class Class:
             return cls.__cache["VMD"](**kwargs)
 
 class Function:
-    # function | default function for modal decomposition
-    # the IMFs (2-dim) means: (K, len(Signal)) (K is the num of IMFs)
-    # CEEFD = ceefd_real_cls.ceefd
+    """ function | default function for modal decomposition
+    the IMFs (2-dim) means: (K, len(Signal)) (K is the num of IMFs)"""
 
     CEEFD = Class.CEEFD(fs=1.0, min_peak_distance=10, envelop_iter=3)
     CEEMD = ceemd

{modal_decomposition-0.1.2 → modal_decomposition-0.1.3}/src/Modal_Decomposition.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Modal-Decomposition
-Version: 0.1.2
+Version: 0.1.3
 Summary: a package for modal decomposition
 Author-email: Mao_HaoChuan <2215269365@qq.com>
 License: Apache-2.0
@@ -55,7 +55,7 @@ All entrance of functions or class are stored in `Modal_Decomposition/__init__.p
 | EFD      | Empirical Fourier Decomposition                                             |   `Function.EFD(signal)`    |                                                                                                                        [10.1016/j.ymssp.2021.108155](https://www.sciencedirect.com/science/article/abs/pii/S0888327021005355?via%3Dihub)                                                                                                                        |
 | EMD      | Empirical Mode Decomposition                                                |   `Function.EMD(signal)`    |                                                                                              [10.1098/rspa.1998.0193](https://www.semanticscholar.org/paper/The-empirical-mode-decomposition-and-the-Hilbert-Huang-Shen/3842d81b0375dae8ae92734aa2a5d4aeed7a91d1)                                                                                               |
 | EWT      | Empirical Wavelet Transform                                                 |   `Function.EWT(signal)`    |                                                                                                                                                  [10.48550/arXiv.2304.06274](https://arxiv.org/abs/2304.06274)                                                                                                                                                  |
-| FMD      | Filtered Mode Decomposition                                                 |   `Function.MEMD(signal)`   |                                                                                                                                            [10.1109/TIE.2022.3156156](https://ieeexplore.ieee.org/document/9732251)                                                                                                                                             |
+| FMD      | Filtered Mode Decomposition                                                 |   `Function.FMD(signal)`    |                                                                                                                                            [10.1109/TIE.2022.3156156](https://ieeexplore.ieee.org/document/9732251)                                                                                                                                             |
 | ICEEMDAN | Improved Complete Ensemble Empirical Mode Decomposition with Adaptive Noise | `Function.ICEEMDAN(signal)` |                                                                                                                                [10.1007/s10470-021-01901-3](https://link.springer.com/article/10.1007/s10470-021-01901-3#citeas)                                                                                                                                |
 | LMD      | Local Mean Decomposition                                                    |   `Function.LMD(signal)`    |                                                                                                                                     [10.1098/rsif.2005.0058](https://royalsocietypublishing.org/doi/10.1098/rsif.2005.0058)                                                                                                                                     |
 | MEMD     | Multivariate Empirical Mode Decomposition                                   |   `Function.MEMD(signal)`   |                                                                                                                                                  [10.48550/arXiv.2206.00926](https://arxiv.org/abs/2206.00926)                                                                                                                                                  |
@@ -79,42 +79,18 @@ pip install -r requirements.txt
 pip install Modal-Decomposition
 ```
 
-*Well, some libs should be installed by yourself, don't use `pip install -r requirements.txt`, because `Triton` need installed by GitHub.*
-
-*`Triton` please visite this url: https://github.com/woct0rdho/triton-windows/releases*
-
 ## Dependence
 
 This lib's dependence are:
 
 ***Python: 3.10***
 
-- [antropy](https://github.com/raphaelvallat/antropy)
-- [colorama](https://github.com/tartley/colorama)
-- [einops](https://github.com/arogozhnikov/einops)
 - [EMD-signal](https://github.com/laszukdawid/PyEMD)
 - [ewtpy](https://github.com/vrcarva/ewtpy)
-- [numba](https://github.com/numba/numba)
-- [numpy](https://github.com/numpy/numpy)
-- [scipy](https://github.com/scipy/scipy)
 - [vmdpy](https://github.com/vrcarva/vmdpy)
-- [psutil](https://github.com/giampaolo/psutil)
 
 *Other dependence please read "requirements.txt"*
 
-## Codes Resource
-
-All codes from :
-
-- Github:
-  - EMD-signal -> EMD, CEEFD, CEEMDAN, EEMD
-  - ewtpy -> EWT
-  - vmdpy -> VMD
-
-
-- Myself:
-  - CEEMD, EFD, FMD, ICEEMDAN, LMD, MEMD, RPSEMD, SSA, SVMD
-
 ## Url
 
 This lib's url is: https://github.com/a-raining-day/Modal-Decomposition

{modal_decomposition-0.1.2 → modal_decomposition-0.1.3}/src/Modal_Decomposition.egg-info/SOURCES.txt

@@ -17,7 +17,6 @@ src/Modal_Decomposition/SSA.py
 src/Modal_Decomposition/SVMD.py
 src/Modal_Decomposition/VMD.py
 src/Modal_Decomposition/__init__.py
-src/Modal_Decomposition/help_function.py
 src/Modal_Decomposition.egg-info/PKG-INFO
 src/Modal_Decomposition.egg-info/SOURCES.txt
 src/Modal_Decomposition.egg-info/dependency_links.txt
@@ -27,6 +26,7 @@ src/Modal_Decomposition/COLOR/__init__.py
 src/Modal_Decomposition/COLOR/color_define.py
 src/Modal_Decomposition/COLOR/colorful_print.py
 src/Modal_Decomposition/Error/CycleError.py
+src/Modal_Decomposition/Error/RealizationError.py
 src/Modal_Decomposition/Utils/EnvironmentMemory.py
 src/Modal_Decomposition/Utils/LazyImport.py
 src/Modal_Decomposition/Utils/Monotonicity.py

modal_decomposition-0.1.2/src/Modal_Decomposition/EEMD.py

@@ -1,130 +0,0 @@
-"""
-Python version:  (must)
-    3.10.11
-
-Lib and Version:  (if None write None)
-    EMD-S - 1.9.0
-
-Only accessed by:  (must)
-    Only __init__.py
-
-Description: (if None write None)
-    Realize the EEMD.
-
-Modify:  (must)
-    2026.3.25 - Create.
-    2026.3.27 - Change the EEMD class' usage. EEMD(parallel=True) (default) -> EEMD(parallel=False). Now, it will not use parallel default.
-    2026.4.2  - Finish the Optimization of the EEMD. Correct the logic.
-"""
-
-import numpy as np
-from typing import Union, Tuple, Optional
-from .Utils import monotonic_increasing, monotonic_decreasing
-from .Error import CycleError
-from time import sleep
-from warnings import warn
-from .EMD import emd
-
-
-def eemd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, N_whitenoise=300, beta=0.3, max_imf: Optional[int]=None, dead_line: int=10, verbose: bool=False) \
-        -> Tuple[np.ndarray, np.ndarray]:
-    """
-    EEMD: Ensemble Empirical Mode Decomposition
-
-    :param S: Signal (1-dim)
-    :param T: the time axis.
-    :param N_whitenoise: the num of the added whitenoise.
-    :param beta:
-    :param max_imf: -1, None or other int | -1 means decompose completely, None means give a int auto, other int means the num of the IMFs
-    :param dead_line: Sometime it'll be in unuseful cycle, when the average of the N's sequence with added whitenoise is empty([]). It'll be forced exit when the time of the cycle above the deadline.
-    :param verbose:
-    :return: IMFs (n_IMFs, N), Res (N,)
-    """
-    if beta <= 0:
-        raise ValueError("The beta should > 0")
-
-    if N_whitenoise <= 0 or not isinstance(N_whitenoise, int):
-        raise TypeError("N_whitenoise must be int type or > 0")
-
-    if not isinstance(S, np.ndarray):
-        S = np.array(S)
-
-    if S.ndim == 0:
-        raise ValueError("The dim of the S must be 1-dim, not 0")
-
-    elif S.ndim > 1:
-        if 1 in S.shape:
-            S = S.reshape(-1)
-
-        else:
-            raise ValueError(f"The dim of S must be 1-dim, not {S.ndim}")
-
-    N = len(S)
-
-    if T is None:  # if T is None, default generate uniform T-axis.
-        T = np.arange(N)  # default fs = 1
-        print(f"Warn: T is None，default T = [0, 1, 2, ..., {N - 1}]")
-
-    else:
-        if not isinstance(T, np.ndarray):
-            T = np.array(T)
-
-        if len(T) != len(S):
-            raise ValueError("The length of T must be equal to Signal.")
-
-        if not np.all(np.diff(T) > 0):
-            raise ValueError("T should be monotonic increasing!")
-
-        if np.any(np.allclose(np.diff(np.diff(T)))):
-            warn("The T is not uniform! Some error may happen.")
-
-    if max_imf is None:
-        max_imf = int(np.log2(len(S))) + 2
-
-    Res = S
-    IMFs = []
-
-    # std_dev = np.std(S)
-
-    count = 0
-    dead_cycle = 0
-    while True:
-        std_dev = np.std(Res)
-
-        _IMFs = []
-        for n in range(N_whitenoise):
-            white_noise = np.random.normal(0, std_dev * beta, N)
-            _S = Res + white_noise
-            _IMFs_, _ = emd(_S, T, max_imf=1)
-            if not _IMFs_:
-                continue
-            _IMFs.append(_IMFs_[0])
-
-        if not _IMFs:
-            dead_cycle += 1
-            continue
-
-        if dead_cycle >= dead_line:
-            raise RuntimeError("Trapped in a vicious cycle")
-        else:
-            dead_cycle = 0
-
-        IMF = np.mean(_IMFs, axis=0)
-
-        IMFs.append(IMF)
-
-        Res -= IMF
-        count += 1
-
-        if verbose:
-            if count % 10 == 0:
-                print(f"has get {count} IMFs...")
-                sleep(1)
-
-        if max_imf != -1:
-            if count >= max_imf or monotonic_increasing(Res) or monotonic_decreasing(Res):
-                return np.array(IMFs), np.array(Res)
-
-        else:
-            if monotonic_increasing(Res) or monotonic_decreasing(Res):
-                return np.array(IMFs), np.array(Res)

modal_decomposition-0.1.2/src/Modal_Decomposition/LMD.py

@@ -1,178 +0,0 @@
-"""
-Python version:  (must)
-    3.10.11
-
-Lib and Version:  (if None write None)
-    numpy - 2.2.6
-	scipy - 1.15.3
-
-Only accessed by:  (must)
-    Only __init__.py
-
-Modify:  (must)
-    2026.3.25
-
-Description: (if None write None)
-    Realize the LMD
-
-Modify:
-    2026.3.25 - Optimize the use of scipy
-    2026.4.3  - Finish the Optimization of the LMD.
-"""
-
-import numpy as np
-from .help_function import is_increasing
-from typing import Union, Tuple
-
-EPS_STABLE = 1e-12
-MIN_AMP = 1e-12
-MAX_AMP = 1e12
-CONVERGE_MEAN = 1e-3
-SMOOTH_WINDOW = 5
-
-def lmd(
-    S: Union[list, np.ndarray],
-    max_pf: int | None = None,
-    max_iter: int = 37,
-    eps: float = 0.05
-) -> Tuple[np.ndarray, np.ndarray]:
-    """
-    LMD: Local mean decomposition
-
-    :param S: Signal (1-dim)
-    :param max_pf: the max num of the PFs. Default log2(N)
-    :param max_iter: max iteration for each iter of decomposing the PFs. Default 37, according the paper.
-    :param eps: Envelope convergence threshold
-
-    Returns:
-        PFs: (n_pf, N), Res: (N,)
-    """
-    from scipy.signal import argrelextrema, hilbert, savgol_filter
-
-    if S.ndim == 0:
-        raise ValueError("The dim of the S must be 1-dim, not 0")
-
-    elif S.ndim > 1:
-        if 1 in S.shape:
-            S = S.reshape(-1)
-
-        else:
-            raise ValueError(f"The dim of S must be 1-dim, not {S.ndim}")
-
-    if not isinstance(S, np.ndarray):
-        S = np.asarray(S, dtype=np.float64).ravel()
-    n_samples = S.size
-
-    if n_samples < 8:
-        raise ValueError("LMD requires signal length ≥ 8 (Smith 2005 standard)")
-
-    t = np.arange(n_samples, dtype=np.float64)
-    max_pf = int(np.log2(n_samples)) if max_pf is None else max_pf
-    residue = S.copy()
-    PFs: list[np.ndarray] = []
-
-    for _ in range(max_pf):
-        h = residue.copy()
-        a_total = np.ones(n_samples, dtype=np.float64)
-        converged = False
-
-        for __ in range(max_iter):
-            max_loc = argrelextrema(h, np.greater)[0]
-            min_loc = argrelextrema(h, np.less)[0]
-            ext_idx = np.unique(np.concatenate([max_loc, min_loc]))
-
-            if len(ext_idx) < 3:
-                break
-
-            ext_idx, ext_vals = _mirror_extend_real(h, ext_idx, n_samples)
-            ext_idx = np.sort(ext_idx)
-
-            t_mid = (ext_idx[:-1] + ext_idx[1:]) / 2.0
-            m_vals = (ext_vals[:-1] + ext_vals[1:]) / 2.0
-            a_vals = np.abs(ext_vals[:-1] - ext_vals[1:]) / 2.0
-
-            m_t = _safe_interpolate(t_mid, m_vals, t)
-            a_t = _safe_interpolate(t_mid, a_vals, t)
-
-            a_t = np.clip(a_t, MIN_AMP, MAX_AMP)
-            a_t = savgol_filter(a_t, SMOOTH_WINDOW, 2)
-
-            if _check_convergence(m_t, a_t, eps):
-                converged = True
-                break
-
-            s_new = (h - m_t) / a_t
-            a_total = np.clip(a_total * a_t, MIN_AMP, MAX_AMP)
-            h = s_new
-
-        if not converged:
-            break
-
-        current_pf = np.clip(a_total * s_new, -MAX_AMP, MAX_AMP)
-
-        if np.any(np.isnan(current_pf)) or np.any(np.isinf(current_pf)):
-            break
-
-        if np.sum(current_pf ** 2) < EPS_STABLE:
-            break
-
-        PFs.append(current_pf)
-        residue -= current_pf
-
-        if (is_increasing(residue) or is_increasing(-residue) or
-                np.sum(residue ** 2) < EPS_STABLE or
-                len(argrelextrema(residue, np.greater)[0]) + len(argrelextrema(residue, np.less)[0]) <= 2):
-            break
-
-    del h, a_total, t
-    return np.array(PFs, dtype=np.float64), residue
-
-def _mirror_extend_real(signal: np.ndarray, ext_idx: np.ndarray, n_samples: int) -> Tuple[np.ndarray, np.ndarray]:
-    ext = ext_idx.copy()
-    vals = signal[ext].copy()
-    last_idx = n_samples - 1
-
-    if ext[0] > 0:
-        mirror_pos = 0
-        mirror_val = 2 * signal[0] - vals[0]
-        ext = np.insert(ext, 0, mirror_pos)
-        vals = np.insert(vals, 0, mirror_val)
-
-    if ext[-1] < last_idx:
-        mirror_pos = last_idx
-        mirror_val = 2 * signal[-1] - vals[-1]
-        ext = np.append(ext, mirror_pos)
-        vals = np.append(vals, mirror_val)
-
-    return ext, vals
-
-def _safe_interpolate(x: np.ndarray, y: np.ndarray, x_new: np.ndarray) -> np.ndarray:
-    from scipy import interpolate
-
-    try:
-        interp = interpolate.CubicSpline(x, y, bc_type="natural")
-        res = interp(x_new)
-    except:
-        res = np.interp(x_new, x, y)
-
-    left_mask = x_new < x[0]
-    right_mask = x_new > x[-1]
-    if np.any(left_mask):
-        slope = (y[1] - y[0]) / (x[1] - x[0])
-        res[left_mask] = y[0] + slope * (x_new[left_mask] - x[0])
-    if np.any(right_mask):
-        slope = (y[-1] - y[-2]) / (x[-1] - x[-2])
-        res[right_mask] = y[-1] + slope * (x_new[right_mask] - x[-1])
-
-    return res
-
-def _check_convergence(m_t: np.ndarray, a_t: np.ndarray, eps: float) -> bool:
-    mean_ok = np.max(np.abs(m_t)) < CONVERGE_MEAN
-    envelope_ok = np.max(np.abs(a_t - 1.0)) < eps
-    return mean_ok and envelope_ok
-
-def compute_envelope(signal: Union[list, np.ndarray]) -> np.ndarray:
-    from scipy.linalg import hilbert
-
-    signal = np.asarray(signal, dtype=np.float64).ravel()
-    return np.abs(hilbert(signal))

modal_decomposition-0.1.2/src/Modal_Decomposition/help_function.py

@@ -1,64 +0,0 @@
-"""
-Python version:  (must)
-    3.10.11
-
-Lib and Version:  (if None write None)
-    numpy - 2.2.6
-	numba - 0.64.0
-
-Only accessed by:  (must)
-    All(for modal decomposition more)
-
-Modify:  (must)
-    2026.3.25
-
-Description: (if None write None)
-    This file stored the helpful function which can be used in other modal decomposition methods.
-
-Modify:
-    Optimize the use of numba, accelerate the speed of import
-"""
-
-import numpy as np
-from typing import Literal, Callable
-
-def is_increasing_1(S) -> bool:
-    diff = np.ediff1d(S)
-    epsilon = 1e-8
-    return np.all(diff > epsilon)
-
-def give_is_increasing_2() -> Callable:
-    from numba import njit
-
-    @njit
-    def is_increasing_2(S, rtol=1e-8, atol=1e-8):
-        for i in range(len(S)-1):
-            diff = S[i+1] - S[i]
-            if diff <= atol + rtol * abs(S[i]):
-                return False
-        return True
-
-    return is_increasing_2
-
-def is_increasing(S, threshold=2, tolerance: Literal["high", "mid", "low"]="high") -> bool:
-    def count_extrema(x):
-        interior = x[1:-1]
-        left = x[:-2]
-        right = x[2:]
-        maxima = (interior > left) & (interior > right)
-        minima = (interior < left) & (interior < right)
-        return np.sum(maxima) + np.sum(minima)
-
-    if tolerance == "high":
-        ans_3 = count_extrema(S) <= threshold
-        return ans_3
-
-    elif tolerance == "mid":
-        diff = np.diff(S)
-
-        sign_changes = np.diff(np.sign(diff))
-
-        count = np.sum(np.abs(sign_changes) == 2)
-
-        ans_1 = count <= threshold  # one way to check
-        return ans_1