complexeva 0.1.16__tar.gz → 0.2.0__tar.gz

complexeva-0.2.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: complexeva
+Version: 0.2.0
+Home-page: 
+Author: Don Yin
+Author-email: don_yin@outlook.com
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+
+# overview
+implementations of complexity measures in 1D sequences
+
+# examples
+```python
+from complexeva import lyapunov_exponent, hfd, lempel_ziv, compression_complexity
+
+signal = numpy.random.rand(1000)  # shape: (1000,)
+complexity = hfd(signal)
+print(complexity)
+```

complexeva-0.2.0/README.md

@@ -0,0 +1,11 @@
+# overview
+implementations of complexity measures in 1D sequences
+
+# examples
+```python
+from complexeva import lyapunov_exponent, hfd, lempel_ziv, compression_complexity
+
+signal = numpy.random.rand(1000)  # shape: (1000,)
+complexity = hfd(signal)
+print(complexity)
+```

{complexeva-0.1.16/complexeva/measures/dimension_1 → complexeva-0.2.0/complexeva/sequence}/__init__.py

@@ -1,11 +1,6 @@
-from .compression import compression_complexity
-from .lyapunov_exponent import lyapunov_exponent
 from .higuchi import hfd
 from .lempel_ziv import lempel_ziv
+from .compression import compression_complexity
+from .lyapunov_exponent import lyapunov_exponent
 
-__all__ = [
-    "compression_complexity",
-    "lyapunov_exponent",
-    "hfd",
-    "lempel_ziv",
-]
+__all__ = ["compression_complexity", "lyapunov_exponent", "hfd", "lempel_ziv"]

complexeva-0.2.0/complexeva/sequence/compression.py

@@ -0,0 +1,18 @@
+#!/Users/donyin/miniconda3/envs/rotation-1/bin/python
+
+import zlib
+import numpy as np
+
+
+def compression_complexity(data: np.ndarray) -> float:
+    """
+    calculate compression complexity using zlib compression -> float: compression complexity score
+    """
+    data = data.tobytes()
+    compressed = zlib.compress(data)
+    return len(compressed) / len(data)  # Normalized complexity score
+
+
+if __name__ == "__main__":
+    signal = np.random.rand(1000)  # shape: (1000,)
+    print(compression_complexity(signal))

{complexeva-0.1.16/complexeva/measures/dimension_1 → complexeva-0.2.0/complexeva/sequence}/higuchi.py

@@ -2,40 +2,9 @@
 
 
 import numpy
-from scipy.fft import fft, ifft
-import matplotlib.pyplot as plt
-from donware import inspect_package
 from numba import njit
 
 
-def hfd_matlab_equivalent(data, k_max=16):
-    """
-    [translated from MATLAB code]
-
-    [output]
-    - produce values between 1 and 2
-    """
-    N = len(data)
-    L = numpy.zeros(k_max)
-    x = numpy.zeros(k_max)
-    y = numpy.zeros(k_max)
-
-    for k in range(1, k_max + 1):
-        Lk = numpy.zeros(k)
-        for m in range(1, k + 1):
-            norm_factor = (N - 1) / (numpy.round((N - m) / k) * k)
-            X = numpy.sum(numpy.abs(numpy.diff(data[m - 1 :: k])))
-            Lk[m - 1] = X * norm_factor / k
-
-        y[k - 1] = numpy.log(numpy.sum(Lk) / k)
-        x[k - 1] = numpy.log(1 / k)
-
-    D = numpy.polyfit(x, y, 1)
-    HFD = D[0]
-
-    return HFD
-
-
 @njit
 def compute_L_x(X, k_max=16):
     N = len(X)
@@ -56,7 +25,14 @@ def compute_L_x(X, k_max=16):
 
 
 def hfd(X, k_max=16):
+    """expect a 1d numpy array as input"""
     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]
+
+
+if __name__ == "__main__":
+    signal = numpy.random.rand(1000)  # shape: (1000,)
+    complexity = hfd(signal)
+    print(complexity)

complexeva-0.2.0/complexeva/sequence/lempel_ziv.py

@@ -0,0 +1,76 @@
+#!/Users/donyin/miniconda3/envs/rotation-1/bin/python
+
+import numpy
+
+
+def lempel_ziv(time_series, method="median", **kwargs):
+    """
+    - 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:
+        if sequence[history_pos + current_len - 1] == sequence[seq_pos + current_len - 1]:
+            current_len += 1
+        else:
+            if current_len > max_pattern_len:
+                max_pattern_len = current_len
+            history_pos += 1
+            if history_pos == seq_pos:
+                complexity += 1
+                seq_pos += max_pattern_len
+                history_pos = 0
+                current_len = 1
+                max_pattern_len = 1
+            else:
+                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)
+
+    match method:
+
+        case "mean":
+            threshold = numpy.mean(vector)
+            binary_seq = "".join(["1" if x > threshold else "0" for x in vector])
+
+        case "median":
+            threshold = numpy.median(vector)
+            binary_seq = "".join(["1" if x > threshold else "0" for x in vector])
+
+        case "diff":  # this measures whether the value is increasing or decreasing as compared to the previous value
+            diffs = numpy.diff(vector)
+            binary_seq = "".join(["1" if x > 0 else "0" for x in diffs])
+
+        case _:
+            raise ValueError("Method must be 'mean', 'median', or 'diff'.")
+
+    return binary_seq
+
+
+if __name__ == "__main__":
+    sequence = "1001111011000010"
+    print(lempel_ziv(sequence))
+    signal = numpy.random.rand(1000)
+    binary_sequence = time_series_to_binary(signal, method="median")
+    print(lempel_ziv(binary_sequence))

{complexeva-0.1.16/complexeva/measures/dimension_1 → complexeva-0.2.0/complexeva/sequence}/lyapunov_exponent.py

@@ -15,28 +15,17 @@ def lyapunov_exponent(data, tau=1, m=2, dt=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

{complexeva-0.1.16/complexeva/measures → complexeva-0.2.0/complexeva}/validate.py

@@ -5,11 +5,9 @@
 """
 
 import numpy
-from scipy.fft import fft, ifft
 import matplotlib.pyplot as plt
-from donware import inspect_package
-from complexeva.measures.dimension_1.higuchi import hfd
-from complexeva.measures.dimension_1.lempel_ziv import lempel_ziv_v1, lempel_ziv_v2, lempel_ziv, lempel_ziv_v4
+from complexeva.sequence.higuchi import hfd
+from complexeva.sequence.lempel_ziv import lempel_ziv
 
 
 class ComplexityMeasuresValidator2D:
@@ -49,7 +47,7 @@ class ComplexityMeasuresValidator2D:
         fBm = numpy.fft.ifft(gaussian * numpy.sqrt(psd)).real
         return fBm
 
-    def plot_hfd_vs_hurst(self):
+    def plot_vs_hurst(self):
         hurst_exponent = numpy.linspace(0.001, 1, self.num_hurst)
         fBm_series = [self.fbm(h) for h in hurst_exponent]
         expected_hfd = [2 - h for h in hurst_exponent]
@@ -113,7 +111,7 @@ class ComplexityMeasuresValidator2D:
 
 if __name__ == "__main__":
     validator = ComplexityMeasuresValidator2D([hfd])
-    validator.plot_hfd_vs_hurst()
+    validator.plot_vs_hurst()
 
-    validator = ComplexityMeasuresValidator2D([lempel_ziv_v1, lempel_ziv_v2, lempel_ziv, lempel_ziv_v4])
-    validator.plot_hfd_vs_hurst()
+    validator = ComplexityMeasuresValidator2D([lempel_ziv])
+    validator.plot_vs_hurst()

complexeva-0.2.0/complexeva.egg-info/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: complexeva
+Version: 0.2.0
+Home-page: 
+Author: Don Yin
+Author-email: don_yin@outlook.com
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+
+# overview
+implementations of complexity measures in 1D sequences
+
+# examples
+```python
+from complexeva import lyapunov_exponent, hfd, lempel_ziv, compression_complexity
+
+signal = numpy.random.rand(1000)  # shape: (1000,)
+complexity = hfd(signal)
+print(complexity)
+```

complexeva-0.2.0/complexeva.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+setup.py
+complexeva/__init__.py
+complexeva/validate.py
+complexeva.egg-info/PKG-INFO
+complexeva.egg-info/SOURCES.txt
+complexeva.egg-info/dependency_links.txt
+complexeva.egg-info/top_level.txt
+complexeva/sequence/__init__.py
+complexeva/sequence/compression.py
+complexeva/sequence/higuchi.py
+complexeva/sequence/lempel_ziv.py
+complexeva/sequence/lyapunov_exponent.py

{complexeva-0.1.16 → complexeva-0.2.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="complexeva",
-    version="0.1.16",
+    version="0.2.0",
     packages=find_packages(),
     install_requires=[],
     author="Don Yin",
@@ -11,5 +11,5 @@ setup(
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",
     url="",
-    pyhon_requires=">=3.11",
+    pyhon_requires=">=3.12",
 )

complexeva-0.1.16/PKG-INFO

@@ -1,16 +0,0 @@
-Metadata-Version: 2.1
-Name: complexeva
-Version: 0.1.16
-Home-page: 
-Author: Don Yin
-Author-email: don_yin@outlook.com
-Description-Content-Type: text/markdown
-
-# overview
-computing fractal dimensions (and other complexity measures) and complexity measures in networks and matrices. The package includes:
-
-# some functions (thus far)
-- Box-counting fractal dimension calculation for networks and matrices
-- Higuchi fractal dimension implementation
-- Network-to-matrix and image-to-matrix conversions
-- Dummy fractal generators for testing

complexeva-0.1.16/README.md

@@ -1,8 +0,0 @@
-# overview
-computing fractal dimensions (and other complexity measures) and complexity measures in networks and matrices. The package includes:
-
-# some functions (thus far)
-- Box-counting fractal dimension calculation for networks and matrices
-- Higuchi fractal dimension implementation
-- Network-to-matrix and image-to-matrix conversions
-- Dummy fractal generators for testing

complexeva-0.1.16/complexeva/dummies/__init__.py

@@ -1,4 +0,0 @@
-from .matrix import DummyAdjacencyMatrix
-from .networks import WebFractalNetwork, SierpinskiFractal
-
-__all__ = ["DummyAdjacencyMatrix", "WebFractalNetwork", "SierpinskiFractal"]

complexeva-0.1.16/complexeva/dummies/matrix.py

@@ -1,150 +0,0 @@
-"""
-    Fractal adjacency matrix generation and analysis with varying degrees of complexity
-"""
-
-import numpy as np
-import matplotlib.pyplot as plt
-
-
-class DummyAdjacencyMatrix:
-    def __init__(self, size, fractal_dimension):
-        """Initialize the FractalAdjacencyMatrix with a given size and fractal dimension.
-
-        Parameters:
-        size (int): The desired size of the adjacency matrix.
-        fractal_dimension (float): The target fractal dimension.
-        """
-        self.size, self.fractal_dimension = size, fractal_dimension
-
-    def generate_matrix(self, remove_upper_triangle=False, save_as=None):
-        """Generate the fractal adjacency matrix based on the specified fractal dimension.
-
-        Parameters:
-        fractal_dimension (float): The target fractal dimension.
-
-        Returns:
-        numpy.ndarray: The generated adjacency matrix.
-        """
-        max_m = min(self.size, 10)
-        m, pattern = self.calculate_m_and_pattern(self.fractal_dimension, max_m)
-        iterations = int(np.ceil(np.log(self.size) / np.log(m)))
-        actual_size = m**iterations
-        matrix = np.ones((actual_size, actual_size), dtype=bool)
-        self.apply_pattern(matrix, 0, 0, actual_size, m, pattern, iterations)
-
-        # Resize matrix if needed
-        if actual_size != self.size:
-            if actual_size > self.size:
-                matrix = matrix[: self.size, : self.size]
-            else:
-                pad_size = self.size - actual_size
-                matrix = np.pad(matrix, ((0, pad_size), (0, pad_size)), mode="constant", constant_values=False)
-
-        matrix = self.post_processing_matrix(matrix, remove_upper_triangle)
-
-        if save_as:
-            save_as = save_as if save_as.endswith(".png") else f"{save_as}.png"
-            plt.figure(figsize=(8, 8))
-            plt.imshow(matrix, cmap="binary", interpolation="nearest")
-            plt.title("Dummy Fractal Adjacency Matrix / FD ~ {:.2f}".format(self.fractal_dimension))
-            plt.axis("off")
-            plt.tight_layout()
-            plt.savefig(save_as, dpi=420, bbox_inches="tight")
-            plt.close()
-
-        return matrix
-
-    @staticmethod
-    def post_processing_matrix(matrix, remove_upper_triangle=False):
-        matrix = matrix.astype(int)
-        if remove_upper_triangle:
-            matrix = np.tril(matrix)
-        return matrix
-
-    def calculate_m_and_pattern(self, target_dimension, max_scaling_factor=10):
-        """Calculate the scaling factor 'm' and the base pattern for the fractal.
-
-        Parameters:
-        target_dimension (float): The target fractal dimension.
-        max_m (int): The maximum value of 'm' to consider (default is 10).
-
-        Returns:
-        tuple: A tuple containing 'm' and the 'pattern' numpy.ndarray.
-        """
-        best_dimension_diff = float("inf")
-        best_scaling_factor = None
-        best_pattern = None
-
-        for scaling_factor in range(2, max_scaling_factor + 1):
-            total_cells = scaling_factor * scaling_factor
-            # Iterate over possible numbers of cells to remove
-            for removed_cells in range(1, total_cells):
-                remaining_cells = total_cells - removed_cells
-                fractal_dim = np.log(remaining_cells) / np.log(scaling_factor)
-                dimension_diff = abs(fractal_dim - target_dimension)
-
-                if dimension_diff < best_dimension_diff:
-                    best_dimension_diff = dimension_diff
-                    best_scaling_factor = scaling_factor
-                    # Create the base pattern
-                    pattern = np.ones((scaling_factor, scaling_factor), dtype=bool)
-                    # Determine which cells to remove, starting from the center
-                    indices = [(i, j) for i in range(scaling_factor) for j in range(scaling_factor)]
-                    center = scaling_factor // 2
-                    indices_sorted = sorted(
-                        indices,
-                        key=lambda x: (abs(x[0] - center) + abs(x[1] - center), x[0], x[1]),
-                    )
-                    for i, j in indices_sorted[:removed_cells]:
-                        pattern[i, j] = False
-                    best_pattern = pattern.copy()
-
-                if best_dimension_diff == 0:
-                    return best_scaling_factor, best_pattern
-
-        return best_scaling_factor, best_pattern
-
-    def apply_pattern(self, matrix, x_start, y_start, size, m, pattern, iterations_left):
-        """Recursively apply the fractal pattern to the matrix.
-
-        Parameters:
-        matrix (numpy.ndarray): The matrix to modify.
-        x_start (int): The starting x-coordinate in the matrix.
-        y_start (int): The starting y-coordinate in the matrix.
-        size (int): The size of the current square in the matrix.
-        m (int): The scaling factor.
-        pattern (numpy.ndarray): The base pattern to apply.
-        iterations_left (int): The number of iterations left to apply.
-        """
-        if iterations_left == 0:
-            return
-        step = size // m
-        for i, j in np.ndindex(m, m):
-            x_slice = slice(x_start + j * step, x_start + (j + 1) * step)
-            y_slice = slice(y_start + i * step, y_start + (i + 1) * step)
-            if not pattern[i, j]:
-                matrix[y_slice, x_slice] = False
-            else:
-                self.apply_pattern(
-                    matrix,
-                    x_start + j * step,
-                    y_start + i * step,
-                    step,
-                    m,
-                    pattern,
-                    iterations_left - 1,
-                )
-
-
-if __name__ == "__main__":
-    size = 256
-    fractal_dimensions = np.linspace(1.0, 2.0, 10)
-
-    for idx, dimension in enumerate(fractal_dimensions):
-        generator = DummyAdjacencyMatrix(size, dimension)
-        plt.figure(figsize=(6, 6))
-        plt.title(f"Fractal Dimension ~ {dimension:.2f}", pad=20)
-        plt.imshow(generator.matrix, cmap="binary", interpolation="nearest")
-        plt.axis("off")
-        plt.savefig(f"fractal_{idx}.png")
-        plt.close()

complexeva-0.1.16/complexeva/dummies/networks.py

@@ -1,111 +0,0 @@
-#!/Users/donyin/miniconda3/envs/rotation-1/bin/python
-
-"""
-all the networkx class dummy implementations
-"""
-
-import numpy as np
-import networkx as nx
-
-
-class WebFractalNetwork:
-    """
-    Generates a pseudo-fractal network using an iterative method.
-
-    Usage:
-    web_fractal = WebFractalNetwork(complexity=3)
-    network = web_fractal.network
-    """
-
-    def __init__(self, complexity=3):
-        self.complexity = complexity
-        self.network = self._generate_network()
-        self.diameter = nx.diameter(self.network)
-
-    def _generate_network(self):
-        """
-        Generates the pseudo-fractal network.
-        """
-        G = nx.Graph()
-        G.add_edges_from([(0, 1), (1, 2), (2, 0)])
-        for _ in range(self.complexity):
-            G = self._fractal_step(G)
-        return G
-
-    def _fractal_step(self, G):
-        """
-        Performs one iteration of the fractal construction.
-        """
-        new_edges = []
-        max_node = max(G.nodes())
-        for u, v in G.edges():
-            new_node = max_node + 1
-            max_node += 1
-            new_edges.extend([(new_node, u), (new_node, v)])
-        G.add_edges_from(new_edges)
-        return G
-
-
-class SierpinskiFractal:
-    """
-    Generates a Sierpinski gasket fractal network.
-
-    Usage:
-    sierpinski = SierpinskiFractal(recursion_depth=3)
-    network = sierpinski.network
-    """
-
-    def __init__(self, recursion_depth=3):
-        self.recursion_depth = recursion_depth
-        self.points = {}
-        self.edges = set()
-        self.point_index = 0
-        self.network = self._generate_network()
-
-    def _generate_network(self):
-        """
-        Generates the Sierpinski gasket fractal network.
-        """
-        vertices = [(0, 0), (0.5, np.sqrt(3) / 2), (1, 0)]
-        self._sierpinski_recursive(vertices, self.recursion_depth)
-        return self._build_graph()
-
-    def _sierpinski_recursive(self, vertices, depth):
-        """
-        Recursively generates the Sierpinski gasket fractal.
-        """
-
-        def add_triangle(v1, v2, v3, current_depth):
-            if current_depth == 0:
-                for v in [v1, v2, v3]:
-                    if v not in self.points:
-                        self.points[v] = self.point_index
-                        self.point_index += 1
-                i1, i2, i3 = self.points[v1], self.points[v2], self.points[v3]
-                self.edges.update([(i1, i2), (i2, i3), (i3, i1)])
-            else:
-                m1 = ((v1[0] + v2[0]) / 2, (v1[1] + v2[1]) / 2)
-                m2 = ((v2[0] + v3[0]) / 2, (v2[1] + v3[1]) / 2)
-                m3 = ((v3[0] + v1[0]) / 2, (v3[1] + v1[1]) / 2)
-                add_triangle(v1, m1, m3, current_depth - 1)
-                add_triangle(m1, v2, m2, current_depth - 1)
-                add_triangle(m3, m2, v3, current_depth - 1)
-
-        add_triangle(vertices[0], vertices[1], vertices[2], depth)
-
-    def _build_graph(self):
-        """
-        Builds the NetworkX graph from the generated points and edges.
-        """
-        G = nx.Graph()
-        for coord, idx in self.points.items():
-            G.add_node(idx, pos=coord)
-        G.add_edges_from(self.edges)
-        return G
-
-
-if __name__ == "__main__":
-    network = SierpinskiFractal(recursion_depth=7)
-    # network = WebFractalNetwork(complexity=4)
-    # handler = FractalHandlerNetworkX(network.network)
-    # handler.compute_fractal_dimensions(box_sizes="auto", iterations=10)

complexeva-0.1.16/complexeva/measures/__init__.py

@@ -1,5 +0,0 @@
-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.16/complexeva/measures/dimension_1/compression.py

@@ -1,25 +0,0 @@
-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