PySDKit 0.4.22__tar.gz → 0.4.24__tar.gz

{pysdkit-0.4.22 → pysdkit-0.4.24}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: PySDKit
-Version: 0.4.22
+Version: 0.4.24
 Summary: A Python library for signal decomposition algorithms with a unified interface.
 Home-page: https://github.com/wwhenxuan/PySDKit
-Author: whenxuan, changewam, josefinez, Yuan Feng
+Author: whenxuan, changewam, josefinez, Yuan Feng, Wentong Zhao, JacktheFowler, Deeksha Manjunath
 Author-email: wwhenxuan@gmail.com
 Keywords: signal decomposition,signal processing,machine learning
 Classifier: Development Status :: 3 - Alpha

{pysdkit-0.4.22 → pysdkit-0.4.24}/PySDKit.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: PySDKit
-Version: 0.4.22
+Version: 0.4.24
 Summary: A Python library for signal decomposition algorithms with a unified interface.
 Home-page: https://github.com/wwhenxuan/PySDKit
-Author: whenxuan, changewam, josefinez, Yuan Feng
+Author: whenxuan, changewam, josefinez, Yuan Feng, Wentong Zhao, JacktheFowler, Deeksha Manjunath
 Author-email: wwhenxuan@gmail.com
 Keywords: signal decomposition,signal processing,machine learning
 Classifier: Development Status :: 3 - Alpha

{pysdkit-0.4.22 → pysdkit-0.4.24}/pysdkit/__init__.py

@@ -2,7 +2,7 @@
 A Python library for signal decomposition algorithms.
 """
 
-__version__ = "0.4.22"
+__version__ = "0.4.24"
 
 # Empirical Mode Decomposition
 from ._emd import EMD
@@ -76,6 +76,9 @@ from ._ewt import ewt, EWT
 # Jump Plus AM-FM Mode Decomposition
 from ._jmd import JMD
 
+# Feature Mode Decomposition
+from ._fmd import FMD
+
 # Moving Average Decomposition
 from .tsa import Moving_Decomp
 
@@ -132,6 +135,7 @@ Variational Nonlinear Chirp Mode Decomposition  |    VNCMD
 Iterative Nonlinear Chirp Mode Decomposition    |    INCMD
 Empirical Wavelet Transform                     |    EWT
 Jump Plus AM-FM Mode Decomposition              |    JMD
+Feature Mode Decomposition                      |    FMD
 Moving Average Decomposition                    |    Moving
 Seasonal-Trend decomposition using LOESS        |    STL
 Hilbert-Huang Transform                         |    HHT
@@ -167,6 +171,7 @@ __all__ = [
     "ewt",
     "EWT",
     "JMD",
+    "FMD",
     "Moving_Decomp",
     "STL",
     "models",

{pysdkit-0.4.22 → pysdkit-0.4.24}/pysdkit/_emd/ceemdan.py

@@ -71,49 +71,38 @@ class CEEMDAN(object):
         :param max_iter: maximum number of decomposition iterations
         :param random_seed: create a random seed for the random number generator
         """
-        # Fixed configuration of the EMD algorithm
         self.max_imfs = max_imfs
+        self._max_imf_iters = 100
         self.trials = trials
         self.epsilon = epsilon
         self.max_iter = max_iter
 
-        # Configuration parameters related to multi-process
         self.parallel = parallel
         self.processes = processes
 
-        # Parameters for creating noise
         self.noise_scale = noise_scale
         self.noise_kind = noise_kind
         self.noise_list = ["normal", "uniform"]
-        # Whether to normalize the decomposed noise
         self.beta_progress = beta_progress
 
-        # Thresholds related to algorithm stopping
         self.range_thr = range_thr
         self.total_power_thr = total_power_thr
 
-        # Create the EMD algorithm to be integrated
         self.EMD = (
             EMD(max_imfs=max_imfs, random_seed=random_seed, max_iteration=self.max_iter)
             if ext_EMD is None
             else ext_EMD
         )
 
-        # Creating a random number generator
         self.random_seed = random_seed
         self.rng = np.random.RandomState(seed=random_seed)
 
-        # Generated noise sequence
         self.all_noises = None
-
-        # List of noises to be decomposed
         self.all_noise_EMD = []
 
-        # Record the results of this algorithm decomposition
         self.imfs = None
         self.residue = None
 
-        # Used to update the trial
         self._signal, self._time, self._seq_len, self._scale = None, None, None, None
 
     def __call__(
@@ -171,9 +160,8 @@ class CEEMDAN(object):
         else:
             all_noise_EMD = [self.EMD(noise, max_imfs=-1) for noise in self.all_noises]
 
-        # Normalize the decomposed noise sequences
         if self.beta_progress:
-            all_stds = [np.var(imfs[0]) for imfs in all_noise_EMD]
+            all_stds = [np.std(imfs[0]) for imfs in all_noise_EMD]
             all_noise_EMD = [
                 imfs / imfs_std for (imfs, imfs_std) in zip(all_noise_EMD, all_stds)
             ]
@@ -188,57 +176,45 @@ class CEEMDAN(object):
         progress: Optional[bool] = True,
     ) -> np.ndarray:
         """Perform the specified EEMD algorithm to obtain the corresponding signal decomposition results."""
-        # Length of the signal
         seq_len = len(signal)
 
-        # Generate the time array
         if time is None:
             time = get_timeline(seq_len, dtype=signal.dtype)
 
-        # Store the current signal state
         self._signal, self._time, self._seq_len = signal, time, seq_len
+        self._eemd_max_imfs = max_imfs if max_imfs is not None else self.max_imfs
 
-        if max_imfs is not None:
-            self.max_imfs = max_imfs
-
-        # For the specified number of trials, perform EMD on the signal with added white noise
         if self.parallel:
             pool = Pool(processes=self.processes)
             map_pool = pool.imap_unordered
-        else:  # Not parallel
+        else:
             map_pool = map
 
-        # Create an array to store the decomposition results
-        self.imfs = np.zeros((1, seq_len))
+        eemd_imfs = np.zeros((1, seq_len))
 
-        # Create an iterator for the decomposition process
         it = (
             iter
             if not progress
             else lambda x: tqdm(x, desc="Decomposing noise", total=self.trials)
         )
 
-        # Perform signal decomposition and store the results
         for IMFs in it(map_pool(self._update_trial, range(self.trials))):
-            if self.imfs.shape[0] < IMFs.shape[0]:
-                num_new_layers = IMFs.shape[0] - self.imfs.shape[0]
-                self.imfs = np.vstack(
-                    (self.imfs, np.zeros(shape=(num_new_layers, seq_len)))
+            if eemd_imfs.shape[0] < IMFs.shape[0]:
+                num_new_layers = IMFs.shape[0] - eemd_imfs.shape[0]
+                eemd_imfs = np.vstack(
+                    (eemd_imfs, np.zeros(shape=(num_new_layers, seq_len)))
                 )
-            self.imfs[: IMFs.shape[0]] += IMFs
+            eemd_imfs[: IMFs.shape[0]] += IMFs
 
         if self.parallel:
             pool.close()
 
-        return self.imfs / self.trials
+        return eemd_imfs / self.trials
 
     def _update_trial(self, trial: int) -> np.ndarray:
         """A single trial evaluation, i.e., EMD(signal + noise)."""
-        # Generate noise
         noise = self.epsilon * self.all_noise_EMD[trial][0]
-
-        # Return the result of a single EMD execution
-        return self._run_emd(self._signal + noise, self._time, self.max_imfs)
+        return self._run_emd(self._signal + noise, self._time, self._eemd_max_imfs)
 
     def _run_emd(
         self,
@@ -302,41 +278,34 @@ class CEEMDAN(object):
         """
         Test for end condition for CEEMDAN method.
 
-        The algorithm's performance can be enhanced by adjusting the decomposition parameters.
+        Procedure stops if:
+        * number of components reaches provided `max_imf`, or
+        * residue has insufficient extrema for further decomposition, or
+        * residue amplitude range falls below `range_thr`, or
+        * residue total power falls below `total_power_thr`.
 
         :param signal: the original input signal as a numpy ndarray
         :param cIMFs: the signal decomposition results
-        :param max_imf: the maximum number of IMFs obtained
+        :param max_imf: the maximum number of IMFs to extract (-1 means no limit)
         :return: a boolean stop flag indicating whether to stop the CEEMDAN method
         """
-        # Number of IMFs currently decomposed
         imf_number = cIMFs.shape[0]
 
-        # Check if the maximum number of cIMFs has been reached
         if 0 < max_imf <= imf_number:
             return True
 
-        # Compute the Empirical Mode Decomposition (EMD) for the residue
         R = signal - np.sum(cIMFs, axis=0)
-        # _test_imfs = self._emd(signal=R, time=None, max_imfs=2)
-        # print("test imfs", _test_imfs.shape)
-        #
-        # # Check if the residue is an IMF or has no extrema
-        # if _test_imfs.shape[0] == 1:
-        #     print("Not enough extrema")
-        #     return True
-
-        # Check for range threshold
+
+        _test_imfs = self._run_emd(signal=R, time=None, max_imfs=1)
+        if _test_imfs.shape[0] == 1:
+            return True
+
         if np.max(R) - np.min(R) < self.range_thr:
-            print("Finished by Range")
             return True
 
-        # Check for power threshold
         if np.sum(np.abs(R)) < self.total_power_thr:
-            print("Finished by Power")
             return True
 
-        # The algorithm did not stop
         return False
 
     def fit_transform(
@@ -351,81 +320,62 @@ class CEEMDAN(object):
 
         :param signal: the original signal on which CEEMDAN is to be performed
         :param time: the time array of the original input signal
-        :param max_imfs: the maximum number of components to extract
+        :param max_imfs: the maximum number of components to extract (-1 for no limit)
         :param progress: whether to print out '.' every 1s to indicate progress
         :return: the intrinsic mode functions (IMFs) after signal decomposition
         """
-        # Normalize the signal's amplitude
         scale_s = np.std(signal)
         signal = signal / scale_s
 
-        # Begin executing the specific decomposition algorithm
         max_imfs = self.max_imfs if max_imfs is None else max_imfs
-        total = (max_imfs - 1) if max_imfs != -1 else None
 
-        # Define the noise sequences to be added
         self.all_noises = self._generate_noise(
             self.noise_scale, size=(self.trials, signal.size)
         )
-
-        # Decompose all noise and remember the standard deviation of the 1st IMF
         self.all_noise_EMD = self._decompose_noise()
 
-        # Create the first IMF
         last_imf = self._run_eemd(signal, time, max_imfs=1, progress=progress)[0]
 
         all_cimfs = last_imf.reshape((-1, last_imf.size))
         prev_res = signal - last_imf
 
-        # Create an iterator object for signal decomposition
+        total = (max_imfs - 1) if max_imfs != -1 else None
         it = (
             iter
             if not progress
             else lambda x: tqdm(x, desc="cIMF decomposition", total=total)
         )
 
-        # Begin the algorithm's iteration
-        for _ in it(range(max_imfs - 1)):
-            # Number of IMFs currently decomposed
-            imf_number = all_cimfs.shape[0]
+        for _ in it(range(self._max_imf_iters)):
+            if self.end_condition(signal=signal, cIMFs=all_cimfs, max_imf=max_imfs):
+                break
 
+            imf_number = all_cimfs.shape[0]
             beta = self.epsilon * np.std(prev_res)
-
             local_mean = np.zeros(signal.size)
 
             for trial in range(self.trials):
-                # Skip if noise[trial] didn't have k'th mode
                 noise_imf = self.all_noise_EMD[trial]
                 res = prev_res.copy()
 
-                # add noise for every imf to be decomposed.
                 if len(noise_imf) > imf_number:
                     res += beta * noise_imf[imf_number]
 
-                # Extract the local mean, which is at the 2nd position
                 imfs = self._run_emd(res, time, max_imfs=1)
                 local_mean += imfs[-1] / self.trials
 
-            # Record the results of this decomposition
             last_imf = prev_res - local_mean
-            # vstack the new imf
             all_cimfs = np.vstack((all_cimfs, last_imf))
             prev_res = local_mean.copy()
 
-            # Determine whether the decomposition algorithm should stop iterating
-            if self.end_condition(signal=signal, cIMFs=all_cimfs, max_imf=max_imfs):
-                # Reached the stopping condition
-                # print("End Decomposition")
-                break
+        residue = signal - np.sum(all_cimfs, axis=0)
+        all_cimfs = np.vstack((all_cimfs, residue))
+
+        all_cimfs = all_cimfs * scale_s
 
-        # Clear all IMF noise
-        # The noise will be initialized for the new input signal
         del self.all_noise_EMD[:]
 
-        # Record the results of this decomposition
         self.imfs = all_cimfs
-
-        # Calculate the remaining residual components
         self.residue = signal * scale_s - np.sum(self.imfs, axis=0)
 
         return all_cimfs

{pysdkit-0.4.22 → pysdkit-0.4.24}/pysdkit/_emd/emd.py

@@ -519,8 +519,7 @@ class EMD(object):
             IMF = np.vstack((IMF, imf.copy()))
             imfNo += 1
 
-            if self.end_condition(signal, IMF) or imfNo == max_imfs - 1:
-                # Determine whether to stop iterative decomposition based on the original input signal and the intrinsic mode function
+            if self.end_condition(signal, IMF) or (max_imfs > 0 and imfNo >= max_imfs):
                 break
 
         # If the last sifting had 2 or less extrema then that's a trend (residue)

{pysdkit-0.4.22 → pysdkit-0.4.24}/pysdkit/_ewt/ewt.py

@@ -251,9 +251,9 @@ def EWT_Boundaries_Detect(
 
     elif reg == "gaussian":
         regFilter = np.zeros(lengthFilter)
-        regFilter[
-            regFilter.size // 2
-        ] = 1  # Ensure center is set for Gaussian filtering
+        regFilter[regFilter.size // 2] = (
+            1  # Ensure center is set for Gaussian filtering
+        )
         presig = np.convolve(
             ff, gaussian_filter(regFilter, sigmaFilter), mode="same"
         )  # Gaussian filter

{pysdkit-0.4.22 → pysdkit-0.4.24}/pysdkit/_fmd/__init__.py

@@ -4,3 +4,4 @@ Created on 2025/01/12 00:05:25
 @author: Whenxuan Wang
 @email: wwhenxuan@gmail.com
 """
+from .fmd import FMD

pysdkit-0.4.24/pysdkit/_fmd/fmd.py

@@ -0,0 +1,302 @@
+# -*- coding: utf-8 -*-
+"""
+Created on 2025/01/12 00:05:39
+@author: Whenxuan Wang
+@email: wwhenxuan@gmail.com
+"""
+import numpy as np
+
+import scipy.signal as signal
+from scipy.fftpack import fft
+from scipy.signal import firwin, hilbert
+
+from typing import Optional, Union, Tuple
+
+
+class FMD(object):
+    """
+    Feature Mode Decomposition (FMD) class for decomposing a signal into a predefined
+    number of modes using iterative filter bank and kurtosis-based optimization.
+
+    Yonghao, Miao, et al. “Feature Mode Decomposition: New Decomposition Theory for Rotating Machinery Fault Diagnosis.”
+    IEEE Transactions on Industrial Electronics, Institute of Electrical and Electronics Engineers (IEEE), 2022, pp. 1–1, doi:10.1109/tie.2022.3156156.
+    Matlab Code: https://www.mathworks.com/matlabcentral/fileexchange/108099-feature-mode-decomposition-fmd
+    """
+
+    def __init__(
+        self,
+        fs: Union[int, float],
+        mode_num: int = 2,
+        filter_size: Union[int, float] = 30,
+        cut_num: Optional[int] = 7,
+        max_iter_num: Optional[int] = 20,
+    ) -> None:
+        """
+        Initialize the FMD instance with specified parameters.
+
+        :param alpha: (Union[int, float]),
+            Sampling frequency of the input signal.
+        :param mode_num: (int, optional),
+            Number of modes to extract from the input signal. Defaults to 2.
+        :param filter_size: (Union[int, float], optional),
+            Length of the FIR filters used in the filter bank. Defaults to 30.
+        :param cut_num: (Optional[int], optional),
+            Number of equally spaced sub-bands to split the frequency range [0, fs/2]. Defaults to 7.
+        :param max_iter_num: (Optional[int], optional),
+            Maximum number of iterations for filter optimization. Defaults to 20.
+        """
+        self.fs = fs
+        self.filter_size = filter_size
+        self.cut_num = cut_num
+        self.mode_num = mode_num
+        self.max_iter_num = max_iter_num
+
+    def fit_transform(
+        self, x: np.ndarray, fs: Optional[Union[int, float]] = None
+    ) -> np.ndarray:
+        """
+        Decompose the input signal into modes using FMD.
+
+        :param x: (array-like),
+            Input signal to be decomposed.
+        :param fs: (Optional[Union[int, float]], optional),
+            Sampling frequency of the input signal. If None, uses the instance's fs. Defaults to None.
+
+        :return: (ndarray, shape (mode_num, len(x))),
+            Extracted modes after decomposition.
+        """
+        # Initialize the input signal and parameters
+        x = np.asarray(x).flatten()
+
+        if fs is not None:
+            self.fs = fs
+
+        freq_bound = np.arange(0, 1, 1 / self.cut_num)
+        temp_filters = np.zeros((self.filter_size, self.cut_num))
+
+        # Initialize a filter bank with Hann-windowed FIR bandpass filters
+        for n, fb in enumerate(freq_bound):
+            b = firwin(
+                self.filter_size,
+                [fb + np.finfo(float).eps, fb + 1 / self.cut_num - np.finfo(float).eps],
+                window="hann",
+                pass_zero=False,
+            )
+            temp_filters[:, n] = b
+
+        temp_sig = np.tile(x[:, None], (1, self.cut_num))
+        itercount = 2
+
+        while True:
+            iternum = 2
+            if itercount == 2:
+                # Reduce iterations for non-target bands to speed convergence
+                iternum = self.max_iter_num - (self.cut_num - self.mode_num) * iternum
+
+            X = []
+            for n in range(temp_filters.shape[1]):
+                # Apply Multi-Cycle Kurtosis Deconvolution (MCKD) to refine each filter output
+                y_iter, f_iter, k_iter, T_iter = self._xxc_mckd(
+                    temp_sig[:, n], temp_filters[:, n], iternum, M=1
+                )
+                freq_resp = np.abs(fft(f_iter))[: self.filter_size // 2]
+                peak_freq = (np.argmax(freq_resp)) * (self.fs / self.filter_size)
+                X.append(
+                    [
+                        y_iter[:, -1],
+                        f_iter[:, -1],
+                        k_iter[-1],
+                        freq_resp,
+                        peak_freq,
+                        T_iter,
+                    ]
+                )
+
+            # Update signal matrix and filter bank using optimized filters
+            temp_sig = np.column_stack([xi[0] for xi in X])
+            temp_filters = np.column_stack([xi[1] for xi in X])
+
+            # Compute pairwise correlation and remove the most redundant component
+            corr_matrix = np.abs(np.corrcoef(temp_sig, rowvar=False))
+            corr_matrix = np.triu(corr_matrix, 1)
+            I, J, _ = _max_IJ(corr_matrix)
+
+            XI = temp_sig[:, I] - np.mean(temp_sig[:, I])
+            XJ = temp_sig[:, J] - np.mean(temp_sig[:, J])
+
+            # Compare cyclic kurtosis (CK) values to decide which component to drop
+            KI = _CK(XI, X[I][5], 1)
+            KJ = _CK(XJ, X[J][5], 1)
+
+            output = J if KI > KJ else I
+            temp_sig = np.delete(temp_sig, output, axis=1)
+            temp_filters = np.delete(temp_filters, output, axis=1)
+
+            if temp_filters.shape[1] == self.mode_num - 1:
+                break
+
+            itercount += 1
+
+        final_modes = np.column_stack([xi[0] for xi in X])
+        return final_modes.T
+
+    def _xxc_mckd(
+        self,
+        x: np.ndarray,
+        f_init: np.ndarray,
+        term_iter: int,
+        T: Optional[int] = None,
+        M: Optional[int] = 3,
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, int]:
+        """
+        Multi-Cycle Kurtosis Deconvolution (MCKD) optimization for filter refinement.
+
+        :param x: (ndarray),
+            Input signal segment.
+        :param f_init: (ndarray),
+            Initial filter coefficients.
+        :param term_iter: (int),
+            Number of iterations to optimize filter.
+        :param T: (int, optional),
+            Cycle period (if None, estimated from signal envelope autocorrelation).
+        :param M: (int, optional, default=3),
+            Order of cyclic kurtosis.
+
+        :return: (Tuple[np.ndarray, np.ndarray, np.ndarray, int]),
+            y_final: Filtered signal at each iteration.
+            f_final: Optimized filter coefficients at each iteration.
+            ck_iter: CK values over iterations.
+            T: Estimated cycle period.
+        """
+        if T is None:
+            env = np.abs(hilbert(x)) - np.mean(np.abs(hilbert(x)))
+            T = _TT(env)
+
+        T = int(round(T))
+        x = np.asarray(x).flatten()
+        L = len(f_init)
+        N = len(x)
+
+        # Build delayed signal matrix XmT for MCKD optimization
+        XmT = np.zeros((L, N, M + 1))
+        for m in range(M + 1):
+            for l in range(L):
+                if l == 0:
+                    XmT[l, m * T :, m] = x[: N - m * T]
+                else:
+                    XmT[l, 1:, m] = XmT[l - 1, :-1, m]
+
+        Xinv = np.linalg.inv(XmT[:, :, 0] @ XmT[:, :, 0].T)
+
+        f = f_init.copy()
+        y_final = []
+        f_final = []
+        ck_iter = []
+
+        for _ in range(term_iter):
+            y = XmT[:, :, 0].T @ f  # filter output
+
+            # Construct shifted versions for cyclic statistics
+            yt = np.zeros((N, M + 1))
+            for m in range(M + 1):
+                yt[:, m] = (
+                    y if m == 0 else np.concatenate([np.zeros(T), yt[:-T, m - 1]])
+                )
+
+            # Compute alpha (partial derivatives) and beta for filter update
+            alpha = np.zeros_like(yt)
+            for m in range(M + 1):
+                idx = [i for i in range(M + 1) if i != m]
+                alpha[:, m] = (np.prod(yt[:, idx], axis=1) ** 2) * yt[:, m]
+
+            beta = np.prod(yt, axis=1)
+
+            Xalpha = np.zeros(L)
+            for m in range(M + 1):
+                Xalpha += XmT[:, :, m] @ alpha[:, m]
+
+            # Update filter using gradient ascent on CK criterion
+            f = (np.sum(y**2) / (2 * np.sum(beta**2))) * (Xinv @ Xalpha)
+            f /= np.sqrt(np.sum(f**2))
+
+            # Compute CK value for convergence monitoring
+            ck_val = np.sum(np.prod(yt, axis=1) ** 2) / (np.sum(y**2) ** (M + 1))
+            ck_iter.append(ck_val)
+
+            # Update delay matrix with new cycle period estimate
+            env_y = np.abs(hilbert(y)) - np.mean(np.abs(hilbert(y)))
+            T = int(round(_TT(env_y)))
+
+            XmT = np.zeros((L, N, M + 1))
+            for m in range(M + 1):
+                for l in range(L):
+                    if l == 0:
+                        XmT[l, m * T :, m] = x[: N - m * T]
+                    else:
+                        XmT[l, 1:, m] = XmT[l - 1, :-1, m]
+
+            Xinv = np.linalg.inv(XmT[:, :, 0] @ XmT[:, :, 0].T)
+
+            y_final.append(signal.lfilter(f, [1], x))
+            f_final.append(f.copy())
+
+        y_final = np.column_stack(y_final) if len(y_final) > 1 else y_final[0][:, None]
+        f_final = np.column_stack(f_final) if len(f_final) > 1 else f_final[0][:, None]
+
+        return y_final, f_final, np.array(ck_iter), T
+
+
+def _TT(y: np.ndarray) -> int:
+    """Estimate signal period T using autocorrelation zero-crossing and peak."""
+    NA = signal.correlate(y, y, mode="full") / np.dot(y, y)
+    NA = NA[len(NA) // 2 :]
+    zeroposi = 1
+    for lag in range(1, len(NA)):
+        if (NA[lag - 1] > 0 and NA[lag] < 0) or NA[lag] == 0:
+            zeroposi = lag
+            break
+
+    if zeroposi >= len(NA):  # fallback if no zero-crossing is found
+        zeroposi = 1
+
+    NA = NA[zeroposi:]
+    max_position = np.argmax(NA)
+    return zeroposi + max_position
+
+
+def _CK(x: np.ndarray, T: int, M: Optional[int] = 2) -> Union[int, float, np.ndarray]:
+    """Compute cyclic kurtosis (CK) of the signal for a given period T and order M."""
+    x = np.asarray(x).flatten()
+    N = len(x)
+    x_shift = np.zeros((M + 1, N))
+    x_shift[0] = x
+    for m in range(1, M + 1):
+        x_shift[m, T:] = x_shift[m - 1, :-T]
+    return np.sum(np.prod(x_shift, axis=0) ** 2) / (np.sum(x**2) ** (M + 1))
+
+
+def _max_IJ(
+    X: np.ndarray,
+) -> Tuple[
+    Union[int, float, np.ndarray],
+    Union[int, float, np.ndarray],
+    Union[int, float, np.ndarray],
+]:
+    """Find the indices (I, J) of the maximum value in the upper triangle of correlation matrix X."""
+    tempI = np.argmax(X, axis=0)
+    temp = np.max(X, axis=0)
+    J = np.argmax(temp)
+    I = tempI[J]
+    return I, J, X[I, J]
+
+
+if __name__ == "__main__":
+    from pysdkit.data import test_emd
+    from pysdkit.plot import plot_IMFs
+    from matplotlib import pyplot as plt
+
+    time, sig = test_emd()
+    fmd = FMD(fs=1000, mode_num=2)
+    modes = fmd.fit_transform(sig)
+    plot_IMFs(sig, modes)
+    plt.show()

{pysdkit-0.4.22 → pysdkit-0.4.24}/pysdkit/_jmd/jmd.py

@@ -77,9 +77,7 @@ class JMD(object):
         """Get the full name and abbreviation of the algorithm"""
         return "Jump Plus AM-FM Mode Decomposition (JMD)"
 
-    def jump_step(
-        self, freqs: np.ndarray, T: int
-    ) -> Tuple[
+    def jump_step(self, freqs: np.ndarray, T: int) -> Tuple[
         float,
         np.ndarray,
         np.ndarray,