exonware-xwnode 0.0.1.22__py3-none-any.whl → 0.0.1.23__py3-none-any.whl

exonware/xwnode/edges/strategies/adj_matrix.py

@@ -6,23 +6,61 @@ with O(1) edge operations and efficient matrix-based algorithms.
 """
 
 from typing import Any, Iterator, Dict, List, Set, Optional, Tuple, Union
-from .base import AGraphEdgeStrategy
+from ._base_edge import AEdgeStrategy
 from ...defs import EdgeMode, EdgeTrait
 
 
-class AdjMatrixStrategy(AGraphEdgeStrategy):
+class AdjMatrixStrategy(AEdgeStrategy):
     """
     Adjacency Matrix edge strategy for dense graph representation.
     
-    Provides O(1) edge operations and efficient matrix-based graph algorithms,
-    ideal for dense graphs where most vertices are connected.
+    WHY this strategy:
+    - O(1) edge lookup - fastest possible for connectivity checks
+    - Matrix multiplication enables powerful graph algorithms (transitive closure, shortest paths)
+    - Cache-friendly for dense graphs (sequential memory access)
+    - Simplest implementation for complete/near-complete graphs
+    
+    WHY this implementation:
+    - 2D list-of-lists for dynamic resizing
+    - Auto-expanding capacity for growing graphs
+    - Direct indexing [i][j] provides O(1) access
+    - Stores full edge data (not just boolean) for weighted graphs
+    
+    Time Complexity:
+    - Add Edge: O(1) - direct array assignment
+    - Has Edge: O(1) - direct array lookup
+    - Get Neighbors: O(V) - scan entire row
+    - Delete Edge: O(1) - direct array assignment
+    
+    Space Complexity: O(V²) - stores all possible edges
+    
+    Trade-offs:
+    - Advantage: Fastest edge lookups, simplest for dense graphs
+    - Limitation: Wastes memory on sparse graphs (stores empty cells)
+    - Compared to ADJ_LIST: Use when graph density > 50%
+    
+    Best for:
+    - Small complete graphs (cliques, fully connected layers)
+    - Dense graphs (social groups, recommendation systems)
+    - Matrix-based algorithms (Floyd-Warshall, matrix powers)
+    - Graphs where |E| ≈ |V|² (not |E| ≈ |V|)
+    
+    Not recommended for:
+    - Sparse graphs (<10% density) - use ADJ_LIST
+    - Very large graphs (>10K vertices) - O(V²) memory prohibitive
+    - Highly dynamic graphs - wasted space on deleted edges
+    
+    Following eXonware Priorities:
+    1. Security: Bounds checking on all array accesses
+    2. Usability: Intuitive matrix[i][j] access pattern
+    3. Maintainability: Simple 2D array, minimal logic
+    4. Performance: O(1) operations, cache-friendly for dense
+    5. Extensibility: Easy to add matrix operations, algorithms
     """
     
     def __init__(self, traits: EdgeTrait = EdgeTrait.NONE, **options):
         """Initialize the Adjacency Matrix strategy."""
-        super().__init__(**options)
-        self._mode = EdgeMode.ADJ_MATRIX
-        self._traits = traits
+        super().__init__(EdgeMode.ADJ_MATRIX, traits, **options)
         
         self.is_directed = options.get('directed', True)
         self.initial_capacity = options.get('initial_capacity', 100)
@@ -52,107 +90,110 @@ class AdjMatrixStrategy(AGraphEdgeStrategy):
     # ============================================================================
     
     def _resize_matrix(self, new_capacity: int) -> None:
-        """Resize the adjacency matrix to new capacity."""
+        """Resize the adjacency matrix to accommodate more vertices."""
         old_capacity = self._capacity
         self._capacity = new_capacity
         
-        # Create new matrix
-        new_matrix = [[None for _ in range(self._capacity)] for _ in range(self._capacity)]
+        # Expand existing rows
+        for row in self._matrix:
+            row.extend([None] * (new_capacity - old_capacity))
         
-        # Copy existing data
-        for i in range(min(old_capacity, self._capacity)):
-            for j in range(min(old_capacity, self._capacity)):
-                new_matrix[i][j] = self._matrix[i][j]
-        
-        self._matrix = new_matrix
+        # Add new rows
+        for _ in range(old_capacity, new_capacity):
+            self._matrix.append([None] * new_capacity)
     
     def _get_vertex_index(self, vertex: str) -> int:
         """Get or create index for vertex."""
-        if vertex not in self._vertex_to_index:
-            if self._vertex_count >= self._capacity:
-                self._resize_matrix(self._capacity * 2)
-            
-            index = self._vertex_count
-            self._vertex_to_index[vertex] = index
-            self._index_to_vertex[index] = vertex
-            self._vertex_count += 1
-            return index
+        if vertex in self._vertex_to_index:
+            return self._vertex_to_index[vertex]
+        
+        # Need to add new vertex
+        if self._vertex_count >= self._capacity:
+            self._resize_matrix(self._capacity * 2)
+        
+        index = self._vertex_count
+        self._vertex_to_index[vertex] = index
+        self._index_to_vertex[index] = vertex
+        self._vertex_count += 1
         
-        return self._vertex_to_index[vertex]
+        return index
     
     def _get_vertex_by_index(self, index: int) -> Optional[str]:
-        """Get vertex by index."""
+        """Get vertex name by index."""
         return self._index_to_vertex.get(index)
     
     # ============================================================================
     # CORE EDGE OPERATIONS
     # ============================================================================
     
-    def add_edge(self, from_node: Any, to_node: Any, **kwargs) -> None:
+    def add_edge(self, source: str, target: str, **properties) -> str:
         """Add an edge between source and target vertices."""
-        source = str(from_node)
-        target = str(to_node)
-        
-        # Validation
-        if not self.allow_self_loops and source == target:
-            raise ValueError("Self loops not allowed")
+        # Validate self-loops
+        if source == target and not self.allow_self_loops:
+            raise ValueError(f"Self-loops not allowed: {source} -> {target}")
         
         # Get vertex indices
         source_idx = self._get_vertex_index(source)
         target_idx = self._get_vertex_index(target)
         
+        # Generate edge ID
+        edge_id = f"edge_{self._edge_id_counter}"
+        self._edge_id_counter += 1
+        
         # Create edge data
         edge_data = {
-            'weight': kwargs.get('weight', self.default_weight),
-            'id': f"edge_{self._edge_id_counter}",
-            **kwargs
+            'id': edge_id,
+            'source': source,
+            'target': target,
+            'weight': properties.get('weight', self.default_weight),
+            'properties': properties.copy()
         }
-        self._edge_id_counter += 1
         
-        # Add edge to matrix
-        if self._matrix[source_idx][target_idx] is None:
+        # Check if edge already exists
+        if self._matrix[source_idx][target_idx] is not None:
+            # Update existing edge
+            self._matrix[source_idx][target_idx] = edge_data
+        else:
+            # Add new edge
+            self._matrix[source_idx][target_idx] = edge_data
             self._edge_count += 1
         
-        self._matrix[source_idx][target_idx] = edge_data
-        
-        # Add reverse edge if undirected
+        # For undirected graphs, add symmetric edge
         if not self.is_directed and source != target:
             if self._matrix[target_idx][source_idx] is None:
-                self._edge_count += 1
-            self._matrix[target_idx][source_idx] = edge_data
+                self._matrix[target_idx][source_idx] = edge_data
+                # Don't increment edge count for undirected (it's the same edge)
     
-    def remove_edge(self, from_node: Any, to_node: Any) -> bool:
-        """Remove edge between vertices."""
-        source = str(from_node)
-        target = str(to_node)
-        
+        return edge_id
+    
+    def remove_edge(self, source: str, target: str, edge_id: Optional[str] = None) -> bool:
+        """Remove edge between source and target."""
         if source not in self._vertex_to_index or target not in self._vertex_to_index:
             return False
         
         source_idx = self._vertex_to_index[source]
         target_idx = self._vertex_to_index[target]
         
-        removed = False
+        # Check if edge exists
+        if self._matrix[source_idx][target_idx] is None:
+            return False
+        
+        # If edge_id specified, verify it matches
+        if edge_id and self._matrix[source_idx][target_idx]['id'] != edge_id:
+            return False
         
-        # Remove edge from matrix
-        if self._matrix[source_idx][target_idx] is not None:
-            self._matrix[source_idx][target_idx] = None
-            self._edge_count -= 1
-            removed = True
+        # Remove edge
+        self._matrix[source_idx][target_idx] = None
+        self._edge_count -= 1
         
-        # Remove reverse edge if undirected
+        # For undirected graphs, remove symmetric edge
         if not self.is_directed and source != target:
-            if self._matrix[target_idx][source_idx] is not None:
-                self._matrix[target_idx][source_idx] = None
-                self._edge_count -= 1
+            self._matrix[target_idx][source_idx] = None
         
-        return removed
+        return True
     
-    def has_edge(self, from_node: Any, to_node: Any) -> bool:
-        """Check if edge exists."""
-        source = str(from_node)
-        target = str(to_node)
-        
+    def has_edge(self, source: str, target: str) -> bool:
+        """Check if edge exists between source and target."""
         if source not in self._vertex_to_index or target not in self._vertex_to_index:
             return False
         
@@ -161,204 +202,249 @@ class AdjMatrixStrategy(AGraphEdgeStrategy):
         
         return self._matrix[source_idx][target_idx] is not None
     
-    def get_edge_count(self) -> int:
-        """Get total number of edges."""
-        return self._edge_count
-    
-    def get_vertex_count(self) -> int:
-        """Get total number of vertices."""
-        return self._vertex_count
-    
-    # ============================================================================
-    # GRAPH EDGE STRATEGY METHODS
-    # ============================================================================
-    
-    def get_neighbors(self, node: Any) -> List[Any]:
-        """Get all neighboring nodes."""
-        vertex = str(node)
-        if vertex not in self._vertex_to_index:
-            return []
-        
-        vertex_idx = self._vertex_to_index[vertex]
-        neighbors = []
-        
-        for i in range(self._capacity):
-            if self._matrix[vertex_idx][i] is not None:
-                neighbor = self._index_to_vertex.get(i)
-                if neighbor:
-                    neighbors.append(neighbor)
-        
-        return neighbors
-    
-    def get_edge_weight(self, from_node: Any, to_node: Any) -> float:
-        """Get edge weight."""
-        source = str(from_node)
-        target = str(to_node)
-        
+    def get_edge_data(self, source: str, target: str) -> Optional[Dict[str, Any]]:
+        """Get edge data between source and target."""
         if source not in self._vertex_to_index or target not in self._vertex_to_index:
-            return 0.0
+            return None
         
         source_idx = self._vertex_to_index[source]
         target_idx = self._vertex_to_index[target]
         
-        edge_data = self._matrix[source_idx][target_idx]
-        return edge_data.get('weight', self.default_weight) if edge_data else 0.0
+        return self._matrix[source_idx][target_idx]
+    
+    def get_edge_weight(self, source: str, target: str) -> Optional[float]:
+        """Get edge weight between source and target."""
+        edge_data = self.get_edge_data(source, target)
+        return edge_data['weight'] if edge_data else None
     
-    def set_edge_weight(self, from_node: Any, to_node: Any, weight: float) -> None:
-        """Set edge weight."""
-        source = str(from_node)
-        target = str(to_node)
+    def neighbors(self, vertex: str, direction: str = 'out') -> Iterator[str]:
+        """Get neighbors of a vertex."""
+        if vertex not in self._vertex_to_index:
+            return
         
-        if source not in self._vertex_to_index or target not in self._vertex_to_index:
-            raise ValueError(f"Edge {source} -> {target} not found")
+        vertex_idx = self._vertex_to_index[vertex]
         
-        source_idx = self._vertex_to_index[source]
-        target_idx = self._vertex_to_index[target]
+        if direction == 'out':
+            # Outgoing neighbors (columns)
+            for target_idx in range(self._vertex_count):
+                if self._matrix[vertex_idx][target_idx] is not None:
+                    yield self._index_to_vertex[target_idx]
+        elif direction == 'in':
+            # Incoming neighbors (rows)
+            for source_idx in range(self._vertex_count):
+                if self._matrix[source_idx][vertex_idx] is not None:
+                    yield self._index_to_vertex[source_idx]
+        elif direction == 'both':
+            # All neighbors
+            seen = set()
+            for neighbor in self.neighbors(vertex, 'out'):
+                if neighbor not in seen:
+                    seen.add(neighbor)
+                    yield neighbor
+            for neighbor in self.neighbors(vertex, 'in'):
+                if neighbor not in seen:
+                    seen.add(neighbor)
+                    yield neighbor
+    
+    def degree(self, vertex: str, direction: str = 'out') -> int:
+        """Get degree of a vertex."""
+        if vertex not in self._vertex_to_index:
+            return 0
         
-        if self._matrix[source_idx][target_idx] is None:
-            raise ValueError(f"Edge {source} -> {target} not found")
+        vertex_idx = self._vertex_to_index[vertex]
         
-        self._matrix[source_idx][target_idx]['weight'] = weight
-    
-    def find_shortest_path(self, start: Any, end: Any) -> List[Any]:
-        """Find shortest path between nodes."""
-        # TODO: Implement Dijkstra's algorithm
-        return []
+        if direction == 'out':
+            # Count non-None entries in row
+            return sum(1 for target_idx in range(self._vertex_count) 
+                      if self._matrix[vertex_idx][target_idx] is not None)
+        elif direction == 'in':
+            # Count non-None entries in column
+            return sum(1 for source_idx in range(self._vertex_count) 
+                      if self._matrix[source_idx][vertex_idx] is not None)
+        elif direction == 'both':
+            out_degree = self.degree(vertex, 'out')
+            in_degree = self.degree(vertex, 'in')
+            # For undirected graphs, avoid double counting
+            return out_degree if not self.is_directed else out_degree + in_degree
+    
+    def edges(self, data: bool = False) -> Iterator[tuple]:
+        """Get all edges in the graph."""
+        for source_idx in range(self._vertex_count):
+            for target_idx in range(self._vertex_count):
+                edge_data = self._matrix[source_idx][target_idx]
+                if edge_data is not None:
+                    source = self._index_to_vertex[source_idx]
+                    target = self._index_to_vertex[target_idx]
+                    
+                    # For undirected graphs, avoid returning duplicate edges
+                    if not self.is_directed and source > target:
+                        continue
+                    
+                    if data:
+                        yield (source, target, edge_data)
+                    else:
+                        yield (source, target)
+    
+    def vertices(self) -> Iterator[str]:
+        """Get all vertices in the graph."""
+        for vertex in self._vertex_to_index.keys():
+            yield vertex
     
-    def find_all_paths(self, start: Any, end: Any) -> List[List[Any]]:
-        """Find all paths between nodes."""
-        # TODO: Implement DFS
-        return []
+    def __len__(self) -> int:
+        """Get the number of edges."""
+        return self._edge_count
     
-    def get_connected_components(self) -> List[List[Any]]:
-        """Get all connected components."""
-        # TODO: Implement connected components
-        return []
+    def vertex_count(self) -> int:
+        """Get the number of vertices."""
+        return self._vertex_count
     
-    def is_connected(self, start: Any, end: Any) -> bool:
-        """Check if two nodes are connected."""
-        # TODO: Implement connectivity check
-        return False
+    def clear(self) -> None:
+        """Clear all edges and vertices."""
+        # Reset matrix
+        for row in self._matrix:
+            for i in range(len(row)):
+                row[i] = None
+        
+        # Reset mappings
+        self._vertex_to_index.clear()
+        self._index_to_vertex.clear()
+        self._vertex_count = 0
+        self._edge_count = 0
+        self._edge_id_counter = 0
     
-    def get_degree(self, node: Any) -> int:
-        """Get degree of node."""
-        return len(self.get_neighbors(node))
+    def add_vertex(self, vertex: str) -> None:
+        """Add a vertex to the graph."""
+        if vertex not in self._vertex_to_index:
+            self._get_vertex_index(vertex)
     
-    def is_cyclic(self) -> bool:
-        """Check if graph contains cycles."""
-        # TODO: Implement cycle detection
-        return False
+    def remove_vertex(self, vertex: str) -> bool:
+        """Remove a vertex and all its edges."""
+        if vertex not in self._vertex_to_index:
+            return False
+        
+        vertex_idx = self._vertex_to_index[vertex]
+        
+        # Count and remove all edges involving this vertex
+        edges_removed = 0
+        
+        # Remove outgoing edges (row)
+        for target_idx in range(self._vertex_count):
+            if self._matrix[vertex_idx][target_idx] is not None:
+                self._matrix[vertex_idx][target_idx] = None
+                edges_removed += 1
+        
+        # Remove incoming edges (column)
+        for source_idx in range(self._vertex_count):
+            if source_idx != vertex_idx and self._matrix[source_idx][vertex_idx] is not None:
+                self._matrix[source_idx][vertex_idx] = None
+                edges_removed += 1
+        
+        self._edge_count -= edges_removed
+        
+        # Note: We don't actually remove the vertex from the matrix to avoid
+        # reindexing all other vertices. Instead, we just mark it as removed.
+        del self._vertex_to_index[vertex]
+        del self._index_to_vertex[vertex_idx]
+        
+        return True
     
     # ============================================================================
-    # MATRIX SPECIFIC OPERATIONS
+    # MATRIX-SPECIFIC OPERATIONS
     # ============================================================================
     
     def get_matrix(self) -> List[List[Optional[float]]]:
-        """Get the adjacency matrix as a 2D list."""
+        """Get the adjacency matrix as weights."""
         matrix = []
-        for i in range(self._vertex_count):
+        for source_idx in range(self._vertex_count):
             row = []
-            for j in range(self._vertex_count):
-                edge_data = self._matrix[i][j]
-                weight = edge_data.get('weight', self.default_weight) if edge_data else 0.0
+            for target_idx in range(self._vertex_count):
+                edge_data = self._matrix[source_idx][target_idx]
+                weight = edge_data['weight'] if edge_data else None
                 row.append(weight)
             matrix.append(row)
         return matrix
     
     def get_binary_matrix(self) -> List[List[int]]:
-        """Get the binary adjacency matrix."""
+        """Get the adjacency matrix as binary (0/1)."""
         matrix = []
-        for i in range(self._vertex_count):
+        for source_idx in range(self._vertex_count):
             row = []
-            for j in range(self._vertex_count):
-                weight = 1 if self._matrix[i][j] is not None else 0
-                row.append(weight)
+            for target_idx in range(self._vertex_count):
+                edge_exists = self._matrix[source_idx][target_idx] is not None
+                row.append(1 if edge_exists else 0)
             matrix.append(row)
         return matrix
     
     def set_matrix(self, matrix: List[List[Union[float, int, None]]], vertices: List[str]) -> None:
-        """Set the adjacency matrix from a 2D list."""
+        """Set the entire matrix from a weight matrix."""
+        if len(matrix) != len(vertices) or any(len(row) != len(vertices) for row in matrix):
+            raise ValueError("Matrix dimensions must match vertex count")
+        
         # Clear existing data
         self.clear()
         
-        # Set vertices
+        # Add vertices
         for vertex in vertices:
-            self._get_vertex_index(vertex)
+            self.add_vertex(vertex)
         
-        # Set edges
-        for i, row in enumerate(matrix):
-            for j, weight in enumerate(row):
+        # Add edges based on matrix
+        for i, source in enumerate(vertices):
+            for j, target in enumerate(vertices):
+                weight = matrix[i][j]
                 if weight is not None and weight != 0:
-                    source = self._index_to_vertex[i]
-                    target = self._index_to_vertex[j]
-                    self.add_edge(source, target, weight=float(weight))
+                    self.add_edge(source, target, weight=weight)
     
     def matrix_multiply(self, other: 'xAdjMatrixStrategy') -> 'xAdjMatrixStrategy':
         """Multiply this matrix with another adjacency matrix."""
-        # TODO: Implement matrix multiplication
-        return self
+        if self._vertex_count != other._vertex_count:
+            raise ValueError("Matrices must have same dimensions")
+        
+        result = xAdjMatrixStrategy(
+            traits=self._traits,
+            directed=self.is_directed,
+            initial_capacity=self._vertex_count
+        )
+        
+        # Add vertices
+        for vertex in self.vertices():
+            result.add_vertex(vertex)
+        
+        # Perform matrix multiplication
+        vertices = list(self.vertices())
+        for i, source in enumerate(vertices):
+            for j, target in enumerate(vertices):
+                sum_value = 0
+                for k in range(self._vertex_count):
+                    intermediate = self._index_to_vertex[k]
+                    
+                    weight1 = self.get_edge_weight(source, intermediate)
+                    weight2 = other.get_edge_weight(intermediate, target)
+                    
+                    if weight1 is not None and weight2 is not None:
+                        sum_value += weight1 * weight2
+                
+                if sum_value != 0:
+                    result.add_edge(source, target, weight=sum_value)
+        
+        return result
     
     def transpose(self) -> 'xAdjMatrixStrategy':
-        """Get the transpose of the adjacency matrix."""
-        # TODO: Implement matrix transpose
-        return self
-    
-    # ============================================================================
-    # ITERATION
-    # ============================================================================
-    
-    def edges(self) -> Iterator[tuple[Any, Any, Dict[str, Any]]]:
-        """Get all edges in the graph."""
-        for i in range(self._vertex_count):
-            for j in range(self._vertex_count):
-                if self._matrix[i][j] is not None:
-                    source = self._index_to_vertex[i]
-                    target = self._index_to_vertex[j]
-                    yield (source, target, self._matrix[i][j])
-    
-    def vertices(self) -> Iterator[Any]:
-        """Get all vertices in the graph."""
-        return iter(self._vertex_to_index.keys())
-    
-    # ============================================================================
-    # UTILITY METHODS
-    # ============================================================================
-    
-    def clear(self) -> None:
-        """Clear all edges and vertices."""
-        self._matrix = [[None for _ in range(self._capacity)] for _ in range(self._capacity)]
-        self._vertex_to_index.clear()
-        self._index_to_vertex.clear()
-        self._vertex_count = 0
-        self._edge_count = 0
-        self._edge_id_counter = 0
-    
-    def add_vertex(self, vertex: str) -> None:
-        """Add a vertex to the graph."""
-        self._get_vertex_index(vertex)
-    
-    def remove_vertex(self, vertex: str) -> bool:
-        """Remove a vertex and all its incident edges."""
-        if vertex not in self._vertex_to_index:
-            return False
+        """Get the transpose of this matrix."""
+        result = xAdjMatrixStrategy(
+            traits=self._traits,
+            directed=True,  # Transpose is always directed
+            initial_capacity=self._vertex_count
+        )
         
-        vertex_idx = self._vertex_to_index[vertex]
+        # Add vertices
+        for vertex in self.vertices():
+            result.add_vertex(vertex)
         
-        # Remove all edges incident to this vertex
-        for i in range(self._capacity):
-            if self._matrix[vertex_idx][i] is not None:
-                self._matrix[vertex_idx][i] = None
-                self._edge_count -= 1
-            if self._matrix[i][vertex_idx] is not None:
-                self._matrix[i][vertex_idx] = None
-                self._edge_count -= 1
-        
-        # Remove vertex from mappings
-        del self._vertex_to_index[vertex]
-        del self._index_to_vertex[vertex_idx]
-        self._vertex_count -= 1
+        # Add transposed edges
+        for source, target, edge_data in self.edges(data=True):
+            result.add_edge(target, source, **edge_data['properties'])
         
-        return True
+        return result
     
     # ============================================================================
     # PERFORMANCE CHARACTERISTICS
@@ -369,12 +455,15 @@ class AdjMatrixStrategy(AGraphEdgeStrategy):
         """Get backend implementation info."""
         return {
             'strategy': 'ADJ_MATRIX',
-            'backend': '2D matrix',
+            'backend': 'Python 2D list matrix',
+            'directed': self.is_directed,
+            'capacity': self._capacity,
+            'utilized': self._vertex_count,
             'complexity': {
                 'add_edge': 'O(1)',
                 'remove_edge': 'O(1)',
                 'has_edge': 'O(1)',
-                'get_neighbors': 'O(V)',
+                'neighbors': 'O(V)',
                 'space': 'O(V²)'
             }
         }
@@ -382,10 +471,15 @@ class AdjMatrixStrategy(AGraphEdgeStrategy):
     @property
     def metrics(self) -> Dict[str, Any]:
         """Get performance metrics."""
+        density = self._edge_count / max(1, self._vertex_count * (self._vertex_count - 1)) if self._vertex_count > 1 else 0
+        memory_utilization = self._vertex_count / max(1, self._capacity) * 100
+        
         return {
             'vertices': self._vertex_count,
             'edges': self._edge_count,
-            'capacity': self._capacity,
-            'directed': self.is_directed,
-            'density': f"{(self._edge_count / max(1, self._vertex_count * (self._vertex_count - 1))) * 100:.1f}%"
+            'matrix_capacity': self._capacity,
+            'memory_utilization': f"{memory_utilization:.1f}%",
+            'density': round(density, 4),
+            'memory_usage': f"{self._capacity * self._capacity * 8} bytes (estimated)",
+            'sparsity': f"{(1 - density) * 100:.1f}%"
         }