PySDKit 0.4.26__tar.gz → 0.4.27__tar.gz

{pysdkit-0.4.26 → pysdkit-0.4.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySDKit
-Version: 0.4.26
+Version: 0.4.27
 Summary: A Python library for signal decomposition algorithms with a unified interface.
 Author: josefinez, Deeksha Manjunath, Yuan Feng, JacktheFowler
 Author-email: Whenxuan Wang <wwhenxuan@gmail.com>, RuiZhe Wang <3133986068@qq.com>, WenTong Zhao <23049200290@stu.xidian.edu.cn>
@@ -159,7 +159,7 @@ plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
 |        [`FAEMD3D`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_faemd/faemd3d.py) (Three-Dimensional Fast and Adaptive EMD)        |   [[paper]](https://ieeexplore.ieee.org/document/8447300)    | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/71270-fast-and-adaptive-multivariate-and-multidimensional-emd) |    ✖️    |
 |                 [`HVD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_hvd/hvd.py) (Hilbert Vibration Decomposition)                 | [[paper]](https://www.sciencedirect.com/science/article/pii/S0022460X06001556) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/178804-hilbert-vibration-decomposition?s_tid=FX_rc1_behav) |    ✔️    |
 |               [`ITD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_itd/itd.py) (Intrinsic Time-Scale Decomposition)                | [[paper]](https://royalsocietypublishing.org/doi/10.1098/rspa.2006.1761) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/69380-intrinsic-time-scale-decomposition-itd) |    ✔️    |
-|                                                [`ALIF`]() (Adaptive Local Iterative Filtering)                                                |          [[paper]](https://arxiv.org/abs/1411.6051)          | [[code]](https://ww2.mathworks.cn/matlabcentral/fileexchange/56210-alif) |    ✖️    |
+|                                                [`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) |    ✖️    |
@@ -176,7 +176,7 @@ plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
 |      [`VNCMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vncmd/vncmd.py) (Variational Nonlinear Chirp Mode Decomposition)       |   [[paper]](https://ieeexplore.ieee.org/document/7990179)    | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/64292-variational-nonlinear-chirp-mode-decomposition) |    ✔️    |
 |       [`INCMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vncmd/incmd.py) (Iterative Nonlinear Chirp Mode Decomposition)        | [[paper]](https://www.sciencedirect.com/science/article/pii/S0022460X2030403X?via%3Dihub) |      [[code]](https://github.com/sheadan/IterativeNCMD)      |    ✔️    |
 |      [`MNCMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vncmd/mncmd.py) (Multivariate Nonlinear Chirp Mode Decomposition)      | [[paper]](https://www.sciencedirect.com/science/article/abs/pii/S0165168420302103) |                          [[code]]()                          |    ✖️    |
-| [`AVNCMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vncmd/avncmd.py) (Adaptive Variational Nonlinear Chirp Mode Decomposition) | [[paper]](https://ieeexplore.ieee.org/abstract/document/9746147) |         [[code]](https://github.com/HauLiang/AVNCMD)         |    ✖️    |
+| [`AVNCMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vncmd/avncmd.py) (Adaptive Variational Nonlinear Chirp Mode Decomposition) | [[paper]](https://ieeexplore.ieee.org/abstract/document/9746147) |         [[code]](https://github.com/HauLiang/AVNCMD)         |    ✔️    |
 |               [`ACMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vmd/acmd.py) (Adaptive Chirp Mode Decomposition)               |                         [[paper]]()                          | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/121373-data-driven-adaptive-chirp-mode-decomposition?s_tid=srchtitle) |    ✔️    |
 |    [`BA-ACMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vmd/ba_acmd.py) (Bandwidth-aware adaptive chirp mode decomposition)    | [[paper]](https://journals.sagepub.com/doi/abs/10.1177/14759217231174699) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/132792-bandwidth-aware-adaptive-chirp-mode-decomposition-ba-acmd?s_tid=srchtitle) |    ✖️    |
 |               [`JMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_jmd/jmd.py) (Jump Plus AM-FM Mode Decomposition)                |         [[paper]](https://arxiv.org/abs/2407.07800)          | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/169388-jump-plus-am-fm-mode-decomposition-jmd?s_tid=prof_contriblnk) |   ️✔️    |

{pysdkit-0.4.26 → pysdkit-0.4.27}/PySDKit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySDKit
-Version: 0.4.26
+Version: 0.4.27
 Summary: A Python library for signal decomposition algorithms with a unified interface.
 Author: josefinez, Deeksha Manjunath, Yuan Feng, JacktheFowler
 Author-email: Whenxuan Wang <wwhenxuan@gmail.com>, RuiZhe Wang <3133986068@qq.com>, WenTong Zhao <23049200290@stu.xidian.edu.cn>
@@ -159,7 +159,7 @@ plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
 |        [`FAEMD3D`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_faemd/faemd3d.py) (Three-Dimensional Fast and Adaptive EMD)        |   [[paper]](https://ieeexplore.ieee.org/document/8447300)    | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/71270-fast-and-adaptive-multivariate-and-multidimensional-emd) |    ✖️    |
 |                 [`HVD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_hvd/hvd.py) (Hilbert Vibration Decomposition)                 | [[paper]](https://www.sciencedirect.com/science/article/pii/S0022460X06001556) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/178804-hilbert-vibration-decomposition?s_tid=FX_rc1_behav) |    ✔️    |
 |               [`ITD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_itd/itd.py) (Intrinsic Time-Scale Decomposition)                | [[paper]](https://royalsocietypublishing.org/doi/10.1098/rspa.2006.1761) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/69380-intrinsic-time-scale-decomposition-itd) |    ✔️    |
-|                                                [`ALIF`]() (Adaptive Local Iterative Filtering)                                                |          [[paper]](https://arxiv.org/abs/1411.6051)          | [[code]](https://ww2.mathworks.cn/matlabcentral/fileexchange/56210-alif) |    ✖️    |
+|                                                [`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) |    ✖️    |
@@ -176,7 +176,7 @@ plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
 |      [`VNCMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vncmd/vncmd.py) (Variational Nonlinear Chirp Mode Decomposition)       |   [[paper]](https://ieeexplore.ieee.org/document/7990179)    | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/64292-variational-nonlinear-chirp-mode-decomposition) |    ✔️    |
 |       [`INCMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vncmd/incmd.py) (Iterative Nonlinear Chirp Mode Decomposition)        | [[paper]](https://www.sciencedirect.com/science/article/pii/S0022460X2030403X?via%3Dihub) |      [[code]](https://github.com/sheadan/IterativeNCMD)      |    ✔️    |
 |      [`MNCMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vncmd/mncmd.py) (Multivariate Nonlinear Chirp Mode Decomposition)      | [[paper]](https://www.sciencedirect.com/science/article/abs/pii/S0165168420302103) |                          [[code]]()                          |    ✖️    |
-| [`AVNCMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vncmd/avncmd.py) (Adaptive Variational Nonlinear Chirp Mode Decomposition) | [[paper]](https://ieeexplore.ieee.org/abstract/document/9746147) |         [[code]](https://github.com/HauLiang/AVNCMD)         |    ✖️    |
+| [`AVNCMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vncmd/avncmd.py) (Adaptive Variational Nonlinear Chirp Mode Decomposition) | [[paper]](https://ieeexplore.ieee.org/abstract/document/9746147) |         [[code]](https://github.com/HauLiang/AVNCMD)         |    ✔️    |
 |               [`ACMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vmd/acmd.py) (Adaptive Chirp Mode Decomposition)               |                         [[paper]]()                          | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/121373-data-driven-adaptive-chirp-mode-decomposition?s_tid=srchtitle) |    ✔️    |
 |    [`BA-ACMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vmd/ba_acmd.py) (Bandwidth-aware adaptive chirp mode decomposition)    | [[paper]](https://journals.sagepub.com/doi/abs/10.1177/14759217231174699) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/132792-bandwidth-aware-adaptive-chirp-mode-decomposition-ba-acmd?s_tid=srchtitle) |    ✖️    |
 |               [`JMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_jmd/jmd.py) (Jump Plus AM-FM Mode Decomposition)                |         [[paper]](https://arxiv.org/abs/2407.07800)          | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/169388-jump-plus-am-fm-mode-decomposition-jmd?s_tid=prof_contriblnk) |   ️✔️    |

{pysdkit-0.4.26 → pysdkit-0.4.27}/PySDKit.egg-info/SOURCES.txt

@@ -7,6 +7,12 @@ PySDKit.egg-info/dependency_links.txt
 PySDKit.egg-info/requires.txt
 PySDKit.egg-info/top_level.txt
 pysdkit/__init__.py
+pysdkit/_alif/__init__.py
+pysdkit/_alif/_helpers.py
+pysdkit/_alif/alif.py
+pysdkit/_alif/iterative_filtering.py
+pysdkit/_alif/data/__init__.py
+pysdkit/_alif/data/prefixed_double_filter.npy
 pysdkit/_emd/__init__.py
 pysdkit/_emd/_find_extrema.py
 pysdkit/_emd/_prepare_points.py
@@ -97,6 +103,7 @@ pysdkit/plot/_plot_imfs.py
 pysdkit/plot/_plot_signal.py
 pysdkit/tests/__init__.py
 pysdkit/tests/run_all.py
+pysdkit/tests/test_alif.py
 pysdkit/tests/test_avncmd.py
 pysdkit/tests/test_ceemdan.py
 pysdkit/tests/test_emd.py

{pysdkit-0.4.26 → pysdkit-0.4.27}/README.md

@@ -105,7 +105,7 @@ plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
 |        [`FAEMD3D`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_faemd/faemd3d.py) (Three-Dimensional Fast and Adaptive EMD)        |   [[paper]](https://ieeexplore.ieee.org/document/8447300)    | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/71270-fast-and-adaptive-multivariate-and-multidimensional-emd) |    ✖️    |
 |                 [`HVD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_hvd/hvd.py) (Hilbert Vibration Decomposition)                 | [[paper]](https://www.sciencedirect.com/science/article/pii/S0022460X06001556) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/178804-hilbert-vibration-decomposition?s_tid=FX_rc1_behav) |    ✔️    |
 |               [`ITD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_itd/itd.py) (Intrinsic Time-Scale Decomposition)                | [[paper]](https://royalsocietypublishing.org/doi/10.1098/rspa.2006.1761) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/69380-intrinsic-time-scale-decomposition-itd) |    ✔️    |
-|                                                [`ALIF`]() (Adaptive Local Iterative Filtering)                                                |          [[paper]](https://arxiv.org/abs/1411.6051)          | [[code]](https://ww2.mathworks.cn/matlabcentral/fileexchange/56210-alif) |    ✖️    |
+|                                                [`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) |    ✖️    |
@@ -122,7 +122,7 @@ plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
 |      [`VNCMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vncmd/vncmd.py) (Variational Nonlinear Chirp Mode Decomposition)       |   [[paper]](https://ieeexplore.ieee.org/document/7990179)    | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/64292-variational-nonlinear-chirp-mode-decomposition) |    ✔️    |
 |       [`INCMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vncmd/incmd.py) (Iterative Nonlinear Chirp Mode Decomposition)        | [[paper]](https://www.sciencedirect.com/science/article/pii/S0022460X2030403X?via%3Dihub) |      [[code]](https://github.com/sheadan/IterativeNCMD)      |    ✔️    |
 |      [`MNCMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vncmd/mncmd.py) (Multivariate Nonlinear Chirp Mode Decomposition)      | [[paper]](https://www.sciencedirect.com/science/article/abs/pii/S0165168420302103) |                          [[code]]()                          |    ✖️    |
-| [`AVNCMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vncmd/avncmd.py) (Adaptive Variational Nonlinear Chirp Mode Decomposition) | [[paper]](https://ieeexplore.ieee.org/abstract/document/9746147) |         [[code]](https://github.com/HauLiang/AVNCMD)         |    ✖️    |
+| [`AVNCMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vncmd/avncmd.py) (Adaptive Variational Nonlinear Chirp Mode Decomposition) | [[paper]](https://ieeexplore.ieee.org/abstract/document/9746147) |         [[code]](https://github.com/HauLiang/AVNCMD)         |    ✔️    |
 |               [`ACMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vmd/acmd.py) (Adaptive Chirp Mode Decomposition)               |                         [[paper]]()                          | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/121373-data-driven-adaptive-chirp-mode-decomposition?s_tid=srchtitle) |    ✔️    |
 |    [`BA-ACMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_vmd/ba_acmd.py) (Bandwidth-aware adaptive chirp mode decomposition)    | [[paper]](https://journals.sagepub.com/doi/abs/10.1177/14759217231174699) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/132792-bandwidth-aware-adaptive-chirp-mode-decomposition-ba-acmd?s_tid=srchtitle) |    ✖️    |
 |               [`JMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_jmd/jmd.py) (Jump Plus AM-FM Mode Decomposition)                |         [[paper]](https://arxiv.org/abs/2407.07800)          | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/169388-jump-plus-am-fm-mode-decomposition-jmd?s_tid=prof_contriblnk) |   ️✔️    |

{pysdkit-0.4.26 → pysdkit-0.4.27}/pyproject.toml

@@ -63,4 +63,6 @@ where = ["."]
 include = ["pysdkit*"]
 
 [tool.setuptools.package-data]
-"*" = ["*.txt"]
+"*" = ["*.txt", "*.npy"]
+"pysdkit._alif" = ["data/*.npy"]
+"pysdkit._alif.data" = ["*.npy"]

{pysdkit-0.4.26 → pysdkit-0.4.27}/pysdkit/__init__.py

@@ -2,7 +2,7 @@
 A Python library for signal decomposition algorithms.
 """
 
-__version__ = "0.4.26"
+__version__ = "0.4.27"
 
 # Empirical Mode Decomposition
 from ._emd import EMD
@@ -73,6 +73,9 @@ from ._vncmd import INCMD
 # Adaptive Variational Nonlinear Chirp Mode Decomposition
 from ._vncmd import AVNCMD
 
+# Adaptive Local Iterative Filtering
+from ._alif import ALIF
+
 # Empirical Wavelet Transform
 from ._ewt import ewt, EWT
 
@@ -136,6 +139,8 @@ Variational Mode Decomposition for 2D Image     |    VMD2D
 Compact VMD for 2D Image                        |    CVMD2D
 Variational Nonlinear Chirp Mode Decomposition  |    VNCMD
 Iterative Nonlinear Chirp Mode Decomposition    |    INCMD
+Adaptive Variational Nonlinear Chirp Mode Dec.  |    AVNCMD
+Adaptive Local Iterative Filtering              |    ALIF
 Empirical Wavelet Transform                     |    EWT
 Jump Plus AM-FM Mode Decomposition              |    JMD
 Feature Mode Decomposition                      |    FMD
@@ -172,6 +177,7 @@ __all__ = [
     "VNCMD",
     "INCMD",
     "AVNCMD",
+    "ALIF",
     "ewt",
     "EWT",
     "JMD",

pysdkit-0.4.27/pysdkit/_alif/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""Adaptive Local Iterative Filtering (ALIF) package."""
+from .alif import ALIF
+from .iterative_filtering import IterativeFiltering
+
+__all__ = ["ALIF", "IterativeFiltering"]

pysdkit-0.4.27/pysdkit/_alif/_helpers.py

@@ -0,0 +1,248 @@
+# -*- coding: utf-8 -*-
+"""
+Shared helpers for Iterative Filtering (IF) and Adaptive Local Iterative Filtering (ALIF).
+
+MATLAB reference: https://github.com/Cicone/ALIF
+"""
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+import numpy as np
+
+_FILTER_PATH = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)),
+    "data",
+    "prefixed_double_filter.npy",
+)
+
+_MM_CACHE: Optional[np.ndarray] = None
+
+
+def load_prefixed_filter() -> np.ndarray:
+    """Load the prefixed double filter shipped with the package."""
+    global _MM_CACHE
+    if _MM_CACHE is None:
+        if not os.path.isfile(_FILTER_PATH):
+            raise FileNotFoundError("Missing ALIF filter data: {}".format(_FILTER_PATH))
+        _MM_CACHE = np.load(_FILTER_PATH).astype(np.float64).ravel()
+    return _MM_CACHE
+
+
+def get_mask_v1(y: np.ndarray, k: float) -> np.ndarray:
+    """
+    Resample the prefixed filter ``y`` to a mask of half-width ``k``.
+
+    Port of MATLAB ``get_mask_v1`` from ALIFv5_4.m / IF_v8_3.m.
+    """
+    y = np.asarray(y, dtype=np.float64).ravel()
+    n = y.size
+    m = (n - 1) / 2.0
+
+    if k < 0:
+        return np.array([], dtype=np.float64)
+
+    if k <= m:
+        if abs(k - round(k)) < 1e-12:
+            k_int = int(round(k))
+            a = np.zeros(2 * k_int + 1, dtype=np.float64)
+            for i in range(1, 2 * k_int + 2):
+                s = (i - 1) * (2 * m + 1) / (2 * k_int + 1) + 1
+                t = i * (2 * m + 1) / (2 * k_int + 1)
+                s2 = np.ceil(s) - s
+                t1 = t - np.floor(t)
+                cs = int(np.ceil(s))
+                ft = int(np.floor(t))
+                mid = y[cs - 1 : ft].sum() if ft >= cs else 0.0
+                a[i - 1] = mid + s2 * y[cs - 1] + t1 * y[ft - 1]
+            return a
+
+        new_k = int(np.floor(k))
+        extra = k - new_k
+        c = (2 * m + 1) / (2 * new_k + 1 + 2 * extra)
+        a = np.zeros(2 * new_k + 3, dtype=np.float64)
+
+        t = extra * c + 1
+        t1 = t - np.floor(t)
+        ft = int(np.floor(t))
+        a[0] = y[:ft].sum() + t1 * y[ft - 1]
+
+        for i in range(2, 2 * new_k + 3):
+            s = extra * c + (i - 2) * c + 1
+            t = extra * c + (i - 1) * c
+            s2 = np.ceil(s) - s
+            t1 = t - np.floor(t)
+            cs = int(np.ceil(s))
+            ft = int(np.floor(t))
+            mid = y[cs - 1 : ft].sum() if ft >= cs else 0.0
+            a[i - 1] = mid + s2 * y[cs - 1] + t1 * y[ft - 1]
+
+        t2 = np.ceil(t) - t
+        ct = int(np.ceil(t))
+        a[-1] = y[ct - 1 :].sum() + t2 * y[ct - 1]
+        return a
+
+    dx = 0.01
+    f = y / dx
+    dy = m * dx / k
+    x_src = np.arange(0.0, m + 1e-12, 1.0)
+    x_query = np.arange(0.0, m + 1e-12, m / k)
+    b = np.interp(x_query, x_src, f[int(m) : 2 * int(m) + 1])
+    a = np.concatenate([b[:0:-1], b]) * dy
+    if abs(np.abs(a).sum() - 1.0) > 1e-14:
+        a = a / np.abs(a).sum()
+    return a
+
+
+def maxmins(
+    f: np.ndarray,
+    extension_type: str = "p",
+    tol: float = 1e-15,
+) -> np.ndarray:
+    """
+    Locate extrema of ``f`` (0-based indices).
+
+    Port of MATLAB ``Maxmins_v3_3`` (periodic / constant cases used by IF & ALIF).
+    """
+    f = np.asarray(f, dtype=np.float64).ravel()
+    n_old = f.size
+    if n_old < 3:
+        return np.array([], dtype=int)
+
+    df = np.diff(f)
+    h = 0
+
+    if extension_type == "p":
+        while h < n_old - 1 and abs(df[h]) <= tol:
+            h += 1
+        if h >= n_old - 1:
+            return np.array([], dtype=int)
+        matlab_h = h + 1
+        df = np.diff(np.concatenate([f, f[1 : matlab_h + 1]]))
+        n_ext = n_old + matlab_h
+        loop_start = matlab_h
+    else:
+        n_ext = n_old
+        loop_start = 1
+        if extension_type == "c" and abs(df[0]) <= tol:
+            while h < n_old - 1 and abs(df[h]) <= tol:
+                h += 1
+            loop_start = h + 1
+
+    maxs = []
+    mins = []
+    c = 0
+    last_df = 0
+    posc = 0
+
+    def _mod_to_0based(matlab_idx: int) -> int:
+        m = matlab_idx % n_old
+        if m == 0:
+            m = n_old
+        return m - 1
+
+    for i_mat in range(loop_start, n_ext - 1):
+        i0 = i_mat - 1
+        if i0 + 1 >= df.size:
+            break
+        prod = df[i0] * df[i0 + 1]
+
+        if -tol <= prod <= tol:
+            if df[i0] < -tol:
+                last_df = -1
+                posc = i_mat
+            elif df[i0] > tol:
+                last_df = 1
+                posc = i_mat
+            c += 1
+            if df[i0 + 1] < -tol:
+                if last_df == 1:
+                    maxs.append(_mod_to_0based(posc + (c - 1) // 2 + 1))
+                c = 0
+            if df[i0 + 1] > tol:
+                if last_df == -1:
+                    mins.append(_mod_to_0based(posc + (c - 1) // 2 + 1))
+                c = 0
+
+        if prod < -tol:
+            if df[i0] < -tol and df[i0 + 1] > tol:
+                m = (i_mat + 1) % n_old
+                if m == 0:
+                    m = 1
+                mins.append(m - 1)
+                last_df = -1
+            elif df[i0] > tol and df[i0 + 1] < -tol:
+                m = (i_mat + 1) % n_old
+                if m == 0:
+                    m = 1
+                maxs.append(m - 1)
+                last_df = 1
+
+    if c > 0 and extension_type == "c":
+        if last_df > 0:
+            maxs.append(posc)
+        else:
+            mins.append(posc)
+
+    if not maxs and not mins:
+        return np.array([], dtype=int)
+
+    maxmins_arr = np.sort(np.unique(np.array(maxs + mins, dtype=int)))
+    if extension_type == "c" and maxmins_arr.size > 0:
+        if maxmins_arr[0] != 0 and maxmins_arr[-1] != n_old - 1:
+            maxmins_arr = np.unique(np.concatenate([[0], maxmins_arr, [n_old - 1]]))
+    return maxmins_arr.astype(int)
+
+
+def build_ifft_kernel(mask: np.ndarray, n: int) -> np.ndarray:
+    """Embed a short mask into an FFT multiplier of length ``n`` (periodic IF)."""
+    a = np.asarray(mask, dtype=np.float64).ravel()
+    nza = n - a.size
+    if nza < 0:
+        raise ValueError("Signal shorter than mask; tile the signal first.")
+
+    if nza % 2 == 0:
+        a_pad = np.concatenate([np.zeros(nza // 2), a, np.zeros(nza // 2)])
+        half = (a_pad.size - 1) // 2
+        a_centered = np.concatenate([a_pad[half:], a_pad[:half]])
+    else:
+        a_pad = np.concatenate(
+            [np.zeros((nza - 1) // 2), a, np.zeros((nza - 1) // 2 + 1)]
+        )
+        mid = a_pad.size // 2
+        a_centered = np.concatenate([a_pad[mid - 1 :], a_pad[: mid - 1]])
+
+    return np.real(np.fft.fft(a_centered))
+
+
+def adaptive_average(
+    h: np.ndarray, mask_lengths: np.ndarray, mm: np.ndarray
+) -> np.ndarray:
+    """
+    Position-dependent moving average used by ALIF (``ave = W * h``).
+
+    Implemented without forming the dense ``N x N`` matrix.
+    """
+    h = np.asarray(h, dtype=np.float64).ravel()
+    mask_lengths = np.asarray(mask_lengths, dtype=np.float64).ravel()
+    n = h.size
+    ave = np.zeros(n, dtype=np.float64)
+
+    for i in range(n):
+        k = float(mask_lengths[i])
+        if k <= 0:
+            continue
+        wn = get_mask_v1(mm, k)
+        if wn.size == 0:
+            continue
+        norm1 = np.abs(wn).sum()
+        if norm1 <= 0:
+            continue
+        wn = wn / norm1
+        half = (wn.size - 1) // 2
+        idxs = np.arange(i - half, i + half + 1) % n
+        if idxs.size != wn.size:
+            continue
+        ave[i] = float(np.dot(wn, h[idxs]))
+    return ave

pysdkit-0.4.27/pysdkit/_alif/alif.py

@@ -0,0 +1,191 @@
+# -*- coding: utf-8 -*-
+"""
+Adaptive Local Iterative Filtering (ALIF).
+
+MATLAB reference: https://github.com/Cicone/ALIF
+Paper: Cicone, A., Liu, J., Zhou, H. Adaptive Local Iterative Filtering for Signal
+Decomposition and Instantaneous Frequency analysis. ACHA, 41(2):384-411, 2016.
+"""
+from __future__ import annotations
+
+import time
+from typing import Optional
+
+import numpy as np
+from scipy.interpolate import interp1d
+
+from pysdkit._alif._helpers import (
+    adaptive_average,
+    load_prefixed_filter,
+    maxmins,
+)
+from pysdkit._alif.iterative_filtering import IterativeFiltering
+
+
+class ALIF(object):
+    """
+    Adaptive Local Iterative Filtering.
+
+    Decomposes a (approximately) periodic signal into IMFs plus a trend:
+        signal ≈ IMF_1 + ... + IMF_K + trend
+    """
+
+    def __init__(
+        self,
+        delta: float = 1e-4,
+        ext_points: int = 3,
+        max_imfs: int = 100,
+        xi: float = 1.6,
+        max_inner: int = 500,
+        max_time: float = np.inf,
+        verbose: int = 0,
+    ) -> None:
+        """
+        :param delta: relative energy stopping criterion for the inner loop
+        :param ext_points: stop when fewer than this many extrema remain
+        :param max_imfs: maximum number of IMFs (excluding the trend)
+        :param xi: mask-length scale factor (``ALIF.xi`` in the MATLAB code)
+        :param max_inner: maximum inner-loop iterations per IMF
+        :param max_time: wall-clock time budget in seconds
+        :param verbose: print progress when > 0
+        """
+        self.delta = delta
+        self.ext_points = ext_points
+        self.max_imfs = max_imfs
+        self.xi = xi
+        self.max_inner = max_inner
+        self.max_time = max_time
+        self.verbose = verbose
+
+        self.imfs: Optional[np.ndarray] = None
+        self.mask_lengths: Optional[np.ndarray] = None
+
+    def __call__(self, signal: np.ndarray) -> np.ndarray:
+        return self.fit_transform(signal)
+
+    def __str__(self) -> str:
+        return "Adaptive Local Iterative Filtering (ALIF)"
+
+    def _instantaneous_periods(
+        self, signal: np.ndarray, extrema: np.ndarray
+    ) -> np.ndarray:
+        """Cubic-interpolate inter-extrema spacings onto the sample grid."""
+        n = signal.size
+        # MATLAB: T_f = [diff(maxmins) (maxmins(1)+N-maxmins(end))]
+        # extrema are 0-based; convert spacings consistently
+        ext = extrema.astype(int)
+        t_f = np.diff(ext).astype(np.float64)
+        t_f = np.append(t_f, ext[0] + n - ext[-1])
+
+        # Replicate extrema / periods for smooth periodic interpolation
+        temp_t = np.tile(t_f, 11)
+        temp_ext = np.concatenate([ext + k * n for k in range(11)]).astype(np.float64)
+        # Query 1..11N in MATLAB → 0..11N-1 in Python, then take center block
+        query = np.arange(1, 11 * n + 1, dtype=np.float64)
+        # Interpolate with cubic; MATLAB interp1(...,'cubic')
+        # Use 1-based style abscissa: extrema positions as MATLAB indices
+        temp_ext_m = temp_ext + 1.0
+        interp = interp1d(
+            temp_ext_m,
+            temp_t,
+            kind="cubic",
+            fill_value="extrapolate",
+            assume_sorted=False,
+        )
+        temp_i = interp(query)
+        return np.asarray(temp_i[5 * n : 6 * n], dtype=np.float64)
+
+    def _mask_from_periods(self, i_t: np.ndarray) -> np.ndarray:
+        """
+        Smooth the instantaneous-period curve with IF and scale by ``2 * xi``.
+        """
+        n_try = 1
+        i_t0 = i_t.copy()
+        while True:
+            iff = IterativeFiltering(
+                delta=0.001,
+                ext_points=3,
+                max_imfs=n_try,
+                xi=1.6,
+                alpha=1.0,
+                max_inner=200,
+                verbose=0,
+            )
+            imf_it = iff.fit_transform(i_t0)
+            trend = imf_it[-1]
+            n_imfs = imf_it.shape[0] - 1
+            if trend.min() <= 0 and n_imfs == n_try:
+                n_try += 1
+                if n_try > 20:
+                    # Fall back to a positive smooth version of i_t
+                    trend = np.maximum(i_t, 1.0)
+                    break
+            elif trend.min() <= 0:
+                trend = np.maximum(trend, 1.0)
+                break
+            else:
+                break
+
+        return 2.0 * self.xi * np.asarray(trend, dtype=np.float64)
+
+    def fit_transform(self, signal: np.ndarray, return_masks: bool = False):
+        """
+        Run ALIF on a 1-D signal.
+
+        :param signal: input samples (treated as one period of a periodic signal)
+        :param return_masks: if True, also return the mask-length functions
+        :return: IMFs with shape ``(n_imfs + 1, N)`` (last row = trend),
+                 optionally ``mask_lengths`` with shape ``(n_imfs, N)``
+        """
+        f = np.asarray(signal, dtype=np.float64).ravel().copy()
+        n = f.size
+        mm = load_prefixed_filter()
+
+        imfs = []
+        masks = []
+        t0 = time.perf_counter()
+
+        extrema = maxmins(f, extension_type="p")
+        while (
+            extrema.size > self.ext_points
+            and len(imfs) < self.max_imfs
+            and (time.perf_counter() - t0) < self.max_time
+        ):
+            if self.verbose > 0:
+                print("ALIF: extracting IMF #{}".format(len(imfs) + 1))
+
+            i_t = self._instantaneous_periods(f, extrema)
+            mask_len = self._mask_from_periods(i_t)
+
+            if np.ceil(np.max(mask_len)) >= np.floor(n / 2.0):
+                if self.verbose > 0:
+                    print(
+                        "Mask length exceeds half the signal; "
+                        "try reducing xi. Stopping IMF extraction."
+                    )
+                break
+
+            masks.append(mask_len.copy())
+            h = f.copy()
+            sd = np.inf
+            in_step = 0
+            while sd > self.delta and in_step < self.max_inner:
+                in_step += 1
+                ave = adaptive_average(h, mask_len, mm)
+                denom = np.linalg.norm(h) ** 2
+                sd = (np.linalg.norm(ave) ** 2 / denom) if denom > 0 else 0.0
+                h = h - ave
+                if self.verbose > 1 and in_step % 10 == 0:
+                    print("  step {:3d}  SD={:.6e}".format(in_step, sd))
+
+            imfs.append(h)
+            f = f - h
+            extrema = maxmins(f, extension_type="p")
+
+        imfs.append(f)
+        self.imfs = np.vstack(imfs)
+        self.mask_lengths = np.vstack(masks) if masks else np.zeros((0, n))
+
+        if return_masks:
+            return self.imfs, self.mask_lengths
+        return self.imfs

pysdkit-0.4.27/pysdkit/_alif/data/__init__.py

@@ -0,0 +1 @@
+# Package data for the prefixed double filter used by ALIF / IF.