PySDKit 0.1__tar.gz

PySDKit-0.1/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: PySDKit
+Version: 0.1
+Summary: name
+Home-page: https://github.com/wwhenxuan/PySDKit
+Author: whenxuan
+Author-email: wwhenxuan@gmail.com
+Keywords: signal,decomposition
+Classifier: Development Status :: 3 - Alpha
+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
+Description-Content-Type: text/markdown
+
+# PySDKit
+A Python library for signal decomposition algorithms

PySDKit-0.1/PySDKit.egg-info/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: PySDKit
+Version: 0.1
+Summary: name
+Home-page: https://github.com/wwhenxuan/PySDKit
+Author: whenxuan
+Author-email: wwhenxuan@gmail.com
+Keywords: signal,decomposition
+Classifier: Development Status :: 3 - Alpha
+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
+Description-Content-Type: text/markdown
+
+# PySDKit
+A Python library for signal decomposition algorithms

PySDKit-0.1/PySDKit.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+setup.py
+PySDKit.egg-info/PKG-INFO
+PySDKit.egg-info/SOURCES.txt
+PySDKit.egg-info/dependency_links.txt
+PySDKit.egg-info/requires.txt
+PySDKit.egg-info/top_level.txt
+emd/__init__.py
+ewt/__init__.py
+mvmd/__init__.py
+vmd/__init__.py
+vmd/vmd_c.py
+vmd/vmd_f.py
+vncmd/__init__.py

PySDKit-0.1/PySDKit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

PySDKit-0.1/PySDKit.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy>=1.24.3
+scipy>=1.11.1
+matplotlib>=3.7.2

PySDKit-0.1/PySDKit.egg-info/top_level.txt

@@ -0,0 +1,5 @@
+emd
+ewt
+mvmd
+vmd
+vncmd

PySDKit-0.1/README.md

@@ -0,0 +1,2 @@
+# PySDKit
+A Python library for signal decomposition algorithms

PySDKit-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

PySDKit-0.1/setup.py

@@ -0,0 +1,36 @@
+import setuptools
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name='PySDKit',  # 使用包的名称
+    packages=setuptools.find_packages(),
+    version='0.1',  # 包的版本号，应遵循语义版本控制规则
+    description='name',  # 包的简短描述
+    url='https://github.com/wwhenxuan/PySDKit',  # 项目的地址通常来说是github
+    author='whenxuan',
+    author_email='wwhenxuan@gmail.com',
+    keywords=['signal', 'decomposition'],  # 在PyPI上搜索的相应的关键词
+    long_description=long_description,  # 这个会将README.md文件的描述放在PyPI网页中
+    long_description_content_type="text/markdown",
+    classifiers=[
+        'Development Status :: 3 - Alpha',  # Alpha表示当前包并不稳定
+        'Intended Audience :: Science/Research',  # 当前包使用的人群这里是科研和研究人员
+        'Topic :: Scientific/Engineering :: Mathematics',  # 应用的领域
+        'Topic :: Scientific/Engineering :: Artificial Intelligence',  # 应用的领域
+        'License :: OSI Approved :: MIT License',  # 使用的执照
+        'Programming Language :: Python :: 3',  # 适用的Python版本 这里是3.6以上的所有版本
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+    ],
+    python_requires='>=3.6',  # 最低的Python版本限制
+    install_requires=[
+        'numpy>=1.24.3',
+        'scipy>=1.11.1',
+        'matplotlib>=3.7.2'
+    ]  # 手动指定依赖的Python以及最低的版本
+)

PySDKit-0.1/vmd/__init__.py

@@ -0,0 +1,2 @@
+from .vmd_f import vmd
+from .vmd_c import VMD

PySDKit-0.1/vmd/vmd_c.py

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+import numpy as np
+
+
+class VMD(object):
+
+    def __init__(self):
+        pass
+
+    def fit_transform(self, f, alpha, tau, K, DC, init, tol):
+        if len(f) % 2:
+            f = f[:-1]
+
+        # Period and sampling frequency of input signal
+        fs = 1. / len(f)
+
+        ltemp = len(f) // 2
+        fMirr = np.append(np.flip(f[:ltemp], axis=0), f)
+        fMirr = np.append(fMirr, np.flip(f[-ltemp:], axis=0))
+
+        # Time Domain 0 to T (of mirrored signal)
+        T = len(fMirr)
+        t = np.arange(1, T + 1) / T
+
+        # Spectral Domain discretization
+        freqs = t - 0.5 - (1 / T)
+
+        # Maximum number of iterations (if not converged yet, then it won't anyway)
+        Niter = 500
+        # For future generalizations: individual alpha for each mode
+        Alpha = alpha * np.ones(K)
+
+        # Construct and center f_hat
+        f_hat = np.fft.fftshift((np.fft.fft(fMirr)))
+        f_hat_plus = np.copy(f_hat)  # copy f_hat
+        f_hat_plus[:T // 2] = 0
+
+        # Initialization of omega_k
+        omega_plus = np.zeros([Niter, K])
+
+        if init == 1:
+            for i in range(K):
+                omega_plus[0, i] = (0.5 / K) * (i)
+        elif init == 2:
+            omega_plus[0, :] = np.sort(np.exp(np.log(fs) + (np.log(0.5) - np.log(fs)) * np.random.rand(1, K)))
+        else:
+            omega_plus[0, :] = 0
+
+        # if DC mode imposed, set its omega to 0
+        if DC:
+            omega_plus[0, 0] = 0
+
+        # start with empty dual variables
+        lambda_hat = np.zeros([Niter, len(freqs)], dtype=complex)
+
+        # other inits
+        uDiff = tol + np.spacing(1)  # update step
+        n = 0  # loop counter
+        sum_uk = 0  # accumulator
+        # matrix keeping track of every iterant // could be discarded for mem
+        u_hat_plus = np.zeros([Niter, len(freqs), K], dtype=complex)
+
+        # *** Main loop for iterative updates***
+
+        while (uDiff > tol and n < Niter - 1):  # not converged and below iterations limit
+            # update first mode accumulator
+            k = 0
+            sum_uk = u_hat_plus[n, :, K - 1] + sum_uk - u_hat_plus[n, :, 0]
+
+            # update spectrum of first mode through Wiener filter of residuals
+            u_hat_plus[n + 1, :, k] = (f_hat_plus - sum_uk - lambda_hat[n, :] / 2) / (
+                    1. + Alpha[k] * (freqs - omega_plus[n, k]) ** 2)
+
+            # update first omega if not held at 0
+            if not (DC):
+                omega_plus[n + 1, k] = np.dot(freqs[T // 2:T], (abs(u_hat_plus[n + 1, T // 2:T, k]) ** 2)) / np.sum(
+                    abs(u_hat_plus[n + 1, T // 2:T, k]) ** 2)
+
+            # update of any other mode
+            for k in np.arange(1, K):
+                # accumulator
+                sum_uk = u_hat_plus[n + 1, :, k - 1] + sum_uk - u_hat_plus[n, :, k]
+                # mode spectrum
+                u_hat_plus[n + 1, :, k] = (f_hat_plus - sum_uk - lambda_hat[n, :] / 2) / (
+                        1 + Alpha[k] * (freqs - omega_plus[n, k]) ** 2)
+                # center frequencies
+                omega_plus[n + 1, k] = np.dot(freqs[T // 2:T], (abs(u_hat_plus[n + 1, T // 2:T, k]) ** 2)) / np.sum(
+                    abs(u_hat_plus[n + 1, T // 2:T, k]) ** 2)
+
+            # Dual ascent
+            lambda_hat[n + 1, :] = lambda_hat[n, :] + tau * (np.sum(u_hat_plus[n + 1, :, :], axis=1) - f_hat_plus)
+
+            # loop counter
+            n = n + 1
+
+            # converged yet?
+            uDiff = np.spacing(1)
+            for i in range(K):
+                uDiff = uDiff + (1 / T) * np.dot((u_hat_plus[n, :, i] - u_hat_plus[n - 1, :, i]),
+                                                 np.conj((u_hat_plus[n, :, i] - u_hat_plus[n - 1, :, i])))
+
+            uDiff = np.abs(uDiff)
+
+            # Postprocessing and cleanup
+
+        # discard empty space if converged early
+        Niter = np.min([Niter, n])
+        omega = omega_plus[:Niter, :]
+
+        idxs = np.flip(np.arange(1, T // 2 + 1), axis=0)
+        # Signal reconstruction
+        u_hat = np.zeros([T, K], dtype=complex)
+        u_hat[T // 2:T, :] = u_hat_plus[Niter - 1, T // 2:T, :]
+        u_hat[idxs, :] = np.conj(u_hat_plus[Niter - 1, T // 2:T, :])
+        u_hat[0, :] = np.conj(u_hat[-1, :])
+
+        u = np.zeros([K, len(t)])
+        for k in range(K):
+            u[k, :] = np.real(np.fft.ifft(np.fft.ifftshift(u_hat[:, k])))
+
+        # remove mirror part
+        u = u[:, T // 4:3 * T // 4]
+
+        # recompute spectrum
+        u_hat = np.zeros([u.shape[1], K], dtype=complex)
+        for k in range(K):
+            u_hat[:, k] = np.fft.fftshift(np.fft.fft(u[k, :]))
+
+        return u, u_hat, omega

PySDKit-0.1/vmd/vmd_f.py

@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Feb 20 19:24:58 2019
+
+@author: Vinícius Rezende Carvalho
+"""
+import numpy as np
+
+
+def vmd(f, alpha, tau, K, DC, init, tol):
+    """
+    u,u_hat,omega = VMD(f, alpha, tau, K, DC, init, tol)
+    Variational mode decomposition
+    Python implementation by Vinícius Rezende Carvalho - vrcarva@gmail.com
+    code based on Dominique Zosso's MATLAB code, available at:
+    https://www.mathworks.com/matlabcentral/fileexchange/44765-variational-mode-decomposition
+    Original paper:
+    Dragomiretskiy, K. and Zosso, D. (2014) ‘Variational Mode Decomposition’,
+    IEEE Transactions on Signal Processing, 62(3), pp. 531–544. doi: 10.1109/TSP.2013.2288675.
+
+
+    Input and Parameters:
+    ---------------------
+    f       - the time domain signal (1D) to be decomposed
+    alpha   - the balancing parameter of the data-fidelity constraint
+    tau     - time-step of the dual ascent ( pick 0 for noise-slack )
+    K       - the number of modes to be recovered
+    DC      - true if the first mode is put and kept at DC (0-freq)
+    init    - 0 = all omegas start at 0
+                       1 = all omegas start uniformly distributed
+                      2 = all omegas initialized randomly
+    tol     - tolerance of convergence criterion; typically around 1e-6
+
+    Output:
+    -------
+    u       - the collection of decomposed modes
+    u_hat   - spectra of the modes
+    omega   - estimated mode center-frequencies
+    """
+
+    if len(f) % 2:
+        f = f[:-1]
+
+    # Period and sampling frequency of input signal
+    fs = 1. / len(f)
+
+    ltemp = len(f) // 2
+    fMirr = np.append(np.flip(f[:ltemp], axis=0), f)
+    fMirr = np.append(fMirr, np.flip(f[-ltemp:], axis=0))
+
+    # Time Domain 0 to T (of mirrored signal)
+    T = len(fMirr)
+    t = np.arange(1, T + 1) / T
+
+    # Spectral Domain discretization
+    freqs = t - 0.5 - (1 / T)
+
+    # Maximum number of iterations (if not converged yet, then it won't anyway)
+    Niter = 500
+    # For future generalizations: individual alpha for each mode
+    Alpha = alpha * np.ones(K)
+
+    # Construct and center f_hat
+    f_hat = np.fft.fftshift((np.fft.fft(fMirr)))
+    f_hat_plus = np.copy(f_hat)  # copy f_hat
+    f_hat_plus[:T // 2] = 0
+
+    # Initialization of omega_k
+    omega_plus = np.zeros([Niter, K])
+
+    if init == 1:
+        for i in range(K):
+            omega_plus[0, i] = (0.5 / K) * (i)
+    elif init == 2:
+        omega_plus[0, :] = np.sort(np.exp(np.log(fs) + (np.log(0.5) - np.log(fs)) * np.random.rand(1, K)))
+    else:
+        omega_plus[0, :] = 0
+
+    # if DC mode imposed, set its omega to 0
+    if DC:
+        omega_plus[0, 0] = 0
+
+    # start with empty dual variables
+    lambda_hat = np.zeros([Niter, len(freqs)], dtype=complex)
+
+    # other inits
+    uDiff = tol + np.spacing(1)  # update step
+    n = 0  # loop counter
+    sum_uk = 0  # accumulator
+    # matrix keeping track of every iterant // could be discarded for mem
+    u_hat_plus = np.zeros([Niter, len(freqs), K], dtype=complex)
+
+    # *** Main loop for iterative updates***
+
+    while (uDiff > tol and n < Niter - 1):  # not converged and below iterations limit
+        # update first mode accumulator
+        k = 0
+        sum_uk = u_hat_plus[n, :, K - 1] + sum_uk - u_hat_plus[n, :, 0]
+
+        # update spectrum of first mode through Wiener filter of residuals
+        u_hat_plus[n + 1, :, k] = (f_hat_plus - sum_uk - lambda_hat[n, :] / 2) / (
+                    1. + Alpha[k] * (freqs - omega_plus[n, k]) ** 2)
+
+        # update first omega if not held at 0
+        if not (DC):
+            omega_plus[n + 1, k] = np.dot(freqs[T // 2:T], (abs(u_hat_plus[n + 1, T // 2:T, k]) ** 2)) / np.sum(
+                abs(u_hat_plus[n + 1, T // 2:T, k]) ** 2)
+
+        # update of any other mode
+        for k in np.arange(1, K):
+            # accumulator
+            sum_uk = u_hat_plus[n + 1, :, k - 1] + sum_uk - u_hat_plus[n, :, k]
+            # mode spectrum
+            u_hat_plus[n + 1, :, k] = (f_hat_plus - sum_uk - lambda_hat[n, :] / 2) / (
+                        1 + Alpha[k] * (freqs - omega_plus[n, k]) ** 2)
+            # center frequencies
+            omega_plus[n + 1, k] = np.dot(freqs[T // 2:T], (abs(u_hat_plus[n + 1, T // 2:T, k]) ** 2)) / np.sum(
+                abs(u_hat_plus[n + 1, T // 2:T, k]) ** 2)
+
+        # Dual ascent
+        lambda_hat[n + 1, :] = lambda_hat[n, :] + tau * (np.sum(u_hat_plus[n + 1, :, :], axis=1) - f_hat_plus)
+
+        # loop counter
+        n = n + 1
+
+        # converged yet?
+        uDiff = np.spacing(1)
+        for i in range(K):
+            uDiff = uDiff + (1 / T) * np.dot((u_hat_plus[n, :, i] - u_hat_plus[n - 1, :, i]),
+                                             np.conj((u_hat_plus[n, :, i] - u_hat_plus[n - 1, :, i])))
+
+        uDiff = np.abs(uDiff)
+
+        # Postprocessing and cleanup
+
+    # discard empty space if converged early
+    Niter = np.min([Niter, n])
+    omega = omega_plus[:Niter, :]
+
+    idxs = np.flip(np.arange(1, T // 2 + 1), axis=0)
+    # Signal reconstruction
+    u_hat = np.zeros([T, K], dtype=complex)
+    u_hat[T // 2:T, :] = u_hat_plus[Niter - 1, T // 2:T, :]
+    u_hat[idxs, :] = np.conj(u_hat_plus[Niter - 1, T // 2:T, :])
+    u_hat[0, :] = np.conj(u_hat[-1, :])
+
+    u = np.zeros([K, len(t)])
+    for k in range(K):
+        u[k, :] = np.real(np.fft.ifft(np.fft.ifftshift(u_hat[:, k])))
+
+    # remove mirror part
+    u = u[:, T // 4:3 * T // 4]
+
+    # recompute spectrum
+    u_hat = np.zeros([u.shape[1], K], dtype=complex)
+    for k in range(K):
+        u_hat[:, k] = np.fft.fftshift(np.fft.fft(u[k, :]))
+
+    return u, u_hat, omega