Modal-Decomposition 0.0.2__tar.gz → 0.0.3__tar.gz

{modal_decomposition-0.0.2 → modal_decomposition-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Modal-Decomposition
-Version: 0.0.2
+Version: 0.0.3
 Summary: a package for modal decomposition
 Author-email: Mao_HaoChuan <2215269365@qq.com>
 License: Apache-2.0

{modal_decomposition-0.0.2 → modal_decomposition-0.0.3}/pyproject.toml

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

{modal_decomposition-0.0.2 → modal_decomposition-0.0.3}/src/Modal_Decomposition/CEEFD.py

@@ -16,6 +16,7 @@ Description: (if None write None)
 """
 
 import numpy as np
+from typing import Union, Tuple
 
 class CEEFD:
     """
@@ -74,7 +75,32 @@ class CEEFD:
                 total_power_thr=self.total_power_thr
             )
 
-    def ceemdan(self, S, T=None, max_imf=-1):
+    def ceemdan(self, S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, max_imf: int=-1, fs=None) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        :param S: Signal (1-dim)
+        :param T: Time axis (1-dim)
+        :param max_imf: the num of the decomposed IMFs. | -1 means all.
+        :param fs: the f of Time.f default 1.
+        :return: IMFs (2-dim), Res (1-dim)
+        """
+
+        if not isinstance(S, np.ndarray):
+            S = np.array(S)
+
+        N = len(S)
+
+        if T is None:
+            if fs is not None:
+                dt = 1.0 / fs  # smaple for time axis
+                T = np.arange(N) * dt
+            else:
+                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)
+
         CEEMDAN = self.give_ceemdan()
         IMF_Residue = CEEMDAN.ceemdan(S, T, max_imf)
 
@@ -83,13 +109,35 @@ class CEEFD:
 
         return IMFs, Res
 
-    def ceefd(self, S, T=None, max_imf=-1):
+    def ceefd(self, S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, max_imf: int=-1, fs=1) -> [np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
         """
-        :return: other_IMFs (ndarray-2D), IMF_ (np.ndarray-2D), Res (ndarray), Res_ (ndarray)
+        Give S, use CEEMDAN(s), get CEEMDAN-IMFs and CEEMDAN-Res, use EFD for the max sample entropy IMF, get EFD-IMFs and EFD-Res.
+        :param S: Signal (1-dim)
+        :param T: Time axis (1-dim)
+        :param max_imf: decomposition's result | if -1, decompose entirely.
+        :param fs: the f of Time. default 1.
+        :return: CEEMDAN_IMFs (2-dim), EFD_IMFs (2-dim), CEEMDAN_Res (1-dim), EFD_Res (1-dim)
         """
         from .EFD import EFD
         import antropy as ant
 
+        if not isinstance(S, np.ndarray):
+            S = np.ndarray(S)
+
+        N = len(S)
+
+        if T is None:
+            if fs is not None:
+                dt = 1.0 / fs  # smaple for time axis
+                T = np.arange(N) * dt
+            else:
+                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)
+
         CEEMDAN = self.give_ceemdan()
         IMF_Residue = CEEMDAN.ceemdan(S, T, max_imf)
 

{modal_decomposition-0.0.2 → modal_decomposition-0.0.3}/src/Modal_Decomposition/CEEMD.py

@@ -17,6 +17,7 @@ Description: (if None write None)
     Realize the CEEMD.
 """
 
+from typing import Union, Tuple
 from time import sleep
 import numpy as np
 from .EMD import emd
@@ -25,17 +26,17 @@ from tqdm import tqdm
 import sys
 
 
-def ceemd(S, T=None, fs=None, beta=0.3, max_imf=None, iterations=30, verbose: bool=False):
+def ceemd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, fs=None, beta=0.3, max_imf=None, iterations=30, verbose: bool=False) \
+        -> Tuple[np.ndarray, np.ndarray]:
     """
-
-    :param S:
-    :param T:
-    :param fs:
+    :param S: Signal (1-dim)
+    :param T: the time axis.
+    :param fs: the f of Time. default 1.
     :param beta:
-    :param max_imf: -1 or other int | 100 is enough, if you choose -1, no one kown when it will finish(^_^)
+    :param max_imf: -1 or other int | 100 is enough, if you choose -1, no one kown when finish(^_^)
     :param iterations:
     :param verbose:
-    :return:
+    :return: IMFs (2-dim), Res (1-dim)
     """
     N = len(S)
 

modal_decomposition-0.0.3/src/Modal_Decomposition/EEMD.py

@@ -0,0 +1,35 @@
+"""
+Python version:  (must)
+    3.10.11
+
+Lib and Version:  (if None write None)
+    EMD-signal - 1.9.0
+
+Only accessed by:  (must)
+    Only __init__.py
+
+Modify:  (must)
+    2026.3.25
+
+Description: (if None write None)
+    Realize the EEMD.
+"""
+import numpy as np
+from PyEMD import EEMD
+from typing import Union, Tuple
+
+Origin_EEMD = EEMD
+
+EEMD = EEMD()
+def eemd(S: Union[list, np.ndarray]) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    :param S: Signal (1-dim)
+    :return: IMFs (2-dim), Res (1-dim)
+    """
+    if not isinstance(S, np.ndarray):
+        S = np.array(S)
+
+    IMFs = EEMD.eemd(S)
+    Res = EEMD.residue
+
+    return IMFs, Res

{modal_decomposition-0.0.2 → modal_decomposition-0.0.3}/src/Modal_Decomposition/EFD.py

@@ -20,12 +20,15 @@ Description: (if None write None)
 
 import numpy as np
 from .COLOR import printc
+from typing import Union, Tuple
 
-def EFD(S, T=None, fs=None):
+
+def EFD(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, fs=None) -> Tuple[np.ndarray, np.ndarray]:
     """
     :param S: Signal (1-dim)
-    :param T: Time axis (uniform spacing)
-    :return: IMFs: np.ndarray (2-dim) | Res: np.ndarray (1-dim)
+    :param T: Time axis (1-dim)
+    :param fs: the f of T (default fs = 1)
+    :return: IMFs 2-dim | Res: 1-dim
     """
     from scipy.signal import find_peaks
 
@@ -42,6 +45,10 @@ def EFD(S, T=None, fs=None):
             T = np.arange(N)  # default fs = 1
             printc(f"Warn: T is None，default T = [0, 1, 2, ..., {N - 1}]", color="red")
 
+    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})")
 

{modal_decomposition-0.0.2 → modal_decomposition-0.0.3}/src/Modal_Decomposition/EMD.py

@@ -19,19 +19,20 @@ Description: (if None write None)
 from PyEMD import EMD
 import numpy as np
 from .COLOR.colorful_print import printc
-from typing import Tuple
+from typing import Tuple, Union
 
 EMD_cls = EMD
 
-def emd(S, T=None, spline_kind: str = "cubic", nbsym: int = 2, max_imf=-1, fs=None) -> Tuple[np.ndarray, np.ndarray]:
+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)\
+        -> Tuple[np.ndarray, np.ndarray]:
     """
-    :param S:
-    :param T:
-    :param spline_kind:
+    :param S: Signal (1-dim)
+    :param T: Time axis (1-dim)
+    :param spline_kind: the kind of spline. default cubic.
     :param nbsym:
-    :param max_imf:
-    :param fs:
-    :return: IMFs (2-dim), Res: None
+    :param max_imf: the max num of IMFs
+    :param fs: the f of T. default 1.
+    :return: IMFs (2-dim), Res (1-dim)
     """
     if not isinstance(S, np.ndarray):
         S = np.array(S)

{modal_decomposition-0.0.2 → modal_decomposition-0.0.3}/src/Modal_Decomposition/EWT.py

@@ -21,7 +21,7 @@ import numpy as np
 
 def ewt \
 (
-    S,
+    S: Union[list, np.ndarray],
     N: int = 5,
     log: int = 0,
     detect: str = "locmax",
@@ -32,7 +32,7 @@ def ewt \
     need_mfd: bool = False,
     need_boundaries: bool = False) -> Union[Tuple[np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]]:
     """
-    :param S: Signal
+    :param S: Signal (1-dim)
     :param N:
     :param log:
     :param detect:
@@ -44,6 +44,9 @@ def ewt \
     """
     from ewtpy import EWT1D
 
+    if not isinstance(S, np.ndarray):
+        S = np.array(S)
+
     ewt, mfb, boundaries = EWT1D(S, N, log, detect, completion, reg, lengthFilter, sigmaFilter)
     ewt = ewt.T
     mfb = mfb.T

{modal_decomposition-0.0.2 → modal_decomposition-0.0.3}/src/Modal_Decomposition/FMD.py

@@ -18,6 +18,7 @@ Description: (if None write None)
 """
 
 import numpy as np
+from typing import Union
 
 def initialize_filters(L, K):
     from scipy.signal import firwin
@@ -41,7 +42,7 @@ def estimate_period(signal):
        period = len(signal)
     return period
 
-def fmd(S, n=10, L=100, max_iters=10):
+def fmd(S: Union[list, np.ndarray], n=10, L=100, max_iters=10) -> np.ndarray:
     """
     :param S: Signal (2-dim)
     :param n: store n IMFs
@@ -66,4 +67,4 @@ def fmd(S, n=10, L=100, max_iters=10):
        if len(modes) >= n:
            break
 
-    return modes[:n]
+    return np.array(modes[:n])

{modal_decomposition-0.0.2 → modal_decomposition-0.0.3}/src/Modal_Decomposition/ICEEMDAN.py

@@ -19,27 +19,41 @@ Description: (if None write None)
 import numpy as np
 from .EMD import emd
 from .help_function import is_increasing
+from typing import Union, Tuple
 
 
-def iceemdan(S, T=None, Ne=300, epsilon_0=None, max_imf=None, verbose: bool=False, spline_kind: str = "cubic", nbsym: int = 2, emd_max_imf=-1, fs=None):
+def iceemdan(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, Ne=300, epsilon_0=None, max_imf=None, verbose: bool=False, spline_kind: str = "cubic", nbsym: int = 2, emd_max_imf=-1, fs=None)\
+        -> Tuple[np.ndarray, np.ndarray]:
     """
-    :param emd_max_imf:
-    :param nbsym:
-    :param spline_kind:
-    :param verbose: is print formation
     :param S: Signal (1-dim)
+    :param T: Time axis (1-dim)
     :param Ne: total num of samples (times of add noise), default 300
     :param epsilon_0: initial amplitude of noise，default: 0.2 * std(S) / std(noise)
     :param max_imf: max num of IMFs
-    :return: IMFs, Res
+    :param verbose: dose print formation
+    :param spline_kind: the kind of spline. default cubic
+    :param nbsym:
+    :param emd_max_imf: the max num of IMFs with EMD
+    :param fs: the f of T, default 1.
+    :return: IMFs (2-dim), Res (1-dim)
     """
 
     if not isinstance(S, np.ndarray):
         S = np.array(S)
 
     T_len = len(S)
+
     if T is None:
-        T = np.arange(0, T_len, 1)
+        if fs is not None:
+            dt = 1.0 / fs  # smaple for time axis
+            T = np.arange(T_len) * dt
+        else:
+            T = np.arange(T_len)  # default fs = 1
+            print(f"Warn: T is None，default T = [0, 1, 2, ..., {T_len - 1}]")
+
+    else:
+        if not isinstance(T, np.ndarray):
+            T = np.array(T)
 
     white_noise = np.random.randn(Ne, T_len)  # generate Ne white nose
 

{modal_decomposition-0.0.2 → modal_decomposition-0.0.3}/src/Modal_Decomposition/LMD.py

@@ -22,15 +22,15 @@ Modify:
 
 import numpy as np
 from .help_function import is_increasing
+from typing import Union, Tuple
 
-
-def lmd(S, max_pf=None, max_iter=37, eps=0.05):
+def lmd(S: Union[list, np.ndarray], max_pf=None, max_iter=37, eps=0.05) -> Tuple[np.ndarray, np.ndarray]:
     """
     :param S: Signal (1-dim)
     :param max_pf: max num of pfs
     :param max_iter: max iterations of each pf
     :param eps: therhold
-    :return: PFs, Res
+    :return: PFs (2-dim), Res (1-dim)
     """
     import scipy.interpolate as ip
     from scipy.signal import argrelextrema

{modal_decomposition-0.0.2 → modal_decomposition-0.0.3}/src/Modal_Decomposition/MEMD.py

@@ -17,16 +17,17 @@ Description: (if None write None)
 """
 
 import numpy as np
+from typing import Union, Tuple
 
-def memd(S, d=None, k=None, max_imf=None, sd_thresh=0.2, max_iter=10):
+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]:
     """
-    :param S: Signal，(d, N)，d -> channels，N -> time points
+    :param S: Signal (2-dim), (d, N) | d -> channels,N -> time points
     :param d: channels or dimensions
     :param k: number of directional vector,default: d * 128
     :param max_imf: max num of IMFs
     :param sd_thresh: therahold
     :param max_iter: max iterations of each IMF
-    :return: IMFs -> (n_imfs, d, N)
+    :return: IMFs (d, N), Res (2-dim)
     """
 
     if not isinstance(S, np.ndarray):

{modal_decomposition-0.0.2 → modal_decomposition-0.0.3}/src/Modal_Decomposition/RPSEMD.py

@@ -19,19 +19,20 @@ import numpy as np
 from .help_function import is_increasing
 from .EMD import emd
 from .COLOR import printc
+from typing import Union, Tuple
 
-def rpsemd(S, T=None, f=None, M=4, max_imf=None, fs=1.0, spline_kind: str = "cubic", nbsym: int = 2, emd_max_imf=-1):
+def rpsemd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, f=None, M=4, max_imf=None, fs=1.0, spline_kind: str = "cubic", nbsym: int = 2, emd_max_imf=-1) -> Tuple[np.ndarray, np.ndarray]:
     """
-    :param emd_max_imf:
-    :param nbsym:
-    :param spline_kind:
-    :param fs:
+    :param S: Signal (1-dim)
     :param T: time axis
-    :param max_imf: max num of IMFs
-    :param S: Signal
     :param f: auxiliary sine wave frequency
     :param M: num of phases
-    :return: IMFs, Res -> np.ndarray(2-dim)
+    :param max_imf: max num of IMFs
+    :param fs: the f of Time. default 1.
+    :param spline_kind: the kind of spline. default cubic spline.
+    :param nbsym:
+    :param emd_max_imf: the max IMFs of EMD
+    :return: IMFs (2-dim), Res (1-dim)
     """
 
     if not isinstance(S, np.ndarray):
@@ -52,6 +53,10 @@ def rpsemd(S, T=None, f=None, M=4, max_imf=None, fs=1.0, spline_kind: str = "cub
         T = np.arange(len(S))
         print(f"warn：T is None | deault：T = 0, 1, 2, ..., {len(S) - 1}")
 
+    else:
+        if not isinstance(T, np.ndarray):
+            T = np.array(T)
+
     phi = np.array([2.0 * np.pi * i / M for i in range(M)])
 
     IMFs = []

{modal_decomposition-0.0.2 → modal_decomposition-0.0.3}/src/Modal_Decomposition/SSA.py

@@ -18,7 +18,7 @@ Description: (if None write None)
 """
 
 import numpy as np
-from typing import Tuple, Callable
+from typing import Union
 
 class SSA:
     def __init__(self, window_size=None):
@@ -32,15 +32,16 @@ class SSA:
         self.U_ = None
         self.V_ = None
 
-    def decompose(self, S, groups=None) -> Tuple[np.ndarray, np.ndarray]:
+    def decompose(self, S: Union[list, np.ndarray], groups=None) -> np.ndarray:
         """
-        :parameter:
-        S: Signal
-        groups: group information, such as: [[0], [1,2], [3,4]] means which components will be merged. If None, return all
+        :param S: Signal (1-dim)
+        :param groups: group information, such as: [[0], [1,2], [3,4]] means which components will be merged. If None, return all
 
-        :return:
-        RCs: IMFs Matrix | each row is a IMF
+        :return: IMFs (2-dim)
         """
+        if not isinstance(S, np.ndarray):
+            S = np.array(S)
+
         series = np.asarray(S).flatten()
         N = len(series)
 
@@ -89,7 +90,7 @@ class SSA:
         self.U_ = U
         self.V_ = VT
 
-        return self.components_, np.zeros((1, self.components_.shape[1]))
+        return self.components_
 
 
 # def give_fast_SSA() -> Callable:

{modal_decomposition-0.0.2 → modal_decomposition-0.0.3}/src/Modal_Decomposition/SVMD.py

@@ -17,7 +17,7 @@ Description: (if None write None)
 """
 
 import numpy as np
-from typing import Tuple
+from typing import Tuple, Union
 
 class SVMD:
     def __init__(self, num_modes=3, alpha=2000, tol=1e-7):
@@ -43,9 +43,8 @@ class SVMD:
 
         return mode
 
-    def decompose(self, S) -> Tuple[np.ndarray, np.ndarray]:
+    def decompose(self, S: Union[list, np.ndarray]) -> Tuple[np.ndarray, np.ndarray]:
         """
-
         :param S: Signal (1-dim)
         :return: IMFs(2-dim), Res(1-dim)
         """

{modal_decomposition-0.0.2 → modal_decomposition-0.0.3}/src/Modal_Decomposition/VMD.py

@@ -15,7 +15,11 @@ Description: (if None write None)
     Realize VMD by using vmdpy lib.
 """
 
-def vmd(S, alpha = 2000, tau = 0.0, K = 2, DC = 0, init = 1, tol = 1e-7):
+from typing import Union, Tuple
+import numpy as np
+
+
+def vmd(S: Union[list, np.ndarray], alpha = 2000, tau = 0.0, K = 2, DC = 0, init = 1, tol = 1e-7) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
     """
     :param S: Signal (1-dim)
     :param alpha: broadband constraints
@@ -24,10 +28,13 @@ def vmd(S, alpha = 2000, tau = 0.0, K = 2, DC = 0, init = 1, tol = 1e-7):
     :param DC: is included directional component
     :param init: way of initial
     :param tol: convergence threshold
-    :return:
+    :return: IMFs (2-dim), u_hat (2-dim), omega (1-dim)
     """
     from vmdpy import VMD
 
+    if not isinstance(S, np.ndarray):
+        S = np.array(S)
+
     u, u_hat, omega = VMD(S, alpha, tau, K, DC, init, tol)
 
     return u, u_hat, omega

{modal_decomposition-0.0.2 → modal_decomposition-0.0.3}/src/Modal_Decomposition/__init__.py

@@ -24,7 +24,8 @@ Description: (if None write None)
     As the entrance of the lib
 
 Modify:
-    Optimize the cost of import, from 5.001s to 0.747s. Put some heavy lib into internal of the function
+    2026.3.25 - Optimize the cost of import, from 5.001s to 0.747s. Put some heavy lib into internal of the function
+    2026.3.26 - Optimize the description of the type of input and output. now, the dim of input and output is more clear.
 """
 from .help_function import is_increasing
 
@@ -66,6 +67,7 @@ class Class:
 
 class Function:
     # function | default function for modal decomposition
+    # the IMFs (2-dim) means: (K, len(Signal)) (K is the num of IMFs)
     EFD = EFD
     CEEFD = ceefd_real_cls.ceefd
     CEEMDAN = ceefd_real_cls.ceemdan

{modal_decomposition-0.0.2 → modal_decomposition-0.0.3}/src/Modal_Decomposition.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Modal-Decomposition
-Version: 0.0.2
+Version: 0.0.3
 Summary: a package for modal decomposition
 Author-email: Mao_HaoChuan <2215269365@qq.com>
 License: Apache-2.0

modal_decomposition-0.0.2/src/Modal_Decomposition/EEMD.py

@@ -1,24 +0,0 @@
-"""
-Python version:  (must)
-    3.10.11
-
-Lib and Version:  (if None write None)
-    EMD-signal - 1.9.0
-
-Only accessed by:  (must)
-    Only __init__.py
-
-Modify:  (must)
-    2026.3.25
-
-Description: (if None write None)
-    Realize the EEMD.
-"""
-
-from PyEMD import EEMD
-
-Origin_EEMD = EEMD
-
-EEMD = EEMD()
-def eemd(S):
-    return EEMD.eemd(S)