pyentrp 0.1.0__tar.gz

pyentrp-0.1.0/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 1.1
+Name: pyentrp
+Version: 0.1.0
+Summary: Functions on top of NumPy for computing different types of entropy
+Home-page: https://github.com/nikdon/pyEntropy
+Author: Nikolay Donets
+Author-email: nd.startup@gmail.com
+License: Apache-2.0
+Download-URL: https://github.com/nikdon/pyEntropy/archive/0.1.0.tar.gz
+Description: UNKNOWN
+Keywords: entropy,python,sample entropy,multiscale entropy,permutation entropy,composite multiscale entropy
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Scientific/Engineering :: Mathematics

pyentrp-0.1.0/pyentrp/entropy.py

@@ -0,0 +1,259 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import unicode_literals
+
+import itertools
+import numpy as np
+
+
+def util_pattern_space(time_series, lag, dim):
+    """Create a set of sequences with given lag and dimension
+
+    Args:
+       time_series: Vector or string of the sample data
+       lag: Lag between beginning of sequences
+       dim: Dimension (number of patterns)
+
+    Returns:
+        2D array of vectors
+
+    """
+    n = len(time_series)
+
+    if lag * dim > n:
+        raise Exception('Result matrix exceeded size limit, try to change lag or dim.')
+    elif lag < 1:
+        raise Exception('Lag should be greater or equal to 1.')
+
+    pattern_space = np.empty((n - lag * (dim - 1), dim))
+    for i in range(n - lag * (dim - 1)):
+        for j in range(dim):
+            pattern_space[i][j] = time_series[i + j * lag]
+
+    return pattern_space
+
+
+def util_standardize_signal(time_series):
+    return (time_series - np.mean(time_series)) / np.std(time_series)
+
+
+def util_granulate_time_series(time_series, scale):
+    """Extract coarse-grained time series
+
+    Args:
+        time_series: Time series
+        scale: Scale factor
+
+    Returns:
+        Vector of coarse-grained time series with given scale factor
+    """
+    n = len(time_series)
+    b = int(np.fix(n / scale))
+    cts = [0] * b
+    for i in range(b):
+        cts[i] = np.mean(time_series[i * scale: (i + 1) * scale])
+    return cts
+
+
+def shannon_entropy(time_series):
+    """Return the Shannon Entropy of the sample data.
+
+    Args:
+        time_series: Vector or string of the sample data
+
+    Returns:
+        The Shannon Entropy as float value
+    """
+
+    # Check if string
+    if not isinstance(time_series, str):
+        time_series = list(time_series)
+
+    # Create a frequency data
+    data_set = list(set(time_series))
+    freq_list = []
+    for entry in data_set:
+        counter = 0.
+        for i in time_series:
+            if i == entry:
+                counter += 1
+        freq_list.append(float(counter) / len(time_series))
+
+    # Shannon entropy
+    ent = 0.0
+    for freq in freq_list:
+        ent += freq * np.log2(freq)
+    ent = -ent
+
+    return ent
+
+
+def sample_entropy(time_series, sample_length, tolerance=None):
+    """Calculate and return Sample Entropy of the given time series.
+    Distance between two vectors defined as Euclidean distance and can
+    be changed in future releases
+
+    Args:
+        time_series: Vector or string of the sample data
+        sample_length: Number of sequential points of the time series
+        tolerance: Tolerance (default = 0.1...0.2 * std(time_series))
+
+    Returns:
+        Vector containing Sample Entropy (float)
+
+    References:
+        [1] http://en.wikipedia.org/wiki/Sample_Entropy
+        [2] http://physionet.incor.usp.br/physiotools/sampen/
+        [3] Madalena Costa, Ary Goldberger, CK Peng. Multiscale entropy analysis
+            of biological signals
+    """
+    if tolerance is None:
+        tolerance = 0.1 * np.std(time_series)
+
+    n = len(time_series)
+    prev = np.zeros(n)
+    curr = np.zeros(n)
+    A = np.zeros((sample_length, 1))  # number of matches for m = [1,...,template_length - 1]
+    B = np.zeros((sample_length, 1))  # number of matches for m = [1,...,template_length]
+
+    for i in range(n - 1):
+        nj = n - i - 1
+        ts1 = time_series[i]
+        for jj in range(nj):
+            j = jj + i + 1
+            if abs(time_series[j] - ts1) < tolerance:  # distance between two vectors
+                curr[jj] = prev[jj] + 1
+                temp_ts_length = min(sample_length, curr[jj])
+                for m in range(int(temp_ts_length)):
+                    A[m] += 1
+                    if j < n - 1:
+                        B[m] += 1
+            else:
+                curr[jj] = 0
+        for j in range(nj):
+            prev[j] = curr[j]
+
+    N = n * (n - 1) / 2
+    B = np.vstack(([N], B[:sample_length - 1]))
+    similarity_ratio = A / B
+    se = - np.log(similarity_ratio)
+    se = np.reshape(se, -1)
+    return se
+
+
+def multiscale_entropy(time_series, sample_length, tolerance):
+    """Calculate the Multiscale Entropy of the given time series considering
+    different time-scales of the time series.
+
+    Args:
+        time_series: Time series for analysis
+        sample_length: Bandwidth or group of points
+        tolerance: Tolerance (default = 0.1...0.2 * std(time_series))
+
+    Returns:
+        Vector containing Multiscale Entropy
+
+    Reference:
+        [1] http://en.pudn.com/downloads149/sourcecode/math/detail646216_en.html
+    """
+    n = len(time_series)
+    mse = np.zeros((1, sample_length))
+
+    for i in range(sample_length):
+        b = int(np.fix(n / (i + 1)))
+        temp_ts = [0] * int(b)
+        for j in range(b):
+            num = sum(time_series[j * (i + 1): (j + 1) * (i + 1)])
+            den = i + 1
+            temp_ts[j] = float(num) / float(den)
+        se = sample_entropy(temp_ts, 1, tolerance)
+        mse[0, i] = se
+
+    return mse[0]
+
+
+def permutation_entropy(time_series, m, delay):
+    """Calculate the Permutation Entropy
+
+    Args:
+        time_series: Time series for analysis
+        m: Order of permutation entropy
+        delay: Time delay
+
+    Returns:
+        Vector containing Permutation Entropy
+
+    Reference:
+        [1] Massimiliano Zanin et al. Permutation Entropy and Its Main Biomedical and Econophysics Applications:
+            A Review. http://www.mdpi.com/1099-4300/14/8/1553/pdf
+        [2] Christoph Bandt and Bernd Pompe. Permutation entropy — a natural complexity
+            measure for time series. http://stubber.math-inf.uni-greifswald.de/pub/full/prep/2001/11.pdf
+        [3] http://www.mathworks.com/matlabcentral/fileexchange/37289-permutation-entropy/content/pec.m
+    """
+    n = len(time_series)
+    permutations = np.array(list(itertools.permutations(range(m))))
+    c = [0] * len(permutations)
+
+    for i in range(n - delay * (m - 1)):
+        # sorted_time_series =    np.sort(time_series[i:i+delay*m:delay], kind='quicksort')
+        sorted_index_array = np.array(np.argsort(time_series[i:i + delay * m:delay], kind='quicksort'))
+        for j in range(len(permutations)):
+            if abs(permutations[j] - sorted_index_array).any() == 0:
+                c[j] += 1
+
+    c = [element for element in c if element != 0]
+    p = np.divide(np.array(c), float(sum(c)))
+    pe = -sum(p * np.log(p))
+    return pe
+
+
+def multiscale_permutation_entropy(time_series, m, delay, scale):
+    """Calculate the Multiscale Permutation Entropy
+
+    Args:
+        time_series: Time series for analysis
+        m: Order of permutation entropy
+        delay: Time delay
+        scale: Scale factor
+
+    Returns:
+        Vector containing Multiscale Permutation Entropy
+
+    Reference:
+        [1] Francesco Carlo Morabito et al. Multivariate Multi-Scale Permutation Entropy for
+            Complexity Analysis of Alzheimer’s Disease EEG. www.mdpi.com/1099-4300/14/7/1186
+        [2] http://www.mathworks.com/matlabcentral/fileexchange/37288-multiscale-permutation-entropy-mpe/content/MPerm.m
+    """
+    mspe = []
+    for i in range(scale):
+        coarse_time_series = util_granulate_time_series(time_series, i + 1)
+        pe = permutation_entropy(coarse_time_series, m, delay)
+        mspe.append(pe)
+    return mspe
+
+
+# TODO add tests
+def composite_multiscale_entropy(time_series, sample_length, scale):
+    """Calculate the Composite Multiscale Entropy of the given time series.
+
+    Args:
+        time_series: Time series for analysis
+        sample_length: Number of sequential points of the time series
+        scale: Scale factor
+
+    Returns:
+        Vector containing Composite Multiscale Entropy
+
+    Reference:
+        [1] Wu, Shuen-De, et al. "Time series analysis using
+            composite multiscale entropy." Entropy 15.3 (2013): 1069-1084.
+    """
+    cmse = np.zeros((1, scale))
+    r = np.std(time_series) * 0.15
+
+    for i in range(scale):
+        for j in range(i):
+            tmp = util_granulate_time_series(time_series[j:], i + 1)
+            cmse[i] += sample_entropy(tmp, sample_length, r) / (i + 1)
+
+    return cmse

pyentrp-0.1.0/setup.cfg

@@ -0,0 +1,8 @@
+[bdist_wheel]
+# This flag says that the code is written to work on both Python 2 and Python
+# 3. If at all possible, it is good practice to do this. If you cannot, you
+# will need to generate wheels for each Python version that you support.
+universal=1
+
+[metadata]
+description-file = README.md

pyentrp-0.1.0/setup.py

@@ -0,0 +1,44 @@
+from distutils.core import setup
+
+setup(
+    name='pyentrp',
+    version='0.1.0',
+    description='Functions on top of NumPy for computing different types of entropy',
+    url='https://github.com/nikdon/pyEntropy',
+    download_url='https://github.com/nikdon/pyEntropy/archive/0.1.0.tar.gz',
+    author='Nikolay Donets',
+    author_email='nd.startup@gmail.com',
+    maintainer='Nikolay Donets',
+    maintainer_email='nd.startup@gmail.com',
+    license='Apache-2.0',
+    packages=['pyentrp'],
+
+    install_requires=[
+        'numpy>=1.7.0 ',
+    ],
+    test_suite="tests.test_entropy",
+
+    keywords=['entropy', 'python', 'sample entropy', 'multiscale entropy', 'permutation entropy',
+              'composite multiscale entropy'],
+
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+
+        'Intended Audience :: Science/Research',
+        'Operating System :: OS Independent',
+
+        'License :: OSI Approved :: Apache Software License',
+
+        'Programming Language :: Python :: 2',
+        'Programming Language :: Python :: 2.7',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.3',
+        'Programming Language :: Python :: 3.4',
+        'Programming Language :: Python :: 3.5',
+        'Programming Language :: Python :: 3.6',
+
+        'Topic :: Scientific/Engineering :: Bio-Informatics',
+        'Topic :: Scientific/Engineering :: Information Analysis',
+        'Topic :: Scientific/Engineering :: Mathematics',
+    ],
+)