complexeva 0.1.5__tar.gz → 0.1.7__tar.gz

{complexeva-0.1.5 → complexeva-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: complexeva
-Version: 0.1.5
+Version: 0.1.7
 Home-page: 
 Author: Don Yin
 Author-email: don_yin@outlook.com

complexeva-0.1.7/complexeva/measures/__init__.py

@@ -0,0 +1,6 @@
+from .dimension_1.lempel_ziv import lempel_ziv
+from .dimension_1.higuchi import hfd_matlab_equivalent, hfd_pyeeg
+from .dimension_2.cbb_matrix import FractalHandlerMatrix
+from .network_space.cbb_networkx import FractalHandlerNetworkX
+
+__all__ = ["lempel_ziv", "hfd_matlab_equivalent", "hfd_pyeeg", "FractalHandlerMatrix", "FractalHandlerNetworkX"]

{complexeva-0.1.5/complexeva/measures → complexeva-0.1.7/complexeva/measures/dimension_1}/higuchi.py

@@ -8,7 +8,7 @@ from donware import inspect_package
 from numba import njit
 
 
-def hfd_matlab_equivalent(data, k_max):
+def hfd_matlab_equivalent(data, k_max=16):
     """
     [translated from MATLAB code]
 
@@ -37,7 +37,7 @@ def hfd_matlab_equivalent(data, k_max):
 
 
 @njit
-def compute_L_x(X, k_max):
+def compute_L_x(X, k_max=16):
     N = len(X)
     L = numpy.zeros(k_max)
     x = numpy.zeros(k_max)
@@ -55,14 +55,14 @@ def compute_L_x(X, k_max):
     return x, L
 
 
-def hfd_pyeeg(X, k_max):
+def hfd_pyeeg(X, k_max=16):
     x, L = compute_L_x(X, k_max)
     A = numpy.column_stack((x, numpy.ones_like(x)))
     beta, _, _, _ = numpy.linalg.lstsq(A, L, rcond=None)
     return beta[0]
 
 
-def _hfd_pyeeg(X, k_max):
+def _hfd_pyeeg(X, k_max=16):
     """
     [from PyEEG package]
     Higuchi Fractal Dimension of a time series X. kmax is an HFD parameter

complexeva-0.1.7/complexeva/measures/dimension_1/lempel_ziv.py

@@ -0,0 +1,201 @@
+#!/Users/donyin/miniconda3/envs/rotation-1/bin/python
+
+import numpy
+
+
+def lempel_ziv(time_series, method="median"):
+    """
+    - compared to other implementations, this implementation is makes the most sense
+
+    Lempel-Ziv complexity as described in Kaspar and Schuster, Phys. Rev. A.
+    Counts the number of distinct patterns that need to be copied to reproduce the sequence.
+    Returns: int: The number of distinct patterns (complexity measure)
+    """
+    sequence = time_series_to_binary(time_series, method=method)
+
+    history_pos = 0  # Position in history we're comparing against
+    current_len = 1  # Length of current pattern we're checking
+    max_pattern_len = 1  # Length of longest matching pattern found
+    seq_pos = 1  # Current position in sequence
+    complexity = 1  # Start with 1 as first character is always a new pattern
+    seq_len = len(sequence)
+
+    while seq_pos + current_len <= seq_len:
+        # Check if current pattern matches what's in history
+        if sequence[history_pos + current_len - 1] == sequence[seq_pos + current_len - 1]:
+            current_len += 1
+        else:
+            # Update longest matching pattern length if needed
+            if current_len > max_pattern_len:
+                max_pattern_len = current_len
+
+            history_pos += 1
+
+            # If we've checked all history, we found a new pattern
+            if history_pos == seq_pos:
+                complexity += 1
+                seq_pos += max_pattern_len
+
+                # Reset for next pattern search
+                history_pos = 0
+                current_len = 1
+                max_pattern_len = 1
+            else:
+                # Try next position in history
+                current_len = 1
+
+    return complexity
+
+
+def time_series_to_binary(vector, method="median"):
+    """
+    - convert a time series to a binary sequence based on a threshold.
+    - returns: str: A binary sequence as a string of '0's and '1's.
+    - https://doi.org/10.1101/2021.09.23.461002 this paper used median, making median the default method.
+    - diff also makes somewhat sense
+    """
+
+    vector = numpy.array(vector)
+
+    if method == "mean":
+        threshold = numpy.mean(vector)
+        binary_seq = "".join(["1" if x > threshold else "0" for x in vector])
+    elif method == "median":
+        threshold = numpy.median(vector)
+        binary_seq = "".join(["1" if x > threshold else "0" for x in vector])
+    elif method == "diff":
+        diffs = numpy.diff(
+            vector
+        )  # this measures whether the value is increasing or decreasing as compared to the previous value
+        binary_seq = "".join(["1" if x > 0 else "0" for x in diffs])
+    else:
+        raise ValueError("Method must be 'mean', 'median', or 'diff'.")
+
+    return binary_seq
+
+
+def lempel_ziv_v1(time_series: numpy.ndarray) -> int:
+    r"""Manual implementation of the Lempel-Ziv complexity.
+
+    It is defined as the number of different substrings encountered as the stream is viewed from begining to the end.
+    As an example:
+
+    >>> s = '1001111011000010'
+    >>> lempel_ziv_complexity(s)  # 1 / 0 / 01 / 11 / 10 / 110 / 00 / 010
+    8
+
+    Marking in the different substrings the sequence complexity :math:`\mathrm{Lempel-Ziv}(s) = 8`: :math:`s = 1 / 0 / 01 / 11 / 10 / 110 / 00 / 010`.
+
+    - See the page https://en.wikipedia.org/wiki/Lempel-Ziv_complexity for more details.
+
+
+    Other examples:
+
+    >>> lempel_ziv_complexity('1010101010101010')  # 1, 0, 10, 101, 01, 010, 1010
+    7
+    >>> lempel_ziv_complexity('1001111011000010000010')  # 1, 0, 01, 11, 10, 110, 00, 010, 000
+    9
+    >>> lempel_ziv_complexity('100111101100001000001010')  # 1, 0, 01, 11, 10, 110, 00, 010, 000, 0101
+    10
+
+    - Note: it is faster to give the sequence as a string of characters, like `'10001001'`, instead of a list or a numpy array.
+    - Note: see this notebook for more details, comparison, benchmarks and experiments: https://Nbviewer.Jupyter.org/github/Naereen/Lempel-Ziv_Complexity/Short_study_of_the_Lempel-Ziv_complexity.ipynb
+    - Note: there is also a Cython-powered version, for speedup, see :download:`lempel_ziv_complexity_cython.pyx`.
+    """
+
+    sequence = time_series_to_binary(time_series, method="median")
+
+    sub_strings = set()
+
+    ind = 0
+    inc = 1
+    while True:
+        if ind + inc > len(sequence):
+            break
+        sub_str = sequence[ind : ind + inc]
+        if sub_str in sub_strings:
+            inc += 1
+        else:
+            sub_strings.add(sub_str)
+            ind += inc
+            inc = 1
+    return len(sub_strings)
+
+
+def lempel_ziv_v2(time_series):
+    """
+    Compute the Lempel-Ziv complexity of a binary sequence.
+
+    Parameters:
+        sequence (str): The binary sequence as a string of '0' and '1'.
+
+    Returns:
+        int: The Lempel-Ziv complexity.
+    """
+    sequence = time_series_to_binary(time_series, method="median")
+
+    sub_strings = set()
+    n = len(sequence)
+    ind = 0
+    count = 0
+
+    while ind < n:
+        inc = 1
+        # Find the shortest substring not already in sub_strings
+        while sequence[ind : ind + inc] in sub_strings and ind + inc <= n:
+            inc += 1
+
+        # Add the new substring to the set
+        sub_strings.add(sequence[ind : ind + inc])
+        count += 1
+        ind += inc
+
+    return count
+
+
+def lempel_ziv_v4(time_series):
+    """
+    Computes the Lempel-Ziv complexity of the input sequence s.
+
+    Parameters:
+    s (str): The input sequence (e.g., a binary string).
+
+    Returns:
+    int: The Lempel-Ziv complexity of the sequence.
+    """
+
+    sequence = time_series_to_binary(time_series, method="median")
+    n = len(sequence)
+    i = 0
+    c = 1  # Complexity starts at 1 since the first character is always new
+    k = 1
+    l = 1
+
+    while l + k <= n:
+        # Check if the substring s[l:l+k] has occurred in s[0:l]
+        if sequence[l : l + k] in sequence[0:l]:
+            k += 1
+            if l + k - 1 == n:
+                c += 1
+                break
+        else:
+            c += 1
+            l = l + k
+            k = 1
+
+    return c
+
+
+if __name__ == "__main__":
+    sequence = "1001111011000010"
+    print(lempel_ziv_v1(sequence))
+    print(lempel_ziv_v2(sequence))
+    print(lempel_ziv(sequence))
+    print(lempel_ziv_v4(sequence))
+
+    signal = numpy.random.rand(1000)
+    binary_sequence = time_series_to_binary(signal, method="median")
+    print(lempel_ziv_v1(binary_sequence))
+    print(lempel_ziv_v2(binary_sequence))
+    print(lempel_ziv(binary_sequence))
+    print(lempel_ziv_v4(binary_sequence))

{complexeva-0.1.5 → complexeva-0.1.7}/complexeva/measures/validate.py

@@ -1,16 +1,20 @@
 #!/Users/donyin/miniconda3/envs/rotation-1/bin/python
 
+"""
+- validating measures of complexity is actually working using synthetic data on various Hurst exponents
+"""
 
 import numpy
 from scipy.fft import fft, ifft
 import matplotlib.pyplot as plt
 from donware import inspect_package
-from complexeva.measures.higuchi import hfd_pyeeg, hfd_matlab_equivalent
+from complexeva.measures.dimension_1.higuchi import hfd_pyeeg, hfd_matlab_equivalent
+from complexeva.measures.dimension_1.lempel_ziv import lempel_ziv_v1, lempel_ziv_v2, lempel_ziv, lempel_ziv_v4
 
 
-class HiguchiMethodValidate:
-    def __init__(self, funcs, k_max: int, timeseries_len=1000, num_hurst=200):
-        self.funcs, self.k_max, self.num_hurst, self.timeseries_len = funcs, k_max, num_hurst, timeseries_len
+class ComplexityMeasuresValidator2D:
+    def __init__(self, funcs, timeseries_len=1000, num_hurst=200):
+        self.funcs, self.num_hurst, self.timeseries_len = funcs, num_hurst, timeseries_len
 
     def fbm(self, hurst):
         """
@@ -52,7 +56,7 @@ class HiguchiMethodValidate:
         hfd_results = []
 
         for func in self.funcs:
-            hfd_results.append([func(series, self.k_max) for series in fBm_series])
+            hfd_results.append([func(series) for series in fBm_series])
 
         # ---- plotting ----
         fig, axs = plt.subplots(3, 1, figsize=(9, 10))
@@ -91,6 +95,8 @@ class HiguchiMethodValidate:
 
 
 if __name__ == "__main__":
-    k_max = 30
-    validator = HiguchiMethodValidate([hfd_pyeeg, hfd_matlab_equivalent], k_max)
+    validator = ComplexityMeasuresValidator2D([hfd_pyeeg, hfd_matlab_equivalent])
+    validator.plot_hfd_vs_hurst()
+
+    validator = ComplexityMeasuresValidator2D([lempel_ziv_v1, lempel_ziv_v2, lempel_ziv, lempel_ziv_v4])
     validator.plot_hfd_vs_hurst()

{complexeva-0.1.5 → complexeva-0.1.7}/complexeva.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: complexeva
-Version: 0.1.5
+Version: 0.1.7
 Home-page: 
 Author: Don Yin
 Author-email: don_yin@outlook.com

{complexeva-0.1.5 → complexeva-0.1.7}/complexeva.egg-info/SOURCES.txt

@@ -9,11 +9,14 @@ complexeva/dummies/__init__.py
 complexeva/dummies/matrix.py
 complexeva/dummies/networks.py
 complexeva/measures/__init__.py
-complexeva/measures/cbb_matrix.py
-complexeva/measures/cbb_networkx.py
-complexeva/measures/co_activation.py
-complexeva/measures/higuchi.py
 complexeva/measures/validate.py
+complexeva/measures/dimension_1/__init__.py
+complexeva/measures/dimension_1/higuchi.py
+complexeva/measures/dimension_1/lempel_ziv.py
+complexeva/measures/dimension_2/__init__.py
+complexeva/measures/dimension_2/cbb_matrix.py
+complexeva/measures/network_space/__init__.py
+complexeva/measures/network_space/cbb_networkx.py
 complexeva/utils/__init__.py
 complexeva/utils/convert_image_matrix.py
 complexeva/utils/convert_matrix_network.py

{complexeva-0.1.5 → complexeva-0.1.7}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="complexeva",
-    version="0.1.5",
+    version="0.1.7",
     packages=find_packages(),
     install_requires=[],
     author="Don Yin",

complexeva-0.1.5/complexeva/measures/__init__.py

@@ -1,5 +0,0 @@
-from .higuchi import hfd_matlab_equivalent, hfd_pyeeg
-from .cbb_matrix import FractalHandlerMatrix
-from .cbb_networkx import FractalHandlerNetworkX
-
-__all__ = ["hfd_matlab_equivalent", "hfd_pyeeg", "FractalHandlerMatrix", "FractalHandlerNetworkX"]

complexeva-0.1.5/complexeva/measures/co_activation.py

@@ -1,100 +0,0 @@
-#!/Users/donyin/miniconda3/envs/rotation-1/bin/python
-
-"""
-- now we have two 1d series as signals make dummy data using numpy
-- use either a sliding window or regression method to produce a new signal that represents the co-activation between the two signals
-- in the sliding_window method, the window_size parameter is used to determine the size of the window used to calculate the co-activation
-- it moves one step at a time and calculates the correlation between the two signals in the window
-- in the regression method, the two signals are used as independent and dependent variables in a linear regression model
-- the resulting signal is the predicted dependent variable
-- if we use the sliding_window method, the window_size parameter must be an integer greater than 0
-- if we use the regression method, we must plot the two signal and the resulting signal
-"""
-
-import numpy as np
-from sklearn.linear_model import LinearRegression
-import matplotlib.pyplot as plt
-
-
-def get_co_activation(
-    signal_1: np.ndarray, signal_2: np.ndarray, method: str, window_size: int = None, save_plot_as=None
-) -> np.ndarray:
-    """
-    Get a measure of co-activation between two 1D signals.
-
-    Args:
-        signal_1: First 1D time series signal
-        signal_2: Second 1D time series signal
-        method: Either 'sliding_window' or 'regression'
-        window_size: Size of the window for 'sliding_window' method (must be an integer greater than 0)
-
-    Returns:
-        np.ndarray: A new signal representing the co-activation between the two signals
-    """
-    match method:
-        case "sliding_window":
-            if window_size is None or window_size <= 0:
-                raise ValueError("window_size must be an integer greater than 0 for sliding_window method")
-            correlations = []
-            num_windows = len(signal_1) - window_size + 1
-            for i in range(num_windows):
-                window_signal_1 = signal_1[i : i + window_size]
-                window_signal_2 = signal_2[i : i + window_size]
-                corr = np.corrcoef(window_signal_1, window_signal_2)[0, 1]
-                correlations.append(corr)
-
-            # Plot signals and correlations
-            correlations = np.array(correlations)
-            if save_plot_as:
-                plt.figure(figsize=(10, 5))
-                plt.plot(signal_1, label="Signal 1", alpha=0.7)
-                plt.plot(signal_2, label="Signal 2", alpha=0.7)
-                plt.plot(
-                    np.arange(window_size // 2, len(correlations) + window_size // 2),
-                    correlations,
-                    label="Sliding Window Correlation",
-                    linestyle="--",
-                )
-                plt.legend()
-                plt.title(f"Sliding Window Method Co-Activation (window size={window_size})")
-                plt.savefig(save_plot_as, dpi=320)
-                plt.close()
-
-            return correlations
-
-        case "regression":
-            # Reshape signals for regression
-            X = signal_1.reshape(-1, 1)
-            y = signal_2
-
-            # Fit linear regression
-            model = LinearRegression()
-            model.fit(X, y)
-
-            # Predict y
-            y_pred = model.predict(X)
-
-            # Plot signals
-            if save_plot_as:
-                plt.figure(figsize=(10, 5))
-                plt.plot(signal_1, label="Signal 1 (IV)")
-                plt.plot(signal_2, label="Signal 2 (DV)")
-                plt.plot(y_pred, label="Predicted DV", linestyle="--")
-                plt.legend()
-                plt.title("Regression Method Co-Activation")
-                plt.savefig(save_plot_as, dpi=320)
-                plt.close()
-
-            return y_pred
-
-        case _:
-            raise ValueError("method must be 'sliding_window' or 'regression'")
-
-
-if __name__ == "__main__":
-    t = np.linspace(0, 10, 1000)
-    signal1 = np.sin(2 * np.pi * 0.5 * t) + 0.2 * np.random.randn(1000)
-    signal2 = 0.8 * np.sin(2 * np.pi * 0.5 * t + np.pi / 4) + 0.2 * np.random.randn(1000)
-
-    get_co_activation(signal1, signal2, method="sliding_window", window_size=32, save_plot_as="coactivation_sliding_window.png")
-    get_co_activation(signal1, signal2, method="regression", save_plot_as="coactivation_regression.png")