complexeva 0.1.5__tar.gz → 0.1.6__tar.gz

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

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

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

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

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

@@ -9,10 +9,6 @@ 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/utils/__init__.py
 complexeva/utils/convert_image_matrix.py

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

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="complexeva",
-    version="0.1.5",
+    version="0.1.6",
     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/cbb_matrix.py

@@ -1,134 +0,0 @@
-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.5/complexeva/measures/cbb_networkx.py

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

complexeva-0.1.5/complexeva/measures/higuchi.py

@@ -1,91 +0,0 @@
-#!/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):
-    """
-    [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):
-    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):
-    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):
-    """
-    [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]