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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Modal-Decomposition
-Version: 0.1.2
+Version: 0.1.4
 Summary: a package for modal decomposition
 Author-email: Mao_HaoChuan <2215269365@qq.com>
 License: Apache-2.0
@@ -44,6 +44,29 @@ Hope my lib can help you.
 
 All entrance of functions or class are stored in `Modal_Decomposition/__init__.py`
 
+## API
+
+There two classification in `__init__.py`: `Class` and `Function`.
+
+- ### Function:
+
+    Use `Function.method` to choose the following mode decomposition method.
+
+- ### Class:
+
+    Use `Class.class` will give you a class. `Class.class.decompose` will decompose the signal.
+
+### Quick Start
+
+```python
+from Modal_Decomposition import Function as f
+import numpy as np
+
+S = np.random.random(10)
+
+IMFs, Res, Info = f.EMD(S)
+```
+
 ## Modal Decomposition
 
 | method   | description                                                                 |             use             |                                                                                                                                                                     resource(doi and link)                                                                                                                                                                      |
@@ -55,20 +78,20 @@ 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)                                                                                                                                                  |
 | RPSEMD   | Random Phase Sinusoidal Assisted Empirical Mode Decomposition               |  `Function.RPSEMD(signal)`  |                                                                                                                                            [10.1109/LSP.2016.2537376](https://ieeexplore.ieee.org/document/7423702)                                                                                                                                             |
 | SSA      | Singular Spectrum Analysis                                                  |   `Function.SSA(signal)`    |                                                                                                                                [10.1016/j.mex.2020.101015](https://www.sciencedirect.com/science/article/pii/S2215016120302351)                                                                                                                                 |
-| SVMD     | Sequential Variational Mode Decomposition                                   |   `Function.SVMD(signal)`   |                                                                                                                             [10.1016/j.sigpro.2020.107610](https://www.sciencedirect.com/science/article/abs/pii/S0165168420301535)                                                                                                                             |
-| VMD      | Variational Mode Decomposition                                              |   `Function.VMD(signal)`    |                                                                                                                             [10.1016/j.sigpro.2020.107610](https://www.sciencedirect.com/science/article/abs/pii/S0165168420301535)                                                                                                                             |
+| SVMD     | Successive Variational Mode Decomposition                                   |   `Function.SVMD(signal)`   |                                                                                                                             [10.1016/j.sigpro.2020.107610](https://www.sciencedirect.com/science/article/abs/pii/S0165168420301535)                                                                                                                             |
+| VMD      | Variational Mode Decomposition                                              |   `Function.VMD(signal)`    |                                                                                                                                            [10.1109/TSP.2013.2288675](https://ieeexplore.ieee.org/document/6655981)                                                                                                                                             |
 
 ## Install
 
 You can install by:
 ```shell
-git clone https://github.com/a-raining-day/Motal-Decomposition.git
+git clone https://github.com/a-raining-day/Modal-Decomposition.git
 cd Motal-Decomposition
 pip install -r requirements.txt
 ```
@@ -79,41 +102,19 @@ 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
+*Please pip `EMD-signal`, not `PyEMD`*
 
 ## Url
 

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

@@ -12,6 +12,29 @@ Hope my lib can help you.
 
 All entrance of functions or class are stored in `Modal_Decomposition/__init__.py`
 
+## API
+
+There two classification in `__init__.py`: `Class` and `Function`.
+
+- ### Function:
+
+    Use `Function.method` to choose the following mode decomposition method.
+
+- ### Class:
+
+    Use `Class.class` will give you a class. `Class.class.decompose` will decompose the signal.
+
+### Quick Start
+
+```python
+from Modal_Decomposition import Function as f
+import numpy as np
+
+S = np.random.random(10)
+
+IMFs, Res, Info = f.EMD(S)
+```
+
 ## Modal Decomposition
 
 | method   | description                                                                 |             use             |                                                                                                                                                                     resource(doi and link)                                                                                                                                                                      |
@@ -23,20 +46,20 @@ 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)                                                                                                                                                  |
 | RPSEMD   | Random Phase Sinusoidal Assisted Empirical Mode Decomposition               |  `Function.RPSEMD(signal)`  |                                                                                                                                            [10.1109/LSP.2016.2537376](https://ieeexplore.ieee.org/document/7423702)                                                                                                                                             |
 | SSA      | Singular Spectrum Analysis                                                  |   `Function.SSA(signal)`    |                                                                                                                                [10.1016/j.mex.2020.101015](https://www.sciencedirect.com/science/article/pii/S2215016120302351)                                                                                                                                 |
-| SVMD     | Sequential Variational Mode Decomposition                                   |   `Function.SVMD(signal)`   |                                                                                                                             [10.1016/j.sigpro.2020.107610](https://www.sciencedirect.com/science/article/abs/pii/S0165168420301535)                                                                                                                             |
-| VMD      | Variational Mode Decomposition                                              |   `Function.VMD(signal)`    |                                                                                                                             [10.1016/j.sigpro.2020.107610](https://www.sciencedirect.com/science/article/abs/pii/S0165168420301535)                                                                                                                             |
+| SVMD     | Successive Variational Mode Decomposition                                   |   `Function.SVMD(signal)`   |                                                                                                                             [10.1016/j.sigpro.2020.107610](https://www.sciencedirect.com/science/article/abs/pii/S0165168420301535)                                                                                                                             |
+| VMD      | Variational Mode Decomposition                                              |   `Function.VMD(signal)`    |                                                                                                                                            [10.1109/TSP.2013.2288675](https://ieeexplore.ieee.org/document/6655981)                                                                                                                                             |
 
 ## Install
 
 You can install by:
 ```shell
-git clone https://github.com/a-raining-day/Motal-Decomposition.git
+git clone https://github.com/a-raining-day/Modal-Decomposition.git
 cd Motal-Decomposition
 pip install -r requirements.txt
 ```
@@ -47,41 +70,19 @@ 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
+*Please pip `EMD-signal`, not `PyEMD`*
 
 ## Url
 

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

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

{modal_decomposition-0.1.2 → modal_decomposition-0.1.4}/src/Modal_Decomposition/CEEFD.py

@@ -19,7 +19,7 @@ Modify:  (must)
 
 import numpy as np
 from typing import Union, Tuple
-
+from .Utils import Check_Time_and_Signal
 
 class ceefd:
     """CEEFD: Cyclic Envelop Empirical Fourier Decomposition"""
@@ -60,39 +60,18 @@ class ceefd:
 
         return imf, mask
 
-    def decompose(self, S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None) -> Tuple[np.ndarray, np.ndarray]:
+    def decompose(self, S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None) -> Tuple[np.ndarray, np.ndarray, None]:
         """
         CEEFD: Cyclic Envelope Empirical Fourier Decomposition
 
         :param S: Signal
         :param T: Time-axis, accepted formation is Unix array. Default uniformly sample.
-        :return: IMFs (2-dim), Res (1-dim)
+        :return: IMFs (2-dim), Res (1-dim), None
         """
 
         from scipy.signal import find_peaks
 
-        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)
+        S, T, N = Check_Time_and_Signal(S, T)
 
         fft_signal = np.fft.fft(S)
         mag_spectrum = np.abs(fft_signal[:N // 2 + 1])
@@ -132,4 +111,4 @@ class ceefd:
         if np.abs(residual).max() > 1e-10:
             imfs.append(residual)
 
-        return np.array(imfs), residual
+        return np.array(imfs), residual, None

modal_decomposition-0.1.4/src/Modal_Decomposition/CEEMD.py

@@ -0,0 +1,103 @@
+"""
+Python version:  (must)
+    3.10.11
+
+Lib and Version:  (if None write None)
+    numpy - 2.2.6
+	time - 1.39.2
+	tqdm - 4.67.3
+
+Only accessed by:  (must)
+    Only __init__.py
+
+Description: (if None write None)
+    Realize the CEEMD.
+
+Modify:  (must)
+    2026.3.25 - Create
+    2026.4.2  - Finish the Optimization of the CEEMD.
+    2026.5.1  - Fix the error of the decomposition.
+"""
+
+from typing import Union, Tuple, Optional
+import numpy as np
+from .EMD import emd
+from .Utils import monotonic_increasing, monotonic_decreasing, Check_Time_and_Signal
+from warnings import warn
+
+
+def ceemd(S: Union[list, np.ndarray], T: Union[list, np.ndarray] = None, N_whitenoise=37, beta=0.2, max_imf: Optional[int] = None, dead_line: int = 10, verbose: bool = False) \
+        -> Tuple[np.ndarray, np.ndarray, None]:
+    """
+        CEEMD: Complementary 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,), None
+        """
+
+    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")
+
+    S, T, N = Check_Time_and_Signal(S, T, verbose)
+
+    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)), 2)):
+        warn("The T is not uniform! Some error may happen.")
+
+    if max_imf is None:
+        max_imf = int(np.log2(len(S))) + 2
+
+    imfs = []
+    residual = S.copy()
+    k = 0
+    dead_cycle = 0
+
+    while True:
+        if max_imf != -1 and k >= max_imf:
+            break
+
+        imf_candidates = []
+        std_dev = np.std(residual)
+
+        for i in range(N_whitenoise):
+            white_noise = np.random.normal(0, std_dev * beta, N)
+            S_plus = residual + white_noise
+            S_minus = residual - white_noise
+
+            imfs_plus, _, _ = emd(S_plus, T, max_imf=1)
+            imfs_minus, _, _ = emd(S_minus, T, max_imf=1)
+
+            if len(imfs_plus) > 0 and len(imfs_minus) > 0:
+                imf_candidate = (imfs_plus[0] + imfs_minus[0]) / 2.0
+                imf_candidates.append(imf_candidate)
+
+        if not imf_candidates:
+            dead_cycle += 1
+            if dead_cycle >= dead_line:
+                raise RuntimeError("Trapped in a vicious cycle")
+            continue
+
+        imf = np.mean(imf_candidates, axis=0)
+        imfs.append(imf)
+        residual = residual - imf
+        k += 1
+
+        from scipy.signal import argrelextrema
+        peaks = argrelextrema(residual, np.greater)[0]
+        valleys = argrelextrema(residual, np.less)[0]
+
+        if monotonic_increasing(residual) or monotonic_decreasing(residual) or len(peaks) + len(valleys) < 3:
+            break
+
+    return np.array(imfs), np.array(residual), None

{modal_decomposition-0.1.2 → modal_decomposition-0.1.4}/src/Modal_Decomposition/CEEMDAN.py

@@ -1,5 +1,24 @@
+"""
+Python version:  (must)
+    3.10.11
+
+Lib and Version:  (if None write None)
+    numpy - 2.2.6
+
+Only accessed by:  (must)
+    Only __init__.py
+
+Description: (if None write None)
+    Realize the CEEMDAN.
+
+Modify:  (must)
+    2026.3.25 - Create.
+"""
+
 from typing import Union, Tuple
 import numpy as np
+from .Utils import Check_Time_and_Signal
+
 
 def ceemdan \
     (
@@ -18,7 +37,7 @@ def ceemdan \
         noise_kind='normal',  # noise kind: 'normal', 'uniform'
         range_thr=0.01,  # Stop threshold
         total_power_thr=0.005
-    ) -> Tuple[np.ndarray, np.ndarray]:
+    ) -> Tuple[np.ndarray, np.ndarray, None]:
 
     """
     CEEMDAN: Complete Ensemble Empirical Mode Decomposition with Adaptive Noise
@@ -39,33 +58,11 @@ def ceemdan \
     :param noise_kind:
     :param range_thr:
     :param total_power_thr:
-    :return: IMFs (n_IMFs, N), Res (N,)
+    :return: IMFs (n_IMFs, N), Res (N,), None
     """
-
     from PyEMD import CEEMDAN
 
-    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)
+    S, T, N = Check_Time_and_Signal(S, T)
 
     CEEMDAN = CEEMDAN \
     (
@@ -89,4 +86,4 @@ def ceemdan \
     IMFs = IMF_Residue[:-1, :]  # shape [n_imfs, len(S)]
     Res = IMF_Residue[-1, :]
 
-    return IMFs, Res
+    return IMFs, Res, None

modal_decomposition-0.1.4/src/Modal_Decomposition/EEMD.py

@@ -0,0 +1,58 @@
+"""
+Python version:  (must)
+    3.10.11
+
+Lib and Version:  (if None write None)
+    numpy - 2.2.6
+
+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
+from .Utils import Check_Time_and_Signal
+
+
+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,
+    parallel: bool = False,
+    **kwargs
+) -> Tuple[np.ndarray, np.ndarray, None]:
+    """
+    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 S std.
+    :param max_imf: Max number of IMFs to extract. -1 for all.
+    :param parallel: Parallelize the EEMD.
+    :param kwargs: Additional parameters passed to PyEMD.EEMD.
+    :return: IMFs (n_IMFs, N), Res (N,)
+    """
+    from PyEMD import EEMD
+
+    S, T, N = Check_Time_and_Signal(S, T)
+
+    decomposer = EEMD(trials=trials, noise_width=noise_width, parallel=parallel, **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, None

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

@@ -17,21 +17,23 @@ 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
-from .COLOR import printc
 from typing import Union, Tuple
+from .Utils import Check_Time_and_Signal
 
 
-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, None]:
     """
     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
-    :return: IMFs (n_IMFs, N), Res: (N,)
+    :param verbose: if print the info?
+    :return: IMFs (n_IMFs, N), Res: (N,), None
     """
 
     from scipy.signal import argrelmax
@@ -43,31 +45,7 @@ def efd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, max_IMFs: i
         if max_IMFs <= 0:
             raise ValueError("Invalid value! Do you want use -1?")
 
-    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) != N:
-        raise ValueError(f"len of T: ({len(T)}) doesn't match ({N})")
+    S, T, N = Check_Time_and_Signal(S, T, verbose)
 
     dt = np.diff(T)
     if not np.allclose(dt, dt[0], rtol=1e-10, atol=1e-14):
@@ -78,7 +56,7 @@ def efd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, max_IMFs: i
     S: np.ndarray = S - np.mean(S)
 
     F = np.fft.fft(S)
-    # fs = np.fft.fftfreq(N // 2 + 1, d=T[1]-T[0])  # only positive freq arr
+    # fs = np.fft.fftfreq(N // 2 + 1, d=T[1]-T[0])  # only positive freq S
     magnitude = np.abs(F)
     phase = np.angle(F)
 
@@ -86,14 +64,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 +89,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)):
@@ -140,4 +117,4 @@ def efd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, max_IMFs: i
         IMFs.append(np.fft.ifft(full_spectrum).real)
 
     IMFs = np.array(IMFs)
-    return IMFs, S - np.sum(IMFs, axis=0) + MEAN
+    return IMFs, S - np.sum(IMFs, axis=0) + MEAN, None