PySDKit 0.4.12__tar.gz → 0.4.14__tar.gz

{pysdkit-0.4.12 → pysdkit-0.4.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PySDKit
-Version: 0.4.12
+Version: 0.4.14
 Summary: A Python library for signal decomposition algorithms with a unified interface.
 Home-page: https://github.com/wwhenxuan/PySDKit
 Author: whenxuan
@@ -43,7 +43,6 @@ Dynamic: summary
 ![License](https://img.shields.io/github/license/wwhenxuan/PySDKit)
 [![Python](https://img.shields.io/badge/python-3.8+-blue?logo=python)](https://www.python.org/)
 [![Downloads](https://pepy.tech/badge/pysdkit)](https://pepy.tech/project/pysdkit)
-![Visits Badge](https://badges.pufler.dev/visits/ForestsKing/D3R)
 [![codestyle](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
 A Python library for signal decomposition algorithms 🥳
@@ -132,7 +131,7 @@ plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
 | [`BEMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/emd2d/bemd.py) (Bidimensional Empirical Mode Decomposition) | [[paper]](https://www.sciencedirect.com/science/article/abs/pii/S0262885603000945) | [[code]](https://github.com/laszukdawid/PyEMD/blob/master/PyEMD/BEMD.py) |   ✖️   |
 |      [`CEMD`]() (Complex Empirical Mode Decomposition)       | [[paper]](https://ieeexplore.ieee.org/abstract/document/4063369) |                          [[code]]()                          |   ✖️   |
 | [`EEMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/emd/eemd.py) (Ensemble Empirical Mode Decomposition) | [[paper]](https://www.sciencedirect.com/topics/physics-and-astronomy/ensemble-empirical-mode-decomposition) | [[code]](https://github.com/laszukdawid/PyEMD/blob/master/PyEMD/EEMD.py) |   ✔️   |
-| [`REMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/emd/remd.py) (Robust Empirical Mode Decomposition) | [[paper]](https://www.sciencedirect.com/science/article/pii/S0019057821003785) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/70032-robust-empirical-mode-decomposition-remd) |   ✖️   |
+| [`REMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/emd/remd.py) (Robust Empirical Mode Decomposition) | [[paper]](https://www.sciencedirect.com/science/article/pii/S0019057821003785) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/70032-robust-empirical-mode-decomposition-remd) |   ✔️   |
 | [`BMEMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/emd2d/bmemd.py) (Bidimensional Multivariate Empirical Mode Decomposition) |   [[paper]](https://ieeexplore.ieee.org/document/8805082)    | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/72343-bidimensional-multivariate-empirical-mode-decomposition?s_tid=FX_rc1_behav) |   ✖️   |
 | [`CEEMDAN`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/emd/ceemdan.py) (Complete Ensemble EMD with Adaptive Noise) |   [[paper]](https://ieeexplore.ieee.org/document/5947265)    | [[code]](https://github.com/laszukdawid/PyEMD/blob/master/PyEMD/EEMD.py) |   ✔️   |
 | [`TVF_EMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/tvf_emd/tvf_emd.py) (Time Varying Filter Based EMD) | [[paper]](https://www.sciencedirect.com/science/article/pii/S0165168417301135) |   [[code]](https://github.com/stfbnc/pytvfemd/tree/master)   |   ✔️   |

{pysdkit-0.4.12 → pysdkit-0.4.14}/PySDKit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PySDKit
-Version: 0.4.12
+Version: 0.4.14
 Summary: A Python library for signal decomposition algorithms with a unified interface.
 Home-page: https://github.com/wwhenxuan/PySDKit
 Author: whenxuan
@@ -43,7 +43,6 @@ Dynamic: summary
 ![License](https://img.shields.io/github/license/wwhenxuan/PySDKit)
 [![Python](https://img.shields.io/badge/python-3.8+-blue?logo=python)](https://www.python.org/)
 [![Downloads](https://pepy.tech/badge/pysdkit)](https://pepy.tech/project/pysdkit)
-![Visits Badge](https://badges.pufler.dev/visits/ForestsKing/D3R)
 [![codestyle](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
 A Python library for signal decomposition algorithms 🥳
@@ -132,7 +131,7 @@ plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
 | [`BEMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/emd2d/bemd.py) (Bidimensional Empirical Mode Decomposition) | [[paper]](https://www.sciencedirect.com/science/article/abs/pii/S0262885603000945) | [[code]](https://github.com/laszukdawid/PyEMD/blob/master/PyEMD/BEMD.py) |   ✖️   |
 |      [`CEMD`]() (Complex Empirical Mode Decomposition)       | [[paper]](https://ieeexplore.ieee.org/abstract/document/4063369) |                          [[code]]()                          |   ✖️   |
 | [`EEMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/emd/eemd.py) (Ensemble Empirical Mode Decomposition) | [[paper]](https://www.sciencedirect.com/topics/physics-and-astronomy/ensemble-empirical-mode-decomposition) | [[code]](https://github.com/laszukdawid/PyEMD/blob/master/PyEMD/EEMD.py) |   ✔️   |
-| [`REMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/emd/remd.py) (Robust Empirical Mode Decomposition) | [[paper]](https://www.sciencedirect.com/science/article/pii/S0019057821003785) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/70032-robust-empirical-mode-decomposition-remd) |   ✖️   |
+| [`REMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/emd/remd.py) (Robust Empirical Mode Decomposition) | [[paper]](https://www.sciencedirect.com/science/article/pii/S0019057821003785) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/70032-robust-empirical-mode-decomposition-remd) |   ✔️   |
 | [`BMEMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/emd2d/bmemd.py) (Bidimensional Multivariate Empirical Mode Decomposition) |   [[paper]](https://ieeexplore.ieee.org/document/8805082)    | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/72343-bidimensional-multivariate-empirical-mode-decomposition?s_tid=FX_rc1_behav) |   ✖️   |
 | [`CEEMDAN`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/emd/ceemdan.py) (Complete Ensemble EMD with Adaptive Noise) |   [[paper]](https://ieeexplore.ieee.org/document/5947265)    | [[code]](https://github.com/laszukdawid/PyEMD/blob/master/PyEMD/EEMD.py) |   ✔️   |
 | [`TVF_EMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/tvf_emd/tvf_emd.py) (Time Varying Filter Based EMD) | [[paper]](https://www.sciencedirect.com/science/article/pii/S0165168417301135) |   [[code]](https://github.com/stfbnc/pytvfemd/tree/master)   |   ✔️   |

{pysdkit-0.4.12 → pysdkit-0.4.14}/PySDKit.egg-info/SOURCES.txt

@@ -8,8 +8,10 @@ PySDKit.egg-info/top_level.txt
 pysdkit/__init__.py
 pysdkit/data/__init__.py
 pysdkit/data/_add_noise.py
+pysdkit/data/_cube.py
 pysdkit/data/_generator.py
 pysdkit/data/_image.py
+pysdkit/data/_time_series.py
 pysdkit/data/texture.txt
 pysdkit/emd/__init__.py
 pysdkit/emd/_find_extrema.py
@@ -20,6 +22,7 @@ pysdkit/emd/eemd.py
 pysdkit/emd/emd.py
 pysdkit/emd/memd.py
 pysdkit/emd/remd.py
+pysdkit/emd/tvf_emd.py
 pysdkit/emd2d/__init__.py
 pysdkit/emd2d/bemd.py
 pysdkit/emd2d/bmemd.py
@@ -53,25 +56,30 @@ pysdkit/plot/_fourier_spectra.py
 pysdkit/plot/_functions.py
 pysdkit/plot/_plot_images.py
 pysdkit/plot/_plot_imfs.py
+pysdkit/plot/_plot_signal.py
 pysdkit/ssa/__init__.py
 pysdkit/ssa/ssa.py
-pysdkit/tvf_emd/__init__.py
-pysdkit/tvf_emd/tvf_emd.py
+pysdkit/tsa/__init__.py
+pysdkit/tsa/_dtw.py
+pysdkit/tsa/_moving_decomp.py
+pysdkit/tsa/mstl.py
+pysdkit/tsa/stl.py
 pysdkit/utils/_Index_of_Orthogonality.py
 pysdkit/utils/__init__.py
+pysdkit/utils/_cite.py
+pysdkit/utils/_correlation.py
 pysdkit/utils/_diagnalization.py
 pysdkit/utils/_differ.py
 pysdkit/utils/_fft.py
 pysdkit/utils/_function.py
+pysdkit/utils/_hilbert.py
+pysdkit/utils/_instantaneous.py
 pysdkit/utils/_kernel_matrix.py
 pysdkit/utils/_lags.py
+pysdkit/utils/_mirror.py
+pysdkit/utils/_process.py
 pysdkit/utils/_smooth1d.py
 pysdkit/utils/_types.py
-pysdkit/utils/correlation.py
-pysdkit/utils/hilbert.py
-pysdkit/utils/instantaneous.py
-pysdkit/utils/mirror.py
-pysdkit/utils/process.py
 pysdkit/vmd/__init__.py
 pysdkit/vmd/acmd.py
 pysdkit/vmd/avmd.py

{pysdkit-0.4.12 → pysdkit-0.4.14}/README.md

@@ -6,7 +6,6 @@
 ![License](https://img.shields.io/github/license/wwhenxuan/PySDKit)
 [![Python](https://img.shields.io/badge/python-3.8+-blue?logo=python)](https://www.python.org/)
 [![Downloads](https://pepy.tech/badge/pysdkit)](https://pepy.tech/project/pysdkit)
-![Visits Badge](https://badges.pufler.dev/visits/ForestsKing/D3R)
 [![codestyle](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
 A Python library for signal decomposition algorithms 🥳
@@ -95,7 +94,7 @@ plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
 | [`BEMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/emd2d/bemd.py) (Bidimensional Empirical Mode Decomposition) | [[paper]](https://www.sciencedirect.com/science/article/abs/pii/S0262885603000945) | [[code]](https://github.com/laszukdawid/PyEMD/blob/master/PyEMD/BEMD.py) |   ✖️   |
 |      [`CEMD`]() (Complex Empirical Mode Decomposition)       | [[paper]](https://ieeexplore.ieee.org/abstract/document/4063369) |                          [[code]]()                          |   ✖️   |
 | [`EEMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/emd/eemd.py) (Ensemble Empirical Mode Decomposition) | [[paper]](https://www.sciencedirect.com/topics/physics-and-astronomy/ensemble-empirical-mode-decomposition) | [[code]](https://github.com/laszukdawid/PyEMD/blob/master/PyEMD/EEMD.py) |   ✔️   |
-| [`REMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/emd/remd.py) (Robust Empirical Mode Decomposition) | [[paper]](https://www.sciencedirect.com/science/article/pii/S0019057821003785) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/70032-robust-empirical-mode-decomposition-remd) |   ✖️   |
+| [`REMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/emd/remd.py) (Robust Empirical Mode Decomposition) | [[paper]](https://www.sciencedirect.com/science/article/pii/S0019057821003785) | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/70032-robust-empirical-mode-decomposition-remd) |   ✔️   |
 | [`BMEMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/emd2d/bmemd.py) (Bidimensional Multivariate Empirical Mode Decomposition) |   [[paper]](https://ieeexplore.ieee.org/document/8805082)    | [[code]](https://www.mathworks.com/matlabcentral/fileexchange/72343-bidimensional-multivariate-empirical-mode-decomposition?s_tid=FX_rc1_behav) |   ✖️   |
 | [`CEEMDAN`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/emd/ceemdan.py) (Complete Ensemble EMD with Adaptive Noise) |   [[paper]](https://ieeexplore.ieee.org/document/5947265)    | [[code]](https://github.com/laszukdawid/PyEMD/blob/master/PyEMD/EEMD.py) |   ✔️   |
 | [`TVF_EMD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/tvf_emd/tvf_emd.py) (Time Varying Filter Based EMD) | [[paper]](https://www.sciencedirect.com/science/article/pii/S0165168417301135) |   [[code]](https://github.com/stfbnc/pytvfemd/tree/master)   |   ✔️   |

{pysdkit-0.4.12 → pysdkit-0.4.14}/pysdkit/__init__.py

@@ -7,11 +7,14 @@ from .emd import EEMD
 # 具有自适应噪声的完全集合经验模态分解
 from .emd import CEEMDAN
 
+# 稳健经验模态分解
+from .emd import REMD
+
 # 多元变分模态分解算法
 from .emd import MEMD
 
 # 基于时变滤波器的经验模态分解
-from .tvf_emd import TVF_EMD
+from .emd import TVF_EMD
 
 # 希尔伯特震动分解
 from .hvd import HVD
@@ -45,3 +48,6 @@ from .vncmd import VNCMD
 
 # 经验小波变换
 from .ewt import ewt, EWT
+
+# 滑动平均分解
+from .tsa import Moving_Decomp

{pysdkit-0.4.12 → pysdkit-0.4.14}/pysdkit/data/__init__.py

@@ -14,17 +14,17 @@ from ._generator import (
 )
 from ._generator import generate_am_signal, generate_exponential_signal
 
+# Generator for 1D univariate time series data
+from ._time_series import generate_time_series
+
 # Generates the main test sample signal
 from ._generator import test_emd
 
 # Generator for 1D univariate
-from ._generator import test_uni_signal
+from ._generator import test_univariate_signal
 
 # Generator for 1D multivariate
-from ._generator import test_multi_signal
-
-# Functions that generate signal visualizations
-from ._generator import plot_signal
+from ._generator import test_multivariate_signal
 
 # add Gaussian noise
 from ._add_noise import add_noise
@@ -32,8 +32,14 @@ from ._add_noise import add_noise
 # Test case for loading a 2D grayscale image
 from ._image import test_grayscale
 
-# Test case for univariate image
-from ._image import test_uni_image
+# Test case for univariate 2D image
+from ._image import test_univariate_image
+
+# Test case for multivariate 2D image
+from ._image import test_multivariate_image
+
+# Test case for univariate 3D cube
+from ._cube import test_univariate_cube
 
-# Test case for multivariate image
-from ._image import test_multi_image
+# Test case for multivariate 3D cube
+from ._cube import test_multivariate_cube

pysdkit-0.4.14/pysdkit/data/_cube.py

@@ -0,0 +1,276 @@
+# -*- coding: utf-8 -*-
+"""
+Created on 2025/02/11 00:19:03
+@author: Whenxuan Wang
+@email: wwhenxuan@gmail.com
+Generate 3D cube test sample
+"""
+import numpy as np
+
+from typing import Optional, Union, Tuple, List
+
+
+def get_meshgrid_3D(
+    low: Union[int, np.ndarray], high: Union[int, np.ndarray], sampling_rate: int = 30
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Generate a grid 3D cube given an input and output range
+    :param low: Minimum value of grid matrix,
+                If it is a ndarray array, its length must be 3 to indicate the range of three dimensions.
+    :param high: Maximum value of grid matrix,
+                If it is a ndarray array, its length must be 3 to indicate the range of three dimensions.
+    :param sampling_rate: The sampling rate of the grid matrix, which is the number of points in the matrix
+    :return: A grid matrix generated from a range in the form of a tuple
+    """
+    # First obtain a one-dimensional range array by specifying the ranges `low` and `high`
+    if isinstance(low, np.ndarray) and isinstance(high, np.ndarray):
+        # Both range parameters are Numpy arrays
+        X = np.linspace(low[0], high[0], sampling_rate)
+        Y = np.linspace(low[1], high[1], sampling_rate)
+        Z = np.linspace(low[2], high[2], sampling_rate)
+
+    elif isinstance(low, np.ndarray) and isinstance(high, int):
+        # `low` is a Numpy array `high` is a constant
+        X = np.linspace(low[0], high, sampling_rate)
+        Y = np.linspace(low[1], high, sampling_rate)
+        Z = np.linspace(low[2], high, sampling_rate)
+
+    elif isinstance(low, int) and isinstance(high, np.ndarray):
+        # `low` is a constant `high` is a Numpy array
+        X = np.linspace(low, high[0], sampling_rate)
+        Y = np.linspace(low, high[1], sampling_rate)
+        Z = np.linspace(low, high[2], sampling_rate)
+
+    elif isinstance(low, int) and isinstance(high, int):
+        # Both range parameters are constants
+        X = np.linspace(low, high, sampling_rate)
+        Y = np.linspace(low, high, sampling_rate)
+        Z = np.linspace(low, high, sampling_rate)
+
+    else:
+        raise TypeError("The params `low` and `high` must be int or ndarray of numpy!")
+
+    # Further generate network cube
+    x, y, z = np.meshgrid(X, Y, Z)
+
+    return x, y, z
+
+
+def test_univariate_cube(
+    case: int = 1,
+    low: Union[int, np.ndarray] = 0,
+    high: Union[int, np.ndarray] = 10,
+    sampling_rate: int = 30,
+) -> np.ndarray:
+    """
+    Generate a 3D cube data for testing 3D univariate signal decomposition algorithms
+
+    :param case: Test case, range in [1, 2, 3, 4, 5, 6]
+    :param low: Minimum value of grid matrix,
+                If it is a ndarray array, its length must be 3 to indicate the range of three dimensions.
+    :param high: Maximum value of grid matrix,
+                If it is a ndarray array, its length must be 3 to indicate the range of three dimensions.
+    :param sampling_rate: The sampling rate of the grid matrix, which is the number of points in the matrix
+    :return: Get a 3D cube data of a specified range
+    """
+    # Generate data based on the input test sample number
+    if case == 1:
+        return test_cube_1(low=low, high=high, sampling_rate=sampling_rate)
+    elif case == 2:
+        return test_cube_2(low=low, high=high, sampling_rate=sampling_rate)
+    elif case == 3:
+        return test_cube_3(low=low, high=high, sampling_rate=sampling_rate)
+    elif case == 4:
+        return test_cube_4(low=low, high=high, sampling_rate=sampling_rate)
+    elif case == 5:
+        return test_cube_5(low=low, high=high, sampling_rate=sampling_rate)
+    elif case == 6:
+        return test_cube_6(low=low, high=high, sampling_rate=sampling_rate)
+    else:
+        raise TypeError("The params `case` must be in the range of [1, 2, 3, 4, 5, 6]")
+
+
+def test_multivariate_cube(
+    case: Union[List[int], Tuple[int], np.ndarray] = None,
+    low: Union[int, np.ndarray] = 0,
+    high: Union[int, np.ndarray] = 10,
+    sampling_rate: int = 30,
+) -> np.ndarray:
+    """
+    Generate 3D cubes data for testing 3D multivariate signal decomposition algorithms
+    :param case: The test cases to use are specified by inputting a list or tuple or ndarray in the range [1, 2, 3, 4, 5, 6],
+                 The default parameter settings are [1, 2, 3].
+    :param low: Minimum value of grid matrix,
+                If it is a ndarray array, its length must be 3 to indicate the range of three dimensions.
+    :param high: Maximum value of grid matrix,
+                If it is a ndarray array, its length must be 3 to indicate the range of three dimensions.
+    :param sampling_rate: The sampling rate of the grid matrix, which is the number of points in the matrix
+    :return: Get 3D cube data of multiple different channels
+    """
+    # Default Parameters
+    if case is None:
+        case = [1, 2, 3]
+    # Make sure it is the correct data type
+    if (
+        isinstance(case, tuple)
+        or isinstance(case, list)
+        or isinstance(case, np.ndarray)
+    ):
+        # Make sure there is content
+        if len(case) >= 1:
+            cubes = np.vstack(
+                [
+                    test_univariate_cube(
+                        case=c, low=low, high=high, sampling_rate=sampling_rate
+                    )
+                    for c in case
+                ]
+            )
+            return cubes
+        else:
+            raise ValueError("The number in `case` must be greater than 1!")
+    else:
+        raise TypeError("The params `case` should be a list or tuple or ndarray!")
+
+
+def test_cube_1(
+    low: Union[int, np.ndarray], high: Union[int, np.ndarray], sampling_rate: int = 30
+) -> np.ndarray:
+    """
+    Generate a 3D cube test example 1
+    :param low: Minimum value of grid matrix
+    :param high: Maximum value of grid matrix
+    :param sampling_rate: The sampling rate of the grid matrix, which is the number of points in the matrix
+    :return: Cube generated by sine and cosine functions
+    """
+    # First generate the grid array
+    x, y, z = get_meshgrid_3D(low=low, high=high, sampling_rate=sampling_rate)
+    # Generate cubes of different frequencies
+    uc1 = np.sin(3.5 * x) + np.sin(3.5 * y) + np.sin(3.5 * z)
+    uc2 = np.sin(x) + np.sin(y) + np.sin(z)
+    ru = np.cos(x / 24) + np.cos(y / 24) + np.cos(z / 24)
+    # Fusion of different modalities
+    u = uc1 + uc2 + ru
+    # Standardize the results of the integration
+    u = (u - np.mean(u)) / np.std(u + 0.01)
+    return u
+
+
+def test_cube_2(
+    low: Union[int, np.ndarray], high: Union[int, np.ndarray], sampling_rate: int = 30
+) -> np.ndarray:
+    """
+    Generate a 3D cube test example 2
+    :param low: Minimum value of grid matrix
+    :param high: Maximum value of grid matrix
+    :param sampling_rate: The sampling rate of the grid matrix, which is the number of points in the matrix
+    :return: Cube generated by sine and cosine functions
+    """
+    # First generate the grid array
+    x, y, z = get_meshgrid_3D(low=low, high=high, sampling_rate=sampling_rate)
+    # Generate cubes of different frequencies
+    uc1 = np.sin(5 * x) + np.sin(5 * y) + np.sin(5 * z)
+    uc2 = np.sin(x) + np.sin(y) + np.sin(z)
+    ru = np.cos(x / 16) + np.cos(y / 16) + np.cos(z / 16)
+    # Fusion of different modalities
+    u = uc1 + uc2 + ru
+    # Standardize the results of the integration
+    u = (u - np.mean(u)) / np.std(u + 0.001)
+    return u
+
+
+def test_cube_3(
+    low: Union[int, np.ndarray], high: Union[int, np.ndarray], sampling_rate: int = 30
+) -> np.ndarray:
+    """
+    Generate a 3D cube test example 3
+    :param low: Minimum value of grid matrix
+    :param high: Maximum value of grid matrix
+    :param sampling_rate: The sampling rate of the grid matrix, which is the number of points in the matrix
+    :return: Cube generated by sine and cosine functions
+    """
+    # First generate the grid array
+    x, y, z = get_meshgrid_3D(low=low, high=high, sampling_rate=sampling_rate)
+    # Generate cubes of different frequencies
+    uc1 = np.sin(2 * x) + np.sin(2 * y) + np.sin(2 * z)
+    uc2 = np.sin(4 * x) + np.sin(4 * y) + np.sin(4 * z)
+    ru = np.cos(x / 24) + np.cos(y / 24) + np.cos(z / 24)
+    # Fusion of different modalities
+    u = uc1 + uc2 + ru
+    # Standardize the results of the integration
+    u = (u - np.mean(u)) / np.std(u + 0.001)
+    return u
+
+
+def test_cube_4(
+    low: Union[int, np.ndarray], high: Union[int, np.ndarray], sampling_rate: int = 30
+) -> np.ndarray:
+    """
+    Generate a 3D cube test example 4
+    :param low: Minimum value of grid matrix
+    :param high: Maximum value of grid matrix
+    :param sampling_rate: The sampling rate of the grid matrix, which is the number of points in the matrix
+    :return: Cube generated by sine and cosine functions
+    """
+    # First generate the grid array
+    x, y, z = get_meshgrid_3D(low=low, high=high, sampling_rate=sampling_rate)
+    # Generate cubes of different frequencies
+    uc1 = np.sin(2 * x**1.5) + np.sin(2 * y**1.5) + np.sin(2 * z * 1.5)
+    uc2 = np.sin(5 * x) + np.sin(5 * y) + np.sin(5 * z)
+    ru = np.cos(x / 24) + np.cos(y / 24) + np.cos(z / 24)
+    # Fusion of different modalities
+    u = uc1 + uc2 + ru
+    # Standardize the results of the integration
+    u = (u - np.mean(u)) / np.std(u + 0.001)
+    return u
+
+
+def test_cube_5(
+    low: Union[int, np.ndarray], high: Union[int, np.ndarray], sampling_rate: int = 30
+) -> np.ndarray:
+    """
+    Generate a 3D cube test example 5
+    :param low: Minimum value of grid matrix
+    :param high: Maximum value of grid matrix
+    :param sampling_rate: The sampling rate of the grid matrix, which is the number of points in the matrix
+    :return: Cube generated by sine and cosine functions
+    """
+    # First generate the grid array
+    x, y, z = get_meshgrid_3D(low=low, high=high, sampling_rate=sampling_rate)
+    # Generate cubes of different frequencies
+    uc1 = np.cos(x**2) + np.cos(y**2) + np.cos(z * 2)
+    uc2 = np.sin(5 * x) + np.sin(5 * y) + np.sin(5 * z)
+    ru = np.cos(x / 24) + np.cos(y / 24) + np.cos(z / 24)
+    # Fusion of different modalities
+    u = uc1 + uc2 + ru
+    # Standardize the results of the integration
+    u = (u - np.mean(u)) / np.std(u + 0.001)
+    return u
+
+
+def test_cube_6(
+    low: Union[int, np.ndarray], high: Union[int, np.ndarray], sampling_rate: int = 30
+) -> np.ndarray:
+    """
+    Generate a 3D cube test example 6
+    :param low: Minimum value of grid matrix
+    :param high: Maximum value of grid matrix
+    :param sampling_rate: The sampling rate of the grid matrix, which is the number of points in the matrix
+    :return: Cube generated by sine and cosine functions
+    """
+    # First generate the grid array
+    x, y, z = get_meshgrid_3D(low=low, high=high, sampling_rate=sampling_rate)
+    # Generate cubes of different frequencies
+    uc1 = np.cos(x**2) + np.cos(y**2) + np.cos(z * 2)
+    uc2 = np.sin(5 * x) + np.sin(5 * y) + np.sin(5 * z)
+    ru = np.cos(x / 24) + np.cos(y / 24) + np.cos(z / 24)
+    # Fusion of different modalities
+    u = uc1 + uc2 + ru
+    # Standardize the results of the integration
+    u = (u - np.mean(u)) / np.std(u + 0.001)
+    return u
+
+
+if __name__ == "__main__":
+    print(test_univariate_cube().shape)
+    print(test_univariate_cube())

{pysdkit-0.4.12 → pysdkit-0.4.14}/pysdkit/data/_generator.py

@@ -8,7 +8,7 @@ import numpy as np
 from scipy.signal import sawtooth
 from matplotlib import pyplot as plt
 
-from typing import Tuple
+from typing import Tuple, Optional
 
 
 def generate_sin_signal(
@@ -198,7 +198,7 @@ def generate_exponential_signal(
     return t, noisy_exp_signal
 
 
-def test_uni_signal(
+def test_univariate_signal(
     case: int = 1,
     duration: float = 1.0,
     sampling_rate: int = 1000,
@@ -254,7 +254,12 @@ def test_1D_2(
     :return: Tuple containing time array and the 3 * 2 ^ (-t) * sin(sin(2 * pi * t)) signal.
     """
     t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
-    signal = 3 * 2 ^ (-t) * np.sin(np.sin(2 * np.pi * t))
+    signal = (
+        3 * 2 ** (-t) * np.sin(np.sin(2 * np.pi * t))
+        + np.cos(2 * np.pi * t * 5)
+        + np.sin(2 * np.pi * (t + 2 * t**2))
+        + np.sin(2 * np.pi * t * 30)
+    )
     return t, signal
 
 
@@ -274,7 +279,13 @@ def test_1D_3(
     """
     np.random.seed(seed=random_state)
     t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
-    signal = 5 * np.sin(2 * np.pi * t) + 3 * np.sin(2 * np.pi * t)
+    signal = (
+        5 * np.sin(2 * np.pi * t)
+        + 3 * np.cos(2 * np.pi * t)
+        + 2 * np.cos(2 * np.pi * t**2)
+        + np.sin(2 * np.pi * t**3)
+        + np.sin(2 * np.pi * (t * 30 + t**2 * 2))
+    )
     noise = np.random.normal(0, noise_level, signal.shape)
     noise_signal = signal + noise
     return t, noise_signal
@@ -302,7 +313,7 @@ def test_emd(
     return t, noise_signal
 
 
-def test_multi_signal(
+def test_multivariate_signal(
     case: int = 1,
     duration: float = 1.0,
     sampling_rate: int = 1000,
@@ -316,18 +327,18 @@ def test_multi_signal(
     :return: the generated signal for multivariate 1D.
     """
     if case == 1:
-        return test_multi_1D_1(duration=duration, sampling_rate=sampling_rate)
+        return test_multivariate_1D_1(duration=duration, sampling_rate=sampling_rate)
     elif case == 2:
-        return test_multi_1D_2(duration=duration, sampling_rate=sampling_rate)
+        return test_multivariate_1D_2(duration=duration, sampling_rate=sampling_rate)
     elif case == 3:
-        return test_multi_1D_3(duration=duration, sampling_rate=sampling_rate)
+        return test_multivariate_1D_3(duration=duration, sampling_rate=sampling_rate)
     else:
         # When there is no such test instance, the function returns `case==1`
         print(f"There is no case {case}, so it will return case==1!")
-        return test_multi_1D_1(duration=duration, sampling_rate=sampling_rate)
+        return test_multivariate_1D_1(duration=duration, sampling_rate=sampling_rate)
 
 
-def test_multi_1D_1(
+def test_multivariate_1D_1(
     duration: float = 1.0, sampling_rate: int = 1000
 ) -> Tuple[np.array, np.array]:
     """
@@ -350,7 +361,7 @@ def test_multi_1D_1(
     return t, signal
 
 
-def test_multi_1D_2(
+def test_multivariate_1D_2(
     duration: float = 1.0, sampling_rate: int = 1000
 ) -> Tuple[np.array, np.array]:
     """
@@ -361,7 +372,6 @@ def test_multi_1D_2(
     """
     np.random.seed(seed=42)
     t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
-    t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
 
     # Generate the multi-channels signals
     signal_1 = (
@@ -391,7 +401,7 @@ def test_multi_1D_2(
     return t, signal
 
 
-def test_multi_1D_3(
+def test_multivariate_1D_3(
     duration: float = 1.0,
     sampling_rate: int = 1000,
     noise_level: float = 0.1,
@@ -445,85 +455,16 @@ def test_multi_1D_3(
     return t, f
 
 
-def plot_signal(
-    t: np.array,
-    signal: np.array,
-    color: str = "royalblue",
-    save: bool = False,
-    dpi: int = 128,
-    fontsize: int = 12,
-) -> plt.figure:
-    """
-    Plot and optionally save an amplitude modulated (AM) signal with time on the x-axis and amplitude on the y-axis.
-    :param t: Array of time points corresponding to the signal.
-    :param signal: Array containing the signal data to be plotted.
-    :param color: Color of the plot line.
-    :param save: Boolean flag to indicate whether the plot should be saved to a file.
-    :param dpi: Dots per inch (resolution) of the figure, if saved.
-    :param fontsize: Font size of the axis labels.
-    :return: The figure object containing the plot.
-    """
-
-    # Determine the number of input signals
-    n_dim = len(signal.shape)
-
-    if n_dim == 1:
-        # Create a figure and a single subplot
-        fig, ax = plt.subplots(figsize=(8, 3))
-
-        # Plot the signal against time with specified line color
-        ax.plot(t, signal, color=color)
-
-        # Set the x-axis label with specified font size
-        ax.set_xlabel("Time (seconds)", fontsize=fontsize)
-
-        # Set the y-axis label with default font size
-        ax.set_ylabel("Amplitude", fontsize=fontsize)
-
-        # Enable grid for better readability
-        ax.grid(True)
-
-    elif n_dim == 2:
-        # Determining the number of multivariate signals
-        n_vars = signal.shape[0]
-
-        # Create a figure and a single subplot
-        fig, ax = plt.subplots(nrows=n_vars, figsize=(10, 1 + 2 * n_vars), sharex=True)
-
-        for i in range(n_vars):
-            # Plot the signal against time with specified line color
-            ax[i].plot(t, signal[i, :], color=color)
-
-            # Set the y-axis label with default font size
-            ax[i].set_ylabel("Amplitude", fontsize=fontsize)
-
-            # Enable grid for better readability
-            ax[i].grid(True)
-
-        # Set the x-axis label with specified font size
-        ax[-1].set_xlabel("Time (seconds)", fontsize=fontsize)
-
-    else:
-        raise ValueError("Wrong input signal, please input the 1D signal.")
-
-    # Check if the figure needs to be saved
-    if save:
-        # Save the figure with the specified dpi and bounding box tightly around the figure
-        fig.savefig("generate_signal.jpg", dpi=dpi, bbox_inches="tight")
-
-    # Return the figure object
-    return fig
-
-
 if __name__ == "__main__":
-    from pysdkit.data import test_emd, plot_signal, test_multi_signal
+    from pysdkit.data import test_emd, test_multivariate_signal
+    from pysdkit.plot import plot_signal
 
-    t, signal = test_uni_signal(case=1)
+    t, signal = test_univariate_signal(case=1)
     print(signal.shape)
 
     fig = plot_signal(t, signal)
 
-    t, signal = test_multi_signal(case=2)
+    t, signal = test_multivariate_signal(case=2)
     print(signal.shape)
 
     fig = plot_signal(t, signal, save=False)