PySDKit 0.4.21__tar.gz → 0.4.23__tar.gz

{pysdkit-0.4.21 → pysdkit-0.4.23}/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2019 Whenxuan Wang
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2019 Whenxuan Wang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{pysdkit-0.4.21 → pysdkit-0.4.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySDKit
-Version: 0.4.21
+Version: 0.4.23
 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
@@ -11,13 +11,11 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
-Requires-Python: >=3.6
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.24.3
@@ -147,7 +145,7 @@ plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
 |                                                [`ALIF`]() (Adaptive Local Iterative Filtering)                                                |          [[paper]](https://arxiv.org/abs/1411.6051)          | [[code]](https://ww2.mathworks.cn/matlabcentral/fileexchange/56210-alif) |    ✖️    |
 |                    [`LMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_lmd/lmd.py) (Local Mean Decomposition)                     | [[paper]](https://www.sciencedirect.com/science/article/abs/pii/S1051200418308133?via%3Dihub) | [[code]](https://github.com/shownlin/PyLMD/blob/master/PyLMD/LMD.py) |    ✔️    |
 |                [`RLMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_lmd/rlmd.py) (Robust Local Mean Decomposition)                | [[paper]](https://www.sciencedirect.com/science/article/abs/pii/S0888327017301619) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/66935-robust-local-mean-decomposition-rlmd) |    ✔️    |
-| [`FMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_fmd/fmd.py) (Feature Mode Decomposition) | [[paper]](https://ieeexplore.ieee.org/document/9732251) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/108099-feature-mode-decomposition-fmd) |    ✖️    |
+| [`FMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_fmd/fmd.py) (Feature Mode Decomposition) | [[paper]](https://ieeexplore.ieee.org/document/9732251) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/108099-feature-mode-decomposition-fmd) |    ✔️    |
 |                [`NFMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_fmd/nfmd.py) (Non-stationary Feature Mode Decomposition)      |   [[paper]](https://ieeexplore.ieee.org/document/9732251)    | [[code]](https://github.com/sheadan/NFMD-ExtractionInstantaneous/blob/master/nfmd/NFMD.py) |    ✖️    |
 |                   [`SSA`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_ssa/ssa.py) (Singular Spectral Analysis)                    | [[paper]](https://orca.cardiff.ac.uk/id/eprint/15208/1/Zhiglavsky_SSA_encyclopedia.pdf) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/58967-singular-spectrum-analysis-beginners-guide) |    ✔️    |
 |                   [`EWT`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_ewt/ewt.py) (Empirical Wavelet Transform)                   |   [[paper]](https://ieeexplore.ieee.org/document/6522142)    | [[code]](https://www.mathworks.com/help/wavelet/ug/empirical-wavelet-transform.html) |    ✔️    |

{pysdkit-0.4.21 → pysdkit-0.4.23}/PySDKit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySDKit
-Version: 0.4.21
+Version: 0.4.23
 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
@@ -11,13 +11,11 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
-Requires-Python: >=3.6
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.24.3
@@ -147,7 +145,7 @@ plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
 |                                                [`ALIF`]() (Adaptive Local Iterative Filtering)                                                |          [[paper]](https://arxiv.org/abs/1411.6051)          | [[code]](https://ww2.mathworks.cn/matlabcentral/fileexchange/56210-alif) |    ✖️    |
 |                    [`LMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_lmd/lmd.py) (Local Mean Decomposition)                     | [[paper]](https://www.sciencedirect.com/science/article/abs/pii/S1051200418308133?via%3Dihub) | [[code]](https://github.com/shownlin/PyLMD/blob/master/PyLMD/LMD.py) |    ✔️    |
 |                [`RLMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_lmd/rlmd.py) (Robust Local Mean Decomposition)                | [[paper]](https://www.sciencedirect.com/science/article/abs/pii/S0888327017301619) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/66935-robust-local-mean-decomposition-rlmd) |    ✔️    |
-| [`FMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_fmd/fmd.py) (Feature Mode Decomposition) | [[paper]](https://ieeexplore.ieee.org/document/9732251) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/108099-feature-mode-decomposition-fmd) |    ✖️    |
+| [`FMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_fmd/fmd.py) (Feature Mode Decomposition) | [[paper]](https://ieeexplore.ieee.org/document/9732251) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/108099-feature-mode-decomposition-fmd) |    ✔️    |
 |                [`NFMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_fmd/nfmd.py) (Non-stationary Feature Mode Decomposition)      |   [[paper]](https://ieeexplore.ieee.org/document/9732251)    | [[code]](https://github.com/sheadan/NFMD-ExtractionInstantaneous/blob/master/nfmd/NFMD.py) |    ✖️    |
 |                   [`SSA`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_ssa/ssa.py) (Singular Spectral Analysis)                    | [[paper]](https://orca.cardiff.ac.uk/id/eprint/15208/1/Zhiglavsky_SSA_encyclopedia.pdf) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/58967-singular-spectrum-analysis-beginners-guide) |    ✔️    |
 |                   [`EWT`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_ewt/ewt.py) (Empirical Wavelet Transform)                   |   [[paper]](https://ieeexplore.ieee.org/document/6522142)    | [[code]](https://www.mathworks.com/help/wavelet/ug/empirical-wavelet-transform.html) |    ✔️    |

{pysdkit-0.4.21 → pysdkit-0.4.23}/README.md

@@ -108,7 +108,7 @@ plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
 |                                                [`ALIF`]() (Adaptive Local Iterative Filtering)                                                |          [[paper]](https://arxiv.org/abs/1411.6051)          | [[code]](https://ww2.mathworks.cn/matlabcentral/fileexchange/56210-alif) |    ✖️    |
 |                    [`LMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_lmd/lmd.py) (Local Mean Decomposition)                     | [[paper]](https://www.sciencedirect.com/science/article/abs/pii/S1051200418308133?via%3Dihub) | [[code]](https://github.com/shownlin/PyLMD/blob/master/PyLMD/LMD.py) |    ✔️    |
 |                [`RLMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_lmd/rlmd.py) (Robust Local Mean Decomposition)                | [[paper]](https://www.sciencedirect.com/science/article/abs/pii/S0888327017301619) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/66935-robust-local-mean-decomposition-rlmd) |    ✔️    |
-| [`FMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_fmd/fmd.py) (Feature Mode Decomposition) | [[paper]](https://ieeexplore.ieee.org/document/9732251) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/108099-feature-mode-decomposition-fmd) |    ✖️    |
+| [`FMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_fmd/fmd.py) (Feature Mode Decomposition) | [[paper]](https://ieeexplore.ieee.org/document/9732251) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/108099-feature-mode-decomposition-fmd) |    ✔️    |
 |                [`NFMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_fmd/nfmd.py) (Non-stationary Feature Mode Decomposition)      |   [[paper]](https://ieeexplore.ieee.org/document/9732251)    | [[code]](https://github.com/sheadan/NFMD-ExtractionInstantaneous/blob/master/nfmd/NFMD.py) |    ✖️    |
 |                   [`SSA`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_ssa/ssa.py) (Singular Spectral Analysis)                    | [[paper]](https://orca.cardiff.ac.uk/id/eprint/15208/1/Zhiglavsky_SSA_encyclopedia.pdf) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/58967-singular-spectrum-analysis-beginners-guide) |    ✔️    |
 |                   [`EWT`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_ewt/ewt.py) (Empirical Wavelet Transform)                   |   [[paper]](https://ieeexplore.ieee.org/document/6522142)    | [[code]](https://www.mathworks.com/help/wavelet/ug/empirical-wavelet-transform.html) |    ✔️    |

{pysdkit-0.4.21 → pysdkit-0.4.23}/pysdkit/__init__.py

@@ -2,7 +2,7 @@
 A Python library for signal decomposition algorithms.
 """
 
-__version__ = "0.4.21"
+__version__ = "0.4.23"
 
 # 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.21 → pysdkit-0.4.23}/pysdkit/_emd/__init__.py

@@ -1,27 +1,27 @@
-# -*- coding: utf-8 -*-
-"""
-Created on 2025/02/03 18:36:18
-@author: Whenxuan Wang
-@email: wwhenxuan@gmail.com
-"""
-from ._splines import akima, cubic, pchip, cubic_hermite, cubic_spline_3pts
-
-from ._find_extrema import find_extrema_parabol, find_extrema_simple
-
-from ._prepare_points import prepare_points_parabol, prepare_points_simple
-
-from .emd import EMD
-
-from .eemd import EEMD
-
-from .ceemdan import CEEMDAN
-
-from .remd import REMD
-
-from .memd import MEMD
-
-from .tvf_emd import TVF_EMD
-
-from .efd import EFD
-
-from .hht import HHT
+# -*- coding: utf-8 -*-
+"""
+Created on 2025/02/03 18:36:18
+@author: Whenxuan Wang
+@email: wwhenxuan@gmail.com
+"""
+from ._splines import akima, cubic, pchip, cubic_hermite, cubic_spline_3pts
+
+from ._find_extrema import find_extrema_parabol, find_extrema_simple
+
+from ._prepare_points import prepare_points_parabol, prepare_points_simple
+
+from .emd import EMD
+
+from .eemd import EEMD
+
+from .ceemdan import CEEMDAN
+
+from .remd import REMD
+
+from .memd import MEMD
+
+from .tvf_emd import TVF_EMD
+
+from .efd import EFD
+
+from .hht import HHT

{pysdkit-0.4.21 → pysdkit-0.4.23}/pysdkit/_emd/_find_extrema.py

@@ -1,146 +1,146 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Sat Mar 5 21:38:26 2024
-@author: Whenxuan Wang
-@email: wwhenxuan@gmail.com
-The following code is mainly used to find extreme points in the EMD algorithm
-
-Code taken from https://github.com/laszukdawid/PyEMD/blob/master/PyEMD/EMD.py
-"""
-import numpy as np
-from pysdkit.utils._process import not_duplicate, find_zero_crossings
-from typing import Tuple
-
-FindExtremaOutput = Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]
-
-
-def find_extrema_parabol(time: np.ndarray, signal: np.ndarray) -> FindExtremaOutput:
-    """
-    Performs parabolic estimation of extremum in a one-dimensional signal array S.
-    This method not only identifies the positions and values of local maxima and minima
-    by fitting a parabola to three consecutive points (where the middle point is the vertex of the parabola),
-    but also provides zero crossing points which are essential for signal analysis.
-
-    :param time: Array representing the time or sequence indices.
-    :param signal: One-dimensional array representing the signal values.
-    :return: Positions and values of local maxima and minima, and positions of zero crossings.
-    """
-
-    # Detect zero crossings by comparing adjacent signal points
-    indzer = find_zero_crossings(signal=signal)
-
-    # Handling duplicate values which are crucial for accurate parabolic fitting
-    idx = not_duplicate(signal)
-    time = time[idx]
-    signal = signal[idx]
-
-    # Initialize variables for parabolic fitting
-    Tp, T0, Tn = time[:-2], time[1:-1], time[2:]
-    Sp, S0, Sn = signal[:-2], signal[1:-1], signal[2:]
-    TnTp, T0Tn, TpT0 = Tn - Tp, T0 - Tn, Tp - T0
-    scale = (
-        Tp * Tn * Tn
-        + Tp * Tp * T0
-        + T0 * T0 * Tn
-        - Tp * Tp * Tn
-        - Tp * T0 * T0
-        - T0 * Tn * Tn
-    )
-
-    # Compute coefficients of the parabola: y = ax^2 + bx + c
-    a = T0Tn * Sp + TnTp * S0 + TpT0 * Sn
-    b = (S0 - Sn) * Tp**2 + (Sn - Sp) * T0**2 + (Sp - S0) * Tn**2
-    c = T0 * Tn * T0Tn * Sp + Tn * Tp * TnTp * S0 + Tp * T0 * TpT0 * Sn
-
-    # Scale and adjust coefficients, and calculate vertex of parabola
-    a = a / scale
-    b = b / scale
-    c = c / scale
-    a[a == 0] = 1e-14
-    tVertex = -0.5 * b / a
-    idx = (tVertex < T0 + 0.5 * (Tn - T0)) & (tVertex >= T0 - 0.5 * (T0 - Tp))
-
-    # Select valid vertices and classify as maxima or minima based on 'a'
-    a, b, c = a[idx], b[idx], c[idx]
-    tVertex = tVertex[idx]
-    sVertex = a * tVertex * tVertex + b * tVertex + c
-    local_max_pos, local_max_val = tVertex[a < 0], sVertex[a < 0]
-    local_min_pos, local_min_val = tVertex[a > 0], sVertex[a > 0]
-
-    return local_max_pos, local_max_val, local_min_pos, local_min_val, indzer
-
-
-def find_extrema_simple(time: np.ndarray, signal: np.ndarray) -> FindExtremaOutput:
-    """
-    Performs extrema detection in a given one-dimensional signal array S.
-    This method identifies local maxima and minima by analyzing the first differences of the signal.
-    The approach is straightforward and computationally efficient, making it suitable for signal processing applications
-    where quick identification of critical turning points in the signal is required.
-
-    :param time: Array representing the time or sequence indices.
-    :param signal: One-dimensional array representing the signal values.
-    :return: Positions and corresponding values of local maxima and minima, and the positions of zero crossings.
-    """
-
-    # Finds indexes of zero-crossings
-    indzer = find_zero_crossings(signal=signal)
-
-    # Finding local extrema points by using first differences
-    d = np.diff(signal)
-
-    # Constructing arrays of previous and next difference values
-    # d1 * d2 < 0 checks for sign changes in differences (product being negative),
-    # indicating a peak or trough between these difference points in signal S.
-    d1, d2 = d[:-1], d[1:]
-    indmin = np.nonzero(np.r_[d1 * d2 < 0] & np.r_[d1 < 0])[0] + 1
-    indmax = np.nonzero(np.r_[d1 * d2 < 0] & np.r_[d1 > 0])[0] + 1
-
-    # Handling cases when two or more points have the same value
-    if np.any(d == 0):
-        imax, imin = [], []
-
-        bad = d == 0
-        dd = np.diff(np.append(np.append(0, bad), 0))
-        debs = np.nonzero(dd == 1)[0]
-        fins = np.nonzero(dd == -1)[0]
-        if debs[0] == 1:
-            if len(debs) > 1:
-                debs, fins = debs[1:], fins[1:]
-            else:
-                debs, fins = [], []
-
-        if len(debs) > 0:
-            if fins[-1] == len(signal) - 1:
-                if len(debs) > 1:
-                    debs, fins = debs[:-1], fins[:-1]
-                else:
-                    debs, fins = [], []
-
-        lc = len(debs)
-        if lc > 0:
-            for k in range(lc):
-                if d[debs[k] - 1] > 0:
-                    if d[fins[k]] < 0:
-                        imax.append(np.round((fins[k] + debs[k]) / 2.0))
-                else:
-                    if d[fins[k]] > 0:
-                        imin.append(np.round((fins[k] + debs[k]) / 2.0))
-
-        if len(imax) > 0:
-            indmax = indmax.tolist()
-            for x in imax:
-                indmax.append(int(x))
-            indmax.sort()
-
-        if len(imin) > 0:
-            indmin = indmin.tolist()
-            for x in imin:
-                indmin.append(int(x))
-            indmin.sort()
-
-    local_max_pos = time[indmax]
-    local_max_val = signal[indmax]
-    local_min_pos = time[indmin]
-    local_min_val = signal[indmin]
-
-    return local_max_pos, local_max_val, local_min_pos, local_min_val, indzer
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Mar 5 21:38:26 2024
+@author: Whenxuan Wang
+@email: wwhenxuan@gmail.com
+The following code is mainly used to find extreme points in the EMD algorithm
+
+Code taken from https://github.com/laszukdawid/PyEMD/blob/master/PyEMD/EMD.py
+"""
+import numpy as np
+from pysdkit.utils._process import not_duplicate, find_zero_crossings
+from typing import Tuple
+
+FindExtremaOutput = Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]
+
+
+def find_extrema_parabol(time: np.ndarray, signal: np.ndarray) -> FindExtremaOutput:
+    """
+    Performs parabolic estimation of extremum in a one-dimensional signal array S.
+    This method not only identifies the positions and values of local maxima and minima
+    by fitting a parabola to three consecutive points (where the middle point is the vertex of the parabola),
+    but also provides zero crossing points which are essential for signal analysis.
+
+    :param time: Array representing the time or sequence indices.
+    :param signal: One-dimensional array representing the signal values.
+    :return: Positions and values of local maxima and minima, and positions of zero crossings.
+    """
+
+    # Detect zero crossings by comparing adjacent signal points
+    indzer = find_zero_crossings(signal=signal)
+
+    # Handling duplicate values which are crucial for accurate parabolic fitting
+    idx = not_duplicate(signal)
+    time = time[idx]
+    signal = signal[idx]
+
+    # Initialize variables for parabolic fitting
+    Tp, T0, Tn = time[:-2], time[1:-1], time[2:]
+    Sp, S0, Sn = signal[:-2], signal[1:-1], signal[2:]
+    TnTp, T0Tn, TpT0 = Tn - Tp, T0 - Tn, Tp - T0
+    scale = (
+        Tp * Tn * Tn
+        + Tp * Tp * T0
+        + T0 * T0 * Tn
+        - Tp * Tp * Tn
+        - Tp * T0 * T0
+        - T0 * Tn * Tn
+    )
+
+    # Compute coefficients of the parabola: y = ax^2 + bx + c
+    a = T0Tn * Sp + TnTp * S0 + TpT0 * Sn
+    b = (S0 - Sn) * Tp**2 + (Sn - Sp) * T0**2 + (Sp - S0) * Tn**2
+    c = T0 * Tn * T0Tn * Sp + Tn * Tp * TnTp * S0 + Tp * T0 * TpT0 * Sn
+
+    # Scale and adjust coefficients, and calculate vertex of parabola
+    a = a / scale
+    b = b / scale
+    c = c / scale
+    a[a == 0] = 1e-14
+    tVertex = -0.5 * b / a
+    idx = (tVertex < T0 + 0.5 * (Tn - T0)) & (tVertex >= T0 - 0.5 * (T0 - Tp))
+
+    # Select valid vertices and classify as maxima or minima based on 'a'
+    a, b, c = a[idx], b[idx], c[idx]
+    tVertex = tVertex[idx]
+    sVertex = a * tVertex * tVertex + b * tVertex + c
+    local_max_pos, local_max_val = tVertex[a < 0], sVertex[a < 0]
+    local_min_pos, local_min_val = tVertex[a > 0], sVertex[a > 0]
+
+    return local_max_pos, local_max_val, local_min_pos, local_min_val, indzer
+
+
+def find_extrema_simple(time: np.ndarray, signal: np.ndarray) -> FindExtremaOutput:
+    """
+    Performs extrema detection in a given one-dimensional signal array S.
+    This method identifies local maxima and minima by analyzing the first differences of the signal.
+    The approach is straightforward and computationally efficient, making it suitable for signal processing applications
+    where quick identification of critical turning points in the signal is required.
+
+    :param time: Array representing the time or sequence indices.
+    :param signal: One-dimensional array representing the signal values.
+    :return: Positions and corresponding values of local maxima and minima, and the positions of zero crossings.
+    """
+
+    # Finds indexes of zero-crossings
+    indzer = find_zero_crossings(signal=signal)
+
+    # Finding local extrema points by using first differences
+    d = np.diff(signal)
+
+    # Constructing arrays of previous and next difference values
+    # d1 * d2 < 0 checks for sign changes in differences (product being negative),
+    # indicating a peak or trough between these difference points in signal S.
+    d1, d2 = d[:-1], d[1:]
+    indmin = np.nonzero(np.r_[d1 * d2 < 0] & np.r_[d1 < 0])[0] + 1
+    indmax = np.nonzero(np.r_[d1 * d2 < 0] & np.r_[d1 > 0])[0] + 1
+
+    # Handling cases when two or more points have the same value
+    if np.any(d == 0):
+        imax, imin = [], []
+
+        bad = d == 0
+        dd = np.diff(np.append(np.append(0, bad), 0))
+        debs = np.nonzero(dd == 1)[0]
+        fins = np.nonzero(dd == -1)[0]
+        if debs[0] == 1:
+            if len(debs) > 1:
+                debs, fins = debs[1:], fins[1:]
+            else:
+                debs, fins = [], []
+
+        if len(debs) > 0:
+            if fins[-1] == len(signal) - 1:
+                if len(debs) > 1:
+                    debs, fins = debs[:-1], fins[:-1]
+                else:
+                    debs, fins = [], []
+
+        lc = len(debs)
+        if lc > 0:
+            for k in range(lc):
+                if d[debs[k] - 1] > 0:
+                    if d[fins[k]] < 0:
+                        imax.append(np.round((fins[k] + debs[k]) / 2.0))
+                else:
+                    if d[fins[k]] > 0:
+                        imin.append(np.round((fins[k] + debs[k]) / 2.0))
+
+        if len(imax) > 0:
+            indmax = indmax.tolist()
+            for x in imax:
+                indmax.append(int(x))
+            indmax.sort()
+
+        if len(imin) > 0:
+            indmin = indmin.tolist()
+            for x in imin:
+                indmin.append(int(x))
+            indmin.sort()
+
+    local_max_pos = time[indmax]
+    local_max_val = signal[indmax]
+    local_min_pos = time[indmin]
+    local_min_val = signal[indmin]
+
+    return local_max_pos, local_max_val, local_min_pos, local_min_val, indzer