Modal-Decomposition 0.0.1__py3-none-any.whl

Modal_Decomposition/CEEFD.py

@@ -0,0 +1,118 @@
+"""
+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 CEEFD and CEEMDAN.
+"""
+
+import numpy as np
+
+class CEEFD:
+    """
+    CEEFD
+    """
+
+    def __init__ \
+        (
+            self,
+            trials=10,
+            noise_width=0.05,  # default: 0.05-0.3
+            noise_seed=42,  # seed
+            spline_kind='cubic',
+            nbsym=2,  # Number of boundary symmetry points
+            extrema_detection='parabol',
+            parallel=False,
+            processes=None,  # None = auto, int >= 1
+            random_state=42,
+            noise_scale=1.0,  # scale factor of noise
+            noise_kind='normal',  # noise kind: 'normal', 'uniform'
+            range_thr=0.01,  # Stop threshold
+            total_power_thr=0.005
+        ):
+
+        self.trials = trials
+        self.noise_width = noise_width
+        self.noise_seed = noise_seed
+        self.spline_kind = spline_kind
+        self.nbsym = nbsym
+        self.extrema_detection = extrema_detection
+        self.parallel = parallel
+        self.processes = processes
+        self.random_state = random_state
+        self.noise_scale = noise_scale
+        self.noise_kind = noise_kind
+        self.range_thr = range_thr
+        self.total_power_thr = total_power_thr
+
+    def give_ceemdan(self):
+        from PyEMD import CEEMDAN
+
+        return CEEMDAN \
+            (
+                trials=self.trials,
+                noise_width=self.noise_width,
+                noise_seed=self.noise_seed,
+                spline_kind=self.spline_kind,
+                nbsym=self.nbsym,
+                extrema_detection=self.extrema_detection,
+                parallel=self.parallel,
+                processes=self.processes,
+                random_state=self.random_state,
+                noise_scale=self.noise_scale,
+                noise_kind=self.noise_kind,
+                range_thr=self.range_thr,
+                total_power_thr=self.total_power_thr
+            )
+
+    def ceemdan(self, S, T=None, max_imf=-1):
+        CEEMDAN = self.give_ceemdan()
+        IMF_Residue = CEEMDAN.ceemdan(S, T, max_imf)
+
+        IMFs = IMF_Residue[:-1, :]  # shape [n_imfs, len(S)]
+        Res = IMF_Residue[-1, :]
+
+        return IMFs, Res
+
+    def ceefd(self, S, T=None, max_imf=-1):
+        """
+        :return: other_IMFs (ndarray-2D), IMF_ (np.ndarray-2D), Res (ndarray), Res_ (ndarray)
+        """
+        from .EFD import EFD
+        import antropy as ant
+
+        CEEMDAN = self.give_ceemdan()
+        IMF_Residue = CEEMDAN.ceemdan(S, T, max_imf)
+
+        IMFs = IMF_Residue[:-1, :]  # shape [n_imfs, len(S)]
+        Res = IMF_Residue[-1, :]
+
+        # cal sample entropy of IMF
+        Entropy = [ant.sample_entropy(IMF) for IMF in IMFs]
+        max_entropy_mask = np.argmax(Entropy)
+        maxIMF = IMFs[max_entropy_mask]
+
+        # EMD for max antropy IMF
+        if T is None:
+            T_efd = np.arange(len(maxIMF))
+        else:
+            T_efd = T
+        IMF_, Res_ = EFD(maxIMF, T_efd)
+
+        # get other_IMFs
+        other_IMFs_list = [IMF for i, IMF in enumerate(IMFs) if i != max_entropy_mask]
+        if other_IMFs_list:
+            other_IMFs = np.stack(other_IMFs_list)
+        else:
+            other_IMFs = None
+
+        return other_IMFs, np.array(IMF_), Res, Res_

Modal_Decomposition/CEEMD.py

@@ -0,0 +1,129 @@
+"""
+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
+
+Modify:  (must)
+    2026.3.25
+
+Description: (if None write None)
+    Realize the CEEMD.
+"""
+
+from time import sleep
+import numpy as np
+from .EMD import emd
+from .help_function import is_increasing
+from tqdm import tqdm
+import sys
+
+
+def ceemd(S, T=None, fs=None, beta=0.3, max_imf=None, iterations=30, verbose: bool=False):
+    """
+
+    :param S:
+    :param T:
+    :param fs:
+    :param beta:
+    :param max_imf: -1 or other int | 100 is enough, if you choose -1, no one kown when it will finish(^_^)
+    :param iterations:
+    :param verbose:
+    :return:
+    """
+    N = len(S)
+
+    if max_imf is None:
+        max_imf = int(np.log2(len(S))) + 2
+
+    if T is None:
+        if fs is not None:
+            # smaple
+            dt = 1.0 / fs
+            T = np.arange(N) * dt
+        else:
+            # default smaple f = 1
+            T = np.arange(N)
+            print(f"Warn: T is None，default T = [0, 1, 2, ..., {N - 1}]")
+
+    # Standard
+    MEAN = np.mean(S)
+    S = S - MEAN
+    STD = np.std(S)
+    S = S / STD
+
+    Res = S
+    IMFs = []
+
+    std_dev = np.std(S)
+    mean = np.mean(S)
+
+    count = 0
+    while True:
+        IMF = np.zeros(N)
+
+        if verbose:
+            for i in tqdm(range(iterations // 2), position=0, file=sys.stdout, desc="iter: "):
+                white_noise = np.random.normal(mean, std_dev * beta, N)
+
+                S_plus = Res + white_noise
+                S_minus = Res - white_noise
+
+                IMFs_plus, _ = emd(S_plus, T)
+                IMFs_minus, _ = emd(S_minus, T)
+
+                if len(IMFs_plus) == 0 or len(IMFs_minus) == 0:
+                    continue
+
+                IMFs_avg = (IMFs_plus[0, :] + IMFs_minus[0, :]) / 2
+
+                IMF += IMFs_avg
+
+        else:
+            for i in range(iterations // 2):
+                white_noise = np.random.normal(mean, std_dev * beta, N)
+
+                S_plus = Res + white_noise
+                S_minus = Res - white_noise
+
+                IMFs_plus, _ = emd(S_plus, T)
+                IMFs_minus, _ = emd(S_minus, T)
+
+                if len(IMFs_plus) == 0 or len(IMFs_minus) == 0:
+                    continue
+
+                IMFs_avg = (IMFs_plus[0, :] + IMFs_minus[0, :]) / 2
+
+                IMF += IMFs_avg
+
+        IMF = IMF / (iterations / 2)
+        IMFs.append(IMF * STD + MEAN)
+        count += 1
+
+        if verbose:
+            if count % 10 == 0:
+                tqdm.write(f"has get {count} IMFs...")
+                sleep(1)
+
+        if max_imf != -1:
+            if count >= max_imf:
+                Res = Res - IMF
+                Res = Res * STD + MEAN
+                break
+
+        Res = Res - IMF
+
+        if np.std(Res) < 1e-10 * np.std(S):
+            break
+
+        if is_increasing(Res):
+            Res = Res * STD + MEAN
+            break
+
+    return np.array(IMFs), np.array(Res)

Modal_Decomposition/COLOR/__init__.py

@@ -0,0 +1,18 @@
+"""
+Python version: 3.11
+
+Role:
+    the main entrance
+
+Lib and Version:
+    colorama - 0.4.6
+
+Only accessed by:
+    All
+
+Modify:
+    2026.3.4
+"""
+
+from .color_define import Color
+from .colorful_print import printc

Modal_Decomposition/COLOR/color_define.py

@@ -0,0 +1,30 @@
+"""
+Python version: 3.11
+
+Lib and Version:
+    colorama - 0.4.6
+
+Only accessed by:
+    __init__.py, colorful_print.py
+
+Modify:
+    2026.3.4
+"""
+
+import colorama as cm
+
+__all__ = ["Color"]
+
+Fore = cm.Fore
+
+Color = \
+{
+    "black": Fore.BLACK,
+    "red": Fore.RED,
+    "green": Fore.GREEN,
+    "yellow": Fore.YELLOW,
+    "blue": Fore.BLUE,
+    "magenta": Fore.MAGENTA,
+    "cyan": Fore.CYAN,
+    "white": Fore.WHITE,
+}

Modal_Decomposition/COLOR/colorful_print.py

@@ -0,0 +1,66 @@
+"""
+Python version: 3.11
+
+Lib and Version:
+    colorama - 0.4.6
+
+Only accessed by:
+    All
+
+Modify:
+    2026.3.4
+"""
+
+import colorama as cm
+from typing import Literal, Any
+
+__all__ = ["printc"]
+
+Fore = cm.Fore
+
+Color = \
+{
+    "black": Fore.BLACK,
+    "red": Fore.RED,
+    "green": Fore.GREEN,
+    "yellow": Fore.YELLOW,
+    "blue": Fore.BLUE,
+    "magenta": Fore.MAGENTA,
+    "cyan": Fore.CYAN,
+    "white": Fore.WHITE,
+}
+
+def printc(*values: Any, color: Literal["black", "red", "green", "yellow", "blue", "magenta", "cyan", "white"] = None, sep: str = ' ', end: str = '\n') -> bool:
+    """
+    (don't think much, just use as print)\n
+    A function that can make output be colorful.\n
+    If the function is successful, will default return True. If 'R' parameter is not change, when fail will Raise.(make 'R'=False, will return False only)\n
+    If you don't choose color or input a error parameter, default white.\n
+    kwargs: you can input 'c' to cover the "color" parameter, and use 'R' to choose whether raise the error, default is raise(R=True).\n
+    Reference Lib: colorama
+
+    :param values: Any, like values in print
+    :param color: color for output
+    :param sep: print parameter
+    :param end: print parameter
+    :return: bool: the result of print
+    """
+
+    if not hasattr(printc, '_initialized'):
+        cm.init(autoreset=True)
+        printc._initialized = True
+
+    # deal color
+    if color is None:
+        print(*values, sep=sep, end=end)
+        return True
+
+    c = Color.get(color, Color["white"])  # check and appoint color
+
+    # for values' type
+    if len(values) == 1:  # only one element been input
+        text: str = str(values[0])
+
+    text: str = sep.join(str(args) for args in values)
+
+    print(c + text, end=end)

Modal_Decomposition/EEMD.py

@@ -0,0 +1,24 @@
+"""
+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)

Modal_Decomposition/EFD.py

@@ -0,0 +1,94 @@
+"""
+Python version:  (must)
+    3.10.11
+
+Lib and Version:  (if None write None)
+    numpy - 2.2.6
+	scipy - 1.15.3
+	matplotlib - 3.10.8
+
+Only accessed by:  (must)
+    Only __init__.py
+
+Modify:  (must)
+    2026.3.25
+
+Description: (if None write None)
+    Realize the EFD.
+    Optimize the use of scipy.signal
+"""
+
+import numpy as np
+from .COLOR import printc
+
+def EFD(S, T=None, fs=None):
+    """
+    :param S: Signal (1-dim)
+    :param T: Time axis (uniform spacing)
+    :return: IMFs: np.ndarray (2-dim) | Res: np.ndarray (1-dim)
+    """
+    from scipy.signal import find_peaks
+
+    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
+            printc(f"Warn: T is None，default T = [0, 1, 2, ..., {N - 1}]", color="red")
+
+    if len(T) != N:
+        raise ValueError(f"len of T: ({len(T)}) doesn't match ({N})")
+
+    dt = np.diff(T)
+    if not np.allclose(dt, dt[0], rtol=1e-10, atol=1e-14):
+        raise ValueError("Time series should be uniform intervals")
+
+    # FFT
+    fft = np.fft.fft
+    F = fft(S)
+    freq = np.fft.fftfreq(len(T), d=T[1]-T[0])
+
+    f = np.abs(F)
+    idx = np.where(freq >= 0)[0]
+    freq_positive = freq[idx]
+    spectrum = f[idx]
+
+    # boundary
+    part_max, _ = find_peaks(spectrum)
+    part_min, _ = find_peaks(-spectrum)
+    boundary = np.concatenate([np.array([0]), part_min, part_max, np.array([len(freq_positive) - 1])])
+    boundary = np.unique(boundary)
+    boundary = np.sort(boundary)
+
+    IMFs = []
+
+    freq_set = []
+    spectrum_set = []
+
+    for b in range(1, len(boundary)):
+        down_bound = boundary[b - 1]
+        up_bound = boundary[b]
+
+        filter_mask = np.zeros(N)
+        filter_mask[N // 2 + down_bound : N // 2 + up_bound + 1] = 1
+        filter_mask[N // 2 - up_bound : N // 2 - down_bound + 1] = 1
+
+        if down_bound == 0:
+            filter_mask[N // 2 + 1 : N // 2 + up_bound + 1] = 1
+
+        F_band = F * filter_mask
+
+        IMF = np.fft.ifft(F_band)
+        IMFs.append(np.real(IMF))
+
+    sum_IMFs = np.sum(IMFs, axis=0)
+    Res: np.ndarray = np.array(S - sum_IMFs)
+    IMFs: np.ndarray = np.array(IMFs)
+
+    return IMFs, Res

Modal_Decomposition/EMD.py

@@ -0,0 +1,53 @@
+"""
+Python version:  (must)
+    3.10.11
+
+Lib and Version:  (if None write None)
+    EMD-signal - 1.9.0
+	numpy - 2.2.6
+
+Only accessed by:  (must)
+    Only __init__.py
+
+Modify:  (must)
+    2026.3.25
+
+Description: (if None write None)
+    Realize the EMD
+"""
+
+from PyEMD import EMD
+import numpy as np
+from .COLOR.colorful_print import printc
+from typing import Tuple
+
+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]:
+    """
+    :param S:
+    :param T:
+    :param spline_kind:
+    :param nbsym:
+    :param max_imf:
+    :param fs:
+    :return: IMFs (2-dim), Res: None
+    """
+    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
+            printc(f"Warn: T is None，default T = [0, 1, 2, ..., {N - 1}]", color="red")
+
+    EMD_cls = EMD(spline_kind, nbsym)
+
+    IMFs = EMD_cls.emd(S, T, max_imf=max_imf)
+
+    return IMFs[:-1, :], IMFs[-1, :]

Modal_Decomposition/EWT.py

@@ -0,0 +1,61 @@
+"""
+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
+
+Modify:  (must)
+    2026.3.25
+
+Description: (if None write None)
+    Realize the EWT
+"""
+
+from typing import Tuple, Union
+import numpy as np
+
+def ewt \
+(
+    S,
+    N: int = 5,
+    log: int = 0,
+    detect: str = "locmax",
+    completion: int = 0,
+    reg: str = 'average',
+    lengthFilter: int = 10,
+    sigmaFilter: int = 5,
+    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 N:
+    :param log:
+    :param detect:
+    :param completion:
+    :param reg:
+    :param lengthFilter:
+    :param sigmaFilter:
+    :return: IMFs(N, len(S)) (2-dim)
+    """
+    from ewtpy import EWT1D
+
+    ewt, mfb, boundaries = EWT1D(S, N, log, detect, completion, reg, lengthFilter, sigmaFilter)
+    ewt = ewt.T
+    mfb = mfb.T
+
+    if need_mfd and not need_boundaries:
+        return ewt[:-1, :], ewt[-1, :], mfb
+
+    if need_boundaries and not need_mfd:
+        return ewt[:-1, :], ewt[-1, :], boundaries
+
+    if need_mfd and need_boundaries:
+        return ewt[:-1, :], ewt[-1, :], mfb, boundaries
+
+    if not need_mfd and not need_boundaries:
+        return ewt[:-1, :], ewt[-1, :]

Modal_Decomposition/FMD.py

@@ -0,0 +1,69 @@
+"""
+Python version:  (must)
+    3.10.11
+
+Lib and Version:  (if None write None)
+    scipy - 1.15.3
+	matplotlib - 3.10.8
+	numpy - 2.2.6
+
+Only accessed by:  (must)
+    Only __init__.py
+
+Modify:  (must)
+    2026.3.25
+
+Description: (if None write None)
+    Realize the FMD
+"""
+
+import numpy as np
+
+def initialize_filters(L, K):
+    from scipy.signal import firwin
+
+    filters = []
+    for k in range(1, K + 1):
+       cutoff = 0.5 / k
+       filter = firwin(L, cutoff, window='hann')
+       filters.append(filter)
+    return filters
+
+def estimate_period(signal):
+    from scipy.signal import correlate, find_peaks
+
+    correlation = correlate(signal, signal, mode='full')
+    correlation = correlation[len(correlation) // 2:]
+    peaks, _ = find_peaks(correlation)
+    if len(peaks) > 1:
+       period = peaks[1]
+    else:
+       period = len(signal)
+    return period
+
+def fmd(S, n=10, L=100, max_iters=10):
+    """
+    :param S: Signal (2-dim)
+    :param n: store n IMFs
+    :param L:
+    :param max_iters:
+    :return:
+    """
+    from scipy.signal import lfilter
+
+    if not isinstance(S, np.ndarray):
+        S = np.array(S)
+
+    K = min(10, max(5, n))
+    filters = initialize_filters(L, K)
+    modes = []
+    S = np.array(S) if isinstance(S, list) else S
+    for i in range(max_iters):
+       for filter in filters:
+           filtered_signal = lfilter(filter, 1.0, S)
+           period = estimate_period(filtered_signal)
+           modes.append(filtered_signal)
+       if len(modes) >= n:
+           break
+
+    return modes[:n]