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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Modal-Decomposition
-Version: 0.1.1
+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.1 → 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.1 → modal_decomposition-0.1.3}/pyproject.toml

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

{modal_decomposition-0.1.1 → modal_decomposition-0.1.3}/src/Modal_Decomposition/CEEFD.py

@@ -14,6 +14,7 @@ Description: (if None write None)
 Modify:  (must)
     2026.3.25 - Create
     2026.3.30 - Desperate the CEEMDAN and the CEEFD, and rename the Cyclic_CEEFD as CEEFD, del the origin CEEFD.
+    2026.4.7  - Fix the problem when the freq_bins include 0 will make the idx out of list. And change _extract_imf to staticmethod.
 """
 
 import numpy as np
@@ -44,13 +45,15 @@ class ceefd:
             envelope = np.maximum(envelope, mag_spectrum)
         return envelope
 
-    def _extract_imf(self, signal, freq_bins):
+    @staticmethod
+    def _extract_imf(signal, freq_bins):
         N = len(signal)
         fft_signal = np.fft.fft(signal)
 
         mask = np.zeros(N, dtype=bool)
         mask[freq_bins] = True
-        mask[N - np.array(freq_bins)] = True
+        # mask[N - np.array(freq_bins)] = True -> \  # 2026.4.7
+        mask[(N - np.array(freq_bins)) % N] = True
 
         imf_fft = fft_signal * mask
         imf = np.fft.ifft(imf_fft).real

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.1 → 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.1 → modal_decomposition-0.1.3}/src/Modal_Decomposition/EMD.py

@@ -18,11 +18,10 @@ Modify:  (must)
 
 from PyEMD import EMD
 import numpy as np
-from .COLOR.colorful_print import printc
 from typing import Tuple, Union
 
 
-def emd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, spline_kind: str = "cubic", nbsym: int = 2, max_imf=-1, fs=None)\
+def emd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, spline_kind: str = "cubic", nbsym: int = 2, max_imf=-1, verbose: bool=False)\
         -> Tuple[np.ndarray, np.ndarray]:
     """
     EMD: Empirical Mode Decomposition
@@ -32,7 +31,7 @@ def emd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, spline_kind
     :param spline_kind: the kind of spline. default cubic.
     :param nbsym:
     :param max_imf: the max num of IMFs
-    :param fs: the f of T. default 1.
+    :param verbose: True will print info, else no.
     :return: IMFs (2-dim), Res (1-dim)
     """
     if not isinstance(S, np.ndarray):
@@ -52,7 +51,8 @@ def emd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, spline_kind
 
     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):
@@ -62,4 +62,13 @@ def emd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, spline_kind
 
     IMFs = EMD_cls.emd(S, T, max_imf=max_imf)
 
-    return IMFs[:-1, :], IMFs[-1, :]
+    Res = IMFs[-1, :]
+    IMFs = IMFs[:-1, :]
+
+    if IMFs.ndim == 1:
+        IMFs = IMFs.reshape(1, -1)
+
+    elif IMFs.ndim == 0:
+        IMFs = np.zeros((1, Res.shape[1]))
+
+    return IMFs, Res

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.1 → 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.1 → 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)
         """