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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Modal-Decomposition
-Version: 0.1.3
+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)                                                                                                                                                                      |
@@ -61,14 +84,14 @@ All entrance of functions or class are stored in `Modal_Decomposition/__init__.p
 | 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
 ```
@@ -91,6 +114,8 @@ This lib's dependence are:
 
 *Other dependence please read "requirements.txt"*
 
+*Please pip `EMD-signal`, not `PyEMD`*
+
 ## Url
 
 This lib's url is: https://github.com/a-raining-day/Modal-Decomposition

{modal_decomposition-0.1.3 → 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)                                                                                                                                                                      |
@@ -29,14 +52,14 @@ All entrance of functions or class are stored in `Modal_Decomposition/__init__.p
 | 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
 ```
@@ -59,6 +82,8 @@ This lib's dependence are:
 
 *Other dependence please read "requirements.txt"*
 
+*Please pip `EMD-signal`, not `PyEMD`*
+
 ## Url
 
 This lib's url is: https://github.com/a-raining-day/Modal-Decomposition

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

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

{modal_decomposition-0.1.3 → 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.3 → 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.3 → modal_decomposition-0.1.4}/src/Modal_Decomposition/EEMD.py

@@ -3,7 +3,7 @@ Python version:  (must)
     3.10.11
 
 Lib and Version:  (if None write None)
-    EMD-S - 1.9.0
+    numpy - 2.2.6
 
 Only accessed by:  (must)
     Only __init__.py
@@ -20,6 +20,8 @@ Modify:  (must)
 
 import numpy as np
 from typing import Union, Tuple, Optional
+from .Utils import Check_Time_and_Signal
+
 
 def eemd(
     S: Union[list, np.ndarray],
@@ -27,8 +29,9 @@ def eemd(
     trials: int = 100,
     noise_width: float = 0.05,
     max_imf: int = -1,
+    parallel: bool = False,
     **kwargs
-) -> Tuple[np.ndarray, np.ndarray]:
+) -> Tuple[np.ndarray, np.ndarray, None]:
     """
     EEMD: Ensemble Empirical Mode Decomposition
     (Standard implementation via PyEMD)
@@ -36,29 +39,20 @@ def eemd(
     :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 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
 
-    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)
+    S, T, N = Check_Time_and_Signal(S, T)
 
-    decomposer = EEMD(trials=trials, noise_width=noise_width, **kwargs)
+    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
+    return IMFs, Res, None

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

@@ -21,11 +21,11 @@ Modify:  (must)
 """
 
 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, verbose: bool=False) -> 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
 
@@ -33,7 +33,7 @@ def efd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, max_IMFs: i
     :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,)
+    :return: IMFs (n_IMFs, N), Res: (N,), None
     """
 
     from scipy.signal import argrelmax
@@ -45,32 +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
-        if verbose:
-            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):
@@ -81,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)
 
@@ -142,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

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

@@ -14,15 +14,15 @@ Description: (if None write None)
 
 Modify:  (must)
     2026.3.25 - Create.
+    2026.5.1  - Change the position of import PyEMD.
 """
 
-from PyEMD import EMD
 import numpy as np
 from typing import Tuple, Union
-
+from .Utils import Check_Time_and_Signal
 
 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]:
+        -> Tuple[np.ndarray, np.ndarray, None]:
     """
     EMD: Empirical Mode Decomposition
 
@@ -32,31 +32,11 @@ def emd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, spline_kind
     :param nbsym:
     :param max_imf: the max num of IMFs
     :param verbose: True will print info, else no.
-    :return: IMFs (2-dim), Res (1-dim)
+    :return: IMFs (n_IMFs, N), Res (N,), None
     """
-    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
-        if verbose:
-            print(f"Warn: T is None，default T = [0, 1, 2, ..., {N - 1}]")
+    from PyEMD import EMD
 
-    else:
-        if not isinstance(T, np.ndarray):
-            T = np.array(T)
+    S, T, N = Check_Time_and_Signal(S, T, verbose)
 
     EMD_cls = EMD(spline_kind, nbsym)
 
@@ -71,4 +51,4 @@ def emd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, spline_kind
     elif IMFs.ndim == 0:
         IMFs = np.zeros((1, Res.shape[1]))
 
-    return IMFs, Res
+    return IMFs, Res, None

modal_decomposition-0.1.4/src/Modal_Decomposition/EWT.py

@@ -0,0 +1,62 @@
+"""
+Python version:  (must)
+    3.10.11
+
+Lib and Version:  (if None write None)
+    ewtpy - 0.2
+	numpy - 2.2.6
+
+Only accessed by:  (must)
+    Only __init__.py
+
+Description: (if None write None)
+    Realize the EWT
+
+Modify:  (must)
+    2026.3.25 - Create.
+    2026.5.1  - Use dict to store other informations.
+"""
+
+from typing import Any, Union
+import numpy as np
+from .Utils import Check_Time_and_Signal
+
+def ewt \
+(
+    S: Union[list, np.ndarray],
+    N: int = 5,
+    log: int = 0,
+    detect: str = "locmax",
+    completion: int = 0,
+    reg: str = 'average',
+    lengthFilter: int = 10,
+    sigmaFilter: int = 5,
+) -> Union[np.ndarray, np.ndarray, dict[str, Any]]:
+    """
+    EWT: Empirical Wavelet Transform
+
+    :param S: Signal (1-dim)
+    :param N:
+    :param log:
+    :param detect:
+    :param completion:
+    :param reg:
+    :param lengthFilter:
+    :param sigmaFilter:
+    :return: IMFs(N, len(S)), Res(N,), Info(dict)
+    """
+    from ewtpy import EWT1D
+
+    S, _, _ = Check_Time_and_Signal(S)
+
+    ewt, mfb, boundaries = EWT1D(S, N, log, detect, completion, reg, lengthFilter, sigmaFilter)
+    ewt: np.ndarray = ewt.T
+    mfb = mfb.T
+
+    Info = \
+    {
+        "MFB": mfb,
+        "Boundaries": boundaries
+    }
+
+    return ewt[:-1, :], ewt[-1, :], Info