complexeva 0.1.7__tar.gz → 0.1.9__tar.gz

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

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

complexeva-0.1.9/complexeva/measures/__init__.py

@@ -0,0 +1,5 @@
+from .dimension_1 import *
+from .dimension_2.cbb_matrix import FractalHandlerMatrix
+from .network_space.cbb_networkx import FractalHandlerNetworkX
+
+__all__ = ["FractalHandlerMatrix", "FractalHandlerNetworkX", *dimension_1.__all__]

complexeva-0.1.9/complexeva/measures/dimension_1/__init__.py

@@ -0,0 +1,14 @@
+from .compression_complexity import compression_complexity
+from .lyapunov_exponent import lyapunov_exponent
+from .kolmogorov_complexity import kolmogorov_complexity
+from .higuchi import hfd_matlab_equivalent, hfd_pyeeg
+from .lempel_ziv import lempel_ziv
+
+__all__ = [
+    "compression_complexity",
+    "lyapunov_exponent",
+    "kolmogorov_complexity",
+    "hfd_matlab_equivalent",
+    "hfd_pyeeg",
+    "lempel_ziv",
+]

complexeva-0.1.9/complexeva/measures/dimension_1/compression_complexity.py

@@ -0,0 +1,25 @@
+import zlib
+import numpy as np
+
+
+def compression_complexity(data):
+    """
+    Calculate compression complexity using zlib compression.
+
+    Args:
+        data: numpy array or list of numerical values
+
+    Returns:
+        float: compression complexity score
+    """
+    # Convert numerical data to bytes
+    if isinstance(data, np.ndarray):
+        data = data.tobytes()
+    elif isinstance(data, list):
+        data = np.array(data).tobytes()
+    else:
+        raise ValueError("Input must be a numpy array or list")
+
+    # Calculate compression ratio
+    compressed = zlib.compress(data)
+    return len(compressed) / len(data)  # Normalized complexity score

complexeva-0.1.9/complexeva/measures/dimension_1/kolmogorov_complexity.py

@@ -0,0 +1,24 @@
+import zlib
+import numpy as np
+
+
+def kolmogorov_complexity(data):
+    """
+    Calculate an approximation of Kolmogorov complexity using zlib compression.
+
+    Args:
+        data: numpy array or list of numerical values
+
+    Returns:
+        int: approximated Kolmogorov complexity (compressed length)
+    """
+    # Convert numerical data to bytes
+    if isinstance(data, np.ndarray):
+        data = data.tobytes()
+    elif isinstance(data, list):
+        data = np.array(data).tobytes()
+    else:
+        raise ValueError("Input must be a numpy array or list")
+
+    # Calculate compressed length as approximation of Kolmogorov complexity
+    return len(zlib.compress(data))

complexeva-0.1.9/complexeva/measures/dimension_1/lyapunov_exponent.py

@@ -0,0 +1,44 @@
+import numpy as np
+from scipy.spatial.distance import pdist, squareform
+
+
+def lyapunov_exponent(data, tau=1, m=2, dt=1):
+    """
+    Calculate the largest Lyapunov exponent for a time series.
+
+    Args:
+        data: numpy array or list of numerical values
+        tau: time delay (default=1)
+        m: embedding dimension (default=2)
+        dt: time step (default=1)
+
+    Returns:
+        float: largest Lyapunov exponent
+    """
+    # Convert to numpy array if needed
+    x = np.array(data)
+    N = len(x)
+
+    # Create time-delay embedding
+    Y = np.zeros((N - (m - 1) * tau, m))
+    for i in range(m):
+        Y[:, i] = x[i * tau : N - (m - 1) * tau + i * tau]
+
+    # Calculate pairwise distances
+    D = squareform(pdist(Y))
+    np.fill_diagonal(D, np.inf)  # Exclude self-matches
+
+    # Find nearest neighbors
+    nearest = np.argmin(D, axis=1)
+
+    # Calculate divergence
+    div = np.zeros(N - (m - 1) * tau - 1)
+    for i in range(len(div)):
+        div[i] = np.abs(x[i + 1] - x[nearest[i] + 1])
+
+    # Calculate Lyapunov exponent
+    positive_div = div[div > 0]  # Avoid log(0)
+    if len(positive_div) == 0:
+        return 0.0
+
+    return np.mean(np.log(positive_div)) / dt

complexeva-0.1.9/complexeva/signal/co_activation.py

@@ -0,0 +1,100 @@
+#!/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")

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

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

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

@@ -11,12 +11,17 @@ complexeva/dummies/networks.py
 complexeva/measures/__init__.py
 complexeva/measures/validate.py
 complexeva/measures/dimension_1/__init__.py
+complexeva/measures/dimension_1/compression_complexity.py
 complexeva/measures/dimension_1/higuchi.py
+complexeva/measures/dimension_1/kolmogorov_complexity.py
 complexeva/measures/dimension_1/lempel_ziv.py
+complexeva/measures/dimension_1/lyapunov_exponent.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/signal/__init__.py
+complexeva/signal/co_activation.py
 complexeva/utils/__init__.py
 complexeva/utils/convert_image_matrix.py
 complexeva/utils/convert_matrix_network.py

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

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

complexeva-0.1.7/complexeva/measures/__init__.py

@@ -1,6 +0,0 @@
-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"]