complexeva 0.1.6__tar.gz → 0.1.8__tar.gz

{complexeva-0.1.6 → complexeva-0.1.8}/PKG-INFO

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

complexeva-0.1.8/complexeva/measures/dimension_1/higuchi.py

@@ -0,0 +1,91 @@
+#!/Users/donyin/miniconda3/envs/rotation-1/bin/python
+
+
+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)
+    L = numpy.zeros(k_max)
+    x = numpy.zeros(k_max)
+    for k in range(1, k_max + 1):
+        Lk = numpy.zeros(k)
+        for m in range(k):
+            Lmk = 0.0
+            n_max = (N - m) // k
+            for i in range(1, n_max):
+                Lmk += abs(X[m + i * k] - X[m + (i - 1) * k])
+            Lmk *= (N - 1) / (n_max * k)
+            Lk[m] = Lmk
+        L[k - 1] = numpy.log(Lk.mean())
+        x[k - 1] = numpy.log(1.0 / k)
+    return x, L
+
+
+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=16):
+    """
+    [from PyEEG package]
+    Higuchi Fractal Dimension of a time series X. kmax is an HFD parameter
+
+    [output]
+    - for some reasons produce values between 0 and 1
+
+    [modifications]
+    - kmax should be inclusive, Kmax + 1
+    """
+    L = []
+    x = []
+    N = len(X)
+    for k in range(1, k_max + 1):
+        Lk = []
+        for m in range(0, k):
+            Lmk = 0
+            for i in range(1, int(numpy.floor((N - m) / k))):
+                Lmk += abs(X[m + i * k] - X[m + i * k - k])
+            Lmk = Lmk * (N - 1) / numpy.floor((N - m) / float(k)) / k
+            Lk.append(Lmk)
+        L.append(numpy.log(numpy.mean(Lk)))
+        x.append([numpy.log(float(1) / k), 1])
+
+    (p, _, _, _) = numpy.linalg.lstsq(x, L, rcond=None)
+    return p[0]

complexeva-0.1.8/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.8/complexeva/measures/dimension_2/cbb_matrix.py

@@ -0,0 +1,134 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import animation
+
+
+class FractalHandlerMatrix:
+    """
+    Handles the fractal dimension calculation of a binary matrix using an improved Compact Box-Burning algorithm.
+    """
+
+    def __init__(self, matrix: np.ndarray):
+        self.matrix = matrix
+
+    def compute_fractal_dimension(self, save_plot_as=None, save_animated_as=None):
+        """
+        Calculate the fractal dimension of the matrix using the improved Compact Box-Burning algorithm.
+
+        Parameters:
+            save_plot_as (str, optional): Path to save the static plot showing fractal dimension calculation
+            save_animated_as (str, optional): Path to save the animated GIF showing box counting process
+
+        Returns:
+            float: The fractal dimension of the matrix.
+        """
+        assert np.all((self.matrix == 0) | (self.matrix == 1)), "> warning: Matrix should be binary (0s and 1s only)"
+        binary_matrix = self.matrix.astype(np.uint8)
+        min_dim = min(binary_matrix.shape)
+        max_scale = 2 ** int(np.floor(np.log2(min_dim)))
+
+        num_scales = int(np.floor(np.log2(max_scale))) * 10
+        scales = np.unique(np.floor(np.logspace(0, np.log2(max_scale), num=num_scales, base=2))).astype(int)
+        scales = scales[scales >= 1]
+
+        box_counts = []
+        padded_matrices = []
+
+        # Animation setup if needed
+        if save_animated_as:
+            fig, ax = plt.subplots(figsize=(8, 8))
+
+        for scale in scales:
+            padded_size = (
+                int(np.ceil(binary_matrix.shape[0] / scale)) * scale,
+                int(np.ceil(binary_matrix.shape[1] / scale)) * scale,
+            )
+            padded_matrix = np.zeros(padded_size, dtype=np.uint8)
+            padded_matrix[: binary_matrix.shape[0], : binary_matrix.shape[1]] = binary_matrix
+
+            if save_animated_as:
+                padded_matrices.append((padded_matrix, scale))
+
+            reshaped = padded_matrix.reshape(padded_size[0] // scale, scale, padded_size[1] // scale, scale)
+            summed = reshaped.sum(axis=(1, 3))
+            occupied_boxes = np.count_nonzero(summed)
+            box_counts.append(occupied_boxes)
+
+        # calculate fractal dimension
+        scales = np.array(scales)
+        box_counts = np.array(box_counts)
+        nonzero = box_counts > 0
+        scales = scales[nonzero]
+        box_counts = box_counts[nonzero]
+
+        log_scales = np.log(1 / scales)
+        log_box_counts = np.log(box_counts)
+
+        coeffs = np.polyfit(log_scales, log_box_counts, 1)
+        fractal_dimension = coeffs[0]
+
+        # save static plot if requested
+        if save_plot_as:
+            save_plot_as = save_plot_as if save_plot_as.endswith(".png") else save_plot_as + ".png"
+            plt.figure(figsize=(8, 6))
+            plt.plot(log_scales, log_box_counts, "o-", label="Data")
+            plt.plot(
+                log_scales,
+                np.polyval(coeffs, log_scales),
+                "r--",
+                label=f"Fit (D = {fractal_dimension:.4f})",
+            )
+            plt.xlabel("log(1/ε)")
+            plt.ylabel("log(N(ε))")
+            plt.title("Fractal Dimension via Compact Box-Burning")
+            plt.legend()
+            plt.grid(True)
+            plt.tight_layout()
+            plt.savefig(save_plot_as, dpi=420, bbox_inches="tight")
+            plt.close()
+
+        # Create and save animation if requested
+        if save_animated_as:
+
+            def init():
+                ax.imshow(binary_matrix, cmap="binary", interpolation="nearest")
+                ax.axis("off")
+                return []
+
+            def update(frame):
+                padded_matrix, scale = padded_matrices[frame]
+                ax.clear()
+                ax.imshow(padded_matrix, cmap="binary", interpolation="nearest")
+                ax.set_title(f"Scale: {scale} pixels, Boxes: {box_counts[frame]}")
+                ax.axis("off")
+
+                # Overlay red boxes on occupied regions
+                for y in range(0, padded_matrix.shape[0], scale):
+                    for x in range(0, padded_matrix.shape[1], scale):
+                        if np.any(padded_matrix[y : y + scale, x : x + scale]):
+                            rect = plt.Rectangle(
+                                (x - 0.5, y - 0.5),
+                                scale,
+                                scale,
+                                edgecolor="red",
+                                facecolor="none",
+                                lw=1,
+                            )
+                            ax.add_patch(rect)
+                return []
+
+            ani = animation.FuncAnimation(
+                fig,
+                update,
+                frames=len(scales),
+                init_func=init,
+                blit=False,
+                repeat=False,
+            )
+
+            if not save_animated_as.endswith((".png", ".gif")):
+                save_animated_as += ".gif"
+            ani.save(save_animated_as.replace(".png", ".gif"), writer="pillow", fps=2)
+            plt.close(fig)
+
+        return fractal_dimension

complexeva-0.1.8/complexeva/measures/network_space/cbb_networkx.py

@@ -0,0 +1,288 @@
+#!/Users/donyin/miniconda3/bin/python
+import random
+from PIL import Image
+import numpy as np
+import networkx as nx
+from tqdm import tqdm
+from scipy import stats
+import matplotlib.pyplot as plt
+from networkx.exception import NetworkXError
+import matplotlib.animation as animation
+
+
+"""
+reference:
+- https://github.com/PeterTKovacs/boxes/blob/main/boxes/cbb.py
+"""
+
+
+class FractalHandlerNetworkX:
+    """
+    Handles fractal analysis of NetworkX graphs using box-covering method.
+    """
+
+    def __init__(self, network: nx.Graph):
+        self.network = network
+
+    def auto_pick_box_sizes(self):
+        diameter = nx.diameter(self.network) if nx.is_connected(self.network) else 1
+        min_size = max(1, diameter // 21)
+        max_size = diameter
+        return np.logspace(np.log10(min_size), np.log10(max_size), num=12, dtype=int)
+
+    def compute_fractal_dimensions(self, box_sizes="auto", iterations=10, save_plot_as=None, save_animated_as=None):
+        box_sizes = self.auto_pick_box_sizes() if box_sizes == "auto" else box_sizes
+        network_image, box_counts = self.plot_network(), []
+
+        # If animation is requested, set up storage for animation frames
+        if save_animated_as:
+            animation_data = []
+            pos = nx.spring_layout(self.network, dim=3)  # 3D layout
+
+            # Create a color mapping based on z-coordinates
+            z_coords = np.array([pos[node][2] for node in self.network.nodes()])
+            z_min, z_max = z_coords.min(), z_coords.max()
+            node_colors = {}
+            for node in self.network.nodes():
+                z = pos[node][2]
+                # Normalize z to [0,1] range for color mapping
+                color_val = (z - z_min) / (z_max - z_min) if z_max != z_min else 0
+                node_colors[node] = plt.cm.rainbow(color_val)
+
+        for max_distance in tqdm(box_sizes, desc="Box sizes"):
+            num_boxes_list = []
+            boxes_for_animation = []
+            for _ in tqdm(range(iterations), desc=f"Networks for size {max_distance}", leave=False):
+                boxes = self.random_box_covering(max_distance)
+                num_boxes_list.append(len(boxes))
+                if save_animated_as:
+                    boxes_for_animation.append(boxes)
+            avg_num_boxes = sum(num_boxes_list) / iterations
+            box_counts.append(avg_num_boxes)
+
+            if save_animated_as:
+                # For animation, store the boxes from the first iteration
+                animation_data.append(
+                    {
+                        "boxes": boxes_for_animation[0],
+                        "max_distance": max_distance,
+                        "num_boxes": num_boxes_list[0],
+                    }
+                )
+
+        log_box_sizes, log_counts = np.log(box_sizes), np.log(box_counts)
+
+        try:
+            slope, intercept, r_value, p_value, std_err = stats.linregress(log_box_sizes, log_counts)
+        except ValueError:
+            slope, intercept, r_value = 0, 0, 0
+        fractal_dimension = -slope
+
+        if save_plot_as:
+            save_plot_as = save_plot_as if save_plot_as.endswith(".png") else f"{save_plot_as}.png"
+            fig, ax = plt.subplots(figsize=(10, 6))
+            ax.scatter(log_box_sizes, log_counts, color="blue", label="Data")
+            ax.plot(
+                log_box_sizes,
+                slope * log_box_sizes + intercept,
+                color="red",
+                label=f"Fit (D={fractal_dimension:.2f})",
+                linestyle="-",
+            )
+            ax.set_xlabel("log(Box Size)", fontsize=21)
+            ax.set_ylabel("log(Number of Boxes)", fontsize=21)
+            ax.set_title("Fractal Dimension Regression", fontsize=21)
+            ax.legend(fontsize=21)
+            ax.grid(True)
+            ax.tick_params(axis="both", which="major", labelsize=21)
+            fig.canvas.draw()
+            plot_image = np.array(fig.canvas.renderer.buffer_rgba())
+            network_height, network_width = network_image.shape[:2]
+            plot_height, plot_width = plot_image.shape[:2]
+            aspect_ratio = network_width / network_height
+            new_network_height = plot_height
+            new_network_width = int(new_network_height * aspect_ratio)
+            resized_network_image = np.array(Image.fromarray(network_image).resize((new_network_width, new_network_height)))
+            resized_network_image = resized_network_image[:, :, :3]
+            plot_image = plot_image[:, :, :3]
+            combined_image = np.hstack((resized_network_image, plot_image))
+            plt.figure(
+                figsize=(
+                    combined_image.shape[1] / 100,
+                    combined_image.shape[0] / 100,
+                )
+            )
+            plt.imshow(combined_image)
+            plt.axis("off")
+            plt.tight_layout()
+            plt.savefig(save_plot_as, dpi=420, bbox_inches="tight")
+            plt.close()
+
+        # Create and save animation if requested
+        if save_animated_as:
+            fig = plt.figure(figsize=(15, 8))  # Wider figure to accommodate legend
+            gs = plt.GridSpec(1, 2, width_ratios=[2, 1])  # 2:1 ratio for plot and legend
+            ax = fig.add_subplot(gs[0], projection="3d")
+            legend_ax = fig.add_subplot(gs[1])  # Create legend subplot once
+            legend_ax.axis("off")
+            legend_ax.spines["top"].set_visible(False)
+
+            def update(frame):
+                ax.clear()
+                legend_ax.clear()  # Clear previous legend
+
+                data = animation_data[frame]
+                boxes = data["boxes"]
+                max_distance = data["max_distance"]
+                num_boxes = data["num_boxes"]
+
+                # Draw network and boxes in 3D subplot
+                edge_list = list(self.network.edges())
+
+                # Assign box colors based on average z-coordinate of nodes in each box
+                box_colors = []
+                for box in boxes:
+                    box_nodes = list(box)
+                    box_colors.append(np.mean([node_colors[node] for node in box_nodes], axis=0))
+
+                # Create a mapping of nodes to their box colors
+                node_to_color = {}
+                for box, color in zip(boxes, box_colors):
+                    for node in box:
+                        node_to_color[node] = color
+
+                # Draw edges with box colors
+                for edge in edge_list:
+                    start = pos[edge[0]]
+                    end = pos[edge[1]]
+                    # Use color of both nodes for edge
+                    start_color = node_to_color.get(edge[0], "gray")
+                    end_color = node_to_color.get(edge[1], "gray")
+                    edge_color = start_color if np.array_equal(start_color, end_color) else "gray"
+
+                    mid_point = (start + end) / 2
+                    offset = np.random.normal(0, 0.05, 3)
+                    control_point = mid_point + offset
+                    t = np.linspace(0, 1, 20)
+                    curve = np.array([(1 - t) ** 2 * start + 2 * (1 - t) * t * control_point + t**2 * end for t in t])
+                    ax.plot3D(curve[:, 0], curve[:, 1], curve[:, 2], c=edge_color, alpha=0.7, linewidth=1.5)
+
+                # Draw boxes and create legend elements
+                legend_elements = []
+                for box_idx, (box, color) in enumerate(zip(boxes, box_colors)):
+                    box_nodes = list(box)
+                    box_pos = np.array([pos[node] for node in box_nodes])
+                    scatter = ax.scatter(
+                        box_pos[:, 0], box_pos[:, 1], box_pos[:, 2], c=[color], s=150, alpha=0.8, edgecolor="white"
+                    )
+                    legend_elements.append((scatter, f"Box {box_idx+1}"))
+
+                # Set 3D plot properties
+                ax.set_title(f"Step {frame+1}/{len(animation_data)}\nBox Size = {max_distance}\nBoxes Required: {num_boxes}")
+                ax.set_xlabel("X")
+                ax.set_ylabel("Y")
+                ax.set_zlabel("Z")
+
+                # Calculate optimal number of columns based on number of boxes
+                n_boxes = len(boxes)
+                n_cols = min(4, n_boxes)  # Max 4 columns for more spacing
+                n_rows = (n_boxes + n_cols - 1) // n_cols  # Ceiling division
+
+                # Create legend with more spacing
+                legend = legend_ax.legend(
+                    *zip(*legend_elements),
+                    loc="center",
+                    ncol=n_cols,
+                    bbox_to_anchor=(0.5, 0.5),
+                    borderaxespad=1,
+                    labelspacing=1.5,  # Increase vertical spacing between legend entries
+                    handletextpad=1.2,  # Increase spacing between marker and text
+                    title="Box Groups",
+                    frameon=True,  # Add frame around legend
+                    fancybox=True,  # Round corners
+                    shadow=True,  # Add shadow
+                )
+                legend.get_title().set_fontsize(14)
+                for text in legend.get_texts():
+                    text.set_fontsize(12)
+
+            ax.set_box_aspect([1, 1, 1])
+            ax.view_init(elev=20, azim=45)
+            ax.dist = 8
+
+            ani = animation.FuncAnimation(fig, update, frames=len(animation_data), interval=2000, repeat=True)
+
+            save_animated_as = save_animated_as if save_animated_as.endswith((".png", ".gif")) else save_animated_as + ".gif"
+            ani.save(save_animated_as.replace(".png", ".gif"), writer="pillow", fps=0.5)
+            plt.close(fig)
+
+        return fractal_dimension, r_value**2, log_box_sizes, log_counts
+
+    # ---- functional helpers ----
+    def random_box_covering(self, max_distance: int):
+        """
+        [NOTE] This implementation handles disconnected graphs by processing each connected component separately.
+
+        This function implements the random box covering algorithm to estimate
+        the boxes needed to cover a network at a given maximum distance.
+
+        Args:
+            max_distance (int): The maximum distance allowed within each box, in number of hops.
+
+        Returns:
+            List[Set]: A list of sets, each containing the nodes in a box.
+        """
+        boxes = []
+        for component in nx.connected_components(self.network):
+            subgraph = self.network.subgraph(component)
+            uncovered_nodes = set(subgraph.nodes())
+            while uncovered_nodes:
+                p = random.choice(list(uncovered_nodes))
+                distances = nx.single_source_shortest_path_length(subgraph, p)
+                box_nodes = set(node for node, dist in distances.items() if dist <= max_distance).intersection(uncovered_nodes)
+                boxes.append(box_nodes)
+                uncovered_nodes -= box_nodes
+        return boxes
+
+    def plot_network(self):
+        pos = nx.get_node_attributes(self.network, "pos")
+        fig = plt.figure(figsize=(10, 8))
+        ax = fig.add_subplot(111, projection="3d")
+
+        if pos:
+            # Use provided positions if they exist
+            pos_3d = {node: (x, y, 0) for node, (x, y) in pos.items()}  # Convert 2D to 3D
+        else:
+            # Generate 3D spring layout
+            pos_3d = nx.spring_layout(self.network, dim=3)
+
+        # Draw edges with curves
+        for edge in self.network.edges():
+            start = np.array(pos_3d[edge[0]])
+            end = np.array(pos_3d[edge[1]])
+            ax.plot([start[0], end[0]], [start[1], end[1]], [start[2], end[2]], "gray", alpha=0.5)
+
+        # Draw nodes
+        node_pos = np.array([pos_3d[node] for node in self.network.nodes()])
+        ax.scatter(node_pos[:, 0], node_pos[:, 1], node_pos[:, 2], c="lightblue", s=30)
+
+        ax.set_title("3D Network Visualization")
+        ax.set_xlabel("X")
+        ax.set_ylabel("Y")
+        ax.set_zlabel("Z")
+
+        plt.tight_layout()
+        fig.canvas.draw()
+        image = np.array(fig.canvas.renderer.buffer_rgba())
+        plt.close(fig)
+        return image
+
+
+if __name__ == "__main__":
+    from src.dummies.networks import WebFractalNetwork, SierpinskiFractal
+
+    network = SierpinskiFractal(recursion_depth=6)
+    network = WebFractalNetwork(complexity=4)
+
+    handler = FractalHandlerNetworkX(network.network)
+    handler.compute_fractal_dimensions(box_sizes=np.linspace(1, 10, 20), iterations=10)

complexeva-0.1.8/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.6 → complexeva-0.1.8}/complexeva.egg-info/PKG-INFO

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

{complexeva-0.1.6 → complexeva-0.1.8}/complexeva.egg-info/SOURCES.txt

@@ -10,6 +10,15 @@ complexeva/dummies/matrix.py
 complexeva/dummies/networks.py
 complexeva/measures/__init__.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/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.6 → complexeva-0.1.8}/setup.py

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